@effect/platform-node 0.42.11 → 0.43.0

package/src/NodeSink.ts

@@ -0,0 +1,8 @@
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ */
+export * from "@effect/platform-node-shared/NodeSink"

package/src/NodeStream.ts

@@ -0,0 +1,8 @@
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @category models
+ */
+export * from "@effect/platform-node-shared/NodeStream"

package/src/NodeTerminal.ts

@@ -0,0 +1,20 @@
+/**
+ * @since 1.0.0
+ */
+import * as NodeTerminal from "@effect/platform-node-shared/NodeTerminal"
+import type { Terminal, UserInput } from "@effect/platform/Terminal"
+import type { Effect } from "effect/Effect"
+import type { Layer } from "effect/Layer"
+import type { Scope } from "effect/Scope"
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: (shouldQuit?: (input: UserInput) => boolean) => Effect<Terminal, never, Scope> = NodeTerminal.make
+
+/**
+ * @since 1.0.0
+ * @category layer
+ */
+export const layer: Layer<Terminal> = NodeTerminal.layer

package/src/NodeWorker.ts

@@ -0,0 +1,27 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Worker from "@effect/platform/Worker"
+import type * as Layer from "effect/Layer"
+import type * as WorkerThreads from "node:worker_threads"
+import * as internal from "./internal/worker.js"
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerManager: Layer.Layer<Worker.WorkerManager> = internal.layerManager
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerWorker: Layer.Layer<Worker.PlatformWorker> = internal.layerWorker
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer: (
+  spawn: (id: number) => WorkerThreads.Worker
+) => Layer.Layer<Worker.WorkerManager | Worker.Spawner, never, never> = internal.layer

package/src/NodeWorkerRunner.ts

@@ -0,0 +1,12 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Runner from "@effect/platform/WorkerRunner"
+import type * as Layer from "effect/Layer"
+import * as internal from "./internal/workerRunner.js"
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer: Layer.Layer<Runner.PlatformRunner> = internal.layer

package/src/index.ts

@@ -1,92 +1,64 @@
 /**
  * @since 1.0.0
  */
-export * as Command from "./Command.js"
+export * as NodeCommandExecutor from "./NodeCommandExecutor.js"
 
 /**
  * @since 1.0.0
  */
-export * as CommandExecutor from "./CommandExecutor.js"
-
-/**
- * @since 1.0.0
- */
-export * as Effectify from "./Effectify.js"
-
-/**
- * @since 1.0.0
- */
-export * as Error from "./Error.js"
-
-/**
- * @since 1.0.0
- */
-export * as FileSystem from "./FileSystem.js"
-
-/**
- * @since 1.0.0
- */
-export * as HttpClient from "./HttpClient.js"
+export * as NodeContext from "./NodeContext.js"
 
 /**
  * @since 1.0.0
  */
-export * as HttpServer from "./HttpServer.js"
+export * as NodeFileSystem from "./NodeFileSystem.js"
 
 /**
  * @since 1.0.0
- *
- * Also includes exports from [`@effect/platform/KeyValueStore`](https://effect-ts.github.io/effect/platform/KeyValueStore.ts.html).
  */
-export * as KeyValueStore from "./KeyValueStore.js"
+export * as NodeHttpClient from "./NodeHttpClient.js"
 
 /**
  * @since 1.0.0
  */
-export * as NodeContext from "./NodeContext.js"
+export * as NodeHttpServer from "./NodeHttpServer.js"
 
 /**
  * @since 1.0.0
  */
-export * as Path from "./Path.js"
+export * as NodeKeyValueStore from "./NodeKeyValueStore.js"
 
 /**
  * @since 1.0.0
  */
-export * as Runtime from "./Runtime.js"
+export * as NodePath from "./NodePath.js"
 
 /**
  * @since 1.0.0
  */
-export * as Sink from "./Sink.js"
+export * as NodeRuntime from "./NodeRuntime.js"
 
 /**
  * @since 1.0.0
  */
-export * as Stream from "./Stream.js"
+export * as NodeSink from "./NodeSink.js"
 
 /**
  * @since 1.0.0
  */
