@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-x6rcf4cj.js

@@ -0,0 +1,544 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  EventSequenceTable2,
+  EventTable2
+} from "./repository-2710q6r3.js";
+import {
+  makeUnsafe2
+} from "./repository-y71avatq.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/bus.ts
+var exports_bus = {};
+__export(exports_bus, {
+  Bus: () => exports_bus,
+  InvalidDurableEventError: () => InvalidDurableEventError2,
+  Service: () => Service78,
+  configured: () => configured12,
+  durable: () => durable2,
+  ephemeral: () => ephemeral2,
+  isSynced: () => isSynced2,
+  latestSequence: () => latestSequence2,
+  node: () => node83,
+  reserveSequence: () => reserveSequence2,
+  versionedType: () => versionedType2
+});
+import { Cause, Clock, Context, Effect, Layer, Option, PubSub, Schema, Stream } from "effect";
+import { Event } from "@opencode/schema/event";
+import { and, asc, eq, gt, lte, sql } from "drizzle-orm";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { isDeepStrictEqual } from "node:util";
+import { Durable } from "@opencode/schema/durable-event-manifest";
+import { SessionEvent } from "@opencode/schema/session-event";
+import { AbsolutePath } from "@opencode/schema/schema";
+var latestSequence2 = Effect.fn("Bus.latestSequence")(function* (db, aggregateID) {
+  const row = yield* db.select({ seq: EventSequenceTable2.seq }).from(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+  return row?.seq ?? -1;
+});
+var reserveSequence2 = Effect.fn("Bus.reserveSequence")(function* (db, aggregateID, seq) {
+  yield* db.insert(EventSequenceTable2).values([{ aggregate_id: aggregateID, seq }]).onConflictDoUpdate({
+    target: EventSequenceTable2.aggregate_id,
+    set: { seq: sql`max(${EventSequenceTable2.seq}, ${seq})` }
+  }).run().pipe(Effect.orDie);
+});
+
+class InvalidDurableEventError2 extends Schema.TaggedError()("Bus.InvalidDurableEvent", {
+  type: Schema.String,
+  message: Schema.String
+}) {
+}
+var envelope = (aggregateID, seq, version) => ({
+  aggregateID,
+  seq: Event.Seq.make(seq),
+  version: Event.Version.make(version)
+});
+var decodeSerializedEvent = (event) => {
+  const definition = Durable.get(event.type);
+  if (!definition?.durable) {
+    throw new InvalidDurableEventError2({ type: event.type, message: `Unknown durable event type ${event.type}` });
+  }
+  return {
+    id: event.id,
+    created: event.created ?? 0,
+    type: definition.type,
+    durable: envelope(event.aggregateID, event.seq, definition.durable.version),
+    data: Schema.decodeUnknownSync(definition.data)(event.data)
+  };
+};
+var versionedType2 = Event.versionedType;
+var durable2 = Event.durable;
+var ephemeral2 = Event.ephemeral;
+var isSynced2 = (item) => item.type === "log.synced";
+var isDefinition = (input) => !Array.isArray(input);
+
+class Service78 extends Context.Service()("@opencode/Bus") {
+}
+function configured12(options) {
+  return makeGlobalNode({
+    service: Service78,
+    deps: [node84],
+    layer: Layer.effect(Service78, Effect.gen(function* () {
+      const { Location } = yield* Effect.promise(() => import("../location.js"));
+      const { SessionTable } = yield* Effect.promise(() => import("../session/sql.js"));
+      const pubsub = {
+        live: yield* PubSub.unbounded(),
+        durable: new Map,
+        typed: new Map
+      };
+      const projectors = new Map;
+      const listeners = new Array;
+      const durableLocks = makeUnsafe2();
+      const { db } = yield* Service79;
+      const logReadPageSize = options?.logReadPageSize ?? 512;
+      const persist = options?.persist ?? false;
+      const sessions = new Map;
+      const routes = new WeakMap;
+      const isSessionEvent = (event) => Object.hasOwn(SessionEvent.All.cases, event.type);
+      const prepareRoutes = Effect.fnUntraced(function* (events) {
+        const updates = new Map;
+        const resolved = new Map;
+        for (const event of events) {
+          if (!isSessionEvent(event))
+            continue;
+          const id = event.data.sessionID;
+          if (event.type === "session.created") {
+            updates.set(id, event.data.location);
+            resolved.set(event, [event.location ?? event.data.location]);
+            continue;
+          }
+          if (event.location && event.type !== "session.forked" && event.type !== "session.moved") {
+            if (event.type === "session.deleted")
+              updates.set(id, undefined);
+            continue;
+          }
+          const owner = event.type === "session.forked" ? event.data.parentID : id;
+          let ref = updates.has(owner) ? updates.get(owner) : sessions.get(owner);
+          if (!ref && !updates.has(owner)) {
+            const row = yield* db.select({ directory: SessionTable.directory, workspaceID: SessionTable.workspace_id }).from(SessionTable).where(eq(SessionTable.id, owner)).get().pipe(Effect.orDie);
+            ref = row ? { directory: AbsolutePath.make(row.directory), workspaceID: row.workspaceID ?? undefined } : undefined;
+            updates.set(owner, ref);
+          }
+          if (event.type === "session.moved") {
+            updates.set(id, event.data.location);
+            resolved.set(event, ref ? [ref, event.data.location] : [event.data.location]);
+            continue;
+          }
+          if (event.type === "session.forked")
+            updates.set(id, ref);
+          resolved.set(event, event.location ? [event.location] : ref ? [ref] : []);
+          if (event.type === "session.deleted")
+            updates.set(id, undefined);
+        }
+        return () => {
+          for (const [id, ref] of updates) {
+            if (ref)
+              sessions.set(id, ref);
+            else
+              sessions.delete(id);
+          }
+          for (const [event, ref] of resolved)
+            routes.set(event, ref);
+        };
+      });
+      const getOrCreate = (definition) => Effect.gen(function* () {
+        const existing = pubsub.typed.get(definition.type);
+        if (existing)
+          return existing;
+        const created = yield* PubSub.unbounded();
+        pubsub.typed.set(definition.type, created);
+        return created;
+      });
+      yield* Effect.addFinalizer(() => Effect.gen(function* () {
+        yield* PubSub.shutdown(pubsub.live);
+        yield* Effect.forEach(pubsub.durable.values(), (pubsubs) => Effect.forEach(pubsubs, PubSub.shutdown, { discard: true }), { discard: true });
+        yield* Effect.forEach(pubsub.typed.values(), PubSub.shutdown, { discard: true });
+      }));
+      function commitDurableEvent(definition, event, input, commit) {
+        return Effect.gen(function* () {
+          const durable = definition.durable;
+          if (!durable)
+            return yield* Effect.void;
+          const aggregateID = event.data[durable.aggregate];
+          if (typeof aggregateID !== "string")
+            return yield* Effect.die(new InvalidDurableEventError2({
+              type: event.type,
+              message: `Expected string aggregate field ${durable.aggregate}`
+            }));
+          if (input && input.aggregateID !== aggregateID) {
+            yield* Effect.die(new InvalidDurableEventError2({
+              type: event.type,
+              message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`
+            }));
+          }
+          const list = projectors.get(versionedType2(definition.type, durable.version)) ?? [];
+          return yield* Effect.uninterruptible(Effect.gen(function* () {
+            const committed = yield* db.transaction(() => Effect.gen(function* () {
+              const row = yield* db.select({ seq: EventSequenceTable2.seq, ownerID: EventSequenceTable2.owner_id }).from(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+              const latest = row?.seq ?? -1;
+              const encoded = Schema.encodeUnknownSync(definition.data)(event.data);
+              if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
+                yield* Effect.die(new InvalidDurableEventError2({
+                  type: event.type,
+                  message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`
+                }));
+              }
+              if (input && input.seq <= latest) {
+                if (!persist)
+                  return;
+                const stored = yield* db.select().from(EventTable2).where(and(eq(EventTable2.aggregate_id, aggregateID), eq(EventTable2.seq, input.seq))).get().pipe(Effect.orDie);
+                if (stored?.id === event.id && stored.type === versionedType2(definition.type, durable.version) && stored.created === (event.created ?? 0) && isDeepStrictEqual(stored.data, encoded)) {
+                  if (input.ownerID && row?.ownerID == null) {
+                    yield* db.update(EventSequenceTable2).set({ owner_id: input.ownerID }).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
+                  }
+                  return;
+                }
+                yield* Effect.die(new InvalidDurableEventError2({
+                  type: event.type,
+                  message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`
+                }));
+              }
+              if (input && row?.ownerID && row.ownerID !== input.ownerID) {
+                return;
+              }
+              const seq = input?.seq ?? latest + 1;
+              if (input && seq !== latest + 1) {
+                yield* Effect.die(new InvalidDurableEventError2({
+                  type: event.type,
+                  message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`
+                }));
+              }
+              if (persist) {
+                const stored = yield* db.select({ aggregateID: EventTable2.aggregate_id, seq: EventTable2.seq }).from(EventTable2).where(eq(EventTable2.id, event.id)).get().pipe(Effect.orDie);
+                if (stored)
+                  yield* Effect.die(new InvalidDurableEventError2({
+                    type: event.type,
+                    message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
+                  }));
+              }
+              const committed = {
+                ...event,
+                durable: { aggregateID, seq, version: durable.version }
+              };
+              const route = yield* prepareRoutes([committed]);
+              for (const projector of list) {
+                yield* projector(committed);
+              }
+              if (commit)
+                yield* commit(seq);
+              yield* db.insert(EventSequenceTable2).values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }]).onConflictDoUpdate({
+                target: EventSequenceTable2.aggregate_id,
+                set: {
+                  seq: sql`max(${EventSequenceTable2.seq}, ${seq})`,
+                  ...input?.ownerID && row?.ownerID == null ? { owner_id: input.ownerID } : {}
+                }
+              }).run().pipe(Effect.orDie);
+              if (persist)
+                yield* db.insert(EventTable2).values([
+                  {
+                    id: event.id,
+                    aggregate_id: aggregateID,
+                    seq,
+                    created: event.created ?? 0,
+                    type: versionedType2(definition.type, durable.version),
+                    data: encoded
+                  }
+                ]).run().pipe(Effect.orDie);
+              return { aggregateID, seq, event: committed, route };
+            }), { behavior: "immediate" }).pipe(Effect.orDie);
+            if (committed) {
+              committed.route();
+              yield* Effect.forEach(pubsub.durable.get(committed.aggregateID) ?? [], (wake) => PubSub.publish(wake, undefined), { discard: true });
+            }
+            return committed;
+          }));
+        });
+      }
+      function publishEvent(definition, event, commit) {
+        return Effect.gen(function* () {
+          if (!definition.durable && commit)
+            return yield* Effect.die(new InvalidDurableEventError2({
+              type: event.type,
+              message: "Local commit hooks require a durable event"
+            }));
+          if (definition.durable) {
+            const aggregateID = event.data[definition.durable.aggregate];
+            if (typeof aggregateID !== "string")
+              return yield* commitDurableEvent(definition, event, undefined, commit).pipe(Effect.as(event));
+            return yield* durableLocks.withLock(aggregateID)(Effect.gen(function* () {
+              const committed = yield* commitDurableEvent(definition, event, undefined, commit);
+              if (!committed)
+                return event;
+              event = committed.event;
+              yield* notify(event, true);
+              return event;
+            }));
+          }
+          const route = yield* prepareRoutes([event]);
+          route();
+          yield* notify(event, false);
+          return event;
+        });
+      }
+      const observe = (event, observer) => Effect.suspend(() => observer(event)).pipe(Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.logError("Event listener failed", { eventID: event.id, eventType: event.type, cause })));
+      function notify(event, isolateListeners) {
+        return Effect.gen(function* () {
+          yield* Effect.forEach(listeners, (listener) => isolateListeners ? observe(event, listener) : listener(event), { discard: true });
+          const typed = pubsub.typed.get(event.type);
+          if (typed)
+            yield* PubSub.publish(typed, event);
+          yield* PubSub.publish(pubsub.live, event);
+        });
+      }
+      function publish(definition, data, options) {
+        return Effect.gen(function* () {
+          const serviceLocation = Option.getOrUndefined(yield* Effect.serviceOption(Location.Service));
+          const location = options?.global ? undefined : options?.location ?? (serviceLocation ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID } : undefined);
+          return yield* publishEvent(definition, {
+            id: options?.id ?? Event.ID.create(),
+            created: yield* Clock.currentTimeMillis,
+            ...options?.metadata ? { metadata: options.metadata } : {},
+            type: definition.type,
+            ...location ? { location } : {},
+            data
+          }, options?.commit);
+        });
+      }
+      function publishAll(events) {
+        return Effect.gen(function* () {
+          const serviceLocation = Option.getOrUndefined(yield* Effect.serviceOption(Location.Service));
+          const payloads = yield* Effect.forEach(events, ([definition, data, options]) => Effect.gen(function* () {
+            const aggregateID = data[definition.durable.aggregate];
+            if (typeof aggregateID !== "string") {
+              return yield* Effect.die(new InvalidDurableEventError2({
+                type: definition.type,
+                message: `Expected string aggregate field ${definition.durable.aggregate}`
+              }));
+            }
+            const location = options?.global ? undefined : options?.location ?? (serviceLocation ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID } : undefined);
+            return {
+              definition,
+              aggregateID,
+              commit: options?.commit,
+              event: {
+                id: options?.id ?? Event.ID.create(),
+                created: yield* Clock.currentTimeMillis,
+                ...options?.metadata ? { metadata: options.metadata } : {},
+                type: definition.type,
+                ...location ? { location } : {},
+                data
+              }
+            };
+          }));
+          const aggregateID = payloads[0].aggregateID;
+          if (payloads.some((item) => item.aggregateID !== aggregateID)) {
+            return yield* Effect.die(new InvalidDurableEventError2({
+              type: payloads[0].definition.type,
+              message: "Published events must belong to the same aggregate"
+            }));
+          }
+          return yield* durableLocks.withLock(aggregateID)(Effect.uninterruptible(Effect.gen(function* () {
+            const committed = yield* db.transaction(() => Effect.gen(function* () {
+              const row = yield* db.select({ seq: EventSequenceTable2.seq }).from(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+              const firstSeq = (row?.seq ?? -1) + 1;
+              const finalSeq = firstSeq + payloads.length - 1;
+              const queued = payloads.map((item, index) => ({
+                ...item.event,
+                durable: envelope(aggregateID, firstSeq + index, item.definition.durable.version)
+              }));
+              const route = yield* prepareRoutes(queued);
+              const rows = new Array;
+              const ids = new Set;
+              for (const [index, item] of payloads.entries()) {
+                const seq = firstSeq + index;
+                const encoded = Schema.encodeUnknownSync(item.definition.data)(item.event.data);
+                if (persist) {
+                  if (ids.has(item.event.id))
+                    yield* Effect.die(new InvalidDurableEventError2({
+                      type: item.event.type,
+                      message: `Event ${item.event.id} appears more than once in the batch`
+                    }));
+                  ids.add(item.event.id);
+                  const stored = yield* db.select({ aggregateID: EventTable2.aggregate_id, seq: EventTable2.seq }).from(EventTable2).where(eq(EventTable2.id, item.event.id)).get().pipe(Effect.orDie);
+                  if (stored)
+                    yield* Effect.die(new InvalidDurableEventError2({
+                      type: item.event.type,
+                      message: `Event ${item.event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
+                    }));
+                }
+                const event = queued[index];
+                for (const projector of projectors.get(versionedType2(item.definition.type, item.definition.durable.version)) ?? []) {
+                  yield* projector(event);
+                }
+                if (item.commit)
+                  yield* item.commit(seq);
+                if (persist)
+                  rows.push({
+                    id: event.id,
+                    aggregate_id: aggregateID,
+                    seq,
+                    created: event.created,
+                    type: versionedType2(item.definition.type, item.definition.durable.version),
+                    data: encoded
+                  });
+              }
+              yield* db.insert(EventSequenceTable2).values([{ aggregate_id: aggregateID, seq: finalSeq }]).onConflictDoUpdate({ target: EventSequenceTable2.aggregate_id, set: { seq: finalSeq } }).run().pipe(Effect.orDie);
+              if (persist)
+                yield* db.insert(EventTable2).values(rows).run().pipe(Effect.orDie);
+              return { events: queued, route };
+            }), { behavior: "immediate" }).pipe(Effect.orDie);
+            committed.route();
+            yield* Effect.forEach(pubsub.durable.get(aggregateID) ?? [], (wake) => PubSub.publish(wake, undefined), {
+              discard: true
+            });
+            yield* Effect.forEach(committed.events, (event) => notify(event, true), { discard: true });
+            return committed.events;
+          })));
+        });
+      }
+      function replay(event, options) {
+        return Effect.gen(function* () {
+          const definition = Durable.get(event.type);
+          if (!definition?.durable)
+            return yield* Effect.die(new InvalidDurableEventError2({ type: event.type, message: `Unknown durable event type ${event.type}` }));
+          yield* durableLocks.withLock(event.aggregateID)(Effect.gen(function* () {
+            const payload = {
+              id: event.id,
+              created: event.created ?? 0,
+              type: definition.type,
+              data: Schema.decodeUnknownSync(definition.data)(event.data)
+            };
+            const committed = yield* commitDurableEvent(definition, payload, {
+              seq: event.seq,
+              aggregateID: event.aggregateID,
+              ownerID: options?.ownerID,
+              strictOwner: options?.strictOwner
+            });
+            if (committed && options?.publish) {
+              yield* notify(committed.event, true);
+            }
+          }));
+        });
+      }
+      function remove(aggregateID) {
+        return db.transaction(() => Effect.gen(function* () {
+          yield* db.delete(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).run();
+          yield* db.delete(EventTable2).where(eq(EventTable2.aggregate_id, aggregateID)).run();
+        })).pipe(Effect.tap(() => Effect.sync(() => sessions.delete(aggregateID))), Effect.orDie);
+      }
+      function claim(aggregateID, ownerID) {
+        return db.update(EventSequenceTable2).set({ owner_id: ownerID }).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
+      }
+      const local = (stream) => Stream.unwrap(Effect.serviceOption(Location.Service).pipe(Effect.map((location) => Option.match(location, {
+        onNone: () => stream,
+        onSome: (location) => {
+          const matches = (ref) => ref.directory === location.directory && ref.workspaceID === location.workspaceID;
+          return stream.pipe(Stream.filter((event) => {
+            const refs = routes.get(event);
+            if (refs)
+              return refs.some(matches);
+            return !event.location || matches(event.location);
+          }));
+        }
+      }))));
+      function subscribe(input) {
+        if (input === undefined)
+          return streamLive();
+        if (isDefinition(input)) {
+          return local(Stream.unwrap(getOrCreate(input).pipe(Effect.map((pubsub) => Stream.fromPubSub(pubsub)))));
+        }
+        const types = new Set(input.map((definition) => definition.type));
+        return streamLive().pipe(Stream.filter((event) => types.has(event.type)));
+      }
+      const streamLive = () => local(Stream.fromPubSub(pubsub.live));
+      const readAfter = (aggregateID, after, input) => (options?.beforeAggregateRead?.(aggregateID) ?? Effect.void).pipe(Effect.andThen(Effect.suspend(() => {
+        const query = db.select().from(EventTable2).where(and(eq(EventTable2.aggregate_id, aggregateID), gt(EventTable2.seq, after), lte(EventTable2.seq, input.through))).orderBy(asc(EventTable2.seq));
+        return query.limit(input.limit).all();
+      })), Effect.orDie, Effect.map((rows) => ({
+        seq: rows.at(-1)?.seq,
+        events: rows.flatMap((event) => {
+          if (!Durable.get(event.type)?.durable)
+            return [];
+          return [
+            decodeSerializedEvent({
+              id: event.id,
+              created: event.created,
+              aggregateID: event.aggregate_id,
+              seq: event.seq,
+              type: event.type,
+              data: event.data
+            })
+          ];
+        })
+      })));
+      const subscribeDurable = (aggregateID) => Effect.gen(function* () {
+        const wake = yield* PubSub.sliding(1);
+        const subscription = yield* PubSub.subscribe(wake);
+        yield* Effect.acquireRelease(Effect.sync(() => {
+          const wakes = pubsub.durable.get(aggregateID) ?? new Set;
+          wakes.add(wake);
+          pubsub.durable.set(aggregateID, wakes);
+        }), () => Effect.sync(() => {
+          const wakes = pubsub.durable.get(aggregateID);
+          wakes?.delete(wake);
+          if (wakes?.size === 0)
+            pubsub.durable.delete(aggregateID);
+        }).pipe(Effect.andThen(PubSub.shutdown(wake))));
+        return subscription;
+      });
+      const log = (input) => Stream.unwrap(Effect.gen(function* () {
+        let sequence = input.after ?? -1;
+        const readThrough = (through) => Stream.paginate(sequence, (cursor) => readAfter(input.aggregateID, cursor, { through, limit: logReadPageSize }).pipe(Effect.tap((page) => Effect.sync(() => {
+          sequence = page.seq ?? sequence;
+        })), Effect.map((page) => [
+          page.events,
+          page.seq !== undefined && page.seq < through ? Option.some(page.seq) : Option.none()
+        ])));
+        const wakes = input.follow ? yield* subscribeDurable(input.aggregateID) : undefined;
+        const target = yield* latestSequence2(db, input.aggregateID);
+        const marker = {
+          type: "log.synced",
+          aggregateID: input.aggregateID,
+          ...target >= 0 ? { seq: Event.Seq.make(target) } : {}
+        };
+        const replay = readThrough(target).pipe(Stream.concat(Stream.make(marker)));
+        if (!wakes)
+          return replay;
+        const live = Stream.fromSubscription(wakes).pipe(Stream.mapEffect(() => latestSequence2(db, input.aggregateID)), Stream.filter((target) => target > sequence), Stream.flatMap((target) => readThrough(target)));
+        return Stream.concat(replay, live);
+      }));
+      const listen = (listener) => Effect.sync(() => {
+        listeners.push(listener);
+        return Effect.sync(() => {
+          const index = listeners.indexOf(listener);
+          if (index >= 0)
+            listeners.splice(index, 1);
+        });
+      });
+      const project = (definition, projector) => Effect.sync(() => {
+        const key = definition.durable ? versionedType2(definition.type, definition.durable.version) : definition.type;
+        const list = projectors.get(key) ?? [];
+        list.push((event) => projector(event));
+        projectors.set(key, list);
+      });
+      return Service78.of({
+        publish,
+        publishAll,
+        subscribe,
+        log,
+        listen,
+        project,
+        replay,
+        remove,
+        claim
+      });
+    }))
+  });
+}
+var node83 = configured12();
+
+export { latestSequence2, reserveSequence2, InvalidDurableEventError2, versionedType2, durable2, ephemeral2, isSynced2, Service78, configured12, node83, exports_bus };

package/dist/chunks/repository-xhhmv89y.js

@@ -0,0 +1,114 @@
+import {
+  Service65
+} from "./repository-3mdgf1e2.js";
+import {
+  __export
+} from "./repository-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* Service65;
+  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 };