@mrclrchtr/supi-lsp 11.0.1 → 11.1.0

package/README.md

@@ -153,7 +153,7 @@ Caller cancellation or deadline stops only that caller's wait. Explicit diagnost
 
 If another request first opens a document during an active semantic or diagnostic request, the client can synchronize and repeat the request once. The retry retains the caller's original signal and deadline. Content, workspace, close, and lifecycle changes still reject stale results. A diagnostic retry collects new request evidence; it does not promote an old cache. This retry is not route recovery. A second enrollment during the retry still rejects the result. Semantic failure reasons state whether the retry failed or was exhausted. The bounded `request.retry` debug event records the retry reason and outcome with the public call's opaque operation ID, when supplied. A completed RPC alone does not establish accepted semantic evidence.
 
-A read-only semantic request can also retry once after an LSP `ContentModified` error (`-32801`). This retry shares the same one-retry budget as enrollment; it does not add another try. The client keeps the original request parameters and checks changes from the first failed input revision. It runs the full input sync before retry and checks current inputs before it accepts a result. An enrollment is still the only input change that can permit a retry. A content, workspace, close, lifecycle, or retirement change blocks it. Client replacement, caller cancellation, and a deadline also block retry. The post-request check rejects a result if inputs change while that attempt runs. This error-code retry applies only to read-only semantic requests. Diagnostics, rename, code actions, and refactors keep the default policy and do not retry `ContentModified`. See the [LSP 3.17 message-ordering rule](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#messageOrdering), the [retry guard](src/client/client-request-enrollment.ts), and the [client query path](src/client/client.ts).
+A read-only semantic request can also retry once after an LSP `ContentModified` error (`-32801`). This retry shares the same one-retry budget as enrollment; it does not add another try. Before this protocol retry, the client waits 100 ms so an immediate retry does not race the same server analysis. The wait is cancellable, respects the original absolute deadline, and does not delay enrollment-only retries. The client keeps the original request parameters and checks changes from the first failed input revision. It runs the full input sync before retry and checks current inputs before it accepts a result. An enrollment is still the only input change that can permit a retry. A content, workspace, close, lifecycle, or retirement change blocks it. Client replacement, caller cancellation, and a deadline also block retry. The post-request check rejects a result if inputs change while that attempt runs. This error-code retry applies only to read-only semantic requests. Diagnostics, rename, code actions, and refactors keep the default policy and do not retry `ContentModified`. See the [LSP 3.17 message-ordering rule](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#messageOrdering), the [retry guard](src/client/client-request-enrollment.ts), and the [client query path](src/client/client.ts).
 
 Diagnostic collection does not close and reopen a document to obtain confirmation. It does not send a no-op `didChange` for that purpose. Refresh retains unchanged documents and their current server state, and resynchronizes changed or invalidated documents. A client restart may reopen tracked documents to restore client state; that is recovery, not diagnostic confirmation.
 

package/node_modules/@mrclrchtr/supi-code-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-runtime",
-  "version": "11.0.1",
+  "version": "11.1.0",
   "description": "Shared workspace context and capability contracts for code intelligence",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "11.0.1",
+  "version": "11.1.0",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-core/src/debug-registry.ts

@@ -14,6 +14,8 @@ export interface DebugRegistryConfig {
   enabled: boolean;
   /** What the agent-callable debug tool may return. */
   agentAccess: DebugAgentAccess;
+  /** Whether Agent Run retrospective capture is explicitly enabled. */
+  agentRunRetrospectivesEnabled: boolean;
   /** Maximum number of session-local events to keep in memory. */
   maxEvents: number;
 }
@@ -21,6 +23,7 @@ export interface DebugRegistryConfig {
 export const DEBUG_REGISTRY_DEFAULTS: DebugRegistryConfig = {
   enabled: false,
   agentAccess: "sanitized",
+  agentRunRetrospectivesEnabled: false,
   maxEvents: 100,
 };
 
@@ -75,6 +78,9 @@ export interface DebugEventQueryResult {
 /** Receives a sanitized event whenever the registry records one. */
 export type DebugEventListener = (event: DebugEventView) => void;
 
+/** Receives sanitized events for persistence; separate from ordinary event subscriptions. */
+export type DebugPersistenceSink = (event: DebugEventView) => void;
+
 export interface DebugSummary {
   total: number;
   byLevel: Partial<Record<DebugLevel, number>>;
@@ -85,6 +91,7 @@ interface DebugRegistryState {
   config: DebugRegistryConfig;
   events: DebugEvent[];
   listeners: Set<DebugEventListener>;
+  persistenceSinks: Set<DebugPersistenceSink>;
   nextId: number;
 }
 
@@ -111,13 +118,15 @@ function getState(): DebugRegistryState {
       config: cloneConfig(DEBUG_REGISTRY_DEFAULTS),
       events: [],
       listeners: new Set(),
+      persistenceSinks: new Set(),
       nextId: 1,
     };
     (globalThis as Record<symbol, unknown>)[REGISTRY_KEY] = state;
   }
   // Keep the shared registry compatible with extension reloads that reuse an
-  // instance created before listeners existed.
+  // instance created before listener sets existed.
   if (!state.listeners) state.listeners = new Set();
+  if (!state.persistenceSinks) state.persistenceSinks = new Set();
   return state;
 }
 
@@ -200,6 +209,19 @@ export function isDebugRegistryEnabled(): boolean {
   return getState().config.enabled;
 }
 
+/**
+ * Return whether a retrospective can be captured: Debug and its explicit opt-in
+ * must be enabled, and at least one persistence sink must be registered.
+ */
+export function canRecordAgentRunRetrospective(): boolean {
+  const state = getState();
+  return (
+    state.config.enabled &&
+    state.config.agentRunRetrospectivesEnabled &&
+    state.persistenceSinks.size > 0
+  );
+}
+
 /** Best-effort redaction helper for data exposed through sanitized debug views. */
 export function redactDebugData<T>(value: T): T {
   return redactValue(value, 8) as T;
@@ -226,6 +248,16 @@ export function subscribeDebugEvents(listener: DebugEventListener): () => void {
   return () => state.listeners.delete(listener);
 }
 
+/**
+ * Register a sanitized event persistence sink. Sinks are tracked separately from
+ * ordinary listeners so eligibility checks only succeed when logging is active.
+ */
+export function subscribeDebugPersistence(sink: DebugPersistenceSink): () => void {
+  const state = getState();
+  state.persistenceSinks.add(sink);
+  return () => state.persistenceSinks.delete(sink);
+}
+
 /** Record a session-local debug event if debugging is enabled. */
 export function recordDebugEvent(input: DebugEventInput): DebugEvent | null {
   const state = getState();
@@ -251,6 +283,13 @@ export function recordDebugEvent(input: DebugEventInput): DebugEvent | null {
       // Debug-event consumers must not alter producer behavior.
     }
   }
+  for (const sink of state.persistenceSinks) {
+    try {
+      sink(toSanitizedView(event));
+    } catch {
+      // Persistence failures must not alter producer behavior.
+    }
+  }
   return {
     ...event,
     data: event.data === undefined ? undefined : redactDebugData(event.data),
@@ -309,5 +348,6 @@ export function resetDebugRegistry(): void {
   state.config = cloneConfig(DEBUG_REGISTRY_DEFAULTS);
   state.events = [];
   state.listeners.clear();
+  state.persistenceSinks.clear();
   state.nextId = 1;
 }

package/node_modules/ignore/README.md

@@ -282,6 +282,12 @@ Returns `function(path)` the filter function.
 
 > New in 5.0.0
 
+**This method is NOT meant for ordinary users or everyday use.** If all you need is to tell whether a `pathname` is ignored, this is not the method you are looking for.
+
+`.test()` is meant for packages that build upon `ignore`. Besides whether a `pathname` is ignored, it tells whether a negative pattern unignored it, which such a package can use to control its own caching, such as what to cache and when a cached result can be reused.
+
+If you only need to know whether a `pathname` should be ignored, use `.ignores()` instead. It returns that answer as a boolean, and always agrees with `.test(pathname).ignored`.
+
 Returns `TestResult`
 
 ```ts
@@ -291,7 +297,8 @@ interface TestResult {
   // true if a negative pattern matched the `pathname` itself, and no parent
   //   directory of it is ignored -- see "When both are false" below
   unignored: boolean
-  // The `IgnoreRule` which ignores the pathname
+  // The `IgnoreRule` which ignores the pathname: the last rule to match, the
+  //   one `git check-ignore -v` reports
   rule?: IgnoreRule
 }
 
@@ -339,13 +346,15 @@ To tell the two situations apart, test the parent directories of the `pathname`,
 ['foobar/'].some(dir => ig2.test(dir).unignored) // true
 ```
 
-`unignored` is meant for packages that implement their own caching mechanism upon `node-ignore`. To simply tell whether a `pathname` is ignored, use `.ignores()` or check `TestResult::ignored`.
-
 ## .checkIgnore(target: string): TestResult
 
 > new in 7.0.0
 
-Debugs gitignore / exclude files, which is equivalent to `git check-ignore -v`. Usually this method is used for other packages to implement the function of `git check-ignore -v` upon `node-ignore`
+Debugs gitignore / exclude files the way `git check-ignore -v` does. Usually this method is used for other packages to implement the function of `git check-ignore -v` upon `node-ignore`. Apart from the [known differences](#known-differences-from-git):
+
+- `ignored` is what `git check-ignore` answers for `target`.
+- When `ignored` is `true`, `rule` is the rule `git check-ignore -v` reports. Its `pattern` is the pattern as it was added, so trailing spaces that git trims are still there.
+- When the last pattern to match is a negative one, `git check-ignore -v` reports it, while `.checkIgnore()` returns `unignored: true` and no `rule`. For a directory passed with a trailing slash, `unignored` is also `true` when a negative pattern re-includes the directory itself, which `git check-ignore -v` does not report.
 
 - **target** `string` the target to test.
 
@@ -471,13 +480,30 @@ not in `git`. For ASCII paths and patterns there is no difference.
 code runs against a real repository, pass the value of the repository's
 `core.ignorecase` explicitly.
 
-### `***` and friends follow the documentation, not the binary
+### A run of asterisks
+
+`git` reads a run of two or more asterisks as a globstar whenever the run
+fills a path segment: it starts the pattern or follows a `/`, and it ends
+the pattern or comes before a `/`. `ignore` does the same, so `***/foo`,
+`a/***` and `a/***/b` behave exactly as `**/foo`, `a/**` and `a/**/b`.
+
+`git` takes two more cases as a globstar, and `ignore` does not:
+
+- **A run right after a literal prefix**, as in `a**/b` or `a***/b`. Before
+  matching, `git` strips the part of a pattern that holds no wildcard, and
+  the run then starts what is left. gitignore(5) lists the positions where
+  `**` is special and calls every other run "regular asterisks", which is
+  what `ignore` does here.
+- **A run next to an escaped slash**, as in `**\/b` or `x\/**/b`.
+
+```js
+ignore().add('a**/b').ignores('axy/z/b')   // false;  git: true
+ignore().add('**\\/b').ignores('x/y/b')    // false;  git: true
+ignore().add('x\\/**/b').ignores('x/y/z/b') // false;  git: true
+```
 
-gitignore(5) says a run of more than two asterisks is "considered regular
-asterisks". The `git` binary, however, strips the literal prefix of a
-pattern before matching, which makes patterns like `***/foo`, `a/***` and
-`a**/b` behave as `**` globstars there. `ignore` follows the documented
-behavior. If you need the globstar, write `**`.
+To get a globstar in either case, give the run a segment of its own, such as
+`a*/**/b`.
 
 ### `checkIgnore()` and a directory passed with a trailing slash
 

package/node_modules/ignore/index.d.ts

@@ -50,8 +50,9 @@ declare namespace ignore {
      */
     unignored: boolean
     /**
-     * The rule that ignores the pathname. Present exactly when `ignored` is
-     *   true.
+     * The rule that ignores the pathname, or the parent directory it is
+     *   ignored with: the last rule to match, which is the rule
+     *   `git check-ignore -v` reports. Present exactly when `ignored` is true.
      */
     rule?: IgnoreRule
   }

package/node_modules/ignore/index.js

@@ -15,6 +15,8 @@ const ESCAPE = '\\'
 const REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/
 const BOM = '\uFEFF'
 const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/
+// A run of two or more asterisks is a globstar (#175)
+const REGEX_ANCHORED_GLOBSTAR = /^\/\*{2,}$/
 const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/
 const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/
 const REGEX_SPLITALL_CRLF = /\r?\n/g
@@ -423,6 +425,21 @@ const REPLACERS = [
     ESCAPE + SPACE
   ],
 
+  // git's wildmatch() reads a run of two or more asterisks as one globstar
+  //   whenever the run fills a path segment: it starts the pattern or follows
+  //   a `/`, and it ends the pattern or comes before a `/`. A run of two is
+  //   already `**`; a longer one is folded into `**` here, so the steps
+  //   below only ever have to know `**`.
+  // `***/foo` -> `**/foo`, `a/***/b` -> `a/**/b`, `a/***` -> `a/**`
+  // git also takes a run beside a literal prefix (`a***/b`) or beside an
+  //   escaped slash (`***\/b`) as a globstar, and this does not; the README
+  //   lists both, under "A run of asterisks".
+  [
+    /(^|\/)\*{3,}(?=\/|$)/g,
+    (_, start) => `${start}**`,
+    '*'
+  ],
+
   // Escape metacharacters
   // which is written down by users but means special for regular expressions.
 
@@ -853,6 +870,15 @@ const pinWildcards = source => {
 
 // @param {pattern}
 const makeRegexPrefix = pattern => {
+  // `/**` matches every path, as `**` does. The translation below only finds
+  //   a globstar beside a slash it keeps, and the leading one is turned into
+  //   an anchor, so `/**` would come out as `/*` and match one level only.
+  //   Here rather than in `createRule`, so that `checkSourceOf`, which
+  //   compiles `/**/` again without its trailing slash, gets it too.
+  if (REGEX_ANCHORED_GLOBSTAR.test(pattern)) {
+    pattern = '**'
+  }
+
   const {source, sources} = extractBrackets(pattern)
 
   const replaced = REPLACERS.reduce(
@@ -1271,17 +1297,10 @@ class RuleManager {
 
   // 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
+  // - mode `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
 
+  // @returns {TestResult}
+  test (path, mode) {
     // Most of a .gitignore is patterns with no slash in them, and running
     //   those against the whole path makes the regular expression engine walk
     //   every directory name on the way to the only segment that could match.
@@ -1296,52 +1315,40 @@ class RuleManager {
       ? basenameOf(path)
       : path
 
+    // The last rule to match decides, as in git, and it is the rule
+    //   `git check-ignore -v` reports, so the scan runs from the end and stops
+    //   at the first match.
     // A plain loop rather than `forEach`, so that `path`, `basename` and
     //   `shortcut` are locals. As a callback they became closure variables,
     //   and reaching for one of those once per rule cost 10% of a scan over a
     //   large rule set -- more than the shortcut they were there to serve.
-    for (let index = 0; index < length; index ++) {
+    for (let index = length - 1; index >= 0; index --) {
       const rule = rules[index]
-      const {negative} = rule
-
-      //          |           ignored : unignored
-      // -------- | ---------------------------------------
-      // negative |   0:0   |   0:1   |   1:0   |   1:1
-      // -------- | ------- | ------- | ------- | --------
-      //     0    |  TEST   |  TEST   |  SKIP   |    X
-      //     1    |  TESTIF |  SKIP   |  TEST   |    X
-
-      // - SKIP: always skip
-      // - TEST: always test
-      // - TESTIF: only test if checkUnignored
-      // - X: that never happen
-      const skip = unignored === negative && ignored !== unignored
-        || negative && !ignored && !unignored && !checkUnignored
-
-      if (!skip && rule[mode].test(
+
+      if (rule[mode].test(
         shortcut && rule._basenameOnly
           ? basename
           : path
       )) {
-        ignored = !negative
-        unignored = negative
+        const {negative} = rule
 
-        matchedRule = negative
-          ? UNDEFINED
-          : rule
-      }
-    }
+        const ret = {
+          ignored: !negative,
+          unignored: negative
+        }
 
-    const ret = {
-      ignored,
-      unignored
-    }
+        if (!negative) {
+          ret.rule = rule
+        }
 
-    if (matchedRule) {
-      ret.rule = matchedRule
+        return ret
+      }
     }
 
-    return ret
+    return {
+      ignored: false,
+      unignored: false
+    }
   }
 }
 
@@ -1457,7 +1464,7 @@ class Ignore {
   }
 
   // @returns {TestResult}
-  _test (originalPath, cache, checkUnignored) {
+  _test (originalPath, cache) {
     const path = originalPath
       // Supports nullable path
       && checkPath.convert(originalPath)
@@ -1470,7 +1477,7 @@ class Ignore {
         : RETURN_FALSE
     )
 
-    return this._t(path, cache, checkUnignored)
+    return this._t(path, cache)
   }
 
   checkIgnore (path) {
@@ -1483,7 +1490,7 @@ class Ignore {
     // 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`).
-    const dir = this._t(path, this._testCache, true)
+    const dir = this._t(path, this._testCache)
 
     if (dir.ignored) {
       return dir
@@ -1501,10 +1508,7 @@ class Ignore {
     path,
 
     // The cache for the result of a certain checking
-    cache,
-
-    // Whether should check if the path is unignored
-    checkUnignored
+    cache
   ) {
     if (path in cache) {
       return cache[path]
@@ -1514,18 +1518,18 @@ class Ignore {
 
     // If the path contains a parent directory, check the parent first
     const parent = parentPath
-      ? this._t(parentPath, cache, checkUnignored)
+      ? this._t(parentPath, cache)
       : UNDEFINED
 
     return cache[path] = parent && parent.ignored
       // > It is not possible to re-include a file if a parent directory of
       // >   that file is excluded.
       ? parent
-      : this._rules.test(path, checkUnignored, MODE_IGNORE)
+      : this._rules.test(path, MODE_IGNORE)
   }
 
   ignores (path) {
-    return this._test(path, this._ignoreCache, false).ignored
+    return this._test(path, this._ignoreCache).ignored
   }
 
   createFilter () {
@@ -1538,7 +1542,7 @@ class Ignore {
 
   // @returns {TestResult}
   test (path) {
-    return this._test(path, this._testCache, true)
+    return this._test(path, this._testCache)
   }
 }
 

package/node_modules/ignore/legacy.js

@@ -26,6 +26,8 @@ var ESCAPE = '\\';
 var REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
 var BOM = "\uFEFF";
 var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+// A run of two or more asterisks is a globstar (#175)
+var REGEX_ANCHORED_GLOBSTAR = /^\/\*{2,}$/;
 var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
 var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
 var REGEX_SPLITALL_CRLF = /\r?\n/g;
@@ -386,6 +388,18 @@ var REPLACERS = [
 /(\\+)( ?)/g, function (_, run, space) {
   return space ? run.slice(0, run.length - run.length % 2) + SPACE : run;
 }, ESCAPE + SPACE],
+// git's wildmatch() reads a run of two or more asterisks as one globstar
+//   whenever the run fills a path segment: it starts the pattern or follows
+//   a `/`, and it ends the pattern or comes before a `/`. A run of two is
+//   already `**`; a longer one is folded into `**` here, so the steps
+//   below only ever have to know `**`.
+// `***/foo` -> `**/foo`, `a/***/b` -> `a/**/b`, `a/***` -> `a/**`
+// git also takes a run beside a literal prefix (`a***/b`) or beside an
+//   escaped slash (`***\/b`) as a globstar, and this does not; the README
+//   lists both, under "A run of asterisks".
+[/(^|\/)\*{3,}(?=\/|$)/g, function (_, start) {
+  return "".concat(start, "**");
+}, '*'],
 // Escape metacharacters
 // which is written down by users but means special for regular expressions.
 
@@ -754,6 +768,14 @@ var pinWildcards = function pinWildcards(source) {
 
 // @param {pattern}
 var makeRegexPrefix = function makeRegexPrefix(pattern) {
+  // `/**` matches every path, as `**` does. The translation below only finds
+  //   a globstar beside a slash it keeps, and the leading one is turned into
+  //   an anchor, so `/**` would come out as `/*` and match one level only.
+  //   Here rather than in `createRule`, so that `checkSourceOf`, which
+  //   compiles `/**/` again without its trailing slash, gets it too.
+  if (REGEX_ANCHORED_GLOBSTAR.test(pattern)) {
+    pattern = '**';
+  }
   var _extractBrackets = extractBrackets(pattern),
     source = _extractBrackets.source,
     sources = _extractBrackets.sources;
@@ -1081,19 +1103,12 @@ var RuleManager = /*#__PURE__*/function () {
 
     // 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`
+    // - mode `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
 
-    // @returns {TestResult} true if a file is ignored
+    // @returns {TestResult}
   }, {
     key: "test",
-    value: function test(path, checkUnignored, mode) {
-      var ignored = false;
-      var unignored = false;
-      var matchedRule;
-
+    value: function test(path, mode) {
       // Most of a .gitignore is patterns with no slash in them, and running
       //   those against the whole path makes the regular expression engine walk
       //   every directory name on the way to the only segment that could match.
@@ -1104,40 +1119,31 @@ var RuleManager = /*#__PURE__*/function () {
       var shortcut = this._basenameCount * 2 >= length;
       var basename = shortcut ? basenameOf(path) : path;
 
+      // The last rule to match decides, as in git, and it is the rule
+      //   `git check-ignore -v` reports, so the scan runs from the end and stops
+      //   at the first match.
       // A plain loop rather than `forEach`, so that `path`, `basename` and
       //   `shortcut` are locals. As a callback they became closure variables,
       //   and reaching for one of those once per rule cost 10% of a scan over a
       //   large rule set -- more than the shortcut they were there to serve.
-      for (var index = 0; index < length; index++) {
+      for (var index = length - 1; index >= 0; index--) {
         var rule = rules[index];
-        var negative = rule.negative;
-
-        //          |           ignored : unignored
-        // -------- | ---------------------------------------
-        // negative |   0:0   |   0:1   |   1:0   |   1:1
-        // -------- | ------- | ------- | ------- | --------
-        //     0    |  TEST   |  TEST   |  SKIP   |    X
-        //     1    |  TESTIF |  SKIP   |  TEST   |    X
-
-        // - SKIP: always skip
-        // - TEST: always test
-        // - TESTIF: only test if checkUnignored
-        // - X: that never happen
-        var skip = unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored;
-        if (!skip && rule[mode].test(shortcut && rule._basenameOnly ? basename : path)) {
-          ignored = !negative;
-          unignored = negative;
-          matchedRule = negative ? UNDEFINED : rule;
+        if (rule[mode].test(shortcut && rule._basenameOnly ? basename : path)) {
+          var negative = rule.negative;
+          var ret = {
+            ignored: !negative,
+            unignored: negative
+          };
+          if (!negative) {
+            ret.rule = rule;
+          }
+          return ret;
         }
       }
-      var ret = {
-        ignored: ignored,
-        unignored: unignored
+      return {
+        ignored: false,
+        unignored: false
       };
-      if (matchedRule) {
-        ret.rule = matchedRule;
-      }
-      return ret;
     }
   }]);
   return RuleManager;
@@ -1249,12 +1255,12 @@ var Ignore = /*#__PURE__*/function () {
     // @returns {TestResult}
   }, {
     key: "_test",
-    value: function _test(originalPath, cache, checkUnignored) {
+    value: function _test(originalPath, cache) {
       var path = originalPath
       // Supports nullable path
       && checkPath.convert(originalPath);
       checkPath(path, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
-      return this._t(path, cache, checkUnignored);
+      return this._t(path, cache);
     }
   }, {
     key: "checkIgnore",
@@ -1268,7 +1274,7 @@ var Ignore = /*#__PURE__*/function () {
       // 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);
+      var dir = this._t(path, this._testCache);
       if (dir.ignored) {
         return dir;
       }
@@ -1281,25 +1287,23 @@ var Ignore = /*#__PURE__*/function () {
     // The path to be tested
     path,
     // The cache for the result of a certain checking
-    cache,
-    // Whether should check if the path is unignored
-    checkUnignored) {
+    cache) {
       if (path in cache) {
         return cache[path];
       }
       var parentPath = parentOf(path);
 
       // If the path contains a parent directory, check the parent first
-      var parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
+      var parent = parentPath ? this._t(parentPath, cache) : UNDEFINED;
       return cache[path] = parent && parent.ignored
       // > It is not possible to re-include a file if a parent directory of
       // >   that file is excluded.
-      ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+      ? parent : this._rules.test(path, MODE_IGNORE);
     }
   }, {
     key: "ignores",
     value: function ignores(path) {
-      return this._test(path, this._ignoreCache, false).ignored;
+      return this._test(path, this._ignoreCache).ignored;
     }
   }, {
     key: "createFilter",
@@ -1319,7 +1323,7 @@ var Ignore = /*#__PURE__*/function () {
   }, {
     key: "test",
     value: function test(path) {
-      return this._test(path, this._testCache, true);
+      return this._test(path, this._testCache);
     }
   }]);
   return Ignore;

package/node_modules/ignore/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignore",
-  "version": "7.0.13",
+  "version": "7.0.14",
   "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/node_modules/vscode-jsonrpc/README.md

@@ -6,6 +6,11 @@
 
 This npm module implements the base messaging protocol spoken between a VSCode language server and a VSCode language client.
 
+The Node.js entry point requires Node.js 14.17.0 or newer. The runtime abstraction layer exposes
+`RAL().crypto.randomUUID()` for cryptographically generated v4 UUIDs. The browser implementation
+uses native `crypto.randomUUID()` when available and falls back to `crypto.getRandomValues()`,
+including in non-secure contexts. Custom RAL implementations must provide this capability.
+
 The npm module can also be used standalone to establish a [JSON-RPC](http://www.jsonrpc.org/) channel between
 a client and a server. Below an example how to setup a JSON-RPC connection. First the client side.
 

package/node_modules/vscode-jsonrpc/lib/browser/ril.js

@@ -145,6 +145,14 @@ class PromiseImpl {
 exports.PromiseImpl = PromiseImpl;
 const _textEncoder = new TextEncoder();
 const _ril = Object.freeze({
+    crypto: Object.freeze({
+        randomUUID() {
+            if (typeof globalThis.crypto.randomUUID === 'function') {
+                return globalThis.crypto.randomUUID();
+            }
+            return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, c => (+c ^ (globalThis.crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (+c / 4)))).toString(16));
+        }
+    }),
     messageBuffer: Object.freeze({
         create: (encoding) => new MessageBuffer(encoding)
     }),

package/node_modules/vscode-jsonrpc/lib/common/connection.js

@@ -418,11 +418,16 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             }
             finally {
                 if (result instanceof Promise) {
+                    // Both settlements must release the parallelism slot. Written as
+                    // .then(...).catch(...) the rejection path skipped the decrement, so
+                    // one failed dispatch left `inFlight` permanently elevated and
+                    // triggerMessageQueue() bailed out forever after.
                     result.then(() => {
-                        inFlight--;
-                        triggerMessageQueue();
                     }).catch((error) => {
                         logger.error(`Processing message queue failed: ${error.toString()}`);
+                    }).finally(() => {
+                        inFlight--;
+                        triggerMessageQueue();
                     });
                 }
                 else {

package/node_modules/vscode-jsonrpc/lib/common/ral.d.ts

@@ -42,7 +42,15 @@ interface _WritableStream {
 }
 interface _DuplexStream extends _ReadableStream, _WritableStream {
 }
+/**
+ * Runtime abstraction implemented by this npm module.
+ * External implementations are not supported. Changes to this interface do not
+ * require a major version bump.
+ */
 interface RAL {
+    readonly crypto: {
+        randomUUID(): string;
+    };
     readonly applicationJson: {
         readonly encoder: ContentTypeEncoder;
         readonly decoder: ContentTypeDecoder;

package/node_modules/vscode-jsonrpc/lib/node/main.d.ts

@@ -46,12 +46,26 @@ export declare class StreamMessageWriter extends WriteableStreamMessageWriter {
 export declare function generateRandomPipeName(): string;
 export interface PipeTransport {
     onConnected(): Promise<[MessageReader, MessageWriter]>;
+    /**
+     * Closes the underlying server if a client hasn't connected yet. Callers
+     * should invoke this if they abandon the transport before `onConnected`
+     * resolves (for example because the server process failed to start) to
+     * avoid leaking the listening pipe.
+     */
+    close(): void;
 }
 export declare function createClientPipeTransport(pipeName: string, encoding?: RAL.MessageBufferEncoding): Promise<PipeTransport>;
 export declare function createServerPipeTransport(pipeName: string, encoding?: RAL.MessageBufferEncoding): [MessageReader, MessageWriter];
 export interface SocketTransport {
     port(): number;
     onConnected(): Promise<[MessageReader, MessageWriter]>;
+    /**
+     * Closes the underlying server if a client hasn't connected yet. Callers
+     * should invoke this if they abandon the transport before `onConnected`
+     * resolves (for example because the server process failed to start) to
+     * avoid leaking the listening socket.
+     */
+    close(): void;
 }
 export declare function createClientSocketTransport(port: number, encoding?: RAL.MessageBufferEncoding): Promise<SocketTransport>;
 export declare function createServerSocketTransport(port: number, encoding?: RAL.MessageBufferEncoding): [MessageReader, MessageWriter];

package/node_modules/vscode-jsonrpc/lib/node/main.js

@@ -84,7 +84,7 @@ class IPCMessageWriter extends api_1.AbstractMessageWriter {
         this.errorCount = 0;
         const eventEmitter = this.process;
         eventEmitter.on('error', (error) => this.fireError(error));
-        eventEmitter.on('close', () => this.fireClose);
+        eventEmitter.on('close', () => this.fireClose());
     }
     write(msg) {
         try {
@@ -119,7 +119,7 @@ class PortMessageReader extends api_1.AbstractMessageReader {
     constructor(port) {
         super();
         this.onData = new api_1.Emitter;
-        port.on('close', () => this.fireClose);
+        port.on('close', () => this.fireClose());
         port.on('error', (error) => this.fireError(error));
         port.on('message', (message) => {
             this.onData.fire(message);
@@ -227,7 +227,8 @@ function createClientPipeTransport(pipeName, encoding = 'utf-8') {
         server.listen(pipeName, () => {
             server.removeListener('error', reject);
             resolve({
-                onConnected: () => { return connected; }
+                onConnected: () => { return connected; },
+                close: () => { server.close(); }
             });
         });
     });
@@ -263,7 +264,8 @@ function createClientSocketTransport(port, encoding = 'utf-8') {
             const boundPort = address.port;
             resolve({
                 port: () => boundPort,
-                onConnected: () => { return connected; }
+                onConnected: () => { return connected; },
+                close: () => { server.close(); }
             });
         });
     });

package/node_modules/vscode-jsonrpc/lib/node/ril.js

@@ -5,6 +5,7 @@
  * ------------------------------------------------------------------------------------------ */
 Object.defineProperty(exports, "__esModule", { value: true });
 const util_1 = require("util");
+const crypto_1 = require("crypto");
 const api_1 = require("../common/api");
 class MessageBuffer extends api_1.AbstractMessageBuffer {
     static emptyBuffer = Buffer.allocUnsafe(0);
@@ -30,7 +31,7 @@ class MessageBuffer extends api_1.AbstractMessageBuffer {
             return buffer instanceof Buffer ? buffer : Buffer.from(buffer);
         }
         else {
-            return buffer instanceof Buffer ? buffer.slice(0, length) : Buffer.from(buffer, 0, length);
+            return buffer instanceof Buffer ? buffer.slice(0, length) : Buffer.from(buffer.subarray(0, length));
         }
     }
     allocNative(length) {
@@ -99,6 +100,9 @@ class WritableStreamWrapper {
     }
 }
 const _ril = Object.freeze({
+    crypto: Object.freeze({
+        randomUUID: () => (0, crypto_1.randomUUID)()
+    }),
     messageBuffer: Object.freeze({
         create: (encoding) => new MessageBuffer(encoding)
     }),

package/node_modules/vscode-jsonrpc/package.json

@@ -1,9 +1,10 @@
 {
 	"name": "vscode-jsonrpc",
 	"description": "A json rpc implementation over streams",
-	"version": "9.0.3",
+	"version": "10.0.0",
 	"author": "Microsoft Corporation",
 	"license": "MIT",
+	"homepage": "https://github.com/microsoft/vscode-languageserver-node/tree/main/jsonrpc",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/Microsoft/vscode-languageserver-node.git",
@@ -13,7 +14,7 @@
 		"url": "https://github.com/Microsoft/vscode-languageserver-node/issues"
 	},
 	"engines": {
-		"node": ">=14.0.0"
+		"node": ">=14.17.0"
 	},
 	"exports": {
 		".": {
@@ -31,6 +32,7 @@
 	},
 	"devDependencies": {
 		"@types/msgpack-lite": "^0.1.12",
+		"@types/node": "22.13.14",
 		"msgpack-lite": "^0.1.26"
 	},
 	"scripts": {

package/node_modules/vscode-languageserver-protocol/package.json

@@ -1,9 +1,10 @@
 {
 	"name": "vscode-languageserver-protocol",
 	"description": "VSCode Language Server Protocol implementation",
-	"version": "3.18.4",
+	"version": "3.18.5",
 	"author": "Microsoft Corporation",
 	"license": "MIT",
+	"homepage": "https://github.com/microsoft/vscode-languageserver-node/tree/main/protocol",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/Microsoft/vscode-languageserver-node.git",
@@ -27,8 +28,8 @@
 		}
 	},
 	"dependencies": {
-		"vscode-jsonrpc": "9.0.3",
-		"vscode-languageserver-types": "3.18.4"
+		"vscode-jsonrpc": "10.0.0",
+		"vscode-languageserver-types": "3.18.5"
 	},
 	"scripts": {
 		"prepublishOnly": "npm run all:publish",

package/node_modules/vscode-languageserver-types/lib/esm/main.js

@@ -222,7 +222,7 @@ export var ColorPresentation;
     function is(value) {
         const candidate = value;
         return Is.objectLiteral(candidate) && Is.string(candidate.label)
-            && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate))
+            && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate.textEdit))
             && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
     }
     ColorPresentation.is = is;
@@ -279,7 +279,7 @@ export var FoldingRange;
      */
     function is(value) {
         const candidate = value;
-        return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine)
+        return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.endLine)
             && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter))
             && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter))
             && (Is.undefined(candidate.kind) || Is.string(candidate.kind));

package/node_modules/vscode-languageserver-types/lib/umd/main.js

@@ -233,7 +233,7 @@
         function is(value) {
             var candidate = value;
             return Is.objectLiteral(candidate) && Is.string(candidate.label)
-                && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate))
+                && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate.textEdit))
                 && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
         }
         ColorPresentation.is = is;
@@ -290,7 +290,7 @@
          */
         function is(value) {
             var candidate = value;
-            return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine)
+            return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.endLine)
                 && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter))
                 && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter))
                 && (Is.undefined(candidate.kind) || Is.string(candidate.kind));

package/node_modules/vscode-languageserver-types/package.json

@@ -1,9 +1,10 @@
 {
 	"name": "vscode-languageserver-types",
 	"description": "Types used by the Language server for node",
-	"version": "3.18.4",
+	"version": "3.18.5",
 	"author": "Microsoft Corporation",
 	"license": "MIT",
+	"homepage": "https://github.com/microsoft/vscode-languageserver-node/tree/main/types",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/Microsoft/vscode-languageserver-node.git",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "11.0.1",
+  "version": "11.1.0",
   "description": "Language Server Protocol runtime for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -34,11 +34,11 @@
   "dependencies": {
     "ignore": "^7.0.5",
     "typescript": "6.0.3",
-    "vscode-jsonrpc": "^9.0.0",
-    "vscode-languageserver-protocol": "^3.18.0",
-    "vscode-languageserver-types": "^3.18.0",
-    "@mrclrchtr/supi-core": "11.0.1",
-    "@mrclrchtr/supi-code-runtime": "11.0.1"
+    "vscode-jsonrpc": "^10.0.0",
+    "vscode-languageserver-protocol": "^3.18.5",
+    "vscode-languageserver-types": "^3.18.5",
+    "@mrclrchtr/supi-code-runtime": "11.1.0",
+    "@mrclrchtr/supi-core": "11.1.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/client/client.ts

@@ -82,6 +82,9 @@ import { SemanticInputSynchronizationError } from "./client-semantic-input-error
 import { JsonRpcClient, JsonRpcRequestError } from "./transport.ts";
 
 const SHUTDOWN_TIMEOUT_MS = 5_000;
+// ContentModified can outlive the server's progress notifications. Yield before
+// spending the single retry instead of immediately racing the same analysis.
+const CONTENT_MODIFIED_RETRY_DELAY_MS = 100;
 
 /** Bounded stderr tail kept for startup-failure error messages. */
 const STDERR_TAIL_MAX_CHARS = 4_000;
@@ -1498,6 +1501,9 @@ export class LspClient {
     for (;;) {
       const attempt: SemanticRequestAttemptState = { inputRevision: undefined };
       try {
+        if (retryGuard.retryReason === "content-modified") {
+          await this.waitForContentModifiedRetry(control);
+        }
         const data = await this.runSemanticRequestAttempt<T>({
           method,
           params,
@@ -1515,6 +1521,21 @@ export class LspClient {
     }
   }
 
+  /** Pause only the protocol retry, without extending the caller's deadline. */
+  private async waitForContentModifiedRetry(control?: CodeRequestControl): Promise<void> {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      await raceRequestControl(
+        new Promise<void>((resolve) => {
+          timer = setTimeout(resolve, CONTENT_MODIFIED_RETRY_DELAY_MS);
+        }),
+        control,
+      );
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+
   /** Return only when another attempt is permitted; retain the cause when retry stops. */
   private prepareSemanticRetry(options: {
     method: string;

package/src/manager/manager.ts

@@ -2975,7 +2975,7 @@ export class LspManager {
     control?: CodeRequestControl,
   ): Promise<{ kind: "enrolled" } | { kind: "unavailable"; reason: string }> {
     throwIfCodeRequestInterrupted(control);
-    const files = [...new Set(filePaths)].sort();
+    const files = [...new Set(filePaths)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
     const routeKey = clientKey(client.name, client.root);
     if (this.clients.get(routeKey) !== client) {
       return { kind: "unavailable", reason: "The semantic route changed during rename planning." };