barely-effect 0.1.0

package/dist/networking/HttpClient.d.ts

@@ -0,0 +1,78 @@
+import { type Cause, Effect } from "effect";
+declare const HttpNetworkError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+    readonly _tag: "HttpNetworkError";
+} & Readonly<A>;
+export declare class HttpNetworkError extends HttpNetworkError_base<{
+    readonly cause: unknown;
+}> {
+}
+declare const HttpStatusError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+    readonly _tag: "HttpStatusError";
+} & Readonly<A>;
+export declare class HttpStatusError extends HttpStatusError_base<{
+    readonly status: number;
+}> {
+}
+declare const HttpParseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+    readonly _tag: "HttpParseError";
+} & Readonly<A>;
+export declare class HttpParseError extends HttpParseError_base<{
+    readonly cause: unknown;
+}> {
+}
+export type HttpClientError = HttpNetworkError | HttpStatusError | HttpParseError | Cause.TimeoutError;
+export interface RetryOptions {
+    times: number;
+    delay?: number;
+    until?: (error: HttpClientError) => boolean;
+}
+export interface HttpClientOptions {
+    retry?: RetryOptions;
+    retryUntilStatus?: (status: number) => boolean;
+    timeout?: number;
+}
+export interface HttpClientRequestOptions {
+    url: string;
+    headers?: Record<string, string>;
+    output?: "json" | "text";
+}
+export interface HttpClientRequestOptionsWithBody extends HttpClientRequestOptions {
+    readonly body?: RequestInit["body"];
+}
+export declare class HttpClient {
+    private readonly options;
+    constructor(options?: HttpClientOptions);
+    get(options: HttpClientRequestOptions & {
+        output: "text";
+    }, overrides?: HttpClientOptions): Effect.Effect<string, HttpClientError>;
+    get(options: HttpClientRequestOptions & {
+        output?: "json";
+    }, overrides?: HttpClientOptions): Effect.Effect<unknown, HttpClientError>;
+    post(options: HttpClientRequestOptionsWithBody & {
+        output: "text";
+    }, overrides?: HttpClientOptions): Effect.Effect<string, HttpClientError>;
+    post(options: HttpClientRequestOptionsWithBody & {
+        output?: "json";
+    }, overrides?: HttpClientOptions): Effect.Effect<unknown, HttpClientError>;
+    put(options: HttpClientRequestOptionsWithBody & {
+        output: "text";
+    }, overrides?: HttpClientOptions): Effect.Effect<string, HttpClientError>;
+    put(options: HttpClientRequestOptionsWithBody & {
+        output?: "json";
+    }, overrides?: HttpClientOptions): Effect.Effect<unknown, HttpClientError>;
+    patch(options: HttpClientRequestOptionsWithBody & {
+        output: "text";
+    }, overrides?: HttpClientOptions): Effect.Effect<string, HttpClientError>;
+    patch(options: HttpClientRequestOptionsWithBody & {
+        output?: "json";
+    }, overrides?: HttpClientOptions): Effect.Effect<unknown, HttpClientError>;
+    delete(options: HttpClientRequestOptions & {
+        output: "text";
+    }, overrides?: HttpClientOptions): Effect.Effect<string, HttpClientError>;
+    delete(options: HttpClientRequestOptions & {
+        output?: "json";
+    }, overrides?: HttpClientOptions): Effect.Effect<unknown, HttpClientError>;
+    private request;
+}
+export {};
+//# sourceMappingURL=HttpClient.d.ts.map

package/dist/networking/HttpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClient.d.ts","sourceRoot":"","sources":["../../src/networking/HttpClient.ts"],"names":[],"mappings":"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"}

package/dist/networking/HttpClient.js

