@lzehrung/codegraph 3.0.0 → 3.1.0

package/dist/bin/query-index-worker.js

@@ -148,17 +148,6 @@ var PYTHON_ROW = {
     { prefix: PYTHON_PLAIN_PREFIX, open: "'", close: "'", escape: "\\" }
   ]
 };
-var CSHARP_ROW = {
-  lineComments: ["//"],
-  blockComments: [SLASH_STAR_COMMENT],
-  strings: [
-    // A verbatim (or interpolated verbatim) string doubles its closing quote; the backslash is data.
-    { prefix: "(?:[$][@]|[@][$]|[@])", open: '"', close: '"', doubled: true },
-    { open: '"""', close: '"""', quoteRun: true },
-    { open: '"', close: '"', escape: "\\" },
-    { open: "'", close: "'", escape: "\\" }
-  ]
-};
 var GO_ROW = {
   lineComments: ["//"],
   blockComments: [SLASH_STAR_COMMENT],
@@ -212,31 +201,16 @@ var SWIFT_ROW = {
     { hashes: true, open: '"', close: '"' }
   ]
 };
-var KOTLIN_ROW = {
-  lineComments: ["//"],
-  blockComments: [NESTED_SLASH_STAR_COMMENT],
-  strings: [
-    { open: '"""', close: '"""', interpolation: { start: "${", end: "}" } },
-    { open: '"', close: '"', escape: "\\", interpolation: { start: "${", end: "}" } },
-    { open: "'", close: "'", escape: "\\" }
-  ]
-};
-var ZIG_ROW = {
+var SCSS_ROW = {
   lineComments: ["//"],
-  blockComments: [],
-  strings: [
-    { open: '"', close: '"', escape: "\\" },
-    { open: "'", close: "'", escape: "\\" }
-  ],
-  zigMultiline: true
-};
-var CSS_FAMILY_ROW = {
-  lineComments: [],
   blockComments: [SLASH_STAR_COMMENT],
   strings: [
-    { open: "'", close: "'", escape: "\\" },
-    { open: '"', close: '"', escape: "\\" }
-  ]
+    { open: "'", close: "'", escape: "\\", interpolation: { start: "#{", end: "}", excludeFromMask: true } },
+    { open: '"', close: '"', escape: "\\", interpolation: { start: "#{", end: "}", excludeFromMask: true } }
+  ],
+  unquotedCssUrl: true,
+  commentInterpolation: { start: "#{", end: "}", excludeFromMask: true },
+  unquotedEscapes: true
 };
 var C_FAMILY_ROW = {
   lineComments: ["//"],
@@ -246,23 +220,6 @@ var C_FAMILY_ROW = {
     { open: "'", close: "'", escape: "\\" }
   ]
 };
