@smthrs/gateway 0.34.0 → 1.0.0-rc.3

package/dist/vendor/chunk-Z7QNPJEB.js

@@ -0,0 +1,229 @@
+import {
+  NetSocket,
+  NodeWS,
+  fromDuplex
+} from "./chunk-YDASSC75.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeSocketServer.js
+var NodeSocketServer_exports = {};
+__export(NodeSocketServer_exports, {
+  IncomingMessage: () => IncomingMessage,
+  layer: () => layer,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  make: () => make2,
+  makeTls: () => makeTls,
+  makeWebSocket: () => makeWebSocket
+});
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { pipe } from "effect/Function";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as References from "effect/References";
+import * as Scope from "effect/Scope";
+import * as NetAddress from "effect/unstable/net/NetAddress";
+import * as Socket from "effect/unstable/socket/Socket";
+import * as SocketServer from "effect/unstable/socket/SocketServer";
+import * as Net from "node:net";
+import * as Tls from "node:tls";
+var isDeno = "Deno" in globalThis;
+var socketAddressFromNode = (address) => typeof address === "string" ? Effect.succeed(NetAddress.unixPathAddress(address)) : Effect.fromResult(NetAddress.inetAddressFromIpString(address.address, address.port)).pipe(Effect.mapError((cause) => new SocketServer.SocketServerError({
+  reason: new SocketServer.SocketServerOpenError({
+    cause
+  })
+})));
+var IncomingMessage = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node-shared/NodeSocketServer/IncomingMessage")) {
+};
+var make2 = (options) => makeNetServer({
+  listenOptions: options,
+  connectionEvent: "connection",
+  createServer: () => Net.createServer(options)
+});
+var layer = /* @__PURE__ */ Function.flow(make2, /* @__PURE__ */ Layer.effect(SocketServer.SocketServer));
+var makeTls = (options) => makeNetServer({
+  listenOptions: options,
+  connectionEvent: "secureConnection",
+  createServer: () => {
+    const server = Tls.createServer(options);
+    server.on("tlsClientError", (_error, socket) => {
+      socket.destroy();
+    });
+    return server;
+  }
+});
+var layerTls = /* @__PURE__ */ Function.flow(makeTls, /* @__PURE__ */ Layer.effect(SocketServer.SocketServer));
+var makeWebSocket = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const pendingConnections = /* @__PURE__ */ new Map();
+  const server = yield* Effect.acquireRelease(Effect.sync(() => new NodeWS.WebSocketServer(options)), (server2) => Effect.callback((resume) => {
+    pendingConnections.forEach(([, remove], conn) => {
+      remove();
+      conn.terminate();
+    });
+    server2.close(() => resume(Effect.void));
+  }));
+  function defaultHandler(conn, req) {
+    const remove = () => {
+      pendingConnections.delete(conn);
+      conn.removeEventListener("close", remove);
+    };
+    pendingConnections.set(conn, [req, remove]);
+    conn.addEventListener("close", remove);
+  }
+  let onConnection = defaultHandler;
+  server.on("connection", (conn, req) => {
+    conn.pause();
+    onConnection(conn, req);
+  });
+  yield* Effect.callback((resume) => {
+    server.once("error", (error) => {
+      resume(Effect.fail(new SocketServer.SocketServerError({
+        reason: new SocketServer.SocketServerOpenError({
+          cause: error
+        })
+      })));
+    });
+    server.once("listening", () => {
+      resume(Effect.void);
+    });
+  });
+  const run = Effect.fnUntraced(function* (handler) {
+    const scope = yield* Scope.make();
+    const services = Context.omit(Scope.Scope)(yield* Effect.context());
+    const trackFiber = Fiber.runIn(scope);
+    const prevOnConnection = onConnection;
+    onConnection = function(conn, req) {
+      let context2 = services;
+      context2 = Context.add(context2, IncomingMessage, req);
+      context2 = Context.add(context2, Socket.WebSocket, conn);
+      pipe(Socket.fromWebSocket(Effect.acquireRelease(Effect.succeed(conn), (conn2) => Effect.sync(() => {
+        conn2.close();
+      }))), Effect.flatMap(handler), Effect.catchCause(reportUnhandledError), Effect.runForkWith(context2), trackFiber);
+    };
+    pendingConnections.forEach(([req, remove], conn) => {
+      remove();
+      onConnection(conn, req);
+    });
+    return yield* Effect.callback((_resume) => {
+      return Effect.sync(() => {
+        onConnection = prevOnConnection;
+      });
+    }).pipe(Effect.ensuring(Scope.close(scope, Exit.void)));
+  });
+  const boundAddress = yield* socketAddressFromNode(server.address());
+  return SocketServer.SocketServer.of({
+    address: boundAddress,
+    run
+  });
+});
+var layerWebSocket = /* @__PURE__ */ Function.flow(makeWebSocket, /* @__PURE__ */ Layer.effect(SocketServer.SocketServer));
+var reportUnhandledError = (cause) => Effect.withFiber((fiber) => {
+  const unhandledLogLevel = fiber.getRef(References.UnhandledLogLevel);
+  if (unhandledLogLevel) {
+    return Effect.logWithLevel(unhandledLogLevel)(cause, "Unhandled error in SocketServer");
+  }
+  return Effect.void;
+});
+var makeNetServer = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const errorDeferred = Deferred.makeUnsafe();
+  const pending = /* @__PURE__ */ new Map();
+  function defaultOnConnection(conn) {
+    const remove = () => {
+      pending.delete(conn);
+      conn.off("close", remove);
+      conn.off("error", remove);
+    };
+    pending.set(conn, remove);
+    conn.on("close", remove);
+    conn.on("error", remove);
+  }
+  let onConnection = defaultOnConnection;
+  let server;
+  yield* Effect.addFinalizer(() => Effect.callback((resume) => {
+    pending.forEach((remove, conn) => {
+      remove();
+      conn.destroy();
+    });
+    server?.close(() => resume(Effect.void));
+  }));
+  server = options.createServer();
+  server.on(options.connectionEvent, (conn) => {
+    if (!isDeno) conn.pause();
+    onConnection(conn);
+  });
+  server.on("error", (err) => Deferred.doneUnsafe(errorDeferred, Exit.fail(err)));
+  yield* Effect.callback((resume) => {
+    server.listen(options.listenOptions, () => resume(Effect.void));
+  }).pipe(Effect.raceFirst(Effect.mapError(Deferred.await(errorDeferred), (err) => new SocketServer.SocketServerError({
+    reason: new SocketServer.SocketServerOpenError({
+      cause: err
+    })
+  }))));
+  const run = Effect.fnUntraced(function* (handler) {
+    const scope = yield* Scope.make();
+    const services = Context.omit(Scope.Scope)(yield* Effect.context());
+    const trackFiber = Fiber.runIn(scope);
+    const prevOnConnection = onConnection;
+    onConnection = function(conn) {
+      let error;
+      conn.on("error", (err) => {
+        error = err;
+      });
+      pipe(fromDuplex(Effect.acquireRelease(Effect.suspend(() => {
+        if (error) {
+          return Effect.fail(new Socket.SocketError({
+            reason: new Socket.SocketOpenError({
+              kind: "Unknown",
+              cause: error
+            })
+          }));
+        } else if (conn.closed) {
+          return Effect.fail(new Socket.SocketError({
+            reason: new Socket.SocketCloseError({
+              code: 1e3
+            })
+          }));
+        }
+        return Effect.succeed(conn);
+      }), (conn2) => Effect.sync(() => {
+        if (conn2.closed === false) {
+          conn2.destroySoon();
+        }
+      })), {
+        tlsServer: true
+      }), Effect.flatMap(handler), Effect.catchCause(reportUnhandledError), Effect.runForkWith(Context.add(services, NetSocket, conn)), trackFiber);
+    };
+    pending.forEach((remove, conn) => {
+      remove();
+      onConnection(conn);
+    });
+    return yield* Effect.callback((_resume) => {
+      return Effect.suspend(() => {
+        onConnection = prevOnConnection;
+        return Scope.close(scope, Exit.void);
+      });
+    });
+  });
+  const boundAddress = yield* socketAddressFromNode(server.address());
+  return SocketServer.SocketServer.of({
+    address: boundAddress,
+    run
+  });
+});
+
+export {
+  IncomingMessage,
+  make2 as make,
+  layer,
+  makeTls,
+  layerTls,
+  makeWebSocket,
+  layerWebSocket,
+  NodeSocketServer_exports
+};

