the-moby-effect 1.48.0 → 1.48.1

package/src/internal/demux/multiplexed.ts

@@ -1,6 +1,7 @@
 import type * as HttpClientResponse from "@effect/platform/HttpClientResponse";
 import type * as ParseResult from "effect/ParseResult";
 import type * as Scope from "effect/Scope";
+import type * as MobyDemux from "../../MobyDemux.js";
 
 import * as Socket from "@effect/platform/Socket";
 import * as Channel from "effect/Channel";
@@ -15,179 +16,72 @@ import * as Schema from "effect/Schema";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import * as Tuple from "effect/Tuple";
+import * as internalCompressed from "./compressed.js";
 
-import { compressDemuxOutput, CompressedDemuxOutput } from "./compressed.js";
-
-/**
- * @since 1.0.0
- * @category Types
- */
+/** @internal */
 export const MultiplexedContentType = "application/vnd.docker.multiplexed-stream" as const;
 
-/**
- * @since 1.0.0
- * @category Type ids
- */
-export const MultiplexedSocketTypeId: unique symbol = Symbol.for(
+/** @internal */
+export const MultiplexedSocketTypeId: MobyDemux.MultiplexedSocketTypeId = Symbol.for(
     "the-moby-effect/demux/MultiplexedSocket"
-) as MultiplexedSocketTypeId;
-
-/**
- * @since 1.0.0
- * @category Type ids
- */
-export type MultiplexedSocketTypeId = typeof MultiplexedSocketTypeId;
+) as MobyDemux.MultiplexedSocketTypeId;
 
-/**
- * @since 1.0.0
- * @category Type ids
- */
-export const MultiplexedChannelTypeId: unique symbol = Symbol.for(
+/** @internal */
+export const MultiplexedChannelTypeId: MobyDemux.MultiplexedChannelTypeId = Symbol.for(
     "the-moby-effect/demux/MultiplexedChannel"
-) as MultiplexedChannelTypeId;
-
-/**
- * @since 1.0.0
- * @category Type ids
- */
-export type MultiplexedChannelTypeId = typeof MultiplexedChannelTypeId;
-
-/**
- * When the TTY setting is disabled in POST /containers/create, the HTTP
- * Content-Type header is set to application/vnd.docker.multiplexed-stream and
- * the stream over the hijacked connected is multiplexed to separate out stdout
- * and stderr. The stream consists of a series of frames, each containing a
- * header and a payload.
- *
- * Note for Leo: This exists because the input error type "IE" might not be
- * known at the time of converting the Socket to a Channel.
- *
- * @since 1.0.0
- * @category Branded Types
- */
-export interface MultiplexedSocket extends Pipeable.Pipeable {
-    readonly "content-type": typeof MultiplexedContentType;
-    readonly [MultiplexedSocketTypeId]: MultiplexedSocketTypeId;
-    readonly underlying: Socket.Socket;
-}
-
-/**
- * When the TTY setting is disabled in POST /containers/create, the HTTP
- * Content-Type header is set to application/vnd.docker.multiplexed-stream and
- * the stream over the hijacked connected is multiplexed to separate out stdout
- * and stderr. The stream consists of a series of frames, each containing a
- * header and a payload.
- *
- * Note for Leo: This exists because there is no way to convert from a Channel
- * to a Socket. In fact, with my current effect knowledge, I believe it is
- * impossible to implement. This is still needed though for the pack and fan
- * implementations which seek to return these types.
- *
- * @since 1.0.0
- * @category Branded Types
- */
-export interface MultiplexedChannel<IE = unknown, OE = Socket.SocketError, R = never> extends Pipeable.Pipeable {
-    readonly "content-type": typeof MultiplexedContentType;
-    readonly [MultiplexedChannelTypeId]: MultiplexedChannelTypeId;
-    readonly underlying: Channel.Channel<
-        Chunk.Chunk<Uint8Array>,
-        Chunk.Chunk<string | Uint8Array | Socket.CloseEvent>,
-        IE | OE,
-        IE,
-        void,
-        unknown,
-        R
-    >;
-}
-
-/**
- * @since 1.0.0
- * @category Types
- */
-export type EitherMultiplexedInput<IE, OE, R> = MultiplexedSocket | MultiplexedChannel<IE, OE, R>;
+) as MobyDemux.MultiplexedChannelTypeId;
 
