@deepseek-ai/dsh-lsp-stdio 0.0.1-rc.5

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-lsp-stdio`.
+* @module @deepseek-ai/dsh-lsp-stdio/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-lsp-stdio";
+/** Cordis companion plugin name. */
+const name = "lsp-stdio-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: process pools and per-workspace queues are private implementation state,
+* and this provider publishes no independent lifecycle event stream or enumerable snapshot.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/abort.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared cancellation helpers for the local LSP provider's host-I/O, queue, and protocol phases.
+ * @module @deepseek-ai/dsh-lsp-stdio/abort
+ */
+/**
+ * Build an abort Error carrying the signal's reason and preserving timeout classification.
+ * @param signal - the aborted signal whose reason to surface.
+ * @returns the timeout reason if present, else the Error reason, else a generic aborted Error.
+ */
+export declare function abortError(signal: AbortSignal): Error;
+/**
+ * Throw the signal's classified abort error when it has already fired.
+ * @param signal - the optional query cancellation signal.
+ */
+export declare function throwIfAborted(signal?: AbortSignal): void;
+/**
+ * Await work while allowing a query signal to abandon its wait; the underlying work keeps its own
+ * handlers and continues to its owner-defined quiescence boundary.
+ * @param work - the owned asynchronous work.
+ * @param signal - optional query cancellation.
+ * @returns the work result, or a rejection carrying the classified abort reason.
+ */
+export declare function abortable<T>(work: Promise<T>, signal?: AbortSignal): Promise<T>;
+//# sourceMappingURL=abort.d.ts.map

package/lib/types/connection.d.ts

@@ -0,0 +1,119 @@
+/**
+ * A JSON-RPC endpoint over one language server spawned through the subprocess
+ * capability. Owns id correlation, outbound requests/notifications, and inbound
+ * server→client requests: it answers `workspace/configuration` from static
+ * config, and rejects `workspace/applyEdit` (this host never applies edits or
+ * runs commands). It caps stderr, surfaces framing/decoder failures as a
+ * fatal close, and exposes tree-scoped termination through the handle so the
+ * instance owns teardown; group/tree mechanics live in the subprocess
+ * Service provider.
+ * @module @deepseek-ai/dsh-lsp-stdio/connection
+ */
+import type { Writable } from 'node:stream';
+import type { SubprocessHandle, SubprocessSpawnSpec } from '@deepseek-ai/dsh-subprocess';
+/** How to launch the server and answer its config requests. */
+export interface ConnectionSpec {
+    /** The resolved absolute executable path (no shell). */
+    readonly command: string;
+    /** Arguments passed to the executable. */
+    readonly args: readonly string[];
+    /** The child's working directory (the canonical workspace). */
+    readonly cwd: string;
+    /** Explicit child environment overrides; the subprocess provider owns its ambient scrub. */
+    readonly env: Record<string, string>;
+    /** Largest single framed message accepted from the server. */
+    readonly maxMessageBytes: number;
+    /** Largest stderr tail retained for diagnostics. */
+    readonly maxStderrBytes: number;
+    /**
+     * The subprocess spec's `graceMs`: the SIGTERM→SIGKILL window of
+     * {@link LspConnection.terminate}'s escalation, and the bound for draining
+     * pipes a surviving helper still holds after the server exits.
+     */
+    readonly killGraceMs: number;
+    /** Static answer to every `workspace/configuration` item. */
+    readonly configuration: unknown;
+}
+/**
+ * Write one JSON-RPC message to the child stdin.
+ * @param stdin - the spawned server stdin.
+ * @param message - the unencoded JSON-RPC message.
+ * @param done - callback that reports asynchronous stream settlement.
+ */
+export type ConnectionWriter = (stdin: Writable, message: unknown, done: (error?: Error | null) => void) => void;
+/** Spawn one subprocess for this connection (the provider passes `ctx.subprocess.spawn`). */
+export type ConnectionSpawner = (spec: SubprocessSpawnSpec) => SubprocessHandle;
+/** A live JSON-RPC endpoint bound to one child process. */
+export declare class LspConnection {
+    private readonly onServerRequest;
+    private readonly writer;
+    private readonly handle;
+    private readonly stdin;
+    private readonly decoder;
+    private readonly pending;
+    private nextId;
+    private closeReason;
+    /** Set once the process has fully exited; the instance awaits it during teardown. */
+    readonly closed: Promise<void>;
+    /**
+     * @param spec - how to launch the server and answer its config requests.
+     * @param spawner - the subprocess seam's spawn (the provider passes `ctx.subprocess.spawn`).
+     * @param onServerRequest - answers a server→client request; rejects to send an error response.
+     * @param writer - message writer; tests inject callback failures without relying on OS pipe races.
+     */
+    constructor(spec: ConnectionSpec, spawner: ConnectionSpawner, onServerRequest: (method: string, params: unknown) => Promise<unknown>, writer?: ConnectionWriter);
+    /** The child's pid, or `-1` when the spawn produced no pid (so signalling is a no-op). */
+    get pid(): number;
+    /** The retained stderr tail, for diagnostics on a failed server. */
+    get stderrTail(): string;
+    /** Whether the transport has failed even if the child close event has not arrived yet. */
+    get failed(): boolean;
+    /**
+     * Test whether a caught error is this connection's retained fatal transport cause.
+     * @param error - error caught by the instance or provider.
+     * @returns `true` only when this connection produced that exact failure.
+     */
+    failedWith(error: unknown): boolean;
+    /**
+     * Send a request and await its result.
+     * @param method - the JSON-RPC method.
+     * @param params - the request params.
+     * @returns the response result; rejects on an error response, write failure, or close.
+     */
+    request(method: string, params: unknown): Promise<unknown>;
+    /**
+     * Send a notification (no id, no response).
+     * @param method - the JSON-RPC method.
+     * @param params - the notification params.
+     * @returns a promise that settles when the framed notification has been written.
+     */
+    notify(method: string, params: unknown): Promise<void>;
+    /**
+     * Send a `$/cancelRequest` for an in-flight request id (best-effort; ignores write failure).
+     * @param requestId - the numeric id of the request to cancel.
+     */
+    cancel(requestId: number): void;
+    /**
+     * The id the NEXT `request()` will use, so the instance can pre-arm a cancel.
+     * @returns the numeric id the next request will be assigned.
+     */
+    peekNextId(): number;
+    /** Terminate the server's process tree (the seam's SIGTERM→grace→SIGKILL escalation; idempotent). */
+    terminate(): void;
+    /**
+     * Wait until the owned process tree has exited.
+     * @param signal - optional bound for the wait.
+     * @returns `true` when the tree exited, or `false` when the signal aborted first.
+     */
+    waitForProcessTreeExit(signal?: AbortSignal): Promise<boolean>;
+    private onStdout;
+    private dispatch;
+    private handleServerRequest;
+    private handleResponse;
+    private write;
+    /** The exit-close error message, appending the retained stderr tail when the server wrote any. */
+    private exitMessage;
+    private fail;
+    private failAll;
+}
+//# sourceMappingURL=connection.d.ts.map

package/lib/types/framing.d.ts

@@ -0,0 +1,35 @@
+/**
+ * LSP base-protocol framing: `Content-Length`-delimited JSON-RPC over a byte stream. The encoder
+ * produces one framed buffer; the decoder buffers incoming bytes and yields complete message bodies,
+ * bounding the header and total message size so a hostile or broken server cannot exhaust memory.
+ * @module @deepseek-ai/dsh-lsp-stdio/framing
+ */
+/**
+ * Encode one JSON-RPC message as a framed LSP buffer (`Content-Length: N\r\n\r\n<utf-8 json>`).
+ * @param message - the JSON-RPC message object to serialize.
+ * @returns the framed bytes ready to write to the server's stdin.
+ */
+export declare function encodeMessage(message: unknown): Buffer;
+/**
+ * A streaming decoder for `Content-Length`-framed JSON-RPC. Feed it stdout chunks; it returns any
+ * whole message bodies that completed. It parses only the `Content-Length` header and ignores other
+ * headers (e.g. `Content-Type`), matching the base protocol.
+ */
+export declare class MessageDecoder {
+    private buffer;
+    private readonly maxMessageBytes;
+    /**
+     * @param maxMessageBytes - reject any single framed body larger than this (guards memory).
+     */
+    constructor(maxMessageBytes: number);
+    /**
+     * Append a chunk and return every message body that is now complete.
+     * @param chunk - raw bytes from the server's stdout.
+     * @returns the parsed JSON bodies, in arrival order (possibly empty).
+     * @throws Error when a header is malformed or a body exceeds `maxMessageBytes`.
+     */
+    push(chunk: Buffer): unknown[];
+    /** Parse and consume the next complete message, or report that more bytes are needed. */
+    private next;
+}
+//# sourceMappingURL=framing.d.ts.map

package/lib/types/host.d.ts

@@ -0,0 +1,39 @@
+/** Filesystem-seam source access for the generic stdio LSP provider. */
+import type { FileSystem, FsTarget } from '@deepseek-ai/dsh-fs';
+/** A canonical workspace in the filesystem/subprocess execution world. */
+export interface HostWorkspace {
+    /** Stable filesystem identity used for provider pooling. */
+    readonly target: FsTarget;
+    /** Canonical absolute path accepted as a subprocess cwd. */
+    readonly canonicalPath: string;
+    /** Canonical file URI sent during LSP initialization. */
+    readonly fileUrl: string;
+}
+/** A validated source and the exact URI sent to the language server. */
+export interface HostSource {
+    /** Canonical file URI in the execution world's platform syntax. */
+    readonly fileUrl: string;
+    /** Current complete UTF-8 text. */
+    readonly text: string;
+}
+/**
+ * Resolve and validate one workspace through `ctx.fs`.
+ * @param fs - filesystem provider sharing the language server's execution world.
+ * @param workspaceRoot - caller-supplied workspace path.
+ * @param signal - optional cancellation around provider operations.
+ * @returns stable identity plus process path and file URI.
+ */
+export declare function canonicalizeWorkspace(fs: FileSystem, workspaceRoot: string, signal?: AbortSignal): Promise<HostWorkspace>;
+/**
+ * Resolve, contain, and read one byte-bounded query source through `ctx.fs`.
+ * This layer owns the LSP-specific complete-document cap while the filesystem
+ * provider owns streaming, regular-file checks, and UTF-8 validation.
+ * @param fs - filesystem provider sharing the server's execution world.
+ * @param filePath - absolute source path or path relative to `workspace`.
+ * @param workspace - already-canonical workspace.
+ * @param maxDocumentBytes - largest complete source accepted by this host.
+ * @param signal - optional cancellation.
+ * @returns canonical file URI and current text.
+ */
+export declare function readHostSource(fs: FileSystem, filePath: string, workspace: HostWorkspace, maxDocumentBytes: number, signal?: AbortSignal): Promise<HostSource>;
+//# sourceMappingURL=host.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Generic stdio language-server backend for `ctx.lsp`. One plugin instance configures a named table
+ * of server commands and registers one isolated provider for each entry. Every provider lazily
+ * single-flights one server process per canonical workspace target, serves transient-open queries
+ * through it, and replaces a selected transport that fails before or during the next read-only
+ * query. Providers read sources through `ctx.fs` and launch servers through
+ * `ctx.subprocess`, so both local and remote implementations share one host.
+ *
+ * Namespace plugin (named exports, no default export). Lifecycle is effect-scoped: disposal
+ * unregisters from `ctx.lsp` and tears down every live server.
+ * @module @deepseek-ai/dsh-lsp-stdio
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export { canonicalizeWorkspace, readHostSource } from './host.ts';
+export { encodeMessage, MessageDecoder } from './framing.ts';
+export { negotiatePositionEncoding, normalizeHover, normalizeLocations, requestMethod, supportsOperation, supportsTransientOpen, } from './translate.ts';
+export { LspInstance } from './instance.ts';
+export { LspConnection } from './connection.ts';
+/** Cordis plugin name for loader diagnostics. */
+export declare const name = "lsp-stdio";
+/** Services required by this plugin. */
+export declare const inject: string[];
+/** One configured local language server and its host bounds. */
+export interface LspLocalServerConfig {
+    /** Executable to spawn (absolute, or resolved on PATH at load). */
+    command: string;
+    /** Lowercase leading-dot extension → LSP language id (e.g. `{ '.ts': 'typescript' }`). */
+    extensionToLanguage: Record<string, string>;
+    /** Arguments passed to the executable (no shell). Default `[]`. */
+    args?: string[];
+    /** Extra env vars merged on top of the scrubbed ambient env. Default `{}`. */
+    env?: Record<string, string>;
+    /** Static `initialize` options forwarded to the server. Default `null`. */
+    initializationOptions?: unknown;
+    /** Static answer to every `workspace/configuration` item. Default `null`. */
+    configuration?: unknown;
+    /** Largest single framed message accepted from the server (bytes). Default 16000000. */
+    maxMessageBytes?: number;
+    /** Largest stderr tail retained for diagnostics (bytes). Default 1000000. */
+    maxStderrBytes?: number;
+    /** Largest source file this host will open (bytes). Default 4000000. */
+    maxDocumentBytes?: number;
+    /** Graceful `shutdown`/`exit` budget before escalation (ms). Default 5000. */
+    shutdownTimeoutMs?: number;
+    /** Request-cancel and SIGTERM→SIGKILL grace (ms). Default 2000. */
+    killGraceMs?: number;
+}
+/** Plugin configuration: provider id → local language-server configuration. */
+export interface Config {
+    /** Non-empty table of stable provider ids to independent local server configurations. */
+    servers: Record<string, LspLocalServerConfig>;
+}
+export declare const Config: z<Config>;
+/**
+ * Register the configured stdio LSP providers. Resolves every executable at load (after credential
+ * scrubbing) before publishing any provider; each process launches lazily on its first matching
+ * query.
+ * @param ctx - the plugin context carrying `fs`, `lsp`, and `subprocess`.
+ * @param config - the resolved plugin configuration (schemastery has filled every default).
+ */
+export declare function apply(ctx: Context, config: Config): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/instance.d.ts

@@ -0,0 +1,89 @@
+/**
+ * One language-server instance: a connection plus the initialize handshake, the serialized abortable
+ * query queue, the transient `didOpen`→request→`didClose` lifecycle, and bounded teardown. One
+ * instance owns one `(provider id, canonical workspace)` process. Queries serialize through a single
+ * queue so a cancellation that fails to stop the server can terminate it without killing unrelated
+ * work; distinct instances run in parallel.
+ * @module @deepseek-ai/dsh-lsp-stdio/instance
+ */
+import type { LspProviderQuery, LspQueryResult } from '@deepseek-ai/dsh-lsp';
+import type { ConnectionSpawner, ConnectionSpec, ConnectionWriter } from './connection.ts';
+import type { HostSource } from './host.ts';
+/** Everything an instance needs beyond the connection spec. */
+export interface InstanceSpec extends ConnectionSpec {
+    /** Canonical workspace file URI supplied by the filesystem provider. */
+    readonly workspaceUri: string;
+    /** Static `initialize` options forwarded to the server. */
+    readonly initializationOptions: unknown;
+    /** Graceful `shutdown`/`exit` budget before escalation (ms). */
+    readonly shutdownTimeoutMs: number;
+}
+/**
+ * A single initialized server process. Not exported as a provider — the provider single-flights and
+ * pools these. `query()` serializes; `dispose()` rejects queued work and tears the process down.
+ */
+export declare class LspInstance {
+    private readonly spec;
+    private readonly connection;
+    private capabilities;
+    /** The serialization tail: each query awaits the prior one, so lifecycles never interleave. */
+    private queue;
+    private disposed;
+    /** The one teardown transaction shared by abort, failure, and explicit disposal. */
+    private teardownPromise;
+    /** Set once the process closes, so the pool can synchronously skip a dead instance. */
+    private processClosed;
+    /** Populated once `initialize` succeeds; a failed handshake rejects every query. */
+    private readonly ready;
+    /**
+     * @param spec - the launch, initialize, and teardown parameters.
+     * @param spawner - the subprocess seam's spawn function.
+     * @param writer - optional connection writer used by transport conformance tests.
+     */
+    constructor(spec: InstanceSpec, spawner: ConnectionSpawner, writer?: ConnectionWriter);
+    /** Synchronous liveness check: true once the process has closed or the instance was disposed. */
+    get dead(): boolean;
+    /**
+     * Test whether a caught query error came from this instance's transport.
+     * @param error - error caught by the provider.
+     * @returns `true` only for the connection's retained fatal transport cause.
+     */
+    isTransportFailure(error: unknown): boolean;
+    /**
+     * Run one query through the serialized queue.
+     * @param request - the resolved provider query.
+     * @param source - the pre-validated, already-read host source (the provider reads before spawning).
+     * @param signal - optional cancellation for this query's full lifecycle.
+     * @returns the normalized result.
+     */
+    query(request: LspProviderQuery, source: HostSource, signal?: AbortSignal): Promise<LspQueryResult>;
+    private initialize;
+    private runQuery;
+    private sendRequest;
+    /**
+     * Race a pending request against abort. On abort, send `$/cancelRequest` and give the server a
+     * bounded grace to acknowledge; if it does not settle in time, invalidate and tear down the
+     * instance so the still-active request cannot overlap the next queued query's document lifecycle.
+     */
+    private raceAbort;
+    private normalize;
+    private answerServerRequest;
+    /**
+     * Reject queued work, attempt graceful `shutdown`/`exit`, then escalate SIGTERM→SIGKILL, awaiting
+     * process close so nothing outlives disposal.
+     */
+    dispose(): Promise<void>;
+    /** Publish disposal once and make every caller await the same quiescence boundary. */
+    private startTeardown;
+    private tearDown;
+    /** Best-effort LSP `shutdown`/`exit`, including process close, bounded by `signal`. */
+    private gracefulShutdown;
+    /**
+     * Terminate the tree (the seam escalates SIGTERM→`killGraceMs`→SIGKILL),
+     * then await leader and helper exit. The awaits are unbounded on purpose:
+     * the seam's escalation already committed to SIGKILL, so quiescence — not
+     * another timer — is the postcondition disposal owes its callers.
+     */
+    private forceTerminate;
+}
+//# sourceMappingURL=instance.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-lsp-stdio`.
+ * @module @deepseek-ai/dsh-lsp-stdio/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "lsp-stdio-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/protocol.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The subset of LSP wire types this generic host reads and writes: initialize capabilities, the four
+ * request results (`Location`, `LocationLink`, `Hover`), and the `textDocumentSync` shapes used to
+ * decide transient-open support. Types only. Fields absent from a real server payload stay optional;
+ * the translation layer normalizes them into the seam's closed unions.
+ * @module @deepseek-ai/dsh-lsp-stdio/protocol
+ */
+/** A zero-based UTF-16 position on the wire (the protocol's `Position`). */
+export interface WirePosition {
+    readonly line: number;
+    readonly character: number;
+}
+/** A wire range (`Range`). */
+export interface WireRange {
+    readonly start: WirePosition;
+    readonly end: WirePosition;
+}
+/** A `Location`: a document URI plus a range. */
+export interface WireLocation {
+    readonly uri: string;
+    readonly range: WireRange;
+}
+/** A `LocationLink`: the target uri plus the selection range to focus. */
+export interface WireLocationLink {
+    readonly targetUri: string;
+    readonly targetSelectionRange: WireRange;
+    readonly targetRange?: WireRange;
+}
+/** A `MarkupContent` hover body (`markdown` or `plaintext`). */
+export interface WireMarkupContent {
+    readonly kind: 'markdown' | 'plaintext';
+    readonly value: string;
+}
+/** A `MarkedString` object form (`{ language, value }`); the string form is a bare `string`. */
+export interface WireMarkedStringObject {
+    readonly language: string;
+    readonly value: string;
+}
+/** One `MarkedString`: a raw string or a language-tagged code block. */
+export type WireMarkedString = string | WireMarkedStringObject;
+/** A `Hover`: contents in any of the protocol's three encodings, plus an optional range. */
+export interface WireHover {
+    readonly contents: WireMarkupContent | WireMarkedString | readonly WireMarkedString[];
+    readonly range?: WireRange;
+}
+/** The legacy enum form of `textDocumentSync` (`0` None, `1` Full, `2` Incremental). */
+export type WireTextDocumentSyncKind = 0 | 1 | 2;
+/** The options form of `textDocumentSync` (`{ openClose, change }`). */
+export interface WireTextDocumentSyncOptions {
+    readonly openClose?: boolean;
+    readonly change?: WireTextDocumentSyncKind;
+}
+/** A `ServerCapabilities.provider` slot: a boolean or an options object (both mean "supported"). */
+export type WireProviderCapability = boolean | Record<string, unknown> | undefined;
+/** The `ServerCapabilities` fields this host inspects. */
+export interface WireServerCapabilities {
+    readonly positionEncoding?: string;
+    readonly textDocumentSync?: WireTextDocumentSyncKind | WireTextDocumentSyncOptions;
+    readonly definitionProvider?: WireProviderCapability;
+    readonly referencesProvider?: WireProviderCapability;
+    readonly implementationProvider?: WireProviderCapability;
+    readonly hoverProvider?: WireProviderCapability;
+}
+/** The `initialize` result envelope. */
+export interface WireInitializeResult {
+    readonly capabilities: WireServerCapabilities;
+}
+//# sourceMappingURL=protocol.d.ts.map

