@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-frwpyczr.js

@@ -0,0 +1,77 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/tool/plugin/opencode.ts
+var exports_opencode = {};
+__export(exports_opencode, {
+  MoveInput: () => MoveInput2,
+  OpenCodeTools: () => exports_opencode,
+  Plugin: () => Plugin3,
+  RenameInput: () => RenameInput2
+});
+import { SystemPart, ToolFailure } from "@opencode/ai";
+import { AbsolutePath } from "@opencode/schema/schema";
+import { Session } from "@opencode/schema/session";
+import { Effect, Schema } from "effect";
+var RenameInput2 = Schema.Struct({
+  sessionID: Schema.optionalKey(Session.ID).annotate({ description: "Omit to rename the current session." }),
+  title: Schema.String.check(Schema.isMinLength(1)).annotate({ description: "New session title." })
+});
+var RenameOutput = Schema.Struct({ sessionID: Session.ID, title: Schema.String });
+var MoveInput2 = Schema.Struct({
+  sessionID: Schema.optionalKey(Session.ID).annotate({ description: "Omit to move the current session." }),
+  directory: AbsolutePath.check(Schema.isMinLength(1)).annotate({
+    description: "Destination directory, relative to the target session's directory or absolute. Supports ~."
+  })
+});
+var MoveOutput = Schema.Struct({ sessionID: Session.ID, directory: AbsolutePath });
+var Plugin3 = {
+  id: "opencode.tools",
+  effect: Effect.fn("OpenCodeTools.Plugin")(function* (ctx) {
+    yield* ctx.session.hook("context", (event) => Effect.sync(() => {
+      event.system.push(SystemPart.make("When you create a worktree outside the current working directory and intend to use it as your primary working directory, consider using `execute` to call `tools.opencode.session_move` and make the worktree the session's working directory."));
+    }));
+    yield* ctx.tool.transform((draft) => {
+      draft.namespace({ name: "opencode", description: "OpenCode session and runtime tools." });
+      draft.add({
+        name: "session_rename",
+        description: "Rename a session, or omit sessionID to rename the current session. Use a short, specific title that summarizes the work being done.",
+        input: RenameInput2,
+        output: RenameOutput,
+        options: { namespace: "opencode", codemode: true },
+        execute: (input, context) => {
+          const sessionID = input.sessionID ?? context.sessionID;
+          const title = input.title.trim();
+          if (!title)
+            return Effect.fail(new ToolFailure({ message: "Session title must not be empty" }));
+          return ctx.session.rename({ sessionID, title }).pipe(Effect.as({
+            output: { sessionID, title },
+            content: `Renamed session ${sessionID} to ${title}.`
+          }), Effect.mapError((error) => new ToolFailure({ message: `Unable to rename session ${sessionID}`, error })));
+        }
+      });
+      draft.add({
+        name: "session_move",
+        description: "Move a session to another directory, or omit sessionID to move the current session. The current session moves at the next safe boundary; do not run destination-dependent tools in the same execute call.",
+        input: MoveInput2,
+        output: MoveOutput,
+        options: { namespace: "opencode", codemode: true, pinned: true },
+        execute: (input, context) => Effect.gen(function* () {
+          const sessionID = input.sessionID ?? context.sessionID;
+          yield* ctx.session.move({
+            sessionID,
+            directory: input.directory,
+            delivery: "steer"
+          });
+          return {
+            output: { sessionID, directory: input.directory },
+            content: `Moved session ${sessionID} to ${input.directory}.`
+          };
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Unable to move session to ${input.directory}`, error })))
+      });
+    }).pipe(Effect.orDie);
+  })
+};
+
+export { RenameInput2, MoveInput2, Plugin3, exports_opencode };

package/dist/chunks/worktree-ftevhb49.js

@@ -0,0 +1,470 @@
+import {
+  Service74
+} from "./worktree-z82wee6n.js";
+import {
+  PATCH_CONTEXT_LINES2,
+  MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2,
+  chunksByFile2
+} from "./worktree-tazgh4e4.js";
+import {
+  DiffError2
+} from "./worktree-vp47j2z8.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/plugin/vcs/git.ts
+var exports_git = {};
+__export(exports_git, {
+  Plugin: () => Plugin32,
+  VcsGitPlugin: () => exports_git
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { AppProcess } from "@opencode/util/process";
+var Plugin32 = define({
+  id: "opencode.vcs.git",
+  effect: Effect.fn("VcsGitPlugin")(function* (ctx) {
+    const location = yield* Service74;
+    if (location.vcs?.type !== "git")
+      return;
+    const processes = yield* AppProcess.Service;
+    const adapter = make(processes, {
+      directory: location.directory,
+      worktree: location.project.directory
+    });
+    yield* ctx.vcs.transform((editor) => {
+      editor.add({
+        id: "git",
+        name: "Git",
+        info: () => adapter.info(),
+        base: () => adapter.base(),
+        branches: (input) => adapter.branches({ search: input.search, limit: input.limit }),
+        status: () => adapter.status(),
+        diff: (input) => adapter.diff(input.mode, { context: input.context, base: input.base })
+      });
+    });
+  })
+});
+function make(proc, input) {
+  const ctx = { git: makeGit(proc), directory: input.directory, worktree: input.worktree };
+  return {
+    info: Effect.fn("VcsGit.info")(function* () {
+      const [current, root] = yield* Effect.all([ctx.git.branch(ctx.directory), ctx.git.defaultBranch(ctx.directory)], {
+        concurrency: 2
+      });
+      return { branch: { current, default: root?.name } };
+    }),
+    base: () => ctx.git.base(ctx.directory),
+    branches: Effect.fn("VcsGit.branches")(function* (options) {
+      return yield* ctx.git.branches(ctx.directory, options);
+    }),
+    status: Effect.fn("VcsGit.status")(function* () {
+      const git = ctx.git;
+      const ref = (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined;
+      const [list, stats] = yield* Effect.all([git.status(ctx.directory), ref ? git.stats(ctx.directory, ref) : Effect.succeed([])], { concurrency: 2 });
+      const map = nums(stats);
+      return yield* Effect.forEach(list.toSorted((a, b) => a.file.localeCompare(b.file)), (item) => Effect.gen(function* () {
+        const stat = map.get(item.file) ?? (item.status === "added" ? yield* git.statUntracked(ctx.worktree, item.file) : undefined);
+        return {
+          file: item.file,
+          additions: stat?.additions ?? 0,
+          deletions: stat?.deletions ?? 0,
+          status: item.status
+        };
+      }));
+    }),
+    diff: Effect.fn("VcsGit.diff")(function* (mode, options) {
+      const git = ctx.git;
+      if (mode === "working") {
+        return yield* track(ctx, (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined, options);
+      }
+      if (!(yield* git.hasHead(ctx.directory))) {
+        return mode === "committed" ? [] : yield* track(ctx, undefined, options);
+      }
+      const base = options?.base ?? (yield* git.defaultBranch(ctx.directory))?.ref;
+      const ref = base ? yield* git.mergeBase(ctx.directory, base) : undefined;
+      if (!ref) {
+        return yield* new DiffError2({
+          message: base ? `No merge base available for ${base}` : "No review base available"
+        });
+      }
+      return yield* diffAgainstRef(ctx, ref, { ...options, target: mode === "committed" ? "HEAD" : undefined });
+    })
+  };
+}
+var cfg = [
+  "--no-optional-locks",
+  "-c",
+  "core.autocrlf=false",
+  "-c",
+  "core.fsmonitor=false",
+  "-c",
+  "core.longpaths=true",
+  "-c",
+  "core.symlinks=true",
+  "-c",
+  "core.quotepath=false"
+];
+var kind = (code) => {
+  if (code === "??")
+    return "added";
+  if (code.includes("U"))
+    return "modified";
+  if (code.includes("A") && !code.includes("D"))
+    return "added";
+  if (code.includes("D") && !code.includes("A"))
+    return "deleted";
+  return "modified";
+};
+var nuls = (text) => text.split("\x00").filter(Boolean);
+function makeGit(proc) {
+  const run = Effect.fnUntraced(function* (args, opts) {
+    const result = yield* proc.run(ChildProcess.make("git", [...cfg, ...args], {
+      cwd: opts.cwd,
+      extendEnv: true,
+      stdin: "ignore"
+    }), { maxOutputBytes: opts.maxOutputBytes });
+    return {
+      exitCode: result.exitCode,
+      text: () => result.stdout.toString("utf8"),
+      truncated: result.stdoutTruncated || result.stderrTruncated
+    };
+  }, Effect.orElseSucceed(() => ({ exitCode: 1, text: () => "", truncated: false })));
+  const text = Effect.fnUntraced(function* (args, opts) {
+    return (yield* run(args, opts)).text();
+  });
+  const lines = Effect.fnUntraced(function* (args, opts) {
+    return (yield* text(args, opts)).split(/\r?\n/).map((item) => item.trim()).filter(Boolean);
+  });
+  const configured = Effect.fnUntraced(function* (cwd, list) {
+    const result = yield* run(["config", "init.defaultBranch"], { cwd });
+    const name = result.text().trim();
+    if (!name || !list.includes(name))
+      return;
+    return { name, ref: name };
+  });
+  const primary = Effect.fnUntraced(function* (cwd) {
+    const list = yield* lines(["remote"], { cwd });
+    if (list.includes("origin"))
+      return "origin";
+    if (list.length === 1)
+      return list[0];
+    if (list.includes("upstream"))
+      return "upstream";
+    return list[0];
+  });
+  const branch = Effect.fn("VcsGit.branch")(function* (cwd) {
+    const result = yield* run(["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const branches = Effect.fn("VcsGit.branches")(function* (cwd, options) {
+    const search = options?.search?.trim().replace(/[*?[\]\\]/g, "\\$&");
+    return (yield* lines([
+      "for-each-ref",
+      "--ignore-case",
+      "--sort=refname",
+      "--sort=-committerdate",
+      "--format=%(refname:short)",
+      ...options?.limit ? [`--count=${options.limit}`] : [],
+      ...search ? [`refs/heads/*${search}*`, `refs/remotes/*${search}*`] : ["refs/heads", "refs/remotes"]
+    ], { cwd })).filter((item) => !item.endsWith("/HEAD"));
+  });
+  const defaultBranch = Effect.fn("VcsGit.defaultBranch")(function* (cwd) {
+    const remote = yield* primary(cwd);
+    if (remote) {
+      const head = yield* run(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd });
+      if (head.exitCode === 0) {
+        const ref = head.text().trim().replace(/^refs\/remotes\//, "");
+        const name = ref.startsWith(`${remote}/`) ? ref.slice(`${remote}/`.length) : "";
+        if (name)
+          return { name, ref };
+      }
+    }
+    const list = yield* lines(["for-each-ref", "--format=%(refname:short)", "refs/heads"], { cwd });
+    const next = yield* configured(cwd, list);
+    if (next)
+      return next;
+    if (list.includes("main"))
+      return { name: "main", ref: "main" };
+    if (list.includes("master"))
+      return { name: "master", ref: "master" };
+  });
+  const resolve = Effect.fnUntraced(function* (cwd, ref) {
+    const result = yield* run(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const ancestor = Effect.fnUntraced(function* (cwd, commit, ref) {
+    if (!/^[a-f0-9]{40,64}$/.test(commit))
+      return false;
+    return (yield* run(["merge-base", "--is-ancestor", commit, ref], { cwd })).exitCode === 0;
+  });
+  const namedRef = Effect.fnUntraced(function* (cwd, input) {
+    if (input === "HEAD" || input.endsWith("/HEAD") || /[~^:@{}\s]/.test(input))
+      return;
+    const ref = (yield* text(["rev-parse", "--symbolic-full-name", "--verify", "--end-of-options", input], {
+      cwd
+    })).trim();
+    if (!/^refs\/(heads|remotes)\/.+/.test(ref) || ref.endsWith("/HEAD") || !(yield* resolve(cwd, ref)))
+      return;
+    return { name: ref.replace(/^refs\/heads\//, "").replace(/^refs\/remotes\/[^/]+\//, ""), ref };
+  });
+  const base = Effect.fn("VcsGit.base")(function* (cwd) {
+    if (!(yield* hasHead(cwd)))
+      return null;
+    const current = yield* branch(cwd);
+    if (!current)
+      return yield* new DiffError2({ message: "Choose a review base" });
+    const history = (yield* lines(["reflog", "show", "--max-count=256", "--format=%H%x00%gs", `refs/heads/${current}`], {
+      cwd
+    })).flatMap((line) => {
+      const match = /^([a-f0-9]+)\0(.+)$/.exec(line);
+      return match ? [{ commit: match[1], message: match[2] }] : [];
+    });
+    const renamed = history.some((entry) => entry.message.startsWith("Branch: renamed "));
+    const creation = renamed ? undefined : history.find((entry) => entry.message.startsWith("branch: Created from "));
+    const origin = creation?.message.slice("branch: Created from ".length);
+    if (creation && origin) {
+      const candidate = yield* namedRef(cwd, origin);
+      if (candidate && candidate.name !== current && (yield* ancestor(cwd, creation.commit, "HEAD")) && (yield* ancestor(cwd, creation.commit, candidate.ref))) {
+        return { ...candidate, source: "reflog" };
+      }
+    }
+    const root = yield* defaultBranch(cwd);
+    if (!root || current !== root.name)
+      return yield* new DiffError2({ message: "Choose a review base" });
+    const candidate = yield* namedRef(cwd, root.ref);
+    if (!candidate)
+      return yield* new DiffError2({ message: "The default review base is unavailable" });
+    return { name: root.name, ref: candidate.ref, source: "default" };
+  });
+  const hasHead = Effect.fn("VcsGit.hasHead")(function* (cwd) {
+    const result = yield* run(["rev-parse", "--verify", "HEAD"], { cwd });
+    return result.exitCode === 0;
+  });
+  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base) {
+    const ref = yield* resolve(cwd, base);
+    if (!ref)
+      return;
+    const result = yield* run(["merge-base", ref, "HEAD"], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const status = Effect.fn("VcsGit.statusNames")(function* (cwd) {
+    return nuls(yield* text(["status", "--porcelain=v1", "--untracked-files=all", "--no-renames", "-z", "--", "."], { cwd })).flatMap((item) => {
+      const file = item.slice(3);
+      if (!file)
+        return [];
+      const code = item.slice(0, 2);
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const diff = Effect.fn("VcsGit.diffNames")(function* (cwd, ref, target) {
+    const result = yield* run(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, ...target ? [target] : [], "--", "."], { cwd });
+    if (result.exitCode !== 0)
+      return yield* new DiffError2({ message: "Unable to list Git changes" });
+    const list = nuls(result.text());
+    return list.flatMap((code, idx) => {
+      if (idx % 2 !== 0)
+        return [];
+      const file = list[idx + 1];
+      if (!code || !file)
+        return [];
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const stats = Effect.fn("VcsGit.stats")(function* (cwd, ref, target) {
+    return nuls(yield* text(["diff", "--no-ext-diff", "--no-renames", "--numstat", "-z", ref, ...target ? [target] : [], "--", "."], { cwd })).flatMap((item) => {
+      const a = item.indexOf("\t");
+      const b = item.indexOf("\t", a + 1);
+      if (a === -1 || b === -1)
+        return [];
+      const file = item.slice(b + 1);
+      if (!file)
+        return [];
+      const adds = item.slice(0, a);
+      const dels = item.slice(a + 1, b);
+      const additions = adds === "-" ? 0 : Number.parseInt(adds || "0", 10);
+      const deletions = dels === "-" ? 0 : Number.parseInt(dels || "0", 10);
+      return [
+        {
+          file,
+          additions: Number.isFinite(additions) ? additions : 0,
+          deletions: Number.isFinite(deletions) ? deletions : 0
+        }
+      ];
+    });
+  });
+  const patch = Effect.fn("VcsGit.patch")(function* (cwd, ref, file, options) {
+    const result = yield* run([
+      "diff",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      ref,
+      ...options?.target ? [options.target] : [],
+      "--",
+      file
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.truncated ? "" : result.text(), truncated: result.truncated };
+  });
+  const patchAll = Effect.fn("VcsGit.patchAll")(function* (cwd, ref, options) {
+    const result = yield* run([
+      "diff",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      ref,
+      ...options?.target ? [options.target] : [],
+      "--",
+      "."
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.text(), truncated: result.truncated };
+  });
+  const patchUntracked = Effect.fn("VcsGit.patchUntracked")(function* (cwd, file, options) {
+    const result = yield* run([
+      "diff",
+      "--no-index",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      "--",
+      "/dev/null",
+      file
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.truncated ? "" : result.text(), truncated: result.truncated };
+  });
+  const statUntracked = Effect.fn("VcsGit.statUntracked")(function* (cwd, file) {
+    const result = yield* run(["diff", "--no-index", "--numstat", "--", "/dev/null", file], {
+      cwd,
+      maxOutputBytes: 4096
+    });
+    if (result.truncated)
+      return;
+    const parts = result.text().split("\t");
+    if (parts.length < 2)
+      return;
+    const additions = parts[0] === "-" ? 0 : Number.parseInt(parts[0] || "0", 10);
+    const deletions = parts[1] === "-" ? 0 : Number.parseInt(parts[1] || "0", 10);
+    return {
+      file,
+      additions: Number.isFinite(additions) ? additions : 0,
+      deletions: Number.isFinite(deletions) ? deletions : 0
+    };
+  });
+  return {
+    branch,
+    branches,
+    base,
+    defaultBranch,
+    hasHead,
+    mergeBase,
+    status,
+    diff,
+    stats,
+    patch,
+    patchAll,
+    patchUntracked,
+    statUntracked
+  };
+}
+var nums = (list) => new Map(list.map((item) => [item.file, { additions: item.additions, deletions: item.deletions }]));
+var merge = (...lists) => {
+  const out = new Map;
+  lists.flat().forEach((item) => {
+    if (!out.has(item.file))
+      out.set(item.file, item);
+  });
+  return [...out.values()];
+};
+var emptyBatch = () => ({ patches: new Map, capped: false });
+var batchPatches = Effect.fnUntraced(function* (ctx, ref, list, options) {
+  if (list.length === 0)
+    return emptyBatch();
+  const result = yield* ctx.git.patchAll(ctx.directory, ref, {
+    target: options?.target,
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_TOTAL_PATCH_BYTES2
+  });
+  return {
+    patches: chunksByFile2(result, (index) => list[index]?.file),
+    capped: result.truncated
+  };
+});
+var nativePatch = Effect.fnUntraced(function* (ctx, ref, item, options) {
+  const result = item.code === "??" || !ref ? yield* ctx.git.patchUntracked(ctx.worktree, item.file, {
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
+  }) : yield* ctx.git.patch(ctx.worktree, ref, item.file, {
+    target: options?.target,
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
+  });
+  if (!result.truncated && result.text)
+    return result.text;
+  return emptyPatch2(item.file);
+});
+var totalPatch = (file, patch, total) => {
+  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES2)
+    return { patch, capped: false };
+  return { patch: emptyPatch2(file), capped: true };
+};
+var patchForItem = Effect.fnUntraced(function* (ctx, ref, item, batch, capped, options) {
+  if (capped)
+    return emptyPatch2(item.file);
+  const batched = batch.patches.get(item.file);
+  if (batched !== undefined)
+    return batched;
+  if (item.code !== "??" && batch.capped)
+    return emptyPatch2(item.file);
+  return yield* nativePatch(ctx, ref, item, options);
+});
+var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
+  const next = [];
+  let total = 0;
+  let capped = false;
+  for (const item of list.toSorted((a, b) => a.file.localeCompare(b.file))) {
+    const stat = map.get(item.file) ?? (!options?.target && item.status === "added" ? yield* ctx.git.statUntracked(ctx.worktree, item.file) : undefined);
+    const patch = yield* patchForItem(ctx, ref, item, batch, capped, options);
+    const result = capped ? { patch, capped: true } : totalPatch(item.file, patch, total);
+    capped = capped || result.capped;
+    if (!capped) {
+      total += Buffer.byteLength(result.patch);
+      capped = total >= MAX_TOTAL_PATCH_BYTES2;
+    }
+    next.push({
+      file: item.file,
+      patch: result.patch,
+      additions: stat?.additions ?? 0,
+      deletions: stat?.deletions ?? 0,
+      status: item.status
+    });
+  }
+  return next;
+});
+var diffAgainstRef = Effect.fnUntraced(function* (ctx, ref, options) {
+  const [list, stats, extra] = yield* Effect.all([
+    ctx.git.diff(ctx.directory, ref, options?.target),
+    ctx.git.stats(ctx.directory, ref, options?.target),
+    options?.target ? Effect.succeed([]) : ctx.git.status(ctx.directory)
+  ], { concurrency: 3 });
+  return yield* files(ctx, ref, merge(list, extra.filter((item) => item.code === "??")), nums(stats), yield* batchPatches(ctx, ref, list, options), options);
+});
+var track = Effect.fnUntraced(function* (ctx, ref, options) {
+  if (!ref)
+    return yield* files(ctx, ref, yield* ctx.git.status(ctx.directory), new Map, emptyBatch(), options);
+  return yield* diffAgainstRef(ctx, ref, options);
+});
+
+export { Plugin32, exports_git };

package/dist/chunks/worktree-fvanntqq.js

@@ -0,0 +1,84 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/v1/config/lsp.ts
+var exports_lsp = {};
+__export(exports_lsp, {
+  ConfigLSPV1: () => exports_lsp,
+  Disabled: () => Disabled2,
+  Entry: () => Entry4,
+  Info: () => Info18,
+  builtinServerIds: () => builtinServerIds2,
+  requiresExtensionsForCustomServers: () => requiresExtensionsForCustomServers2
+});
+import { Schema } from "effect";
+var Disabled2 = Schema.Struct({
+  disabled: Schema.Literal(true)
+});
+var Entry4 = Schema.Union([
+  Disabled2,
+  Schema.Struct({
+    command: Schema.mutable(Schema.Array(Schema.String)),
+    extensions: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+    disabled: Schema.optional(Schema.Boolean),
+    env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    initialization: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+  })
+]);
+var builtinServerIds2 = [
+  "deno",
+  "typescript",
+  "vue",
+  "eslint",
+  "oxlint",
+  "biome",
+  "gopls",
+  "ruby-lsp",
+  "ty",
+  "pyright",
+  "elixir-ls",
+  "zls",
+  "csharp",
+  "razor",
+  "fsharp",
+  "sourcekit-lsp",
+  "rust",
+  "clangd",
+  "svelte",
+  "astro",
+  "jdtls",
+  "kotlin-ls",
+  "yaml-ls",
+  "lua-ls",
+  "php intelephense",
+  "prisma",
+  "dart",
+  "ocaml-lsp",
+  "bash",
+  "terraform",
+  "texlab",
+  "dockerfile",
+  "gleam",
+  "clojure-lsp",
+  "nixd",
+  "tinymist",
+  "haskell-language-server",
+  "julials"
+];
+var requiresExtensionsForCustomServers2 = Schema.makeFilter((data) => {
+  if (typeof data === "boolean")
+    return;
+  const ids = new Set(builtinServerIds2);
+  const ok = Object.entries(data).every(([id, config]) => {
+    if ("disabled" in config && config.disabled)
+      return true;
+    if (ids.has(id))
+      return true;
+    return "extensions" in config && Boolean(config.extensions);
+  });
+  return ok ? undefined : "For custom LSP servers, 'extensions' array is required.";
+});
+var Info18 = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry4)]).check(requiresExtensionsForCustomServers2);
+
+export { Disabled2, Entry4, builtinServerIds2, requiresExtensionsForCustomServers2, Info18, exports_lsp };