@askdkc/dsh-lsp-server 0.1.12 → 0.1.14

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;

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

@@ -0,0 +1,147 @@
+import type { CompletionResult, DiagnosticsResult, LspPosition, LspRange, NavigationResult } from '../service.js';
+export type StructureLanguage = 'javascript' | 'typescript' | 'tsx';
+export type CodeIntelligenceStatus = 'ok' | 'partial' | 'unsupported' | 'unavailable' | 'stale' | 'cancelled' | 'timeout' | 'limit_exceeded';
+export type SourceKind = 'disk' | 'overlay';
+/** Values are created by the trusted host adapter, never from model arguments. */
+export interface SnapshotScope {
+    ownerId: string;
+    sessionId: string;
+    workspaceRoot: string;
+}
+export interface SnapshotDescriptor {
+    handle: string;
+    version: number;
+    filePath: string;
+    language: StructureLanguage | null;
+    sourceKind: SourceKind;
+    contentHash: string;
+    sourceBytes: number;
+}
+export interface SnapshotOpenResult extends SnapshotDescriptor {
+    status: 'ok';
+    parserAvailable: boolean;
+    parseErrors: boolean;
+}
+export interface SnapshotReleaseResult {
+    released: boolean;
+}
+export interface StructureNode {
+    handle: string;
+    kind: string;
+    range: LspRange;
+    name?: string;
+    childCount?: number;
+}
+export interface StructureErrorSummary {
+    hasError: boolean;
+    errorNodes: number;
+    missingNodes: number;
+    truncated: boolean;
+}
+export interface StructureOutlineResult {
+    status: 'ok' | 'partial' | 'unsupported';
+    handle: string;
+    version: number;
+    declarations: StructureNode[];
+    truncated: boolean;
+    processed: number;
+    errors: StructureErrorSummary;
+}
+export interface StructureEnclosingResult {
+    status: 'ok' | 'partial' | 'unsupported';
+    handle: string;
+    version: number;
+    node?: StructureNode;
+    ancestors: StructureNode[];
+    errors?: StructureErrorSummary;
+}
+export interface StructureCapture {
+    capture: string;
+    kind: string;
+    range: LspRange;
+    nodeHandle: string;
+    name?: string;
+}
+export interface StructureQueryResult {
+    status: 'ok' | 'partial';
+    handle: string;
+    version: number;
+    queryId: string;
+    captures: StructureCapture[];
+    truncated: boolean;
+    processed: number;
+    errors: StructureErrorSummary;
+}
+export interface StructureSpanResult {
+    status: 'ok' | 'partial';
+    text: string;
+    truncated: boolean;
+    range: LspRange;
+}
+export type SemanticOperation = 'definition' | 'references' | 'implementation' | 'hover' | 'diagnostics' | 'completion';
+export interface SemanticQuery {
+    operation: SemanticOperation;
+    position?: LspPosition;
+    severity?: 'all' | 'error' | 'warning';
+    servers?: string[];
+    maxResults?: number;
+}
+export interface SemanticResult {
+    status: 'ok' | 'partial' | 'unsupported' | 'unavailable' | 'stale' | 'cancelled' | 'timeout' | 'limit_exceeded';
+    operation: SemanticOperation;
+    result?: unknown;
+    truncated?: boolean;
+    omitted?: number;
+}
+export interface CodeIntelligenceCapabilities {
+    version: 1;
+    parsers: Array<{
+        language: StructureLanguage;
+        extensions: string[];
+        available: boolean;
+        abiVersion: number | null;
+        runtimeAbi: {
+            minimum: number;
+            current: number;
+        };
+        lastError?: string;
+    }>;
+    sourceKind: 'disk';
+    overlay: 'unavailable';
+    limits: {
+        maxDocumentBytes: number;
+        maxCaptures: number;
+        maxOutline: number;
+        maxSpanChars: number;
+        maxResponseBytes: number;
+    };
+    incrementalParsing: boolean;
+}
+export interface CodeIntelligenceToolServiceV1 {
+    readonly version: 1;
+    snapshot: {
+        open(scope: SnapshotScope, filePath: string, signal?: AbortSignal): Promise<SnapshotOpenResult>;
+        release(scope: SnapshotScope, handle: string): Promise<SnapshotReleaseResult>;
+    };
+    structure: {
+        outline(scope: SnapshotScope, handle: string, options?: {
+            range?: LspRange;
+            limit?: number;
+        }, signal?: AbortSignal): Promise<StructureOutlineResult>;
+        enclosing(scope: SnapshotScope, handle: string, position: LspPosition, options?: {
+            kinds?: string[];
+        }, signal?: AbortSignal): Promise<StructureEnclosingResult>;
+        query(scope: SnapshotScope, handle: string, queryId: string, options?: {
+            range?: LspRange;
+            limit?: number;
+        }, signal?: AbortSignal): Promise<StructureQueryResult>;
+        span(scope: SnapshotScope, nodeHandle: string, maxChars?: number, signal?: AbortSignal): Promise<StructureSpanResult>;
+    };
+    semantic: {
+        query(scope: SnapshotScope, handle: string, request: SemanticQuery, signal?: AbortSignal): Promise<SemanticResult>;
+    };
+    capabilities(): CodeIntelligenceCapabilities;
+    releaseOwner?(scope: SnapshotScope): Promise<number>;
+    dispose?(): Promise<void>;
+}
+export type SnapshotSemanticCallback = (scope: SnapshotScope, snapshot: SnapshotDescriptor, request: SemanticQuery, signal: AbortSignal) => Promise<CompletionResult | DiagnosticsResult | NavigationResult>;

