@opencode-ai/simulation 0.0.0-dev-17880 → 0.0.0-reserved

package/dist/backend/simulated-provider.js

@@ -1,485 +0,0 @@
-import { SdkPlugins } from "@opencode-ai/core/plugin/sdk";
-import { Tool } from "@opencode-ai/core/tool";
-import { Plugin } from "@opencode-ai/plugin/effect";
-import { createHash } from "node:crypto";
-import {
-  Cause,
-  Context,
-  Deferred,
-  Effect,
-  Exit,
-  Fiber,
-  FiberSet,
-  JsonSchema,
-  Layer,
-  PubSub,
-  Queue,
-  Ref,
-  Schema,
-  Scope,
-  Semaphore,
-  Stream
-} from "effect";
-import { SimulationControlServer } from "../control-server";
-import { SimulationProtocol } from "../protocol";
-
-export class ProviderDisconnectedError extends Schema.TaggedError()("SimulatedProvider.ProviderDisconnectedError", { message: Schema.String }) {
-}
-
-export class Service extends Context.Service()("@opencode/simulation/SimulatedProvider") {
-}
-
-class InvocationNotFoundError extends Schema.TaggedError()("SimulatedProvider.InvocationNotFoundError", { id: Schema.String, message: Schema.String }) {
-}
-
-class ControllerDisconnectedError extends Schema.TaggedError()("SimulatedProvider.ControllerDisconnectedError", { message: Schema.String }) {
-}
-
-class ToolInvocationNotFoundError extends Schema.TaggedError()("SimulatedProvider.ToolInvocationNotFoundError", { id: Schema.String, message: Schema.String }) {
-}
-
-class ToolControllerError extends Schema.TaggedError()("SimulatedProvider.ToolControllerError", {
-  message: Schema.String
-}) {
-}
-export const layerDrive = (options) => Layer.effect(Service, Effect.gen(function* () {
-  const state = yield* Ref.make({ counter: 0, pending: new Map }), opened = yield* PubSub.unbounded(), lock = yield* Semaphore.make(1), close = (invocation) => Effect.gen(function* () {
-    yield* Queue.shutdown(invocation.responses);
-    yield* lock.withPermit(Ref.update(state, (current) => current.pending.get(invocation.id) === invocation ? remove(current, invocation.id) : current));
-  });
-  yield* Effect.addFinalizer(() => Effect.gen(function* () {
-    const current = yield* Ref.get(state);
-    yield* Effect.forEach(current.pending.values(), (invocation) => Queue.shutdown(invocation.responses), {
-      discard: !0
-    });
-    yield* PubSub.shutdown(opened);
-  }));
-  const open = (request) => lock.withPermit(Effect.gen(function* () {
-    const current = yield* Ref.get(state), id = `inv_${current.counter + 1}`, responses = yield* Queue.bounded(256), invocation = { id, ...request, responses };
-    yield* Ref.set(state, {
-      counter: current.counter + 1,
-      pending: new Map(current.pending).set(id, invocation)
-    });
-    yield* PubSub.publish(opened, { id, ...request });
-    return invocation;
-  })), requireInvocation = (id) => Effect.gen(function* () {
-    const invocation = (yield* Ref.get(state)).pending.get(id);
-    if (invocation)
-      return invocation;
-    return yield* Effect.fail(new InvocationNotFoundError({
-      id,
-      message: `Simulated provider invocation not found or already finished: ${id}`
-    }));
-  }), remove = (current, id) => {
-    const pending = new Map(current.pending);
-    pending.delete(id);
-    return { ...current, pending };
-  }, driver = {
-    requests: Stream.unwrap(lock.withPermit(Effect.gen(function* () {
-      const subscription = yield* PubSub.subscribe(opened), current = yield* Ref.get(state), pending = Array.from(current.pending.values(), ({ id, url, body }) => ({ id, url, body }));
-      return Stream.concat(Stream.fromIterable(pending), Stream.fromEffectRepeat(PubSub.take(subscription)));
-    }))),
-    push: (id, items) => Effect.gen(function* () {
-      const invocation = yield* lock.withPermit(requireInvocation(id));
-      yield* Queue.offerAll(invocation.responses, items);
-    }),
-    finish: (id, reason) => Effect.gen(function* () {
-      const invocation = yield* lock.withPermit(Effect.gen(function* () {
-        const invocation = yield* requireInvocation(id), current = yield* Ref.get(state);
-        yield* Ref.set(state, remove(current, id));
-        return invocation;
-      }));
-      yield* Queue.offer(invocation.responses, { type: "finish", reason });
-      yield* Queue.end(invocation.responses);
-    }),
-    disconnect: (id) => Effect.gen(function* () {
-      const invocation = yield* lock.withPermit(Effect.gen(function* () {
-        const invocation = yield* requireInvocation(id), current = yield* Ref.get(state);
-        yield* Ref.set(state, remove(current, id));
-        return invocation;
-      }));
-      yield* Queue.fail(invocation.responses, new ProviderDisconnectedError({ message: "Simulated model provider disconnected" }));
-    }),
-    pending: () => lock.withPermit(Ref.get(state).pipe(Effect.map((current) => Array.from(current.pending.values(), ({ id, url, body }) => ({ id, url, body })))))
-  }, fibers = yield* FiberSet.make(), activeController = yield* Ref.make(void 0), controllerLock = yield* Semaphore.make(1), tools = yield* makeToolDriver();
-  yield* Effect.addFinalizer(() => tools.shutdown);
-  yield* SimulationControlServer.start({
-    endpoint: options.endpoint,
-    label: "opencode drive backend websocket",
-    data: () => ({}),
-    decode: SimulationProtocol.Backend.decodeRequestEffect,
-    handle: (socket, request) => handle(driver, tools, fibers, activeController, controllerLock, socket, request, options.version),
-    close: (socket) => Effect.all([releaseController(activeController, controllerLock, socket), tools.release(socket)], {
-      discard: !0
-    })
-  });
-  yield* Effect.sync(() => process.stderr.write(`opencode drive backend websocket: ${options.endpoint}
-`));
-  return Service.of({
-    stream: (request) => Stream.unwrap(Effect.acquireRelease(open(request), close).pipe(Effect.map((invocation) => Stream.fromQueue(invocation.responses).pipe(Stream.takeUntil((event) => event.type === "finish")))))
-  });
-}));
-function handle(driver, tools, fibers, activeController, controllerLock, socket, request, version) {
-  switch (request.method) {
-    case "simulation.handshake":
-      return SimulationProtocol.Handshake.dispatch({
-        role: "backend",
-        server: { name: "opencode", version },
-        capabilities: SimulationProtocol.Backend.Capabilities
-      }, request.params);
-    case "llm.attach":
-      return controllerLock.withPermit(Effect.gen(function* () {
-        if (socket.data.closed)
-          return yield* Effect.fail(new ControllerDisconnectedError({ message: "Drive controller disconnected before attachment" }));
-        const previous = yield* Ref.get(activeController);
-        if (previous)
-          yield* Fiber.interrupt(previous);
-        const attachment = yield* FiberSet.run(fibers, driver.requests.pipe(Stream.runForEach((invocation) => socket.send(JSON.stringify({ jsonrpc: "2.0", method: "llm.request", params: invocation })))));
-        if (socket.data.closed) {
-          yield* Fiber.interrupt(attachment);
-          return yield* Effect.fail(new ControllerDisconnectedError({ message: "Drive controller disconnected during attachment" }));
-        }
-        socket.data.attachment = attachment;
-        yield* Ref.set(activeController, attachment);
-        return { attached: !0 };
-      }));
-    case "llm.chunk":
-      return driver.push(request.params.id, request.params.items).pipe(Effect.as({ ok: !0 }));
-    case "llm.finish":
-      return driver.finish(request.params.id, request.params.reason).pipe(Effect.as({ ok: !0 }));
-    case "llm.disconnect":
-      return driver.disconnect(request.params.id).pipe(Effect.as({ ok: !0 }));
-    case "llm.pending":
-      return driver.pending().pipe(Effect.map((invocations) => ({ invocations })));
-    case "tool.attach":
-      return tools.attach(socket, request.params.tools);
-    case "tool.update":
-      return tools.update(socket, request.params).pipe(Effect.as({ ok: !0 }));
-    case "tool.finish":
-      return tools.finish(socket, request.params).pipe(Effect.as({ ok: !0 }));
-    case "tool.fail":
-      return tools.fail(socket, request.params).pipe(Effect.as({ ok: !0 }));
-  }
-}
-const makeToolDriver = Effect.fn("SimulatedProvider.makeToolDriver")(function* () {
-  const completedRetention = 256, plugins = yield* SdkPlugins.Service, state = yield* Ref.make({
-    counter: 0,
-    generation: 0,
-    appliedGeneration: 0,
-    registrations: [],
-    pending: new Map,
-    completed: new Map,
-    activeOverlays: new Set,
-    reconciliation: new Map
-  }), registrationUpdates = yield* PubSub.unbounded(), lock = yield* Semaphore.make(1), attachmentLock = yield* Semaphore.make(1), remove = (current, id) => {
-    const pending = new Map(current.pending);
-    pending.delete(id);
-    return { ...current, pending };
-  }, complete = (current, id, completion) => {
-    const completed = new Map(current.completed);
-    completed.set(id, completion);
-    if (completed.size > completedRetention) {
-      const oldest = completed.keys().next().value;
-      if (oldest !== void 0)
-        completed.delete(oldest);
-    }
-    return { ...remove(current, id), completed };
-  }, notify = (socket, method, params) => socket.send(JSON.stringify({ jsonrpc: "2.0", method, params })), requireController = (socket) => Effect.gen(function* () {
-    const current = yield* Ref.get(state);
-    if (current.controller?.socket === socket)
-      return current;
-    return yield* Effect.fail(new ToolControllerError({ message: "Drive tool controller is not attached" }));
-  }), requireInvocation = (socket, id) => Effect.gen(function* () {
-    const current = yield* requireController(socket), invocation = current.pending.get(id);
-    if (invocation)
-      return { current, invocation };
-    return yield* Effect.fail(new ToolInvocationNotFoundError({
-      id,
-      message: `Simulated tool invocation not found or already finished: ${id}`
-    }));
-  }), cancel = (id) => Effect.gen(function* () {
-    const invocation = yield* lock.withPermit(Ref.get(state).pipe(Effect.map((current) => current.pending.get(id))));
-    if (!invocation)
-      return;
-    yield* invocation.operations.withPermit(lock.withPermit(Effect.gen(function* () {
-      const current = yield* Ref.get(state);
-      if (current.pending.get(id) !== invocation)
-        return;
-      yield* Ref.set(state, remove(current, id));
-      if (current.controller && !current.controller.socket.data.closed)
-        yield* notify(current.controller.socket, "tool.cancel", { id, reason: "interrupted" });
-    })));
-  }), invoke = (registrationGeneration, name, input, context) => Effect.gen(function* () {
-    const encoded = yield* Schema.decodeUnknownEffect(Schema.Json)(input).pipe(Effect.mapError((error) => new Tool.Error({ message: `Simulated tool input is not JSON: ${error.message}` }))), invocation = yield* Effect.uninterruptibleMask((restore) => attachmentLock.withPermit(lock.withPermit(Effect.gen(function* () {
-      const current = yield* Ref.get(state);
-      if (current.generation !== registrationGeneration)
-        yield* Effect.fail(new Tool.Error({ message: `Simulated tool registration is no longer active: ${name}` }));
-      const id = `tool_${current.counter + 1}`, completion = yield* Deferred.make(), notification = {
-        id,
-        name,
-        input: encoded,
-        context: {
-          sessionID: context.sessionID,
-          agent: context.agent,
-          messageID: context.messageID,
-          id: context.id
-        }
-      }, pending = {
-        id,
-        notification,
-        progress: context.progress,
-        completion,
-        operations: Semaphore.makeUnsafe(1)
-      };
-      yield* Ref.set(state, {
-        counter: current.counter + 1,
-        generation: current.generation,
-        appliedGeneration: current.appliedGeneration,
-        ...current.controller === void 0 ? {} : { controller: current.controller },
-        registrations: current.registrations,
-        pending: new Map(current.pending).set(id, pending),
-        completed: current.completed,
-        activeOverlays: current.activeOverlays,
-        reconciliation: current.reconciliation
-      });
-      if (current.controller && !current.controller.socket.data.closed)
-        yield* notify(current.controller.socket, "tool.invocation", notification);
-      return pending;
-    }))).pipe(Effect.flatMap((pending) => restore(Deferred.await(pending.completion)).pipe(Effect.onInterrupt(() => cancel(pending.id)), Effect.ensuring(lock.withPermit(Ref.update(state, (current) => current.pending.get(pending.id) === pending ? remove(current, pending.id) : current)))))));
-    if (invocation.type === "success")
-      return {
-        output: invocation.output.structured,
-        ...invocation.output.content.length === 0 ? {} : {
-          content: invocation.output.content.map((part) => part.type === "text" ? part : {
-            type: "file",
-            uri: `data:${part.mime};base64,${part.data}`,
-            mime: part.mime,
-            ...part.name === void 0 ? {} : { name: part.name }
-          })
-        }
-      };
-    return yield* new Tool.Error({ message: invocation.message });
-  });
-  yield* plugins.register(Plugin.define({
-    id: "opencode.simulation.tools",
-    effect: (ctx) => Effect.gen(function* () {
-      const scope = yield* Scope.Scope, token = {}, registrationLock = Semaphore.makeUnsafe(1);
-      let currentScope;
-      const reconcile = (generation, nextRegistrations) => registrationLock.withPermit(Effect.gen(function* () {
-        const nextScope = yield* Scope.fork(scope), applied = yield* Effect.exit(ctx.tool.transform((draft) => {
-          for (const registration of nextRegistrations)
-            draft.add({
-              name: registration.name,
-              options: registration.permission === void 0 ? registration.options : { ...registration.options, permission: registration.permission },
-              description: registration.description,
-              input: registration.inputSchema,
-              output: registration.outputSchema ?? {},
-              execute: (input, context) => invoke(generation, SimulationProtocol.Backend.exposedToolName(registration), input, context)
-            });
-        }).pipe(Scope.provide(nextScope)));
-        if (Exit.isFailure(applied)) {
-          yield* Scope.close(nextScope, applied);
-          yield* Effect.failCause(applied.cause);
-        }
-        const previousScope = currentScope;
-        currentScope = nextScope;
-        if (previousScope)
-          yield* Scope.close(previousScope, Exit.void);
-      })), acknowledge = (generation, result) => lock.withPermit(Effect.gen(function* () {
-        const reconciliation = (yield* Ref.get(state)).reconciliation.get(token);
-        if (reconciliation?.generation !== generation)
-          return;
-        yield* Deferred.succeed(reconciliation.result, result);
-      })), initialized = yield* lock.withPermit(Effect.gen(function* () {
-        const subscription = yield* PubSub.subscribe(registrationUpdates), current = yield* Ref.get(state), activeOverlays = new Set(current.activeOverlays).add(token);
-        yield* Ref.set(state, { ...current, activeOverlays });
-        return { subscription, generation: current.generation, registrations: current.registrations };
-      }));
-      yield* Effect.addFinalizer(() => lock.withPermit(Effect.gen(function* () {
-        const current = yield* Ref.get(state), activeOverlays = new Set(current.activeOverlays);
-        activeOverlays.delete(token);
-        const reconciliation = new Map(current.reconciliation), pending = reconciliation.get(token);
-        reconciliation.delete(token);
-        yield* Ref.set(state, { ...current, activeOverlays, reconciliation });
-        if (pending)
-          yield* Deferred.succeed(pending.result, Exit.void);
-      })));
-      yield* reconcile(initialized.generation, initialized.registrations);
-      yield* Stream.fromEffectRepeat(PubSub.take(initialized.subscription)).pipe(Stream.runForEach((update) => Effect.gen(function* () {
-        const result = yield* Effect.exit(reconcile(update.generation, update.registrations));
-        yield* acknowledge(update.generation, result);
-      })), Effect.forkScoped({ startImmediately: !0 }));
-    })
-  }));
-  const reconcileRegistrations = (controller, registrations, targetGeneration) => Effect.gen(function* () {
-    const reconciliation = yield* lock.withPermit(Effect.gen(function* () {
-      const current = yield* Ref.get(state), generation = targetGeneration ?? current.generation + 1, reconciliation = new Map;
-      for (const token of current.activeOverlays)
-        reconciliation.set(token, {
-          generation,
-          result: Deferred.makeUnsafe()
-        });
-      yield* Ref.set(state, {
-        counter: current.counter,
-        generation,
-        appliedGeneration: current.appliedGeneration,
-        ...controller === void 0 ? {} : { controller },
-        registrations,
-        pending: current.pending,
-        completed: current.completed,
-        activeOverlays: current.activeOverlays,
-        reconciliation
-      });
-      yield* PubSub.publish(registrationUpdates, { generation, registrations });
-      return { generation, previous: current, reconciliation };
-    })), failure = (yield* Effect.forEach(reconciliation.reconciliation.values(), (item) => Deferred.await(item.result))).find(Exit.isFailure);
-    yield* lock.withPermit(Ref.update(state, (current) => current.generation === reconciliation.generation ? {
-      ...current,
-      ...failure === void 0 ? { appliedGeneration: reconciliation.generation } : {},
-      reconciliation: new Map
-    } : current));
-    return { failure, previous: reconciliation.previous };
-  }), attach = (socket, registrations) => attachmentLock.withPermit(Effect.gen(function* () {
-    if (socket.data.closed)
-      return yield* Effect.fail(new ToolControllerError({ message: "Drive tool controller disconnected before attachment" }));
-    const current = yield* Ref.get(state);
-    if (current.controller && current.controller.socket !== socket && !current.controller.socket.data.closed)
-      return yield* Effect.fail(new ToolControllerError({ message: "Another Drive tool controller is already attached" }));
-    const controller = { socket }, replay = current.controller?.socket !== socket, sameRegistrations = current.appliedGeneration === current.generation && fingerprintJson(current.registrations) === fingerprintJson(registrations);
-    if (replay && current.pending.size > 0 && !sameRegistrations)
-      return yield* Effect.fail(new ToolControllerError({
-        message: "A reconnecting Drive tool controller must settle pending invocations before replacing tools"
-      }));
-    if (sameRegistrations) {
-      yield* lock.withPermit(Effect.gen(function* () {
-        const current = yield* Ref.get(state);
-        yield* Ref.set(state, { ...current, controller });
-        if (replay)
-          yield* Effect.forEach(current.pending.values(), (invocation) => notify(socket, "tool.invocation", invocation.notification), { discard: !0 });
-      }));
-      return { attached: !0 };
-    }
-    const reconciled = yield* reconcileRegistrations(controller, registrations);
-    if (reconciled.failure) {
-      const rolledBack = yield* reconcileRegistrations(reconciled.previous.controller, reconciled.previous.registrations, reconciled.previous.generation);
-      return yield* Effect.fail(new ToolControllerError({
-        message: rolledBack.failure ? `Failed to apply and restore simulated tools: ${Cause.pretty(reconciled.failure.cause)}; ${Cause.pretty(rolledBack.failure.cause)}` : `Failed to apply simulated tools: ${Cause.pretty(reconciled.failure.cause)}`
-      }));
-    }
-    if (replay)
-      yield* lock.withPermit(Effect.gen(function* () {
-        const current = yield* Ref.get(state);
-        if (current.controller?.socket !== socket)
-          return;
-        yield* Effect.forEach(current.pending.values(), (invocation) => notify(socket, "tool.invocation", invocation.notification), { discard: !0 });
-      }));
-    return { attached: !0 };
-  })), update = (socket, params) => Effect.gen(function* () {
-    const { invocation } = yield* lock.withPermit(requireInvocation(socket, params.id));
-    yield* invocation.operations.withPermit(Effect.gen(function* () {
-      if ((yield* lock.withPermit(Ref.get(state))).pending.get(params.id) !== invocation)
-        yield* Effect.fail(new ToolInvocationNotFoundError({
-          id: params.id,
-          message: `Simulated tool invocation not found or already finished: ${params.id}`
-        }));
-      const fingerprint = fingerprintJson(params.update), applied = invocation.update;
-      if (applied?.sequence === params.sequence && applied.fingerprint === fingerprint)
-        return;
-      if (applied?.sequence === params.sequence)
-        yield* Effect.fail(new ToolControllerError({
-          message: `Simulated tool update sequence ${params.sequence} was reused with different progress`
-        }));
-      const expected = applied === void 0 ? 0 : applied.sequence + 1;
-      if (params.sequence !== expected)
-        yield* Effect.fail(new ToolControllerError({
-          message: `Expected simulated tool update sequence ${expected}, received ${params.sequence}`
-        }));
-      yield* invocation.progress(params.update);
-      invocation.update = { sequence: params.sequence, fingerprint };
-    }));
-  }), settle = (socket, id, completion) => Effect.gen(function* () {
-    const current = yield* lock.withPermit(requireController(socket)), fingerprint = fingerprintJson(completion), invocation = current.pending.get(id);
-    if (!invocation) {
-      if (current.completed.get(id) === fingerprint)
-        return;
-      yield* Effect.fail(new ToolInvocationNotFoundError({
-        id,
-        message: `Simulated tool invocation not found or already finished: ${id}`
-      }));
-      return;
-    }
-    yield* invocation.operations.withPermit(Effect.uninterruptible(lock.withPermit(Effect.gen(function* () {
-      const current = yield* Ref.get(state);
-      if (current.pending.get(id) !== invocation) {
-        if (current.completed.get(id) === fingerprint)
-          return;
-        yield* Effect.fail(new ToolInvocationNotFoundError({
-          id,
-          message: `Simulated tool invocation not found or already finished: ${id}`
-        }));
-        return;
-      }
-      yield* Ref.set(state, complete(current, id, fingerprint));
-      yield* Deferred.succeed(invocation.completion, completion);
-    }))));
-  }), release = (socket) => attachmentLock.withPermit(lock.withPermit(Ref.update(state, (current) => current.controller?.socket !== socket ? current : {
-    counter: current.counter,
-    generation: current.generation,
-    appliedGeneration: current.appliedGeneration,
-    registrations: current.registrations,
-    pending: current.pending,
-    completed: current.completed,
-    activeOverlays: current.activeOverlays,
-    reconciliation: current.reconciliation
-  }))), shutdown = attachmentLock.withPermit(Effect.gen(function* () {
-    yield* reconcileRegistrations(void 0, []);
-    const current = yield* lock.withPermit(Effect.gen(function* () {
-      const current = yield* Ref.get(state);
-      yield* Ref.set(state, {
-        counter: current.counter,
-        generation: current.generation,
-        appliedGeneration: current.appliedGeneration,
-        registrations: [],
-        pending: new Map,
-        completed: current.completed,
-        activeOverlays: new Set,
-        reconciliation: new Map
-      });
-      return current;
-    }));
-    yield* Effect.forEach(current.pending.values(), (invocation) => Deferred.succeed(invocation.completion, {
-      type: "failure",
-      message: "Simulated tool controller shut down"
-    }), { discard: !0 });
-    yield* PubSub.shutdown(registrationUpdates);
-  }));
-  return {
-    attach,
-    update,
-    finish: (socket, params) => settle(socket, params.id, { type: "success", output: params.output }),
-    fail: (socket, params) => settle(socket, params.id, { type: "failure", message: params.message }),
-    release,
-    shutdown
-  };
-});
-function canonicalJson(value) {
-  if (Array.isArray(value))
-    return `[${value.map(canonicalJson).join(",")}]`;
-  if (typeof value === "object" && value !== null)
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
-  return JSON.stringify(value) ?? String(value);
-}
-function fingerprintJson(value) {
-  return createHash("sha256").update(canonicalJson(value)).digest("base64url");
-}
-function releaseController(activeController, controllerLock, socket) {
-  return controllerLock.withPermit(Effect.gen(function* () {
-    const attachment = socket.data.attachment;
-    if (!attachment)
-      return;
-    yield* Fiber.interrupt(attachment);
-    yield* Ref.update(activeController, (active) => active === attachment ? void 0 : active);
-  }));
-}
-
-export * as SimulatedProvider from "./simulated-provider";