-var JAVA_ROW = {
-  lineComments: ["//"],
-  blockComments: [SLASH_STAR_COMMENT],
-  strings: [
-    { open: '"""', close: '"""', escape: "\\" },
-    { open: '"', close: '"', escape: "\\" },
-    { open: "'", close: "'", escape: "\\" }
-  ]
-};
-var SQL_ROW = {
-  lineComments: ["--"],
-  blockComments: [SLASH_STAR_COMMENT],
-  strings: [
-    { open: "'", close: "'", doubled: true },
-    { open: '"', close: '"', doubled: true }
-  ]
-};
 var TRIVIA_ROWS = {
   js: JS_LIKE_ROW,
   ts: JS_LIKE_ROW,
@@ -271,30 +228,49 @@ var TRIVIA_ROWS = {
   typescript: JS_LIKE_ROW,
   jsx: JS_LIKE_ROW,
   python: PYTHON_ROW,
-  csharp: CSHARP_ROW,
   go: GO_ROW,
   rust: RUST_ROW,
   php: PHP_ROW,
   ruby: RUBY_ROW,
   swift: SWIFT_ROW,
-  kotlin: KOTLIN_ROW,
-  zig: ZIG_ROW,
-  css: CSS_FAMILY_ROW,
-  less: CSS_FAMILY_ROW,
-  scss: CSS_FAMILY_ROW,
-  c: C_FAMILY_ROW,
-  cpp: C_FAMILY_ROW,
-  java: JAVA_ROW,
-  sql: SQL_ROW
+  scss: SCSS_ROW,
+  cpp: C_FAMILY_ROW
 };
 function triviaRowFor(languageId) {
   return TRIVIA_ROWS[languageId] ?? JS_LIKE_ROW;
 }
 
 // dist/util/trivia.js
+function isHexUnit(unit) {
+  return unit >= 48 && unit <= 57 || unit >= 65 && unit <= 70 || unit >= 97 && unit <= 102;
+}
+function skipScssEscape(source, index) {
+  const next = index + 1;
+  if (next >= source.length)
+    return source.length;
+  const unit = source.charCodeAt(next);
+  if (unit === 10 || unit === 12)
+    return next + 1;
+  if (unit === 13)
+    return source.charCodeAt(next + 1) === 10 ? next + 2 : next + 1;
+  if (isHexUnit(unit)) {
+    let cursor = next + 1;
+    const limit = Math.min(source.length, next + 6);
+    while (cursor < limit && isHexUnit(source.charCodeAt(cursor)))
+      cursor += 1;
+    const space = source.charCodeAt(cursor);
+    if (space === 32 || space === 9 || space === 10 || space === 12)
+      return cursor + 1;
+    if (space === 13)
+      return source.charCodeAt(cursor + 1) === 10 ? cursor + 2 : cursor + 1;
+    return cursor;
+  }
+  return next + 1;
+}
 function maskTrivia(source, languageId, options) {
   const mask = buildMarkedMask(source, languageId, {
     maskStrings: options?.maskStrings ?? true,
+    maskCssUrls: options?.maskCssUrls ?? false,
     mode: "render"
   });
   let out = "";
@@ -324,14 +300,32 @@ function buildMarkedMask(source, languageId, options) {
   const length = source.length;
   let index = 0;
   while (index < length) {
+    if (row.unquotedEscapes && source.charCodeAt(index) === 92) {
+      index = skipScssEscape(source, index);
+      continue;
+    }
     if (!starters[source.charCodeAt(index)]) {
       index += 1;
       continue;
     }
+    const cssUrl = row.unquotedCssUrl ? unquotedCssUrlConstruct(source, row, index) : null;
+    if (cssUrl !== null) {
+      if (options.maskCssUrls && options.maskStrings) {
+        for (const [start, end] of constructSpans(cssUrl, options.mode)) {
+          for (let i = start; i < end; i += 1)
+            mask[i] = 1;
+        }
+      }
+      index = cssUrl.end;
+      continue;
+    }
     const commentEnd = commentSpanEnd(source, row, index);
     if (commentEnd !== null) {
-      for (let i = index; i < commentEnd; i += 1)
-        mask[i] = 1;
+      const spans = options.mode === "holes" && row.commentInterpolation ? loudCommentMaskSpans(source, row, index, commentEnd) : [[index, commentEnd]];
+      for (const [start, end] of spans) {
+        for (let i = start; i < end; i += 1)
+          mask[i] = 1;
+      }
       index = commentEnd;
       continue;
     }
@@ -364,6 +358,81 @@ function constructSpans(construct, mode) {
     return construct.renderSpans;
   return construct.maskSpans;
 }
+function isCssIdentifierUnit(unit) {
+  const isLetterOrDigit = unit >= 48 && unit <= 57 || unit >= 65 && unit <= 90 || unit >= 97 && unit <= 122;
+  return isLetterOrDigit || unit === 95 || unit === 45 || unit === 92 || unit >= 128;
+}
+function isCssSpaceUnit(unit) {
+  return unit === 32 || unit === 9 || unit === 10 || unit === 13 || unit === 12;
+}
+var CSS_URL_INTERPOLATION = {
+  start: "#{",
+  end: "}",
+  excludeFromMask: true
+};
+function unquotedCssUrlConstruct(source, row, index) {
+  if (source.charCodeAt(index + 3) !== 40 || (source.charCodeAt(index) | 32) !== 117 || (source.charCodeAt(index + 1) | 32) !== 114 || (source.charCodeAt(index + 2) | 32) !== 108) {
+    return null;
+  }
+  if (index > 0 && source.charCodeAt(index - 1) === 46)
+    return null;
+  if (index > 0 && isCssIdentifierUnit(source.charCodeAt(index - 1)))
+    return null;
+  const bodyStart = index + 4;
+  const holes = [];
+  const holeTrivia = [];
+  let cursor = bodyStart;
+  while (cursor < source.length && isCssSpaceUnit(source.charCodeAt(cursor)))
+    cursor += 1;
+  while (cursor < source.length) {
+    const unit = source.charCodeAt(cursor);
+    if (unit === 41) {
+      const maskSpans = [[index, bodyStart]];
+      let segmentStart = bodyStart;
+      for (const [holeStart, holeEnd] of holes) {
+        if (segmentStart < holeStart)
+          maskSpans.push([segmentStart, holeStart]);
+        segmentStart = holeEnd;
+      }
+      if (segmentStart < cursor)
+        maskSpans.push([segmentStart, cursor]);
+      for (const span of holeTrivia)
+        maskSpans.push(span);
+      maskSpans.push([cursor, cursor + 1]);
+      return {
+        start: index,
+        end: cursor + 1,
+        renderSpans: bodyStart < cursor ? [[bodyStart, cursor]] : [],
+        maskSpans,
+        delimitersAreTrivia: false
+      };
+    }
+    if (isCssSpaceUnit(unit)) {
+      while (cursor < source.length && isCssSpaceUnit(source.charCodeAt(cursor)))
+        cursor += 1;
+      if (source.charCodeAt(cursor) !== 41)
+        return null;
+      continue;
+    }
+    if (unit === 92) {
+      cursor = skipScssEscape(source, cursor);
+      continue;
+    }
+    if (unit === 35 && source.charCodeAt(cursor + 1) === 123) {
+      const hole = collectInterpolationSpans(source, row, cursor, CSS_URL_INTERPOLATION);
+      holes.push([cursor, hole.end]);
+      for (const span of hole.spans)
+        holeTrivia.push(span);
+      cursor = hole.end;
+      continue;
+    }
+    const isUrlUnit = unit === 33 || unit === 37 || unit === 38 || unit === 35 || unit >= 42 && unit <= 126 || unit >= 128;
+    if (!isUrlUnit)
+      return null;
+    cursor += 1;
+  }
+  return null;
+}
 var starterCache = /* @__PURE__ */ new WeakMap();
 var prefixRegexCache = /* @__PURE__ */ new WeakMap();
 var openerRegexCache = /* @__PURE__ */ new WeakMap();
@@ -395,8 +464,10 @@ function rowStarterCodes(row) {
   }
   if (row.percentLiterals)
     add("%");
-  if (row.zigMultiline)
-    add("\\");
+  if (row.unquotedCssUrl) {
+    add("u");
+    add("U");
+  }
   starterCache.set(row, starters);
   return starters;
 }
@@ -444,11 +515,45 @@ function nextTriviaConstruct(source, row, index) {
     if (percentConstruct !== null)
       return percentConstruct;
   }
-  if (row.zigMultiline && source.startsWith("\\\\", index)) {
-    return zigMultilineConstruct(source, index);
-  }
   return null;
 }
+function loudCommentMaskSpans(source, row, index, commentEnd) {
+  const interpolation = row.commentInterpolation;
+  if (!interpolation || !source.startsWith("/*", index))
+    return [[index, commentEnd]];
+  const spans = [];
+  let cursor = index;
+  let segmentStart = index;
+  while (cursor < commentEnd) {
+    if (source.startsWith(interpolation.start, cursor)) {
+      if (segmentStart < cursor)
+        spans.push([segmentStart, cursor]);
+      const inner = collectInterpolationSpans(source, row, cursor, interpolation);
+      const end = Math.min(inner.end, commentEnd);
+      if (end <= cursor) {
+        cursor += 1;
+        segmentStart = cursor;
+        continue;
+      }
+      spans.push([cursor, Math.min(cursor + interpolation.start.length, end)]);
+      for (const span of inner.spans) {
+        const start = Math.max(span[0], cursor);
+        const stop = Math.min(span[1], end);
+        if (start < stop)
+          spans.push([start, stop]);
+      }
+      if (end > cursor && end <= commentEnd && source.charCodeAt(end - 1) === 125)
+        spans.push([end - 1, end]);
+      cursor = end;
+      segmentStart = cursor;
+      continue;
+    }
+    cursor += 1;
+  }
+  if (segmentStart < commentEnd)
+    spans.push([segmentStart, commentEnd]);
+  return spans;
+}
 function commentSpanEnd(source, row, index) {
   for (const prefix of row.lineComments) {
     if (source.startsWith(prefix, index))
@@ -552,22 +657,6 @@ function quotedStringConstruct(source, row, form, index) {
       maskSpans: [[index, charEnd]],
       delimitersAreTrivia: false
     };
-  } else if (form.quoteRun) {
-    let run = 0;
-    while (source[cursor + run] === form.open[0])
-      run += 1;
-    if (run < form.open.length)
-      return null;
-    const scanned = quoteRunStringEnd(source, cursor + run, form.open[0] ?? '"', run);
-    const bodyStart2 = cursor + run;
-    const body2 = [bodyStart2, scanned.closeStart];
-    return {
-      start: index,
-      end: scanned.end,
-      renderSpans: body2[0] < body2[1] ? [body2] : [],
-      maskSpans: [[index, scanned.end]],
-      delimitersAreTrivia: false
-    };
   } else {
     if (!source.startsWith(form.open, cursor))
       return null;
@@ -603,6 +692,8 @@ function collectQuotedBody(source, row, form, start, close, hashCount) {
         if (interpolation.excludeFromMask) {
           pushSegment(cursor);
           const inner = collectInterpolationSpans(source, row, cursor, interpolation);
+          for (const span of inner.spans)
+            segments.push(span);
           cursor = inner.end;
           segmentStart = cursor;
           continue;
@@ -657,22 +748,6 @@ function charLiteralEnd(source, quoteIndex, form) {
     return cursor + 2;
   return null;
 }
-function quoteRunStringEnd(source, index, quote, runLength) {
-  let cursor = index;
-  while (cursor < source.length) {
-    if (source[cursor] !== quote) {
-      cursor += 1;
-      continue;
-    }
-    let run = 0;
-    while (source[cursor + run] === quote)
-      run += 1;
-    if (run >= runLength)
-      return { end: cursor + run, closeStart: cursor };
-    cursor += run;
-  }
-  return { end: source.length, closeStart: source.length };
-}
 function closeAloneOnItsLine(source, closeIndex) {
   const lineStart = source.lastIndexOf("\n", closeIndex - 1) + 1;
   for (let i = lineStart; i < closeIndex; i += 1) {
@@ -691,7 +766,19 @@ function collectInterpolationSpans(source, row, start, interpolation) {
   let depth = 1;
   let cursor = start + interpolation.start.length;
   while (cursor < source.length) {
+    if (row.unquotedCssUrl) {
+      const cssUrl = unquotedCssUrlConstruct(source, row, cursor);
+      if (cssUrl !== null) {
+        spans.push(...cssUrl.maskSpans);
+        cursor = cssUrl.end;
+        continue;
+      }
+    }
     const ch = source[cursor];
+    if (row.unquotedEscapes && ch === "\\") {
+      cursor = skipScssEscape(source, cursor);
+      continue;
+    }
     if (source.startsWith(interpolation.end, cursor)) {
       depth -= 1;
       if (!depth)
@@ -831,39 +918,6 @@ function percentLiteralConstructAt(source, index) {
     delimitersAreTrivia: false
   };
 }
-function zigMultilineConstruct(source, start) {
-  const renderSpans = [];
-  let cursor = start;
-  let end = source.length;
-  while (cursor < source.length) {
-    let lineEnd = cursor;
-    while (lineEnd < source.length && source[lineEnd] !== "\n")
-      lineEnd += 1;
-    if (cursor + 2 < lineEnd)
-      renderSpans.push([cursor + 2, lineEnd]);
-    if (lineEnd >= source.length) {
-      end = source.length;
-      break;
-    }
-    let probe = lineEnd + 1;
-    while (probe < source.length && (source[probe] === " " || source[probe] === "	" || source[probe] === "\r")) {
-      probe += 1;
-    }
-    if (source[probe] === "\\" && source[probe + 1] === "\\") {
-      cursor = probe;
-      continue;
-    }
-    end = lineEnd;
-    break;
-  }
-  return {
-    start,
-    end,
-    renderSpans,
-    maskSpans: [[start, end]],
-    delimitersAreTrivia: false
-  };
-}
 
 // dist/util/comments.js
 function stripJsLikeComments(src) {
@@ -1424,10 +1478,7 @@ function normalizeCsharpIdentifier(name) {
   const withoutVerbatimPrefix = name.startsWith("@") ? name.slice(1) : name;
   return hasNonAsciiCodePoint(withoutVerbatimPrefix) ? withoutVerbatimPrefix.replace(CSHARP_IDENTIFIER_FORMAT_PATTERN, "") : withoutVerbatimPrefix;
 }
-var JAVA_IDENTIFIER_SOURCE = String.raw`[\p{L}\p{Nl}\p{Sc}\p{Pc}][\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mn}\p{Mc}${JAVA_IDENTIFIER_IGNORABLE_SOURCE}]*`;
-var CSHARP_IDENTIFIER_SOURCE = String.raw`@?[\p{L}\p{Nl}_][\p{L}\p{Nl}_\p{Nd}\p{Pc}\p{Mn}\p{Mc}${CSHARP_IDENTIFIER_FORMAT_SOURCE}]*`;
 var GO_IDENTIFIER_SOURCE = String.raw`[\p{L}_][\p{L}\p{Nd}_]*`;
-var KOTLIN_IDENTIFIER_SOURCE = String.raw`[\p{L}_][\p{L}\p{Nd}_]*`;
 
 // dist/languages/definitions/python.js
 function isTypeAliasLeftName(node) {
@@ -1460,7 +1511,7 @@ function isPythonReceiverAttributeAssignmentName(node) {
   const assignment = attr.parent;
   if (assignment?.type !== "assignment")
     return false;
-  return assignment.childForFieldName("left")?.id === attr.id;
+  return assignment.childForFieldName("left")?.id === attr.id && !!assignment.childForFieldName("right");
 }
 var PYTHON_GRAPH_IMPORT_QUERY = `
       (import_statement name: (dotted_name) @from) @stmt
@@ -1571,10 +1622,12 @@ var PYTHON_DEF = {
       (assignment left: [(pattern_list (identifier) @name) (tuple_pattern (identifier) @name)])
       ;; Instance / class attributes declared as \`self.x = ...\` or \`cls.x = ...\`.
       ((assignment
-        left: (attribute object: (identifier) @receiver attribute: (identifier) @name))
+        left: (attribute object: (identifier) @receiver attribute: (identifier) @name)
+        right: (_))
         (#eq? @receiver "self"))
       ((assignment
-        left: (attribute object: (identifier) @receiver attribute: (identifier) @name))
+        left: (attribute object: (identifier) @receiver attribute: (identifier) @name)
+        right: (_))
         (#eq? @receiver "cls"))
       (named_expression name: (identifier) @name)
       (type_alias_statement left: (type [(identifier) @name (generic_type (identifier) @name)]))
@@ -2248,10 +2301,6 @@ registerLanguage(GO_DEF);
 
 // dist/languages/definitions/java.js
 var JAVA_IDENTIFIER_IGNORABLE_PATTERN = new RegExp(`[${JAVA_IDENTIFIER_IGNORABLE_SOURCE}]`, "gu");
-var JAVA_IMPORT_QUERY = `
-      (import_declaration (scoped_identifier) @from (asterisk)? @wild) @stmt
-      (import_declaration (identifier) @from (asterisk)? @wild) @stmt
-    `;
 var JAVA_DEF = {
   id: "java",
   extensions: [".java"],
@@ -2298,7 +2347,8 @@ var JAVA_DEF = {
     comments: ["line_comment", "block_comment"]
   },
   graph: {
-    imports: JAVA_IMPORT_QUERY,
+    // Java imports are read from the syntax tree (src/util/jvm-tree.ts), so no imports query runs.
+    imports: "",
     exports: `
       (class_declaration name: (identifier) @name)
       (record_declaration name: (identifier) @name)
@@ -2322,7 +2372,8 @@ var JAVA_DEF = {
       (spread_parameter (variable_declarator name: (identifier) @name))
       (receiver_parameter (identifier) @name)
     `,
-    importBindings: JAVA_IMPORT_QUERY
+    // Java imports are read from the syntax tree (src/util/jvm-tree.ts), so no import-binding query runs.
+    importBindings: ""
   },
   nodeTypes: {
     identifier: ["identifier", "type_identifier"],
@@ -2419,12 +2470,8 @@ var CSHARP_DEF = {
     comments: ["comment"]
   },
   graph: {
-    // Path node is `identifier` | `qualified_name` | `alias_qualified_name` (`global::System`).
-    // An identifier/qualified_name alternation misses `alias_qualified_name`, so keep `(_)`.
-    imports: `
-      (using_directive !name (_) @from) @stmt
-      (using_directive name: (identifier) (_) @from) @stmt
-    `,
+    // C# using directives are read from the syntax tree (src/util/csharp-tree.ts), so no imports query runs.
+    imports: "",
     exports: `
       (class_declaration name: (identifier) @name)
       (record_declaration name: (identifier) @name)
@@ -2455,13 +2502,9 @@ var CSHARP_DEF = {
       (variable_declarator name: (identifier) @name)
       (declaration_pattern name: (identifier) @name)
     `,
-    // extern alias has no path node in the grammar, so there is no @from.
-    // using path node: identifier | qualified_name | alias_qualified_name — keep `(_)`.
-    importBindings: `
-      (using_directive name: (identifier) @alias (_) @from) @stmt
-      (using_directive !name (_) @from) @stmt
-      (extern_alias_directive name: (identifier) @alias) @stmt
-    `
+    // C# using and extern-alias directives are read from the syntax tree (src/util/csharp-tree.ts), so no
+    // import-binding query runs.
+    importBindings: ""
   },
   nodeTypes: {
     identifier: ["identifier"],
@@ -3089,9 +3132,8 @@ var KOTLIN_DEF = {
     comments: ["line_comment", "block_comment"]
   },
   graph: {
-    imports: `
-      (import (qualified_identifier) @from) @stmt
-    `,
+    // Kotlin imports are read from the syntax tree (src/util/jvm-tree.ts), so no imports query runs.
+    imports: "",
     exports: `
       (source_file
         [
@@ -3122,11 +3164,8 @@ var KOTLIN_DEF = {
       (class_parameter (identifier) @name)
       (type_parameter (identifier) @name)
     `,
-    importBindings: `
-      (import (qualified_identifier) @from (identifier) @alias) @stmt
-      (import (qualified_identifier) @from ("*") @wild) @stmt
-      (import (qualified_identifier) @from) @stmt
-    `
+    // Kotlin imports are read from the syntax tree (src/util/jvm-tree.ts), so no import-binding query runs.
+    importBindings: ""
   },
   nodeTypes: {
     identifier: ["identifier"],
@@ -3410,6 +3449,177 @@ var SQL_DEF = {
 };
 registerLanguage(SQL_DEF);
 
+// 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/terraform/syntax.js
+function isSyntaxNode(node) {
+  return node.type !== "comment";
+}
+function sameNode(left, right) {
+  return !!left && !!right && left.type === right.type && left.startIndex === right.startIndex && left.endIndex === right.endIndex;
+}
+function blockTypeName(block) {
+  const first = block.namedChildren.filter(isSyntaxNode)[0];
+  return first?.type === "identifier" ? first.text : void 0;
+}
+function blockLabels(block) {
+  const labels = [];
+  for (const child of block.namedChildren.filter(isSyntaxNode).slice(1)) {
+    if (child.type === "block_start")
+      break;
+    labels.push(child);
+  }
+  return labels;
+}
+function isTopLevelBlock(block) {
+  return block.parent?.type === "body" && block.parent.parent?.type === "config_file";
+}
+function literalStringText(stringLit) {
+  if (stringLit?.type !== "string_lit")
+    return null;
+  const parts = stringLit.namedChildren.filter(isSyntaxNode).filter((child) => child.type !== "quoted_template_start" && child.type !== "quoted_template_end");
+  const text = parts.length === 1 ? parts[0] : void 0;
+  return text?.type === "template_literal" ? text : null;
+}
+function attributeNameNode(attribute) {
+  const name = attribute.namedChildren.filter(isSyntaxNode)[0];
+  return name?.type === "identifier" ? name : void 0;
+}
+function terraformDeclarationForNameNode(node) {
+  if (node.type === "identifier") {
+    const attribute = node.parent;
+    if (attribute?.type !== "attribute" || !sameNode(attributeNameNode(attribute), node))
+      return null;
+    const block2 = attribute.parent?.parent;
+    if (block2?.type !== "block" || !isTopLevelBlock(block2))
+      return null;
+    if (blockTypeName(block2) !== "locals" || blockLabels(block2).length)
+      return null;
+    return { kind: "local" };
+  }
+  if (node.type !== "template_literal")
+    return null;
+  const label = node.parent;
+  const block = label?.parent;
+  if (!label || block?.type !== "block" || !isTopLevelBlock(block))
+    return null;
+  if (!sameNode(literalStringText(label), node))
+    return null;
+  const labels = blockLabels(block);
+  const kind = blockTypeName(block);
+  if ((kind === "variable" || kind === "output" || kind === "module") && labels.length === 1)
+    return { kind };
+  if ((kind === "resource" || kind === "data") && labels.length === 2 && sameNode(labels[1], label)) {
+    const type = literalStringText(labels[0]);
+    return type ? { kind, type: type.text } : null;
+  }
+  return null;
+}
+function classifyTerraformDefinition(node) {
+  const declaration = terraformDeclarationForNameNode(node);
+  if (!declaration || declaration.kind === "local")
+    return "variable";
+  return declaration.kind;
+}
+
+// dist/languages/definitions/terraform.js
+function literalLabel(capture) {
+  const name = capture ? ` @${capture}` : "";
+  return `(string_lit . (quoted_template_start) . (template_literal)${name} . (quoted_template_end) .)`;
+}
+var COMMENT_GAP = ". (comment)* .";
+function labeledChunkBlock(keywords, labels, captureId) {
+  const keywordList = keywords.map((keyword) => `"${keyword}"`).join(" ");
+  const leading = labels === 2 ? ` ${COMMENT_GAP} (string_lit)` : "";
+  return {
+    type: "block",
+    nameQuery: `. (identifier) @kw (#any-of? @kw ${keywordList})${leading} ${COMMENT_GAP} (string_lit (template_literal) @chunk.name) ${COMMENT_GAP} (block_start)`,
+    captureId
+  };
+}
+function unlabeledChunkBlock(keywords, captureId) {
+  const keywordList = keywords.map((keyword) => `"${keyword}"`).join(" ");
+  return {
+    type: "block",
+    nameQuery: `. (identifier) @chunk.name (#any-of? @chunk.name ${keywordList}) ${COMMENT_GAP} (block_start)`,
+    captureId
+  };
+}
+var ONE_LABEL_DECLARATION = `(config_file (body (block . (identifier) @kind (#any-of? @kind "variable" "output" "module") ${COMMENT_GAP} ${literalLabel("name")} ${COMMENT_GAP} (block_start))))`;
+var TWO_LABEL_DECLARATION = `(config_file (body (block . (identifier) @kind (#any-of? @kind "resource" "data") ${COMMENT_GAP} ${literalLabel()} ${COMMENT_GAP} ${literalLabel("name")} ${COMMENT_GAP} (block_start))))`;
+var LOCALS_DECLARATION = `(config_file (body (block . (identifier) @kind (#eq? @kind "locals") ${COMMENT_GAP} (block_start) (body (attribute . (identifier) @name)))))`;
+var TERRAFORM_DEF = {
+  id: "terraform",
+  extensions: [".tf"],
+  usesQueryDrivenLocals: true,
+  structure: {
+    blocks: [
+      labeledChunkBlock(["resource"], 2, "resource"),
+      labeledChunkBlock(["data"], 2, "data"),
+      labeledChunkBlock(["module"], 1, "module"),
+      labeledChunkBlock(["variable"], 1, "variable"),
+      labeledChunkBlock(["output"], 1, "output"),
+      unlabeledChunkBlock(["locals"], "locals"),
+      labeledChunkBlock(["provider", "check"], 1, "block"),
+      labeledChunkBlock(["ephemeral"], 2, "block"),
+      unlabeledChunkBlock(["terraform", "moved", "import", "removed"], "block")
+    ],
+    splitPoints: [],
+    comments: ["comment"]
+  },
+  graph: {
+    // A module call depends on its local `source` directory; remote sources stay external.
+    imports: `
+      (config_file (body (block . (identifier) @kw (#eq? @kw "module")
+        (body (attribute . (identifier) @attr (#eq? @attr "source")
+          ${COMMENT_GAP} (expression . (literal_value . ${literalLabel("from")} .) .)))) @stmt))
+    `,
+    exports: `
+      (config_file (body (block . (identifier) @kind (#any-of? @kind "variable" "output") ${COMMENT_GAP} ${literalLabel("name")} ${COMMENT_GAP} (block_start))))
+    `,
+    locals: `
+      ${ONE_LABEL_DECLARATION}
+      ${TWO_LABEL_DECLARATION}
+      ${LOCALS_DECLARATION}
+    `,
+    // Module calls bind no local names; `module.<name>` resolves in src/terraform/.
+    importBindings: ""
+  },
+  nodeTypes: {
+    identifier: ["identifier"]
+  },
+  // Terraform references resolve in src/terraform/, so generic cross-module and member passes skip it.
+  supportsCrossModuleSymbols: false,
+  classifyDefinition: classifyTerraformDefinition,
+  isDeclarationName: (node) => terraformDeclarationForNameNode(node) !== null
+};
+registerLanguage(TERRAFORM_DEF);
+
 // dist/languages/definitions/zig.js
 var ZIG_TYPE_INITIALIZER_TYPES = /* @__PURE__ */ new Set([
   "builtin_type",
@@ -3511,30 +3721,16 @@ var ZIG_DEF = {
 registerLanguage(ZIG_DEF);
 
 // dist/bootstrap/tree-sitter-languages.js
-var idToConfigKey = {
+var CHUNK_LANGUAGE_ALIASES = {
   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"
+  ts: "typescript"
 };
+function chunkLanguageKey(id) {
+  return CHUNK_LANGUAGE_ALIASES[id] ?? id;
+}
 var LANG_CONFIGS = {};
 for (const lang of getAllLanguages()) {
-  const key = idToConfigKey[lang.id] || lang.id;
+  const key = chunkLanguageKey(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;
   }
@@ -3602,9 +3798,6 @@ function collectChunkBlockGroups(language, matches) {
   return { mainBlocks, innerBlocks, comments };
 }
 
-// dist/chunking/chunk-matches.js
-import { Buffer as Buffer2 } from "node:buffer";
-
 // dist/languages.js
 import fs from "node:fs";
 import path from "node:path";
@@ -3651,6 +3844,7 @@ 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 TERRAFORM_SUPPORT = adaptDefinition(getLanguageById("terraform"));
 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"]);
@@ -3727,39 +3921,64 @@ function isLikelyCppHeader(sample) {
   return CPP_HEADER_HINT.test(masked) || CPP_MODULE_IMPORT_HINT.test(masked);
 }
 
+// dist/native/byte-index.js
+var EMPTY_BYTE_TO_STRING_INDEX = new Uint32Array(0);
+var EMPTY_LINE_START_BYTES = [];
+function buildByteMap(source) {
+  const byteLength = Buffer.byteLength(source, "utf8");
+  if (byteLength === source.length) {
+    return {
+      isAscii: true,
+      sourceLength: source.length,
+      byteToStringIndex: EMPTY_BYTE_TO_STRING_INDEX,
+      lineStartBytes: EMPTY_LINE_START_BYTES
+    };
+  }
+  const byteToStringIndex = new Uint32Array(byteLength + 1);
+  const lineStartBytes = [0];
+  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;
+    if (codePoint === 10) {
+      lineStartBytes.push(byteOffset);
+    }
+  }
+  byteToStringIndex[byteOffset] = source.length;
+  return { isAscii: false, sourceLength: source.length, byteToStringIndex, lineStartBytes };
+}
+function stringIndexForByte(map, byteIndex) {
+  if (map.isAscii)
+    return Math.max(0, Math.min(byteIndex, map.sourceLength));
+  const bounded = Math.max(0, Math.min(byteIndex, map.byteToStringIndex.length - 1));
+  return map.byteToStringIndex[bounded] ?? map.sourceLength;
+}
+function utf8ByteLengthForCodePoint(codePoint) {
+  if (codePoint <= 127)
+    return 1;
+  if (codePoint <= 2047)
+    return 2;
+  if (codePoint <= 65535)
+    return 3;
+  return 4;
+}
+
 // dist/native/runtime.js
 import fs5 from "node:fs";
 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/binding-loader.js
 import fs4 from "node:fs";
 import path4 from "node:path";
@@ -4795,61 +5014,25 @@ function getChunkMatches(language, source, _filePath) {
   if (support) {
     const nativeExecution = getNativeSingleQueryExecution(source, support, language.queryText);
     if (nativeExecution.matches) {
-      const toStringIndex = createUtf8ByteToStringIndex(source);
-      return nativeExecution.matches.map((match) => toChunkMatchFromNative(match, toStringIndex));
+      const byteMap = buildByteMap(source);
+      return nativeExecution.matches.map((match) => toChunkMatchFromNative(match, byteMap));
     }
   }
   return [];
 }
-function toChunkMatchFromNative(match, toStringIndex) {
+function toChunkMatchFromNative(match, byteMap) {
   return {
     captures: match.captures.map((capture) => ({
       name: capture.name,
       text: capture.text,
-      startByte: toStringIndex(capture.start.index),
-      endByte: toStringIndex(capture.end.index),
+      startByte: stringIndexForByte(byteMap, capture.start.index),
+      endByte: stringIndexForByte(byteMap, 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/chunk-id.js
 import { createHash as createHash2 } from "node:crypto";
@@ -5308,10 +5491,6 @@ function collectNewlineOffsets(source) {
 
 // dist/agent/query-index/content.js
 var MAX_QUERY_INDEX_TEXT_BYTES = 3e5;
-var CHUNK_LANGUAGE_ALIASES = {
-  js: "javascript",
-  ts: "typescript"
-};
 function compressQueryText(text) {
   const compressed = brotliCompressSync(text, {
     params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 4 }
@@ -5332,7 +5511,7 @@ function detectQueryIndexSurface(relativePath) {
   return "code";
 }
 function chunkQueryText(file, text, support) {
-  const languageId = support ? CHUNK_LANGUAGE_ALIASES[support.id] ?? support.id : void 0;
+  const languageId = support ? chunkLanguageKey(support.id) : void 0;
   const language = languageId ? LANG_CONFIGS[languageId] : void 0;
   if (language) {
     try {