@@ -0,0 +1,77 @@
+import { Data, Duration, Effect, Schedule } from "effect";
+export class HttpNetworkError extends Data.TaggedError("HttpNetworkError") {
+}
+export class HttpStatusError extends Data.TaggedError("HttpStatusError") {
+}
+export class HttpParseError extends Data.TaggedError("HttpParseError") {
+}
+const defaultOptions = {
+    timeout: 5000,
+    retry: {
+        times: 3,
+        delay: 200,
+        until: () => true,
+    },
+    retryUntilStatus: (status) => status >= 200 && status < 300,
+};
+export class HttpClient {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            timeout: options.timeout ?? defaultOptions.timeout,
+            retryUntilStatus: options.retryUntilStatus ?? defaultOptions.retryUntilStatus,
+            retry: "retry" in options ? options.retry : defaultOptions.retry,
+        };
+    }
+    get(options, overrides) {
+        return this.request(options, "GET", overrides);
+    }
+    post(options, overrides) {
+        return this.request(options, "POST", overrides);
+    }
+    put(options, overrides) {
+        return this.request(options, "PUT", overrides);
+    }
+    patch(options, overrides) {
+        return this.request(options, "PATCH", overrides);
+    }
+    delete(options, overrides) {
+        return this.request(options, "DELETE", overrides);
+    }
+    request(requestOptions, method, overrides) {
+        const options = { ...this.options, ...overrides };
+        const output = requestOptions.output ?? "json";
+        const fetchEffect = Effect.gen({ self: this }, function* () {
+            const response = yield* Effect.tryPromise({
+                try: () => fetch(requestOptions.url, {
+                    method,
+                    headers: requestOptions.headers,
+                    body: requestOptions.body,
+                }),
+                catch: (cause) => new HttpNetworkError({ cause }),
+            });
+            if (options.retryUntilStatus && !options.retryUntilStatus(response.status)) {
+                return yield* Effect.fail(new HttpStatusError({ status: response.status }));
+            }
+            return yield* Effect.tryPromise({
+                try: () => (output === "text" ? response.text() : response.json()),
+                catch: (cause) => new HttpParseError({ cause }),
+            });
+        });
+        let result = fetchEffect;
+        if (options.timeout) {
+            result = Effect.timeout(result, Duration.millis(options.timeout));
+        }
+        if (options.retry) {
+            const retryOpts = options.retry;
+            result = Effect.retry(result, {
+                times: retryOpts.times,
+                ...(retryOpts.delay != null
+                    ? { schedule: Schedule.spaced(Duration.millis(retryOpts.delay)) }
+                    : {}),
+                ...(retryOpts.until ? { while: retryOpts.until } : {}),
+            });
+        }
+        return result;
+    }
+}

package/dist/networking/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./HttpClient";
+//# sourceMappingURL=index.d.ts.map

package/dist/networking/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/networking/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA"}

package/dist/networking/index.js

@@ -0,0 +1 @@
+export * from "./HttpClient.js";

package/dist/platform/filesystem/AbsolutePath.d.ts

@@ -0,0 +1,18 @@
+declare class AbsolutePathClazz {
+    readonly path: string;
+    constructor(absolutePath: string);
+    getName(): string;
+    getDirPath(): AbsolutePath;
+    join(...paths: Array<string>): AbsolutePath;
+    relativeFrom(root: AbsolutePath): string;
+    contains(other: AbsolutePath): boolean;
+    eq(other: AbsolutePath): boolean;
+    toString(): string;
+}
+export declare const AbsolutePath: {
+    new (absolutePath: string): AbsolutePathClazz;
+    (absolutePath: string): AbsolutePathClazz;
+};
+export type AbsolutePath = AbsolutePathClazz;
+export {};
+//# sourceMappingURL=AbsolutePath.d.ts.map

package/dist/platform/filesystem/AbsolutePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbsolutePath.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/AbsolutePath.ts"],"names":[],"mappings":"AAEA,cAAM,iBAAiB;IACrB,SAAgB,IAAI,EAAE,MAAM,CAAA;gBAEhB,YAAY,EAAE,MAAM;IAOhC,OAAO,IAAI,MAAM;IAIjB,UAAU,IAAI,YAAY;IAI1B,IAAI,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,YAAY;IAI3C,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM;IAIxC,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO;IAStC,EAAE,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO;IAIhC,QAAQ,IAAI,MAAM;CAGnB;AAQD,eAAO,MAAM,YAAY,EAAqE;IAC5F,KAAK,YAAY,EAAE,MAAM,GAAG,iBAAiB,CAAA;IAC7C,CAAC,YAAY,EAAE,MAAM,GAAG,iBAAiB,CAAA;CAC1C,CAAA;AACD,MAAM,MAAM,YAAY,GAAG,iBAAiB,CAAA"}

