@askdkc/dsh-lsp-server 0.1.12 → 0.1.13

package/lib/structure/parser-worker.mjs

@@ -0,0 +1,200 @@
+import { Language, Parser, Query } from 'web-tree-sitter'
+
+const port = (await import('node:worker_threads')).parentPort
+if (!port) throw new Error('structure worker requires a parent port')
+
+const assets = {
+  javascript: 'tree-sitter-javascript.wasm',
+  typescript: 'tree-sitter-typescript.wasm',
+  tsx: 'tree-sitter-tsx.wasm',
+}
+const MAX_CACHE_ENTRIES = 16
+const MAX_CACHE_BYTES = 16 * 1024 * 1024
+let init
+const languages = new Map()
+const trees = new Map()
+let cachedBytes = 0
+
+async function loadLanguage(language) {
+  if (!assets[language]) throw new Error('unsupported grammar')
+  init ??= Parser.init()
+  await init
+  if (!languages.has(language)) {
+    const url = new URL(`./grammars/${assets[language]}`, import.meta.url)
+    languages.set(language, await Language.load(url))
+  }
+  return languages.get(language)
+}
+
+function summarizeErrors(root, limit = 100) {
+  const stack = [root]
+  let errorNodes = 0, missingNodes = 0, visited = 0
+  while (stack.length && visited < 200_000) {
+    const node = stack.pop()
+    visited++
+    if (node.type === 'ERROR') errorNodes++
+    if (node.isMissing) missingNodes++
+    if (errorNodes + missingNodes >= limit) break
+    for (const child of node.children) stack.push(child)
+  }
+  return { hasError: root.hasError, errorNodes: Math.min(errorNodes, limit), missingNodes: Math.min(missingNodes, limit), truncated: stack.length > 0 }
+}
+
+function nodeSummary(node) {
+  const name = node.childForFieldName('name')
+  return {
+    kind: node.type,
+    startIndex: node.startIndex,
+    endIndex: node.endIndex,
+    startPosition: node.startPosition,
+    endPosition: node.endPosition,
+    ...(name ? { nameStartIndex: name.startIndex, nameEndIndex: name.endIndex } : {}),
+    childCount: node.namedChildCount,
+  }
+}
+
+async function run(request) {
+  const language = await loadLanguage(request.language)
+  let cached = request.snapshotHandle ? trees.get(request.snapshotHandle) : undefined
+  let incremental = false
+  if (cached && (cached.languageName !== request.language || cached.text !== request.text)) {
+    cached.tree.delete()
+    cachedBytes -= cached.bytes
+    trees.delete(request.snapshotHandle)
+    cached = undefined
+  }
+  let previous = !cached && request.previousSnapshotHandle ? trees.get(request.previousSnapshotHandle) : undefined
+  if (previous && previous.languageName !== request.language) previous = undefined
+  let tree = cached?.tree
+  let parser
+  try {
+    if (tree) {
+      trees.delete(request.snapshotHandle)
+      trees.set(request.snapshotHandle, cached)
+    } else if (previous && previous.text === request.text) {
+      trees.delete(request.previousSnapshotHandle)
+      tree = previous.tree
+      if (request.snapshotHandle) trees.set(request.snapshotHandle, previous)
+      else { cachedBytes -= previous.bytes; tree.delete() }
+    } else {
+      parser = new Parser()
+      parser.setLanguage(language)
+      if (previous) {
+        try {
+          const edit = changedRange(previous.text, request.text)
+          previous.tree.edit(edit)
+          tree = parser.parse(request.text, previous.tree)
+          incremental = Boolean(tree)
+        } catch {
+          tree = undefined
+        } finally {
+          trees.delete(request.previousSnapshotHandle)
+          cachedBytes -= previous.bytes
+          previous.tree.delete()
+        }
+      }
+      tree ??= parser.parse(request.text)
+      if (!tree) throw new Error('parser returned no tree')
+      if (request.snapshotHandle && Buffer.byteLength(request.text, 'utf8') <= MAX_CACHE_BYTES) {
+        const bytes = Buffer.byteLength(request.text, 'utf8')
+        trees.set(request.snapshotHandle, { tree, text: request.text, languageName: request.language, bytes })
+        cachedBytes += bytes
+        while (trees.size > MAX_CACHE_ENTRIES || cachedBytes > MAX_CACHE_BYTES) {
+          const [oldestKey, oldest] = trees.entries().next().value
+          trees.delete(oldestKey)
+          cachedBytes -= oldest.bytes
+          oldest.tree.delete()
+          if (oldestKey === request.snapshotHandle) {
+            tree = undefined
+            break
+          }
+        }
+      }
+    }
+    const root = tree.rootNode
+    const errors = summarizeErrors(root)
+    if (request.operation === 'inspect') return { status: errors.hasError ? 'partial' : 'ok', errors, abiVersion: language.abiVersion, reusedTree: Boolean(cached), incremental }
+    if (request.operation === 'enclosing') {
+      const leaf = root.namedDescendantForIndex(request.index, request.index) ?? root
+      const allowed = request.kinds?.length ? new Set(request.kinds) : undefined
+      const nodes = []
+      for (let node = leaf; node && nodes.length < 16; node = node.parent) {
+        if (!allowed || allowed.has(node.type)) nodes.push(nodeSummary(node))
+      }
+      return { status: errors.hasError ? 'partial' : 'ok', nodes, errors, reusedTree: Boolean(cached), incremental }
+    }
+    const query = new Query(language, request.querySource)
+    try {
+      const options = {
+        matchLimit: Math.max(1, Math.min(2048, request.limit + 1)),
+        ...(request.startIndex === undefined ? {} : { startIndex: request.startIndex }),
+        ...(request.endIndex === undefined ? {} : { endIndex: request.endIndex }),
+      }
+      const matches = query.matches(root, options)
+      const result = matches.slice(0, request.limit + 1).map(match => ({
+        captures: match.captures.map(capture => ({ name: capture.name, ...nodeSummary(capture.node) })),
+      }))
+      return { status: errors.hasError ? 'partial' : 'ok', matches: result, truncated: matches.length > request.limit, errors, reusedTree: Boolean(cached), incremental }
+    } finally { query.delete() }
+  } finally {
+    if (tree && (!request.snapshotHandle || trees.get(request.snapshotHandle)?.tree !== tree)) tree.delete()
+    parser?.delete()
+  }
+}
+
+function changedRange(oldText, newText) {
+  let prefix = 0
+  const sharedLength = Math.min(oldText.length, newText.length)
+  while (prefix < sharedLength && oldText.charCodeAt(prefix) === newText.charCodeAt(prefix)) prefix++
+  while (prefix > 0 && (splitsSurrogate(oldText, prefix) || splitsSurrogate(newText, prefix))) prefix--
+
+  let suffix = 0
+  while (suffix < oldText.length - prefix && suffix < newText.length - prefix &&
+    oldText.charCodeAt(oldText.length - suffix - 1) === newText.charCodeAt(newText.length - suffix - 1)) suffix++
+  while (suffix > 0 && (splitsSurrogate(oldText, oldText.length - suffix) || splitsSurrogate(newText, newText.length - suffix))) suffix--
+
+  const oldEndIndex = oldText.length - suffix
+  const newEndIndex = newText.length - suffix
+  return {
+    startIndex: prefix,
+    oldEndIndex,
+    newEndIndex,
+    startPosition: pointAt(oldText, prefix),
+    oldEndPosition: pointAt(oldText, oldEndIndex),
+    newEndPosition: pointAt(newText, newEndIndex),
+  }
+}
+
+function pointAt(text, index) {
+  let row = 0
+  let lineStart = 0
+  for (let cursor = 0; cursor < index; cursor++) {
+    if (text.charCodeAt(cursor) === 10) { row++; lineStart = cursor + 1 }
+  }
+  return { row, column: index - lineStart }
+}
+
+function splitsSurrogate(text, index) {
+  if (index <= 0 || index >= text.length) return false
+  const before = text.charCodeAt(index - 1)
+  const after = text.charCodeAt(index)
+  return before >= 0xd800 && before <= 0xdbff && after >= 0xdc00 && after <= 0xdfff
+}
+
+port.on('message', async request => {
+  if (typeof request.releaseSnapshotHandle === 'string') {
+    const cached = trees.get(request.releaseSnapshotHandle)
+    if (cached) {
+      trees.delete(request.releaseSnapshotHandle)
+      cachedBytes -= cached.bytes
+      cached.tree.delete()
+    }
+    return
+  }
+  try {
+    const value = await run(request)
+    port.postMessage({ id: request.id, ok: true, value })
+  } catch (error) {
+    port.postMessage({ id: request.id, ok: false, error: error instanceof Error ? error.message.slice(0, 500) : 'structure parse failed' })
+  }
+})

