Add LSP inline value provider support for mcfunction and Molang documents (#498)

This change adds first-class inline values support to the language
server so debug sessions can request variable lookups directly from the
server. The implementation introduces the `textDocument/inlineValue`
capability and handles requests for supported Bedrock script languages.

- **Capability + handler wiring**
- Added a new `InlineValueService` in
`ide/base/server/src/lsp/inline-values/service.ts`.
  - Advertises `inlineValueProvider` during initialization.
  - Registers a `connection.languages.inlineValue.on(...)` handler.

- **Inline value generation**
  - Supports `mcfunction` and `molang` documents.
- Scans requested line ranges for variable-like identifiers and emits
`InlineValueVariableLookup` entries.
- Constrains processing to the requested range / stopped location
context and returns empty results for unsupported docs.

- **Server integration**
- Wired `InlineValueService` into `setupServer(...)` service
registration in `ide/base/server/src/lsp/server/setup.ts`.

```ts
onInitialize(capabilities: CapabilityBuilder): void {
  capabilities.set('inlineValueProvider', {
    workDoneProgress: true,
  });
}

setupHandlers(connection: Connection): void {
  this.addDisposable(connection.languages.inlineValue.on(this.onInlineValue.bind(this)));
}
```

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: DaanV2 <2393905+DaanV2@users.noreply.github.com>

Author: Copilot

ide/base/server/src/lsp/inline-values/service.ts

@@ -0,0 +1,80 @@
+import { Languages } from '@blockception/ide-shared';
+import {
+  Connection,
+  InlineValue,
+  InlineValueParams,
+  InlineValueVariableLookup,
+  Range,
+} from 'vscode-languageserver';
+import { ExtensionContext } from '../extension';
+import { IExtendedLogger } from '../logger/logger';
+import { BaseService } from '../services/base';
+import { CapabilityBuilder } from '../services/capabilities';
+import { IService } from '../services/service';
+
+const VariablePattern = /\b[a-zA-Z_][a-zA-Z0-9_.]*\b/g;
+
+export class InlineValueService extends BaseService implements IService {
+  readonly name: string = 'inline-values';
+
+  constructor(logger: IExtendedLogger, extension: ExtensionContext) {
+    super(logger.withPrefix('[inline-values]'), extension);
+  }
+
+  onInitialize(capabilities: CapabilityBuilder): void {
+    capabilities.set('inlineValueProvider', {
+      workDoneProgress: true,
+    });
+  }
+
+  setupHandlers(connection: Connection): void {
+    this.addDisposable(connection.languages.inlineValue.on(this.onInlineValue.bind(this)));
+  }
+
+  private async onInlineValue(params: InlineValueParams): Promise<InlineValue[]> {
+    const document = this.extension.documents.get(params.textDocument.uri);
+    if (!document) return [];
+
+    if (!SupportsInlineValues(document.languageId)) return [];
+
+    const output: InlineValue[] = [];
+    const startLine = Math.max(params.range.start.line, 0);
+    const endLine = Math.min(params.range.end.line, params.context.stoppedLocation.start.line);
+
+    for (let line = startLine; line <= endLine; line++) {
+      const text = document.getLine(line);
+      const lineStart = line === params.range.start.line ? params.range.start.character : 0;
+      const lineEnd = line === params.range.end.line ? params.range.end.character : text.length;
+      if (lineEnd <= lineStart) continue;
+
+      const segment = text.slice(lineStart, lineEnd);
+      VariablePattern.lastIndex = 0;
+
+      for (let match = VariablePattern.exec(segment); match !== null; match = VariablePattern.exec(segment)) {
+        const variableName = match[0];
+        if (IsIgnoredName(variableName)) continue;
+
+        const startCharacter = lineStart + match.index;
+        const endCharacter = startCharacter + variableName.length;
+
+        output.push(
+          InlineValueVariableLookup.create(
+            Range.create(line, startCharacter, line, endCharacter),
+            variableName,
+            true,
+          ),
+        );
+      }
+    }
+
+    return output;
+  }
+}
+
+function SupportsInlineValues(languageId: string): boolean {
+  return languageId === Languages.McFunctionIdentifier || languageId === Languages.McMolangIdentifier;
+}
+
+function IsIgnoredName(variableName: string): boolean {
+  return variableName === 'true' || variableName === 'false';
+}

ide/base/server/src/lsp/server/setup.ts

@@ -10,6 +10,7 @@ import { DiagnoserService } from '../diagnostics/service';
 import { DocumentManager, IDocumentManager } from '../documents/manager';
 import { ExtensionContext } from '../extension';
 import { FormatService } from '../format/service';
+import { InlineValueService } from '../inline-values/service';
 import { ExtendedLogger } from '../logger/logger';
 import { DocumentProcessor, PackProcessor, WorkspaceProcessor } from '../process';
 import { DefinitionService, ImplementationService, ReferenceService, TypeDefinitionService } from '../references';
@@ -57,6 +58,7 @@ export function setupServer(config: LSPConfig) {
       new DocumentSymbolService(logger, extension),
       new FormatService(logger, extension),
       new ImplementationService(logger, extension),
+      new InlineValueService(logger, extension),
       new ReferenceService(logger, extension),
       new SemanticsServer(logger, extension),
       new SignatureService(logger, extension),