@mrclrchtr/supi-lsp 7.2.1 → 7.3.1

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

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

package/node_modules/@mrclrchtr/supi-core/README.md

@@ -23,6 +23,7 @@ pnpm add @mrclrchtr/supi-core
 - `@mrclrchtr/supi-core/api` — reusable helpers for other packages and extensions
 - `@mrclrchtr/supi-core/llm` — PI-owned direct model requests and JSON helpers
 - `@mrclrchtr/supi-core/report` — shared text/report rendering helpers for TUI and plain-text summaries
+- `@mrclrchtr/supi-core/tui` — shared terminal UI helpers for list titles, rows, menus, and descriptions
 
 ## What you get from the API
 
@@ -70,6 +71,14 @@ Both completion helpers require a stable `affinityScope`. PI owns auth and endpo
 - active-branch session helper: `getActiveBranchEntries()`
 - terminal helpers such as `formatTitle()`, `signalWaiting()`, and `signalDone()`
 
+### TUI helpers
+
+- `formatTuiTitleLine()` — use the shared title style in terminal lists
+- `renderSelectableRow()` — render a selected row with an aligned value
+- `renderDescriptionViewport()` — show a fixed-height description preview
+- `renderTuiHintLine()` — render short key hints in one line
+- `createSelectListMenu()` — build an action menu with shared key hints
+
 ### Report helpers
 
 - `clampReportWidth()` — enforce a minimum readable report width
@@ -125,3 +134,4 @@ export default function myExtension(pi: ExtensionAPI) {
 - `src/debug-timing.ts` — monotonic total and phase timers for Debug Event Producers
 - `src/settings/` — settings registry, schema, scope resolution, and persistence
 - `src/report.ts` — shared text/report rendering helpers
+- `src/tui.ts` — shared terminal UI list and action-menu helpers

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

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "7.2.1",
+  "version": "7.3.1",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {
@@ -67,6 +67,7 @@
     "./settings": "./src/settings.ts",
     "./spinner-frames": "./src/spinner-frames.ts",
     "./status-spinner": "./src/status-spinner.ts",
-    "./terminal": "./src/terminal.ts"
+    "./terminal": "./src/terminal.ts",
+    "./tui": "./src/tui.ts"
   }
 }

package/node_modules/@mrclrchtr/supi-core/src/api.ts

@@ -38,3 +38,5 @@ export * from "./spinner-frames.ts";
 export * from "./status-spinner.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./terminal.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./tui.ts";

package/node_modules/@mrclrchtr/supi-core/src/index.ts

@@ -34,3 +34,5 @@ export * from "./settings.ts";
 export * from "./status-spinner.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./terminal.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./tui.ts";

package/node_modules/@mrclrchtr/supi-core/src/session-capabilities.ts