package/dist/platform/filesystem/AbsolutePath.js

@@ -0,0 +1,41 @@
+import * as pathModule from "node:path";
+class AbsolutePathClazz {
+    path;
+    constructor(absolutePath) {
+        if (!pathModule.isAbsolute(absolutePath)) {
+            throw new Error(`Path is not absolute, was: ${absolutePath}`);
+        }
+        this.path = pathModule.resolve(absolutePath);
+    }
+    getName() {
+        return pathModule.basename(this.path);
+    }
+    getDirPath() {
+        return AbsolutePath(pathModule.dirname(this.path));
+    }
+    join(...paths) {
+        return AbsolutePath(pathModule.join(this.path, ...paths));
+    }
+    relativeFrom(root) {
+        return pathModule.relative(root.path, this.path);
+    }
+    contains(other) {
+        const relative = pathModule.relative(this.path, other.path);
+        if (relative === "") {
+            return true;
+        }
+        return !relative.startsWith("../") && relative !== ".." && !pathModule.isAbsolute(relative);
+    }
+    eq(other) {
+        return this.path === other.path;
+    }
+    toString() {
+        return this.path;
+    }
+}
+function AbsolutePathClass(absolutePath) {
+    return new AbsolutePathClazz(absolutePath);
+}
+Object.setPrototypeOf(AbsolutePathClass, AbsolutePathClazz);
+AbsolutePathClass.prototype = AbsolutePathClazz.prototype;
+export const AbsolutePath = Object.assign(AbsolutePathClass, AbsolutePathClazz);

package/dist/platform/filesystem/FileSystem.d.ts

@@ -0,0 +1,30 @@
+import { Effect } from "effect";
+import { type AbsolutePath } from "./AbsolutePath";
+import { FsDirNotEmptyError, FsNotADirError, type FsDirAccessError, type FsDirCreateError, type FsDirRemoveError, type FsFileAccessError, type FsFileWriteError, type FileSystemEntry, type IFileSystem } from "./IFileSystem";
+export declare class FileSystem implements IFileSystem {
+    readFile(path: AbsolutePath): Effect.Effect<string, FsFileAccessError>;
+    writeFile(path: AbsolutePath, contents: string): Effect.Effect<void, FsFileWriteError>;
+    exists(path: AbsolutePath): Effect.Effect<boolean>;
+    get(path: AbsolutePath): Effect.Effect<FileSystemEntry | undefined>;
+    listDir(path: AbsolutePath): Effect.Effect<FileSystemEntry[], FsDirAccessError>;
+    createDir(path: AbsolutePath, options?: {
+        recursive: boolean;
+    }): Effect.Effect<void, FsDirCreateError>;
+    removeDir(path: AbsolutePath, options: {
+        recursive: true;
+        force: true;
+    }): Effect.Effect<void, never>;
+    removeDir(path: AbsolutePath, options: {
+        recursive: true;
+        force: false;
+    }): Effect.Effect<void, FsDirAccessError>;
+    removeDir(path: AbsolutePath, options: {
+        recursive: false;
+        force: true;
+    }): Effect.Effect<void, FsDirNotEmptyError | FsNotADirError>;
+    removeDir(path: AbsolutePath, options: {
+        recursive: false;
+        force: false;
+    }): Effect.Effect<void, FsDirRemoveError>;
+}
+//# sourceMappingURL=FileSystem.d.ts.map

package/dist/platform/filesystem/FileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystem.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/FileSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAG/B,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAClD,OAAO,EAEL,kBAAkB,EAIlB,cAAc,EAGd,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,WAAW,EACjB,MAAM,eAAe,CAAA;AAEtB,qBAAa,UAAW,YAAW,WAAW;IAC5C,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAkBtE,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAkBtF,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;IAYlD,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,GAAG,SAAS,CAAC;IAmBnE,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,gBAAgB,CAAC;IAwB/E,SAAS,CACP,IAAI,EAAE,YAAY,EAClB,OAAO,GAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAwB,GACpD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAkBxC,SAAS,CACP,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;QAAE,SAAS,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,IAAI,CAAA;KAAE,GACxC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC;IAC7B,SAAS,CACP,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;QAAE,SAAS,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,GACzC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC;IACxC,SAAS,CACP,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;QAAE,SAAS,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,IAAI,CAAA;KAAE,GACzC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,cAAc,CAAC;IAC3D,SAAS,CACP,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;QAAE,SAAS,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,GAC1C,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,CAAC;CAiCzC"}

