the-moby-effect 1.51.7 → 1.54.1

package/src/internal/convey/sinks.ts

@@ -1,24 +1,20 @@
-import type * as Chunk from "effect/Chunk";
-import type * as Scope from "effect/Scope";
-import type * as MobySchemas from "../generated/index.js";
-
 import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
-import * as Match from "effect/Match";
 import * as Predicate from "effect/Predicate";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 
+import type * as MobySchemas from "../generated/index.js";
+
 /** @internal */
 export const waitForProgressToComplete = <E1, R1>(
     stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
-): Effect.Effect<Chunk.Chunk<MobySchemas.JSONMessage>, E1, Exclude<R1, Scope.Scope>> =>
-    Stream.run(stream, Sink.collectAll());
+): Effect.Effect<Array<MobySchemas.JSONMessage>, E1, R1> => Stream.run(stream, Sink.collect());
 
 /** @internal */
 export const followProgressSink = Sink.forEach<MobySchemas.JSONMessage, void, never, never>(
-    Effect.fnUntraced(function* (message) {
+    Effect.fnUntraced(function* (message: MobySchemas.JSONMessage) {
         if (Predicate.isNotUndefined(message.status)) {
             yield* Console.log(`${message.status}${message.progress ? " " : ""}${message.progress ?? ""}`);
         } else if (Predicate.isNotUndefined(message.stream)) {
@@ -30,32 +26,5 @@ export const followProgressSink = Sink.forEach<MobySchemas.JSONMessage, void, ne
 /** @internal */
 export const followProgressInConsole = <E1, R1>(
     stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
-): Effect.Effect<Chunk.Chunk<MobySchemas.JSONMessage>, E1, Exclude<R1, Scope.Scope>> =>
+): Effect.Effect<Array<MobySchemas.JSONMessage>, E1, R1> =>
     Function.pipe(stream, Stream.tapSink(followProgressSink), waitForProgressToComplete);
-
-/** @internal */
-export const mapError = <E1, R1>(
-    stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
-): Stream.Stream<MobySchemas.JSONMessage, E1 | string, R1> =>
-    Stream.mapEffect(stream, (message) => {
-        if (Predicate.isNotUndefined(message.error)) {
-            const cause: string = Function.pipe(
-                Match.value(message.errorDetail!),
-                Match.when(
-                    { code: Match.undefined, message: Match.undefined },
-                    () => "Errored with an unknown reason with an unknown code"
-                ),
-                Match.when({ message: Match.string }, ({ message }) => `Errored with ${message} and an unknown code`),
-                Match.when({ code: Match.number }, ({ code }) => `Errored with an unknown reason and code ${code}`),
-                Match.when(
-                    { code: Match.number, message: Match.string },
-                    ({ code, message }) => `Errored with ${message} and code ${code}`
-                ),
-                Match.orElseAbsurd
-            );
-
-            return Effect.fail(cause);
-        } else {
-            return Effect.succeed(message);
-        }
-    });

package/src/internal/convey/streams.ts

@@ -0,0 +1,34 @@
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Match from "effect/Match";
+import * as Predicate from "effect/Predicate";
+import * as Stream from "effect/Stream";
+
+import type * as MobySchemas from "../../MobySchemas.ts";
+
+/** @internal */
+export const mapError = <E1, R1>(
+    stream: Stream.Stream<MobySchemas.JSONMessage, E1, R1>
+): Stream.Stream<MobySchemas.JSONMessage, E1 | string, R1> =>
+    Stream.mapEffect(stream, (message) => {
+        if (Predicate.isNotUndefined(message.error)) {
+            const cause: string = Function.pipe(
+                Match.value(message.errorDetail!),
+                Match.when(
+                    { code: Match.undefined, message: Match.undefined },
+                    () => "Errored with an unknown reason with an unknown code"
+                ),
+                Match.when({ message: Match.string }, ({ message }) => `Errored with ${message} and an unknown code`),
+                Match.when({ code: Match.number }, ({ code }) => `Errored with an unknown reason and code ${code}`),
+                Match.when(
+                    { code: Match.number, message: Match.string },
+                    ({ code, message }) => `Errored with ${message} and code ${code}`
+                ),
+                Match.orElseAbsurd
+            );
+
+            return Effect.fail(cause);
+        } else {
+            return Effect.succeed(message);
+        }
+    });

package/src/internal/demux/compressed.ts

@@ -1,7 +1,7 @@
-import type * as MobyDemux from "../../MobyDemux.js";
-
 import * as Predicate from "effect/Predicate";
 
+import type * as MobyDemux from "../../MobyDemux.js";
+
 /** @internal */
 export const compressDemuxOutput = <A1, A2>(
     data: readonly [ranStdout: A1, ranStderr: A2]

package/src/internal/demux/demux.ts

@@ -1,14 +1,14 @@
-import type * as Socket from "@effect/platform/Socket";
 import type * as Effect from "effect/Effect";
-import type * as ParseResult from "effect/ParseResult";
-import type * as Scope from "effect/Scope";
+import type * as Schema from "effect/Schema";
 import type * as Stream from "effect/Stream";
-import type * as MobyDemux from "../../MobyDemux.js";
+import type * as Socket from "effect/unstable/socket/Socket";
 
 import * as Function from "effect/Function";
 import * as Sink from "effect/Sink";
 import * as Tuple from "effect/Tuple";
 
+import type * as MobyDemux from "../../MobyDemux.js";
+
 import { demuxMultiplexedToSingleSink, isMultiplexedChannel, isMultiplexedSocket } from "./multiplexed.js";
 import { demuxRawToSingleSink, isRawChannel, isRawSocket } from "./raw.js";
 
@@ -26,22 +26,14 @@ export const demuxToSingleSink = Function.dual<
         options?: { encoding?: string | undefined } | undefined
     ) => <IE = never, OE = Socket.SocketError, R3 = never>(
         sockets: MobyDemux.EitherRawInput<E1 | IE, OE, R3> | MobyDemux.EitherMultiplexedInput<E1 | IE, OE, R3>
-    ) => Effect.Effect<
-        A1,
-        E1 | E2 | IE | OE | ParseResult.ParseError,
-        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
-    >,
+    ) => Effect.Effect<A1, E1 | E2 | IE | OE | Schema.SchemaError, R1 | R2 | R3>,
     // Data-first signature.
     <A1, L1, E1, E2, R1, R2, IE = never, OE = Socket.SocketError, R3 = never>(
         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
-    ) => Effect.Effect<
-        A1,
-        E1 | E2 | IE | OE | ParseResult.ParseError,
-        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
-    >
+    ) => Effect.Effect<A1, E1 | E2 | IE | OE | Schema.SchemaError, R1 | R2 | R3>
 >(
     /**
      * We are data-first if the first argument is a channel or if the first
@@ -59,17 +51,13 @@ export const demuxToSingleSink = Function.dual<
         source: Stream.Stream<string | Uint8Array, E1, R1>,
         sink: Sink.Sink<A1, string, L1, E2, R2>,
         options?: { encoding?: string | undefined } | undefined
-    ): Effect.Effect<
-        A1,
-        E1 | E2 | IE | OE | ParseResult.ParseError,
-        Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
-    > => {
+    ): Effect.Effect<A1, E1 | E2 | IE | OE | Schema.SchemaError, R1 | R2 | R3> => {
         if (isRawSocket(socketOptions) || isRawChannel<E1 | IE, OE, R3>(socketOptions)) {
             return demuxRawToSingleSink(socketOptions, source, sink, options);
         }
 
         if (isMultiplexedSocket(socketOptions) || isMultiplexedChannel<E1 | IE, OE, R3>(socketOptions)) {
-            return demuxMultiplexedToSingleSink(socketOptions, source, Sink.mapInput(sink, Tuple.getSecond), options);
+            return demuxMultiplexedToSingleSink(socketOptions, source, Sink.mapInput(sink, Tuple.get(1)), options);
         }
 
         return Function.absurd(socketOptions);

package/src/internal/demux/fan.ts

@@ -1,23 +1,32 @@
-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 Array from "effect/Array";
+import type * as Cause from "effect/Cause";
+import type * as Schema from "effect/Schema";
 import type * as Scope from "effect/Scope";
-import type * as MobyDemux from "../../MobyDemux.js";
+import type * as Socket from "effect/unstable/socket/Socket";
 
 import * as Channel from "effect/Channel";
 import * as Effect from "effect/Effect";
-import * as Either from "effect/Either";
-import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
 import * as Function from "effect/Function";
-import * as Option from "effect/Option";
+import * as Pull from "effect/Pull";
 import * as Queue from "effect/Queue";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 
+import type * as MobyDemux from "../../MobyDemux.js";
+
 import { demuxMultiplexedToSeparateSinks, isMultiplexedChannel, isMultiplexedSocket } from "./multiplexed.js";
-import { makeRawChannel, rawFromStreamWith } from "./raw.js";
+import { makeRawChannel } from "./raw.js";
 
-/** @internal */
+/**
+ * The fan demux driver runs exactly once, forked into the caller's scope, and
+ * the returned channels are pure queue plumbing. This keeps the demux
+ * deterministic - there is no racing over which consumer starts the driver,
+ * and consuming any subset of the returned channels (in any order) observes
+ * all of the data.
+ *
+ * @internal
+ */
 export const fan = Function.dual<
     <IE = never, OE = Socket.SocketError, R = never>(options: {
         readonly requestedCapacity:
@@ -30,12 +39,12 @@ export const fan = Function.dual<
         readonly encoding?: string | undefined;
     }) => (multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>) => Effect.Effect<
         {
-            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>;
+            stdin: MobyDemux.RawChannel<IE, IE | OE | Schema.SchemaError, never>;
+            stdout: MobyDemux.RawChannel<IE, IE | OE | Schema.SchemaError, never>;
+            stderr: MobyDemux.RawChannel<IE, IE | OE | Schema.SchemaError, never>;
         },
         never,
-        Exclude<R, Scope.Scope>
+        R | Scope.Scope
     >,
     <IE = never, OE = Socket.SocketError, R = never>(
         multiplexedInput: MobyDemux.EitherMultiplexedInput<IE, OE, R>,
@@ -51,12 +60,12 @@ export const fan = Function.dual<
         }
     ) => Effect.Effect<
         {
-            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>;
+            stdin: MobyDemux.RawChannel<IE, IE | OE | Schema.SchemaError, never>;
+            stdout: MobyDemux.RawChannel<IE, IE | OE | Schema.SchemaError, never>;
+            stderr: MobyDemux.RawChannel<IE, IE | OE | Schema.SchemaError, never>;
         },
         never,
-        Exclude<R, Scope.Scope>
+        R | Scope.Scope
     >
 >(
     (arguments_) => isMultiplexedChannel(arguments_[0]) || isMultiplexedSocket(arguments_[0]),
@@ -73,76 +82,73 @@ export const fan = Function.dual<
             readonly encoding?: string | undefined;
         }
     ) {
-        const mutex = yield* Effect.makeSemaphore(1);
-        const context = yield* Effect.context<Exclude<R, Scope.Scope>>();
+        type CanReceive = string | Uint8Array | Socket.CloseEvent;
+        type FanError = IE | OE | Schema.SchemaError;
 
-        // Internal buffers
+        // Internal buffers. The consumer queues carry the driver's failure so
+        // that a demux error surfaces on whichever channels are being read.
         const capacity = options.requestedCapacity;
-        const stdoutConsumerQueue = yield* Queue.bounded<string>(
+        const stdoutConsumerQueue = yield* Queue.bounded<string, FanError | Cause.Done>(
             typeof capacity === "number" ? capacity : capacity.stdoutCapacity
         );
-        const stderrConsumerQueue = yield* Queue.bounded<string>(
+        const stderrConsumerQueue = yield* Queue.bounded<string, FanError | Cause.Done>(
             typeof capacity === "number" ? capacity : capacity.stderrCapacity
         );
-        const stdinProducerQueue = yield* Queue.bounded<
-            Either.Either<Chunk.Chunk<Uint8Array | string | Socket.CloseEvent>, Exit.Exit<void, IE>>
-        >(typeof capacity === "number" ? capacity : capacity.stdinCapacity);
+        const stdinProducerQueue = yield* Queue.bounded<CanReceive, IE | Cause.Done>(
+            typeof capacity === "number" ? capacity : capacity.stdinCapacity
+        );
 
-        // We MUST only touch the underlying once!!! Very important!!!
-        // Demux everything to and fro the correct places. We can touch
-        // this more than once because it is wrapped with a mutex.
-        const motherChannel = demuxMultiplexedToSeparateSinks(
+        // The driver demuxes the multiplexed input into the consumer queues
+        // and pumps the stdin producer queue into it. On completion the
+        // consumer queues are ended; on failure the failure is forwarded to
+        // them so it surfaces on whichever channels are being read.
+        const driver = yield* demuxMultiplexedToSeparateSinks(
             multiplexedInput,
-            Function.pipe(
-                Stream.fromQueue(stdinProducerQueue, { shutdown: true }),
-                Stream.map(
-                    Either.match({
-                        onRight: Exit.succeed,
-                        onLeft: Function.flow(
-                            Exit.mapBoth({
-                                onFailure: Option.some,
-                                onSuccess: Function.compose(Option.none, Exit.fail),
-                            }),
-                            Exit.flatten
-                        ),
-                    })
-                ),
-                Stream.flattenExitOption,
-                Stream.flattenChunks
-            ),
-            Sink.fromQueue(stdoutConsumerQueue, { shutdown: true }),
-            Sink.fromQueue(stderrConsumerQueue, { shutdown: true }),
+            Stream.fromQueue(stdinProducerQueue),
+            Sink.forEachArray((chunk) => Queue.offerAll(stdoutConsumerQueue, chunk)),
+            Sink.forEachArray((chunk) => Queue.offerAll(stderrConsumerQueue, chunk)),
             {
                 bufferSize: 32,
                 encoding: options.encoding,
             }
-        )
-            .pipe(mutex.withPermitsIfAvailable(1))
-            .pipe(Effect.asVoid)
-            .pipe(Channel.fromEffect)
-            .pipe(Channel.provideContext(context));
+        ).pipe(
+            Effect.tap(() => Effect.andThen(Queue.end(stdoutConsumerQueue), Queue.end(stderrConsumerQueue))),
+            Effect.tapCause((cause) =>
+                Effect.andThen(Queue.failCause(stdoutConsumerQueue, cause), Queue.failCause(stderrConsumerQueue, cause))
+            ),
+            Effect.forkScoped
+        );
 
-        // Any one of these will kick off the mother demux, but only one will
-        const independentStdinChannel = Channel.toQueue(stdinProducerQueue)
-            .pipe(Channel.mapInput(Function.constVoid))
-            .pipe(Channel.zipLeft(motherChannel, { concurrent: true }))
-            .pipe(makeRawChannel<IE, IE | OE | ParseResult.ParseError, never>);
+        // Forwards the stdin channel's input into the stdin producer queue,
+        // propagating input errors and the end-of-input signal.
+        const feedStdin = (
+            upstream: Pull.Pull<Array.NonEmptyReadonlyArray<CanReceive>, IE, unknown, never>
+        ): Effect.Effect<void> =>
+            upstream.pipe(
+                Effect.flatMap((chunk) => Queue.offerAll(stdinProducerQueue, chunk)),
+                Effect.forever,
+                Pull.catchDone(() => Queue.end(stdinProducerQueue)),
+                Effect.catchCause((cause) => Queue.failCause(stdinProducerQueue, cause)),
+                Effect.asVoid
+            );
 
-        // Any one of these will kick off the mother demux, but only one will
-        const independentStdoutChannel = Stream.fromQueue(stdoutConsumerQueue)
-            .pipe(Stream.encodeText)
-            .pipe(rawFromStreamWith<IE>())
-            .pipe(({ underlying }) => underlying)
-            .pipe(Channel.zipLeft(motherChannel, { concurrent: true }))
-            .pipe(makeRawChannel<IE, IE | OE | ParseResult.ParseError, never>);
+        // The stdin channel completes (or fails) with the driver.
+        const independentStdinChannel = Channel.fromEffectDrain(Fiber.join(driver)).pipe(
+            Channel.embedInput<Array.NonEmptyReadonlyArray<CanReceive>, IE, unknown, never>(feedStdin),
+            makeRawChannel<IE, IE | OE | Schema.SchemaError, never>
+        );
 
-        // Any one of these will kick off the mother demux, but only one will
-        const independentStderrChannel = Stream.fromQueue(stderrConsumerQueue)
-            .pipe(Stream.encodeText)
-            .pipe(rawFromStreamWith<IE>())
-            .pipe(({ underlying }) => underlying)
-            .pipe(Channel.zipLeft(motherChannel, { concurrent: true }))
-            .pipe(makeRawChannel<IE, IE | OE | ParseResult.ParseError, never>);
+        const independentStdoutChannel = Stream.fromQueue(stdoutConsumerQueue).pipe(
+            Stream.encodeText,
+            Stream.toChannel,
+            makeRawChannel<IE, IE | OE | Schema.SchemaError, never>
+        );
+
+        const independentStderrChannel = Stream.fromQueue(stderrConsumerQueue).pipe(
+            Stream.encodeText,
+            Stream.toChannel,
+            makeRawChannel<IE, IE | OE | Schema.SchemaError, never>
+        );
 
         return {
             stdin: independentStdinChannel,

package/src/internal/demux/hijack.ts

@@ -1,10 +1,12 @@
-import type * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import type * as MobyDemux from "../../MobyDemux.js";
+import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
 
-import * as Socket from "@effect/platform/Socket";
 import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as Socket from "effect/unstable/socket/Socket";
 
+import type * as MobyDemux from "../../MobyDemux.js";
 import type { IExposeSocketOnEffectClientResponseHack } from "../platforms/node.js";
+
 import { makeMultiplexedSocket, responseIsMultiplexedResponse } from "./multiplexed.js";
 import { makeRawSocket, responseIsRawResponse } from "./raw.js";
 
@@ -15,7 +17,20 @@ export const hijackResponseUnsafe = (
     Effect.flatMap(
         Effect.promise(() => import("@effect/platform-node/NodeSocket")),
         (nodeSocketLazy) => {
-            const socket = (response as IExposeSocketOnEffectClientResponseHack).original.source.socket;
+            let current = response as IExposeSocketOnEffectClientResponseHack;
+            while (Predicate.isNotUndefined(current.original)) current = current.original;
+
+            const socket = current.source?.socket;
+            if (Predicate.isUndefined(socket)) {
+                return Effect.fail(
+                    new Socket.SocketError({
+                        reason: new Socket.SocketReadError({
+                            cause: "Could not find the underlying tcp socket on the http client response",
+                        }),
+                    })
+                );
+            }
+
             return nodeSocketLazy.fromDuplex(Effect.sync(() => socket));
         }
     );
@@ -26,9 +41,10 @@ export const responseToMultiplexedStreamSocketOrFailUnsafe = (
 ): Effect.Effect<MobyDemux.MultiplexedSocket, Socket.SocketError, never> => {
     if (!responseIsMultiplexedResponse(response)) {
         return Effect.fail(
-            new Socket.SocketGenericError({
-                reason: "Read",
-                cause: `Response with content type "${response.headers["content-type"]}" is not a multiplexed streaming socket`,
+            new Socket.SocketError({
+                reason: new Socket.SocketReadError({
+                    cause: `Response with content type "${response.headers["content-type"]}" is not a multiplexed streaming socket`,
+                }),
             })
         );
     }
@@ -42,9 +58,10 @@ export const responseToRawStreamSocketOrFailUnsafe = (
 ): Effect.Effect<MobyDemux.RawSocket, Socket.SocketError, never> => {
     if (!responseIsRawResponse(response)) {
         return Effect.fail(
-            new Socket.SocketGenericError({
-                reason: "Read",
-                cause: `Response with content type "${response.headers["content-type"]}" is not a raw streaming socket`,
+            new Socket.SocketError({
+                reason: new Socket.SocketReadError({
+                    cause: `Response with content type "${response.headers["content-type"]}" is not a raw streaming socket`,
+                }),
             })
         );
     }
@@ -64,5 +81,11 @@ export const responseToStreamingSocketOrFailUnsafe = (
         return responseToRawStreamSocketOrFailUnsafe(response);
     }
 
-    return Effect.fail(new Socket.SocketGenericError({ reason: "Read", cause: "Response is not a streaming socket" }));
+    return Effect.fail(
+        new Socket.SocketError({
+            reason: new Socket.SocketReadError({
+                cause: "Response is not a streaming socket",
+            }),
+        })
+    );
 };