diff --git a/Makefile.cbm b/Makefile.cbm
index 6e65d47d2..67f4cfd1b 100644
--- a/Makefile.cbm
+++ b/Makefile.cbm
@@ -544,6 +544,11 @@ PIPELINE_SRCS = \
     internal/cbm/resolve/adapter_perl.c \
     internal/cbm/resolve/adapter_ruby.c \
     internal/cbm/resolve/adapter_zig.c \
+    internal/cbm/resolve/adapter_lua.c \
+    internal/cbm/resolve/adapter_vim.c \
+    internal/cbm/resolve/adapter_shell.c \
+    internal/cbm/resolve/adapter_tcl.c \
+    internal/cbm/resolve/adapter_make.c \
     internal/cbm/resolve/adapter_haskell.c \
     internal/cbm/resolve/adapter_ocaml.c \
     internal/cbm/resolve/adapter_dart.c \
diff --git a/internal/cbm/cbm.c b/internal/cbm/cbm.c
index 4082b20a0..b83732d64 100644
--- a/internal/cbm/cbm.c
+++ b/internal/cbm/cbm.c
@@ -6059,6 +6059,18 @@ static CBMFileResult *extract_file_ex_body(const char *source, int source_len, C
             }
             cbm_run_ts_lsp(a, result, source, source_len, root, js_mode, jsx_mode, dts_mode);
         }
+        /* A component's scripts are a module of their own language. */
+        if (language == CBM_LANG_VUE || language == CBM_LANG_SVELTE) {
+            CBMLanguage script_language = CBM_LANG_JAVASCRIPT;
+            TSRange range;
+            memset(&range, 0, sizeof(range));
+            TSTree *script = cbm_component_binding_tree(&ctx, &script_language, &range);
+            if (script) {
+                cbm_run_ts_lsp(a, result, source, source_len, ts_tree_root_node(script),
+                               script_language == CBM_LANG_JAVASCRIPT, false, false);
+                ts_tree_delete(script);
+            }
+        }
         if (language == CBM_LANG_CSHARP) {
             cbm_run_cs_lsp(a, result, source, source_len, root);
         }
diff --git a/internal/cbm/cbm.h b/internal/cbm/cbm.h
index 9e587404b..5faf96341 100644
--- a/internal/cbm/cbm.h
+++ b/internal/cbm/cbm.h
@@ -1531,6 +1531,8 @@ void cbm_extract_imports(CBMExtractCtx *ctx);
 /* Owned inner tree for one fully audited Vue/Svelte inline script. Absolute
  * source coordinates are preserved; NULL means the host domain is unproved. */
 TSTree *cbm_component_binding_tree(CBMExtractCtx *ctx, CBMLanguage *language, TSRange *range);
+/* The script names a component's markup assigns. The names live in ctx->arena. */
+size_t cbm_component_template_writes(CBMExtractCtx *ctx, const char ***names);
 void cbm_extract_usages(CBMExtractCtx *ctx);
 void cbm_extract_semantic(CBMExtractCtx *ctx);
 void cbm_extract_type_refs(CBMExtractCtx *ctx);
diff --git a/internal/cbm/extract_defs.c b/internal/cbm/extract_defs.c
index 4d5750e99..075b402d5 100644
--- a/internal/cbm/extract_defs.c
+++ b/internal/cbm/extract_defs.c
@@ -11788,21 +11788,30 @@ static void extract_lua_vars(CBMExtractCtx *ctx, TSNode node, CBMArena *a) {
             continue;
         }
         TSNode expr_list = cbm_find_child_by_kind(child, "expression_list");
-        if (!ts_node_is_null(expr_list) && ts_node_named_child_count(expr_list) > 0) {
-            TSNode val = ts_node_named_child(expr_list, 0);
-            if (!ts_node_is_null(val) && strcmp(ts_node_type(val), "function_definition") == 0) {
-                continue;
-            }
-        }
         TSNode vars = ts_node_child_by_field_name(child, TS_FIELD("variables"));
         if (ts_node_is_null(vars)) {
             vars = cbm_find_child_by_kind(child, "variable_list");
         }
-        if (!ts_node_is_null(vars) && ts_node_named_child_count(vars) > 0) {
-            TSNode first = ts_node_named_child(vars, 0);
-            if (!ts_node_is_null(first)) {
-                push_var_def(ctx, cbm_node_text(a, first, ctx->source), node);
+        if (ts_node_is_null(vars)) {
+            continue;
+        }
+        uint32_t names = ts_node_named_child_count(vars);
+        uint32_t values = ts_node_is_null(expr_list) ? 0 : ts_node_named_child_count(expr_list);
+        /* `local describe, it = t.describe, t.it` declares both. A function value is a
+         * Function node of that name, and an attribute is not a name. */
+        for (uint32_t k = 0, position = 0; k < names; k++) {
+            TSNode name = ts_node_named_child(vars, k);
+            if (strcmp(ts_node_type(name), "identifier") != 0) {
+                continue;
             }
+            TSNode value =
+                position < values ? ts_node_named_child(expr_list, position) : (TSNode){0};
+            position++;
+            if (!ts_node_is_null(value) &&
+                strcmp(ts_node_type(value), "function_definition") == 0) {
+                continue;
+            }
+            push_var_def(ctx, cbm_node_text(a, name, ctx->source), node);
         }
     }
 }
@@ -14771,12 +14780,14 @@ static void walk_defs(CBMExtractCtx *ctx, TSNode root, const CBMLangSpec *spec,
                 // the body's `name = args: ...` bindings are reached. Inner curried
                 // lambdas (`f = a: b: ...`) resolve no name and mint nothing, so the
                 // extra descent adds defs without adding noise.
+                // Lua: a test file is one `describe(name, function() ... end)`, so nearly
+                // all of its `local function`s live inside an anonymous function.
                 bool descend_into_func =
                     (ctx->language == CBM_LANG_C && cbm_test_definition_qn(ctx, node) != NULL) ||
                     (ctx->language == CBM_LANG_WOLFRAM || ctx->language == CBM_LANG_TYPESCRIPT ||
                      ctx->language == CBM_LANG_JAVASCRIPT || ctx->language == CBM_LANG_TSX ||
                      ctx->language == CBM_LANG_ARKTS || ctx->language == CBM_LANG_ADA ||
-                     ctx->language == CBM_LANG_NIX);
+                     ctx->language == CBM_LANG_NIX || ctx->language == CBM_LANG_LUA);
                 if (!descend_into_func) {
                     continue;
                 }
diff --git a/internal/cbm/extract_imports.c b/internal/cbm/extract_imports.c
index 575c0e19e..d3e7013ba 100644
--- a/internal/cbm/extract_imports.c
+++ b/internal/cbm/extract_imports.c
@@ -2312,62 +2312,92 @@ static void parse_elixir_imports(CBMExtractCtx *ctx) {
 // --- Lua imports ---
 // function_call: require("X")
 
+/* A name in a binding position that is `require`: this file's require is not the loader. */
+static bool lua_binds_require(const CBMExtractCtx *ctx, TSNode node) {
+    const char *kind = ts_node_type(node);
+    TSNode bound = (TSNode){0};
+    if (strcmp(kind, "function_declaration") == 0) {
+        bound = ts_node_child_by_field_name(node, TS_FIELD("name"));
+    } else if (strcmp(kind, "parameters") == 0 || strcmp(kind, "variable_list") == 0) {
+        uint32_t count = ts_node_named_child_count(node);
+        for (uint32_t i = 0; i < count && ts_node_is_null(bound); i++) {
+            TSNode name = ts_node_named_child(node, i);
+            uint32_t start = ts_node_start_byte(name), end = ts_node_end_byte(name);
+            if (strcmp(ts_node_type(name), "identifier") == 0 && end - start == strlen("require") &&
+                memcmp(ctx->source + start, "require", strlen("require")) == 0)
+                bound = name;
+        }
+    }
+    if (ts_node_is_null(bound) || strcmp(ts_node_type(bound), "identifier") != 0)
+        return false;
+    uint32_t start = ts_node_start_byte(bound), end = ts_node_end_byte(bound);
+    return end - start == strlen("require") &&
+           memcmp(ctx->source + start, "require", strlen("require")) == 0;
+}
+
+/* The module of `require('a.b')` or `pcall(require, 'a.b')`, when spelled as one literal. */
+static const char *lua_required_module(CBMExtractCtx *ctx, TSNode call) {
+    TSNode callee = ts_node_child_by_field_name(call, TS_FIELD("name"));
+    TSNode arguments = ts_node_child_by_field_name(call, TS_FIELD("arguments"));
+    if (ts_node_is_null(callee) || ts_node_is_null(arguments) ||
+        strcmp(ts_node_type(callee), "identifier") != 0)
+        return NULL;
+    char *name = cbm_node_text(ctx->arena, callee, ctx->source);
+    uint32_t count = ts_node_named_child_count(arguments);
+    TSNode literal = (TSNode){0};
+    if (name && strcmp(name, "require") == 0 && count == 1) {
+        literal = ts_node_named_child(arguments, 0);
+    } else if (name && strcmp(name, "pcall") == 0 && count == 2) {
+        TSNode loader = ts_node_named_child(arguments, 0);
+        char *text = strcmp(ts_node_type(loader), "identifier") == 0
+                         ? cbm_node_text(ctx->arena, loader, ctx->source)
+                         : NULL;
+        if (text && strcmp(text, "require") == 0)
+            literal = ts_node_named_child(arguments, 1);
+    }
+    if (ts_node_is_null(literal) || strcmp(ts_node_type(literal), "string") != 0 ||
+        ts_node_named_child_count(literal) != 1)
+        return NULL;
+    TSNode content = ts_node_named_child(literal, 0);
+    return strcmp(ts_node_type(content), "string_content") == 0
+               ? cbm_node_text(ctx->arena, content, ctx->source)
+               : NULL;
+}
+
+/* A require loads a module wherever it runs, so every depth counts, and a comment that spells
+ * one loads nothing. */
 static void parse_lua_imports(CBMExtractCtx *ctx) {
     CBMArena *a = ctx->arena;
-
+    int first = ctx->result->imports.count;
+    bool rebound = false;
+    bool entering = true;
     TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
-    if (!ts_tree_cursor_goto_first_child(&cursor)) {
-        ts_tree_cursor_delete(&cursor);
-        return;
+    while (!rebound) {
+        if (entering) {
+            TSNode node = ts_tree_cursor_current_node(&cursor);
+            rebound = lua_binds_require(ctx, node);
+            if (strcmp(ts_node_type(node), "function_call") == 0) {
+                const char *module = lua_required_module(ctx, node);
+                if (module && module[0]) {
+                    char *mod = cbm_arena_strdup(a, module);
+                    CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
+                    push_import_at(ctx, node, imp);
+                }
+            }
+            if (ts_tree_cursor_goto_first_child(&cursor))
+                continue;
+        }
+        if (ts_tree_cursor_goto_next_sibling(&cursor)) {
+            entering = true;
+            continue;
+        }
+        if (!ts_tree_cursor_goto_parent(&cursor))
+            break;
+        entering = false;
     }
-    do {
-        TSNode node = ts_tree_cursor_current_node(&cursor);
-        // Lua: local X = require("Y") → assignment_statement or variable_declaration
-        // containing function_call(require, "Y")
-        char *text = cbm_node_text(a, node, ctx->source);
-        if (!text) {
-            continue;
-        }
-        if (strstr(text, "require") == NULL) {
-            continue;
-        }
-
-        // Simple extraction: find require("...") pattern in node text
-        const char *req = strstr(text, "require");
-        if (!req) {
-            continue;
-        }
-
-        // Find the string argument
-        const char *open = strchr(req, '(');
-        if (!open) {
-            open = strchr(req, '"');
-        }
-        if (!open) {
-            open = strchr(req, '\'');
-        }
-        if (!open) {
-            continue;
-        }
-
-        const char *q1 = strchr(open, '"');
-        const char *q2 = strchr(open, '\'');
-        if (!q1 && !q2) {
-            continue;
-        }
-        const char *start = q1 && (!q2 || q1 < q2) ? q1 : q2;
-        char delim = *start;
-        start++;
-        const char *end = strchr(start, delim);
-        if (!end) {
-            continue;
-        }
-
-        char *mod = cbm_arena_strndup(a, start, (size_t)(end - start));
-        CBMImport imp = {.local_name = path_last(a, mod), .module_path = mod};
-        push_import_at(ctx, node, imp);
-    } while (ts_tree_cursor_goto_next_sibling(&cursor));
     ts_tree_cursor_delete(&cursor);
+    if (rebound)
+        ctx->result->imports.count = first;
 }
 
 // --- R imports: library()/require()/source() + box::use() (#218) ---
@@ -3297,81 +3327,14 @@ static bool markup_script_host(CBMLanguage language) {
            language == CBM_LANG_ASTRO;
 }
 
-/* Component scripts have module-local bindings even without an explicit ESM
- * statement. This proof subset admits one inline script and an inert host.
- * Multiple script contexts, template expressions/directives, external scripts
- * and unknown markup remain unproved; extraction is deliberately broader. */
-static bool embedded_binding_identifier(const char *source, TSNode value) {
-    uint32_t start = ts_node_start_byte(value), end = ts_node_end_byte(value);
-    if (end <= start + 2 || source[start++] != '{' || source[--end] != '}')
-        return false;
-    while (start < end && isspace((unsigned char)source[start]))
-        start++;
-    while (end > start && isspace((unsigned char)source[end - 1]))
-        end--;
-    if (start == end || !((source[start] >= 'a' && source[start] <= 'z') ||
-                          (source[start] >= 'A' && source[start] <= 'Z') || source[start] == '_' ||
-                          source[start] == '$'))
-        return false;
-    for (uint32_t i = start + 1; i < end; i++) {
-        unsigned char c = (unsigned char)source[i];
-        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ||
-              c == '_' || c == '$'))
-            return false;
-    }
-    return true;
-}
-
-static bool embedded_binding_attribute(CBMExtractCtx *ctx, TSNode attribute, bool script,
-                                       CBMLanguage *language, unsigned *seen) {
-    uint32_t count = ts_node_named_child_count(attribute);
-    if (!count || count > 2)
-        return false;
-    TSNode name_node = ts_node_named_child(attribute, 0);
-    if (strcmp(ts_node_type(name_node), "attribute_name"))
-        return false;
-    const char *name = cbm_node_text(ctx->arena, name_node, ctx->source);
-    if (!name || !name[0])
-        return false;
-    if (script) {
-        unsigned flag = ascii_trimmed_equals(name, "lang")                        ? 1u
-                        : ctx->language == CBM_LANG_VUE && !strcmp(name, "setup") ? 2u
-                                                                                  : 0u;
-        if (!flag || (*seen & flag) || (flag == 2u && count != 1))
-            return false;
-        *seen |= flag;
-        return apply_script_attribute(ctx, attribute, language);
-    }
-    /* A Svelte event handler may capture a bare identifier, but may not run
-     * an expression while creating the handler or write a script binding. */
-    if (ctx->language == CBM_LANG_SVELTE && !strncmp(name, "on:", 3)) {
-        if (!name[3] || count != 2)
-            return false;
-        for (const char *p = name + 3; *p; p++)
-            if (!((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')))
-                return false;
-        TSNode value = ts_node_named_child(attribute, 1);
-        return !strcmp(ts_node_type(value), "expression") &&
-               embedded_binding_identifier(ctx->source, value);
-    }
-    if (!strncmp(name, "v-", 2) || !strncmp(name, "on", 2))
-        return false;
-    for (const char *p = name; *p; p++)
-        if (!((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') || (*p >= '0' && *p <= '9') ||
-              *p == '_' || *p == '-'))
-            return false;
-    /* Static attribute text cannot conceal a component expression. This is
-     * intentionally narrower than either host grammar's value syntax. */
-    uint32_t begin = ts_node_end_byte(name_node), end = ts_node_end_byte(attribute);
-    for (uint32_t i = begin; i < end; i++)
-        if (ctx->source[i] == '{' || ctx->source[i] == '}' || ctx->source[i] == '&')
-            return false;
-    return true;
-}
-
+/* A component's scripts have module-local bindings even without an explicit ESM statement. A
+ * Vue SFC's `<script>` and `<script setup>` compile to one module, as do Svelte's
+ * `context="module"` script and its instance script. Markup cannot declare a script binding:
+ * its expressions read script names and call them, and the only way they touch a binding is
+ * assigning it, which cbm_component_template_writes reports. A script loaded from `src`, or in
+ * a language this does not parse, stays unproved. */
 static bool embedded_binding_script(CBMExtractCtx *ctx, TSNode script, CBMEmbeddedBlock *block,
                                     CBMLanguage *language) {
-    unsigned attributes = 0;
     bool content = false, start_tag = false, end_tag = false;
     uint32_t count = ts_node_named_child_count(script);
     for (uint32_t i = 0; i < count; i++) {
@@ -3383,10 +3346,8 @@ static bool embedded_binding_script(CBMExtractCtx *ctx, TSNode script, CBMEmbedd
             for (uint32_t j = 0; j < children; j++) {
                 TSNode item = ts_node_named_child(child, j);
                 const char *item_kind = ts_node_type(item);
-                if (!strcmp(item_kind, "tag_name"))
-                    continue;
-                if (strcmp(item_kind, "attribute") ||
-                    !embedded_binding_attribute(ctx, item, true, language, &attributes))
+                if (!strcmp(item_kind, "attribute") ? !apply_script_attribute(ctx, item, language)
+                                                    : strcmp(item_kind, "tag_name") != 0)
                     return false;
             }
         } else if (!strcmp(kind, "end_tag") && !end_tag) {
@@ -3406,57 +3367,43 @@ TSTree *cbm_component_binding_tree(CBMExtractCtx *ctx, CBMLanguage *language, TS
         ctx->source_len <= 0 || ts_node_is_null(ctx->root) || ts_node_has_error(ctx->root) ||
         ts_node_end_byte(ctx->root) != (uint32_t)ctx->source_len)
         return NULL;
-    enum { BINDING_HOST_STACK = 512, BINDING_HOST_NODES = 1000000 };
-    TSNode stack[BINDING_HOST_STACK];
-    size_t top = 0, visited = 0;
-    stack[top++] = ctx->root;
-    CBMEmbeddedBlock block = {0};
-    bool found = false;
+    enum { COMPONENT_SCRIPTS = 2 };
+    TSRange ranges[COMPONENT_SCRIPTS];
+    uint32_t count = 0;
+    bool usable = true;
     *language = CBM_LANG_JAVASCRIPT;
-    while (top) {
-        TSNode node = stack[--top];
-        if (++visited > BINDING_HOST_NODES)
-            return NULL;
-        const char *kind = ts_node_type(node);
-        if (!strcmp(kind, "script_element")) {
-            if (!ts_node_eq(ts_node_parent(node), ctx->root) || found ||
-                !embedded_binding_script(ctx, node, &block, language))
-                return NULL;
-            found = true;
-            continue;
-        }
-        if (!strcmp(kind, "attribute")) {
-            unsigned unused = 0;
-            if (!embedded_binding_attribute(ctx, node, false, language, &unused))
-                return NULL;
-            continue;
-        }
-        bool container = !strcmp(kind, "document") || !strcmp(kind, "element") ||
-                         !strcmp(kind, "template_element") || !strcmp(kind, "start_tag") ||
-                         !strcmp(kind, "end_tag") || !strcmp(kind, "self_closing_tag");
-        bool leaf = !strcmp(kind, "text") || !strcmp(kind, "comment") || !strcmp(kind, "tag_name");
-        if (!container && !leaf)
-            return NULL;
-        uint32_t children = ts_node_named_child_count(node);
-        if (leaf && children)
-            return NULL;
-        if (children > BINDING_HOST_STACK - top)
-            return NULL;
-        for (uint32_t i = children; i > 0; i--)
-            stack[top++] = ts_node_named_child(node, i - 1);
+    TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode node = ts_tree_cursor_current_node(&cursor);
+            if (strcmp(ts_node_type(node), "script_element"))
+                continue;
+            CBMEmbeddedBlock block = {0};
+            CBMLanguage own = CBM_LANG_JAVASCRIPT;
+            if (count == COMPONENT_SCRIPTS || !embedded_binding_script(ctx, node, &block, &own) ||
+                (count && own != *language)) {
+                usable = false;
+                break;
+            }
+            *language = own;
+            ranges[count++] = (TSRange){.start_point = ts_node_start_point(block.content),
+                                        .end_point = ts_node_end_point(block.content),
+                                        .start_byte = ts_node_start_byte(block.content),
+                                        .end_byte = ts_node_end_byte(block.content)};
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
     }
-    if (!found)
+    ts_tree_cursor_delete(&cursor);
+    if (!usable || !count)
         return NULL;
-    *range = (TSRange){.start_point = ts_node_start_point(block.content),
-                       .end_point = ts_node_end_point(block.content),
-                       .start_byte = ts_node_start_byte(block.content),
-                       .end_byte = ts_node_end_byte(block.content)};
+    *range = ranges[0];
+    range->end_point = ranges[count - 1].end_point;
+    range->end_byte = ranges[count - 1].end_byte;
     if (range->end_byte <= range->start_byte || range->end_byte > (uint32_t)ctx->source_len)
         return NULL;
     TSParser *parser = ts_parser_new();
     TSTree *tree = NULL;
     if (parser && ts_parser_set_language(parser, cbm_ts_language(*language)) &&
-        ts_parser_set_included_ranges(parser, range, 1))
+        ts_parser_set_included_ranges(parser, ranges, count))
         tree = ts_parser_parse_string(parser, NULL, ctx->source, (uint32_t)ctx->source_len);
     if (parser)
         ts_parser_delete(parser);
@@ -3467,6 +3414,141 @@ TSTree *cbm_component_binding_tree(CBMExtractCtx *ctx, CBMLanguage *language, TS
     return tree;
 }
 
+static bool component_name_byte(unsigned char c) {
+    return isalnum(c) || c == '_' || c == '$';
+}
+
+typedef struct {
+    const char **items;
+    size_t count, capacity;
+} component_writes_t;
+
+static void component_note_write(CBMExtractCtx *ctx, component_writes_t *writes, const char *name,
+                                 size_t length) {
+    if (writes->count == writes->capacity) {
+        size_t capacity = writes->capacity ? writes->capacity * 2 : 8;
+        const char **items = cbm_arena_alloc(ctx->arena, capacity * sizeof(*items));
+        if (!items)
+            return;
+        if (writes->count)
+            memcpy(items, writes->items, writes->count * sizeof(*items));
+        writes->items = items;
+        writes->capacity = capacity;
+    }
+    const char *copy = cbm_arena_strndup(ctx->arena, name, length);
+    if (copy)
+        writes->items[writes->count++] = copy;
+}
+
+/* The names an expression assigns: `x = y`, `x += y`, `x++`. `x.y = z` writes a member and
+ * leaves the binding alone; `===`, `=>` and string contents are not assignments. */
+static void component_scan_assignments(CBMExtractCtx *ctx, component_writes_t *writes,
+                                       const char *text, size_t length) {
+    for (size_t at = 0; at < length;) {
+        unsigned char c = (unsigned char)text[at];
+        if (c == '\'' || c == '"' || c == '`') {
+            size_t close = at + 1;
+            while (close < length && text[close] != (char)c)
+                close += text[close] == '\\' ? 2 : 1;
+            at = close + 1;
+            continue;
+        }
+        if (!component_name_byte(c) || isdigit(c)) {
+            at++;
+            continue;
+        }
+        size_t begin = at;
+        while (at < length && component_name_byte((unsigned char)text[at]))
+            at++;
+        bool member = begin && text[begin - 1] == '.';
+        size_t next = at;
+        while (next < length && isspace((unsigned char)text[next]))
+            next++;
+        if (member || next >= length)
+            continue;
+        const char *rest = text + next;
+        size_t left = length - next;
+        bool plain = rest[0] == '=' && (left < 2 || (rest[1] != '=' && rest[1] != '>'));
+        bool compound = left >= 2 && rest[1] == '=' && strchr("+-*/%|&^", rest[0]);
+        bool step =
+            left >= 2 && ((rest[0] == '+' && rest[1] == '+') || (rest[0] == '-' && rest[1] == '-'));
+        if (plain || compound || step)
+            component_note_write(ctx, writes, text + begin, at - begin);
+    }
+}
+
+/* `v-model="x"` and `bind:value={x}` assign x. */
+static void component_scan_bound_name(CBMExtractCtx *ctx, component_writes_t *writes,
+                                      const char *text, size_t length) {
+    size_t at = 0;
+    while (at < length && (isspace((unsigned char)text[at]) || text[at] == '{'))
+        at++;
+    size_t begin = at;
+    while (at < length && component_name_byte((unsigned char)text[at]))
+        at++;
+    size_t end = at;
+    while (at < length && (isspace((unsigned char)text[at]) || text[at] == '}'))
+        at++;
+    if (end > begin && at == length)
+        component_note_write(ctx, writes, text + begin, end - begin);
+}
+
+static void component_scan_attribute(CBMExtractCtx *ctx, component_writes_t *writes, TSNode node) {
+    uint32_t count = ts_node_named_child_count(node);
+    if (count < 2)
+        return;
+    TSNode name = ts_node_named_child(node, 0);
+    TSNode value = ts_node_named_child(node, count - 1);
+    uint32_t begin = ts_node_start_byte(name), end = ts_node_end_byte(name);
+    const char *text = ctx->source + begin;
+    size_t size = end - begin;
+    bool bound = (size >= strlen("v-model") && !strncmp(text, "v-model", strlen("v-model"))) ||
+                 (size >= strlen("bind:") && !strncmp(text, "bind:", strlen("bind:")));
+    if (!bound && strcmp(ts_node_type(node), "directive_attribute"))
+        return;
+    uint32_t from = ts_node_start_byte(value), to = ts_node_end_byte(value);
+    bool quoted = to - from >= 2 && (ctx->source[from] == '"' || ctx->source[from] == '\'');
+    const char *body = ctx->source + from + (quoted ? 1 : 0);
+    size_t length = to - from - (quoted ? 2 : 0);
+    if (bound)
+        component_scan_bound_name(ctx, writes, body, length);
+    else
+        component_scan_assignments(ctx, writes, body, length);
+}
+
+size_t cbm_component_template_writes(CBMExtractCtx *ctx, const char ***names) {
+    component_writes_t writes = {0};
+    *names = NULL;
+    if (!ctx || !ctx->source || ts_node_is_null(ctx->root))
+        return 0;
+    TSTreeCursor cursor = ts_tree_cursor_new(ctx->root);
+    bool entering = true;
+    for (;;) {
+        TSNode node = ts_tree_cursor_current_node(&cursor);
+        const char *kind = ts_node_type(node);
+        bool skip = !strcmp(kind, "script_element") || !strcmp(kind, "style_element");
+        if (entering && !skip) {
+            if (!strcmp(kind, "directive_attribute") || !strcmp(kind, "attribute"))
+                component_scan_attribute(ctx, &writes, node);
+            else if (!strcmp(kind, "expression"))
+                component_scan_assignments(ctx, &writes, ctx->source + ts_node_start_byte(node),
+                                           ts_node_end_byte(node) - ts_node_start_byte(node));
+            if (ts_tree_cursor_goto_first_child(&cursor))
+                continue;
+        }
+        if (ts_tree_cursor_goto_next_sibling(&cursor)) {
+            entering = true;
+            continue;
+        }
+        if (!ts_tree_cursor_goto_parent(&cursor))
+            break;
+        entering = false;
+    }
+    ts_tree_cursor_delete(&cursor);
+    *names = writes.items;
+    return writes.count;
+}
+
 static void parse_one_embedded_block(CBMExtractCtx *ctx, const CBMEmbeddedBlock *block,
                                      CBMLanguage embedded_language) {
     const TSLanguage *language = cbm_ts_language(embedded_language);
diff --git a/internal/cbm/resolve/adapter_lua.c b/internal/cbm/resolve/adapter_lua.c
new file mode 100644
index 000000000..de582a7bd
--- /dev/null
+++ b/internal/cbm/resolve/adapter_lua.c
@@ -0,0 +1,1993 @@
+/* Lua binding rules, from the reference manual (§3.5 visibility, §2.2 environments, §3.3
+ * statements, §6.3 modules).
+ *
+ * A `local` is lexical: it is visible from the statement after its declaration to the end of
+ * its block, `local function f` also inside f, and nothing at runtime can rebind the name. A
+ * name no local binds is a field of the environment, one table the whole program shares, so
+ * `function foo()` and `function vim.api.foo()` declare in one global namespace that every
+ * file reads. Tables are plain values: `function M.f()`, `M.f = v` and `{ f = v }` declare a
+ * member of the table the name holds. `require('a.b')` is the value file a/b.lua returned,
+ * through package.path: `./?.lua`, `./?/init.lua`, and a project's `lua/` root.
+ *
+ * Nothing here is a name match. A target is reached by following one value from a site: a
+ * local's single assignment, a table's member, a file's single returned value, a function's
+ * single returned value, a metatable's `__index`. Each step abstains when it is not exactly
+ * one thing: a local written twice, a member with two declarations, two different returns.
+ * A write through a computed key (`M[k] = v`) is taken to write no member it does not spell.
+ *
+ * What can change a binding is only what the manual says can: `local _ENV` and `setfenv`
+ * replace where free names live, and `debug.setlocal` writes a local. `load`, `dofile` and
+ * `_G.x = v` do not touch a lexical name, and the last is one more global declaration.
+ *
+ * The walk is the same in both phases, so a name binds the same declaration in both. Phase one
+ * records values as encoded access paths, because another file's table is unknown until every
+ * file was seen; phase two evaluates them, with a memo per file, so each distinct path costs
+ * once and a cycle ends. Every lookup is a hash probe. */
+#include "source_adapter_internal.h"
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Encoded value: a root, then steps. `G` the global table, `T:f\x1db` a table constructor,
+ * `F:f\x1db` a function, `L:f\x1db` a local, `R:dir\x1dname` a require. A step is `.name`, `()`,
+ * or `#n`: value n of a call, from 1 past the first. U+001E and U+001D cannot occur in an
+ * identifier or in a repository path we index. */
+#define LUA_STEP "\x1e"
+#define LUA_PART "\x1d"
+#define LUA_GLOBALS "G"
+#define LUA_META "\x01meta"
+#define LUA_LAZY "\x01lazy"
+#define LUA_SHAPE "\x01shape"
+#define LUA_MODULES "R:"
+#define LUA_RETURNS "M:"
+#define LUA_FLAGS "E:"
+#define LUA_OWN_GLOBAL "H:"
+#define LUA_CLASSES "C:"
+#define LUA_ANNOTATED "N:"
+#define LUA_PARENTS "P:"
+#define LUA_CLASS_OF "\x01class"
+#define LUA_RETURN_AT "\x01return"
+
+enum {
+    LUA_MAX_EVAL_DEPTH = 256,
+    LUA_MAX_CANON_HOPS = 32,
+    LUA_DOC_PARAMS = 32,
+    LUA_VALUE_NAMES = 4,
+    LUA_RETURN_VALUES = 8
+};
+
+typedef enum { LUA_UNKNOWN = 0, LUA_TABLE, LUA_FUNCTION } lua_kind_t;
+
+typedef struct {
+    lua_kind_t kind;
+    const char *key; /* TABLE: its identity */
+    /* TABLE: access paths that reached it. A write through any of them landed on it. */
+    const char *names[LUA_VALUE_NAMES];
+    const cbm_source_decl_t *function;
+    const char *reason;
+    bool absent; /* TABLE: a path nothing declares */
+    bool pending;
+} lua_value_t;
+
+typedef struct lua_binder {
+    const char *name;
+    const char *identity;
+    const char *qn; /* phase two: the graph node declared for it */
+    struct lua_binder *shadowed;
+    struct lua_binder *below;
+    bool assigned; /* its declaration or first write gave it a value */
+    bool global;   /* Lua 5.5 `global x`: the name is a global here */
+} lua_binder_t;
+
+typedef struct {
+    const char *value;
+    bool open;
+    /* The values after the first: `return a, b`. */
+    const char *later[LUA_RETURN_VALUES];
+    bool later_open[LUA_RETURN_VALUES];
+} lua_flow_t;
+
+/* LuaCATS annotations on the statement that follows them. Only a type that is one name counts:
+ * `string|nil` and `fun(): x` select no class. */
+typedef struct {
+    const char *class_name;
+    const char *type_name;
+    const char *return_type;
+    const char *param_names[LUA_DOC_PARAMS];
+    const char *param_types[LUA_DOC_PARAMS];
+    unsigned param_count;
+    uint32_t last_row;
+    bool present;
+} lua_doc_t;
+
+typedef struct {
+    cbm_source_walk_t *walk;
+    CBMHashTable *visible;
+    CBMHashTable *memo;
+    lua_binder_t *top;
+    lua_flow_t *flow;
+    const char *directory;
+    lua_doc_t *doc; /* phase one: what annotates the statement being visited */
+    lua_binder_t *last_local;
+    const char *module_table; /* a literal in this statement has `@module` fields */
+    unsigned function_depth;
+    bool collecting;
+    bool environment_open; /* setfenv or `_ENV = x`: free names are not the globals */
+} lua_ctx_t;
+
+typedef struct {
+    TSNode *items;
+    uint32_t count;
+} lua_nodes_t;
+
+static void lua_visit(lua_ctx_t *ctx, TSNode node, unsigned depth);
+static lua_value_t lua_eval(lua_ctx_t *ctx, const char *encoded, unsigned depth);
+
+/* ── Syntax ────────────────────────────────────────────────────────── */
+
+static bool lua_ignored(TSNode node) {
+    return cbm_source_is(node, "comment") || cbm_source_is(node, "hash_bang_line");
+}
+
+static lua_nodes_t lua_children(lua_ctx_t *ctx, TSNode node, const char *field) {
+    lua_nodes_t nodes = {0};
+    uint32_t capacity = ts_node_is_null(node) ? 0 : ts_node_named_child_count(node);
+    if (!capacity)
+        return nodes;
+    nodes.items = cbm_arena_alloc(ctx->walk->arena, capacity * sizeof(*nodes.items));
+    if (!nodes.items) {
+        cbm_source_fail(ctx->walk, "lua_scope_allocation");
+        return nodes;
+    }
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (!ts_node_is_named(child) || lua_ignored(child))
+                continue;
+            if (field) {
+                const char *name = ts_tree_cursor_current_field_name(&cursor);
+                if (!name || strcmp(name, field))
+                    continue;
+            }
+            nodes.items[nodes.count++] = child;
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+    return nodes;
+}
+
+/* The text of a literal string with no escape in it; anything else is not spelled. */
+static const char *lua_literal(lua_ctx_t *ctx, TSNode node) {
+    if (!cbm_source_is(node, "string") || ts_node_named_child_count(node) != 1)
+        return NULL;
+    TSNode content = cbm_source_field(node, "content");
+    return cbm_source_is(content, "string_content") ? cbm_source_text(ctx->walk, content) : NULL;
+}
+
+static bool lua_is_index(TSNode node) {
+    return cbm_source_is(node, "dot_index_expression") ||
+           cbm_source_is(node, "bracket_index_expression") ||
+           cbm_source_is(node, "method_index_expression");
+}
+
+/* The member an index expression spells, NULL when it computes one. */
+static const char *lua_index_member(lua_ctx_t *ctx, TSNode node) {
+    if (cbm_source_is(node, "dot_index_expression"))
+        return cbm_source_text(ctx->walk, cbm_source_field(node, "field"));
+    if (cbm_source_is(node, "method_index_expression"))
+        return cbm_source_text(ctx->walk, cbm_source_field(node, "method"));
+    if (cbm_source_is(node, "bracket_index_expression"))
+        return lua_literal(ctx, cbm_source_field(node, "field"));
+    return NULL;
+}
+
+/* ── Scope ─────────────────────────────────────────────────────────── */
+
+static const char *lua_identity(lua_ctx_t *ctx, char kind, uint32_t at) {
+    return cbm_arena_sprintf(ctx->walk->arena, "%c:%s" LUA_PART "%u", kind, ctx->walk->file, at);
+}
+
+static lua_binder_t *lua_binder_of(const lua_ctx_t *ctx, const char *name) {
+    lua_binder_t *binder = name ? cbm_ht_get(ctx->visible, name) : NULL;
+    return binder && !binder->global ? binder : NULL;
+}
+
+/* `local _ENV` or `function f(_ENV)`: free names here are fields of that value. */
+static bool lua_environment_replaced(const lua_ctx_t *ctx) {
+    return ctx->environment_open || cbm_ht_get(ctx->visible, "_ENV") != NULL;
+}
+
+/* line is where the statement declaring it starts, when that statement can have a graph node:
+ * 0 for a parameter or a loop variable, which never do. */
+static lua_binder_t *lua_push(lua_ctx_t *ctx, const char *name, uint32_t at, uint32_t line) {
+    lua_binder_t *binder = name ? cbm_arena_calloc(ctx->walk->arena, sizeof(*binder)) : NULL;
+    if (!binder) {
+        if (name)
+            cbm_source_fail(ctx->walk, "lua_scope_allocation");
+        return NULL;
+    }
+    binder->name = name;
+    binder->identity = lua_identity(ctx, 'L', at);
+    if (!ctx->collecting && line)
+        binder->qn = cbm_source_def_qn_at(ctx->walk, name, line);
+    binder->shadowed = cbm_ht_get(ctx->visible, name);
+    binder->below = ctx->top;
+    ctx->top = binder;
+    cbm_ht_set(ctx->visible, name, binder);
+    return binder;
+}
+
+static void lua_pop_to(lua_ctx_t *ctx, lua_binder_t *mark) {
+    while (ctx->top != mark) {
+        lua_binder_t *binder = ctx->top;
+        ctx->top = binder->below;
+        if (binder->shadowed)
+            cbm_ht_set(ctx->visible, binder->name, binder->shadowed);
+        else
+            cbm_ht_delete(ctx->visible, binder->name);
+    }
+}
+
+/* ── Phase one: facts ──────────────────────────────────────────────── */
+
+static const cbm_source_decl_t *lua_fact(lua_ctx_t *ctx, const char *root) {
+    const char *part = strchr(root, LUA_PART[0]);
+    if (!part)
+        return NULL;
+    const char *owner = cbm_arena_strndup(ctx->walk->arena, root, (size_t)(part - root));
+    return owner ? cbm_source_lookup(ctx->walk, owner, part + 1) : NULL;
+}
+
+static cbm_source_decl_t *lua_declare(lua_ctx_t *ctx, const char *owner, const char *name,
+                                      const char *qn, const char *type) {
+    cbm_source_decl_t *decl = cbm_source_declare(ctx->walk, owner, name, qn, 0, 0);
+    if (decl && type)
+        decl->type = cbm_source_table_intern(ctx->walk, type);
+    return decl;
+}
+
+static void lua_declare_root(lua_ctx_t *ctx, const char *root, const char *qn, const char *type) {
+    const char *part = strchr(root, LUA_PART[0]);
+    const char *owner =
+        part ? cbm_arena_strndup(ctx->walk->arena, root, (size_t)(part - root)) : NULL;
+    if (owner)
+        (void)lua_declare(ctx, owner, part + 1, qn, type);
+}
+
+/* `vim.iter = require('vim.iter')` written by two files in two directories names one module. */
+static bool lua_same_value(const char *left, const char *right) {
+    if (!left || !right)
+        return false;
+    if (!strcmp(left, right))
+        return true;
+    if (strncmp(left, LUA_MODULES, strlen(LUA_MODULES)) ||
+        strncmp(right, LUA_MODULES, strlen(LUA_MODULES)))
+        return false;
+    const char *left_name = strchr(left, LUA_PART[0]);
+    const char *right_name = strchr(right, LUA_PART[0]);
+    return left_name && right_name && !strcmp(left_name, right_name);
+}
+
+/* One entry per (table, member). Declaring a second, different value marks it instead of
+ * growing a list, so a member assigned many times stays one probe. Two functions on one QN
+ * are one node of the graph, so they are one declaration here. A chunk's own statements declare
+ * the table; a write inside a function happens when it runs, as a test's
+ * `vim.fn.has = function() ... end` mock does, and does not compete with them. */
+static void lua_member_fact(lua_ctx_t *ctx, const char *owner, const char *name, const char *qn,
+                            const char *type) {
+    bool runtime = ctx->function_depth > 0;
+    cbm_source_decl_t *head = (cbm_source_decl_t *)cbm_source_lookup(ctx->walk, owner, name);
+    if (!head) {
+        cbm_source_decl_t *decl = lua_declare(ctx, owner, name, qn, type);
+        if (decl && runtime)
+            decl->flags |= CBM_SOURCE_DECL_F_CONDITIONAL;
+        return;
+    }
+    bool head_runtime = (head->flags & CBM_SOURCE_DECL_F_CONDITIONAL) != 0;
+    if (runtime && !head_runtime)
+        return;
+    bool same = (qn && head->qn && !strcmp(qn, head->qn)) || lua_same_value(type, head->type);
+    if (same && runtime == head_runtime)
+        return;
+    if (!runtime && head_runtime) {
+        head->qn = qn ? cbm_source_table_intern(ctx->walk, qn) : NULL;
+        head->type = type ? cbm_source_table_intern(ctx->walk, type) : NULL;
+        head->file = cbm_source_table_intern(ctx->walk, ctx->walk->file);
+        head->flags &= ~(uint32_t)(CBM_SOURCE_DECL_F_CONDITIONAL | CBM_SOURCE_DECL_F_OPEN);
+        return;
+    }
+    head->flags |= CBM_SOURCE_DECL_F_OPEN;
+}
+
+/* A global also gets an entry for its own file: two scripts of one project each declaring
+ * `function usage()` are one name to the program, but each script reads its own. */
+static void lua_write_member(lua_ctx_t *ctx, const char *owner, const char *name, const char *qn,
+                             const char *type) {
+    if (!owner || !name)
+        return;
+    lua_member_fact(ctx, owner, name, qn, type);
+    if (owner[0] == LUA_GLOBALS[0]) {
+        const char *own = cbm_arena_sprintf(ctx->walk->arena, LUA_OWN_GLOBAL "%s" LUA_PART "%s",
+                                            ctx->walk->file, owner);
+        if (own)
+            lua_member_fact(ctx, own, name, qn, type);
+    }
+}
+
+static bool lua_made_by_call(const char *encoded) {
+    return strstr(encoded, LUA_STEP "()") || strstr(encoded, LUA_STEP "#");
+}
+
+/* The table a write through this path lands in: a local's value when it has one. */
+static const char *lua_owner_key(lua_ctx_t *ctx, const char *encoded, unsigned hops) {
+    if (!encoded || encoded[0] != 'L')
+        return encoded;
+    if (hops > LUA_MAX_CANON_HOPS)
+        return NULL;
+    const char *step = strchr(encoded, LUA_STEP[0]);
+    size_t length = step ? (size_t)(step - encoded) : strlen(encoded);
+    const char *root = cbm_arena_strndup(ctx->walk->arena, encoded, length);
+    const cbm_source_decl_t *fact = root ? lua_fact(ctx, root) : NULL;
+    if (!fact || !fact->type || (fact->flags & CBM_SOURCE_DECL_F_OPEN))
+        return NULL;
+    /* A call makes a new table each time, so what is written through this local is its own. */
+    if (lua_made_by_call(fact->type))
+        return encoded;
+    const char *expanded =
+        cbm_arena_sprintf(ctx->walk->arena, "%s%s", fact->type, step ? step : "");
+    return lua_owner_key(ctx, expanded, hops + 1);
+}
+
+/* ── Encoding: what an expression's value is, as a path ────────────── */
+
+static const char *lua_encode(lua_ctx_t *ctx, TSNode node, unsigned depth);
+
+static const char *lua_encode_global(lua_ctx_t *ctx, const char *name) {
+    if (lua_environment_replaced(ctx))
+        return NULL;
+    if (!strcmp(name, "_G") || !strcmp(name, "_ENV"))
+        return LUA_GLOBALS;
+    return cbm_arena_sprintf(ctx->walk->arena, LUA_GLOBALS LUA_STEP ".%s", name);
+}
+
+static bool lua_global_callee(const lua_ctx_t *ctx, TSNode callee, const char *name) {
+    if (!cbm_source_is(callee, "identifier"))
+        return false;
+    const char *text = cbm_source_text(ctx->walk, callee);
+    return text && !strcmp(text, name) && !cbm_ht_get(ctx->visible, name);
+}
+
+static const char *lua_encode_require(lua_ctx_t *ctx, TSNode literal) {
+    const char *module = lua_literal(ctx, literal);
+    if (!module || !*module)
+        return NULL;
+    return cbm_arena_sprintf(ctx->walk->arena, LUA_MODULES "%s" LUA_PART "%s", ctx->directory,
+                             module);
+}
+
+static const char *lua_encode_call(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    TSNode callee = cbm_source_field(node, "name");
+    lua_nodes_t args = lua_children(ctx, cbm_source_field(node, "arguments"), NULL);
+    if (lua_global_callee(ctx, callee, "require"))
+        return args.count == 1 ? lua_encode_require(ctx, args.items[0]) : NULL;
+    /* setmetatable returns its first argument. */
+    if (lua_global_callee(ctx, callee, "setmetatable"))
+        return args.count == 2 ? lua_encode(ctx, args.items[0], depth + 1) : NULL;
+    const char *encoded = lua_encode(ctx, callee, depth + 1);
+    return encoded ? cbm_arena_sprintf(ctx->walk->arena, "%s" LUA_STEP "()", encoded) : NULL;
+}
+
+/* `a or {}` is a, or a table with nothing declared in it: only a can select a member. */
+static const char *lua_encode_or(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    TSNode right = cbm_source_field(node, "right");
+    if (!cbm_source_token(node, "or"))
+        return NULL;
+    if (cbm_source_is(right, "table_constructor") || cbm_source_is(right, "nil"))
+        return lua_encode(ctx, cbm_source_field(node, "left"), depth + 1);
+    return NULL;
+}
+
+static const char *lua_encode(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    if (ts_node_is_null(node) || depth > LUA_MAX_EVAL_DEPTH)
+        return NULL;
+    cbm_source_walk_t *walk = ctx->walk;
+    if (cbm_source_is(node, "identifier")) {
+        const char *name = cbm_source_text(walk, node);
+        if (!name)
+            return NULL;
+        const lua_binder_t *binder = lua_binder_of(ctx, name);
+        return binder ? binder->identity : lua_encode_global(ctx, name);
+    }
+    if (lua_is_index(node)) {
+        const char *member = lua_index_member(ctx, node);
+        const char *table =
+            member ? lua_encode(ctx, cbm_source_field(node, "table"), depth + 1) : NULL;
+        return table ? cbm_arena_sprintf(walk->arena, "%s" LUA_STEP ".%s", table, member) : NULL;
+    }
+    if (cbm_source_is(node, "function_call"))
+        return lua_encode_call(ctx, node, depth);
+    if (cbm_source_is(node, "table_constructor"))
+        return lua_identity(ctx, 'T', ts_node_start_byte(node));
+    if (cbm_source_is(node, "function_definition"))
+        return lua_identity(ctx, 'F', ts_node_start_byte(node));
+    if (cbm_source_is(node, "parenthesized_expression")) {
+        lua_nodes_t inner = lua_children(ctx, node, NULL);
+        return inner.count == 1 ? lua_encode(ctx, inner.items[0], depth + 1) : NULL;
+    }
+    if (cbm_source_is(node, "binary_expression"))
+        return lua_encode_or(ctx, node, depth);
+    return NULL;
+}
+
+/* ── Phase two: evaluation ─────────────────────────────────────────── */
+
+static lua_value_t lua_unknown(const char *reason) {
+    return (lua_value_t){.kind = LUA_UNKNOWN, .reason = reason};
+}
+
+/* Names the host defines. A project may wrap one in its own file, but another file's
+ * declaration does not decide what the name means everywhere. */
+static bool lua_standard_global(const char *name) {
+    static const char *const names[] = {
+        "assert",     "collectgarbage", "coroutine", "debug",    "dofile",       "error",
+        "getfenv",    "getmetatable",   "io",        "ipairs",   "load",         "loadfile",
+        "loadstring", "math",           "module",    "next",     "os",           "package",
+        "pairs",      "pcall",          "print",     "rawequal", "rawget",       "rawlen",
+        "rawset",     "require",        "select",    "setfenv",  "setmetatable", "string",
+        "table",      "tonumber",       "tostring",  "type",     "unpack",       "utf8",
+        "warn",       "xpcall",         "bit32",     "bit",      "jit",          "ffi",
+        NULL};
+    for (size_t i = 0; names[i]; i++)
+        if (!strcmp(name, names[i]))
+            return true;
+    return false;
+}
+
+/* The host preloads these in package.loaded: `require('os')` never reads an os.lua. */
+static bool lua_preloaded_library(const char *module) {
+    static const char *const names[] = {"string", "table", "math",    "io",        "os",
+                                        "debug",  "utf8",  "package", "coroutine", "bit",
+                                        "bit32",  "ffi",   "jit",     "_G",        NULL};
+    for (size_t i = 0; names[i]; i++)
+        if (!strcmp(module, names[i]))
+            return true;
+    return false;
+}
+
+static void lua_value_add_name(lua_value_t *value, const char *name) {
+    if (!name || (value->key && !strcmp(value->key, name)))
+        return;
+    for (size_t i = 0; i < LUA_VALUE_NAMES; i++) {
+        if (!value->names[i]) {
+            value->names[i] = name;
+            return;
+        }
+        if (!strcmp(value->names[i], name))
+            return;
+    }
+}
+
+/* A global's own-file entry first: `function usage()` in this script is what it reads. */
+static const cbm_source_decl_t *lua_own_global(lua_ctx_t *ctx, const char *table,
+                                               const char *name) {
+    if (!table || table[0] != LUA_GLOBALS[0])
+        return NULL;
+    const char *own = cbm_arena_sprintf(ctx->walk->arena, LUA_OWN_GLOBAL "%s" LUA_PART "%s",
+                                        ctx->walk->file, table);
+    return own ? cbm_source_lookup(ctx->walk, own, name) : NULL;
+}
+
+static const cbm_source_decl_t *lua_member_decl(lua_ctx_t *ctx, const lua_value_t *table,
+                                                const char *name) {
+    const cbm_source_decl_t *mine = lua_own_global(ctx, table->key, name);
+    for (size_t i = 0; !mine && i < LUA_VALUE_NAMES && table->names[i]; i++)
+        mine = lua_own_global(ctx, table->names[i], name);
+    if (mine)
+        return mine;
+    const cbm_source_decl_t *decl = cbm_source_lookup(ctx->walk, table->key, name);
+    for (size_t i = 0; !decl && i < LUA_VALUE_NAMES && table->names[i]; i++)
+        decl = cbm_source_lookup(ctx->walk, table->names[i], name);
+    if (decl && !strcmp(table->key, LUA_GLOBALS) && lua_standard_global(name))
+        return NULL;
+    return decl;
+}
+
+static lua_value_t lua_member(lua_ctx_t *ctx, lua_value_t base, const char *name, unsigned depth);
+
+/* `__index = function(t, k) ... require('prefix.' .. k) ...`: a member t does not have is that
+ * module, when the project has it. */
+static bool lua_lazy_module(lua_ctx_t *ctx, const lua_value_t *base, const char *name,
+                            unsigned depth, lua_value_t *out) {
+    const cbm_source_decl_t *lazy = lua_member_decl(ctx, base, LUA_LAZY);
+    if (!lazy || !lazy->type)
+        return false;
+    const char *root = cbm_arena_sprintf(ctx->walk->arena, LUA_MODULES "%s" LUA_PART "%s%s",
+                                         ctx->directory, lazy->type, name);
+    if (!root)
+        return false;
+    lua_value_t value = lua_eval(ctx, root, depth + 1);
+    if (value.kind == LUA_UNKNOWN)
+        return false;
+    *out = value;
+    return true;
+}
+
+/* `@class C: A, B`: a member C does not declare is the parents', when one of them declares it.
+ * A parent the project has no table for could hold any name, so it leaves them all open. */
+static bool lua_class_member(lua_ctx_t *ctx, const lua_value_t *base, const char *name,
+                             unsigned depth, lua_value_t *out) {
+    const char *class_name = NULL;
+    if (!strncmp(base->key, LUA_CLASSES, strlen(LUA_CLASSES))) {
+        class_name = base->key + strlen(LUA_CLASSES);
+    } else {
+        const cbm_source_decl_t *own = lua_member_decl(ctx, base, LUA_CLASS_OF);
+        if (own && !(own->flags & CBM_SOURCE_DECL_F_OPEN))
+            class_name = own->type;
+    }
+    if (!class_name)
+        return false;
+    lua_value_t chosen = {0};
+    bool found = false;
+    for (const cbm_source_decl_t *parent = cbm_source_lookup(ctx->walk, LUA_PARENTS, class_name);
+         parent; parent = parent->next) {
+        if (!parent->type)
+            return false;
+        /* Both through the memo: a hierarchy is walked once per (class, name), and a class that
+         * reaches itself comes back unknown. */
+        const char *root = cbm_arena_sprintf(ctx->walk->arena, LUA_CLASSES "%s", parent->type);
+        const char *path =
+            root ? cbm_arena_sprintf(ctx->walk->arena, "%s" LUA_STEP ".%s", root, name) : NULL;
+        if (!path || lua_eval(ctx, root, depth + 1).kind != LUA_TABLE)
+            return false;
+        lua_value_t member = lua_eval(ctx, path, depth + 1);
+        if (member.absent && member.reason && !strcmp(member.reason, "lua_member_not_declared"))
+            continue;
+        if (member.absent)
+            return false;
+        bool same = member.kind == chosen.kind &&
+                    (member.kind == LUA_FUNCTION ? member.function == chosen.function
+                     : member.kind == LUA_TABLE  ? !strcmp(member.key, chosen.key)
+                                                 : false);
+        if (found && !same)
+            return false;
+        chosen = member;
+        found = true;
+    }
+    if (found)
+        *out = chosen;
+    return found;
+}
+
+/* `setmetatable(t, mt)`: a member t does not have comes from mt.__index. */
+static bool lua_metatable_member(lua_ctx_t *ctx, const lua_value_t *base, const char *name,
+                                 unsigned depth, lua_value_t *out) {
+    const cbm_source_decl_t *meta = lua_member_decl(ctx, base, LUA_META);
+    if (!meta || (meta->flags & CBM_SOURCE_DECL_F_OPEN) || !meta->type)
+        return false;
+    lua_value_t metatable = lua_eval(ctx, meta->type, depth + 1);
+    if (metatable.kind != LUA_TABLE)
+        return false;
+    const cbm_source_decl_t *index = lua_member_decl(ctx, &metatable, "__index");
+    if (!index || (index->flags & CBM_SOURCE_DECL_F_OPEN) || !index->type)
+        return false;
+    lua_value_t parent = lua_eval(ctx, index->type, depth + 1);
+    if (parent.kind != LUA_TABLE)
+        return false;
+    lua_value_t found = lua_member(ctx, parent, name, depth + 1);
+    if (found.kind == LUA_TABLE && found.absent)
+        return false;
+    *out = found;
+    return true;
+}
+
+static bool lua_inherited(lua_ctx_t *ctx, const lua_value_t *base, const char *name, unsigned depth,
+                          lua_value_t *out) {
+    if (lua_lazy_module(ctx, base, name, depth, out))
+        return true;
+    const cbm_source_decl_t *shape = lua_member_decl(ctx, base, LUA_SHAPE);
+    if (shape && !(shape->flags & CBM_SOURCE_DECL_F_OPEN) && shape->type) {
+        lua_value_t found = lua_member(ctx, lua_eval(ctx, shape->type, depth + 1), name, depth + 1);
+        if (found.kind != LUA_UNKNOWN && !found.absent) {
+            *out = found;
+            return true;
+        }
+    }
+    return lua_metatable_member(ctx, base, name, depth, out) ||
+           lua_class_member(ctx, base, name, depth, out);
+}
+
+static lua_value_t lua_member(lua_ctx_t *ctx, lua_value_t base, const char *name, unsigned depth) {
+    if (base.kind != LUA_TABLE)
+        return lua_unknown(base.kind == LUA_FUNCTION ? "lua_member_of_a_function" : base.reason);
+    if (depth > LUA_MAX_EVAL_DEPTH)
+        return lua_unknown("lua_value_chain_too_long");
+    lua_value_t virtual_path = {.kind = LUA_TABLE, .absent = true};
+    virtual_path.key = cbm_arena_sprintf(ctx->walk->arena, "%s" LUA_STEP ".%s", base.key, name);
+    if (!virtual_path.key)
+        return lua_unknown("lua_value_allocation");
+    for (size_t i = 0; i < LUA_VALUE_NAMES && base.names[i]; i++)
+        lua_value_add_name(&virtual_path, cbm_arena_sprintf(ctx->walk->arena, "%s" LUA_STEP ".%s",
+                                                            base.names[i], name));
+    const cbm_source_decl_t *decl = lua_member_decl(ctx, &base, name);
+    if (decl) {
+        if (decl->flags & CBM_SOURCE_DECL_F_OPEN) {
+            /* Which value it holds is open; a member spelled through the path is not. */
+            virtual_path.reason = "lua_member_not_one_declaration";
+            return virtual_path;
+        }
+        if (!decl->type)
+            return lua_unknown("lua_member_value_unknown");
+        lua_value_t value = lua_eval(ctx, decl->type, depth + 1);
+        if (value.kind == LUA_TABLE) {
+            lua_value_add_name(&value, virtual_path.key);
+            for (size_t i = 0; i < LUA_VALUE_NAMES && virtual_path.names[i]; i++)
+                lua_value_add_name(&value, virtual_path.names[i]);
+        }
+        return value;
+    }
+    lua_value_t inherited;
+    if (lua_inherited(ctx, &base, name, depth, &inherited))
+        return inherited;
+    virtual_path.reason = "lua_member_not_declared";
+    return virtual_path;
+}
+
+/* What LuaCATS says this local or function holds, for when its value does not say. */
+static bool lua_annotated(lua_ctx_t *ctx, const char *owner, const char *name, unsigned depth,
+                          lua_value_t *out) {
+    const char *key = cbm_arena_sprintf(ctx->walk->arena, LUA_ANNOTATED "%s", owner);
+    const cbm_source_decl_t *fact = key ? cbm_source_lookup(ctx->walk, key, name) : NULL;
+    if (!fact || !fact->type)
+        return false;
+    lua_value_t value = lua_eval(ctx, fact->type, depth + 1);
+    if (value.kind == LUA_UNKNOWN)
+        return false;
+    *out = value;
+    return true;
+}
+
+/* A table's `__call`, when it is called. */
+static lua_value_t lua_callable_of(lua_ctx_t *ctx, lua_value_t value, unsigned depth) {
+    if (value.kind != LUA_TABLE)
+        return value;
+    const cbm_source_decl_t *meta = lua_member_decl(ctx, &value, LUA_META);
+    if (meta && !(meta->flags & CBM_SOURCE_DECL_F_OPEN) && meta->type) {
+        lua_value_t metatable = lua_eval(ctx, meta->type, depth + 1);
+        if (metatable.kind == LUA_TABLE) {
+            const cbm_source_decl_t *call = lua_member_decl(ctx, &metatable, "__call");
+            if (call && !(call->flags & CBM_SOURCE_DECL_F_OPEN) && call->type)
+                return lua_eval(ctx, call->type, depth + 1);
+        }
+    }
+    return lua_unknown(value.absent ? value.reason : "lua_call_of_a_table_value");
+}
+
+static lua_value_t lua_call_result(lua_ctx_t *ctx, lua_value_t value, unsigned depth) {
+    lua_value_t callable = lua_callable_of(ctx, value, depth);
+    if (callable.kind != LUA_FUNCTION)
+        return lua_unknown(callable.reason);
+    lua_value_t returned = callable.function->type
+                               ? lua_eval(ctx, callable.function->type, depth + 1)
+                               : lua_unknown("lua_return_value_unknown");
+    lua_value_t annotated;
+    if ((returned.kind == LUA_UNKNOWN || returned.absent) &&
+        lua_annotated(ctx, callable.function->owner, callable.function->name, depth, &annotated))
+        return annotated;
+    return returned;
+}
+
+/* `local a, b = f()`: b is what every `return x, y` of f gives second. */
+static lua_value_t lua_call_value_at(lua_ctx_t *ctx, lua_value_t value, const char *position,
+                                     unsigned depth) {
+    lua_value_t callable = lua_callable_of(ctx, value, depth);
+    if (callable.kind != LUA_FUNCTION)
+        return lua_unknown(callable.reason);
+    const cbm_source_decl_t *function = callable.function;
+    const char *owner =
+        cbm_arena_sprintf(ctx->walk->arena, "%s" LUA_PART "%s", function->owner, function->name);
+    const char *name = cbm_arena_sprintf(ctx->walk->arena, LUA_RETURN_AT "%s", position);
+    const cbm_source_decl_t *fact =
+        owner && name ? cbm_source_lookup(ctx->walk, owner, name) : NULL;
+    if (!fact || (fact->flags & CBM_SOURCE_DECL_F_OPEN) || !fact->type)
+        return lua_unknown("lua_return_value_unknown");
+    return lua_eval(ctx, fact->type, depth + 1);
+}
+
+/* Every file that this literal can load by package.path, nearest first. The working directory
+ * is the requiring file's or one of its ancestors; a `lua/` root is on the path by convention,
+ * and is only taken when it alone offers the name. */
+static const char *lua_required_file(lua_ctx_t *ctx, const char *directory, const char *module,
+                                     const char **reason) {
+    cbm_source_walk_t *walk = ctx->walk;
+    if (lua_preloaded_library(module)) {
+        *reason = "lua_require_of_a_preloaded_library";
+        return NULL;
+    }
+    char *path = cbm_arena_strdup(walk->arena, module);
+    char *current = cbm_arena_strdup(walk->arena, directory);
+    if (!path || !current)
+        return NULL;
+    for (char *p = path; *p; p++)
+        if (*p == '.')
+            *p = '/';
+    for (;;) {
+        const char *base =
+            cbm_arena_sprintf(walk->arena, "%s%s%s", current, *current ? "/" : "", path);
+        const char *first = base ? cbm_arena_sprintf(walk->arena, "%s.lua", base) : NULL;
+        const char *second = base ? cbm_arena_sprintf(walk->arena, "%s/init.lua", base) : NULL;
+        const char *key1 = first ? cbm_arena_sprintf(walk->arena, LUA_RETURNS "%s", first) : NULL;
+        const char *key2 = second ? cbm_arena_sprintf(walk->arena, LUA_RETURNS "%s", second) : NULL;
+        if (key1 && cbm_source_lookup(walk, key1, ""))
+            return first;
+        if (key2 && cbm_source_lookup(walk, key2, ""))
+            return second;
+        if (!*current)
+            break;
+        char *slash = strrchr(current, '/');
+        if (slash)
+            *slash = '\0';
+        else
+            current[0] = '\0';
+    }
+    const cbm_source_decl_t *named = cbm_source_lookup(walk, LUA_MODULES, path);
+    if (!named) {
+        *reason = "lua_require_outside_project";
+        return NULL;
+    }
+    for (const cbm_source_decl_t *other = named->next; other; other = other->next) {
+        if (strcmp(other->file, named->file)) {
+            *reason = "lua_require_several_project_files";
+            return NULL;
+        }
+    }
+    return named->file;
+}
+
+static lua_value_t lua_eval_root(lua_ctx_t *ctx, const char *root, unsigned depth) {
+    cbm_source_walk_t *walk = ctx->walk;
+    switch (root[0]) {
+    case 'G':
+        return (lua_value_t){.kind = LUA_TABLE, .key = LUA_GLOBALS};
+    case 'T':
+        return (lua_value_t){.kind = LUA_TABLE, .key = root};
+    case 'F': {
+        const cbm_source_decl_t *function = lua_fact(ctx, root);
+        return function ? (lua_value_t){.kind = LUA_FUNCTION, .function = function}
+                        : lua_unknown("lua_function_not_collected");
+    }
+    case 'C': {
+        const char *class_name = root + strlen(LUA_CLASSES);
+        const cbm_source_decl_t *declared = cbm_source_lookup(walk, LUA_CLASSES, class_name);
+        if (!declared && cbm_source_lookup(walk, LUA_PARENTS, class_name))
+            return (lua_value_t){.kind = LUA_TABLE, .key = root};
+        if (!declared || (declared->flags & CBM_SOURCE_DECL_F_OPEN) || !declared->type)
+            return lua_unknown("lua_annotated_class_has_no_table");
+        return lua_eval(ctx, declared->type, depth + 1);
+    }
+    case 'L': {
+        const char *part = strchr(root, LUA_PART[0]);
+        const char *owner =
+            part ? cbm_arena_strndup(walk->arena, root, (size_t)(part - root)) : NULL;
+        const char *flags = part ? cbm_arena_sprintf(walk->arena, LUA_FLAGS "%.*s",
+                                                     (int)(part - root - 2), root + 2)
+                                 : NULL;
+        if (!owner)
+            return lua_unknown("lua_value_allocation");
+        if (flags && cbm_source_lookup(walk, flags, "debug"))
+            return lua_unknown("lua_debug_rewrites_locals");
+        const cbm_source_decl_t *fact = cbm_source_lookup(walk, owner, part + 1);
+        lua_value_t value = !fact ? lua_unknown("lua_local_value_unknown")
+                            : (fact->flags & CBM_SOURCE_DECL_F_OPEN)
+                                ? lua_unknown("lua_local_written_more_than_once")
+                            : fact->type ? lua_eval(ctx, fact->type, depth + 1)
+                                         : lua_unknown("lua_local_value_unknown");
+        lua_value_t annotated;
+        if ((value.kind == LUA_UNKNOWN || value.absent) &&
+            lua_annotated(ctx, owner, part + 1, depth, &annotated))
+            return annotated;
+        /* A table a call made: this local's writes are the ones that apply to it. */
+        if (value.kind == LUA_TABLE && fact && fact->type && lua_made_by_call(fact->type))
+            lua_value_add_name(&value, root);
+        return value;
+    }
+    case 'R': {
+        const char *part = strchr(root, LUA_PART[0]);
+        if (!part)
+            return lua_unknown("lua_require_not_literal");
+        if (cbm_source_lookup(walk, LUA_GLOBALS, "require"))
+            return lua_unknown("lua_require_redefined");
+        const char *directory = cbm_arena_strndup(walk->arena, root + strlen(LUA_MODULES),
+                                                  (size_t)(part - root) - strlen(LUA_MODULES));
+        const char *reason = "lua_require_outside_project";
+        const char *file = directory ? lua_required_file(ctx, directory, part + 1, &reason) : NULL;
+        if (!file)
+            return lua_unknown(reason);
+        const char *key = cbm_arena_sprintf(walk->arena, LUA_RETURNS "%s", file);
+        const cbm_source_decl_t *module = key ? cbm_source_lookup(walk, key, "") : NULL;
+        if (!module || (module->flags & CBM_SOURCE_DECL_F_OPEN) || !module->type)
+            return lua_unknown("lua_module_return_unknown");
+        lua_value_t value = lua_eval(ctx, module->type, depth + 1);
+        /* A file can extend what it required: `function M.more()` on `require('a')`. */
+        if (value.kind == LUA_TABLE)
+            lua_value_add_name(&value, root);
+        return value;
+    }
+    default:
+        return lua_unknown("lua_value_not_modelled");
+    }
+}
+
+static lua_value_t lua_eval_uncached(lua_ctx_t *ctx, const char *encoded, unsigned depth) {
+    if (depth > LUA_MAX_EVAL_DEPTH)
+        return lua_unknown("lua_value_chain_too_long");
+    cbm_source_walk_t *walk = ctx->walk;
+    const char *step = strchr(encoded, LUA_STEP[0]);
+    const char *root =
+        step ? cbm_arena_strndup(walk->arena, encoded, (size_t)(step - encoded)) : encoded;
+    if (!root)
+        return lua_unknown("lua_value_allocation");
+    lua_value_t value = lua_eval_root(ctx, root, depth);
+    while (step) {
+        const char *next = strchr(step + 1, LUA_STEP[0]);
+        const char *part =
+            next ? cbm_arena_strndup(walk->arena, step + 1, (size_t)(next - step - 1)) : step + 1;
+        if (!part)
+            return lua_unknown("lua_value_allocation");
+        value = part[0] == '.'   ? lua_member(ctx, value, part + 1, depth)
+                : part[0] == '#' ? lua_call_value_at(ctx, value, part + 1, depth)
+                                 : lua_call_result(ctx, value, depth);
+        step = next;
+    }
+    return value;
+}
+
+/* The memo makes each distinct path cost once per file and ends a cycle: a path that needs
+ * itself has no value. */
+static lua_value_t lua_eval(lua_ctx_t *ctx, const char *encoded, unsigned depth) {
+    lua_value_t *known = cbm_ht_get(ctx->memo, encoded);
+    if (known)
+        return known->pending ? lua_unknown("lua_value_needs_itself") : *known;
+    lua_value_t *slot = cbm_arena_calloc(ctx->walk->arena, sizeof(*slot));
+    const char *key = cbm_arena_strdup(ctx->walk->arena, encoded);
+    if (!slot || !key)
+        return lua_unknown("lua_value_allocation");
+    slot->pending = true;
+    cbm_ht_set(ctx->memo, key, slot);
+    lua_value_t value = lua_eval_uncached(ctx, encoded, depth);
+    *slot = value;
+    slot->pending = false;
+    return value;
+}
+
+/* ── Phase two: sites ──────────────────────────────────────────────── */
+
+static cbm_resolve_rule_t lua_rule(const lua_ctx_t *ctx, const cbm_source_decl_t *function) {
+    return strcmp(function->file, ctx->walk->file) ? CBM_RESOLVE_RULE_IMPORT_BINDING
+                                                   : CBM_RESOLVE_RULE_SCOPE_BINDING;
+}
+
+static void lua_emit_call(lua_ctx_t *ctx, TSNode call, TSNode callee) {
+    cbm_source_walk_t *walk = ctx->walk;
+    if (lua_global_callee(ctx, callee, "require")) {
+        cbm_source_emit_node(walk, call, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE, NULL,
+                             "lua_require_loads_a_module");
+        return;
+    }
+    const char *encoded = lua_encode(ctx, callee, 0);
+    if (!encoded) {
+        cbm_source_emit_node(walk, call, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE, NULL,
+                             "lua_callee_computed");
+        return;
+    }
+    lua_value_t value = lua_callable_of(ctx, lua_eval(ctx, encoded, 0), 0);
+    if (value.kind != LUA_FUNCTION) {
+        cbm_source_emit_node(walk, call, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE, NULL,
+                             value.reason ? value.reason : "lua_callee_value_unknown");
+        return;
+    }
+    const char *target = value.function->qn;
+    cbm_source_emit_node(walk, call, CBM_SOURCE_SITE_CALL, target, lua_rule(ctx, value.function),
+                         value.function->file,
+                         target ? "lua_value_flow_selected_declaration"
+                                : "lua_function_has_no_graph_node");
+}
+
+static void lua_emit_value(lua_ctx_t *ctx, TSNode site, const char *encoded) {
+    cbm_source_walk_t *walk = ctx->walk;
+    lua_value_t value = encoded ? lua_eval(ctx, encoded, 0) : lua_unknown("lua_value_computed");
+    if (value.kind == LUA_FUNCTION) {
+        const char *target = value.function->qn;
+        cbm_source_emit_node(walk, site, CBM_SOURCE_SITE_REFERENCE, target,
+                             lua_rule(ctx, value.function), value.function->file,
+                             target ? "lua_value_flow_selected_declaration"
+                                    : "lua_function_has_no_graph_node");
+        return;
+    }
+    cbm_source_emit_node(walk, site, CBM_SOURCE_SITE_REFERENCE, NULL, CBM_RESOLVE_RULE_NONE, NULL,
+                         value.reason ? value.reason : "lua_value_is_not_a_declaration");
+}
+
+/* An identifier read: the local its scope binds, or the global namespace. */
+static void lua_emit_identifier(lua_ctx_t *ctx, TSNode node, bool callee) {
+    cbm_source_walk_t *walk = ctx->walk;
+    const char *name = cbm_source_text(walk, node);
+    if (!name)
+        return;
+    const lua_binder_t *binder = lua_binder_of(ctx, name);
+    if (binder) {
+        const char *target = binder->qn;
+        /* Calling a function declared under this very name is the call, not a read. */
+        if (target && callee) {
+            lua_value_t value = lua_eval(ctx, binder->identity, 0);
+            if (value.kind == LUA_FUNCTION && value.function->qn &&
+                !strcmp(value.function->qn, target))
+                target = NULL;
+        }
+        cbm_source_emit_node(walk, node, CBM_SOURCE_SITE_REFERENCE, target,
+                             CBM_RESOLVE_RULE_SCOPE_BINDING, walk->file,
+                             target       ? "lua_lexical_local"
+                             : binder->qn ? "lua_callee_name_is_the_call"
+                                          : "lua_local_has_no_graph_node");
+        return;
+    }
+    if (callee) {
+        cbm_source_emit_node(walk, node, CBM_SOURCE_SITE_REFERENCE, NULL, CBM_RESOLVE_RULE_NONE,
+                             NULL, "lua_callee_name_is_the_call");
+        return;
+    }
+    lua_emit_value(ctx, node, lua_encode_global(ctx, name));
+}
+
+/* ── The walk, shared by both phases ───────────────────────────────── */
+
+static void lua_visit_children(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (ts_node_is_named(child) && !lua_ignored(child))
+                lua_visit(ctx, child, depth + 1);
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+}
+
+static void lua_visit_scoped(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    lua_binder_t *mark = ctx->top;
+    lua_visit_children(ctx, node, depth);
+    lua_pop_to(ctx, mark);
+}
+
+static void lua_annotate_root(lua_ctx_t *ctx, const char *root, const char *type) {
+    const char *qualified = cbm_arena_sprintf(ctx->walk->arena, LUA_ANNOTATED "%s", root);
+    const char *value = cbm_arena_sprintf(ctx->walk->arena, LUA_CLASSES "%s", type);
+    if (qualified && value)
+        lua_declare_root(ctx, qualified, NULL, value);
+}
+
+/* `@param client vim.lsp.Client`: the parameter holds an instance of that class. */
+static void lua_bind_parameters(lua_ctx_t *ctx, TSNode parameters, const lua_doc_t *doc) {
+    lua_nodes_t names = lua_children(ctx, parameters, "name");
+    for (uint32_t i = 0; i < names.count; i++) {
+        TSNode name = names.items[i];
+        lua_binder_t *binder =
+            lua_push(ctx, cbm_source_text(ctx->walk, name), ts_node_start_byte(name), 0);
+        /* It holds what the caller passed, so `opts = opts or {}` is not its only value. */
+        if (binder)
+            binder->assigned = true;
+        if (!binder || !doc)
+            continue;
+        for (unsigned p = 0; p < doc->param_count; p++) {
+            if (strcmp(doc->param_names[p], binder->name))
+                continue;
+            lua_annotate_root(ctx, binder->identity, doc->param_types[p]);
+            break;
+        }
+    }
+}
+
+/* A function's value facts and its body. spelled is the name its declaration or assignment
+ * gives it, which is how extraction named its node; receiver is what `self` holds. */
+static void lua_visit_function(lua_ctx_t *ctx, TSNode node, const char *spelled,
+                               const char *receiver, uint32_t self_at, unsigned depth) {
+    if (!cbm_source_step(ctx->walk, depth))
+        return;
+    lua_flow_t flow = {0};
+    lua_flow_t *outer = ctx->flow;
+    const lua_doc_t *doc = ctx->doc;
+    ctx->doc = NULL;
+    ctx->flow = &flow;
+    lua_binder_t *mark = ctx->top;
+    ctx->function_depth++;
+    /* `function a:m()` binds self, whatever a is. */
+    if (self_at) {
+        lua_binder_t *self = lua_push(ctx, "self", self_at, 0);
+        if (self && receiver && ctx->collecting) {
+            self->assigned = true;
+            lua_declare_root(ctx, self->identity, NULL, receiver);
+        }
+    }
+    lua_bind_parameters(ctx, cbm_source_field(node, "parameters"), doc);
+    TSNode body = cbm_source_field(node, "body");
+    if (!ts_node_is_null(body))
+        lua_visit(ctx, body, depth + 1);
+    lua_pop_to(ctx, mark);
+    ctx->function_depth--;
+    ctx->flow = outer;
+    if (ctx->collecting) {
+        const char *root = lua_identity(ctx, 'F', ts_node_start_byte(node));
+        const char *qn =
+            spelled ? cbm_source_def_qn_at(ctx->walk, spelled, ts_node_start_point(node).row + 1)
+                    : NULL;
+        if (root)
+            lua_declare_root(ctx, root, qn, flow.open ? NULL : flow.value);
+        for (unsigned i = 0; root && i < LUA_RETURN_VALUES; i++) {
+            if (flow.later_open[i] || !flow.later[i])
+                continue;
+            const char *name = cbm_arena_sprintf(ctx->walk->arena, LUA_RETURN_AT "%u", i + 1);
+            if (name)
+                (void)lua_declare(ctx, root, name, NULL, flow.later[i]);
+        }
+        if (root && doc && doc->return_type)
+            lua_annotate_root(ctx, root, doc->return_type);
+    }
+}
+
+/* The QN a function assigned under this spelling will have. */
+static const char *lua_function_qn(lua_ctx_t *ctx, TSNode value, const char *spelled) {
+    return spelled && cbm_source_is(value, "function_definition")
+               ? cbm_source_def_qn_at(ctx->walk, spelled, ts_node_start_point(value).row + 1)
+               : NULL;
+}
+
+/* A write to a local: its first value if it had none, otherwise it holds more than one. */
+static void lua_write_local(lua_ctx_t *ctx, lua_binder_t *binder, const char *encoded) {
+    if (!binder->assigned) {
+        binder->assigned = true;
+        if (encoded)
+            lua_declare_root(ctx, binder->identity, NULL, encoded);
+        return;
+    }
+    /* `x = setmetatable(x, mt)` keeps x, and `screen = Screen.new()` in each test writes one
+     * value many times. */
+    if (encoded && !strcmp(encoded, binder->identity))
+        return;
+    cbm_source_decl_t *fact = (cbm_source_decl_t *)lua_fact(ctx, binder->identity);
+    if (fact && !(encoded && fact->type && !strcmp(encoded, fact->type)))
+        fact->flags |= CBM_SOURCE_DECL_F_OPEN;
+}
+
+/* `x = v` where x is not a local, or `M.x = v`, `M['x'] = v`. */
+static void lua_write_target(lua_ctx_t *ctx, TSNode target, TSNode value, const char *encoded) {
+    cbm_source_walk_t *walk = ctx->walk;
+    const char *spelled = cbm_source_text(walk, target);
+    const char *qn = lua_function_qn(ctx, value, spelled);
+    if (cbm_source_is(target, "identifier")) {
+        lua_binder_t *binder = lua_binder_of(ctx, spelled);
+        if (binder) {
+            lua_write_local(ctx, binder, encoded);
+            return;
+        }
+        if (spelled && !strcmp(spelled, "_ENV")) {
+            (void)lua_declare(ctx, cbm_arena_sprintf(walk->arena, LUA_FLAGS "%s", walk->file),
+                              "setfenv", NULL, NULL);
+            return;
+        }
+        if (lua_environment_replaced(ctx) || !spelled)
+            return;
+        /* `vim = vim or {}` keeps what the name had. */
+        const char *self = lua_encode_global(ctx, spelled);
+        if (!encoded || !self || strcmp(encoded, self))
+            lua_write_member(ctx, LUA_GLOBALS, spelled, qn, encoded);
+        return;
+    }
+    const char *member = lua_index_member(ctx, target);
+    const char *table = member ? lua_encode(ctx, cbm_source_field(target, "table"), 0) : NULL;
+    if (table)
+        lua_write_member(ctx, lua_owner_key(ctx, table, 0), member, qn, encoded);
+}
+
+/* `x = x or v` keeps x when it is set, so what the statement adds is v. */
+static TSNode lua_unwrap_self_default(lua_ctx_t *ctx, TSNode target, TSNode value) {
+    if (!cbm_source_is(value, "binary_expression") || !cbm_source_token(value, "or"))
+        return value;
+    const char *left = cbm_source_text(ctx->walk, cbm_source_field(value, "left"));
+    const char *spelled = cbm_source_text(ctx->walk, target);
+    return left && spelled && !strcmp(left, spelled) ? cbm_source_field(value, "right") : value;
+}
+
+/* `@class vim.lsp.Client` on `local Client = {}`: the class is this table. A value computed any
+ * other way is not what the annotation is about. */
+static void lua_note_class(lua_ctx_t *ctx, TSNode value, const char *table, const char *holder) {
+    if (!ctx->collecting || !ctx->doc || !ctx->doc->class_name)
+        return;
+    if (cbm_source_is(value, "table_constructor") ||
+        (cbm_source_is(value, "function_call") &&
+         lua_global_callee(ctx, cbm_source_field(value, "name"), "setmetatable"))) {
+        if (!table)
+            return;
+        lua_member_fact(ctx, LUA_CLASSES, ctx->doc->class_name, NULL, table);
+        const char *owner = lua_owner_key(ctx, table, 0);
+        if (owner)
+            lua_member_fact(ctx, owner, LUA_CLASS_OF, NULL, ctx->doc->class_name);
+        return;
+    }
+    /* `@class C: A, B` on `M = merge(M, other)`: what M holds now is stated, not computed. */
+    if (holder && holder[0] == 'L' && !strchr(holder, LUA_STEP[0]))
+        lua_annotate_root(ctx, holder, ctx->doc->class_name);
+}
+
+/* `a, b = f()`: the names past the expressions take the last call's later values. */
+static const char *lua_encode_later_value(lua_ctx_t *ctx, const lua_nodes_t *values, uint32_t at) {
+    if (!values->count || at < values->count)
+        return NULL;
+    TSNode last = values->items[values->count - 1];
+    if (!cbm_source_is(last, "function_call"))
+        return NULL;
+    const char *callee = lua_encode(ctx, cbm_source_field(last, "name"), 0);
+    return callee ? cbm_arena_sprintf(ctx->walk->arena, "%s" LUA_STEP "#%u", callee,
+                                      at - values->count + 1)
+                  : NULL;
+}
+
+static void lua_visit_assignment(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    cbm_source_walk_t *walk = ctx->walk;
+    lua_nodes_t targets = {0};
+    TSNode list = (TSNode){0};
+    lua_nodes_t parts = lua_children(ctx, node, NULL);
+    for (uint32_t i = 0; i < parts.count; i++) {
+        if (cbm_source_is(parts.items[i], "variable_list"))
+            targets = lua_children(ctx, parts.items[i], "name");
+        else if (cbm_source_is(parts.items[i], "expression_list"))
+            list = parts.items[i];
+    }
+    lua_nodes_t values = ts_node_is_null(list) ? (lua_nodes_t){0} : lua_children(ctx, list, NULL);
+    if (ctx->collecting) {
+        for (uint32_t i = 0; i < targets.count; i++) {
+            TSNode value = i < values.count ? values.items[i] : (TSNode){0};
+            /* Reading a member of nil raises: a nil selects nothing and replaces nothing. */
+            if (cbm_source_is(value, "nil"))
+                continue;
+            if (!ts_node_is_null(value))
+                value = lua_unwrap_self_default(ctx, targets.items[i], value);
+            const char *encoded = ts_node_is_null(value) ? lua_encode_later_value(ctx, &values, i)
+                                                         : lua_encode(ctx, value, 0);
+            /* `---@type uv` on `vim.uv = ...`: the value says nothing, the annotation does. */
+            if (!encoded && !i && ctx->doc && ctx->doc->type_name)
+                encoded = cbm_arena_sprintf(walk->arena, LUA_CLASSES "%s", ctx->doc->type_name);
+            lua_write_target(ctx, targets.items[i], value, encoded);
+            if (!i) {
+                const char *written = lua_encode(ctx, targets.items[i], 0);
+                lua_note_class(ctx, value, written, written);
+            }
+        }
+    }
+    /* A write target reads only the table it indexes. */
+    for (uint32_t i = 0; i < targets.count; i++) {
+        TSNode target = targets.items[i];
+        if (lua_is_index(target)) {
+            lua_visit(ctx, cbm_source_field(target, "table"), depth + 1);
+            if (cbm_source_is(target, "bracket_index_expression"))
+                lua_visit(ctx, cbm_source_field(target, "field"), depth + 1);
+        }
+        if (!ctx->collecting) {
+            TSNode name = cbm_source_is(target, "dot_index_expression")
+                              ? cbm_source_field(target, "field")
+                              : target;
+            if (cbm_source_is(name, "identifier"))
+                cbm_source_emit_node(walk, name, CBM_SOURCE_SITE_REFERENCE, NULL,
+                                     CBM_RESOLVE_RULE_NONE, NULL, "lua_assignment_target_written");
+        }
+    }
+    for (uint32_t i = 0; i < values.count; i++) {
+        TSNode value = values.items[i];
+        const char *spelled = i < targets.count && cbm_source_is(value, "function_definition")
+                                  ? cbm_source_text(walk, targets.items[i])
+                                  : NULL;
+        lua_doc_t *statement_doc = ctx->doc;
+        if (spelled) {
+            lua_visit_function(ctx, value, spelled, NULL, 0, depth + 1);
+        } else {
+            ctx->doc = NULL;
+            lua_visit(ctx, value, depth + 1);
+        }
+        ctx->doc = statement_doc;
+    }
+}
+
+/* `local old = M.f` above `function M.f() old() end`: the chunk runs in order, so this reads what
+ * M.f held before, which is not the declaration further down. Only a table this chunk built can
+ * say so; another module's table is complete by the time it is required. */
+static const char *lua_chunk_read(lua_ctx_t *ctx, const char *encoded) {
+    if (!encoded || ctx->function_depth)
+        return encoded;
+    const char *step = strrchr(encoded, LUA_STEP[0]);
+    if (!step || step[1] != '.')
+        return encoded;
+    const char *table = cbm_arena_strndup(ctx->walk->arena, encoded, (size_t)(step - encoded));
+    const char *owner = table ? lua_owner_key(ctx, table, 0) : NULL;
+    if (!owner || owner[0] != 'T' || cbm_source_lookup(ctx->walk, owner, step + 2))
+        return encoded;
+    return NULL;
+}
+
+/* `local ok, m = pcall(require, 'm')`: on success, the second value is the module. */
+static const char *lua_protected_require(lua_ctx_t *ctx, TSNode value) {
+    if (!cbm_source_is(value, "function_call") ||
+        !lua_global_callee(ctx, cbm_source_field(value, "name"), "pcall"))
+        return NULL;
+    lua_nodes_t args = lua_children(ctx, cbm_source_field(value, "arguments"), NULL);
+    return args.count == 2 && lua_global_callee(ctx, args.items[0], "require")
+               ? lua_encode_require(ctx, args.items[1])
+               : NULL;
+}
+
+static void lua_visit_local(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    cbm_source_walk_t *walk = ctx->walk;
+    ctx->module_table = NULL;
+    lua_nodes_t parts = lua_children(ctx, node, NULL);
+    TSNode names = (TSNode){0}, list = (TSNode){0};
+    for (uint32_t i = 0; i < parts.count; i++) {
+        if (cbm_source_is(parts.items[i], "variable_list"))
+            names = parts.items[i];
+        else if (cbm_source_is(parts.items[i], "assignment_statement")) {
+            lua_nodes_t inner = lua_children(ctx, parts.items[i], NULL);
+            for (uint32_t j = 0; j < inner.count; j++) {
+                if (cbm_source_is(inner.items[j], "variable_list"))
+                    names = inner.items[j];
+                else if (cbm_source_is(inner.items[j], "expression_list"))
+                    list = inner.items[j];
+            }
+        }
+    }
+    lua_nodes_t binders =
+        ts_node_is_null(names) ? (lua_nodes_t){0} : lua_children(ctx, names, "name");
+    lua_nodes_t values = ts_node_is_null(list) ? (lua_nodes_t){0} : lua_children(ctx, list, NULL);
+    /* The values are read before the names exist: `local x = x` reads the outer x. */
+    const char **encoded = binders.count && ctx->collecting
+                               ? cbm_arena_calloc(walk->arena, binders.count * sizeof(*encoded))
+                               : NULL;
+    if (encoded) {
+        for (uint32_t i = 0; i < binders.count; i++) {
+            if (i < values.count)
+                encoded[i] = lua_chunk_read(ctx, lua_encode(ctx, values.items[i], 0));
+            else if (i == 1 && values.count == 1)
+                encoded[i] = lua_protected_require(ctx, values.items[0]);
+            if (!encoded[i] && i >= values.count)
+                encoded[i] = lua_chunk_read(ctx, lua_encode_later_value(ctx, &values, i));
+        }
+    }
+    for (uint32_t i = 0; i < values.count; i++) {
+        TSNode value = values.items[i];
+        const char *spelled = i < binders.count && cbm_source_is(value, "function_definition")
+                                  ? cbm_source_text(walk, binders.items[i])
+                                  : NULL;
+        lua_doc_t *statement_doc = ctx->doc;
+        if (spelled) {
+            lua_visit_function(ctx, value, spelled, NULL, 0, depth + 1);
+        } else {
+            ctx->doc = NULL;
+            lua_visit(ctx, value, depth + 1);
+        }
+        ctx->doc = statement_doc;
+    }
+    for (uint32_t i = 0; i < binders.count; i++) {
+        TSNode name = binders.items[i];
+        /* Only a chunk-level statement has a Variable node; a function has a node anywhere. */
+        TSNode initial = i < values.count ? values.items[i] : (TSNode){0};
+        uint32_t line = !ctx->function_depth ? ts_node_start_point(node).row + 1
+                        : cbm_source_is(initial, "function_definition")
+                            ? ts_node_start_point(initial).row + 1
+                            : 0;
+        lua_binder_t *binder =
+            lua_push(ctx, cbm_source_text(walk, name), ts_node_start_byte(name), line);
+        if (!ctx->collecting)
+            cbm_source_emit_node(walk, name, CBM_SOURCE_SITE_REFERENCE, NULL, CBM_RESOLVE_RULE_NONE,
+                                 NULL, "lua_name_being_declared");
+        if (!binder || !ctx->collecting)
+            continue;
+        TSNode value = i < values.count ? values.items[i] : (TSNode){0};
+        binder->assigned =
+            (!ts_node_is_null(value) && !cbm_source_is(value, "nil")) || (i > 0 && values.count);
+        if (encoded && encoded[i]) {
+            binder->assigned = true;
+            lua_declare_root(ctx, binder->identity, NULL, encoded[i]);
+        }
+        if (!i && ctx->doc && ctx->doc->type_name)
+            lua_annotate_root(ctx, binder->identity, ctx->doc->type_name);
+        if (!i) {
+            ctx->last_local = binder;
+            /* The class is this statement's table, whatever the local holds later. */
+            lua_note_class(ctx, value, encoded && encoded[i] ? encoded[i] : binder->identity,
+                           binder->identity);
+            if (ctx->module_table)
+                lua_member_fact(ctx, binder->identity, LUA_SHAPE, NULL, ctx->module_table);
+        }
+    }
+}
+
+/* Lua 5.5 `global x = v`: the name is the global here, whatever a local says. */
+static void lua_visit_global(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    cbm_source_walk_t *walk = ctx->walk;
+    lua_nodes_t parts = lua_children(ctx, node, NULL);
+    for (uint32_t i = 0; i < parts.count; i++) {
+        if (cbm_source_is(parts.items[i], "assignment_statement")) {
+            lua_nodes_t inner = lua_children(ctx, parts.items[i], NULL);
+            for (uint32_t j = 0; j < inner.count; j++) {
+                if (cbm_source_is(inner.items[j], "variable_list")) {
+                    lua_nodes_t names = lua_children(ctx, inner.items[j], "name");
+                    for (uint32_t k = 0; k < names.count; k++) {
+                        lua_binder_t *binder = lua_push(ctx, cbm_source_text(walk, names.items[k]),
+                                                        ts_node_start_byte(names.items[k]), 0);
+                        if (binder)
+                            binder->global = true;
+                    }
+                }
+            }
+            lua_visit_assignment(ctx, parts.items[i], depth + 1);
+        } else if (cbm_source_is(parts.items[i], "variable_list")) {
+            lua_nodes_t names = lua_children(ctx, parts.items[i], "name");
+            for (uint32_t k = 0; k < names.count; k++) {
+                lua_binder_t *binder = lua_push(ctx, cbm_source_text(walk, names.items[k]),
+                                                ts_node_start_byte(names.items[k]), 0);
+                if (binder)
+                    binder->global = true;
+            }
+        }
+    }
+}
+
+static void lua_visit_function_declaration(lua_ctx_t *ctx, TSNode node, bool local,
+                                           unsigned depth) {
+    cbm_source_walk_t *walk = ctx->walk;
+    TSNode name = cbm_source_field(node, "name");
+    const char *spelled = cbm_source_text(walk, name);
+    uint32_t line = ts_node_start_point(node).row + 1;
+    const char *encoded = lua_identity(ctx, 'F', ts_node_start_byte(node));
+    const char *qn = spelled && ctx->collecting ? cbm_source_def_qn_at(walk, spelled, line) : NULL;
+    if (local) {
+        /* Visible inside its own body. */
+        lua_binder_t *binder = lua_push(ctx, spelled, ts_node_start_byte(name), line);
+        if (binder)
+            binder->assigned = true;
+        if (binder && ctx->collecting)
+            lua_declare_root(ctx, binder->identity, NULL, encoded);
+        lua_visit_function(ctx, node, spelled, NULL, 0, depth);
+        return;
+    }
+    const char *receiver = NULL;
+    uint32_t self_at = 0;
+    if (lua_is_index(name)) {
+        lua_visit(ctx, cbm_source_field(name, "table"), depth + 1);
+        if (cbm_source_is(name, "method_index_expression")) {
+            receiver = lua_encode(ctx, cbm_source_field(name, "table"), 0);
+            self_at = ts_node_start_byte(cbm_source_field(name, "method"));
+        }
+    }
+    if (ctx->collecting) {
+        if (cbm_source_is(name, "identifier")) {
+            lua_binder_t *binder = lua_binder_of(ctx, spelled);
+            if (binder)
+                lua_write_local(ctx, binder, encoded);
+            else if (spelled && !lua_environment_replaced(ctx))
+                lua_write_member(ctx, LUA_GLOBALS, spelled, qn, encoded);
+        } else if (lua_is_index(name)) {
+            const char *member = lua_index_member(ctx, name);
+            const char *table = member ? lua_encode(ctx, cbm_source_field(name, "table"), 0) : NULL;
+            if (table)
+                lua_write_member(ctx, lua_owner_key(ctx, table, 0), member, qn, encoded);
+        }
+    }
+    lua_visit_function(ctx, node, spelled, receiver, self_at, depth);
+}
+
+/* Finds `require('prefix' .. key)` in a function, where key is its second parameter. */
+static const char *lua_required_prefix(lua_ctx_t *ctx, TSNode node, const char *key,
+                                       unsigned depth) {
+    if (ts_node_is_null(node) || !cbm_source_step(ctx->walk, depth))
+        return NULL;
+    if (cbm_source_is(node, "function_call") &&
+        lua_global_callee(ctx, cbm_source_field(node, "name"), "require")) {
+        lua_nodes_t args = lua_children(ctx, cbm_source_field(node, "arguments"), NULL);
+        if (args.count == 1 && cbm_source_is(args.items[0], "binary_expression")) {
+            const char *prefix = lua_literal(ctx, cbm_source_field(args.items[0], "left"));
+            const char *right =
+                cbm_source_text(ctx->walk, cbm_source_field(args.items[0], "right"));
+            if (prefix && right && !strcmp(right, key))
+                return prefix;
+        }
+    }
+    const char *found = NULL;
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (ts_node_is_named(child))
+                found = lua_required_prefix(ctx, child, key, depth + 1);
+        } while (!found && ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+    return found;
+}
+
+/* A metatable literal whose `__index` loads a module named after the key. */
+static void lua_note_lazy_index(lua_ctx_t *ctx, const char *owner, TSNode metatable) {
+    if (!cbm_source_is(metatable, "table_constructor"))
+        return;
+    lua_nodes_t fields = lua_children(ctx, metatable, NULL);
+    for (uint32_t i = 0; i < fields.count; i++) {
+        TSNode value = cbm_source_field(fields.items[i], "value");
+        const char *name = cbm_source_text(ctx->walk, cbm_source_field(fields.items[i], "name"));
+        if (!name || strcmp(name, "__index") || !cbm_source_is(value, "function_definition"))
+            continue;
+        lua_nodes_t parameters = lua_children(ctx, cbm_source_field(value, "parameters"), "name");
+        const char *key =
+            parameters.count == 2 ? cbm_source_text(ctx->walk, parameters.items[1]) : NULL;
+        const char *prefix =
+            key ? lua_required_prefix(ctx, cbm_source_field(value, "body"), key, 0) : NULL;
+        if (prefix)
+            lua_write_member(ctx, owner, LUA_LAZY, NULL, prefix);
+    }
+}
+
+/* What a call does to the facts, whatever its value is used for. */
+static void lua_call_effects(lua_ctx_t *ctx, TSNode callee, TSNode arguments) {
+    cbm_source_walk_t *walk = ctx->walk;
+    if (cbm_source_is(callee, "dot_index_expression")) {
+        const char *member = lua_index_member(ctx, callee);
+        if (member &&
+            (!strcmp(member, "setlocal") || !strcmp(member, "setupvalue") ||
+             !strcmp(member, "upvaluejoin")) &&
+            lua_global_callee(ctx, cbm_source_field(callee, "table"), "debug")) {
+            const char *flags = cbm_arena_sprintf(walk->arena, LUA_FLAGS "%s", walk->file);
+            if (flags && !cbm_source_lookup(walk, flags, "debug"))
+                (void)lua_declare(ctx, flags, "debug", NULL, NULL);
+        }
+        return;
+    }
+    if (lua_global_callee(ctx, callee, "setfenv")) {
+        const char *flags = cbm_arena_sprintf(walk->arena, LUA_FLAGS "%s", walk->file);
+        if (flags && !cbm_source_lookup(walk, flags, "setfenv"))
+            (void)lua_declare(ctx, flags, "setfenv", NULL, NULL);
+        return;
+    }
+    bool metatable = lua_global_callee(ctx, callee, "setmetatable");
+    bool rawset = !metatable && lua_global_callee(ctx, callee, "rawset");
+    if (!metatable && !rawset)
+        return;
+    lua_nodes_t args = lua_children(ctx, arguments, NULL);
+    if (args.count < (rawset ? 3u : 2u))
+        return;
+    const char *table = lua_encode(ctx, args.items[0], 0);
+    const char *owner = table ? lua_owner_key(ctx, table, 0) : NULL;
+    if (!owner)
+        return;
+    if (metatable) {
+        /* `setmetatable(o, self)` follows the receiver of each call, which one declaration
+         * does not know: the method is called on subclasses too. */
+        const char *spelled = cbm_source_is(args.items[1], "identifier")
+                                  ? cbm_source_text(walk, args.items[1])
+                                  : NULL;
+        if (!spelled || strcmp(spelled, "self"))
+            lua_write_member(ctx, owner, LUA_META, NULL, lua_encode(ctx, args.items[1], 0));
+        lua_note_lazy_index(ctx, owner, args.items[1]);
+        return;
+    }
+    const char *member = lua_literal(ctx, args.items[1]);
+    if (member)
+        lua_write_member(ctx, owner, member, NULL, lua_encode(ctx, args.items[2], 0));
+}
+
+static void lua_visit_call(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    TSNode callee = cbm_source_field(node, "name");
+    TSNode arguments = cbm_source_field(node, "arguments");
+    /* An annotation over a call statement is not about a callback passed to it. */
+    ctx->doc = NULL;
+    if (ctx->collecting)
+        lua_call_effects(ctx, callee, arguments);
+    else
+        lua_emit_call(ctx, node, callee);
+    if (cbm_source_is(callee, "identifier")) {
+        if (!ctx->collecting)
+            lua_emit_identifier(ctx, callee, true);
+    } else if (cbm_source_is(callee, "dot_index_expression") ||
+               cbm_source_is(callee, "method_index_expression")) {
+        lua_visit(ctx, cbm_source_field(callee, "table"), depth + 1);
+        if (!ctx->collecting) {
+            TSNode member = cbm_source_field(
+                callee, cbm_source_is(callee, "method_index_expression") ? "method" : "field");
+            cbm_source_emit_node(ctx->walk, member, CBM_SOURCE_SITE_REFERENCE, NULL,
+                                 CBM_RESOLVE_RULE_NONE, NULL, "lua_callee_name_is_the_call");
+        }
+    } else {
+        lua_visit(ctx, callee, depth + 1);
+    }
+    if (!ts_node_is_null(arguments))
+        lua_visit_children(ctx, arguments, depth);
+}
+
+/* `buf = ..., --- @module 'vim.lsp.buf'`: the field holds that module. */
+static const char *lua_doc_module(lua_ctx_t *ctx, TSNode comment) {
+    const char *text = cbm_source_text(ctx->walk, comment);
+    const char *tag = text ? strstr(text, "@module") : NULL;
+    const char *open = tag ? strpbrk(tag, "'\"") : NULL;
+    const char *close = open ? strchr(open + 1, open[0]) : NULL;
+    if (!close)
+        return NULL;
+    const char *module = cbm_arena_strndup(ctx->walk->arena, open + 1, (size_t)(close - open - 1));
+    return module ? cbm_arena_sprintf(ctx->walk->arena, LUA_MODULES "%s" LUA_PART "%s",
+                                      ctx->directory, module)
+                  : NULL;
+}
+
+static void lua_visit_table(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    cbm_source_walk_t *walk = ctx->walk;
+    const char *owner = ctx->collecting ? lua_identity(ctx, 'T', ts_node_start_byte(node)) : NULL;
+    const char *pending = NULL;
+    uint32_t pending_row = 0;
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode field = ts_tree_cursor_current_node(&cursor);
+            if (cbm_source_is(field, "comment")) {
+                const char *module = pending && ts_node_start_point(field).row == pending_row
+                                         ? lua_doc_module(ctx, field)
+                                         : NULL;
+                if (module) {
+                    lua_member_fact(ctx, owner, pending, NULL, module);
+                    ctx->module_table = owner;
+                }
+                pending = NULL;
+                continue;
+            }
+            if (!cbm_source_is(field, "field"))
+                continue;
+            pending = NULL;
+            TSNode name = cbm_source_field(field, "name");
+            TSNode value = cbm_source_field(field, "value");
+            bool computed =
+                !ts_node_is_null(name) && walk->source[ts_node_start_byte(field)] == '[';
+            const char *member = NULL;
+            if (!ts_node_is_null(name))
+                member = computed ? lua_literal(ctx, name) : cbm_source_text(walk, name);
+            if (ctx->collecting && member && owner && !ts_node_is_null(value)) {
+                /* `name = ...` says nothing itself: the comment after it may. */
+                if (cbm_source_is(value, "vararg_expression")) {
+                    pending = member;
+                    pending_row = ts_node_end_point(field).row;
+                } else if (!cbm_source_is(value, "number") && !cbm_source_is(value, "string") &&
+                           !cbm_source_is(value, "true") && !cbm_source_is(value, "false")) {
+                    /* A literal selects no declaration, and a data table has many. */
+                    lua_member_fact(ctx, owner, member, NULL, lua_encode(ctx, value, 0));
+                }
+            }
+            if (computed)
+                lua_visit(ctx, name, depth + 1);
+            if (!ts_node_is_null(value))
+                lua_visit(ctx, value, depth + 1);
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+}
+
+/* What a `return` gives past its first value. Only a last call or `...` can give more than it
+ * spells, and a missing or nil one is the failure path, as it is for the first. */
+static void lua_flow_later_values(lua_ctx_t *ctx, const lua_nodes_t *values) {
+    lua_flow_t *flow = ctx->flow;
+    for (uint32_t i = 1; i < values->count && i <= LUA_RETURN_VALUES; i++) {
+        unsigned slot = i - 1;
+        if (cbm_source_is(values->items[i], "nil"))
+            continue;
+        const char *encoded = lua_encode(ctx, values->items[i], 0);
+        if (!encoded || (flow->later[slot] && strcmp(flow->later[slot], encoded)))
+            flow->later_open[slot] = true;
+        else
+            flow->later[slot] = encoded;
+    }
+    TSNode last = values->items[values->count - 1];
+    if (cbm_source_is(last, "function_call") || cbm_source_is(last, "vararg_expression"))
+        for (uint32_t i = values->count; i <= LUA_RETURN_VALUES; i++)
+            flow->later_open[i - 1] = true;
+}
+
+static void lua_visit_return(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    lua_nodes_t parts = lua_children(ctx, node, NULL);
+    for (uint32_t i = 0; i < parts.count; i++) {
+        if (!cbm_source_is(parts.items[i], "expression_list"))
+            continue;
+        lua_nodes_t values = lua_children(ctx, parts.items[i], NULL);
+        if (ctx->collecting && ctx->flow && values.count) {
+            /* `return nil, err` is the failure path: a member of nil raises. */
+            if (!cbm_source_is(values.items[0], "nil")) {
+                const char *encoded = lua_encode(ctx, values.items[0], 0);
+                if (!encoded || (ctx->flow->value && strcmp(ctx->flow->value, encoded)))
+                    ctx->flow->open = true;
+                else
+                    ctx->flow->value = encoded;
+            }
+            lua_flow_later_values(ctx, &values);
+        }
+        lua_visit_children(ctx, parts.items[i], depth);
+    }
+}
+
+static void lua_visit_for(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    lua_binder_t *mark = ctx->top;
+    TSNode clause = cbm_source_field(node, "clause");
+    /* The clause's expressions are read outside the scope of the names it binds. */
+    lua_nodes_t parts =
+        ts_node_is_null(clause) ? (lua_nodes_t){0} : lua_children(ctx, clause, NULL);
+    for (uint32_t i = 0; i < parts.count; i++) {
+        TSNode part = parts.items[i];
+        if (cbm_source_is(part, "variable_list"))
+            continue;
+        if (cbm_source_is(part, "identifier") && cbm_source_is(clause, "for_numeric_clause") &&
+            ts_node_eq(part, cbm_source_field(clause, "name")))
+            continue;
+        lua_visit(ctx, part, depth + 1);
+    }
+    for (uint32_t i = 0; i < parts.count; i++) {
+        TSNode part = parts.items[i];
+        if (cbm_source_is(part, "variable_list")) {
+            lua_nodes_t names = lua_children(ctx, part, "name");
+            for (uint32_t j = 0; j < names.count; j++)
+                (void)lua_push(ctx, cbm_source_text(ctx->walk, names.items[j]),
+                               ts_node_start_byte(names.items[j]), 0);
+        } else if (cbm_source_is(part, "identifier") &&
+                   cbm_source_is(clause, "for_numeric_clause") &&
+                   ts_node_eq(part, cbm_source_field(clause, "name"))) {
+            (void)lua_push(ctx, cbm_source_text(ctx->walk, part), ts_node_start_byte(part), 0);
+        }
+    }
+    TSNode body = cbm_source_field(node, "body");
+    if (!ts_node_is_null(body))
+        lua_visit(ctx, body, depth + 1);
+    lua_pop_to(ctx, mark);
+}
+
+/* The `until` condition sees the locals of the body. */
+static void lua_visit_repeat(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    lua_binder_t *mark = ctx->top;
+    TSNode body = cbm_source_field(node, "body");
+    TSNode condition = cbm_source_field(node, "condition");
+    if (!ts_node_is_null(body))
+        lua_visit_children(ctx, body, depth + 1);
+    if (!ts_node_is_null(condition))
+        lua_visit(ctx, condition, depth + 1);
+    lua_pop_to(ctx, mark);
+}
+
+/* One whitespace-free word of an annotation, advancing past it. */
+static const char *lua_doc_word(lua_ctx_t *ctx, const char **cursor) {
+    const char *at = *cursor;
+    while (*at == ' ' || *at == '\t')
+        at++;
+    const char *end = at;
+    while (*end && *end != ' ' && *end != '\t' && *end != '\r' && *end != '\n')
+        end++;
+    *cursor = end;
+    return end > at ? cbm_arena_strndup(ctx->walk->arena, at, (size_t)(end - at)) : NULL;
+}
+
+/* A type that names one class: `vim.lsp.Client`, `vim.lsp.Client?`. */
+static const char *lua_doc_type(lua_ctx_t *ctx, const char *word) {
+    if (!word)
+        return NULL;
+    size_t length = strlen(word);
+    if (length && word[length - 1] == '?')
+        length--;
+    if (!length ||
+        strspn(word, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.") != length)
+        return NULL;
+    return cbm_arena_strndup(ctx->walk->arena, word, length);
+}
+
+/* `a.b`, `a.b<T, U>`: the class named. Type arguments do not change which members it has. */
+static const char *lua_doc_class_word(lua_ctx_t *ctx, const char **cursor) {
+    const char *at = *cursor + strspn(*cursor, " \t");
+    size_t length = strspn(at, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.");
+    const char *end = at + length;
+    if (*end == '<') {
+        unsigned open = 0;
+        do {
+            if (*end == '<')
+                open++;
+            else if (*end == '>')
+                open--;
+            end++;
+        } while (*end && open);
+        if (open) {
+            *cursor = end;
+            return NULL;
+        }
+    }
+    *cursor = end;
+    return length ? cbm_arena_strndup(ctx->walk->arena, at, length) : NULL;
+}
+
+/* One entry per parent. An entry with no type is a parent this cannot read. */
+static void lua_doc_parents(lua_ctx_t *ctx, const char *class_name, const char *at) {
+    for (;;) {
+        const char *parent = lua_doc_class_word(ctx, &at);
+        char next = *at;
+        bool ends = !next || next == ' ' || next == '\t' || next == '\r' || next == ',';
+        (void)lua_declare(ctx, LUA_PARENTS, class_name, NULL, parent && ends ? parent : NULL);
+        if (!parent || !ends)
+            return;
+        at += strspn(at, " \t");
+        if (*at != ',')
+            return;
+        at++;
+    }
+}
+
+static void lua_doc_read(lua_ctx_t *ctx, lua_doc_t *doc, TSNode comment) {
+    const char *text = cbm_source_text(ctx->walk, comment);
+    if (!text || strncmp(text, "---", 3))
+        return;
+    const char *at = text + 3;
+    while (*at == '-' || *at == ' ' || *at == '\t')
+        at++;
+    uint32_t row = ts_node_end_point(comment).row;
+    if (doc->present && doc->last_row + 1 != row)
+        *doc = (lua_doc_t){0};
+    doc->present = true;
+    doc->last_row = row;
+    if (*at != '@')
+        return;
+    const char *tag = lua_doc_word(ctx, &at);
+    if (!tag)
+        return;
+    if (!strcmp(tag, "@class")) {
+        at += strspn(at, " \t");
+        if (*at == '(') {
+            at = strchr(at, ')');
+            if (!at)
+                return;
+            at++;
+        }
+        doc->class_name = lua_doc_class_word(ctx, &at);
+        at += strspn(at, " \t");
+        if (doc->class_name && *at == ':')
+            lua_doc_parents(ctx, doc->class_name, at + 1);
+    } else if (!strcmp(tag, "@type")) {
+        doc->type_name = lua_doc_type(ctx, lua_doc_word(ctx, &at));
+    } else if (!strcmp(tag, "@return")) {
+        if (!doc->return_type)
+            doc->return_type = lua_doc_type(ctx, lua_doc_word(ctx, &at));
+    } else if (!strcmp(tag, "@param") && doc->param_count < LUA_DOC_PARAMS) {
+        const char *name = lua_doc_word(ctx, &at);
+        const char *type = lua_doc_type(ctx, lua_doc_word(ctx, &at));
+        size_t length = name ? strlen(name) : 0;
+        if (length && name[length - 1] == '?')
+            name = cbm_arena_strndup(ctx->walk->arena, name, length - 1);
+        if (name && type) {
+            doc->param_names[doc->param_count] = name;
+            doc->param_types[doc->param_count++] = type;
+        }
+    }
+}
+
+/* `local x = y --- @type T`: a type for the local this line just declared. */
+static void lua_doc_trailing(lua_ctx_t *ctx, TSNode comment, uint32_t statement_row) {
+    if (!ctx->last_local || ts_node_start_point(comment).row != statement_row)
+        return;
+    lua_doc_t trailing = {0};
+    lua_doc_read(ctx, &trailing, comment);
+    if (!trailing.type_name)
+        return;
+    lua_annotate_root(ctx, ctx->last_local->identity, trailing.type_name);
+}
+
+static void lua_visit_statements(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    /* `local` and `global` are field names on the statement, not kinds. */
+    lua_doc_t doc = {0};
+    lua_doc_t *outer = ctx->doc;
+    uint32_t last_row = UINT32_MAX;
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (!ts_node_is_named(child))
+                continue;
+            if (cbm_source_is(child, "comment")) {
+                if (ctx->collecting) {
+                    lua_doc_trailing(ctx, child, last_row);
+                    if (ts_node_start_point(child).row != last_row)
+                        lua_doc_read(ctx, &doc, child);
+                }
+                continue;
+            }
+            if (lua_ignored(child))
+                continue;
+            /* An annotation is about the line right below it. */
+            bool adjacent = doc.present && doc.last_row + 1 == ts_node_start_point(child).row;
+            ctx->doc = ctx->collecting && adjacent ? &doc : NULL;
+            ctx->last_local = NULL;
+            const char *field = ts_tree_cursor_current_field_name(&cursor);
+            bool local = field && !strcmp(field, "local_declaration");
+            bool global = field && !strcmp(field, "global_declaration");
+            if (cbm_source_is(child, "function_declaration")) {
+                if (cbm_source_step(ctx->walk, depth + 1))
+                    lua_visit_function_declaration(ctx, child, local, depth + 1);
+            } else if (cbm_source_is(child, "variable_declaration")) {
+                if (cbm_source_step(ctx->walk, depth + 1)) {
+                    if (global)
+                        lua_visit_global(ctx, child, depth + 1);
+                    else
+                        lua_visit_local(ctx, child, depth + 1);
+                }
+            } else {
+                lua_visit(ctx, child, depth + 1);
+            }
+            doc = (lua_doc_t){0};
+            last_row = ts_node_end_point(child).row;
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+    ctx->doc = outer;
+}
+
+static void lua_visit(lua_ctx_t *ctx, TSNode node, unsigned depth) {
+    if (!cbm_source_step(ctx->walk, depth))
+        return;
+    if (cbm_source_is(node, "identifier")) {
+        if (!ctx->collecting)
+            lua_emit_identifier(ctx, node, false);
+        return;
+    }
+    if (cbm_source_is(node, "dot_index_expression")) {
+        lua_visit(ctx, cbm_source_field(node, "table"), depth + 1);
+        if (!ctx->collecting)
+            lua_emit_value(ctx, cbm_source_field(node, "field"), lua_encode(ctx, node, 0));
+        return;
+    }
+    if (cbm_source_is(node, "method_index_expression")) {
+        lua_visit(ctx, cbm_source_field(node, "table"), depth + 1);
+        return;
+    }
+    if (cbm_source_is(node, "bracket_index_expression")) {
+        lua_visit(ctx, cbm_source_field(node, "table"), depth + 1);
+        lua_visit(ctx, cbm_source_field(node, "field"), depth + 1);
+        return;
+    }
+    if (cbm_source_is(node, "function_call")) {
+        lua_visit_call(ctx, node, depth);
+        return;
+    }
+    if (cbm_source_is(node, "block")) {
+        lua_binder_t *mark = ctx->top;
+        lua_visit_statements(ctx, node, depth);
+        lua_pop_to(ctx, mark);
+        return;
+    }
+    if (cbm_source_is(node, "function_definition")) {
+        lua_visit_function(ctx, node, NULL, NULL, 0, depth);
+        return;
+    }
+    if (cbm_source_is(node, "table_constructor")) {
+        lua_visit_table(ctx, node, depth);
+        return;
+    }
+    if (cbm_source_is(node, "assignment_statement")) {
+        lua_visit_assignment(ctx, node, depth);
+        return;
+    }
+    if (cbm_source_is(node, "return_statement")) {
+        lua_visit_return(ctx, node, depth);
+        return;
+    }
+    if (cbm_source_is(node, "for_statement")) {
+        lua_visit_for(ctx, node, depth);
+        return;
+    }
+    if (cbm_source_is(node, "repeat_statement")) {
+        lua_visit_repeat(ctx, node, depth);
+        return;
+    }
+    if (cbm_source_is(node, "goto_statement") || cbm_source_is(node, "label_statement") ||
+        cbm_source_is(node, "attribute") || cbm_source_is(node, "string") ||
+        cbm_source_is(node, "number"))
+        return;
+    lua_visit_scoped(ctx, node, depth);
+}
+
+/* ── Module names ──────────────────────────────────────────────────── */
+
+/* Where a Lua project keeps what package.path points at: Neovim's and LuaRocks' `lua/`, and
+ * LuaRocks' `src/` and `lib/` layouts. */
+static bool lua_source_root_segment(const char *at, size_t size) {
+    return (size == 3 &&
+            (!strncmp(at, "lua", 3) || !strncmp(at, "src", 3) || !strncmp(at, "lib", 3)));
+}
+
+const char *cbm_lua_root_module(const char *rel_path, const char *from, size_t *length) {
+    size_t size = strlen(rel_path);
+    if (size < strlen(".lua") || strcmp(rel_path + size - strlen(".lua"), ".lua"))
+        return NULL;
+    const char *end = rel_path + size - strlen(".lua");
+    if (size >= strlen("init.lua") && !strcmp(rel_path + size - strlen("init.lua"), "init.lua") &&
+        (size == strlen("init.lua") || rel_path[size - strlen("init.lua") - 1] == '/'))
+        end = size == strlen("init.lua") ? rel_path : rel_path + size - strlen("/init.lua");
+    /* from is a name already returned: the next root starts after it. */
+    const char *at = from ? from : rel_path;
+    while (at < end) {
+        const char *slash = strchr(at, '/');
+        if (!slash || slash >= end)
+            return NULL;
+        if (lua_source_root_segment(at, (size_t)(slash - at))) {
+            *length = (size_t)(end - (slash + 1));
+            return slash + 1;
+        }
+        at = slash + 1;
+    }
+    return NULL;
+}
+
+/* A file a project's source root names. Those under the repository root or an ancestor of the
+ * requiring file need no entry: they are probed by path. */
+static void lua_register_module_names(lua_ctx_t *ctx) {
+    cbm_source_walk_t *walk = ctx->walk;
+    size_t length = 0;
+    for (const char *name = cbm_lua_root_module(walk->file, NULL, &length); name;
+         name = cbm_lua_root_module(walk->file, name, &length)) {
+        const char *module = cbm_arena_strndup(walk->arena, name, length);
+        if (module)
+            (void)cbm_source_declare(walk, LUA_MODULES, module, NULL, 0, 0);
+    }
+}
+
+static const char *lua_directory_of(cbm_source_walk_t *walk) {
+    const char *slash = strrchr(walk->file, '/');
+    return slash ? cbm_arena_strndup(walk->arena, walk->file, (size_t)(slash - walk->file)) : "";
+}
+
+static bool lua_ctx_init(lua_ctx_t *ctx, cbm_source_walk_t *walk, bool collecting) {
+    *ctx = (lua_ctx_t){.walk = walk, .collecting = collecting};
+    ctx->visible = cbm_ht_create(64);
+    ctx->memo = collecting ? NULL : cbm_ht_create(64);
+    ctx->directory = lua_directory_of(walk);
+    if (!ctx->visible || (!collecting && !ctx->memo) || !ctx->directory) {
+        cbm_source_fail(walk, "lua_scope_allocation");
+        return false;
+    }
+    return true;
+}
+
+static void lua_ctx_free(lua_ctx_t *ctx) {
+    cbm_ht_free(ctx->visible);
+    cbm_ht_free(ctx->memo);
+}
+
+static void lua_collect(cbm_source_walk_t *walk) {
+    /* Facts of the files before this one, and this file's so far, for a repeated write. */
+    walk->table = walk->writable;
+    lua_ctx_t ctx;
+    if (!lua_ctx_init(&ctx, walk, true))
+        return;
+    lua_flow_t flow = {0};
+    ctx.flow = &flow;
+    lua_register_module_names(&ctx);
+    lua_visit_statements(&ctx, walk->root, 0);
+    const char *key = cbm_arena_sprintf(walk->arena, LUA_RETURNS "%s", walk->file);
+    if (key)
+        (void)lua_declare(&ctx, key, "", NULL, flow.open ? NULL : flow.value);
+    lua_ctx_free(&ctx);
+}
+
+static void lua_resolve(cbm_source_walk_t *walk) {
+    lua_ctx_t ctx;
+    if (!lua_ctx_init(&ctx, walk, false))
+        return;
+    const char *flags = cbm_arena_sprintf(walk->arena, LUA_FLAGS "%s", walk->file);
+    ctx.environment_open = flags && cbm_source_lookup(walk, flags, "setfenv");
+    lua_visit_statements(&ctx, walk->root, 0);
+    lua_ctx_free(&ctx);
+}
+
+const cbm_source_adapter_t cbm_source_adapter_lua = {.language = CBM_LANG_LUA,
+                                                     .collect = lua_collect,
+                                                     .resolve = lua_resolve,
+                                                     .decides_references = true,
+                                                     .one_name_one_node = true};
diff --git a/internal/cbm/resolve/adapter_make.c b/internal/cbm/resolve/adapter_make.c
new file mode 100644
index 000000000..907ba6a98
--- /dev/null
+++ b/internal/cbm/resolve/adapter_make.c
@@ -0,0 +1,91 @@
+/* Make variable rules, from the GNU make manual's "How to Use Variables".
+ *
+ * A make process has one variable namespace. `X = v`, `X := v`, `X ?= v` and `X += v` all write
+ * the same variable, which is why the graph has one node for them, and `$(X)` or `${X}` reads it
+ * wherever the assignment sits, since a recursive variable expands when it is used. A name the
+ * file does not assign comes from an included file, the environment or the command line, which
+ * this does not decide. A computed name (`$($(X)_FLAGS)`) is unknown. */
+#include "source_adapter_internal.h"
+
+#define MAKE_VARIABLES "V:"
+
+typedef struct {
+    cbm_source_walk_t *walk;
+    const char *owner;
+} make_ctx_t;
+
+static void make_collect_walk(make_ctx_t *ctx, TSNode node, unsigned depth) {
+    if (!cbm_source_step(ctx->walk, depth))
+        return;
+    if (cbm_source_is(node, "variable_assignment")) {
+        TSNode name = cbm_source_field(node, "name");
+        const char *text = cbm_source_is(name, "word") ? cbm_source_text(ctx->walk, name) : NULL;
+        if (text && !cbm_source_lookup(ctx->walk, ctx->owner, text))
+            (void)cbm_source_declare(
+                ctx->walk, ctx->owner, text,
+                cbm_source_def_qn(ctx->walk, text, ts_node_start_point(node).row + 1), 0, 0);
+    }
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (ts_node_is_named(child))
+                make_collect_walk(ctx, child, depth + 1);
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+}
+
+static void make_visit_reference(make_ctx_t *ctx, TSNode node) {
+    cbm_source_walk_t *walk = ctx->walk;
+    const char *name = NULL;
+    if (ts_node_named_child_count(node) == 1 && cbm_source_is(ts_node_named_child(node, 0), "word"))
+        name = cbm_source_text(walk, ts_node_named_child(node, 0));
+    const cbm_source_decl_t *decl = name ? cbm_source_lookup(walk, ctx->owner, name) : NULL;
+    cbm_source_emit_node(walk, node, CBM_SOURCE_SITE_REFERENCE, decl ? decl->qn : NULL,
+                         CBM_RESOLVE_RULE_SCOPE_BINDING, ctx->owner,
+                         !name      ? "make_variable_name_computed"
+                         : !decl    ? "make_variable_not_assigned_in_this_file"
+                         : decl->qn ? "make_variable_of_this_file"
+                                    : "make_variable_has_no_graph_node");
+}
+
+static void make_resolve_walk(make_ctx_t *ctx, TSNode node, unsigned depth) {
+    if (!cbm_source_step(ctx->walk, depth))
+        return;
+    if (cbm_source_is(node, "variable_reference"))
+        make_visit_reference(ctx, node);
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (ts_node_is_named(child))
+                make_resolve_walk(ctx, child, depth + 1);
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+}
+
+static const char *make_owner(cbm_source_walk_t *walk) {
+    return cbm_arena_sprintf(walk->arena, MAKE_VARIABLES "%s", walk->file);
+}
+
+static void make_collect(cbm_source_walk_t *walk) {
+    walk->table = walk->writable;
+    make_ctx_t ctx = {.walk = walk, .owner = make_owner(walk)};
+    if (ctx.owner)
+        make_collect_walk(&ctx, walk->root, 0);
+}
+
+static void make_resolve(cbm_source_walk_t *walk) {
+    make_ctx_t ctx = {.walk = walk, .owner = make_owner(walk)};
+    if (ctx.owner)
+        make_resolve_walk(&ctx, walk->root, 0);
+}
+
+const cbm_source_adapter_t cbm_source_adapter_make = {.language = CBM_LANG_MAKEFILE,
+                                                      .collect = make_collect,
+                                                      .resolve = make_resolve,
+                                                      .decides_references = true,
+                                                      .parse_errors_are_local = true,
+                                                      .one_name_one_node = true};
diff --git a/internal/cbm/resolve/adapter_shell.c b/internal/cbm/resolve/adapter_shell.c
new file mode 100644
index 000000000..443dcd5d8
--- /dev/null
+++ b/internal/cbm/resolve/adapter_shell.c
@@ -0,0 +1,412 @@
+/* Shell binding rules, from the Bash manual's "Command Search and Execution".
+ *
+ * A command name without a slash is looked up as a function first, then as a builtin, then on
+ * PATH, so a function a script defines wins over everything but an alias. Functions live in one
+ * table per shell process, and a process consists of the script and what it `source`s: another
+ * script in the project is another process, however uniquely it names a function.
+ *
+ * A definition takes effect when it runs. A function body runs later, so it can call what is
+ * defined further down; a command at the top level runs now, and only sees definitions above it.
+ * `command foo` and `builtin foo` skip the table by design, and need nothing here: the command
+ * there is `command`. `unset -f foo` makes the name unknown again, and a command computed from a
+ * variable is unknown.
+ *
+ * `source` reaches another file when its path is spelled literally, or relative to the script's
+ * own directory through `$(dirname "$0")`, its BASH_SOURCE spellings, or a variable assigned one
+ * of those once (`ROOT=$(dirname "$0")/..`, `source "$ROOT/lib.sh"`). A literal path is relative
+ * to the working directory: the script's own directory or the repository root. */
+#include "source_adapter_internal.h"
+#include <stdio.h>
+
+#define SHELL_FUNCTIONS "F:"
+#define SHELL_SOURCES "S:"
+#define SHELL_UNSET "U:"
+#define SHELL_VARIABLES "V:"
+#define SHELL_LOCALS "W:"
+#define SHELL_FILES "P:"
+
+enum { SHELL_PATH_BUF = 1024, SHELL_CLOSURE_MAX = 256 };
+
+typedef struct {
+    cbm_source_walk_t *walk;
+    const char *functions, *sources, *unset, *variables, *locals;
+    const char **closure; /* files this script's process consists of, itself first */
+    size_t closure_count;
+    unsigned function_depth;
+} shell_ctx_t;
+
+static const char *shell_directory(cbm_source_walk_t *walk) {
+    const char *slash = strrchr(walk->file, '/');
+    return slash ? cbm_arena_strndup(walk->arena, walk->file, (size_t)(slash - walk->file)) : "";
+}
+
+/* Past `$(dirname "$0")` or its BASH_SOURCE spellings: the script's own directory. */
+static const char *shell_after_dirname(const char *text) {
+    static const char *const forms[] = {"\"$0\"",
+                                        "$0",
+                                        "\"${0}\"",
+                                        "${0}",
+                                        "\"${BASH_SOURCE[0]}\"",
+                                        "${BASH_SOURCE[0]}",
+                                        "\"${BASH_SOURCE}\"",
+                                        "${BASH_SOURCE}",
+                                        "\"$BASH_SOURCE\"",
+                                        "$BASH_SOURCE"};
+    const char *at = strstr(text, "$(dirname ");
+    if (!at)
+        return NULL;
+    at += strlen("$(dirname ");
+    for (size_t i = 0; i < sizeof(forms) / sizeof(forms[0]); i++) {
+        size_t length = strlen(forms[i]);
+        if (!strncmp(at, forms[i], length) && at[length] == ')')
+            return at + length + 1;
+    }
+    return NULL;
+}
+
+static size_t shell_path_span(const char *text) {
+    return strspn(text, "/._-+abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
+}
+
+/* What a path expression names, relative to the script's directory (*own) or to the working
+ * directory. It reads the forms scripts use to find themselves: a literal, `$(dirname "$0")/x`,
+ * `"$(cd "$(dirname "$0")/.." && pwd)"/x`, and a variable assigned one of those. */
+static const char *shell_path_expression(shell_ctx_t *ctx, const char *text, bool *own) {
+    cbm_source_walk_t *walk = ctx->walk;
+    *own = false;
+    const char *after = shell_after_dirname(text);
+    if (after) {
+        size_t first = shell_path_span(after);
+        const char *rest = after + first;
+        const char *close = strrchr(rest, ')');
+        rest = close ? close + 1 : rest;
+        while (*rest == '"')
+            rest++;
+        size_t second = shell_path_span(rest);
+        const char *tail = rest + second;
+        while (*tail == '"')
+            tail++;
+        if (*tail)
+            return NULL;
+        *own = true;
+        const char *joined =
+            cbm_arena_sprintf(walk->arena, "%.*s%.*s", (int)first, after, (int)second, rest);
+        while (joined && *joined == '/')
+            joined++;
+        return joined;
+    }
+    const char *at = text;
+    while (*at == '"')
+        at++;
+    if (*at != '$') {
+        if (strpbrk(at, "$`*?"))
+            return NULL;
+        size_t length = strlen(at);
+        while (length && (at[length - 1] == '"' || at[length - 1] == '\''))
+            length--;
+        if (*at == '\'') {
+            at++;
+            length--;
+        }
+        return cbm_arena_strndup(walk->arena, at, length);
+    }
+    at++;
+    bool braced = *at == '{';
+    if (braced)
+        at++;
+    size_t name_size =
+        strspn(at, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_");
+    if (!name_size || (braced && at[name_size] != '}'))
+        return NULL;
+    const char *name = cbm_arena_strndup(walk->arena, at, name_size);
+    const cbm_source_decl_t *variable = name ? cbm_source_lookup(walk, ctx->variables, name) : NULL;
+    if (!variable || (variable->flags & CBM_SOURCE_DECL_F_OPEN) || !variable->type)
+        return NULL;
+    at += name_size + (braced ? 1 : 0);
+    while (*at == '"')
+        at++;
+    size_t tail_size = shell_path_span(at);
+    const char *tail = at + tail_size;
+    while (*tail == '"')
+        tail++;
+    if (*tail)
+        return NULL;
+    *own = true;
+    const char *joined =
+        cbm_arena_sprintf(walk->arena, "%s%.*s", variable->type, (int)tail_size, at);
+    while (joined && *joined == '/')
+        joined++;
+    return joined;
+}
+
+static const char *shell_command_word(cbm_source_walk_t *walk, TSNode command) {
+    TSNode name = cbm_source_field(command, "name");
+    if (!cbm_source_is(name, "command_name") || ts_node_named_child_count(name) != 1 ||
+        !cbm_source_is(ts_node_named_child(name, 0), "word"))
+        return NULL;
+    return cbm_source_text(walk, name);
+}
+
+/* One chained list per file, under the empty name: a closure walks a file's sources. */
+static void shell_note_source(shell_ctx_t *ctx, const char *path) {
+    cbm_source_decl_t *decl = cbm_source_declare(ctx->walk, ctx->sources, "", NULL, 0, 0);
+    if (decl)
+        decl->type = cbm_source_table_intern(ctx->walk, path);
+}
+
+static void shell_collect_source(shell_ctx_t *ctx, TSNode command) {
+    cbm_source_walk_t *walk = ctx->walk;
+    TSNode argument = cbm_source_field(command, "argument");
+    const char *text = cbm_source_text(walk, argument);
+    bool own = false;
+    const char *path = text ? shell_path_expression(ctx, text, &own) : NULL;
+    if (!path || !*path || *path == '/')
+        return;
+    char joined[SHELL_PATH_BUF];
+    const char *directory = shell_directory(walk);
+    if (directory && cbm_source_join_path(directory, path, joined, sizeof(joined)))
+        shell_note_source(ctx, joined);
+    if (!own && cbm_source_join_path("", path, joined, sizeof(joined)))
+        shell_note_source(ctx, joined);
+}
+
+/* `ROOT=$(dirname "$0")/..`: a name for a directory relative to the script. */
+static void shell_collect_variable(shell_ctx_t *ctx, TSNode assignment) {
+    cbm_source_walk_t *walk = ctx->walk;
+    const char *name = cbm_source_text(walk, cbm_source_field(assignment, "name"));
+    const char *text = cbm_source_text(walk, cbm_source_field(assignment, "value"));
+    if (!name)
+        return;
+    cbm_source_decl_t *known = (cbm_source_decl_t *)cbm_source_lookup(walk, ctx->variables, name);
+    const char *qn = cbm_source_def_qn(walk, name, ts_node_start_point(assignment).row + 1);
+    if (known) {
+        known->flags |= CBM_SOURCE_DECL_F_OPEN;
+        if (!known->qn && qn)
+            known->qn = cbm_source_table_intern(walk, qn);
+        return;
+    }
+    bool own = false;
+    const char *path = text ? shell_path_expression(ctx, text, &own) : NULL;
+    cbm_source_decl_t *decl = cbm_source_declare(walk, ctx->variables, name, qn, 0, 0);
+    if (decl && path && own)
+        decl->type = cbm_source_table_intern(walk, path);
+}
+
+/* `local x`, `declare x`: this name is a function's own somewhere in the file, and a read of it
+ * is not decided here. */
+static void shell_collect_local(shell_ctx_t *ctx, TSNode node) {
+    cbm_source_walk_t *walk = ctx->walk;
+    uint32_t count = ts_node_named_child_count(node);
+    for (uint32_t i = 0; i < count; i++) {
+        TSNode child = ts_node_named_child(node, i);
+        TSNode bound =
+            cbm_source_is(child, "variable_assignment") ? cbm_source_field(child, "name") : child;
+        if (!cbm_source_is(bound, "variable_name"))
+            continue;
+        const char *name = cbm_source_text(walk, bound);
+        if (name && !cbm_source_lookup(walk, ctx->locals, name))
+            (void)cbm_source_declare(walk, ctx->locals, name, NULL, 0, 0);
+    }
+}
+
+static void shell_collect_walk(shell_ctx_t *ctx, TSNode node, unsigned depth) {
+    cbm_source_walk_t *walk = ctx->walk;
+    if (!cbm_source_step(walk, depth))
+        return;
+    if (cbm_source_is(node, "function_definition")) {
+        const char *name = cbm_source_text(walk, cbm_source_field(node, "name"));
+        uint32_t line = ts_node_start_point(node).row + 1;
+        const cbm_source_decl_t *first =
+            name ? cbm_source_lookup(walk, ctx->functions, name) : NULL;
+        if (name && !first)
+            (void)cbm_source_declare(walk, ctx->functions, name,
+                                     cbm_source_def_qn_at(walk, name, line), 0, line);
+    } else if (cbm_source_is(node, "command")) {
+        const char *word = shell_command_word(walk, node);
+        if (word && (!strcmp(word, "source") || !strcmp(word, ".")))
+            shell_collect_source(ctx, node);
+    } else if (cbm_source_is(node, "declaration_command")) {
+        shell_collect_local(ctx, node);
+    } else if (cbm_source_is(node, "variable_assignment")) {
+        shell_collect_variable(ctx, node);
+    } else if (cbm_source_is(node, "unset_command")) {
+        uint32_t count = ts_node_named_child_count(node);
+        for (uint32_t i = 0; i < count; i++) {
+            TSNode child = ts_node_named_child(node, i);
+            const char *name = cbm_source_text(walk, child);
+            if (name && name[0] != '-')
+                (void)cbm_source_declare(walk, ctx->unset, name, NULL, 0, 0);
+        }
+    }
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (ts_node_is_named(child))
+                shell_collect_walk(ctx, child, depth + 1);
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+}
+
+static bool shell_ctx_init(shell_ctx_t *ctx, cbm_source_walk_t *walk) {
+    *ctx = (shell_ctx_t){.walk = walk};
+    ctx->functions = cbm_arena_sprintf(walk->arena, SHELL_FUNCTIONS "%s", walk->file);
+    ctx->sources = cbm_arena_sprintf(walk->arena, SHELL_SOURCES "%s", walk->file);
+    ctx->unset = cbm_arena_sprintf(walk->arena, SHELL_UNSET "%s", walk->file);
+    ctx->variables = cbm_arena_sprintf(walk->arena, SHELL_VARIABLES "%s", walk->file);
+    ctx->locals = cbm_arena_sprintf(walk->arena, SHELL_LOCALS "%s", walk->file);
+    if (!ctx->functions || !ctx->sources || !ctx->unset || !ctx->variables || !ctx->locals) {
+        cbm_source_fail(walk, "shell_scope_allocation");
+        return false;
+    }
+    return true;
+}
+
+static void shell_collect(cbm_source_walk_t *walk) {
+    walk->table = walk->writable;
+    shell_ctx_t ctx;
+    if (!shell_ctx_init(&ctx, walk))
+        return;
+    (void)cbm_source_declare(walk, SHELL_FILES, walk->file, NULL, 0, 0);
+    shell_collect_walk(&ctx, walk->root, 0);
+}
+
+static bool shell_in_closure(const shell_ctx_t *ctx, const char *file) {
+    for (size_t i = 0; i < ctx->closure_count; i++)
+        if (!strcmp(ctx->closure[i], file))
+            return true;
+    return false;
+}
+
+/* Breadth first through literal `source` statements; each file enters once. Past the bound the
+ * process is not fully known, and a name no file so far declares stays unknown. */
+static bool shell_build_closure(shell_ctx_t *ctx) {
+    cbm_source_walk_t *walk = ctx->walk;
+    ctx->closure = cbm_arena_calloc(walk->arena, SHELL_CLOSURE_MAX * sizeof(*ctx->closure));
+    if (!ctx->closure)
+        return false;
+    ctx->closure[ctx->closure_count++] = walk->file;
+    for (size_t at = 0; at < ctx->closure_count; at++) {
+        const char *owner = cbm_arena_sprintf(walk->arena, SHELL_SOURCES "%s", ctx->closure[at]);
+        if (!owner)
+            return false;
+        for (const cbm_source_decl_t *entry = cbm_source_lookup(walk, owner, ""); entry;
+             entry = entry->next) {
+            if (!entry->type || !cbm_source_lookup(walk, SHELL_FILES, entry->type) ||
+                shell_in_closure(ctx, entry->type))
+                continue;
+            if (ctx->closure_count == SHELL_CLOSURE_MAX)
+                return true;
+            ctx->closure[ctx->closure_count++] = entry->type;
+        }
+    }
+    return true;
+}
+
+static void shell_visit_command(shell_ctx_t *ctx, TSNode command) {
+    cbm_source_walk_t *walk = ctx->walk;
+    const char *word = shell_command_word(walk, command);
+    if (!word) {
+        cbm_source_emit_node(walk, command, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE, NULL,
+                             "shell_command_computed");
+        return;
+    }
+    if (cbm_source_lookup(walk, ctx->unset, word)) {
+        cbm_source_emit_node(walk, command, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE, NULL,
+                             "shell_function_unset_in_this_file");
+        return;
+    }
+    const cbm_source_decl_t *own = cbm_source_lookup(walk, ctx->functions, word);
+    if (own) {
+        uint32_t line = ts_node_start_point(command).row + 1;
+        if (!ctx->function_depth && own->line > line) {
+            cbm_source_emit_node(walk, command, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE,
+                                 NULL, "shell_function_not_yet_defined");
+            return;
+        }
+        cbm_source_emit_node(walk, command, CBM_SOURCE_SITE_CALL, own->qn,
+                             CBM_RESOLVE_RULE_SCOPE_BINDING, ctx->functions,
+                             own->qn ? "shell_function_table" : "shell_function_has_no_graph_node");
+        return;
+    }
+    const cbm_source_decl_t *found = NULL;
+    for (size_t i = 1; i < ctx->closure_count; i++) {
+        const char *owner = cbm_arena_sprintf(walk->arena, SHELL_FUNCTIONS "%s", ctx->closure[i]);
+        const cbm_source_decl_t *decl = owner ? cbm_source_lookup(walk, owner, word) : NULL;
+        if (!decl)
+            continue;
+        /* The later `source` wins at runtime, and order across files is not modelled. */
+        if (found && (!decl->qn || !found->qn || strcmp(decl->qn, found->qn))) {
+            cbm_source_emit_node(walk, command, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE,
+                                 NULL, "shell_function_in_two_sourced_files");
+            return;
+        }
+        found = decl;
+    }
+    if (found) {
+        cbm_source_emit_node(walk, command, CBM_SOURCE_SITE_CALL, found->qn,
+                             CBM_RESOLVE_RULE_IMPORT_BINDING, found->file,
+                             found->qn ? "shell_function_from_sourced_file"
+                                       : "shell_function_has_no_graph_node");
+        return;
+    }
+    cbm_source_emit_node(walk, command, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE, NULL,
+                         "shell_command_not_a_function_of_this_process");
+}
+
+/* `$x` and `${x}`: the variable this file assigns, unless a function here makes the name local. */
+static void shell_visit_expansion(shell_ctx_t *ctx, TSNode node) {
+    cbm_source_walk_t *walk = ctx->walk;
+    TSNode name = ts_node_named_child_count(node) ? ts_node_named_child(node, 0) : (TSNode){0};
+    if (!cbm_source_is(name, "variable_name"))
+        return;
+    const char *text = cbm_source_text(walk, name);
+    if (!text)
+        return;
+    const cbm_source_decl_t *variable = cbm_source_lookup(walk, ctx->variables, text);
+    bool local = cbm_source_lookup(walk, ctx->locals, text) != NULL;
+    const char *target = variable && !local ? variable->qn : NULL;
+    cbm_source_emit_node(walk, name, CBM_SOURCE_SITE_REFERENCE, target,
+                         CBM_RESOLVE_RULE_SCOPE_BINDING, ctx->variables,
+                         target  ? "shell_variable_of_this_file"
+                         : local ? "shell_name_is_local_in_this_file"
+                                 : "shell_variable_not_assigned_at_the_top_of_this_file");
+}
+
+static void shell_resolve_walk(shell_ctx_t *ctx, TSNode node, unsigned depth) {
+    if (!cbm_source_step(ctx->walk, depth))
+        return;
+    bool function = cbm_source_is(node, "function_definition");
+    if (cbm_source_is(node, "command"))
+        shell_visit_command(ctx, node);
+    else if (cbm_source_is(node, "simple_expansion") || cbm_source_is(node, "expansion"))
+        shell_visit_expansion(ctx, node);
+    if (function)
+        ctx->function_depth++;
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (ts_node_is_named(child))
+                shell_resolve_walk(ctx, child, depth + 1);
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+    if (function)
+        ctx->function_depth--;
+}
+
+static void shell_resolve(cbm_source_walk_t *walk) {
+    shell_ctx_t ctx;
+    if (!shell_ctx_init(&ctx, walk) || !shell_build_closure(&ctx))
+        return;
+    shell_resolve_walk(&ctx, walk->root, 0);
+}
+
+const cbm_source_adapter_t cbm_source_adapter_shell = {.language = CBM_LANG_BASH,
+                                                       .collect = shell_collect,
+                                                       .resolve = shell_resolve,
+                                                       .decides_references = true,
+                                                       .parse_errors_are_local = true,
+                                                       .one_name_one_node = true};
diff --git a/internal/cbm/resolve/adapter_tcl.c b/internal/cbm/resolve/adapter_tcl.c
new file mode 100644
index 000000000..0a4edd09d
--- /dev/null
+++ b/internal/cbm/resolve/adapter_tcl.c
@@ -0,0 +1,308 @@
+/* Tcl binding rules, from the Tcl(n) dodecalogue and the `namespace` manual page.
+ *
+ * Every word in command position is looked up in the command table of the current namespace,
+ * then of the global one, when the command runs; nothing lexical can shadow it, and a variable
+ * lives in another table. `proc` writes that table, so which procs are visible is a matter of
+ * which files ran in the interpreter. `a::b` and `::a::b` name their namespace directly.
+ *
+ * A script's own procs are always visible to it. Another file's proc reaches it only through the
+ * global table of a shared interpreter, and the evidence for one is `source` in the project: a
+ * file sourced by a literal path is library code, and a file that sources by a computed path is
+ * a harness whose procs the scripts it loads can call. A proc declared by two such files leaves
+ * the name open, because the last `source` decides, and `rename` of a name makes it unknown
+ * everywhere. A standalone script's procs are visible to nobody else.
+ *
+ * The Tcl grammar leaves expression syntax as parse errors in most real files. No binding here
+ * depends on the structure around such an error, so the rest of the file still decides. */
+#include "source_adapter_internal.h"
+#include <stdio.h>
+
+#define TCL_PROCS "P:"
+#define TCL_OWN "H:"
+#define TCL_SOURCED "L:"
+
+enum { TCL_PATH_BUF = 1024 };
+
+typedef struct {
+    cbm_source_walk_t *walk;
+    const char *directory;
+    const char *namespace_name; /* current namespace, "" for the global one */
+} tcl_ctx_t;
+
+static const char *tcl_directory(cbm_source_walk_t *walk) {
+    const char *slash = strrchr(walk->file, '/');
+    return slash ? cbm_arena_strndup(walk->arena, walk->file, (size_t)(slash - walk->file)) : "";
+}
+
+static const char *tcl_owner(tcl_ctx_t *ctx, const char *table, const char *space) {
+    return cbm_arena_sprintf(ctx->walk->arena, "%s%s", table, space);
+}
+
+static const char *tcl_own_owner(tcl_ctx_t *ctx, const char *space) {
+    return cbm_arena_sprintf(ctx->walk->arena, TCL_OWN "%s\x1d%s", ctx->walk->file, space);
+}
+
+/* A name's namespace and leaf, from where it is written. `::a::b` is absolute, and so is a name
+ * inside a namespace once it has been joined with that namespace. */
+static void tcl_split(tcl_ctx_t *ctx, const char *name, const char *space, const char **out_space,
+                      const char **out_leaf) {
+    bool absolute = !strncmp(name, "::", 2);
+    const char *body = absolute ? name + 2 : name;
+    const char *last = NULL;
+    for (const char *p = body; (p = strstr(p, "::")); p += 2)
+        last = p;
+    *out_leaf = last ? last + 2 : body;
+    if (!last) {
+        *out_space = absolute ? "" : space;
+        return;
+    }
+    const char *prefix = cbm_arena_strndup(ctx->walk->arena, body, (size_t)(last - body));
+    *out_space = absolute || !*space
+                     ? prefix
+                     : cbm_arena_sprintf(ctx->walk->arena, "%s::%s", space, prefix ? prefix : "");
+}
+
+static void tcl_declare_once(tcl_ctx_t *ctx, const char *owner, const char *name, const char *qn) {
+    cbm_source_decl_t *head = (cbm_source_decl_t *)cbm_source_lookup(ctx->walk, owner, name);
+    if (!head) {
+        (void)cbm_source_declare(ctx->walk, owner, name, qn, 0, 0);
+        return;
+    }
+    if (!qn || !head->qn || strcmp(qn, head->qn))
+        head->flags |= CBM_SOURCE_DECL_F_OPEN;
+}
+
+static const char *tcl_word(tcl_ctx_t *ctx, TSNode word) {
+    if (cbm_source_is(word, "simple_word"))
+        return cbm_source_text(ctx->walk, word);
+    if (cbm_source_is(word, "quoted_word") && ts_node_named_child_count(word) == 0) {
+        const char *text = cbm_source_text(ctx->walk, word);
+        size_t length = text ? strlen(text) : 0;
+        return length > 2 ? cbm_arena_strndup(ctx->walk->arena, text + 1, length - 2) : NULL;
+    }
+    return NULL;
+}
+
+static void tcl_collect_source(tcl_ctx_t *ctx, TSNode arguments) {
+    /* The grammar splits `tests/$name.tcl` into words: the whole list says if it is computed. */
+    const char *text = cbm_source_text(ctx->walk, arguments);
+    size_t length = text ? strlen(text) : 0;
+    const char *path = text && length >= 2 && text[0] == '"' && text[length - 1] == '"'
+                           ? cbm_arena_strndup(ctx->walk->arena, text + 1, length - 2)
+                           : text;
+    if (!path || strpbrk(path, "$[")) {
+        (void)cbm_source_declare(ctx->walk, TCL_SOURCED, ctx->walk->file, NULL, 0, 0);
+        return;
+    }
+    if (!*path || *path == '/')
+        return;
+    char joined[TCL_PATH_BUF];
+    /* Relative to the working directory: the script's own, or the repository's. */
+    if (ctx->directory && cbm_source_join_path(ctx->directory, path, joined, sizeof(joined)))
+        (void)cbm_source_declare(ctx->walk, TCL_SOURCED, joined, NULL, 0, 0);
+    if (cbm_source_join_path("", path, joined, sizeof(joined)))
+        (void)cbm_source_declare(ctx->walk, TCL_SOURCED, joined, NULL, 0, 0);
+}
+
+static void tcl_collect_command(tcl_ctx_t *ctx, TSNode command) {
+    const char *name = cbm_source_text(ctx->walk, cbm_source_field(command, "name"));
+    TSNode arguments = cbm_source_field(command, "arguments");
+    if (!name || ts_node_is_null(arguments) || !ts_node_named_child_count(arguments))
+        return;
+    TSNode first = ts_node_named_child(arguments, 0);
+    if (!strcmp(name, "source")) {
+        tcl_collect_source(ctx, arguments);
+    } else if (!strcmp(name, "rename")) {
+        const char *renamed = tcl_word(ctx, first);
+        if (renamed) {
+            const char *space = "", *leaf = renamed;
+            tcl_split(ctx, renamed, ctx->namespace_name, &space, &leaf);
+            const char *owner = tcl_owner(ctx, TCL_PROCS, space ? space : "");
+            if (owner) {
+                tcl_declare_once(ctx, owner, leaf, NULL);
+                tcl_declare_once(ctx, owner, leaf, NULL);
+            }
+        }
+    }
+}
+
+static void tcl_collect_walk(tcl_ctx_t *ctx, TSNode node, unsigned depth);
+
+static void tcl_collect_children(tcl_ctx_t *ctx, TSNode node, unsigned depth) {
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (ts_node_is_named(child))
+                tcl_collect_walk(ctx, child, depth + 1);
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+}
+
+/* `namespace eval a { ... }`: the namespace a word list names, NULL for any other subcommand. */
+static const char *tcl_namespace_of(tcl_ctx_t *ctx, TSNode node, TSNode *body) {
+    TSNode words = (TSNode){0};
+    uint32_t count = ts_node_named_child_count(node);
+    for (uint32_t i = 0; i < count && ts_node_is_null(words); i++)
+        if (cbm_source_is(ts_node_named_child(node, i), "word_list"))
+            words = ts_node_named_child(node, i);
+    if (ts_node_is_null(words) || ts_node_named_child_count(words) < 3)
+        return NULL;
+    const char *verb = cbm_source_text(ctx->walk, ts_node_named_child(words, 0));
+    const char *name = tcl_word(ctx, ts_node_named_child(words, 1));
+    if (!verb || strcmp(verb, "eval") || !name)
+        return NULL;
+    *body = ts_node_named_child(words, 2);
+    const char *leaf = NULL, *space = NULL;
+    const char *full = cbm_arena_sprintf(ctx->walk->arena, "%s::x", name);
+    if (!full)
+        return NULL;
+    tcl_split(ctx, full, ctx->namespace_name, &space, &leaf);
+    return space;
+}
+
+static void tcl_collect_walk(tcl_ctx_t *ctx, TSNode node, unsigned depth) {
+    cbm_source_walk_t *walk = ctx->walk;
+    if (!cbm_source_step(walk, depth))
+        return;
+    if (cbm_source_is(node, "procedure")) {
+        const char *name = cbm_source_text(walk, cbm_source_field(node, "name"));
+        if (name) {
+            const char *space = "", *leaf = name;
+            tcl_split(ctx, name, ctx->namespace_name, &space, &leaf);
+            const char *qn = cbm_source_def_qn_at(walk, name, ts_node_start_point(node).row + 1);
+            const char *project = tcl_owner(ctx, TCL_PROCS, space ? space : "");
+            const char *own = tcl_own_owner(ctx, space ? space : "");
+            if (project && own) {
+                tcl_declare_once(ctx, project, leaf, qn);
+                tcl_declare_once(ctx, own, leaf, qn);
+            }
+        }
+    } else if (cbm_source_is(node, "command")) {
+        tcl_collect_command(ctx, node);
+    } else if (cbm_source_is(node, "namespace")) {
+        TSNode body = (TSNode){0};
+        const char *inner = tcl_namespace_of(ctx, node, &body);
+        if (inner) {
+            const char *outer = ctx->namespace_name;
+            ctx->namespace_name = inner;
+            tcl_collect_children(ctx, body, depth);
+            ctx->namespace_name = outer;
+            return;
+        }
+    }
+    tcl_collect_children(ctx, node, depth);
+}
+
+static void tcl_collect(cbm_source_walk_t *walk) {
+    walk->table = walk->writable;
+    tcl_ctx_t ctx = {.walk = walk, .namespace_name = ""};
+    ctx.directory = tcl_directory(walk);
+    if (!ctx.directory) {
+        cbm_source_fail(walk, "tcl_scope_allocation");
+        return;
+    }
+    tcl_collect_walk(&ctx, walk->root, 0);
+}
+
+static void tcl_emit_abstain(tcl_ctx_t *ctx, TSNode command, const char *reason) {
+    cbm_source_emit_node(ctx->walk, command, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE,
+                         NULL, reason);
+}
+
+/* A command's own namespace first, then the global one, for a name with no `::` in it. */
+static const cbm_source_decl_t *tcl_lookup_table(tcl_ctx_t *ctx, const char *space,
+                                                 const char *leaf, bool own) {
+    const char *owner = own ? tcl_own_owner(ctx, space) : tcl_owner(ctx, TCL_PROCS, space);
+    return owner ? cbm_source_lookup(ctx->walk, owner, leaf) : NULL;
+}
+
+static void tcl_visit_command(tcl_ctx_t *ctx, TSNode command) {
+    cbm_source_walk_t *walk = ctx->walk;
+    TSNode name_node = cbm_source_field(command, "name");
+    const char *name =
+        cbm_source_is(name_node, "simple_word") ? cbm_source_text(walk, name_node) : NULL;
+    if (!name || strpbrk(name, "$[")) {
+        tcl_emit_abstain(ctx, command, "tcl_command_computed");
+        return;
+    }
+    const char *space = "", *leaf = name;
+    bool qualified = strstr(name, "::") != NULL;
+    tcl_split(ctx, name, ctx->namespace_name, &space, &leaf);
+    if (!space)
+        space = "";
+    /* Inside a namespace an unqualified name tries it, then the global one. */
+    const char *tries[2] = {space, qualified || !*space ? NULL : ""};
+    for (size_t i = 0; i < 2 && tries[i]; i++) {
+        const cbm_source_decl_t *own = tcl_lookup_table(ctx, tries[i], leaf, true);
+        const cbm_source_decl_t *project = tcl_lookup_table(ctx, tries[i], leaf, false);
+        if (!project)
+            continue;
+        /* `rename` marked the shared entry: the name is not what its proc declared. */
+        if (own && !(own->flags & CBM_SOURCE_DECL_F_OPEN)) {
+            cbm_source_emit_node(
+                walk, command, CBM_SOURCE_SITE_CALL, own->qn, CBM_RESOLVE_RULE_SCOPE_BINDING,
+                walk->file, own->qn ? "tcl_proc_of_this_script" : "tcl_proc_has_no_graph_node");
+            return;
+        }
+        if (project->flags & CBM_SOURCE_DECL_F_OPEN) {
+            tcl_emit_abstain(ctx, command, "tcl_proc_declared_by_more_than_one_file");
+            return;
+        }
+        if (!cbm_source_lookup(walk, TCL_SOURCED, project->file)) {
+            tcl_emit_abstain(ctx, command, "tcl_proc_of_a_file_nothing_sources");
+            return;
+        }
+        cbm_source_emit_node(walk, command, CBM_SOURCE_SITE_CALL, project->qn,
+                             CBM_RESOLVE_RULE_IMPORT_BINDING, project->file,
+                             project->qn ? "tcl_proc_of_a_sourced_file"
+                                         : "tcl_proc_has_no_graph_node");
+        return;
+    }
+    tcl_emit_abstain(ctx, command, "tcl_command_not_a_project_proc");
+}
+
+static void tcl_resolve_walk(tcl_ctx_t *ctx, TSNode node, unsigned depth);
+
+static void tcl_resolve_children(tcl_ctx_t *ctx, TSNode node, unsigned depth) {
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (ts_node_is_named(child))
+                tcl_resolve_walk(ctx, child, depth + 1);
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+}
+
+static void tcl_resolve_walk(tcl_ctx_t *ctx, TSNode node, unsigned depth) {
+    if (!cbm_source_step(ctx->walk, depth))
+        return;
+    if (cbm_source_is(node, "command")) {
+        tcl_visit_command(ctx, node);
+    } else if (cbm_source_is(node, "namespace")) {
+        TSNode body = (TSNode){0};
+        const char *inner = tcl_namespace_of(ctx, node, &body);
+        if (inner) {
+            const char *outer = ctx->namespace_name;
+            ctx->namespace_name = inner;
+            tcl_resolve_children(ctx, body, depth);
+            ctx->namespace_name = outer;
+            return;
+        }
+    }
+    tcl_resolve_children(ctx, node, depth);
+}
+
+static void tcl_resolve(cbm_source_walk_t *walk) {
+    tcl_ctx_t ctx = {.walk = walk, .namespace_name = ""};
+    tcl_resolve_walk(&ctx, walk->root, 0);
+}
+
+const cbm_source_adapter_t cbm_source_adapter_tcl = {.language = CBM_LANG_TCL,
+                                                     .collect = tcl_collect,
+                                                     .resolve = tcl_resolve,
+                                                     .parse_errors_are_local = true,
+                                                     .one_name_one_node = true};
diff --git a/internal/cbm/resolve/adapter_vim.c b/internal/cbm/resolve/adapter_vim.c
new file mode 100644
index 000000000..64a55fe93
--- /dev/null
+++ b/internal/cbm/resolve/adapter_vim.c
@@ -0,0 +1,250 @@
+/* Vim script binding rules, from `:help user-function`, `:help script-local` and
+ * `:help autoload`.
+ *
+ * The prefix of a function name says where it lives, and nothing can move it:
+ *   s:Name, <SID>Name   the script's own functions, one namespace per file;
+ *   a#b#c               an autoload function, which only runtime file autoload/a/b.vim defines;
+ *   Name, g:Name        one global namespace for the whole editor session.
+ * A bare name that starts in lower case is a builtin: `:function` refuses to declare one, so a
+ * project declaration can never be what `get(...)` means.
+ *
+ * A global is read from the file's own declaration when it has one, then from the one project
+ * file that declares it. Two files declaring a global leave it open: which one is in effect
+ * depends on what was sourced last. A variable holding a Funcref is looked up before a function
+ * of that name (`let F = function('X')`, `call F()`), so a capitalized name a file also assigns
+ * abstains there. A dict function is selected by the dict's runtime value and stays unknown. */
+#include "source_adapter_internal.h"
+#include <ctype.h>
+#include <stdio.h>
+
+#define VIM_GLOBAL "G"
+#define VIM_AUTOLOAD "A"
+#define VIM_SCRIPT "S:"
+#define VIM_OWN "H:"
+#define VIM_ASSIGNED "V:"
+
+typedef struct {
+    cbm_source_walk_t *walk;
+    const char *script_owner;
+    const char *own_owner;
+    const char *assigned_owner;
+} vim_ctx_t;
+
+static bool vim_script_scope(const char *text) {
+    return !strncmp(text, "s:", 2) || !strncmp(text, "<SID>", 5) || !strncmp(text, "<sid>", 5);
+}
+
+static void vim_declare_once(vim_ctx_t *ctx, const char *owner, const char *name, const char *qn) {
+    cbm_source_decl_t *head = (cbm_source_decl_t *)cbm_source_lookup(ctx->walk, owner, name);
+    if (!head) {
+        (void)cbm_source_declare(ctx->walk, owner, name, qn, 0, 0);
+        return;
+    }
+    if (!qn || !head->qn || strcmp(qn, head->qn))
+        head->flags |= CBM_SOURCE_DECL_F_OPEN;
+}
+
+/* a#b#c belongs in autoload/a/b.vim, the only file `:help autoload` reads for it. */
+static bool vim_autoload_file(const vim_ctx_t *ctx, const char *name) {
+    const char *last = strrchr(name, '#');
+    const char *file = ctx->walk->file;
+    if (!last || !file)
+        return false;
+    char path[512];
+    int length = snprintf(path, sizeof(path), "autoload/%.*s.vim", (int)(last - name), name);
+    if (length <= 0 || (size_t)length >= sizeof(path))
+        return false;
+    for (char *p = path; *p; p++)
+        if (*p == '#')
+            *p = '/';
+    size_t size = strlen(file);
+    if (size < (size_t)length || strcmp(file + size - (size_t)length, path))
+        return false;
+    return size == (size_t)length || file[size - (size_t)length - 1] == '/';
+}
+
+static void vim_collect_function(vim_ctx_t *ctx, TSNode node) {
+    cbm_source_walk_t *walk = ctx->walk;
+    TSNode declaration = (TSNode){0};
+    uint32_t count = ts_node_named_child_count(node);
+    for (uint32_t i = 0; i < count && ts_node_is_null(declaration); i++)
+        if (cbm_source_is(ts_node_named_child(node, i), "function_declaration"))
+            declaration = ts_node_named_child(node, i);
+    TSNode name = cbm_source_field(declaration, "name");
+    const char *text = cbm_source_text(walk, name);
+    if (!text)
+        return;
+    const char *qn = cbm_source_def_qn_at(walk, text, ts_node_start_point(node).row + 1);
+    if (cbm_source_is(name, "scoped_identifier")) {
+        const char *bare = cbm_source_text(walk, ts_node_named_child(name, 1));
+        if (!bare)
+            return;
+        if (vim_script_scope(text)) {
+            vim_declare_once(ctx, ctx->script_owner, bare, qn);
+        } else if (!strncmp(text, "g:", 2)) {
+            vim_declare_once(ctx, VIM_GLOBAL, bare, qn);
+            vim_declare_once(ctx, ctx->own_owner, bare, qn);
+        }
+        return;
+    }
+    if (!cbm_source_is(name, "identifier"))
+        return;
+    if (strchr(text, '#')) {
+        /* The file's own definition is what it reads, wherever the file sits. */
+        vim_declare_once(ctx, ctx->own_owner, text, qn);
+        if (vim_autoload_file(ctx, text))
+            vim_declare_once(ctx, VIM_AUTOLOAD, text, qn);
+        return;
+    }
+    vim_declare_once(ctx, VIM_GLOBAL, text, qn);
+    vim_declare_once(ctx, ctx->own_owner, text, qn);
+}
+
+/* A capitalized name assigned anywhere in the file can hold a Funcref. */
+static void vim_collect_assigned(vim_ctx_t *ctx, TSNode node) {
+    if (!ts_node_named_child_count(node))
+        return;
+    TSNode target = ts_node_named_child(node, 0);
+    if (cbm_source_is(target, "scoped_identifier"))
+        target = ts_node_named_child(target, 1);
+    if (!cbm_source_is(target, "identifier"))
+        return;
+    const char *text = cbm_source_text(ctx->walk, target);
+    if (text && isupper((unsigned char)text[0]))
+        vim_declare_once(ctx, ctx->assigned_owner, text, NULL);
+}
+
+static void vim_collect_walk(vim_ctx_t *ctx, TSNode node, unsigned depth) {
+    if (!cbm_source_step(ctx->walk, depth))
+        return;
+    if (cbm_source_is(node, "function_definition"))
+        vim_collect_function(ctx, node);
+    else if (cbm_source_is(node, "let_statement") || cbm_source_is(node, "const_statement") ||
+             cbm_source_is(node, "for_loop"))
+        vim_collect_assigned(ctx, node);
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (ts_node_is_named(child))
+                vim_collect_walk(ctx, child, depth + 1);
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+}
+
+static bool vim_ctx_init(vim_ctx_t *ctx, cbm_source_walk_t *walk) {
+    *ctx = (vim_ctx_t){.walk = walk};
+    ctx->script_owner = cbm_arena_sprintf(walk->arena, VIM_SCRIPT "%s", walk->file);
+    ctx->own_owner = cbm_arena_sprintf(walk->arena, VIM_OWN "%s", walk->file);
+    ctx->assigned_owner = cbm_arena_sprintf(walk->arena, VIM_ASSIGNED "%s", walk->file);
+    if (!ctx->script_owner || !ctx->own_owner || !ctx->assigned_owner) {
+        cbm_source_fail(walk, "vim_scope_allocation");
+        return false;
+    }
+    return true;
+}
+
+static void vim_collect(cbm_source_walk_t *walk) {
+    walk->table = walk->writable;
+    vim_ctx_t ctx;
+    if (vim_ctx_init(&ctx, walk))
+        vim_collect_walk(&ctx, walk->root, 0);
+}
+
+static void vim_emit(vim_ctx_t *ctx, TSNode call, const cbm_source_decl_t *decl, const char *domain,
+                     const char *absent) {
+    if (!decl) {
+        cbm_source_emit_node(ctx->walk, call, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE,
+                             NULL, absent);
+        return;
+    }
+    if (decl->flags & CBM_SOURCE_DECL_F_OPEN) {
+        cbm_source_emit_node(ctx->walk, call, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE,
+                             NULL, "vim_declared_by_more_than_one_file");
+        return;
+    }
+    cbm_resolve_rule_t rule = strcmp(decl->file, ctx->walk->file) ? CBM_RESOLVE_RULE_IMPORT_BINDING
+                                                                  : CBM_RESOLVE_RULE_SCOPE_BINDING;
+    cbm_source_emit_node(ctx->walk, call, CBM_SOURCE_SITE_CALL, decl->qn, rule, domain,
+                         decl->qn ? "vim_namespace_declaration" : "vim_function_has_no_graph_node");
+}
+
+static void vim_emit_global(vim_ctx_t *ctx, TSNode call, const char *name) {
+    const cbm_source_decl_t *own = cbm_source_lookup(ctx->walk, ctx->own_owner, name);
+    vim_emit(ctx, call, own ? own : cbm_source_lookup(ctx->walk, VIM_GLOBAL, name), VIM_GLOBAL,
+             "vim_global_not_declared_in_project");
+}
+
+static void vim_visit_call(vim_ctx_t *ctx, TSNode call) {
+    cbm_source_walk_t *walk = ctx->walk;
+    TSNode function = cbm_source_field(call, "function");
+    const char *text = cbm_source_text(walk, function);
+    if (!text)
+        return;
+    if (cbm_source_is(function, "scoped_identifier")) {
+        const char *bare = cbm_source_text(walk, ts_node_named_child(function, 1));
+        if (!bare)
+            return;
+        if (vim_script_scope(text)) {
+            vim_emit(ctx, call, cbm_source_lookup(walk, ctx->script_owner, bare), ctx->script_owner,
+                     "vim_script_function_not_in_this_file");
+        } else if (!strncmp(text, "g:", 2)) {
+            vim_emit_global(ctx, call, bare);
+        } else {
+            cbm_source_emit_node(walk, call, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE,
+                                 NULL, "vim_funcref_in_a_variable");
+        }
+        return;
+    }
+    if (!cbm_source_is(function, "identifier")) {
+        cbm_source_emit_node(walk, call, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE, NULL,
+                             "vim_callee_is_a_runtime_value");
+        return;
+    }
+    if (strchr(text, '#')) {
+        const cbm_source_decl_t *own = cbm_source_lookup(walk, ctx->own_owner, text);
+        vim_emit(ctx, call, own ? own : cbm_source_lookup(walk, VIM_AUTOLOAD, text), VIM_AUTOLOAD,
+                 "vim_autoload_file_not_in_project");
+        return;
+    }
+    if (!isupper((unsigned char)text[0])) {
+        cbm_source_emit_node(walk, call, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE, NULL,
+                             "vim_builtin_function");
+        return;
+    }
+    if (cbm_source_lookup(walk, ctx->assigned_owner, text)) {
+        cbm_source_emit_node(walk, call, CBM_SOURCE_SITE_CALL, NULL, CBM_RESOLVE_RULE_NONE, NULL,
+                             "vim_name_also_assigned_a_funcref");
+        return;
+    }
+    vim_emit_global(ctx, call, text);
+}
+
+static void vim_resolve_walk(vim_ctx_t *ctx, TSNode node, unsigned depth) {
+    if (!cbm_source_step(ctx->walk, depth))
+        return;
+    if (cbm_source_is(node, "call_expression"))
+        vim_visit_call(ctx, node);
+    TSTreeCursor cursor = ts_tree_cursor_new(node);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode child = ts_tree_cursor_current_node(&cursor);
+            if (ts_node_is_named(child))
+                vim_resolve_walk(ctx, child, depth + 1);
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+}
+
+static void vim_resolve(cbm_source_walk_t *walk) {
+    vim_ctx_t ctx;
+    if (vim_ctx_init(&ctx, walk))
+        vim_resolve_walk(&ctx, walk->root, 0);
+}
+
+const cbm_source_adapter_t cbm_source_adapter_vim = {.language = CBM_LANG_VIMSCRIPT,
+                                                     .collect = vim_collect,
+                                                     .resolve = vim_resolve,
+                                                     .parse_errors_are_local = true,
+                                                     .one_name_one_node = true};
diff --git a/internal/cbm/resolve/binding.c b/internal/cbm/resolve/binding.c
index c8ab4db10..d0ab0f054 100644
--- a/internal/cbm/resolve/binding.c
+++ b/internal/cbm/resolve/binding.c
@@ -62,6 +62,8 @@ typedef struct {
     const cbm_resolve_js_import_t *js_import;
     /* A module-level class's own `constructor`, which `new` runs. */
     const char *js_constructor;
+    /* `const { m: x } = f()`: what calling x runs is f's returned m. */
+    const char *js_call_callee, *js_call_member;
     /* One-based index of a Python import below module level or under a
      * statement: the extractor records only top-level imports. */
     uint32_t nested_import;
@@ -125,6 +127,20 @@ typedef struct {
     bool self_is_class;
 } binding_scope_t;
 
+/* One member of a `return { ... }` in a module-level function. A NULL member is a return of
+ * anything else, which leaves the function's value open. */
+typedef struct {
+    const char *function_name, *function_target;
+    uint32_t function_start, function_end;
+    const char *member;
+    const char *local;
+    uint32_t scope;
+    const char *value_name;
+    uint32_t value_start, value_end;
+    const char *target;
+    bool conflict;
+} js_returned_t;
+
 /* A module-scope write or an `exports.x = v` value, captured during the walk
  * and settled once every declaration in the file is known. */
 typedef struct {
@@ -264,6 +280,8 @@ struct cbm_resolve_binding_index {
     size_t import_count, import_capacity;
     js_write_t *js_writes;
     size_t js_write_count, js_write_capacity;
+    const char **markup_writes;
+    size_t markup_write_count;
     js_raw_export_t *js_raw_exports;
     size_t js_raw_export_count, js_raw_export_capacity;
     cbm_resolve_js_export_t *js_exports;
@@ -273,6 +291,8 @@ struct cbm_resolve_binding_index {
     size_t js_export_alias_count, js_export_alias_capacity;
     js_member_t *js_members;
     size_t js_member_count, js_member_capacity;
+    js_returned_t *js_returned;
+    size_t js_returned_count, js_returned_capacity;
     const char *current_this_owner;
     bool current_this_prototype;
 };
@@ -893,52 +913,8 @@ static bool supported_node(CBMLanguage language, const char *kind) {
                                                  "keyword_pattern",
                                                  "type_alias_statement",
                                                  NULL};
-    static const char *const lua[] = {"chunk",
-                                      "block",
-                                      "function_declaration",
-                                      "function_definition",
-                                      "parameters",
-                                      "identifier",
-                                      "variable",
-                                      "variable_list",
-                                      "expression_list",
-                                      "function_call",
-                                      "arguments",
-                                      "return_statement",
-                                      "assignment_statement",
-                                      "variable_declaration",
-                                      "number",
-                                      "string",
-                                      "string_content",
-                                      "escape_sequence",
-                                      "true",
-                                      "false",
-                                      "nil",
-                                      "binary_expression",
-                                      "unary_expression",
-                                      "parenthesized_expression",
-                                      "if_statement",
-                                      "elseif_statement",
-                                      "else_statement",
-                                      "while_statement",
-                                      "repeat_statement",
-                                      "for_statement",
-                                      "for_numeric_clause",
-                                      "for_generic_clause",
-                                      "do_statement",
-                                      "break_statement",
-                                      "comment",
-                                      "empty_statement",
-                                      "table_constructor",
-                                      "field",
-                                      "dot_index_expression",
-                                      "method_index_expression",
-                                      "bracket_index_expression",
-                                      NULL};
-    if (language == CBM_LANG_PYTHON)
-        return listed(kind, python) || listed(kind, python_expressions) ||
-               listed(kind, python_binders);
-    return listed(kind, lua);
+    (void)language;
+    return listed(kind, python) || listed(kind, python_expressions) || listed(kind, python_binders);
 }
 
 /* These grammar containers add no binders. The ordinary walk still audits
@@ -1019,12 +995,8 @@ static bool dynamic_name(CBMLanguage language, const char *name) {
      * here. __import__ loads a module and returns it. exec, eval, globals and
      * locals/vars are classified at the occurrence below. */
     static const char *const python[] = {"exec", "eval", "globals", NULL};
-    static const char *const lua[] = {"exec",     "eval",    "globals",    "locals",   "vars",
-                                      "setattr",  "delattr", "__import__", "__dict__", "load",
-                                      "loadfile", "dofile",  "loadstring", "setfenv",  "getfenv",
-                                      "debug",    "_ENV",    "_G",         "rawset",   NULL};
-    /* Lua environment operations have no special meaning in Python. */
-    return listed(name, language == CBM_LANG_LUA ? lua : python);
+    (void)language;
+    return listed(name, python);
 }
 
 /* An identifier is a lexical read only outside the member and keyword roles:
@@ -1129,19 +1101,6 @@ static bool python_namespace_view(cbm_resolve_binding_index_t *index, TSNode nod
     return !in_function && (ts_node_is_null(args) || ts_node_named_child_count(args) == 0);
 }
 
-static bool lua_local_function(TSNode node) {
-    if (!ts_node_is_null(field(node, "local_declaration"))) {
-        return true;
-    }
-    uint32_t children = ts_node_child_count(node);
-    for (uint32_t i = 0; i < children; i++) {
-        if (kind_is(ts_node_child(node, i), "local")) {
-            return true;
-        }
-    }
-    return false;
-}
-
 /* A name bound by `if TYPE_CHECKING:` exists only for annotations; the
  * extractor keeps that distinction and this audit leaves such names blocked. */
 static bool python_type_checking_import(cbm_resolve_binding_index_t *index, TSNode node) {
@@ -1276,7 +1235,7 @@ static void note_import(cbm_resolve_binding_index_t *index, TSNode node, bool ne
 }
 
 static void note_call(cbm_resolve_binding_index_t *index, TSNode node) {
-    TSNode callee = field(node, index->language == CBM_LANG_LUA ? "name" : "function");
+    TSNode callee = field(node, "function");
     if (kind_is(node, "new_expression")) {
         callee = field(node, "constructor");
     }
@@ -1306,6 +1265,9 @@ typedef struct {
     unsigned char js_binder, js_declaration, js_for_binder;
     bool js_type_level, js_ambient, js_body, js_no_site, js_this_prototype;
     const char *js_this_owner;
+    /* The module-level function a `return` here belongs to; NULL in anything nested. */
+    const char *js_function_name;
+    uint32_t js_function_start, js_function_end;
 } binding_walk_t;
 
 /* Function defaults/annotations and class bases execute in the enclosing
@@ -2926,27 +2888,37 @@ static void js_member_value(cbm_resolve_binding_index_t *index, js_member_t *row
 static void note_javascript_object_members(cbm_resolve_binding_index_t *index, const char *owner,
                                            TSNode object, bool prototype) {
     uint32_t count = ts_node_named_child_count(object);
+    /* A later key wins, so `{ ...base, m() {} }` has this m whatever base holds. A spread or a
+     * computed key can only replace what comes before it. */
+    uint32_t settled_from = 0;
+    for (uint32_t i = 0; i < count; i++) {
+        TSNode item = ts_node_named_child(object, i);
+        bool computed = kind_is(item, "spread_element") ||
+                        ((kind_is(item, "pair") || kind_is(item, "method_definition")) &&
+                         !kind_is(kind_is(item, "pair") ? field(item, "key") : field(item, "name"),
+                                  "property_identifier"));
+        if (computed)
+            settled_from = i + 1;
+    }
     for (uint32_t i = 0; i < count; i++) {
         TSNode item = ts_node_named_child(object, i);
         const char *member = NULL;
         js_member_t *row = NULL;
-        if (kind_is(item, "spread_element")) {
-            (void)js_member_row(index, owner, JS_MEMBER_COMPUTED, prototype);
-        } else if (kind_is(item, "shorthand_property_identifier")) {
+        if (kind_is(item, "shorthand_property_identifier")) {
             member = node_text(index, item);
             row = js_member_row(index, owner, member, prototype);
-            if (row)
+            if (row) {
                 row->local = member;
+                row->conflict = i < settled_from;
+            }
         } else if (kind_is(item, "pair") || kind_is(item, "method_definition")) {
             TSNode key = kind_is(item, "pair") ? field(item, "key") : field(item, "name");
-            if (!kind_is(key, "property_identifier")) {
-                (void)js_member_row(index, owner, JS_MEMBER_COMPUTED, prototype);
+            if (!kind_is(key, "property_identifier"))
                 continue;
-            }
             member = node_text(index, key);
             row = js_member_row(index, owner, member, prototype);
             /* `get m()` runs on the read; what a call then invokes is its return value. */
-            if (row && (child_token(item, "get") || child_token(item, "set")))
+            if (row && (i < settled_from || child_token(item, "get") || child_token(item, "set")))
                 row->conflict = true;
             else if (row)
                 js_member_value(index, row, kind_is(item, "pair") ? field(item, "value") : item,
@@ -3546,6 +3518,43 @@ static const char *js_require_pattern_member(cbm_resolve_binding_index_t *index,
     return member;
 }
 
+/* The `variable_declarator` whose pattern this name sits in, however deep. */
+static TSNode js_pattern_declarator(TSNode node) {
+    for (TSNode at = ts_node_parent(node); !ts_node_is_null(at); at = ts_node_parent(at)) {
+        if (kind_is(at, "variable_declarator"))
+            return at;
+        if (!kind_is(at, "object_pattern") && !kind_is(at, "array_pattern") &&
+            !kind_is(at, "pair_pattern") && !kind_is(at, "object_assignment_pattern") &&
+            !kind_is(at, "assignment_pattern") && !kind_is(at, "rest_pattern"))
+            break;
+    }
+    return (TSNode){0};
+}
+
+/* `const { m, n: x } = f()`: the pattern's own member of one plain call. */
+static void js_note_destructured_call(cbm_resolve_binding_index_t *index, binding_name_t *row,
+                                      TSNode node, TSNode declarator) {
+    TSNode value = js_unwrap_value(field(declarator, "value"));
+    TSNode callee = kind_is(value, "call_expression") ? field(value, "function") : (TSNode){0};
+    if (!kind_is(callee, "identifier") || child_token(value, "optional_chain"))
+        return;
+    TSNode pattern = ts_node_parent(node);
+    const char *member = NULL;
+    if (kind_is(node, "shorthand_property_identifier_pattern") &&
+        kind_is(pattern, "object_pattern")) {
+        member = row->name;
+    } else if (kind_is(pattern, "pair_pattern") && ts_node_eq(node, field(pattern, "value")) &&
+               kind_is(field(pattern, "key"), "property_identifier")) {
+        member = node_text(index, field(pattern, "key"));
+        pattern = ts_node_parent(pattern);
+    }
+    if (!member || !kind_is(pattern, "object_pattern") ||
+        !ts_node_eq(pattern, field(declarator, "name")))
+        return;
+    row->js_call_callee = node_text(index, callee);
+    row->js_call_member = member;
+}
+
 static void note_javascript_binder(cbm_resolve_binding_index_t *index, TSNode node,
                                    const char *name, const binding_walk_t *state) {
     if (state->js_binder == JS_BINDER_WRITE) {
@@ -3602,6 +3611,23 @@ static void note_javascript_binder(cbm_resolve_binding_index_t *index, TSNode no
         js_set_lines(index, row, declarator);
         if (index->name_count > row)
             index->names[row].at_start = ts_node_start_byte(declarator);
+    } else if (!direct && !ts_node_is_null(js_pattern_declarator(node))) {
+        /* `const { a, b: c } = f()`: the name is declared here, whatever the value turns out
+         * to be, so a read of it names this variable. Calling it stays with what it holds.
+         * Only module level has a Variable node to name. */
+        TSNode whole = js_pattern_declarator(node);
+        bool is_const = kind_is(ts_node_parent(whole), "lexical_declaration") &&
+                        child_token(ts_node_parent(whole), "const");
+        add_name(index, name, ts_node_end_byte(whole),
+                 !module_level ? BINDING_BLOCKED
+                               : BINDING_VALUE_DECLARATION | (is_const ? BINDING_CONST_VALUE : 0));
+        if (module_level)
+            js_set_lines(index, row, whole);
+        if (index->name_count > row) {
+            index->names[row].at_start = ts_node_start_byte(whole);
+            if (is_const)
+                js_note_destructured_call(index, &index->names[row], node, whole);
+        }
     } else {
         add_name(index, name, 0, BINDING_BLOCKED);
         if (direct && kind_is(value, "this") && state->js_this_owner && index->name_count > row) {
@@ -3635,6 +3661,92 @@ static bool javascript_named_function_scope_kind(const char *kind) {
     return !strcmp(kind, "function_expression") || !strcmp(kind, "generator_function");
 }
 
+static js_returned_t *js_returned_row(cbm_resolve_binding_index_t *index,
+                                      const binding_walk_t *state, const char *member) {
+    js_returned_t *items = grow_array(index, index->js_returned, index->js_returned_count,
+                                      &index->js_returned_capacity, sizeof(*items));
+    if (!items)
+        return NULL;
+    index->js_returned = items;
+    js_returned_t *row = &items[index->js_returned_count++];
+    *row = (js_returned_t){.function_name = state->js_function_name,
+                           .function_start = state->js_function_start,
+                           .function_end = state->js_function_end,
+                           .member = member,
+                           .scope = state->scope};
+    return row;
+}
+
+static void js_returned_function(js_returned_t *row, TSNode value, const char *name) {
+    row->value_name = name;
+    row->value_start = ts_node_start_point(value).row + 1;
+    row->value_end = ts_node_end_point(value).row + 1;
+}
+
+/* What a module-level function returns. A later key wins, so only a spread or a computed key can
+ * take a member from what is spelled before it. */
+static void js_note_returned(cbm_resolve_binding_index_t *index, TSNode value,
+                             const binding_walk_t *state) {
+    if (!kind_is(value, "object")) {
+        (void)js_returned_row(index, state, NULL);
+        return;
+    }
+    size_t first = index->js_returned_count;
+    TSTreeCursor cursor = ts_tree_cursor_new(value);
+    if (ts_tree_cursor_goto_first_child(&cursor)) {
+        do {
+            TSNode item = ts_tree_cursor_current_node(&cursor);
+            if (!ts_node_is_named(item) || kind_is(item, "comment"))
+                continue;
+            TSNode key = kind_is(item, "pair")                ? field(item, "key")
+                         : kind_is(item, "method_definition") ? field(item, "name")
+                                                              : (TSNode){0};
+            if (kind_is(item, "shorthand_property_identifier")) {
+                const char *member = node_text(index, item);
+                js_returned_t *row = js_returned_row(index, state, member);
+                if (row)
+                    row->local = member;
+            } else if (kind_is(key, "property_identifier")) {
+                const char *member = node_text(index, key);
+                js_returned_t *row = js_returned_row(index, state, member);
+                TSNode held = kind_is(item, "pair") ? js_unwrap_value(field(item, "value")) : item;
+                if (!row)
+                    continue;
+                if (kind_is(held, "identifier"))
+                    row->local = node_text(index, held);
+                else if (kind_is(item, "pair") && js_function_value(held))
+                    js_returned_function(row, held, member);
+                else if (kind_is(item, "method_definition") && !child_token(item, "get") &&
+                         !child_token(item, "set"))
+                    js_returned_function(row, held, member);
+                else
+                    row->conflict = true;
+            } else {
+                for (size_t r = first; r < index->js_returned_count; r++)
+                    index->js_returned[r].conflict = true;
+            }
+        } while (ts_tree_cursor_goto_next_sibling(&cursor));
+    }
+    ts_tree_cursor_delete(&cursor);
+}
+
+/* A module-level function, by the name and lines its extracted definition has. */
+static void js_enter_function(cbm_resolve_binding_index_t *index, TSNode node,
+                              binding_walk_t *state) {
+    state->js_function_name = NULL;
+    if (state->scope != 0)
+        return;
+    TSNode name = field(node, "name");
+    TSNode parent = ts_node_is_null(name) ? ts_node_parent(node) : (TSNode){0};
+    if (kind_is(parent, "variable_declarator") && ts_node_eq(node, field(parent, "value")))
+        name = field(parent, "name");
+    if (!kind_is(name, "identifier"))
+        return;
+    state->js_function_name = node_text(index, name);
+    state->js_function_start = ts_node_start_point(node).row + 1;
+    state->js_function_end = ts_node_end_point(node).row + 1;
+}
+
 static binding_walk_t note_javascript_node(cbm_resolve_binding_index_t *index, TSNode node,
                                            const char *parent_kind, const char *field_name,
                                            unsigned depth, binding_walk_t state) {
@@ -3742,7 +3854,12 @@ static binding_walk_t note_javascript_node(cbm_resolve_binding_index_t *index, T
         state.js_no_site = true;
     }
 
+    if (kind_is(node, "return_statement") && state.js_function_name &&
+        ts_node_named_child_count(node))
+        js_note_returned(index, js_unwrap_value(ts_node_named_child(node, 0)), &state);
+
     if (javascript_runtime_function(node)) {
+        js_enter_function(index, node, &state);
         javascript_this_owner(index, node, &state);
         index->current_this_owner = state.js_this_owner;
         index->current_this_prototype = state.js_this_prototype;
@@ -3756,6 +3873,11 @@ static binding_walk_t note_javascript_node(cbm_resolve_binding_index_t *index, T
         index->current_scope = state.scope;
         state.js_body = true;
         state.named_export = false;
+        if (state.js_function_name && kind_is(node, "arrow_function")) {
+            TSNode body = js_unwrap_value(field(node, "body"));
+            if (!kind_is(body, "statement_block"))
+                js_note_returned(index, body, &state);
+        }
         /* A function expression's own name is visible only inside it. */
         if (javascript_named_function_scope_kind(kind)) {
             const char *text = node_text(index, field(node, "name"));
@@ -4564,8 +4686,7 @@ static binding_walk_t note_node(cbm_resolve_binding_index_t *index, TSNode node,
         bool decorated = index->language == CBM_LANG_PYTHON && parent_kind &&
                          !strcmp(parent_kind, "decorated_definition");
         bool supported =
-            kind_is(name, "identifier") && !decorated &&
-            (index->language == CBM_LANG_PYTHON || (depth == 1 && lua_local_function(node)));
+            kind_is(name, "identifier") && !decorated && index->language == CBM_LANG_PYTHON;
         if (!ts_node_is_null(name)) {
             const char *text = node_text(index, name);
             add_name(index, text, ts_node_start_byte(node),
@@ -4793,6 +4914,23 @@ static bool js_row_in_space(const binding_name_t *row, js_space_t space) {
     return true;
 }
 
+/* Markup assigning a script's `let` or function rebinds it like a script write would. Assigning
+ * a const is the compiler's unref, `x.value = v`, which leaves the const's value in place. */
+static void js_note_markup_writes(cbm_resolve_binding_index_t *index) {
+    for (size_t w = 0; w < index->markup_write_count; w++) {
+        const char *name = index->markup_writes[w];
+        size_t high = 0;
+        size_t low = js_name_range(index, name, strlen(name), 0, &high);
+        for (size_t r = low; r < high; r++) {
+            const binding_name_t *row = &index->names[r];
+            if (js_row_in_space(row, JS_SPACE_VALUE) && !(row->flags & BINDING_CONST_VALUE)) {
+                js_write(index, name, 0);
+                break;
+            }
+        }
+    }
+}
+
 static void js_apply_writes(cbm_resolve_binding_index_t *index) {
     size_t missing = 0;
     for (size_t w = 0; w < index->js_write_count; w++) {
@@ -5214,6 +5352,112 @@ static void js_settle_members(cbm_resolve_binding_index_t *index) {
     }
 }
 
+static const binding_name_t *find_lexical_name(const cbm_resolve_binding_index_t *index,
+                                               const char *name, size_t length, uint32_t scope,
+                                               cbm_resolve_lookup_t *query, js_space_t space);
+
+static int js_compare_returned(const void *left, const void *right) {
+    const js_returned_t *a = left, *b = right;
+    int order = strcmp(a->function_target ? a->function_target : "",
+                       b->function_target ? b->function_target : "");
+    if (order)
+        return order;
+    /* The rows that leave the whole function open come first. */
+    return strcmp(a->member ? a->member : "", b->member ? b->member : "");
+}
+
+/* What each function's `return` statements agree a member holds. */
+static void js_settle_returned(cbm_resolve_binding_index_t *index) {
+    int definitions = index->result->defs.count;
+    if (!index->js_returned_count || !definitions ||
+        index->analysis != CBM_RESOLVE_ANALYSIS_COMPLETE)
+        return;
+    const CBMDefinition **sorted =
+        cbm_arena_alloc(index->arena, (size_t)definitions * sizeof(*sorted));
+    if (!sorted) {
+        fail_index(index, CBM_RESOLVE_ANALYSIS_FAILED, "binding_member_allocation");
+        return;
+    }
+    for (int d = 0; d < definitions; d++)
+        sorted[d] = &index->result->defs.items[d];
+    qsort(sorted, (size_t)definitions, sizeof(*sorted), js_compare_definition);
+    for (size_t r = 0; r < index->js_returned_count; r++) {
+        js_returned_t *row = &index->js_returned[r];
+        js_raw_export_t function = {.function_name = row->function_name,
+                                    .start_line = row->function_start,
+                                    .end_line = row->function_end};
+        row->function_target = js_function_target(index, sorted, &function);
+        if (!row->member || row->conflict)
+            continue;
+        if (row->value_name) {
+            js_raw_export_t value = {.function_name = row->value_name,
+                                     .start_line = row->value_start,
+                                     .end_line = row->value_end};
+            row->target = js_function_target(index, sorted, &value);
+        } else if (row->local) {
+            const binding_name_t *binding = find_lexical_name(index, row->local, strlen(row->local),
+                                                              row->scope, NULL, JS_SPACE_VALUE);
+            if (binding && !(binding->flags & BINDING_BLOCKED) &&
+                (binding->flags & BINDING_DECLARATION))
+                row->target = binding->target;
+        }
+    }
+    qsort(index->js_returned, index->js_returned_count, sizeof(*index->js_returned),
+          js_compare_returned);
+    const char *open_function = NULL;
+    for (size_t r = 0; r < index->js_returned_count;) {
+        js_returned_t *row = &index->js_returned[r];
+        size_t next = r + 1;
+        bool same = row->target != NULL;
+        while (next < index->js_returned_count &&
+               !js_compare_returned(row, &index->js_returned[next])) {
+            const char *other = index->js_returned[next].target;
+            same = same && other && !strcmp(row->target, other);
+            next++;
+        }
+        if (!row->member)
+            open_function = row->function_target;
+        bool open = !same || !row->function_target ||
+                    (open_function && !strcmp(open_function, row->function_target));
+        for (size_t at = r; at < next; at++)
+            index->js_returned[at].target = open ? NULL : row->target;
+        r = next;
+    }
+}
+
+bool cbm_resolve_binding_js_returned_member_at(const cbm_resolve_binding_index_t *index,
+                                               size_t offset, const char **function,
+                                               const char **member, const char **target) {
+    if (!index || !javascript_language(index->language) ||
+        index->analysis != CBM_RESOLVE_ANALYSIS_COMPLETE || offset >= index->js_returned_count)
+        return false;
+    const js_returned_t *row = &index->js_returned[offset];
+    *function = row->function_target;
+    *member = row->member;
+    *target = row->target;
+    return true;
+}
+
+bool cbm_resolve_binding_js_literal_member_at(const cbm_resolve_binding_index_t *index,
+                                              size_t offset, const char **owner,
+                                              const char **member, const char **target) {
+    if (!index || !javascript_language(index->language) ||
+        index->analysis != CBM_RESOLVE_ANALYSIS_COMPLETE || offset >= index->js_member_count)
+        return false;
+    const js_member_t *row = &index->js_members[offset];
+    bool conflict = false;
+    const binding_name_t *holder = js_module_row(index, row->owner, JS_SPACE_VALUE, &conflict);
+    js_member_t computed = {.owner = row->owner, .member = JS_MEMBER_COMPUTED};
+    bool open = !holder || conflict || (holder->flags & (BINDING_BLOCKED | BINDING_WRITTEN)) ||
+                holder->js_import || row->conflict || row->prototype ||
+                bsearch(&computed, index->js_members, index->js_member_count,
+                        sizeof(*index->js_members), js_compare_member);
+    *owner = holder ? holder->target : NULL;
+    *member = row->member;
+    *target = open ? NULL : row->target;
+    return true;
+}
+
 bool cbm_resolve_binding_js_exports_complete(const cbm_resolve_binding_index_t *index) {
     return index && javascript_language(index->language) &&
            index->analysis == CBM_RESOLVE_ANALYSIS_COMPLETE && !index->js_exports_open;
@@ -5652,8 +5896,8 @@ static cbm_resolve_binding_index_t *binding_build(CBMArena *arena, const CBMFile
         return index;
     }
     bool component = language == CBM_LANG_VUE || language == CBM_LANG_SVELTE;
-    if (language != CBM_LANG_PYTHON && language != CBM_LANG_LUA && language != CBM_LANG_DART &&
-        language != CBM_LANG_RUST && !javascript_language(language) && !component) {
+    if (language != CBM_LANG_PYTHON && language != CBM_LANG_DART && language != CBM_LANG_RUST &&
+        !javascript_language(language) && !component) {
         return index;
     }
     if (!result || !source || !result->module_qn || source_len > UINT32_MAX || result->has_error ||
@@ -5695,7 +5939,11 @@ static cbm_resolve_binding_index_t *binding_build(CBMArena *arena, const CBMFile
                               .language = language,
                               .module_qn = result->module_qn,
                               .root = ts_tree_root_node(tree)};
+        const char **markup_writes = NULL;
+        size_t markup_write_count = cbm_component_template_writes(&host, &markup_writes);
         TSTree *script = cbm_component_binding_tree(&host, &language, &range);
+        index->markup_writes = markup_writes;
+        index->markup_write_count = markup_write_count;
         if (owned_tree)
             ts_tree_delete(owned_tree);
         tree = owned_tree = script;
@@ -5762,10 +6010,12 @@ static cbm_resolve_binding_index_t *binding_build(CBMArena *arena, const CBMFile
             python_refuse_class_comprehension_reads(index);
     }
     if (javascript_language(language)) {
+        js_note_markup_writes(index);
         js_apply_writes(index);
         audit_javascript_values(index);
         js_settle_exports(index);
         js_settle_members(index);
+        js_settle_returned(index);
         js_settle_constructors(index);
     }
     /* An explicit replacement of annotation storage can invoke user code
@@ -6158,6 +6408,37 @@ const cbm_resolve_js_import_t *cbm_resolve_binding_js_import(
 static const js_member_t *js_site_member(const cbm_resolve_binding_index_t *index, const char *name,
                                          const binding_site_t *site, cbm_resolve_lookup_t *query);
 
+bool cbm_resolve_binding_js_destructured_call(const cbm_resolve_binding_index_t *index,
+                                              const char *name, uint32_t start, uint32_t end,
+                                              CBMSourceOrigin origin,
+                                              const cbm_resolve_js_import_t **import,
+                                              const char **callee, const char **function,
+                                              const char **member) {
+    if (!index || !javascript_language(index->language) ||
+        index->analysis != CBM_RESOLVE_ANALYSIS_COMPLETE || !name ||
+        origin != CBM_SOURCE_ORIGIN_RAW || end <= start || !index->sites || !index->site_count)
+        return false;
+    binding_site_t key = {.name = name, .start = start, .end = end};
+    const binding_site_t *site =
+        bsearch(&key, index->sites, index->site_count, sizeof(*index->sites), compare_site);
+    if (!site || site->member_path || !site->invocation)
+        return false;
+    const binding_name_t *binding =
+        find_lexical_name(index, name, strlen(name), site->scope, NULL, JS_SPACE_VALUE);
+    if (!binding || !binding->js_call_member)
+        return false;
+    const binding_name_t *called =
+        find_lexical_name(index, binding->js_call_callee, strlen(binding->js_call_callee),
+                          binding->scope, NULL, JS_SPACE_VALUE);
+    if (!called || (called->flags & BINDING_BLOCKED))
+        return false;
+    *import = called->js_import;
+    *callee = binding->js_call_callee;
+    *function = (called->flags & BINDING_DECLARATION) ? called->target : NULL;
+    *member = binding->js_call_member;
+    return *import || *function;
+}
+
 bool cbm_resolve_binding_js_declaration_lines(const cbm_resolve_binding_index_t *index,
                                               const char *name, uint32_t start, uint32_t end,
                                               CBMSourceOrigin origin, uint32_t *start_line,
@@ -6263,6 +6544,11 @@ cbm_resolve_result_t cbm_resolve_binding_validate(const cbm_resolve_binding_inde
         find_lexical_name(index, spelled, root_length, located->scope, &query, space);
     /* `import type` names a type, so a type position may use it. */
     bool type_import = binding && located->type_position && (binding->flags & BINDING_TYPE_IMPORT);
+    /* `const { m } = f(); m()`: f's returned m, which the caller established. */
+    bool returned_member = ecma && !dot && binding && binding->js_call_member &&
+                           candidate.rule == CBM_RESOLVE_RULE_IMPORT_BINDING &&
+                           (prior_facts & CBM_RESOLVE_FACT_IMPORT_BOUND) &&
+                           (prior_facts & CBM_RESOLVE_FACT_LOOKUP_COMPLETE);
     /* A later declaration binds a closure that runs after it, in any scope but
      * its own and never inside its own initializer. */
     bool too_early = binding && start < binding->at &&
@@ -6276,8 +6562,9 @@ cbm_resolve_result_t cbm_resolve_binding_validate(const cbm_resolve_binding_inde
                        candidate.rule == CBM_RESOLVE_RULE_IMPORT_BINDING &&
                        (prior_facts & CBM_RESOLVE_FACT_IMPORT_BOUND) &&
                        (prior_facts & CBM_RESOLVE_FACT_LOOKUP_COMPLETE);
-    if (!dart_import && (!binding || ((binding->flags & BINDING_BLOCKED) && !type_import) ||
-                         (too_early && !python_deferred_site(index, located, binding)))) {
+    if (!dart_import &&
+        (!binding || ((binding->flags & BINDING_BLOCKED) && !type_import && !returned_member) ||
+         (too_early && !python_deferred_site(index, located, binding)))) {
         candidate.reason = "binding_shadowed_or_unavailable";
         return binding_query_finish(index, &query, candidate);
     }
@@ -6288,7 +6575,7 @@ cbm_resolve_result_t cbm_resolve_binding_validate(const cbm_resolve_binding_inde
             return binding_query_finish(index, &query, candidate);
         }
     }
-    if (binding && (binding->flags & BINDING_VALUE_DECLARATION) &&
+    if (binding && (binding->flags & BINDING_VALUE_DECLARATION) && !returned_member &&
         (located->invocation ||
          (prior_facts & (CBM_RESOLVE_FACT_CALLABLE_TYPED | CBM_RESOLVE_FACT_RECEIVER_TYPED |
                          CBM_RESOLVE_FACT_TYPE_BOUND | CBM_RESOLVE_FACT_CLASS_CALLABLE)))) {
@@ -6303,7 +6590,7 @@ cbm_resolve_result_t cbm_resolve_binding_validate(const cbm_resolve_binding_inde
                binding->target && strcmp(binding->target, candidate.target) == 0) {
         candidate.facts |= CBM_RESOLVE_FACT_SCOPE_BOUND;
     } else if (candidate.rule == CBM_RESOLVE_RULE_IMPORT_BINDING &&
-               ((binding->flags & BINDING_IMPORT) || type_import) &&
+               ((binding->flags & BINDING_IMPORT) || type_import || returned_member) &&
                (prior_facts & CBM_RESOLVE_FACT_IMPORT_BOUND) &&
                (prior_facts & CBM_RESOLVE_FACT_LOOKUP_COMPLETE)) {
         candidate.facts |= CBM_RESOLVE_FACT_SCOPE_BOUND;
diff --git a/internal/cbm/resolve/binding.h b/internal/cbm/resolve/binding.h
index 859b8be03..e5c92632e 100644
--- a/internal/cbm/resolve/binding.h
+++ b/internal/cbm/resolve/binding.h
@@ -158,6 +158,25 @@ const cbm_resolve_js_import_t *cbm_resolve_binding_js_import(const cbm_resolve_b
 cbm_resolve_result_t cbm_resolve_binding_js_member(const cbm_resolve_binding_index_t *,
                                                    const char *name, uint32_t start, uint32_t end,
                                                    CBMSourceOrigin origin);
+/* The module-level object literals of this file, member by member, for another file's `x.m()`
+ * through an import of `x`: QN of x, the member's name, and the declaration it holds. False past
+ * the end; a member with no one declaration, or whose owner is written, reports a NULL target. */
+bool cbm_resolve_binding_js_literal_member_at(const cbm_resolve_binding_index_t *, size_t offset,
+                                              const char **owner, const char **member,
+                                              const char **target);
+/* The members of `return { ... }` in this file's module-level functions, for another file's
+ * `const { m } = f(); m()`: QN of f, the member's name, and the declaration every return gives it.
+ * False past the end; a member with no one declaration reports a NULL target. */
+bool cbm_resolve_binding_js_returned_member_at(const cbm_resolve_binding_index_t *, size_t offset,
+                                               const char **function, const char **member,
+                                               const char **target);
+/* This invocation calls a const destructured from one plain call: `const { m: x } = f(); x()`.
+ * f is an import or a declaration of this file; member is m. */
+bool cbm_resolve_binding_js_destructured_call(const cbm_resolve_binding_index_t *, const char *name,
+                                              uint32_t start, uint32_t end, CBMSourceOrigin origin,
+                                              const cbm_resolve_js_import_t **import,
+                                              const char **callee, const char **function,
+                                              const char **member);
 /* This occurrence names a type, in a type annotation or as its `Ns` path root. */
 bool cbm_resolve_binding_js_type_occurrence(const cbm_resolve_binding_index_t *, const char *name,
                                             uint32_t start, uint32_t end, CBMSourceOrigin origin);
diff --git a/internal/cbm/resolve/capabilities.c b/internal/cbm/resolve/capabilities.c
index c89ee2ba3..5a43214a8 100644
--- a/internal/cbm/resolve/capabilities.c
+++ b/internal/cbm/resolve/capabilities.c
@@ -53,12 +53,12 @@ static const edge_row_t edge_rows[] = {
      "entries abstain."},
     {CBM_LANG_ARKTS, SOURCE_EDGES,
      "Source JavaScript-style imports only; containing-language typed dispatch is unsupported."},
-    {CBM_LANG_VUE, CALLABLE_EDGES,
-     "One inline script with audited lexical bindings and an inert template; multiple script "
-     "contexts, template effects and external script sources abstain."},
-    {CBM_LANG_SVELTE, CALLABLE_EDGES,
-     "One inline script with audited lexical bindings; only static markup and bare-identifier "
-     "event references are supported. Multiple contexts and template effects abstain."},
+    {CBM_LANG_VUE, SOURCE_EDGES | EDGE(WRITES) | EDGE(USES_TYPE),
+     "Inline scripts as one module under the ECMAScript resolver; an external script source and "
+     "an unparsed script language abstain, and expressions in the template are not occurrences."},
+    {CBM_LANG_SVELTE, SOURCE_EDGES | EDGE(WRITES) | EDGE(USES_TYPE),
+     "Inline scripts as one module under the ECMAScript resolver; an external script source and "
+     "an unparsed script language abstain, and expressions in markup are not occurrences."},
     {CBM_LANG_PYTHON, SOURCE_EDGES | EDGE(WRITES) | EDGE(USES_TYPE),
      "Static project imports from the file's own search path, reexports and closed star imports; "
      "dynamic imports, unknown star sources and competing search-path candidates abstain."},
@@ -107,7 +107,17 @@ static const edge_row_t edge_rows[] = {
      "pubspec's own name and path dependencies; declared and constructed receiver types, and "
      "class type arguments fixed in extends clauses, along class, mixin and superclass chains. "
      "Collection element types, conditional imports and part-of by library name abstain."},
-    {CBM_LANG_LUA, EDGE(CALLS), NULL},
+    {CBM_LANG_VIMSCRIPT, EDGE(CALLS), NULL},
+    {CBM_LANG_MAKEFILE, EDGE(USAGE), NULL},
+    {CBM_LANG_BASH, EDGE(IMPORTS) | EDGE(CALLS) | EDGE(USAGE),
+     "source of a literal path relative to the script's directory or the repository root; a path "
+     "computed at runtime abstains."},
+    {CBM_LANG_TCL, EDGE(IMPORTS) | EDGE(CALLS),
+     "source of a literal path relative to the script's directory or the repository root; a path "
+     "computed at runtime abstains."},
+    {CBM_LANG_LUA, EDGE(IMPORTS) | CALLABLE_EDGES | EDGE(USAGE),
+     "require of a literal found through package.path's default forms under the requiring file's "
+     "ancestors, or under one project lua/ root; other package.path entries abstain."},
     {CBM_LANG_CSS, EDGE(IMPORTS),
      "Top-level quoted literal imports before style rules, relative to the source stylesheet; "
      "URL functions, escaping, layer ordering and remote paths abstain."},
@@ -269,14 +279,11 @@ bool cbm_resolve_capabilities(CBMLanguage language, cbm_resolve_capabilities_t *
     case CBM_LANG_VUE:
     case CBM_LANG_SVELTE:
         out->adapter = "embedded_javascript_lexical";
-        out->proof_subsets = CBM_RESOLVE_CAP_SCOPE | CBM_RESOLVE_CAP_CALLABLE;
-        out->limitation = language == CBM_LANG_VUE
-                              ? "One inline script with audited lexical bindings and an inert "
-                                "template; multiple scripts, template effects and external script "
-                                "sources abstain."
-                              : "One inline script with audited lexical bindings; static markup "
-                                "and bare-identifier event references only. Multiple script "
-                                "contexts and template effects abstain.";
+        out->proof_subsets =
+            CBM_RESOLVE_CAP_SCOPE | CBM_RESOLVE_CAP_IMPORT_EXPORT | CBM_RESOLVE_CAP_CALLABLE;
+        out->limitation = "Inline scripts as one module under the ECMAScript resolver. Markup "
+                          "assignments rebind what they spell; expressions in markup are not "
+                          "occurrences, and an external script source abstains.";
         break;
     case CBM_LANG_GO:
         out->adapter = "go";
@@ -473,11 +480,37 @@ bool cbm_resolve_capabilities(CBMLanguage language, cbm_resolve_capabilities_t *
             "receiver types with class type arguments fixed by subclasses; collection "
             "element types and conditional imports abstain.";
         break;
+    case CBM_LANG_MAKEFILE:
+        out->adapter = "make_source";
+        out->proof_subsets = CBM_RESOLVE_CAP_SCOPE;
+        out->limitation = "Variables assigned in the file that reads them; included files, the "
+                          "environment and computed names abstain.";
+        break;
+    case CBM_LANG_VIMSCRIPT:
+        out->adapter = "vim_source";
+        out->proof_subsets = CBM_RESOLVE_CAP_SCOPE | CBM_RESOLVE_CAP_IMPORT_EXPORT;
+        out->limitation = "Script-local, autoload and global function namespaces by name prefix; "
+                          "dict functions and Funcrefs in variables abstain.";
+        break;
+    case CBM_LANG_BASH:
+        out->adapter = "shell_source";
+        out->proof_subsets = CBM_RESOLVE_CAP_SCOPE | CBM_RESOLVE_CAP_IMPORT_EXPORT;
+        out->limitation = "A script's functions and those of files it sources by a literal path; "
+                          "another script is another process, and computed commands abstain.";
+        break;
+    case CBM_LANG_TCL:
+        out->adapter = "tcl_source";
+        out->proof_subsets = CBM_RESOLVE_CAP_SCOPE | CBM_RESOLVE_CAP_IMPORT_EXPORT;
+        out->limitation = "A script's own procs, and procs of a file the project sources by a "
+                          "literal path; computed commands and renamed procs abstain.";
+        break;
     case CBM_LANG_LUA:
         out->adapter = "lua_source";
-        out->proof_subsets = CBM_RESOLVE_CAP_SCOPE;
-        out->limitation = "Direct local function bindings; runtime require/export and receiver "
-                          "type proofs unimplemented.";
+        out->proof_subsets = CBM_RESOLVE_CAP_SCOPE | CBM_RESOLVE_CAP_IMPORT_EXPORT |
+                             CBM_RESOLVE_CAP_MEMBER | CBM_RESOLVE_CAP_TYPE_FLOW;
+        out->limitation = "Lexical scope, the one global namespace, table members, require through "
+                          "package.path and metatable __index. A value with more than one "
+                          "assignment, computed keys and untyped parameters abstain.";
         break;
     case CBM_LANG_ARKTS:
         out->adapter = "javascript_source";
diff --git a/internal/cbm/resolve/source_adapter.c b/internal/cbm/resolve/source_adapter.c
index 6e0ab5285..7ac11949d 100644
--- a/internal/cbm/resolve/source_adapter.c
+++ b/internal/cbm/resolve/source_adapter.c
@@ -37,7 +37,9 @@ static const cbm_source_adapter_t *adapter_for(CBMLanguage language) {
         &cbm_source_adapter_php,     &cbm_source_adapter_elixir, &cbm_source_adapter_erlang,
         &cbm_source_adapter_perl,    &cbm_source_adapter_ruby,   &cbm_source_adapter_zig,
         &cbm_source_adapter_haskell, &cbm_source_adapter_ocaml,  &cbm_source_adapter_dart,
-        &cbm_source_adapter_swift,   &cbm_source_adapter_scala,
+        &cbm_source_adapter_swift,   &cbm_source_adapter_scala,  &cbm_source_adapter_lua,
+        &cbm_source_adapter_vim,     &cbm_source_adapter_shell,  &cbm_source_adapter_tcl,
+        &cbm_source_adapter_make,
     };
     for (size_t i = 0; i < sizeof(adapters) / sizeof(adapters[0]); i++)
         if (adapters[i]->language == language)
@@ -276,6 +278,44 @@ const char *cbm_source_def_qn(cbm_source_walk_t *walk, const char *name, uint32_
     return cbm_source_def_qn_label(walk, name, line, NULL);
 }
 
+const char *cbm_source_def_qn_at(cbm_source_walk_t *walk, const char *name, uint32_t line) {
+    if (!name || !source_def_index(walk))
+        return NULL;
+    for (const source_def_link_t *link = cbm_ht_get(walk->def_index, name); link; link = link->next)
+        if (link->def->start_line == line)
+            return link->def->qualified_name;
+    return NULL;
+}
+
+bool cbm_source_join_path(const char *directory, const char *relative, char *out, size_t capacity) {
+    char joined[1024];
+    int length =
+        snprintf(joined, sizeof(joined), "%s%s%s", directory, *directory ? "/" : "", relative);
+    if (length <= 0 || (size_t)length >= sizeof(joined) || (size_t)length >= capacity)
+        return false;
+    size_t used = 0;
+    for (char *part = joined; *part;) {
+        char *end = strchr(part, '/');
+        size_t size = end ? (size_t)(end - part) : strlen(part);
+        if (size == 2 && part[0] == '.' && part[1] == '.') {
+            if (!used)
+                return false;
+            while (used && out[used - 1] != '/')
+                used--;
+            if (used)
+                used--;
+        } else if (size && !(size == 1 && part[0] == '.')) {
+            if (used)
+                out[used++] = '/';
+            memcpy(out + used, part, size);
+            used += size;
+        }
+        part += size + (end ? 1 : 0);
+    }
+    out[used] = '\0';
+    return used > 0;
+}
+
 const char *cbm_source_table_intern(cbm_source_walk_t *walk, const char *text) {
     cbm_source_table_t *table = walk->writable;
     return text && table ? cbm_arena_strdup(&table->arena, text) : NULL;
@@ -473,8 +513,9 @@ static const char *source_gate(const cbm_source_adapter_t *adapter, const CBMFil
                                const char *source, size_t source_len) {
     if (!result || !source || !result->module_qn || source_len > UINT32_MAX)
         return "source_adapter_input_unavailable";
-    if (result->has_error || result->parse_unusable ||
-        (result->parse_incomplete && !adapter->contains_parse_damage))
+    if (!adapter->parse_errors_are_local &&
+        (result->has_error || result->parse_unusable ||
+         (result->parse_incomplete && !adapter->contains_parse_damage)))
         return "source_adapter_parse_incomplete";
     return NULL;
 }
@@ -586,6 +627,8 @@ static bool source_tree_usable(const cbm_source_adapter_t *adapter, TSTree *tree
     TSNode root = ts_tree_root_node(tree);
     if (!ts_node_has_error(root))
         return true;
+    if (adapter->parse_errors_are_local)
+        return true;
     if (!adapter->contains_parse_damage)
         return false;
     source_damage_scan_t scan = {
diff --git a/internal/cbm/resolve/source_adapter.h b/internal/cbm/resolve/source_adapter.h
index c11ca5992..fdd183ce3 100644
--- a/internal/cbm/resolve/source_adapter.h
+++ b/internal/cbm/resolve/source_adapter.h
@@ -38,6 +38,9 @@ bool cbm_source_adapter_supported(CBMLanguage language);
 /* All clauses and arities of one name share one graph node in this language, so
  * several same-QN definitions in one file are that one name, not a conflict. */
 bool cbm_source_adapter_one_name_one_node(CBMLanguage language);
+/* The next module name a project's `lua/` root gives this file, as a span of rel_path after
+ * from (NULL for the first): runtime/lua/vim/lsp.lua is `vim/lsp`. NULL when there is no other. */
+const char *cbm_lua_root_module(const char *rel_path, const char *from, size_t *length);
 /* Relations this language's adapter actually decides. Others stay unsupported. */
 bool cbm_source_adapter_decides_references(CBMLanguage language);
 /* This language keeps older binding rules, which decide what its adapter leaves. */
diff --git a/internal/cbm/resolve/source_adapter_internal.h b/internal/cbm/resolve/source_adapter_internal.h
index 81053a564..80b84bec7 100644
--- a/internal/cbm/resolve/source_adapter_internal.h
+++ b/internal/cbm/resolve/source_adapter_internal.h
@@ -96,6 +96,9 @@ typedef struct {
     /* optional: collects a file whose tree is unusable, when the adapter has another way to
      * read it. It sets walk->failure when it has none. */
     cbm_source_pass_fn collect_unusable;
+    /* A parse error costs this language only the commands inside it: no binding depends on
+     * the structure around an error, so the rest of the file still decides. */
+    bool parse_errors_are_local;
 } cbm_source_adapter_t;
 
 /* Per-language rule tables. A row here is what makes a language supported. */
@@ -110,6 +113,11 @@ extern const cbm_source_adapter_t cbm_source_adapter_ocaml;
 extern const cbm_source_adapter_t cbm_source_adapter_dart;
 extern const cbm_source_adapter_t cbm_source_adapter_swift;
 extern const cbm_source_adapter_t cbm_source_adapter_scala;
+extern const cbm_source_adapter_t cbm_source_adapter_lua;
+extern const cbm_source_adapter_t cbm_source_adapter_vim;
+extern const cbm_source_adapter_t cbm_source_adapter_shell;
+extern const cbm_source_adapter_t cbm_source_adapter_tcl;
+extern const cbm_source_adapter_t cbm_source_adapter_make;
 
 /* One walk of a class chain. A class appears once on a linearized chain, so a
  * revisit adds nothing: a cycle or a diamond cannot make the walk exponential. */
@@ -157,6 +165,12 @@ const char *cbm_source_def_qn(cbm_source_walk_t *walk, const char *name, uint32_
 const char *cbm_source_def_qn_of_name(cbm_source_walk_t *walk, const char *name);
 const char *cbm_source_def_qn_label(cbm_source_walk_t *walk, const char *name, uint32_t line,
                                     const char *label);
+/* The definition of this name that starts on exactly this line. For a language whose inner
+ * declaration may have no node of its own, where the enclosing one's span would also match. */
+const char *cbm_source_def_qn_at(cbm_source_walk_t *walk, const char *name, uint32_t line);
+
+/* directory/relative with `.` and `..` collapsed. False when it climbs above the repository. */
+bool cbm_source_join_path(const char *directory, const char *relative, char *out, size_t capacity);
 
 /* Phase one. Copies everything into the table; returns NULL on allocation failure. */
 cbm_source_decl_t *cbm_source_declare(cbm_source_walk_t *walk, const char *owner, const char *name,
diff --git a/src/pipeline/pass_lsp_cross.c b/src/pipeline/pass_lsp_cross.c
index 7cb40ba3e..dddca8f5e 100644
--- a/src/pipeline/pass_lsp_cross.c
+++ b/src/pipeline/pass_lsp_cross.c
@@ -22,6 +22,7 @@
 #include "resolve/snapshot.h"
 
 #include "callable_sig.h"
+#include "lang_specs.h"
 #include "foundation/compat.h" /* CBM_TLS */
 #include "foundation/compat_fs.h"
 #include "foundation/constants.h"
@@ -1756,8 +1757,9 @@ int cbm_pxc_build_import_map_ex(const cbm_pipeline_ctx_t *ctx, const char *rel_p
                                 const char ***out_vals, int *out_count) {
     const cbm_gbuf_t *gbuf = ctx->gbuf;
     const char *project_name = ctx->project_name;
-    if (result && (lang == CBM_LANG_JAVASCRIPT || lang == CBM_LANG_TYPESCRIPT ||
-                   lang == CBM_LANG_TSX || lang == CBM_LANG_ARKTS))
+    if (result &&
+        (lang == CBM_LANG_JAVASCRIPT || lang == CBM_LANG_TYPESCRIPT || lang == CBM_LANG_TSX ||
+         lang == CBM_LANG_ARKTS || lang == CBM_LANG_VUE || lang == CBM_LANG_SVELTE))
         return cbm_pipeline_ecma_import_map(ctx, rel_path, result, include_type_only, out_keys,
                                             out_vals, out_count);
     if (result && (lang == CBM_LANG_C || lang == CBM_LANG_CPP || lang == CBM_LANG_CUDA))
@@ -1956,6 +1958,8 @@ bool cbm_pxc_has_cross_lsp(CBMLanguage lang) {
     case CBM_LANG_JAVASCRIPT:
     case CBM_LANG_TYPESCRIPT:
     case CBM_LANG_TSX:
+    case CBM_LANG_VUE:    /* its script: see cbm_pxc_dispatch_file_with_imports */
+    case CBM_LANG_SVELTE: /* its script: see cbm_pxc_dispatch_file_with_imports */
     case CBM_LANG_PHP:
     case CBM_LANG_CSHARP: /* tier-2 prebuilt registry path (pass_parallel.c) */
     case CBM_LANG_JAVA:   /* fallback cbm_pxc_run_one path */
@@ -2828,6 +2832,39 @@ static void pxc_run_oo(CBMLanguage lang, CBMFileResult *result, const char *sour
     pxc_scratch_give(PXC_SCRATCH_DISPATCH, &scratch);
 }
 
+/* The parse of a component's scripts. It needs the host tree, which a retained result keeps. */
+static TSTree *pxc_component_script(CBMFileResult *result, CBMLanguage lang, const char *source,
+                                    int source_len, CBMLanguage *script_language) {
+    TSTree *host = result->cached_tree;
+    TSTree *owned = NULL;
+    if (!host) {
+        TSParser *parser = ts_parser_new();
+        if (parser && ts_parser_set_language(parser, cbm_ts_language(lang)))
+            owned = ts_parser_parse_string(parser, NULL, source, (uint32_t)source_len);
+        if (parser)
+            ts_parser_delete(parser);
+        host = owned;
+    }
+    if (!host)
+        return NULL;
+    CBMArena arena;
+    cbm_arena_init(&arena);
+    CBMExtractCtx context = {.arena = &arena,
+                             .result = result,
+                             .source = source,
+                             .source_len = source_len,
+                             .language = lang,
+                             .module_qn = result->module_qn,
+                             .root = ts_tree_root_node(host)};
+    TSRange range;
+    memset(&range, 0, sizeof(range));
+    TSTree *script = cbm_component_binding_tree(&context, script_language, &range);
+    cbm_arena_destroy(&arena);
+    if (owned)
+        ts_tree_delete(owned);
+    return script;
+}
+
 void cbm_pxc_dispatch_file_with_imports(CBMLanguage lang, CBMFileResult *result, const char *source,
                                         int source_len, const char *rel, const char *def_module,
                                         const CBMCrossLspRegistries *cross_registries,
@@ -2846,6 +2883,23 @@ void cbm_pxc_dispatch_file_with_imports(CBMLanguage lang, CBMFileResult *result,
     if (!result) {
         return;
     }
+    /* A component's script is a TypeScript or JavaScript module, in the original bytes: its
+     * walk is that language's, over the tree of the script alone. */
+    if (lang == CBM_LANG_VUE || lang == CBM_LANG_SVELTE) {
+        CBMLanguage script_language = CBM_LANG_JAVASCRIPT;
+        TSTree *script = pxc_component_script(result, lang, source, source_len, &script_language);
+        if (script) {
+            TSTree *host = result->cached_tree;
+            result->cached_tree = script;
+            cbm_pxc_dispatch_file_with_imports(
+                script_language, result, source, source_len, rel, def_module, cross_registries,
+                module_def_index, all_defs, all_def_count, imp_keys, imp_vals, imp_count,
+                rust_shared_get, rust_shared_ctx, bindings, imports);
+            result->cached_tree = host;
+            ts_tree_delete(script);
+        }
+        return;
+    }
     if (cross_registries && cross_registries->oo && cbm_oo_language(lang))
         pxc_run_oo(lang, result, source, source_len, rel, cross_registries->oo);
     /* Source occurrence identities use the extractor's file module, while
diff --git a/src/pipeline/pass_pkgmap.c b/src/pipeline/pass_pkgmap.c
index e1fb0d135..ac17bdac8 100644
--- a/src/pipeline/pass_pkgmap.c
+++ b/src/pipeline/pass_pkgmap.c
@@ -3863,6 +3863,16 @@ static bool source_module_facts(const cbm_file_info_t *files, int count, CBMFile
             if (length <= 0 || (size_t)length >= sizeof(module) ||
                 !source_module_put(map, "erlang_module", module, files[i].rel_path))
                 return false;
+        } else if (files[i].language == CBM_LANG_LUA) {
+            size_t size = 0;
+            for (const char *name = cbm_lua_root_module(files[i].rel_path, NULL, &size); name;
+                 name = cbm_lua_root_module(files[i].rel_path, name, &size)) {
+                char module[PKGMAP_PATH_BUF];
+                int length = snprintf(module, sizeof(module), "%.*s", (int)size, name);
+                if (length <= 0 || (size_t)length >= sizeof(module) ||
+                    !source_module_put(map, "lua_module", module, files[i].rel_path))
+                    return false;
+            }
         } else if (files[i].language == CBM_LANG_ELIXIR && cache && cache[i]) {
             const CBMFileResult *result = cache[i];
             for (int d = 0; d < result->defs.count; d++) {
@@ -5612,6 +5622,47 @@ static const cbm_gbuf_node_t *resolve_ancestor_lib_file(const cbm_pipeline_ctx_t
     }
 }
 
+/* `require('a.b')` searches package.path, whose default is `./?.lua;./?/init.lua`. The working
+ * directory is the requiring file's or an ancestor of it; the nearest one holding the file is
+ * the program it belongs to. */
+static const cbm_gbuf_node_t *resolve_lua_ancestor_module(const cbm_pipeline_ctx_t *ctx,
+                                                          const char *source_rel,
+                                                          const char *module) {
+    char *directory = path_dirname(source_rel ? source_rel : "");
+    char current[PKGMAP_PATH_BUF];
+    int length = directory ? snprintf(current, sizeof(current), "%s", directory) : -1;
+    cbm_free(CBM_MEM_CLASS_SEMANTIC, directory);
+    if (length < 0 || (size_t)length >= sizeof(current))
+        return NULL;
+    if (!strcmp(current, "."))
+        current[0] = '\0';
+    for (;;) {
+        char path[PKGMAP_PATH_BUF];
+        static const char *const forms[] = {"%s.lua", "%s/init.lua"};
+        for (size_t f = 0; f < sizeof(forms) / sizeof(forms[0]); f++) {
+            char leaf[PKGMAP_PATH_BUF];
+            int size = snprintf(leaf, sizeof(leaf), forms[f], module);
+            int written =
+                size > 0 && (size_t)size < sizeof(leaf)
+                    ? snprintf(path, sizeof(path), "%s%s%s", current, current[0] ? "/" : "", leaf)
+                    : -1;
+            const cbm_gbuf_node_t *found =
+                written > 0 && (size_t)written < sizeof(path)
+                    ? cbm_pipeline_file_node(ctx->gbuf, ctx->project_name, path)
+                    : NULL;
+            if (found)
+                return found;
+        }
+        if (!current[0])
+            return NULL;
+        char *slash = strrchr(current, '/');
+        if (slash)
+            *slash = '\0';
+        else
+            current[0] = '\0';
+    }
+}
+
 static const cbm_gbuf_node_t *resolve_source_module(const cbm_pipeline_ctx_t *ctx,
                                                     CBMHashTable *namespace_map, const char *kind,
                                                     const char *module, bool *ambiguous) {
@@ -5710,6 +5761,48 @@ static bool resolve_source_language_import(const cbm_pipeline_ctx_t *ctx, const
         *reason = "haskell_declared_module";
         *out = resolve_source_module(ctx, namespace_map, "haskell_module", path, ambiguous);
         return true;
+    case CBM_LANG_BASH:
+    case CBM_LANG_TCL:
+        /* A literal path is relative to the working directory: the script's or the repository's. */
+        *reason = "script_source_path_computed";
+        if (path[0] == '/' || strpbrk(path, "$[`"))
+            return true;
+        *reason = "script_source_literal_path";
+        directory = path_dirname(source_rel);
+        if (directory && cbm_repo_rel_join(directory, path, joined, sizeof(joined)))
+            *out = cbm_pipeline_file_node(ctx->gbuf, ctx->project_name, joined);
+        cbm_free(CBM_MEM_CLASS_SEMANTIC, directory);
+        if (!*out && cbm_repo_rel_join("", path, joined, sizeof(joined)))
+            *out = cbm_pipeline_file_node(ctx->gbuf, ctx->project_name, joined);
+        return true;
+    case CBM_LANG_LUA: {
+        char module[PKGMAP_PATH_BUF];
+        int length = snprintf(module, sizeof(module), "%s", path);
+        if (length <= 0 || (size_t)length >= sizeof(module)) {
+            *reason = "lua_module_name_too_long";
+            return true;
+        }
+        for (char *p = module; *p; p++)
+            if (*p == '.')
+                *p = '/';
+        /* The host preloads these in package.loaded: `require('os')` never reads an os.lua. */
+        static const char *const preloaded[] = {"string", "table", "math",     "io",  "os",
+                                                "debug",  "utf8",  "package",  "bit", "bit32",
+                                                "ffi",    "jit",   "coroutine"};
+        for (size_t p = 0; p < sizeof(preloaded) / sizeof(preloaded[0]); p++) {
+            if (!strcmp(module, preloaded[p])) {
+                *reason = "lua_require_of_a_preloaded_library";
+                return true;
+            }
+        }
+        *reason = "lua_require_package_path";
+        *out = resolve_lua_ancestor_module(ctx, source_rel, module);
+        if (!*out) {
+            *reason = "lua_require_lua_root";
+            *out = resolve_source_module(ctx, namespace_map, "lua_module", module, ambiguous);
+        }
+        return true;
+    }
     default:
         return false;
     }
diff --git a/src/pipeline/pass_resolver.c b/src/pipeline/pass_resolver.c
index 52ee5dfdc..aa092547c 100644
--- a/src/pipeline/pass_resolver.c
+++ b/src/pipeline/pass_resolver.c
@@ -205,6 +205,11 @@ struct cbm_shared_resolver {
     CBMHashTable *python_namespaces;
     bool python_unknown_namespace_escape;
     cbm_ecma_table_t *ecma;
+    /* QN of a module-level object literal + U+001F + member: the declaration it holds. */
+    CBMHashTable *ecma_literal_members;
+    /* QN of a module-level function + U+001F + member: what its `return { ... }` statements give.
+     */
+    CBMHashTable *ecma_returned_members;
     CBMHashTable *python_star_provided; /* "<module>.<name>" a closed star import binds */
     CBMHashTable *python_written;       /* "<module>.<path>" a statement stores or deletes */
     CBMHashTable *python_parent_loaded; /* a submodule its package's own __init__ loads */
@@ -2029,6 +2034,40 @@ static bool python_owner_pair_present(const cbm_shared_resolver_t *resolver,
     return false;
 }
 
+/* `export const store = { fetch() {} }`: what another file's `store.fetch()` selects. The table
+ * holds what this file's own `store.fetch()` would select, by the same member rule. */
+static bool ecma_note_literal_members(cbm_shared_resolver_t *resolver,
+                                      const cbm_resolve_binding_index_t *index) {
+    const char *owner = NULL, *member = NULL, *target = NULL;
+    for (size_t m = 0; cbm_resolve_binding_js_literal_member_at(index, m, &owner, &member, &target);
+         m++) {
+        if (!owner || !target)
+            continue;
+        const char *key = cbm_arena_sprintf(&resolver->arena, "%s\x1f%s", owner, member);
+        const char *value = cbm_arena_strdup(&resolver->arena, target);
+        if (!key || !value)
+            return false;
+        cbm_ht_set(resolver->ecma_literal_members, key, (void *)value);
+    }
+    return true;
+}
+
+static bool ecma_note_returned_members(cbm_shared_resolver_t *resolver,
+                                       const cbm_resolve_binding_index_t *index) {
+    const char *function = NULL, *member = NULL, *target = NULL;
+    for (size_t m = 0;
+         cbm_resolve_binding_js_returned_member_at(index, m, &function, &member, &target); m++) {
+        if (!function || !member || !target)
+            continue;
+        const char *key = cbm_arena_sprintf(&resolver->arena, "%s\x1f%s", function, member);
+        const char *value = cbm_arena_strdup(&resolver->arena, target);
+        if (!key || !value)
+            return false;
+        cbm_ht_set(resolver->ecma_returned_members, key, (void *)value);
+    }
+    return true;
+}
+
 static bool export_file(cbm_shared_resolver_t *resolver, const cbm_pipeline_ctx_t *ctx,
                         const CBMFileResult *result, const cbm_file_info_t *file) {
     if (!export_language(file->language))
@@ -2083,6 +2122,9 @@ static bool export_file(cbm_shared_resolver_t *resolver, const cbm_pipeline_ctx_
         ok = audit && cbm_ecma_table_add(resolver->ecma, ctx, file->rel_path, result->module_qn,
                                          index, audit);
     }
+    if (ok && ecma_language(file->language))
+        ok = ecma_note_literal_members(resolver, index) &&
+             ecma_note_returned_members(resolver, index);
     if (ok && (file->language == CBM_LANG_JAVASCRIPT || file->language == CBM_LANG_TYPESCRIPT ||
                file->language == CBM_LANG_TSX || file->language == CBM_LANG_ARKTS))
         ok = http_file_capture(resolver, ctx, &arena, index, result, file->rel_path);
@@ -3245,6 +3287,8 @@ cbm_shared_resolver_t *cbm_shared_resolver_build(const cbm_pipeline_ctx_t *ctx,
     resolver->go_types =
         cbm_go_stabilization_new(&resolver->arena, &resolver->proofs, resolver->solver);
     resolver->ecma = cbm_ecma_table_new(&resolver->arena);
+    resolver->ecma_literal_members = cbm_ht_create(64);
+    resolver->ecma_returned_members = cbm_ht_create(64);
     resolver->source_table = cbm_source_table_new();
     cbm_source_table_set_packages(resolver->source_table, cbm_pipeline_get_pkgmap());
     resolver->complete = true;
@@ -3254,7 +3298,9 @@ cbm_shared_resolver_t *cbm_shared_resolver_build(const cbm_pipeline_ctx_t *ctx,
         !resolver->python_parent_loaded || !resolver->python_nested || !resolver->python_members ||
         !resolver->http_defaults || !resolver->http_sites || !resolver->http_unsafe ||
         !resolver->http_candidates || !resolver->http_veto || !resolver->project ||
-        !resolver->solver || !resolver->go_types || !resolver->ecma || !resolver->source_table) {
+        !resolver->solver || !resolver->go_types || !resolver->ecma ||
+        !resolver->ecma_literal_members || !resolver->ecma_returned_members ||
+        !resolver->source_table) {
         cbm_shared_resolver_free(resolver);
         return NULL;
     }
@@ -3489,6 +3535,8 @@ void cbm_shared_resolver_free(cbm_shared_resolver_t *resolver) {
     cbm_ht_free(resolver->http_veto);
     cbm_go_stabilization_dispose(resolver->go_types);
     cbm_ecma_table_free(resolver->ecma);
+    cbm_ht_free(resolver->ecma_literal_members);
+    cbm_ht_free(resolver->ecma_returned_members);
     cbm_source_table_free(resolver->source_table);
     cbm_arena_destroy(&resolver->arena);
     cbm_free(CBM_MEM_CLASS_SEMANTIC, resolver);
@@ -4128,6 +4176,11 @@ static cbm_ecma_value_t ecma_import_value(const file_resolver_t *resolver,
  * declaration only by an exact member declared in the same file. */
 static const char *ecma_member_target(file_resolver_t *resolver, const char *owner,
                                       const char *member) {
+    const char *key = cbm_arena_sprintf(resolver->arena, "%s\x1f%s", owner, member);
+    const char *literal =
+        key && resolver->shared ? cbm_ht_get(resolver->shared->ecma_literal_members, key) : NULL;
+    if (literal)
+        return literal;
     const char *qn = cbm_arena_sprintf(resolver->arena, "%s.%s", owner, member);
     const cbm_gbuf_node_t *node = qn ? cbm_gbuf_find_by_qn(resolver->file->graph, qn) : NULL;
     const cbm_gbuf_node_t *base = cbm_gbuf_find_by_qn(resolver->file->graph, owner);
@@ -4251,6 +4304,44 @@ static cbm_resolve_result_t ecma_import_result(file_resolver_t *resolver,
     return ecma_finish(&query, result);
 }
 
+/* `const { open } = useThing(); open()`: what every `return { open }` of useThing names. */
+static bool ecma_returned_member_result(file_resolver_t *resolver, const char *name, uint32_t start,
+                                        uint32_t end, CBMSourceOrigin origin,
+                                        cbm_resolve_result_t *out) {
+    const cbm_resolve_js_import_t *import = NULL;
+    const char *callee = NULL, *function = NULL, *member = NULL;
+    if (!resolver->shared ||
+        !cbm_resolve_binding_js_destructured_call(resolver->bindings, name, start, end, origin,
+                                                  &import, &callee, &function, &member))
+        return false;
+    if (import)
+        function = ecma_import_result(resolver, import, callee, false, false).target;
+    const char *key =
+        function ? cbm_arena_sprintf(resolver->arena, "%s\x1f%s", function, member) : NULL;
+    const char *target = key ? cbm_ht_get(resolver->shared->ecma_returned_members, key) : NULL;
+    if (!target)
+        return false;
+    cbm_resolve_lookup_t query;
+    cbm_resolve_lookup_begin(&query, cbm_resolve_binding_lookup_context(resolver->bindings),
+                             "ecma.returned_member", name, 0, 0, CBM_SOURCE_ORIGIN_RAW);
+    (void)cbm_resolve_lookup_observe(&query, "ecma.returned_members", key, target,
+                                     CBM_RESOLVE_BINDING_UNIQUE, CBM_RESOLVE_ANALYSIS_COMPLETE, 0,
+                                     true, "ecma_returned_member_observed");
+    cbm_resolve_result_t found = {.binding = CBM_RESOLVE_BINDING_UNIQUE,
+                                  .domain = CBM_RESOLVE_DOMAIN_PROJECT,
+                                  .analysis = CBM_RESOLVE_ANALYSIS_COMPLETE,
+                                  .rule = CBM_RESOLVE_RULE_IMPORT_BINDING,
+                                  .facts = CBM_RESOLVE_FACT_EXACT_TARGET |
+                                           CBM_RESOLVE_FACT_LOOKUP_COMPLETE |
+                                           CBM_RESOLVE_FACT_IMPORT_BOUND,
+                                  .target = target,
+                                  .candidate_count = 1,
+                                  .reason = "ecma_returned_member"};
+    *out = cbm_resolve_binding_validate(resolver->bindings, name, start, end, origin,
+                                        ecma_finish(&query, found));
+    return cbm_resolve_admit(out);
+}
+
 static bool python_member_result(file_resolver_t *resolver, const char *name, uint32_t start,
                                  uint32_t end, CBMSourceOrigin origin, bool invocation,
                                  cbm_resolve_result_t *out) {
@@ -4300,6 +4391,10 @@ static cbm_resolve_result_t generic_result(file_resolver_t *resolver, const char
         return unresolved("reference_spelling_missing");
     if (ecma_language(file->language) || file->language == CBM_LANG_VUE ||
         file->language == CBM_LANG_SVELTE) {
+        cbm_resolve_result_t returned;
+        if (invocation &&
+            ecma_returned_member_result(resolver, name, start, end, origin, &returned))
+            return returned;
         cbm_resolve_result_t local =
             cbm_resolve_binding_local(resolver->bindings, name, start, end, origin);
         if (cbm_resolve_admit(&local))
diff --git a/tests/test_grammar_probe_e.c b/tests/test_grammar_probe_e.c
index 38462912d..edc0a349a 100644
--- a/tests/test_grammar_probe_e.c
+++ b/tests/test_grammar_probe_e.c
@@ -1133,23 +1133,19 @@ TEST(probe_vue_cross_component_import) {
         .case_id = "probe_vue_cross_component_import-exact-dependency",
         .site = {.file = "App.vue",
                  .caller = "App.vue.__file__",
-                 .needle = "import BaseButton from './BaseButton.vue'"},
+                 .needle = "BaseButton"},
         .relation = "IMPORTS",
         .target = {.file = "BaseButton.vue",
                    .suffix = "BaseButton.vue.__file__",
                    .label = "File",
                    .declaration_line = 1,
                    .declaration_text = "<template><button><slot /></button></template>"},
-        .mode = RQ_KNOWN_GAP,
-        .gap_id = "vue-embedded-component-import-proof",
-        .why = "Vue script imports need an audited embedded-source origin and raw literal proof.",
-        .tried = "Preserved original sources and indexing checks; exact target, wrong-target "
-                 "control, and required ESM call use full production indexing."};
+        .mode = RQ_REQUIRED};
     const RQ_Forbidden forbidden = {
         .case_id = "probe_vue_cross_component_import-invalid-target",
         .site = {.file = "App.vue",
                  .caller = "App.vue.__file__",
-                 .needle = "import BaseButton from './BaseButton.vue'"},
+                 .needle = "BaseButton"},
         .relation = "IMPORTS",
         .target = {.file = "decoy/BaseButton.vue",
                    .suffix = "decoy.BaseButton.vue.__file__",
@@ -1162,8 +1158,8 @@ TEST(probe_vue_cross_component_import) {
                                    "probe_vue_cross_component_import", &expected, &forbidden,
                                    &report));
     ASSERT_EQ(report.genuine, 2);
-    ASSERT_EQ(report.found, 1);
-    ASSERT_EQ(report.missing, 1);
+    ASSERT_EQ(report.found, 2);
+    ASSERT_EQ(report.missing, 0);
     PASS();
 }
 
@@ -1226,23 +1222,18 @@ TEST(probe_svelte_cross_component_import) {
         .case_id = "probe_svelte_cross_component_import-exact-dependency",
         .site = {.file = "App.svelte",
                  .caller = "App.svelte.__file__",
-                 .needle = "import Button from './Button.svelte';"},
+                 .needle = "Button"},
         .relation = "IMPORTS",
         .target = {.file = "Button.svelte",
                    .suffix = "Button.svelte.__file__",
                    .label = "File",
                    .declaration_line = 1,
                    .declaration_text = "<script>"},
-        .mode = RQ_KNOWN_GAP,
-        .gap_id = "svelte-embedded-component-import-proof",
-        .why =
-            "Svelte script imports need an audited embedded-source origin and raw literal proof.",
-        .tried = "Preserved original sources and indexing checks; exact target, wrong-target "
-                 "control, and required ESM call use full production indexing."};
+        .mode = RQ_REQUIRED};
     const RQ_Forbidden forbidden = {.case_id = "probe_svelte_cross_component_import-invalid-target",
                                     .site = {.file = "App.svelte",
                                              .caller = "App.svelte.__file__",
-                                             .needle = "import Button from './Button.svelte';"},
+                                             .needle = "Button"},
                                     .relation = "IMPORTS",
                                     .target = {.file = "decoy/Button.svelte",
                                                .suffix = "decoy.Button.svelte.__file__",
@@ -1255,8 +1246,8 @@ TEST(probe_svelte_cross_component_import) {
                                    "probe_svelte_cross_component_import", &expected, &forbidden,
                                    &report));
     ASSERT_EQ(report.genuine, 2);
-    ASSERT_EQ(report.found, 1);
-    ASSERT_EQ(report.missing, 1);
+    ASSERT_EQ(report.found, 2);
+    ASSERT_EQ(report.missing, 0);
     PASS();
 }
 
diff --git a/tests/test_grammar_probe_f.c b/tests/test_grammar_probe_f.c
index e4382d8b9..992831667 100644
--- a/tests/test_grammar_probe_f.c
+++ b/tests/test_grammar_probe_f.c
@@ -3629,9 +3629,8 @@ TEST(probe_mcp_trace_run) {
     PASS();
 }
 
-/* Deploy traversal follows retained DEPLOYS/SPAWNS edges and exact CALLS.
- * Its source-authored missing shell link is measured below; call-graph mode
- * still stops at the chart. */
+/* Deploy traversal follows retained DEPLOYS/SPAWNS edges and exact CALLS;
+ * call-graph mode still stops at the chart. */
 static int gpf_query_int(const GpfFile *files, int nfiles, const char *sql);
 
 TEST(probe_mcp_trace_deploy) {
@@ -3655,13 +3654,10 @@ TEST(probe_mcp_trace_deploy) {
                           "\"format\":\"json\"}");
     ASSERT_NOT_NULL(r);
     ASSERT_NOT_NULL(strstr(r, "install_web"));
-    /* WHY: deploy mode reaches the installing function through DEPLOYS. The
-     * exact script-to-function CALLS gap below prevents reaching the script
-     * and its CI caller; it must not be bridged by a guessed graph edge. Tried
-     * the unchanged source plus direct deployment/run edge checks. */
-    ASSERT_NULL(strstr(r, ".hack\""));
-    ASSERT_NULL(strstr(r, ".github.workflows\""));
-    ASSERT_NULL(strstr(r, "\"release\""));
+    /* Deploy mode reaches the installing function through DEPLOYS, the script through its own
+     * proven call of that function, and the CI job through SPAWNS. */
+    ASSERT_NOT_NULL(strstr(r, ".hack\""));
+    ASSERT_NOT_NULL(strstr(r, "\"release\""));
     free(r);
     r = gpf_tool_on(files, 3, "trace_path",
                     "{\"function_name\":\"web-app\",\"project\":\"%s\","
@@ -3670,7 +3666,7 @@ TEST(probe_mcp_trace_deploy) {
     ASSERT_NULL(strstr(r, "install_web"));
     free(r);
     /* Preserve the two direct non-controlled relations independently of the
-     * missing shell CALLS edge and the consumer's bounded traversal. */
+     * shell CALLS edge and the consumer's bounded traversal. */
     ASSERT_EQ(
         gpf_query_int(
             files, 3,
@@ -3696,14 +3692,7 @@ TEST(probe_mcp_trace_deploy) {
                     .label = "Function",
                     .declaration_line = 3,
                     .declaration_text = "install_web() {"},
-         .mode = RQ_KNOWN_GAP,
-         .gap_id = "bash_local_function_binding_proof_missing",
-         .why = "The script defines install_web once and invokes it directly at module scope "
-                "without rebinding; Bash lacks an audited immutable lexical binding proof.",
-         .tried =
-             "Preserved the original script/workflow/chart and exact direct DEPLOYS/SPAWNS "
-             "contracts. The missing source-authored CALLS obligation is measured with a required "
-             "ESM control in both drivers; deploy traversal must stop at that missing link."}};
+         .mode = RQ_REQUIRED}};
     ASSERT_TRUE(gpf_infra_quality(files, 3, "probe_mcp_trace_deploy", expected, 1, NULL, 0));
     PASS();
 }
diff --git a/tests/test_lang_contract.c b/tests/test_lang_contract.c
index 02a234993..4544723ce 100644
--- a/tests/test_lang_contract.c
+++ b/tests/test_lang_contract.c
@@ -983,7 +983,7 @@ typedef struct {
 /* Source-authored invocation sites and full declaration-line anchors. Binding
  * classifications identify an audited missing proof stage, not a claim that
  * extraction has no additional gap. Dart, CUDA and the languages with a source
- * adapter (Ruby, Swift, Scala, Perl, Zig, Elixir, OCaml, Haskell, Erlang) are
+ * adapter (Ruby, Swift, Scala, Perl, Zig, Elixir, OCaml, Haskell, Erlang, Lua, Bash, Tcl, Vim) are
  * required capabilities. */
 static const CallOracle CALL_ORACLES[] = {
     {"ruby",
@@ -1006,12 +1006,10 @@ static const CallOracle CALL_ORACLES[] = {
      1,
      1,
      "function helper(x)",
-     RQ_KNOWN_GAP,
+     RQ_REQUIRED,
      "binding",
-     "Global function declarations write _ENV; the Lua subset proves only direct local function "
-     "bindings.",
-     "The original global declarations remain unchanged; lua_local_function rejects both and "
-     "records BINDING_BLOCKED."},
+     "",
+     ""},
     {"swift",
      "run",
      "helper",
@@ -1056,11 +1054,10 @@ static const CallOracle CALL_ORACLES[] = {
      1,
      1,
      "helper() {",
-     RQ_KNOWN_GAP,
+     RQ_REQUIRED,
      "binding",
-     "Shell function lookup versus command execution has no audited Bash binding environment.",
-     "Kept the bare helper command and preceding function declaration; the generic language gate "
-     "excludes Bash."},
+     "",
+     ""},
     {"perl",
      "run",
      "helper",
@@ -1236,10 +1233,10 @@ static const CallOracle CALL_ORACLES[] = {
      1,
      1,
      "proc helper {x} {",
-     RQ_KNOWN_GAP,
+     RQ_REQUIRED,
      "binding",
-     "Tcl proc registration and command-substitution lookup have no audited interpreter binding.",
-     "Kept the nested [helper 21] command inside run; no Tcl semantic proof adapter is selected."},
+     "",
+     ""},
     {"solidity",
      "run",
      "helper",
@@ -1638,16 +1635,15 @@ static const CallOracle CALL_ORACLES[] = {
     {"vimscript",
      "Run",
      "Helper",
-     {"call Helper()"},
-     {0},
+     {"Helper()"},
+     {1},
      1,
      1,
      "function! Helper() abort",
-     RQ_KNOWN_GAP,
+     RQ_REQUIRED,
      "binding",
-     "Vimscript named-function lookup and call-statement binding have no audited adapter.",
-     "Kept function! Helper and call Helper() with case preserved; the generic language gate "
-     "excludes Vimscript."},
+     "",
+     ""},
     {"wgsl",
      "run",
      "helper",
@@ -1839,8 +1835,8 @@ TEST(contract_calls_breadth) {
     for (int run = 0; run < RUNS; run++) {
         ASSERT(accepted[run]);
         ASSERT_EQ(reports[run].genuine, SITES);
-        ASSERT_EQ(reports[run].found, 11);   /* Dart, CUDA and the nine adapter languages */
-        ASSERT_EQ(reports[run].missing, 44); /* includes both original Fortran references */
+        ASSERT_EQ(reports[run].found, 15);   /* Dart, CUDA and the thirteen adapter languages */
+        ASSERT_EQ(reports[run].missing, 40); /* includes both original Fortran references */
     }
     ASSERT(equivalent);
     PASS();
diff --git a/tests/test_node_creation_probe.c b/tests/test_node_creation_probe.c
index e369c6faa..341b74378 100644
--- a/tests/test_node_creation_probe.c
+++ b/tests/test_node_creation_probe.c
@@ -1563,12 +1563,7 @@ TEST(probe_bash_functions_calls) {
                     .suffix = "log",
                     .declaration_line = 3,
                     .declaration_text = "log() {"},
-         .mode = RQ_KNOWN_GAP,
-         .gap_id = "no-bash-call-proof",
-         .why = "This language has no admitted semantic CALLS binding bridge; each authored local "
-                "declaration remains a genuine missing target.",
-         .tried = "The original canonical v69 probe failed its CALLS assertion; reviewed the "
-                  "unchanged fixture and current proof boundary."},
+         .mode = RQ_REQUIRED},
         {.case_id = "probe_bash_functions_calls-2",
          .site = {.file = "deploy.sh",
                   .caller = "deploy",
@@ -1579,12 +1574,7 @@ TEST(probe_bash_functions_calls) {
                     .suffix = "log",
                     .declaration_line = 3,
                     .declaration_text = "log() {"},
-         .mode = RQ_KNOWN_GAP,
-         .gap_id = "no-bash-call-proof",
-         .why = "This language has no admitted semantic CALLS binding bridge; each authored local "
-                "declaration remains a genuine missing target.",
-         .tried = "The original canonical v69 probe failed its CALLS assertion; reviewed the "
-                  "unchanged fixture and current proof boundary."},
+         .mode = RQ_REQUIRED},
         {.case_id = "probe_bash_functions_calls-3",
          .site =
              {.file = "deploy.sh", .caller = "deploy", .needle = "build", .occurrence_index = 2},
@@ -1593,12 +1583,7 @@ TEST(probe_bash_functions_calls) {
                     .suffix = "build",
                     .declaration_line = 7,
                     .declaration_text = "build() {"},
-         .mode = RQ_KNOWN_GAP,
-         .gap_id = "no-bash-call-proof",
-         .why = "This language has no admitted semantic CALLS binding bridge; each authored local "
-                "declaration remains a genuine missing target.",
-         .tried = "The original canonical v69 probe failed its CALLS assertion; reviewed the "
-                  "unchanged fixture and current proof boundary."},
+         .mode = RQ_REQUIRED},
         {.case_id = "probe_bash_functions_calls-4",
          .site = {.file = "deploy.sh",
                   .caller = "main",
@@ -1609,12 +1594,15 @@ TEST(probe_bash_functions_calls) {
                     .suffix = "deploy",
                     .declaration_line = 12,
                     .declaration_text = "deploy() {"},
-         .mode = RQ_KNOWN_GAP,
-         .gap_id = "no-bash-call-proof",
-         .why = "This language has no admitted semantic CALLS binding bridge; each authored local "
-                "declaration remains a genuine missing target.",
-         .tried = "The original canonical v69 probe failed its CALLS assertion; reviewed the "
-                  "unchanged fixture and current proof boundary."}};
+         .mode = RQ_REQUIRED},
+        {.case_id = "probe_bash_functions_calls-5",
+         .site = {.file = "deploy.sh", .caller = "deploy", .needle = "main \"$@\""},
+         .relation = "CALLS",
+         .target = {.file = "deploy.sh",
+                    .suffix = "main",
+                    .declaration_line = 17,
+                    .declaration_text = "main() {"},
+         .mode = RQ_REQUIRED}};
     NcpMetrics m = ncp_metrics_quality("deploy.sh",
                                        "#!/usr/bin/env bash\n\n"
                                        "log() {\n"
@@ -1637,7 +1625,8 @@ TEST(probe_bash_functions_calls) {
     ASSERT_TRUE(m.functions >= 3); /* log, build, deploy, main */
     ASSERT_TRUE(m.quality_ok);
     ASSERT_EQ(m.quality.genuine, sizeof(expected) / sizeof(expected[0]));
-    ASSERT_EQ(m.quality.missing, sizeof(expected) / sizeof(expected[0]));
+    ASSERT_EQ(m.quality.found, sizeof(expected) / sizeof(expected[0]));
+    ASSERT_EQ(m.quality.missing, 0);
     ASSERT_EQ(m.quality.wrong, 0);
     PASS();
 }
@@ -1655,12 +1644,7 @@ TEST(probe_bash_function_keyword) {
                     .suffix = "helper",
                     .declaration_line = 1,
                     .declaration_text = "function helper {"},
-         .mode = RQ_KNOWN_GAP,
-         .gap_id = "no-bash-call-proof",
-         .why = "This language has no admitted semantic CALLS binding bridge; each authored local "
-                "declaration remains a genuine missing target.",
-         .tried = "The original canonical v69 probe failed its CALLS assertion; reviewed the "
-                  "unchanged fixture and current proof boundary."},
+         .mode = RQ_REQUIRED},
         {.case_id = "probe_bash_function_keyword-2",
          .site = {.file = "lib.sh",
                   .caller = "runner",
@@ -1671,12 +1655,7 @@ TEST(probe_bash_function_keyword) {
                     .suffix = "helper",
                     .declaration_line = 1,
                     .declaration_text = "function helper {"},
-         .mode = RQ_KNOWN_GAP,
-         .gap_id = "no-bash-call-proof",
-         .why = "This language has no admitted semantic CALLS binding bridge; each authored local "
-                "declaration remains a genuine missing target.",
-         .tried = "The original canonical v69 probe failed its CALLS assertion; reviewed the "
-                  "unchanged fixture and current proof boundary."}};
+         .mode = RQ_REQUIRED}};
     NcpMetrics m = ncp_metrics_quality("lib.sh",
                                        "function helper {\n"
                                        "    echo \"help: $1\"\n"
@@ -1690,7 +1669,8 @@ TEST(probe_bash_function_keyword) {
     ASSERT_TRUE(m.functions >= 2);
     ASSERT_TRUE(m.quality_ok);
     ASSERT_EQ(m.quality.genuine, sizeof(expected) / sizeof(expected[0]));
-    ASSERT_EQ(m.quality.missing, sizeof(expected) / sizeof(expected[0]));
+    ASSERT_EQ(m.quality.found, sizeof(expected) / sizeof(expected[0]));
+    ASSERT_EQ(m.quality.missing, 0);
     ASSERT_EQ(m.quality.wrong, 0);
     PASS();
 }
diff --git a/tests/test_resolver_binding.c b/tests/test_resolver_binding.c
index cc947247c..d9a4acc13 100644
--- a/tests/test_resolver_binding.c
+++ b/tests/test_resolver_binding.c
@@ -221,32 +221,6 @@ TEST(resolver_binding_exact_occurrence_and_origin_required) {
     PASS();
 }
 
-TEST(resolver_binding_lua_local_function_and_shadow) {
-    const char *sources[] = {
-        "local function helper() return 1 end\nlocal function caller() return helper() end\n",
-        "local function helper() return 1 end\nlocal function caller(helper) return helper() end\n",
-        "function helper() return 1 end\nfunction caller() return helper() end\n",
-    };
-    for (size_t i = 0; i < sizeof(sources) / sizeof(sources[0]); i++) {
-        const char *source = sources[i];
-        CBMFileResult *result = cbm_extract_file(source, (int)strlen(source), CBM_LANG_LUA, "test",
-                                                 "binding.lua", 0, NULL, NULL);
-        ASSERT_NOT_NULL(result);
-        CBMArena arena;
-        cbm_arena_init(&arena);
-        cbm_resolve_binding_index_t *index =
-            cbm_resolve_binding_build(&arena, result, CBM_LANG_LUA, source, strlen(source));
-        const CBMCall *call = find_call(result, "helper");
-        ASSERT_NOT_NULL(call);
-        cbm_resolve_result_t resolved =
-            validate_call(index, call, local_candidate(&arena, result, "helper"));
-        ASSERT_EQ(cbm_resolve_admit(&resolved), i == 0);
-        cbm_arena_destroy(&arena);
-        cbm_free_result(result);
-    }
-    PASS();
-}
-
 TEST(resolver_binding_unsupported_language_is_explicit) {
     CBMArena arena;
     cbm_arena_init(&arena);
@@ -670,6 +644,5 @@ SUITE(resolver_binding) {
     RUN_TEST(resolver_binding_python_import_needs_independent_export_proof);
     RUN_TEST(resolver_binding_python_relative_import_preserves_local_authority);
     RUN_TEST(resolver_binding_exact_occurrence_and_origin_required);
-    RUN_TEST(resolver_binding_lua_local_function_and_shadow);
     RUN_TEST(resolver_binding_unsupported_language_is_explicit);
 }
diff --git a/tests/test_resolver_binding_generic.c b/tests/test_resolver_binding_generic.c
index 56b9296b3..913ee9687 100644
--- a/tests/test_resolver_binding_generic.c
+++ b/tests/test_resolver_binding_generic.c
@@ -842,34 +842,17 @@ TEST(resolver_binding_language_dynamic_controls_remain_blocked) {
                             "globals()['target'] = None", "locals()['target'] = None",
                             "vars()['target'] = None",
                             "setattr(sys.modules[__name__], 'target', None)"};
-    const char *lua[] = {"debug.getregistry()",
-                         "load('return nil')",
-                         "rawset(_G, 'target', nil)",
-                         "loadfile('unknown.lua')",
-                         "dofile('unknown.lua')",
-                         "loadstring('return nil')",
-                         "setfenv(1, {})",
-                         "getfenv(1)",
-                         "_ENV.target = nil",
-                         "_G.target = nil"};
-    for (int language = 0; language < 2; language++) {
-        const char *const *effects = language ? lua : python;
-        size_t count = language ? sizeof(lua) / sizeof(lua[0]) : sizeof(python) / sizeof(python[0]);
+    {
+        size_t count = sizeof(python) / sizeof(python[0]);
+        const char *const *effects = python;
         for (size_t i = 0; i < count; i++) {
             char source[512];
-            if (language)
-                snprintf(source, sizeof(source),
-                         "local function target() return 1 end\n%s\n"
-                         "local function caller() return target() end\n",
-                         effects[i]);
-            else
-                snprintf(source, sizeof(source),
-                         "def target():\n    return 1\n%s\ndef caller():\n    return target()\n",
-                         effects[i]);
-            CBMLanguage kind = language ? CBM_LANG_LUA : CBM_LANG_PYTHON;
-            CBMFileResult *file =
-                cbm_extract_file(source, (int)strlen(source), kind, "isolation",
-                                 language ? "main.lua" : "main.py", 0, NULL, NULL);
+            snprintf(source, sizeof(source),
+                     "def target():\n    return 1\n%s\ndef caller():\n    return target()\n",
+                     effects[i]);
+            CBMLanguage kind = CBM_LANG_PYTHON;
+            CBMFileResult *file = cbm_extract_file(source, (int)strlen(source), kind, "isolation",
+                                                   "main.py", 0, NULL, NULL);
             ASSERT_NOT_NULL(file);
             ASSERT(!file->has_error && !file->parse_incomplete && !file->parse_unusable);
             CBMArena arena;
@@ -891,8 +874,8 @@ TEST(resolver_binding_language_dynamic_controls_remain_blocked) {
                                              CBM_SOURCE_ORIGIN_RAW, candidate);
             bool admitted = cbm_resolve_admit(&proof);
             if (!blocked || admitted)
-                fprintf(stderr, "Dynamic control language=%d case=%zu status=%s admitted=%d\n",
-                        language, i, cbm_resolve_binding_status(index), admitted);
+                fprintf(stderr, "Dynamic control case=%zu status=%s admitted=%d\n", i,
+                        cbm_resolve_binding_status(index), admitted);
             cbm_arena_destroy(&arena);
             cbm_free_result(file);
             ASSERT(blocked);
@@ -1885,6 +1868,27 @@ TEST(resolver_binding_component_scripts_exact_local_scope) {
     } fixtures[] = {{"App.vue", "<template><p>Vue</p></template>\n<script setup lang=\"ts\">\n"
                                 "function callee(): number { return 42; }\n"
                                 "function caller(): number { return callee(); }\n</script>\n"},
+                    /* koel's SFCs: directives, bound attributes, handlers, a style block and
+                     * interpolation neither declare nor rebind a script name. */
+                    {"App.vue",
+                     "<template><Card v-if=\"caller\" :title=\"`${caller()}`\" @click.prevent=\"caller\">"
+                     "{{ caller() }}</Card></template>\n<script setup lang=\"ts\">\n"
+                     "function callee(): number { return 42; }\n"
+                     "function caller(): number { return callee(); }\n</script>\n"
+                     "<style scoped>\n.a { color: red; }\n</style>\n"},
+                    /* A normal script and `<script setup>` are one module. */
+                    {"App.vue",
+                     "<script lang=\"ts\">\nfunction callee(): number { return 42; }\n</script>\n"
+                     "<script setup lang=\"ts\" generic=\"T\">\n"
+                     "function caller(): number { return callee(); }\n</script>\n"},
+                    /* Assigning a const in markup writes its .value: the const stays. */
+                    {"App.vue",
+                     "<template><input v-model=\"count\" @click=\"count = 1\"/></template>\n"
+                     "<script setup>\nconst count = 1;\nfunction callee() { return count; }\n"
+                     "function caller() { return callee(); }\n</script>\n"},
+                    {"Toggle.svelte", "<script context=\"module\">\nfunction callee() { return 42; }\n"
+                                      "</script>\n<script>\nfunction caller() { return callee(); }\n"
+                                      "</script>\n<p>{caller()}</p>\n"},
                     {"App.vue", "<template><p>Vue</p></template>\n<script setup>\n"
                                 "function callee() { return 42; }\n"
                                 "function caller() { return callee(); }\n</script>\n"},
@@ -1908,6 +1912,14 @@ TEST(resolver_binding_component_scripts_scope_and_write_barriers) {
         {"App.vue", "<template><button @click=\"callee = caller\">Change</button></template>\n"
                     "<script setup>\nfunction callee() { return 42; }\n"
                     "function caller() { return callee(); }\n</script>\n"},
+        {"App.vue", "<template><input v-model=\"callee\"/></template>\n"
+                    "<script setup>\nfunction callee() { return 42; }\n"
+                    "function caller() { return callee(); }\n</script>\n"},
+        {"App.vue", "<template><p>x</p></template>\n<script src=\"./x.js\"></script>\n"
+                    "<script setup>\nfunction callee() { return 42; }\n"
+                    "function caller() { return callee(); }\n</script>\n"},
+        {"App.vue", "<script lang=\"coffee\">\nfunction callee() { return 42; }\n"
+                    "function caller() { return callee(); }\n</script>\n"},
         {"Toggle.svelte", "<script>\nfunction callee() { return 42; }\n"
                           "function caller() { return callee(); }\n</script>\n"
                           "<button on:click={() => callee = caller}>Change</button>\n"},
@@ -2250,7 +2262,14 @@ TEST(resolver_binding_unsupported_import_carriers_do_not_authorize_paths) {
                                       "project='unsupported-imports' "
                                       "AND relation='IMPORTS' AND emitted=0 AND target='' "
                                       "AND reason='unsupported_import_language' AND file_path IN "
-                                      "('main.jsonnet','main.ncl','main.sh')") == 3 &&
+                                      "('main.jsonnet','main.ncl')") == 2 &&
+                 ok;
+            /* Shell has an import rule now: a path built at runtime is its own abstention. */
+            ok = generic_count(store, "SELECT count(*) FROM resolver_occurrences WHERE "
+                                      "project='unsupported-imports' "
+                                      "AND relation='IMPORTS' AND emitted=0 AND target='' "
+                                      "AND reason='script_source_path_computed' AND "
+                                      "file_path='main.sh'") == 1 &&
                  ok;
             ok = generic_count(store,
                                "SELECT count(*) FROM edges e JOIN nodes s ON s.id=e.source_id "
diff --git a/tests/test_resolver_binding_js.c b/tests/test_resolver_binding_js.c
index b359302d5..f3c3446ba 100644
--- a/tests/test_resolver_binding_js.c
+++ b/tests/test_resolver_binding_js.c
@@ -627,7 +627,6 @@ TEST(resolver_binding_js_const_initialization_shadow_and_writes_abstain) {
          "}",
          "return target"},
         {"export {}; function caller() { const target = 42; return target; }", "return target"},
-        {"export const {target} = object; function caller() { return target; }", "return target"},
     };
     for (size_t i = 0; i < sizeof(fixtures) / sizeof(fixtures[0]); i++) {
         const char *source = fixtures[i].source;
@@ -650,12 +649,14 @@ TEST(resolver_binding_js_const_initialization_shadow_and_writes_abstain) {
 
 /* These used to be pinned as abstentions. A `let` or `var` with a later write still
  * names its one declaration, and a USAGE edge is about which declaration a name
- * selects, not which value it holds. A function const is a declared function. */
+ * selects, not which value it holds. A function const is a declared function, and a
+ * name a module-level pattern declares is that variable, whatever `object` holds. */
 TEST(resolver_binding_js_variable_and_function_const_references_bind) {
     static const char *const sources[] = {
         "export let target = 42; function caller() { return target; }",
         "export var target = 42; function caller() { return target; }",
         "export const target = () => 42; function caller() { return target; }",
+        "export const {target} = object; function caller() { return target; }",
     };
     for (size_t i = 0; i < sizeof(sources) / sizeof(sources[0]); i++) {
         CBMFileResult *result = cbm_extract_file(sources[i], (int)strlen(sources[i]),
diff --git a/tests/test_resolver_capabilities.c b/tests/test_resolver_capabilities.c
index d04e6c94a..d7bdc0b05 100644
--- a/tests/test_resolver_capabilities.c
+++ b/tests/test_resolver_capabilities.c
@@ -25,7 +25,8 @@ TEST(resolver_capability_is_never_an_occurrence_proof) {
     ASSERT(cbm_resolve_capabilities(CBM_LANG_JULIA, &capability));
     ASSERT_EQ(capability.proof_subsets, 0);
     ASSERT(cbm_resolve_capabilities(CBM_LANG_LUA, &capability));
-    ASSERT_EQ(capability.proof_subsets, CBM_RESOLVE_CAP_SCOPE);
+    ASSERT(capability.proof_subsets & CBM_RESOLVE_CAP_MEMBER);
+    ASSERT_STR_EQ(capability.adapter, "lua_source");
     ASSERT(cbm_resolve_capabilities(CBM_LANG_DART, &capability));
     ASSERT(!(capability.proof_subsets & CBM_RESOLVE_CAP_TYPE_FLOW));
     PASS();
@@ -138,14 +139,15 @@ TEST(resolver_capabilities_match_existing_bounded_producers) {
     for (size_t i = 0; i < sizeof(embedded) / sizeof(embedded[0]); i++) {
         ASSERT(cbm_resolve_capabilities(embedded[i], &capability));
         ASSERT_STR_EQ(capability.adapter, "embedded_javascript_lexical");
-        ASSERT_EQ(capability.proof_subsets, CBM_RESOLVE_CAP_SCOPE | CBM_RESOLVE_CAP_CALLABLE);
+        ASSERT_EQ(capability.proof_subsets, CBM_RESOLVE_CAP_SCOPE | CBM_RESOLVE_CAP_IMPORT_EXPORT |
+                                                CBM_RESOLVE_CAP_CALLABLE);
         ASSERT_EQ(capability.edges[CBM_RESOLVE_EDGE_CALLS].availability,
                   CBM_RESOLVE_EDGE_SUPPORTED_SUBSET);
         ASSERT_EQ(capability.edges[CBM_RESOLVE_EDGE_CALL_REFERENCE].availability,
                   CBM_RESOLVE_EDGE_SUPPORTED_SUBSET);
         ASSERT_EQ(capability.edges[CBM_RESOLVE_EDGE_IMPORTS].availability,
-                  CBM_RESOLVE_EDGE_UNSUPPORTED);
-        ASSERT_NOT_NULL(strstr(capability.limitation, "inline script"));
+                  CBM_RESOLVE_EDGE_SUPPORTED_SUBSET);
+        ASSERT_NOT_NULL(strstr(capability.limitation, "Inline scripts"));
     }
     ASSERT(cbm_resolve_capabilities(CBM_LANG_YAML, &capability));
     ASSERT_NOT_NULL(strstr(capability.edges[CBM_RESOLVE_EDGE_USAGE].limitation, "Compose"));
diff --git a/tests/test_resolver_quality.c b/tests/test_resolver_quality.c
index 1f31fff47..b930d828b 100644
--- a/tests/test_resolver_quality.c
+++ b/tests/test_resolver_quality.c
@@ -35,15 +35,10 @@ static const quality_case_t QUALITY_CASES[] = {
     {"Rust", "main.rs", "actual.rs", "decoy.rs",
      "mod actual;\nuse crate::actual::target;\nfn caller() { target(); }\nfn main() {}\n",
      "pub fn target() {}\n", "pub fn target() {}\n", true, NULL, NULL},
-    /* WHY: Lua require result/export-table binding has no proof adapter.
-     * TRIED: explicit local require plus a named function in a literal table;
-     * scope-only binding cannot prove the cross-file returned member. */
     {"Lua", "main.lua", "actual.lua", "decoy.lua",
      "local actual = require('actual')\nlocal function caller() actual.target() end\n",
      "local function target() end\nreturn {target=target}\n",
-     "local function target() end\nreturn {target=target}\n", false,
-     "require return-table member binding unimplemented",
-     "explicit local require and literal returned table"},
+     "local function target() end\nreturn {target=target}\n", true, NULL, NULL},
     /* WHY: Perl's legacy engine has no cross-file proof bridge.
      * TRIED: a literal require of a file declaring a main-package sub, with
      * repository-root cwd as the fixture's execution context. */
diff --git a/tests/test_resolver_source_langs.c b/tests/test_resolver_source_langs.c
index 026e165c3..6dd560b57 100644
--- a/tests/test_resolver_source_langs.c
+++ b/tests/test_resolver_source_langs.c
@@ -5206,6 +5206,1184 @@ TEST(resolver_source_ocaml_sequential_scope_and_modules) {
     PASS();
 }
 
+/* ── Lua ───────────────────────────────────────────────────────────── */
+
+/* Forms from neovim: `local clear = n.clear`, `require('test.functional.testnvim')()`, a module
+ * table returned from a `lua/` root, `Screen.new` building an instance through `__index`, and
+ * LuaCATS stubs declaring `vim.api.*` in one global namespace. */
+static const char LUA_HELPER[] = "local M = {}\n"
+                                 "\n"
+                                 "function M.greet(name)\n"
+                                 "  return name\n"
+                                 "end\n"
+                                 "\n"
+                                 "M.assigned = function() end\n"
+                                 "\n"
+                                 "function M:method()\n"
+                                 "  return self:sibling()\n"
+                                 "end\n"
+                                 "\n"
+                                 "function M:sibling()\n"
+                                 "  return M.greet('from sibling')\n"
+                                 "end\n"
+                                 "\n"
+                                 "local function hidden() end\n"
+                                 "\n"
+                                 "M.renamed = hidden\n"
+                                 "\n"
+                                 "M.conflict = hidden\n"
+                                 "M.conflict = M.greet\n"
+                                 "\n"
+                                 "M.format = function() end\n"
+                                 "\n"
+                                 "return M\n";
+static const char LUA_UTIL[] = "local M = {\n"
+                               "  eq = function() end,\n"
+                               "}\n"
+                               "\n"
+                               "function M.ok() end\n"
+                               "\n"
+                               "return M\n";
+static const char LUA_FACTORY[] = "local M = {}\n"
+                                  "\n"
+                                  "function M.clear() end\n"
+                                  "\n"
+                                  "return function()\n"
+                                  "  return M\n"
+                                  "end\n";
+static const char LUA_CLASS[] = "local Base = require('lib.base')\n"
+                                "\n"
+                                "local Class = setmetatable({}, { __index = Base })\n"
+                                "Class.__index = Class\n"
+                                "\n"
+                                "function Class.new()\n"
+                                "  local self = setmetatable({}, Class)\n"
+                                "  return self\n"
+                                "end\n"
+                                "\n"
+                                "function Class:run()\n"
+                                "  self:inherited()\n"
+                                "  return self\n"
+                                "end\n"
+                                "\n"
+                                "return Class\n";
+static const char LUA_BASE[] = "local Base = {}\n"
+                               "\n"
+                               "function Base:inherited() end\n"
+                               "\n"
+                               "return Base\n";
+static const char LUA_STUBS[] = "vim.api = {}\n"
+                                "\n"
+                                "function vim.api.nvim_thing() end\n";
+static const char LUA_SHARED[] = "function shared_global() end\n"
+                                 "\n"
+                                 "function vim.keycode(text)\n"
+                                 "  return text\n"
+                                 "end\n"
+                                 "\n"
+                                 "function usage() end\n"
+                                 "\n"
+                                 "function print(...) end\n";
+static const char LUA_OTHER[] = "function usage() end\n"
+                                "\n"
+                                "function own_script()\n"
+                                "  usage()\n"
+                                "end\n";
+static const char LUA_MAIN[] =
+    "local h = require('lib.helper')\n"
+    "local t = require('test.util')\n"
+    "local n = require('test.factory')()\n"
+    "local Class = require('lib.class')\n"
+    "local greet = h.greet\n"
+    "local helper_mod = h\n"
+    "local a, second_ok = h.greet, t.ok\n"
+    "local api = vim.api\n"
+    "local counter = 0\n"
+    "\n"
+    "local function own() end\n"
+    "\n"
+    "local function caller()\n"
+    "  h.greet('x')\n"
+    "  greet('y')\n"
+    "  second_ok(1)\n"
+    "  n.clear()\n"
+    "  own()\n"
+    "  h:method()\n"
+    "  require('lib.helper').greet('z')\n"
+    "  local c = Class.new()\n"
+    "  c:run()\n"
+    "  c:inherited()\n"
+    "  shared_global()\n"
+    "  vim.api.nvim_thing()\n"
+    "  api.nvim_thing()\n"
+    "  vim.keycode('k')\n"
+    "  t.eq(1)\n"
+    "end\n"
+    "\n"
+    "local function reads()\n"
+    "  return counter, helper_mod.renamed, second_ok\n"
+    "end\n"
+    "\n"
+    "local function shadow(greet, own)\n"
+    "  greet('p')\n"
+    "  own()\n"
+    "  local counter = 1\n"
+    "  return counter\n"
+    "end\n"
+    "\n"
+    "local function rewritten()\n"
+    "  local f = h.greet\n"
+    "  f = h.assigned\n"
+    "  f()\n"
+    "end\n"
+    "\n"
+    "local function not_proved()\n"
+    "  h.missing()\n"
+    "  h.conflict()\n"
+    "  string.format('x')\n"
+    "  print('x')\n"
+    "  usage()\n"
+    "  require('ext.lib').greet()\n"
+    "end\n"
+    "\n"
+    "local function replaced_environment()\n"
+    "  local _ENV = { shared_global = own }\n"
+    "  shared_global()\n"
+    "end\n"
+    "\n"
+    "local function scoped()\n"
+    "  do\n"
+    "    local inner = greet\n"
+    "    inner('in')\n"
+    "  end\n"
+    "  inner('out')\n"
+    "end\n"
+    "\n"
+    "local Wrapped = {}\n"
+    "local before = Wrapped.go\n"
+    "function Wrapped.go()\n"
+    "  before()\n"
+    "end\n"
+    "\n"
+    "local function with_default(opts)\n"
+    "  opts = opts or {}\n"
+    "  local setup = opts.setup\n"
+    "  function opts.setup()\n"
+    "    setup()\n"
+    "  end\n"
+    "end\n"
+    "\n"
+    "local function preloaded()\n"
+    "  require('os').shadowed_by_a_project_file()\n"
+    "end\n"
+    "\n"
+    "local function own_require(require)\n"
+    "  local z = require('lib.helper')\n"
+    "  z.greet('s')\n"
+    "end\n"
+    "\n"
+    "return { caller = caller }\n";
+
+#define LUA_HELPER_FILE "lua/lib/helper.lua"
+#define LUA_FILE "test/main_spec.lua"
+#define LUA_CALL(id, text, tfile, tsuffix, tline, tdecl)                                       \
+    SL_CALL_AT(id, LUA_FILE, "main_spec.caller", text, 0, tfile, tsuffix, "Function", tline, tdecl)
+#define LUA_DENY(id, method, text) SL_DENY_AT(id, LUA_FILE, "main_spec." method, text, 0)
+
+TEST(resolver_source_lua_values_modules_and_scope) {
+    static const RQ_Source sources[] = {
+        {.path = LUA_FILE, .text = LUA_MAIN},
+        {.path = LUA_HELPER_FILE, .text = LUA_HELPER},
+        {.path = "test/util.lua", .text = LUA_UTIL},
+        {.path = "test/factory.lua", .text = LUA_FACTORY},
+        {.path = "lua/lib/class.lua", .text = LUA_CLASS},
+        {.path = "lua/lib/base.lua", .text = LUA_BASE},
+        {.path = "meta/api.lua", .text = LUA_STUBS},
+        {.path = "shared.lua", .text = LUA_SHARED},
+        {.path = "other_script.lua", .text = LUA_OTHER},
+        {.path = "os.lua", .text = "local M = {}\nfunction M.shadowed_by_a_project_file() end\nreturn M\n"},
+    };
+    static const RQ_Expected expected[] = {
+        LUA_CALL("member-of-a-required-table", "h.greet('x')", LUA_HELPER_FILE, "helper.M.greet", 3,
+                 "function M.greet(name)"),
+        LUA_CALL("local-holding-a-member", "greet('y')", LUA_HELPER_FILE, "helper.M.greet", 3,
+                 "function M.greet(name)"),
+        LUA_CALL("second-name-of-a-local-statement", "second_ok(1)", "test/util.lua", "util.M.ok", 5,
+                 "function M.ok() end"),
+        LUA_CALL("value-a-required-function-returns", "n.clear()", "test/factory.lua",
+                 "factory.M.clear", 3, "function M.clear() end"),
+        SL_CALL_AT("local-function", LUA_FILE, "main_spec.caller", "own()", 1, LUA_FILE, "main_spec.own",
+                   "Function", 11, "local function own() end"),
+        LUA_CALL("method-of-a-required-table", "h:method()", LUA_HELPER_FILE, "helper.M:method", 9,
+                 "function M:method()"),
+        LUA_CALL("member-of-a-require-expression", "require('lib.helper').greet('z')",
+                 LUA_HELPER_FILE, "helper.M.greet", 3, "function M.greet(name)"),
+        LUA_CALL("constructor-function", "Class.new()", "lua/lib/class.lua", "class.Class.new", 6,
+                 "function Class.new()"),
+        LUA_CALL("method-of-an-instance", "c:run()", "lua/lib/class.lua", "class.Class:run", 11,
+                 "function Class:run()"),
+        LUA_CALL("metatable-index-chain", "c:inherited()", "lua/lib/base.lua",
+                 "base.Base:inherited", 3, "function Base:inherited() end"),
+        LUA_CALL("global-function-of-another-file", "shared_global()", "shared.lua",
+                 "shared.shared_global", 1, "function shared_global() end"),
+        LUA_CALL("global-table-member", "vim.api.nvim_thing()", "meta/api.lua",
+                 "api.vim.api.nvim_thing", 3, "function vim.api.nvim_thing() end"),
+        SL_CALL_AT("local-holding-a-global-table", LUA_FILE, "main_spec.caller", "api.nvim_thing()", 1,
+                   "meta/api.lua", "api.vim.api.nvim_thing", "Function", 3,
+                   "function vim.api.nvim_thing() end"),
+        LUA_CALL("function-in-a-global-table", "vim.keycode('k')", "shared.lua",
+                 "shared.vim.keycode", 3, "function vim.keycode(text)"),
+        SL_CALL_AT("self-method", LUA_HELPER_FILE, "helper.M:method", "self:sibling()", 0,
+                   LUA_HELPER_FILE, "helper.M:sibling", "Function", 13, "function M:sibling()"),
+        SL_CALL_AT("inner-block-local", LUA_FILE, "main_spec.scoped", "inner('in')", 0,
+                   LUA_HELPER_FILE, "helper.M.greet", "Function", 3, "function M.greet(name)"),
+        SL_CALL_AT("own-file-global-before-another-file", "other_script.lua",
+                   "other_script.own_script", "usage()", 1, "other_script.lua",
+                   "other_script.usage", "Function", 1, "function usage() end"),
+        SL_USE_AT("block-local-reads-the-chunk-alias", LUA_FILE, "main_spec.scoped", "greet", 10,
+                  LUA_FILE, "main_spec.greet", "Variable", 5, "local greet = h.greet"),
+        SL_USE_AT("chunk-level-local-read", LUA_FILE, "main_spec.reads", "counter", 1, LUA_FILE,
+                  "main_spec.counter", "Variable", 9, "local counter = 0"),
+        SL_USE_AT("alias-local-read", LUA_FILE, "main_spec.reads", "helper_mod", 1, LUA_FILE,
+                  "main_spec.helper_mod", "Variable", 6, "local helper_mod = h"),
+        SL_USE_AT("second-name-has-a-node", LUA_FILE, "main_spec.reads", "second_ok", 2, LUA_FILE,
+                  "main_spec.second_ok", "Variable", 7, "local a, second_ok = h.greet, t.ok"),
+        SL_USE_AT("member-read-holding-a-function", LUA_FILE, "main_spec.reads", "renamed", 0,
+                  LUA_HELPER_FILE, "helper.hidden", "Function", 17, "local function hidden() end"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        LUA_DENY("parameter-shadows-the-alias", "shadow", "greet('p')"),
+        SL_DENY_AT("parameter-shadows-the-function", LUA_FILE, "main_spec.shadow", "own()", 2),
+        SL_NO_USE_AT("inner-local-is-not-the-chunk-local", LUA_FILE, "main_spec.shadow", "counter",
+                     1),
+        LUA_DENY("a-local-written-with-another-value", "rewritten", "f()"),
+        SL_DENY_AT("function-in-a-table-field-has-no-node", LUA_FILE, "main_spec.caller", "t.eq(1)", 0),
+        LUA_DENY("member-nothing-declares", "not_proved", "h.missing()"),
+        LUA_DENY("member-with-two-declarations", "not_proved", "h.conflict()"),
+        LUA_DENY("standard-library-is-not-a-same-named-member", "not_proved", "string.format('x')"),
+        LUA_DENY("standard-global-is-not-another-files-wrapper", "not_proved", "print('x')"),
+        LUA_DENY("global-two-files-declare", "not_proved", "usage()"),
+        LUA_DENY("module-outside-the-project", "not_proved", "require('ext.lib').greet()"),
+        LUA_DENY("local-environment-replaces-globals", "replaced_environment", "shared_global()"),
+        LUA_DENY("name-past-its-block-is-a-global", "scoped", "inner('out')"),
+        LUA_DENY("parameter-named-require", "own_require", "z.greet('s')"),
+        SL_DENY_AT("read-above-the-declaration-is-the-old-value", LUA_FILE, "main_spec.Wrapped.go",
+                   "before()", 0),
+        SL_DENY_AT("parameter-default-is-not-its-only-value", LUA_FILE, "main_spec.opts.setup",
+                   "setup()", 0),
+        LUA_DENY("library-the-host-preloads", "preloaded",
+                 "require('os').shadowed_by_a_project_file()"),
+    };
+    ASSERT(sl_check("lua-rules", ".lua", "local filler = 1\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
+/* LuaCATS is what a Lua project states about a value it cannot show: a parameter, a return. An
+ * annotation is about the next line. The rest of neovim's runtime reads this way:
+ * `--- @param client vim.lsp.Client`, `vim.uv = ...` under `---@type uv`. */
+static const char LUA_THING[] = "--- @class lib.Thing\n"
+                                "local Thing = {}\n"
+                                "Thing.__index = Thing\n"
+                                "\n"
+                                "function Thing:run() end\n"
+                                "\n"
+                                "--- @return lib.Thing\n"
+                                "function Thing.make()\n"
+                                "  return mystery()\n"
+                                "end\n"
+                                "\n"
+                                "return Thing\n";
+static const char LUA_ANNOTATED[] = "local Thing = require('lib.thing')\n"
+                                    "\n"
+                                    "--- @param t lib.Thing\n"
+                                    "local function annotated(t)\n"
+                                    "  t:run()\n"
+                                    "end\n"
+                                    "\n"
+                                    "--- @param s string\n"
+                                    "local function not_a_class(s)\n"
+                                    "  s:run()\n"
+                                    "end\n"
+                                    "\n"
+                                    "local function no_annotation(u)\n"
+                                    "  u:run()\n"
+                                    "end\n"
+                                    "\n"
+                                    "--- @class lib.Shape\n"
+                                    "\n"
+                                    "local Unrelated = {}\n"
+                                    "function Unrelated.run() end\n"
+                                    "\n"
+                                    "--- @param o lib.Shape\n"
+                                    "local function class_not_adjacent(o)\n"
+                                    "  o.run()\n"
+                                    "end\n"
+                                    "\n"
+                                    "local function via_return()\n"
+                                    "  Thing.make():run()\n"
+                                    "end\n"
+                                    "\n"
+                                    "local other = mystery() --- @type lib.Thing\n"
+                                    "local function trailing()\n"
+                                    "  other:run()\n"
+                                    "end\n"
+                                    "\n"
+                                    "---@type lib.Thing\n"
+                                    "shared_thing = ...\n"
+                                    "local function typed_global()\n"
+                                    "  shared_thing:run()\n"
+                                    "end\n";
+
+TEST(resolver_source_lua_annotations_state_what_a_value_cannot) {
+    static const RQ_Source sources[] = {
+        {.path = "lua/lib/thing.lua", .text = LUA_THING},
+        {.path = "use.lua", .text = LUA_ANNOTATED},
+    };
+    static const RQ_Expected expected[] = {
+        SL_CALL_AT("param-annotation", "use.lua", "use.annotated", "t:run()", 0,
+                   "lua/lib/thing.lua", "thing.Thing:run", "Function", 5, "function Thing:run() end"),
+        SL_CALL_AT("function-whose-return-is-annotated", "use.lua", "use.via_return", "Thing.make()",
+                   0, "lua/lib/thing.lua", "thing.Thing.make", "Function", 8,
+                   "function Thing.make()"),
+        SL_CALL_AT("return-annotation", "use.lua", "use.via_return", "Thing.make():run()", 0,
+                   "lua/lib/thing.lua", "thing.Thing:run", "Function", 5, "function Thing:run() end"),
+        SL_CALL_AT("trailing-type-annotation", "use.lua", "use.trailing", "other:run()", 0,
+                   "lua/lib/thing.lua", "thing.Thing:run", "Function", 5, "function Thing:run() end"),
+        SL_CALL_AT("type-annotation-on-an-assignment", "use.lua", "use.typed_global",
+                   "shared_thing:run()", 0, "lua/lib/thing.lua", "thing.Thing:run", "Function", 5,
+                   "function Thing:run() end"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        SL_DENY_AT("annotation-naming-no-class", "use.lua", "use.not_a_class", "s:run()", 0),
+        SL_DENY_AT("no-annotation", "use.lua", "use.no_annotation", "u:run()", 0),
+        SL_DENY_AT("class-annotation-across-a-blank-line", "use.lua", "use.class_not_adjacent",
+                   "o.run()", 0),
+    };
+    ASSERT(sl_check("lua-annotations", ".lua", "local filler = 1\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
+/* Forms from neovim: a lazy `__index` over `require(prefix .. key)`, `@module` fields of the table
+ * `vim._defer_require` is given, and a test's `local function` inside `describe(...)`. A mock in a
+ * test body does not compete with the declaration, and a factory's new table keeps its own writes. */
+static const char LUA_LAZY[] =
+    "local lazy = setmetatable({}, {\n"
+    "  __index = function(t, key)\n"
+    "    t[key] = require('lazylib.' .. key)\n"
+    "    return t[key]\n"
+    "  end,\n"
+    "})\n"
+    "local function make_deferred() return {} end\n"
+    "local deferred = make_deferred('pkg', {\n"
+    "  buf = ..., --- @module 'pkg.buf'\n"
+    "})\n"
+    "\n"
+    "local function make()\n"
+    "  return {}\n"
+    "end\n"
+    "local first = make()\n"
+    "function first.only_first() end\n"
+    "local second = make()\n"
+    "function second.only_second() end\n"
+    "\n"
+    "function global_api() end\n"
+    "\n"
+    "local function callers()\n"
+    "  lazy.sub.go()\n"
+    "  deferred.buf.format()\n"
+    "  first.only_first()\n"
+    "  global_api()\n"
+    "end\n"
+    "\n"
+    "local function no_proof()\n"
+    "  lazy.absent.go()\n"
+    "  deferred.other.format()\n"
+    "  first.only_second()\n"
+    "end\n"
+    "\n"
+    "describe('suite', function()\n"
+    "  local function nested_helper() end\n"
+    "  local function nested_caller()\n"
+    "    nested_helper()\n"
+    "  end\n"
+    "end)\n";
+
+TEST(resolver_source_lua_lazy_modules_factories_and_nested_functions) {
+    static const RQ_Source sources[] = {
+        {.path = "lazy.lua", .text = LUA_LAZY},
+        {.path = "lazylib/sub.lua", .text = "local M = {}\nfunction M.go() end\nreturn M\n"},
+        {.path = "pkg/buf.lua", .text = "local M = {}\nfunction M.format() end\nreturn M\n"},
+        {.path = "pkg/other.lua", .text = "local M = {}\nfunction M.format() end\nreturn M\n"},
+        {.path = "mock_spec.lua", .text = "local function mocks()\n"
+                                          "  global_api = function() end\n"
+                                          "end\n"},
+        {.path = "global_user.lua", .text = "local function use_global()\n"
+                                            "  global_api()\n"
+                                            "end\n"},
+    };
+    static const RQ_Expected expected[] = {
+        SL_CALL_AT("lazy-index-requires-the-key", "lazy.lua", "lazy.callers", "lazy.sub.go()", 0,
+                   "lazylib/sub.lua", "sub.M.go", "Function", 2, "function M.go() end"),
+        SL_CALL_AT("module-annotated-field", "lazy.lua", "lazy.callers", "deferred.buf.format()", 0,
+                   "pkg/buf.lua", "buf.M.format", "Function", 2, "function M.format() end"),
+        SL_CALL_AT("write-through-a-factory-local", "lazy.lua", "lazy.callers", "first.only_first()",
+                   1, "lazy.lua", "lazy.first.only_first", "Function", 16,
+                   "function first.only_first() end"),
+        SL_CALL_AT("own-file-global", "lazy.lua", "lazy.callers", "global_api()", 1, "lazy.lua",
+                   "lazy.global_api", "Function", 20, "function global_api() end"),
+        SL_CALL_AT("mock-in-a-function-does-not-compete", "global_user.lua",
+                   "global_user.use_global", "global_api()", 0, "lazy.lua", "lazy.global_api",
+                   "Function", 20, "function global_api() end"),
+        SL_CALL_AT("local-function-inside-a-callback", "lazy.lua", "lazy.nested_caller",
+                   "nested_helper()", 1, "lazy.lua", "lazy.nested_helper", "Function", 36,
+                   "  local function nested_helper() end"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        SL_DENY_AT("lazy-module-outside-the-project", "lazy.lua", "lazy.no_proof",
+                   "lazy.absent.go()", 0),
+        SL_DENY_AT("field-the-annotation-does-not-name", "lazy.lua", "lazy.no_proof",
+                   "deferred.other.format()", 0),
+        SL_DENY_AT("write-through-the-other-factory-local", "lazy.lua", "lazy.no_proof",
+                   "first.only_second()", 0),
+    };
+    ASSERT(sl_check("lua-lazy", ".lua", "local filler = 1\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
+/* `@class C: A, B` states what a value it cannot compute holds, as neovim's test helper does with
+ * `M = vim.tbl_extend('error', M, t_global)`. One parent declaring the name selects it; two, or a
+ * parent the project has no table for, leave it open. `return a, b` gives `local x, y = f()` its y
+ * when every return agrees and no last call can give more. */
+static const char LUA_LATER_VALUES[] = "local merged = require('merged')\n"
+                                       "local open_parent = require('open_parent')\n"
+                                       "local generic = require('generic')\n"
+                                       "\n"
+                                       "local function pair()\n"
+                                       "  local function first_value() end\n"
+                                       "  local function second_value() end\n"
+                                       "  return first_value, second_value\n"
+                                       "end\n"
+                                       "\n"
+                                       "local function failing()\n"
+                                       "  local function failure_path_value() end\n"
+                                       "  if unknown_flag then\n"
+                                       "    return nil\n"
+                                       "  end\n"
+                                       "  return 1, failure_path_value\n"
+                                       "end\n"
+                                       "\n"
+                                       "local function disagree()\n"
+                                       "  local function a() end\n"
+                                       "  local function b() end\n"
+                                       "  if unknown_flag then\n"
+                                       "    return 1, a\n"
+                                       "  end\n"
+                                       "  return 1, b\n"
+                                       "end\n"
+                                       "\n"
+                                       "local function forwards()\n"
+                                       "  local function c() end\n"
+                                       "  local function third() end\n"
+                                       "  if unknown_flag then\n"
+                                       "    return c, nil, third\n"
+                                       "  end\n"
+                                       "  return c, pair()\n"
+                                       "end\n"
+                                       "\n"
+                                       "local one, two = pair()\n"
+                                       "local f1, f2 = failing()\n"
+                                       "local d1, d2 = disagree()\n"
+                                       "local g1, g2, g3 = forwards()\n"
+                                       "\n"
+                                       "local function callers()\n"
+                                       "  merged.base_fn()\n"
+                                       "  merged.extra_fn()\n"
+                                       "  merged.own_fn()\n"
+                                       "  generic.base_fn()\n"
+                                       "  two()\n"
+                                       "  f2()\n"
+                                       "  g2()\n"
+                                       "end\n"
+                                       "\n"
+                                       "local function no_proof()\n"
+                                       "  merged.both()\n"
+                                       "  open_parent.base_fn()\n"
+                                       "  d2()\n"
+                                       "  g3()\n"
+                                       "end\n";
+
+TEST(resolver_source_lua_class_parents_and_later_return_values) {
+    static const RQ_Source sources[] = {
+        {.path = "use.lua", .text = LUA_LATER_VALUES},
+        {.path = "base.lua",
+         .text = "--- @class base.mod\n"
+                 "local M = {}\n"
+                 "function M.base_fn() end\n"
+                 "function M.both() end\n"
+                 "return M\n"},
+        {.path = "extra.lua",
+         .text = "--- @class extra.mod\n"
+                 "local M = {}\n"
+                 "function M.extra_fn() end\n"
+                 "function M.both() end\n"
+                 "return M\n"},
+        {.path = "merged.lua",
+         .text = "local function own_fn() end\n"
+                 "--- @class merged.own\n"
+                 "local M = {\n"
+                 "  own_fn = own_fn,\n"
+                 "}\n"
+                 "--- @class merged.mod: merged.own, base.mod, extra.mod\n"
+                 "M = merge(M)\n"
+                 "return M\n"},
+        {.path = "open_parent.lua",
+         .text = "--- @class open.mod: base.mod, not.in.project\n"
+                 "local M = {}\n"
+                 "return M\n"},
+        {.path = "generic.lua",
+         .text = "--- @class (private, exact) gen.child<T, U> : base.mod\n"
+                 "local M = {}\n"
+                 "return M\n"},
+    };
+    static const RQ_Expected expected[] = {
+        SL_CALL_AT("merged-module-first-parent", "use.lua", "use.callers", "merged.base_fn()", 0,
+                   "base.lua", "base.M.base_fn", "Function", 3, "function M.base_fn() end"),
+        SL_CALL_AT("merged-module-second-parent", "use.lua", "use.callers", "merged.extra_fn()", 0,
+                   "extra.lua", "extra.M.extra_fn", "Function", 3, "function M.extra_fn() end"),
+        SL_CALL_AT("class-table-the-write-replaced", "use.lua", "use.callers", "merged.own_fn()", 0,
+                   "merged.lua", "merged.own_fn", "Function", 1, "local function own_fn() end"),
+        SL_CALL_AT("parent-of-a-class-with-its-own-table", "use.lua", "use.callers",
+                   "generic.base_fn()", 0, "base.lua", "base.M.base_fn", "Function", 3,
+                   "function M.base_fn() end"),
+        SL_CALL_AT("second-return-value", "use.lua", "use.callers", "two()", 0, "use.lua",
+                   "second_value", "Function", 7, "  local function second_value() end"),
+        SL_CALL_AT("nil-failure-path-does-not-compete", "use.lua", "use.callers", "f2()", 0,
+                   "use.lua", "failure_path_value", "Function", 12,
+                   "  local function failure_path_value() end"),
+        SL_CALL_AT("call-in-last-place-gives-its-first", "use.lua", "use.callers", "g2()", 0,
+                   "use.lua", "first_value", "Function", 6, "  local function first_value() end"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        SL_DENY_AT("two-parents-declare-the-name", "use.lua", "use.no_proof", "merged.both()", 0),
+        SL_DENY_AT("parent-the-project-does-not-have", "use.lua", "use.no_proof",
+                   "open_parent.base_fn()", 0),
+        SL_DENY_AT("returns-disagree-on-the-position", "use.lua", "use.no_proof", "d2()", 0),
+        SL_DENY_AT("position-past-a-last-call", "use.lua", "use.no_proof", "g3()", 0),
+    };
+    ASSERT(sl_check("lua-later", ".lua", "local filler = 1\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
+/* The effects that once voided a whole file. None of them can rebind a local: `load` and
+ * `dofile` run elsewhere, and `_G.x = v` declares a global. What the manual says can change a
+ * binding does abstain: setfenv for free names, debug.setlocal for a local's value. */
+static const char LUA_EFFECTS[] = "local function target() return 1 end\n"
+                                  "debug.getregistry()\n"
+                                  "load('return nil')\n"
+                                  "rawset(_G, 'other', nil)\n"
+                                  "loadfile('unknown.lua')\n"
+                                  "dofile('unknown.lua')\n"
+                                  "loadstring('return nil')\n"
+                                  "local version = _G._VERSION\n"
+                                  "local function caller(...) goto done ::done:: return target() end\n"
+                                  "_G.declared = function() end\n"
+                                  "local function reads_g() return declared() end\n";
+static const char LUA_SETFENV[] = "function free_name() return 1 end\n"
+                                  "setfenv(1, {})\n"
+                                  "function caller_free() return free_name() end\n";
+static const char LUA_DEBUG[] = "local function f() return 1 end\n"
+                                "local g = f\n"
+                                "debug.setlocal(1, 1, nil)\n"
+                                "local function caller_debug() return g() end\n";
+
+TEST(resolver_source_lua_effects_that_can_change_a_binding) {
+    static const RQ_Source sources[] = {
+        {.path = "effects.lua", .text = LUA_EFFECTS},
+        {.path = "setfenv.lua", .text = LUA_SETFENV},
+        {.path = "writes_local.lua", .text = LUA_DEBUG},
+    };
+    static const RQ_Expected expected[] = {
+        SL_CALL_AT("local-under-dynamic-effects", "effects.lua", "effects.caller", "target()", 1,
+                   "effects.lua", "effects.target", "Function", 1,
+                   "local function target() return 1 end"),
+        SL_CALL_AT("global-declared-through-G", "effects.lua", "effects.reads_g", "declared()", 0,
+                   "effects.lua", "effects._G.declared", "Function", 10,
+                   "_G.declared = function() end"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        SL_DENY_AT("setfenv-moves-free-names", "setfenv.lua", "setfenv.caller_free", "free_name()",
+                   0),
+        SL_DENY_AT("debug-setlocal-writes-locals", "writes_local.lua", "writes_local.caller_debug",
+                   "g()", 0),
+    };
+    ASSERT(sl_check("lua-effects", ".lua", "local filler = 1\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
+/* ── Vim script ────────────────────────────────────────────────────── */
+
+/* Forms from neovim's runtime and test/old/testdir. */
+static const char VIM_MAIN[] = "function! s:Local() abort\n"
+                               "  return 1\n"
+                               "endfunction\n"
+                               "function! s:Caller() abort\n"
+                               "  call s:Local()\n"
+                               "  call <SID>Local()\n"
+                               "  call foo#bar#baz(1)\n"
+                               "  call Global(2)\n"
+                               "  call Shared(3)\n"
+                               "  return 0\n"
+                               "endfunction\n"
+                               "function! Global(x) abort\n"
+                               "  return a:x\n"
+                               "endfunction\n"
+                               "function! s:NoProof(F) abort\n"
+                               "  call get(a:F, 'k')\n"
+                               "  call s:Missing()\n"
+                               "  call Both(1)\n"
+                               "  call Holder()\n"
+                               "  call a:F()\n"
+                               "  call wrong#place#fn()\n"
+                               "endfunction\n"
+                               "let Holder = function('Global')\n"
+                               "let s:dict = {}\n"
+                               "function s:dict.get() abort\n"
+                               "endfunction\n";
+static const char VIM_SHARED[] = "function! Shared(x) abort\n"
+                                 "  return a:x\n"
+                                 "endfunction\n"
+                                 "function! Both(x) abort\n"
+                                 "endfunction\n"
+                                 "function! Holder() abort\n"
+                                 "endfunction\n"
+                                 "function! s:Missing() abort\n"
+                                 "endfunction\n"
+                                 "function! wrong#place#fn() abort\n"
+                                 "endfunction\n";
+static const char VIM_OTHER[] = "function! Both(x) abort\n"
+                                "endfunction\n";
+static const char VIM_AUTOLOAD[] = "function! foo#bar#baz(x) abort\n"
+                                   "  return s:Inner(a:x)\n"
+                                   "endfunction\n"
+                                   "function! s:Inner(x) abort\n"
+                                   "  return a:x\n"
+                                   "endfunction\n";
+
+#define VIM_FILE "plugin/main.vim"
+#define VIM_CALL(id, text, at, tfile, tsuffix, tline, tdecl)                                   \
+    SL_CALL_AT(id, VIM_FILE, "main.s:Caller", text, at, tfile, tsuffix, "Function", tline, tdecl)
+#define VIM_DENY(id, text) SL_DENY_AT(id, VIM_FILE, "main.s:NoProof", text, 0)
+
+TEST(resolver_source_vim_name_prefixes_select_the_namespace) {
+    static const RQ_Source sources[] = {
+        {.path = VIM_FILE, .text = VIM_MAIN},
+        {.path = "plugin/shared.vim", .text = VIM_SHARED},
+        {.path = "plugin/other.vim", .text = VIM_OTHER},
+        {.path = "autoload/foo/bar.vim", .text = VIM_AUTOLOAD},
+    };
+    static const RQ_Expected expected[] = {
+        VIM_CALL("script-local", "s:Local()", 1, VIM_FILE, "main.s:Local", 1,
+                 "function! s:Local() abort"),
+        VIM_CALL("sid-spelling", "<SID>Local()", 0, VIM_FILE, "main.s:Local", 1,
+                 "function! s:Local() abort"),
+        VIM_CALL("autoload-path", "foo#bar#baz(1)", 0, "autoload/foo/bar.vim", "bar.foo#bar#baz", 1,
+                 "function! foo#bar#baz(x) abort"),
+        VIM_CALL("global-of-this-file", "Global(2)", 0, VIM_FILE, "main.Global", 12,
+                 "function! Global(x) abort"),
+        VIM_CALL("global-of-one-other-file", "Shared(3)", 0, "plugin/shared.vim", "shared.Shared", 1,
+                 "function! Shared(x) abort"),
+        SL_CALL_AT("script-local-of-an-autoload-file", "autoload/foo/bar.vim", "bar.foo#bar#baz",
+                   "s:Inner(a:x)", 0, "autoload/foo/bar.vim", "bar.s:Inner", "Function", 4,
+                   "function! s:Inner(x) abort"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        VIM_DENY("lower-case-is-a-builtin-not-a-dict-function", "get(a:F, 'k')"),
+        VIM_DENY("script-local-of-another-file", "s:Missing()"),
+        VIM_DENY("global-two-files-declare", "Both(1)"),
+        VIM_DENY("name-assigned-a-funcref", "Holder()"),
+        VIM_DENY("parameter-funcref", "a:F()"),
+        VIM_DENY("autoload-name-outside-its-path", "wrong#place#fn()"),
+    };
+    ASSERT(sl_check("vim-rules", ".vim", "let g:filler = 1\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
+/* ── Tcl ───────────────────────────────────────────────────────────── */
+
+/* Forms from redis's tests. `expr` syntax is a parse error in this grammar, and is in most files. */
+static const char TCL_MAIN[] = "proc local_proc {a} {\n"
+                               "    return $a\n"
+                               "}\n"
+                               "proc caller {} {\n"
+                               "    local_proc 1\n"
+                               "    wait_for_it 2\n"
+                               "    set x [wait_for_it 3]\n"
+                               "    harness_proc 31\n"
+                               "    return [expr ($x+1) / 2]\n"
+                               "}\n"
+                               "proc no_proof {} {\n"
+                               "    both 4\n"
+                               "    standalone_only 5\n"
+                               "    puts 6\n"
+                               "    $computed 7\n"
+                               "    renamed 8\n"
+                               "}\n"
+                               "namespace eval ns {\n"
+                               "    proc outer {} {\n"
+                               "        sibling 9\n"
+                               "        wait_for_it 10\n"
+                               "    }\n"
+                               "    proc sibling {x} {\n"
+                               "        return $x\n"
+                               "    }\n"
+                               "}\n";
+static const char TCL_HELPER[] = "source tests/support/util.tcl\n"
+                                 "source tests/support/other.tcl\n"
+                                 "proc harness_proc {x} {\n"
+                                 "}\n"
+                                 "proc run_test {name} {\n"
+                                 "    source tests/$name.tcl\n"
+                                 "}\n";
+static const char TCL_UTIL[] = "proc wait_for_it {x} {\n"
+                               "    return $x\n"
+                               "}\n"
+                               "proc both {} {\n"
+                               "}\n"
+                               "proc renamed {x} {\n"
+                               "}\n"
+                               "rename renamed hidden\n";
+static const char TCL_OTHER[] = "proc both {} {\n"
+                                "}\n";
+static const char TCL_STANDALONE[] = "proc standalone_only {x} {\n"
+                                     "}\n";
+
+#define TCL_FILE "tests/unit/main.tcl"
+#define TCL_DENY(id, text) SL_DENY_AT(id, TCL_FILE, "main.no_proof", text, 0)
+
+TEST(resolver_source_tcl_procs_and_shared_interpreter) {
+    static const RQ_Source sources[] = {
+        {.path = TCL_FILE, .text = TCL_MAIN},
+        {.path = "tests/helper.tcl", .text = TCL_HELPER},
+        {.path = "tests/support/util.tcl", .text = TCL_UTIL},
+        {.path = "tests/support/other.tcl", .text = TCL_OTHER},
+        {.path = "tools/standalone.tcl", .text = TCL_STANDALONE},
+    };
+    static const RQ_Expected expected[] = {
+        SL_CALL_AT("proc-of-this-script", TCL_FILE, "main.caller", "local_proc 1", 0, TCL_FILE,
+                   "main.local_proc", "Function", 1, "proc local_proc {a} {"),
+        SL_CALL_AT("proc-of-a-sourced-file", TCL_FILE, "main.caller", "wait_for_it 2", 0,
+                   "tests/support/util.tcl", "util.wait_for_it", "Function", 1,
+                   "proc wait_for_it {x} {"),
+        SL_CALL_AT("command-substitution", TCL_FILE, "main.caller", "wait_for_it 3", 0,
+                   "tests/support/util.tcl", "util.wait_for_it", "Function", 1,
+                   "proc wait_for_it {x} {"),
+        SL_CALL_AT("proc-of-the-harness-that-loads-it", TCL_FILE, "main.caller", "harness_proc 31", 0,
+                   "tests/helper.tcl", "helper.harness_proc", "Function", 3,
+                   "proc harness_proc {x} {"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        TCL_DENY("two-sourced-files-declare-it", "both 4"),
+        TCL_DENY("file-nothing-sources", "standalone_only 5"),
+        TCL_DENY("builtin-command", "puts 6"),
+        TCL_DENY("computed-command", "$computed 7"),
+        TCL_DENY("renamed-proc", "renamed 8"),
+    };
+    ASSERT(sl_check("tcl-rules", ".tcl", "set filler 1\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
+/* ── Shell ─────────────────────────────────────────────────────────── */
+
+static const char SH_MAIN[] = "#!/bin/bash\n"
+                              "source \"$(dirname \"$0\")/lib.sh\"\n"
+                              "source scripts/literal.sh\n"
+                              "ROOT=$(dirname \"${BASH_SOURCE[0]}\")/..\n"
+                              "source \"${ROOT}/hack/init.sh\"\n"
+                              "early\n"
+                              "helper() {\n"
+                              "  later 1\n"
+                              "  lib_fn 2\n"
+                              "  literal_fn 3\n"
+                              "  init_fn 31\n"
+                              "}\n"
+                              "later() {\n"
+                              "  helper 4\n"
+                              "}\n"
+                              "early() {\n"
+                              "  :\n"
+                              "}\n"
+                              "no_proof() {\n"
+                              "  other_script_fn 5\n"
+                              "  gone 6\n"
+                              "  $computed 7\n"
+                              "  command later 8\n"
+                              "}\n"
+                              "gone() {\n"
+                              "  :\n"
+                              "}\n"
+                              "unset -f gone\n"
+                              "early 9\n"
+                              "TOP_LEVEL=1\n"
+                              "reads() {\n"
+                              "  echo \"$TOP_LEVEL\"\n"
+                              "}\n"
+                              "SHADOWED=1\n"
+                              "reads_local() {\n"
+                              "  local SHADOWED=2\n"
+                              "  echo \"$SHADOWED\"\n"
+                              "}\n";
+static const char SH_LIB[] = "lib_fn() {\n"
+                             "  :\n"
+                             "}\n";
+static const char SH_INIT[] = "init_fn() {\n"
+                              "  :\n"
+                              "}\n";
+static const char SH_LITERAL[] = "literal_fn() {\n"
+                                 "  :\n"
+                                 "}\n";
+static const char SH_OTHER[] = "other_script_fn() {\n"
+                               "  :\n"
+                               "}\n"
+                               "lib_fn() {\n"
+                               "  :\n"
+                               "}\n";
+
+#define SH_FILE "scripts/main.sh"
+
+TEST(resolver_source_shell_function_table_of_one_process) {
+    static const RQ_Source sources[] = {
+        {.path = SH_FILE, .text = SH_MAIN},
+        {.path = "scripts/lib.sh", .text = SH_LIB},
+        {.path = "scripts/literal.sh", .text = SH_LITERAL},
+        {.path = "hack/init.sh", .text = SH_INIT},
+        {.path = "tools/other.sh", .text = SH_OTHER},
+    };
+    static const RQ_Expected expected[] = {
+        SL_USE_AT("variable-of-this-file", SH_FILE, "main.reads", "TOP_LEVEL", 1, SH_FILE,
+                  "main.TOP_LEVEL", "Variable", 30, "TOP_LEVEL=1"),
+        SL_CALL_AT("body-calls-a-later-definition", SH_FILE, "main.helper", "later 1", 0, SH_FILE,
+                   "main.later", "Function", 13, "later() {"),
+        SL_CALL_AT("sourced-through-the-scripts-directory", SH_FILE, "main.helper", "lib_fn 2", 0,
+                   "scripts/lib.sh", "lib.lib_fn", "Function", 1, "lib_fn() {"),
+        SL_CALL_AT("sourced-by-a-literal-path", SH_FILE, "main.helper", "literal_fn 3", 0,
+                   "scripts/literal.sh", "literal.literal_fn", "Function", 1, "literal_fn() {"),
+        SL_CALL_AT("top-level-after-the-definition", SH_FILE, "main", "early 9", 0, SH_FILE,
+                   "main.early", "Function", 16, "early() {"),
+        SL_CALL_AT("sourced-through-a-variable-naming-a-directory", SH_FILE, "main.helper",
+                   "init_fn 31", 0, "hack/init.sh", "init.init_fn", "Function", 1, "init_fn() {"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        SL_NO_USE_AT("name-a-function-makes-local", SH_FILE, "main.reads_local", "SHADOWED", 2),
+        SL_DENY_AT("top-level-before-the-definition", SH_FILE, "main", "early\n", 0),
+        SL_DENY_AT("another-script-is-another-process", SH_FILE, "main.no_proof",
+                   "other_script_fn 5", 0),
+        SL_DENY_AT("unset-function", SH_FILE, "main.no_proof", "gone 6", 0),
+        SL_DENY_AT("computed-command", SH_FILE, "main.no_proof", "$computed 7", 0),
+        SL_DENY_AT("command-builtin-skips-the-table", SH_FILE, "main.no_proof", "command later 8",
+                   0),
+    };
+    ASSERT(sl_check("shell-rules", ".sh", "filler=1\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
+/* ── Make ──────────────────────────────────────────────────────────── */
+
+/* From redis's deps/lua/Makefile. */
+static const char MAKE_MAIN[] = "INSTALL_TOP= /usr/local\n"
+                                "INSTALL_BIN= $(INSTALL_TOP)/bin\n"
+                                "FROM_ENV_COPY= $(FROM_ENV)\n"
+                                "COMPUTED= $($(INSTALL_TOP)_FLAGS)\n"
+                                "SIBLING= sibling-only\n";
+
+TEST(resolver_source_make_variables_of_the_file) {
+    static const RQ_Source sources[] = {
+        {.path = "deps/Makefile", .text = MAKE_MAIN},
+        {.path = "other/Makefile", .text = "FROM_ENV= elsewhere\n"},
+    };
+    static const RQ_Expected expected[] = {
+        SL_USE_AT("variable-assigned-in-this-file", "deps/Makefile", "Makefile",
+                  "$(INSTALL_TOP)", 0, "deps/Makefile", "Makefile.INSTALL_TOP", "Variable", 1,
+                  "INSTALL_TOP= /usr/local"),
+        SL_USE_AT("read-inside-a-computed-name", "deps/Makefile", "Makefile", "$(INSTALL_TOP)", 1,
+                  "deps/Makefile", "Makefile.INSTALL_TOP", "Variable", 1,
+                  "INSTALL_TOP= /usr/local"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        SL_NO_USE_AT("variable-of-another-makefile", "deps/Makefile", "Makefile",
+                     "$(FROM_ENV)", 0),
+    };
+    ASSERT(sl_check("make-rules", ".mk", "FILLER= 1\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
+/* ── Vue ───────────────────────────────────────────────────────────── */
+
+/* koel's SFC: the template's directives, the style block and the two scripts do not stop the
+ * script from being a module, and a member of an exported object literal is selected across
+ * files by the rule the literal's own file uses. */
+/* A composable's `return { a }`, as Vue and React code read it: `const { a } = useThing()`.
+ * Every return must agree, a spread takes what is before it, and what is not a function of this
+ * project selects nothing. */
+static const char COMPOSABLE[] = "const outside = () => {}\n"
+                                 "export const useThing = () => {\n"
+                                 "  const open = () => {}\n"
+                                 "  function declared() {}\n"
+                                 "  let written = () => {}\n"
+                                 "  written = () => {}\n"
+                                 "  return {\n"
+                                 "    open,\n"
+                                 "    declared,\n"
+                                 "    renamed: open,\n"
+                                 "    written,\n"
+                                 "    outside,\n"
+                                 "    inline: () => {},\n"
+                                 "    computed: open.bind(null),\n"
+                                 "  }\n"
+                                 "}\n"
+                                 "export function useSpread() {\n"
+                                 "  const before = () => {}\n"
+                                 "  const after = () => {}\n"
+                                 "  return { before, ...other(), after }\n"
+                                 "}\n"
+                                 "export function useTwoReturns(flag) {\n"
+                                 "  const one = () => {}\n"
+                                 "  const two = () => {}\n"
+                                 "  const same = () => {}\n"
+                                 "  if (flag) return { picked: one, same }\n"
+                                 "  return { picked: two, same }\n"
+                                 "}\n"
+                                 "export function useValue() {\n"
+                                 "  const hidden = () => {}\n"
+                                 "  if (other()) return { hidden }\n"
+                                 "  return makeObject()\n"
+                                 "}\n"
+                                 "export const useExpression = () => ({ made: outside })\n";
+
+static const char COMPOSABLE_USER[] =
+    "<script setup>\n"
+    "import { useThing, useSpread, useTwoReturns, useValue, useExpression } from './composable'\n"
+    "const { open, declared, renamed, written, outside, inline, computed } = useThing()\n"
+    "const { open: alias } = useThing()\n"
+    "const { before, after } = useSpread()\n"
+    "const { picked, same } = useTwoReturns(true)\n"
+    "const { hidden } = useValue()\n"
+    "const { made } = useExpression()\n"
+    "let { open: reassigned } = useThing()\n"
+    "const { open: defaulted = () => {} } = useThing()\n"
+    "const { renamed: { declared: nested_member } } = useThing()\n"
+    "\n"
+    "function calls() {\n"
+    "  open()\n"
+    "  declared()\n"
+    "  renamed()\n"
+    "  outside()\n"
+    "  inline()\n"
+    "  alias()\n"
+    "  after()\n"
+    "  same()\n"
+    "  made()\n"
+    "}\n"
+    "\n"
+    "function no_proof(parameter) {\n"
+    "  written()\n"
+    "  computed()\n"
+    "  before()\n"
+    "  picked()\n"
+    "  hidden()\n"
+    "  reassigned()\n"
+    "  defaulted()\n"
+    "  nested_member()\n"
+    "}\n"
+    "\n"
+    "function shadowed(open) {\n"
+    "  open()\n"
+    "}\n"
+    "\n"
+    "function nested() {\n"
+    "  const { open: inner } = useThing()\n"
+    "  inner()\n"
+    "}\n"
+    "</script>\n";
+
+TEST(resolver_source_vue_composable_return_selects_the_member) {
+    static const RQ_Source sources[] = {
+        {.path = "src/composable.ts", .text = COMPOSABLE},
+        {.path = "src/Main.vue", .text = COMPOSABLE_USER},
+    };
+#define COMPOSABLE_USER_FILE "src/Main.vue"
+#define COMPOSABLE_FILE "src/composable.ts"
+    static const RQ_Expected expected[] = {
+        SL_CALL_AT("shorthand-of-a-local-function", COMPOSABLE_USER_FILE, "Main.calls", "open()", 0,
+                   COMPOSABLE_FILE, "open", "Function", 3, "  const open = () => {}"),
+        SL_CALL_AT("shorthand-of-a-declaration", COMPOSABLE_USER_FILE, "Main.calls", "declared()", 0,
+                   COMPOSABLE_FILE, "declared", "Function", 4, "  function declared() {}"),
+        SL_CALL_AT("renamed-member", COMPOSABLE_USER_FILE, "Main.calls", "renamed()", 0,
+                   COMPOSABLE_FILE, "open", "Function", 3, "  const open = () => {}"),
+        SL_CALL_AT("module-level-function-returned", COMPOSABLE_USER_FILE, "Main.calls", "outside()",
+                   0, COMPOSABLE_FILE, "outside", "Function", 1, "const outside = () => {}"),
+        SL_CALL_AT("inline-function-member", COMPOSABLE_USER_FILE, "Main.calls", "inline()", 0,
+                   COMPOSABLE_FILE, "inline", "Function", 13, "    inline: () => {},"),
+        SL_CALL_AT("pattern-renames-the-local", COMPOSABLE_USER_FILE, "Main.calls", "alias()", 0,
+                   COMPOSABLE_FILE, "open", "Function", 3, "  const open = () => {}"),
+        SL_CALL_AT("after-a-spread-is-the-literals", COMPOSABLE_USER_FILE, "Main.calls", "after()",
+                   0, COMPOSABLE_FILE, "after", "Function", 19, "  const after = () => {}"),
+        SL_CALL_AT("every-return-agrees", COMPOSABLE_USER_FILE, "Main.calls", "same()", 0,
+                   COMPOSABLE_FILE, "same", "Function", 25, "  const same = () => {}"),
+        SL_CALL_AT("expression-body-object", COMPOSABLE_USER_FILE, "Main.calls", "made()", 0,
+                   COMPOSABLE_FILE, "outside", "Function", 1, "const outside = () => {}"),
+        SL_CALL_AT("function-level-destructure", COMPOSABLE_USER_FILE, "Main.nested", "inner()", 0,
+                   COMPOSABLE_FILE, "open", "Function", 3, "  const open = () => {}"),
+        SL_CALL_AT("the-composable-itself", COMPOSABLE_USER_FILE, "Main.nested", "useThing()", 5,
+                   COMPOSABLE_FILE, "useThing", "Function", 2, "export const useThing = () => {"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        SL_DENY_AT("returned-local-is-written", COMPOSABLE_USER_FILE, "Main.no_proof", "written()",
+                   0),
+        SL_DENY_AT("member-value-is-computed", COMPOSABLE_USER_FILE, "Main.no_proof", "computed()",
+                   0),
+        SL_DENY_AT("spread-can-replace-what-is-before-it", COMPOSABLE_USER_FILE, "Main.no_proof",
+                   "before()", 0),
+        SL_DENY_AT("returns-disagree", COMPOSABLE_USER_FILE, "Main.no_proof", "picked()", 0),
+        SL_DENY_AT("another-return-is-not-an-object", COMPOSABLE_USER_FILE, "Main.no_proof",
+                   "hidden()", 0),
+        SL_DENY_AT("let-can-be-written", COMPOSABLE_USER_FILE, "Main.no_proof", "reassigned()", 0),
+        SL_DENY_AT("default-can-be-the-value", COMPOSABLE_USER_FILE, "Main.no_proof", "defaulted()",
+                   0),
+        SL_DENY_AT("nested-pattern-is-a-member-of-the-member", COMPOSABLE_USER_FILE, "Main.no_proof",
+                   "nested_member()", 0),
+        SL_DENY_AT("parameter-shadows-the-destructured-const", COMPOSABLE_USER_FILE, "Main.shadowed",
+                   "open()", 1),
+    };
+    ASSERT(sl_check("vue-composable", ".vue", "<script>const filler = 1</script>\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
+static const char VUE_SERVICE[] = "export const authService = {\n"
+                                  "  login() {\n"
+                                  "    return 1\n"
+                                  "  },\n"
+                                  "  logout: () => 2,\n"
+                                  "}\n"
+                                  "\n"
+                                  "export const written = {\n"
+                                  "  replaced() {},\n"
+                                  "}\n"
+                                  "written.replaced = () => 3\n"
+                                  "\n"
+                                  "export function plain() {}\n"
+                                  "\n"
+                                  "const base = {}\n"
+                                  "export const spreadFirst = {\n"
+                                  "  ...base,\n"
+                                  "  first() {},\n"
+                                  "}\n"
+                                  "export const spreadLast = {\n"
+                                  "  last() {},\n"
+                                  "  ...base,\n"
+                                  "}\n";
+static const char VUE_MAIN[] = "<template>\n"
+                               "  <BaseCard v-if=\"ready\" :title=\"`x`\" @click.prevent=\"go\">\n"
+                               "    {{ go() }}\n"
+                               "  </BaseCard>\n"
+                               "</template>\n"
+                               "\n"
+                               "<script lang=\"ts\">\n"
+                               "export const sharedConstant = 1\n"
+                               "</script>\n"
+                               "\n"
+                               "<script setup lang=\"ts\" generic=\"T\">\n"
+                               "import { authService, written, plain, spreadFirst, spreadLast } "
+                               "from './service'\n"
+                               "\n"
+                               "const { podcast } = defineProps<{ podcast: T }>()\n"
+                               "const ready = true\n"
+                               "function helper() {}\n"
+                               "const reads = () => podcast\n"
+                               "const reads_parameter = (podcast) => podcast\n"
+                               "const go = () => {\n"
+                               "  plain()\n"
+                               "  helper()\n"
+                               "  authService.login()\n"
+                               "  authService.logout()\n"
+                               "  authService.missing()\n"
+                               "  written.replaced()\n"
+                               "  spreadFirst.first()\n"
+                               "  spreadLast.last()\n"
+                               "  return sharedConstant\n"
+                               "}\n"
+                               "</script>\n"
+                               "\n"
+                               "<style scoped>\n"
+                               ".a { color: red; }\n"
+                               "</style>\n";
+
+#define VUE_FILE "src/Main.vue"
+
+TEST(resolver_source_vue_script_reaches_the_ecma_resolver) {
+    static const RQ_Source sources[] = {
+        {.path = VUE_FILE, .text = VUE_MAIN},
+        {.path = "src/service.ts", .text = VUE_SERVICE},
+    };
+    static const RQ_Expected expected[] = {
+        SL_USE_AT("read-of-a-destructured-const", VUE_FILE, "Main.reads", "podcast", 2, VUE_FILE,
+                  "Main.podcast", "Variable", 14,
+                  "const { podcast } = defineProps<{ podcast: T }>()"),
+        SL_CALL_AT("imported-function", VUE_FILE, "Main.go", "plain()", 0, "src/service.ts",
+                   "service.plain", "Function", 13, "export function plain() {}"),
+        SL_CALL_AT("function-of-the-script", VUE_FILE, "Main.go", "helper()", 1, VUE_FILE,
+                   "Main.helper", "Function", 16, "function helper() {}"),
+        SL_CALL_AT("method-of-an-exported-literal", VUE_FILE, "Main.go", "authService.login()", 0,
+                   "src/service.ts", "service.login", "Function", 2, "  login() {"),
+        SL_CALL_AT("member-after-a-spread-is-the-literals", VUE_FILE, "Main.go", "spreadFirst.first()",
+                   0, "src/service.ts", "service.first", "Function", 18, "  first() {},"),
+        SL_CALL_AT("arrow-of-an-exported-literal", VUE_FILE, "Main.go", "authService.logout()", 0,
+                   "src/service.ts", "service.logout", "Function", 5, "  logout: () => 2,"),
+    };
+    static const RQ_Forbidden forbidden[] = {
+        SL_NO_USE_AT("parameter-is-not-the-destructured-const", VUE_FILE, "Main.reads_parameter",
+                     "podcast", 4),
+        SL_DENY_AT("member-the-literal-does-not-have", VUE_FILE, "Main.go",
+                   "authService.missing()", 0),
+        SL_DENY_AT("member-of-a-written-literal", VUE_FILE, "Main.go", "written.replaced()", 0),
+        SL_DENY_AT("spread-can-replace-what-is-before-it", VUE_FILE, "Main.go", "spreadLast.last()", 0),
+    };
+    ASSERT(sl_check("vue-rules", ".ts", "export const filler = 1\n", sources,
+                    sizeof(sources) / sizeof(sources[0]), expected,
+                    sizeof(expected) / sizeof(expected[0]), forbidden,
+                    sizeof(forbidden) / sizeof(forbidden[0])));
+    PASS();
+}
+
 SUITE(resolver_source_langs) {
     RUN_TEST(resolver_source_elixir_modules_aliases_imports_and_arity);
     RUN_TEST(resolver_source_erlang_module_arity_export_and_import);
@@ -5245,4 +6423,15 @@ SUITE(resolver_source_langs) {
     RUN_TEST(resolver_source_scala_packages_precedence_and_receivers);
     RUN_TEST(resolver_source_haskell_imports_and_scope);
     RUN_TEST(resolver_source_ocaml_sequential_scope_and_modules);
+    RUN_TEST(resolver_source_lua_values_modules_and_scope);
+    RUN_TEST(resolver_source_lua_effects_that_can_change_a_binding);
+    RUN_TEST(resolver_source_lua_annotations_state_what_a_value_cannot);
+    RUN_TEST(resolver_source_lua_lazy_modules_factories_and_nested_functions);
+    RUN_TEST(resolver_source_lua_class_parents_and_later_return_values);
+    RUN_TEST(resolver_source_vim_name_prefixes_select_the_namespace);
+    RUN_TEST(resolver_source_tcl_procs_and_shared_interpreter);
+    RUN_TEST(resolver_source_shell_function_table_of_one_process);
+    RUN_TEST(resolver_source_make_variables_of_the_file);
+    RUN_TEST(resolver_source_vue_script_reaches_the_ecma_resolver);
+    RUN_TEST(resolver_source_vue_composable_return_selects_the_member);
 }