the-moby-effect 1.48.0 → 1.48.2

package/src/MobyPlatforms.ts

@@ -6,9 +6,9 @@
 
 import type * as HttpClient from "@effect/platform/HttpClient";
 import type * as Socket from "@effect/platform/Socket";
-import type * as Layer from "effect/Layer";
+import type * as MobyConnection from "./MobyConnection.js";
 
-import * as MobyConnection from "./MobyConnection.js";
+import * as Layer from "effect/Layer";
 import * as internalAgnostic from "./internal/platforms/agnostic.js";
 import * as internalBun from "./internal/platforms/bun.js";
 import * as internalDeno from "./internal/platforms/deno.js";
@@ -26,7 +26,15 @@ import * as internalWeb from "./internal/platforms/web.js";
  */
 export const makeAgnosticHttpClientLayer: (
     connectionOptions: MobyConnection.MobyConnectionOptions
-) => Layer.Layer<HttpClient.HttpClient, never, HttpClient.HttpClient> = internalAgnostic.makeAgnosticHttpClientLayer;
+) => Layer.Layer<
+    HttpClient.HttpClient | Socket.WebSocketConstructor,
+    never,
+    HttpClient.HttpClient | Socket.WebSocketConstructor
+> = (connectionOptions) =>
+    Layer.merge(
+        Layer.context<Socket.WebSocketConstructor>(),
+        internalAgnostic.makeAgnosticHttpClientLayer(connectionOptions)
+    );
 
 /**
  * Given the moby connection options, it will construct a layer that provides a
@@ -52,8 +60,6 @@ export const makeBunHttpClientLayer: (
  *
  * FIXME: https://github.com/denoland/deno/issues/21436?
  *
- * Will fallback to using undici for now because that seems to work
- *
  * @since 1.0.0
  * @category Deno
  */

package/src/internal/blobs/constants.ts

@@ -1,7 +1,10 @@
 /** @internal */
 export const DefaultDindBaseImage: RecommendedDindBaseImages = "docker.io/library/docker:dind-rootless" as const;
 
-/** @internal */
+/**
+ * @since 1.0.0
+ * @category Types
+ */
 export type RecommendedDindBaseImages =
     | "docker.io/library/docker:dind-rootless"
     | "docker.io/library/docker:23-dind-rootless"

package/src/internal/convey/sinks.ts

@@ -1,5 +1,6 @@
 import type * as Chunk from "effect/Chunk";
 import type * as Scope from "effect/Scope";
+import type { JSONMessage } from "../generated/JSONMessage.generated.js";
 
 import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
@@ -8,8 +9,6 @@ import * as Predicate from "effect/Predicate";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 
-import { JSONMessage } from "../generated/JSONMessage.generated.js";
-
 /** @internal */
 export const waitForProgressToComplete = <E1, R1>(
     stream: Stream.Stream<JSONMessage, E1, R1>

package/src/internal/demux/compressed.ts

@@ -1,24 +1,11 @@
-import * as Predicate from "effect/Predicate";
+import type * as MobyDemux from "../../MobyDemux.js";
 
-/**
- * @since 1.0.0
- * @category Types
- */
-export type CompressedDemuxOutput<A1, A2> = A1 extends undefined | void
-    ? A2 extends undefined | void
-        ? void
-        : readonly [stdout: undefined, stderr: A2]
-    : A2 extends undefined | void
-      ? readonly [stdout: A1, stderr: undefined]
-      : readonly [stdout: A1, stderr: A2];
+import * as Predicate from "effect/Predicate";
 
-/**
- * @since 1.0.0
- * @category Demux Helpers
- */
+/** @internal */
 export const compressDemuxOutput = <A1, A2>(
     data: readonly [ranStdout: A1, ranStderr: A2]
-): CompressedDemuxOutput<A1, A2> =>
+): MobyDemux.CompressedDemuxOutput<A1, A2> =>
     Predicate.isUndefined(data[0]) && Predicate.isUndefined(data[1])
-        ? (void undefined as CompressedDemuxOutput<A1, A2>)
-        : (data as CompressedDemuxOutput<A1, A2>);
+        ? (void undefined as MobyDemux.CompressedDemuxOutput<A1, A2>)
+        : (data as MobyDemux.CompressedDemuxOutput<A1, A2>);

