@effect/platform-node 0.19.2 → 0.19.4

package/{mjs/internal/fileSystem.mjs → internal/fileSystem.esm.js}

@@ -1,21 +1,24 @@
-import { handleErrnoException } from "@effect/platform-node/internal/error";
-import { effectify } from "@effect/platform/Effectify";
-import * as Error from "@effect/platform/Error";
-import * as FileSystem from "@effect/platform/FileSystem";
-import * as Effect from "effect/Effect";
-import { pipe } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Crypto from "node:crypto";
-import * as NFS from "node:fs";
-import * as OS from "node:os";
-import * as Path from "node:path";
+import { effectify } from '@effect/platform/Effectify';
+import * as Error from '@effect/platform/Error';
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Effect from 'effect/Effect';
+import { pipe } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Crypto from 'node:crypto';
+import * as NFS from 'node:fs';
+import * as OS from 'node:os';
+import * as NodePath from 'node:path';
+import { handleErrnoException } from './error.esm.js';
+
 const handleBadArgument = method => err => Error.BadArgument({
   module: "FileSystem",
   method,
   message: err.message ?? String(err)
 });
+
 // == access
+
 const access = /*#__PURE__*/(() => {
   const nodeAccess = /*#__PURE__*/effectify(NFS.access, /*#__PURE__*/handleErrnoException("FileSystem", "access"), /*#__PURE__*/handleBadArgument("access"));
   return (path, options) => {
@@ -29,7 +32,9 @@ const access = /*#__PURE__*/(() => {
     return nodeAccess(path, mode);
   };
 })();
+
 // == copy
+
 const copy = /*#__PURE__*/(() => {
   const nodeCp = /*#__PURE__*/effectify(NFS.cp, /*#__PURE__*/handleErrnoException("FileSystem", "copy"), /*#__PURE__*/handleBadArgument("copy"));
   return (fromPath, toPath, options) => nodeCp(fromPath, toPath, {
@@ -38,27 +43,37 @@ const copy = /*#__PURE__*/(() => {
     recursive: true
   });
 })();
+
 // == copyFile
+
 const copyFile = /*#__PURE__*/(() => {
   const nodeCopyFile = /*#__PURE__*/effectify(NFS.copyFile, /*#__PURE__*/handleErrnoException("FileSystem", "copyFile"), /*#__PURE__*/handleBadArgument("copyFile"));
   return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);
 })();
+
 // == chmod
+
 const chmod = /*#__PURE__*/(() => {
   const nodeChmod = /*#__PURE__*/effectify(NFS.chmod, /*#__PURE__*/handleErrnoException("FileSystem", "chmod"), /*#__PURE__*/handleBadArgument("chmod"));
   return (path, mode) => nodeChmod(path, mode);
 })();
+
 // == chown
+
 const chown = /*#__PURE__*/(() => {
   const nodeChown = /*#__PURE__*/effectify(NFS.chown, /*#__PURE__*/handleErrnoException("FileSystem", "chown"), /*#__PURE__*/handleBadArgument("chown"));
   return (path, uid, gid) => nodeChown(path, uid, gid);
 })();
+
 // == link
+
 const link = /*#__PURE__*/(() => {
   const nodeLink = /*#__PURE__*/effectify(NFS.link, /*#__PURE__*/handleErrnoException("FileSystem", "link"), /*#__PURE__*/handleBadArgument("link"));
   return (existingPath, newPath) => nodeLink(existingPath, newPath);
 })();
+
 // == makeDirectory
+
 const makeDirectory = /*#__PURE__*/(() => {
   const nodeMkdir = /*#__PURE__*/effectify(NFS.mkdir, /*#__PURE__*/handleErrnoException("FileSystem", "makeDirectory"), /*#__PURE__*/handleBadArgument("makeDirectory"));
   return (path, options) => nodeMkdir(path, {
@@ -66,17 +81,21 @@ const makeDirectory = /*#__PURE__*/(() => {
     mode: options?.mode
   });
 })();
+
 // == makeTempDirectory
+
 const makeTempDirectoryFactory = method => {
   const nodeMkdtemp = effectify(NFS.mkdtemp, handleErrnoException("FileSystem", method), handleBadArgument(method));
   return options => Effect.suspend(() => {
     const prefix = options?.prefix ?? "";
-    const directory = typeof options?.directory === "string" ? Path.join(options.directory, ".") : OS.tmpdir();
-    return nodeMkdtemp(prefix ? Path.join(directory, prefix) : directory + "/");
+    const directory = typeof options?.directory === "string" ? NodePath.join(options.directory, ".") : OS.tmpdir();
+    return nodeMkdtemp(prefix ? NodePath.join(directory, prefix) : directory + "/");
   });
 };
 const makeTempDirectory = /*#__PURE__*/makeTempDirectoryFactory("makeTempDirectory");
+
 // == remove
+
 const removeFactory = method => {
   const nodeRm = effectify(NFS.rm, handleErrnoException("FileSystem", method), handleBadArgument(method));
   return (path, options) => nodeRm(path, {
@@ -84,7 +103,9 @@ const removeFactory = method => {
   });
 };
 const remove = /*#__PURE__*/removeFactory("remove");
+
 // == makeTempDirectoryScoped
+
 const makeTempDirectoryScoped = /*#__PURE__*/(() => {
   const makeDirectory = /*#__PURE__*/makeTempDirectoryFactory("makeTempDirectoryScoped");
   const removeDirectory = /*#__PURE__*/removeFactory("makeTempDirectoryScoped");
@@ -92,7 +113,9 @@ const makeTempDirectoryScoped = /*#__PURE__*/(() => {
     recursive: true
   })));
 })();
+
 // == open
+
 const openFactory = method => {
   const nodeOpen = effectify(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
   const nodeClose = effectify(NFS.close, handleErrnoException("FileSystem", method), handleBadArgument(method));
@@ -109,11 +132,11 @@ const makeFile = /*#__PURE__*/(() => {
   const nodeWrite = /*#__PURE__*/nodeWriteFactory("write");
   const nodeWriteAll = /*#__PURE__*/nodeWriteFactory("writeAll");
   class FileImpl {
+    semaphore = Effect.unsafeMakeSemaphore(1);
+    position = 0n;
     constructor(fd, append) {
       this.fd = fd;
       this.append = append;
-      this.semaphore = Effect.unsafeMakeSemaphore(1);
-      this.position = 0n;
       this[FileSystem.FileTypeId] = FileSystem.FileTypeId;
     }
     get stat() {
@@ -198,31 +221,38 @@ const makeFile = /*#__PURE__*/(() => {
       return this.semaphore.withPermits(1)(this.writeAllChunk(buffer));
     }
   }
-  FileSystem.FileTypeId;
   return (fd, append) => new FileImpl(fd, append);
 })();
+
 // == makeTempFile
+
 const makeTempFileFactory = method => {
   const makeDirectory = makeTempDirectoryFactory(method);
   const open = openFactory(method);
   const randomHexString = bytes => Effect.sync(() => Crypto.randomBytes(bytes).toString("hex"));
-  return options => pipe(Effect.zip(makeDirectory(options), randomHexString(6)), Effect.map(([directory, random]) => Path.join(directory, random)), Effect.tap(path => Effect.scoped(open(path, {
+  return options => pipe(Effect.zip(makeDirectory(options), randomHexString(6)), Effect.map(([directory, random]) => NodePath.join(directory, random)), Effect.tap(path => Effect.scoped(open(path, {
     flag: "w+"
   }))));
 };
 const makeTempFile = /*#__PURE__*/makeTempFileFactory("makeTempFile");
+
 // == makeTempFileScoped
+
 const makeTempFileScoped = /*#__PURE__*/(() => {
   const makeFile = /*#__PURE__*/makeTempFileFactory("makeTempFileScoped");
   const removeFile = /*#__PURE__*/removeFactory("makeTempFileScoped");
   return options => Effect.acquireRelease(makeFile(options), file => Effect.orDie(removeFile(file)));
 })();
+
 // == readDirectory
+
 const readDirectory = /*#__PURE__*/(() => {
   const nodeReadDirectory = /*#__PURE__*/effectify(NFS.readdir, /*#__PURE__*/handleErrnoException("FileSystem", "readDirectory"), /*#__PURE__*/handleBadArgument("readDirectory"));
   return (path, options) => nodeReadDirectory(path, options);
 })();
+
 // == readFile
+
 const readFile = path => Effect.async((resume, signal) => {
   try {
     NFS.readFile(path, {
@@ -238,22 +268,30 @@ const readFile = path => Effect.async((resume, signal) => {
     resume(Effect.fail(handleBadArgument("readFile")(err)));
   }
 });
+
 // == readLink
+
 const readLink = /*#__PURE__*/(() => {
   const nodeReadLink = /*#__PURE__*/effectify(NFS.readlink, /*#__PURE__*/handleErrnoException("FileSystem", "readLink"), /*#__PURE__*/handleBadArgument("readLink"));
   return path => nodeReadLink(path);
 })();
+
 // == realPath
+
 const realPath = /*#__PURE__*/(() => {
   const nodeRealPath = /*#__PURE__*/effectify(NFS.realpath, /*#__PURE__*/handleErrnoException("FileSystem", "realPath"), /*#__PURE__*/handleBadArgument("realPath"));
   return path => nodeRealPath(path);
 })();
+
 // == rename
+
 const rename = /*#__PURE__*/(() => {
   const nodeRename = /*#__PURE__*/effectify(NFS.rename, /*#__PURE__*/handleErrnoException("FileSystem", "rename"), /*#__PURE__*/handleBadArgument("rename"));
   return (oldPath, newPath) => nodeRename(oldPath, newPath);
 })();
+
 // == stat
+
 const makeFileInfo = stat => ({
   type: stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : stat.isBlockDevice() ? "BlockDevice" : stat.isCharacterDevice() ? "CharacterDevice" : stat.isFIFO() ? "FIFO" : stat.isSocket() ? "Socket" : "Unknown",
   mtime: Option.fromNullable(stat.mtime),
@@ -274,22 +312,30 @@ const stat = /*#__PURE__*/(() => {
   const nodeStat = /*#__PURE__*/effectify(NFS.stat, /*#__PURE__*/handleErrnoException("FileSystem", "stat"), /*#__PURE__*/handleBadArgument("stat"));
   return path => Effect.map(nodeStat(path), makeFileInfo);
 })();
+
 // == symlink
+
 const symlink = /*#__PURE__*/(() => {
   const nodeSymlink = /*#__PURE__*/effectify(NFS.symlink, /*#__PURE__*/handleErrnoException("FileSystem", "symlink"), /*#__PURE__*/handleBadArgument("symlink"));
   return (target, path) => nodeSymlink(target, path);
 })();
+
 // == truncate
+
 const truncate = /*#__PURE__*/(() => {
   const nodeTruncate = /*#__PURE__*/effectify(NFS.truncate, /*#__PURE__*/handleErrnoException("FileSystem", "truncate"), /*#__PURE__*/handleBadArgument("truncate"));
   return (path, length) => nodeTruncate(path, length !== undefined ? Number(length) : undefined);
 })();
+
 // == utimes
+
 const utimes = /*#__PURE__*/(() => {
   const nodeUtimes = /*#__PURE__*/effectify(NFS.utimes, /*#__PURE__*/handleErrnoException("FileSystem", "utime"), /*#__PURE__*/handleBadArgument("utime"));
   return (path, atime, mtime) => nodeUtimes(path, atime, mtime);
 })();
+
 // == writeFile
+
 const writeFile = (path, data, options) => Effect.async((resume, signal) => {
   try {
     NFS.writeFile(path, data, {
@@ -332,6 +378,8 @@ const fileSystemImpl = /*#__PURE__*/FileSystem.make({
   utimes,
   writeFile
 });
+
 /** @internal */
-export const layer = /*#__PURE__*/Layer.succeed(FileSystem.FileSystem, fileSystemImpl);
-//# sourceMappingURL=fileSystem.mjs.map
+const layer = /*#__PURE__*/Layer.succeed(FileSystem.FileSystem, fileSystemImpl);
+
+export { layer };

package/{mjs/internal/http/etag.mjs → internal/http/etag.esm.js}

@@ -1,6 +1,7 @@
-import * as Etag from "@effect/platform/Http/Etag";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
+import * as Etag from '@effect/platform/Http/Etag';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
 const fromFileInfo = info => {
   const mtime = info.mtime._tag === "Some" ? info.mtime.value.getTime().toString(16) : "0";
   return `${info.size.toString(16)}-${mtime}`;
@@ -8,8 +9,9 @@ const fromFileInfo = info => {
 const fromFileWeb = file => {
   return `${file.size.toString(16)}-${file.lastModified.toString(16)}`;
 };
+
 /** @internal */
-export const layer = /*#__PURE__*/Layer.succeed(Etag.Generator, /*#__PURE__*/Etag.Generator.of({
+const layer = /*#__PURE__*/Layer.succeed(Etag.Generator, /*#__PURE__*/Etag.Generator.of({
   [Etag.GeneratorTypeId]: Etag.GeneratorTypeId,
   fromFileInfo(info) {
     return Effect.sync(() => ({
@@ -24,8 +26,9 @@ export const layer = /*#__PURE__*/Layer.succeed(Etag.Generator, /*#__PURE__*/Eta
     }));
   }
 }));
+
 /** @internal */
-export const layerWeak = /*#__PURE__*/Layer.succeed(Etag.Generator, /*#__PURE__*/Etag.Generator.of({
+const layerWeak = /*#__PURE__*/Layer.succeed(Etag.Generator, /*#__PURE__*/Etag.Generator.of({
   [Etag.GeneratorTypeId]: Etag.GeneratorTypeId,
   fromFileInfo(info) {
     return Effect.sync(() => ({
@@ -40,4 +43,5 @@ export const layerWeak = /*#__PURE__*/Layer.succeed(Etag.Generator, /*#__PURE__*
     }));
   }
 }));
-//# sourceMappingURL=etag.mjs.map
+
+export { layer, layerWeak };

package/{mjs/internal/http/formData.mjs → internal/http/formData.esm.js}

@@ -1,17 +1,18 @@
-import * as NodeStream from "@effect/platform-node/Stream";
-import * as FileSystem from "@effect/platform/FileSystem";
-import * as FormData from "@effect/platform/Http/FormData";
-import * as Path from "@effect/platform/Path";
-import Busboy from "busboy";
-import * as Chunk from "effect/Chunk";
-import * as Effect from "effect/Effect";
-import * as FiberRef from "effect/FiberRef";
-import { pipe } from "effect/Function";
-import * as Option from "effect/Option";
-import * as Stream from "effect/Stream";
-import * as NodeFs from "node:fs";
-import * as NodeStreamP from "node:stream/promises";
-export const stream = (source, headers) => pipe(Effect.Do, Effect.bind("maxParts", () => FiberRef.get(FormData.maxParts)), Effect.bind("maxFields", () => FiberRef.get(FormData.maxFields)), Effect.bind("maxFiles", () => FiberRef.get(FormData.maxFiles)), Effect.bind("fieldMimeTypes", () => FiberRef.get(FormData.fieldMimeTypes)), Effect.bind("maxFieldSize", () => FiberRef.get(FormData.maxFieldSize)), Effect.bind("maxFileSize", () => FiberRef.get(FormData.maxFileSize)), Effect.bind("busboy", ({
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as FormData from '@effect/platform/Http/FormData';
+import * as Path from '@effect/platform/Path';
+import Busboy from 'busboy';
+import * as Chunk from 'effect/Chunk';
+import * as Effect from 'effect/Effect';
+import * as FiberRef from 'effect/FiberRef';
+import { pipe } from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Stream from 'effect/Stream';
+import * as NFS from 'node:fs';
+import * as NodeStreamP from 'node:stream/promises';
+import { fromReadable, toString } from '../../Stream/dist/effect-platform-node-Stream.esm.js';
+
+const stream = (source, headers) => pipe(Effect.Do, Effect.bind("maxParts", () => FiberRef.get(FormData.maxParts)), Effect.bind("maxFields", () => FiberRef.get(FormData.maxFields)), Effect.bind("maxFiles", () => FiberRef.get(FormData.maxFiles)), Effect.bind("fieldMimeTypes", () => FiberRef.get(FormData.fieldMimeTypes)), Effect.bind("maxFieldSize", () => FiberRef.get(FormData.maxFieldSize)), Effect.bind("maxFileSize", () => FiberRef.get(FormData.maxFileSize)), Effect.bind("busboy", ({
   maxFieldSize,
   maxFields,
   maxFileSize,
@@ -46,7 +47,7 @@ export const stream = (source, headers) => pipe(Effect.Do, Effect.bind("maxParts
     stream.once("limit", () => {
       emit.fail(FormData.FormDataError("FileTooLarge", new Error("maxFileSize exceeded")));
     });
-    emit.single(new FileImpl(name, info.filename, info.mimeType, NodeStream.fromReadable(() => stream, error => FormData.FormDataError("InternalError", error)), stream));
+    emit.single(new FileImpl(name, info.filename, info.mimeType, fromReadable(() => stream, error => FormData.FormDataError("InternalError", error)), stream));
   });
   busboy.on("error", _ => {
     emit.fail(FormData.FormDataError("InternalError", _));
@@ -55,34 +56,33 @@ export const stream = (source, headers) => pipe(Effect.Do, Effect.bind("maxParts
     emit.end();
   });
   source.pipe(busboy);
-}), part => part._tag === "File" && Chunk.some(fieldMimeTypes, _ => part.contentType.includes(_)) ? Effect.map(NodeStream.toString({
+}), part => part._tag === "File" && Chunk.some(fieldMimeTypes, _ => part.contentType.includes(_)) ? Effect.map(toString({
   readable: () => part.source,
   onFailure: error => FormData.FormDataError("InternalError", error)
 }), content => new FieldImpl(part.key, part.contentType, content)) : Effect.succeed(part))), Stream.unwrapScoped);
 class FieldImpl {
+  _tag = "Field";
   constructor(key, contentType, value) {
     this.key = key;
     this.contentType = contentType;
     this.value = value;
-    this._tag = "Field";
     this[FormData.TypeId] = FormData.TypeId;
   }
 }
-FormData.TypeId;
 class FileImpl {
+  _tag = "File";
   constructor(key, name, contentType, content, source) {
     this.key = key;
     this.name = name;
     this.contentType = contentType;
     this.content = content;
     this.source = source;
-    this._tag = "File";
     this[FormData.TypeId] = FormData.TypeId;
   }
 }
-FormData.TypeId;
+
 /** @internal */
-export const formData = (source, headers) => Effect.flatMap(Effect.all([Effect.mapError(Effect.flatMap(FileSystem.FileSystem, fs => fs.makeTempDirectoryScoped()), error => FormData.FormDataError("InternalError", error)), Path.Path]), ([dir, path_]) => Stream.runFoldEffect(stream(source, headers), new globalThis.FormData(), (formData, part) => {
+const formData = (source, headers) => Effect.flatMap(Effect.all([Effect.mapError(Effect.flatMap(FileSystem.FileSystem, fs => fs.makeTempDirectoryScoped()), error => FormData.FormDataError("InternalError", error)), Path.Path]), ([dir, path_]) => Stream.runFoldEffect(stream(source, headers), new globalThis.FormData(), (formData, part) => {
   if (part._tag === "Field") {
     formData.append(part.key, part.value);
     return Effect.succeed(formData);
@@ -96,10 +96,11 @@ export const formData = (source, headers) => Effect.flatMap(Effect.all([Effect.m
   });
   formData.append(part.key, blob, path);
   return Effect.as(Effect.tryPromise({
-    try: signal => NodeStreamP.pipeline(file.source, NodeFs.createWriteStream(path), {
+    try: signal => NodeStreamP.pipeline(file.source, NFS.createWriteStream(path), {
       signal
     }),
     catch: error => FormData.FormDataError("InternalError", error)
   }), formData);
 }));
-//# sourceMappingURL=formData.mjs.map
+
+export { formData, stream };

package/{mjs/internal/http/incomingMessage.mjs → internal/http/incomingMessage.esm.js}

@@ -1,12 +1,13 @@
-import * as NodeStream from "@effect/platform-node/Stream";
-import * as Headers from "@effect/platform/Http/Headers";
-import * as IncomingMessage from "@effect/platform/Http/IncomingMessage";
-import * as UrlParams from "@effect/platform/Http/UrlParams";
-import * as Effect from "effect/Effect";
-import * as FiberRef from "effect/FiberRef";
-import * as Option from "effect/Option";
+import * as Headers from '@effect/platform/Http/Headers';
+import * as IncomingMessage from '@effect/platform/Http/IncomingMessage';
+import * as UrlParams from '@effect/platform/Http/UrlParams';
+import * as Effect from 'effect/Effect';
+import * as FiberRef from 'effect/FiberRef';
+import * as Option from 'effect/Option';
+import { toString, fromReadable, toUint8Array } from '../../Stream/dist/effect-platform-node-Stream.esm.js';
+
 /** @internal */
-export class IncomingMessageImpl {
+class IncomingMessageImpl {
   constructor(source, onError, remoteAddressOverride) {
     this.source = source;
     this.onError = onError;
@@ -23,7 +24,7 @@ export class IncomingMessageImpl {
     if (this.textEffect) {
       return this.textEffect;
     }
-    this.textEffect = Effect.runSync(Effect.cached(Effect.flatMap(FiberRef.get(IncomingMessage.maxBodySize), maxBodySize => NodeStream.toString({
+    this.textEffect = Effect.runSync(Effect.cached(Effect.flatMap(FiberRef.get(IncomingMessage.maxBodySize), maxBodySize => toString({
       readable: () => this.source,
       onFailure: this.onError,
       maxBytes: Option.getOrUndefined(maxBodySize)
@@ -43,15 +44,15 @@ export class IncomingMessageImpl {
     }));
   }
   get stream() {
-    return NodeStream.fromReadable(() => this.source, this.onError);
+    return fromReadable(() => this.source, this.onError);
   }
   get arrayBuffer() {
-    return Effect.flatMap(FiberRef.get(IncomingMessage.maxBodySize), maxBodySize => NodeStream.toUint8Array({
+    return Effect.flatMap(FiberRef.get(IncomingMessage.maxBodySize), maxBodySize => toUint8Array({
       readable: () => this.source,
       onFailure: this.onError,
       maxBytes: Option.getOrUndefined(maxBodySize)
     }));
   }
 }
-IncomingMessage.TypeId;
-//# sourceMappingURL=incomingMessage.mjs.map
+
+export { IncomingMessageImpl };

package/{mjs/internal/http/nodeClient.mjs → internal/http/nodeClient.esm.js}

@@ -1,32 +1,37 @@
-import { IncomingMessageImpl } from "@effect/platform-node/internal/http/incomingMessage";
-import * as NodeSink from "@effect/platform-node/Sink";
-import * as Client from "@effect/platform/Http/Client";
-import * as Error from "@effect/platform/Http/ClientError";
-import * as ClientResponse from "@effect/platform/Http/ClientResponse";
-import * as UrlParams from "@effect/platform/Http/UrlParams";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import { pipe } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Stream from "effect/Stream";
-import * as Http from "node:http";
-import * as Https from "node:https";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
+import * as Client from '@effect/platform/Http/Client';
+import * as Error from '@effect/platform/Http/ClientError';
+import * as ClientResponse from '@effect/platform/Http/ClientResponse';
+import * as UrlParams from '@effect/platform/Http/UrlParams';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import { pipe } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Stream from 'effect/Stream';
+import * as Http from 'node:http';
+import * as Https from 'node:https';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { fromWritable } from '../../Sink/dist/effect-platform-node-Sink.esm.js';
+import { IncomingMessageImpl } from './incomingMessage.esm.js';
+
 /** @internal */
-export const HttpAgentTypeId = /*#__PURE__*/Symbol.for("@effect/platform-node/Http/NodeClient/HttpAgent");
+const HttpAgentTypeId = /*#__PURE__*/Symbol.for("@effect/platform-node/Http/NodeClient/HttpAgent");
+
 /** @internal */
-export const HttpAgent = /*#__PURE__*/Context.Tag(HttpAgentTypeId);
+const HttpAgent = /*#__PURE__*/Context.Tag(HttpAgentTypeId);
+
 /** @internal */
-export const makeAgent = options => Effect.map(Effect.all([Effect.acquireRelease(Effect.sync(() => new Http.Agent(options)), agent => Effect.sync(() => agent.destroy())), Effect.acquireRelease(Effect.sync(() => new Https.Agent(options)), agent => Effect.sync(() => agent.destroy()))]), ([http, https]) => ({
+const makeAgent = options => Effect.map(Effect.all([Effect.acquireRelease(Effect.sync(() => new Http.Agent(options)), agent => Effect.sync(() => agent.destroy())), Effect.acquireRelease(Effect.sync(() => new Https.Agent(options)), agent => Effect.sync(() => agent.destroy()))]), ([http, https]) => ({
   [HttpAgentTypeId]: HttpAgentTypeId,
   http,
   https
 }));
+
 /** @internal */
-export const makeAgentLayer = options => Layer.scoped(HttpAgent, makeAgent(options));
+const makeAgentLayer = options => Layer.scoped(HttpAgent, makeAgent(options));
+
 /** @internal */
-export const agentLayer = /*#__PURE__*/makeAgentLayer();
+const agentLayer = /*#__PURE__*/makeAgentLayer();
 const fromAgent = agent => Client.make(request => Effect.flatMap(UrlParams.makeUrl(request.url, request.urlParams, _ => Error.RequestError({
   request,
   reason: "InvalidUrl",
@@ -82,7 +87,7 @@ const sendBody = (nodeRequest, request, body) => Effect.suspend(() => {
           request,
           reason: "Encode",
           error: _
-        })), NodeSink.fromWritable(() => nodeRequest, _ => Error.RequestError({
+        })), fromWritable(() => nodeRequest, _ => Error.RequestError({
           request,
           reason: "Transport",
           error: _
@@ -149,11 +154,14 @@ class ClientResponseImpl extends IncomingMessageImpl {
     };
   }
 }
-ClientResponse.TypeId;
+
 /** @internal */
-export const make = /*#__PURE__*/Effect.map(HttpAgent, fromAgent);
+const make = /*#__PURE__*/Effect.map(HttpAgent, fromAgent);
+
 /** @internal */
-export const layerWithoutAgent = /*#__PURE__*/Layer.effect(Client.Client, make);
+const layerWithoutAgent = /*#__PURE__*/Layer.effect(Client.Client, make);
+
 /** @internal */
-export const layer = /*#__PURE__*/Layer.provide(agentLayer, layerWithoutAgent);
-//# sourceMappingURL=nodeClient.mjs.map
+const layer = /*#__PURE__*/Layer.provide(agentLayer, layerWithoutAgent);
+
+export { HttpAgent, HttpAgentTypeId, agentLayer, layer, layerWithoutAgent, make, makeAgent, makeAgentLayer };

package/{mjs/internal/http/platform.mjs → internal/http/platform.esm.js}

@@ -1,16 +1,17 @@
-import * as FileSystem from "@effect/platform-node/FileSystem";
-import * as Etag from "@effect/platform-node/Http/Etag";
-import * as Platform from "@effect/platform/Http/Platform";
-import * as ServerResponse from "@effect/platform/Http/ServerResponse";
-import { pipe } from "effect/Function";
-import * as Layer from "effect/Layer";
-import Mime from "mime";
-import * as Fs from "node:fs";
-import { Readable } from "node:stream";
+import * as Platform from '@effect/platform/Http/Platform';
+import * as ServerResponse from '@effect/platform/Http/ServerResponse';
+import { pipe } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import Mime from 'mime';
+import * as NFS from 'node:fs';
+import { Readable } from 'node:stream';
+import { layer as layer$1 } from '../../FileSystem/dist/effect-platform-node-FileSystem.esm.js';
+import { layer as layer$2 } from '../../Http/Http/Etag/dist/effect-platform-node-Http-Etag.esm.js';
+
 /** @internal */
-export const make = /*#__PURE__*/Platform.make({
+const make = /*#__PURE__*/Platform.make({
   fileResponse(path, status, statusText, headers, start, end, contentLength) {
-    const stream = Fs.createReadStream(path, {
+    const stream = NFS.createReadStream(path, {
       start,
       end
     });
@@ -36,6 +37,8 @@ export const make = /*#__PURE__*/Platform.make({
     });
   }
 });
+
 /** @internal */
-export const layer = /*#__PURE__*/pipe( /*#__PURE__*/Layer.effect(Platform.Platform, make), /*#__PURE__*/Layer.use(FileSystem.layer), /*#__PURE__*/Layer.use(Etag.layer));
-//# sourceMappingURL=platform.mjs.map
+const layer = /*#__PURE__*/pipe( /*#__PURE__*/Layer.effect(Platform.Platform, make), /*#__PURE__*/Layer.use(layer$1), /*#__PURE__*/Layer.use(layer$2));
+
+export { layer, make };