package/dist/vendor/chunk-Z7QPP4YH.js

@@ -0,0 +1,249 @@
+import {
+  pullIntoWritable
+} from "./chunk-37CUR3PO.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeStream.js
+var NodeStream_exports = {};
+__export(NodeStream_exports, {
+  fromDuplex: () => fromDuplex,
+  fromReadable: () => fromReadable,
+  fromReadableChannel: () => fromReadableChannel,
+  pipeThroughDuplex: () => pipeThroughDuplex,
+  pipeThroughSimple: () => pipeThroughSimple,
+  toArrayBuffer: () => toArrayBuffer,
+  toReadable: () => toReadable,
+  toReadableNever: () => toReadableNever,
+  toString: () => toString,
+  toUint8Array: () => toUint8Array
+});
+import * as Arr from "effect/Array";
+import * as ByteSize from "effect/ByteSize";
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
+import * as Latch from "effect/Latch";
+import * as MutableRef from "effect/MutableRef";
+import * as Pull from "effect/Pull";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import { Readable } from "node:stream";
+var fromReadable = (options) => Stream.fromChannel(fromReadableChannel(options));
+var fromReadableChannel = (options) => Channel.fromTransform((_, scope) => readableToPullUnsafe({
+  scope,
+  readable: options.evaluate(),
+  onError: options.onError ?? defaultOnError,
+  chunkSize: options.chunkSize,
+  closeOnDone: options.closeOnDone
+}));
+var fromDuplex = (options) => Channel.fromTransform((upstream, scope) => {
+  const duplex = options.evaluate();
+  const exit = MutableRef.make(void 0);
+  const latch = Latch.makeUnsafe(false);
+  return pullIntoWritable({
+    pull: upstream,
+    writable: duplex,
+    onError: options.onError ?? defaultOnError,
+    endOnDone: options.endOnDone,
+    encoding: options.encoding
+  }).pipe(Effect.catchCause((cause) => {
+    if (Pull.isDoneCause(cause)) return Effect.void;
+    exit.current = Exit.failCause(cause);
+    latch.openUnsafe();
+    return Effect.void;
+  }), Effect.forkIn(scope), Effect.flatMap(() => readableToPullUnsafe({
+    scope,
+    exit,
+    latch,
+    readable: duplex,
+    onError: options.onError ?? defaultOnError,
+    chunkSize: options.chunkSize
+  })));
+});
+var pipeThroughDuplex = /* @__PURE__ */ dual(2, (self, options) => Stream.pipeThroughChannelOrFail(self, fromDuplex(options)));
+var pipeThroughSimple = /* @__PURE__ */ dual(2, (self, duplex) => pipeThroughDuplex(self, {
+  evaluate: duplex
+}));
+var toReadable = (stream) => Effect.map(Effect.context(), (context2) => new StreamAdapter(context2, stream));
+var toReadableNever = (stream) => new StreamAdapter(Context.empty(), stream);
+var toString = (readable, options) => {
+  const maxBytesNumber = toMaxBytes(options?.maxBytes);
+  const onError = options?.onError ?? defaultOnError;
+  const encoding = options?.encoding ?? "utf8";
+  return Effect.callback((resume) => {
+    const stream = readable();
+    stream.setEncoding(encoding);
+    stream.once("error", (err) => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+      resume(Effect.fail(onError(err)));
+    });
+    let string = "";
+    let bytes = 0;
+    stream.once("end", () => {
+      resume(Effect.succeed(string));
+    });
+    stream.on("data", (chunk) => {
+      string += chunk;
+      bytes += Buffer.byteLength(chunk);
+      if (maxBytesNumber !== void 0 && bytes > maxBytesNumber) {
+        if ("closed" in stream && !stream.closed) {
+          stream.destroy();
+        }
+        resume(Effect.fail(onError(new Error("maxBytes exceeded"))));
+      }
+    });
+    return Effect.sync(() => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+    });
+  });
+};
+var toArrayBuffer = (readable, options) => {
+  const maxBytesNumber = toMaxBytes(options?.maxBytes);
+  const onError = options?.onError ?? defaultOnError;
+  return Effect.callback((resume) => {
+    const stream = readable();
+    const buffers = [];
+    let bytes = 0;
+    stream.once("error", (err) => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+      resume(Effect.fail(onError(err)));
+    });
+    stream.once("end", () => {
+      const buffer = buffers.length === 1 ? buffers[0] : Buffer.concat(buffers);
+      if (buffer.byteOffset === 0 && buffer.buffer.byteLength === buffer.byteLength) {
+        return resume(Effect.succeed(buffer.buffer));
+      }
+      resume(Effect.succeed(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)));
+    });
+    stream.on("data", (chunk) => {
+      buffers.push(chunk);
+      bytes += chunk.length;
+      if (maxBytesNumber !== void 0 && bytes > maxBytesNumber) {
+        if ("closed" in stream && !stream.closed) {
+          stream.destroy();
+        }
+        resume(Effect.fail(onError(new Error("maxBytes exceeded"))));
+      }
+    });
+    return Effect.sync(() => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy();
+      }
+    });
+  });
+};
+var toUint8Array = (readable, options) => Effect.map(toArrayBuffer(readable, options), (buffer) => new Uint8Array(buffer));
+var readableToPullUnsafe = (options) => {
+  const readable = options.readable;
+  const closeOnDone = options.closeOnDone ?? true;
+  const exit = options.exit ?? MutableRef.make(void 0);
+  const latch = options.latch ?? Latch.makeUnsafe(false);
+  function onReadable() {
+    latch.openUnsafe();
+  }
+  function onError(error) {
+    exit.current = Exit.fail(options.onError(error));
+    latch.openUnsafe();
+  }
+  function onEnd() {
+    exit.current = Exit.fail(Cause.Done());
+    latch.openUnsafe();
+  }
+  readable.on("readable", onReadable);
+  readable.once("error", onError);
+  readable.once("end", onEnd);
+  const pull = Effect.suspend(function loop() {
+    let item = options.readable.read(options.chunkSize);
+    if (item === null) {
+      if (exit.current) {
+        return exit.current;
+      }
+      if (readable.readableEnded) {
+        return Effect.fail(Cause.Done());
+      }
+      latch.closeUnsafe();
+      return Effect.flatMap(latch.await, loop);
+    }
+    const chunk = Arr.of(item);
+    while (true) {
+      item = options.readable.read(options.chunkSize);
+      if (item === null) break;
+      chunk.push(item);
+    }
+    return Effect.succeed(chunk);
+  });
+  return Effect.as(Scope.addFinalizer(options.scope, Effect.sync(() => {
+    readable.off("readable", onReadable);
+    readable.off("error", onError);
+    readable.off("end", onEnd);
+    if (closeOnDone && "closed" in options.readable && !options.readable.closed) {
+      options.readable.destroy();
+    }
+  })), pull);
+};
+var StreamAdapter = class extends Readable {
+  readLatch;
+  fiber = void 0;
+  constructor(context2, stream) {
+    super({});
+    this.readLatch = Latch.makeUnsafe(false);
+    this.fiber = Stream.runForEachArray(stream, (chunk) => this.readLatch.whenOpen(Effect.sync(() => {
+      this.readLatch.closeUnsafe();
+      for (let i = 0; i < chunk.length; i++) {
+        const item = chunk[i];
+        if (typeof item === "string") {
+          this.push(item, "utf8");
+        } else {
+          this.push(item);
+        }
+      }
+    }))).pipe(this.readLatch.whenOpen, Effect.provideContext(context2), Effect.runFork);
+    this.fiber.addObserver((exit) => {
+      this.fiber = void 0;
+      if (Exit.isSuccess(exit)) {
+        this.push(null);
+      } else {
+        this.destroy(Cause.squash(exit.cause));
+      }
+    });
+  }
+  _read(_size) {
+    this.readLatch.openUnsafe();
+  }
+  _destroy(error, callback2) {
+    if (!this.fiber) {
+      return callback2(error);
+    }
+    Effect.runFork(Fiber.interrupt(this.fiber)).addObserver((exit) => {
+      callback2(exit._tag === "Failure" ? Cause.squash(exit.cause) : error);
+    });
+  }
+};
+var defaultOnError = (error) => new Cause.UnknownError(error);
+var toMaxBytes = (maxBytes) => maxBytes === void 0 || maxBytes === Infinity ? void 0 : Number(ByteSize.fromInputUnsafe(maxBytes));
+
+export {
+  fromReadable,
+  fromReadableChannel,
+  fromDuplex,
+  pipeThroughDuplex,
+  pipeThroughSimple,
+  toReadable,
+  toReadableNever,
+  toString,
+  toArrayBuffer,
+  toUint8Array,
+  NodeStream_exports
+};