-export * as Terminal from "./Terminal.js"
+export * as NodeStream from "./NodeStream.js"
 
 /**
  * @since 1.0.0
- *
- * Also includes exports from [`@effect/platform/Transferable`](https://effect-ts.github.io/effect/platform/Transferable.ts.html).
  */
-export * as Transferable from "./Transferable.js"
+export * as NodeTerminal from "./NodeTerminal.js"
 
 /**
  * @since 1.0.0
- *
- * Also includes exports from [`@effect/platform/Worker`](https://effect-ts.github.io/effect/platform/Worker.ts.html).
  */
-export * as Worker from "./Worker.js"
+export * as NodeWorker from "./NodeWorker.js"
 
 /**
  * @since 1.0.0
- *
- * Also includes exports from [`@effect/platform/WorkerRunner`](https://effect-ts.github.io/effect/platform/WorkerRunner.ts.html).
  */
-export * as WorkerRunner from "./WorkerRunner.js"
+export * as NodeWorkerRunner from "./NodeWorkerRunner.js"

package/src/internal/http/{nodeClient.ts → client.ts}

@@ -14,8 +14,8 @@ import * as Http from "node:http"
 import * as Https from "node:https"
 import { Readable } from "node:stream"
 import { pipeline } from "node:stream/promises"
-import type * as NodeClient from "../../Http/NodeClient.js"
-import * as NodeSink from "../../Sink.js"
+import type * as NodeClient from "../../NodeHttpClient.js"
+import * as NodeSink from "../../NodeSink.js"
 import { IncomingMessageImpl } from "./incomingMessage.js"
 
 /** @internal */
@@ -24,10 +24,10 @@ export const HttpAgentTypeId: NodeClient.HttpAgentTypeId = Symbol.for(
 ) as NodeClient.HttpAgentTypeId
 
 /** @internal */
-export const HttpAgent = Context.Tag<NodeClient.HttpAgent>(HttpAgentTypeId)
+export const HttpAgent = Context.GenericTag<NodeClient.HttpAgent>("@effect/platform-node/Http/NodeClient/HttpAgent")
 
 /** @internal */