-/**
- * @since 1.0.0
- * @category Types
- */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export type AnyMultiplexedInput = EitherMultiplexedInput<any, any, any>;
-/* eslint-enable @typescript-eslint/no-explicit-any */
-
-/**
- * @since 1.0.0
- * @category Constructors
- */
-export const makeMultiplexedSocket = (underlying: Socket.Socket): MultiplexedSocket => ({
+/** @internal */
+export const makeMultiplexedSocket = (underlying: Socket.Socket): MobyDemux.MultiplexedSocket => ({
     underlying,
     "content-type": MultiplexedContentType,
     [MultiplexedSocketTypeId]: MultiplexedSocketTypeId,
     pipe() {
-        // eslint-disable-next-line prefer-rest-params
         return Pipeable.pipeArguments(this, arguments);
     },
 });
 
-/**
- * @since 1.0.0
- * @category Constructors
- */
+/** @internal */
 export const makeMultiplexedChannel = <IE = unknown, OE = Socket.SocketError, R = never>(
     underlying: Channel.Channel<
         Chunk.Chunk<Uint8Array>,
         Chunk.Chunk<string | Uint8Array | Socket.CloseEvent>,
-        IE | OE,
+        OE,
         IE,
         void,
         unknown,
         R
     >
-): MultiplexedChannel<IE, OE, R> => ({
+): MobyDemux.MultiplexedChannel<IE, IE | OE, R> => ({
     underlying,
     "content-type": MultiplexedContentType,
     [MultiplexedChannelTypeId]: MultiplexedChannelTypeId,
     pipe() {
-        // eslint-disable-next-line prefer-rest-params
         return Pipeable.pipeArguments(this, arguments);
     },
 });
 
-/**
- * @since 1.0.0
- * @category Predicates
- */
-export const isMultiplexedSocket = (u: unknown): u is MultiplexedSocket =>
+/** @internal */
+export const isMultiplexedSocket = (u: unknown): u is MobyDemux.MultiplexedSocket =>
     Predicate.hasProperty(u, MultiplexedSocketTypeId);
 
-/**
- * @since 1.0.0
- * @category Predicates
- */
+/** @internal */
 export const isMultiplexedChannel = <IE = unknown, OE = Socket.SocketError, R = never>(
     u: unknown
-): u is MultiplexedChannel<IE, OE, R> => Predicate.hasProperty(u, MultiplexedChannelTypeId);
+): u is MobyDemux.MultiplexedChannel<IE, IE | OE, R> => Predicate.hasProperty(u, MultiplexedChannelTypeId);
 
-/**
- * @since 1.0.0
- * @category Predicates
- */
+/** @internal */
 export const responseIsMultiplexedResponse = (response: HttpClientResponse.HttpClientResponse): boolean =>
     response.headers["content-type"] === MultiplexedContentType;
 
-/**
- * @since 1.0.0
- * @category Types
- */
+/** @internal */
 export enum MultiplexedHeaderType {
     Stdin = 0,
     Stdout = 1,
     Stderr = 2,
 }
 
-/**
- * @since 1.0.0
- * @category Types
- */
+/** @internal */
 export type MultiplexedAccumulator = {
     headerBytesRead: number;
     messageBytesRead: number;
@@ -197,41 +91,33 @@ export type MultiplexedAccumulator = {
     messageType: number | undefined;
 };
 
-/**
- * @since 1.0.0
- * @category Types
- */
+/** @internal */
 export interface $MultiplexedSchema
     extends Schema.Tuple<
         [Schema.Enums<typeof MultiplexedHeaderType>, Schema.Schema<Uint8Array, ReadonlyArray<number>, never>]
     > {}
 
-/**
- * @since 1.0.0
- * @category Schemas
- */
+/** @internal */
 export const MultiplexedSchema: $MultiplexedSchema = Schema.Tuple(
     Schema.Enums(MultiplexedHeaderType),
     Schema.Uint8Array
 );
 
-/**
- * @since 1.0.0
- * @category Conversions
- */
+/** @internal */
 export const asMultiplexedChannel = <IE = never, OE = Socket.SocketError, R = never>(
-    input: EitherMultiplexedInput<IE, OE, R>
-): MultiplexedChannel<IE, OE, R> =>
+    input: MobyDemux.EitherMultiplexedInput<IE, OE, R>
+): MobyDemux.MultiplexedChannel<IE, OE, R> =>
     isMultiplexedSocket(input)
-        ? (makeMultiplexedChannel(Socket.toChannel<IE>(input.underlying)) as unknown as MultiplexedChannel<IE, OE, R>)
-        : (input as MultiplexedChannel<IE, OE, R>);
-
-/**
- * @since 1.0.0
- * @category Conversions
- */
+        ? (makeMultiplexedChannel(Socket.toChannel<IE>(input.underlying)) as unknown as MobyDemux.MultiplexedChannel<
+              IE,
+              OE,
+              R
+          >)
+        : (input as MobyDemux.MultiplexedChannel<IE, OE, R>);
+
+/** @internal */
 export const multiplexedToStream = <IE = never, OE = Socket.SocketError, R = never>(
-    input: EitherMultiplexedInput<IE, OE, R>
+    input: MobyDemux.EitherMultiplexedInput<IE, OE, R>
 ): Stream.Stream<Uint8Array, IE | OE, R> =>
     Channel.toStream(
         asMultiplexedChannel(input).underlying as Channel.Channel<
@@ -245,46 +131,29 @@ export const multiplexedToStream = <IE = never, OE = Socket.SocketError, R = nev
         >
     );
 
-/**
- * @since 1.0.0
- * @category Conversions
- */
+/** @internal */
 export const multiplexedToSink = <IE = never, OE = Socket.SocketError, R = never>(
-    input: EitherMultiplexedInput<IE, OE, R>
+    input: MobyDemux.EitherMultiplexedInput<IE, OE, R>
 ): Sink.Sink<void, string | Uint8Array | Socket.CloseEvent, Uint8Array, IE | OE, R> =>
     Channel.toSink(asMultiplexedChannel(input).underlying);
 
-/**
- * @since 1.0.0
- * @category Conversions
- */
+/** @internal */
 export const multiplexedFromStreamWith =
     <IE>() =>
-    <E, R>(input: Stream.Stream<Uint8Array, IE | E, R>): MultiplexedChannel<IE, E, R> =>
-        makeMultiplexedChannel<IE, E, R>(Stream.toChannel(input));
+    <E, R>(input: Stream.Stream<Uint8Array, IE | E, R>): MobyDemux.MultiplexedChannel<IE, IE | E, R> =>
+        makeMultiplexedChannel<IE, IE | E, R>(Stream.toChannel(input));
 
-/**
- * @since 1.0.0
- * @category Conversions
- */
+/** @internal */
 export const multiplexedFromStream = <E, R>(
     input: Stream.Stream<Uint8Array, E, R>
-): MultiplexedChannel<unknown, E, R> => multiplexedFromStreamWith<unknown>()(input);
+): MobyDemux.MultiplexedChannel<never, E, R> => multiplexedFromStreamWith<never>()(input);
 
-/**
- * @since 1.0.0
- * @category Conversions
- */
+/** @internal */
 export const multiplexedFromSink = <E, R>(
     input: Sink.Sink<void, string | Uint8Array | Socket.CloseEvent, Uint8Array, E, R>
-): MultiplexedChannel<never, E, R> => makeMultiplexedChannel<never, E, R>(Sink.toChannel(input));
+): MobyDemux.MultiplexedChannel<never, E, R> => makeMultiplexedChannel<never, E, R>(Sink.toChannel(input));
 