@@ -0,0 +1,188 @@
+/** Session-only tool and skill visibility state. */
+export interface SessionCapabilityState {
+  version: 1;
+  eligibleToolNames: string[];
+  initiallyInactiveToolNames: string[];
+  toolDenylist: string[];
+  /** Tools that the user explicitly enabled for this session. */
+  toolEnabledNames?: string[];
+  hiddenSkillNames: string[];
+}
+
+/** A model-visible skill that a provider can offer to the selector. */
+export interface SessionCapabilitySkill {
+  name: string;
+  description: string;
+}
+
+/** Skill inventory provider registered by the skills extension. */
+export interface SessionCapabilitySkillProvider<TContext = unknown> {
+  listEligibleSkills(
+    context: TContext,
+  ): Promise<SessionCapabilitySkill[]> | SessionCapabilitySkill[];
+}
+
+/** Custom session-entry type used for hidden capability snapshots. */
+export const SESSION_CAPABILITIES_ENTRY = "supi-capabilities";
+
+const REGISTRY_PREFIX = "@mrclrchtr/supi-core/session-capabilities/";
+const STATE_KEY = Symbol.for(`${REGISTRY_PREFIX}state`);
+const PROVIDER_KEY = Symbol.for(`${REGISTRY_PREFIX}skill-providers`);
+const FORK_KEY = Symbol.for(`${REGISTRY_PREFIX}pending-forks`);
+
+type GlobalRegistry = typeof globalThis & Record<symbol, unknown>;
+
+type SkillProviderMap = Map<string, SessionCapabilitySkillProvider<unknown>>;
+type ForkStateMap = Map<string, SessionCapabilityState>;
+
+function getStateMap(): Map<string, SessionCapabilityState> {
+  const target = globalThis as GlobalRegistry;
+  let map = target[STATE_KEY] as Map<string, SessionCapabilityState> | undefined;
+  if (!map) {
+    map = new Map();
+    target[STATE_KEY] = map;
+  }
+  return map;
+}
+
+function getProviderMap(): SkillProviderMap {
+  const target = globalThis as GlobalRegistry;
+  let map = target[PROVIDER_KEY] as SkillProviderMap | undefined;
+  if (!map) {
+    map = new Map();
+    target[PROVIDER_KEY] = map;
+  }
+  return map;
+}
+
+function getForkMap(): ForkStateMap {
+  const target = globalThis as GlobalRegistry;
+  let map = target[FORK_KEY] as ForkStateMap | undefined;
+  if (!map) {
+    map = new Map();
+    target[FORK_KEY] = map;
+  }
+  return map;
+}
+
+function stringList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return Array.from(new Set(value.filter((item): item is string => typeof item === "string")));
+}
+
+/** Create an empty state snapshot. */
+export function createEmptySessionCapabilityState(): SessionCapabilityState {
+  return {
+    version: 1,
+    eligibleToolNames: [],
+    initiallyInactiveToolNames: [],
+    toolDenylist: [],
+    toolEnabledNames: [],
+    hiddenSkillNames: [],
+  };
+}
+
+/** Validate and copy one stored snapshot. */
+export function decodeSessionCapabilities(value: unknown): SessionCapabilityState | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const record = value as Record<string, unknown>;
+  if (record.version !== 1) return undefined;
+
+  const initiallyInactiveToolNames = stringList(record.initiallyInactiveToolNames);
+  const initiallyInactive = new Set(initiallyInactiveToolNames);
+  const eligibleToolNames = stringList(record.eligibleToolNames).filter(
+    (name) => !initiallyInactive.has(name),
+  );
+  const eligible = new Set(eligibleToolNames);
+  const toolDenylist = stringList(record.toolDenylist).filter((name) => eligible.has(name));
+  const denied = new Set(toolDenylist);
+
+  return {
+    version: 1,
+    eligibleToolNames,
+    initiallyInactiveToolNames,
+    toolDenylist,
+    toolEnabledNames: stringList(record.toolEnabledNames).filter(
+      (name) => eligible.has(name) && !denied.has(name),
+    ),
+    hiddenSkillNames: stringList(record.hiddenSkillNames),
+  };
+}
+
+/** Return a safe copy of the latest valid snapshot in all session entries. */
+export function findSessionCapabilities(
+  entries: readonly unknown[],
+): SessionCapabilityState | undefined {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (typeof entry !== "object" || entry === null) continue;
+    const record = entry as Record<string, unknown>;
+    if (record.type !== "custom" || record.customType !== SESSION_CAPABILITIES_ENTRY) continue;
+    const state = decodeSessionCapabilities(record.data);
+    if (state) return state;
+  }
+  return undefined;
+}
+
+/** Shared session state. Session IDs keep sessions in the same cwd separate. */
+export const sessionCapabilityState = {
+  get(sessionId: string): SessionCapabilityState | undefined {
+    const state = getStateMap().get(sessionId);
+    return state ? decodeSessionCapabilities(state) : undefined;
+  },
+  set(sessionId: string, state: SessionCapabilityState): void {
+    const decoded = decodeSessionCapabilities(state);
+    if (decoded) getStateMap().set(sessionId, decoded);
+  },
+  clear(sessionId: string): void {
+    getStateMap().delete(sessionId);
+  },
+};
+
+/** Register the current session's skill inventory provider. */
+export function registerSessionCapabilitySkillProvider<TContext>(
+  sessionId: string,
+  provider: SessionCapabilitySkillProvider<TContext>,
+): () => void {
+  const providers = getProviderMap();
+  providers.set(sessionId, provider as SessionCapabilitySkillProvider<unknown>);
+  return () => {
+    if (providers.get(sessionId) === provider) providers.delete(sessionId);
+  };
+}
+
+/** Get the current session's skill inventory provider, if one is loaded. */
+export function getSessionCapabilitySkillProvider<TContext = unknown>(
+  sessionId: string,
+): SessionCapabilitySkillProvider<TContext> | undefined {
+  return getProviderMap().get(sessionId) as SessionCapabilitySkillProvider<TContext> | undefined;
+}
+
+function forkKey(sourceSessionFile: string | undefined): string {
+  return sourceSessionFile ?? "<memory-session>";
+}
+
+/** Hold a state copy until PI starts the forked session. */
+export function setPendingSessionCapabilityFork(
+  sourceSessionFile: string | undefined,
+  state: SessionCapabilityState,
+): void {
+  const decoded = decodeSessionCapabilities(state);
+  if (decoded) getForkMap().set(forkKey(sourceSessionFile), decoded);
+}
+
+/** Take the state copy for one fork. The copy is used once. */
+export function readPendingSessionCapabilityFork(
+  sourceSessionFile: string | undefined,
+): SessionCapabilityState | undefined {
+  const forks = getForkMap();
+  const key = forkKey(sourceSessionFile);
+  const state = forks.get(key);
+  forks.delete(key);
+  return state ? decodeSessionCapabilities(state) : undefined;
+}
+
+/** Clear pending fork copies after a cancelled or unrelated transition. */
+export function clearPendingSessionCapabilityForks(): void {
+  getForkMap().clear();
+}