package/dist/vendor/chunk-ZCHYLHJH.js

@@ -0,0 +1,86 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunWorkerRunner.js
+var BunWorkerRunner_exports = {};
+__export(BunWorkerRunner_exports, {
+  layer: () => layer
+});
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { identity } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/unstable/workers/WorkerError";
+import * as WorkerRunner from "effect/unstable/workers/WorkerRunner";
+var layer = /* @__PURE__ */ Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
+  start: /* @__PURE__ */ Effect.fnUntraced(function* () {
+    if (!("postMessage" in self)) {
+      return yield* new WorkerError({
+        reason: new WorkerSpawnError({
+          message: "not in a Worker context"
+        })
+      });
+    }
+    const port = self;
+    const run = (handler) => Effect.scopedWith(Effect.fnUntraced(function* (scope) {
+      const closeLatch = Deferred.makeUnsafe();
+      const trackFiber = Fiber.runIn(scope);
+      const services = yield* Effect.context();
+      const runFork = Effect.runForkWith(services);
+      const onExit = (exit) => {
+        if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
+          runFork(Effect.logError("unhandled error in worker", exit.cause));
+        }
+      };
+      function onMessage(event) {
+        const message = event.data;
+        if (message[0] === 0) {
+          const result = handler(0, message[1]);
+          if (Effect.isEffect(result)) {
+            const fiber = runFork(result);
+            fiber.addObserver(onExit);
+            trackFiber(fiber);
+          }
+        } else {
+          port.close();
+          Deferred.doneUnsafe(closeLatch, Exit.void);
+        }
+      }
+      function onMessageError(error) {
+        Deferred.doneUnsafe(closeLatch, new WorkerError({
+          reason: new WorkerReceiveError({
+            message: "received messageerror event",
+            cause: error.data
+          })
+        }));
+      }
+      yield* Scope.addFinalizer(scope, Effect.sync(() => {
+        port.removeEventListener("message", onMessage);
+        port.removeEventListener("messageerror", onMessageError);
+      }));
+      port.addEventListener("message", onMessage);
+      port.addEventListener("messageerror", onMessageError);
+      port.postMessage([0]);
+      return yield* Deferred.await(closeLatch);
+    }));
+    const sendUnsafe = (_portId, message, transfer) => port.postMessage([1, message], {
+      transfer
+    });
+    const send = (_portId, message, transfer) => Effect.sync(() => sendUnsafe(0, message, transfer));
+    return identity({
+      run,
+      send,
+      sendUnsafe
+    });
+  })
+});
+
+export {
+  layer,
+  BunWorkerRunner_exports
+};