-/**
- * Accumulates the header and its message bytes into a single value.
- *
- * @since 1.0.0
- * @category Demux
- */
+/** @internal */
 export const demuxMultiplexedFolderSink: Sink.Sink<MultiplexedAccumulator, number, number, never, never> = Sink.fold(
     {
         headerBytesRead: 0,
@@ -327,10 +196,7 @@ export const demuxMultiplexedFolderSink: Sink.Sink<MultiplexedAccumulator, numbe
     }
 );
 
-/**
- * @since 1.0.0
- * @category Grouping
- */
+/** @internal */
 export const aggregate = <E, R>(
     multiplexedStream: Stream.Stream<Uint8Array, E, R>
 ): Stream.Stream<readonly [MultiplexedHeaderType, Uint8Array], ParseResult.ParseError | E, R> =>
@@ -342,12 +208,7 @@ export const aggregate = <E, R>(
         Stream.flatMap(Schema.decodeUnknown(MultiplexedSchema))
     );
 
-/**
- * Demux a multiplexed socket, all output goes to a single sink.
- *
- * @since 1.0.0
- * @category Demux
- */
+/** @internal */
 export const demuxMultiplexedToSingleSink = Function.dual<
     // One sink, data-last signature.
     <A1, L1, E1, E2, R1, R2>(
@@ -355,7 +216,7 @@ export const demuxMultiplexedToSingleSink = Function.dual<
         sink: Sink.Sink<A1, readonly [MultiplexedHeaderType, string], L1, E2, R2>,
         options?: { encoding?: string | undefined } | undefined
     ) => <IE = never, OE = Socket.SocketError, R3 = never>(
-        socket: EitherMultiplexedInput<E1 | IE, OE, R3>
+        socket: MobyDemux.EitherMultiplexedInput<E1 | IE, OE, R3>
     ) => Effect.Effect<
         A1,
         E1 | E2 | IE | OE | ParseResult.ParseError,
