@namzu/cli 37.2.0 → 38.0.0

package/dist/chunks/{dist-KGLSBIES.js → dist-ADL22Y3L.js}

@@ -1,22 +1,883 @@
 import { createRequire as __namzuCreateRequire } from 'node:module';
 const require = __namzuCreateRequire(import.meta.url);
 import {
+  CUT_MARK_CHARS,
   EMPTY_ROWS,
   ParserUnavailableError,
   isDeclarationFile,
   languageOf
-} from "./chunk-7WKQQOKK.js";
+} from "./chunk-M6CYVSNV.js";
 import {
-  __name
+  __commonJS,
+  __name,
+  __toESM
 } from "./chunk-76FLAFCG.js";
 
+// ../../node_modules/.pnpm/ignore@7.0.12/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "../../node_modules/.pnpm/ignore@7.0.12/node_modules/ignore/index.js"(exports, module) {
+    "use strict";
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    __name(makeArray, "makeArray");
+    var UNDEFINED = void 0;
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
+    var BOM = "\uFEFF";
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var DOUBLE_SLASH = "//";
+    var SLASH_CODE = 47;
+    var DOT_CODE = 46;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = /* @__PURE__ */ __name((object, key, value) => {
+      Object.defineProperty(object, key, { value });
+      return value;
+    }, "define");
+    var RETURN_FALSE = /* @__PURE__ */ __name(() => false, "RETURN_FALSE");
+    var cleanRangeBackSlash = /* @__PURE__ */ __name((slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    }, "cleanRangeBackSlash");
+    var POSIX_CLASSES = {
+      alnum: "0-9A-Za-z",
+      alpha: "A-Za-z",
+      blank: " \\t",
+      cntrl: "\\x00-\\x1f\\x7f",
+      digit: "0-9",
+      graph: "!-.0-~",
+      lower: "a-z",
+      print: " -.0-~",
+      punct: "!-.:-@\\[-`{-~",
+      // git's `sane-ctype.h` classifies \v and \f as control, not space,
+      //   unlike C's `isspace`
+      space: " \\t\\n\\r",
+      upper: "A-Z",
+      xdigit: "0-9A-Fa-f"
+    };
+    var CLASS_MEMBERS_TO_ESCAPE = "\\]^-[";
+    var escapeMember = /* @__PURE__ */ __name((char) => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0 ? char : ESCAPE + char, "escapeMember");
+    var NON_SLASH = "(?!\\/)";
+    var classSource = /* @__PURE__ */ __name((negated, body) => {
+      if (negated) {
+        return `[^\\/${body}]`;
+      }
+      const source = `[${body}]`;
+      return new RegExp(source).test("/") ? NON_SLASH + source : source;
+    }, "classSource");
+    var scanBracket = /* @__PURE__ */ __name((pattern, start) => {
+      const { length } = pattern;
+      let index = start + 1;
+      let negated = EMPTY;
+      const lead = pattern[index];
+      if (lead === "!" || lead === "^") {
+        negated = "^";
+        index++;
+      }
+      let body = EMPTY;
+      let prev = EMPTY;
+      for (; ; ) {
+        const char = pattern[index];
+        if (char === UNDEFINED) {
+          return null;
+        }
+        if (char === ESCAPE) {
+          const escaped = pattern[index + 1];
+          if (escaped === UNDEFINED) {
+            return null;
+          }
+          body += escapeMember(escaped);
+          prev = escaped;
+          index++;
+        } else if (char === "-" && prev && index + 1 < length && pattern[index + 1] !== "]") {
+          index++;
+          let to = pattern[index];
+          if (to === ESCAPE) {
+            to = pattern[index += 1];
+          }
+          if (prev <= to) {
+            body += `-${escapeMember(to)}`;
+          }
+          prev = EMPTY;
+        } else if (char === "[" && pattern[index + 1] === ":") {
+          const nameStart = index + 2;
+          let end = nameStart;
+          while (end < length && pattern[end] !== "]") {
+            end++;
+          }
+          if (end === length) {
+            return null;
+          }
+          if (end > nameStart && pattern[end - 1] === ":") {
+            const expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)];
+            if (expanded === UNDEFINED) {
+              return null;
+            }
+            body += expanded;
+            prev = EMPTY;
+            index = end;
+          } else {
+            body += escapeMember("[");
+            prev = "[";
+            index = nameStart - 2;
+          }
+        } else {
+          body += escapeMember(char);
+          prev = char;
+        }
+        index++;
+        if (pattern[index] === "]") {
+          return {
+            end: index,
+            source: classSource(negated, body)
+          };
+        }
+      }
+    }, "scanBracket");
+    var NEVER_MATCH = "[]";
+    var PLACEHOLDER = "\0";
+    var REGEX_RESTORE_PLACEHOLDER = new RegExp(
+      `${PLACEHOLDER}(\\d+)${PLACEHOLDER}`,
+      "g"
+    );
+    var TRAILING_WILDCARD = "\uE000";
+    var TRAILING_DOUBLESTAR = "\uE001";
+    var extractBrackets = /* @__PURE__ */ __name((pattern) => {
+      const sources = [];
+      const hold = /* @__PURE__ */ __name((source) => `${PLACEHOLDER}${sources.push(source) - 1}${PLACEHOLDER}`, "hold");
+      const { length } = pattern;
+      let out = EMPTY;
+      let index = 0;
+      while (index < length) {
+        const char = pattern[index];
+        if (char === ESCAPE) {
+          const escaped = pattern[index + 1];
+          if (escaped === UNDEFINED || escaped === SLASH && index + 2 === length) {
+            out += hold(NEVER_MATCH);
+          } else if (escaped === "*" || escaped === "[" || escaped === SPACE || escaped === ESCAPE) {
+            out += pattern.slice(index, index + 2);
+          } else {
+            out += hold(
+              REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : escaped
+            );
+          }
+          index += 2;
+        } else if (char === PLACEHOLDER) {
+          out += hold(`[${PLACEHOLDER}]`);
+          index++;
+        } else if (char === "[") {
+          const scanned = scanBracket(pattern, index);
+          if (scanned === null) {
+            out += hold(NEVER_MATCH);
+            index = length;
+          } else {
+            out += hold(scanned.source);
+            index = scanned.end + 1;
+          }
+        } else {
+          out += char;
+          index++;
+        }
+      }
+      return {
+        source: out,
+        sources
+      };
+    }, "extractBrackets");
+    var DIRECT = null;
+    var REGEX_INNER_SLASH = /\/(?!$)/;
+    var REPLACERS = [
+      // Replace (\ ) with ' '
+      // Only a space: an escaped tab or other whitespace is already a literal by
+      //   the time it reaches here, and a bare tab must be left as one, not turned
+      //   into a space.
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        // A run of backslashes is taken whole, from its first one, so no match
+        //   ever starts again inside it -- `(\\+?) ` did, which made a long run
+        //   quadratic.
+        /(\\+)( ?)/g,
+        (_, run, space) => space ? run.slice(0, run.length - run.length % 2) + SPACE : run,
+        ESCAPE + SPACE
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]",
+        "?"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^",
+        SLASH
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/",
+        SLASH
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*(?:\\\*\\\*\\\/)+/,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?",
+        "*"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        DIRECT,
+        (source, pattern) => {
+          if (!source || source[0] === "^") {
+            return source;
+          }
+          const anchor = !REGEX_INNER_SLASH.test(pattern) ? "(?:^|\\/)" : "^";
+          return anchor + source;
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? str.slice(index + 6) === "\\/" ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : `\\/${TRAILING_DOUBLESTAR}`,
+        "*"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        },
+        "*"
+      ],
+      // trailing wildcard, held apart from a literal star
+      [
+        // The step above leaves a trailing `*` alone, so a single `\*` is all that
+        //   can be left at the end here. Whether it is a wildcard or a literal
+        //   turns on the backslashes the user put in front of it: the escaper has
+        //   since doubled every one, so what stands here is those `2N` doubled
+        //   backslashes and then the star's own escape. An even number of the
+        //   original `N` leaves the star unescaped -- a wildcard -- and an odd
+        //   number escapes it -- a literal. This runs while the two are still
+        //   distinct, before the unescape steps below collapse the literal onto
+        //   the very `\*` a wildcard leaves behind.
+        /(^|[^\\])((?:\\\\)*)\\\*$/,
+        (match, p1, p2) => (
+          // `p2` holds the doubled user backslashes; half of them is `N`.
+          p2.length / 2 % 2 === 0 ? p1 + p2 + TRAILING_WILDCARD : match
+        ),
+        "*"
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE,
+        ESCAPE + ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE,
+        ESCAPE + ESCAPE
+      ],
+      [
+        // Every real bracket expression -- POSIX classes included -- has already
+        //   been held aside by `extractBrackets`, so the only `[` left in the
+        //   pattern is an escaped, literal one.
+        // `\` is escaped by step 3
+        /\\\[([^\]/]*?)(\\*)($|\])/g,
+        // '\\[bar]' -> '\\\\[bar\\]'
+        (match, range, endEscape, close) => `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`,
+        "["
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        DIRECT,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (source) => {
+          const last = source[source.length - 1];
+          if (!last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR) {
+            return source;
+          }
+          return last === SLASH ? `${source}$` : `${source}(?=$|\\/$)`;
+        }
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var replaceTrailingWildcard = /* @__PURE__ */ __name((_, p1) => {
+      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    }, "replaceTrailingWildcard");
+    var REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/;
+    var replaceTrailingDoublestar = /* @__PURE__ */ __name(() => ".+(?=$|\\/$)", "replaceTrailingDoublestar");
+    var WILDCARD = "[^\\/]*";
+    var separatorAfter = /* @__PURE__ */ __name((run, at) => {
+      let separator = EMPTY;
+      for (let index = at + 1; index < run.length && !run[index].wildcard; index++) {
+        separator += run[index].single;
+      }
+      return separator;
+    }, "separatorAfter");
+    var pinWildcards = /* @__PURE__ */ __name((source) => {
+      if (source.indexOf(WILDCARD) < 0) {
+        return source;
+      }
+      const tokens = [];
+      const { length } = source;
+      let index = 0;
+      while (index < length) {
+        const char = source[index];
+        if (source.startsWith(WILDCARD, index)) {
+          tokens.push({ wildcard: true });
+          index += WILDCARD.length;
+        } else if (char === "[") {
+          let end = index + 1;
+          if (source[end] === "^") {
+            end++;
+          }
+          if (source[end] === "]") {
+            end++;
+          }
+          while (end < length && source[end] !== "]") {
+            end += source[end] === ESCAPE ? 2 : 1;
+          }
+          end++;
+          tokens.push({ single: source.slice(index, end) });
+          index = end;
+        } else if (char === ESCAPE) {
+          tokens.push({ single: source.slice(index, index + 2) });
+          index += 2;
+        } else if (char === "(") {
+          let depth = 0;
+          let end = index;
+          do {
+            if (source[end] === ESCAPE) {
+              end++;
+            } else if (source[end] === "(") {
+              depth++;
+            } else if (source[end] === ")") {
+              depth--;
+            }
+            end++;
+          } while (end < length && depth > 0);
+          if ("*+?".indexOf(source[end]) >= 0) {
+            end++;
+          }
+          tokens.push({ boundary: source.slice(index, end) });
+          index = end;
+        } else if (char === "^" || char === "$") {
+          tokens.push({ boundary: char });
+          index++;
+        } else {
+          tokens.push({ single: char });
+          index++;
+        }
+      }
+      let out = EMPTY;
+      let run = [];
+      const flush = /* @__PURE__ */ __name(() => {
+        let lastWildcard;
+        run.forEach((token, at) => {
+          if (token.wildcard) {
+            lastWildcard = at;
+          }
+        });
+        run.forEach((token, at) => {
+          if (!token.wildcard) {
+            out += token.single;
+            return;
+          }
+          out += at === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run, at)})[^\\/])*`;
+        });
+        run = [];
+      }, "flush");
+      tokens.forEach((token) => {
+        if (token.boundary === void 0) {
+          run.push(token);
+          return;
+        }
+        flush();
+        out += token.boundary;
+      });
+      flush();
+      return out;
+    }, "pinWildcards");
+    var makeRegexPrefix = /* @__PURE__ */ __name((pattern) => {
+      const { source, sources } = extractBrackets(pattern);
+      const replaced = REPLACERS.reduce(
+        // A pass whose matcher finds nothing hands back the very string it was
+        //   given, so asking first costs a search and saves a rewrite. Ten of the
+        //   fifteen passes never fire for a typical .gitignore line, and between
+        //   them they were 45% of this chain.
+        (prev, [matcher, replacer, required]) => {
+          if (matcher === DIRECT) {
+            return replacer(prev, pattern);
+          }
+          if (required !== UNDEFINED && prev.indexOf(required) < 0) {
+            return prev;
+          }
+          return matcher.test(prev) ? prev.replace(matcher, replacer.bind(pattern)) : prev;
+        },
+        source
+      );
+      return sources.length ? replaced.replace(
+        REGEX_RESTORE_PLACEHOLDER,
+        (match, index) => sources[index]
+      ) : replaced;
+    }, "makeRegexPrefix");
+    var checkSourceOf = /* @__PURE__ */ __name((body, prefix) => {
+      if (body[body.length - 1] === SLASH) {
+        prefix = makeRegexPrefix(body.slice(0, -1));
+      }
+      const head = prefix.slice(0, -1);
+      const last = prefix[prefix.length - 1];
+      return last === TRAILING_WILDCARD ? `${head}$` : last === TRAILING_DOUBLESTAR ? `${head}.*$` : NEVER_MATCH;
+    }, "checkSourceOf");
+    var matchesBasename = /* @__PURE__ */ __name((body) => {
+      const index = body.indexOf(SLASH);
+      return index < 0 || index === body.length - 1;
+    }, "matchesBasename");
+    var basenameOf = /* @__PURE__ */ __name((path) => {
+      const end = path.length - 1;
+      const index = path.lastIndexOf(
+        SLASH,
+        path[end] === SLASH ? end - 1 : end
+      );
+      return index < 0 ? path : path.slice(index + 1);
+    }, "basenameOf");
+    var parentOf = /* @__PURE__ */ __name((path) => {
+      if (path.charCodeAt(0) === SLASH_CODE || path.indexOf(DOUBLE_SLASH) >= 0) {
+        const slices = path.split(SLASH).filter(Boolean);
+        slices.pop();
+        return slices.length ? slices.join(SLASH) + SLASH : EMPTY;
+      }
+      const end = path.length - 1;
+      const cut = path.lastIndexOf(
+        SLASH,
+        path.charCodeAt(end) === SLASH_CODE ? end - 1 : end
+      );
+      return cut < 0 ? EMPTY : path.slice(0, cut + 1);
+    }, "parentOf");
+    var isString = /* @__PURE__ */ __name((subject) => typeof subject === "string", "isString");
+    var checkPattern = /* @__PURE__ */ __name((pattern) => pattern && isString(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern), "checkPattern");
+    var splitPattern = /* @__PURE__ */ __name((pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean), "splitPattern");
+    var IgnoreRule = class {
+      static {
+        __name(this, "IgnoreRule");
+      }
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      // Worked out on first use and kept behind an own property, the way `regex`
+      //   caches itself in `_regex`. Deciding it in the constructor instead would
+      //   add a fourth `defineProperty` to every rule ever built, which cost 4% of
+      //   every compile -- including the compiles of rules that are never matched
+      //   against anything.
+      get _basenameOnly() {
+        return define(this, "_basenameOnly", matchesBasename(this.body));
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = pinWildcards(
+          mode === MODE_IGNORE ? this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard).replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar) : checkSourceOf(this.body, this.regexPrefix)
+        );
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    };
+    var isLineEnd = /* @__PURE__ */ __name((char) => char === "\r" || char === "\n", "isLineEnd");
+    var trimEnd = /* @__PURE__ */ __name((body) => {
+      let end = body.length;
+      while (end && isLineEnd(body[end - 1])) {
+        end--;
+      }
+      const lineEnd = end;
+      while (end && body[end - 1] === SPACE) {
+        end--;
+      }
+      if (end === lineEnd) {
+        return body.slice(0, end);
+      }
+      let backslashes = 0;
+      while (backslashes < end && body[end - backslashes - 1] === ESCAPE) {
+        backslashes++;
+      }
+      return backslashes % 2 ? body.slice(0, end - 1) + SPACE : body.slice(0, end);
+    }, "trimEnd");
+    var createRule = /* @__PURE__ */ __name(({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let body = pattern[0] === BOM ? pattern.slice(1) : pattern;
+      if (body[0] === "#") {
+        return;
+      }
+      let negative = false;
+      if (body[0] === "!") {
+        negative = true;
+        body = body.slice(1);
+      }
+      const last = body[body.length - 1];
+      if (last === SPACE || last === "\r" || last === "\n") {
+        body = trimEnd(body);
+      }
+      if (!body) {
+        return;
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    }, "createRule");
+    var RuleManager = class {
+      static {
+        __name(this, "RuleManager");
+      }
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+        this._basenameCount = 0;
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._basenameCount += pattern._rules._basenameCount;
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        const rule = checkPattern(pattern.pattern) && createRule(pattern, this._ignoreCase);
+        if (rule) {
+          this._added = true;
+          this._rules.push(rule);
+          if (matchesBasename(rule.body)) {
+            this._basenameCount++;
+          }
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        if (this._added) {
+          this._literalRules = UNDEFINED;
+        }
+        return this._added;
+      }
+      // Match the literal 'abc/' for `checkIgnore`, last rule wins. Only a rule
+      //   ending in a wildcard can match it (see `checkSourceOf`), so the rest
+      //   are left out once, rather than tested or compiled for every path.
+      testLiteral(path) {
+        const rules = this._literalRules || (this._literalRules = this._rules.filter(
+          ({ body }) => body[body.length - (body[body.length - 1] === SLASH ? 2 : 1)] === "*"
+        ));
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        for (let index = rules.length - 1; index >= 0; index--) {
+          const rule = rules[index];
+          if (rule.checkRegex.test(path)) {
+            ignored = !rule.negative;
+            unignored = rule.negative;
+            matchedRule = rule.negative ? UNDEFINED : rule;
+            break;
+          }
+        }
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        const rules = this._rules;
+        const { length } = rules;
+        const shortcut = this._basenameCount * 2 >= length;
+        const basename3 = shortcut ? basenameOf(path) : path;
+        for (let index = 0; index < length; index++) {
+          const rule = rules[index];
+          const { negative } = rule;
+          const skip = unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored;
+          if (!skip && rule[mode].test(
+            shortcut && rule._basenameOnly ? basename3 : path
+          )) {
+            ignored = !negative;
+            unignored = negative;
+            matchedRule = negative ? UNDEFINED : rule;
+          }
+        }
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
+    var throwError = /* @__PURE__ */ __name((message, Ctor) => {
+      throw new Ctor(message);
+    }, "throwError");
+    var checkPath = /* @__PURE__ */ __name((path, originalPath, doThrow) => {
+      if (!isString(path)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    }, "checkPath");
+    var isNotRelative = /* @__PURE__ */ __name((path) => {
+      const first = path.charCodeAt(0);
+      if (first === SLASH_CODE) {
+        return true;
+      }
+      if (first !== DOT_CODE) {
+        return false;
+      }
+      if (path.length === 1) {
+        return true;
+      }
+      const second = path.charCodeAt(1);
+      if (second === SLASH_CODE) {
+        return true;
+      }
+      if (second !== DOT_CODE) {
+        return false;
+      }
+      return path.length === 2 || path.charCodeAt(2) === SLASH_CODE;
+    }, "isNotRelative");
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      static {
+        __name(this, "Ignore");
+      }
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored) {
+        const path = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path, cache, checkUnignored);
+      }
+      checkIgnore(path) {
+        if (path.charCodeAt(path.length - 1) !== SLASH_CODE) {
+          return this.test(path);
+        }
+        const dir = this._t(path, this._testCache, true);
+        if (dir.ignored) {
+          return dir;
+        }
+        const literal = this._rules.testLiteral(path);
+        return literal.ignored || literal.unignored ? literal : dir;
+      }
+      _t(path, cache, checkUnignored) {
+        if (path in cache) {
+          return cache[path];
+        }
+        const parentPath = parentOf(path);
+        const parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
+        return cache[path] = parent && parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path) {
+        return this._test(path, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path) => !this.ignores(path);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path) {
+        return this._test(path, this._testCache, true);
+      }
+    };
+    var factory = /* @__PURE__ */ __name((options) => new Ignore(options), "factory");
+    var isPathValid = /* @__PURE__ */ __name((path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE), "isPathValid");
+    var setupWindows = /* @__PURE__ */ __name(() => {
+      const makePosix = /* @__PURE__ */ __name((str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/"), "makePosix");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+    }, "setupWindows");
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module.exports = factory;
+    factory.default = factory;
+    module.exports.isPathValid = isPathValid;
+    define(module.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
 // ../analysis/dist/provider.js
-import { lstat as lstat4, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { lstat as lstat5, realpath as realpath3, stat as stat3 } from "node:fs/promises";
 
 // ../analysis/dist/context.js
 import { createHash as createHash3 } from "node:crypto";
-import { lstat as lstat3 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
+
+// ../analysis/dist/collect.js
+var import_ignore = __toESM(require_ignore(), 1);
+import { lstat as lstat3, readdir as readdir2 } from "node:fs/promises";
+import { basename, extname, join as join4 } from "node:path";
+import { setImmediate as nextTurn2 } from "node:timers/promises";
 
 // ../analysis/dist/fsafe.js
 import { constants } from "node:fs";
@@ -47,7 +908,7 @@ async function descriptorInside(rootReal, fd, path, opened) {
   }
 }
 __name(descriptorInside, "descriptorInside");
-async function readRegular(rootReal, abs) {
+async function readRegular(rootReal, abs, limit) {
   let before;
   try {
     before = await lstat(abs);
@@ -74,7 +935,14 @@ async function readRegular(rootReal, abs) {
       }
       if (!await descriptorInside(rootReal, handle.fd, abs, opened))
         return { ok: false, why: "outside" };
-      const buffer = await handle.readFile();
+      let buffer;
+      if (limit === void 0)
+        buffer = await handle.readFile();
+      else {
+        const chunk = Buffer.alloc(Math.min(limit, opened.size));
+        const { bytesRead } = await handle.read(chunk, 0, chunk.length, 0);
+        buffer = chunk.subarray(0, bytesRead);
+      }
       if (!isInside(rootReal, await realpath(abs)))
         return { ok: false, why: "outside" };
       return { ok: true, buffer, stat: opened };
@@ -109,13 +977,15 @@ async function conditionOf(rootReal, abs, recorded) {
   return s.size === recorded.size && s.mtimeMs === recorded.mtimeMs ? "same" : "changed";
 }
 __name(conditionOf, "conditionOf");
-
-// ../analysis/dist/indexer.js
-import { createHash as createHash2 } from "node:crypto";
-import { lstat as lstat2, readdir as readdir2, realpath as realpath2 } from "node:fs/promises";
-import { join as join3, sep as sep3 } from "node:path";
-import { setImmediate as nextTurn } from "node:timers/promises";
-import { TextDecoder } from "node:util";
+function toRel(root, abs) {
+  if (abs === root)
+    return "";
+  const prefix = root.endsWith(sep) ? root : root + sep;
+  if (!abs.startsWith(prefix))
+    return void 0;
+  return abs.slice(prefix.length).split(sep).join("/");
+}
+__name(toRel, "toRel");
 
 // ../analysis/dist/host.js
 import { fork } from "node:child_process";
@@ -288,7 +1158,12 @@ var ParserHost = class {
           }
           if (m.t === "done" && m.rel === job.rel) {
             cleanup();
-            resolve2({ kind: "rows", parseErrors: m.parseErrors, rows: m.rows });
+            resolve2({
+              kind: "rows",
+              parseErrors: m.parseErrors,
+              degraded: m.degraded,
+              rows: m.rows
+            });
           } else if (m.t === "fail" && m.rel === job.rel) {
             cleanup();
             if (m.unavailable)
@@ -363,6 +1238,13 @@ function abortError() {
 }
 __name(abortError, "abortError");
 
+// ../analysis/dist/indexer.js
+import { createHash as createHash2 } from "node:crypto";
+import { lstat as lstat2, realpath as realpath2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { setImmediate as nextTurn } from "node:timers/promises";
+import { TextDecoder } from "node:util";
+
 // ../analysis/dist/lines.js
 function lineStarts(text) {
   let count = 1;
@@ -479,7 +1361,7 @@ async function evictCaches(cacheDir, keep, policy, now = Date.now()) {
 __name(evictCaches, "evictCaches");
 
 // ../analysis/dist/store.js
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 3;
 var sqlite;
 async function loadSqlite() {
   sqlite ??= import("node:sqlite").catch(() => void 0);
@@ -491,17 +1373,23 @@ CREATE TABLE IF NOT EXISTS meta(key TEXT PRIMARY KEY, value TEXT NOT NULL);
 CREATE TABLE IF NOT EXISTS files(
 	id INTEGER PRIMARY KEY, path TEXT NOT NULL UNIQUE, chars INTEGER NOT NULL, lang TEXT NOT NULL,
 	parse_errors INTEGER NOT NULL, line_starts BLOB NOT NULL, size INTEGER NOT NULL,
-	mtime_ms REAL NOT NULL, hash TEXT NOT NULL);
+	mtime_ms REAL NOT NULL, hash TEXT NOT NULL, degraded INTEGER NOT NULL DEFAULT 0);
 CREATE TABLE IF NOT EXISTS dirs(path TEXT PRIMARY KEY, mtime_ms REAL NOT NULL);
+CREATE TABLE IF NOT EXISTS excl(
+	path TEXT NOT NULL, kind TEXT NOT NULL, name TEXT NOT NULL, n INTEGER NOT NULL,
+	PRIMARY KEY(path, kind, name));
 CREATE TABLE IF NOT EXISTS functions(
 	id INTEGER PRIMARY KEY, file_id INTEGER NOT NULL, parent_id INTEGER, kind TEXT NOT NULL, name TEXT,
-	start INTEGER NOT NULL, "end" INTEGER NOT NULL, sline INTEGER NOT NULL, eline INTEGER NOT NULL);
+	start INTEGER NOT NULL, "end" INTEGER NOT NULL, sline INTEGER NOT NULL, eline INTEGER NOT NULL,
+	qname TEXT);
+CREATE TABLE IF NOT EXISTS classes(
+	file_id INTEGER NOT NULL, name TEXT, start INTEGER NOT NULL, "end" INTEGER NOT NULL);
 CREATE TABLE IF NOT EXISTS strings(
 	id INTEGER PRIMARY KEY, file_id INTEGER NOT NULL, fn_id INTEGER, start INTEGER NOT NULL,
-	"end" INTEGER NOT NULL, kind TEXT NOT NULL, value TEXT NOT NULL);
+	"end" INTEGER NOT NULL, kind TEXT NOT NULL, value TEXT NOT NULL, cut INTEGER NOT NULL DEFAULT 0);
 CREATE TABLE IF NOT EXISTS calls(
 	file_id INTEGER NOT NULL, fn_id INTEGER, start INTEGER NOT NULL, "end" INTEGER NOT NULL,
-	callee TEXT NOT NULL, kind TEXT NOT NULL, nargs INTEGER NOT NULL);
+	callee TEXT NOT NULL, kind TEXT NOT NULL, nargs INTEGER NOT NULL, owner TEXT, unres INTEGER NOT NULL DEFAULT 0);
 CREATE TABLE IF NOT EXISTS imports(
 	file_id INTEGER NOT NULL, kind TEXT NOT NULL, source TEXT NOT NULL, names TEXT NOT NULL, start INTEGER NOT NULL);
 CREATE TABLE IF NOT EXISTS exports(
@@ -510,6 +1398,10 @@ CREATE TABLE IF NOT EXISTS exports(
 var SECONDARY_INDEXES = `
 CREATE INDEX IF NOT EXISTS fn_file_start ON functions(file_id, start);
 CREATE INDEX IF NOT EXISTS fn_name ON functions(name);
+CREATE INDEX IF NOT EXISTS fn_qname ON functions(qname) WHERE qname IS NOT NULL;
+CREATE INDEX IF NOT EXISTS class_file ON classes(file_id, start);
+CREATE INDEX IF NOT EXISTS str_cut ON strings(file_id) WHERE cut > 0;
+CREATE INDEX IF NOT EXISTS call_unres ON calls(file_id) WHERE unres = 1;
 CREATE INDEX IF NOT EXISTS str_fn ON strings(fn_id);
 CREATE INDEX IF NOT EXISTS str_file ON strings(file_id, start);
 CREATE INDEX IF NOT EXISTS call_callee ON calls(callee);
@@ -699,9 +1591,24 @@ var Store = class _Store {
     this.db.exec(SECONDARY_INDEXES);
   }
   /** Every stored file at or under `scope` (a relative path; empty is all), keyed by path. */
-  storedFiles(scope) {
+  /**
+   * The files recorded at or under `scope`. With `shallow`, only the scope
+   * itself and its direct children, plus everything under the `vanished`
+   * subdirectories.
+   */
+  storedFiles(scope, only) {
     const map = /* @__PURE__ */ new Map();
-    const rows = scope === "" ? this.all("SELECT id, path, size, mtime_ms, hash FROM files") : this.all("SELECT id, path, size, mtime_ms, hash FROM files WHERE path = ? OR (path >= ? AND path < ?)", scope, `${scope}/`, `${scope}0`);
+    const select = "SELECT id, path, size, mtime_ms, hash FROM files";
+    const rows = [];
+    if (only) {
+      const prefix = scope === "" ? "" : `${scope}/`;
+      rows.push(...this.all(`${select} WHERE path = ? OR (path >= ? AND path < ? AND instr(substr(path, ?), '/') = 0)`, scope, prefix, scope === "" ? "\uFFFF" : `${scope}0`, Array.from(prefix).length + 1));
+      for (const v of only.vanished) {
+        rows.push(...this.all(`${select} WHERE path >= ? AND path < ?`, `${v}/`, `${v}0`));
+      }
+    } else {
+      rows.push(...scope === "" ? this.all(select) : this.all(`${select} WHERE path = ? OR (path >= ? AND path < ?)`, scope, `${scope}/`, `${scope}0`));
+    }
     for (const r of rows) {
       map.set(String(r.path), {
         id: Number(r.id),
@@ -712,12 +1619,23 @@ var Store = class _Store {
     }
     return map;
   }
+  /** Recorded directories directly below `scope`. */
+  childDirs(scope) {
+    const prefix = scope === "" ? "" : `${scope}/`;
+    return this.all("SELECT path FROM dirs WHERE path >= ? AND path < ? AND path != '' AND instr(substr(path, ?), '/') = 0", prefix, scope === "" ? "\uFFFF" : `${scope}0`, Array.from(prefix).length + 1).map((r) => String(r.path));
+  }
+  /** Forget a directory and everything recorded below it about what its walk saw. */
+  dropDirectoryRows(rel) {
+    for (const table of ["dirs", "excl"]) {
+      this.prepare(`DELETE FROM ${table} WHERE path = ? OR (path >= ? AND path < ?)`).run(rel, `${rel}/`, `${rel}0`);
+    }
+  }
   /** Remove a file and every row that hangs off it. */
   removeFile(fileId) {
     if (this.fts) {
       this.prepare("INSERT INTO lit(lit, rowid, value) SELECT 'delete', id, value FROM strings WHERE file_id = ? AND length(value) >= 3").run(fileId);
     }
-    for (const table of ["strings", "calls", "functions", "imports", "exports"]) {
+    for (const table of ["strings", "calls", "functions", "classes", "imports", "exports"]) {
       this.prepare(`DELETE FROM ${table} WHERE file_id = ?`).run(fileId);
     }
     this.prepare("DELETE FROM files WHERE id = ?").run(fileId);
@@ -753,23 +1671,28 @@ var Store = class _Store {
       }
       return lo + 1;
     }, "lineOf");
-    const result = this.prepare("INSERT INTO files(path, chars, lang, parse_errors, line_starts, size, mtime_ms, hash) VALUES(?,?,?,?,?,?,?,?)").run(record.path, record.chars, record.lang, record.parseErrors, encodeLineStarts(lineStarts2), record.size, record.mtimeMs, record.hash);
+    const result = this.prepare("INSERT INTO files(path, chars, lang, parse_errors, line_starts, size, mtime_ms, hash, degraded) VALUES(?,?,?,?,?,?,?,?,?)").run(record.path, record.chars, record.lang, record.parseErrors, encodeLineStarts(lineStarts2), record.size, record.mtimeMs, record.hash, record.degraded);
     const id = Number(result.lastInsertRowid);
     const remap = /* @__PURE__ */ __name((local) => local === null ? null : base + local, "remap");
-    const insFn = this.prepare("INSERT INTO functions VALUES(?,?,?,?,?,?,?,?,?)");
+    const insFn = this.prepare("INSERT INTO functions VALUES(?,?,?,?,?,?,?,?,?,?)");
     for (const f of rows.functions) {
-      insFn.run(base + f.id, id, remap(f.parentId), f.kind, f.name, f.start, f.end, lineOf(f.start), lineOf(f.end));
+      insFn.run(base + f.id, id, remap(f.parentId), f.kind, f.name, f.start, f.end, lineOf(f.start), lineOf(f.end), f.qname !== null && f.qname !== f.name ? f.qname : null);
     }
-    const insStr = this.prepare('INSERT INTO strings(file_id, fn_id, start, "end", kind, value) VALUES(?,?,?,?,?,?)');
+    const insClass = this.prepare("INSERT INTO classes VALUES(?,?,?,?)");
+    for (const c of rows.classes)
+      insClass.run(id, c.name, c.start, c.end);
+    const insStr = this.prepare('INSERT INTO strings(file_id, fn_id, start, "end", kind, value, cut) VALUES(?,?,?,?,?,?,?)');
     const insLit = this.fts ? this.prepare("INSERT INTO lit(rowid, value) VALUES(?, ?)") : void 0;
     for (const s of rows.strings) {
-      const r = insStr.run(id, remap(s.fnId), s.start, s.end, s.kind, s.value);
+      const r = insStr.run(id, remap(s.fnId), s.start, s.end, s.kind, s.value, s.cut);
       if (insLit && s.value.length >= 3)
         insLit.run(Number(r.lastInsertRowid), s.value);
     }
-    const insCall = this.prepare("INSERT INTO calls VALUES(?,?,?,?,?,?,?)");
-    for (const c of rows.calls)
-      insCall.run(id, remap(c.fnId), c.start, c.end, c.callee, c.kind, c.nargs);
+    const insCall = this.prepare("INSERT INTO calls VALUES(?,?,?,?,?,?,?,?,?)");
+    for (const c of rows.calls) {
+      const unresolved = c.callee === "?" || c.callee.endsWith("[]") ? 1 : 0;
+      insCall.run(id, remap(c.fnId), c.start, c.end, c.callee, c.kind, c.nargs, c.owner, unresolved);
+    }
     const insImp = this.prepare("INSERT INTO imports VALUES(?,?,?,?,?)");
     for (const i of rows.imports)
       insImp.run(id, i.kind, i.source, i.names, i.start);
@@ -817,7 +1740,11 @@ var DEFAULT_IGNORED_DIRS = [
   ".namzu",
   ".turbo",
   ".cache",
-  "coverage"
+  "coverage",
+  "dist",
+  "build",
+  "out",
+  ".next"
 ];
 var DEFAULT_MAX_FILE_BYTES = 32 * 1024 * 1024;
 var DEFAULT_MAX_FILES = 15e4;
@@ -826,6 +1753,26 @@ var DEFAULT_MAX_MILLIS = 45e3;
 var SLICE_MS = 20;
 var NAMED_LIMIT = 20;
 var decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+function truncationOf(limits, o) {
+  if (limits.size === 0)
+    return void 0;
+  const order = ["dirs", "files", "time"];
+  const kinds = order.filter((l) => limits.has(l));
+  const words = kinds.map((l) => l === "dirs" ? `after walking ${o.maxDirectories.toLocaleString("en-US")} directories` : l === "files" ? `at the ${o.maxFiles.toLocaleString("en-US")}-file limit` : `after ${Math.round(o.maxMillis / 1e3)} seconds`);
+  return { text: `stopped ${words.join(" and ")}`, limits: kinds };
+}
+__name(truncationOf, "truncationOf");
+function nextStep(limits) {
+  const time = limits?.includes("time") ?? false;
+  const reach = (limits ?? []).some((l) => l === "dirs" || l === "files");
+  if (time && reach) {
+    return "Call the index operation again to continue where the time ran out, and index a narrower path to reach what the directory or file limit cut off";
+  }
+  if (time)
+    return "Call the index operation again to continue where it stopped";
+  return "Call the index operation with a narrower path to cover the rest";
+}
+__name(nextStep, "nextStep");
 function decodeText(buffer) {
   const head = Math.min(buffer.length, 8192);
   for (let i = 0; i < head; i++)
@@ -842,107 +1789,11 @@ function hashOf(buffer) {
   return createHash2("sha1").update(buffer).digest("hex");
 }
 __name(hashOf, "hashOf");
-function toRel(root, abs) {
-  if (abs === root)
-    return "";
-  const prefix = root.endsWith(sep3) ? root : root + sep3;
-  if (!abs.startsWith(prefix))
-    return void 0;
-  return abs.slice(prefix.length).split(sep3).join("/");
-}
-__name(toRel, "toRel");
 function checkAbort(signal) {
   if (signal?.aborted)
     throw abortError();
 }
 __name(checkAbort, "checkAbort");
-function overTime(b) {
-  return performance.now() - b.started > b.options.maxMillis;
-}
-__name(overTime, "overTime");
-async function collect(root, start, b, skip) {
-  const walk = { files: [], dirs: [], truncated: void 0 };
-  const ignored = new Set(b.options.ignoreDirs);
-  let first;
-  try {
-    first = await lstat2(start);
-  } catch {
-    return walk;
-  }
-  const startRel = toRel(root, start) ?? "";
-  if (first.isSymbolicLink()) {
-    skip("symbolic link");
-    return walk;
-  }
-  if (first.isFile()) {
-    if (languageOf(start) !== void 0 && !isDeclarationFile(start))
-      walk.files.push({ rel: startRel, abs: start });
-    return walk;
-  }
-  if (!first.isDirectory())
-    return walk;
-  const pending = [{ abs: start, rel: startRel }];
-  let lastYield = performance.now();
-  let visited = 0;
-  while (pending.length > 0) {
-    checkAbort(b.signal);
-    if (visited >= b.options.maxDirectories) {
-      walk.truncated = `stopped after walking ${visited.toLocaleString("en-US")} directories`;
-      break;
-    }
-    if (overTime(b)) {
-      walk.truncated = `stopped after ${Math.round(b.options.maxMillis / 1e3)} seconds`;
-      break;
-    }
-    const dir = pending.pop();
-    visited++;
-    let entries;
-    try {
-      entries = await readdir2(dir.abs, { withFileTypes: true });
-      walk.dirs.push({ rel: dir.rel, mtimeMs: (await lstat2(dir.abs)).mtimeMs });
-    } catch {
-      skip("unreadable directory");
-      continue;
-    }
-    entries.sort((x, y) => x.name < y.name ? -1 : x.name > y.name ? 1 : 0);
-    const subdirs = [];
-    for (const entry of entries) {
-      const rel = dir.rel === "" ? entry.name : `${dir.rel}/${entry.name}`;
-      if (entry.isSymbolicLink()) {
-        if (languageOf(entry.name) !== void 0)
-          skip("symbolic link");
-        continue;
-      }
-      if (entry.isDirectory()) {
-        if (!ignored.has(entry.name))
-          subdirs.push({ abs: join3(dir.abs, entry.name), rel });
-        continue;
-      }
-      if (!entry.isFile() || languageOf(entry.name) === void 0)
-        continue;
-      if (isDeclarationFile(entry.name)) {
-        skip("declaration file");
-        continue;
-      }
-      if (walk.files.length >= b.options.maxFiles) {
-        walk.truncated = `stopped at the ${b.options.maxFiles.toLocaleString("en-US")}-file limit`;
-        break;
-      }
-      walk.files.push({ rel, abs: join3(dir.abs, entry.name) });
-    }
-    for (let i = subdirs.length - 1; i >= 0; i--)
-      pending.push(subdirs[i]);
-    if (walk.truncated)
-      break;
-    if (performance.now() - lastYield > SLICE_MS) {
-      await nextTurn();
-      lastYield = performance.now();
-    }
-  }
-  walk.files.sort((x, y) => x.rel < y.rel ? -1 : x.rel > y.rel ? 1 : 0);
-  return walk;
-}
-__name(collect, "collect");
 function jsonList(store, key) {
   try {
     const parsed = JSON.parse(store.meta(key) ?? "[]");
@@ -980,9 +1831,11 @@ async function refreshIndex(store, root, scopeAbs, options, host, signal) {
     }
   } catch {
   }
-  const walk = await collect(root, scopeAbs, budget, skip);
-  let truncated = walk.truncated;
-  const stored = store.storedFiles(scopeRel);
+  const shallow = options.shallow === true;
+  const walk = await collect(root, scopeAbs, budget, skip, shallow ? new Set(store.childDirs(scopeRel)) : void 0);
+  const limits = new Set(walk.limits);
+  const truncatedNow = /* @__PURE__ */ __name(() => truncationOf(limits, options), "truncatedNow");
+  const stored = shallow ? store.storedFiles(scopeRel, { shallow: true, vanished: walk.vanished }) : store.storedFiles(scopeRel);
   const seen = new Set(walk.files.map((f) => f.rel));
   let parsed = 0;
   let unchanged = 0;
@@ -1031,8 +1884,8 @@ async function refreshIndex(store, root, scopeAbs, options, host, signal) {
       queue(() => store.setMeta("violations", "[]"));
     for (const candidate of walk.files) {
       checkAbort(signal);
-      if (overTime(budget)) {
-        truncated ??= `stopped after ${Math.round(options.maxMillis / 1e3)} seconds`;
+      if (performance.now() - budget.started > options.maxMillis) {
+        limits.add("time");
         break;
       }
       const before = stored.get(candidate.rel);
@@ -1097,18 +1950,23 @@ async function refreshIndex(store, root, scopeAbs, options, host, signal) {
       if (result.kind === "rows") {
         const rowCount = result.rows.strings.length + result.rows.calls.length + result.rows.functions.length;
         queue(() => {
-          store.writeFile({ ...base, parseErrors: result.parseErrors, rows: result.rows });
+          store.writeFile({
+            ...base,
+            parseErrors: result.parseErrors,
+            degraded: result.degraded,
+            rows: result.rows
+          });
           unnote(store, "crashed", candidate.rel);
         }, rowCount);
         parsed++;
       } else if (result.kind === "crash") {
         queue(() => {
-          store.writeFile({ ...base, parseErrors: CRASHED, rows: EMPTY_ROWS });
+          store.writeFile({ ...base, parseErrors: CRASHED, degraded: 0, rows: EMPTY_ROWS });
           noteNamed(store, "crashed", candidate.rel);
         });
         skip("parser crashed");
       } else {
-        queue(() => store.writeFile({ ...base, parseErrors: 1, rows: EMPTY_ROWS }));
+        queue(() => store.writeFile({ ...base, parseErrors: 1, degraded: 0, rows: EMPTY_ROWS }));
         skip("parser failure");
       }
       changed = true;
@@ -1119,7 +1977,7 @@ async function refreshIndex(store, root, scopeAbs, options, host, signal) {
         lastYield = performance.now();
       }
     }
-    if (!walk.truncated) {
+    if (walk.limits.size === 0) {
       for (const [path, file] of stored) {
         if (seen.has(path))
           continue;
@@ -1134,16 +1992,30 @@ async function refreshIndex(store, root, scopeAbs, options, host, signal) {
       }
     }
     queue(() => {
-      if (!walk.truncated)
-        recordDirs(store, scopeRel, walk.dirs);
+      if (shallow) {
+        if (walk.limits.size === 0) {
+          for (const v of walk.vanished)
+            store.dropDirectoryRows(v);
+          recordDirs(store, scopeRel, walk.dirs, true);
+        }
+        recordExcluded(store, scopeRel, false, walk.dirs, walk.excluded);
+      } else {
+        if (walk.limits.size === 0)
+          recordDirs(store, scopeRel, walk.dirs);
+        recordExcluded(store, scopeRel, walk.limits.size === 0, walk.dirs, walk.excluded);
+      }
       store.ensureIndexes();
-      recordCoverage(store, scopeRel, skippedReasons, truncated);
+      if (options.quiet !== true)
+        recordCoverage(store, scopeRel, skippedReasons, truncatedNow());
     });
     await flush();
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
       try {
-        queue(() => recordCoverage(store, scopeRel, skippedReasons, "was cancelled before it finished", true));
+        queue(() => {
+          if (options.quiet !== true)
+            recordCoverage(store, scopeRel, skippedReasons, "was cancelled before it finished", true);
+        });
         dirty = true;
         await flush();
       } catch {
@@ -1154,11 +2026,29 @@ async function refreshIndex(store, root, scopeAbs, options, host, signal) {
     }
     throw err;
   }
-  return outcomeOf(store, skippedReasons, parsed, unchanged, removed, changed, truncated);
+  return outcomeOf(store, skippedReasons, parsed, unchanged, removed, changed, truncatedNow());
 }
 __name(refreshIndex, "refreshIndex");
-function recordDirs(store, scopeRel, dirs) {
-  if (scopeRel === "")
+function recordExcluded(store, scopeRel, finished, visited, rows) {
+  if (finished) {
+    if (scopeRel === "")
+      store.exec("DELETE FROM excl");
+    else
+      store.prepare("DELETE FROM excl WHERE path = ? OR (path >= ? AND path < ?)").run(scopeRel, `${scopeRel}/`, `${scopeRel}0`);
+  } else {
+    const del = store.prepare("DELETE FROM excl WHERE path = ?");
+    for (const d of visited)
+      del.run(d.rel);
+  }
+  const ins = store.prepare("INSERT OR REPLACE INTO excl(path, kind, name, n) VALUES(?, ?, ?, ?)");
+  for (const r of rows)
+    ins.run(r.path, r.kind, r.name, r.n);
+}
+__name(recordExcluded, "recordExcluded");
+function recordDirs(store, scopeRel, dirs, shallow = false) {
+  if (shallow)
+    store.prepare("DELETE FROM dirs WHERE path = ?").run(scopeRel);
+  else if (scopeRel === "")
     store.exec("DELETE FROM dirs");
   else
     store.prepare("DELETE FROM dirs WHERE path = ? OR (path >= ? AND path < ?)").run(scopeRel, `${scopeRel}/`, `${scopeRel}0`);
@@ -1178,7 +2068,7 @@ function outcomeOf(store, skippedReasons, parsed, unchanged, removed, changed, t
     withParseErrors: Number(counts.bad),
     indexed: Number(counts.indexed),
     changed,
-    ...truncated ? { truncated } : {}
+    ...truncated ? { truncated: truncated.text, limits: truncated.limits } : {}
   };
 }
 __name(outcomeOf, "outcomeOf");
@@ -1204,10 +2094,12 @@ function coveringEntry(covered, scopeRel) {
 }
 __name(coveringEntry, "coveringEntry");
 function recordCoverage(store, scopeRel, skipped, truncated, cancelled = false) {
+  const text = typeof truncated === "string" ? truncated : truncated?.text;
   const mine = {
     s: scopeRel,
     c: truncated ? 0 : 1,
-    ...truncated ? { r: truncated } : {},
+    ...text ? { r: text } : {},
+    ...typeof truncated === "object" ? { w: truncated.limits } : {},
     ...cancelled ? { k: "cancel" } : {}
   };
   let covered = readCovered(store);
@@ -1231,9 +2123,271 @@ function recordCoverage(store, scopeRel, skipped, truncated, cancelled = false)
 }
 __name(recordCoverage, "recordCoverage");
 
+// ../analysis/dist/collect.js
+var UNINDEXED_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".es",
+  ".es5",
+  ".es6",
+  ".jsm",
+  ".html",
+  ".htm",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".coffee"
+]);
+var MAY_HOLD_JS = UNINDEXED_CODE_EXTENSIONS;
+var BUILD_OUTPUT_NAMES = /* @__PURE__ */ new Set(["dist", "build", "out"]);
+function isDefaultList(list) {
+  return list.length === DEFAULT_IGNORED_DIRS.length && list.every((n, i) => n === DEFAULT_IGNORED_DIRS[i]);
+}
+__name(isDefaultList, "isDefaultList");
+var NEVER_SOURCE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  ".namzu"
+]);
+var SHEBANG_BYTES = 256;
+var MAX_GITIGNORE_BYTES = 1024 * 1024;
+var MAX_PATTERN_CHARS = 4096;
+var MAX_CHECKED_LINES = 5e3;
+var SLICE_MS2 = 20;
+var NODE_SHEBANG = /^#!\s*(?:\S*\/)?(?:env\s+(?:-\S+\s+)*)?(?:node|nodejs|bun|deno)(?:\s|$)/;
+function hasNodeShebang(head) {
+  if (head.length < 3 || head[0] !== 35 || head[1] !== 33)
+    return false;
+  const text = Buffer.from(head).toString("latin1");
+  const line = text.split(/\r?\n/, 1)[0] ?? "";
+  return NODE_SHEBANG.test(line);
+}
+__name(hasNodeShebang, "hasNodeShebang");
+function isExtensionless(name) {
+  return !name.slice(1).includes(".");
+}
+__name(isExtensionless, "isExtensionless");
+async function shebangOf(root, abs) {
+  const read = await readRegular(root, abs, SHEBANG_BYTES);
+  return read.ok && hasNodeShebang(read.buffer);
+}
+__name(shebangOf, "shebangOf");
+async function loadGitignore(root, abs, base) {
+  const read = await readRegular(root, join4(abs, ".gitignore"));
+  if (!read.ok || read.buffer.length > MAX_GITIGNORE_BYTES)
+    return void 0;
+  const text = read.buffer.toString("utf8");
+  const lines = text.split(/\r?\n/);
+  try {
+    if (lines.length > MAX_CHECKED_LINES)
+      return { base, ig: (0, import_ignore.default)().add(text) };
+    const kept = lines.filter((line) => {
+      if (line.length > MAX_PATTERN_CHARS)
+        return false;
+      try {
+        const probe = (0, import_ignore.default)().add(line);
+        probe.test("probe/path.js");
+        probe.test("probe/dir/");
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    return { base, ig: (0, import_ignore.default)().add(kept.join("\n")) };
+  } catch {
+    return void 0;
+  }
+}
+__name(loadGitignore, "loadGitignore");
+function gitIgnored(rules, rel, isDir) {
+  let ignored = false;
+  for (const { base, ig } of rules) {
+    const within = base === "" ? rel : rel.startsWith(`${base}/`) ? rel.slice(base.length + 1) : void 0;
+    if (within === void 0 || within === "")
+      continue;
+    let verdict;
+    try {
+      verdict = ig.test(isDir ? `${within}/` : within);
+    } catch {
+      continue;
+    }
+    if (verdict.unignored)
+      ignored = false;
+    else if (verdict.ignored)
+      ignored = true;
+  }
+  return ignored;
+}
+__name(gitIgnored, "gitIgnored");
+function ancestors(rel) {
+  if (rel === "")
+    return [""];
+  const parts = rel.split("/");
+  const out = [""];
+  for (let i = 1; i < parts.length; i++)
+    out.push(parts.slice(0, i).join("/"));
+  return out;
+}
+__name(ancestors, "ancestors");
+async function collect(root, start, b, skip, known) {
+  const walk = { files: [], dirs: [], limits: /* @__PURE__ */ new Set(), excluded: [], vanished: [] };
+  const ignored = new Set(b.options.ignoreDirs);
+  const conditional = isDefaultList(b.options.ignoreDirs);
+  const useGit = b.options.respectGitignore !== false;
+  const abortIfAsked = /* @__PURE__ */ __name(() => {
+    if (b.signal?.aborted)
+      throw abortError();
+  }, "abortIfAsked");
+  let first;
+  try {
+    first = await lstat3(start);
+  } catch {
+    return walk;
+  }
+  const startRel = toRel(root, start) ?? "";
+  if (first.isSymbolicLink()) {
+    skip("symbolic link");
+    return walk;
+  }
+  if (first.isFile()) {
+    if (languageOf(start) !== void 0) {
+      if (!isDeclarationFile(start))
+        walk.files.push({ rel: startRel, abs: start });
+    } else if (isExtensionless(basename(start)) && await shebangOf(root, start)) {
+      walk.files.push({ rel: startRel, abs: start });
+    }
+    return walk;
+  }
+  if (!first.isDirectory())
+    return walk;
+  const inherited = [];
+  if (useGit) {
+    for (const dir of ancestors(startRel)) {
+      if (dir === startRel)
+        break;
+      const rules = await loadGitignore(root, dir === "" ? root : join4(root, ...dir.split("/")), dir);
+      if (rules)
+        inherited.push(rules);
+    }
+  }
+  if (inherited.length > 0 && gitIgnored(inherited, startRel, true))
+    inherited.length = 0;
+  const pending = [{ abs: start, rel: startRel, rules: inherited }];
+  let lastYield = performance.now();
+  let visited = 0;
+  const tally2 = /* @__PURE__ */ new Map();
+  const note = /* @__PURE__ */ __name((path, kind, name) => {
+    const key = `${path}\0${kind}\0${name}`;
+    const row = tally2.get(key);
+    tally2.set(key, { path, kind, name, n: (row?.n ?? 0) + 1 });
+  }, "note");
+  while (pending.length > 0) {
+    abortIfAsked();
+    if (visited >= b.options.maxDirectories) {
+      walk.limits.add("dirs");
+      break;
+    }
+    if (performance.now() - b.started > b.options.maxMillis) {
+      walk.limits.add("time");
+      break;
+    }
+    const dir = pending.pop();
+    visited++;
+    let entries;
+    try {
+      const mtimeMs = (await lstat3(dir.abs)).mtimeMs;
+      entries = await readdir2(dir.abs, { withFileTypes: true });
+      walk.dirs.push({ rel: dir.rel, mtimeMs });
+    } catch {
+      skip("unreadable directory");
+      continue;
+    }
+    entries.sort((x, y) => x.name < y.name ? -1 : x.name > y.name ? 1 : 0);
+    let rules = dir.rules;
+    if (useGit && entries.some((e) => e.name === ".gitignore" && e.isFile())) {
+      const own = await loadGitignore(root, dir.abs, dir.rel);
+      if (own)
+        rules = [...rules, own];
+    }
+    const subdirs = [];
+    const hasPackageJson = entries.some((e) => e.name === "package.json" && e.isFile());
+    const kept = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      const rel = dir.rel === "" ? entry.name : `${dir.rel}/${entry.name}`;
+      if (entry.isSymbolicLink()) {
+        if (languageOf(entry.name) !== void 0)
+          skip("symbolic link");
+        continue;
+      }
+      if (entry.isDirectory()) {
+        const byName = ignored.has(entry.name) && !(conditional && BUILD_OUTPUT_NAMES.has(entry.name) && !hasPackageJson);
+        if (byName)
+          note(dir.rel, "dir", entry.name);
+        else if (rules.length > 0 && gitIgnored(rules, rel, true))
+          note(dir.rel, "git", `${entry.name}/`);
+        else if (known?.has(rel) && dir.rel === startRel)
+          kept.add(rel);
+        else
+          subdirs.push({ abs: join4(dir.abs, entry.name), rel, rules });
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      const abs = join4(dir.abs, entry.name);
+      const lang = languageOf(entry.name);
+      if (lang === void 0) {
+        const ext = extname(entry.name).toLowerCase();
+        if (UNINDEXED_CODE_EXTENSIONS.has(ext)) {
+          note(dir.rel, "ext", ext);
+        } else if (isExtensionless(entry.name) && await shebangOf(root, abs)) {
+          if (rules.length > 0 && gitIgnored(rules, rel, false))
+            note(dir.rel, "git", entry.name);
+          else if (walk.files.length >= b.options.maxFiles) {
+            walk.limits.add("files");
+            break;
+          } else
+            walk.files.push({ rel, abs });
+        }
+        continue;
+      }
+      if (isDeclarationFile(entry.name)) {
+        skip("declaration file");
+        note(dir.rel, "dts", "");
+        continue;
+      }
+      if (rules.length > 0 && gitIgnored(rules, rel, false)) {
+        note(dir.rel, "git", entry.name);
+        continue;
+      }
+      if (walk.files.length >= b.options.maxFiles) {
+        walk.limits.add("files");
+        break;
+      }
+      walk.files.push({ rel, abs });
+    }
+    for (let i = subdirs.length - 1; i >= 0; i--)
+      pending.push(subdirs[i]);
+    if (known && dir.rel === startRel) {
+      for (const k of known)
+        if (!kept.has(k))
+          walk.vanished.push(k);
+    }
+    if (walk.limits.has("files"))
+      break;
+    if (performance.now() - lastYield > SLICE_MS2) {
+      await nextTurn2();
+      lastYield = performance.now();
+    }
+  }
+  walk.files.sort((x, y) => x.rel < y.rel ? -1 : x.rel > y.rel ? 1 : 0);
+  walk.excluded.push(...tally2.values());
+  return walk;
+}
+__name(collect, "collect");
+
 // ../analysis/dist/context.js
 async function refreshFile(env, rel) {
-  await refreshIndex(env.store, env.root, join4(env.root, ...rel.split("/")), { ...env.options, force: false }, env.host, env.signal);
+  await refreshIndex(env.store, env.root, join5(env.root, ...rel.split("/")), { ...env.options, force: false }, env.host, env.signal);
 }
 __name(refreshFile, "refreshFile");
 var DEFAULT_LIMIT = 50;
@@ -1307,9 +2461,10 @@ var Files = class {
     return {
       id: Number(row.id),
       rel,
-      abs: join4(this.root, ...rel.split("/")),
+      abs: join5(this.root, ...rel.split("/")),
       chars: Number(row.chars),
       parseErrors: Number(row.parse_errors),
+      degraded: Number(row.degraded ?? 0),
       size: Number(row.size),
       mtimeMs: Number(row.mtime_ms),
       hash: String(row.hash),
@@ -1432,6 +2587,7 @@ function toFunction(row, info) {
   return {
     id: Number(row.id),
     name: row.name === null || row.name === void 0 ? null : String(row.name),
+    ...row.qname !== null && row.qname !== void 0 ? { qualifiedName: String(row.qname) } : {},
     kind: String(row.kind),
     path: info.abs,
     line: at.line,
@@ -1455,15 +2611,48 @@ function parentsOf(store, files, parentId) {
   return out;
 }
 __name(parentsOf, "parentsOf");
-function sliceOf(text, start, end, maxChars) {
+function safeEnd(text, at) {
+  const last = text.charCodeAt(at - 1);
+  return last >= 55296 && last <= 56319 ? at - 1 : at;
+}
+__name(safeEnd, "safeEnd");
+var HEADER_CHARS = 400;
+function sliceOf(text, start, end, maxChars, around) {
   const chars = end - start;
   if (chars <= maxChars)
     return { text: text.slice(start, end), chars, truncated: false };
-  let stop = start + maxChars;
-  const last = text.charCodeAt(stop - 1);
-  if (last >= 55296 && last <= 56319)
-    stop--;
-  return { text: text.slice(start, stop), chars, truncated: true };
+  if (around === void 0 || around < start || around >= end) {
+    return { text: text.slice(start, safeEnd(text, start + maxChars)), chars, truncated: true };
+  }
+  const header = Math.min(Math.floor(maxChars / 4), HEADER_CHARS);
+  const headerEnd = safeEnd(text, start + header);
+  const budget = maxChars - header;
+  let from = around - Math.floor(budget / 2);
+  let to = from + budget;
+  if (from < headerEnd) {
+    from = headerEnd;
+    to = from + budget;
+  }
+  if (to > end) {
+    to = end;
+    from = Math.max(headerEnd, to - budget);
+  }
+  const first = text.charCodeAt(from);
+  if (from > headerEnd && first >= 56320 && first <= 57343)
+    from--;
+  to = safeEnd(text, to);
+  const gapBefore = from - headerEnd;
+  const gapAfter = end - to;
+  const cut = text.slice(start, headerEnd) + (gapBefore > 0 ? `
+/* \u2026 ${gapBefore.toLocaleString("en-US")} characters omitted \u2026 */
+` : "") + text.slice(from, to) + (gapAfter > 0 ? `
+/* \u2026 ${gapAfter.toLocaleString("en-US")} characters omitted \u2026 */` : "");
+  return {
+    text: cut,
+    chars,
+    truncated: true,
+    window: { headerChars: headerEnd - start, from, to }
+  };
 }
 __name(sliceOf, "sliceOf");
 var BENIGN_SKIPS = /* @__PURE__ */ new Set(["declaration file", "symbolic link"]);
@@ -1480,6 +2669,17 @@ function named(list) {
   return list.length > 3 ? `${list.slice(0, 3).join(", ")} and ${list.length - 3} more` : list.join(", ");
 }
 __name(named, "named");
+function inScope(path, scopeRel) {
+  return scopeRel === "" || path === scopeRel || path.startsWith(`${scopeRel}/`);
+}
+__name(inScope, "inScope");
+function scopeWhere(scopeRel) {
+  return {
+    sql: "path = ? OR (path >= ? AND path < ?)",
+    params: [scopeRel, `${scopeRel}/`, `${scopeRel}0`]
+  };
+}
+__name(scopeWhere, "scopeWhere");
 function workspaceGaps(store, scopeRel = "") {
   const reasons = [];
   const covered = readCovered(store);
@@ -1493,7 +2693,7 @@ function workspaceGaps(store, scopeRel = "") {
   for (const e of covered) {
     if (e.c === 0 && (scopeRel === "" || e === covering)) {
       const where = e.s === "" ? "the root" : e.s;
-      reasons.push(e.k === "cancel" ? `indexing ${where} ${e.r}, so what was indexed is partial. Call the index operation to continue` : `indexing ${where} ${e.r ?? "stopped at a limit"}, so what was indexed is partial. Call the index operation with a narrower path to cover more`);
+      reasons.push(e.k === "cancel" ? `indexing ${where} ${e.r}, so what was indexed is partial. Call the index operation to continue` : `indexing ${where} ${e.r ?? "stopped at a limit"}, so what was indexed is partial. ${nextStep(e.w)}`);
     }
   }
   let skipped = {};
@@ -1514,49 +2714,201 @@ function workspaceGaps(store, scopeRel = "") {
   if (totals.size > 0) {
     reasons.push(`not indexed: ${[...totals].map(([why, n]) => `${n} ${why}`).join(", ")}`);
   }
-  const crashed = listOf(store, "crashed");
+  const excluded = exclusionReasons(store, scopeRel);
+  reasons.push(...excluded.gaps);
+  const scoped = scopeRel === "" ? void 0 : scopeWhere(scopeRel);
+  const and = scoped ? ` AND (${scoped.sql})` : "";
+  const crashed = store.all(`SELECT path FROM files WHERE parse_errors < 0${and} ORDER BY path`, ...scoped?.params ?? []).map((r) => String(r.path));
   if (crashed.length > 0) {
     reasons.push(`the parser crashed on ${crashed.length} file(s) (${named(crashed)}), which are recorded with no rows`);
   }
-  const violations = listOf(store, "violations");
+  const violations = listOf(store, "violations").filter((path) => inScope(path, scopeRel));
   if (violations.length > 0) {
     reasons.push(`${violations.length} file(s) (${named(violations)}) became a link or resolved outside the root after they were indexed, and were dropped without being read`);
   }
-  const bad = store.get("SELECT count(*) AS n FROM files WHERE parse_errors > 0");
+  const bad = store.get(`SELECT count(*) AS n, coalesce(sum(degraded = 1), 0) AS repaired, coalesce(sum(degraded = 2), 0) AS scanned FROM files WHERE parse_errors > 0${and}`, ...scoped?.params ?? []);
   if (bad && Number(bad.n) > 0) {
-    reasons.push(`${bad.n} file(s) had syntax errors; the parser kept whatever tree it could recover, often none, so rows from them may be missing`);
+    const repaired = Number(bad.repaired);
+    const scanned = Number(bad.scanned);
+    reasons.push(`${bad.n} file(s) had syntax errors, so rows from them may be missing${repaired > 0 ? `; ${repaired} read after setting the broken lines aside` : ""}${scanned > 0 ? `; ${scanned} degraded to a tolerant scan that finds strings and function declarations only, with no calls, methods or imports` : ""}`);
   }
-  return reasons;
+  return { gaps: reasons, notes: excluded.notes };
 }
 __name(workspaceGaps, "workspaceGaps");
-var NEW_FILE_CHECK_DIRS = 400;
-async function newFileReasons(store, root, scopeRel) {
-  const rows = scopeRel === "" ? store.all("SELECT path, mtime_ms FROM dirs ORDER BY path LIMIT ?", NEW_FILE_CHECK_DIRS + 1) : store.all("SELECT path, mtime_ms FROM dirs WHERE path = ? OR (path >= ? AND path < ?) ORDER BY path LIMIT ?", scopeRel, `${scopeRel}/`, `${scopeRel}0`, NEW_FILE_CHECK_DIRS + 1);
-  const changed = [];
-  for (const row of rows.slice(0, NEW_FILE_CHECK_DIRS)) {
-    const rel = String(row.path);
+function tally(rows, shown = 6) {
+  const sorted = [...rows].sort((a, b) => b.n - a.n || (a.name < b.name ? -1 : 1));
+  const head = sorted.slice(0, shown).map((r) => `${r.name || "(none)"} \xD7${r.n}`);
+  return sorted.length > shown ? `${head.join(", ")} and ${sorted.length - shown} more` : head.join(", ");
+}
+__name(tally, "tally");
+function exclusionReasons(store, scopeRel) {
+  const where = scopeRel === "" ? { sql: "", params: [] } : {
+    sql: " WHERE path = ? OR (path >= ? AND path < ?)",
+    params: [scopeRel, `${scopeRel}/`, `${scopeRel}0`]
+  };
+  let rows;
+  try {
+    rows = store.all(`SELECT kind, name, sum(n) AS n FROM excl${where.sql} GROUP BY kind, name`, ...where.params);
+  } catch {
+    return { gaps: [], notes: [] };
+  }
+  const pick = /* @__PURE__ */ __name((kind, keep = () => true) => rows.filter((r) => r.kind === kind && keep(String(r.name))).map((r) => ({ name: String(r.name), n: Number(r.n) })), "pick");
+  const isDefaultDir = /* @__PURE__ */ __name((name) => DEFAULT_IGNORED_DIRS.includes(name), "isDefaultDir");
+  const dirs = pick("dir");
+  const neverSource = dirs.filter((r) => NEVER_SOURCE_DIRS.has(r.name));
+  const buildDirs = dirs.filter((r) => !NEVER_SOURCE_DIRS.has(r.name) && isDefaultDir(r.name));
+  const ownDirs = dirs.filter((r) => !isDefaultDir(r.name));
+  const gitDirs = pick("git", (name) => name.endsWith("/"));
+  const gitFiles = pick("git", (name) => !name.endsWith("/"));
+  const exts = pick("ext");
+  const jsExts = exts.filter((r) => MAY_HOLD_JS.has(r.name));
+  const otherExts = exts.filter((r) => !MAY_HOLD_JS.has(r.name));
+  const dts = pick("dts").reduce((a, r) => a + r.n, 0);
+  const gaps = [];
+  const notes = [];
+  if (ownDirs.length > 0) {
+    gaps.push(`not indexed: ignored directories ${tally(ownDirs)}. To search one, pass its path to the index operation`);
+  }
+  if (gitFiles.length > 0) {
+    gaps.push(`not indexed: source files a .gitignore lists, ${tally(gitFiles)}. Index one by path to search it`);
+  }
+  if (jsExts.length > 0) {
+    gaps.push(`not indexed: files in languages this index does not parse (${tally(jsExts)}); a string in one cannot be found`);
+  }
+  const left = [...neverSource, ...buildDirs];
+  if (left.length > 0) {
+    notes.push(`left out as never or build-output directories: ${tally(left)} (to search one, pass its path to the index operation)`);
+  }
+  if (gitDirs.length > 0) {
+    notes.push(`left out as directories a .gitignore lists: ${tally(gitDirs)}`);
+  }
+  if (otherExts.length > 0) {
+    notes.push(`files in other languages are not parsed (${tally(otherExts)})`);
+  }
+  if (dts > 0) {
+    notes.push(`${dts} declaration file(s) (.d.ts) are not indexed; they hold types only, so no literal or call is missing, but a signature there cannot be shown`);
+  }
+  return { gaps, notes };
+}
+__name(exclusionReasons, "exclusionReasons");
+function coverageOf(reasons) {
+  return reasons.length === 0 ? { status: "complete" } : { status: "partial", reasons };
+}
+__name(coverageOf, "coverageOf");
+
+// ../analysis/dist/freshen.js
+import { lstatSync } from "node:fs";
+import { lstat as lstat4 } from "node:fs/promises";
+import { basename as basename2, join as join6 } from "node:path";
+import { setImmediate as nextTurn3 } from "node:timers/promises";
+var FEW_FILES = 25;
+var FEW_DIRS = 25;
+var FEW_BYTES = 16 * 1024 * 1024;
+var MAX_FILES_CHECKED = 25e4;
+var MAX_DIRS_CHECKED = 2e4;
+var SLICE_MS3 = 4;
+function scopeWhere2(column, scopeRel) {
+  if (scopeRel === "")
+    return { sql: "", params: [] };
+  return {
+    sql: ` WHERE ${column} = ? OR (${column} >= ? AND ${column} < ?)`,
+    params: [scopeRel, `${scopeRel}/`, `${scopeRel}0`]
+  };
+}
+__name(scopeWhere2, "scopeWhere");
+async function statAll(paths, visit) {
+  let sliceStart = performance.now();
+  for (let i = 0; i < paths.length; i++) {
+    let stats;
     try {
-      const s = await lstat3(join4(root, ...rel.split("/").filter(Boolean)));
-      if (s.mtimeMs !== Number(row.mtime_ms))
-        changed.push(rel === "" ? "." : rel);
+      stats = lstatSync(paths[i]);
     } catch {
-      changed.push(rel === "" ? "." : rel);
+      stats = void 0;
+    }
+    visit(i, stats);
+    if ((i & 63) === 63 && performance.now() - sliceStart > SLICE_MS3) {
+      await nextTurn3();
+      sliceStart = performance.now();
     }
   }
-  const reasons = [];
-  if (changed.length > 0) {
-    reasons.push(`${changed.length} director${changed.length === 1 ? "y" : "ies"} changed since the index was built (${named(changed)}), so files added there may be missing. Run the index operation to pick them up`);
+}
+__name(statAll, "statAll");
+function named2(list) {
+  return list.length > 3 ? `${list.slice(0, 3).join(", ")} and ${list.length - 3} more` : list.join(", ");
+}
+__name(named2, "named");
+async function freshenScope(env, scopeRel) {
+  const { store, root } = env;
+  const notes = [];
+  const gaps = [];
+  const fileScope = scopeWhere2("path", scopeRel);
+  const stored = store.all(`SELECT path, size, mtime_ms FROM files${fileScope.sql} LIMIT ?`, ...fileScope.params, MAX_FILES_CHECKED + 1);
+  const dirScope = scopeWhere2("path", scopeRel);
+  const dirRows = store.all(`SELECT path, mtime_ms FROM dirs${dirScope.sql} LIMIT ?`, ...dirScope.params, MAX_DIRS_CHECKED + 1);
+  const changedFiles = [];
+  const checkedFiles = stored.slice(0, MAX_FILES_CHECKED);
+  await statAll(checkedFiles.map((row) => join6(root, ...String(row.path).split("/"))), (i, s) => {
+    const row = checkedFiles[i];
+    if (!s)
+      changedFiles.push({ rel: String(row.path), size: 0 });
+    else if (!s.isFile() || s.size !== Number(row.size) || s.mtimeMs !== Number(row.mtime_ms))
+      changedFiles.push({ rel: String(row.path), size: s.size });
+  });
+  const changedDirs = [];
+  const checkedDirs = dirRows.slice(0, MAX_DIRS_CHECKED);
+  await statAll(checkedDirs.map((row) => join6(root, ...String(row.path).split("/").filter(Boolean))), (i, s) => {
+    const row = checkedDirs[i];
+    if (!s || s.mtimeMs !== Number(row.mtime_ms))
+      changedDirs.push(String(row.path));
+  });
+  if (scopeRel !== "" && !stored.some((r) => String(r.path) === scopeRel) && !dirRows.some((r) => String(r.path) === scopeRel)) {
+    const s = await lstat4(join6(root, ...scopeRel.split("/"))).catch(() => void 0);
+    if (s?.isFile()) {
+      const source = languageOf(scopeRel) !== void 0 || isExtensionless(basename2(scopeRel)) && await shebangOf(root, join6(root, ...scopeRel.split("/")));
+      if (source)
+        changedFiles.push({ rel: scopeRel, size: s.size });
+    } else if (s?.isDirectory())
+      changedDirs.push(scopeRel);
+  }
+  if (stored.length > MAX_FILES_CHECKED || dirRows.length > MAX_DIRS_CHECKED) {
+    gaps.push(`only the first ${checkedFiles.length.toLocaleString("en-US")} files and ${checkedDirs.length.toLocaleString("en-US")} directories were compared with the disk, so later edits may be missing. Run the index operation`);
+  }
+  if (changedFiles.length === 0 && changedDirs.length === 0)
+    return { notes, gaps };
+  const bytes = changedFiles.reduce((a, f) => a + f.size, 0);
+  const few = changedFiles.length <= FEW_FILES && changedDirs.length <= FEW_DIRS && bytes <= FEW_BYTES;
+  if (!few) {
+    const files = changedFiles.map((f) => f.rel).sort();
+    const parts = [];
+    if (files.length > 0) {
+      parts.push(`${files.length} file(s) changed since indexing (${named2(files)})`);
+    }
+    if (changedDirs.length > 0) {
+      parts.push(`${changedDirs.length} director${changedDirs.length === 1 ? "y" : "ies"} changed since indexing (${named2([...changedDirs].sort().map((d) => d || "."))}), so files added there may be missing`);
+    }
+    gaps.push(`${parts.join("; ")}; too many to re-read for one query. Run the index operation to refresh`);
+    return { notes, gaps };
+  }
+  const dirs = [...new Set(changedDirs)].sort();
+  const dirSet = new Set(dirs);
+  const parentOf = /* @__PURE__ */ __name((rel) => rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : "", "parentOf");
+  const lone = changedFiles.map((f) => f.rel).filter((rel) => !dirSet.has(parentOf(rel)));
+  let incomplete;
+  for (const target of [...dirs, ...lone]) {
+    const abs = target === "" ? root : join6(root, ...target.split("/"));
+    if (toRel(root, abs) === void 0)
+      continue;
+    const out = await refreshIndex(store, root, abs, { ...env.options, force: false, quiet: true, shallow: dirSet.has(target) }, env.host, env.signal);
+    incomplete ??= out.truncated;
   }
-  if (rows.length > NEW_FILE_CHECK_DIRS) {
-    reasons.push(`only the first ${NEW_FILE_CHECK_DIRS} directories were checked for new files`);
+  const total = changedFiles.length + changedDirs.length;
+  notes.push(`${changedFiles.length} file(s) and ${changedDirs.length} director${changedDirs.length === 1 ? "y" : "ies"} had changed since the index was built and were re-read before this answer`);
+  if (incomplete) {
+    gaps.push(`the re-read of ${total} changed path(s) ${incomplete}, so the answer may miss recent edits. Run the index operation`);
   }
-  return reasons;
-}
-__name(newFileReasons, "newFileReasons");
-function coverageOf(reasons) {
-  return reasons.length === 0 ? { status: "complete" } : { status: "partial", reasons };
+  return { notes, gaps };
 }
-__name(coverageOf, "coverageOf");
+__name(freshenScope, "freshenScope");
 
 // ../analysis/dist/provider.js
 var failed = /* @__PURE__ */ __name((error) => ({ kind: "failed", error }), "failed");
@@ -1580,6 +2932,7 @@ function createCodeAnalysisProvider(options = {}) {
     maxFiles: options.maxFiles ?? DEFAULT_MAX_FILES,
     maxDirectories: options.maxDirectories ?? DEFAULT_MAX_DIRECTORIES,
     maxMillis: options.maxMillis ?? DEFAULT_MAX_MILLIS,
+    respectGitignore: options.respectGitignore !== false,
     force
   }), "indexOptions");
   const envOf = /* @__PURE__ */ __name((o, signal, force = false) => ({
@@ -1651,7 +3004,7 @@ function createCodeAnalysisProvider(options = {}) {
       return void 0;
     if (coveringEntry(readCovered(env.store), rel))
       return void 0;
-    if (rel !== "" && !await lstat4(scopeAbs).then(() => true, () => false))
+    if (rel !== "" && !await lstat5(scopeAbs).then(() => true, () => false))
       return void 0;
     const started = performance.now();
     const out = await refreshIndex(env.store, env.root, scopeAbs, env.options, env.host, env.signal);
@@ -1659,7 +3012,7 @@ function createCodeAnalysisProvider(options = {}) {
   }
   __name(ensureCovered, "ensureCovered");
   const evidence = /* @__PURE__ */ __name((observed, inferred, gaps, built) => ({
-    observed: built ? [...observed, built] : observed,
+    observed: built === void 0 || built === "" ? observed : [...observed, ...typeof built === "string" ? [built] : built],
     inferred,
     coverage: coverageOf(gaps)
   }), "evidence");
@@ -1672,7 +3025,7 @@ function createCodeAnalysisProvider(options = {}) {
     if (info)
       return info;
     return {
-      error: `${rel} is not in the index. Only .js .mjs .cjs .jsx .ts .mts .cts .tsx files are indexed, and not declaration files, symbolic links, files in ignored directories (${(options.ignoreDirs ?? DEFAULT_IGNORED_DIRS).join(", ")}), or files that are binary, too large or unparseable.`
+      error: `${rel} is not in the index. Only .js .mjs .cjs .jsx .ts .mts .cts .tsx files (and extension-less scripts that start with a node, bun or deno shebang) are indexed, and not declaration files, symbolic links, files in ignored directories (${(options.ignoreDirs ?? DEFAULT_IGNORED_DIRS).join(", ")}), files a .gitignore lists, or files that are binary, too large or unparseable.`
     };
   }
   __name(fileAt, "fileAt");
@@ -1726,6 +3079,7 @@ function createCodeAnalysisProvider(options = {}) {
         if (scopeRel === void 0)
           return failed(`${scopeAbs} is outside the indexed root ${o.root}.`);
         const out = await refreshIndex(o.store, o.root, scopeAbs, indexOptions(request.force === true), host, signal);
+        const left = workspaceGaps(o.store, scopeRel);
         const count = /* @__PURE__ */ __name((table) => Number(o.store.get(`SELECT count(*) AS n FROM ${table}`).n), "count");
         const summary = {
           root: o.root,
@@ -1744,29 +3098,37 @@ function createCodeAnalysisProvider(options = {}) {
           calls: count("calls"),
           durationMs: Math.round(performance.now() - started),
           ...out.truncated ? {
-            truncated: `Indexing ${scopeRel === "" ? "the root" : scopeRel} ${out.truncated}, so the index is partial. Index a narrower path to cover the rest; what was indexed is kept and answers queries now.`
+            truncated: `Indexing ${scopeRel === "" ? "the root" : scopeRel} ${out.truncated}, so the index is partial. ${nextStep(out.limits)}; what was indexed is kept and answers queries now.`
           } : {}
         };
         return {
           kind: "ok",
           value: summary,
           evidence: evidence([
-            `walked ${scopeRel === "" ? o.root : scopeRel}: ${out.parsed} file(s) parsed, ${out.unchanged} unchanged by size, mtime or content hash, ${out.removed} removed`
+            `walked ${scopeRel === "" ? o.root : scopeRel}: ${out.parsed} file(s) parsed, ${out.unchanged} unchanged by size, mtime or content hash, ${out.removed} removed`,
+            ...left.notes
           ], o.store.fts ? [] : [
             "this Node.js has no FTS5, so find_literal scans every literal instead of using a substring index; answers are the same, slower"
-          ], workspaceGaps(o.store, scopeRel))
+          ], left.gaps)
         };
       });
     },
-    findLiteral: /* @__PURE__ */ __name((request) => withScope(request.root, request.path, request.signal, async (o, _env, built) => {
+    findLiteral: /* @__PURE__ */ __name((request) => withScope(request.root, request.path, request.signal, async (o, env, built) => {
       const files = new Files(o.store, o.root);
+      if (CUT_MARK_CHARS.some((c) => request.text.includes(c))) {
+        return failed("the search text contains U+0001 or U+0002, which the index uses to mark where a long literal was cut; they cannot be searched for");
+      }
+      const asked = request.path === void 0 ? "" : toRel(o.root, request.path);
+      if (asked === void 0)
+        return failed(`${request.path} is outside the indexed root ${o.root}.`);
+      const current = await freshenScope(env, asked);
       const scope = scopeSql(o, files, request.path, "s.file_id");
       if ("error" in scope)
         return failed(scope.error);
       const limit = clampLimit(request.limit);
       const insensitive = request.caseSensitive === false;
       const codePoints = Array.from(request.text).length;
-      const useFts = o.store.fts && codePoints >= 3;
+      const useFts = o.store.fts && codePoints >= 3 && !request.text.includes("\0");
       const test = insensitive ? "instr(lower(s.value), lower(?)) > 0" : "instr(s.value, ?) > 0";
       const prefilter = useFts ? " AND s.id IN (SELECT rowid FROM lit WHERE lit MATCH ?)" : "";
       const where = `WHERE ${test}${prefilter}${scope.sql}`;
@@ -1820,7 +3182,7 @@ function createCodeAnalysisProvider(options = {}) {
           start: Number(r.start),
           end: Number(r.end),
           kind: String(r.kind),
-          value: value.length > PREVIEW_CHARS ? value.slice(0, PREVIEW_CHARS) : value,
+          value: previewOf(value, request.text, insensitive),
           valueTruncated: value.length > PREVIEW_CHARS,
           ...fn ? { function: fn } : {},
           ...mark ? { stale: mark } : {}
@@ -1832,6 +3194,7 @@ function createCodeAnalysisProvider(options = {}) {
         total,
         ...next < total ? { nextCursor: encodeCursor({ g: generation, o: next, q }) } : {}
       };
+      const left = workspaceGaps(o.store, scope.rel);
       return {
         kind: "ok",
         value: page,
@@ -1839,12 +3202,15 @@ function createCodeAnalysisProvider(options = {}) {
           `${total} string or template literal(s) contain ${JSON.stringify(request.text)}${insensitive ? " (ASCII case-insensitive)" : ""}`,
           "each hit lists the innermost function whose source range contains it"
         ], [
-          "literals are indexed up to 4096 characters, and a template literal is indexed per static chunk, so a match cannot span a ${...} or sit past the cut"
+          "a template literal is indexed per static chunk, so a match cannot span a ${...}; a literal over 8192 characters is indexed by its first and last 4096"
         ], [
-          ...workspaceGaps(o.store, scope.rel),
+          ...left.gaps,
           ...markReasons(fresh.marks),
-          ...await newFileReasons(o.store, o.root, scope.rel)
-        ], built)
+          // One character is not a search for a passage; what a cut literal
+          // dropped is only worth reporting for a needle that could be in it.
+          ...codePoints > 1 ? cutReasons(o.store, scope.sql, scope.params) : [],
+          ...current.gaps
+        ], [...left.notes, ...built ? [built] : [], ...current.notes])
       };
     }), "findLiteral"),
     enclosingFunction: /* @__PURE__ */ __name((request) => withScope(request.root, request.path, request.signal, async (o, env, built) => {
@@ -1866,12 +3232,19 @@ function createCodeAnalysisProvider(options = {}) {
         ...built ? [built] : []
       ];
       if (!row) {
+        const cls = o.store.get('SELECT name FROM classes WHERE file_id = ? AND start <= ? AND "end" > ? ORDER BY start DESC LIMIT 1', info.id, at.offset, at.offset);
+        const place = `${info.rel}:${request.line}:${request.column ?? 1}`;
+        const className = cls && cls.name !== null ? String(cls.name) : void 0;
         return {
           kind: "ok",
-          value: { function: null, parents: [] },
+          value: {
+            function: null,
+            parents: [],
+            ...cls ? { inClass: className ?? "(anonymous class)" } : {}
+          },
           evidence: {
             observed: [
-              `${info.rel}:${request.line}:${request.column ?? 1} lies in no function body; it is at the top level of the file`,
+              cls ? `${place} is in the body of class ${className ?? "(anonymous)"} outside every method (a field initializer or a static block), not in a function` : `${place} lies in no function body; it is at the top level of the file`,
               ...notes
             ],
             inferred: [],
@@ -1886,7 +3259,7 @@ function createCodeAnalysisProvider(options = {}) {
         value: {
           function: fn,
           parents,
-          source: sliceOf(text, fn.start, fn.end, clampChars(request.maxChars))
+          source: sliceOf(text, fn.start, fn.end, clampChars(request.maxChars), at.offset)
         },
         evidence: {
           observed: [
@@ -1941,8 +3314,8 @@ function createCodeAnalysisProvider(options = {}) {
           if ("error" in fresh)
             return failed(fresh.error);
           info = fresh.info;
-          total = Number(o.store.get("SELECT count(*) AS n FROM functions WHERE file_id = ? AND name = ?", info.id, request.name).n);
-          rows = o.store.all("SELECT * FROM functions WHERE file_id = ? AND name = ? ORDER BY start LIMIT ? OFFSET ?", info.id, request.name, limit, cursor.offset);
+          total = Number(o.store.get("SELECT count(*) AS n FROM functions WHERE file_id = ? AND (name = ? OR qname = ?)", info.id, request.name, request.name).n);
+          rows = o.store.all("SELECT * FROM functions WHERE file_id = ? AND (name = ? OR qname = ?) ORDER BY start LIMIT ? OFFSET ?", info.id, request.name, request.name, limit, cursor.offset);
         } else {
           return failed("functionSource needs `id`, or `path` together with `name`.");
         }
@@ -1951,12 +3324,15 @@ function createCodeAnalysisProvider(options = {}) {
         });
         if ("error" in verified)
           return failed(verified.error);
+        const aroundOffset = request.around ? offsetOf(verified.info.starts, verified.info.chars, request.around.line, request.around.column ?? 1) : void 0;
+        if (aroundOffset && "error" in aroundOffset)
+          return failed(`${verified.info.rel}: ${aroundOffset.error}`);
         const items = rows.map((row) => {
           const fn = toFunction(row, verified.info);
           return {
             function: fn,
             parents: parentsOf(o.store, files, row.parent_id === null ? null : Number(row.parent_id)),
-            source: sliceOf(verified.text, fn.start, fn.end, maxChars)
+            source: sliceOf(verified.text, fn.start, fn.end, maxChars, aroundOffset?.offset)
           };
         });
         const next = cursor.offset + items.length;
@@ -2000,6 +3376,12 @@ function createCodeAnalysisProvider(options = {}) {
           gaps.push(...fileGaps(fresh.info));
           scoped = { sql: " AND c.file_id = ?", params: [fresh.info.id] };
         } else {
+          const asked = request.path === void 0 ? "" : toRel(o.root, request.path);
+          if (asked === void 0)
+            return failed(`${request.path} is outside the indexed root ${o.root}.`);
+          const current = await freshenScope(env, asked);
+          notes.push(...current.notes);
+          gaps.push(...current.gaps);
           const s = scopeSql(o, files, request.path, "c.file_id");
           if ("error" in s)
             return failed(s.error);
@@ -2007,10 +3389,17 @@ function createCodeAnalysisProvider(options = {}) {
           scopeRel = s.rel;
         }
         const limit = clampLimit(request.limit);
-        const test = member ? "(c.callee = ? OR (length(c.callee) > length(?) AND substr(c.callee, -(length(?) + 1)) = '.' || ?))" : "c.callee = ?";
-        const testParams = member ? [request.name, request.name, request.name, request.name] : [request.name];
+        const dot = request.name.lastIndexOf(".");
+        const method = dot > 0 && !request.name.startsWith("this.") && o.store.get("SELECT 1 AS x FROM functions WHERE qname = ? LIMIT 1", request.name) !== void 0 ? { cls: request.name.slice(0, dot), member: request.name.slice(dot + 1) } : void 0;
+        const suffix = `.${method ? method.member : request.name}`;
+        const endsWith = "(length(c.callee) > ? AND substr(c.callee, -?) = ?)";
+        const test = method ? `(c.callee = ? OR ${endsWith})` : member ? `(c.callee = ? OR ${endsWith})` : "c.callee = ?";
+        const testParams = method || member ? [request.name, suffix.length, suffix.length, suffix] : [request.name];
         const where = `WHERE ${test}${scoped.sql}`;
         const params = [...testParams, ...scoped.params];
+        const resolvedTest = method ? "(c.callee = ? OR (c.callee = 'this.' || ? AND c.owner = ?))" : void 0;
+        const resolvedParams = method ? [request.name, method.member, method.cls] : [];
+        const tierSql = resolvedTest ? `CASE WHEN ${resolvedTest} THEN 0 ELSE 1 END` : "0";
         let offset = 0;
         let rows = [];
         let total = 0;
@@ -2025,7 +3414,7 @@ function createCodeAnalysisProvider(options = {}) {
             return failed(cursor.error);
           offset = cursor.offset;
           total = Number(o.store.get(`SELECT count(*) AS n FROM calls c ${where}`, ...params).n);
-          rows = o.store.all(`SELECT c.rowid AS rid, c.file_id, c.fn_id, c.start, c.callee, c.kind, c.nargs FROM calls c ${where} ORDER BY c.rowid LIMIT ? OFFSET ?`, ...params, limit, offset);
+          rows = o.store.all(`SELECT c.rowid AS rid, c.file_id, c.fn_id, c.start, c.callee, c.kind, c.nargs, ${tierSql} AS tier FROM calls c ${where} ORDER BY tier, c.rowid LIMIT ? OFFSET ?`, ...resolvedParams, ...params, limit, offset);
           freshness = await checkFreshness(o.store, files, o.root, rows.map((r) => Number(r.file_id)));
           if (freshness.dropped.length === 0)
             break;
@@ -2055,12 +3444,23 @@ function createCodeAnalysisProvider(options = {}) {
             callee: String(r.callee),
             kind: String(r.kind),
             argumentCount: Number(r.nargs),
+            ...method ? { resolution: Number(r.tier) === 0 ? "resolved" : "text-only" } : {},
             ...caller ? { caller } : {},
             ...mark ? { stale: mark } : {}
           };
         });
+        const unresolved = Number(o.store.get(`SELECT count(*) AS n FROM calls c WHERE c.unres = 1${scoped.sql}`, ...scoped.params).n);
+        const callsInScope = Number(o.store.get(`SELECT count(*) AS n FROM calls c WHERE 1 = 1${scoped.sql}`, ...scoped.params).n);
+        if (unresolved > 0 && total === 0) {
+          gaps.push(`no static call to ${JSON.stringify(request.name)} found; ${unresolved} call(s) in scope use a computed callee and could reach it`);
+        } else if (unresolved > 0 && unresolved >= callsInScope * UNRESOLVED_SHARE) {
+          gaps.push(`${unresolved} of ${callsInScope} calls in scope use a computed callee (${Math.round(unresolved / callsInScope * 100)}%), so a call to ${JSON.stringify(request.name)} made through one of them is not in these results`);
+        }
+        const resolvedCount = method ? Number(o.store.get(`SELECT count(*) AS n FROM calls c ${where} AND ${resolvedTest}`, ...params, ...resolvedParams).n) : 0;
         if (scope === "workspace") {
-          gaps.push(...workspaceGaps(o.store, scopeRel), ...markReasons(freshness.marks), ...await newFileReasons(o.store, o.root, scopeRel));
+          const left = workspaceGaps(o.store, scopeRel);
+          gaps.push(...left.gaps, ...markReasons(freshness.marks));
+          notes.push(...left.notes);
         } else {
           gaps.push(...markReasons(freshness.marks));
         }
@@ -2074,11 +3474,15 @@ function createCodeAnalysisProvider(options = {}) {
             ...next < total ? { nextCursor: encodeCursor({ g: generation, o: next, q }) } : {}
           },
           evidence: evidence([
-            `${total} call expression(s) whose callee text is ${member ? `${JSON.stringify(request.name)} or ends in .${request.name}` : JSON.stringify(request.name)}, in ${distinct} file(s)`,
+            method ? `${total} call expression(s) of ${JSON.stringify(request.name)} or of a .${method.member}() on some other receiver, in ${distinct} file(s): ${resolvedCount} resolved (this.${method.member}() inside ${method.cls}, or the qualified text), ${total - resolvedCount} text-only` : `${total} call expression(s) whose callee text is ${member ? `${JSON.stringify(request.name)} or ends in .${request.name}` : JSON.stringify(request.name)}, in ${distinct} file(s)`,
+            `${unresolved} of ${callsInScope} calls in scope use a computed callee`,
             ...notes
           ], [
             "callers are matched by the callee TEXT, not by scope or binding: two unrelated functions called by the same name are the same callee here",
-            "a call through an alias, a destructured binding, .call/.apply or computed access (obj[name]()) is not matched",
+            '(0, a.b)() is read as a.b() and obj["b"]() as obj.b(); f.call(), f.apply() and f.bind() are listed as call-via and tagged templates as tagged; a call through an alias, a destructured binding or a computed key that is not a string literal is not matched',
+            ...method ? [
+              `${request.name} is a method: only this.${method.member}() inside ${method.cls} is resolved. A text-only match may be a different class's ${method.member}, or a subclass's; the receiver's type is not known`
+            ] : [],
             ...scope === "workspace" && distinct > 1 ? [
               `the matches span ${distinct} files and may be different functions that share a name`
             ] : []
@@ -2157,6 +3561,25 @@ function createCodeAnalysisProvider(options = {}) {
   return provider;
 }
 __name(createCodeAnalysisProvider, "createCodeAnalysisProvider");
+function previewOf(value, needle, insensitive) {
+  if (value.length <= PREVIEW_CHARS)
+    return value;
+  const at = insensitive ? value.toLowerCase().indexOf(needle.toLowerCase()) : value.indexOf(needle);
+  if (at < 0 || at + needle.length <= PREVIEW_CHARS)
+    return value.slice(0, PREVIEW_CHARS);
+  const from = Math.max(0, Math.min(at - 60, value.length - PREVIEW_CHARS));
+  const first = value.charCodeAt(from);
+  return value.slice(first >= 56320 && first <= 57343 ? from + 1 : from, from + PREVIEW_CHARS);
+}
+__name(previewOf, "previewOf");
+var UNRESOLVED_SHARE = 0.05;
+function cutReasons(store, scopeSql, params) {
+  const n = Number(store.get(`SELECT count(*) AS n FROM strings s WHERE s.cut > 0${scopeSql}`, ...params).n);
+  return n === 0 ? [] : [
+    `${n} literal(s) in scope are longer than 8192 characters and keep only their first and last 4096, so a match in the middle of one cannot be found`
+  ];
+}
+__name(cutReasons, "cutReasons");
 function fileGaps(info) {
   if (info.parseErrors < 0) {
     return [
@@ -2165,7 +3588,7 @@ function fileGaps(info) {
   }
   if (info.parseErrors > 0) {
     return [
-      `${info.rel} had syntax errors; the parser kept whatever tree it could recover, which is often none, so rows from it may be missing`
+      info.degraded === 2 ? `${info.rel} had syntax errors and was read by a tolerant scan: strings and function declarations only, no calls, methods or imports` : info.degraded === 1 ? `${info.rel} had syntax errors; it was read after setting the broken lines aside, so rows from those lines are missing` : `${info.rel} had syntax errors; the parser kept whatever tree it could recover, which is often none, so rows from it may be missing`
     ];
   }
   return [];
@@ -2179,4 +3602,4 @@ export {
   DEFAULT_MAX_MILLIS,
   createCodeAnalysisProvider
 };
-//# sourceMappingURL=dist-KGLSBIES.js.map
+//# sourceMappingURL=dist-ADL22Y3L.js.map