@lzehrung/codegraph 2.3.30 → 2.3.31

package/dist/bin/cli.js

@@ -41387,6 +41387,108 @@ var init_angularjs2 = __esm({
   }
 });
 
+// dist/util/dynamic-import-tables.js
+function createDynamicImportEntries(folds) {
+  const JS_TS_DYNAMIC_IMPORT_ENTRY = {
+    // Comments are blanked before matching so a `require(...)` inside a comment cannot match;
+    // string literals stay intact because the fold reads their contents.
+    text: stripJsLikeComments,
+    guard: buildJsLikeLiteralMask,
+    shapes: [
+      {
+        pattern: JS_DYNAMIC_PATH_CALL_PATTERN,
+        fold: folds.foldCapturedPath(JS_PATH_FOLD_PROFILE, folds.resolveFoldedPathAgainstBase)
+      },
+      {
+        pattern: JS_DYNAMIC_URL_CALL_PATTERN,
+        fold: ({ match, fromFile }) => {
+          const folded = folds.foldNewUrlArgument(match[1] ?? "", JS_PATH_FOLD_PROFILE);
+          return folded ? folds.resolveFoldedPathAgainstFileDir(folded, fromFile) : null;
+        }
+      }
+    ]
+  };
+  const RUBY_DYNAMIC_IMPORT_ENTRY = {
+    text: (source) => source,
+    guard: (text) => buildTriviaMask(text, "ruby"),
+    shapes: [
+      {
+        // Only the computed `require File.join(__dir__, ...)` form is folded here; bare-string
+        // requires flow through the static pipeline and `$LOAD_PATH` lookups stay external.
+        pattern: RUBY_REQUIRE_FILE_JOIN_PATTERN,
+        fold: folds.foldCapturedPath(RUBY_PATH_FOLD_PROFILE, folds.resolveFoldedPathByConcatenation)
+      }
+    ]
+  };
+  const PHP_DYNAMIC_IMPORT_ENTRY = {
+    text: (source) => source,
+    guard: (text) => buildTriviaMask(text, "php"),
+    shapes: [
+      {
+        // Computed `include`/`require` whose path is a constant chain rooted at `__DIR__` (or
+        // the legacy `dirname(__FILE__)`); plain string operands stay with the static pipeline
+        // and the include-path search stays external.
+        pattern: PHP_COMPUTED_INCLUDE_PATTERN,
+        fold: folds.foldCapturedPath(PHP_PATH_FOLD_PROFILE, folds.resolveFoldedPathByConcatenation)
+      }
+    ]
+  };
+  const PYTHON_DYNAMIC_IMPORT_ENTRY = {
+    text: (source) => source,
+    guard: (text) => buildTriviaMask(text, "python"),
+    prepare: (source) => {
+      const { importlibAliases, importModuleAliases } = folds.collectPythonDynamicImportAliases(source);
+      return { pythonImportlibAliases: importlibAliases, pythonImportModuleAliases: importModuleAliases };
+    },
+    shapes: [
+      {
+        pattern: PYTHON_DYNAMIC_CALL_PREFIX_PATTERN,
+        fold: ({ text, match, preparation }) => folds.foldPythonDynamicModuleArgument(text, match, preparation)
+      }
+    ]
+  };
+  const entries = {
+    js: JS_TS_DYNAMIC_IMPORT_ENTRY,
+    ts: JS_TS_DYNAMIC_IMPORT_ENTRY,
+    python: PYTHON_DYNAMIC_IMPORT_ENTRY,
+    ruby: RUBY_DYNAMIC_IMPORT_ENTRY,
+    php: PHP_DYNAMIC_IMPORT_ENTRY
+  };
+  return entries;
+}
+var JS_PATH_FOLD_PROFILE, RUBY_PATH_FOLD_PROFILE, PHP_PATH_FOLD_PROFILE, JS_DYNAMIC_PATH_CALL_PATTERN, JS_DYNAMIC_URL_CALL_PATTERN, RUBY_REQUIRE_FILE_JOIN_PATTERN, PHP_COMPUTED_INCLUDE_PATTERN, PYTHON_DYNAMIC_CALL_PREFIX_PATTERN;
+var init_dynamic_import_tables = __esm({
+  "dist/util/dynamic-import-tables.js"() {
+    "use strict";
+    init_comments();
+    init_identifiers();
+    init_trivia();
+    JS_PATH_FOLD_PROFILE = {
+      bases: {
+        __dirname: "fileDir",
+        __filename: "filePath",
+        "import.meta.url": "filePath",
+        "process.cwd()": "project"
+      },
+      joinHelpers: ["path.join", "path.resolve"]
+    };
+    RUBY_PATH_FOLD_PROFILE = {
+      bases: { __dir__: "fileDir" },
+      joinHelpers: ["File.join"]
+    };
+    PHP_PATH_FOLD_PROFILE = {
+      bases: { __DIR__: "fileDir", "dirname(__FILE__)": "fileDir" },
+      joinHelpers: [],
+      concat: "."
+    };
+    JS_DYNAMIC_PATH_CALL_PATTERN = /(?<!["'`])\b(?:require|import)\s*\(\s*(path\.(?:join|resolve)\s*\((?:[^()]|\([^()]*\))*\))\s*\)/g;
+    JS_DYNAMIC_URL_CALL_PATTERN = /(?<!["'`])\b(?:require|import)\s*\(\s*(new\s+URL\s*\([^)]*\))\s*\)/g;
+    RUBY_REQUIRE_FILE_JOIN_PATTERN = /(?<![\p{XID_Continue}])require\s*\(?\s*(File\.join\s*\((?:[^()]|\([^()]*\))*\))/gu;
+    PHP_COMPUTED_INCLUDE_PATTERN = /(?<![\p{XID_Continue}$])(?:include_once|include|require_once|require)\b\s*\(?\s*([^;\r\n]*?)\s*\)?\s*;/gu;
+    PYTHON_DYNAMIC_CALL_PREFIX_PATTERN = new RegExp(String.raw`(?<![._\p{XID_Continue}])(${PYTHON_IDENTIFIER_SOURCE})(?:\s*\.\s*(${PYTHON_IDENTIFIER_SOURCE}))?\s*\(\s*(?:name\s*=\s*)?`, "gmu");
+  }
+});
+
 // dist/util/specifiers.js
 import path30 from "node:path";
 function splitJsTsNamedSpecifiers(namedBlock) {
@@ -41835,89 +41937,19 @@ function extractPythonSpecifiers(source) {
   }
   return out;
 }
-var JS_TS_NAMED_TYPE_SPECIFIER_PATTERN, JS_PATH_FOLD_PROFILE, RUBY_PATH_FOLD_PROFILE, PHP_PATH_FOLD_PROFILE, JOIN_HELPER_PATTERNS, JS_DYNAMIC_PATH_CALL_PATTERN, JS_DYNAMIC_URL_CALL_PATTERN, RUBY_REQUIRE_FILE_JOIN_PATTERN, PHP_COMPUTED_INCLUDE_PATTERN, JS_TS_DYNAMIC_IMPORT_ENTRY, RUBY_DYNAMIC_IMPORT_ENTRY, PHP_DYNAMIC_IMPORT_ENTRY, PYTHON_DOTTED_NAME_SOURCE, PYTHON_IMPORTLIB_ALIAS_PATTERN, PYTHON_IMPORT_MODULE_ALIAS_PATTERN, PYTHON_DYNAMIC_CALL_PREFIX_PATTERN, PYTHON_DYNAMIC_MODULE_PATTERN, PYTHON_FROM_IMPORTLIB_PATTERN, PYTHON_SIMPLE_STRING_ESCAPES, PYTHON_DYNAMIC_IMPORT_ENTRY, DYNAMIC_IMPORT_SPECIFIER_EXTRACTORS;
+var JS_TS_NAMED_TYPE_SPECIFIER_PATTERN, JOIN_HELPER_PATTERNS, PYTHON_DOTTED_NAME_SOURCE, PYTHON_IMPORTLIB_ALIAS_PATTERN, PYTHON_IMPORT_MODULE_ALIAS_PATTERN, PYTHON_DYNAMIC_MODULE_PATTERN, PYTHON_FROM_IMPORTLIB_PATTERN, PYTHON_SIMPLE_STRING_ESCAPES, DYNAMIC_IMPORT_SPECIFIER_EXTRACTORS;
 var init_specifiers = __esm({
   "dist/util/specifiers.js"() {
     "use strict";
     init_comments();
+    init_dynamic_import_tables();
     init_identifiers();
-    init_trivia();
     init_paths();
     JS_TS_NAMED_TYPE_SPECIFIER_PATTERN = new RegExp(String.raw`^type\s+(${ECMASCRIPT_IDENTIFIER_SOURCE})(?:\s+as\s+(${ECMASCRIPT_IDENTIFIER_SOURCE}))?$`, "u");
-    JS_PATH_FOLD_PROFILE = {
-      bases: {
-        __dirname: "fileDir",
-        __filename: "filePath",
-        "import.meta.url": "filePath",
-        "process.cwd()": "project"
-      },
-      joinHelpers: ["path.join", "path.resolve"]
-    };
-    RUBY_PATH_FOLD_PROFILE = {
-      bases: { __dir__: "fileDir" },
-      joinHelpers: ["File.join"]
-    };
-    PHP_PATH_FOLD_PROFILE = {
-      bases: { __DIR__: "fileDir", "dirname(__FILE__)": "fileDir" },
-      joinHelpers: [],
-      concat: "."
-    };
     JOIN_HELPER_PATTERNS = /* @__PURE__ */ new WeakMap();
-    JS_DYNAMIC_PATH_CALL_PATTERN = /(?<!["'`])\b(?:require|import)\s*\(\s*(path\.(?:join|resolve)\s*\((?:[^()]|\([^()]*\))*\))\s*\)/g;
-    JS_DYNAMIC_URL_CALL_PATTERN = /(?<!["'`])\b(?:require|import)\s*\(\s*(new\s+URL\s*\([^)]*\))\s*\)/g;
-    RUBY_REQUIRE_FILE_JOIN_PATTERN = /(?<![\p{XID_Continue}])require\s*\(?\s*(File\.join\s*\((?:[^()]|\([^()]*\))*\))/gu;
-    PHP_COMPUTED_INCLUDE_PATTERN = /(?<![\p{XID_Continue}$])(?:include_once|include|require_once|require)\b\s*\(?\s*([^;\r\n]*?)\s*\)?\s*;/gu;
-    JS_TS_DYNAMIC_IMPORT_ENTRY = {
-      languageId: "js",
-      // Comments are blanked before matching so a `require(...)` inside a comment cannot match;
-      // string literals stay intact because the fold reads their contents.
-      text: stripJsLikeComments,
-      guard: buildJsLikeLiteralMask,
-      shapes: [
-        {
-          pattern: JS_DYNAMIC_PATH_CALL_PATTERN,
-          fold: foldCapturedPath(JS_PATH_FOLD_PROFILE, resolveFoldedPathAgainstBase)
-        },
-        {
-          pattern: JS_DYNAMIC_URL_CALL_PATTERN,
-          fold: ({ match, fromFile }) => {
-            const folded = foldNewUrlArgument(match[1] ?? "", JS_PATH_FOLD_PROFILE);
-            return folded ? resolveFoldedPathAgainstFileDir(folded, fromFile) : null;
-          }
-        }
-      ]
-    };
-    RUBY_DYNAMIC_IMPORT_ENTRY = {
-      languageId: "ruby",
-      text: (source) => source,
-      guard: (text) => buildTriviaMask(text, "ruby"),
-      shapes: [
-        {
-          // Only the computed `require File.join(__dir__, ...)` form is folded here; bare-string
-          // requires flow through the static pipeline and `$LOAD_PATH` lookups stay external.
-          pattern: RUBY_REQUIRE_FILE_JOIN_PATTERN,
-          fold: foldCapturedPath(RUBY_PATH_FOLD_PROFILE, resolveFoldedPathByConcatenation)
-        }
-      ]
-    };
-    PHP_DYNAMIC_IMPORT_ENTRY = {
-      languageId: "php",
-      text: (source) => source,
-      guard: (text) => buildTriviaMask(text, "php"),
-      shapes: [
-        {
-          // Computed `include`/`require` whose path is a constant chain rooted at `__DIR__` (or
-          // the legacy `dirname(__FILE__)`); plain string operands stay with the static pipeline
-          // and the include-path search stays external.
-          pattern: PHP_COMPUTED_INCLUDE_PATTERN,
-          fold: foldCapturedPath(PHP_PATH_FOLD_PROFILE, resolveFoldedPathByConcatenation)
-        }
-      ]
-    };
     PYTHON_DOTTED_NAME_SOURCE = String.raw`${PYTHON_IDENTIFIER_SOURCE}(?:\.${PYTHON_IDENTIFIER_SOURCE})*`;
     PYTHON_IMPORTLIB_ALIAS_PATTERN = new RegExp(String.raw`^importlib(?:\s+as\s+(${PYTHON_IDENTIFIER_SOURCE}))?$`, "u");
     PYTHON_IMPORT_MODULE_ALIAS_PATTERN = new RegExp(String.raw`^import_module(?:\s+as\s+(${PYTHON_IDENTIFIER_SOURCE}))?$`, "u");
-    PYTHON_DYNAMIC_CALL_PREFIX_PATTERN = new RegExp(String.raw`(?<![._\p{XID_Continue}])(${PYTHON_IDENTIFIER_SOURCE})(?:\s*\.\s*(${PYTHON_IDENTIFIER_SOURCE}))?\s*\(\s*(?:name\s*=\s*)?`, "gmu");
     PYTHON_DYNAMIC_MODULE_PATTERN = new RegExp(String.raw`^\.*${PYTHON_DOTTED_NAME_SOURCE}$`, "u");
     PYTHON_FROM_IMPORTLIB_PATTERN = /^\s*from\s+importlib\s+import\s+(?:\(([\s\S]*?)\)|([^\r\n;]+))/gmu;
     PYTHON_SIMPLE_STRING_ESCAPES = {
@@ -41932,28 +41964,15 @@ var init_specifiers = __esm({
       t: "	",
       v: "\v"
     };
-    PYTHON_DYNAMIC_IMPORT_ENTRY = {
-      languageId: "python",
-      text: (source) => source,
-      guard: (text) => buildTriviaMask(text, "python"),
-      prepare: (source) => {
-        const { importlibAliases, importModuleAliases } = collectPythonDynamicImportAliases(source);
-        return { pythonImportlibAliases: importlibAliases, pythonImportModuleAliases: importModuleAliases };
-      },
-      shapes: [
-        {
-          pattern: PYTHON_DYNAMIC_CALL_PREFIX_PATTERN,
-          fold: ({ text, match, preparation }) => foldPythonDynamicModuleArgument(text, match, preparation)
-        }
-      ]
-    };
-    DYNAMIC_IMPORT_SPECIFIER_EXTRACTORS = {
-      js: JS_TS_DYNAMIC_IMPORT_ENTRY,
-      ts: JS_TS_DYNAMIC_IMPORT_ENTRY,
-      python: PYTHON_DYNAMIC_IMPORT_ENTRY,
-      ruby: RUBY_DYNAMIC_IMPORT_ENTRY,
-      php: PHP_DYNAMIC_IMPORT_ENTRY
-    };
+    DYNAMIC_IMPORT_SPECIFIER_EXTRACTORS = createDynamicImportEntries({
+      foldCapturedPath,
+      foldNewUrlArgument,
+      resolveFoldedPathAgainstBase,
+      resolveFoldedPathAgainstFileDir,
+      resolveFoldedPathByConcatenation,
+      foldPythonDynamicModuleArgument,
+      collectPythonDynamicImportAliases
+    });
   }
 });
 
@@ -46827,6 +46846,418 @@ var init_parse_context = __esm({
   }
 });
 
+// dist/indexer/imports/import-binding-tables.js
+function pushCsharpOverride(context, parsed, typeOnly, fromValue, resolved) {
+  if (parsed.alias) {
+    const fromParts = parsed.from.split(".");
+    const imported = fromParts[fromParts.length - 1] ?? parsed.alias;
+    context.pushBinding({
+      kind: "named",
+      local: parsed.alias,
+      imported,
+      from: fromValue,
+      explicitAlias: true,
+      resolved,
+      typeOnly
+    });
+    return;
+  }
+  context.pushBinding({
+    kind: "star",
+    from: fromValue,
+    resolved,
+    typeOnly
+  });
+}
+async function applyCsharpStatementOverride(context, normalizedStmt, typeOnly) {
+  const externAlias = normalizedStmt.match(CSHARP_EXTERN_ALIAS_PATTERN)?.[1];
+  if (externAlias) {
+    context.pushBinding({ kind: "namespace", localNS: externAlias, from: externAlias });
+    return true;
+  }
+  const parsed = parseCsharpUsingDirective(normalizedStmt);
+  if (!parsed)
+    return false;
+  const namespaceTargets = await resolveCsharpNamespaceImportPaths(context.projectRoot, parsed.from, context.file);
+  if (parsed.alias && namespaceTargets.length) {
+    context.pushBinding({
+      kind: "namespace",
+      localNS: parsed.alias,
+      from: parsed.from,
+      ...namespaceTargets.length === 1 ? { resolved: namespaceTargets[0].replace(/\\/g, "/") } : {},
+      typeOnly
+    });
+    return true;
+  }
+  let fromValue = parsed.from;
+  let resolved = await context.resolveFrom(fromValue);
+  if (typeof resolved !== "string" && namespaceTargets.length === 1) {
+    resolved = namespaceTargets[0].replace(/\\/g, "/");
+  }
+  if (parsed.alias) {
+    const fromParts = parsed.from.split(".");
+    if (typeof resolved !== "string" && fromParts.length > 1) {
+      const fallbackFrom = fromParts.slice(0, -1).join(".");
+      if (fallbackFrom) {
+        const fallbackResolved = await context.resolveFrom(fallbackFrom);
+        if (typeof fallbackResolved === "string") {
+          fromValue = fallbackFrom;
+          resolved = fallbackResolved;
+        }
+      }
+    }
+  }
+  pushCsharpOverride(context, parsed, typeOnly, fromValue, resolved);
+  return true;
+}
+async function applyJavaStatementOverride(context, normalizedStmt, typeOnly) {
+  return await applyJvmStatementOverride(context, normalizedStmt, typeOnly, parseJavaImportStatement, (parsed) => {
+    if (parsed.kind === "named")
+      return parsed.imported;
+    return void 0;
+  });
+}
+async function applyKotlinStatementOverride(context, normalizedStmt, typeOnly) {
+  return await applyJvmStatementOverride(context, normalizedStmt, typeOnly, parseKotlinImportStatement, (parsed) => {
+    if (parsed.kind === "named")
+      return parsed.local;
+    return void 0;
+  });
+}
+async function applyJvmStatementOverride(context, normalizedStmt, typeOnly, parseStatement, localNameFor) {
+  const parsed = parseStatement(normalizedStmt);
+  if (!parsed)
+    return false;
+  return await pushJvmImportBinding(context, parsed, localNameFor(parsed), typeOnly);
+}
+async function pushJvmImportBinding(context, parsed, local, typeOnly) {
+  const resolved = await context.resolveFrom(parsed.from);
+  if (parsed.kind === "star") {
+    context.pushBinding({
+      kind: "star",
+      from: parsed.from,
+      resolved,
+      typeOnly
+    });
+    return true;
+  }
+  context.pushBinding({
+    kind: "named",
+    local: local ?? parsed.imported,
+    imported: parsed.imported,
+    from: parsed.from,
+    ...parsed.explicitAlias ? { explicitAlias: true } : {},
+    resolved,
+    typeOnly
+  });
+  return true;
+}
+async function applyRustStatementOverride(context, normalizedStmt, typeOnly, statementStartIndex) {
+  if (isRustTestOnlyStatement(context, normalizedStmt, statementStartIndex))
+    return true;
+  const parsedList = parseRustImportStatements(normalizedStmt);
+  if (!parsedList.length)
+    return false;
+  const seen = new Set(context.getBindings().map(rustBindingKey));
+  await pushParsedRustImports(context, parsedList, typeOnly, statementStartIndex, seen);
+  return true;
+}
+async function resolveRustParsedFrom(context, from4, pathAttribute, statementStartIndex) {
+  if (pathAttribute) {
+    const attributed = await resolveRustImportPath(context.projectRoot, context.file, from4, pathAttribute, statementStartIndex);
+    if (attributed)
+      return attributed.replace(/\\/g, "/");
+    return { external: from4 };
+  }
+  return context.resolveFrom(from4);
+}
+function rustBindingKey(binding) {
+  const resolved = JSON.stringify(binding.resolved);
+  if (binding.kind === "named")
+    return `named:${binding.local}:${binding.imported}:${binding.from}:${resolved}`;
+  if (binding.kind === "namespace")
+    return `namespace:${binding.localNS}:${binding.from}:${resolved}`;
+  if (binding.kind === "star")
+    return `star:${binding.from}:${resolved}`;
+  return JSON.stringify(binding);
+}
+function buildRustBinding(parsed, resolved, typeOnly) {
+  if (parsed.kind === "member") {
+    return {
+      kind: "named",
+      local: parsed.local,
+      imported: parsed.imported,
+      from: parsed.from,
+      ...parsed.explicitAlias ? { explicitAlias: true } : {},
+      resolved,
+      typeOnly
+    };
+  }
+  if (parsed.kind === "module") {
+    return { kind: "namespace", localNS: parsed.local, from: parsed.from, resolved, typeOnly };
+  }
+  return { kind: "star", from: parsed.from, resolved, typeOnly };
+}
+async function pushParsedRustImports(context, parsedList, typeOnly, statementStartIndex, seen) {
+  const statementPathAttribute = extractRustModPathAttribute(context.source, void 0, statementStartIndex);
+  for (const parsed of parsedList) {
+    const pathAttribute = parsed.kind === "module" && !parsed.isExternCrate ? parsed.pathAttribute ?? statementPathAttribute : void 0;
+    const resolved = await resolveRustParsedFrom(context, parsed.from, pathAttribute, statementStartIndex);
+    const binding = buildRustBinding(parsed, resolved, typeOnly);
+    const key = rustBindingKey(binding);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    context.pushBinding(binding);
+  }
+}
+function isRustTestOnlyStatement(context, normalizedStmt, statementStartIndex) {
+  if (context.languageId !== "rust")
+    return false;
+  if (statementStartIndex !== void 0) {
+    const keywordOffset = rustImportKeywordOffset(context.source.slice(statementStartIndex));
+    const keywordIndex = keywordOffset >= 0 ? statementStartIndex + keywordOffset : statementStartIndex;
+    const keywordText = keywordOffset >= 0 ? context.source.slice(keywordIndex) : normalizedStmt;
+    return isRustCfgTestStatement(context.source, keywordText, keywordIndex);
+  }
+  return isRustCfgTestStatement(context.source, normalizedStmt, statementStartIndex);
+}
+async function applyPhpStatementOverride(context, normalizedStmt, typeOnly) {
+  const parsed = parsePhpImportStatement(normalizedStmt, context.file);
+  if (!parsed.length)
+    return false;
+  for (const entry of parsed) {
+    if (entry.kind === "include") {
+      const resolved2 = await context.resolveFrom(entry.from);
+      context.pushBinding({
+        kind: "star",
+        from: entry.from,
+        resolved: resolved2,
+        typeOnly,
+        mechanism: "php"
+      });
+      continue;
+    }
+    const resolved = await context.resolveFrom(entry.from, entry.importType);
+    context.pushBinding({
+      kind: "named",
+      local: entry.local,
+      imported: entry.imported,
+      from: entry.from,
+      ...entry.explicitAlias ? { explicitAlias: true } : {},
+      phpImportType: entry.importType,
+      resolved,
+      typeOnly,
+      mechanism: "php"
+    });
+  }
+  return true;
+}
+function pushNamedImplicitBinding(context, binding, stmtText, stmtStartIndex, source, alwaysAliased) {
+  if (stmtStartIndex !== void 0 && source !== void 0) {
+    attributeNamedBindingRanges({
+      bindings: [binding],
+      fromIndex: 0,
+      text: maskImportBindingTrivia(stmtText, context.languageId),
+      textStartIndex: stmtStartIndex,
+      source,
+      ...alwaysAliased !== void 0 ? { alwaysAliased } : {}
+    });
+  }
+  context.pushBinding(binding);
+}
+function appendJavaImplicitBinding(context, { from: from4, resolved, typeOnly, stmtText, stmtStartIndex, source }) {
+  const parts = from4.split(".");
+  const last = parts[parts.length - 1];
+  if (last === "*") {
+    context.pushBinding({ kind: "star", from: from4, resolved, typeOnly });
+  } else if (last) {
+    pushNamedImplicitBinding(context, { kind: "named", local: last, imported: last, from: from4, resolved, typeOnly }, stmtText, stmtStartIndex, source, void 0);
+  }
+}
+function appendCsharpImplicitBinding(context, { from: from4, resolved, typeOnly, stmtText, stmtStartIndex, source, alias }) {
+  if (alias) {
+    const fromParts = from4.split(".");
+    const imported = fromParts[fromParts.length - 1] ?? alias;
+    pushNamedImplicitBinding(context, { kind: "named", local: alias, imported, from: from4, explicitAlias: true, resolved, typeOnly }, stmtText, stmtStartIndex, source, IMPORT_BINDING_ROWS.csharp.alwaysAliased);
+  } else {
+    context.pushBinding({ kind: "star", from: from4, resolved, typeOnly });
+  }
+}
+function appendRubyImplicitBinding(context, { from: from4, resolved }) {
+  context.pushBinding({ kind: "star", from: from4, resolved });
+}
+function appendGoImplicitBinding(context, { from: from4, resolved, alias }) {
+  if (alias === "_")
+    return;
+  if (alias === ".") {
+    context.pushBinding({ kind: "star", from: from4, resolved });
+    return;
+  }
+  if (alias) {
+    context.pushBinding({ kind: "namespace", localNS: alias, from: from4, resolved });
+    return;
+  }
+  const parts = from4.replace(/"/g, "").split("/");
+  const last = parts[parts.length - 1];
+  if (last)
+    context.pushBinding({ kind: "namespace", localNS: last, from: from4, resolved });
+}
+function appendRustImplicitBinding(context, { from: from4, resolved, stmtText, stmtStartIndex, source }) {
+  if (stmtText.startsWith("mod ")) {
+    context.pushBinding({ kind: "namespace", localNS: from4, from: from4, resolved });
+  } else {
+    const parts = from4.split("::");
+    const last = parts[parts.length - 1];
+    if (!last)
+      return;
+    if (last === "*") {
+      context.pushBinding({ kind: "star", from: from4, resolved });
+    } else {
+      pushNamedImplicitBinding(context, { kind: "named", local: last, imported: last, from: from4, resolved }, stmtText, stmtStartIndex, source, void 0);
+    }
+  }
+}
+function appendKotlinImplicitBinding(context, { from: from4, resolved, typeOnly, stmtText, stmtStartIndex, source, alias, wildcard }) {
+  if (wildcard || from4.endsWith(".*")) {
+    context.pushBinding({ kind: "star", from: from4, resolved, typeOnly });
+  } else {
+    const parts = from4.split(".");
+    const imported = parts[parts.length - 1];
+    if (imported)
+      pushNamedImplicitBinding(context, {
+        kind: "named",
+        local: alias ?? imported,
+        imported,
+        from: from4,
+        ...alias !== void 0 ? { explicitAlias: true } : {},
+        resolved,
+        typeOnly
+      }, stmtText, stmtStartIndex, source, void 0);
+  }
+}
+function appendSwiftImplicitBinding(context, { from: from4, resolved, typeOnly, stmtText, stmtStartIndex, source }) {
+  const parts = from4.split(".");
+  const last = parts[parts.length - 1];
+  if (!last)
+    return;
+  if (parts.length === 1) {
+    context.pushBinding({ kind: "namespace", localNS: last, from: from4, resolved, typeOnly });
+    context.pushBinding({ kind: "star", from: from4, resolved, typeOnly });
+  } else {
+    pushNamedImplicitBinding(context, { kind: "named", local: last, imported: last, from: from4, resolved, typeOnly }, stmtText, stmtStartIndex, source, void 0);
+  }
+}
+function appendZigImplicitBinding(context, { from: from4, resolved, typeOnly, alias }) {
+  if (alias)
+    context.pushBinding({ kind: "namespace", localNS: alias, from: from4, resolved, typeOnly });
+}
+function appendIncludeStarImplicitBinding(context, { from: from4, resolved, typeOnly }) {
+  context.pushBinding({ kind: "star", from: from4, resolved, typeOnly });
+}
+var CSHARP_EXTERN_ALIAS_PATTERN, ECMASCRIPT_STATEMENT_OMITTED, ECMASCRIPT_IMPLICIT_OMITTED, STYLESHEET_OMITTED, INCLUDE_STATEMENT_OMITTED, IMPORT_BINDING_ROWS;
+var init_import_binding_tables = __esm({
+  "dist/indexer/imports/import-binding-tables.js"() {
+    "use strict";
+    init_import_statement_parsers();
+    init_identifiers();
+    init_rust_test_modules();
+    init_csharp2();
+    init_rust2();
+    init_binding_ranges();
+    CSHARP_EXTERN_ALIAS_PATTERN = new RegExp(String.raw`^extern\s+alias\s+(${CSHARP_IDENTIFIER_SOURCE})\s*;$`, "u");
+    ECMASCRIPT_STATEMENT_OMITTED = "ECMAScript import bindings come from native captures and the JS text fallback, not a statement parser override.";
+    ECMASCRIPT_IMPLICIT_OMITTED = "ECMAScript named/default/namespace/star bindings are emitted from native captures; implicit mapping is unused.";
+    STYLESHEET_OMITTED = "Style language; import bindings are graph-only stylesheet specifiers, not this registry.";
+    INCLUDE_STATEMENT_OMITTED = "C/C++ #include bindings are implicit star imports from native captures; there is no statement parser override.";
+    IMPORT_BINDING_ROWS = {
+      adoc: { omittedReason: "AsciiDoc document format; embedded code blocks parse as their own language." },
+      astro: { omittedReason: "Astro document format; scripts parse as js/ts and templates as html." },
+      c: {
+        appendImplicit: appendIncludeStarImplicitBinding,
+        statementOmittedReason: INCLUDE_STATEMENT_OMITTED
+      },
+      cpp: {
+        appendImplicit: appendIncludeStarImplicitBinding,
+        statementOmittedReason: INCLUDE_STATEMENT_OMITTED
+      },
+      css: { omittedReason: STYLESHEET_OMITTED },
+      csharp: {
+        applyStatement: applyCsharpStatementOverride,
+        appendImplicit: appendCsharpImplicitBinding,
+        maskTrivia: true,
+        normalizeDots: true,
+        alwaysAliased: true
+      },
+      go: {
+        appendImplicit: appendGoImplicitBinding,
+        statementOmittedReason: "Go import bindings come from native captures plus implicit alias/blank/dot mapping; there is no statement parser override."
+      },
+      hbs: { omittedReason: "Handlebars document format; embedded scripts parse as their own language." },
+      html: { omittedReason: "Document format; embedded scripts parse as their own language." },
+      java: {
+        applyStatement: applyJavaStatementOverride,
+        appendImplicit: appendJavaImplicitBinding,
+        maskTrivia: true,
+        normalizeDots: true
+      },
+      js: {
+        statementOmittedReason: ECMASCRIPT_STATEMENT_OMITTED,
+        implicitOmittedReason: ECMASCRIPT_IMPLICIT_OMITTED
+      },
+      kotlin: {
+        applyStatement: applyKotlinStatementOverride,
+        appendImplicit: appendKotlinImplicitBinding,
+        maskTrivia: true,
+        normalizeDots: true
+      },
+      less: { omittedReason: STYLESHEET_OMITTED },
+      markdown: { omittedReason: "Document format; fenced code blocks parse as their own language." },
+      mdx: { omittedReason: "MDX document format; scripts parse as js/ts and templates as html." },
+      php: {
+        applyStatement: applyPhpStatementOverride,
+        maskTrivia: "use-keyword",
+        implicitOmittedReason: "PHP use and include statements are fully handled by the statement override."
+      },
+      python: {
+        omittedReason: "Python import bindings are collected in python.ts, not through statement overrides or implicit mapping."
+      },
+      rst: { omittedReason: "reStructuredText document format; embedded code blocks parse as their own language." },
+      ruby: {
+        appendImplicit: appendRubyImplicitBinding,
+        statementOmittedReason: "Ruby require/load/autoload bindings are implicit star imports from native captures; there is no statement parser override."
+      },
+      rust: {
+        applyStatement: applyRustStatementOverride,
+        appendImplicit: appendRustImplicitBinding,
+        maskTrivia: false,
+        statementKeyUsesOffset: true,
+        rescanTextBindings: true
+      },
+      scss: { omittedReason: STYLESHEET_OMITTED },
+      sql: { omittedReason: "Data language; no import-statement or implicit-binding dispatch." },
+      svelte: { omittedReason: "Svelte component format; script blocks parse as js/ts and templates as html." },
+      swift: {
+        appendImplicit: appendSwiftImplicitBinding,
+        statementOmittedReason: "Swift import bindings are implicit namespace/star (or named) mappings from native captures; there is no statement parser override."
+      },
+      ts: {
+        statementOmittedReason: ECMASCRIPT_STATEMENT_OMITTED,
+        implicitOmittedReason: ECMASCRIPT_IMPLICIT_OMITTED
+      },
+      tsx: {
+        statementOmittedReason: ECMASCRIPT_STATEMENT_OMITTED,
+        implicitOmittedReason: ECMASCRIPT_IMPLICIT_OMITTED
+      },
+      vue: { omittedReason: "Vue component format; script blocks parse as js/ts and templates as html." },
+      zig: {
+        appendImplicit: appendZigImplicitBinding,
+        statementOmittedReason: "Zig @import bindings are implicit namespace mappings from the captured alias; there is no statement parser override."
+      }
+    };
+  }
+});
+
 // dist/indexer/imports/graph-only.js
 async function collectGraphOnlyImports(context) {
   const entries = Array.from(extractGraphOnlyModuleSpecifiers(context.languageId, context.source));
@@ -47262,7 +47693,8 @@ function normalizeGoImports(context) {
 async function appendTextImportBindings(context) {
   if (!hasTextImportBindings(context.languageId))
     return;
-  if (context.languageId !== "rust" && context.getBindings().length)
+  const row = IMPORT_BINDING_ROWS[context.languageId];
+  if (!row?.rescanTextBindings && context.getBindings().length)
     return;
   const state = createStatementImportOverrideState();
   for (const request of collectTextImportBindingRequests(context.languageId, context.source, {
@@ -47278,7 +47710,7 @@ async function appendTextImportBindings(context) {
       text: maskImportBindingTrivia(request.raw, context.languageId),
       textStartIndex: request.start,
       source: context.source,
-      ...context.languageId === "csharp" ? { alwaysAliased: true } : {}
+      ...row?.alwaysAliased ? { alwaysAliased: true } : {}
     });
   }
 }
@@ -47312,362 +47744,53 @@ async function finalizeLanguageSpecificImports(context) {
   await appendTextImportBindings(context);
   await appendPhpComposerImplicitImports(context);
 }
-function pushCsharpOverride(context, parsed, typeOnly, fromValue, resolved) {
-  if (parsed.alias) {
-    const fromParts = parsed.from.split(".");
-    const imported = fromParts[fromParts.length - 1] ?? parsed.alias;
-    context.pushBinding({
-      kind: "named",
-      local: parsed.alias,
-      imported,
-      from: fromValue,
-      explicitAlias: true,
-      resolved,
-      typeOnly
-    });
-    return;
-  }
-  context.pushBinding({
-    kind: "star",
-    from: fromValue,
-    resolved,
-    typeOnly
-  });
-}
-async function applyCsharpStatementOverride(context, normalizedStmt, typeOnly) {
-  const externAlias = normalizedStmt.match(CSHARP_EXTERN_ALIAS_PATTERN)?.[1];
-  if (externAlias) {
-    context.pushBinding({ kind: "namespace", localNS: externAlias, from: externAlias });
-    return true;
-  }
-  const parsed = parseCsharpUsingDirective(normalizedStmt);
-  if (!parsed)
-    return false;
-  const namespaceTargets = await resolveCsharpNamespaceImportPaths(context.projectRoot, parsed.from, context.file);
-  if (parsed.alias && namespaceTargets.length) {
-    context.pushBinding({
-      kind: "namespace",
-      localNS: parsed.alias,
-      from: parsed.from,
-      ...namespaceTargets.length === 1 ? { resolved: namespaceTargets[0].replace(/\\/g, "/") } : {},
-      typeOnly
-    });
-    return true;
-  }
-  let fromValue = parsed.from;
-  let resolved = await context.resolveFrom(fromValue);
-  if (typeof resolved !== "string" && namespaceTargets.length === 1) {
-    resolved = namespaceTargets[0].replace(/\\/g, "/");
-  }
-  if (parsed.alias) {
-    const fromParts = parsed.from.split(".");
-    if (typeof resolved !== "string" && fromParts.length > 1) {
-      const fallbackFrom = fromParts.slice(0, -1).join(".");
-      if (fallbackFrom) {
-        const fallbackResolved = await context.resolveFrom(fallbackFrom);
-        if (typeof fallbackResolved === "string") {
-          fromValue = fallbackFrom;
-          resolved = fallbackResolved;
-        }
-      }
-    }
-  }
-  pushCsharpOverride(context, parsed, typeOnly, fromValue, resolved);
-  return true;
-}
-async function applyJavaStatementOverride(context, normalizedStmt, typeOnly) {
-  return await applyJvmStatementOverride(context, normalizedStmt, typeOnly, parseJavaImportStatement, (parsed) => {
-    if (parsed.kind === "named")
-      return parsed.imported;
-    return void 0;
-  });
-}
-async function applyKotlinStatementOverride(context, normalizedStmt, typeOnly) {
-  return await applyJvmStatementOverride(context, normalizedStmt, typeOnly, parseKotlinImportStatement, (parsed) => {
-    if (parsed.kind === "named")
-      return parsed.local;
-    return void 0;
-  });
-}
-async function applyJvmStatementOverride(context, normalizedStmt, typeOnly, parseStatement, localNameFor) {
-  const parsed = parseStatement(normalizedStmt);
-  if (!parsed)
-    return false;
-  return await pushJvmImportBinding(context, parsed, localNameFor(parsed), typeOnly);
-}
-async function pushJvmImportBinding(context, parsed, local, typeOnly) {
-  const resolved = await context.resolveFrom(parsed.from);
-  if (parsed.kind === "star") {
-    context.pushBinding({
-      kind: "star",
-      from: parsed.from,
-      resolved,
-      typeOnly
-    });
-    return true;
-  }
-  context.pushBinding({
-    kind: "named",
-    local: local ?? parsed.imported,
-    imported: parsed.imported,
-    from: parsed.from,
-    ...parsed.explicitAlias ? { explicitAlias: true } : {},
-    resolved,
-    typeOnly
-  });
-  return true;
-}
-async function applyRustStatementOverride(context, normalizedStmt, typeOnly, statementStartIndex) {
-  if (isRustTestOnlyStatement(context, normalizedStmt, statementStartIndex))
-    return true;
-  const parsedList = parseRustImportStatements(normalizedStmt);
-  if (!parsedList.length)
-    return false;
-  const seen = new Set(context.getBindings().map(rustBindingKey));
-  await pushParsedRustImports(context, parsedList, typeOnly, statementStartIndex, seen);
-  return true;
-}
-async function resolveRustParsedFrom(context, from4, pathAttribute, statementStartIndex) {
-  if (pathAttribute) {
-    const attributed = await resolveRustImportPath(context.projectRoot, context.file, from4, pathAttribute, statementStartIndex);
-    if (attributed)
-      return attributed.replace(/\\/g, "/");
-    return { external: from4 };
-  }
-  return context.resolveFrom(from4);
-}
-function rustBindingKey(binding) {
-  const resolved = JSON.stringify(binding.resolved);
-  if (binding.kind === "named")
-    return `named:${binding.local}:${binding.imported}:${binding.from}:${resolved}`;
-  if (binding.kind === "namespace")
-    return `namespace:${binding.localNS}:${binding.from}:${resolved}`;
-  if (binding.kind === "star")
-    return `star:${binding.from}:${resolved}`;
-  return JSON.stringify(binding);
-}
-function buildRustBinding(parsed, resolved, typeOnly) {
-  if (parsed.kind === "member") {
-    return {
-      kind: "named",
-      local: parsed.local,
-      imported: parsed.imported,
-      from: parsed.from,
-      ...parsed.explicitAlias ? { explicitAlias: true } : {},
-      resolved,
-      typeOnly
-    };
-  }
-  if (parsed.kind === "module") {
-    return { kind: "namespace", localNS: parsed.local, from: parsed.from, resolved, typeOnly };
-  }
-  return { kind: "star", from: parsed.from, resolved, typeOnly };
-}
-async function pushParsedRustImports(context, parsedList, typeOnly, statementStartIndex, seen) {
-  const statementPathAttribute = extractRustModPathAttribute(context.source, void 0, statementStartIndex);
-  for (const parsed of parsedList) {
-    const pathAttribute = parsed.kind === "module" && !parsed.isExternCrate ? parsed.pathAttribute ?? statementPathAttribute : void 0;
-    const resolved = await resolveRustParsedFrom(context, parsed.from, pathAttribute, statementStartIndex);
-    const binding = buildRustBinding(parsed, resolved, typeOnly);
-    const key = rustBindingKey(binding);
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    context.pushBinding(binding);
-  }
-}
-function isRustTestOnlyStatement(context, normalizedStmt, statementStartIndex) {
-  if (context.languageId !== "rust")
-    return false;
-  if (statementStartIndex !== void 0) {
-    const keywordOffset = rustImportKeywordOffset(context.source.slice(statementStartIndex));
-    const keywordIndex = keywordOffset >= 0 ? statementStartIndex + keywordOffset : statementStartIndex;
-    const keywordText = keywordOffset >= 0 ? context.source.slice(keywordIndex) : normalizedStmt;
-    return isRustCfgTestStatement(context.source, keywordText, keywordIndex);
-  }
-  return isRustCfgTestStatement(context.source, normalizedStmt, statementStartIndex);
-}
-async function applyPhpStatementOverride(context, normalizedStmt, typeOnly) {
-  const parsed = parsePhpImportStatement(normalizedStmt, context.file);
-  if (!parsed.length)
-    return false;
-  for (const entry of parsed) {
-    if (entry.kind === "include") {
-      const resolved2 = await context.resolveFrom(entry.from);
-      context.pushBinding({
-        kind: "star",
-        from: entry.from,
-        resolved: resolved2,
-        typeOnly,
-        mechanism: "php"
-      });
-      continue;
-    }
-    const resolved = await context.resolveFrom(entry.from, entry.importType);
-    context.pushBinding({
-      kind: "named",
-      local: entry.local,
-      imported: entry.imported,
-      from: entry.from,
-      ...entry.explicitAlias ? { explicitAlias: true } : {},
-      phpImportType: entry.importType,
-      resolved,
-      typeOnly,
-      mechanism: "php"
-    });
+function masksStatementTrivia(row, normalizedStmt) {
+  if (row.maskTrivia === "use-keyword")
+    return /^\s*use\b/i.test(normalizedStmt);
+  return row.maskTrivia ?? false;
+}
+function parserTextForStatement(row, languageId, normalizedStmt) {
+  if (!masksStatementTrivia(row, normalizedStmt))
+    return normalizedStmt;
+  let parserStmt = maskImportBindingTrivia(normalizedStmt, languageId);
+  if (row.normalizeDots)
+    parserStmt = parserStmt.replace(/\s*\.\s*/gu, ".");
+  return parserStmt;
+}
+function statementImportOverrideKey(row, normalizedStmt, statementStartIndex) {
+  if (row.statementKeyUsesOffset && statementStartIndex !== void 0) {
+    return `${normalizedStmt}@${statementStartIndex}`;
   }
-  return true;
+  return normalizedStmt;
 }
 async function applyStatementImportOverride(context, state, stmtText, typeOnly, statementStartIndex) {
   const normalizedStmt = stmtText.trim();
   if (!normalizedStmt)
     return false;
-  const statementKey = statementImportOverrideKey(context.languageId, normalizedStmt, statementStartIndex);
+  const row = IMPORT_BINDING_ROWS[context.languageId];
+  const applyStatement = row?.applyStatement;
+  if (!row || !applyStatement)
+    return false;
+  const statementKey = statementImportOverrideKey(row, normalizedStmt, statementStartIndex);
   if (state.handledStatements.has(statementKey))
     return true;
-  let parserStmt = normalizedStmt;
-  const canMaskStrings = context.languageId !== "rust" && (context.languageId !== "php" || /^\s*use\b/i.test(normalizedStmt));
-  if (canMaskStrings) {
-    parserStmt = maskImportBindingTrivia(normalizedStmt, context.languageId);
-    if (context.languageId === "csharp" || context.languageId === "java" || context.languageId === "kotlin") {
-      parserStmt = parserStmt.replace(/\s*\.\s*/gu, ".");
-    }
-  }
-  let handled = false;
-  if (context.languageId === "csharp") {
-    handled = await applyCsharpStatementOverride(context, parserStmt, typeOnly);
-  } else if (context.languageId === "java") {
-    handled = await applyJavaStatementOverride(context, parserStmt, typeOnly);
-  } else if (context.languageId === "kotlin") {
-    handled = await applyKotlinStatementOverride(context, parserStmt, typeOnly);
-  } else if (context.languageId === "rust") {
-    handled = await applyRustStatementOverride(context, normalizedStmt, typeOnly, statementStartIndex);
-  } else if (context.languageId === "php") {
-    handled = await applyPhpStatementOverride(context, parserStmt, typeOnly);
-  }
+  const handled = await applyStatement(context, parserTextForStatement(row, context.languageId, normalizedStmt), typeOnly, statementStartIndex);
   if (!handled)
     return false;
   state.handledStatements.add(statementKey);
   return true;
 }
-function statementImportOverrideKey(languageId, normalizedStmt, statementStartIndex) {
-  if (languageId === "rust" && statementStartIndex !== void 0) {
-    return `${normalizedStmt}@${statementStartIndex}`;
-  }
-  return normalizedStmt;
-}
 function appendImplicitImportBinding(context, args) {
-  const { from: from4, resolved, typeOnly, stmtText, stmtStartIndex, source, alias, wildcard } = args;
-  const pushNamed = (binding, alwaysAliased) => pushNamedImplicitBinding(context, binding, stmtText, stmtStartIndex, source, alwaysAliased);
-  if (context.languageId === "java") {
-    const parts = from4.split(".");
-    const last = parts[parts.length - 1];
-    if (last === "*") {
-      context.pushBinding({ kind: "star", from: from4, resolved, typeOnly });
-    } else if (last) {
-      pushNamed({ kind: "named", local: last, imported: last, from: from4, resolved, typeOnly });
-    }
-  } else if (context.languageId === "csharp") {
-    if (alias) {
-      const fromParts = from4.split(".");
-      const imported = fromParts[fromParts.length - 1] ?? alias;
-      pushNamed({ kind: "named", local: alias, imported, from: from4, explicitAlias: true, resolved, typeOnly }, true);
-    } else {
-      context.pushBinding({ kind: "star", from: from4, resolved, typeOnly });
-    }
-  } else if (context.languageId === "ruby") {
-    context.pushBinding({ kind: "star", from: from4, resolved });
-  } else if (context.languageId === "go") {
-    const goAlias = alias;
-    if (goAlias === "_")
-      return;
-    if (goAlias === ".") {
-      context.pushBinding({ kind: "star", from: from4, resolved });
-      return;
-    }
-    if (goAlias) {
-      context.pushBinding({ kind: "namespace", localNS: goAlias, from: from4, resolved });
-      return;
-    }
-    const parts = from4.replace(/"/g, "").split("/");
-    const last = parts[parts.length - 1];
-    if (last)
-      context.pushBinding({ kind: "namespace", localNS: last, from: from4, resolved });
-  } else if (context.languageId === "rust") {
-    if (stmtText.startsWith("mod ")) {
-      context.pushBinding({ kind: "namespace", localNS: from4, from: from4, resolved });
-    } else {
-      const parts = from4.split("::");
-      const last = parts[parts.length - 1];
-      if (!last)
-        return;
-      if (last === "*") {
-        context.pushBinding({ kind: "star", from: from4, resolved });
-      } else {
-        pushNamed({ kind: "named", local: last, imported: last, from: from4, resolved });
-      }
-    }
-  } else if (context.languageId === "kotlin") {
-    if (wildcard || from4.endsWith(".*")) {
-      context.pushBinding({ kind: "star", from: from4, resolved, typeOnly });
-    } else {
-      const parts = from4.split(".");
-      const imported = parts[parts.length - 1];
-      if (imported)
-        pushNamed({
-          kind: "named",
-          local: alias ?? imported,
-          imported,
-          from: from4,
-          ...alias !== void 0 ? { explicitAlias: true } : {},
-          resolved,
-          typeOnly
-        });
-    }
-  } else if (context.languageId === "swift") {
-    const parts = from4.split(".");
-    const last = parts[parts.length - 1];
-    if (!last)
-      return;
-    if (parts.length === 1) {
-      context.pushBinding({ kind: "namespace", localNS: last, from: from4, resolved, typeOnly });
-      context.pushBinding({ kind: "star", from: from4, resolved, typeOnly });
-    } else {
-      pushNamed({ kind: "named", local: last, imported: last, from: from4, resolved, typeOnly });
-    }
-  } else if (context.languageId === "zig") {
-    if (alias)
-      context.pushBinding({ kind: "namespace", localNS: alias, from: from4, resolved, typeOnly });
-  } else if (context.languageId === "c" || context.languageId === "cpp") {
-    context.pushBinding({ kind: "star", from: from4, resolved, typeOnly });
-  }
-}
-function pushNamedImplicitBinding(context, binding, stmtText, stmtStartIndex, source, alwaysAliased) {
-  if (stmtStartIndex !== void 0 && source !== void 0) {
-    attributeNamedBindingRanges({
-      bindings: [binding],
-      fromIndex: 0,
-      text: maskImportBindingTrivia(stmtText, context.languageId),
-      textStartIndex: stmtStartIndex,
-      source,
-      ...alwaysAliased !== void 0 ? { alwaysAliased } : {}
-    });
-  }
-  context.pushBinding(binding);
+  IMPORT_BINDING_ROWS[context.languageId]?.appendImplicit?.(context, args);
 }
-var CSHARP_EXTERN_ALIAS_PATTERN;
 var init_language_specific = __esm({
   "dist/indexer/imports/language-specific.js"() {
     "use strict";
-    init_import_statement_parsers();
     init_identifiers();
-    init_rust_test_modules();
     init_resolution();
-    init_csharp2();
-    init_rust2();
     init_binding_ranges();
+    init_import_binding_tables();
     init_text_import_extractors();
-    CSHARP_EXTERN_ALIAS_PATTERN = new RegExp(String.raw`^extern\s+alias\s+(${CSHARP_IDENTIFIER_SOURCE})\s*;$`, "u");
   }
 });
 
@@ -48203,7 +48326,7 @@ async function collectImportsForFile(file2, projectRoot, opts) {
         text: maskImportBindingTrivia(stmtText, resolvedSup.id),
         textStartIndex: statementStartIndex,
         source: resolvedSource,
-        alwaysAliased: resolvedSup.id === "csharp"
+        alwaysAliased: IMPORT_BINDING_ROWS[resolvedSup.id]?.alwaysAliased
       });
     }
     return handled;
@@ -48292,6 +48415,7 @@ var init_imports = __esm({
     init_comments();
     init_tree_sitter_native();
     init_binding_ranges();
+    init_import_binding_tables();
     init_graph_only();
     init_js_text_imports();
     init_language_specific();
@@ -62594,15 +62718,166 @@ var init_navigation_local = __esm({
   }
 });
 
+// dist/util/member-access-tables.js
+function supportsReceiverMemberNavigation(languageId) {
+  return MEMBER_ACCESS_ROWS[languageId]?.receiverKeywords !== void 0;
+}
+function isKeywordReceiver(languageId, receiverName) {
+  const keywords = MEMBER_ACCESS_ROWS[languageId]?.receiverKeywords;
+  if (!keywords)
+    return false;
+  return keywords.own.includes(receiverName) || keywords.supertype.includes(receiverName);
+}
+var C_FIELD_ACCESS_SHAPE, CPP_QUALIFIED_ACCESS_SHAPE, THIS_SUPER_RECEIVERS, SELF_RECEIVERS, MEMBER_ACCESS_ROWS, receiverKeywordLanguageIds;
+var init_member_access_tables = __esm({
+  "dist/util/member-access-tables.js"() {
+    "use strict";
+    C_FIELD_ACCESS_SHAPE = {
+      nodeTypes: ["field_expression"],
+      object: { field: "argument", fallbackIndex: 0 },
+      property: { field: "field", fallbackIndex: 2 }
+    };
+    CPP_QUALIFIED_ACCESS_SHAPE = {
+      nodeTypes: ["qualified_identifier"],
+      object: { field: "scope", fallbackIndex: 0 },
+      property: { field: "name", fallbackIndex: 2 }
+    };
+    THIS_SUPER_RECEIVERS = { own: ["this"], supertype: ["super"] };
+    SELF_RECEIVERS = { own: ["self"], supertype: ["super"] };
+    MEMBER_ACCESS_ROWS = {
+      adoc: { omittedReason: "AsciiDoc document format; embedded code blocks parse as their own language." },
+      astro: { omittedReason: "Astro document format; scripts parse as js/ts and templates as html." },
+      c: {
+        memberAccessShapes: [C_FIELD_ACCESS_SHAPE],
+        receiverKeywordsOmittedReason: "C has no receiver keyword; member access always names an explicit object or pointer."
+      },
+      cpp: {
+        memberAccessShapes: [C_FIELD_ACCESS_SHAPE, CPP_QUALIFIED_ACCESS_SHAPE],
+        receiverKeywords: { own: ["this"], supertype: [] }
+      },
+      css: { omittedReason: "Style language; no member-access concept." },
+      csharp: {
+        memberAccessShapes: [{ object: { index: 0 }, property: { index: 2 } }],
+        receiverKeywords: { own: ["this"], supertype: ["base"] }
+      },
+      go: {
+        extraTraversalTypes: ["qualified_type"],
+        extraMemberAccessTypes: ["qualified_type"],
+        memberAccessShapes: [{ nodeTypes: ["qualified_type"], object: { namedIndex: 0 }, property: { namedIndex: 1 } }],
+        // Go has no receiver keyword: a method call's receiver is an ordinary value. The row still
+        // exists so go receivers must be proven rather than falling back to a bare name.
+        receiverKeywords: { own: [], supertype: [] }
+      },
+      hbs: { omittedReason: "Handlebars document format; embedded scripts parse as their own language." },
+      html: { omittedReason: "Document format; embedded scripts parse as their own language." },
+      java: {
+        memberAccessShapes: [
+          {
+            nodeTypes: ["method_invocation"],
+            object: { field: "object", fallbackIndex: 0 },
+            property: { field: "name", fallbackIndex: 2 }
+          },
+          {
+            nodeTypes: ["scoped_identifier", "scoped_type_identifier"],
+            object: { field: "scope", fallbackIndex: 0 },
+            property: { field: "name", fallbackIndex: 2 }
+          }
+        ],
+        receiverKeywords: THIS_SUPER_RECEIVERS
+      },
+      js: {
+        memberAccessOmittedReason: "The shared generic default already reads member_expression's object and property fields.",
+        receiverKeywords: THIS_SUPER_RECEIVERS
+      },
+      kotlin: {
+        memberAccessShapes: [
+          { nodeTypes: ["navigation_expression"], object: { namedIndex: 0 }, property: { navigation: true } }
+        ],
+        navigationFallbackLastChild: true,
+        receiverKeywords: THIS_SUPER_RECEIVERS
+      },
+      less: { omittedReason: "Style language; no member-access concept." },
+      markdown: { omittedReason: "Document format; fenced code blocks parse as their own language." },
+      mdx: { omittedReason: "MDX document format; scripts parse as js/ts and templates as html." },
+      php: {
+        extraMemberAccessTypes: ["member_call_expression", "nullsafe_member_call_expression", "scoped_call_expression"],
+        memberAccessShapes: [
+          {
+            nodeTypes: ["member_call_expression", "nullsafe_member_call_expression"],
+            object: { field: "object", fallbackIndex: 0 },
+            property: { field: "name", fallbackIndex: 2 }
+          },
+          {
+            nodeTypes: ["scoped_call_expression"],
+            object: { field: "scope", fallbackIndex: 0 },
+            property: { field: "name", fallbackIndex: 2 }
+          }
+        ],
+        receiverKeywords: { own: ["$this", "self", "static"], supertype: ["parent"] }
+      },
+      python: {
+        memberExpressionType: "attribute",
+        memberAccessShapes: [
+          { object: { field: "object", fallbackIndex: 0 }, property: { field: "attribute", fallbackIndex: 2 } }
+        ],
+        receiverKeywords: { own: ["self", "cls"], supertype: [] }
+      },
+      rst: { omittedReason: "reStructuredText document format; embedded code blocks parse as their own language." },
+      ruby: {
+        memberExpressionType: "call",
+        memberAccessShapes: [
+          {
+            nodeTypes: ["scope_resolution"],
+            object: { field: "scope", fallbackIndex: 0 },
+            property: { field: "name", fallbackIndex: 2 }
+          },
+          // Ruby models every other member access as a `call` node with receiver and method fields.
+          { object: { field: "receiver", fallbackIndex: 0 }, property: { field: "method", fallbackIndex: 2 } }
+        ],
+        receiverKeywords: { own: ["self"], supertype: [] }
+      },
+      rust: {
+        memberAccessShapes: [
+          {
+            nodeTypes: ["scoped_identifier"],
+            object: { field: "path", fallbackIndex: 0 },
+            property: { field: "name", fallbackIndex: 2 }
+          }
+        ],
+        receiverKeywords: { own: ["self", "Self"], supertype: [] }
+      },
+      scss: { omittedReason: "Style language; no member-access concept." },
+      svelte: { omittedReason: "Svelte component format; script blocks parse as js/ts and templates as html." },
+      sql: { omittedReason: "Data language; no member-access concept." },
+      swift: {
+        memberAccessShapes: [
+          { nodeTypes: ["navigation_expression"], object: { namedIndex: 0 }, property: { navigation: true } }
+        ],
+        receiverKeywords: SELF_RECEIVERS
+      },
+      ts: {
+        memberAccessOmittedReason: "The shared generic default already reads member_expression's object and property fields.",
+        receiverKeywords: THIS_SUPER_RECEIVERS
+      },
+      tsx: {
+        memberAccessOmittedReason: "The shared generic default already reads member_expression's object and property fields.",
+        receiverKeywords: THIS_SUPER_RECEIVERS
+      },
+      vue: { omittedReason: "Vue component format; script blocks parse as js/ts and templates as html." },
+      zig: {
+        memberAccessOmittedReason: "No per-language extraction today; the shared generic default is zig's behavior.",
+        receiverKeywords: { own: ["self"], supertype: [] }
+      }
+    };
+    receiverKeywordLanguageIds = Object.keys(MEMBER_ACCESS_ROWS).filter((languageId) => MEMBER_ACCESS_ROWS[languageId].receiverKeywords !== void 0);
+  }
+});
+
 // dist/util/member-access.js
 function memberExpressionTypeFor(sup) {
   if (sup.nodeTypes.memberExpression)
     return sup.nodeTypes.memberExpression;
-  if (sup.id === "python")
-    return "attribute";
-  if (sup.id === "ruby")
-    return "call";
-  return "member_expression";
+  return MEMBER_ACCESS_ROWS[sup.id]?.memberExpressionType ?? "member_expression";
 }
 function memberPropertyIdentifierTypes(sup) {
   return [...sup.nodeTypes.propertyIdentifier ?? ["property_identifier"]];
@@ -62617,17 +62892,12 @@ function memberAccessTraversalTypes(sup) {
     "subscript_expression",
     "optional_chain"
   ]);
-  if (sup.id === "go")
-    types.add("qualified_type");
-  if (sup.id === "python")
-    types.add("attribute");
-  if (sup.id === "kotlin" || sup.id === "swift")
-    types.add("navigation_expression");
+  for (const nodeType of MEMBER_ACCESS_ROWS[sup.id]?.extraTraversalTypes ?? [])
+    types.add(nodeType);
   return types;
 }
 function isMemberAccessNode(sup, node) {
-  const memberExpressionType = memberExpressionTypeFor(sup);
-  return node.type === memberExpressionType || sup.id === "go" && node.type === "qualified_type" || sup.id === "php" && (node.type === "member_call_expression" || node.type === "nullsafe_member_call_expression" || node.type === "scoped_call_expression") || node.type === "member_access_expression" || node.type === "qualified_name" || node.type === "field_access" || node.type === "method_invocation" || node.type === "scoped_identifier" || node.type === "scoped_type_identifier" || node.type === "qualified_identifier" || node.type === "call" || node.type === "scope_resolution" || node.type === "field_expression" || node.type === "attribute" || node.type === "navigation_expression";
+  return node.type === memberExpressionTypeFor(sup) || GENERIC_MEMBER_ACCESS_TYPES[node.type] || (MEMBER_ACCESS_ROWS[sup.id]?.extraMemberAccessTypes?.includes(node.type) ?? false);
 }
 function isMemberObjectIdentifier(nodeType) {
   return nodeType === "identifier" || nodeType === "type_identifier" || nodeType === "package_identifier" || nodeType === "constant" || nodeType === "namespace_identifier" || nodeType === "simple_identifier" || nodeType === "instance_variable" || nodeType === "class_variable";
@@ -62645,69 +62915,23 @@ function getNavigationExpressionProperty(sup, expr) {
   const fromSuffix = suffix.childForFieldName("suffix") ?? suffix.childForFieldName("name") ?? suffix.namedChildren[0] ?? suffix.child(0);
   if (fromSuffix)
     return fromSuffix;
-  if (sup.id === "kotlin") {
+  if (MEMBER_ACCESS_ROWS[sup.id]?.navigationFallbackLastChild) {
     return expr.namedChildren[expr.namedChildren.length - 1] ?? expr.child(2);
   }
   return null;
 }
-function fieldParts(node, objectField, propertyField) {
-  return {
-    object: node.childForFieldName(objectField) ?? node.child(0),
-    property: node.childForFieldName(propertyField) ?? node.child(2)
-  };
+function shapeChild(memberNode, child) {
+  if ("field" in child)
+    return memberNode.childForFieldName(child.field) ?? memberNode.child(child.fallbackIndex);
+  if ("index" in child)
+    return memberNode.child(child.index);
+  return memberNode.namedChildren[child.namedIndex] ?? memberNode.child(child.namedIndex);
 }
 function getMemberAccessParts(sup, memberNode) {
-  if (sup.id === "c" || sup.id === "cpp") {
-    if (memberNode.type === "field_expression")
-      return fieldParts(memberNode, "argument", "field");
-    if (memberNode.type === "qualified_identifier")
-      return fieldParts(memberNode, "scope", "name");
-  }
-  if (sup.id === "python") {
-    return fieldParts(memberNode, "object", "attribute");
-  }
-  if (sup.id === "csharp") {
-    return {
-      object: memberNode.child(0),
-      property: memberNode.child(2)
-    };
-  }
-  if (sup.id === "java") {
-    if (memberNode.type === "method_invocation") {
-      return fieldParts(memberNode, "object", "name");
-    }
-    if (memberNode.type === "scoped_identifier" || memberNode.type === "scoped_type_identifier") {
-      return fieldParts(memberNode, "scope", "name");
-    }
-  }
-  if (sup.id === "ruby") {
-    if (memberNode.type === "scope_resolution") {
-      return fieldParts(memberNode, "scope", "name");
-    }
-    return fieldParts(memberNode, "receiver", "method");
-  }
-  if (sup.id === "php") {
-    if (memberNode.type === "member_call_expression" || memberNode.type === "nullsafe_member_call_expression") {
-      return fieldParts(memberNode, "object", "name");
-    }
-    if (memberNode.type === "scoped_call_expression") {
-      return fieldParts(memberNode, "scope", "name");
-    }
-  }
-  if (sup.id === "rust" && memberNode.type === "scoped_identifier") {
-    return fieldParts(memberNode, "path", "name");
-  }
-  if (sup.id === "go" && memberNode.type === "qualified_type") {
-    return {
-      object: memberNode.namedChildren[0] ?? memberNode.child(0),
-      property: memberNode.namedChildren[1] ?? memberNode.child(1)
-    };
-  }
-  if ((sup.id === "kotlin" || sup.id === "swift") && memberNode.type === "navigation_expression") {
-    return {
-      object: memberNode.namedChildren[0] ?? memberNode.child(0),
-      property: getNavigationExpressionProperty(sup, memberNode)
-    };
+  const shape = MEMBER_ACCESS_ROWS[sup.id]?.memberAccessShapes?.find((candidate) => candidate.nodeTypes === void 0 || candidate.nodeTypes.includes(memberNode.type));
+  if (shape) {
+    const property = "navigation" in shape.property ? getNavigationExpressionProperty(sup, memberNode) : shapeChild(memberNode, shape.property);
+    return { object: shapeChild(memberNode, shape.object), property };
   }
   return {
     object: memberNode.childForFieldName("object") ?? memberNode.child(0),
@@ -62758,10 +62982,26 @@ function collectMemberAccessChain(args) {
     return null;
   return { base: current, names };
 }
+var GENERIC_MEMBER_ACCESS_TYPES;
 var init_member_access = __esm({
   "dist/util/member-access.js"() {
     "use strict";
     init_ast();
+    init_member_access_tables();
+    GENERIC_MEMBER_ACCESS_TYPES = {
+      member_access_expression: true,
+      qualified_name: true,
+      field_access: true,
+      method_invocation: true,
+      scoped_identifier: true,
+      scoped_type_identifier: true,
+      qualified_identifier: true,
+      call: true,
+      scope_resolution: true,
+      field_expression: true,
+      attribute: true,
+      navigation_expression: true
+    };
   }
 });
 
@@ -62936,15 +63176,6 @@ var init_ast2 = __esm({
 
 // dist/graphs/symbol-graph-detailed/receiver-calls.js
 import { readFileSync } from "node:fs";
-function supportsReceiverMemberNavigation(languageId) {
-  return RECEIVER_KEYWORDS[languageId] !== void 0;
-}
-function isKeywordReceiver(languageId, receiverName) {
-  const keywords = RECEIVER_KEYWORDS[languageId];
-  if (!keywords)
-    return false;
-  return keywords.own.includes(receiverName) || keywords.supertype.includes(receiverName);
-}
 function hasStaticMemberDistinction(languageId) {
   return STATIC_MEMBER_LANGUAGES[languageId] !== void 0;
 }
@@ -63338,7 +63569,7 @@ function ownTypeMemberScope(receiverName) {
   return INSTANCE_RECEIVER_KEYWORDS.has(receiverName) ? "instance" : "any";
 }
 function classifyReceiver(sup, receiver, source, proofCache, cacheScope, accessNode) {
-  const keywords = RECEIVER_KEYWORDS[sup.id];
+  const keywords = MEMBER_ACCESS_ROWS[sup.id]?.receiverKeywords;
   const text = sliceText(receiver, source).trim();
   if (!text)
     return null;
@@ -63547,34 +63778,16 @@ function provenMemberTarget(graph, membersByOwner, owners, candidate, memberScop
     return { status: "unique", memberId: byArity[0] };
   return { status: "ambiguous" };
 }
-var THIS_SUPER_RECEIVERS, SELF_RECEIVERS, RECEIVER_KEYWORDS, INSTANCE_RECEIVER_KEYWORDS, receiverKeywordLanguageIds, STATIC_MEMBER_LANGUAGES, staticMemberLanguageIds, RECEIVER_CALL_NODE_TYPES, MEMBER_CONTAINER_TYPES, CALL_ARGUMENT_NODE_TYPES, HIERARCHY_LABELS, VALUE_BINDING_TYPES, PARAMETER_LIST_NODE_TYPES, TYPE_SCOPED_ACCESS_TYPES, BINDING_SCOPE_TYPES, BINDING_CONTAINER_TYPES, BINDING_DECLARATION_TYPES, RUBY_CONSTANT_SOURCE, LANGUAGE_CONSTRUCTION_FORMS, MAX_SUPERTYPE_DEPTH;
+var INSTANCE_RECEIVER_KEYWORDS, STATIC_MEMBER_LANGUAGES, staticMemberLanguageIds, RECEIVER_CALL_NODE_TYPES, MEMBER_CONTAINER_TYPES, CALL_ARGUMENT_NODE_TYPES, HIERARCHY_LABELS, VALUE_BINDING_TYPES, PARAMETER_LIST_NODE_TYPES, TYPE_SCOPED_ACCESS_TYPES, BINDING_SCOPE_TYPES, BINDING_CONTAINER_TYPES, BINDING_DECLARATION_TYPES, RUBY_CONSTANT_SOURCE, LANGUAGE_CONSTRUCTION_FORMS, MAX_SUPERTYPE_DEPTH;
 var init_receiver_calls = __esm({
   "dist/graphs/symbol-graph-detailed/receiver-calls.js"() {
     "use strict";
     init_types2();
     init_ast();
     init_identifiers();
+    init_member_access_tables();
     init_member_access();
-    THIS_SUPER_RECEIVERS = { own: ["this"], supertype: ["super"] };
-    SELF_RECEIVERS = { own: ["self"], supertype: ["super"] };
-    RECEIVER_KEYWORDS = {
-      cpp: { own: ["this"], supertype: [] },
-      csharp: { own: ["this"], supertype: ["base"] },
-      go: { own: [], supertype: [] },
-      java: THIS_SUPER_RECEIVERS,
-      js: THIS_SUPER_RECEIVERS,
-      kotlin: THIS_SUPER_RECEIVERS,
-      php: { own: ["$this", "self", "static"], supertype: ["parent"] },
-      python: { own: ["self", "cls"], supertype: [] },
-      ruby: { own: ["self"], supertype: [] },
-      rust: { own: ["self", "Self"], supertype: [] },
-      swift: SELF_RECEIVERS,
-      ts: THIS_SUPER_RECEIVERS,
-      tsx: THIS_SUPER_RECEIVERS,
-      zig: { own: ["self"], supertype: [] }
-    };
     INSTANCE_RECEIVER_KEYWORDS = /* @__PURE__ */ new Set(["this", "$this"]);
-    receiverKeywordLanguageIds = Object.keys(RECEIVER_KEYWORDS);
     STATIC_MEMBER_LANGUAGES = {
       cpp: true,
       csharp: true,
@@ -71575,12 +71788,13 @@ var init_navigation_goto = __esm({
     init_ast();
     init_paths();
     init_member_access();
+    init_member_access_tables();
     init_receiver_calls();
     init_parse_context();
     init_navigation_provenance();
     init_navigation_resolve();
     init_types2();
-    init_receiver_calls();
+    init_member_access_tables();
     NESTED_MEMBER_LOCAL_CONTAINERS = /* @__PURE__ */ new Set([
       "block",
       "class",
@@ -74864,7 +75078,151 @@ var init_report = __esm({
   }
 });
 
+// dist/impact/call-compatibility/providers/profiles.js
+var CALL_COMPATIBILITY_LANGUAGE_ID_DECLARATIONS, GENERIC_PROFILE, cFamilyProfile, jsFamilyProfile, pythonProfile, rubyProfile, rustProfile, CALL_COMPATIBILITY_LANGUAGE_PROFILES;
+var init_profiles = __esm({
+  "dist/impact/call-compatibility/providers/profiles.js"() {
+    "use strict";
+    CALL_COMPATIBILITY_LANGUAGE_ID_DECLARATIONS = [
+      "c",
+      "cpp",
+      "csharp",
+      "go",
+      "java",
+      "js",
+      "kotlin",
+      "php",
+      "python",
+      "ruby",
+      "rust",
+      "swift",
+      "ts",
+      "tsx",
+      "zig"
+    ];
+    GENERIC_PROFILE = {
+      receiver: {
+        skipFirst: "always",
+        methodScopeTypes: [],
+        nonMethodScopeTypes: [],
+        firstPositionExact: [],
+        firstPositionTypedPrefixes: [],
+        thisKeyword: null
+      },
+      directParameterChildType: null,
+      parameterSeparators: [],
+      restPrefixes: [],
+      restWordPatterns: [],
+      optionalNameMarker: null,
+      keywordParameterPattern: null,
+      keywordParameterValuePattern: null,
+      zeroSlotParameters: [],
+      signatureCommaScanDetectsRegexLiterals: true,
+      sourceFallback: false,
+      callsiteParenthesesFallback: false,
+      spreadPrefixes: []
+    };
+    cFamilyProfile = {
+      ...GENERIC_PROFILE,
+      zeroSlotParameters: ["void"]
+    };
+    jsFamilyProfile = {
+      ...GENERIC_PROFILE,
+      receiver: {
+        skipFirst: "always",
+        methodScopeTypes: [],
+        nonMethodScopeTypes: [],
+        firstPositionExact: [],
+        firstPositionTypedPrefixes: [],
+        // `this` parameters are receivers at any position.
+        thisKeyword: "this"
+      },
+      // `name?` optional parameters.
+      optionalNameMarker: "?",
+      // The AST path can fail where the source still shows the call, so paren scanning rescues it.
+      sourceFallback: true
+    };
+    pythonProfile = {
+      ...GENERIC_PROFILE,
+      receiver: {
+        // Instance methods drop the receiver; module-level functions keep it as a regular slot.
+        skipFirst: "class-methods",
+        methodScopeTypes: ["class_definition"],
+        nonMethodScopeTypes: ["function_definition"],
+        firstPositionExact: ["self", "cls"],
+        firstPositionTypedPrefixes: ["self:", "cls:"],
+        thisKeyword: null
+      },
+      // `/` (positional-only) and `*` (keyword-only) group markers occupy no slot.
+      parameterSeparators: ["/", "*"],
+      // `*args`/`**kwargs` rest parameters, and the same prefixes make callsites uncountable.
+      restPrefixes: ["*"],
+      spreadPrefixes: ["*"],
+      // `/` is the positional-only separator, so the signature comma-scan cannot treat `/.../` as a regex.
+      signatureCommaScanDetectsRegexLiterals: false
+    };
+    rubyProfile = {
+      ...GENERIC_PROFILE,
+      receiver: {
+        skipFirst: "always",
+        methodScopeTypes: [],
+        nonMethodScopeTypes: [],
+        firstPositionExact: ["self", "cls"],
+        firstPositionTypedPrefixes: ["self:", "cls:"],
+        thisKeyword: null
+      },
+      // `*rest`/`**kw` rest parameters, and the same prefixes make callsites uncountable.
+      restPrefixes: ["*"],
+      spreadPrefixes: ["*"],
+      // `name:` keyword parameters occupy their own slot; `name: value` carries a default and is optional.
+      keywordParameterPattern: /^[A-Za-z_]\w*:/,
+      keywordParameterValuePattern: /^[A-Za-z_]\w*:\s*\S/
+    };
+    rustProfile = {
+      ...GENERIC_PROFILE,
+      receiver: {
+        skipFirst: "always",
+        methodScopeTypes: [],
+        nonMethodScopeTypes: [],
+        firstPositionExact: ["self", "&self", "&mut self"],
+        firstPositionTypedPrefixes: ["self:"],
+        thisKeyword: null
+      }
+    };
+    CALL_COMPATIBILITY_LANGUAGE_PROFILES = {
+      c: cFamilyProfile,
+      cpp: cFamilyProfile,
+      // `params` marks the rest parameter.
+      csharp: { ...GENERIC_PROFILE, restWordPatterns: [/\bparams\b/] },
+      // Trailing `...string` variadics ride the generic top-level ellipsis scan.
+      go: GENERIC_PROFILE,
+      // `String...` variadics ride the generic top-level ellipsis scan; Java has no optional parameters.
+      java: GENERIC_PROFILE,
+      js: jsFamilyProfile,
+      ts: jsFamilyProfile,
+      tsx: jsFamilyProfile,
+      // `vararg` marks the rest parameter.
+      kotlin: { ...GENERIC_PROFILE, restWordPatterns: [/\bvararg\b/] },
+      // `...$rest` spreads ride the generic leading-`...` callsite rule.
+      php: GENERIC_PROFILE,
+      python: pythonProfile,
+      ruby: rubyProfile,
+      rust: rustProfile,
+      // Parameter clauses expose no list node; span the declaration's direct `parameter` children.
+      swift: { ...GENERIC_PROFILE, directParameterChildType: "parameter" },
+      // Callsites expose no argument-list node; scan for the call parentheses instead.
+      zig: { ...GENERIC_PROFILE, callsiteParenthesesFallback: true }
+    };
+  }
+});
+
 // dist/impact/call-compatibility/providers/index.js
+function getCallCompatibilityLanguageProfile(languageId) {
+  if (!callCompatibilityLanguageIds.includes(languageId)) {
+    return null;
+  }
+  return CALL_COMPATIBILITY_LANGUAGE_PROFILES[languageId];
+}
 function registerCallCompatibilityExtractors(extractors) {
   registeredExtractors = extractors;
 }
@@ -74879,29 +75237,13 @@ function getCallCompatibilityProvider(languageId) {
 function getCallCompatibilitySupportedLanguages() {
   return callCompatibilityLanguageIds;
 }
-var CALL_COMPATIBILITY_LANGUAGE_ID_DECLARATIONS, callCompatibilityLanguageIds, registeredExtractors, structuralCallCompatibilityProvider, callCompatibilityProviders;
+var callCompatibilityLanguageIds, registeredExtractors, structuralCallCompatibilityProvider, callCompatibilityProviders;
 var init_providers = __esm({
   "dist/impact/call-compatibility/providers/index.js"() {
     "use strict";
     init_all();
     init_registry();
-    CALL_COMPATIBILITY_LANGUAGE_ID_DECLARATIONS = [
-      "c",
-      "cpp",
-      "csharp",
-      "go",
-      "java",
-      "js",
-      "kotlin",
-      "php",
-      "python",
-      "ruby",
-      "rust",
-      "swift",
-      "ts",
-      "tsx",
-      "zig"
-    ];
+    init_profiles();
     callCompatibilityLanguageIds = CALL_COMPATIBILITY_LANGUAGE_ID_DECLARATIONS.filter((languageId) => getLanguageById(languageId) !== void 0);
     registeredExtractors = null;
     structuralCallCompatibilityProvider = {
@@ -76042,41 +76384,23 @@ function hasTopLevelEquals(text) {
   }
   return false;
 }
-function isOptionalParameter(parameter) {
-  const colonIndex = parameter.indexOf(":");
-  let searchText = parameter;
-  if (colonIndex >= 0) {
-    searchText = parameter.slice(0, colonIndex);
-  }
-  return searchText.includes("?") || hasTopLevelEquals(parameter);
-}
-function isThisParameter(parameter) {
-  const colonIndex = parameter.indexOf(":");
-  if (colonIndex < 0) {
-    return parameter.trim() === "this";
+function shouldSkipFirstReceiverParameter(profile, declaration) {
+  if (profile.receiver.skipFirst !== "class-methods") {
+    return true;
   }
-  return parameter.slice(0, colonIndex).trim() === "this";
-}
-function isPythonMethodDeclaration(declaration) {
   let current = declaration.parent;
   while (current) {
-    if (current.type === "class_definition") {
+    if (profile.receiver.methodScopeTypes.includes(current.type)) {
       return true;
     }
-    if (current.type === "function_definition") {
+    if (profile.receiver.nonMethodScopeTypes.includes(current.type)) {
       return false;
     }
     current = current.parent;
   }
   return false;
 }
-function shouldSkipFirstReceiverParameter(languageId, declaration) {
-  if (languageId === "python") {
-    return isPythonMethodDeclaration(declaration);
-  }
-  return true;
-}
-function findSignatureParameterText(request) {
+function findSignatureParameterText(request, profile) {
   if (!request.tree) {
     return null;
   }
@@ -76085,6 +76409,7 @@ function findSignatureParameterText(request) {
   if (!declaration) {
     return null;
   }
+  const skipFirstReceiver = shouldSkipFirstReceiverParameter(profile, declaration);
   let params = directSignatureParameterNode(declaration);
   if (!params && declaration.type === "variable_declarator") {
     const valueNode = declaration.childForFieldName("value");
@@ -76097,47 +76422,44 @@ function findSignatureParameterText(request) {
     params = findFirstDescendantOfTypes(declaration, parameterListTypes);
   }
   if (!params) {
-    if (request.languageId === "swift") {
-      const parameterNodes = declaration.namedChildren.filter((child) => child.type === "parameter");
+    const directParameterChildType = profile.directParameterChildType;
+    if (directParameterChildType !== null) {
+      const parameterNodes = declaration.namedChildren.filter((child) => child.type === directParameterChildType);
       const first = parameterNodes[0];
       const last = parameterNodes[parameterNodes.length - 1];
       if (first && last) {
         return {
           text: request.source.slice(first.startIndex, last.endIndex),
-          skipFirstReceiver: shouldSkipFirstReceiverParameter(request.languageId, declaration)
+          skipFirstReceiver
         };
       }
     }
-    return {
-      text: "",
-      skipFirstReceiver: shouldSkipFirstReceiverParameter(request.languageId, declaration)
-    };
+    return { text: "", skipFirstReceiver };
   }
   const text = request.source.slice(params.startIndex, params.endIndex).trim();
   if (text.startsWith("(") && text.endsWith(")")) {
-    return {
-      text: text.slice(1, -1),
-      skipFirstReceiver: shouldSkipFirstReceiverParameter(request.languageId, declaration)
-    };
+    return { text: text.slice(1, -1), skipFirstReceiver };
   }
-  return {
-    text,
-    skipFirstReceiver: shouldSkipFirstReceiverParameter(request.languageId, declaration)
-  };
+  return { text, skipFirstReceiver };
 }
-function isReceiverParameter(languageId, parameter, index, skipFirstReceiver) {
+function isReceiverParameter(profile, parameter, index, skipFirstReceiver) {
   if (!skipFirstReceiver) {
     return false;
   }
   const trimmed = parameter.trim();
-  if (!index && (languageId === "python" || languageId === "ruby")) {
-    return trimmed === "self" || trimmed === "cls" || trimmed.startsWith("self:") || trimmed.startsWith("cls:");
-  }
-  if (!index && languageId === "rust") {
-    return trimmed === "self" || trimmed === "&self" || trimmed === "&mut self" || trimmed.startsWith("self:");
+  if (!index) {
+    if (profile.receiver.firstPositionExact.includes(trimmed)) {
+      return true;
+    }
+    if (profile.receiver.firstPositionTypedPrefixes.some((prefix) => trimmed.startsWith(prefix))) {
+      return true;
+    }
   }
-  if (isJsTsLanguage(languageId)) {
-    return isThisParameter(trimmed);
+  const thisKeyword = profile.receiver.thisKeyword;
+  if (thisKeyword !== null) {
+    const colonIndex = trimmed.indexOf(":");
+    const namePortion = colonIndex >= 0 ? trimmed.slice(0, colonIndex).trim() : trimmed;
+    return namePortion === thisKeyword;
   }
   return false;
 }
@@ -76232,11 +76554,7 @@ function hasTopLevelEllipsis(text) {
   }
   return false;
 }
-function isParameterSeparator(languageId, parameter) {
-  const trimmed = parameter.trim();
-  return languageId === "python" && (trimmed === "/" || trimmed === "*");
-}
-function isRestParameter(languageId, parameter) {
+function isRestParameter(profile, parameter) {
   const trimmed = parameter.trim();
   if (!trimmed) {
     return false;
@@ -76244,42 +76562,41 @@ function isRestParameter(languageId, parameter) {
   if (hasTopLevelEllipsis(trimmed)) {
     return true;
   }
-  if (languageId === "python" || languageId === "ruby") {
-    return trimmed.startsWith("*") || trimmed.startsWith("**");
-  }
-  if (languageId === "csharp") {
-    return /\bparams\b/.test(trimmed);
-  }
-  if (languageId === "kotlin") {
-    return /\bvararg\b/.test(trimmed);
+  if (profile.restPrefixes.some((prefix) => trimmed.startsWith(prefix))) {
+    return true;
   }
-  return false;
+  return profile.restWordPatterns.some((pattern) => pattern.test(trimmed));
 }
-function isOptionalParameterForLanguage(languageId, parameter) {
+function isOptionalParameter(profile, parameter) {
   const trimmed = parameter.trim();
   if (!trimmed) {
     return false;
   }
-  if (isJsTsLanguage(languageId)) {
-    return isOptionalParameter(trimmed);
+  const nameMarker = profile.optionalNameMarker;
+  if (nameMarker !== null) {
+    const colonIndex = trimmed.indexOf(":");
+    const namePortion = colonIndex >= 0 ? trimmed.slice(0, colonIndex) : trimmed;
+    if (namePortion.includes(nameMarker)) {
+      return true;
+    }
   }
-  if (languageId === "ruby" && /^[A-Za-z_]\w*:\s*\S/.test(trimmed)) {
+  if (profile.keywordParameterValuePattern?.test(trimmed)) {
     return true;
   }
   return hasTopLevelEquals(trimmed);
 }
-function parameterSlotCount(languageId, parameter) {
+function parameterSlotCount(profile, parameter) {
   const trimmed = parameter.trim();
   if (!trimmed) {
     return 0;
   }
-  if ((languageId === "c" || languageId === "cpp") && trimmed === "void") {
+  if (profile.zeroSlotParameters.includes(trimmed)) {
     return 0;
   }
   return 1;
 }
-function signatureFromParameterText(languageId, parameterText, angleMode, skipFirstReceiver = true) {
-  const parameters = splitTopLevelCommaGroups(parameterText, angleMode, languageId !== "python");
+function signatureFromParameterText(profile, parameterText, angleMode, skipFirstReceiver = true) {
+  const parameters = splitTopLevelCommaGroups(parameterText, angleMode, profile.signatureCommaScanDetectsRegexLiterals);
   if (!parameters) {
     return null;
   }
@@ -76289,41 +76606,42 @@ function signatureFromParameterText(languageId, parameterText, angleMode, skipFi
   let hasRest = false;
   parameters.forEach((parameter, index) => {
     const trimmed = parameter.trim();
-    if (!trimmed || isParameterSeparator(languageId, trimmed) || isReceiverParameter(languageId, trimmed, index, skipFirstReceiver)) {
+    if (!trimmed || profile.parameterSeparators.includes(trimmed) || isReceiverParameter(profile, trimmed, index, skipFirstReceiver)) {
       return;
     }
-    if (isRestParameter(languageId, trimmed)) {
+    if (isRestParameter(profile, trimmed)) {
       hasRest = true;
       return;
     }
-    if (languageId === "ruby" && /^[A-Za-z_]\w*:/.test(trimmed)) {
+    if (profile.keywordParameterPattern?.test(trimmed)) {
       maxArgs += 1;
-      if (!isOptionalParameterForLanguage(languageId, trimmed)) {
+      if (!isOptionalParameter(profile, trimmed)) {
         minArgs += 1;
       }
       return;
     }
-    const slotCount = parameterSlotCount(languageId, trimmed);
+    const slotCount = parameterSlotCount(profile, trimmed);
     if (!slotCount) {
       return;
     }
     positionalArgCount += slotCount;
     maxArgs += slotCount;
-    if (!isOptionalParameterForLanguage(languageId, trimmed)) {
+    if (!isOptionalParameter(profile, trimmed)) {
       minArgs = positionalArgCount;
     }
   });
   return { minArgs, maxArgs: hasRest ? null : maxArgs, confidence: "high" };
 }
 function extractCallableSignatureFromProvider(request) {
-  if (!supportsCallCompatibilityLanguage(request.languageId)) {
+  const profile = getCallCompatibilityLanguageProfile(request.languageId);
+  if (!profile) {
     return null;
   }
-  const astParameterText = findSignatureParameterText(request);
+  const astParameterText = findSignatureParameterText(request, profile);
   if (astParameterText !== null) {
-    return signatureFromParameterText(request.languageId, astParameterText.text, "type-context", astParameterText.skipFirstReceiver);
+    return signatureFromParameterText(profile, astParameterText.text, "type-context", astParameterText.skipFirstReceiver);
   }
-  if (!isJsTsLanguage(request.languageId)) {
+  if (!profile.sourceFallback) {
     return null;
   }
   const openIndex = findSignatureOpeningParen(request.source, request.symbolStartIndex);
@@ -76331,17 +76649,18 @@ function extractCallableSignatureFromProvider(request) {
   if (!balanced) {
     return null;
   }
-  return signatureFromParameterText(request.languageId, balanced.inner, "type-context");
+  return signatureFromParameterText(profile, balanced.inner, "type-context");
 }
 function extractCallsiteArgumentsFromProvider(request) {
-  if (!supportsCallCompatibilityLanguage(request.languageId)) {
+  const profile = getCallCompatibilityLanguageProfile(request.languageId);
+  if (!profile) {
     return null;
   }
-  const astArgumentText = findCallsiteArgumentText(request);
+  const astArgumentText = findCallsiteArgumentText(request, profile);
   if (astArgumentText !== null) {
-    return callsiteFromArgumentText(request.languageId, astArgumentText.text, astArgumentText.trailingArgumentCount);
+    return callsiteFromArgumentText(profile, astArgumentText.text, astArgumentText.trailingArgumentCount);
   }
-  if (!isJsTsLanguage(request.languageId)) {
+  if (!profile.sourceFallback) {
     return null;
   }
   const openIndex = findCallOpeningParen(request.source, request.calleeStartIndex, request.calleeEndIndex);
@@ -76349,7 +76668,7 @@ function extractCallsiteArgumentsFromProvider(request) {
   if (!balanced) {
     return null;
   }
-  return callsiteFromArgumentText(request.languageId, balanced.inner);
+  return callsiteFromArgumentText(profile, balanced.inner);
 }
 function extractCallableSignature(request) {
   const provider = getCallCompatibilityProvider(request.languageId);
@@ -76433,7 +76752,7 @@ function countTrailingClosureArguments(text) {
   }
   return count;
 }
-function findCallsiteArgumentText(request) {
+function findCallsiteArgumentText(request, profile) {
   if (!request.tree) {
     return null;
   }
@@ -76480,33 +76799,27 @@ function findCallsiteArgumentText(request) {
     }
     return { text, trailingArgumentCount };
   }
-  if (request.languageId === "zig") {
+  if (profile.callsiteParenthesesFallback) {
     const openIndex = findOpeningParen(request.source, callNode.startIndex);
     const balanced = findBalancedParentheses(request.source, openIndex);
     return balanced ? { text: balanced.inner, trailingArgumentCount: 0 } : null;
   }
   return null;
 }
-function hasUncountableSpreadArgument(languageId, arg) {
+function hasUncountableSpreadArgument(profile, arg) {
   const trimmed = arg.trim();
   if (trimmed.startsWith("...")) {
     return true;
   }
-  if (languageId === "python" || languageId === "ruby") {
-    return trimmed.startsWith("*") || trimmed.startsWith("**");
-  }
-  if (languageId === "php") {
-    return trimmed.startsWith("...");
-  }
-  return false;
+  return profile.spreadPrefixes.some((prefix) => trimmed.startsWith(prefix));
 }
-function callsiteFromArgumentText(languageId, argumentText, trailingArgumentCount = 0) {
+function callsiteFromArgumentText(profile, argumentText, trailingArgumentCount = 0) {
   const args = splitTopLevelCommaGroups(argumentText, "type-context");
   if (!args) {
     return null;
   }
   for (const arg of args) {
-    if (hasUncountableSpreadArgument(languageId, arg)) {
+    if (hasUncountableSpreadArgument(profile, arg)) {
       return null;
     }
   }
@@ -76909,7 +77222,6 @@ var init_call_compatibility = __esm({
     init_parse_context();
     init_types2();
     init_languages();
-    init_js_family2();
     init_ast();
     init_paths();
     init_providers();
@@ -76980,7 +77292,7 @@ var init_member_resolution_coverage = __esm({
   "dist/impact/member-resolution-coverage.js"() {
     "use strict";
     init_languages();
-    init_receiver_calls();
+    init_member_access_tables();
     init_paths();
   }
 });