package/dist/vendor/chunk-ZIQVYVMA.js

@@ -0,0 +1,22 @@
+import {
+  layer,
+  make
+} from "./chunk-3OSW7CT7.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeTerminal.js
+var NodeTerminal_exports = {};
+__export(NodeTerminal_exports, {
+  layer: () => layer2,
+  make: () => make2
+});
+var make2 = make;
+var layer2 = layer;
+
+export {
+  make2 as make,
+  layer2 as layer,
+  NodeTerminal_exports
+};

package/dist/vendor/chunk-ZPIG2CUA.js

@@ -0,0 +1,34 @@
+import {
+  layer as layer5
+} from "./chunk-X73E2UPI.js";
+import {
+  layer as layer6
+} from "./chunk-ZIQVYVMA.js";
+import {
+  layer as layer4
+} from "./chunk-LIHLXXGQ.js";
+import {
+  layer as layer2
+} from "./chunk-DS2R6WOM.js";
+import {
+  layer as layer3
+} from "./chunk-XY3Q62EO.js";
+import {
+  layer
+} from "./chunk-DZ2VOUDP.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeServices.js
+var NodeServices_exports = {};
+__export(NodeServices_exports, {
+  layer: () => layer7
+});
+import * as Layer from "effect/Layer";
+var layer7 = /* @__PURE__ */ Layer.provideMerge(layer, /* @__PURE__ */ Layer.mergeAll(layer3, layer2, layer4, layer5, layer6));
+
+export {
+  layer7 as layer,
+  NodeServices_exports
+};

package/dist/vendor/cjs/bun/BunChildProcessSpawner.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Bun implementation of `ChildProcessSpawner`.
+ *
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeChildProcessSpawner.js";
+//# sourceMappingURL=BunChildProcessSpawner.d.ts.map

package/dist/vendor/cjs/bun/BunChildProcessSpawner.js

@@ -0,0 +1 @@
+module.exports = require("../../bun/BunChildProcessSpawner.js")