@effect/platform-node 4.0.0-beta.102 → 4.0.0-beta.104

package/src/NodeHttpClient.ts

@@ -51,14 +51,14 @@ export {
    * Use to access or override the fetch implementation used by the Node
    * fetch-based HTTP client.
    *
-   * @category fetch
+   * @category services
    * @since 4.0.0
    */
   Fetch,
   /**
    * Layer that provides the fetch-based HTTP client implementation.
    *
-   * @category fetch
+   * @category layers
    * @since 4.0.0
    */
   layer as layerFetch,
@@ -69,7 +69,7 @@ export {
    *
    * Use to provide default fetch request options for Node HTTP requests.
    *
-   * @category fetch
+   * @category services
    * @since 4.0.0
    */
   RequestInit
@@ -83,7 +83,7 @@ export {
  * Service tag for the Undici `Dispatcher` used by the Undici-backed HTTP
  * client.
  *
- * @category Dispatcher
+ * @category services
  * @since 4.0.0
  */
 export class Dispatcher extends Context.Service<Dispatcher, Undici.Dispatcher>()(
@@ -94,10 +94,12 @@ export class Dispatcher extends Context.Service<Dispatcher, Undici.Dispatcher>()
  * Acquires a new Undici `Agent` dispatcher and destroys it when the enclosing
  * scope is finalized.
  *
- * @category Dispatcher
+ * @category resource management
  * @since 4.0.0
  */
 export const makeDispatcher: Effect.Effect<Undici.Dispatcher, never, Scope.Scope> = Effect.acquireRelease(
+  // oxlint cannot resolve values re-exported through the local Undici facade.
+  // oxlint-disable-next-line import/namespace
   Effect.sync(() => new Undici.Agent()),
   (dispatcher) => Effect.promise(() => dispatcher.destroy())
 )
@@ -105,7 +107,7 @@ export const makeDispatcher: Effect.Effect<Undici.Dispatcher, never, Scope.Scope
 /**
  * Provides the `Dispatcher` service using a scoped Undici `Agent`.
  *
- * @category Dispatcher
+ * @category layers
  * @since 4.0.0
  */
 export const layerDispatcher: Layer.Layer<Dispatcher> = Layer.effect(Dispatcher)(makeDispatcher)
@@ -114,16 +116,18 @@ export const layerDispatcher: Layer.Layer<Dispatcher> = Layer.effect(Dispatcher)
  * Provides the `Dispatcher` service from Undici's process-global dispatcher,
  * without creating or owning a new agent.
  *
- * @category Dispatcher
+ * @category layers
  * @since 4.0.0
  */
+// oxlint cannot resolve values re-exported through the local Undici facade.
+// oxlint-disable-next-line import/namespace
 export const dispatcherLayerGlobal: Layer.Layer<Dispatcher> = Layer.sync(Dispatcher)(() => Undici.getGlobalDispatcher())
 
 /**
  * Fiber reference containing default Undici request options applied to requests
  * sent by `makeUndici`.
  *
- * @category Undici
+ * @category services
  * @since 4.0.0
  */
 export const UndiciOptions = Context.Reference<Partial<Undici.Dispatcher.RequestOptions>>(
@@ -136,7 +140,7 @@ export const UndiciOptions = Context.Reference<Partial<Undici.Dispatcher.Request
  * `Dispatcher`, converts Effect HTTP bodies to Undici bodies, and maps
  * transport and decode failures to `HttpClientError`.
  *
- * @category Undici
+ * @category constructors
  * @since 4.0.0
  */
 export const makeUndici = Effect.gen(function*() {
@@ -353,7 +357,7 @@ class UndiciResponse extends Inspectable.Class implements HttpClientResponse, Pi
  * Provides an Undici-backed `HttpClient` using the current `Dispatcher`
  * service.
  *
- * @category Undici
+ * @category layers
  * @since 4.0.0
  */
 export const layerUndiciNoDispatcher: Layer.Layer<
@@ -366,7 +370,7 @@ export const layerUndiciNoDispatcher: Layer.Layer<
  * Provides an Undici-backed `HttpClient` together with a scoped default
  * Undici `Agent` dispatcher.
  *
- * @category Undici
+ * @category layers
  * @since 4.0.0
  */
 export const layerUndici: Layer.Layer<Client.HttpClient> = Layer.provide(layerUndiciNoDispatcher, layerDispatcher)
@@ -379,7 +383,7 @@ export const layerUndici: Layer.Layer<Client.HttpClient> = Layer.provide(layerUn
  * Service tag for the paired Node `http` and `https` agents used by the
  * node:http-backed HTTP client.
  *
- * @category HttpAgent
+ * @category services
  * @since 4.0.0
  */
 export class HttpAgent extends Context.Service<HttpAgent, {
@@ -391,7 +395,7 @@ export class HttpAgent extends Context.Service<HttpAgent, {
  * Acquires Node `http` and `https` agents with the supplied options and
  * destroys both agents when the enclosing scope is finalized.
  *
- * @category HttpAgent
+ * @category resource management
  * @since 4.0.0
  */
 export const makeAgent = (options?: Https.AgentOptions): Effect.Effect<HttpAgent["Service"], never, Scope.Scope> =>
@@ -411,7 +415,7 @@ export const makeAgent = (options?: Https.AgentOptions): Effect.Effect<HttpAgent
  * Provides the `HttpAgent` service using scoped Node `http` and `https`
  * agents configured with the supplied options.
  *
- * @category HttpAgent
+ * @category layers
  * @since 4.0.0
  */
 export const layerAgentOptions: (options?: Https.AgentOptions | undefined) => Layer.Layer<
@@ -422,7 +426,7 @@ export const layerAgentOptions: (options?: Https.AgentOptions | undefined) => La
  * Provides the `HttpAgent` service using default scoped Node `http` and
  * `https` agents.
  *
- * @category HttpAgent
+ * @category layers
  * @since 4.0.0
  */
 export const layerAgent: Layer.Layer<HttpAgent> = layerAgentOptions()
@@ -432,7 +436,7 @@ export const layerAgent: Layer.Layer<HttpAgent> = layerAgentOptions()
  * current `HttpAgent`, streaming request bodies, and wrapping Node responses
  * as `HttpClientResponse` values.
  *
- * @category node:http
+ * @category constructors
  * @since 4.0.0
  */
 export const makeNodeHttp = Effect.gen(function*() {
@@ -451,8 +455,11 @@ export const makeNodeHttp = Effect.gen(function*() {
         headers: request.headers,
         signal
       })
-    return Effect.forkChild(sendBody(nodeRequest, request, request.body)).pipe(
-      Effect.flatMap(() => waitForResponse(nodeRequest, request)),
+    return Effect.raceFirst(
+      waitForResponse(nodeRequest, request),
+      sendBody(nodeRequest, request, request.body).pipe(Effect.andThen(Effect.never))
+    ).pipe(
+      Effect.onError(() => Effect.sync(() => nodeRequest.destroy())),
       Effect.map((_) => new NodeHttpResponse(request, _))
     )
   })
@@ -645,7 +652,7 @@ class NodeHttpResponse extends NodeHttpIncomingMessage<Error.HttpClientError> im
  * Provides a node:http-backed `HttpClient` using the current `HttpAgent`
  * service.
  *
- * @category node:http
+ * @category layers
  * @since 4.0.0
  */
 export const layerNodeHttpNoAgent: Layer.Layer<
@@ -658,7 +665,7 @@ export const layerNodeHttpNoAgent: Layer.Layer<
  * Provides a node:http-backed `HttpClient` together with default scoped Node
  * `http` and `https` agents.
  *
- * @category node:http
+ * @category layers
  * @since 4.0.0
  */
 export const layerNodeHttp: Layer.Layer<Client.HttpClient> = Layer.provide(layerNodeHttpNoAgent, layerAgent)

package/src/NodeHttpPlatform.ts

@@ -8,16 +8,63 @@
  *
  * @since 4.0.0
  */
+import * as NodeHttpCompression from "@effect/platform-node-shared/NodeHttpCompression"
+import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as EtagImpl from "effect/unstable/http/Etag"
 import * as Headers from "effect/unstable/http/Headers"
+import * as HttpBody from "effect/unstable/http/HttpBody"
 import * as Platform from "effect/unstable/http/HttpPlatform"
 import * as ServerResponse from "effect/unstable/http/HttpServerResponse"
 import * as Fs from "node:fs"
 import { Readable } from "node:stream"
 import Mime from "./Mime.ts"
 import * as NodeFileSystem from "./NodeFileSystem.ts"
+import * as NodeStream from "./NodeStream.ts"
+
+// replaces the response body while keeping every other field, dropping the
+// now-stale Content-Length header
+const compressedBody = (
+  response: ServerResponse.HttpServerResponse,
+  body: HttpBody.HttpBody
+): ServerResponse.HttpServerResponse =>
+  ServerResponse.removeHeader(ServerResponse.setBody(response, body), "content-length")
+
+const compression = NodeHttpCompression.make({
+  algorithms: NodeHttpCompression.algorithms,
+  compressResponse(response, algorithm, options) {
+    const body = response.body
+    switch (body._tag) {
+      case "Stream": {
+        return Effect.succeed(compressedBody(
+          response,
+          HttpBody.stream(
+            NodeStream.pipeThroughDuplex(body.stream, {
+              evaluate: () => NodeHttpCompression.compressTransform(algorithm, options)
+            }),
+            body.contentType
+          )
+        ))
+      }
+      case "Raw": {
+        const readable = body.body instanceof Readable
+          ? body.body
+          : Readable.fromWeb(new Response(body.body as BodyInit).body as any)
+        const transform = NodeHttpCompression.compressTransform(algorithm, options)
+        readable.on("error", (cause) => transform.destroy(cause))
+        transform.on("error", (cause) => readable.destroy(cause))
+        transform.on("close", () => readable.destroy())
+        return Effect.succeed(
+          compressedBody(response, HttpBody.raw(readable.pipe(transform), { contentType: body.contentType }))
+        )
+      }
+      default: {
+        return Effect.succeed(response)
+      }
+    }
+  }
+})
 
 /**
  * Creates the Node `HttpPlatform`, serving file responses from Node readable
@@ -27,6 +74,8 @@ import * as NodeFileSystem from "./NodeFileSystem.ts"
  * @since 4.0.0
  */
 export const make = Platform.make({
+  platform: "node",
+  compression,
   fileResponse(path, status, statusText, headers, start, end, contentLength) {
     const stream = contentLength === 0
       ? Readable.from([])

package/src/NodeHttpServer.ts

@@ -62,6 +62,26 @@ import * as NodeMultipart from "./NodeMultipart.ts"
 import * as NodeServices from "./NodeServices.ts"
 import { NodeWS } from "./NodeSocket.ts"
 
+/**
+ * Options accepted by the Node `HttpServer` constructors and layers.
+ *
+ * @category options
+ * @since 4.0.0
+ */
+export interface Options extends Net.ListenOptions {
+  readonly disablePreemptiveShutdown?: boolean | undefined
+  readonly gracefulShutdownTimeout?: Duration.Input | undefined
+  /**
+   * Options forwarded to the underlying `ws` `WebSocketServer`, minus the
+   * wiring options the server manages itself. Use this to enable
+   * `permessage-deflate` compression or tune payload limits, e.g.
+   * `websocket: { perMessageDeflate: true }`.
+   */
+  readonly websocket?:
+    | Omit<NodeWS.ServerOptions, "noServer" | "server" | "host" | "port" | "path">
+    | undefined
+}
+
 /**
  * Creates a scoped `HttpServer` from a Node `http.Server`, starts listening
  * with the supplied options, registers request and upgrade handling, and closes
@@ -72,10 +92,7 @@ import { NodeWS } from "./NodeSocket.ts"
  */
 export const make = Effect.fnUntraced(function*(
   evaluate: LazyArg<Http.Server>,
-  options: Net.ListenOptions & {
-    readonly disablePreemptiveShutdown?: boolean | undefined
-    readonly gracefulShutdownTimeout?: Duration.Input | undefined
-  }
+  options: Options
 ) {
   const scope = yield* Effect.scope
   const server = evaluate()
@@ -116,7 +133,7 @@ export const make = Effect.fnUntraced(function*(
   const address = server.address()!
 
   const wss = yield* Effect.acquireRelease(
-    Effect.sync(() => new NodeWS.WebSocketServer({ noServer: true })),
+    Effect.sync(() => new NodeWS.WebSocketServer({ ...options.websocket, noServer: true })),
     (wss) =>
       Effect.callback<void>((resume) => {
         wss.close(() => resume(Effect.void))
@@ -189,9 +206,8 @@ export const makeHandler = <
       nodeRequest: Http.IncomingMessage,
       nodeResponse: Http.ServerResponse
     ) {
-      const map = new Map(services.mapUnsafe)
-      map.set(HttpServerRequest.key, new ServerRequestImpl(nodeRequest, nodeResponse))
-      const fiber = Fiber.runIn(Effect.runForkWith(Context.makeUnsafe<any>(map))(handled), options.scope)
+      const context = Context.add(services, HttpServerRequest, new ServerRequestImpl(nodeRequest, nodeResponse))
+      const fiber = Fiber.runIn(Effect.runForkWith(context as Context.Context<any>)(handled), options.scope)
       nodeResponse.on("close", () => {
         if (!nodeResponse.writableEnded) {
           fiber.interruptUnsafe(parent.id, ClientAbort.annotation)
@@ -256,9 +272,13 @@ export const makeUpgradeHandler = <
             (ws) => Effect.sync(() => ws.close())
           )
       ))
-      const map = new Map(services.mapUnsafe)
-      map.set(HttpServerRequest.key, new ServerRequestImpl(nodeRequest, nodeResponse, upgradeEffect))
-      const fiber = Fiber.runIn(Effect.runForkWith(Context.makeUnsafe<any>(map))(handledApp), options.scope)
+      const context = Context.add(
+        services,
+        HttpServerRequest,
+        new ServerRequestImpl(nodeRequest, nodeResponse, upgradeEffect)
+      )
+      const fiber = Fiber.runIn(Effect.runForkWith(context as Context.Context<any>)(handledApp), options.scope)
+      socket.on("error", () => {})
       socket.on("close", () => {
         if (!socket.writableEnded) {
           fiber.interruptUnsafe(parent.id, ClientAbort.annotation)
@@ -330,8 +350,9 @@ class ServerRequestImpl extends NodeHttpIncomingMessage<HttpServerError> impleme
     return this.source.url!
   }
 
+  private cachedMethod: HttpMethod | undefined
   get method(): HttpMethod {
-    return this.source.method!.toUpperCase() as HttpMethod
+    return this.cachedMethod ??= this.source.method!.toUpperCase() as HttpMethod
   }
 
   override get headers(): Headers.Headers {
@@ -397,10 +418,7 @@ class ServerRequestImpl extends NodeHttpIncomingMessage<HttpServerError> impleme
  */
 export const layerServer: (
   evaluate: LazyArg<Http.Server<typeof Http.IncomingMessage, typeof Http.ServerResponse>>,
-  options: Net.ListenOptions & {
-    readonly disablePreemptiveShutdown?: boolean | undefined
-    readonly gracefulShutdownTimeout?: Duration.Input | undefined
-  }
+  options: Options
 ) => Layer.Layer<HttpServer.HttpServer, ServeError> = flow(make, Layer.effect(HttpServer.HttpServer))
 
 /**
@@ -427,10 +445,7 @@ export const layerHttpServices: Layer.Layer<
  */
 export const layer = (
   evaluate: LazyArg<Http.Server>,
-  options: Net.ListenOptions & {
-    readonly disablePreemptiveShutdown?: boolean | undefined
-    readonly gracefulShutdownTimeout?: Duration.Input | undefined
-  }
+  options: Options
 ): Layer.Layer<
   HttpServer.HttpServer | NodeServices.NodeServices | HttpPlatform.HttpPlatform | Etag.Generator,
   ServeError
@@ -450,12 +465,7 @@ export const layer = (
  */
 export const layerConfig = (
   evaluate: LazyArg<Http.Server>,
-  options: Config.Wrap<
-    Net.ListenOptions & {
-      readonly disablePreemptiveShutdown?: boolean | undefined
-      readonly gracefulShutdownTimeout?: Duration.Input | undefined
-    }
-  >
+  options: Config.Wrap<Options>
 ): Layer.Layer<
   HttpServer.HttpServer | NodeServices.NodeServices | HttpPlatform.HttpPlatform | Etag.Generator,
   ServeError | Config.ConfigError
@@ -517,14 +527,20 @@ const handleResponse = (
 
   if (request.method === "HEAD") {
     nodeResponse.writeHead(response.status, headers)
-    return Effect.callback<void>((resume) => {
-      const done = () => {
-        nodeResponse.off("close", done)
-        resume(Effect.void)
-      }
-      nodeResponse.once("close", done)
-      nodeResponse.end(done)
-    })
+    return Effect.andThen(
+      cancelResponseBody(response.body),
+      Effect.callback<void>((resume) => {
+        let completed = false
+        const done = () => {
+          if (completed) return
+          completed = true
+          nodeResponse.off("close", done)
+          resume(Effect.void)
+        }
+        nodeResponse.once("close", done)
+        nodeResponse.end(done)
+      })
+    )
   }
   const body = response.body
   switch (body._tag) {
@@ -608,17 +624,9 @@ const handleResponse = (
       return body.stream.pipe(
         Stream.orDie,
         Stream.runForEachArray((array) => {
-          let needDrain = false
-          for (let i = 0; i < array.length; i++) {
-            const written = nodeResponse.write(array[i])
-            if (!written && !needDrain) {
-              needDrain = true
-              drainLatch.closeUnsafe()
-            } else if (written && needDrain) {
-              needDrain = false
-            }
-          }
-          if (!needDrain) return Effect.void
+          const chunk = array.length > 1 ? Buffer.concat(array) : array[0]
+          if (nodeResponse.write(chunk)) return Effect.void
+          drainLatch.closeUnsafe()
           return drainLatch.await
         }),
         Effect.interruptible,
@@ -631,6 +639,14 @@ const handleResponse = (
   }
 }
 
+const cancelResponseBody = (body: HttpServerResponse["body"]): Effect.Effect<void> => {
+  const stream = body._tag === "Raw" ? body.body : undefined
+  if (stream instanceof Readable) {
+    return Effect.sync(() => stream.destroy())
+  }
+  return Effect.void
+}
+
 const handleCause = (
   nodeResponse: Http.ServerResponse,
   originalResponse: HttpServerResponse

package/src/NodeMultipart.ts

@@ -17,11 +17,12 @@ import type * as Path from "effect/Path"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as Multipart from "effect/unstable/http/Multipart"
-import * as MP from "effect/unstable/http/Multipasta/Node"
+import * as MultipartParser from "effect/unstable/http/MultipartParser"
 import * as NFS from "node:fs"
 import type { IncomingHttpHeaders } from "node:http"
 import type { Readable } from "node:stream"
 import * as NodeStreamP from "node:stream/promises"
+import * as MP from "./NodeMultipartParser.ts"
 import * as NodeStream from "./NodeStream.ts"
 
 /**
@@ -103,13 +104,13 @@ class FieldImpl extends PartBase implements Multipart.Field {
   readonly value: string
 
   constructor(
-    info: MP.PartInfo,
+    info: MultipartParser.PartInfo,
     value: Uint8Array
   ) {
     super()
     this.key = info.name
     this.contentType = info.contentType
-    this.value = MP.decodeField(info, value)
+    this.value = MultipartParser.decodeField(info, value)
   }
 
   toJSON(): unknown {
@@ -158,7 +159,7 @@ class FileImpl extends PartBase implements Multipart.File {
   }
 }
 
-function convertError(cause: MP.MultipartError): Multipart.MultipartError {
+function convertError(cause: MultipartParser.MultipartError): Multipart.MultipartError {
   switch (cause._tag) {
     case "ReachedLimit": {
       switch (cause.limit) {

package/src/NodeMultipartParser.ts

@@ -0,0 +1,184 @@
+/**
+ * Node.js streams adapter for the low-level multipart parser.
+ *
+ * @since 4.0.0
+ */
+// oxlint-disable typescript/no-unsafe-declaration-merging
+/// <reference types="node" />
+import type { BaseConfig, MultipartError, Parser, PartInfo } from "effect/unstable/http/MultipartParser"
+import { make as makeParser } from "effect/unstable/http/MultipartParser"
+import type { IncomingHttpHeaders } from "node:http"
+import { Duplex, Readable } from "node:stream"
+
+/**
+ * A part emitted by the Node.js multipart parser.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type Part = Field | FileStream
+
+/**
+ * A parsed multipart field.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Field {
+  readonly _tag: "Field"
+  readonly info: PartInfo
+  readonly value: Uint8Array
+}
+
+/**
+ * A Node.js duplex stream that emits parsed multipart parts.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface MultipartStream extends Duplex {
+  [Symbol.asyncIterator](): NodeJS.AsyncIterator<Part>
+
+  on(event: "field", listener: (field: Field) => void): this
+  on(event: "file", listener: (file: FileStream) => void): this
+  on(event: "close", listener: () => void): this
+  on(event: "data", listener: (part: Part) => void): this
+  on(event: "drain", listener: () => void): this
+  on(event: "end", listener: () => void): this
+  on(event: "error", listener: (err: MultipartError) => void): this
+  on(event: "finish", listener: () => void): this
+  on(event: "pause", listener: () => void): this
+  on(event: "pipe", listener: (src: Readable) => void): this
+  on(event: "readable", listener: () => void): this
+  on(event: "resume", listener: () => void): this
+  on(event: "unpipe", listener: (src: Readable) => void): this
+  on(event: string | symbol, listener: (...args: Array<any>) => void): this
+
+  read(size?: number): Part | null
+}
+
+/**
+ * Configuration for the Node.js multipart parser.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type NodeConfig = Omit<BaseConfig, "headers"> & {
+  readonly headers: IncomingHttpHeaders
+}
+
+/**
+ * A Node.js duplex stream that parses multipart input.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export class MultipartStream extends Duplex {
+  private _parser: Parser
+  _canWrite = true
+  private _writeCallback: (() => void) | undefined
+
+  constructor(config: NodeConfig) {
+    super({ readableObjectMode: true })
+    let currentError: MultipartError | undefined
+    let currentFile: FileStream | undefined
+    this._parser = makeParser({
+      ...(config as any),
+      onField: (info, value) => {
+        if (currentError !== undefined) return
+        const field: Field = { _tag: "Field", info, value }
+        this.push(field)
+        this.emit("field", field)
+      },
+      onFile: (info) => {
+        if (currentError !== undefined) return (_) => {}
+        const file = new FileStream(info, this)
+        currentFile = file
+        this.push(file)
+        this.emit("file", file)
+        return (chunk) => {
+          if (currentError !== undefined) return
+          this._canWrite = file.push(chunk)
+          if (chunk === null && !this._canWrite) {
+            currentFile = undefined
+            this._resume()
+          }
+        }
+      },
+      onError: (error) => {
+        this.emit("error", error)
+        currentFile?.emit("error", error)
+        currentError = error
+      },
+      onDone: () => {
+        this.push(null)
+      }
+    })
+  }
+
+  _resume() {
+    this._canWrite = true
+    if (this._writeCallback !== undefined) {
+      const callback = this._writeCallback
+      this._writeCallback = undefined
+      callback()
+    }
+  }
+
+  override _read(_size: number) {}
+
+  override _write(
+    chunk: any,
+    encoding: BufferEncoding,
+    callback: (error?: Error | null | undefined) => void
+  ): void {
+    this._parser.write(
+      chunk instanceof Uint8Array ? chunk : Buffer.from(chunk, encoding)
+    )
+    if (this._canWrite) {
+      callback()
+    } else {
+      this._writeCallback = callback
+    }
+  }
+
+  override _final(callback: (error?: Error | null | undefined) => void): void {
+    this._parser.end()
+    callback()
+  }
+}
+
+/**
+ * Creates a Node.js multipart parser stream.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make = (config: NodeConfig): MultipartStream => new MultipartStream(config)
+
+/**
+ * A readable stream containing a parsed multipart file.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export class FileStream extends Readable {
+  readonly _tag = "File"
+  readonly filename: string | undefined
+  readonly info: PartInfo
+  private _parent: MultipartStream
+  constructor(
+    info: PartInfo,
+    parent: MultipartStream
+  ) {
+    super()
+    this.info = info
+    this._parent = parent
+    this.filename = info.filename
+  }
+  override _read(_size: number) {
+    if (this._parent._canWrite === false) {
+      this._parent._resume()
+    }
+  }
+}