package/dist/platform/filesystem/FileSystem.js

@@ -0,0 +1,129 @@
+import { Effect } from "effect";
+import { access, mkdir, readdir, readFile, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import {} from "./AbsolutePath.js";
+import { FsAlreadyExistsError, FsDirNotEmptyError, FsDirNotFoundError, FsFileIsADirError, FsFileNotFoundError, FsNotADirError, FsOtherError, FsParentNotFoundError, } from "./IFileSystem.js";
+export class FileSystem {
+    readFile(path) {
+        return Effect.tryPromise({
+            try: () => readFile(path.path, "utf8"),
+            catch: (error) => {
+                if (error instanceof Error && "code" in error) {
+                    switch (error.code) {
+                        case "ENOENT":
+                            return new FsFileNotFoundError({ path });
+                        case "EISDIR":
+                            return new FsFileIsADirError({ path });
+                    }
+                }
+                return new FsOtherError({ cause: error });
+            },
+        });
+    }
+    writeFile(path, contents) {
+        return Effect.tryPromise({
+            try: () => writeFile(path.path, contents, "utf8"),
+            catch: (error) => {
+                if (error instanceof Error && "code" in error) {
+                    switch (error.code) {
+                        case "EISDIR":
+                            return new FsFileIsADirError({ path });
+                        case "ENOENT":
+                            return new FsParentNotFoundError({ path });
+                    }
+                }
+                return new FsOtherError({ cause: error });
+            },
+        });
+    }
+    exists(path) {
+        return Effect.promise(async () => {
+            try {
+                await access(path.path);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    get(path) {
+        return Effect.promise(async () => {
+            try {
+                const stats = await stat(path.path);
+                if (stats.isFile()) {
+                    return { type: "file", path };
+                }
+                if (stats.isDirectory()) {
+                    return { type: "dir", path };
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+                    return undefined;
+                }
+                throw error;
+            }
+        });
+    }
+    listDir(path) {
+        return Effect.gen({ self: this }, function* () {
+            const entry = yield* this.get(path);
+            if (entry === undefined) {
+                return yield* Effect.fail(new FsDirNotFoundError({ path }));
+            }
+            if (entry.type === "file") {
+                return yield* Effect.fail(new FsNotADirError({ path }));
+            }
+            const entries = yield* Effect.promise(() => readdir(path.path, { withFileTypes: true }));
+            return entries.map((dirent) => {
+                const entryPath = path.join(dirent.name);
+                if (dirent.isDirectory()) {
+                    return { type: "dir", path: entryPath };
+                }
+                return { type: "file", path: entryPath };
+            });
+        });
+    }
+    createDir(path, options = { recursive: true }) {
+        return Effect.tryPromise({
+            try: () => mkdir(path.path, { recursive: options.recursive }),
+            catch: (error) => {
+                if (error instanceof Error && "code" in error) {
+                    switch (error.code) {
+                        case "EEXIST":
+                            return new FsAlreadyExistsError({ path });
+                        case "ENOENT":
+                            return new FsParentNotFoundError({ path });
+                    }
+                }
+                return new FsOtherError({ cause: error });
+            },
+        }).pipe(Effect.asVoid);
+    }
+    removeDir(path, options) {
+        return Effect.tryPromise({
+            try: async () => {
+                if (options.recursive) {
+                    await rm(path.path, { recursive: true, force: options.force });
+                }
+                else {
+                    await rmdir(path.path);
+                }
+            },
+            catch: (error) => {
+                if (error instanceof Error && "code" in error) {
+                    switch (error.code) {
+                        case "EEXIST":
+                        case "ENOTEMPTY":
+                            return new FsDirNotEmptyError({ path });
+                        case "ENOENT":
+                            return new FsDirNotFoundError({ path });
+                        case "ENOTDIR":
+                            return new FsNotADirError({ path });
+                    }
+                }
+                throw error;
+            },
+        }).pipe(Effect.catchTag("FsDirNotFoundError", (err) => options.force ? Effect.void : Effect.fail(err)));
+    }
+}

package/dist/platform/filesystem/IFileSystem.d.ts

@@ -0,0 +1,98 @@
+import { type Effect } from "effect";
+import { type AbsolutePath } from "./AbsolutePath";
+declare const FsFileNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FsFileNotFoundError";
+} & Readonly<A>;
+export declare class FsFileNotFoundError extends FsFileNotFoundError_base<{
+    readonly path: AbsolutePath;
+}> {
+}
+declare const FsFileIsADirError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FsFileIsADirError";
+} & Readonly<A>;
+export declare class FsFileIsADirError extends FsFileIsADirError_base<{
+    readonly path: AbsolutePath;
+}> {
+}
+declare const FsOtherError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FsOtherError";
+} & Readonly<A>;
+export declare class FsOtherError extends FsOtherError_base<{
+    readonly cause: unknown;
+}> {
+}
+declare const FsParentNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FsParentNotFoundError";
+} & Readonly<A>;
+export declare class FsParentNotFoundError extends FsParentNotFoundError_base<{
+    readonly path: AbsolutePath;
+}> {
+}
+declare const FsDirNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FsDirNotFoundError";
+} & Readonly<A>;
+export declare class FsDirNotFoundError extends FsDirNotFoundError_base<{
+    readonly path: AbsolutePath;
+}> {
+}
+declare const FsNotADirError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FsNotADirError";
+} & Readonly<A>;
+export declare class FsNotADirError extends FsNotADirError_base<{
+    readonly path: AbsolutePath;
+}> {
+}
+declare const FsDirNotEmptyError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FsDirNotEmptyError";
+} & Readonly<A>;
+export declare class FsDirNotEmptyError extends FsDirNotEmptyError_base<{
+    readonly path: AbsolutePath;
+}> {
+}
+declare const FsAlreadyExistsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").MatchRecord<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }, void, { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FsAlreadyExistsError";
+} & Readonly<A>;
+export declare class FsAlreadyExistsError extends FsAlreadyExistsError_base<{
+    readonly path: AbsolutePath;
+}> {
+}
+export type FsFileAccessError = FsFileNotFoundError | FsFileIsADirError | FsOtherError;
+export type FsFileWriteError = FsFileIsADirError | FsParentNotFoundError | FsOtherError;
+export type FsDirAccessError = FsDirNotFoundError | FsNotADirError;
+export type FsDirRemoveError = FsDirAccessError | FsDirNotEmptyError;
+export type FsDirCreateError = FsParentNotFoundError | FsAlreadyExistsError | FsOtherError;
+export type FileSystemEntry = {
+    type: "file";
+    path: AbsolutePath;
+} | {
+    type: "dir";
+    path: AbsolutePath;
+};
+export interface IFileSystem {
+    readFile(path: AbsolutePath): Effect.Effect<string, FsFileAccessError>;
+    writeFile(path: AbsolutePath, contents: string): Effect.Effect<void, FsFileWriteError>;
+    createDir(path: AbsolutePath, options?: {
+        recursive: boolean;
+    }): Effect.Effect<void, FsDirCreateError>;
+    removeDir(path: AbsolutePath, options: {
+        recursive: true;
+        force: true;
+    }): Effect.Effect<void, never>;
+    removeDir(path: AbsolutePath, options: {
+        recursive: true;
+        force: false;
+    }): Effect.Effect<void, FsDirAccessError>;
+    removeDir(path: AbsolutePath, options: {
+        recursive: false;
+        force: true;
+    }): Effect.Effect<void, FsDirNotEmptyError | FsNotADirError>;
+    removeDir(path: AbsolutePath, options: {
+        recursive: false;
+        force: false;
+    }): Effect.Effect<void, FsDirRemoveError>;
+    listDir(path: AbsolutePath): Effect.Effect<FileSystemEntry[], FsDirAccessError>;
+    get(path: AbsolutePath): Effect.Effect<FileSystemEntry | undefined>;
+    exists(path: AbsolutePath): Effect.Effect<boolean>;
+}
+export {};
+//# sourceMappingURL=IFileSystem.d.ts.map