-export const makeAgent = (options?: Https.AgentOptions): Effect.Effect<Scope.Scope, never, NodeClient.HttpAgent> =>
+export const makeAgent = (options?: Https.AgentOptions): Effect.Effect<NodeClient.HttpAgent, never, Scope.Scope> =>
   Effect.map(
     Effect.all([
       Effect.acquireRelease(
@@ -47,7 +47,7 @@ export const makeAgent = (options?: Https.AgentOptions): Effect.Effect<Scope.Sco
   )
 
 /** @internal */
-export const makeAgentLayer = (options?: Https.AgentOptions): Layer.Layer<never, never, NodeClient.HttpAgent> =>
+export const makeAgentLayer = (options?: Https.AgentOptions): Layer.Layer<NodeClient.HttpAgent> =>
   Layer.scoped(HttpAgent, makeAgent(options))
 
 /** @internal */
@@ -93,8 +93,8 @@ const sendBody = (
   nodeRequest: Http.ClientRequest,
   request: ClientRequest.ClientRequest,
   body: Body.Body
-): Effect.Effect<never, Error.RequestError, void> =>
-  Effect.suspend((): Effect.Effect<never, Error.RequestError, void> => {
+): Effect.Effect<void, Error.RequestError> =>
+  Effect.suspend((): Effect.Effect<void, Error.RequestError> => {
     switch (body._tag) {
       case "Empty": {
         nodeRequest.end()
@@ -142,7 +142,7 @@ const sendBody = (
   })
 
 const waitForResponse = (nodeRequest: Http.ClientRequest, request: ClientRequest.ClientRequest) =>
-  Effect.async<never, Error.RequestError, Http.IncomingMessage>((resume) => {
+  Effect.async<Http.IncomingMessage, Error.RequestError>((resume) => {
     function onError(error: Error) {
       resume(Effect.fail(Error.RequestError({
         request,
@@ -167,7 +167,7 @@ const waitForResponse = (nodeRequest: Http.ClientRequest, request: ClientRequest
   })
 
 const waitForFinish = (nodeRequest: Http.ClientRequest, request: ClientRequest.ClientRequest) =>
-  Effect.async<never, Error.RequestError, void>((resume) => {
+  Effect.async<void, Error.RequestError>((resume) => {
     function onError(error: Error) {
       resume(Effect.fail(Error.RequestError({
         request,
@@ -210,7 +210,7 @@ class ClientResponseImpl extends IncomingMessageImpl<Error.ResponseError> implem
     return this.source.statusCode!
   }
 
-  get formData(): Effect.Effect<never, Error.ResponseError, FormData> {
+  get formData(): Effect.Effect<FormData, Error.ResponseError> {
     return Effect.tryPromise({
       try: () => {
         const init: {

package/src/internal/http/incomingMessage.ts

@@ -6,7 +6,7 @@ import * as FiberRef from "effect/FiberRef"
 import * as Option from "effect/Option"
 import type * as Stream from "effect/Stream"
 import type * as Http from "node:http"
-import * as NodeStream from "../../Stream.js"
+import * as NodeStream from "../../NodeStream.js"
 
 /** @internal */
 export class IncomingMessageImpl<E> implements IncomingMessage.IncomingMessage<E> {
@@ -28,8 +28,8 @@ export class IncomingMessageImpl<E> implements IncomingMessage.IncomingMessage<E
     return Option.fromNullable(this.remoteAddressOverride ?? this.source.socket.remoteAddress)
   }
 
-  private textEffect: Effect.Effect<never, E, string> | undefined
-  get text(): Effect.Effect<never, E, string> {
+  private textEffect: Effect.Effect<string, E> | undefined
+  get text(): Effect.Effect<string, E> {
     if (this.textEffect) {
       return this.textEffect
     }
@@ -46,14 +46,14 @@ export class IncomingMessageImpl<E> implements IncomingMessage.IncomingMessage<E
     return this.textEffect
   }
 
-  get json(): Effect.Effect<never, E, unknown> {
+  get json(): Effect.Effect<unknown, E> {
     return Effect.tryMap(this.text, {
       try: (_) => _ === "" ? null : JSON.parse(_) as unknown,
       catch: this.onError
     })
   }
 
-  get urlParamsBody(): Effect.Effect<never, E, UrlParams.UrlParams> {
+  get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, E> {
     return Effect.flatMap(this.text, (_) =>
       Effect.try({
         try: () => UrlParams.fromInput(new URLSearchParams(_)),
@@ -61,14 +61,14 @@ export class IncomingMessageImpl<E> implements IncomingMessage.IncomingMessage<E
       }))
   }
 
-  get stream(): Stream.Stream<never, E, Uint8Array> {
+  get stream(): Stream.Stream<Uint8Array, E> {
     return NodeStream.fromReadable<E, Uint8Array>(
       () => this.source,
       this.onError
     )
   }
 
-  get arrayBuffer(): Effect.Effect<never, E, ArrayBuffer> {
+  get arrayBuffer(): Effect.Effect<ArrayBuffer, E> {
     return Effect.flatMap(
       FiberRef.get(IncomingMessage.maxBodySize),
       (maxBodySize) =>

package/src/internal/http/platform.ts

@@ -1,3 +1,4 @@
+import * as EtagImpl from "@effect/platform-node-shared/Http/Etag"
 import * as Headers from "@effect/platform/Http/Headers"
 import * as Platform from "@effect/platform/Http/Platform"
 import * as ServerResponse from "@effect/platform/Http/ServerResponse"
@@ -6,8 +7,7 @@ import * as Layer from "effect/Layer"
 import Mime from "mime"
 import * as Fs from "node:fs"
 import { Readable } from "node:stream"
-import * as FileSystem from "../../FileSystem.js"
-import * as Etag from "../../Http/Etag.js"
+import * as FileSystem from "../../NodeFileSystem.js"
 
 /** @internal */
 export const make = Platform.make({
@@ -42,5 +42,5 @@ export const make = Platform.make({
 export const layer = pipe(
   Layer.effect(Platform.Platform, make),
   Layer.provide(FileSystem.layer),
-  Layer.provide(Etag.layer)
+  Layer.provide(EtagImpl.layer)
 )

package/src/internal/http/server.ts

@@ -1,3 +1,5 @@
+import * as Etag from "@effect/platform-node-shared/Http/Etag"
+import * as MultipartNode from "@effect/platform-node-shared/Http/Multipart"
 import * as FileSystem from "@effect/platform/FileSystem"
 import * as App from "@effect/platform/Http/App"
 import type * as Headers from "@effect/platform/Http/Headers"
@@ -23,21 +25,21 @@ import type * as Http from "node:http"
 import type * as Net from "node:net"
 import { Readable } from "node:stream"
 import { pipeline } from "node:stream/promises"
-import * as NodeSink from "../../Sink.js"
+import * as NodeContext from "../../NodeContext.js"
+import * as NodeSink from "../../NodeSink.js"
 import { IncomingMessageImpl } from "./incomingMessage.js"
-import * as internalMultipart from "./multipart.js"
 import * as internalPlatform from "./platform.js"
 
 /** @internal */
 export const make = (
   evaluate: LazyArg<Http.Server>,
   options: Net.ListenOptions
-): Effect.Effect<Scope.Scope, Error.ServeError, Server.Server> =>
+): Effect.Effect<Server.Server, Error.ServeError, Scope.Scope> =>
   Effect.gen(function*(_) {
     const server = yield* _(Effect.acquireRelease(
       Effect.sync(evaluate),
       (server) =>
-        Effect.async<never, never, void>((resume) => {
+        Effect.async<void>((resume) => {
           server.close((error) => {
             if (error) {
               resume(Effect.die(error))
@@ -48,7 +50,7 @@ export const make = (
         })
     ))
 
-    yield* _(Effect.async<never, Error.ServeError, void>((resume) => {
+    yield* _(Effect.async<void, Error.ServeError>((resume) => {
       server.on("error", (error) => {
         resume(Effect.fail(Error.ServeError({ error })))
       })
@@ -67,7 +69,7 @@ export const make = (
         } :
         {
           _tag: "TcpAddress",
-          hostname: address.address,
+          hostname: address.address === "::" ? "0.0.0.0" : address.address,
           port: address.port
         },
       serve: (httpApp, middleware) =>
@@ -91,17 +93,17 @@ export const make = (
 /** @internal */
 export const makeHandler: {
   <R, E>(httpApp: App.Default<R, E>): Effect.Effect<
-    Exclude<R, ServerRequest.ServerRequest | Scope.Scope>,
+    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void,
     never,
-    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void
+    Exclude<R, ServerRequest.ServerRequest | Scope.Scope>
   >
   <R, E, App extends App.Default<any, any>>(
     httpApp: App.Default<R, E>,
     middleware: Middleware.Middleware.Applied<R, E, App>
   ): Effect.Effect<
-    Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>,
+    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void,
     never,
-    (nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) => void
+    Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>
   >
 } = <R, E>(httpApp: App.Default<R, E>, middleware?: Middleware.Middleware) => {
   const handledApp = Effect.scoped(
@@ -209,27 +211,27 @@ class ServerRequestImpl extends IncomingMessageImpl<Error.RequestError> implemen
 
   private multipartEffect:
     | Effect.Effect<
-      Scope.Scope | FileSystem.FileSystem | Path.Path,
+      Multipart.Persisted,
       Multipart.MultipartError,
-      Multipart.Persisted
+      Scope.Scope | FileSystem.FileSystem | Path.Path
     >
     | undefined
   get multipart(): Effect.Effect<
-    Scope.Scope | FileSystem.FileSystem | Path.Path,
+    Multipart.Persisted,
     Multipart.MultipartError,
-    Multipart.Persisted
+    Scope.Scope | FileSystem.FileSystem | Path.Path
   > {
     if (this.multipartEffect) {
       return this.multipartEffect
     }
     this.multipartEffect = Effect.runSync(Effect.cached(
-      internalMultipart.persisted(this.source, this.source.headers)
+      MultipartNode.persisted(this.source, this.source.headers)
     ))
     return this.multipartEffect
   }
 
-  get multipartStream(): Stream.Stream<never, Multipart.MultipartError, Multipart.Part> {
-    return internalMultipart.stream(this.source, this.source.headers)
+  get multipartStream(): Stream.Stream<Multipart.Part, Multipart.MultipartError> {
+    return MultipartNode.stream(this.source, this.source.headers)
   }
 
   toString(): string {
@@ -247,14 +249,22 @@ class ServerRequestImpl extends IncomingMessageImpl<Error.RequestError> implemen
   }
 }
 
+/** @internal */
+export const layerServer = (
+  evaluate: LazyArg<Http.Server>,
+  options: Net.ListenOptions
+) => Layer.scoped(Server.Server, make(evaluate, options))
+
 /** @internal */
 export const layer = (
   evaluate: LazyArg<Http.Server>,
   options: Net.ListenOptions
 ) =>
-  Layer.merge(
+  Layer.mergeAll(
     Layer.scoped(Server.Server, make(evaluate, options)),
-    internalPlatform.layer
+    internalPlatform.layer,
+    Etag.layerWeak,
+    NodeContext.layer
   )
 
 /** @internal */
@@ -262,16 +272,18 @@ export const layerConfig = (
   evaluate: LazyArg<Http.Server>,
   options: Config.Config.Wrap<Net.ListenOptions>
 ) =>
-  Layer.merge(
+  Layer.mergeAll(
     Layer.scoped(
       Server.Server,
       Effect.flatMap(Config.unwrap(options), (options) => make(evaluate, options))
     ),
-    internalPlatform.layer
+    internalPlatform.layer,
+    Etag.layerWeak,
+    NodeContext.layer
   )
 
 const handleResponse = (request: ServerRequest.ServerRequest, response: ServerResponse.ServerResponse) =>
-  Effect.suspend((): Effect.Effect<never, Error.ResponseError, void> => {
+  Effect.suspend((): Effect.Effect<void, Error.ResponseError> => {
     const nodeResponse = (request as ServerRequestImpl).response
     if (request.method === "HEAD") {
       nodeResponse.writeHead(response.status, response.headers)
@@ -311,7 +323,7 @@ const handleResponse = (request: ServerRequest.ServerRequest, response: ServerRe
         return Effect.unit
       }
       case "FormData": {
-        return Effect.async<never, Error.ResponseError, void>((resume) => {
+        return Effect.async<void, Error.ResponseError>((resume) => {
           const r = new Response(body.formData)
           const headers = {
             ...response.headers,

package/src/internal/worker.ts

@@ -13,7 +13,7 @@ const platformWorkerImpl = Worker.PlatformWorker.of({
       const worker = worker_ as WorkerThreads.Worker
       yield* _(Effect.addFinalizer(() =>
         pipe(
-          Effect.async<never, never, void>((resume) => {
+          Effect.async<void>((resume) => {
             worker.once("exit", () => {
               resume(Effect.unit)
             })
@@ -26,7 +26,7 @@ const platformWorkerImpl = Worker.PlatformWorker.of({
       const queue = yield* _(Queue.unbounded<Worker.BackingWorker.Message<O>>())
       yield* _(Effect.addFinalizer(() => Queue.shutdown(queue)))
       const fiber = yield* _(
-        Effect.async<never, WorkerError, never>((resume) => {
+        Effect.async<never, WorkerError>((resume) => {
           worker.on("message", (message: Worker.BackingWorker.Message<O>) => {
             queue.unsafeOffer(message)
           })
@@ -60,15 +60,8 @@ export const layerWorker = Layer.succeed(Worker.PlatformWorker, platformWorkerIm
 export const layerManager = Layer.provide(Worker.layerManager, layerWorker)
 
 /** @internal */
-export const makePool = Worker.makePool<WorkerThreads.Worker>()
-
-/** @internal */
-export const makePoolLayer = Worker.makePoolLayer<WorkerThreads.Worker>(layerManager)
-
-/** @internal */
-export const makePoolSerialized = Worker.makePoolSerialized<WorkerThreads.Worker>()
-
-/** @internal */
-export const makePoolSerializedLayer = Worker.makePoolSerializedLayer<WorkerThreads.Worker>(
-  layerManager
-)
+export const layer = (spawn: (id: number) => WorkerThreads.Worker) =>
+  Layer.merge(
+    layerManager,
+    Worker.layerSpawner(spawn)
+  )

package/src/internal/workerRunner.ts

@@ -1,17 +1,15 @@
 import { WorkerError } from "@effect/platform/WorkerError"
 import * as Runner from "@effect/platform/WorkerRunner"
-import type * as Schema from "@effect/schema/Schema"
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Queue from "effect/Queue"
 import * as Schedule from "effect/Schedule"
-import type * as Stream from "effect/Stream"
 import * as WorkerThreads from "node:worker_threads"
 
 const platformRunnerImpl = Runner.PlatformRunner.of({
   [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
-  start<I, O>(shutdown: Effect.Effect<never, never, void>) {
+  start<I, O>(shutdown: Effect.Effect<void>) {
     return Effect.gen(function*(_) {
       if (!WorkerThreads.parentPort) {
         return yield* _(Effect.fail(WorkerError("spawn", "not in worker")))
@@ -19,7 +17,7 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
       const port = WorkerThreads.parentPort
       const queue = yield* _(Queue.unbounded<I>())
       yield* _(
-        Effect.async<never, WorkerError, never>((resume) => {
+        Effect.async<never, WorkerError>((resume) => {
           port.on("message", (message: Runner.BackingRunner.Message<I>) => {
             if (message[0] === 0) {
               queue.unsafeOffer(message[1])
@@ -53,25 +51,4 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
 })
 
 /** @internal */
-export const layerPlatform = Layer.succeed(Runner.PlatformRunner, platformRunnerImpl)
-
-/** @internal */
-export const layer = <I, R, E, O>(
-  process: (request: I) => Stream.Stream<R, E, O>,
-  options?: Runner.Runner.Options<I, E, O>
-): Layer.Layer<R, WorkerError, never> => Layer.provide(Runner.layer(process, options), layerPlatform)
-
-/** @internal */
-export const layerSerialized = <
-  R,
-  I,
-  A extends Schema.TaggedRequest.Any,
-  Handlers extends Runner.SerializedRunner.Handlers<A>
->(
-  schema: Schema.Schema<R, I, A>,
-  handlers: Handlers
-): Layer.Layer<
-  R | Runner.SerializedRunner.HandlersContext<Handlers>,
-  WorkerError,
-  never
-> => Layer.provide(Runner.layerSerialized(schema, handlers), layerPlatform)
+export const layer = Layer.succeed(Runner.PlatformRunner, platformRunnerImpl)

package/Command/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Command.js",
-  "module": "../dist/esm/Command.js",
-  "types": "../dist/dts/Command.d.ts",
-  "sideEffects": []
-}

package/CommandExecutor/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/CommandExecutor.js",
-  "module": "../dist/esm/CommandExecutor.js",
-  "types": "../dist/dts/CommandExecutor.d.ts",
-  "sideEffects": []
-}

package/Effectify/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Effectify.js",
-  "module": "../dist/esm/Effectify.js",
-  "types": "../dist/dts/Effectify.d.ts",
-  "sideEffects": []
-}

package/Error/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Error.js",
-  "module": "../dist/esm/Error.js",
-  "types": "../dist/dts/Error.d.ts",
-  "sideEffects": []
-}

package/FileSystem/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/FileSystem.js",
-  "module": "../dist/esm/FileSystem.js",
-  "types": "../dist/dts/FileSystem.d.ts",
-  "sideEffects": []
-}

package/Http/Etag/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../../dist/cjs/Http/Etag.js",
-  "module": "../../dist/esm/Http/Etag.js",
-  "types": "../../dist/dts/Http/Etag.d.ts",
-  "sideEffects": []
-}

package/Http/Multipart/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../../dist/cjs/Http/Multipart.js",
-  "module": "../../dist/esm/Http/Multipart.js",
-  "types": "../../dist/dts/Http/Multipart.d.ts",
-  "sideEffects": []
-}

package/Http/NodeClient/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../../dist/cjs/Http/NodeClient.js",
-  "module": "../../dist/esm/Http/NodeClient.js",
-  "types": "../../dist/dts/Http/NodeClient.d.ts",
-  "sideEffects": []
-}

package/HttpClient/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/HttpClient.js",
-  "module": "../dist/esm/HttpClient.js",
-  "types": "../dist/dts/HttpClient.d.ts",
-  "sideEffects": []
-}