@mrclrchtr/supi-lsp 8.0.1 → 9.0.0

package/node_modules/ignore/legacy.js

@@ -1,19 +1,17 @@
 "use strict";
 
-var _TRAILING_WILD_CARD_R;
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 // A simple implementation of make-array
 function makeArray(subject) {
   return Array.isArray(subject) ? subject : [subject];
@@ -26,12 +24,7 @@ var ESCAPE = '\\';
 // The characters that carry a meaning of their own inside a regular
 //   expression, so a literal one has to be escaped before it is emitted.
 var REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
-// A line of only spaces is blank -- the trailing-space trimming empties it --
-//   but a line holding a tab is a pattern for a tab-named path, since git
-//   never trims a tab.
-// A leading BOM is removed during compilation, so reject a line that would
-//   become empty after removing it and trimming spaces.
-var REGEX_TEST_BLANK_LINE = /^\uFEFF? *$/;
+var BOM = "\uFEFF";
 var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
 var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
 var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
@@ -245,6 +238,11 @@ var REGEX_RESTORE_PLACEHOLDER = new RegExp("".concat(PLACEHOLDER, "(\\d+)").conc
 //   into a `RegExp` -- `_make` always turns it back into a real wildcard first.
 var TRAILING_WILDCARD = "\uE000";
 
+// A trailing "/**" is deferred the same way, because `checkRegex` has to tell
+//   it apart from a trailing "/*" (see `checkSourceOf`). For `.ignores()` it
+//   still never matches the folder itself (#21).
+var TRAILING_DOUBLESTAR = "\uE001";
+
 // Replace every bracket expression with a placeholder the replacers below
 //   leave alone, and translate it separately.
 var extractBrackets = function extractBrackets(pattern) {
@@ -272,10 +270,13 @@ var extractBrackets = function extractBrackets(pattern) {
       //   wildcard by `TRAILING_WILDCARD` and the wildcard replacers), `\[`
       //   (a literal bracket, the one `[` the bracket replacer still expects),
       //   `\ ` (a quoted trailing space), and `\\` (a literal backslash). A
-      //   lone trailing backslash never reaches here -- `checkPattern` throws
-      //   it out first.
+      //   lone trailing backslash can reach here after line-ending cleanup.
       var escaped = pattern[index + 1];
-      if (escaped === '*' || escaped === '[' || escaped === SPACE || escaped === ESCAPE) {
+      if (escaped === UNDEFINED || escaped === SLASH && index + 2 === length) {
+        // Git removes a final directory slash before matching. An escape
+        //   without a character after that removal makes the pattern invalid.
+        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);
@@ -349,33 +350,7 @@ var REGEX_INNER_SLASH = /\/(?!$)/;
 //   that then finds nothing -- for the wildcard step, whose `[^\\]+`
 //   backtracks its way through the whole string before giving up, 11ns
 //   against 400ns.
-var REPLACERS = [[
-// Remove BOM
-// TODO:
-// Other similar zero-width characters?
-/^\uFEFF/, function () {
-  return EMPTY;
-}, "\uFEFF"], [
-// A trailing line terminator, left on when a whole file's contents are
-//   added as one pattern rather than split into lines. git never sees one
-//   -- it reads a `.gitignore` line by line -- so it is not part of the
-//   pattern and is dropped here, apart from the trailing-space trimming,
-//   which follows git in touching spaces and nothing else.
-/[\r\n]+$/, function () {
-  return EMPTY;
-}],
-// > Trailing spaces are ignored unless they are quoted with backslash ("\")
-[
-// Only spaces, never tabs or other whitespace: git trims a trailing run
-//   of `' '` and nothing else (dir.c, `trim_trailing_spaces`, a single
-//   `case ' '`), so a pattern ending in a tab keeps it as a literal.
-// (a\ ) -> (a )
-// (a  ) -> (a)
-// (a ) -> (a)
-// (a \ ) -> (a  )
-/((?:\\\\)*?)(\\? +)$/, function (_, m1, m2) {
-  return m1 + (m2.indexOf('\\') === 0 ? SPACE : EMPTY);
-}],
+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
@@ -383,10 +358,13 @@ var REPLACERS = [[
 // (\ ) -> ' '
 // (\\ ) -> '\\ '
 // (\\\ ) -> '\\ '
-[/(\\+?) /g, function (_, m1) {
-  var length = m1.length;
-  return m1.slice(0, length - length % 2) + 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, function (_, run, space) {
+  return 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.
 
@@ -494,8 +472,9 @@ function (_, index, str) {
   // case: /**
   // > A trailing `"/**"` matches everything inside.
 
-  // #21: everything inside but it should not include the current folder
-  : '\\/.+';
+  // #21: everything inside but it should not include the current folder,
+  //   resolved by `_make`
+  : "\\/".concat(TRAILING_DOUBLESTAR);
 }, '*'],
 // normal intermediate wildcards
 [
@@ -580,10 +559,11 @@ DIRECT,
 function (source) {
   var last = source[source.length - 1];
 
-  // The pattern is empty, or ends in the pending trailing wildcard the next
-  //   step owns. A trailing `*` that is not the marker is a literal star,
-  //   which anchors like any other final character.
-  if (!last || last === TRAILING_WILDCARD) {
+  // The pattern is empty, or ends in a pending marker `_make` owns --
+  //   the trailing wildcard, or a trailing "/**". A trailing `*` that is
+  //   not the marker is a literal star, which anchors like any other
+  //   final character.
+  if (!last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR) {
     return source;
   }
   return last === SLASH
@@ -595,7 +575,7 @@ var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/;
 var MODE_IGNORE = 'regex';
 var MODE_CHECK_IGNORE = 'checkRegex';
 var UNDERSCORE = '_';
-var TRAILING_WILD_CARD_REPLACERS = (_TRAILING_WILD_CARD_R = {}, _defineProperty(_TRAILING_WILD_CARD_R, MODE_IGNORE, function (_, p1) {
+var replaceTrailingWildcard = function replaceTrailingWildcard(_, p1) {
   var prefix = p1
   // '\^':
   // '/*' does not match EMPTY
@@ -607,16 +587,13 @@ var TRAILING_WILD_CARD_REPLACERS = (_TRAILING_WILD_CARD_R = {}, _defineProperty(
   // 'a*' matches 'aa'
   : '[^/]*';
   return "".concat(prefix, "(?=$|\\/$)");
-}), _defineProperty(_TRAILING_WILD_CARD_R, MODE_CHECK_IGNORE, function (_, p1) {
-  // When doing `git check-ignore`
-  var prefix = p1
-  // '\\\/':
-  // 'abc/*' DOES match 'abc/' !
-  ? "".concat(p1, "[^/]*") // 'a*' matches 'a'
-  // 'a*' matches 'aa'
-  : '[^/]*';
-  return "".concat(prefix, "(?=$|\\/$)");
-}), _TRAILING_WILD_CARD_R);
+};
+var REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/;
+
+// 'abc/**' matches everything under 'abc', but not 'abc/' itself (#21)
+var replaceTrailingDoublestar = function replaceTrailingDoublestar() {
+  return '.+(?=$|\\/$)';
+};
 var WILDCARD = '[^\\/]*';
 
 // Where a run of non-slash wildcards is split by single fixed characters --
@@ -785,6 +762,22 @@ var makeRegexPrefix = function makeRegexPrefix(pattern) {
   }) : replaced;
 };
 
+// `checkRegex` tests a path with a trailing slash, 'abc/', the way
+//   `git check-ignore` matches that literal string once the directory itself
+//   is known not to be excluded (see `checkIgnore`): a trailing '/' of the
+//   pattern is dropped, a basename pattern sees an empty basename, and only a
+//   pattern whose last segment is a pending wildcard can match what is left
+//   after the final slash -- 'abc/*' and 'abc/**' match 'abc/', and 'abc/**'
+//   also matches 'abc/d/' (#77, #169).
+var checkSourceOf = function checkSourceOf(body, prefix) {
+  if (body[body.length - 1] === SLASH) {
+    prefix = makeRegexPrefix(body.slice(0, -1));
+  }
+  var head = prefix.slice(0, -1);
+  var last = prefix[prefix.length - 1];
+  return last === TRAILING_WILDCARD ? "".concat(head, "$") : last === TRAILING_DOUBLESTAR ? "".concat(head, ".*$") : NEVER_MATCH;
+};
+
 // A trailing slash does not stop a pattern being basename-only: it restricts
 //   the match to a directory, it does not let the pattern reach across one.
 //   Everything else a pattern can hold -- a wildcard, a character class, an
@@ -840,12 +833,10 @@ var isString = function isString(subject) {
   return typeof subject === 'string';
 };
 
-// > A blank line matches no files, so it can serve as a separator for readability.
+// Blank lines and comments are told by `createRule`, once the pattern is
+//   normalized.
 var checkPattern = function checkPattern(pattern) {
-  return pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)
-
-  // > A line starting with # serves as a comment.
-  && pattern.indexOf('#') !== 0;
+  return pattern && isString(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern);
 };
 var splitPattern = function splitPattern(pattern) {
   return pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
@@ -892,25 +883,73 @@ var IgnoreRule = /*#__PURE__*/function () {
   }, {
     key: "_make",
     value: function _make(mode, key) {
-      var str = pinWildcards(this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD,
-      // It does not need to bind pattern
-      TRAILING_WILD_CARD_REPLACERS[mode]));
+      var str = pinWildcards(mode === MODE_IGNORE ? this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard).replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar) : checkSourceOf(this.body, this.regexPrefix));
       var regex = this.ignoreCase ? new RegExp(str, 'i') : new RegExp(str);
       return define(this, key, regex);
     }
   }]);
   return IgnoreRule;
 }();
+var isLineEnd = function isLineEnd(_char5) {
+  return _char5 === '\r' || _char5 === '\n';
+};
+
+// Drop a line terminator, which can remain when patterns are passed as an
+//   array, and then the trailing spaces. Git trims spaces only, and a space
+//   escaped by an odd run of backslashes stays, unescaped, as the last one.
+// Scanned from the end: a regular expression can only try each start in
+//   turn, which is quadratic over a long run of spaces or backslashes.
+// 'a  ' -> 'a';  'a\ ' -> 'a ';  'a\\ ' -> 'a\\';  'a\t' -> 'a\t'
+var trimEnd = function trimEnd(body) {
+  var end = body.length;
+  while (end && isLineEnd(body[end - 1])) {
+    end--;
+  }
+  var lineEnd = end;
+  while (end && body[end - 1] === SPACE) {
+    end--;
+  }
+  if (end === lineEnd) {
+    return body.slice(0, end);
+  }
+  var backslashes = 0;
+  while (backslashes < end && body[end - backslashes - 1] === ESCAPE) {
+    backslashes++;
+  }
+  return backslashes % 2 ? body.slice(0, end - 1) + SPACE : body.slice(0, end);
+};
 var createRule = function createRule(_ref3, ignoreCase) {
   var pattern = _ref3.pattern,
     mark = _ref3.mark;
+  // Git drops a BOM before it reads the first line, so before anything else.
+  var body = pattern[0] === BOM ? pattern.slice(1) : pattern;
+
+  // > A line starting with # serves as a comment.
+  if (body[0] === '#') {
+    return;
+  }
   var negative = false;
-  var body = pattern;
 
   // > An optional prefix "!" which negates the pattern;
-  if (body.indexOf('!') === 0) {
+  if (body[0] === '!') {
     negative = true;
-    body = body.substr(1);
+    body = body.slice(1);
+  }
+
+  // Normalize the body before checking which slashes anchor the pattern.
+  //   Otherwise `bar/ ` is mistaken for a pattern containing an inner slash.
+  //   Only a body ending in a space or a line terminator has anything to trim.
+  var last = body[body.length - 1];
+  if (last === SPACE || last === '\r' || last === '\n') {
+    body = trimEnd(body);
+  }
+
+  // > A blank line matches no files, so it can serve as a separator for
+  // >   readability.
+  // Nor does a lone "!", or anything else left empty here: an empty pattern
+  //   would compile to a regex matching every path.
+  if (!body) {
+    return;
   }
   body = body
   // > Put a backslash ("\") in front of the first "!" for patterns that
@@ -958,8 +997,8 @@ var RuleManager = /*#__PURE__*/function () {
           pattern: pattern
         };
       }
-      if (checkPattern(pattern.pattern)) {
-        var rule = createRule(pattern, this._ignoreCase);
+      var rule = checkPattern(pattern.pattern) && createRule(pattern, this._ignoreCase);
+      if (rule) {
         this._added = true;
         this._rules.push(rule);
 
@@ -978,9 +1017,44 @@ var RuleManager = /*#__PURE__*/function () {
     value: function 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.
+  }, {
+    key: "testLiteral",
+    value: function testLiteral(path) {
+      var rules = this._literalRules || (this._literalRules = this._rules.filter(function (_ref4) {
+        var body = _ref4.body;
+        return body[body.length - (body[body.length - 1] === SLASH ? 2 : 1)] === '*';
+      }));
+      var ignored = false;
+      var unignored = false;
+      var matchedRule;
+      for (var index = rules.length - 1; index >= 0; index--) {
+        var rule = rules[index];
+        if (rule.checkRegex.test(path)) {
+          ignored = !rule.negative;
+          unignored = rule.negative;
+          matchedRule = rule.negative ? UNDEFINED : rule;
+          break;
+        }
+      }
+      var ret = {
+        ignored: ignored,
+        unignored: 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,
@@ -1107,13 +1181,13 @@ checkPath.convert = function (p) {
 };
 var Ignore = /*#__PURE__*/function () {
   function Ignore() {
-    var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-      _ref4$ignorecase = _ref4.ignorecase,
-      ignorecase = _ref4$ignorecase === void 0 ? true : _ref4$ignorecase,
-      _ref4$ignoreCase = _ref4.ignoreCase,
-      ignoreCase = _ref4$ignoreCase === void 0 ? ignorecase : _ref4$ignoreCase,
-      _ref4$allowRelativePa = _ref4.allowRelativePaths,
-      allowRelativePaths = _ref4$allowRelativePa === void 0 ? false : _ref4$allowRelativePa;
+    var _ref5 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref5$ignorecase = _ref5.ignorecase,
+      ignorecase = _ref5$ignorecase === void 0 ? true : _ref5$ignorecase,
+      _ref5$ignoreCase = _ref5.ignoreCase,
+      ignoreCase = _ref5$ignoreCase === void 0 ? ignorecase : _ref5$ignoreCase,
+      _ref5$allowRelativePa = _ref5.allowRelativePaths,
+      allowRelativePaths = _ref5$allowRelativePa === void 0 ? false : _ref5$allowRelativePa;
     _classCallCheck(this, Ignore);
     define(this, KEY_IGNORE, true);
     this._rules = new RuleManager(ignoreCase);
@@ -1166,14 +1240,16 @@ var Ignore = /*#__PURE__*/function () {
       if (path.charCodeAt(path.length - 1) !== SLASH_CODE) {
         return this.test(path);
       }
-      var parentPath = parentOf(path);
-      if (parentPath) {
-        var parent = this._t(parentPath, this._testCache, true);
-        if (parent.ignored) {
-          return parent;
-        }
+
+      // Like `git check-ignore`: a directory excluded by itself or by an
+      //   ancestor settles it, and only then is the literal 'abc/' matched
+      //   against the rules (see `checkSourceOf`).
+      var dir = this._t(path, this._testCache, true);
+      if (dir.ignored) {
+        return dir;
       }
-      return this._rules.test(path, false, MODE_CHECK_IGNORE);
+      var literal = this._rules.testLiteral(path);
+      return literal.ignored || literal.unignored ? literal : dir;
     }
   }, {
     key: "_t",

package/node_modules/ignore/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignore",
-  "version": "7.0.10",
+  "version": "7.0.12",
   "description": "Ignore is a manager and filter for .gitignore rules, the one used by eslint, gitbook and many others.",
   "types": "index.d.ts",
   "files": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "8.0.1",
+  "version": "9.0.0",
   "description": "Language Server Protocol runtime for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -37,8 +37,8 @@
     "vscode-jsonrpc": "^9.0.0",
     "vscode-languageserver-protocol": "^3.18.0",
     "vscode-languageserver-types": "^3.18.0",
-    "@mrclrchtr/supi-code-runtime": "8.0.1",
-    "@mrclrchtr/supi-core": "8.0.1"
+    "@mrclrchtr/supi-code-runtime": "9.0.0",
+    "@mrclrchtr/supi-core": "9.0.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/client/client.ts

@@ -78,6 +78,9 @@ import { JsonRpcClient, JsonRpcRequestError } from "./transport.ts";
 
 const SHUTDOWN_TIMEOUT_MS = 5_000;
 
+/** Bounded stderr tail kept for startup-failure error messages. */
+const STDERR_TAIL_MAX_CHARS = 4_000;
+
 interface SemanticRequestAttemptState {
   inputRevision: number | undefined;
 }
@@ -699,8 +702,13 @@ export class LspClient {
       this.handleProcessFailure(new Error("Client process error"));
     });
 
-    // Suppress stderr to avoid noise in the agent
-    this.process.stderr?.on("data", () => {});
+    // Capture a bounded stderr tail (discarded otherwise) so startup
+    // failures can surface the server's own exit reason — expired builds,
+    // missing runtimes, or invalid flags. Stderr never reaches the agent.
+    let stderrTail = "";
+    this.process.stderr?.on("data", (chunk: Buffer | string) => {
+      stderrTail = `${stderrTail}${chunk}`.slice(-STDERR_TAIL_MAX_CHARS);
+    });
 
     // Initialize handshake
     try {
@@ -736,7 +744,10 @@ export class LspClient {
 
       this.armNoProgressTimer();
     } catch (err) {
-      const failure = new Error(`${this.name}: initialize failed: ${err}`, { cause: err });
+      const stderrDetail = stderrTail.trim() ? `\n${this.name} stderr:\n${stderrTail.trim()}` : "";
+      const failure = new Error(`${this.name}: initialize failed: ${err}${stderrDetail}`, {
+        cause: err,
+      });
       this.handleProcessFailure(failure);
       killFailedStartupProcess(this.process);
       throw failure;

package/src/config/defaults.json

@@ -77,6 +77,12 @@
       "args": ["--slave", "-e", "languageserver::run()"],
       "fileTypes": ["r"],
       "rootMarkers": ["DESCRIPTION", "renv.lock", ".Rprofile"]
+    },
+    "latex": {
+      "command": "texlab",
+      "args": [],
+      "fileTypes": ["tex", "bib"],
+      "rootMarkers": []
     }
   }
 }

package/src/diagnostics/evidence.ts

@@ -1,6 +1,6 @@
 /** Reason for a partial or unavailable single-file result when the push stays tentative. */
 export const TENTATIVE_PUSH_UNAVAILABLE_REASON =
-  "The current diagnostic publication is ambient evidence and cannot confirm the document synchronization.";
+  "A diagnostic publication is ambient evidence only; it may show issues, but an empty publication cannot confirm that the document is clean.";
 
 /** A final evidence state for one tracked document. */
 export type DiagnosticEvidenceStatus = "confirmed" | "unconfirmed" | "failed" | "removed";

package/src/manager/manager.ts

@@ -2390,7 +2390,7 @@ export class LspManager {
     return Array.from(activeServers.entries())
       .map(([name, openFiles]) => ({
         name,
-        openFiles: Array.from(openFiles).sort(),
+        openFiles: Array.from(openFiles).sort((left, right) => left.localeCompare(right)),
       }))
       .sort((a, b) => b.openFiles.length - a.openFiles.length || a.name.localeCompare(b.name));
   }

package/src/provider/refactor-planning.ts

@@ -31,6 +31,7 @@ export async function runRenameRefactor(options: {
     return {
       kind: "unavailable",
       reason: response.reason ?? "No routed LSP client could plan the rename.",
+      authorizedMutationRoots: [...response.authorizedMutationRoots],
     };
   }
   return normalizeSemanticEdit(

package/src/provider/semantic-edit-normalizer.ts

@@ -133,7 +133,7 @@ function normalizeChanges(
   }
 
   const edits: FileEdit[] = [];
-  for (const uri of Object.keys(changes).sort()) {
+  for (const uri of Object.keys(changes).sort((left, right) => left.localeCompare(right))) {
     const file = toFilePath(uri);
     const textEdits = changes[uri];
     if (!file) {

package/src/utils.ts

@@ -53,6 +53,8 @@ const EXT_TO_LANGUAGE: Record<string, string> = {
   kts: "kotlin",
   swift: "swift",
   lua: "lua",
+  tex: "latex",
+  bib: "bibtex",
   zig: "zig",
 };