package/dist/platform/filesystem/IFileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IFileSystem.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/IFileSystem.ts"],"names":[],"mappings":"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"}

package/dist/platform/filesystem/IFileSystem.js

@@ -0,0 +1,19 @@
+import { Data } from "effect";
+import {} from "./AbsolutePath.js";
+// --- Error types ---
+export class FsFileNotFoundError extends Data.TaggedError("FsFileNotFoundError") {
+}
+export class FsFileIsADirError extends Data.TaggedError("FsFileIsADirError") {
+}
+export class FsOtherError extends Data.TaggedError("FsOtherError") {
+}
+export class FsParentNotFoundError extends Data.TaggedError("FsParentNotFoundError") {
+}
+export class FsDirNotFoundError extends Data.TaggedError("FsDirNotFoundError") {
+}
+export class FsNotADirError extends Data.TaggedError("FsNotADirError") {
+}
+export class FsDirNotEmptyError extends Data.TaggedError("FsDirNotEmptyError") {
+}
+export class FsAlreadyExistsError extends Data.TaggedError("FsAlreadyExistsError") {
+}

package/dist/platform/filesystem/KeyedMap.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A Map-like data structure that supports arbitrary keys via a serialization function.
+ * This is useful when you want to use objects (like AbsolutePath) as map keys
+ * while maintaining proper equality semantics.
+ */
+export declare class KeyedMap<K, V> {
+    private readonly serialize;
+    private readonly map;
+    private readonly keyMap;
+    constructor(serialize: (key: K) => string);
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    forEach(callbackfn: (value: V, key: K, map: KeyedMap<K, V>) => void): void;
+}
+//# sourceMappingURL=KeyedMap.d.ts.map