@@ -363,7 +224,7 @@ export const demuxMultiplexedToSingleSink = Function.dual<
     >,
     // One sink, data-first signature.
     <A1, L1, E1, E2, R1, R2, IE = never, OE = Socket.SocketError, R3 = never>(
-        socket: EitherMultiplexedInput<E1 | IE, OE, R3>,
+        socket: MobyDemux.EitherMultiplexedInput<E1 | IE, OE, R3>,
         source: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>,
         sink: Sink.Sink<A1, readonly [MultiplexedHeaderType, string], L1, E2, R2>,
         options?: { encoding?: string | undefined } | undefined
@@ -388,18 +249,7 @@ export const demuxMultiplexedToSingleSink = Function.dual<
     }
 );
 
-/**
- * Demux a multiplexed socket. When given a multiplexed socket, we must parse
- * the chunks by headers and then forward each chunk based on its datatype to
- * the correct sink.
- *
- * When partitioning the stream into stdout and stderr, the first sink may
- * advance by up to bufferSize elements further than the slower one. The default
- * bufferSize is 16.
- *
- * @since 1.0.0
- * @category Demux
- */
+/** @internal */
 export const demuxMultiplexedToSeparateSinks = Function.dual<
     // Two sinks, data-last signature.
     <A1, A2, L1, L2, E1, E2, E3, R1, R2, R3>(
@@ -408,21 +258,21 @@ export const demuxMultiplexedToSeparateSinks = Function.dual<
         sink2: Sink.Sink<A2, string, L2, E3, R3>,
         options?: { bufferSize?: number | undefined; encoding?: string | undefined } | undefined
     ) => <IE = never, OE = Socket.SocketError, R4 = never>(
-        socket: EitherMultiplexedInput<E1 | IE, OE, R4>
+        socket: MobyDemux.EitherMultiplexedInput<E1 | IE, OE, R4>
     ) => Effect.Effect<
