@@ -1468,7 +1468,19 @@ static bool pxc_edge_string_prop(const char *json, const char *key, char *out, s
     return true;
 }
 
-/* `visited` holds barrel file QNs already searched for `name`: barrels form
+static void pxc_free_visit_key(const char *key, void *value, void *userdata) {
+    (void)key;
+    (void)userdata;
+    free(value);
+}
+
+/* Free a `visited` table built by pxc_barrel_symbol_qn and its owned keys. */
+static void pxc_barrel_visited_free(CBMHashTable *visited) {
+    cbm_ht_foreach(visited, pxc_free_visit_key, NULL);
+    cbm_ht_free(visited);
+}
+
+/* `visited` holds (barrel file QN, name) pairs already searched: barrels form
  * DAGs (and cycles) where one lib index is reachable through many paths, and
  * re-walking it on each path is exponential in the depth cap. */
 static char *pxc_barrel_symbol_qn(const cbm_gbuf_t *gbuf, const char *project_name,
@@ -1501,10 +1513,24 @@ static char *pxc_barrel_symbol_qn(const cbm_gbuf_t *gbuf, const char *project_na
             free(file_qn);
         }
     }
-    if (!file_node || cbm_ht_has(visited, file_node->qualified_name)) {
+    if (!file_node || !file_node->qualified_name) {
+        return NULL;
+    }
+    /* Key on file and name: a named re-export renames the symbol, so one
+     * file can be searched for two names in one walk (`export *` and
+     * `export { a as b }` from the same module). The key owns its bytes and
+     * is the stored value; pxc_barrel_visited_free releases it. */
+    size_t vk_len = strlen(file_node->qualified_name) + 1 + strlen(name) + 1;
+    char *visit_key = (char *)malloc(vk_len);
+    if (!visit_key) {
         return NULL;
     }
-    cbm_ht_set(visited, file_node->qualified_name, (void *)file_node);
+    snprintf(visit_key, vk_len, "%s\x1f%s", file_node->qualified_name, name);
+    if (cbm_ht_has(visited, visit_key)) {
+        free(visit_key);
+        return NULL;
+    }
+    cbm_ht_set(visited, visit_key, visit_key);
     char *defined = pxc_defined_symbol_qn(gbuf, project_name, rel, name);
     if (defined) {
         return defined;
@@ -1563,6 +1589,114 @@ static bool pxc_import_map_has_local(const char *const *keys, int count, const c
     return false;
 }
 
+/* True when `local` is a JS/TS module-object binding: `import * as local`
+ * or `const local = require(...)`. Such an import has no member, is not a
+ * default import and is not a re-export. A local that also names a member
+ * import is not treated as one. */
+static bool pxc_js_namespace_local(const CBMFileResult *result, const char *local) {
+    if (!result || !local) {
+        return false;
+    }
+    bool found = false;
+    for (int i = 0; i < result->imports.count; i++) {
+        const CBMImport *imp = &result->imports.items[i];
+        if (!imp->local_name || strcmp(imp->local_name, local) != 0) {
+            continue;
+        }
+        if (imp->member || imp->is_default || imp->reexport != CBM_REEXPORT_NONE ||
+            !cbm_import_binds_runtime_name(imp)) {
+            return false;
+        }
+        found = true;
+    }
+    return found;
+}
+
+/* A JS identifier: the member part of `ns.member`. */
+static bool pxc_js_identifier(const char *s) {
+    if (!s || !s[0] || (s[0] >= '0' && s[0] <= '9')) {
+        return false;
+    }
+    for (const char *p = s; *p; p++) {
+        char c = *p;
+        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ||
+              c == '_' || c == '$')) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/* Grow the parallel key/value arrays of an import map to hold `need` slots.
+ * Namespace members add entries beyond the one-per-edge first estimate, so
+ * every write in cbm_pxc_build_import_map_ex reserves first. */
+static bool pxc_import_map_reserve(const char ***keys, const char ***vals, size_t *capacity,
+                                   size_t need) {
+    if (need <= *capacity) {
+        return true;
+    }
+    size_t grown = *capacity * 2 > need ? *capacity * 2 : need;
+    const char **nk = (const char **)realloc((void *)*keys, grown * sizeof(char *));
+    if (!nk) {
+        return false;
+    }
+    *keys = nk;
+    const char **nv = (const char **)realloc((void *)*vals, grown * sizeof(char *));
+    if (!nv) {
+        return false; /* keys grew, capacity did not: still consistent */
+    }
+    *vals = nv;
+    *capacity = grown;
+    return true;
+}
+
+/* Calls through a namespace import. For each call `local.member()` in the
+ * file, follow the imported module (and its re-export chain, as for a named
+ * import) to the one file that defines `member`, and add the key
+ * "local.member" with that definition's QN. The registry looks up the whole
+ * callee as a key before it splits it, so `ns.fn()` binds to fn's defining
+ * file even when the imported module only re-exports fn. Nothing is added
+ * when no definition, or more than one, is found. */
+static void pxc_add_js_namespace_members(const cbm_gbuf_t *gbuf, const char *project_name,
+                                         const CBMFileResult *result, const char *local,
+                                         const cbm_gbuf_node_t *target, const char ***keys,
+                                         const char ***vals, int *count, size_t *capacity) {
+    if (!result || !target || !target->label ||
+        (strcmp(target->label, "Module") != 0 && strcmp(target->label, "Folder") != 0)) {
+        return;
+    }
+    size_t local_len = strlen(local);
+    for (int i = 0; i < result->calls.count; i++) {
+        const char *callee = result->calls.items[i].callee_name;
+        if (!callee || strncmp(callee, local, local_len) != 0 || callee[local_len] != '.' ||
+            !pxc_js_identifier(callee + local_len + 1) ||
+            pxc_import_map_has_local(*keys, *count, callee)) {
+            continue;
+        }
+        CBMHashTable *visited = cbm_ht_create(16);
+        char *qn = visited ? pxc_barrel_symbol_qn(gbuf, project_name, target,
+                                                  callee + local_len + 1, 0, visited)
+                           : NULL;
+        pxc_barrel_visited_free(visited);
+        if (!qn) {
+            continue;
+        }
+        char *key = strdup(callee);
+        if (!key) {
+            free(qn);
+            continue;
+        }
+        if (!pxc_import_map_reserve(keys, vals, capacity, (size_t)*count + 1)) {
+            free(key);
+            free(qn);
+            return;
+        }
+        (*keys)[*count] = key;
+        (*vals)[*count] = qn;
+        (*count)++;
+    }
+}
+
 /* Recover a Python import directly from extraction metadata when graph import
  * materialization produced no edge. Prefer an already materialized exact node
  * (including the shared project-prefix rule); otherwise accept only the
@@ -1710,17 +1844,26 @@ int cbm_pxc_build_import_map_ex(const cbm_gbuf_t *gbuf, const char *project_name
             CBMHashTable *visited = direct ? NULL : cbm_ht_create(16);
             if (visited) {
                 barrel = pxc_barrel_symbol_qn(gbuf, project_name, target, local, 0, visited);
-                cbm_ht_free(visited);
+                pxc_barrel_visited_free(visited);
             }
             free(direct);
             if (barrel) {
                 free(value);
                 value = barrel;
             }
         }
+        if (!pxc_import_map_reserve(&keys, &vals, &capacity, (size_t)count + 1)) {
+            free(local);
+            free(value);
+            continue;
+        }
         keys[count] = local;
         vals[count] = value;
         count++;
+        if (pxc_is_js_family(lang) && pxc_js_namespace_local(result, local)) {
+            pxc_add_js_namespace_members(gbuf, project_name, result, local, target, &keys, &vals,
+                                         &count, &capacity);
+        }
     }
 
     /* IMPORTS edges are best-effort graph relationships. The cross-LSP still
@@ -1745,7 +1888,8 @@ int cbm_pxc_build_import_map_ex(const cbm_gbuf_t *gbuf, const char *project_name
         if (!value)
             continue;
         char *local = strdup(imp->local_name);
-        if (!local) {
+        if (!local || !pxc_import_map_reserve(&keys, &vals, &capacity, (size_t)count + 1)) {
+            free(local);
             free(value);
             continue;
         }
 
@@ -1880,6 +1880,32 @@ static cbm_resolution_t resolve_import_map(const cbm_registry_t *r, const char *
         return empty_result();
     }
 
+    /* Whole-callee key. The JS/TS import map adds "ns.member" for a call
+     * through a namespace import whose member it followed to the defining
+     * file (cbm_pxc_build_import_map). It wins over the split lookup below,
+     * which only sees the imported module and misses re-exported members. */
+    if (suffix && suffix[0]) {
+        char whole[CBM_SZ_512];
+        int wn = snprintf(whole, sizeof(whole), "%s.%s", prefix, suffix);
+        const char *member_qn = NULL;
+        if (wn > 0 && (size_t)wn < sizeof(whole)) {
+            if (_import_map_cache) {
+                member_qn = (const char *)cbm_ht_get(_import_map_cache, whole);
+            } else {
+                for (int i = 0; i < map_count; i++) {
+                    if (strcmp(keys[i], whole) == 0) {
+                        member_qn = vals[i];
+                        break;
+                    }
+                }
+            }
+        }
+        const char *direct = member_qn ? cbm_ht_get_key(r->exact, member_qn) : NULL;
+        if (direct) {
+            return (cbm_resolution_t){direct, "import_map", CONF_IMPORT_MAP, REG_RESOLVED};
+        }
+    }
+
     /* Build candidate: resolved.suffix or resolved.prefix.
      * When the callee has a dot ("pkg.Func"), prefix="pkg" is the import key
      * and suffix="Func" is the function name, so the target QN is
 
@@ -1385,6 +1385,65 @@ TEST(lrp_ts_barrel_reexport_member_calls) {
     PASS();
 }
 
+/* JS namespace imports. `import * as ns from './m'; ns.fn()` binds the
+ * call to m's `fn` (N1). When m only re-exports the name, the call binds
+ * through the re-export to the defining file: `export *` (N2), a renamed
+ * `export { a as b }` (N3) and a barrel folder's index.js (N4). A decoy
+ * function with the N2 name lives in another file, so a name guess cannot
+ * make N2 pass and the decoy must get no edge (D). */
+TEST(lrp_js_namespace_import_member_calls) {
+    static const LRP_File f[] = {
+        {"src/lib/direct.js", "export function directFn(x) { return x + 1; }\n"},
+        {"src/lib/impl.js", "export function starFn(x) { return x * 2; }\n"
+                            "export function innerFn(x) { return x - 1; }\n"},
+        {"src/lib/barrel.js", "export * from './impl';\n"
+                              "export { innerFn as renamedFn } from './impl';\n"},
+        {"src/lib/pkg/pkgimpl.js", "export function pkgFn(x) { return x * 3; }\n"},
+        {"src/lib/pkg/index.js", "export { pkgFn } from './pkgimpl';\n"},
+        {"src/other/decoy.js", "export function starFn(x) { return 0; }\n"},
+        {"src/app.js", "import * as direct from './lib/direct';\n"
+                       "import * as barrel from './lib/barrel';\n"
+                       "import * as pkg from './lib/pkg';\n"
+                       "export function run(x) {\n"
+                       "  const a = direct.directFn(x);\n"
+                       "  const b = barrel.starFn(x);\n"
+                       "  const c = barrel.renamedFn(x);\n"
+                       "  const d = pkg.pkgFn(x);\n"
+                       "  return a + b + c + d;\n"
+                       "}\n"},
+        /* A namespace import before another import: its member entry fills
+         * the map's first-estimate slots, so the next import must grow it. */
+        {"src/two.js", "import * as direct from './lib/direct';\n"
+                       "import { pkgFn } from './lib/pkg/pkgimpl';\n"
+                       "export function runTwo(x) { return direct.directFn(x) + pkgFn(x); }\n"},
+    };
+    LRP_Proj lp;
+    cbm_store_t *store = lrp_index(&lp, f, (int)(sizeof(f) / sizeof(f[0])));
+    ASSERT_NOT_NULL(store);
+
+    int n1 = lrp_exact_edge_by_qn_suffix(store, lp.project, "CALLS", "app.run", "direct.directFn");
+    int n2 = lrp_exact_edge_by_qn_suffix(store, lp.project, "CALLS", "app.run", "impl.starFn");
+    int n3 = lrp_exact_edge_by_qn_suffix(store, lp.project, "CALLS", "app.run", "impl.innerFn");
+    int n4 = lrp_exact_edge_by_qn_suffix(store, lp.project, "CALLS", "app.run", "pkgimpl.pkgFn");
+    int d = lrp_exact_edge_by_qn_suffix(store, lp.project, "CALLS", "app.run", "decoy.starFn");
+    int t1 = lrp_exact_edge_by_qn_suffix(store, lp.project, "CALLS", "two.runTwo",
+                                         "direct.directFn");
+    int t2 = lrp_exact_edge_by_qn_suffix(store, lp.project, "CALLS", "two.runTwo",
+                                         "pkgimpl.pkgFn");
+    printf("  [js/namespace] N1=%d N2=%d N3=%d N4=%d decoy=%d T1=%d T2=%d\n", n1, n2, n3, n4, d,
+           t1, t2);
+    lrp_cleanup(&lp, store);
+
+    ASSERT_EQ(n1, 1);
+    ASSERT_EQ(n2, 1);
+    ASSERT_EQ(n3, 1);
+    ASSERT_EQ(n4, 1);
+    ASSERT_EQ(d, 0);
+    ASSERT_EQ(t1, 1);
+    ASSERT_EQ(t2, 1);
+    PASS();
+}
+
 /* ══════════════════════════════════════════════════════════════════════
  * ─── GROUP 7: JAVA (lsp_cross NOT WIRED) ─────────────────────────────
  * ══════════════════════════════════════════════════════════════════════
@@ -2033,6 +2092,7 @@ SUITE(lsp_resolution_probe) {
     RUN_TEST(lrp_ts_s7_generic);
     RUN_TEST(lrp_ts_s8_field_type_hint);
     RUN_TEST(lrp_ts_barrel_reexport_member_calls);
+    RUN_TEST(lrp_js_namespace_import_member_calls);
 
     /* ── Java (lsp_cross NOT WIRED) — S1 GREEN, S2–S8 RED reproductions ── */
     RUN_TEST(lrp_java_s1_crossfile_call);