@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-rp98wqty.js

@@ -0,0 +1,326 @@
+import {
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./worktree-2a5m3afh.js";
+import {
+  Service74
+} from "./worktree-z82wee6n.js";
+import {
+  Service52
+} from "./worktree-pr7ch8ks.js";
+import {
+  Service15
+} from "./worktree-8mvsftc3.js";
+import {
+  Service51,
+  readText2,
+  syncTextBom2
+} from "./worktree-nsx3nvvw.js";
+import {
+  Service70
+} from "./worktree-k56d8zdx.js";
+import {
+  Service69,
+  resolvePath2
+} from "./worktree-13bmfrpk.js";
+import {
+  fileDiff2
+} from "./worktree-6prwharc.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/tool/plugin/patch.ts
+var exports_patch = {};
+__export(exports_patch, {
+  Applied: () => Applied2,
+  Input: () => Input12,
+  Output: () => Output8,
+  PatchTool: () => exports_patch,
+  Plugin: () => Plugin13,
+  name: () => name12,
+  toModelContent: () => toModelContent6
+});
+import { ToolFailure } from "@opencode/ai";
+import { FileDiff } from "@opencode/schema/file-diff";
+import { Effect, Result, Schema } from "effect";
+import { Bom } from "@opencode/util/bom";
+import { Patch } from "@opencode/util/patch";
+
+// src/tool/patch.txt
+var patch_default = `Use the \`patch\` tool to edit files. Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Within that envelope, you get a sequence of file operations.
+You MUST include a header to specify the action you are taking.
+Each operation starts with one of three headers:
+
+*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+*** Delete File: <path> - remove an existing file. Nothing follows.
+*** Update File: <path> - patch an existing file in place (optionally with a rename).
+
+Example patch:
+
+\`\`\`
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch
+\`\`\`
+
+It is important to remember:
+
+- You must include a header with your intended action (Add/Delete/Update)
+- You must prefix new lines with \`+\` even when creating a new file
+`;
+
+// src/tool/plugin/patch.ts
+var name12 = "patch";
+var Input12 = Schema.Struct({
+  patchText: Schema.String.annotate({
+    description: "The full patch text describing add, update, and delete operations"
+  })
+});
+var Applied2 = Schema.Struct({
+  type: Schema.Literals(["add", "update", "delete"]),
+  resource: Schema.String,
+  target: Schema.String
+});
+var Output8 = Schema.Struct({
+  applied: Schema.Array(Applied2),
+  files: Schema.Array(FileDiff.Info)
+});
+var toModelContent6 = (output) => [
+  "Success. Updated the following files:",
+  ...output.applied.map((item) => `${item.type === "add" ? "A" : item.type === "delete" ? "D" : "M"} ${item.resource}`)
+].join(`
+`);
+var Plugin13 = {
+  id: "opencode.tool.patch",
+  effect: Effect.fn("PatchTool.Plugin")(function* (ctx) {
+    const environment = yield* Service52;
+    const access = yield* Service69;
+    const fileMutation = yield* Service51;
+    const formatter = yield* Service15;
+    const location = yield* Service74;
+    const permission = yield* Service70;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name12,
+      options: { codemode: false, permission: "edit" },
+      description: patch_default,
+      input: Input12,
+      output: Output8,
+      execute: (input, context) => {
+        const applied = [];
+        const parsed = Patch.parse(input.patchText);
+        const lockTargets = Result.isSuccess(parsed) ? parsed.success.flatMap((hunk) => [
+          resolvePath2(location.directory, hunk.path),
+          ...hunk.type === "update" && hunk.movePath ? [resolvePath2(location.directory, hunk.movePath)] : []
+        ]) : [];
+        const fail = (operation, error) => {
+          const completed = applied.map((item) => item.resource).join(", ");
+          return new ToolFailure({
+            message: `${operation}: ${errorMessage(error)}${completed ? `. Completed before failure: ${completed}` : ""}`
+          });
+        };
+        return Effect.gen(function* () {
+          const source = {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          };
+          if (!input.patchText)
+            return yield* new ToolFailure({ message: "patchText is required" });
+          const hunks = yield* Effect.fromResult(parsed).pipe(Effect.mapError((error) => new ToolFailure({ message: `patch verification failed: ${error.message}` })));
+          if (hunks.length === 0) {
+            return yield* new ToolFailure({ message: "patch rejected: empty patch" });
+          }
+          const prepared = [];
+          const updates = new Map;
+          const resolveTarget = Effect.fnUntraced(function* (value) {
+            const target = yield* access.resolve({ path: value, kind: "file" });
+            if (!target.externalDirectory)
+              return target;
+            yield* access.authorizeExternal([target], context, {
+              filepath: target.absolute,
+              parentDir: target.externalDirectory.directory
+            });
+            return target;
+          });
+          for (const hunk of hunks) {
+            yield* Effect.gen(function* () {
+              const target = yield* resolveTarget(hunk.path);
+              if (hunk.type === "add") {
+                const content = hunk.contents.endsWith(`
+`) || hunk.contents === "" ? hunk.contents : `${hunk.contents}
+`;
+                prepared.push({
+                  ...hunk,
+                  target,
+                  content,
+                  before: "",
+                  after: Bom.split(content).text
+                });
+                return;
+              }
+              if (hunk.type === "delete") {
+                const content = yield* readText2(environment.files, target.absolute).pipe(Effect.mapError((error) => new ToolFailure({
+                  message: `patch verification failed: Failed to delete ${target.resource}: ${errorMessage(error)}`
+                })));
+                prepared.push({ ...hunk, target, before: content.text, after: "" });
+                return;
+              }
+              const previous = updates.get(target.absolute);
+              const original = previous ?? (yield* Effect.gen(function* () {
+                const content = yield* readText2(environment.files, target.absolute).pipe(Effect.mapError((error) => new ToolFailure({
+                  message: `patch verification failed: Failed to read file to update ${target.absolute}: ${errorMessage(error)}`
+                })));
+                return Bom.join(content.text, content.bom);
+              }));
+              const before = Bom.split(original).text;
+              const update = yield* Effect.try({
+                try: () => Patch.derive(hunk.path, hunk.chunks, original),
+                catch: (error) => new ToolFailure({ message: `patch verification failed: ${errorMessage(error)}` })
+              });
+              const moveTarget = hunk.movePath ? yield* resolveTarget(hunk.movePath) : undefined;
+              prepared.push({
+                ...hunk,
+                target,
+                content: Patch.joinBom(update.content, update.bom),
+                before,
+                after: update.content,
+                moveTarget
+              });
+              if (!moveTarget)
+                updates.set(target.absolute, Patch.joinBom(update.content, update.bom));
+            }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to prepare patch at ${hunk.path}`, error })));
+          }
+          const patchFiles = prepared.map((change) => patchFile(change));
+          const targets = prepared.flatMap((change) => [
+            change.target,
+            ...change.type === "update" && change.moveTarget ? [change.moveTarget] : []
+          ]);
+          yield* permission.assert({
+            action: "edit",
+            resources: [...new Set(targets.map((target) => target.resource))],
+            save: ["*"],
+            metadata: {
+              filepath: targets.map((target) => target.resource).join(", "),
+              diff: patchFiles.map((file) => `${file.patch}
+`).join(""),
+              files: patchFiles
+            },
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+          yield* Effect.forEach(prepared, (change) => Effect.gen(function* () {
+            if (change.type === "delete") {
+              yield* environment.files.remove(change.target.absolute).pipe(Effect.mapError((error) => fail(`Failed to delete ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.target.resource,
+                target: change.target.absolute
+              });
+              return;
+            }
+            if (change.type === "update" && change.moveTarget) {
+              const moveTarget = change.moveTarget;
+              yield* environment.files.write(moveTarget.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${moveTarget.resource}`, error)));
+              yield* environment.files.remove(change.target.absolute).pipe(Effect.mapError((error) => fail(`Wrote ${moveTarget.resource} but failed to remove ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.moveTarget.resource,
+                target: change.moveTarget.absolute
+              });
+              return;
+            }
+            yield* environment.files.write(change.target.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)));
+            applied.push({
+              type: change.type,
+              resource: change.target.resource,
+              target: change.target.absolute
+            });
+          }), { discard: true });
+          const formatted = new Map;
+          yield* Effect.forEach([...new Set(applied.filter((item) => item.type !== "delete").map((item) => item.target))], (target) => Effect.gen(function* () {
+            const current = yield* readText2(environment.files, target).pipe(Effect.mapError((error) => fail(`Failed to read ${target}`, error)));
+            formatted.set(target, (yield* formatter.file(target)) ? yield* syncTextBom2(environment.files, target, current.bom).pipe(Effect.mapError((error) => fail(`Failed to sync ${target}`, error))) : current.text);
+          }), { discard: true });
+          const files = prepared.map((change) => {
+            if (change.type === "delete")
+              return patchFile(change);
+            const target = change.type === "update" && change.moveTarget ? change.moveTarget : change.target;
+            return patchFile(change, formatted.get(target.absolute));
+          });
+          return { applied, files };
+        }).pipe(fileMutation.withLock(lockTargets), Effect.map((output) => ({
+          output,
+          content: toModelContent6(output),
+          metadata: { files: output.files }
+        })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: "Unable to apply patch", error })));
+      }
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.sync(() => {
+      const usePatch = event.model.id.includes("gpt-") && !event.model.id.includes("oss") && !event.model.id.includes("gpt-4");
+      if (usePatch) {
+        delete event.tools.edit;
+        delete event.tools.write;
+        return;
+      }
+      delete event.tools.patch;
+    }));
+  })
+};
+function errorMessage(error) {
+  if (error instanceof NotFound2)
+    return "file does not exist";
+  if (error instanceof WrongKind2)
+    return error.actual === "directory" ? "path is a directory" : `path is ${error.actual}`;
+  if (error instanceof Failed2)
+    return errorMessage(error.cause);
+  return error instanceof Error ? error.message : String(error);
+}
+function patchFile(change, after = change.after) {
+  const target = (change.type === "update" ? change.moveTarget : undefined)?.resource ?? change.target.resource;
+  const diff = fileDiff2(change.target.absolute, change.before, after, change.type === "add" ? "added" : change.type === "delete" ? "deleted" : "modified");
+  return {
+    ...diff,
+    file: target,
+    patch: trimDiff(diff.patch)
+  };
+}
+function trimDiff(diff) {
+  const lines = diff.split(`
+`);
+  const content = lines.filter((line) => (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++"));
+  if (content.length === 0)
+    return diff;
+  const indent = content.reduce((result, line) => {
+    const value = line.slice(1);
+    if (value.trim().length === 0)
+      return result;
+    return Math.min(result, value.match(/^(\s*)/)?.[1].length ?? result);
+  }, Infinity);
+  if (indent === Infinity || indent === 0)
+    return diff;
+  return lines.map((line) => {
+    if ((line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++")) {
+      return line[0] + line.slice(1 + indent);
+    }
+    return line;
+  }).join(`
+`);
+}
+
+export { name12, Input12, Applied2, Output8, toModelContent6, Plugin13, exports_patch };

package/dist/chunks/worktree-rqsgeg7f.js

@@ -0,0 +1,148 @@
+import {
+  ephemeral2,
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  Service58,
+  node62
+} from "./worktree-madgwgkk.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/wellknown.ts
+var exports_wellknown = {};
+__export(exports_wellknown, {
+  Auth: () => Auth2,
+  Config: () => Config2,
+  Event: () => Event10,
+  Manifest: () => Manifest2,
+  RemoteConfig: () => RemoteConfig2,
+  Service: () => Service56,
+  WellKnown: () => exports_wellknown,
+  inspect: () => inspect2,
+  node: () => node60,
+  resolve: () => resolve3
+});
+import { Integration } from "@opencode/schema/integration";
+import { Context, Effect, Layer, Ref, Schema, Semaphore } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { isDeepStrictEqual } from "node:util";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+var Auth2 = Schema.Struct({
+  command: Schema.Array(Schema.String),
+  env: Schema.String
+}).annotate({ identifier: "WellKnown.Auth" });
+var RemoteConfig2 = Schema.Struct({
+  url: Schema.String,
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String))
+}).annotate({ identifier: "WellKnown.RemoteConfig" });
+var Config2 = Schema.Record(Schema.String, Schema.Json).annotate({ identifier: "WellKnown.Config" });
+var Manifest2 = Schema.Struct({
+  auth: Schema.optional(Auth2),
+  config: Schema.optional(Schema.NullOr(Config2)),
+  remote_config: Schema.optional(RemoteConfig2)
+}).annotate({ identifier: "WellKnown.Manifest" });
+
+class Service56 extends Context.Service()("@opencode/WellKnown") {
+}
+var Event10 = {
+  Updated: ephemeral2({ type: "wellknown.updated", schema: {} })
+};
+var inspect2 = Effect.fn("WellKnown.inspect")(function* (origin) {
+  const url = `${origin.replace(/\/+$/, "")}/.well-known/opencode`;
+  const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+  return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Manifest2)), Effect.mapError((cause) => new Error(`Failed to load wellknown manifest from ${url}`, { cause })));
+});
+var resolve3 = Effect.fn("WellKnown.resolve")(function* (input) {
+  const manifest = yield* inspect2(input.origin);
+  return yield* resolveEntry({ origin: input.origin, integrationID: Integration.ID.make(input.origin.replace(/\/+$/, "")), manifest }, input.variables ?? {});
+});
+var resolveEntry = Effect.fnUntraced(function* (entry, variables) {
+  const configs = entry.manifest.config ? [entry.manifest.config] : [];
+  if (!entry.manifest.remote_config)
+    return configs;
+  const substitute = (value) => value.replace(/\{env:([^}]+)\}/g, (_, name) => variables[name] ?? process.env[name] ?? "");
+  const url = substitute(entry.manifest.remote_config.url);
+  const headers = Object.fromEntries(Object.entries(entry.manifest.remote_config.headers ?? {}).map(([key, value]) => [key, substitute(value)]));
+  const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+  const remote = yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders(headers))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Config2)), Effect.mapError((cause) => new Error(`Failed to load wellknown remote config from ${url}`, { cause })));
+  if (Schema.is(Config2)(remote.config))
+    return [...configs, remote.config];
+  return [...configs, remote];
+});
+var sourcesKey = "wellknown:sources";
+var Sources = Schema.Array(Schema.String);
+var layer = Layer.effect(Service56, Effect.gen(function* () {
+  const http = yield* HttpClient.HttpClient;
+  const kv = yield* Service58;
+  const bus = yield* Service79;
+  const cache = yield* Ref.make(new Map);
+  const lock = Semaphore.makeUnsafe(1);
+  const loadEntry = Effect.fn("WellKnown.loadEntry")(function* (origin) {
+    const manifest = yield* inspect2(origin).pipe(Effect.provideService(HttpClient.HttpClient, http));
+    return { origin, integrationID: Integration.ID.make(origin), manifest };
+  });
+  const load = Effect.fn("WellKnown.load")(function* () {
+    const value = yield* kv.get(sourcesKey);
+    const origins = Schema.is(Sources)(value) ? value : [];
+    const current = yield* Ref.get(cache);
+    const entries = yield* Effect.forEach(origins, (origin) => {
+      const cached = current.get(origin);
+      if (cached)
+        return Effect.succeed(cached);
+      return loadEntry(origin);
+    });
+    yield* Ref.set(cache, new Map(entries.map((entry) => [entry.origin, entry])));
+    return entries;
+  });
+  const refresh = Effect.fn("WellKnown.refresh")(function* () {
+    const value = yield* kv.get(sourcesKey);
+    const origins = Schema.is(Sources)(value) ? value : [];
+    if (!origins.length)
+      return false;
+    const entries = yield* Effect.forEach(origins, loadEntry);
+    const next = new Map(entries.map((entry) => [entry.origin, entry]));
+    const changed = !isDeepStrictEqual(Ref.getUnsafe(cache), next);
+    if (!changed)
+      return false;
+    yield* Ref.set(cache, next);
+    yield* bus.publish(Event10.Updated, {});
+    return true;
+  }, (effect) => lock.withPermit(effect));
+  return Service56.of({
+    entries: load,
+    snapshot: () => Array.from(Ref.getUnsafe(cache).values()),
+    refresh,
+    add: Effect.fn("WellKnown.add")(function* (value) {
+      const origin = value.replace(/\/+$/, "");
+      const entry = yield* loadEntry(origin);
+      if (!entry.manifest.auth)
+        return yield* Effect.fail(new Error(`No authentication method found at ${origin}`));
+      const sources = yield* kv.get(sourcesKey);
+      const origins = Schema.is(Sources)(sources) ? sources : [];
+      yield* kv.set(sourcesKey, Array.from(new Set([...origins, origin])));
+      yield* Ref.update(cache, (current) => new Map(current).set(origin, entry));
+      yield* bus.publish(Event10.Updated, {});
+      return entry;
+    }, (effect, _value) => lock.withPermit(effect)),
+    remove: Effect.fn("WellKnown.remove")(function* (value) {
+      const origin = value.replace(/\/+$/, "");
+      const sources = yield* kv.get(sourcesKey);
+      const origins = Schema.is(Sources)(sources) ? sources : [];
+      yield* kv.set(sourcesKey, origins.filter((item) => item !== origin));
+      yield* Ref.update(cache, (current) => {
+        const next = new Map(current);
+        next.delete(origin);
+        return next;
+      });
+      yield* bus.publish(Event10.Updated, {});
+    }, (effect, _value) => lock.withPermit(effect)),
+    resolve: Effect.fn("WellKnown.resolveEntry")((entry, variables) => resolveEntry(entry, variables).pipe(Effect.provideService(HttpClient.HttpClient, http)))
+  });
+}));
+var node60 = makeGlobalNode({ service: Service56, layer, deps: [httpClient, node62, node84] });
+
+export { Auth2, RemoteConfig2, Config2, Manifest2, Service56, Event10, inspect2, resolve3, node60, exports_wellknown };