package/src/internal/demux/demux.ts

@@ -3,18 +3,14 @@ import type * as Effect from "effect/Effect";
 import type * as ParseResult from "effect/ParseResult";
 import type * as Scope from "effect/Scope";
 import type * as Stream from "effect/Stream";
+import type * as MobyDemux from "../../MobyDemux.js";
 
 import * as Function from "effect/Function";
 import * as Sink from "effect/Sink";
 import * as Tuple from "effect/Tuple";
 
-import {
-    demuxMultiplexedToSingleSink,
-    EitherMultiplexedInput,
-    isMultiplexedChannel,
-    isMultiplexedSocket,
-} from "./multiplexed.js";
-import { demuxRawToSingleSink, EitherRawInput, isRawChannel, isRawSocket } from "./raw.js";
+import { demuxMultiplexedToSingleSink, isMultiplexedChannel, isMultiplexedSocket } from "./multiplexed.js";
+import { demuxRawToSingleSink, isRawChannel, isRawSocket } from "./raw.js";
 
 /**
  * Demux either a raw socket or a multiplexed socket to a single sink.
@@ -29,7 +25,7 @@ export const demuxToSingleSink = Function.dual<
         sink: Sink.Sink<A1, string, L1, E2, R2>,
         options?: { encoding?: string | undefined } | undefined
     ) => <IE = never, OE = Socket.SocketError, R3 = never>(
-        sockets: EitherRawInput<E1 | IE, OE, R3> | EitherMultiplexedInput<E1 | IE, OE, R3>
+        sockets: MobyDemux.EitherRawInput<E1 | IE, OE, R3> | MobyDemux.EitherMultiplexedInput<E1 | IE, OE, R3>
     ) => Effect.Effect<
         A1,
         E1 | E2 | IE | OE | ParseResult.ParseError,
@@ -37,7 +33,7 @@ export const demuxToSingleSink = Function.dual<
     >,
     // Data-first signature.
     <A1, L1, E1, E2, R1, R2, IE = never, OE = Socket.SocketError, R3 = never>(
-        sockets: EitherRawInput<E1 | IE, OE, R3> | EitherMultiplexedInput<E1 | IE, OE, R3>,
+        sockets: MobyDemux.EitherRawInput<E1 | IE, OE, R3> | MobyDemux.EitherMultiplexedInput<E1 | IE, OE, R3>,
         source: Stream.Stream<string | Uint8Array, E1, R1>,
         sink: Sink.Sink<A1, string, L1, E2, R2>,
         options?: { encoding?: string | undefined } | undefined
@@ -59,7 +55,7 @@ export const demuxToSingleSink = Function.dual<
 
     // Implementation, need the type parameters for checking the underlying.
     <A1, L1, E1, E2, R1, R2, IE = never, OE = Socket.SocketError, R3 = never>(
-        socketOptions: EitherRawInput<E1 | IE, OE, R3> | EitherMultiplexedInput<E1 | IE, OE, R3>,
+        socketOptions: MobyDemux.EitherRawInput<E1 | IE, OE, R3> | MobyDemux.EitherMultiplexedInput<E1 | IE, OE, R3>,
         source: Stream.Stream<string | Uint8Array, E1, R1>,
         sink: Sink.Sink<A1, string, L1, E2, R2>,
         options?: { encoding?: string | undefined } | undefined

package/src/internal/demux/fan.ts

@@ -2,6 +2,7 @@ import type * as Socket from "@effect/platform/Socket";
 import type * as Chunk from "effect/Chunk";
 import type * as ParseResult from "effect/ParseResult";
 import type * as Scope from "effect/Scope";
+import type * as MobyDemux from "../../MobyDemux.js";
 
 import * as Channel from "effect/Channel";
 import * as Effect from "effect/Effect";
@@ -13,41 +14,31 @@ import * as Queue from "effect/Queue";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 
-import {
-    demuxMultiplexedToSeparateSinks,
-    EitherMultiplexedInput,
-    isMultiplexedChannel,
-    isMultiplexedSocket,
-    MultiplexedChannel,
-    MultiplexedSocket,
-} from "./multiplexed.js";
-import { makeRawChannel, RawChannel, rawFromStreamWith } from "./raw.js";
+import { demuxMultiplexedToSeparateSinks, isMultiplexedChannel, isMultiplexedSocket } from "./multiplexed.js";
+import { makeRawChannel, rawFromStreamWith } from "./raw.js";
 
-/**
- * @since 1.0.0
- * @category Fanning
- */
+/** @internal */
 export const fan = Function.dual<
     <IE = never, OE = Socket.SocketError, R = never>(options: {
         requestedCapacity: number;
         encoding?: string | undefined;
-    }) => (multiplexedInput: EitherMultiplexedInput<IE, OE, R>) => Effect.Effect<
+    }) => (multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>) => Effect.Effect<
         {
-            stdin: RawChannel<IE, OE | ParseResult.ParseError, never>;
-            stdout: RawChannel<IE, OE | ParseResult.ParseError, never>;
-            stderr: RawChannel<IE, OE | ParseResult.ParseError, never>;
+            stdin: MobyDemux.RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
+            stdout: MobyDemux.RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
+            stderr: MobyDemux.RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
         },
         never,
         Exclude<R, Scope.Scope>
     >,
     <IE = never, OE = Socket.SocketError, R = never>(
-        multiplexedInput: EitherMultiplexedInput<IE, OE, R>,
+        multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>,
         options: { requestedCapacity: number; encoding?: string | undefined }
     ) => Effect.Effect<
         {
-            stdin: RawChannel<IE, OE | ParseResult.ParseError, never>;
-            stdout: RawChannel<IE, OE | ParseResult.ParseError, never>;
-            stderr: RawChannel<IE, OE | ParseResult.ParseError, never>;
+            stdin: MobyDemux.RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
+            stdout: MobyDemux.RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
+            stderr: MobyDemux.RawChannel<IE, IE | OE | ParseResult.ParseError, never>;
         },
         never,
         Exclude<R, Scope.Scope>
