effect-start 0.23.1 → 0.26.0

package/dist/node/NodeFileSystem.js

@@ -1,410 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as FileSystem from "../FileSystem.js";
-import * as Stream from "effect/Stream";
-import * as NCrypto from "node:crypto";
-import * as NFS from "node:fs";
-import * as NOS from "node:os";
-import * as NPath from "node:path";
-import * as PlatformError from "../PlatformError.js";
-import * as Effectify from "../Effectify.js";
-const handleBadArgument = (method) => (cause) => new PlatformError.BadArgument({
-    module: "FileSystem",
-    method,
-    cause,
-});
-const access = (() => {
-    const nodeAccess = Effectify.effectify(NFS.access, handleErrnoException("FileSystem", "access"), handleBadArgument("access"));
-    return (path, options) => {
-        let mode = NFS.constants.F_OK;
-        if (options?.readable) {
-            mode |= NFS.constants.R_OK;
-        }
-        if (options?.writable) {
-            mode |= NFS.constants.W_OK;
-        }
-        return nodeAccess(path, mode);
-    };
-})();
-const 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,
-    });
-})();
-const copyFile = (() => {
-    const nodeCopyFile = Effectify.effectify(NFS.copyFile, handleErrnoException("FileSystem", "copyFile"), handleBadArgument("copyFile"));
-    return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);
-})();
-const chmod = (() => {
-    const nodeChmod = Effectify.effectify(NFS.chmod, handleErrnoException("FileSystem", "chmod"), handleBadArgument("chmod"));
-    return (path, mode) => nodeChmod(path, mode);
-})();
-const chown = (() => {
-    const nodeChown = Effectify.effectify(NFS.chown, handleErrnoException("FileSystem", "chown"), handleBadArgument("chown"));
-    return (path, uid, gid) => nodeChown(path, uid, gid);
-})();
-const link = (() => {
-    const nodeLink = Effectify.effectify(NFS.link, handleErrnoException("FileSystem", "link"), handleBadArgument("link"));
-    return (existingPath, newPath) => nodeLink(existingPath, newPath);
-})();
-const makeDirectory = (() => {
-    const nodeMkdir = Effectify.effectify(NFS.mkdir, handleErrnoException("FileSystem", "makeDirectory"), handleBadArgument("makeDirectory"));
-    return (path, options) => nodeMkdir(path, {
-        recursive: options?.recursive ?? false,
-        mode: options?.mode,
-    });
-})();
-const makeTempDirectoryFactory = (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" ? NPath.join(options.directory, ".") : NOS.tmpdir();
-        return nodeMkdtemp(prefix ? NPath.join(directory, prefix) : directory + "/");
-    });
-};
-const makeTempDirectory = makeTempDirectoryFactory("makeTempDirectory");
-const removeFactory = (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");
-const makeTempDirectoryScoped = (() => {
-    const makeDirectory = makeTempDirectoryFactory("makeTempDirectoryScoped");
-    const removeDirectory = removeFactory("makeTempDirectoryScoped");
-    return (options) => Effect.acquireRelease(makeDirectory(options), (directory) => Effect.orDie(removeDirectory(directory, { recursive: true })));
-})();
-const openFactory = (method) => {
-    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.effectify(NFS.read, handleErrnoException("FileSystem", method), handleBadArgument(method));
-    const nodeRead = nodeReadFactory("read");
-    const nodeReadAlloc = nodeReadFactory("readAlloc");
-    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 {
-        [FileSystem.FileTypeId];
-        fd;
-        append;
-        semaphore = Effect.unsafeMakeSemaphore(1);
-        position = 0n;
-        constructor(fd, append) {
-            this[FileSystem.FileTypeId] = FileSystem.FileTypeId;
-            this.fd = fd;
-            this.append = append;
-        }
-        get stat() {
-            return Effect.map(nodeStat(this.fd), makeFileInfo);
-        }
-        get sync() {
-            return nodeSync(this.fd);
-        }
-        seek(offset, from) {
-            const offsetSize = FileSystem.Size(offset);
-            return this.semaphore.withPermits(1)(Effect.sync(() => {
-                if (from === "start") {
-                    this.position = offsetSize;
-                }
-                else if (from === "current") {
-                    this.position = this.position + offsetSize;
-                }
-                return this.position;
-            }));
-        }
-        read(buffer) {
-            return this.semaphore.withPermits(1)(Effect.map(Effect.suspend(() => nodeRead(this.fd, {
-                buffer,
-                position: this.position,
-            })), (bytesRead) => {
-                const sizeRead = FileSystem.Size(bytesRead);
-                this.position = this.position + sizeRead;
-                return sizeRead;
-            }));
-        }
-        readAlloc(size) {
-            const sizeNumber = Number(size);
-            return this.semaphore.withPermits(1)(Effect.flatMap(Effect.sync(() => Buffer.allocUnsafeSlow(sizeNumber)), (buffer) => Effect.map(nodeReadAlloc(this.fd, {
-                buffer,
-                position: this.position,
-            }), (bytesRead) => {
-                if (bytesRead === 0) {
-                    return Option.none();
-                }
-                this.position = this.position + BigInt(bytesRead);
-                if (bytesRead === sizeNumber) {
-                    return Option.some(buffer);
-                }
-                const dst = Buffer.allocUnsafeSlow(bytesRead);
-                buffer.copy(dst, 0, 0, bytesRead);
-                return Option.some(dst);
-            })));
-        }
-        truncate(length) {
-            return this.semaphore.withPermits(1)(Effect.map(nodeTruncate(this.fd, length ? Number(length) : undefined), () => {
-                if (!this.append) {
-                    const len = BigInt(length ?? 0);
-                    if (this.position > len) {
-                        this.position = len;
-                    }
-                }
-            }));
-        }
-        write(buffer) {
-            return this.semaphore.withPermits(1)(Effect.map(Effect.suspend(() => nodeWrite(this.fd, buffer, undefined, undefined, this.append ? undefined : Number(this.position))), (bytesWritten) => {
-                const sizeWritten = FileSystem.Size(bytesWritten);
-                if (!this.append) {
-                    this.position = this.position + sizeWritten;
-                }
-                return sizeWritten;
-            }));
-        }
-        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 PlatformError.SystemError({
-                        module: "FileSystem",
-                        method: "writeAll",
-                        reason: "WriteZero",
-                        pathOrDescriptor: this.fd,
-                        description: "write returned 0 bytes written",
-                    }));
-                }
-                if (!this.append) {
-                    this.position = this.position + BigInt(bytesWritten);
-                }
-                return bytesWritten < buffer.length
-                    ? this.writeAllChunk(buffer.subarray(bytesWritten))
-                    : Effect.void;
-            });
-        }
-        writeAll(buffer) {
-            return this.semaphore.withPermits(1)(this.writeAllChunk(buffer));
-        }
-    }
-    return (fd, append) => new FileImpl(fd, append);
-})();
-const makeTempFileFactory = (method) => {
-    const makeDirectory = makeTempDirectoryFactory(method);
-    const open = openFactory(method);
-    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");
-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 })));
-})();
-const readDirectory = (path, options) => Effect.tryPromise({
-    try: () => NFS.promises.readdir(path, options),
-    catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path]),
-});
-const readFile = (path) => Effect.async((resume, signal) => {
-    try {
-        NFS.readFile(path, { signal }, (err, data) => {
-            if (err) {
-                resume(Effect.fail(handleErrnoException("FileSystem", "readFile")(err, [path])));
-            }
-            else {
-                resume(Effect.succeed(data));
-            }
-        });
-    }
-    catch (err) {
-        resume(Effect.fail(handleBadArgument("readFile")(err)));
-    }
-});
-const readLink = (() => {
-    const nodeReadLink = Effectify.effectify(NFS.readlink, handleErrnoException("FileSystem", "readLink"), handleBadArgument("readLink"));
-    return (path) => nodeReadLink(path);
-})();
-const realPath = (() => {
-    const nodeRealPath = Effectify.effectify(NFS.realpath, handleErrnoException("FileSystem", "realPath"), handleBadArgument("realPath"));
-    return (path) => nodeRealPath(path);
-})();
-const rename = (() => {
-    const nodeRename = Effectify.effectify(NFS.rename, handleErrnoException("FileSystem", "rename"), handleBadArgument("rename"));
-    return (oldPath, newPath) => nodeRename(oldPath, newPath);
-})();
-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),
-    atime: Option.fromNullable(stat.atime),
-    birthtime: Option.fromNullable(stat.birthtime),
-    dev: stat.dev,
-    rdev: Option.fromNullable(stat.rdev),
-    ino: Option.fromNullable(stat.ino),
-    mode: stat.mode,
-    nlink: Option.fromNullable(stat.nlink),
-    uid: Option.fromNullable(stat.uid),
-    gid: Option.fromNullable(stat.gid),
-    size: FileSystem.Size(stat.size),
-    blksize: Option.map(Option.fromNullable(stat.blksize), FileSystem.Size),
-    blocks: Option.fromNullable(stat.blocks),
-});
-const stat = (() => {
-    const nodeStat = Effectify.effectify(NFS.stat, handleErrnoException("FileSystem", "stat"), handleBadArgument("stat"));
-    return (path) => Effect.map(nodeStat(path), makeFileInfo);
-})();
-const symlink = (() => {
-    const nodeSymlink = Effectify.effectify(NFS.symlink, handleErrnoException("FileSystem", "symlink"), handleBadArgument("symlink"));
-    return (target, path) => nodeSymlink(target, path);
-})();
-const truncate = (() => {
-    const nodeTruncate = Effectify.effectify(NFS.truncate, handleErrnoException("FileSystem", "truncate"), handleBadArgument("truncate"));
-    return (path, length) => nodeTruncate(path, length !== undefined ? Number(length) : undefined);
-})();
-const utimes = (() => {
-    const nodeUtimes = Effectify.effectify(NFS.utimes, handleErrnoException("FileSystem", "utime"), handleBadArgument("utime"));
-    return (path, atime, mtime) => nodeUtimes(path, atime, mtime);
-})();
-const watchNode = (path, options) => Stream.asyncScoped((emit) => Effect.acquireRelease(Effect.sync(() => {
-    const watcher = NFS.watch(path, { recursive: options?.recursive }, (event, path) => {
-        if (!path)
-            return;
-        switch (event) {
-            case "rename": {
-                emit.fromEffect(Effect.matchEffect(stat(path), {
-                    onSuccess: (_) => Effect.succeed(FileSystem.WatchEventCreate({ path })),
-                    onFailure: (err) => err._tag === "SystemError" && err.reason === "NotFound"
-                        ? Effect.succeed(FileSystem.WatchEventRemove({ path }))
-                        : Effect.fail(err),
-                }));
-                return;
-            }
-            case "change": {
-                emit.single(FileSystem.WatchEventUpdate({ path }));
-                return;
-            }
-        }
-    });
-    watcher.on("error", (error) => {
-        emit.fail(new PlatformError.SystemError({
-            module: "FileSystem",
-            reason: "Unknown",
-            method: "watch",
-            pathOrDescriptor: path,
-            cause: error,
-        }));
-    });
-    watcher.on("close", () => {
-        emit.end();
-    });
-    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);
-const writeFile = (path, data, options) => Effect.async((resume, signal) => {
-    try {
-        NFS.writeFile(path, data, {
-            signal,
-            flag: options?.flag,
-            mode: options?.mode,
-        }, (err) => {
-            if (err) {
-                resume(Effect.fail(handleErrnoException("FileSystem", "writeFile")(err, [path])));
-            }
-            else {
-                resume(Effect.void);
-            }
-        });
-    }
-    catch (err) {
-        resume(Effect.fail(handleBadArgument("writeFile")(err)));
-    }
-});
-const make = Effect.map(Effect.serviceOption(FileSystem.WatchBackend), (backend) => FileSystem.make({
-    access,
-    chmod,
-    chown,
-    copy,
-    copyFile,
-    link,
-    makeDirectory,
-    makeTempDirectory,
-    makeTempDirectoryScoped,
-    makeTempFile,
-    makeTempFileScoped,
-    open,
-    readDirectory,
-    readFile,
-    readLink,
-    realPath,
-    remove,
-    rename,
-    stat,
-    symlink,
-    truncate,
-    utimes,
-    watch(path, options) {
-        return watch(backend, path, options);
-    },
-    writeFile,
-}));
-export const layer = Layer.effect(FileSystem.FileSystem, make);
-export { PlatformError as Error };
-export function handleErrnoException(module, method) {
-    return function (err, [path]) {
-        let reason = "Unknown";
-        switch (err.code) {
-            case "ENOENT":
-                reason = "NotFound";
-                break;
-            case "EACCES":
-                reason = "PermissionDenied";
-                break;
-            case "EEXIST":
-                reason = "AlreadyExists";
-                break;
-            case "EISDIR":
-                reason = "BadResource";
-                break;
-            case "ENOTDIR":
-                reason = "BadResource";
-                break;
-            case "EBUSY":
-                reason = "Busy";
-                break;
-            case "ELOOP":
-                reason = "BadResource";
-                break;
-        }
-        return new PlatformError.SystemError({
-            reason,
-            module,
-            method,
-            pathOrDescriptor: path,
-            syscall: err.syscall,
-            description: err.message,
-            cause: err,
-        });
-    };
-}

package/dist/node/NodeUtils.d.ts

@@ -1,2 +0,0 @@
-export declare const getEntrypoint: () => string;
-export declare const findClosestPackageJson: (path: string) => Promise<string | undefined>;

package/dist/node/NodeUtils.js

@@ -1,20 +0,0 @@
-import * as NFS from "node:fs/promises";
-import * as NPath from "node:path";
-export const getEntrypoint = () => NPath.dirname(process.argv[1]);
-export const findClosestPackageJson = async (path) => {
-    const resolved = NPath.resolve(path);
-    const stat = await NFS.stat(resolved).catch(() => undefined);
-    let dir = stat?.isDirectory() ? resolved : NPath.dirname(resolved);
-    const root = NPath.parse(dir).root;
-    while (dir !== root) {
-        const candidate = NPath.join(dir, "package.json");
-        try {
-            await NFS.access(candidate);
-            return candidate;
-        }
-        catch {
-            dir = NPath.dirname(dir);
-        }
-    }
-    return undefined;
-};

package/dist/node/PlatformError.d.ts

@@ -1,46 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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/node/Utils.d.ts

@@ -1 +0,0 @@
-export declare const findClosestPackageJson: (path: string) => Promise<string | undefined>;

package/dist/node/Utils.js

@@ -1,19 +0,0 @@
-import * as NFS from "node:fs/promises";
-import * as NPath from "node:path";
-export const findClosestPackageJson = async (path) => {
-    const resolved = NPath.resolve(path);
-    const stat = await NFS.stat(resolved).catch(() => undefined);
-    let dir = stat?.isDirectory() ? resolved : NPath.dirname(resolved);
-    const root = NPath.parse(dir).root;
-    while (dir !== root) {
-        const candidate = NPath.join(dir, "package.json");
-        try {
-            await NFS.access(candidate);
-            return candidate;
-        }
-        catch {
-            dir = NPath.dirname(dir);
-        }
-    }
-    return undefined;
-};

package/dist/repro_fail.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/repro_fail.js

@@ -1,14 +0,0 @@
-import { Context } from "effect";
-import * as Route from "./RouteBody";
-const ServiceA = Context.GenericTag("ServiceA");
-const ServiceB = Context.GenericTag("ServiceB");
-// This handler requires BOTH ServiceA and ServiceB.
-// In the original type definition, Generator requires all yields to have the same R.
-// ServiceA != ServiceB, so this should fail type checking.
-const handler = Route.handle(function* () {
-    yield* ServiceA;
-    yield* ServiceB;
-    return "ok";
-});
-// To avoid unused variable warning
-console.log(handler);

package/dist/sql/bun/index.d.ts

@@ -1,3 +0,0 @@
-import * as Layer from "effect/Layer";
-import * as Sql from "../../Sql.ts";
-export declare const layer: (config: ConstructorParameters<typeof Bun.SQL>[0]) => Layer.Layer<Sql.SqlClient, Sql.SqlError>;

package/dist/sql/bun/index.js

@@ -1,75 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as FiberRef from "effect/FiberRef";
-import * as GlobalValue from "effect/GlobalValue";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Sql from "../../Sql.js";
-const errorCode = (error) => {
-    const e = error;
-    if (typeof e?.errno === "string")
-        return e.errno;
-    return e?.code ?? "UNKNOWN";
-};
-const wrapError = (error) => new Sql.SqlError({
-    code: errorCode(error),
-    message: error instanceof Error ? error.message : String(error),
-    cause: error,
-});
-const wrap = (fn) => Effect.tryPromise({ try: () => Promise.resolve(fn()), catch: wrapError });
-const makeValues = (obj, ...columns) => {
-    const items = Array.isArray(obj) ? obj : [obj];
-    const cols = columns.length > 0 ? columns : Object.keys(items[0]);
-    return { value: items, columns: cols };
-};
-const currentTransaction = GlobalValue.globalValue(Symbol.for("effect-start/sql/bun/currentTransaction"), () => FiberRef.unsafeMake(Option.none()));
-const makeRun = (bunSql) => (fn) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => wrap(() => fn(Option.isSome(txOpt) ? txOpt.value.conn : bunSql)));
-const makeWithTransaction = (bunSql) => (self) => Effect.uninterruptibleMask((restore) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-    if (Option.isSome(txOpt)) {
-        const { conn, depth } = txOpt.value;
-        const name = `sp_${depth}`;
-        return Effect.gen(function* () {
-            yield* wrap(() => conn.unsafe(`SAVEPOINT ${name}`));
-            const exit = yield* Effect.exit(restore(Effect.locally(self, currentTransaction, Option.some({ conn, depth: depth + 1 }))));
-            if (Exit.isSuccess(exit)) {
-                yield* wrap(() => conn.unsafe(`RELEASE SAVEPOINT ${name}`));
-                return exit.value;
-            }
-            yield* wrap(() => conn.unsafe(`ROLLBACK TO SAVEPOINT ${name}`)).pipe(Effect.orDie);
-            return yield* exit;
-        });
-    }
-    const runTx = (conn) => Effect.gen(function* () {
-        yield* wrap(() => conn.unsafe("BEGIN"));
-        const exit = yield* Effect.exit(restore(Effect.locally(self, currentTransaction, Option.some({ conn, depth: 1 }))));
-        if (Exit.isSuccess(exit)) {
-            yield* wrap(() => conn.unsafe("COMMIT"));
-            return exit.value;
-        }
-        yield* wrap(() => conn.unsafe("ROLLBACK")).pipe(Effect.orDie);
-        return yield* exit;
-    });
-    return Effect.matchEffect(wrap(() => bunSql.reserve()), {
-        onFailure: () => runTx(bunSql),
-        onSuccess: (reserved) => Effect.ensuring(runTx(reserved), Effect.sync(() => reserved.release())),
-    });
-}));
-export const layer = (config) => Layer.scoped(Sql.SqlClient, Effect.acquireRelease(Effect.try({
-    try: () => {
-        const bunSql = new Bun.SQL(config);
-        const run = makeRun(bunSql);
-        const use = (fn) => Effect.tryPromise({ try: () => Promise.resolve(fn(bunSql)), catch: wrapError });
-        return Object.assign((strings, ...values) => run((conn) => conn(strings, ...values)), {
-            unsafe: (query, values) => run((conn) => conn.unsafe(query, values)),
-            values: makeValues,
-            withTransaction: makeWithTransaction(bunSql),
-            reserve: Effect.acquireRelease(wrap(() => bunSql.reserve()), (reserved) => Effect.sync(() => reserved.release())).pipe(Effect.map((reserved) => Object.assign((strings, ...values) => wrap(() => reserved(strings, ...values)), {
-                unsafe: (query, values) => wrap(() => reserved.unsafe(query, values)),
-                values: makeValues,
-            }))),
-            close: (options) => use((bunSql) => bunSql.close(options)),
-            use,
-        });
-    },
-    catch: wrapError,
-}), (client) => client.close().pipe(Effect.orDie)));

package/dist/sql/mssql/docker.d.ts

@@ -1,2 +0,0 @@
-export declare const start: () => Promise<void>;
-export declare const stop: () => Promise<void>;