@lzehrung/codegraph 2.1.0

package/dist/bin/queryIndexWorker.js

@@ -0,0 +1,3914 @@
+import { createRequire as __codegraphCreateRequire } from 'node:module';
+const require = __codegraphCreateRequire(import.meta.url);
+
+
+// dist/agent/query-index/content.js
+import fs4 from "node:fs/promises";
+import { brotliCompressSync, constants as zlibConstants } from "node:zlib";
+
+// dist/languages/queryGenerator.js
+function generateChunkingQuery(def) {
+  const parts = [];
+  if (def.structure.comments.length) {
+    parts.push(`;; ----- Comments -----`);
+    for (const type of def.structure.comments) {
+      parts.push(`(${type}) @chunk.comment`);
+    }
+    parts.push("");
+  }
+  if (def.structure.blocks.length) {
+    parts.push(`;; ----- Blocks -----`);
+    for (const block of def.structure.blocks) {
+      let query = `(${block.type}`;
+      if (block.nameQuery) {
+        query += ` ${block.nameQuery}`;
+      }
+      const isBlockCapture = block.isBlock ?? true;
+      if (isBlockCapture) {
+        query += `) @chunk.block.${block.captureId || block.type}`;
+      } else {
+        query += `)`;
+      }
+      if (block.parentType) {
+        query = `(${block.parentType} ${query})`;
+      }
+      parts.push(query);
+    }
+    parts.push("");
+  }
+  if (def.structure.splitPoints.length) {
+    parts.push(`;; ----- Split Points -----`);
+    for (const type of def.structure.splitPoints) {
+      parts.push(`(${type}) @chunk.block.inner`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+
+// dist/chunking/languageConfig.js
+function makeLanguageConfig(def, publicId = def.id) {
+  const queryText = generateChunkingQuery(def);
+  return {
+    id: publicId,
+    supportId: def.id,
+    queryText,
+    definition: def,
+    captures: {
+      name: "chunk.name",
+      blockPrefix: "chunk.block.",
+      innerBlock: "chunk.block.inner",
+      comments: ["chunk.comment", "chunk.docstring"]
+    }
+  };
+}
+
+// dist/languages/registry.js
+var registry = /* @__PURE__ */ new Map();
+function registerLanguage(def) {
+  registry.set(def.id, def);
+}
+function getAllLanguages() {
+  return Array.from(registry.values());
+}
+function getLanguageById(id) {
+  return registry.get(id);
+}
+
+// dist/parserBackend.js
+function loadTreeSitterLanguage(packageName) {
+  return { name: packageName };
+}
+function loadTypeScriptGrammars() {
+  return {
+    typescript: { name: "tree-sitter-typescript/typescript" },
+    tsx: { name: "tree-sitter-typescript/tsx" }
+  };
+}
+
+// dist/languages/definitions/jsFamily.js
+var ECMASCRIPT_CONTROL_SPLIT_POINTS = [
+  "if_statement",
+  "else_clause",
+  "switch_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "try_statement",
+  "catch_clause",
+  "finally_clause"
+];
+var ECMASCRIPT_CORE_FUNCTION_BLOCKS = [
+  {
+    type: "class_declaration",
+    nameQuery: "name: (identifier) @chunk.name",
+    captureId: "class"
+  },
+  {
+    type: "function_declaration",
+    nameQuery: "name: (identifier) @chunk.name",
+    captureId: "function"
+  },
+  {
+    type: "generator_function_declaration",
+    nameQuery: "name: (identifier) @chunk.name",
+    captureId: "function"
+  },
+  {
+    type: "method_definition",
+    nameQuery: "name: (_) @chunk.name body: (statement_block) @chunk.block.method",
+    captureId: "method"
+  },
+  {
+    type: "lexical_declaration",
+    nameQuery: `(variable_declarator name: (identifier) @chunk.name value: [ (function_expression body: (statement_block) @chunk.block.function) (arrow_function body: (statement_block) @chunk.block.function) ])`,
+    captureId: "function"
+  },
+  {
+    type: "variable_declaration",
+    nameQuery: `(variable_declarator name: (identifier) @chunk.name value: [ (function_expression body: (statement_block) @chunk.block.function) (arrow_function body: (statement_block) @chunk.block.function) ])`,
+    captureId: "function"
+  },
+  {
+    type: "assignment_expression",
+    nameQuery: `left: (_) @chunk.name right: [ (function_expression body: (statement_block) @chunk.block.function) (arrow_function body: (statement_block) @chunk.block.function) ]`,
+    captureId: "function"
+  },
+  {
+    type: "arrow_function",
+    nameQuery: "body: (statement_block) @chunk.block.function",
+    captureId: "function"
+  },
+  {
+    type: "function_expression",
+    nameQuery: "body: (statement_block) @chunk.block.function",
+    captureId: "function"
+  }
+];
+var ECMASCRIPT_MODULE_VAR_BLOCKS = [
+  { type: "import_statement", captureId: "imports" },
+  {
+    type: "lexical_declaration",
+    nameQuery: `(variable_declarator name: (identifier) @chunk.name)`,
+    captureId: "module_var",
+    parentType: "program"
+  },
+  {
+    type: "variable_declaration",
+    nameQuery: `(variable_declarator name: (identifier) @chunk.name)`,
+    captureId: "module_var",
+    parentType: "program"
+  }
+];
+
+// dist/languages/definitions/typescript.js
+function normalizeTypeScriptNativeQuery(kind, query) {
+  let normalized = query.replace(/\(class_declaration name: \(identifier\) @/g, "(class_declaration name: (type_identifier) @");
+  if (kind !== "exports") {
+    return normalized;
+  }
+  normalized = normalized.replace(/^\s*\(export_assignment \(identifier\) @ts_export_assign\)\s*$/gm, "");
+  return normalized;
+}
+var TYPESCRIPT_CLASS_BLOCK = {
+  type: "class_declaration",
+  nameQuery: "name: (type_identifier) @chunk.name",
+  captureId: "class"
+};
+var BASE_STRUCTURE = {
+  blocks: [
+    TYPESCRIPT_CLASS_BLOCK,
+    ...ECMASCRIPT_CORE_FUNCTION_BLOCKS.filter((block) => block.type !== "class_declaration"),
+    // TS Specifics
+    {
+      type: "interface_declaration",
+      nameQuery: "name: (type_identifier) @chunk.name",
+      captureId: "interface"
+    },
+    {
+      type: "enum_declaration",
+      nameQuery: "name: [ (identifier) (type_identifier) ] @chunk.name",
+      captureId: "enum"
+    },
+    {
+      type: "type_alias_declaration",
+      nameQuery: "name: (type_identifier) @chunk.name",
+      captureId: "type_alias"
+    },
+    {
+      type: "internal_module",
+      nameQuery: "name: (identifier) @chunk.name body: (statement_block) @chunk.block.namespace",
+      captureId: "namespace"
+    },
+    {
+      type: "module",
+      nameQuery: "name: (identifier) @chunk.name body: (statement_block) @chunk.block.namespace",
+      captureId: "namespace"
+    },
+    // Data
+    { type: "object", captureId: "data" },
+    // Top level vars
+    ...ECMASCRIPT_MODULE_VAR_BLOCKS.map((block) => block.type === "import_statement" ? { ...block, parentType: "program" } : block)
+  ],
+  splitPoints: [...ECMASCRIPT_CONTROL_SPLIT_POINTS, "switch_case", "switch_default"],
+  comments: ["comment"]
+};
+var BASE_GRAPH = {
+  imports: `
+    (import_statement (string) @mod) @stmt
+    ;; import x = require("...") is represented via import_require_clause
+    (import_statement (import_require_clause (string) @mod)) @stmt
+    (export_statement (string) @mod) @stmt
+    (call_expression function: (import) arguments: (arguments (string) @mod)) @stmt
+    ;; declare module "foo" {} \u2014 ambient module augmentations create a type-only
+    ;; dependency on the named module and must appear in the file graph so that
+    ;; changes to "foo" propagate to augmenting files (and vice-versa).
+    ;; The inner node type is "module" (not "module_declaration"); its string
+    ;; child uses field-name "name".
+    (ambient_declaration (module name: (string) @mod)) @stmt
+  `,
+  exports: `
+    (export_statement) @stmt
+    (export_statement declaration: (function_declaration name: (identifier) @name)) @stmt
+    (export_statement declaration: (generator_function_declaration name: (identifier) @name)) @stmt
+    (export_statement declaration: (class_declaration name: (type_identifier) @name)) @stmt
+    (export_statement declaration: (abstract_class_declaration name: (type_identifier) @name)) @stmt
+    (export_statement declaration: (enum_declaration name: [ (identifier) (type_identifier) ] @name)) @stmt
+    (export_statement declaration: (function_declaration) @anon_default) @stmt
+    (export_statement declaration: (generator_function_declaration) @anon_default) @stmt
+    (export_statement declaration: (class_declaration) @anon_default) @stmt
+    (export_statement declaration: (abstract_class_declaration) @anon_default) @stmt
+    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name))) @stmt
+    (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias)) (string) @from) @stmt
+    (export_statement (export_clause (export_specifier name: (identifier) @src !alias)) (string) @from) @stmt
+    (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias))) @stmt
+    (export_statement (export_clause (export_specifier name: (identifier) @src !alias))) @stmt
+    (export_statement (string) @from) @stmt
+    (export_assignment (identifier) @ts_export_assign)
+  `,
+  locals: `
+    (function_declaration name: (identifier) @name)
+    (generator_function_declaration name: (identifier) @name)
+    (method_definition name: (property_identifier) @name)
+    (method_signature name: (property_identifier) @name)
+    (abstract_method_signature name: (property_identifier) @name)
+    (class_declaration name: (type_identifier) @name)
+    (abstract_class_declaration name: (type_identifier) @name)
+    (variable_declarator name: (identifier) @name)
+    (interface_declaration name: (type_identifier) @name)
+    (type_alias_declaration name: (type_identifier) @name)
+    (enum_declaration name: [ (identifier) (type_identifier) ] @name)
+  `,
+  importBindings: `
+    (import_statement) @stmt
+    (import_statement (string) @from) @stmt
+    (import_statement (import_require_clause (identifier) @def (string) @from)) @stmt
+    (import_statement (import_clause (identifier) @def) (string) @from) @stmt
+    (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname alias: (identifier) @alias))) (string) @from) @stmt
+    (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname))) (string) @from) @stmt
+    (import_statement (import_clause (namespace_import (identifier) @ns)) (string) @from) @stmt
+  `
+};
+var BASE_HELPERS = {
+  nodeTypes: {
+    identifier: ["identifier", "type_identifier"],
+    propertyIdentifier: ["property_identifier"],
+    shorthandPropertyIdentifier: ["shorthand_property_identifier", "shorthand_property_identifier_pattern"],
+    memberExpression: "member_expression"
+  },
+  classifyDefinition: (n) => {
+    const t = n.parent?.type;
+    if (t === "function_declaration")
+      return "function";
+    if (t === "generator_function_declaration")
+      return "function";
+    if (t === "method_definition")
+      return "function";
+    if (t === "method_signature")
+      return "function";
+    if (t === "abstract_method_signature")
+      return "function";
+    if (t === "class_declaration")
+      return "class";
+    if (t === "abstract_class_declaration")
+      return "class";
+    if (t === "interface_declaration")
+      return "interface";
+    if (t === "type_alias_declaration")
+      return "type";
+    if (t === "enum_declaration")
+      return "type";
+    return "variable";
+  },
+  isDeclarationName: (node) => {
+    const p = node.parent?.type;
+    return !!p && [
+      "generator_function_declaration",
+      "function_declaration",
+      "class_declaration",
+      "abstract_class_declaration",
+      "variable_declarator",
+      "interface_declaration",
+      "type_alias_declaration",
+      "enum_declaration",
+      "import_specifier",
+      "namespace_import",
+      "import_clause",
+      "import_equals_declaration",
+      // Method names in classes and abstract method signatures: needed so
+      // that editing a method name is classified as a definition change.
+      "method_definition",
+      "method_signature",
+      "abstract_method_signature"
+    ].includes(p);
+  },
+  createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body",
+  createsFunctionScope: (n) => n.type === "generator_function_declaration" || n.type === "function_declaration" || n.type === "function" || n.type === "function_expression" || n.type === "arrow_function" || n.type === "method_definition",
+  membersAreImplicitlyInScope: false,
+  supportsCrossModuleSymbols: true
+};
+var TYPESCRIPT_DEF = {
+  id: "ts",
+  extensions: [".ts", ".mts", ".cts"],
+  grammar: () => loadTypeScriptGrammars().typescript,
+  structure: BASE_STRUCTURE,
+  graph: BASE_GRAPH,
+  ...BASE_HELPERS,
+  isTypeOnly: (stmtText) => /\b(import|export)\s+type\b/.test(stmtText),
+  native: {
+    normalizeQuery: normalizeTypeScriptNativeQuery,
+    authoritativeKinds: ["exports"],
+    notes: ["drops unsupported TypeScript export-assignment nodes while keeping native export results authoritative"]
+  }
+};
+registerLanguage(TYPESCRIPT_DEF);
+var TSX_DEF = {
+  id: "tsx",
+  extensions: [".tsx"],
+  grammar: () => loadTypeScriptGrammars().tsx,
+  structure: {
+    ...BASE_STRUCTURE,
+    blocks: [
+      ...BASE_STRUCTURE.blocks,
+      { type: "jsx_element", captureId: "jsx" },
+      { type: "jsx_self_closing_element", captureId: "jsx" }
+    ]
+  },
+  graph: BASE_GRAPH,
+  ...BASE_HELPERS,
+  isTypeOnly: (stmtText) => /\b(import|export)\s+type\b/.test(stmtText),
+  native: {
+    normalizeQuery: normalizeTypeScriptNativeQuery,
+    authoritativeKinds: ["exports"],
+    notes: ["drops unsupported TypeScript export-assignment nodes while keeping native export results authoritative"]
+  }
+};
+registerLanguage(TSX_DEF);
+
+// dist/languages/definitions/javascript.js
+var JS_OBJECT_METHOD_EXPORT_PATTERN = `
+      ;; CJS: module.exports = { helper () {} }
+      (expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
+        right: (object (pair key: (property_identifier) @cjs_export_name value: (function_declaration) @cjs_fn))))
+        (#eq? @mod "module") (#eq? @prop "exports")
+`;
+var JS_OBJECT_METHOD_EXPORT_NATIVE_PATTERN = `
+      ;; CJS: module.exports = { helper () {} }
+      (expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
+        right: (object (method_definition name: (property_identifier) @cjs_export_name) @cjs_fn)))
+        (#eq? @mod "module") (#eq? @prop "exports")
+`;
+var JAVASCRIPT_DEF = {
+  id: "js",
+  extensions: [".js", ".jsx", ".mjs", ".cjs"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-javascript"),
+  structure: {
+    blocks: [...ECMASCRIPT_CORE_FUNCTION_BLOCKS, ...ECMASCRIPT_MODULE_VAR_BLOCKS],
+    splitPoints: [...ECMASCRIPT_CONTROL_SPLIT_POINTS],
+    comments: ["comment"]
+  },
+  graph: {
+    imports: `
+      (import_statement (string) @mod) @stmt
+      (export_statement (string) @mod) @stmt
+      (call_expression function: (import) arguments: (arguments (string) @mod)) @stmt
+      ((call_expression function: (identifier) @fn arguments: (arguments (string) @mod)) @stmt
+        (#eq? @fn "require"))
+    `,
+    exports: `
+      (export_statement) @stmt
+      (export_statement declaration: (function_declaration name: (identifier) @name)) @stmt
+      (export_statement declaration: (generator_function_declaration name: (identifier) @name)) @stmt
+      (export_statement declaration: (class_declaration name: (identifier) @name)) @stmt
+      (export_statement declaration: (function_declaration) @anon_default) @stmt
+      (export_statement declaration: (generator_function_declaration) @anon_default) @stmt
+      (export_statement declaration: (class_declaration) @anon_default) @stmt
+      (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name))) @stmt
+      (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias)) (string) @from)
+      (export_statement (export_clause (export_specifier name: (identifier) @src !alias)) (string) @from)
+      (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias)))
+      (export_statement (export_clause (export_specifier name: (identifier) @src !alias)))
+      (export_statement (string) @from)
+      (expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
+        right: (object (shorthand_property_identifier) @cjs_shorthand)))
+        (#eq? @mod "module") (#eq? @prop "exports")
+      ;; CJS spread export: module.exports = { ...base }
+      ((expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
+        right: (object (spread_element (identifier) @cjs_spread))) @stmt)
+        (#eq? @mod "module") (#eq? @prop "exports"))
+      (expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
+        right: (object (pair key: (property_identifier) @cjs_export_name value: (identifier) @cjs_local))))
+        (#eq? @mod "module") (#eq? @prop "exports")
+      (expression_statement (assignment_expression
+        left: (member_expression object: (member_expression object: (identifier) @mod property: (property_identifier) @prop) property: (property_identifier) @cjs_export_name)
+        right: (identifier) @cjs_local))
+        (#eq? @mod "module") (#eq? @prop "exports")
+      (expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @exp property: (property_identifier) @cjs_export_name)
+        right: (identifier) @cjs_local))
+        (#eq? @exp "exports")
+      ;; CJS function/arrow direct exports
+      (expression_statement (assignment_expression
+        left: (member_expression object: (member_expression object: (identifier) @mod property: (property_identifier) @prop) property: (property_identifier) @cjs_export_name)
+        right: (function) @cjs_fn))
+        (#eq? @mod "module") (#eq? @prop "exports")
+      (expression_statement (assignment_expression
+        left: (member_expression object: (member_expression object: (identifier) @mod property: (property_identifier) @prop) property: (property_identifier) @cjs_export_name)
+        right: (arrow_function) @cjs_fn))
+        (#eq? @mod "module") (#eq? @prop "exports")
+      (expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @exp property: (property_identifier) @cjs_export_name)
+        right: (function) @cjs_fn))
+        (#eq? @exp "exports")
+      (expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @exp property: (property_identifier) @cjs_export_name)
+        right: (arrow_function) @cjs_fn))
+        (#eq? @exp "exports")
+      ;; CJS object export with function value
+      (expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
+        right: (object (pair key: (property_identifier) @cjs_export_name value: (function) @cjs_fn))))
+        (#eq? @mod "module") (#eq? @prop "exports")
+      (expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
+        right: (object (pair key: (property_identifier) @cjs_export_name value: (arrow_function) @cjs_fn))))
+        (#eq? @mod "module") (#eq? @prop "exports")
+      ;; CJS: module.exports = { helper () {} }
+      (expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
+        right: (object (pair key: (property_identifier) @cjs_export_name value: (function_declaration) @cjs_fn))))
+        (#eq? @mod "module") (#eq? @prop "exports")
+    `,
+    locals: `
+      (function_declaration name: (identifier) @name)
+      (generator_function_declaration name: (identifier) @name)
+      (method_definition name: (property_identifier) @name)
+      (class_declaration name: (identifier) @name)
+      (variable_declarator name: (identifier) @name)
+    `,
+    importBindings: `
+      (import_statement) @stmt
+      (import_statement (string) @from) @stmt
+      (import_statement (import_clause (identifier) @def) (string) @from) @stmt
+      (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname alias: (identifier) @alias))) (string) @from) @stmt
+      (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname))) (string) @from) @stmt
+      (import_statement (import_clause (namespace_import (identifier) @ns)) (string) @from) @stmt
+      (lexical_declaration (variable_declarator name:(identifier) @def value: (call_expression (identifier) @req arguments: (arguments (string) @from)))) (#eq? @req "require")
+      (lexical_declaration (variable_declarator (object_pattern) @pattern value: (call_expression (identifier) @req arguments: (arguments (string) @from)))) (#eq? @req "require")
+    `
+  },
+  nodeTypes: {
+    identifier: ["identifier"],
+    propertyIdentifier: ["property_identifier"],
+    shorthandPropertyIdentifier: ["shorthand_property_identifier", "shorthand_property_identifier_pattern"],
+    memberExpression: "member_expression"
+  },
+  classifyDefinition: (n) => {
+    const t = n.parent?.type;
+    if (t === "function_declaration")
+      return "function";
+    if (t === "generator_function_declaration")
+      return "function";
+    if (t === "method_definition")
+      return "function";
+    if (t === "class_declaration")
+      return "class";
+    return "variable";
+  },
+  isDeclarationName: (node) => {
+    const p = node.parent?.type;
+    return !!p && [
+      "function_declaration",
+      "generator_function_declaration",
+      "class_declaration",
+      "variable_declarator",
+      "import_specifier",
+      "namespace_import",
+      "import_clause",
+      // Method names in classes: needed so that editing a method name is
+      // classified as a definition change, not an unrecognised node.
+      "method_definition"
+    ].includes(p);
+  },
+  createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body",
+  createsFunctionScope: (n) => n.type === "function_declaration" || n.type === "generator_function_declaration" || n.type === "function" || n.type === "function_expression" || n.type === "arrow_function" || n.type === "method_definition",
+  membersAreImplicitlyInScope: false,
+  supportsCrossModuleSymbols: true,
+  native: {
+    normalizeQuery: (_kind, query) => query.replace(/\(function\)/g, "(function_expression)").replace(JS_OBJECT_METHOD_EXPORT_PATTERN, JS_OBJECT_METHOD_EXPORT_NATIVE_PATTERN),
+    authoritativeKinds: ["exports"],
+    notes: ["normalizes function node compatibility for native javascript grammar"]
+  }
+};
+registerLanguage(JAVASCRIPT_DEF);
+
+// dist/languages/definitions/python.js
+var PYTHON_DEF = {
+  id: "python",
+  extensions: [".py", ".pyi"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-python"),
+  usesQueryDrivenLocals: true,
+  structure: {
+    blocks: [
+      {
+        type: "class_definition",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "class"
+      },
+      {
+        type: "function_definition",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "function"
+      },
+      // Docstrings - only capture top-level module docstrings as standalone chunks
+      {
+        type: "expression_statement",
+        nameQuery: "(string) @chunk.docstring",
+        isBlock: false,
+        parentType: "module"
+      },
+      // Top level assignments
+      {
+        type: "assignment",
+        nameQuery: "left: (identifier) @chunk.name",
+        captureId: "module_var"
+      },
+      // Imports
+      { type: "import_statement", captureId: "imports" },
+      { type: "import_from_statement", captureId: "imports" }
+    ],
+    splitPoints: [
+      "if_statement",
+      "for_statement",
+      "while_statement",
+      "try_statement",
+      "with_statement",
+      "match_statement"
+    ],
+    comments: ["comment"]
+  },
+  graph: {
+    imports: `
+      (import_statement) @stmt
+      (import_from_statement) @stmt
+      (future_import_statement) @stmt
+    `,
+    // NOTE: These __all__ queries only capture module-level assignments.
+    // Dynamic __all__ definitions inside functions, conditionals, or loops
+    // (e.g., `if PY3: __all__ = [...]`) are not detected by these patterns.
+    // This is a known limitation - such patterns are rare in practice.
+    exports: `
+      ;; __all__ = ["a", "b"] - simple list assignment
+      (assignment left: (identifier) @left right: (list (string)+ @all_item)) @stmt
+      ;; __all__ = ("a", "b") - tuple assignment
+      (assignment left: (identifier) @left right: (tuple (string)+ @all_item)) @stmt
+      ;; __all__ = ["a"] + ["b"] - concatenation (captures strings in both sides)
+      (assignment left: (identifier) @left right: (binary_operator (list (string)+ @all_item))) @stmt
+      (assignment left: (identifier) @left right: (binary_operator right: (list (string)+ @all_item))) @stmt
+      ;; __all__.extend(["a"]) - extend pattern
+      (expression_statement (call function: (attribute object: (identifier) @left attribute: (identifier) @method) arguments: (argument_list (list (string)+ @all_item)))) @stmt
+      ;; __all__.append("a") - append pattern
+      (expression_statement (call function: (attribute object: (identifier) @left attribute: (identifier) @method) arguments: (argument_list (string) @all_item))) @stmt
+      ;; __all__ += ["a"] - augmented assignment
+      (augmented_assignment left: (identifier) @left right: (list (string)+ @all_item)) @stmt
+      (function_definition name: (identifier) @name)
+      (class_definition name: (identifier) @name)
+      (assignment left: (identifier) @name)
+    `,
+    locals: `
+      (function_definition name: (identifier) @name)
+      (class_definition name: (identifier) @name)
+      (assignment left: (identifier) @name)
+      ;; \`case Point(x=x, y=y):\` binds the right-hand identifier of a keyword
+      ;; pattern as a new local, distinct from the left-hand attribute name it
+      ;; matches against.
+      ;; A bare identifier in a case pattern is represented as a single-name
+      ;; dotted_name inside a case_pattern. Nested tuple/list/or patterns
+      ;; preserve this shape for each capture.
+      (case_pattern (dotted_name (identifier) @name))
+      ;; \`case value as alias:\` binds the direct identifier child as its alias.
+      (as_pattern (identifier) @name)
+      ;; \`case [head, *tail]:\` binds the capture after the splat.
+      (splat_pattern (identifier) @name)
+    `,
+    importBindings: `
+      (import_statement) @stmt
+      (import_from_statement) @stmt
+      (future_import_statement) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["identifier"],
+    propertyIdentifier: ["identifier"],
+    memberExpression: "attribute"
+  },
+  classifyDefinition: (n) => {
+    const t = n.parent?.type;
+    if (t === "function_definition")
+      return "function";
+    if (t === "class_definition")
+      return "class";
+    return "variable";
+  },
+  scopeDeclarationNames: (node) => {
+    const parentType = node.parent?.type;
+    return parentType === "case_pattern" || parentType === "as_pattern" || parentType === "splat_pattern" || parentType === "dotted_name";
+  },
+  isDeclarationName: (node) => {
+    const parent = node.parent;
+    const t = parent?.type;
+    if (t === "dotted_name" && parent && parent.namedChildren.length === 1 && (parent.parent?.type === "keyword_pattern" || parent.parent?.type === "case_pattern"))
+      return true;
+    if (parent?.type === "as_pattern")
+      return true;
+    if (t === "splat_pattern")
+      return true;
+    return !!t && ["function_definition", "class_definition", "assignment", "aliased_import"].includes(t);
+  },
+  createsBlockScope: (n) => n.type === "module" || n.type === "block",
+  createsFunctionScope: (n) => n.type === "function_definition" || n.type === "lambda",
+  membersAreImplicitlyInScope: false,
+  supportsCrossModuleSymbols: true
+};
+registerLanguage(PYTHON_DEF);
+
+// dist/languages/definitions/php.js
+var PHP_DEF = {
+  id: "php",
+  extensions: [".php"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-php"),
+  usesQueryDrivenLocals: true,
+  structure: {
+    blocks: [
+      {
+        type: "namespace_definition",
+        nameQuery: "name: (namespace_name) @chunk.name",
+        captureId: "namespace"
+      },
+      {
+        type: "class_declaration",
+        nameQuery: "name: (name) @chunk.name",
+        captureId: "class"
+      },
+      {
+        type: "interface_declaration",
+        nameQuery: "name: (name) @chunk.name",
+        captureId: "interface"
+      },
+      {
+        type: "trait_declaration",
+        nameQuery: "name: (name) @chunk.name",
+        captureId: "trait"
+      },
+      {
+        type: "enum_declaration",
+        nameQuery: "name: (name) @chunk.name",
+        captureId: "enum"
+      },
+      {
+        type: "function_definition",
+        nameQuery: "name: (name) @chunk.name",
+        captureId: "function"
+      },
+      {
+        type: "method_declaration",
+        nameQuery: "name: (name) @chunk.name",
+        captureId: "method"
+      },
+      {
+        type: "const_declaration",
+        nameQuery: "(const_element (name) @chunk.name)",
+        captureId: "const"
+      }
+    ],
+    splitPoints: [
+      "if_statement",
+      "switch_statement",
+      "for_statement",
+      "foreach_statement",
+      "while_statement",
+      "do_statement",
+      "try_statement",
+      "match_expression"
+    ],
+    comments: ["comment"]
+  },
+  graph: {
+    imports: `
+      (require_expression) @stmt
+      (include_expression) @stmt
+      (require_once_expression) @stmt
+      (include_once_expression) @stmt
+      (namespace_use_declaration) @stmt
+    `,
+    exports: `
+      (namespace_definition name: (namespace_name) @name)
+      (class_declaration name: (name) @name)
+      (interface_declaration name: (name) @name)
+      (trait_declaration name: (name) @name)
+      (enum_declaration name: (name) @name)
+      (enum_case name: (name) @name)
+      (function_definition name: (name) @name)
+      (const_declaration (const_element (name) @name))
+    `,
+    locals: `
+      (class_declaration name: (name) @name)
+      (interface_declaration name: (name) @name)
+      (trait_declaration name: (name) @name)
+      (enum_declaration name: (name) @name)
+      (enum_case name: (name) @name)
+      (function_definition name: (name) @name)
+      (method_declaration name: (name) @name)
+      (const_declaration (const_element (name) @name))
+      (property_element (variable_name) @name)
+    `,
+    importBindings: `
+      (require_expression) @stmt
+      (include_expression) @stmt
+      (require_once_expression) @stmt
+      (include_once_expression) @stmt
+      (namespace_use_declaration) @stmt
+  `
+  },
+  nodeTypes: {
+    identifier: ["name", "variable_name", "namespace_name", "qualified_name", "relative_name"],
+    propertyIdentifier: ["name"],
+    memberExpression: "member_access_expression"
+  },
+  classifyDefinition: (node) => {
+    const parentType = node.parent?.type;
+    if (parentType === "class_declaration")
+      return "class";
+    if (parentType === "interface_declaration")
+      return "interface";
+    if (parentType === "trait_declaration")
+      return "trait";
+    if (parentType === "enum_declaration")
+      return "type";
+    if (parentType === "enum_case")
+      return "constant";
+    if (parentType === "function_definition")
+      return "function";
+    if (parentType === "method_declaration")
+      return "method";
+    if (parentType === "namespace_definition")
+      return "namespace";
+    if (parentType === "const_element" || parentType === "const_declaration") {
+      return "constant";
+    }
+    return "variable";
+  },
+  normalizeIdentifier: (name) => name.replace(/^\$/, ""),
+  isDeclarationName: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return false;
+    const nameFieldOwnerTypes = /* @__PURE__ */ new Set([
+      "namespace_definition",
+      "class_declaration",
+      "interface_declaration",
+      "trait_declaration",
+      "enum_declaration",
+      "enum_case",
+      "function_definition",
+      "method_declaration"
+    ]);
+    if (nameFieldOwnerTypes.has(parent.type)) {
+      return parent.childForFieldName("name")?.id === node.id;
+    }
+    if (parent.type === "property_element" && node.type === "variable_name")
+      return true;
+    return parent.type === "const_element" && parent.namedChildren.some((child) => child.id === node.id && child.type === "name");
+  },
+  scopeDeclarationNames: (node) => node.type === "variable_name" && node.parent?.type === "property_element",
+  createsFunctionScope: (node) => node.type === "function_definition" || node.type === "method_declaration",
+  membersAreImplicitlyInScope: false,
+  supportsCrossModuleSymbols: true
+};
+registerLanguage(PHP_DEF);
+
+// dist/languages/definitions/html.js
+var HTML_DEF = {
+  id: "html",
+  extensions: [".html", ".htm"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-html"),
+  structure: {
+    blocks: [
+      {
+        type: "element",
+        nameQuery: `(start_tag (attribute (attribute_name) @attr (#eq? @attr "id") (quoted_attribute_value (attribute_value) @chunk.name)))`,
+        captureId: "element"
+      },
+      { type: "script_element", captureId: "script" },
+      { type: "style_element", captureId: "style" }
+    ],
+    splitPoints: ["element"],
+    comments: ["comment"]
+  },
+  graph: {
+    imports: `
+      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt
+      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#match? @tag "^(link|a)$")
+      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#match? @tag "^(link|a)$")
+      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#eq? @tag "img")
+      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#eq? @tag "img")
+    `,
+    exports: "",
+    locals: `
+      (attribute (attribute_name) @attr (#eq? @attr "id") (quoted_attribute_value (attribute_value) @name))
+    `,
+    importBindings: `
+      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt
+      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @from)))) @stmt (#match? @tag "^(link|a)$")
+      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @from)))) @stmt (#match? @tag "^(link|a)$")
+      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt (#eq? @tag "img")
+      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt (#eq? @tag "img")
+    `
+  },
+  nodeTypes: {
+    identifier: ["attribute_value", "tag_name"]
+  }
+};
+registerLanguage(HTML_DEF);
+
+// dist/languages/definitions/htmlStub.js
+function htmlStubLanguage(id, extensions) {
+  return {
+    id,
+    extensions,
+    grammar: () => loadTreeSitterLanguage("tree-sitter-html"),
+    structure: {
+      blocks: [],
+      splitPoints: [],
+      comments: []
+    },
+    graph: {
+      imports: "",
+      exports: "",
+      locals: "",
+      importBindings: ""
+    },
+    nodeTypes: {
+      identifier: []
+    }
+  };
+}
+
+// dist/languages/definitions/astro.js
+var ASTRO_DEF = htmlStubLanguage("astro", [".astro"]);
+registerLanguage(ASTRO_DEF);
+
+// dist/languages/definitions/hbs.js
+var HBS_DEF = htmlStubLanguage("hbs", [".hbs", ".handlebars"]);
+registerLanguage(HBS_DEF);
+
+// dist/languages/definitions/markdown.js
+var MARKDOWN_DEF = htmlStubLanguage("markdown", [".md"]);
+registerLanguage(MARKDOWN_DEF);
+
+// dist/languages/definitions/mdx.js
+var MDX_DEF = htmlStubLanguage("mdx", [".mdx"]);
+registerLanguage(MDX_DEF);
+
+// dist/languages/definitions/rst.js
+var RST_DEF = htmlStubLanguage("rst", [".rst"]);
+registerLanguage(RST_DEF);
+
+// dist/languages/definitions/adoc.js
+var ADOC_DEF = htmlStubLanguage("adoc", [".adoc", ".asciidoc"]);
+registerLanguage(ADOC_DEF);
+
+// dist/languages/definitions/cssLike.js
+function cssLikeStructure() {
+  return {
+    blocks: [
+      { type: "rule_set", captureId: "rule" },
+      { type: "media_statement", captureId: "media" },
+      { type: "keyframes_statement", captureId: "keyframes" }
+    ],
+    splitPoints: ["rule_set"],
+    comments: ["comment", "js_comment"]
+  };
+}
+function cssLikeGraph() {
+  return {
+    imports: `
+      (import_statement (string_value) @mod) @stmt
+    `,
+    exports: "",
+    locals: `
+      (class_selector (class_name) @name)
+      (id_selector (id_name) @name)
+    `,
+    importBindings: `
+      (import_statement (string_value) @from) @stmt
+    `
+  };
+}
+function cssLikeNodeTypes() {
+  return {
+    identifier: ["class_name", "id_name"]
+  };
+}
+
+// dist/languages/definitions/css.js
+var CSS_DEF = {
+  id: "css",
+  extensions: [".css"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-css"),
+  structure: cssLikeStructure(),
+  graph: cssLikeGraph(),
+  nodeTypes: cssLikeNodeTypes()
+};
+registerLanguage(CSS_DEF);
+
+// dist/languages/definitions/scss.js
+var SCSS_SYMBOL_QUERY_PATTERNS = [
+  "(mixin_statement (name) @name)",
+  "(function_statement (name) @name)",
+  "(variable_declaration (variable) @name)",
+  "(class_selector (class_name) @name)",
+  "(id_selector (id_name) @name)"
+];
+var SCSS_DEF = {
+  id: "scss",
+  extensions: [".scss"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-scss"),
+  structure: {
+    blocks: [
+      { type: "rule_set", captureId: "rule" },
+      { type: "mixin_statement", captureId: "mixin" },
+      { type: "function_statement", captureId: "function" },
+      { type: "media_statement", captureId: "media" },
+      { type: "keyframes_statement", captureId: "keyframes" }
+    ],
+    splitPoints: ["rule_set", "mixin_statement", "function_statement"],
+    comments: ["comment", "js_comment"]
+  },
+  graph: {
+    imports: `
+      (import_statement (string_value) @mod) @stmt
+      (use_statement (string_value) @mod) @stmt
+      (forward_statement (string_value) @mod) @stmt
+    `,
+    exports: `
+      (mixin_statement (name) @name)
+      (function_statement (name) @name)
+      (variable_declaration (variable) @name)
+    `,
+    locals: `
+      (mixin_statement (name) @name)
+      (function_statement (name) @name)
+      (variable_declaration (variable) @name)
+      (class_selector (class_name) @name)
+      (id_selector (id_name) @name)
+    `,
+    importBindings: `
+      (import_statement (string_value) @from) @stmt
+      (use_statement (string_value) @from) @stmt
+      (forward_statement (string_value) @from) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["name", "variable", "class_name", "id_name"]
+  },
+  native: {
+    normalizeQuery: (_kind, query) => SCSS_SYMBOL_QUERY_PATTERNS.some((pattern) => query.includes(pattern)) ? "" : query,
+    notes: ["skips unsupported SCSS symbol queries in the native runtime"]
+  }
+};
+registerLanguage(SCSS_DEF);
+
+// dist/languages/definitions/less.js
+var LESS_DEF = {
+  id: "less",
+  extensions: [".less"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-css"),
+  structure: cssLikeStructure(),
+  graph: cssLikeGraph(),
+  nodeTypes: cssLikeNodeTypes()
+};
+registerLanguage(LESS_DEF);
+
+// dist/languages/definitions/vue.js
+var VUE_DEF = {
+  id: "vue",
+  extensions: [".vue"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-vue"),
+  structure: {
+    blocks: [
+      { type: "template_element", captureId: "template" },
+      { type: "script_element", captureId: "script" },
+      { type: "style_element", captureId: "style" }
+    ],
+    splitPoints: ["template_element", "script_element", "style_element"],
+    comments: ["comment"]
+  },
+  graph: {
+    imports: `
+      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt
+    `,
+    exports: "",
+    locals: "",
+    importBindings: `
+      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["attribute_value"]
+  }
+};
+registerLanguage(VUE_DEF);
+
+// dist/languages/definitions/svelte.js
+var SVELTE_DEF = {
+  id: "svelte",
+  extensions: [".svelte"],
+  grammar: () => loadTreeSitterLanguage("@tree-sitter-grammars/tree-sitter-svelte"),
+  structure: {
+    blocks: [
+      { type: "script_element", captureId: "script" },
+      { type: "style_element", captureId: "style" },
+      { type: "element", captureId: "element" }
+    ],
+    splitPoints: ["script_element", "style_element"],
+    comments: ["comment"]
+  },
+  graph: {
+    imports: `
+      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt
+    `,
+    exports: "",
+    locals: "",
+    importBindings: `
+      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["attribute_value"]
+  }
+};
+registerLanguage(SVELTE_DEF);
+
+// dist/languages/definitions/ruby.js
+var RUBY_DEF = {
+  id: "ruby",
+  extensions: [".rb"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-ruby"),
+  structure: {
+    blocks: [
+      {
+        type: "class",
+        nameQuery: "name: (constant) @chunk.name",
+        captureId: "class"
+      },
+      {
+        type: "module",
+        nameQuery: "name: (constant) @chunk.name",
+        captureId: "module"
+      },
+      {
+        type: "method",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "method"
+      },
+      {
+        type: "singleton_method",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "method"
+      }
+    ],
+    splitPoints: ["if", "unless", "case", "while", "until", "for", "begin"],
+    comments: ["comment"]
+  },
+  graph: {
+    imports: `
+      (call method: (identifier) @method arguments: (argument_list (string (string_content) @mod)) (#match? @method "^(require|require_relative)$")) @stmt
+    `,
+    exports: `
+      (class name: (constant) @name)
+      (module name: (constant) @name)
+      (method name: (identifier) @name)
+      (assignment left: (constant) @name)
+    `,
+    locals: `
+      (class name: (constant) @name)
+      (module name: (constant) @name)
+      (method name: (identifier) @name)
+      (assignment left: (identifier) @name)
+      (assignment left: (constant) @name)
+    `,
+    importBindings: `
+      ((call method: (identifier) @method arguments: (argument_list (string (string_content) @from))) @stmt (#match? @method "^(require|require_relative)$"))
+    `
+  },
+  nodeTypes: {
+    identifier: ["identifier", "constant"],
+    memberExpression: "call"
+  },
+  supportsCrossModuleSymbols: true,
+  classifyDefinition: (node) => {
+    const assignment = node.parent;
+    const value = assignment?.childForFieldName("right");
+    if (assignment?.type === "assignment" && assignment.childForFieldName("left")?.id === node.id && value?.type === "call" && value.childForFieldName("receiver")?.text === "Struct" && value.childForFieldName("method")?.text === "new") {
+      return "class";
+    }
+    return "variable";
+  },
+  scopeDeclarationNames: (node) => node.type === "constant" && node.parent?.type === "assignment",
+  createsFunctionScope: (node) => node.type === "method" || node.type === "singleton_method",
+  createsBlockScope: (node) => node.type === "do_block" || node.type === "block",
+  isDeclarationName: (node) => {
+    const p = node.parent;
+    if (!p)
+      return false;
+    if (p.type === "class" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "module" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "method" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "singleton_method" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "assignment" && p.childForFieldName("left")?.id === node.id)
+      return true;
+    return false;
+  }
+};
+registerLanguage(RUBY_DEF);
+
+// dist/languages/definitions/go.js
+var GO_DEF = {
+  id: "go",
+  extensions: [".go"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-go"),
+  usesQueryDrivenLocals: true,
+  structure: {
+    blocks: [
+      {
+        type: "function_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "function"
+      },
+      {
+        type: "method_declaration",
+        nameQuery: "name: (field_identifier) @chunk.name",
+        captureId: "method"
+      },
+      {
+        type: "type_declaration",
+        nameQuery: "(type_spec name: (type_identifier) @chunk.name)",
+        captureId: "type"
+      }
+    ],
+    splitPoints: [
+      "if_statement",
+      "for_statement",
+      "expression_switch_statement",
+      "type_switch_statement",
+      "select_statement"
+    ],
+    comments: ["comment"]
+  },
+  graph: {
+    imports: `
+      (import_spec path: (interpreted_string_literal) @mod) @stmt
+    `,
+    exports: `
+      (function_declaration name: (identifier) @name)
+      (method_declaration name: (field_identifier) @name)
+      (type_spec name: (type_identifier) @name)
+      (const_spec name: (identifier) @name)
+      (var_spec name: (identifier) @name)
+    `,
+    locals: `
+      (function_declaration name: (identifier) @name)
+      (method_declaration name: (field_identifier) @name)
+      (type_spec name: (type_identifier) @name)
+      (parameter_declaration name: (identifier) @name)
+      (variadic_parameter_declaration name: (identifier) @name)
+      (short_var_declaration left: (expression_list (identifier) @name))
+      (var_spec name: (identifier) @name)
+      (const_spec name: (identifier) @name)
+      (type_spec type: (struct_type (field_declaration_list (field_declaration name: (field_identifier) @name))))
+      (range_clause left: (expression_list (identifier) @name) (#not-eq? @name "_"))
+    `,
+    importBindings: `
+      (import_spec name: (package_identifier) @alias path: (interpreted_string_literal) @from) @stmt
+      (import_spec path: (interpreted_string_literal) @from) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["identifier", "field_identifier", "type_identifier", "package_identifier"],
+    memberExpression: "selector_expression"
+  },
+  supportsCrossModuleSymbols: true,
+  classifyDefinition: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return "variable";
+    if (parent.type === "function_declaration" || parent.type === "method_declaration")
+      return "function";
+    if (parent.type === "type_spec" && parent.childForFieldName("name")?.id === node.id)
+      return "type";
+    return "variable";
+  },
+  createsFunctionScope: (node) => node.type === "function_declaration" || node.type === "method_declaration" || node.type === "func_literal",
+  createsBlockScope: (node) => node.type === "block" || node.type === "for_statement",
+  membersAreImplicitlyInScope: false,
+  isDeclarationName: (node) => {
+    const p = node.parent;
+    if (!p)
+      return false;
+    if (p.type === "function_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "method_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "type_spec" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "var_spec" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "const_spec" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "expression_list" && p.parent?.type === "short_var_declaration")
+      return node.type === "identifier";
+    if (p.type === "expression_list" && p.parent?.type === "range_clause")
+      return node.type === "identifier" && node.text !== "_";
+    if (p.type === "parameter_declaration" || p.type === "variadic_parameter_declaration") {
+      return node.type === "identifier";
+    }
+    if (p.type === "field_declaration" && node.type === "field_identifier")
+      return true;
+    return false;
+  },
+  scopeDeclarationNames: (node) => node.type === "field_identifier" && node.parent?.type === "field_declaration" || node.type === "identifier" && node.parent?.type === "expression_list" && node.parent.parent?.type === "range_clause"
+};
+registerLanguage(GO_DEF);
+
+// dist/languages/definitions/java.js
+var JAVA_DEF = {
+  id: "java",
+  extensions: [".java"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-java"),
+  usesQueryDrivenLocals: true,
+  structure: {
+    blocks: [
+      {
+        type: "class_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "class"
+      },
+      {
+        type: "record_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "class"
+      },
+      {
+        type: "interface_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "interface"
+      },
+      {
+        type: "enum_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "enum"
+      },
+      {
+        type: "annotation_type_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "interface"
+      },
+      {
+        type: "method_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "method"
+      },
+      {
+        type: "constructor_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "method"
+      }
+    ],
+    splitPoints: ["if_statement", "for_statement", "while_statement", "try_statement", "switch_expression"],
+    comments: ["line_comment", "block_comment"]
+  },
+  graph: {
+    imports: `
+      (import_declaration . (_) @mod) @stmt
+    `,
+    exports: `
+      (class_declaration name: (identifier) @name)
+      (record_declaration name: (identifier) @name)
+      (interface_declaration name: (identifier) @name)
+      (enum_declaration name: (identifier) @name)
+      (annotation_type_declaration name: (identifier) @name)
+      (enum_constant name: (identifier) @name)
+      (method_declaration name: (identifier) @name)
+      (field_declaration (variable_declarator name: (identifier) @name))
+    `,
+    locals: `
+      (class_declaration name: (identifier) @name)
+      (record_declaration name: (identifier) @name)
+      (interface_declaration name: (identifier) @name)
+      (enum_declaration name: (identifier) @name)
+      (annotation_type_declaration name: (identifier) @name)
+      (enum_constant name: (identifier) @name)
+      (method_declaration name: (identifier) @name)
+      (variable_declarator name: (identifier) @name)
+    `,
+    importBindings: `
+      (import_declaration . (_) @from) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["identifier", "type_identifier"],
+    memberExpression: "field_access"
+  },
+  supportsCrossModuleSymbols: true,
+  classifyDefinition: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return "variable";
+    if (parent.type === "method_declaration" || parent.type === "constructor_declaration")
+      return "method";
+    if (parent.type === "class_declaration" || parent.type === "record_declaration")
+      return "class";
+    if (parent.type === "interface_declaration" || parent.type === "annotation_type_declaration")
+      return "interface";
+    if (parent.type === "enum_declaration")
+      return "type";
+    return "variable";
+  },
+  createsFunctionScope: (node) => node.type === "method_declaration" || node.type === "constructor_declaration",
+  createsBlockScope: (node) => node.type === "block" || node.type === "class_body",
+  isDeclarationName: (node) => {
+    const p = node.parent;
+    if (!p)
+      return false;
+    if (p.type === "class_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "record_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "interface_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "annotation_type_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "enum_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "enum_constant" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "method_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "variable_declarator" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "formal_parameter" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    return false;
+  }
+};
+registerLanguage(JAVA_DEF);
+
+// dist/languages/definitions/csharp.js
+var CSHARP_DEF = {
+  id: "csharp",
+  extensions: [".cs"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-c-sharp"),
+  usesQueryDrivenLocals: true,
+  structure: {
+    blocks: [
+      {
+        type: "class_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "class"
+      },
+      {
+        type: "record_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "class"
+      },
+      {
+        type: "interface_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "interface"
+      },
+      {
+        type: "enum_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "enum"
+      },
+      {
+        type: "method_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "method"
+      },
+      {
+        type: "namespace_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "namespace"
+      }
+    ],
+    splitPoints: [
+      "if_statement",
+      "for_statement",
+      "foreach_statement",
+      "while_statement",
+      "switch_statement",
+      "try_statement"
+    ],
+    comments: ["comment"]
+  },
+  graph: {
+    imports: `
+      (using_directive . (_) @mod) @stmt
+    `,
+    exports: `
+      (class_declaration name: (identifier) @name)
+      (record_declaration name: (identifier) @name)
+      (interface_declaration name: (identifier) @name)
+      (enum_declaration name: (identifier) @name)
+      (enum_member_declaration name: (identifier) @name)
+      (method_declaration name: (identifier) @name)
+      (property_declaration name: (identifier) @name)
+    `,
+    locals: `
+      (class_declaration name: (identifier) @name)
+      (record_declaration name: (identifier) @name)
+      (interface_declaration name: (identifier) @name)
+      (enum_declaration name: (identifier) @name)
+      (enum_member_declaration name: (identifier) @name)
+      (method_declaration name: (identifier) @name)
+      (variable_declarator (identifier) @name)
+      (declaration_pattern name: (identifier) @name)
+    `,
+    importBindings: `
+      (using_directive name: (identifier) @alias . (_) @from) @stmt
+      (using_directive . (_) @from) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["identifier"],
+    memberExpression: "member_access_expression"
+  },
+  supportsCrossModuleSymbols: true,
+  classifyDefinition: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return "variable";
+    if (parent.type === "method_declaration" || parent.type === "constructor_declaration")
+      return "method";
+    if (parent.type === "class_declaration" || parent.type === "record_declaration")
+      return "class";
+    if (parent.type === "interface_declaration")
+      return "interface";
+    if (parent.type === "enum_declaration")
+      return "type";
+    return "variable";
+  },
+  createsFunctionScope: (node) => node.type === "method_declaration" || node.type === "constructor_declaration",
+  createsBlockScope: (node) => node.type === "block" || node.type === "declaration_list",
+  isDeclarationName: (node) => {
+    const p = node.parent;
+    if (!p)
+      return false;
+    if (p.type === "class_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "record_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "interface_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "enum_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "enum_member_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "method_declaration" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "variable_declarator" && p.child(0)?.id === node.id)
+      return true;
+    if (p.type === "parameter" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "declaration_pattern" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    return false;
+  }
+};
+registerLanguage(CSHARP_DEF);
+
+// dist/languages/definitions/rust.js
+var RUST_DEF = {
+  id: "rust",
+  extensions: [".rs"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-rust"),
+  usesQueryDrivenLocals: true,
+  structure: {
+    blocks: [
+      {
+        type: "function_item",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "function"
+      },
+      {
+        type: "struct_item",
+        nameQuery: "name: (type_identifier) @chunk.name",
+        captureId: "struct"
+      },
+      {
+        type: "enum_item",
+        nameQuery: "name: (type_identifier) @chunk.name",
+        captureId: "enum"
+      },
+      {
+        type: "impl_item",
+        nameQuery: "type: (type_identifier) @chunk.name",
+        captureId: "impl"
+      },
+      {
+        type: "mod_item",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "module"
+      },
+      {
+        type: "macro_definition",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "macro"
+      }
+    ],
+    splitPoints: ["if_expression", "for_expression", "while_expression", "loop_expression", "match_expression"],
+    comments: ["line_comment", "block_comment"]
+  },
+  graph: {
+    imports: `
+      (mod_item name: (identifier) @mod) @stmt
+      (extern_crate_declaration name: (identifier) @mod) @stmt
+      (use_declaration argument: (_) @mod) @stmt
+    `,
+    exports: `
+      (function_item name: (identifier) @name) @stmt
+      (struct_item name: (type_identifier) @name) @stmt
+      (trait_item name: (type_identifier) @name) @stmt
+      (enum_item name: (type_identifier) @name) @stmt
+      (enum_variant name: (identifier) @name) @stmt
+      (const_item name: (identifier) @name) @stmt
+      (static_item name: (identifier) @name) @stmt
+      (macro_definition name: (identifier) @name) @stmt
+      (use_declaration argument: (scoped_identifier path: (_) @from name: (identifier) @src)) @stmt
+      (use_declaration argument: (identifier) @src) @stmt
+      ;; Grouped imports: \`use foo::{Bar, Baz};\` (and scoped forms like
+      ;; \`use crate::foo::{Bar, Baz};\`) - emit one export per named member
+      ;; so each is a resolvable target, matching the plain scoped_identifier
+      ;; form above. The shared path may itself be scoped, so it is captured
+      ;; generically rather than requiring a single bare identifier segment.
+      (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (identifier) @src))) @stmt
+      ;; Aliased members inside a group (\`use foo::{Bar as Baz}\`) export
+      ;; under their alias, matching how a single aliased import behaves.
+      (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (use_as_clause alias: (identifier) @src)))) @stmt
+    `,
+    locals: `
+      (function_item name: (identifier) @name)
+      (struct_item name: (type_identifier) @name)
+      (trait_item name: (type_identifier) @name)
+      (enum_item name: (type_identifier) @name)
+      (enum_variant name: (identifier) @name)
+      (const_item name: (identifier) @name)
+      (static_item name: (identifier) @name)
+      (macro_definition name: (identifier) @name)
+      (let_declaration pattern: (identifier) @name)
+      (parameter pattern: (identifier) @name)
+    `,
+    importBindings: `
+      (mod_item name: (identifier) @from) @stmt
+      (extern_crate_declaration name: (identifier) @from) @stmt
+      (extern_crate_declaration name: (identifier) @from alias: (identifier) @alias) @stmt
+      (use_declaration argument: (use_as_clause path: (identifier) @from alias: (identifier) @alias)) @stmt
+      (use_declaration argument: (use_as_clause path: (scoped_identifier path: (_) @from name: (identifier) @iname) alias: (identifier) @alias)) @stmt
+      (use_declaration argument: (scoped_identifier path: (_) @from name: (identifier) @iname)) @stmt
+      (use_declaration argument: (identifier) @from) @stmt
+      (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (identifier) @iname))) @stmt
+      ;; Aliased members inside a group (\`use foo::{Bar as Baz}\`): import
+      ;; the original name under its local alias.
+      (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (use_as_clause path: (identifier) @iname alias: (identifier) @alias)))) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["identifier", "type_identifier"],
+    memberExpression: "field_expression"
+  },
+  supportsCrossModuleSymbols: true,
+  scopeDeclarationNames: (node) => node.parent?.type === "macro_definition",
+  classifyDefinition: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return "variable";
+    if (parent.type === "function_item" || parent.type === "macro_definition")
+      return "function";
+    if (parent.type === "enum_item")
+      return "type";
+    if (parent.type === "struct_item" || parent.type === "trait_item")
+      return "class";
+    return "variable";
+  },
+  createsFunctionScope: (node) => node.type === "function_item",
+  createsBlockScope: (node) => node.type === "block",
+  membersAreImplicitlyInScope: false,
+  isDeclarationName: (node) => {
+    const p = node.parent;
+    if (!p)
+      return false;
+    if (p.type === "function_item" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "struct_item" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "trait_item" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "enum_item" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "enum_variant" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "const_item" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "static_item" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "macro_definition" && p.childForFieldName("name")?.id === node.id)
+      return true;
+    if (p.type === "let_declaration" && p.childForFieldName("pattern")?.id === node.id)
+      return true;
+    if (p.type === "parameter" && p.childForFieldName("pattern")?.id === node.id)
+      return true;
+    return false;
+  }
+};
+registerLanguage(RUST_DEF);
+
+// dist/languages/definitions/cFamily.js
+var cFamilyContainerTypes = /* @__PURE__ */ new Set([
+  "function_definition",
+  "declaration",
+  "parameter_declaration",
+  "field_declaration",
+  "type_definition",
+  "init_declarator"
+]);
+var cFamilyControlSplitPoints = [
+  "if_statement",
+  "for_statement",
+  "while_statement",
+  "do_statement",
+  "switch_statement",
+  "case_statement"
+];
+var cFamilyIncludeImportsQuery = `
+      (preproc_include path: (string_literal) @mod) @stmt
+      (preproc_include path: (system_lib_string) @mod) @stmt
+      (preproc_include path: (identifier) @mod) @stmt
+    `;
+var cFamilyIncludeBindingsQuery = `
+      (preproc_include path: (string_literal) @from) @stmt
+      (preproc_include path: (system_lib_string) @from) @stmt
+      (preproc_include path: (identifier) @from) @stmt
+    `;
+var cFamilyParameterListTypes = /* @__PURE__ */ new Set(["parameter_declaration", "parameter_list"]);
+function cFunctionNameQuery(captureName, includeFieldIdentifier) {
+  const identifierTypes = includeFieldIdentifier ? ["identifier", "field_identifier"] : ["identifier"];
+  const patterns = [];
+  for (const identifierType of identifierTypes) {
+    patterns.push(`(function_declarator declarator: (${identifierType}) @${captureName})`);
+    patterns.push(`(function_declarator declarator: (pointer_declarator declarator: (${identifierType}) @${captureName}))`);
+    patterns.push(`(pointer_declarator declarator: (function_declarator declarator: (${identifierType}) @${captureName}))`);
+    patterns.push(`(function_declarator declarator: (parenthesized_declarator (pointer_declarator declarator: (${identifierType}) @${captureName})))`);
+  }
+  return `
+  declarator: [
+    ${patterns.join("\n    ")}
+  ]
+`;
+}
+function cFamilyCoreExportQueries(functionNameQuery) {
+  return [
+    `(function_definition ${functionNameQuery})`,
+    `(declaration ${functionNameQuery})`,
+    `(struct_specifier name: (type_identifier) @name)`,
+    `(enum_specifier name: (type_identifier) @name)`,
+    `(type_definition declarator: (type_identifier) @name)`,
+    `(declaration declarator: (identifier) @name)`,
+    `(declaration declarator: (init_declarator declarator: (identifier) @name))`
+  ];
+}
+function cFamilyCoreLocalQueries(functionNameQuery) {
+  return [
+    `(function_definition ${functionNameQuery})`,
+    `(struct_specifier name: (type_identifier) @name)`,
+    `(enum_specifier name: (type_identifier) @name)`,
+    `(type_definition declarator: (type_identifier) @name)`,
+    `(declaration declarator: (identifier) @name)`,
+    `(declaration declarator: (init_declarator declarator: (identifier) @name))`,
+    `(parameter_declaration declarator: (identifier) @name)`,
+    `(field_declaration declarator: (field_identifier) @name)`
+  ];
+}
+function joinQueryPatterns(patterns) {
+  return `
+      ${patterns.join("\n      ")}
+    `;
+}
+function cFamilyBlock(type, nameQuery, captureId) {
+  return {
+    type,
+    nameQuery,
+    captureId
+  };
+}
+function cFamilyFunctionBlock(functionNameQuery) {
+  return cFamilyBlock("function_definition", functionNameQuery, "function");
+}
+function cFamilyTypeIdentifierBlock(type, captureId) {
+  return cFamilyBlock(type, "name: (type_identifier) @chunk.name", captureId);
+}
+function createCFamilyLanguageDefinition(options) {
+  const functionNameQuery = cFunctionNameQuery("chunk.name", options.includeFieldIdentifier);
+  const graphFunctionNameQuery = cFunctionNameQuery("name", options.includeFieldIdentifier);
+  return {
+    id: options.id,
+    extensions: [...options.extensions],
+    grammar: () => loadTreeSitterLanguage(options.grammarPackage),
+    structure: {
+      blocks: options.blocks(functionNameQuery),
+      splitPoints: [...options.splitPoints ?? cFamilyControlSplitPoints],
+      comments: ["comment"]
+    },
+    graph: {
+      imports: cFamilyIncludeImportsQuery,
+      exports: joinQueryPatterns([
+        ...cFamilyCoreExportQueries(graphFunctionNameQuery),
+        ...options.extraExportQueries ?? []
+      ]),
+      locals: joinQueryPatterns([
+        ...cFamilyCoreLocalQueries(graphFunctionNameQuery),
+        ...options.extraLocalQueries ?? []
+      ]),
+      importBindings: cFamilyIncludeBindingsQuery
+    },
+    nodeTypes: options.nodeTypes,
+    classifyDefinition: options.classifyDefinition,
+    isDeclarationName: options.isDeclarationName,
+    scopeDeclarationNames: "all",
+    createsFunctionScope: options.createsFunctionScope,
+    createsBlockScope: (node) => node.type === "compound_statement",
+    supportsCrossModuleSymbols: true,
+    usesQueryDrivenLocals: options.usesQueryDrivenLocals || false
+  };
+}
+function isWithin(node, ancestor) {
+  let current = node;
+  while (current) {
+    if (ancestor && current.id === ancestor.id)
+      return true;
+    current = current.parent;
+  }
+  return false;
+}
+function isInField(node, parent, field) {
+  return isWithin(node, parent.childForFieldName(field));
+}
+function findAncestor(node, types) {
+  let current = node.parent;
+  while (current) {
+    if (types.has(current.type))
+      return current;
+    current = current.parent;
+  }
+  return null;
+}
+function isInParameterList(node) {
+  return !!findAncestor(node, cFamilyParameterListTypes);
+}
+function resolveDeclaratorRoot(ancestor) {
+  let declaratorNode = ancestor.childForFieldName("declarator");
+  if (!declaratorNode)
+    return null;
+  if (declaratorNode.type === "init_declarator") {
+    const inner = declaratorNode.childForFieldName("declarator");
+    if (inner)
+      declaratorNode = inner;
+  }
+  if (declaratorNode.type === "function_declarator") {
+    const inner = declaratorNode.childForFieldName("declarator");
+    if (inner)
+      declaratorNode = inner;
+  }
+  return declaratorNode;
+}
+function isInAncestorDeclarator(node, ancestorTypes) {
+  const ancestor = findAncestor(node, ancestorTypes);
+  if (!ancestor)
+    return false;
+  const declaratorNode = resolveDeclaratorRoot(ancestor);
+  if (!declaratorNode)
+    return false;
+  return isWithin(node, declaratorNode);
+}
+function isFunctionDeclarator(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "function_declarator")
+      return true;
+    if (cFamilyContainerTypes.has(current.type))
+      return false;
+    current = current.parent;
+  }
+  return false;
+}
+
+// dist/languages/definitions/c.js
+var C_DEF = createCFamilyLanguageDefinition({
+  id: "c",
+  extensions: [".c", ".h", ".i"],
+  grammarPackage: "tree-sitter-c",
+  includeFieldIdentifier: false,
+  blocks: (functionNameQuery) => [
+    cFamilyFunctionBlock(functionNameQuery),
+    cFamilyTypeIdentifierBlock("struct_specifier", "struct"),
+    cFamilyTypeIdentifierBlock("union_specifier", "union"),
+    cFamilyTypeIdentifierBlock("enum_specifier", "enum"),
+    cFamilyBlock("type_definition", "declarator: (type_identifier) @chunk.name", "type"),
+    cFamilyBlock("preproc_def", "name: (identifier) @chunk.name", "macro"),
+    cFamilyBlock("preproc_function_def", "name: (identifier) @chunk.name", "macro")
+  ],
+  extraExportQueries: [
+    `(union_specifier name: (type_identifier) @name)`,
+    `(enumerator name: (identifier) @name)`,
+    `(preproc_def name: (identifier) @name)`,
+    `(preproc_function_def name: (identifier) @name)`
+  ],
+  extraLocalQueries: [
+    `(union_specifier name: (type_identifier) @name)`,
+    `(enumerator name: (identifier) @name)`,
+    `(preproc_def name: (identifier) @name)`,
+    `(preproc_function_def name: (identifier) @name)`
+  ],
+  nodeTypes: {
+    identifier: ["identifier", "field_identifier", "type_identifier"],
+    propertyIdentifier: ["field_identifier"],
+    memberExpression: "field_expression"
+  },
+  classifyDefinition: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return "variable";
+    if (parent.type === "enum_specifier")
+      return "type";
+    if (parent.type === "struct_specifier" || parent.type === "union_specifier")
+      return "class";
+    if (parent.type === "type_definition" && isInField(node, parent, "declarator"))
+      return "type";
+    const container = findAncestor(node, cFamilyContainerTypes);
+    if (container?.type === "function_definition")
+      return "function";
+    if (container?.type === "declaration" && isFunctionDeclarator(node))
+      return "function";
+    return "variable";
+  },
+  isDeclarationName: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return false;
+    if ((parent.type === "struct_specifier" || parent.type === "union_specifier" || parent.type === "enum_specifier") && isInField(node, parent, "name"))
+      return true;
+    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["parameter_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["field_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["init_declarator"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["type_definition"])))
+      return true;
+    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["function_definition"])) && !isInParameterList(node))
+      return true;
+    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["declaration"])) && !isInParameterList(node))
+      return true;
+    if (parent.type === "enumerator" && isInField(node, parent, "name"))
+      return true;
+    if (parent.type === "preproc_def" && isInField(node, parent, "name"))
+      return true;
+    if (parent.type === "preproc_function_def" && isInField(node, parent, "name"))
+      return true;
+    return false;
+  },
+  createsFunctionScope: (node) => node.type === "function_definition"
+});
+registerLanguage(C_DEF);
+
+// dist/languages/definitions/cpp.js
+var CPP_DEF = createCFamilyLanguageDefinition({
+  id: "cpp",
+  extensions: [".cc", ".cpp", ".cxx", ".c++", ".hpp", ".hh", ".hxx", ".ipp", ".tpp", ".inl"],
+  grammarPackage: "tree-sitter-cpp",
+  includeFieldIdentifier: true,
+  usesQueryDrivenLocals: true,
+  blocks: (functionNameQuery) => [
+    cFamilyFunctionBlock(functionNameQuery),
+    cFamilyTypeIdentifierBlock("class_specifier", "class"),
+    cFamilyTypeIdentifierBlock("struct_specifier", "struct"),
+    cFamilyTypeIdentifierBlock("enum_specifier", "enum"),
+    cFamilyBlock("namespace_definition", "name: (namespace_identifier) @chunk.name", "namespace"),
+    cFamilyTypeIdentifierBlock("alias_declaration", "type"),
+    cFamilyBlock("type_definition", "declarator: (type_identifier) @chunk.name", "type")
+  ],
+  splitPoints: [...cFamilyControlSplitPoints, "try_statement", "catch_clause"],
+  extraExportQueries: [
+    `(class_specifier name: (type_identifier) @name)`,
+    `(enumerator name: (identifier) @name)`,
+    `(namespace_definition name: (namespace_identifier) @name)`,
+    `(alias_declaration name: (type_identifier) @name)`,
+    `(using_declaration (qualified_identifier name: (identifier) @name))`
+  ],
+  extraLocalQueries: [
+    `(class_specifier name: (type_identifier) @name)`,
+    `(enumerator name: (identifier) @name)`,
+    `(namespace_definition name: (namespace_identifier) @name)`,
+    `(alias_declaration name: (type_identifier) @name)`
+  ],
+  nodeTypes: {
+    identifier: ["identifier", "field_identifier", "type_identifier", "namespace_identifier"],
+    propertyIdentifier: ["field_identifier", "identifier"],
+    memberExpression: "field_expression"
+  },
+  classifyDefinition: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return "variable";
+    if (parent.type === "enum_specifier")
+      return "type";
+    if (parent.type === "class_specifier" || parent.type === "struct_specifier" || parent.type === "namespace_definition")
+      return "class";
+    if (parent.type === "alias_declaration" || parent.type === "type_definition" && isInField(node, parent, "declarator"))
+      return "type";
+    const container = findAncestor(node, cFamilyContainerTypes);
+    if (container?.type === "function_definition")
+      return "function";
+    if (container?.type === "declaration" && isFunctionDeclarator(node))
+      return "function";
+    return "variable";
+  },
+  isDeclarationName: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return false;
+    if ((parent.type === "class_specifier" || parent.type === "struct_specifier" || parent.type === "enum_specifier") && isInField(node, parent, "name"))
+      return true;
+    if (parent.type === "namespace_definition" && isInField(node, parent, "name"))
+      return true;
+    if (parent.type === "alias_declaration" && isInField(node, parent, "name"))
+      return true;
+    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["parameter_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["field_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["init_declarator"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["type_definition"])))
+      return true;
+    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["function_definition"])) && !isInParameterList(node))
+      return true;
+    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["declaration"])) && !isInParameterList(node))
+      return true;
+    if (parent.type === "qualified_identifier" && parent.parent?.type === "using_declaration" && isInField(node, parent, "name"))
+      return true;
+    if (parent.type === "enumerator" && isInField(node, parent, "name"))
+      return true;
+    return false;
+  },
+  createsFunctionScope: (node) => node.type === "function_definition" || node.type === "lambda_expression"
+});
+registerLanguage(CPP_DEF);
+
+// dist/languages/definitions/kotlin.js
+function normalizeKotlinNativeQuery(kind, query) {
+  if (kind === "imports") {
+    return `
+      (import (qualified_identifier) @mod) @stmt
+    `;
+  }
+  if (kind === "importBindings") {
+    return `
+      (import (qualified_identifier) @from (identifier) @alias) @stmt
+      (import (qualified_identifier) @from "*" @wild) @stmt
+      (import (qualified_identifier) @from) @stmt
+    `;
+  }
+  const normalized = query.replace(/\bimport_header\b/g, "import").replace(/\bsimple_identifier\b/g, "identifier").replace(/\btype_identifier\b/g, "identifier");
+  return normalized;
+}
+var KOTLIN_DEF = {
+  id: "kotlin",
+  extensions: [".kt", ".kts"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-kotlin"),
+  usesQueryDrivenLocals: true,
+  structure: {
+    blocks: [
+      {
+        type: "class_declaration",
+        nameQuery: "(type_identifier) @chunk.name",
+        captureId: "class"
+      },
+      {
+        type: "object_declaration",
+        nameQuery: "(type_identifier) @chunk.name",
+        captureId: "object"
+      },
+      {
+        type: "function_declaration",
+        nameQuery: "(simple_identifier) @chunk.name",
+        captureId: "function"
+      },
+      {
+        type: "property_declaration",
+        nameQuery: "(variable_declaration (simple_identifier) @chunk.name)",
+        captureId: "property"
+      },
+      {
+        type: "type_alias",
+        nameQuery: "(type_identifier) @chunk.name",
+        captureId: "type"
+      }
+    ],
+    splitPoints: [
+      "if_expression",
+      "when_expression",
+      "for_statement",
+      "while_statement",
+      "do_while_statement",
+      "try_expression",
+      "catch_block",
+      "finally_block"
+    ],
+    comments: ["line_comment", "block_comment"]
+  },
+  graph: {
+    imports: `
+      (import_header (identifier) @mod) @stmt
+    `,
+    exports: `
+      (class_declaration (type_identifier) @name)
+      (object_declaration (type_identifier) @name)
+      (function_declaration (simple_identifier) @name)
+      (property_declaration (variable_declaration (simple_identifier) @name))
+      (type_alias (type_identifier) @name)
+      (enum_entry (simple_identifier) @name)
+    `,
+    locals: `
+      (class_declaration (type_identifier) @name)
+      (object_declaration (type_identifier) @name)
+      (function_declaration (simple_identifier) @name)
+      (property_declaration (variable_declaration (simple_identifier) @name))
+      (type_alias (type_identifier) @name)
+      (enum_entry (simple_identifier) @name)
+      (parameter (simple_identifier) @name)
+      (class_parameter (simple_identifier) @name)
+      (type_parameter (type_identifier) @name)
+    `,
+    importBindings: `
+      (import_header (identifier) @from (import_alias (type_identifier) @alias)) @stmt
+      (import_header (identifier) @from (wildcard_import) @wild) @stmt
+      (import_header (identifier) @from) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["identifier", "interpolated_identifier", "simple_identifier", "type_identifier"],
+    propertyIdentifier: ["simple_identifier", "type_identifier"],
+    memberExpression: "navigation_expression"
+  },
+  classifyDefinition: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return "variable";
+    if (parent.type === "class_declaration" || parent.type === "object_declaration")
+      return "class";
+    if (parent.type === "function_declaration")
+      return "function";
+    if (parent.type === "type_alias")
+      return "type";
+    return "variable";
+  },
+  isDeclarationName: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return false;
+    if (parent.type === "class_declaration" && node.type === "type_identifier")
+      return true;
+    if (parent.type === "object_declaration" && node.type === "type_identifier")
+      return true;
+    if (parent.type === "function_declaration" && (node.type === "simple_identifier" || node.type === "identifier"))
+      return true;
+    if (parent.type === "type_alias" && node.type === "type_identifier")
+      return true;
+    if (parent.type === "variable_declaration" && node.type === "simple_identifier")
+      return true;
+    if (parent.type === "parameter" && (node.type === "simple_identifier" || node.type === "identifier"))
+      return true;
+    if (parent.type === "class_parameter" && (node.type === "simple_identifier" || node.type === "identifier"))
+      return true;
+    if (parent.type === "enum_entry" && (node.type === "simple_identifier" || node.type === "identifier"))
+      return true;
+    if (parent.type === "type_parameter" && node.type === "type_identifier")
+      return true;
+    return false;
+  },
+  scopeDeclarationNames: "all",
+  createsFunctionScope: (node) => node.type === "function_declaration" || node.type === "anonymous_function" || node.type === "lambda_literal",
+  createsBlockScope: (node) => node.type === "function_body" || node.type === "class_body" || node.type === "control_structure_body" || node.type === "catch_block" || node.type === "finally_block",
+  supportsCrossModuleSymbols: true,
+  native: {
+    normalizeQuery: normalizeKotlinNativeQuery,
+    authoritativeKinds: ["imports", "importBindings", "exports", "locals"],
+    notes: ["normalizes kotlin import and identifier node names for the native grammar"]
+  }
+};
+registerLanguage(KOTLIN_DEF);
+
+// dist/languages/definitions/swift.js
+var SWIFT_DEF = {
+  id: "swift",
+  extensions: [".swift"],
+  grammar: () => loadTreeSitterLanguage("tree-sitter-swift"),
+  usesQueryDrivenLocals: true,
+  structure: {
+    blocks: [
+      {
+        type: "class_declaration",
+        nameQuery: 'declaration_kind: "class" name: (_) @chunk.name',
+        captureId: "class"
+      },
+      {
+        type: "class_declaration",
+        nameQuery: 'declaration_kind: "struct" name: (_) @chunk.name',
+        captureId: "struct"
+      },
+      {
+        type: "class_declaration",
+        nameQuery: 'declaration_kind: "enum" name: (_) @chunk.name',
+        captureId: "enum"
+      },
+      {
+        type: "class_declaration",
+        nameQuery: 'declaration_kind: "extension" name: (user_type (type_identifier) @chunk.name)',
+        captureId: "extension"
+      },
+      {
+        type: "class_declaration",
+        nameQuery: 'declaration_kind: "actor" name: (_) @chunk.name',
+        captureId: "actor"
+      },
+      {
+        type: "protocol_declaration",
+        nameQuery: "name: (type_identifier) @chunk.name",
+        captureId: "protocol"
+      },
+      {
+        type: "function_declaration",
+        nameQuery: "name: (simple_identifier) @chunk.name",
+        captureId: "function"
+      },
+      {
+        type: "property_declaration",
+        nameQuery: "name: (pattern bound_identifier: (simple_identifier) @chunk.name)",
+        captureId: "property"
+      },
+      {
+        type: "typealias_declaration",
+        nameQuery: "name: (type_identifier) @chunk.name",
+        captureId: "type"
+      },
+      {
+        type: "init_declaration",
+        captureId: "initializer"
+      },
+      {
+        type: "deinit_declaration",
+        captureId: "deinitializer"
+      },
+      {
+        type: "subscript_declaration",
+        captureId: "subscript"
+      }
+    ],
+    splitPoints: [
+      "if_statement",
+      "guard_statement",
+      "for_statement",
+      "while_statement",
+      "repeat_while_statement",
+      "switch_statement",
+      "do_statement",
+      "catch_block"
+    ],
+    comments: ["comment", "multiline_comment"]
+  },
+  graph: {
+    imports: `
+      (import_declaration (identifier) @mod) @stmt
+    `,
+    exports: `
+      (class_declaration declaration_kind: "class" name: (_) @name)
+      (class_declaration declaration_kind: "struct" name: (_) @name)
+      (class_declaration declaration_kind: "enum" name: (_) @name)
+      (class_declaration declaration_kind: "extension" name: (user_type (type_identifier) @name))
+      (class_declaration declaration_kind: "actor" name: (_) @name)
+      (enum_entry name: (simple_identifier) @name)
+      (protocol_declaration name: (type_identifier) @name)
+      (function_declaration name: (simple_identifier) @name)
+      (typealias_declaration name: (type_identifier) @name)
+      (property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
+      (protocol_function_declaration name: (simple_identifier) @name)
+      (protocol_property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
+    `,
+    locals: `
+      (class_declaration declaration_kind: "class" name: (_) @name)
+      (class_declaration declaration_kind: "struct" name: (_) @name)
+      (class_declaration declaration_kind: "enum" name: (_) @name)
+      (class_declaration declaration_kind: "extension" name: (user_type (type_identifier) @name))
+      (class_declaration declaration_kind: "actor" name: (_) @name)
+      (enum_entry name: (simple_identifier) @name)
+      (protocol_declaration name: (type_identifier) @name)
+      (function_declaration name: (simple_identifier) @name)
+      (typealias_declaration name: (type_identifier) @name)
+      (property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
+      (parameter name: (simple_identifier) @name)
+      (protocol_function_declaration name: (simple_identifier) @name)
+      (protocol_property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
+    `,
+    importBindings: `
+      (import_declaration (identifier) @from) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["identifier", "simple_identifier", "type_identifier"],
+    propertyIdentifier: ["simple_identifier", "type_identifier"],
+    memberExpression: "navigation_expression"
+  },
+  classifyDefinition: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return "variable";
+    if (parent.type === "function_declaration")
+      return "function";
+    if (parent.type === "protocol_function_declaration")
+      return "function";
+    if (parent.type === "class_declaration") {
+      const declarationKind = parent.childForFieldName("declaration_kind")?.text;
+      if (declarationKind === "enum")
+        return "type";
+      return "class";
+    }
+    if (parent.type === "user_type" && parent.parent?.type === "class_declaration")
+      return "class";
+    if (parent.type === "protocol_declaration" || parent.type === "typealias_declaration")
+      return "type";
+    return "variable";
+  },
+  isDeclarationName: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return false;
+    if (parent.type === "class_declaration" && parent.childForFieldName("name")?.id === node.id)
+      return true;
+    if (parent.type === "user_type" && parent.parent?.type === "class_declaration" && parent.parent.childForFieldName("name")?.id === parent.id)
+      return true;
+    if (parent.type === "protocol_declaration" && parent.childForFieldName("name")?.id === node.id)
+      return true;
+    if (parent.type === "enum_entry" && parent.childForFieldName("name")?.id === node.id)
+      return true;
+    if (parent.type === "function_declaration" && parent.childForFieldName("name")?.id === node.id)
+      return true;
+    if (parent.type === "typealias_declaration" && parent.childForFieldName("name")?.id === node.id)
+      return true;
+    if (parent.type === "parameter" && parent.childForFieldName("name")?.id === node.id)
+      return true;
+    if (parent.type === "protocol_function_declaration" && parent.childForFieldName("name")?.id === node.id)
+      return true;
+    if (parent.type === "protocol_property_declaration" && parent.childForFieldName("name")?.id === node.id)
+      return true;
+    if (parent.type === "pattern" && parent.childForFieldName("bound_identifier")?.id === node.id && (parent.parent?.type === "property_declaration" || parent.parent?.type === "protocol_property_declaration"))
+      return true;
+    return false;
+  },
+  scopeDeclarationNames: "all",
+  createsFunctionScope: (node) => node.type === "function_declaration" || node.type === "init_declaration" || node.type === "deinit_declaration" || node.type === "subscript_declaration",
+  createsBlockScope: (node) => node.type === "function_body" || node.type === "class_body" || node.type === "protocol_body" || node.type === "enum_class_body" || node.type === "catch_block" || node.type === "willset_didset_block",
+  supportsCrossModuleSymbols: true
+};
+registerLanguage(SWIFT_DEF);
+
+// dist/languages/definitions/sql.js
+var SQL_DEF = {
+  id: "sql",
+  extensions: [".sql"],
+  grammar: () => loadTreeSitterLanguage("@derekstride/tree-sitter-sql"),
+  structure: {
+    blocks: [
+      { type: "statement", nameQuery: "(create_table)", captureId: "create" },
+      { type: "statement", nameQuery: "(create_view)", captureId: "create" },
+      { type: "statement", nameQuery: "(create_materialized_view)", captureId: "create" },
+      { type: "statement", nameQuery: "(create_index)", captureId: "create" },
+      { type: "statement", nameQuery: "(create_function)", captureId: "routine" },
+      { type: "statement", nameQuery: "(create_trigger)", captureId: "routine" },
+      { type: "statement", nameQuery: "(alter_table)", captureId: "alter" },
+      { type: "statement", nameQuery: "(drop_table)", captureId: "drop" },
+      { type: "statement", nameQuery: "(drop_view)", captureId: "drop" },
+      { type: "statement", nameQuery: "(drop_index)", captureId: "drop" },
+      { type: "statement", nameQuery: "(insert)", captureId: "write" },
+      { type: "statement", nameQuery: "(update)", captureId: "write" },
+      { type: "statement", nameQuery: "(delete)", captureId: "write" },
+      { type: "statement", nameQuery: "(select)", captureId: "select" }
+    ],
+    splitPoints: [],
+    comments: ["comment"]
+  },
+  graph: {
+    imports: "(statement) @stmt",
+    exports: "",
+    locals: "",
+    importBindings: ""
+  },
+  supportsCrossModuleSymbols: false
+};
+registerLanguage(SQL_DEF);
+
+// dist/languages/definitions/zig.js
+var ZIG_TYPE_INITIALIZER_TYPES = /* @__PURE__ */ new Set([
+  "builtin_type",
+  "struct_declaration",
+  "enum_declaration",
+  "union_declaration",
+  "opaque_declaration",
+  "error_set_declaration"
+]);
+var ZIG_DEF = {
+  id: "zig",
+  extensions: [".zig"],
+  grammar: () => loadTreeSitterLanguage("@tree-sitter-grammars/tree-sitter-zig"),
+  usesQueryDrivenLocals: true,
+  structure: {
+    blocks: [
+      { type: "function_declaration", nameQuery: "name: (identifier) @chunk.name", captureId: "function" },
+      { type: "test_declaration", nameQuery: "(string) @chunk.name", captureId: "test" }
+    ],
+    splitPoints: ["if_expression", "for_expression", "while_expression", "switch_expression"],
+    comments: ["line_comment", "doc_comment"]
+  },
+  graph: {
+    imports: '(builtin_function (builtin_identifier) @fn (arguments (string) @mod) (#eq? @fn "@import")) @stmt',
+    exports: `
+      (function_declaration name: (identifier) @name)
+      (variable_declaration (identifier) @name)
+    `,
+    locals: `
+      (function_declaration name: (identifier) @name)
+      (parameter (identifier) @name)
+      (variable_declaration (identifier) @name)
+    `,
+    importBindings: `
+      (variable_declaration
+        (identifier) @alias
+        (builtin_function (builtin_identifier) @fn (arguments (string) @from) (#eq? @fn "@import"))
+      ) @stmt
+    `
+  },
+  nodeTypes: {
+    identifier: ["identifier"],
+    memberExpression: "field_expression"
+  },
+  supportsCrossModuleSymbols: true,
+  classifyDefinition: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return "variable";
+    if (parent.type === "function_declaration")
+      return "function";
+    if (parent.type !== "variable_declaration")
+      return "variable";
+    const declaredName = parent.namedChildren.find((child) => child.type === "identifier");
+    if (declaredName?.id !== node.id)
+      return "variable";
+    const initializer = parent.namedChildren.find((child) => child.id !== node.id);
+    if (initializer && ZIG_TYPE_INITIALIZER_TYPES.has(initializer.type))
+      return "type";
+    return "variable";
+  },
+  createsFunctionScope: (node) => node.type === "function_declaration",
+  createsBlockScope: (node) => node.type === "block",
+  isDeclarationName: (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return false;
+    if (parent.type === "function_declaration" && parent.childForFieldName("name")?.id === node.id)
+      return true;
+    return parent.type === "variable_declaration";
+  }
+};
+registerLanguage(ZIG_DEF);
+
+// dist/bootstrap/treeSitterLanguages.js
+var idToConfigKey = {
+  js: "javascript",
+  ts: "typescript",
+  tsx: "tsx",
+  python: "python",
+  php: "php",
+  html: "html",
+  css: "css",
+  scss: "scss",
+  less: "less",
+  ruby: "ruby",
+  go: "go",
+  java: "java",
+  csharp: "csharp",
+  rust: "rust",
+  c: "c",
+  cpp: "cpp",
+  kotlin: "kotlin",
+  swift: "swift",
+  zig: "zig"
+};
+var LANG_CONFIGS = {};
+for (const lang of getAllLanguages()) {
+  const key = idToConfigKey[lang.id] || lang.id;
+  if (lang.id === "vue" || lang.id === "svelte" || lang.id === "markdown" || lang.id === "mdx" || lang.id === "astro" || lang.id === "hbs" || lang.id === "rst" || lang.id === "adoc") {
+    continue;
+  }
+  LANG_CONFIGS[key] = makeLanguageConfig(lang, key);
+}
+
+// dist/chunking/chunkBlocks.js
+function collectChunkBlockGroups(language, matches) {
+  const mainBlocks = [];
+  const innerBlocks = [];
+  const comments = [];
+  for (const match of matches) {
+    let nameCapture;
+    let blockCapture;
+    let innerCapture;
+    let blockKind;
+    for (const capture of match.captures) {
+      const { name } = capture;
+      if (name === language.captures.name) {
+        nameCapture = capture;
+      }
+      if (language.captures.comments.includes(name)) {
+        comments.push({
+          kind: name === "chunk.docstring" ? "docstring" : "comment",
+          startByte: capture.startByte,
+          endByte: capture.endByte,
+          startLine: capture.startLine,
+          endLine: capture.endLine
+        });
+      }
+      if (name === language.captures.innerBlock) {
+        innerCapture = capture;
+      }
+      if (name.startsWith(language.captures.blockPrefix) && name !== language.captures.innerBlock) {
+        blockCapture = capture;
+        blockKind = name.slice(language.captures.blockPrefix.length) || capture.nodeType;
+      }
+    }
+    if (innerCapture) {
+      innerBlocks.push({
+        kind: "inner",
+        startByte: innerCapture.startByte,
+        endByte: innerCapture.endByte,
+        startLine: innerCapture.startLine,
+        endLine: innerCapture.endLine
+      });
+    }
+    if (blockCapture) {
+      const candidate = {
+        kind: blockKind ?? "block",
+        startByte: blockCapture.startByte,
+        endByte: blockCapture.endByte,
+        startLine: blockCapture.startLine,
+        endLine: blockCapture.endLine
+      };
+      if (nameCapture) {
+        candidate.name = nameCapture.text;
+      }
+      mainBlocks.push(candidate);
+    }
+  }
+  mainBlocks.sort((a, b) => a.startByte - b.startByte || a.endByte - b.endByte);
+  innerBlocks.sort((a, b) => a.startByte - b.startByte || a.endByte - b.endByte);
+  comments.sort((a, b) => a.startByte - b.startByte || a.endByte - b.endByte);
+  return { mainBlocks, innerBlocks, comments };
+}
+
+// dist/chunking/chunkMatches.js
+import { Buffer as Buffer2 } from "node:buffer";
+
+// dist/languages.js
+import fs from "node:fs";
+import path from "node:path";
+function adaptDefinition(def) {
+  return {
+    id: def.id,
+    matchExts: def.extensions,
+    language: (filename) => def.grammar(filename),
+    nodeTypes: def.nodeTypes || { identifier: ["identifier"] },
+    queries: def.graph,
+    classifyDefinition: def.classifyDefinition || (() => "variable"),
+    isDeclarationName: def.isDeclarationName || (() => false),
+    scopeDeclarationNames: def.scopeDeclarationNames === "all" ? () => true : def.scopeDeclarationNames ?? (() => false),
+    createsBlockScope: def.createsBlockScope || (() => false),
+    createsFunctionScope: def.createsFunctionScope || (() => false),
+    membersAreImplicitlyInScope: def.membersAreImplicitlyInScope ?? true,
+    supportsCrossModuleSymbols: def.supportsCrossModuleSymbols || false,
+    isTypeOnly: def.isTypeOnly || (() => false),
+    usesQueryDrivenLocals: def.usesQueryDrivenLocals || false,
+    normalizeIdentifier: def.normalizeIdentifier || ((name) => name),
+    ...def.native ? { native: def.native } : {}
+  };
+}
+var TS_SUPPORT = adaptDefinition(getLanguageById("ts"));
+var TSX_SUPPORT = adaptDefinition(getLanguageById("tsx"));
+var JS_SUPPORT = adaptDefinition(getLanguageById("js"));
+var PY_SUPPORT = adaptDefinition(getLanguageById("python"));
+var PHP_SUPPORT = adaptDefinition(getLanguageById("php"));
+var HTML_SUPPORT = adaptDefinition(getLanguageById("html"));
+var CSS_SUPPORT = adaptDefinition(getLanguageById("css"));
+var SCSS_SUPPORT = adaptDefinition(getLanguageById("scss"));
+var LESS_SUPPORT = adaptDefinition(getLanguageById("less"));
+var VUE_SUPPORT = adaptDefinition(getLanguageById("vue"));
+var SVELTE_SUPPORT = adaptDefinition(getLanguageById("svelte"));
+var RUBY_SUPPORT = adaptDefinition(getLanguageById("ruby"));
+var GO_SUPPORT = adaptDefinition(getLanguageById("go"));
+var JAVA_SUPPORT = adaptDefinition(getLanguageById("java"));
+var CSHARP_SUPPORT = adaptDefinition(getLanguageById("csharp"));
+var RUST_SUPPORT = adaptDefinition(getLanguageById("rust"));
+var C_SUPPORT = adaptDefinition(getLanguageById("c"));
+var CPP_SUPPORT = adaptDefinition(getLanguageById("cpp"));
+var KOTLIN_SUPPORT = adaptDefinition(getLanguageById("kotlin"));
+var SWIFT_SUPPORT = adaptDefinition(getLanguageById("swift"));
+var ZIG_SUPPORT = adaptDefinition(getLanguageById("zig"));
+var SQL_SUPPORT = adaptDefinition(getLanguageById("sql"));
+var LANGUAGE_SUPPORTS = getAllLanguages().map(adaptDefinition);
+var LANGUAGE_EXTENSION_KEY_PATTERN = /^\.[a-z0-9][a-z0-9._+-]*$/;
+var NON_REMAPPABLE_EXTENSIONS = /* @__PURE__ */ new Set([".vue", ".svelte"]);
+function isLiteralLanguageExtension(extension) {
+  return LANGUAGE_EXTENSION_KEY_PATTERN.test(extension.trim().toLowerCase());
+}
+function isRemappableLanguageExtension(extension) {
+  return !NON_REMAPPABLE_EXTENSIONS.has(extension.trim().toLowerCase());
+}
+function normalizeLanguageExtensions(extensions) {
+  const entries = Object.entries(extensions ?? {}).map(([extension, languageId]) => [extension.trim().toLowerCase(), languageId.trim().toLowerCase()]).filter(([extension, languageId]) => isLiteralLanguageExtension(extension) && isRemappableLanguageExtension(extension) && !!supportById(languageId)).sort((left, right) => left[0].localeCompare(right[0]));
+  if (!entries.length)
+    return void 0;
+  return Object.fromEntries(entries);
+}
+function mappedSupportForFile(filename, extensionMap) {
+  const mappings = Object.entries(normalizeLanguageExtensions(extensionMap) ?? {}).sort((left, right) => right[0].length - left[0].length || left[0].localeCompare(right[0]));
+  const lowerFilename = filename.toLowerCase();
+  for (const [extension, languageId] of mappings) {
+    if (!lowerFilename.endsWith(extension))
+      continue;
+    return supportById(languageId);
+  }
+  return void 0;
+}
+function supportForFile(filename, extensionMap) {
+  const mapped = extensionMap ? mappedSupportForFile(filename, extensionMap) : void 0;
+  if (mapped)
+    return mapped;
+  const ext = path.extname(filename).toLowerCase();
+  if (ext === ".h") {
+    const sample = readFileSample(filename);
+    if (sample && isLikelyCppHeader(sample))
+      return CPP_SUPPORT;
+    return C_SUPPORT;
+  }
+  return LANGUAGE_SUPPORTS.find((s) => s.matchExts.includes(ext));
+}
+function supportById(id) {
+  return LANGUAGE_SUPPORTS.find((s) => s.id === id);
+}
+var HEADER_SAMPLE_SIZE = 8e3;
+var CPP_HEADER_HINT = /\b(class|namespace|template|typename|constexpr|operator|using\s+namespace)\b|::/;
+function readFileSample(filePath) {
+  try {
+    const contents = fs.readFileSync(filePath, "utf8");
+    return contents.slice(0, HEADER_SAMPLE_SIZE);
+  } catch {
+    return null;
+  }
+}
+function isLikelyCppHeader(sample) {
+  return CPP_HEADER_HINT.test(sample);
+}
+
+// dist/native/runtime.js
+import path5 from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+// dist/util/ast.js
+function stringifyUnknown(value) {
+  if (value instanceof Error)
+    return value.message;
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return "[Object]";
+    }
+  }
+  if (typeof value === "symbol")
+    return value.toString();
+  if (typeof value === "function") {
+    return `[Function: ${value.name || "anonymous"}]`;
+  }
+  return "unknown";
+}
+
+// dist/native/bindingLoader.js
+import fs3 from "node:fs";
+import path4 from "node:path";
+
+// dist/util/paths.js
+import fsp from "node:fs/promises";
+import path2 from "node:path";
+
+// dist/util/errors.js
+function errorMessage(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+
+// dist/util/paths.js
+function normalizePath(p) {
+  return typeof p === "string" ? p.replace(/\\/g, "/") : "";
+}
+function normalizeWindowsComparablePath(filePath) {
+  return normalizePath(filePath).replace(/^([A-Za-z]):/, (_, driveLetter) => `${driveLetter.toUpperCase()}:`);
+}
+var defaultCaseInsensitiveFileIdentity = process.platform === "win32" || process.platform === "darwin";
+function isWindowsQualifiedAbsolutePath(filePath) {
+  const normalizedPath = normalizePath(filePath);
+  return /^[A-Za-z]:\//.test(normalizedPath) || normalizedPath.startsWith("//");
+}
+function isPosixQualifiedAbsolutePath(filePath) {
+  const normalizedPath = normalizePath(filePath);
+  return path2.posix.isAbsolute(normalizedPath) && !isWindowsQualifiedAbsolutePath(normalizedPath);
+}
+function isAbsoluteFilePath(filePath) {
+  return path2.posix.isAbsolute(filePath) || path2.win32.isAbsolute(filePath);
+}
+function resolveFilePathFromRoot(projectRoot, filePath) {
+  if (isAbsoluteFilePath(filePath)) {
+    return filePath;
+  }
+  if (isWindowsQualifiedAbsolutePath(projectRoot)) {
+    return path2.win32.resolve(projectRoot, filePath);
+  }
+  if (isPosixQualifiedAbsolutePath(projectRoot)) {
+    return path2.posix.resolve(normalizePath(projectRoot), normalizePath(filePath));
+  }
+  return path2.resolve(projectRoot, filePath);
+}
+function resolveComparableProjectRoot(projectRoot) {
+  if (isAbsoluteFilePath(projectRoot)) {
+    return projectRoot;
+  }
+  return path2.resolve(projectRoot);
+}
+function isRelativeToRoot(normalizedRoot, normalizedFile) {
+  const rootIsWindowsPath = isWindowsQualifiedAbsolutePath(normalizedRoot);
+  const fileIsWindowsPath = isWindowsQualifiedAbsolutePath(normalizedFile);
+  const rootIsPosixPath = isPosixQualifiedAbsolutePath(normalizedRoot);
+  const fileIsPosixPath = isPosixQualifiedAbsolutePath(normalizedFile);
+  const comparableRoot = rootIsWindowsPath ? normalizeWindowsComparablePath(normalizedRoot) : normalizedRoot;
+  const comparableFile = fileIsWindowsPath ? normalizeWindowsComparablePath(normalizedFile) : normalizedFile;
+  if (rootIsWindowsPath && fileIsWindowsPath) {
+    if (comparableFile === comparableRoot) {
+      return true;
+    }
+    const relativePath2 = normalizePath(path2.win32.relative(comparableRoot, comparableFile));
+    return !!relativePath2.length && !relativePath2.startsWith("..") && !path2.win32.isAbsolute(relativePath2);
+  }
+  if (rootIsWindowsPath || fileIsWindowsPath) {
+    return false;
+  }
+  if (rootIsPosixPath && fileIsPosixPath) {
+    if (comparableFile === comparableRoot) {
+      return true;
+    }
+    const relativePath2 = path2.posix.relative(comparableRoot, comparableFile);
+    return !!relativePath2.length && !relativePath2.startsWith("..") && !path2.posix.isAbsolute(relativePath2);
+  }
+  if (rootIsPosixPath || fileIsPosixPath) {
+    return false;
+  }
+  if (comparableFile === comparableRoot) {
+    return true;
+  }
+  const relativePath = path2.relative(comparableRoot, comparableFile);
+  return !!relativePath.length && !relativePath.startsWith("..") && !path2.isAbsolute(relativePath);
+}
+function isFilePathWithinRoot(projectRoot, filePath) {
+  const normalizedRoot = normalizePath(resolveComparableProjectRoot(projectRoot));
+  const normalizedFile = normalizePath(resolveFilePathFromRoot(normalizedRoot, filePath));
+  return isRelativeToRoot(normalizedRoot, normalizedFile);
+}
+function assertFilePathWithinRoot(projectRoot, filePath, label = "File") {
+  const normalizedRoot = normalizePath(resolveComparableProjectRoot(projectRoot));
+  const normalizedFile = normalizePath(resolveFilePathFromRoot(normalizedRoot, filePath));
+  if (!isFilePathWithinRoot(normalizedRoot, normalizedFile)) {
+    throw new Error(`${label} is outside project root: ${normalizedFile} (root: ${normalizedRoot})`);
+  }
+  return normalizedFile;
+}
+
+// dist/native/runtimeCache.js
+import { createHash, randomBytes } from "node:crypto";
+import fs2 from "node:fs";
+import path3 from "node:path";
+var CACHE_SCHEMA_VERSION = 1;
+var HASH_BUFFER_SIZE = 1024 * 1024;
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function isWithinDirectory(filePath, directoryPath) {
+  const relative = path3.relative(directoryPath, filePath);
+  return !relative || !relative.startsWith("..") && !path3.isAbsolute(relative);
+}
+function assertSafeCacheSegment(value, label) {
+  if (!value || value === "." || value === ".." || path3.basename(value) !== value) {
+    throw new Error(`invalid native cache ${label}: ${value}`);
+  }
+  if (!/^[A-Za-z0-9._+-]+$/.test(value)) {
+    throw new Error(`invalid native cache ${label}: ${value}`);
+  }
+}
+function assertSafePathComponent(componentPath) {
+  const stats = fs2.lstatSync(componentPath);
+  if (!stats.isDirectory() || stats.isSymbolicLink()) {
+    throw new Error(`unsafe native cache path component: ${componentPath}`);
+  }
+}
+function prepareSafeDirectory(directoryPath) {
+  const absolute = path3.resolve(directoryPath);
+  const parsed = path3.parse(absolute);
+  let current = parsed.root;
+  assertSafePathComponent(current);
+  const relativeParts = absolute.slice(parsed.root.length).split(path3.sep).filter(Boolean);
+  for (const part of relativeParts) {
+    current = path3.join(current, part);
+    try {
+      assertSafePathComponent(current);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+      try {
+        fs2.mkdirSync(current);
+      } catch (mkdirError) {
+        if (mkdirError.code !== "EEXIST")
+          throw mkdirError;
+      }
+      assertSafePathComponent(current);
+    }
+  }
+  return fs2.realpathSync.native(absolute);
+}
+function resolveProductionCacheRoot() {
+  const localAppData = process.env.LOCALAPPDATA;
+  if (!localAppData) {
+    throw new Error("LOCALAPPDATA is unavailable; cannot prepare the Windows native runtime cache");
+  }
+  return path3.join(localAppData, "codegraph", "native-cache", `v${CACHE_SCHEMA_VERSION}`);
+}
+function hashFileStreaming(filePath, onChunk) {
+  const before = fs2.statSync(filePath);
+  if (!before.isFile() || before.size <= 0) {
+    throw new Error(`native binary is not a non-empty regular file: ${filePath}`);
+  }
+  const hash = createHash("sha256");
+  const buffer = Buffer.allocUnsafe(HASH_BUFFER_SIZE);
+  const descriptor = fs2.openSync(filePath, "r");
+  let size = 0;
+  try {
+    while (true) {
+      const bytesRead = fs2.readSync(descriptor, buffer, 0, buffer.length, null);
+      if (!bytesRead)
+        break;
+      hash.update(buffer.subarray(0, bytesRead));
+      size += bytesRead;
+      onChunk?.(bytesRead);
+    }
+  } finally {
+    fs2.closeSync(descriptor);
+  }
+  if (size !== before.size) {
+    throw new Error(`native binary changed while hashing: ${filePath}`);
+  }
+  return { sha256: hash.digest("hex"), size };
+}
+function randomSuffix() {
+  return `${process.pid}.${randomBytes(8).toString("hex")}`;
+}
+function copyFileExclusive(sourcePath, destinationPath) {
+  const source = fs2.openSync(sourcePath, "r");
+  let destination;
+  const buffer = Buffer.allocUnsafe(HASH_BUFFER_SIZE);
+  try {
+    destination = fs2.openSync(destinationPath, "wx");
+    while (true) {
+      const bytesRead = fs2.readSync(source, buffer, 0, buffer.length, null);
+      if (!bytesRead)
+        break;
+      let written = 0;
+      while (written < bytesRead) {
+        written += fs2.writeSync(destination, buffer, written, bytesRead - written);
+      }
+    }
+    fs2.fsyncSync(destination);
+  } finally {
+    if (destination !== void 0)
+      fs2.closeSync(destination);
+    fs2.closeSync(source);
+  }
+}
+function removeRegularTemporaryFile(filePath) {
+  try {
+    const stats = fs2.lstatSync(filePath);
+    if (stats.isFile() && !stats.isSymbolicLink())
+      fs2.unlinkSync(filePath);
+  } catch {
+  }
+}
+function verifyFile(filePath, expected) {
+  try {
+    const actual = hashFileStreaming(filePath);
+    return actual.size === expected.size && actual.sha256 === expected.sha256;
+  } catch {
+    return false;
+  }
+}
+function publishExclusive(temporaryPath, finalPath) {
+  try {
+    fs2.linkSync(temporaryPath, finalPath);
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST")
+      return false;
+    throw error;
+  } finally {
+    removeRegularTemporaryFile(temporaryPath);
+  }
+}
+function populateBinary(sourcePath, finalPath, expected) {
+  const temporaryPath = `${finalPath}.${randomSuffix()}.tmp`;
+  try {
+    copyFileExclusive(sourcePath, temporaryPath);
+    if (!verifyFile(temporaryPath, expected)) {
+      throw new Error("native cache temporary file failed integrity verification");
+    }
+    return publishExclusive(temporaryPath, finalPath);
+  } catch (error) {
+    removeRegularTemporaryFile(temporaryPath);
+    throw error;
+  }
+}
+function recoverCorruptFinal(finalPath) {
+  const recoveryPath = `${finalPath}.corrupt.${randomSuffix()}`;
+  fs2.renameSync(finalPath, recoveryPath);
+}
+function writeManifest(entryPath, manifest) {
+  const finalPath = path3.join(entryPath, "manifest.json");
+  if (fs2.existsSync(finalPath))
+    return;
+  const temporaryPath = `${finalPath}.${randomSuffix()}.tmp`;
+  try {
+    const descriptor = fs2.openSync(temporaryPath, "wx");
+    try {
+      fs2.writeFileSync(descriptor, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+      fs2.fsyncSync(descriptor);
+    } finally {
+      fs2.closeSync(descriptor);
+    }
+    publishExclusive(temporaryPath, finalPath);
+  } catch (error) {
+    removeRegularTemporaryFile(temporaryPath);
+    throw error;
+  }
+}
+function prepareNativeRuntimeCache(request) {
+  const sourcePath = path3.resolve(request.sourcePath);
+  try {
+    assertSafeCacheSegment(request.target, "target");
+    assertSafeCacheSegment(request.packageVersion, "package version");
+    const sourceRealPath = fs2.realpathSync.native(sourcePath);
+    const source = hashFileStreaming(sourceRealPath);
+    const cacheRoot = prepareSafeDirectory(request.cacheRoot ?? resolveProductionCacheRoot());
+    const targetPath = prepareSafeDirectory(path3.join(cacheRoot, request.target));
+    if (!isWithinDirectory(targetPath, cacheRoot)) {
+      throw new Error("native cache target escaped the cache root");
+    }
+    const cacheKey = `${request.packageName}@${request.packageVersion}:${request.target}:${source.sha256}`;
+    const entryPath = prepareSafeDirectory(path3.join(targetPath, `${request.packageVersion}-${source.sha256}`));
+    if (!isWithinDirectory(entryPath, cacheRoot)) {
+      throw new Error("native cache entry escaped the cache root");
+    }
+    const sourceFileName = path3.basename(sourceRealPath);
+    const finalPath = path3.join(entryPath, sourceFileName);
+    let status = "reused";
+    const finalExists = fs2.existsSync(finalPath);
+    if (!finalExists || !verifyFile(finalPath, source)) {
+      if (finalExists)
+        recoverCorruptFinal(finalPath);
+      status = populateBinary(sourceRealPath, finalPath, source) ? "cached" : "reused";
+      if (!verifyFile(finalPath, source)) {
+        throw new Error("native cache winner failed integrity verification");
+      }
+    }
+    writeManifest(entryPath, {
+      schemaVersion: CACHE_SCHEMA_VERSION,
+      packageName: request.packageName,
+      packageVersion: request.packageVersion,
+      target: request.target,
+      sourceFileName,
+      sourceSize: source.size,
+      sourceSha256: source.sha256,
+      cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      status,
+      sourcePath: sourceRealPath,
+      loadedPath: finalPath,
+      cacheKey,
+      sha256: source.sha256
+    };
+  } catch (error) {
+    return { status: "unavailable", sourcePath, error: asError(error) };
+  }
+}
+
+// dist/native/bindingLoader.js
+function isMuslRuntime() {
+  if (process.platform !== "linux")
+    return false;
+  const report = process.report?.getReport();
+  const header = report && typeof report === "object" && "header" in report ? report.header : null;
+  const glibcVersionRuntime = header && typeof header === "object" && "glibcVersionRuntime" in header ? header.glibcVersionRuntime : null;
+  if (typeof glibcVersionRuntime === "string" && glibcVersionRuntime)
+    return false;
+  return true;
+}
+function nativeTargetSuffixFor(platform, arch) {
+  if (platform === "win32") {
+    if (arch === "x64")
+      return "win32-x64-msvc";
+    if (arch === "arm64")
+      return "win32-arm64-msvc";
+  }
+  if (platform === "darwin") {
+    if (arch === "x64")
+      return "darwin-x64";
+    if (arch === "arm64")
+      return "darwin-arm64";
+  }
+  if (platform === "linux") {
+    const abi = isMuslRuntime() ? "musl" : "gnu";
+    if (arch === "x64")
+      return `linux-x64-${abi}`;
+    if (arch === "arm64")
+      return `linux-arm64-${abi}`;
+  }
+  return null;
+}
+function currentNativeTargetSuffix() {
+  return nativeTargetSuffixFor(process.platform, process.arch);
+}
+function normalizePathForComparison(filePath) {
+  const resolved = path4.resolve(filePath);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function isWithinDirectory2(filePath, directoryPath) {
+  const normalizedFile = normalizePathForComparison(filePath);
+  const normalizedDir = normalizePathForComparison(directoryPath);
+  return normalizedFile === normalizedDir || normalizedFile.startsWith(`${normalizedDir}${path4.sep}`);
+}
+function findLocalNativeBinary(packageRoot) {
+  const suffix = currentNativeTargetSuffix();
+  if (!suffix) {
+    return null;
+  }
+  const expectedName = `index.${suffix}.node`;
+  try {
+    const entries = fs3.readdirSync(packageRoot, { withFileTypes: true });
+    const binary = entries.find((entry) => entry.isFile() && entry.name === expectedName);
+    return binary ? path4.join(packageRoot, binary.name) : null;
+  } catch {
+    return null;
+  }
+}
+function readPlatformPackage(packageName, target, resolveFn) {
+  const platformPackageName = `${packageName}-${target}`;
+  const resolvedEntry = resolveFn(platformPackageName);
+  const expectedFileName = `index.${target}.node`;
+  if (path4.basename(resolvedEntry) !== expectedFileName) {
+    throw new Error(`unexpected native platform entry for ${platformPackageName}: ${resolvedEntry}`);
+  }
+  const sourcePath = fs3.realpathSync.native(resolvedEntry);
+  const stats = fs3.statSync(sourcePath);
+  if (!stats.isFile() || stats.size <= 0) {
+    throw new Error(`native platform entry is not a non-empty regular file: ${sourcePath}`);
+  }
+  const packageJsonPath = path4.join(path4.dirname(sourcePath), "package.json");
+  const parsed = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+  if (parsed.name !== platformPackageName || !parsed.version) {
+    throw new Error(`invalid native platform package metadata: ${packageJsonPath}`);
+  }
+  return { sourcePath, packageVersion: parsed.version };
+}
+function loadNativeBinding(options) {
+  const localBinary = findLocalNativeBinary(options.localPackageRoot);
+  const localTarget = currentNativeTargetSuffix();
+  let lastError;
+  if (localBinary) {
+    try {
+      return {
+        binding: options.requireFn(localBinary),
+        origin: {
+          mode: "workspace",
+          packageName: options.packageName,
+          ...localTarget ? { target: localTarget } : {},
+          sourcePath: normalizePath(localBinary),
+          loadedPath: normalizePath(localBinary)
+        }
+      };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  const packageEntry = (() => {
+    if (!options.resolveFn)
+      return null;
+    try {
+      return options.resolveFn(options.packageName);
+    } catch {
+      return null;
+    }
+  })();
+  if (packageEntry && isWithinDirectory2(packageEntry, options.localPackageRoot)) {
+    return {
+      binding: null,
+      error: lastError ?? new Error("local workspace native addon is not built; run `npm run build:native`"),
+      origin: {
+        mode: "workspace",
+        packageName: options.packageName,
+        ...localTarget ? { target: localTarget } : {}
+      }
+    };
+  }
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const target = nativeTargetSuffixFor(platform, arch);
+  let installedSourcePath;
+  let installedPackageVersion;
+  let cacheError;
+  if (target && options.resolveFn) {
+    try {
+      const platformPackage = readPlatformPackage(options.packageName, target, options.resolveFn);
+      installedSourcePath = platformPackage.sourcePath;
+      installedPackageVersion = platformPackage.packageVersion;
+    } catch (error) {
+      if (platform === "win32") {
+        cacheError = errorMessage(error);
+      }
+    }
+  }
+  if (platform === "win32" && target && installedSourcePath && installedPackageVersion) {
+    const cached = prepareNativeRuntimeCache({
+      sourcePath: installedSourcePath,
+      packageName: `${options.packageName}-${target}`,
+      packageVersion: installedPackageVersion,
+      target,
+      cacheRoot: options.cacheRoot
+    });
+    if (cached.status === "unavailable") {
+      cacheError = cached.error.message;
+    } else {
+      try {
+        return {
+          binding: options.requireFn(cached.loadedPath),
+          origin: {
+            mode: "cache",
+            packageName: `${options.packageName}-${target}`,
+            packageVersion: installedPackageVersion,
+            target,
+            sourcePath: normalizePath(cached.sourcePath),
+            loadedPath: normalizePath(cached.loadedPath),
+            cacheKey: cached.cacheKey,
+            sha256: cached.sha256
+          }
+        };
+      } catch (error) {
+        cacheError = `cached native addon failed to load: ${errorMessage(error)}`;
+        lastError = error;
+      }
+    }
+  }
+  let originPackageName = options.packageName;
+  let originLoadedPath = packageEntry;
+  if (target && installedSourcePath && installedPackageVersion) {
+    originPackageName = `${options.packageName}-${target}`;
+    originLoadedPath = installedSourcePath;
+  }
+  const packageOrigin = {
+    mode: "package",
+    packageName: originPackageName,
+    ...installedPackageVersion ? { packageVersion: installedPackageVersion } : {},
+    ...target ? { target } : {},
+    ...installedSourcePath ? { sourcePath: normalizePath(installedSourcePath) } : {},
+    ...originLoadedPath ? { loadedPath: normalizePath(originLoadedPath) } : {},
+    ...cacheError ? { cacheError } : {}
+  };
+  try {
+    return {
+      binding: options.requireFn(options.packageName),
+      origin: packageOrigin
+    };
+  } catch (error) {
+    return {
+      binding: null,
+      error: error ?? lastError,
+      origin: packageOrigin
+    };
+  }
+}
+
+// dist/native/runtime.js
+var require2 = createRequire(import.meta.url);
+var localNativePackageRoot = path5.resolve(path5.dirname(fileURLToPath(import.meta.url)), "../../packages/codegraph-native");
+var NATIVE_REQUIRED_ERROR_PREFIX = "native tree-sitter required by explicit option but unavailable";
+var bindingState;
+function isNativeTreeSitterDisabledByEnv(env = process.env) {
+  const rawValue = env.CODEGRAPH_DISABLE_NATIVE;
+  if (typeof rawValue !== "string") {
+    return false;
+  }
+  const normalized = rawValue.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+function normalizeNativeRuntimeMode(mode) {
+  return mode ?? "auto";
+}
+function loadBinding() {
+  if (bindingState)
+    return bindingState;
+  const loaded = loadNativeBinding({
+    packageName: "@lzehrung/codegraph-native",
+    localPackageRoot: localNativePackageRoot,
+    requireFn: require2,
+    resolveFn: require2.resolve
+  });
+  if (loaded.binding) {
+    bindingState = {
+      loaded: true,
+      binding: loaded.binding,
+      supportedLanguageIds: new Set(loaded.binding.supportedLanguageIds()),
+      origin: loaded.origin
+    };
+    return bindingState;
+  }
+  bindingState = {
+    loaded: false,
+    error: loaded.error,
+    ...loaded.origin ? { origin: loaded.origin } : {}
+  };
+  return bindingState;
+}
+function resolveNativeBindingState(mode, env = process.env) {
+  const normalizedMode = normalizeNativeRuntimeMode(mode);
+  if (normalizedMode === "off") {
+    return {
+      loaded: false,
+      error: new Error("native tree-sitter disabled by explicit option")
+    };
+  }
+  if (normalizedMode === "auto" && isNativeTreeSitterDisabledByEnv(env)) {
+    return {
+      loaded: false,
+      error: new Error("native tree-sitter disabled by CODEGRAPH_DISABLE_NATIVE")
+    };
+  }
+  return loadBinding();
+}
+function throwIfNativeRequiredUnavailable(mode, state) {
+  if (normalizeNativeRuntimeMode(mode) !== "on" || state.loaded)
+    return;
+  const suffix = state.error ? `: ${stringifyUnknown(state.error)}` : "";
+  throw new Error(`${NATIVE_REQUIRED_ERROR_PREFIX}${suffix}`);
+}
+
+// dist/native/queries.js
+function normalizeNativeQueryForSupport(support, kind, queryText) {
+  return support.native?.normalizeQuery?.(kind, queryText) ?? queryText;
+}
+
+// dist/native/execution.js
+function getNativeSingleQueryExecution(source, support, queryText, mode) {
+  const state = resolveNativeBindingState(mode);
+  throwIfNativeRequiredUnavailable(mode, state);
+  if (!state.loaded) {
+    return unavailableSingleQueryExecution(state);
+  }
+  if (!state.supportedLanguageIds.has(support.id)) {
+    return { matches: null, fallbackReason: "unsupportedLanguage" };
+  }
+  if (!state.binding.runQuery) {
+    return {
+      matches: null,
+      fallbackReason: "unavailable",
+      error: "native binding does not expose runQuery"
+    };
+  }
+  const normalizedQuery = normalizeNativeQueryForSupport(support, "adHoc", queryText);
+  try {
+    return {
+      matches: state.binding.runQuery(source, support.id, normalizedQuery).matches
+    };
+  } catch (error) {
+    return {
+      matches: null,
+      fallbackReason: "queryFailure",
+      error: errorMessage(error)
+    };
+  }
+}
+function unavailableSingleQueryExecution(state) {
+  return {
+    matches: null,
+    ...unavailableNativeFailure(state)
+  };
+}
+function unavailableNativeFailure(state) {
+  if (!state.error) {
+    return { fallbackReason: "unavailable" };
+  }
+  if (state.error instanceof Error) {
+    return { fallbackReason: "unavailable", error: state.error.message };
+  }
+  return { fallbackReason: "unavailable", error: stringifyUnknown(state.error) };
+}
+
+// dist/chunking/chunkMatches.js
+function getChunkMatches(language, source, _filePath) {
+  const support = supportById(language.supportId);
+  if (support) {
+    const nativeExecution = getNativeSingleQueryExecution(source, support, language.queryText);
+    if (nativeExecution.matches) {
+      const toStringIndex = createUtf8ByteToStringIndex(source);
+      return nativeExecution.matches.map((match) => toChunkMatchFromNative(match, toStringIndex));
+    }
+  }
+  return [];
+}
+function toChunkMatchFromNative(match, toStringIndex) {
+  return {
+    captures: match.captures.map((capture) => ({
+      name: capture.name,
+      text: capture.text,
+      startByte: toStringIndex(capture.start.index),
+      endByte: toStringIndex(capture.end.index),
+      startLine: capture.start.row + 1,
+      endLine: capture.end.row + 1,
+      nodeType: capture.nodeType
+    }))
+  };
+}
+function createUtf8ByteToStringIndex(source) {
+  const utf8Length = Buffer2.byteLength(source, "utf8");
+  if (utf8Length === source.length) {
+    return (byteOffset2) => Math.max(0, Math.min(byteOffset2, source.length));
+  }
+  const byteToStringIndex = new Uint32Array(utf8Length + 1);
+  let byteOffset = 0;
+  let stringIndex = 0;
+  while (stringIndex < source.length) {
+    const codePoint = source.codePointAt(stringIndex);
+    if (codePoint === void 0)
+      break;
+    const charStringLength = codePoint > 65535 ? 2 : 1;
+    const charByteLength = utf8ByteLengthForCodePoint(codePoint);
+    for (let offset = 1; offset < charByteLength; offset += 1) {
+      byteToStringIndex[byteOffset + offset] = stringIndex;
+    }
+    byteOffset += charByteLength;
+    stringIndex += charStringLength;
+    byteToStringIndex[byteOffset] = stringIndex;
+  }
+  byteToStringIndex[byteOffset] = source.length;
+  return (index) => {
+    const bounded = Math.max(0, Math.min(index, byteToStringIndex.length - 1));
+    return byteToStringIndex[bounded] ?? source.length;
+  };
+}
+function utf8ByteLengthForCodePoint(codePoint) {
+  if (codePoint <= 127)
+    return 1;
+  if (codePoint <= 2047)
+    return 2;
+  if (codePoint <= 65535)
+    return 3;
+  return 4;
+}
+
+// dist/chunking/chunkId.js
+import { createHash as createHash2 } from "node:crypto";
+function withStableChunkIds(chunks, languageId, filePath) {
+  const occurrences = /* @__PURE__ */ new Map();
+  const scopedPath = filePath ?? "unknown";
+  return chunks.map((chunk) => {
+    const digest = createHash2("sha256").update("codegraph-chunk-id-v1\0").update(languageId).update("\0").update(scopedPath).update("\0").update(chunk.type).update("\0").update(chunk.name ?? "").update("\0").update(chunk.text).digest("hex");
+    const occurrence = occurrences.get(digest) ?? 0;
+    occurrences.set(digest, occurrence + 1);
+    const id = occurrence === 0 ? `${languageId}:${scopedPath}:${digest}` : `${languageId}:${scopedPath}:${digest}:${occurrence}`;
+    return { ...chunk, id };
+  });
+}
+
+// dist/chunking/chunkSplit.js
+function splitLargeBlockSimple(block, source, tokenizer, maxTokens, out, languageId, filePath) {
+  let currentStart = -1;
+  let currentEnd = -1;
+  let currentStartLine = block.startLine;
+  let currentTokens = 0;
+  const flush = () => {
+    if (currentStart === -1)
+      return;
+    emitRangeWithinBudget(block, source, currentStart, currentEnd, currentStartLine, tokenizer, maxTokens, out, languageId, filePath);
+    currentStart = -1;
+    currentEnd = -1;
+    currentTokens = 0;
+  };
+  for (const line of lineRanges(source, block.startByte, block.endByte, block.startLine)) {
+    const lineText = source.slice(line.start, line.end);
+    const lineTokens = tokenizer(lineText);
+    if (lineTokens > maxTokens) {
+      flush();
+      emitRangeWithinBudget(block, source, line.start, line.end, line.startLine, tokenizer, maxTokens, out, languageId, filePath);
+      continue;
+    }
+    if (currentStart !== -1 && currentTokens + lineTokens > maxTokens) {
+      flush();
+    }
+    if (currentStart === -1) {
+      currentStart = line.start;
+      currentStartLine = line.startLine;
+    }
+    currentEnd = line.end;
+    currentTokens += lineTokens;
+  }
+  flush();
+}
+function splitLargeBlockUsingInnerBlocks(block, _innerBlocks, source, tokenizer, maxTokens, out, languageId, _newlineOffsets, filePath) {
+  splitLargeBlockSimple(block, source, tokenizer, maxTokens, out, languageId, filePath);
+}
+function splitTextWithinTokenBudget(text, tokenizer, maxTokens) {
+  if (!text.length)
+    return [];
+  if (tokenizer(text) <= maxTokens)
+    return [text];
+  const segments = [];
+  let start = 0;
+  while (start < text.length) {
+    if (tokenizer(text.slice(start)) <= maxTokens) {
+      segments.push(text.slice(start));
+      break;
+    }
+    let low = nextCodePointBoundary(text, start);
+    let high = text.length;
+    let end = start;
+    while (low <= high) {
+      const candidate = previousCodePointBoundary(text, low + (high - low >>> 1));
+      if (candidate <= start) {
+        low = nextCodePointBoundary(text, start);
+        continue;
+      }
+      if (tokenizer(text.slice(start, candidate)) <= maxTokens) {
+        end = candidate;
+        low = candidate + 1;
+      } else {
+        high = candidate - 1;
+      }
+    }
+    if (end === start) {
+      const next = nextCodePointBoundary(text, start);
+      const singleCodePoint = text.slice(start, next);
+      if (tokenizer(singleCodePoint) > maxTokens) {
+        throw new RangeError("maxTokens is smaller than the configured tokenizer's smallest unit");
+      }
+      end = next;
+    }
+    segments.push(text.slice(start, end));
+    start = end;
+  }
+  return segments;
+}
+function emitRangeWithinBudget(block, source, start, end, startLine, tokenizer, maxTokens, out, languageId, filePath) {
+  const text = source.slice(start, end);
+  const tokenCount = tokenizer(text);
+  if (tokenCount <= maxTokens) {
+    pushRangedChunk(out, block, languageId, filePath, start, end, startLine, endLineForText(startLine, text), text, tokenCount);
+    return;
+  }
+  let segmentStart = start;
+  let segmentStartLine = startLine;
+  for (const segment of splitTextWithinTokenBudget(text, tokenizer, maxTokens)) {
+    const segmentEnd = segmentStart + segment.length;
+    pushRangedChunk(out, block, languageId, filePath, segmentStart, segmentEnd, segmentStartLine, endLineForText(segmentStartLine, segment), segment, tokenizer(segment));
+    segmentStartLine += countLineBreaks(segment);
+    segmentStart = segmentEnd;
+  }
+}
+function pushRangedChunk(out, block, languageId, filePath, sourceStart, sourceEnd, startLine, endLine, text, tokenCount) {
+  out.push({
+    id: "",
+    languageId,
+    type: block.kind,
+    startLine,
+    endLine,
+    text,
+    tokenCount,
+    sourceStart,
+    sourceEnd,
+    ...filePath !== void 0 ? { filePath } : {},
+    ...block.name !== void 0 ? { name: block.name } : {}
+  });
+}
+function lineRanges(source, start, end, startLine) {
+  const ranges = [];
+  let rangeStart = start;
+  let line = startLine;
+  for (let offset = start; offset < end; offset++) {
+    if (source[offset] !== "\n")
+      continue;
+    ranges.push({ start: rangeStart, end: offset + 1, startLine: line });
+    rangeStart = offset + 1;
+    line++;
+  }
+  if (rangeStart < end) {
+    ranges.push({ start: rangeStart, end, startLine: line });
+  }
+  return ranges;
+}
+function countLineBreaks(text) {
+  let count = 0;
+  for (let index = 0; index < text.length; index++) {
+    if (text[index] === "\n")
+      count++;
+  }
+  return count;
+}
+function endLineForText(startLine, text) {
+  const lineBreaks = countLineBreaks(text);
+  return startLine + lineBreaks - (text.endsWith("\n") ? 1 : 0);
+}
+function nextCodePointBoundary(text, index) {
+  if (index >= text.length)
+    return text.length;
+  const codePoint = text.codePointAt(index);
+  return index + (codePoint !== void 0 && codePoint > 65535 ? 2 : 1);
+}
+function previousCodePointBoundary(text, index) {
+  if (index <= 0 || index >= text.length || text.charCodeAt(index) < 56320 || text.charCodeAt(index) > 57343) {
+    return index;
+  }
+  return index - 1;
+}
+
+// dist/chunking/chunkMerge.js
+function mergeSmallChunks(chunks, minTokens, maxTokens, tokenizer) {
+  if (!chunks.length)
+    return [];
+  const merged = [];
+  let index = 0;
+  while (index < chunks.length) {
+    let current = { ...chunks[index] };
+    index++;
+    while (current.tokenCount < minTokens && index < chunks.length) {
+      if (current.type === "misc" && current.tokenCount === 0)
+        break;
+      const next = chunks[index];
+      if (next.sourceStart < current.sourceEnd)
+        break;
+      if (next.sourceStart !== current.sourceEnd)
+        break;
+      const combinedText = `${current.text}${next.text}`;
+      const combinedTokens = tokenizer(combinedText);
+      if (combinedTokens > maxTokens)
+        break;
+      const resolvedName = current.name ?? next.name;
+      let type = current.type;
+      if (current.type === "misc" && current.tokenCount === 0) {
+        type = next.type;
+      } else if (next.type === "misc" && next.tokenCount === 0) {
+        type = current.type;
+      } else if (current.type !== next.type) {
+        type = `${current.type}+${next.type}`;
+      }
+      current = {
+        ...current,
+        endLine: next.endLine,
+        sourceEnd: next.sourceEnd,
+        text: combinedText,
+        tokenCount: combinedTokens,
+        type,
+        ...resolvedName !== void 0 ? { name: resolvedName } : {}
+      };
+      index++;
+    }
+    merged.push(current);
+  }
+  return merged;
+}
+function fillGapsWithMiscChunks(chunks, source, languageId, filePath, tokenizer, minTokens, maxTokens, newlineOffsets) {
+  if (!source.length)
+    return [];
+  const result = [];
+  let currentOffset = 0;
+  const sortedChunks = [...chunks].sort((left, right) => left.sourceStart - right.sourceStart || right.sourceEnd - left.sourceEnd);
+  for (const chunk of sortedChunks) {
+    if (chunk.sourceStart > currentOffset) {
+      const appendedToPrevious = appendTriviaGap(result, source, currentOffset, chunk.sourceStart, tokenizer, maxTokens, newlineOffsets);
+      if (!appendedToPrevious) {
+        pushMiscRange(result, source, currentOffset, chunk.sourceStart, languageId, filePath, tokenizer, maxTokens, newlineOffsets);
+      }
+    }
+    result.push(chunk);
+    currentOffset = Math.max(currentOffset, chunk.sourceEnd);
+  }
+  if (currentOffset < source.length) {
+    const appendedToPrevious = appendTriviaGap(result, source, currentOffset, source.length, tokenizer, maxTokens, newlineOffsets);
+    if (!appendedToPrevious) {
+      pushMiscRange(result, source, currentOffset, source.length, languageId, filePath, tokenizer, maxTokens, newlineOffsets);
+    }
+  }
+  return mergeSmallChunks(result, minTokens, maxTokens, tokenizer);
+}
+function appendTriviaGap(chunks, source, start, end, tokenizer, maxTokens, newlineOffsets) {
+  if (!chunks.length || end <= start)
+    return false;
+  const previous = chunks[chunks.length - 1];
+  if (previous.sourceEnd !== start)
+    return false;
+  const text = source.slice(start, end);
+  if (!/^[\s;]+$/u.test(text))
+    return false;
+  const combinedText = `${previous.text}${text}`;
+  const tokenCount = tokenizer(combinedText);
+  if (tokenCount > maxTokens)
+    return false;
+  const [endRow] = locateLineFromOffset(newlineOffsets, Math.max(start, end - 1));
+  chunks[chunks.length - 1] = {
+    ...previous,
+    endLine: endRow + 1,
+    sourceEnd: end,
+    text: combinedText,
+    tokenCount
+  };
+  return true;
+}
+function pushMiscRange(out, source, start, end, languageId, filePath, tokenizer, maxTokens, newlineOffsets) {
+  if (end <= start)
+    return;
+  const [startRow] = locateLineFromOffset(newlineOffsets, start);
+  const [endRow] = locateLineFromOffset(newlineOffsets, Math.max(start, end - 1));
+  const block = {
+    kind: "misc",
+    startByte: start,
+    endByte: end,
+    startLine: startRow + 1,
+    endLine: endRow + 1
+  };
+  const text = source.slice(start, end);
+  const tokenCount = tokenizer(text);
+  if (tokenCount <= maxTokens) {
+    out.push({
+      id: "",
+      languageId,
+      type: "misc",
+      startLine: block.startLine,
+      endLine: block.endLine,
+      text,
+      tokenCount,
+      sourceStart: start,
+      sourceEnd: end,
+      ...filePath !== void 0 ? { filePath } : {}
+    });
+    return;
+  }
+  splitLargeBlockSimple(block, source, tokenizer, maxTokens, out, languageId, filePath);
+}
+function locateLineFromOffset(newlineOffsets, offset) {
+  let low = 0;
+  let high = newlineOffsets.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if (newlineOffsets[mid] < offset)
+      low = mid + 1;
+    else
+      high = mid;
+  }
+  const previousNewline = low > 0 ? newlineOffsets[low - 1] : -1;
+  return [low, offset - previousNewline - 1];
+}
+
+// dist/chunking/tokenizer.js
+function countWhitespaceTokens(text) {
+  if (!text.trim())
+    return 0;
+  return text.trim().split(/\s+/).length;
+}
+
+// dist/chunking/chunkFile.js
+function chunkFile(opts) {
+  const { language, source, filePath, minTokens = 150, maxTokens = 400, tokenizer = countWhitespaceTokens } = opts;
+  const matches = getChunkMatches(language, source, filePath);
+  const newlineOffsets = collectNewlineOffsets(source);
+  const { mainBlocks, innerBlocks, comments } = collectChunkBlockGroups(language, matches);
+  const selectedBlocks = selectMainBlocks(mainBlocks);
+  const preliminaryChunks = [];
+  const sortedInnerBlocks = [...innerBlocks].sort((left, right) => left.startByte - right.startByte || left.endByte - right.endByte);
+  for (const block of selectedBlocks) {
+    appendBlockChunks(block, sortedInnerBlocks, source, tokenizer, maxTokens, preliminaryChunks, language.id, newlineOffsets, filePath);
+  }
+  for (const comment of selectStandaloneComments(comments, selectedBlocks)) {
+    appendBlockChunks(comment, [], source, tokenizer, maxTokens, preliminaryChunks, language.id, newlineOffsets, filePath);
+  }
+  preliminaryChunks.sort((left, right) => left.sourceStart - right.sourceStart || right.sourceEnd - left.sourceEnd);
+  const mergedChunks = mergeSmallChunks(preliminaryChunks, minTokens, maxTokens, tokenizer);
+  const completeChunks = fillGapsWithMiscChunks(mergedChunks, source, language.id, filePath, tokenizer, minTokens, maxTokens, newlineOffsets);
+  return withStableChunkIds(completeChunks.map(({ sourceStart: _sourceStart, sourceEnd: _sourceEnd, ...chunk }) => chunk), language.id, filePath);
+}
+function appendBlockChunks(block, innerBlocks, source, tokenizer, maxTokens, out, languageId, newlineOffsets, filePath) {
+  const text = source.slice(block.startByte, block.endByte);
+  const tokens = tokenizer(text);
+  if (tokens <= maxTokens) {
+    out.push({
+      id: "",
+      languageId,
+      type: block.kind,
+      startLine: block.startLine,
+      endLine: block.endLine,
+      text,
+      tokenCount: tokens,
+      sourceStart: block.startByte,
+      sourceEnd: block.endByte,
+      ...filePath !== void 0 ? { filePath } : {},
+      ...block.name !== void 0 ? { name: block.name } : {}
+    });
+    return;
+  }
+  const innerInRange = collectContainedInnerBlocks(innerBlocks, block);
+  if (!innerInRange.length) {
+    splitLargeBlockSimple(block, source, tokenizer, maxTokens, out, languageId, filePath);
+    return;
+  }
+  splitLargeBlockUsingInnerBlocks(block, innerInRange, source, tokenizer, maxTokens, out, languageId, newlineOffsets, filePath);
+}
+function collectContainedInnerBlocks(sortedInnerBlocks, block) {
+  let low = 0;
+  let high = sortedInnerBlocks.length;
+  while (low < high) {
+    const mid = low + high >> 1;
+    if (sortedInnerBlocks[mid].startByte <= block.startByte)
+      low = mid + 1;
+    else
+      high = mid;
+  }
+  const innerInRange = [];
+  for (let index = low; index < sortedInnerBlocks.length; index++) {
+    const innerBlock = sortedInnerBlocks[index];
+    if (innerBlock.startByte >= block.endByte)
+      break;
+    if (innerBlock.endByte < block.endByte)
+      innerInRange.push(innerBlock);
+  }
+  return innerInRange;
+}
+function selectMainBlocks(mainBlocks) {
+  const nodes = buildBlockTree(mainBlocks);
+  const selected = [];
+  const visit = (node) => {
+    selected.push(node.block);
+    for (const child of node.children) {
+      visit(child);
+    }
+  };
+  for (const node of nodes) {
+    visit(node);
+  }
+  return selected;
+}
+function buildBlockTree(mainBlocks) {
+  const sortedBlocks = deduplicateBlocks(mainBlocks).sort((left, right) => left.startByte - right.startByte || right.endByte - left.endByte);
+  const roots = [];
+  const stack = [];
+  for (const block of sortedBlocks) {
+    while (stack.length && stack[stack.length - 1].block.endByte <= block.startByte) {
+      stack.pop();
+    }
+    const parent = stack[stack.length - 1];
+    const node = { block, children: [] };
+    if (parent && block.endByte <= parent.block.endByte) {
+      parent.children.push(node);
+      stack.push(node);
+      continue;
+    }
+    if (parent && block.startByte < parent.block.endByte) {
+      continue;
+    }
+    roots.push(node);
+    stack.push(node);
+  }
+  return roots;
+}
+function deduplicateBlocks(blocks) {
+  const byRange = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const key = `${block.startByte}:${block.endByte}`;
+    const existing = byRange.get(key);
+    if (!existing || !existing.name && block.name || existing.name === block.name && block.kind < existing.kind) {
+      byRange.set(key, block);
+    }
+  }
+  return [...byRange.values()];
+}
+function selectStandaloneComments(comments, selectedBlocks) {
+  const selectedComments = [];
+  for (const comment of deduplicateBlocks(comments)) {
+    if (selectedBlocks.some((block) => block.startByte <= comment.startByte && comment.endByte <= block.endByte)) {
+      continue;
+    }
+    const previous = selectedComments[selectedComments.length - 1];
+    if (previous && comment.startByte < previous.endByte)
+      continue;
+    selectedComments.push(comment);
+  }
+  return selectedComments;
+}
+function collectNewlineOffsets(source) {
+  const newlineOffsets = [];
+  for (let index = 0; index < source.length; index++) {
+    if (source[index] === "\n")
+      newlineOffsets.push(index);
+  }
+  return newlineOffsets;
+}
+
+// dist/agent/query-index/content.js
+var MAX_QUERY_INDEX_TEXT_BYTES = 3e5;
+var CHUNK_LANGUAGE_ALIASES = {
+  js: "javascript",
+  ts: "typescript"
+};
+function compressQueryText(text) {
+  return brotliCompressSync(text, {
+    params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 4 }
+  });
+}
+function normalizeQuerySearchText(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function detectQueryIndexSurface(relativePath) {
+  const lower = relativePath.toLowerCase();
+  if (lower === "readme.md" || lower.startsWith("docs/") || lower.endsWith(".md") || lower.endsWith(".mdx") || lower.endsWith(".rst") || lower.endsWith(".adoc") || lower.endsWith(".txt")) {
+    return "docs";
+  }
+  if (lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".toml") || lower.endsWith(".ini") || lower.endsWith(".env") || lower === "dockerfile" || lower.startsWith(".github/")) {
+    return "config";
+  }
+  return "code";
+}
+function buildQueryTextChunks(file, text) {
+  const support = supportForFile(file);
+  const languageId = support ? CHUNK_LANGUAGE_ALIASES[support.id] ?? support.id : void 0;
+  const language = languageId ? LANG_CONFIGS[languageId] : void 0;
+  if (language) {
+    try {
+      const chunks = chunkFile({
+        language,
+        source: text,
+        filePath: file,
+        minTokens: 1,
+        maxTokens: 120
+      });
+      if (chunks.length) {
+        return chunks.map((chunk, ordinal) => ({
+          ordinal,
+          kind: chunk.type,
+          ...chunk.name ? { name: chunk.name } : {},
+          text: chunk.text,
+          normalizedText: normalizeQuerySearchText([chunk.name, chunk.text].filter(Boolean).join(" ")),
+          startLine: chunk.startLine,
+          endLine: chunk.endLine
+        }));
+      }
+    } catch {
+    }
+  }
+  return text.split(/\r?\n/).map((line, ordinal) => ({
+    ordinal,
+    kind: "line",
+    text: line,
+    normalizedText: normalizeQuerySearchText(line),
+    startLine: ordinal + 1,
+    endLine: ordinal + 1
+  }));
+}
+async function prepareQueryIndexFile(input) {
+  try {
+    const stat = await fs4.stat(input.absolutePath);
+    const support = supportForFile(input.absolutePath);
+    if (stat.size > MAX_QUERY_INDEX_TEXT_BYTES) {
+      return {
+        path: input.path,
+        sourceIdentity: input.sourceIdentity,
+        surface: detectQueryIndexSurface(input.path),
+        ...support ? { language: support.id } : {},
+        byteLength: stat.size,
+        lineCount: 0,
+        normalizedText: compressQueryText(""),
+        chunks: [],
+        sourceRead: false
+      };
+    }
+    const text = await fs4.readFile(input.absolutePath, "utf8");
+    return {
+      path: input.path,
+      sourceIdentity: input.sourceIdentity,
+      surface: detectQueryIndexSurface(input.path),
+      ...support ? { language: support.id } : {},
+      byteLength: stat.size,
+      lineCount: text ? text.split(/\r?\n/).length : 0,
+      normalizedText: compressQueryText(normalizeQuerySearchText(text)),
+      chunks: buildQueryTextChunks(input.absolutePath, text).map((chunk) => ({
+        ...chunk,
+        text: compressQueryText(chunk.text)
+      })),
+      sourceRead: true
+    };
+  } catch {
+    return null;
+  }
+}
+
+// dist/agent/query-index/paths.js
+import { createHash as createHash3 } from "node:crypto";
+import path6 from "node:path";
+function resolveQueryIndexSourcePath(projectRoot, relativePath) {
+  if (relativePath.includes("\0") || isAbsoluteFilePath(relativePath)) {
+    throw new Error(`Invalid query index relative path: ${relativePath}`);
+  }
+  const normalized = normalizePath(relativePath);
+  const segments = normalized.split("/");
+  if (!normalized || normalized === "." || isAbsoluteFilePath(normalized) || segments.includes("..")) {
+    throw new Error(`Invalid query index relative path: ${relativePath}`);
+  }
+  return assertFilePathWithinRoot(projectRoot, path6.resolve(projectRoot, ...segments), "Query index row");
+}
+
+// dist/agent/query-index/queryIndexWorker.js
+async function prepareQueryIndexWorkerTask(task) {
+  const absolutePath = resolveQueryIndexSourcePath(task.projectRoot, task.relativePath);
+  return await prepareQueryIndexFile({
+    absolutePath,
+    path: task.relativePath,
+    sourceIdentity: task.sourceIdentity
+  });
+}
+export {
+  prepareQueryIndexWorkerTask as default
+};