@@ -55,7 +46,7 @@ export const fan = Function.dual<
 >(
     (arguments_) => isMultiplexedChannel(arguments_[0]) || isMultiplexedSocket(arguments_[0]),
     Effect.fnUntraced(function* <IE = never, OE = Socket.SocketError, R = never>(
-        multiplexedInput: MultiplexedSocket | MultiplexedChannel<IE, OE, R>,
+        multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>,
         options: { requestedCapacity: number; encoding?: string | undefined }
     ) {
         const mutex = yield* Effect.makeSemaphore(1);
@@ -106,7 +97,7 @@ export const fan = Function.dual<
         const independentStdinChannel = Channel.toQueue(stdinProducerQueue)
             .pipe(Channel.mapInput(Function.constVoid))
             .pipe(Channel.zipLeft(motherChannel, { concurrent: true }))
-            .pipe(makeRawChannel<IE, OE | ParseResult.ParseError, never>);
+            .pipe(makeRawChannel<IE, IE | OE | ParseResult.ParseError, never>);
 
         // Any one of these will kick off the mother demux, but only one will
         const independentStdoutChannel = Stream.fromQueue(stdoutConsumerQueue)
@@ -114,7 +105,7 @@ export const fan = Function.dual<
             .pipe(rawFromStreamWith<IE>())
             .pipe(({ underlying }) => underlying)
             .pipe(Channel.zipLeft(motherChannel, { concurrent: true }))
-            .pipe(makeRawChannel<IE, OE | ParseResult.ParseError, never>);
+            .pipe(makeRawChannel<IE, IE | OE | ParseResult.ParseError, never>);
 
         // Any one of these will kick off the mother demux, but only one will
         const independentStderrChannel = Stream.fromQueue(stderrConsumerQueue)
@@ -122,7 +113,7 @@ export const fan = Function.dual<
             .pipe(rawFromStreamWith<IE>())
             .pipe(({ underlying }) => underlying)
             .pipe(Channel.zipLeft(motherChannel, { concurrent: true }))
-            .pipe(makeRawChannel<IE, OE | ParseResult.ParseError, never>);
+            .pipe(makeRawChannel<IE, IE | OE | ParseResult.ParseError, never>);
 
         return {
             stdin: independentStdinChannel,

package/src/internal/demux/hijack.ts

@@ -1,22 +1,14 @@
 import type * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import type * as MobyDemux from "../../MobyDemux.js";
+import type { IExposeSocketOnEffectClientResponseHack } from "../platforms/node.js";
 
 import * as Socket from "@effect/platform/Socket";
 import * as Effect from "effect/Effect";
 
-import { IExposeSocketOnEffectClientResponseHack } from "../platforms/node.js";
-import { makeMultiplexedSocket, MultiplexedSocket, responseIsMultiplexedResponse } from "./multiplexed.js";
-import { makeRawSocket, RawSocket, responseIsRawResponse } from "./raw.js";
+import { makeMultiplexedSocket, responseIsMultiplexedResponse } from "./multiplexed.js";
+import { makeRawSocket, responseIsRawResponse } from "./raw.js";
 
-/**
- * Hijacks an http response into a socket.
- *
- * FIXME: this function relies on a hack to expose the underlying tcp socket
- * from the http client response. This will only work in NodeJs, not tested in
- * Bun/Deno yet, and will never work in the browser.
- *
- * @since 1.0.0
- * @category Transformations
- */
+/** @internal */
 export const hijackResponseUnsafe = (
     response: HttpClientResponse.HttpClientResponse
 ): Effect.Effect<Socket.Socket, Socket.SocketError, never> =>
@@ -28,20 +20,10 @@ export const hijackResponseUnsafe = (
         }
     );
 
-/**
- * Transforms an http response into a multiplexed stream socket. If the response
- * is not a multiplexed stream socket, then an error will be returned.
- *
- * FIXME: this function relies on a hack to expose the underlying tcp socket
- * from the http client response. This will only work in NodeJs, not tested in
- * Bun/Deno yet, and will never work in the browser.
- *
- * @since 1.0.0
- * @category Predicates
- */
+/** @internal */
 export const responseToMultiplexedStreamSocketOrFailUnsafe = (
     response: HttpClientResponse.HttpClientResponse
-): Effect.Effect<MultiplexedSocket, Socket.SocketError, never> => {
+): Effect.Effect<MobyDemux.MultiplexedSocket, Socket.SocketError, never> => {
     if (!responseIsMultiplexedResponse(response)) {
         return Effect.fail(
             new Socket.SocketGenericError({
@@ -54,20 +36,10 @@ export const responseToMultiplexedStreamSocketOrFailUnsafe = (
     return Effect.map(hijackResponseUnsafe(response), makeMultiplexedSocket);
 };
 
-/**
- * Transforms an http response into a raw stream socket. If the response is not
- * a raw stream socket, then an error will be returned.
- *
- * FIXME: this function relies on a hack to expose the underlying tcp socket
- * from the http client response. This will only work in NodeJs, not tested in
- * Bun/Deno yet, and will never work in the browser.
- *
- * @since 1.0.0
- * @category Predicates
- */
+/** @internal */
 export const responseToRawStreamSocketOrFailUnsafe = (
     response: HttpClientResponse.HttpClientResponse
-): Effect.Effect<RawSocket, Socket.SocketError, never> => {
+): Effect.Effect<MobyDemux.RawSocket, Socket.SocketError, never> => {
     if (!responseIsRawResponse(response)) {
         return Effect.fail(
             new Socket.SocketGenericError({
@@ -80,21 +52,10 @@ export const responseToRawStreamSocketOrFailUnsafe = (
     return Effect.map(hijackResponseUnsafe(response), makeRawSocket);
 };
 
-/**
- * Transforms an http response into a multiplexed stream socket or a raw stream
- * socket. If the response is neither a multiplexed stream socket nor a raw or
- * can not be transformed, then an error will be returned.
- *
- * FIXME: this function relies on a hack to expose the underlying tcp socket
- * from the http client response. This will only work in NodeJs, not tested in
- * Bun/Deno yet, and will never work in the browser.
- *
- * @since 1.0.0
- * @category Predicates
- */
+/** @internal */
 export const responseToStreamingSocketOrFailUnsafe = (
     response: HttpClientResponse.HttpClientResponse
-): Effect.Effect<RawSocket | MultiplexedSocket, Socket.SocketError, never> => {
+): Effect.Effect<MobyDemux.RawSocket | MobyDemux.MultiplexedSocket, Socket.SocketError, never> => {
     if (responseIsMultiplexedResponse(response)) {
         return responseToMultiplexedStreamSocketOrFailUnsafe(response);
     }