package/dist/platform/filesystem/KeyedMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyedMap.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/KeyedMap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC;IAIZ,OAAO,CAAC,QAAQ,CAAC,SAAS;IAHtC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAuB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;gBAEjB,SAAS,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM;IAE1D,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAI1B,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAO3B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAMvB,KAAK,IAAI,IAAI;IAKb,IAAI,IAAI,IAAI,MAAM,CAEjB;IAEA,IAAI,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAM3B,MAAM,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAI7B,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAOpC,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAI7C,OAAO,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,GAAG,IAAI;CAK3E"}

package/dist/platform/filesystem/KeyedMap.js

@@ -0,0 +1,59 @@
+/**
+ * A Map-like data structure that supports arbitrary keys via a serialization function.
+ * This is useful when you want to use objects (like AbsolutePath) as map keys
+ * while maintaining proper equality semantics.
+ */
+export class KeyedMap {
+    serialize;
+    map = new Map();
+    keyMap = new Map();
+    constructor(serialize) {
+        this.serialize = serialize;
+    }
+    get(key) {
+        return this.map.get(this.serialize(key));
+    }
+    set(key, value) {
+        const serialized = this.serialize(key);
+        this.map.set(serialized, value);
+        this.keyMap.set(serialized, key);
+        return this;
+    }
+    has(key) {
+        return this.map.has(this.serialize(key));
+    }
+    delete(key) {
+        const serialized = this.serialize(key);
+        this.keyMap.delete(serialized);
+        return this.map.delete(serialized);
+    }
+    clear() {
+        this.map.clear();
+        this.keyMap.clear();
+    }
+    get size() {
+        return this.map.size;
+    }
+    *keys() {
+        for (const key of this.keyMap.values()) {
+            yield key;
+        }
+    }
+    *values() {
+        yield* this.map.values();
+    }
+    *entries() {
+        for (const [serialized, value] of this.map.entries()) {
+            const key = this.keyMap.get(serialized);
+            yield [key, value];
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(callbackfn) {
+        for (const [key, value] of this.entries()) {
+            callbackfn(value, key, this);
+        }
+    }
+}