package/node_modules/@mrclrchtr/supi-core/src/session.ts

@@ -1,6 +1,23 @@
 // supi-core session domain — session utilities and registries.
 
 export { createRegistry, createSessionStateRegistry } from "./registry-utils.ts";
+export type {
+  SessionCapabilitySkill,
+  SessionCapabilitySkillProvider,
+  SessionCapabilityState,
+} from "./session-capabilities.ts";
+export {
+  clearPendingSessionCapabilityForks,
+  createEmptySessionCapabilityState,
+  decodeSessionCapabilities,
+  findSessionCapabilities,
+  getSessionCapabilitySkillProvider,
+  readPendingSessionCapabilityFork,
+  registerSessionCapabilitySkillProvider,
+  SESSION_CAPABILITIES_ENTRY,
+  sessionCapabilityState,
+  setPendingSessionCapabilityFork,
+} from "./session-capabilities.ts";
 export type { SessionNameTrackerHost } from "./session-utils.ts";
 export {
   createSessionNameTracker,

package/node_modules/@mrclrchtr/supi-core/src/tui.ts

@@ -0,0 +1,141 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  type SelectItem,
+  SelectList,
+  type TuiMouseEvent,
+  type TuiMouseEventResult,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+/** The theme methods used by the shared TUI list renderers. */
+export type TuiTheme = Pick<Theme, "fg" | "bold">;
+
+/** Settings for one selectable row in a themed list. */
+export interface SelectableRowOptions {
+  /** The row label. */
+  label: string;
+  /** The value shown beside the label. */
+  value: string;
+  /** The row indent in terminal columns. */
+  indent: number;
+  /** The largest indent used by the list. */
+  maxIndent: number;
+  /** The label column width. */
+  maxLabelWidth: number;
+  /** The row width in terminal columns. */
+  width: number;
+  /** True when this row is selected. */
+  selected: boolean;
+  /** Theme used for row colors. */
+  theme: TuiTheme;
+}
+
+/** Settings for a shared action menu. */
+export interface SelectListMenuOptions {
+  /** The title shown above the choices. */
+  title: string;
+  /** The choices shown in the menu. */
+  items: SelectItem[];
+  /** Theme used for menu colors. */
+  theme: TuiTheme;
+  /** Called when the user selects a choice. */
+  onSelect: (item: SelectItem) => void;
+  /** Called when the user closes the menu without a choice. */
+  onCancel: () => void;
+}
+
+/** Component methods for a shared action menu. */
+export interface SelectListMenuComponent {
+  render(width: number): string[];
+  invalidate(): void;
+  handleInput(data: string): void;
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+}
+
+/** Build a title line with optional right-side tabs in the shared TUI style. */
+export function formatTuiTitleLine(title: string, theme: TuiTheme, trailing = ""): string {
+  const titleText = theme.fg("accent", theme.bold(title));
+  return ` ${titleText}${trailing ? `  ${trailing}` : ""}`;
+}
+
+/** Render one row with a selected marker and an aligned value column. */
+export function renderSelectableRow(options: SelectableRowOptions): string {
+  const indent = Math.max(0, options.indent);
+  const maxIndent = Math.max(indent, options.maxIndent);
+  const maxLabelWidth = Math.max(0, options.maxLabelWidth);
+  const width = Math.max(0, options.width);
+  const label = truncateToWidth(options.label, maxLabelWidth, "");
+  const labelWidth = visibleWidth(label);
+  const prefix = options.selected
+    ? `${" ".repeat(Math.max(0, indent - 2))}${options.theme.fg("accent", "→ ")}`
+    : " ".repeat(indent);
+  const labelPadding = " ".repeat(maxIndent - indent + maxLabelWidth - labelWidth);
+  const valueWidth = Math.max(0, width - maxIndent - maxLabelWidth - 4);
+  const value = truncateToWidth(options.value, valueWidth, "");
+  const labelText = options.theme.fg(options.selected ? "accent" : "text", label + labelPadding);
+  const valueText = options.theme.fg(options.selected ? "accent" : "muted", value);
+
+  return truncateToWidth(`${prefix}${labelText}  ${valueText}`, width);
+}
+
+/** Render a fixed-height, four-line description preview for a selected row. */
+export function renderDescriptionViewport(
+  description: string | undefined,
+  width: number,
+): string[] {
+  const height = 4;
+  const indent = "  ";
+  const contentWidth = Math.max(1, width - 4);
+  const wrapped = description ? wrapTextWithAnsi(description, contentWidth) : [];
+  const visible = wrapped.slice(0, height);
+
+  if (wrapped.length > height) {
+    const lastIndex = height - 1;
+    visible[lastIndex] = truncateToWidth(`${visible[lastIndex] ?? ""}…`, contentWidth, "…");
+  }
+
+  while (visible.length < height) visible.push("");
+  return visible.map((line) => (line ? `${indent}${line}` : ""));
+}
+
+/** Render a dimmed hint line with the shared separator and truncation rules. */
+export function renderTuiHintLine(hints: string[], theme: TuiTheme, width: number): string {
+  return truncateToWidth(theme.fg("dim", hints.join(" · ")), width);
+}
+
+/** Build the shared title, choices, and key hints for an action menu. */
+export function createSelectListMenu(options: SelectListMenuOptions): SelectListMenuComponent {
+  const { items, onSelect, onCancel, theme, title } = options;
+  const selectList = new SelectList(items, Math.min(items.length + 2, 15), {
+    selectedPrefix: (text) => theme.fg("accent", text),
+    selectedText: (text) => theme.fg("accent", text),
+    description: (text) => theme.fg("muted", text),
+    scrollInfo: (text) => theme.fg("dim", text),
+    noMatch: (text) => theme.fg("warning", text),
+  });
+  selectList.onSelect = onSelect;
+  selectList.onCancel = onCancel;
+
+  return {
+    render(width) {
+      return [
+        truncateToWidth(theme.fg("accent", `  ${title}`), width),
+        ...selectList.render(width),
+        "",
+        renderTuiHintLine(["  ↑↓ navigate", "Enter select", "Esc cancel"], theme, width),
+      ];
+    },
+    invalidate() {
+      selectList.invalidate();
+    },
+    handleInput(data) {
+      selectList.handleInput(data);
+    },
+    handleMouse(event) {
+      if (event.y < 1) return undefined;
+      return selectList.handleMouse({ ...event, y: event.y - 1 });
+    },
+  };
+}

package/node_modules/ignore/index.js

@@ -727,6 +727,20 @@ const WILDCARD = '[^\\/]*'
 // The source is read one token at a time -- a wildcard, a single-character
 //   piece (a literal, an escape, a class), or a parenthesised group or anchor
 //   that ends the run -- so only a genuine wildcard is touched.
+
+// The fixed pieces between the wildcard at `at` and the next wildcard of the
+//   run, joined as they appear in the source. A run never holds two wildcards
+//   in a row, so there is always at least one piece.
+const separatorAfter = (run, at) => {
+  let separator = EMPTY
+
+  for (let index = at + 1; index < run.length && !run[index].wildcard; index ++) {
+    separator += run[index].single
+  }
+
+  return separator
+}
+
 const pinWildcards = source => {
   if (source.indexOf(WILDCARD) < 0) {
     return source
@@ -814,14 +828,19 @@ const pinWildcards = source => {
         return
       }
 
-      // A wildcard that is not the last in the run is always immediately
-      //   followed by the single character that separates it from the next
-      //   one, because a run never holds two wildcards in a row, so it can be
-      //   pinned to stop there. The last wildcard stays as it is and takes up
-      //   the rest.
+      // A wildcard that is not the last in the run is pinned to the whole
+      //   fixed piece that separates it from the next wildcard, not just to
+      //   that piece's first character: stopping at the first character alone
+      //   would let the wildcard hand over at a place where the rest of the
+      //   separator cannot follow, and the pin leaves no way back, so
+      //   `f*o/*/*` would miss `foo/b/c` -- the first `o` of `foo` is not the
+      //   one the `o/` after it needs. Every piece matches exactly one
+      //   character, so pinning to the first place the whole separator fits
+      //   is the leftmost place it can sit, and the wildcards that follow
+      //   take up whatever is left.
       out += at === lastWildcard
         ? WILDCARD
-        : `(?:(?!${run[at + 1].single})[^\\/])*`
+        : `(?:(?!${separatorAfter(run, at)})[^\\/])*`
     })
 
     run = []

package/node_modules/ignore/legacy.js

@@ -632,6 +632,17 @@ var WILDCARD = '[^\\/]*';
 // The source is read one token at a time -- a wildcard, a single-character
 //   piece (a literal, an escape, a class), or a parenthesised group or anchor
 //   that ends the run -- so only a genuine wildcard is touched.
+
+// The fixed pieces between the wildcard at `at` and the next wildcard of the
+//   run, joined as they appear in the source. A run never holds two wildcards
+//   in a row, so there is always at least one piece.
+var separatorAfter = function separatorAfter(run, at) {
+  var separator = EMPTY;
+  for (var index = at + 1; index < run.length && !run[index].wildcard; index++) {
+    separator += run[index].single;
+  }
+  return separator;
+};
 var pinWildcards = function pinWildcards(source) {
   if (source.indexOf(WILDCARD) < 0) {
     return source;
@@ -714,12 +725,17 @@ var pinWildcards = function pinWildcards(source) {
         return;
       }
 
-      // A wildcard that is not the last in the run is always immediately
-      //   followed by the single character that separates it from the next
-      //   one, because a run never holds two wildcards in a row, so it can be
-      //   pinned to stop there. The last wildcard stays as it is and takes up
-      //   the rest.
-      out += at === lastWildcard ? WILDCARD : "(?:(?!".concat(run[at + 1].single, ")[^\\/])*");
+      // A wildcard that is not the last in the run is pinned to the whole
+      //   fixed piece that separates it from the next wildcard, not just to
+      //   that piece's first character: stopping at the first character alone
+      //   would let the wildcard hand over at a place where the rest of the
+      //   separator cannot follow, and the pin leaves no way back, so
+      //   `f*o/*/*` would miss `foo/b/c` -- the first `o` of `foo` is not the
+      //   one the `o/` after it needs. Every piece matches exactly one
+      //   character, so pinning to the first place the whole separator fits
+      //   is the leftmost place it can sit, and the wildcards that follow
+      //   take up whatever is left.
+      out += at === lastWildcard ? WILDCARD : "(?:(?!".concat(separatorAfter(run, at), ")[^\\/])*");
     });
     run = [];
   };