package/lib/types/code-intelligence-contracts.d.ts

@@ -0,0 +1,113 @@
+/** Side-effect-free V1 protocol shared with protected Lisp adapters. */
+export declare const CODE_INTELLIGENCE_SERVICE: "codeIntelligence";
+export declare const CODE_INTELLIGENCE_VERSION: 1;
+export type CodeStatus = 'ok' | 'partial' | 'unsupported' | 'unavailable' | 'stale' | 'cancelled' | 'timeout' | 'limit_exceeded';
+export interface CodePosition {
+    line: number;
+    character: number;
+}
+export interface CodeRange {
+    start: CodePosition;
+    end: CodePosition;
+}
+export type CodeSemanticKind = 'definition' | 'references' | 'implementation' | 'hover' | 'diagnostics' | 'completion';
+export type CodeQueryId = 'declarations' | 'calls' | 'imports';
+export type CodeRequestV1 = {
+    method: 'capabilities';
+} | {
+    method: 'snapshot.open';
+    path: string;
+} | {
+    method: 'snapshot.release';
+    handle: string;
+} | {
+    method: 'structure.outline';
+    handle: string;
+    range?: CodeRange;
+    limit?: number;
+} | {
+    method: 'structure.enclosing';
+    handle: string;
+    position: CodePosition;
+    kinds?: string[];
+} | {
+    method: 'structure.query';
+    handle: string;
+    queryId: CodeQueryId;
+    range?: CodeRange;
+    limit?: number;
+} | {
+    method: 'structure.span';
+    nodeHandle: string;
+    maxChars?: number;
+} | {
+    method: 'semantic.query';
+    handle: string;
+    kind: CodeSemanticKind;
+    position?: CodePosition;
+    limit?: number;
+};
+export interface CodeCapabilitiesV1 {
+    version: 1;
+    capabilities: Array<'snapshots' | 'structure' | 'semantic'>;
+    languages: string[];
+    queryIds: CodeQueryId[];
+    semanticReady: boolean;
+    sourceKinds: ['disk'];
+    languageCapabilities: Array<{
+        language: string;
+        structure: boolean;
+        semantic: CodeSemanticKind[];
+        semanticReady: boolean;
+        reason?: string;
+    }>;
+    limits: {
+        documentBytes: number;
+        captureItems: number;
+        outlineItems: number;
+        spanChars: number;
+        responseBytes: number;
+        files: number;
+        inputBytes: number;
+        outputBytes: number;
+        calls: number;
+        batchMs: number;
+        structureMs: number;
+        semanticMs: number;
+    };
+}
+export interface CodeResponseV1 {
+    protocol: 'code-intelligence/v1';
+    status: CodeStatus;
+    reason?: string;
+    sourceKind: 'disk';
+    freshness: 'pinned' | 'current' | 'unknown' | 'stale';
+    snapshotVersion?: string;
+    truncated: boolean;
+    omitted: number;
+    inputBytes?: number;
+    data?: unknown;
+}
+/** Authority comes from the host binding, never from code primitive arguments. */
+export interface CodeHostBindingV1 {
+    owner: {
+        agentId: string;
+        sessionId: string;
+    };
+    workspaceRoot: string;
+    scope: object;
+    context: {
+        get(name: string, strict?: boolean): unknown;
+    };
+    assertCurrent(): void | Promise<void>;
+}
+export interface CodeLeaseV1 {
+    request(input: CodeRequestV1, signal: AbortSignal): Promise<CodeResponseV1>;
+    dispose(): Promise<void>;
+}
+export interface CodeIntelligenceServiceV1 {
+    version: 1;
+    capabilities: readonly ('snapshots' | 'structure' | 'semantic')[];
+    bind(binding: CodeHostBindingV1, signal: AbortSignal): Promise<CodeLeaseV1>;
+    dispose?(): Promise<void>;
+}