-        CompressedDemuxOutput<A1, A2>,
+        MobyDemux.CompressedDemuxOutput<A1, A2>,
         E1 | E2 | E3 | IE | OE | ParseResult.ParseError,
         Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope> | Exclude<R4, Scope.Scope>
     >,
     // Two sinks, data-first signature.
     <A1, A2, L1, L2, E1, E2, E3, R1, R2, R3, IE = never, OE = Socket.SocketError, R4 = never>(
-        socket: EitherMultiplexedInput<E1 | IE, OE, R4>,
+        socket: MobyDemux.EitherMultiplexedInput<E1 | IE, OE, R4>,
         source: Stream.Stream<string | Uint8Array | Socket.CloseEvent, E1, R1>,
         sink1: Sink.Sink<A1, string, L1, E2, R2>,
         sink2: Sink.Sink<A2, string, L2, E3, R3>,
         options?: { bufferSize?: number | undefined; encoding?: string | undefined } | undefined
     ) => Effect.Effect<
-        CompressedDemuxOutput<A1, A2>,
+        MobyDemux.CompressedDemuxOutput<A1, A2>,
         E1 | E2 | E3 | IE | OE | ParseResult.ParseError,
         Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope> | Exclude<R4, Scope.Scope>
     >
@@ -452,7 +302,7 @@ export const demuxMultiplexedToSeparateSinks = Function.dual<
             ),
             Effect.map(Effect.allWith({ concurrency: 2 })),
             Effect.flatten,
-            Effect.map(compressDemuxOutput),
+            Effect.map(internalCompressed.compressDemuxOutput),
             Effect.scoped
         )
 );

package/src/internal/demux/pack.ts

@@ -1,4 +1,5 @@
 import type * as Scope from "effect/Scope";
+import type * as MobyDemux from "../../MobyDemux.js";
 
 import * as Socket from "@effect/platform/Socket";
 import * as Channel from "effect/Channel";
@@ -14,18 +15,10 @@ import * as Queue from "effect/Queue";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 
-import {
-    makeMultiplexedChannel,
-    MultiplexedChannel,
-    multiplexedFromStreamWith,
-    MultiplexedHeaderType,
-} from "./multiplexed.js";
-import { demuxStdioRawToSeparateSinks, HeterogeneousStdioRawInput } from "./raw.js";
+import { makeMultiplexedChannel, multiplexedFromStreamWith, MultiplexedHeaderType } from "./multiplexed.js";
+import { demuxStdioRawToSeparateSinks } from "./raw.js";
 
-/**
- * @since 1.0.0
- * @category Packing
- */
+/** @internal */
 export const pack = Function.dual<
     <
         IE1 = never,
@@ -41,9 +34,9 @@ export const pack = Function.dual<
         requestedCapacity: number;
         encoding?: string | undefined;
     }) => (
-        stdio: HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>
+        stdio: MobyDemux.HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>
     ) => Effect.Effect<
-        MultiplexedChannel<IE1 | IE2 | IE3, IE1 | IE2 | IE3 | OE1 | OE2 | OE3, never>,
+        MobyDemux.MultiplexedChannel<IE1 | IE2 | IE3, IE1 | IE2 | IE3 | OE1 | OE2 | OE3, never>,
         never,
         Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
     >,
@@ -58,10 +51,10 @@ export const pack = Function.dual<
         R2 = never,
         R3 = never,
     >(
-        stdio: HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>,
+        stdio: MobyDemux.HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>,
         options: { requestedCapacity: number; encoding?: string | undefined }
     ) => Effect.Effect<
-        MultiplexedChannel<IE1 | IE2 | IE3, IE1 | IE2 | IE3 | OE1 | OE2 | OE3, never>,
+        MobyDemux.MultiplexedChannel<IE1 | IE2 | IE3, IE1 | IE2 | IE3 | OE1 | OE2 | OE3, never>,
         never,
         Exclude<R1, Scope.Scope> | Exclude<R2, Scope.Scope> | Exclude<R3, Scope.Scope>
     >
@@ -78,7 +71,7 @@ export const pack = Function.dual<
         R2 = never,
         R3 = never,
     >(
-        stdio: HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>,
+        stdio: MobyDemux.HeterogeneousStdioRawInput<IE1, IE2, IE3, OE1, OE2, OE3, R1, R2, R3>,
         options: { requestedCapacity: number; encoding?: string | undefined }
     ) {
         const mutex = yield* Effect.makeSemaphore(1);