effect-start 0.17.2 → 0.19.0

package/dist/node/Effectify.d.ts

@@ -0,0 +1,209 @@
+import * as Effect from "effect/Effect";
+interface Callback<E, A> {
+    (err: E, a?: A): void;
+}
+type ArgsWithCallback<Args extends Array<any>, E, A> = [...args: Args, cb: Callback<E, A>];
+type WithoutNull<A> = unknown extends A ? void : Exclude<A, null | undefined>;
+type Effectify<T, E> = T extends {
+    (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;
+    (...args: ArgsWithCallback<infer Args2, infer _E2, infer A2>): infer _R2;
+    (...args: ArgsWithCallback<infer Args3, infer _E3, infer A3>): infer _R3;
+    (...args: ArgsWithCallback<infer Args4, infer _E4, infer A4>): infer _R4;
+    (...args: ArgsWithCallback<infer Args5, infer _E5, infer A5>): infer _R5;
+    (...args: ArgsWithCallback<infer Args6, infer _E6, infer A6>): infer _R6;
+    (...args: ArgsWithCallback<infer Args7, infer _E7, infer A7>): infer _R7;
+    (...args: ArgsWithCallback<infer Args8, infer _E8, infer A8>): infer _R8;
+    (...args: ArgsWithCallback<infer Args9, infer _E9, infer A9>): infer _R9;
+    (...args: ArgsWithCallback<infer Args10, infer _E10, infer A10>): infer _R10;
+} ? {
+    (...args: Args1): Effect.Effect<WithoutNull<A1>, E>;
+    (...args: Args2): Effect.Effect<WithoutNull<A2>, E>;
+    (...args: Args3): Effect.Effect<WithoutNull<A3>, E>;
+    (...args: Args4): Effect.Effect<WithoutNull<A4>, E>;
+    (...args: Args5): Effect.Effect<WithoutNull<A5>, E>;
+    (...args: Args6): Effect.Effect<WithoutNull<A6>, E>;
+    (...args: Args7): Effect.Effect<WithoutNull<A7>, E>;
+    (...args: Args8): Effect.Effect<WithoutNull<A8>, E>;
+    (...args: Args9): Effect.Effect<WithoutNull<A9>, E>;
+    (...args: Args10): Effect.Effect<WithoutNull<A10>, E>;
+} : T extends {
+    (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;
+    (...args: ArgsWithCallback<infer Args2, infer _E2, infer A2>): infer _R2;
+    (...args: ArgsWithCallback<infer Args3, infer _E3, infer A3>): infer _R3;
+    (...args: ArgsWithCallback<infer Args4, infer _E4, infer A4>): infer _R4;
+    (...args: ArgsWithCallback<infer Args5, infer _E5, infer A5>): infer _R5;
+    (...args: ArgsWithCallback<infer Args6, infer _E6, infer A6>): infer _R6;
+    (...args: ArgsWithCallback<infer Args7, infer _E7, infer A7>): infer _R7;
+    (...args: ArgsWithCallback<infer Args8, infer _E8, infer A8>): infer _R8;
+    (...args: ArgsWithCallback<infer Args9, infer _E9, infer A9>): infer _R9;
+} ? {
+    (...args: Args1): Effect.Effect<WithoutNull<A1>, E>;
+    (...args: Args2): Effect.Effect<WithoutNull<A2>, E>;
+    (...args: Args3): Effect.Effect<WithoutNull<A3>, E>;
+    (...args: Args4): Effect.Effect<WithoutNull<A4>, E>;
+    (...args: Args5): Effect.Effect<WithoutNull<A5>, E>;
+    (...args: Args6): Effect.Effect<WithoutNull<A6>, E>;
+    (...args: Args7): Effect.Effect<WithoutNull<A7>, E>;
+    (...args: Args8): Effect.Effect<WithoutNull<A8>, E>;
+    (...args: Args9): Effect.Effect<WithoutNull<A9>, E>;
+} : T extends {
+    (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;
+    (...args: ArgsWithCallback<infer Args2, infer _E2, infer A2>): infer _R2;
+    (...args: ArgsWithCallback<infer Args3, infer _E3, infer A3>): infer _R3;
+    (...args: ArgsWithCallback<infer Args4, infer _E4, infer A4>): infer _R4;
+    (...args: ArgsWithCallback<infer Args5, infer _E5, infer A5>): infer _R5;
+    (...args: ArgsWithCallback<infer Args6, infer _E6, infer A6>): infer _R6;
+    (...args: ArgsWithCallback<infer Args7, infer _E7, infer A7>): infer _R7;
+    (...args: ArgsWithCallback<infer Args8, infer _E8, infer A8>): infer _R8;
+} ? {
+    (...args: Args1): Effect.Effect<WithoutNull<A1>, E>;
+    (...args: Args2): Effect.Effect<WithoutNull<A2>, E>;
+    (...args: Args3): Effect.Effect<WithoutNull<A3>, E>;
+    (...args: Args4): Effect.Effect<WithoutNull<A4>, E>;
+    (...args: Args5): Effect.Effect<WithoutNull<A5>, E>;
+    (...args: Args6): Effect.Effect<WithoutNull<A6>, E>;
+    (...args: Args7): Effect.Effect<WithoutNull<A7>, E>;
+    (...args: Args8): Effect.Effect<WithoutNull<A8>, E>;
+} : T extends {
+    (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;
+    (...args: ArgsWithCallback<infer Args2, infer _E2, infer A2>): infer _R2;
+    (...args: ArgsWithCallback<infer Args3, infer _E3, infer A3>): infer _R3;
+    (...args: ArgsWithCallback<infer Args4, infer _E4, infer A4>): infer _R4;
+    (...args: ArgsWithCallback<infer Args5, infer _E5, infer A5>): infer _R5;
+    (...args: ArgsWithCallback<infer Args6, infer _E6, infer A6>): infer _R6;
+    (...args: ArgsWithCallback<infer Args7, infer _E7, infer A7>): infer _R7;
+} ? {
+    (...args: Args1): Effect.Effect<WithoutNull<A1>, E>;
+    (...args: Args2): Effect.Effect<WithoutNull<A2>, E>;
+    (...args: Args3): Effect.Effect<WithoutNull<A3>, E>;
+    (...args: Args4): Effect.Effect<WithoutNull<A4>, E>;
+    (...args: Args5): Effect.Effect<WithoutNull<A5>, E>;
+    (...args: Args6): Effect.Effect<WithoutNull<A6>, E>;
+    (...args: Args7): Effect.Effect<WithoutNull<A7>, E>;
+} : T extends {
+    (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;
+    (...args: ArgsWithCallback<infer Args2, infer _E2, infer A2>): infer _R2;
+    (...args: ArgsWithCallback<infer Args3, infer _E3, infer A3>): infer _R3;
+    (...args: ArgsWithCallback<infer Args4, infer _E4, infer A4>): infer _R4;
+    (...args: ArgsWithCallback<infer Args5, infer _E5, infer A5>): infer _R5;
+    (...args: ArgsWithCallback<infer Args6, infer _E6, infer A6>): infer _R6;
+} ? {
+    (...args: Args1): Effect.Effect<WithoutNull<A1>, E>;
+    (...args: Args2): Effect.Effect<WithoutNull<A2>, E>;
+    (...args: Args3): Effect.Effect<WithoutNull<A3>, E>;
+    (...args: Args4): Effect.Effect<WithoutNull<A4>, E>;
+    (...args: Args5): Effect.Effect<WithoutNull<A5>, E>;
+    (...args: Args6): Effect.Effect<WithoutNull<A6>, E>;
+} : T extends {
+    (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;
+    (...args: ArgsWithCallback<infer Args2, infer _E2, infer A2>): infer _R2;
+    (...args: ArgsWithCallback<infer Args3, infer _E3, infer A3>): infer _R3;
+    (...args: ArgsWithCallback<infer Args4, infer _E4, infer A4>): infer _R4;
+    (...args: ArgsWithCallback<infer Args5, infer _E5, infer A5>): infer _R5;
+} ? {
+    (...args: Args1): Effect.Effect<WithoutNull<A1>, E>;
+    (...args: Args2): Effect.Effect<WithoutNull<A2>, E>;
+    (...args: Args3): Effect.Effect<WithoutNull<A3>, E>;
+    (...args: Args4): Effect.Effect<WithoutNull<A4>, E>;
+    (...args: Args5): Effect.Effect<WithoutNull<A5>, E>;
+} : T extends {
+    (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;
+    (...args: ArgsWithCallback<infer Args2, infer _E2, infer A2>): infer _R2;
+    (...args: ArgsWithCallback<infer Args3, infer _E3, infer A3>): infer _R3;
+    (...args: ArgsWithCallback<infer Args4, infer _E4, infer A4>): infer _R4;
+} ? {
+    (...args: Args1): Effect.Effect<WithoutNull<A1>, E>;
+    (...args: Args2): Effect.Effect<WithoutNull<A2>, E>;
+    (...args: Args3): Effect.Effect<WithoutNull<A3>, E>;
+    (...args: Args4): Effect.Effect<WithoutNull<A4>, E>;
+} : T extends {
+    (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;
+    (...args: ArgsWithCallback<infer Args2, infer _E2, infer A2>): infer _R2;
+    (...args: ArgsWithCallback<infer Args3, infer _E3, infer A3>): infer _R3;
+} ? {
+    (...args: Args1): Effect.Effect<WithoutNull<A1>, E>;
+    (...args: Args2): Effect.Effect<WithoutNull<A2>, E>;
+    (...args: Args3): Effect.Effect<WithoutNull<A3>, E>;
+} : T extends {
+    (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;
+    (...args: ArgsWithCallback<infer Args2, infer _E2, infer A2>): infer _R2;
+} ? {
+    (...args: Args1): Effect.Effect<WithoutNull<A1>, E>;
+    (...args: Args2): Effect.Effect<WithoutNull<A2>, E>;
+} : T extends {
+    (...args: ArgsWithCallback<infer Args1, infer _E1, infer A1>): infer _R1;
+} ? {
+    (...args: Args1): Effect.Effect<WithoutNull<A1>, E>;
+} : never;
+type EffectifyError<T> = T extends {
+    (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
+    (...args: ArgsWithCallback<infer _Args2, infer E2, infer _A2>): infer _R2;
+    (...args: ArgsWithCallback<infer _Args3, infer E3, infer _A3>): infer _R3;
+    (...args: ArgsWithCallback<infer _Args4, infer E4, infer _A4>): infer _R4;
+    (...args: ArgsWithCallback<infer _Args5, infer E5, infer _A5>): infer _R5;
+    (...args: ArgsWithCallback<infer _Args6, infer E6, infer _A6>): infer _R6;
+    (...args: ArgsWithCallback<infer _Args7, infer E7, infer _A7>): infer _R7;
+    (...args: ArgsWithCallback<infer _Args8, infer E8, infer _A8>): infer _R8;
+    (...args: ArgsWithCallback<infer _Args9, infer E9, infer _A9>): infer _R9;
+    (...args: ArgsWithCallback<infer _Args10, infer E10, infer _A10>): infer _R10;
+} ? NonNullable<E1 | E2 | E3 | E4 | E5 | E6 | E7 | E8 | E9 | E10> : T extends {
+    (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
+    (...args: ArgsWithCallback<infer _Args2, infer E2, infer _A2>): infer _R2;
+    (...args: ArgsWithCallback<infer _Args3, infer E3, infer _A3>): infer _R3;
+    (...args: ArgsWithCallback<infer _Args4, infer E4, infer _A4>): infer _R4;
+    (...args: ArgsWithCallback<infer _Args5, infer E5, infer _A5>): infer _R5;
+    (...args: ArgsWithCallback<infer _Args6, infer E6, infer _A6>): infer _R6;
+    (...args: ArgsWithCallback<infer _Args7, infer E7, infer _A7>): infer _R7;
+    (...args: ArgsWithCallback<infer _Args8, infer E8, infer _A8>): infer _R8;
+    (...args: ArgsWithCallback<infer _Args9, infer E9, infer _A9>): infer _R9;
+} ? NonNullable<E1 | E2 | E3 | E4 | E5 | E6 | E7 | E8 | E9> : T extends {
+    (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
+    (...args: ArgsWithCallback<infer _Args2, infer E2, infer _A2>): infer _R2;
+    (...args: ArgsWithCallback<infer _Args3, infer E3, infer _A3>): infer _R3;
+    (...args: ArgsWithCallback<infer _Args4, infer E4, infer _A4>): infer _R4;
+    (...args: ArgsWithCallback<infer _Args5, infer E5, infer _A5>): infer _R5;
+    (...args: ArgsWithCallback<infer _Args6, infer E6, infer _A6>): infer _R6;
+    (...args: ArgsWithCallback<infer _Args7, infer E7, infer _A7>): infer _R7;
+    (...args: ArgsWithCallback<infer _Args8, infer E8, infer _A8>): infer _R8;
+} ? NonNullable<E1 | E2 | E3 | E4 | E5 | E6 | E7 | E8> : T extends {
+    (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
+    (...args: ArgsWithCallback<infer _Args2, infer E2, infer _A2>): infer _R2;
+    (...args: ArgsWithCallback<infer _Args3, infer E3, infer _A3>): infer _R3;
+    (...args: ArgsWithCallback<infer _Args4, infer E4, infer _A4>): infer _R4;
+    (...args: ArgsWithCallback<infer _Args5, infer E5, infer _A5>): infer _R5;
+    (...args: ArgsWithCallback<infer _Args6, infer E6, infer _A6>): infer _R6;
+    (...args: ArgsWithCallback<infer _Args7, infer E7, infer _A7>): infer _R7;
+} ? NonNullable<E1 | E2 | E3 | E4 | E5 | E6 | E7> : T extends {
+    (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
+    (...args: ArgsWithCallback<infer _Args2, infer E2, infer _A2>): infer _R2;
+    (...args: ArgsWithCallback<infer _Args3, infer E3, infer _A3>): infer _R3;
+    (...args: ArgsWithCallback<infer _Args4, infer E4, infer _A4>): infer _R4;
+    (...args: ArgsWithCallback<infer _Args5, infer E5, infer _A5>): infer _R5;
+    (...args: ArgsWithCallback<infer _Args6, infer E6, infer _A6>): infer _R6;
+} ? NonNullable<E1 | E2 | E3 | E4 | E5 | E6> : T extends {
+    (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
+    (...args: ArgsWithCallback<infer _Args2, infer E2, infer _A2>): infer _R2;
+    (...args: ArgsWithCallback<infer _Args3, infer E3, infer _A3>): infer _R3;
+    (...args: ArgsWithCallback<infer _Args4, infer E4, infer _A4>): infer _R4;
+    (...args: ArgsWithCallback<infer _Args5, infer E5, infer _A5>): infer _R5;
+} ? NonNullable<E1 | E2 | E3 | E4 | E5> : T extends {
+    (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
+    (...args: ArgsWithCallback<infer _Args2, infer E2, infer _A2>): infer _R2;
+    (...args: ArgsWithCallback<infer _Args3, infer E3, infer _A3>): infer _R3;
+    (...args: ArgsWithCallback<infer _Args4, infer E4, infer _A4>): infer _R4;
+} ? NonNullable<E1 | E2 | E3 | E4> : T extends {
+    (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
+    (...args: ArgsWithCallback<infer _Args2, infer E2, infer _A2>): infer _R2;
+    (...args: ArgsWithCallback<infer _Args3, infer E3, infer _A3>): infer _R3;
+} ? NonNullable<E1 | E2 | E3> : T extends {
+    (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
+    (...args: ArgsWithCallback<infer _Args2, infer E2, infer _A2>): infer _R2;
+} ? NonNullable<E1 | E2> : T extends {
+    (...args: ArgsWithCallback<infer _Args1, infer E1, infer _A1>): infer _R1;
+} ? NonNullable<E1> : never;
+export declare const effectify: {
+    <F extends (...args: Array<any>) => any>(fn: F): Effectify<F, EffectifyError<F>>;
+    <F extends (...args: Array<any>) => any, E>(fn: F, onError: (error: EffectifyError<F>, args: Parameters<F>) => E): Effectify<F, E>;
+    <F extends (...args: Array<any>) => any, E, E2>(fn: F, onError: (error: EffectifyError<F>, args: Parameters<F>) => E, onSyncError: (error: unknown, args: Parameters<F>) => E2): Effectify<F, E | E2>;
+};
+export {};

package/dist/node/Effectify.js

@@ -0,0 +1,19 @@
+/*
+ * Adapted from @effect/platform
+ */
+import * as Effect from "effect/Effect";
+export const effectify = ((fn, onError, onSyncError) => (...args) => Effect.async((resume) => {
+    try {
+        fn(...args, (err, result) => {
+            if (err) {
+                resume(Effect.fail(onError ? onError(err, args) : err));
+            }
+            else {
+                resume(Effect.succeed(result));
+            }
+        });
+    }
+    catch (err) {
+        resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err));
+    }
+}));

package/dist/node/FileSystem.d.ts

@@ -1,9 +1,7 @@
-import * as Error from "@effect/platform/Error";
-import type { PlatformError } from "@effect/platform/Error";
-import { SystemError } from "@effect/platform/Error";
 import * as FileSystem from "@effect/platform/FileSystem";
 import * as Layer from "effect/Layer";
 import * as NFS from "node:fs";
+import * as PlatformError from "./PlatformError.ts";
 export declare const layer: Layer.Layer<FileSystem.FileSystem, never, never>;
-export { Error, FileSystem, };
-export declare function handleErrnoException(module: SystemError["module"], method: string): (err: NodeJS.ErrnoException, [path]: [path: NFS.PathLike | number, ...args: Array<any>]) => PlatformError;
+export { FileSystem, PlatformError as Error, };
+export declare function handleErrnoException(module: PlatformError.SystemError["module"], method: string): (err: NodeJS.ErrnoException, [path]: [path: NFS.PathLike | number, ...args: Array<any>]) => PlatformError.PlatformError;

package/dist/node/FileSystem.js

@@ -1,27 +1,25 @@
 /*
  * Adapted from @effect/platform
  */
-import { effectify } from "@effect/platform/Effectify";
-import * as Error from "@effect/platform/Error";
-import { SystemError } from "@effect/platform/Error";
 import * as FileSystem from "@effect/platform/FileSystem";
 import * as Effect from "effect/Effect";
-import { pipe } from "effect/Function";
+import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import * as Crypto from "node:crypto";
+import * as NCrypto from "node:crypto";
 import * as NFS from "node:fs";
 import * as NOS from "node:os";
 import * as NPath from "node:path";
-const handleBadArgument = (method) => (cause) => new Error.BadArgument({
+import * as Effectify from "./Effectify.js";
+import * as PlatformError from "./PlatformError.js";
+const handleBadArgument = (method) => (cause) => new PlatformError.BadArgument({
     module: "FileSystem",
     method,
     cause,
 });
-// == access
 const access = (() => {
-    const nodeAccess = effectify(NFS.access, handleErrnoException("FileSystem", "access"), handleBadArgument("access"));
+    const nodeAccess = Effectify.effectify(NFS.access, handleErrnoException("FileSystem", "access"), handleBadArgument("access"));
     return (path, options) => {
         let mode = NFS.constants.F_OK;
         if (options?.readable) {
@@ -33,46 +31,39 @@ const access = (() => {
         return nodeAccess(path, mode);
     };
 })();
-// == copy
 const copy = (() => {
-    const nodeCp = effectify(NFS.cp, handleErrnoException("FileSystem", "copy"), handleBadArgument("copy"));
+    const nodeCp = Effectify.effectify(NFS.cp, handleErrnoException("FileSystem", "copy"), handleBadArgument("copy"));
     return (fromPath, toPath, options) => nodeCp(fromPath, toPath, {
         force: options?.overwrite ?? false,
         preserveTimestamps: options?.preserveTimestamps ?? false,
         recursive: true,
     });
 })();
-// == copyFile
 const copyFile = (() => {
-    const nodeCopyFile = effectify(NFS.copyFile, handleErrnoException("FileSystem", "copyFile"), handleBadArgument("copyFile"));
+    const nodeCopyFile = Effectify.effectify(NFS.copyFile, handleErrnoException("FileSystem", "copyFile"), handleBadArgument("copyFile"));
     return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);
 })();
-// == chmod
 const chmod = (() => {
-    const nodeChmod = effectify(NFS.chmod, handleErrnoException("FileSystem", "chmod"), handleBadArgument("chmod"));
+    const nodeChmod = Effectify.effectify(NFS.chmod, handleErrnoException("FileSystem", "chmod"), handleBadArgument("chmod"));
     return (path, mode) => nodeChmod(path, mode);
 })();
-// == chown
 const chown = (() => {
-    const nodeChown = effectify(NFS.chown, handleErrnoException("FileSystem", "chown"), handleBadArgument("chown"));
+    const nodeChown = Effectify.effectify(NFS.chown, handleErrnoException("FileSystem", "chown"), handleBadArgument("chown"));
     return (path, uid, gid) => nodeChown(path, uid, gid);
 })();
-// == link
 const link = (() => {
-    const nodeLink = effectify(NFS.link, handleErrnoException("FileSystem", "link"), handleBadArgument("link"));
+    const nodeLink = Effectify.effectify(NFS.link, handleErrnoException("FileSystem", "link"), handleBadArgument("link"));
     return (existingPath, newPath) => nodeLink(existingPath, newPath);
 })();
-// == makeDirectory
 const makeDirectory = (() => {
-    const nodeMkdir = effectify(NFS.mkdir, handleErrnoException("FileSystem", "makeDirectory"), handleBadArgument("makeDirectory"));
+    const nodeMkdir = Effectify.effectify(NFS.mkdir, handleErrnoException("FileSystem", "makeDirectory"), handleBadArgument("makeDirectory"));
     return (path, options) => nodeMkdir(path, {
         recursive: options?.recursive ?? false,
         mode: options?.mode,
     });
 })();
-// == makeTempDirectory
 const makeTempDirectoryFactory = (method) => {
-    const nodeMkdtemp = effectify(NFS.mkdtemp, handleErrnoException("FileSystem", method), handleBadArgument(method));
+    const nodeMkdtemp = Effectify.effectify(NFS.mkdtemp, handleErrnoException("FileSystem", method), handleBadArgument(method));
     return (options) => Effect.suspend(() => {
         const prefix = options?.prefix ?? "";
         const directory = typeof options?.directory === "string"
@@ -82,36 +73,33 @@ const makeTempDirectoryFactory = (method) => {
     });
 };
 const makeTempDirectory = makeTempDirectoryFactory("makeTempDirectory");
-// == remove
 const removeFactory = (method) => {
-    const nodeRm = effectify(NFS.rm, handleErrnoException("FileSystem", method), handleBadArgument(method));
+    const nodeRm = Effectify.effectify(NFS.rm, handleErrnoException("FileSystem", method), handleBadArgument(method));
     return (path, options) => nodeRm(path, {
         recursive: options?.recursive ?? false,
         force: options?.force ?? false,
     });
 };
 const remove = removeFactory("remove");
-// == makeTempDirectoryScoped
 const makeTempDirectoryScoped = (() => {
     const makeDirectory = makeTempDirectoryFactory("makeTempDirectoryScoped");
     const removeDirectory = removeFactory("makeTempDirectoryScoped");
     return (options) => Effect.acquireRelease(makeDirectory(options), (directory) => Effect.orDie(removeDirectory(directory, { 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));
-    return (path, options) => pipe(Effect.acquireRelease(nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) => Effect.orDie(nodeClose(fd))), Effect.map((fd) => makeFile(FileSystem.FileDescriptor(fd), options?.flag?.startsWith("a") ?? false)));
+    const nodeOpen = Effectify.effectify(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
+    const nodeClose = Effectify.effectify(NFS.close, handleErrnoException("FileSystem", method), handleBadArgument(method));
+    return (path, options) => Function.pipe(Effect.acquireRelease(nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) => Effect.orDie(nodeClose(fd))), Effect.map((fd) => makeFile(FileSystem.FileDescriptor(fd), options?.flag?.startsWith("a") ?? false)));
 };
 const open = openFactory("open");
 const makeFile = (() => {
-    const nodeReadFactory = (method) => effectify(NFS.read, handleErrnoException("FileSystem", method), handleBadArgument(method));
+    const nodeReadFactory = (method) => Effectify.effectify(NFS.read, handleErrnoException("FileSystem", method), handleBadArgument(method));
     const nodeRead = nodeReadFactory("read");
     const nodeReadAlloc = nodeReadFactory("readAlloc");
-    const nodeStat = effectify(NFS.fstat, handleErrnoException("FileSystem", "stat"), handleBadArgument("stat"));
-    const nodeTruncate = effectify(NFS.ftruncate, handleErrnoException("FileSystem", "truncate"), handleBadArgument("truncate"));
-    const nodeSync = effectify(NFS.fsync, handleErrnoException("FileSystem", "sync"), handleBadArgument("sync"));
-    const nodeWriteFactory = (method) => effectify(NFS.write, handleErrnoException("FileSystem", method), handleBadArgument(method));
+    const nodeStat = Effectify.effectify(NFS.fstat, handleErrnoException("FileSystem", "stat"), handleBadArgument("stat"));
+    const nodeTruncate = Effectify.effectify(NFS.ftruncate, handleErrnoException("FileSystem", "truncate"), handleBadArgument("truncate"));
+    const nodeSync = Effectify.effectify(NFS.fsync, handleErrnoException("FileSystem", "sync"), handleBadArgument("sync"));
+    const nodeWriteFactory = (method) => Effectify.effectify(NFS.write, handleErrnoException("FileSystem", method), handleBadArgument(method));
     const nodeWrite = nodeWriteFactory("write");
     const nodeWriteAll = nodeWriteFactory("writeAll");
     class FileImpl {
@@ -193,7 +181,7 @@ const makeFile = (() => {
         writeAllChunk(buffer) {
             return Effect.flatMap(Effect.suspend(() => nodeWriteAll(this.fd, buffer, undefined, undefined, this.append ? undefined : Number(this.position))), (bytesWritten) => {
                 if (bytesWritten === 0) {
-                    return Effect.fail(new Error.SystemError({
+                    return Effect.fail(new PlatformError.SystemError({
                         module: "FileSystem",
                         method: "writeAll",
                         reason: "WriteZero",
@@ -215,26 +203,22 @@ const makeFile = (() => {
     }
     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]) => NPath.join(directory, random + (options?.suffix ?? ""))), Effect.tap((path) => Effect.scoped(open(path, { flag: "w+" }))));
+    const randomHexString = (bytes) => Effect.sync(() => NCrypto.randomBytes(bytes).toString("hex"));
+    return (options) => Function.pipe(Effect.zip(makeDirectory(options), randomHexString(6)), Effect.map(([directory, random]) => NPath.join(directory, random + (options?.suffix ?? ""))), Effect.tap((path) => Effect.scoped(open(path, { flag: "w+" }))));
 };
 const makeTempFile = makeTempFileFactory("makeTempFile");
-// == makeTempFileScoped
 const makeTempFileScoped = (() => {
     const makeFile = makeTempFileFactory("makeTempFileScoped");
     const removeDirectory = removeFactory("makeTempFileScoped");
     return (options) => Effect.acquireRelease(makeFile(options), (file) => Effect.orDie(removeDirectory(NPath.dirname(file), { recursive: true })));
 })();
-// == readDirectory
 const readDirectory = (path, options) => Effect.tryPromise({
     try: () => NFS.promises.readdir(path, options),
     catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path]),
 });
-// == readFile
 const readFile = (path) => Effect.async((resume, signal) => {
     try {
         NFS.readFile(path, { signal }, (err, data) => {
@@ -250,22 +234,18 @@ const readFile = (path) => Effect.async((resume, signal) => {
         resume(Effect.fail(handleBadArgument("readFile")(err)));
     }
 });
-// == readLink
 const readLink = (() => {
-    const nodeReadLink = effectify(NFS.readlink, handleErrnoException("FileSystem", "readLink"), handleBadArgument("readLink"));
+    const nodeReadLink = Effectify.effectify(NFS.readlink, handleErrnoException("FileSystem", "readLink"), handleBadArgument("readLink"));
     return (path) => nodeReadLink(path);
 })();
-// == realPath
 const realPath = (() => {
-    const nodeRealPath = effectify(NFS.realpath, handleErrnoException("FileSystem", "realPath"), handleBadArgument("realPath"));
+    const nodeRealPath = Effectify.effectify(NFS.realpath, handleErrnoException("FileSystem", "realPath"), handleBadArgument("realPath"));
     return (path) => nodeRealPath(path);
 })();
-// == rename
 const rename = (() => {
-    const nodeRename = effectify(NFS.rename, handleErrnoException("FileSystem", "rename"), handleBadArgument("rename"));
+    const nodeRename = Effectify.effectify(NFS.rename, handleErrnoException("FileSystem", "rename"), handleBadArgument("rename"));
     return (oldPath, newPath) => nodeRename(oldPath, newPath);
 })();
-// == stat
 const makeFileInfo = (stat) => ({
     type: stat.isFile()
         ? "File"
@@ -297,25 +277,21 @@ const makeFileInfo = (stat) => ({
     blocks: Option.fromNullable(stat.blocks),
 });
 const stat = (() => {
-    const nodeStat = effectify(NFS.stat, handleErrnoException("FileSystem", "stat"), handleBadArgument("stat"));
+    const nodeStat = Effectify.effectify(NFS.stat, handleErrnoException("FileSystem", "stat"), handleBadArgument("stat"));
     return (path) => Effect.map(nodeStat(path), makeFileInfo);
 })();
-// == symlink
 const symlink = (() => {
-    const nodeSymlink = effectify(NFS.symlink, handleErrnoException("FileSystem", "symlink"), handleBadArgument("symlink"));
+    const nodeSymlink = Effectify.effectify(NFS.symlink, handleErrnoException("FileSystem", "symlink"), handleBadArgument("symlink"));
     return (target, path) => nodeSymlink(target, path);
 })();
-// == truncate
 const truncate = (() => {
-    const nodeTruncate = effectify(NFS.truncate, handleErrnoException("FileSystem", "truncate"), handleBadArgument("truncate"));
+    const nodeTruncate = Effectify.effectify(NFS.truncate, handleErrnoException("FileSystem", "truncate"), handleBadArgument("truncate"));
     return (path, length) => nodeTruncate(path, length !== undefined ? Number(length) : undefined);
 })();
-// == utimes
 const utimes = (() => {
-    const nodeUtimes = effectify(NFS.utimes, handleErrnoException("FileSystem", "utime"), handleBadArgument("utime"));
+    const nodeUtimes = Effectify.effectify(NFS.utimes, handleErrnoException("FileSystem", "utime"), handleBadArgument("utime"));
     return (path, atime, mtime) => nodeUtimes(path, atime, mtime);
 })();
-// == watch
 const watchNode = (path, options) => Stream.asyncScoped((emit) => Effect.acquireRelease(Effect.sync(() => {
     const watcher = NFS.watch(path, { recursive: options?.recursive }, (event, path) => {
         if (!path)
@@ -337,7 +313,7 @@ const watchNode = (path, options) => Stream.asyncScoped((emit) => Effect.acquire
         }
     });
     watcher.on("error", (error) => {
-        emit.fail(new Error.SystemError({
+        emit.fail(new PlatformError.SystemError({
             module: "FileSystem",
             reason: "Unknown",
             method: "watch",
@@ -351,7 +327,6 @@ const watchNode = (path, options) => Stream.asyncScoped((emit) => Effect.acquire
     return watcher;
 }), (watcher) => Effect.sync(() => watcher.close())));
 const watch = (backend, path, options) => stat(path).pipe(Effect.map((stat) => backend.pipe(Option.flatMap((_) => _.register(path, stat, options)), Option.getOrElse(() => watchNode(path, options)))), Stream.unwrap);
-// == writeFile
 const writeFile = (path, data, options) => Effect.async((resume, signal) => {
     try {
         NFS.writeFile(path, data, {
@@ -371,7 +346,7 @@ const writeFile = (path, data, options) => Effect.async((resume, signal) => {
         resume(Effect.fail(handleBadArgument("writeFile")(err)));
     }
 });
-const makeFileSystem = Effect.map(Effect.serviceOption(FileSystem.WatchBackend), (backend) => FileSystem.make({
+const make = Effect.map(Effect.serviceOption(FileSystem.WatchBackend), (backend) => FileSystem.make({
     access,
     chmod,
     chown,
@@ -399,8 +374,13 @@ const makeFileSystem = Effect.map(Effect.serviceOption(FileSystem.WatchBackend),
     },
     writeFile,
 }));
-export const layer = Layer.effect(FileSystem.FileSystem, makeFileSystem);
-export { Error, FileSystem, };
+export const layer = Layer.unwrapEffect(Effect
+    .gen(function* () {
+    const mod = yield* Effect.tryPromise(() => import("@effect/platform/FileSystem"));
+    return Layer.effect(mod.FileSystem, make);
+})
+    .pipe(Effect.catchAll(() => Effect.die(new globalThis.Error("@effect/platform is not installed")))));
+export { FileSystem, PlatformError as Error, };
 export function handleErrnoException(module, method) {
     return function (err, [path]) {
         let reason = "Unknown";
@@ -427,7 +407,7 @@ export function handleErrnoException(module, method) {
                 reason = "BadResource";
                 break;
         }
-        return new SystemError({
+        return new PlatformError.SystemError({
             reason,
             module,
             method,

package/dist/node/PlatformError.d.ts

@@ -0,0 +1,46 @@
+import type * as Cause from "effect/Cause";
+import * as Schema from "effect/Schema";
+import type * as Types from "effect/Types";
+import { TypeId as TypeId_ } from "@effect/platform/Error";
+export declare const TypeId: typeof TypeId_;
+export type TypeId = typeof TypeId;
+export declare const isPlatformError: (u: unknown) => u is PlatformError;
+export declare const TypeIdError: <const TypeId extends symbol, const Tag extends string>(typeId: TypeId, tag: Tag) => new <A extends Record<string, any>>(args: Types.Simplify<A>) => Cause.YieldableError & Record<TypeId, TypeId> & {
+    readonly _tag: Tag;
+} & Readonly<A>;
+export declare const Module: Schema.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
+declare const BadArgument_base: Schema.TaggedErrorClass<BadArgument, "BadArgument", {
+    readonly _tag: Schema.tag<"BadArgument">;
+} & {
+    module: Schema.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
+    method: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+export declare class BadArgument extends BadArgument_base {
+    readonly [TypeId]: typeof TypeId;
+    get message(): string;
+}
+export declare const SystemErrorReason: Schema.Literal<["AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero"]>;
+export type SystemErrorReason = typeof SystemErrorReason.Type;
+declare const SystemError_base: Schema.TaggedErrorClass<SystemError, "SystemError", {
+    readonly _tag: Schema.tag<"SystemError">;
+} & {
+    reason: Schema.Literal<["AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero"]>;
+    module: Schema.Literal<["Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal"]>;
+    method: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+    syscall: Schema.optional<typeof Schema.String>;
+    pathOrDescriptor: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+export declare class SystemError extends SystemError_base {
+    readonly [TypeId]: typeof TypeId;
+    get message(): string;
+}
+export type PlatformError = BadArgument | SystemError;
+export declare const PlatformError: Schema.Union<[
+    typeof BadArgument,
+    typeof SystemError
+]>;
+export {};

package/dist/node/PlatformError.js

@@ -0,0 +1,43 @@
+import * as Data from "effect/Data";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import { TypeId as TypeId_ } from "@effect/platform/Error";
+export const TypeId = TypeId_;
+export const isPlatformError = (u) => Predicate.hasProperty(u, TypeId);
+export const TypeIdError = (typeId, tag) => {
+    class Base extends Data.Error {
+        _tag = tag;
+    }
+    ;
+    Base.prototype[typeId] = typeId;
+    Base.prototype.name = tag;
+    return Base;
+};
+export const Module = Schema.Literal("Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal");
+export class BadArgument extends Schema.TaggedError("@effect/platform/Error/BadArgument")("BadArgument", {
+    module: Module,
+    method: Schema.String,
+    description: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Defect),
+}) {
+    [TypeId] = TypeId;
+    get message() {
+        return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`;
+    }
+}
+export const SystemErrorReason = Schema.Literal("AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero");
+export class SystemError extends Schema.TaggedError("@effect/platform/Error/SystemError")("SystemError", {
+    reason: SystemErrorReason,
+    module: Module,
+    method: Schema.String,
+    description: Schema.optional(Schema.String),
+    syscall: Schema.optional(Schema.String),
+    pathOrDescriptor: Schema.optional(Schema.Union(Schema.String, Schema.Number)),
+    cause: Schema.optional(Schema.Defect),
+}) {
+    [TypeId] = TypeId;
+    get message() {
+        return `${this.reason}: ${this.module}.${this.method}${this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""}${this.description ? `: ${this.description}` : ""}`;
+    }
+}
+export const PlatformError = Schema.Union(BadArgument, SystemError);

package/dist/testing/TestLogger.js

@@ -15,7 +15,7 @@ export function layer() {
         const mutableRef = messages.ref;
         const customLogger = Logger.make(({ message, logLevel, cause }) => {
             const causeStr = !Cause.isEmpty(cause)
-                ? ` ${Cause.pretty(cause)}`
+                ? ` ${Cause.pretty(cause, { renderErrorCause: true })}`
                 : "";
             MutableRef.update(mutableRef, (msgs) => [...msgs, `[${logLevel._tag}] ${String(message)}${causeStr}`]);
         });