package/lib/types/code-intelligence.d.ts

@@ -0,0 +1,5 @@
+export { CODE_INTELLIGENCE_SERVICE, CODE_INTELLIGENCE_VERSION } from './code-intelligence-contracts.js';
+export type { CodeCapabilitiesV1, CodeHostBindingV1, CodeIntelligenceServiceV1, CodeLeaseV1, CodePosition, CodeQueryId, CodeRange, CodeRequestV1, CodeResponseV1, CodeSemanticKind, CodeStatus } from './code-intelligence-contracts.js';
+export type { CodeIntelligenceCapabilities, CodeIntelligenceStatus, SemanticOperation, SemanticQuery, SemanticResult, SnapshotDescriptor, SnapshotOpenResult, SnapshotReleaseResult, SnapshotScope, SourceKind, StructureCapture, StructureEnclosingResult, StructureErrorSummary, StructureLanguage, StructureNode, StructureOutlineResult, StructureQueryResult, StructureSpanResult } from './structure/types.js';
+export { createCodeIntelligenceToolServiceV1 } from './structure/code-intelligence.js';
+export type { CodeIntelligenceToolServiceV1 } from './structure/types.js';

package/lib/types/errors.d.ts

@@ -1,5 +1,5 @@
 import { LspError } from '@deepseek-ai/dsh-lsp';
