@smthrs/std 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/NodeLanguageServer.js

@@ -0,0 +1,796 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NodeLanguageServer_exports = {};
+__export(NodeLanguageServer_exports, {
+  MAX_PENDING_REQUESTS: () => MAX_PENDING_REQUESTS,
+  MAX_QUEUED_FRAMES: () => MAX_QUEUED_FRAMES,
+  layer: () => layer,
+  layerLazy: () => layerLazy,
+  make: () => make,
+  makeLazy: () => makeLazy
+});
+module.exports = __toCommonJS(NodeLanguageServer_exports);
+var ChildProcessEnvironment = __toESM(require("@smthrs/kernel/ChildProcessEnvironment"), 1);
+var ChildProcessSpawner = __toESM(require("@smthrs/kernel/ChildProcessSpawner"), 1);
+var import_effect = require("effect");
+var ChildProcess = __toESM(require("effect/unstable/process/ChildProcess"), 1);
+var import_node_crypto = require("node:crypto");
+var NodeFs = __toESM(require("node:fs"), 1);
+var NodePath = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var LanguageServer = __toESM(require("./LanguageServer.js"), 1);
+var StdError = __toESM(require("./StdError.js"), 1);
+const MAX_QUEUED_FRAMES = 256;
+const MAX_PENDING_REQUESTS = 512;
+const DEFAULT_SETTLE_MS = 5e3;
+const DEFAULT_QUIET_MS = 300;
+const BARRIER_METHOD = "$/smithers/barrier";
+const BARRIER_TIMEOUT_MS = 1e3;
+const METHOD_NOT_FOUND = -32601;
+const LANGUAGE_IDS = {
+  ".ts": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".tsx": "typescriptreact",
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "javascriptreact",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".rb": "ruby",
+  ".sh": "shellscript",
+  ".md": "markdown",
+  ".yml": "yaml",
+  ".cc": "cpp",
+  ".cpp": "cpp",
+  ".hpp": "cpp",
+  ".cs": "csharp"
+};
+const extensionOf = (path) => NodePath.extname(path).toLowerCase();
+const languageId = (path) => {
+  const extension = extensionOf(path);
+  return LANGUAGE_IDS[extension] ?? (extension.slice(1) || "plaintext");
+};
+const failure = (code, message) => new StdError.StdError({ code, message });
+const maximumHeaderBytes = 8 * 1024;
+const maximumFrameBytes = 8 * 1024 * 1024;
+const headerEnd = new Uint8Array([13, 10, 13, 10]);
+const contentLengthPrefix = new TextEncoder().encode("Content-Length:");
+const concatenate = (left, right) => {
+  const combined = new Uint8Array(left.length + right.length);
+  combined.set(left);
+  combined.set(right, left.length);
+  return combined;
+};
+const makeChunkBuffer = () => {
+  let chunks = [];
+  let head = 0;
+  let headOffset = 0;
+  let length = 0;
+  const compact = () => {
+    if (head === chunks.length) {
+      chunks = [];
+      head = 0;
+      headOffset = 0;
+    } else if (head >= 64 && head * 2 >= chunks.length) {
+      chunks = chunks.slice(head);
+      head = 0;
+    }
+  };
+  const consume = (count, output) => {
+    let remaining = count;
+    let outputOffset = 0;
+    for (const chunk of chunks.slice(head)) {
+      if (remaining === 0) break;
+      const available = chunk.byteLength - headOffset;
+      const consumed = Math.min(available, remaining);
+      if (output !== void 0) {
+        output.set(chunk.subarray(headOffset, headOffset + consumed), outputOffset);
+        outputOffset += consumed;
+      }
+      headOffset += consumed;
+      length -= consumed;
+      remaining -= consumed;
+      if (headOffset === chunk.byteLength) {
+        head++;
+        headOffset = 0;
+      }
+    }
+    compact();
+  };
+  return {
+    get length() {
+      return length;
+    },
+    push: (chunk) => {
+      if (chunk.byteLength === 0) return;
+      chunks.push(chunk.slice());
+      length += chunk.byteLength;
+    },
+    indexOf: (needle) => {
+      let absolute = 0;
+      let matched = 0;
+      for (let chunkIndex = head; chunkIndex < chunks.length; chunkIndex++) {
+        const chunk = chunks[chunkIndex];
+        const start = chunkIndex === head ? headOffset : 0;
+        for (let index = start; index < chunk.byteLength; index++) {
+          const byte = chunk[index];
+          if (byte === needle[matched]) matched++;
+          else matched = byte === needle[0] ? 1 : 0;
+          if (matched === needle.byteLength) return absolute - needle.byteLength + 1;
+          absolute++;
+        }
+      }
+      return -1;
+    },
+    prefix: (count) => {
+      if (count > length) return void 0;
+      return {
+        take: () => {
+          const output = new Uint8Array(count);
+          consume(count, output);
+          return output;
+        },
+        discard: () => consume(count)
+      };
+    }
+  };
+};
+const malformedId = (body) => {
+  const match = /"id"\s*:\s*(\d+)/.exec(body);
+  if (match === null) return void 0;
+  const id = Number(match[1]);
+  return Number.isSafeInteger(id) ? id : void 0;
+};
+const makeFrameDecoder = () => {
+  const pending = makeChunkBuffer();
+  let bodyLength;
+  let resynchronizing = false;
+  return {
+    push: (chunk) => {
+      pending.push(chunk);
+      const events = [];
+      while (pending.length > 0 || bodyLength === 0) {
+        if (resynchronizing) {
+          const nextHeader = pending.indexOf(contentLengthPrefix);
+          if (nextHeader < 0) {
+            pending.prefix(Math.max(0, pending.length - contentLengthPrefix.byteLength + 1)).discard();
+            break;
+          }
+          pending.prefix(nextHeader).discard();
+          resynchronizing = false;
+        }
+        if (bodyLength !== void 0) {
+          const reader = pending.prefix(bodyLength);
+          if (reader === void 0) break;
+          const body = new TextDecoder().decode(reader.take());
+          bodyLength = void 0;
+          try {
+            events.push({ _tag: "Message", value: JSON.parse(body) });
+          } catch {
+            events.push({
+              _tag: "Failure",
+              error: failure("request_failed", "Language server returned malformed JSON"),
+              id: malformedId(body)
+            });
+          }
+          continue;
+        }
+        const delimiter = pending.indexOf(headerEnd);
+        if (delimiter < 0) {
+          if (pending.length > maximumHeaderBytes) {
+            events.push({
+              _tag: "Failure",
+              error: failure(
+                "request_failed",
+                `Language server frame header exceeded ${maximumHeaderBytes} bytes`
+              )
+            });
+            pending.prefix(1).discard();
+            resynchronizing = true;
+            continue;
+          }
+          break;
+        }
+        if (delimiter > maximumHeaderBytes) {
+          events.push({
+            _tag: "Failure",
+            error: failure("request_failed", `Language server frame header exceeded ${maximumHeaderBytes} bytes`)
+          });
+          pending.prefix(delimiter + headerEnd.byteLength).discard();
+          resynchronizing = true;
+          continue;
+        }
+        const header = new TextDecoder().decode(pending.prefix(delimiter).take());
+        pending.prefix(headerEnd.byteLength).discard();
+        const match = /(?:^|\r\n)Content-Length:\s*(\d+)(?:\r\n|$)/i.exec(header);
+        if (match === null) {
+          events.push({
+            _tag: "Failure",
+            error: failure("request_failed", "Language server frame omitted Content-Length")
+          });
+          resynchronizing = true;
+          continue;
+        }
+        const length = Number(match[1]);
+        if (!Number.isSafeInteger(length) || length < 0 || length > maximumFrameBytes) {
+          events.push({
+            _tag: "Failure",
+            error: failure("request_failed", `Language server frame exceeded ${maximumFrameBytes} bytes`)
+          });
+          resynchronizing = true;
+          continue;
+        }
+        bodyLength = length;
+      }
+      return events;
+    }
+  };
+};
+const asMessage = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const frame = (message) => {
+  const body = new TextEncoder().encode(JSON.stringify(message));
+  const header = new TextEncoder().encode(`Content-Length: ${body.byteLength}\r
+\r
+`);
+  return concatenate(header, body);
+};
+const firstCallHierarchyItem = (value) => Array.isArray(value) ? value[0] : void 0;
+const isFile = (path) => {
+  try {
+    return NodeFs.statSync(path, { throwIfNoEntry: false })?.isFile() === true;
+  } catch {
+    return false;
+  }
+};
+const exists = (path) => {
+  try {
+    return NodeFs.statSync(path, { throwIfNoEntry: false }) !== void 0;
+  } catch {
+    return false;
+  }
+};
+const realPath = (path) => {
+  try {
+    return NodeFs.realpathSync(path);
+  } catch {
+    return NodePath.resolve(path);
+  }
+};
+const isWithin = (root, path) => {
+  const relative = NodePath.relative(root, path);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${NodePath.sep}`) && !NodePath.isAbsolute(relative);
+};
+const resolveCommand = (command, cwd, path) => {
+  if (command.includes("/") || command.includes(NodePath.sep)) {
+    const candidate = NodePath.resolve(cwd, command);
+    return isFile(candidate) ? candidate : void 0;
+  }
+  for (const entry of (path ?? "").split(NodePath.delimiter)) {
+    const candidate = NodePath.resolve(cwd, entry, command);
+    if (!isFile(candidate)) continue;
+    try {
+      NodeFs.accessSync(candidate, NodeFs.constants.X_OK);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+};
+const LAUNCHERS = /* @__PURE__ */ new Set([
+  "sh",
+  "bash",
+  "zsh",
+  "dash",
+  "ksh",
+  "fish",
+  "csh",
+  "tcsh",
+  "env",
+  "npx",
+  "pnpx",
+  "npm",
+  "pnpm",
+  "yarn",
+  "bunx",
+  "deno",
+  "cmd",
+  "powershell",
+  "pwsh"
+]);
+const CODE_FLAGS = /* @__PURE__ */ new Set(["-e", "--eval", "-p", "--print", "-r", "--require", "--import", "--loader"]);
+const launcher = (config) => {
+  const name = NodePath.basename(config.command).toLowerCase().replace(/\.(?:exe|cmd|bat|ps1)$/, "");
+  if (LAUNCHERS.has(name)) return name;
+  if (name !== "node" && name !== "bun" && name !== "nodejs") return void 0;
+  const args = config.args ?? [];
+  if (name === "bun" && ["x", "run", "exec"].includes(args[0] ?? "")) return `bun ${args[0]}`;
+  const flag = args.find((argument) => CODE_FLAGS.has(argument.split("=")[0]) || argument === "--experimental-loader");
+  return flag === void 0 ? void 0 : `${name} ${flag.split("=")[0]}`;
+};
+const workspaceProgram = (config, path) => {
+  const launching = launcher(config);
+  if (launching !== void 0) {
+    return failure(
+      "permission_denied",
+      `Language server command runs ${launching}, which executes a program its arguments or the workspace choose; name the server's own host binary instead`
+    );
+  }
+  const lexicalRoot = NodePath.resolve(config.cwd);
+  const realRoot = realPath(lexicalRoot);
+  const inWorkspace = (file) => isWithin(lexicalRoot, file) || isWithin(realRoot, file) || isWithin(realRoot, realPath(file)) || isWithin(lexicalRoot, realPath(file));
+  const program = resolveCommand(config.command, lexicalRoot, path);
+  if (program !== void 0 && inWorkspace(program)) {
+    return failure(
+      "permission_denied",
+      `Language server program ${program} is inside the workspace ${lexicalRoot}; run a host copy instead`
+    );
+  }
+  for (const argument of config.args ?? []) {
+    for (const value of [argument, argument.slice(argument.indexOf("=") + 1)]) {
+      if (value === "") continue;
+      const candidate = NodePath.resolve(lexicalRoot, value);
+      if (exists(candidate) && inWorkspace(candidate)) {
+        return failure(
+          "permission_denied",
+          `Language server argument names ${candidate}, a path inside the workspace ${lexicalRoot}`
+        );
+      }
+    }
+  }
+  return void 0;
+};
+const digestOf = (text) => (0, import_node_crypto.createHash)("sha256").update(text).digest("hex");
+const makeClient = (config) => import_effect.Effect.gen(function* () {
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const timeoutMs = config.timeoutMs ?? 3e4;
+  const settleMs = config.settleMs ?? DEFAULT_SETTLE_MS;
+  const quietMs = config.quietMs ?? DEFAULT_QUIET_MS;
+  const env = ChildProcessEnvironment.make(process.env, config.environment);
+  const refused = yield* import_effect.Effect.sync(() => workspaceProgram(config, env.PATH));
+  if (refused !== void 0) return yield* import_effect.Effect.fail(refused);
+  const input = yield* import_effect.Queue.bounded(MAX_QUEUED_FRAMES);
+  const handle = yield* spawner.spawn(
+    ChildProcess.make(config.command, config.args ?? [], {
+      cwd: config.cwd,
+      env,
+      extendEnv: false,
+      stdin: { stream: import_effect.Stream.fromQueue(input), endOnDone: false }
+    })
+  ).pipe(
+    import_effect.Effect.mapError(
+      (error) => failure("provider_unavailable", `Language server process could not be started: ${error.message}`)
+    )
+  );
+  const pending = /* @__PURE__ */ new Map();
+  const decoder = makeFrameDecoder();
+  let nextId = 1;
+  let terminalError;
+  const maximumStderrBytes = 64 * 1024;
+  let stderrTail = new Uint8Array(0);
+  const stderrFiber = yield* handle.stderr.pipe(
+    import_effect.Stream.runForEach(
+      (chunk) => import_effect.Effect.sync(() => {
+        stderrTail = chunk.byteLength >= maximumStderrBytes ? chunk.slice(-maximumStderrBytes) : concatenate(
+          stderrTail.slice(Math.max(0, stderrTail.byteLength + chunk.byteLength - maximumStderrBytes)),
+          chunk
+        );
+      })
+    ),
+    import_effect.Effect.catch((cause) => import_effect.Effect.logWarning("Language server stderr stream failed", cause)),
+    import_effect.Effect.forkScoped({ startImmediately: true })
+  );
+  const stderr = () => {
+    let start = 0;
+    while (start < stderrTail.byteLength && start < 3 && (stderrTail[start] & 192) === 128) start++;
+    return new TextDecoder().decode(stderrTail.subarray(start));
+  };
+  const failPending = (error) => import_effect.Effect.flatMap(
+    import_effect.Effect.sync(() => {
+      const deferreds = [...pending.values()];
+      pending.clear();
+      return deferreds;
+    }),
+    (deferreds) => import_effect.Effect.forEach(deferreds, (deferred) => import_effect.Deferred.fail(deferred, error), { discard: true })
+  );
+  const failRequest = (id, error) => {
+    const deferred = pending.get(id);
+    if (deferred === void 0) return import_effect.Effect.void;
+    pending.delete(id);
+    return import_effect.Deferred.fail(deferred, error).pipe(import_effect.Effect.asVoid);
+  };
+  const closeWith = (error) => import_effect.Effect.gen(function* () {
+    yield* import_effect.Fiber.await(stderrFiber).pipe(import_effect.Effect.timeoutOption(100));
+    terminalError ??= error;
+    yield* failPending(terminalError);
+  });
+  const uriOf = (path) => (0, import_node_url.pathToFileURL)(NodePath.resolve(config.cwd, path)).href;
+  const documents = /* @__PURE__ */ new Map();
+  const versions = /* @__PURE__ */ new Map();
+  const published = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  let publishSequence = 0;
+  let pullUnsupported = false;
+  let pullSupported = false;
+  let versionedPublishes = false;
+  let barrierAnswered = true;
+  const publish = (params) => {
+    const notification = asMessage(params);
+    if (typeof notification?.uri !== "string" || !Array.isArray(notification.diagnostics)) return import_effect.Effect.void;
+    const uri = notification.uri;
+    const version = typeof notification.version === "number" ? notification.version : void 0;
+    if (version !== void 0) versionedPublishes = true;
+    const previous = published.get(uri)?.version;
+    if (version !== void 0 && previous !== void 0 && version < previous) return import_effect.Effect.void;
+    published.set(uri, {
+      version,
+      sequence: ++publishSequence,
+      diagnostics: notification.diagnostics
+    });
+    const waiting = listeners.get(uri);
+    if (waiting === void 0) return import_effect.Effect.void;
+    listeners.delete(uri);
+    return import_effect.Effect.forEach(waiting, (listener) => import_effect.Deferred.succeed(listener, void 0), { discard: true });
+  };
+  const receive = (value) => {
+    const message = asMessage(value);
+    if (message?.method === "textDocument/publishDiagnostics") return publish(message.params);
+    if (message === void 0 || typeof message.id !== "number") return import_effect.Effect.void;
+    const deferred = pending.get(message.id);
+    if (deferred === void 0) return import_effect.Effect.void;
+    pending.delete(message.id);
+    if (message.error === void 0) return import_effect.Deferred.succeed(deferred, message.result);
+    const error = asMessage(message.error);
+    return import_effect.Deferred.fail(
+      deferred,
+      new StdError.StdError({
+        code: "request_failed",
+        message: typeof error?.message === "string" ? error.message : "Language server returned a JSON-RPC error",
+        ...typeof error?.code === "number" && typeof error.message === "string" ? {
+          rpcError: {
+            code: error.code,
+            message: error.message,
+            ...error.data === void 0 ? {} : { data: error.data }
+          }
+        } : {}
+      })
+    );
+  };
+  const receiveFrame = (event) => event._tag === "Message" ? receive(event.value) : event.id === void 0 ? failPending(event.error) : failRequest(event.id, event.error);
+  yield* handle.stdout.pipe(
+    import_effect.Stream.runForEach((chunk) => import_effect.Effect.forEach(decoder.push(chunk), receiveFrame, { discard: true })),
+    import_effect.Effect.matchEffect({
+      onFailure: () => closeWith(failure("request_failed", "Language server output stream failed")),
+      onSuccess: () => closeWith(failure("request_failed", "Language server output stream closed"))
+    }),
+    import_effect.Effect.forkScoped({ startImmediately: true })
+  );
+  yield* handle.exitCode.pipe(
+    import_effect.Effect.flatMap(
+      (exitCode) => closeWith(failure("request_failed", `Language server process exited with code ${exitCode}`))
+    ),
+    import_effect.Effect.catch(() => closeWith(failure("request_failed", "Language server process exited"))),
+    import_effect.Effect.forkScoped({ startImmediately: true })
+  );
+  const send = (message) => import_effect.Effect.suspend(
+    () => terminalError === void 0 ? import_effect.Queue.offer(input, frame(message)).pipe(
+      import_effect.Effect.asVoid,
+      import_effect.Effect.timeout(timeoutMs),
+      import_effect.Effect.mapError(
+        () => failure(
+          "timeout",
+          `Language server stdin is not being drained; frame offer exceeded ${timeoutMs}ms`
+        )
+      )
+    ) : import_effect.Effect.fail(terminalError)
+  );
+  const request = (method, params) => import_effect.Effect.gen(function* () {
+    const deferred = yield* import_effect.Deferred.make();
+    const registered = yield* import_effect.Effect.sync(() => {
+      if (terminalError !== void 0) return terminalError;
+      if (pending.size >= MAX_PENDING_REQUESTS) {
+        return failure(
+          "request_failed",
+          `Language server reached the ${MAX_PENDING_REQUESTS} pending-request cap`
+        );
+      }
+      const id2 = nextId++;
+      pending.set(id2, deferred);
+      return id2;
+    });
+    if (registered instanceof StdError.StdError) return yield* import_effect.Effect.fail(registered);
+    const id = registered;
+    return yield* import_effect.Effect.gen(function* () {
+      yield* send({ jsonrpc: "2.0", id, method, params });
+      return yield* import_effect.Deferred.await(deferred).pipe(
+        import_effect.Effect.timeout(timeoutMs),
+        import_effect.Effect.mapError(
+          (cause) => cause instanceof StdError.StdError ? cause : failure("timeout", `Language server request timed out: ${method}`)
+        )
+      );
+    }).pipe(
+      import_effect.Effect.ensuring(
+        import_effect.Effect.sync(() => {
+          pending.delete(id);
+        })
+      )
+    );
+  }).pipe(import_effect.Effect.mapError(
+    (error) => new StdError.StdError({
+      ...error,
+      method,
+      message: error.rpcError === void 0 ? error.message : `${method}: ${error.message}`,
+      ...stderrTail.byteLength === 0 ? {} : { stderr: stderr() }
+    })
+  ));
+  const notify = (method, params) => send({ jsonrpc: "2.0", method, params });
+  yield* request("initialize", {
+    processId: null,
+    rootUri: (0, import_node_url.pathToFileURL)(config.cwd).href,
+    capabilities: {
+      textDocument: {
+        synchronization: { dynamicRegistration: false },
+        publishDiagnostics: { versionSupport: true },
+        diagnostic: { dynamicRegistration: false }
+      }
+    },
+    ...config.initializationOptions === void 0 ? {} : { initializationOptions: config.initializationOptions }
+  });
+  yield* notify("initialized", {});
+  const positionParams = (position) => ({
+    textDocument: { uri: uriOf(position.path) },
+    position: { line: position.line, character: position.character }
+  });
+  const barrier = import_effect.Effect.suspend(
+    () => pullSupported || versionedPublishes || !barrierAnswered ? import_effect.Effect.void : request(BARRIER_METHOD, null).pipe(
+      import_effect.Effect.timeoutOption(Math.min(BARRIER_TIMEOUT_MS, timeoutMs)),
+      import_effect.Effect.flatMap(
+        (answer) => import_effect.Effect.sync(() => {
+          if (import_effect.Option.isNone(answer)) barrierAnswered = false;
+        })
+      ),
+      // The answer is MethodNotFound; any answer drains what came before it.
+      import_effect.Effect.ignore
+    )
+  );
+  const syncLock = yield* import_effect.Semaphore.make(1);
+  const sync = (path, text) => syncLock.withPermit(import_effect.Effect.andThen(barrier, () => {
+    const uri = uriOf(path);
+    const open = documents.get(uri);
+    const version = (versions.get(uri) ?? 0) + 1;
+    const sentAt = publishSequence;
+    const message = open === void 0 ? notify("textDocument/didOpen", {
+      textDocument: { uri, languageId: languageId(path), version, text }
+    }) : notify("textDocument/didChange", { textDocument: { uri, version }, contentChanges: [{ text }] });
+    return message.pipe(
+      import_effect.Effect.tap(
+        () => import_effect.Effect.sync(() => {
+          versions.set(uri, version);
+          documents.set(uri, { version, sentAt, digest: digestOf(text) });
+        })
+      )
+    );
+  }));
+  const closeUri = (uri) => import_effect.Effect.suspend(() => {
+    if (!documents.has(uri)) return import_effect.Effect.void;
+    documents.delete(uri);
+    published.delete(uri);
+    return notify("textDocument/didClose", { textDocument: { uri } });
+  });
+  const close = (path) => syncLock.withPermit(closeUri(uriOf(path)));
+  const refresh = import_effect.Effect.suspend(
+    () => import_effect.Effect.forEach([...documents], ([uri, open]) => {
+      const path = (0, import_node_url.fileURLToPath)(uri);
+      let text;
+      try {
+        text = NodeFs.readFileSync(path, "utf8");
+      } catch {
+        text = void 0;
+      }
+      if (text === void 0) return syncLock.withPermit(closeUri(uri));
+      return digestOf(text) === open.digest ? import_effect.Effect.void : sync(path, text);
+    }, { discard: true })
+  );
+  const current = (uri) => {
+    const entry = published.get(uri);
+    const open = documents.get(uri);
+    if (entry === void 0 || open === void 0) return void 0;
+    const fresh = entry.version === void 0 ? entry.sequence > open.sentAt : entry.version >= open.version;
+    return fresh ? entry : void 0;
+  };
+  const awaitPublished = (uri, after = 0) => import_effect.Effect.suspend(() => {
+    const entry = current(uri);
+    if (entry !== void 0 && entry.sequence > after) return import_effect.Effect.succeed(entry);
+    return import_effect.Effect.flatMap(import_effect.Deferred.make(), (listener) => {
+      const waiting = listeners.get(uri) ?? /* @__PURE__ */ new Set();
+      waiting.add(listener);
+      listeners.set(uri, waiting);
+      return import_effect.Deferred.await(listener).pipe(
+        import_effect.Effect.ensuring(import_effect.Effect.sync(() => {
+          listeners.get(uri)?.delete(listener);
+        })),
+        import_effect.Effect.flatMap(() => awaitPublished(uri, after))
+      );
+    });
+  });
+  const pushedDiagnostics = (path) => import_effect.Effect.gen(function* () {
+    const uri = uriOf(path);
+    if (!documents.has(uri)) {
+      const text = yield* import_effect.Effect.try({
+        try: () => NodeFs.readFileSync(NodePath.resolve(config.cwd, path), "utf8"),
+        catch: () => new StdError.StdError({ code: "not_found", message: `File not found: ${path}`, path })
+      });
+      yield* sync(path, text);
+    }
+    const started = yield* import_effect.Clock.currentTimeMillis;
+    const entry = yield* awaitPublished(uri).pipe(import_effect.Effect.timeoutOption(settleMs));
+    if (import_effect.Option.isNone(entry)) {
+      return yield* import_effect.Effect.fail(
+        new StdError.StdError({
+          code: "timeout",
+          message: `Language server published no diagnostics for ${path} within ${settleMs}ms`,
+          method: "textDocument/publishDiagnostics",
+          path
+        })
+      );
+    }
+    let latest = entry.value;
+    for (; ; ) {
+      const remaining = settleMs - ((yield* import_effect.Clock.currentTimeMillis) - started);
+      if (remaining <= 0) break;
+      const next = yield* awaitPublished(uri, latest.sequence).pipe(
+        import_effect.Effect.timeoutOption(Math.min(quietMs, remaining))
+      );
+      if (import_effect.Option.isNone(next)) break;
+      latest = next.value;
+    }
+    return { kind: "full", items: latest.diagnostics };
+  });
+  const diagnostics = (path) => pullUnsupported ? pushedDiagnostics(path) : request("textDocument/diagnostic", { textDocument: { uri: uriOf(path) } }).pipe(
+    import_effect.Effect.tap(
+      () => import_effect.Effect.sync(() => {
+        pullSupported = true;
+      })
+    ),
+    import_effect.Effect.catchIf(
+      (error) => error.rpcError?.code === METHOD_NOT_FOUND,
+      () => {
+        pullUnsupported = true;
+        return pushedDiagnostics(path);
+      }
+    )
+  );
+  const prepareCallHierarchy = (position) => request("textDocument/prepareCallHierarchy", positionParams(position));
+  const callHierarchy = (method, position) => prepareCallHierarchy(position).pipe(
+    import_effect.Effect.flatMap((prepared) => {
+      const item = firstCallHierarchyItem(prepared);
+      return item === void 0 ? import_effect.Effect.succeed([]) : request(method, { item });
+    })
+  );
+  return LanguageServer.make({
+    hover: (position) => request("textDocument/hover", positionParams(position)),
+    definition: (position) => request("textDocument/definition", positionParams(position)),
+    references: (position) => request("textDocument/references", {
+      ...positionParams(position),
+      context: { includeDeclaration: true }
+    }),
+    implementation: (position) => request("textDocument/implementation", positionParams(position)),
+    documentSymbols: (path) => request("textDocument/documentSymbol", { textDocument: { uri: uriOf(path) } }),
+    workspaceSymbols: (query) => request("workspace/symbol", { query }),
+    prepareCallHierarchy,
+    callHierarchyIncoming: (position) => callHierarchy("callHierarchy/incomingCalls", position),
+    callHierarchyOutgoing: (position) => callHierarchy("callHierarchy/outgoingCalls", position),
+    diagnostics,
+    sync,
+    close,
+    refresh
+  });
+});
+const normalizeExtension = (extension) => (extension.startsWith(".") ? extension : `.${extension}`).toLowerCase();
+const routed = (configs, client, started) => {
+  const claims = configs.map((entry) => entry.extensions?.map(normalizeExtension));
+  const fallback = claims.findIndex((claimed) => claimed === void 0);
+  const indexOf = (path) => {
+    const extension = extensionOf(path);
+    const claimed = claims.findIndex((entry) => entry?.includes(extension) === true);
+    const index = claimed >= 0 ? claimed : fallback;
+    return index >= 0 ? import_effect.Effect.succeed(index) : import_effect.Effect.fail(
+      new StdError.StdError({
+        code: "unsupported",
+        message: `No language server is configured for ${extension || "extensionless"} files`,
+        path
+      })
+    );
+  };
+  const route = (path) => import_effect.Effect.flatMap(indexOf(path), client);
+  const byPosition = (method) => (position) => import_effect.Effect.flatMap(route(position.path), (server) => server[method](position));
+  const indices = configs.map((_, index) => index);
+  return LanguageServer.make({
+    hover: byPosition("hover"),
+    definition: byPosition("definition"),
+    references: byPosition("references"),
+    implementation: byPosition("implementation"),
+    prepareCallHierarchy: byPosition("prepareCallHierarchy"),
+    callHierarchyIncoming: byPosition("callHierarchyIncoming"),
+    callHierarchyOutgoing: byPosition("callHierarchyOutgoing"),
+    documentSymbols: (path) => import_effect.Effect.flatMap(route(path), (server) => server.documentSymbols(path)),
+    diagnostics: (path) => import_effect.Effect.flatMap(route(path), (server) => server.diagnostics(path)),
+    sync: (path, text) => import_effect.Effect.flatMap(route(path), (server) => server.sync(path, text)),
+    // A server that never started holds no open file.
+    close: (path) => import_effect.Effect.flatMap(indexOf(path), (index) => started(index)?.close(path) ?? import_effect.Effect.void),
+    refresh: import_effect.Effect.suspend(
+      () => import_effect.Effect.forEach(indices, (index) => started(index)?.refresh ?? import_effect.Effect.void, { discard: true })
+    ),
+    workspaceSymbols: (query) => configs.length === 1 ? import_effect.Effect.flatMap(client(0), (server) => server.workspaceSymbols(query)) : import_effect.Effect.forEach(
+      indices,
+      (index) => import_effect.Effect.flatMap(client(index), (server) => server.workspaceSymbols(query)),
+      { concurrency: "unbounded" }
+    ).pipe(
+      import_effect.Effect.map(
+        (answers) => answers.flatMap((answer) => Array.isArray(answer) ? answer : answer == null ? [] : [answer])
+      )
+    )
+  });
+};
+const configList = (config) => {
+  const configs = Array.isArray(config) ? config : [config];
+  return configs.length === 0 ? import_effect.Effect.fail(failure("invalid_input", "At least one language server must be configured")) : import_effect.Effect.succeed(configs);
+};
+const make = (config) => import_effect.Effect.gen(function* () {
+  const configs = yield* configList(config);
+  const clients = yield* import_effect.Effect.forEach(configs, makeClient);
+  return routed(configs, (index) => import_effect.Effect.succeed(clients[index]), (index) => clients[index]);
+});
+const makeLazy = (config) => import_effect.Effect.gen(function* () {
+  const configs = yield* configList(config);
+  for (const entry of configs) {
+    const refused = workspaceProgram(entry, ChildProcessEnvironment.make(process.env, entry.environment).PATH);
+    if (refused !== void 0) return yield* import_effect.Effect.fail(refused);
+  }
+  const clients = configs.map(() => void 0);
+  const starts = yield* import_effect.Effect.forEach(configs, (entry, index) => import_effect.Effect.gen(function* () {
+    const wanted = yield* import_effect.Deferred.make();
+    const ready = yield* import_effect.Deferred.make();
+    yield* import_effect.Deferred.await(wanted).pipe(
+      import_effect.Effect.andThen(makeClient(entry)),
+      import_effect.Effect.tap((client) => import_effect.Effect.sync(() => void (clients[index] = client))),
+      import_effect.Effect.exit,
+      import_effect.Effect.flatMap((exit) => import_effect.Deferred.done(ready, exit)),
+      import_effect.Effect.forkScoped({ startImmediately: true })
+    );
+    return import_effect.Deferred.succeed(wanted, void 0).pipe(import_effect.Effect.andThen(import_effect.Deferred.await(ready)));
+  }));
+  return routed(configs, (index) => starts[index], (index) => clients[index]);
+});
+const layer = (config) => import_effect.Layer.effect(LanguageServer.LanguageServer, make(config));
+const layerLazy = (config) => import_effect.Layer.effect(LanguageServer.LanguageServer, makeLazy(config));
+//# sourceMappingURL=NodeLanguageServer.js.map