package/dist/control-server.d.ts

@@ -1,27 +0,0 @@
-import { Effect, Fiber } from "effect";
-export interface Server {
-    readonly url: string;
-}
-interface Request {
-    readonly id?: string | number | null;
-}
-export interface SocketData {
-    readonly drive?: true;
-    attachment?: Fiber.Fiber<void>;
-    closed?: true;
-}
-export interface Socket {
-    readonly data: SocketData;
-    readonly send: (message: string) => Effect.Effect<void>;
-}
-export declare function start<RequestType extends Request, Error, Services>(options: {
-    readonly endpoint: string;
-    readonly label: string;
-    readonly data: () => SocketData;
-    readonly decode: (input: string) => Effect.Effect<RequestType, Error>;
-    readonly handle: (socket: Socket, request: RequestType) => Effect.Effect<unknown, unknown, Services>;
-    readonly close?: (socket: Socket) => Effect.Effect<void, never, Services>;
-}): Effect.Effect<{
-    url: string;
-}, unknown, Services | import("effect/Scope").Scope>;
-export * as SimulationControlServer from "./control-server";

package/dist/control-server.js

@@ -1,99 +0,0 @@
-import { Effect, Fiber, FiberSet, Queue, Stream } from "effect";
-import { SimulationProtocol } from "./protocol";
-const maxOutboundBytes = 67108864;
-export function start(options) {
-  return Effect.gen(function* () {
-    const messages = yield* Queue.bounded(256);
-    yield* Stream.fromQueue(messages).pipe(Stream.runForEach((message) => options.decode(message.input).pipe(Effect.flatMap((request) => options.handle(message.socket, request).pipe(Effect.matchEffect({
-      onFailure: (error) => send(message.socket, SimulationProtocol.JsonRpc.failure(request.id, error)),
-      onSuccess: (result) => send(message.socket, SimulationProtocol.JsonRpc.success(request.id, result))
-    }))), Effect.catch((error) => send(message.socket, SimulationProtocol.JsonRpc.failure(void 0, error))), Effect.catchCause((cause) => Effect.logWarning(`${options.label}: request failed`, cause)))), Effect.forkScoped);
-    const url = yield* Effect.try({ try: () => new URL(options.endpoint), catch: (cause) => cause }), websocket = yield* Effect.promise(() => import("ws")), runPromise = yield* FiberSet.makeRuntimePromise();
-    yield* Effect.acquireRelease(Effect.tryPromise(() => new Promise((resolve, reject) => {
-      const server = new websocket.WebSocketServer({ host: url.hostname, port: Number(url.port) }), sockets = new Map, report = (scope, cause) => void runPromise(Effect.logWarning(`${options.label}: ${scope} error`, cause)), onServerError = (cause) => report("server", cause), onStartupError = (cause) => {
-        server.off("listening", onListening);
-        server.on("error", onServerError);
-        reject(cause);
-      }, onListening = () => {
-        server.off("error", onStartupError);
-        server.on("error", onServerError);
-        resolve({
-          close: async () => {
-            const accepted = Array.from(sockets.entries());
-            accepted.forEach(([connection, record]) => {
-              record.socket.data.closed = !0;
-              connection.terminate();
-            });
-            await Promise.all([
-              new Promise((resolveClose, rejectClose) => {
-                server.close((cause) => cause ? rejectClose(cause) : resolveClose());
-                queueMicrotask(() => {
-                  if (server.address() === null)
-                    resolveClose();
-                });
-              }),
-              Promise.all(accepted.map(([, record]) => record.cleanup()))
-            ]);
-            server.off("error", onServerError);
-          }
-        });
-      };
-      server.once("listening", onListening);
-      server.once("error", onStartupError);
-      server.on("connection", (connection) => {
-        let pendingBytes = 0, outbound = Promise.resolve(), cleanup;
-        const socket = {
-          data: options.data(),
-          send: (message) => Effect.tryPromise({
-            try: () => {
-              const bytes = Buffer.byteLength(message);
-              if (bytes > maxOutboundBytes || pendingBytes + bytes > maxOutboundBytes)
-                return Promise.reject(Error(`Simulation outbound queue exceeds ${maxOutboundBytes} bytes`));
-              pendingBytes += bytes;
-              const current = outbound.then(() => new Promise((resolveSend, rejectSend) => {
-                if (connection.readyState !== websocket.WebSocket.OPEN) {
-                  rejectSend(Error("Simulation control socket is not open"));
-                  return;
-                }
-                connection.send(message, (cause) => cause ? rejectSend(cause) : resolveSend());
-              }));
-              outbound = current.catch(() => {
-                return;
-              });
-              return current.finally(() => {
-                pendingBytes -= bytes;
-              });
-            },
-            catch: (cause) => cause instanceof Error ? cause : Error(String(cause))
-          }).pipe(Effect.tapError(() => Effect.sync(() => {
-            connection.terminate();
-          })), Effect.orDie)
-        }, close = () => {
-          socket.data.closed = !0;
-          cleanup ??= runPromise(options.close?.(socket) ?? Effect.void).finally(() => sockets.delete(connection));
-          return cleanup;
-        };
-        sockets.set(connection, { socket, cleanup: close });
-        connection.on("close", () => void close());
-        connection.on("error", (cause) => {
-          report("socket", cause);
-          connection.terminate();
-        });
-        connection.on("message", (message) => {
-          const input = Array.isArray(message) ? Buffer.concat(message).toString() : message instanceof ArrayBuffer ? Buffer.from(message).toString() : message.toString();
-          if (Queue.offerUnsafe(messages, { socket, input }))
-            return;
-          runPromise(socket.send(JSON.stringify(SimulationProtocol.JsonRpc.failure(void 0, Error("Simulation control queue is full")))).pipe(Effect.catchCause((cause) => Effect.logWarning(`${options.label}: queue rejection failed`, cause))));
-        });
-      });
-    })), ({ close }) => Effect.promise(close));
-    return { url: options.endpoint };
-  });
-}
-function send(socket, response) {
-  if (!response)
-    return Effect.void;
-  return socket.send(JSON.stringify(response));
-}
-
-export * as SimulationControlServer from "./control-server";