-export type WebstackErrorCode = 'LSP_UNAVAILABLE' | 'LSP_UNSUPPORTED_OPERATION' | 'LSP_DISPOSED' | 'LSP_MALFORMED_RESPONSE' | 'LSP_CONFLICT' | 'LSP_WORKSPACE_REQUIRED' | 'LSP_WEBSTACK_CONFIG_INVALID';
+export type WebstackErrorCode = 'LSP_UNAVAILABLE' | 'LSP_UNSUPPORTED_OPERATION' | 'LSP_DISPOSED' | 'LSP_MALFORMED_RESPONSE' | 'LSP_CONFLICT' | 'LSP_WORKSPACE_REQUIRED' | 'LSP_WEBSTACK_CONFIG_INVALID' | 'LSP_STALE_SNAPSHOT' | 'LSP_SNAPSHOT_LIMIT' | 'LSP_STRUCTURE_BUSY' | 'LSP_STRUCTURE_TIMEOUT' | 'LSP_STRUCTURE_LIMIT' | 'LSP_STRUCTURE_UNAVAILABLE' | 'LSP_STRUCTURE_UNSUPPORTED' | 'LSP_CODE_INTELLIGENCE_UNAVAILABLE';
 export declare class WebstackLspError extends LspError {
     readonly code: WebstackErrorCode;
     constructor(code: WebstackErrorCode, message: string, options?: ErrorOptions);

package/lib/types/extra-tool.d.ts

@@ -1,6 +1,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
 import type { WebstackLspService } from './service.js';
+import type { CodeIntelligenceToolServiceV1 } from './structure/types.js';
 export declare const name = "lsp_extra";
 export declare const inject: string[];
 export interface Config {
@@ -9,5 +10,5 @@ export interface Config {
     maxResultChars?: number;
     timeoutMs?: number;
 }
-export declare function createExtraTool(service: WebstackLspService, config?: Config): ToolDefinition;
+export declare function createExtraTool(service: WebstackLspService, codeIntelligence?: CodeIntelligenceToolServiceV1, config?: Config): ToolDefinition;
 export declare function apply(ctx: Context, config?: Config): void;

package/lib/types/provider.d.ts

@@ -2,6 +2,8 @@ import type { Context } from '@deepseek-ai/cordis';
 import type { LspProvider, LspProviderQuery, LspQueryResult } from '@deepseek-ai/dsh-lsp';
 import type { Config as PluginConfig, ResolvedConfig } from './config.js';
 import type { WebstackLspService } from './service.js';
+import type { CodeIntelligenceServiceV1 } from './code-intelligence-contracts.js';
+import type { CodeIntelligenceToolServiceV1 } from './structure/types.js';
 export type { LspProvider, LspProviderQuery, LspQueryResult };
 export type Config = PluginConfig;
 export declare const name = "lsp-webstack-provider";
@@ -9,6 +11,8 @@ export declare const inject: string[];
 declare module '@deepseek-ai/cordis' {
     interface Context {
         webstackLsp: WebstackLspService;
+        codeIntelligence: CodeIntelligenceServiceV1;
+        codeIntelligenceRuntime: CodeIntelligenceToolServiceV1;
     }
 }
 export declare const OUTER_EXTENSION_MAP: {

package/lib/types/runtime/webstack-runtime.d.ts

@@ -3,12 +3,18 @@ import type { SubprocessRuntime } from '@deepseek-ai/dsh-subprocess';
 import type { ResolvedConfig } from '../config.js';
 import { type HostFileSystem } from '../host/dsh.js';
 import type { CompletionRequest, CompletionResult, DiagnosticsRequest, DiagnosticsResult, WebstackLspStatus } from '../service.js';
+import type { CodeIntelligenceServiceV1 } from '../code-intelligence-contracts.js';
+import type { CodeIntelligenceToolServiceV1 } from '../structure/types.js';
 export type HostSubprocess = Pick<SubprocessRuntime, 'spawn' | 'resolveExecutable'>;
 export declare class WebstackLspRuntime {
     private readonly config;
     private readonly fs;
     private readonly subprocess;
     private readonly pool;
+    private readonly snapshots;
+    readonly codeIntelligence: CodeIntelligenceServiceV1;
+    readonly codeIntelligenceRuntime: CodeIntelligenceToolServiceV1;
+    private readonly semanticOperations;
     private readonly workspaces;
     private readonly lifetime;
     private readonly live;
@@ -16,12 +22,18 @@ export declare class WebstackLspRuntime {
     private readonly restarts;
     constructor(config: ResolvedConfig, fs: HostFileSystem, subprocess: HostSubprocess);
     navigation(request: LspProviderQuery, signal?: AbortSignal): Promise<LspQueryResult>;
+    private navigationFromSource;
     completion(request: CompletionRequest, signal?: AbortSignal): Promise<CompletionResult>;
+    private completionFromSource;
     diagnostics(request: DiagnosticsRequest, signal?: AbortSignal): Promise<DiagnosticsResult>;
-    status(): Promise<WebstackLspStatus>;
+    private diagnosticsFromSource;
+    private semanticFromSnapshot;
+    status(signal?: AbortSignal): Promise<WebstackLspStatus>;
+    private codeCapabilities;
     dispose(): Promise<void>;
     private signal;
     private prepare;
+    private rememberWorkspace;
     private validatePosition;
     private useTailwind;
     private document;

package/lib/types/service.d.ts

@@ -43,6 +43,22 @@ export interface NormalizedCompletionItem {
     insertTextFormat?: number;
     deprecated?: boolean;
 }
+export type NavigationResult = {
+    kind: 'locations';
+    locations: ReadonlyArray<{
+        uri: string;
+        range: LspRange;
+    }>;
+    resolvedWorkspaceUri: string;
+    truncated?: boolean;
+    omitted?: number;
+} | {
+    kind: 'hover';
+    hover: {
+        contents: string;
+        range?: LspRange;
+    } | null;
+};
 /** A skipped diagnostic query is unverified; an empty diagnostics array alone is not evidence of a clean file. */
 export interface DiagnosticsResult {
     skipped?: {

package/lib/types/structure/code-intelligence.d.ts

@@ -0,0 +1,23 @@
+import { DocumentSnapshotStore } from './snapshots.js';
+import type { SnapshotRecord } from './snapshots.js';
+import type { CodeIntelligenceCapabilities, CodeIntelligenceToolServiceV1, SemanticQuery, SnapshotScope } from './types.js';
+import type { CompletionResult, DiagnosticsResult, NavigationResult } from '../service.js';
+export interface CodeIntelligenceServiceOptions {
+    snapshots: DocumentSnapshotStore;
+    semanticQuery(scope: SnapshotScope, snapshot: SnapshotRecord, request: SemanticQuery, signal: AbortSignal): Promise<CompletionResult | DiagnosticsResult | NavigationResult>;
+}
+export declare class CodeIntelligenceRuntime implements CodeIntelligenceToolServiceV1 {
+    readonly version: 1;
+    readonly snapshot: CodeIntelligenceToolServiceV1['snapshot'];
+    readonly structure: CodeIntelligenceToolServiceV1['structure'];
+    readonly semantic: CodeIntelligenceToolServiceV1['semantic'];
+    private readonly store;
+    private readonly engine;
+    constructor(options: CodeIntelligenceServiceOptions);
+    capabilities(): CodeIntelligenceCapabilities;
+    releaseOwner(scope: SnapshotScope): Promise<number>;
+    dispose(): Promise<void>;
+    private span;
+    private withSnapshot;
+}
+export declare function createCodeIntelligenceToolServiceV1(options: CodeIntelligenceServiceOptions): CodeIntelligenceToolServiceV1;

package/lib/types/structure/coordinates.d.ts

@@ -0,0 +1,14 @@
+import type { LspPosition, LspRange } from '../service.js';
+/** web-tree-sitter 0.27.1 exposes JS-string indices as UTF-16 code-unit offsets. */
+export declare class Utf16Coordinates {
+    private readonly text;
+    private readonly lines;
+    constructor(text: string);
+    positionToIndex(position: LspPosition): number;
+    indexToPosition(index: number): LspPosition;
+    rangeToIndices(range: LspRange): {
+        startIndex: number;
+        endIndex: number;
+    };
+    indicesToRange(startIndex: number, endIndex: number): LspRange;
+}

package/lib/types/structure/engine.d.ts

@@ -0,0 +1,49 @@
+import { type SnapshotRecord } from './snapshots.js';
+import { StructureWorkerPool } from './worker-pool.js';
+import type { SnapshotScope, StructureEnclosingResult, StructureLanguage, StructureNode, StructureOutlineResult, StructureQueryResult, StructureSpanResult } from './types.js';
+export declare const MAX_CAPTURES = 200;
+export declare const MAX_OUTLINE = 100;
+export declare const MAX_SPAN_CHARS = 8000;
+export declare const MAX_STRUCTURE_RESPONSE_BYTES: number;
+export declare class StructureEngine {
+    private readonly workers;
+    private readonly nodeHandles;
+    private readonly snapshotOwners;
+    private readonly parserFailures;
+    constructor(workers?: StructureWorkerPool);
+    inspect(record: SnapshotRecord, signal?: AbortSignal): Promise<{
+        available: boolean;
+        parseErrors: boolean;
+        reason?: string;
+    }>;
+    outline(record: SnapshotRecord, scope: SnapshotScope, options?: {
+        range?: StructureNode['range'];
+        limit?: number;
+    }, signal?: AbortSignal): Promise<StructureOutlineResult>;
+    enclosing(record: SnapshotRecord, scope: SnapshotScope, position: {
+        line: number;
+        character: number;
+    }, kinds?: string[], signal?: AbortSignal): Promise<StructureEnclosingResult>;
+    query(record: SnapshotRecord, scope: SnapshotScope, queryId: string, options?: {
+        range?: StructureNode['range'];
+        limit?: number;
+    }, signal?: AbortSignal): Promise<StructureQueryResult>;
+    span(record: SnapshotRecord, scope: SnapshotScope, nodeHandle: string, maxChars?: number): Promise<StructureSpanResult>;
+    releaseSnapshot(handle: string): void;
+    releaseSnapshotForOwner(scope: SnapshotScope, handle: string): void;
+    snapshotForNode(scope: SnapshotScope, nodeHandle: string): string;
+    releaseOwner(scope: SnapshotScope): void;
+    capabilities(): Array<{
+        language: StructureLanguage;
+        extensions: string[];
+        available: boolean;
+        abiVersion: number | null;
+        lastError?: string;
+    }>;
+    dispose(): Promise<void>;
+    private runMatches;
+    private capability;
+    private runWorker;
+    private outlineResult;
+    private node;
+}

package/lib/types/structure/protocol.d.ts

@@ -0,0 +1,19 @@
+import type { CodeCapabilitiesV1, CodeHostBindingV1, CodeIntelligenceServiceV1, CodeLeaseV1 } from '../code-intelligence-contracts.js';
+import type { CodeIntelligenceToolServiceV1 } from './types.js';
+export interface CodeIntelligenceProtocolOptions {
+    backend: CodeIntelligenceToolServiceV1;
+    fs: unknown;
+    subprocess: unknown;
+    capabilities(signal: AbortSignal): Promise<CodeCapabilitiesV1>;
+}
+/** Host-bound V1 facade. Each lease owns its handles and cumulative evaluation budget. */
+export declare class CodeIntelligenceProtocolService implements CodeIntelligenceServiceV1 {
+    private readonly options;
+    readonly version: 1;
+    readonly capabilities: readonly ["snapshots", "structure", "semantic"];
+    private readonly leases;
+    private closed;
+    constructor(options: CodeIntelligenceProtocolOptions);
+    bind(binding: CodeHostBindingV1, signal: AbortSignal): Promise<CodeLeaseV1>;
+    dispose(): Promise<void>;
+}

package/lib/types/structure/queries.d.ts

@@ -0,0 +1,4 @@
+import type { StructureLanguage } from './types.js';
+export type RegisteredQueryId = 'declarations' | 'calls' | 'imports';
+export declare function getRegisteredQuery(language: StructureLanguage, queryId: string): string | undefined;
+export declare function isRegisteredQueryId(value: string): value is RegisteredQueryId;

package/lib/types/structure/snapshots.d.ts

@@ -0,0 +1,37 @@
+import type { HostSource } from '../host/dsh.js';
+import type { SnapshotDescriptor, SnapshotScope, StructureLanguage } from './types.js';
+export declare const SNAPSHOT_TTL_MS: number;
+export declare const SNAPSHOT_MAX_DOCUMENTS = 32;
+export declare const SNAPSHOT_MAX_BYTES: number;
+export declare const STRUCTURE_MAX_DOCUMENT_BYTES: number;
+export interface SnapshotRecord {
+    readonly descriptor: SnapshotDescriptor;
+    readonly scopeKey: string;
+    readonly source: HostSource;
+    readonly previousSnapshotHandle?: string;
+    readonly openedAt: number;
+    lastUsedAt: number;
+}
+export type SnapshotReader = (workspaceRoot: string, filePath: string, maxBytes: number, signal?: AbortSignal) => Promise<HostSource>;
+export declare class DocumentSnapshotStore {
+    private readonly readSource;
+    private readonly maxDocumentBytes;
+    private readonly records;
+    private readonly versions;
+    constructor(readSource: SnapshotReader, maxDocumentBytes: number);
+    open(scope: SnapshotScope, filePath: string, signal?: AbortSignal): Promise<SnapshotRecord>;
+    current(scope: SnapshotScope, handle: string, signal?: AbortSignal): Promise<SnapshotRecord>;
+    readFresh(scope: SnapshotScope, filePath: string, signal?: AbortSignal): Promise<HostSource>;
+    release(scope: SnapshotScope, handle: string): boolean;
+    releaseOwner(scope: SnapshotScope): number;
+    clear(): void;
+    get size(): number;
+    get documentByteLimit(): number;
+    private totalBytes;
+    private rememberVersion;
+    private evictExpired;
+}
+export declare function languageForPath(filePath: string): StructureLanguage | null;
+export declare function validateScope(scope: SnapshotScope): void;
+export declare function normalizeRelativePath(filePath: string): string;
+export declare function scopeIdentity(scope: SnapshotScope): string;