package/lib/types/translate.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Pure protocol translation for the local host: what the server's capabilities allow, and how its
+ * `Location`/`LocationLink`/`Hover` payloads normalize into the seam's closed result unions. No I/O
+ * or process state — every function here is a pure transform, which the fake-stdio tests pin exactly.
+ * @module @deepseek-ai/dsh-lsp-stdio/translate
+ */
+import type { LspHover, LspLocation, LspOperation } from '@deepseek-ai/dsh-lsp';
+import type { WireServerCapabilities } from './protocol.ts';
+/**
+ * The `textDocument/*` request method for each LSP operation.
+ * @param operation - the LSP operation to map.
+ * @returns the LSP request method name.
+ */
+export declare function requestMethod(operation: LspOperation): string;
+/**
+ * Whether the server advertises the requested operation.
+ * @param capabilities - the server's `initialize` capabilities.
+ * @param operation - the LSP operation to check.
+ * @returns true when the corresponding provider capability is present.
+ */
+export declare function supportsOperation(capabilities: WireServerCapabilities, operation: LspOperation): boolean;
+/**
+ * Whether a `textDocumentSync` value permits the transient `didOpen`/`didClose` this host relies on.
+ * The legacy enum form implies open/close for `Full`/`Incremental`; the options form requires an
+ * explicit `openClose: true`, because the protocol defaults an omitted `openClose` to false.
+ * @param sync - the server's advertised `textDocumentSync` capability.
+ * @returns true when transient open/close is supported.
+ */
+export declare function supportsTransientOpen(sync: WireServerCapabilities['textDocumentSync']): boolean;
+/**
+ * Normalize the negotiated position encoding. An omitted encoding defaults to `utf-16`; any value
+ * other than `utf-16` is a protocol error this host does not support.
+ * @param encoding - the server's advertised `positionEncoding`, if any.
+ * @returns the string `'utf-16'`.
+ * @throws Error for any non-`utf-16` encoding.
+ */
+export declare function negotiatePositionEncoding(encoding: string | undefined): 'utf-16';
+/**
+ * Normalize a navigation result (`Location`, `Location[]`, `LocationLink[]`, or `null`) to the seam's
+ * locations. `Location` maps directly; `LocationLink` maps `targetUri` + `targetSelectionRange`.
+ * @param payload - the raw `textDocument/definition|references|implementation` result.
+ * @returns the normalized locations (empty for `null`/`[]`).
+ * @throws Error when an element is neither a `Location` nor a `LocationLink`.
+ */
+export declare function normalizeLocations(payload: unknown): LspLocation[];
+/**
+ * Normalize a `Hover` (or `null`) to the seam's hover. `MarkupContent` uses its `value`; a string
+ * `MarkedString` is verbatim; a language-tagged `MarkedString` becomes a fenced code block; an array
+ * joins its rendered parts with one blank line. The model-facing tool owns the complete result cap.
+ * @param payload - the raw `textDocument/hover` result.
+ * @returns the normalized hover, or `null` when there is no content.
+ * @throws Error when the payload is a non-null, non-object, or structurally invalid hover.
+ */
+export declare function normalizeHover(payload: unknown): LspHover | null;
+//# sourceMappingURL=translate.d.ts.map

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@deepseek-ai/dsh-lsp-stdio",
+  "description": "Generic stdio language-server provider for the DeepSeek Harness LSP capability seam (ctx.lsp) — spawns configured servers, translates JSON-RPC, and serves transient-open goToDefinition/findReferences/goToImplementation/hover queries in the host filesystem namespace",
+  "version": "0.0.1-rc.5",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/lsp/lsp-stdio"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "BSD-3-Clause",
+  "peerDependencies": {
+    "@deepseek-ai/dsh-brand": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-fs": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-timeout": "^0.0.1-rc.5",
+    "@deepseek-ai/cordis": "^4.0.1-rc.4",
+    "@deepseek-ai/dsh-subprocess": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-lsp": "^0.0.1-rc.5"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1-rc.4"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "typescript-language-server": "^5.0.0",
+    "@deepseek-ai/dsh-brand": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-fs": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-fs-local": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-lsp": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-subprocess": "^0.0.1-rc.5",
+    "@deepseek-ai/dsh-timeout": "^0.0.1-rc.5",
+    "@deepseek-ai/cordis": "^4.0.1-rc.4",
+    "@deepseek-ai/dsh-subprocess-local": "^0.0.1-rc.5"
+  }
+}