package/node_modules/ignore/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignore",
-  "version": "7.0.9",
+  "version": "7.0.10",
   "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/lib/common/connection.js

@@ -781,7 +781,8 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                     }
                 }
             }
-            tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
+            const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : '';
+            tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms.${error}`, data);
         }
         else {
             logLSPMessage('send-response', message);
@@ -1145,7 +1146,6 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
                     responsePromises.delete(id);
                     responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, error.message ? error.message : 'Unknown reason'));
                     logger.error(`Sending request failed.`);
-                    throw error;
                 }
             });
         },

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

@@ -50,6 +50,7 @@ export interface PipeTransport {
 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]>;
 }
 export declare function createClientSocketTransport(port: number, encoding?: RAL.MessageBufferEncoding): Promise<SocketTransport>;

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

@@ -255,7 +255,14 @@ function createClientSocketTransport(port, encoding = 'utf-8') {
         server.on('error', reject);
         server.listen(port, '127.0.0.1', () => {
             server.removeListener('error', reject);
+            const address = server.address();
+            if (address === null || typeof address === 'string') {
+                reject(new Error(`Unexpected server address: ${address}`));
+                return;
+            }
+            const boundPort = address.port;
             resolve({
+                port: () => boundPort,
                 onConnected: () => { return connected; }
             });
         });

package/node_modules/vscode-jsonrpc/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "vscode-jsonrpc",
 	"description": "A json rpc implementation over streams",
-	"version": "9.0.2",
+	"version": "9.0.3",
 	"author": "Microsoft Corporation",
 	"license": "MIT",
 	"repository": {
@@ -34,7 +34,7 @@
 		"msgpack-lite": "^0.1.26"
 	},
 	"scripts": {
-		"prepublishOnly": "echo \"⛔ Can only publish from a secure pipeline ⛔\" && node ../build/npm/fail",
+		"prepublishOnly": "npm run all:publish",
 		"prepack": "npm run all:publish",
 		"preversion": "npm test",
 		"compile": "tsc -b ./tsconfig.json",

package/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlayHint.d.ts

@@ -1,7 +1,7 @@
 import { RequestHandler, RequestHandler0 } from 'vscode-jsonrpc';
 import { Range, TextDocumentIdentifier, InlayHint } from 'vscode-languageserver-types';
 import { CM, MessageDirection, ProtocolRequestType, ProtocolRequestType0 } from './messages';
-import { type StaticRegistrationOptions, type TextDocumentRegistrationOptions, type WorkDoneProgressOptions, type WorkDoneProgressParams } from './protocol';
+import { type PartialResultParams, type StaticRegistrationOptions, type TextDocumentRegistrationOptions, type WorkDoneProgressOptions, type WorkDoneProgressParams } from './protocol';
 /**
  * @since 3.18.0
  */
@@ -67,7 +67,7 @@ export type InlayHintRegistrationOptions = InlayHintOptions & TextDocumentRegist
  *
  * @since 3.17.0
  */
-export type InlayHintParams = WorkDoneProgressParams & {
+export type InlayHintParams = WorkDoneProgressParams & PartialResultParams & {
     /**
      * The text document.
      */

package/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineCompletion.d.ts

@@ -1,7 +1,7 @@
 import { InlineCompletionItem, InlineCompletionContext, InlineCompletionList } from 'vscode-languageserver-types';
 import { RequestHandler } from 'vscode-jsonrpc';
 import { CM, MessageDirection, ProtocolRequestType } from './messages';
-import { type TextDocumentRegistrationOptions, type WorkDoneProgressOptions, type StaticRegistrationOptions, type WorkDoneProgressParams, type TextDocumentPositionParams } from './protocol';
+import { type TextDocumentRegistrationOptions, type WorkDoneProgressOptions, type StaticRegistrationOptions, type WorkDoneProgressParams, type TextDocumentPositionParams, type PartialResultParams } from './protocol';
 /**
  * Client capabilities specific to inline completions.
  *
@@ -30,7 +30,7 @@ export type InlineCompletionRegistrationOptions = InlineCompletionOptions & Text
  *
  * @since 3.18.0
  */
-export type InlineCompletionParams = WorkDoneProgressParams & TextDocumentPositionParams & {
+export type InlineCompletionParams = WorkDoneProgressParams & TextDocumentPositionParams & PartialResultParams & {
     /**
      * Additional information about the context in which inline completions were
      * requested.

package/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineValue.d.ts

@@ -1,7 +1,7 @@
 import { TextDocumentIdentifier, Range, InlineValue, InlineValueContext } from 'vscode-languageserver-types';
 import { RequestHandler, RequestHandler0 } from 'vscode-jsonrpc';
 import { CM, MessageDirection, ProtocolRequestType, ProtocolRequestType0 } from './messages';
-import { type TextDocumentRegistrationOptions, type WorkDoneProgressOptions, type StaticRegistrationOptions, type WorkDoneProgressParams } from './protocol';
+import { type TextDocumentRegistrationOptions, type WorkDoneProgressOptions, type StaticRegistrationOptions, type WorkDoneProgressParams, type PartialResultParams } from './protocol';
 /**
  * Client capabilities specific to inline values.
  *
@@ -47,7 +47,7 @@ export type InlineValueRegistrationOptions = InlineValueOptions & TextDocumentRe
  *
  * @since 3.17.0
  */
-export type InlineValueParams = WorkDoneProgressParams & {
+export type InlineValueParams = WorkDoneProgressParams & PartialResultParams & {
     /**
      * The text document.
      */

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

@@ -1,7 +1,7 @@
 {
 	"name": "vscode-languageserver-protocol",
 	"description": "VSCode Language Server Protocol implementation",
-	"version": "3.18.3",
+	"version": "3.18.4",
 	"author": "Microsoft Corporation",
 	"license": "MIT",
 	"repository": {
@@ -27,11 +27,11 @@
 		}
 	},
 	"dependencies": {
-		"vscode-jsonrpc": "9.0.2",
-		"vscode-languageserver-types": "3.18.3"
+		"vscode-jsonrpc": "9.0.3",
+		"vscode-languageserver-types": "3.18.4"
 	},
 	"scripts": {
-		"prepublishOnly": "echo \"⛔ Can only publish from a secure pipeline ⛔\" && node ../build/npm/fail",
+		"prepublishOnly": "npm run all:publish",
 		"prepack": "npm run all:publish",
 		"postpublish": "node ../build/npm/post-publish.js",
 		"preversion": "npm test",

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

@@ -1,7 +1,7 @@
 {
 	"name": "vscode-languageserver-types",
 	"description": "Types used by the Language server for node",
-	"version": "3.18.3",
+	"version": "3.18.4",
 	"author": "Microsoft Corporation",
 	"license": "MIT",
 	"repository": {
@@ -23,7 +23,7 @@
 		}
 	},
 	"scripts": {
-		"prepublishOnly": "echo \"⛔ Can only publish from a secure pipeline ⛔\" && node ../build/npm/fail",
+		"prepublishOnly": "npm run all:publish",
 		"prepack": "npm run all:publish",
 		"compile": "tsc -b ./tsconfig.json",
 		"clean": "rimraf lib",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "7.2.1",
+  "version": "7.3.1",
   "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": "7.2.1",
-    "@mrclrchtr/supi-core": "7.2.1"
+    "@mrclrchtr/supi-core": "7.3.1",
+    "@mrclrchtr/supi-code-runtime": "7.3.1"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",