package/lib/types/structure/worker-pool.d.ts

@@ -0,0 +1,66 @@
+import type { StructureLanguage } from './types.js';
+export interface StructureWorkerRequest {
+    operation: 'matches' | 'enclosing' | 'inspect';
+    language: StructureLanguage;
+    text: string;
+    querySource: string;
+    limit: number;
+    snapshotHandle?: string;
+    previousSnapshotHandle?: string;
+    startIndex?: number;
+    endIndex?: number;
+    index?: number;
+    kinds?: string[];
+}
+export interface WorkerNodeSummary {
+    kind: string;
+    startIndex: number;
+    endIndex: number;
+    startPosition: {
+        row: number;
+        column: number;
+    };
+    endPosition: {
+        row: number;
+        column: number;
+    };
+    nameStartIndex?: number;
+    nameEndIndex?: number;
+    childCount: number;
+}
+export interface WorkerErrorSummary {
+    hasError: boolean;
+    errorNodes: number;
+    missingNodes: number;
+    truncated: boolean;
+}
+export interface WorkerMatch {
+    captures: Array<{
+        name: string;
+    } & WorkerNodeSummary>;
+}
+export interface StructureWorkerResult {
+    status: 'ok' | 'partial';
+    abiVersion?: number;
+    reusedTree?: boolean;
+    incremental?: boolean;
+    matches?: WorkerMatch[];
+    nodes?: WorkerNodeSummary[];
+    truncated?: boolean;
+    errors: WorkerErrorSummary;
+}
+/** CPU-bound parsing runs off the event loop; cancellation terminates the active worker. */
+export declare class StructureWorkerPool {
+    private readonly slots;
+    private readonly queue;
+    private disposed;
+    execute(request: StructureWorkerRequest, signal?: AbortSignal): Promise<StructureWorkerResult>;
+    dispose(): Promise<void>;
+    releaseSnapshot(snapshotHandle: string): void;
+    get queued(): number;
+    get active(): number;
+    private pump;
+    private createWorker;
+    private retire;
+    private finishTask;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askdkc/dsh-lsp-server",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Composite read-only LSP provider for DeepSeek Harness web stacks",
   "type": "module",
   "main": "./lib/provider.js",
@@ -18,6 +18,14 @@
       "types": "./lib/types/extra-tool.d.ts",
       "default": "./lib/extra-tool.js"
     },
+    "./code-intelligence": {
+      "types": "./lib/types/code-intelligence.d.ts",
+      "default": "./lib/code-intelligence.js"
+    },
+    "./code-intelligence-contracts": {
+      "types": "./lib/types/code-intelligence-contracts.d.ts",
+      "default": "./lib/code-intelligence-contracts.js"
+    },
     "./package.json": "./package.json",
     "./lsp": {
       "types": "./lib/types/lsp.d.ts",
@@ -45,7 +53,7 @@
     }
   },
   "scripts": {
-    "build": "tsdown && tsc -p tsconfig.build.json",
+    "build": "tsdown && tsc -p tsconfig.build.json && node scripts/copy-structure-assets.mjs",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
@@ -61,7 +69,8 @@
     "svelte-language-server": "0.17.15",
     "typescript": "5.7.3",
     "typescript-language-server": "4.3.3",
-    "vscode-langservers-extracted": "4.10.0"
+    "vscode-langservers-extracted": "4.10.0",
+    "web-tree-sitter": "0.27.1"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "~4.0.4",
@@ -96,6 +105,8 @@
     "@types/node": "22.10.5",
     "tailwindcss-v3": "npm:tailwindcss@3.4.17",
     "tailwindcss-v4": "npm:tailwindcss@4.1.13",
+    "tree-sitter-javascript": "0.25.0",
+    "tree-sitter-typescript": "0.23.2",
     "tsdown": "0.15.0",
     "typescript": "5.7.3",
     "vitest": "4.1.11"
@@ -111,7 +122,9 @@
     "overrides": {
       "tsdown>rolldown": "1.0.0-beta.38",
       "svelte-language-server>svelte": "5.55.7",
-      "vite": "6.4.3"
+      "vite": "6.4.3",
+      "source-map-js": "1.2.2",
+      "postcss-selector-parser": "7.1.6"
     }
   },
   "license": "MIT",