package/dist/chunks/worktree-rxv654xr.js

@@ -0,0 +1,114 @@
+import {
+  Service52
+} from "./worktree-pr7ch8ks.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/mcp/stdio.ts
+var exports_stdio = {};
+__export(exports_stdio, {
+  McpStdio: () => exports_stdio,
+  make: () => make2
+});
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
+import { Cause, Duration, Effect, Queue, Scope, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+var CLOSE_GRACE = Duration.seconds(2);
+var FORCE_KILL_AFTER = Duration.seconds(2);
+var OUTGOING_CAPACITY = 64;
+var MAX_FRAME_BYTES = 16 * 1024 * 1024;
+var make2 = Effect.fnUntraced(function* (options) {
+  const environment = yield* Service52;
+  const scope = yield* Effect.scope;
+  const outgoing = yield* Queue.bounded(OUTGOING_CAPACITY);
+  const buffer = new ReadBuffer;
+  const state = { phase: "ready" };
+  let startup;
+  let closing;
+  let trailingBytes = 0;
+  const stop = Effect.fnUntraced(function* (handle) {
+    yield* Effect.timeoutOption(handle.exitCode, CLOSE_GRACE).pipe(Effect.ignore);
+    const terminated = yield* Effect.timeoutOption(handle.kill({ killSignal: "SIGTERM" }), FORCE_KILL_AFTER);
+    if (terminated._tag === "None")
+      yield* handle.kill({ killSignal: "SIGKILL" });
+  }, Effect.ignore());
+  const close = () => closing ??= Effect.runPromise(Effect.gen(function* () {
+    state.phase = "closed";
+    Queue.endUnsafe(outgoing);
+    if (startup)
+      yield* Effect.promise(() => startup.catch(() => {
+        return;
+      }));
+    const handle = state.handle;
+    if (!handle)
+      return;
+    state.handle = undefined;
+    yield* stop(handle);
+  }).pipe(Effect.ensuring(Queue.shutdown(outgoing)), Effect.ensuring(Effect.sync(() => buffer.clear()))));
+  const transport = {
+    start: () => {
+      if (state.phase !== "ready")
+        return Promise.reject(new Error("Stdio transport already started"));
+      state.phase = "starting";
+      startup = Effect.runPromise(Effect.gen(function* () {
+        const handle = yield* environment.spawner.spawn(ChildProcess.make(options.command, [...options.args], {
+          cwd: options.cwd,
+          env: options.environment,
+          extendEnv: true,
+          stdin: { stream: Stream.encodeText(Stream.fromQueue(outgoing)), endOnDone: true },
+          stdout: "pipe",
+          stderr: "pipe",
+          forceKillAfter: FORCE_KILL_AFTER
+        }));
+        state.handle = handle;
+        if (state.phase === "closed") {
+          state.handle = undefined;
+          return yield* stop(handle);
+        }
+        state.phase = "open";
+        yield* startOutput(handle);
+      }).pipe(Scope.provide(scope)));
+      return startup;
+    },
+    send: (message) => state.phase !== "open" ? Promise.reject(new Error("Not connected")) : Effect.runPromise(Queue.offer(outgoing, serializeMessage(message)).pipe(Effect.flatMap((offered) => offered ? Effect.void : Effect.fail(new Error("Not connected"))))),
+    close
+  };
+  const deliver = (chunk) => Effect.gen(function* () {
+    for (const byte of chunk) {
+      trailingBytes = byte === 10 ? 0 : trailingBytes + 1;
+      if (trailingBytes > MAX_FRAME_BYTES)
+        return yield* Effect.fail(new Error("MCP stdio frame exceeded 16 MiB"));
+    }
+    buffer.append(Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+    while (true) {
+      const message = yield* Effect.try({
+        try: () => buffer.readMessage(),
+        catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
+      }).pipe(Effect.catch((error) => Effect.sync(() => {
+        transport.onerror?.(error);
+        return;
+      })));
+      if (message === undefined)
+        continue;
+      if (message === null)
+        return;
+      transport.onmessage?.(message);
+    }
+  });
+  const startOutput = (handle) => Effect.gen(function* () {
+    yield* Effect.forkScoped(Stream.runForEach(handle.stdout, deliver).pipe(Effect.tapCause((cause) => Effect.sync(() => {
+      const error = Cause.squash(cause);
+      transport.onerror?.(error instanceof Error ? error : new Error(String(error)));
+    })), Effect.ignore, Effect.ensuring(Effect.gen(function* () {
+      const unexpected = state.phase !== "closed";
+      if (unexpected)
+        yield* Effect.promise(close);
+      transport.onclose?.();
+    }))));
+    yield* Effect.forkScoped(handle.stderr.pipe(Stream.decodeText(), Stream.runForEach((output) => output.trim() === "" ? Effect.void : Effect.logDebug("mcp server stderr", { server: options.server, output })), Effect.ignore));
+  });
+  return transport;
+});
+
+export { make2, exports_stdio };