superlib 0.1.0

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

@@ -0,0 +1,19 @@
+declare class AbsolutePathClazz {
+    readonly path: string;
+    constructor(path: string);
+    getName(): string;
+    getDirPath(): AbsolutePath;
+    join(...paths: Array<string>): AbsolutePath;
+    /**
+     * Note: this returns a string representing relative path
+     */
+    relativeFrom(root: AbsolutePath): string;
+}
+declare function AbsolutePathClass(absolutePath: string): AbsolutePathClazz;
+declare namespace AbsolutePathClass {
+    var prototype: AbsolutePathClazz;
+}
+export declare const AbsolutePath: typeof AbsolutePathClass & typeof AbsolutePathClazz;
+export type AbsolutePath = InstanceType<typeof 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":"AAGA,cAAM,iBAAiB;IACrB,SAAgB,IAAI,EAAE,MAAM,CAAA;gBAEhB,IAAI,EAAE,MAAM;IAMxB,OAAO,IAAI,MAAM;IAIjB,UAAU,IAAI,YAAY;IAI1B,IAAI,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,YAAY;IAI3C;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM;CAGzC;AAED,iBAAS,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,iBAAiB,CAElE;kBAFQ,iBAAiB;;;AAM1B,eAAO,MAAM,YAAY,qDAAsD,CAAA;AAC/E,MAAM,MAAM,YAAY,GAAG,YAAY,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/platform/filesystem/AbsolutePath.js

@@ -0,0 +1,31 @@
+import assert from "node:assert";
+import * as pathModule from "node:path";
+class AbsolutePathClazz {
+    path;
+    constructor(path) {
+        assert(pathModule.isAbsolute(path), `Path is not absolute, was: ${path}`);
+        const normalizedPath = pathModule.resolve(path);
+        this.path = normalizedPath;
+    }
+    getName() {
+        return pathModule.basename(this.path);
+    }
+    getDirPath() {
+        return AbsolutePath(pathModule.dirname(this.path));
+    }
+    join(...paths) {
+        return AbsolutePath(pathModule.join(this.path, ...paths));
+    }
+    /**
+     * Note: this returns a string representing relative path
+     */
+    relativeFrom(root) {
+        return pathModule.relative(root.path, 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,21 @@
+import type { DirAccessError, DirRemoveError, FileAccessError, FileSystemEntry, FileWriteError, IFileSystem } from "./IFileSystem";
+import { Result } from "../../basic/Result";
+import { AbsolutePath } from "./AbsolutePath";
+export declare class FileSystem implements IFileSystem {
+    readFile(path: AbsolutePath): Promise<Result<string, FileAccessError>>;
+    writeFile(path: AbsolutePath, contents: string): Promise<Result<void, FileWriteError>>;
+    exists(path: AbsolutePath): Promise<boolean>;
+    get(path: AbsolutePath): Promise<FileSystemEntry | undefined>;
+    listDirectory(path: AbsolutePath): Promise<Result<FileSystemEntry[], DirAccessError>>;
+    createDirectory(path: AbsolutePath, options: {
+        recursive: boolean;
+    }): Promise<void>;
+    removeDirectory(path: AbsolutePath, options: {
+        recursive: boolean;
+        force: boolean;
+    }): Promise<Result<void, DirRemoveError>>;
+    createTempDir(prefix: string): Promise<AsyncDisposable & {
+        path: AbsolutePath;
+    }>;
+}
+//# 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":"AAcA,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,eAAe,EACf,eAAe,EACf,cAAc,EACd,WAAW,EACZ,MAAM,eAAe,CAAA;AAEtB,OAAO,EAAW,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAEpD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE7C,qBAAa,UAAW,YAAW,WAAW;IACtC,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAkBtE,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAgBtF,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAS5C,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAoB7D,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,cAAc,CAAC,CAAC;IAqBrF,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAInF,eAAe,CACnB,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,GAC9C,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IA4ClC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG;QAAE,IAAI,EAAE,YAAY,CAAA;KAAE,CAAC;CAWvF"}

package/dist/platform/filesystem/FileSystem.js

@@ -0,0 +1,128 @@
+import { access, mkdir, mkdtemp, readdir, readFile, rm, rmdir, stat, writeFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import * as pathModule from "node:path";
+import { Err, Ok, Result } from "../../basic/Result.js";
+import { ResultAsync } from "../../basic/ResultAsync.js";
+import { AbsolutePath } from "./AbsolutePath.js";
+export class FileSystem {
+    async readFile(path) {
+        return ResultAsync.try(() => readFile(path.path, "utf8"), (error) => {
+            if (error instanceof Error && "code" in error) {
+                switch (error.code) {
+                    case "ENOENT":
+                        return { type: "fs/file-not-found", path };
+                    case "EISDIR":
+                        return { type: "fs/file-is-a-dir", path };
+                }
+            }
+            return { type: "fs/other", cause: error };
+        }).toPromise();
+    }
+    async writeFile(path, contents) {
+        return ResultAsync.try(() => writeFile(path.path, contents, "utf8"), (error) => {
+            if (error instanceof Error && "code" in error) {
+                switch (error.code) {
+                    case "EISDIR":
+                        return { type: "fs/file-is-a-dir", path };
+                }
+            }
+            return { type: "fs/other", cause: error };
+        }).toPromise();
+    }
+    async exists(path) {
+        try {
+            await access(path.path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async get(path) {
+        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) {
+                switch (error.code) {
+                    case "ENOENT":
+                        return undefined;
+                }
+            }
+            throw error;
+        }
+    }
+    async listDirectory(path) {
+        const entry = await this.get(path);
+        if (entry === undefined) {
+            return Err({ type: "fs/dir-not-found", path });
+        }
+        if (entry.type === "file") {
+            return Err({ type: "fs/not-a-dir", path });
+        }
+        const entries = await readdir(path.path, { withFileTypes: true });
+        return Ok(entries.map((dirent) => {
+            const entryPath = path.join(dirent.name);
+            if (dirent.isDirectory()) {
+                return { type: "dir", path: entryPath };
+            }
+            return { type: "file", path: entryPath };
+        }));
+    }
+    async createDirectory(path, options) {
+        await mkdir(path.path, { recursive: options.recursive });
+    }
+    async removeDirectory(path, options) {
+        // @todo it might be possible to simplify this
+        if (options.recursive) {
+            return ResultAsync.try(() => rm(path.path, { recursive: true, force: options.force }), (error) => {
+                if (error instanceof Error && "code" in error) {
+                    switch (error.code) {
+                        case "ENOENT":
+                            return { type: "fs/dir-not-found", path };
+                        case "ENOTDIR":
+                            return { type: "fs/not-a-dir", path };
+                    }
+                }
+                throw error;
+            }).toPromise();
+        }
+        return ResultAsync.try(() => rmdir(path.path), (error) => {
+            if (error instanceof Error && "code" in error) {
+                switch (error.code) {
+                    case "EEXIST":
+                    case "ENOTEMPTY":
+                        return { type: "fs/dir-not-empty", path };
+                    case "ENOENT": {
+                        if (options.force) {
+                            return Ok();
+                        }
+                        else {
+                            return { type: "fs/dir-not-found", path };
+                        }
+                    }
+                    case "ENOTDIR": {
+                        return { type: "fs/not-a-dir", path };
+                    }
+                }
+            }
+            throw error;
+        }).toPromise();
+    }
+    async createTempDir(prefix) {
+        const tempDirPath = await mkdtemp(pathModule.join(tmpdir(), prefix));
+        const tempPath = AbsolutePath(tempDirPath);
+        return {
+            path: tempPath,
+            async [Symbol.asyncDispose]() {
+                await rm(tempPath.path, { recursive: true, force: true });
+            },
+        };
+    }
+}

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

@@ -0,0 +1,55 @@
+import type { Result } from "../../basic/Result";
+import type { AbsolutePath } from "./AbsolutePath";
+export interface IFileSystem {
+    readFile(path: AbsolutePath): Promise<Result<string, FileAccessError>>;
+    writeFile(path: AbsolutePath, contents: string): Promise<Result<void, FileWriteError>>;
+    createDirectory(path: AbsolutePath, options: {
+        recursive: boolean;
+    }): Promise<void>;
+    removeDirectory(path: AbsolutePath, options: {
+        recursive: boolean;
+        force: boolean;
+    }): Promise<Result<void, DirRemoveError>>;
+    listDirectory(path: AbsolutePath): Promise<Result<FileSystemEntry[], DirAccessError>>;
+    get(path: AbsolutePath): Promise<FileSystemEntry | undefined>;
+    exists(path: AbsolutePath): Promise<boolean>;
+    createTempDir(prefix: string): Promise<AsyncDisposable & {
+        path: AbsolutePath;
+    }>;
+}
+export type FileSystemEntry = {
+    type: "file";
+    path: AbsolutePath;
+} | {
+    type: "dir";
+    path: AbsolutePath;
+};
+export type FileAccessError = {
+    type: "fs/file-not-found";
+    path: AbsolutePath;
+} | {
+    type: "fs/file-is-a-dir";
+    path: AbsolutePath;
+} | {
+    type: "fs/other";
+    cause: unknown;
+};
+export type FileWriteError = {
+    type: "fs/file-is-a-dir";
+    path: AbsolutePath;
+} | {
+    type: "fs/other";
+    cause: unknown;
+};
+export type DirAccessError = {
+    type: "fs/dir-not-found";
+    path: AbsolutePath;
+} | {
+    type: "fs/not-a-dir";
+    path: AbsolutePath;
+};
+export type DirRemoveError = DirAccessError | {
+    type: "fs/dir-not-empty";
+    path: AbsolutePath;
+};
+//# 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":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAGlD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAA;IACtE,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAA;IACtF,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnF,eAAe,CACb,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,GAC9C,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAA;IACxC,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,cAAc,CAAC,CAAC,CAAA;IAErF,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAAA;IAC7D,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAE5C,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG;QAAE,IAAI,EAAE,YAAY,CAAA;KAAE,CAAC,CAAA;CACjF;AAED,MAAM,MAAM,eAAe,GACvB;IACE,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,YAAY,CAAA;CACnB,GACD;IACE,IAAI,EAAE,KAAK,CAAA;IACX,IAAI,EAAE,YAAY,CAAA;CACnB,CAAA;AAEL,MAAM,MAAM,eAAe,GACvB;IACE,IAAI,EAAE,mBAAmB,CAAA;IACzB,IAAI,EAAE,YAAY,CAAA;CACnB,GACD;IACE,IAAI,EAAE,kBAAkB,CAAA;IACxB,IAAI,EAAE,YAAY,CAAA;CACnB,GACD;IACE,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAEL,MAAM,MAAM,cAAc,GACtB;IACE,IAAI,EAAE,kBAAkB,CAAA;IACxB,IAAI,EAAE,YAAY,CAAA;CACnB,GACD;IACE,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAEL,MAAM,MAAM,cAAc,GACtB;IACE,IAAI,EAAE,kBAAkB,CAAA;IACxB,IAAI,EAAE,YAAY,CAAA;CACnB,GACD;IACE,IAAI,EAAE,cAAc,CAAA;IACpB,IAAI,EAAE,YAAY,CAAA;CACnB,CAAA;AAEL,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,IAAI,EAAE,YAAY,CAAA;CAAE,CAAA"}

package/dist/platform/filesystem/IFileSystem.js

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

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

@@ -0,0 +1,41 @@
+import type { DirAccessError, DirRemoveError, FileAccessError, FileSystemEntry, FileWriteError, IFileSystem } from "./IFileSystem";
+import { type Result } from "../../basic/Result";
+import { AbsolutePath } from "./AbsolutePath";
+type TempDirHandle = AsyncDisposable & {
+    path: AbsolutePath;
+};
+type FsGenesis = {
+    [path: string]: FsGenesis | string;
+};
+export declare class MemoryFileSystem implements IFileSystem {
+    private readonly files;
+    private readonly directories;
+    private readonly root;
+    private tempDirCounter;
+    constructor(genesis?: FsGenesis);
+    private seedFromGenesis;
+    readFile(path: AbsolutePath): Promise<Result<string, FileAccessError>>;
+    writeFile(path: AbsolutePath, contents: string): Promise<Result<void, FileWriteError>>;
+    writeFileSync(path: AbsolutePath, contents: string): Result<void, FileWriteError>;
+    exists(path: AbsolutePath): Promise<boolean>;
+    createDirectory(dirPath: AbsolutePath, options: {
+        recursive: boolean;
+    }): Promise<void>;
+    createDirectorySync(dirPath: AbsolutePath, options: {
+        recursive: boolean;
+    }): void;
+    removeDirectory(dirPath: AbsolutePath, options: {
+        recursive: boolean;
+        force: boolean;
+    }): Promise<Result<void, DirRemoveError>>;
+    createTempDir(prefix: string): Promise<TempDirHandle>;
+    listDirectory(path: AbsolutePath): Promise<Result<FileSystemEntry[], DirAccessError>>;
+    get(path: AbsolutePath): Promise<FileSystemEntry | undefined>;
+    private getFiles;
+    private getDirs;
+    private removeDirectoryRecursive;
+    private isWithinDir;
+    private hasEntriesWithin;
+}
+export {};
+//# sourceMappingURL=MemoryFileSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryFileSystem.d.ts","sourceRoot":"","sources":["../../../src/platform/filesystem/MemoryFileSystem.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,eAAe,EACf,eAAe,EACf,cAAc,EACd,WAAW,EACZ,MAAM,eAAe,CAAA;AAEtB,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE7C,KAAK,aAAa,GAAG,eAAe,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAA;AAE7D,KAAK,SAAS,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAA;CAAE,CAAA;AAEvD,qBAAa,gBAAiB,YAAW,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4B;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IAEzC,OAAO,CAAC,cAAc,CAAI;gBAEd,OAAO,GAAE,SAAc;IAMnC,OAAO,CAAC,eAAe;IAajB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAatE,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IAI5F,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC;IAU3E,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAI5C,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5F,mBAAmB,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IA4B3E,eAAe,CACnB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,GAC9C,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IA0BlC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAiBrD,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,cAAc,CAAC,CAAC;IAcrF,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IAgBnE,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,wBAAwB;IAgBhC,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,gBAAgB;CAezB"}

package/dist/platform/filesystem/MemoryFileSystem.js

@@ -0,0 +1,185 @@
+import * as pathModule from "node:path";
+import { Err, Ok } from "../../basic/Result.js";
+import { AbsolutePath } from "./AbsolutePath.js";
+export class MemoryFileSystem {
+    files = new Map();
+    directories = new Set();
+    root = AbsolutePath("/");
+    tempDirCounter = 0; // used for numbering of temp dirs
+    constructor(genesis = {}) {
+        this.directories.add(this.root.path);
+        this.seedFromGenesis(AbsolutePath("/"), genesis);
+    }
+    seedFromGenesis(cwd, genesis) {
+        for (const [key, value] of Object.entries(genesis)) {
+            const path = cwd.join(key);
+            if (typeof value === "string") {
+                this.createDirectorySync(path.getDirPath(), { recursive: true });
+                this.writeFileSync(path, value);
+            }
+            else {
+                this.createDirectorySync(path, { recursive: true });
+                this.seedFromGenesis(path, value);
+            }
+        }
+    }
+    async readFile(path) {
+        if (this.directories.has(path.path)) {
+            return Err({ type: "fs/file-is-a-dir", path });
+        }
+        const contents = this.files.get(path.path);
+        if (contents === undefined) {
+            return Err({ type: "fs/file-not-found", path });
+        }
+        return Ok(contents);
+    }
+    async writeFile(path, contents) {
+        return this.writeFileSync(path, contents);
+    }
+    writeFileSync(path, contents) {
+        this.createDirectorySync(path.getDirPath(), { recursive: true });
+        if (this.directories.has(path.path)) {
+            return Err({ type: "fs/file-is-a-dir", path });
+        }
+        this.files.set(path.path, contents);
+        return Ok();
+    }
+    async exists(path) {
+        return (await this.get(path)) !== undefined;
+    }
+    async createDirectory(dirPath, options) {
+        this.createDirectorySync(dirPath, options);
+    }
+    createDirectorySync(dirPath, options) {
+        if (this.directories.has(dirPath.path)) {
+            if (!options.recursive) {
+                throw new Error(`Directory already exists: ${dirPath.path}`);
+            }
+            return;
+        }
+        const parentPath = dirPath.getDirPath();
+        if (!options.recursive && !this.directories.has(parentPath.path)) {
+            throw new Error(`Parent directory does not exist: ${parentPath.path}`);
+        }
+        if (options.recursive) {
+            let current = dirPath.path;
+            while (!this.directories.has(current)) {
+                this.directories.add(current);
+                const parentPath = pathModule.dirname(current);
+                if (parentPath === current) {
+                    break;
+                }
+                current = parentPath;
+            }
+        }
+        else {
+            this.directories.add(dirPath.path);
+        }
+    }
+    async removeDirectory(dirPath, options) {
+        if (this.files.has(dirPath.path)) {
+            return Err({ type: "fs/not-a-dir", path: dirPath });
+        }
+        if (!this.directories.has(dirPath.path)) {
+            if (options.force) {
+                return Ok();
+            }
+            return Err({ type: "fs/dir-not-found", path: dirPath });
+        }
+        const hasChildren = this.hasEntriesWithin(dirPath.path);
+        if (hasChildren && !options.recursive) {
+            return Err({ type: "fs/dir-not-empty", path: dirPath });
+        }
+        if (options.recursive) {
+            this.removeDirectoryRecursive(dirPath.path);
+        }
+        else {
+            this.directories.delete(dirPath.path);
+        }
+        return Ok();
+    }
+    async createTempDir(prefix) {
+        const tempDirPath = this.root.join("tmp", `${prefix}${this.tempDirCounter++}`);
+        await this.createDirectory(tempDirPath, { recursive: true });
+        const removeTempDir = () => {
+            this.removeDirectoryRecursive(tempDirPath.path);
+        };
+        return {
+            path: tempDirPath,
+            async [Symbol.asyncDispose]() {
+                removeTempDir();
+            },
+        };
+    }
+    async listDirectory(path) {
+        if (this.files.has(path.path)) {
+            return Err({ type: "fs/not-a-dir", path });
+        }
+        if (!this.directories.has(path.path)) {
+            return Err({ type: "fs/dir-not-found", path });
+        }
+        const files = this.getFiles(path.path).map((path) => ({ type: "file", path }));
+        const dirs = this.getDirs(path.path).map((path) => ({ type: "dir", path }));
+        return Ok([...files, ...dirs]);
+    }
+    async get(path) {
+        if (this.files.has(path.path)) {
+            return {
+                type: "file",
+                path,
+            };
+        }
+        if (this.directories.has(path.path)) {
+            return {
+                type: "dir",
+                path,
+            };
+        }
+        return undefined;
+    }
+    getFiles(dirPath) {
+        // Use Array.from() instead of iterator helpers for Node 20 compatibility
+        return Array.from(this.files.keys())
+            .filter((file) => pathModule.dirname(file) === dirPath)
+            .map((file) => AbsolutePath(file));
+    }
+    getDirs(dirPath) {
+        // Use Array.from() instead of iterator helpers for Node 20 compatibility
+        return Array.from(this.directories.keys())
+            .filter((dir) => pathModule.dirname(dir) === dirPath && dir !== dirPath)
+            .map((dir) => AbsolutePath(dir));
+    }
+    removeDirectoryRecursive(dirPath) {
+        for (const filePath of this.files.keys()) {
+            if (this.isWithinDir(filePath, dirPath)) {
+                this.files.delete(filePath);
+            }
+        }
+        for (const directoryPath of Array.from(this.directories)) {
+            if (this.isWithinDir(directoryPath, dirPath)) {
+                this.directories.delete(directoryPath);
+            }
+        }
+        this.directories.add(this.root.path);
+    }
+    isWithinDir(targetPath, dirPath) {
+        const relative = pathModule.relative(dirPath, targetPath);
+        if (relative === "") {
+            return true;
+        }
+        return !relative.startsWith(`../`) && relative !== ".." && !pathModule.isAbsolute(relative);
+    }
+    hasEntriesWithin(dirPath) {
+        for (const filePath of this.files.keys()) {
+            if (this.isWithinDir(filePath, dirPath) && filePath !== dirPath) {
+                return true;
+            }
+        }
+        for (const directoryPath of this.directories) {
+            if (this.isWithinDir(directoryPath, dirPath) && directoryPath !== dirPath) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { FileSystemEntry, IFileSystem } from "../IFileSystem";
+import { AbsolutePath } from "../AbsolutePath";
+export interface GlobOptions {
+    pattern: string;
+    onlyFiles?: boolean;
+    cwd: AbsolutePath;
+}
+export declare function glob(options: GlobOptions & {
+    onlyFiles: true;
+}, fs: IFileSystem): Promise<AbsolutePath[]>;
+export declare function glob(options: GlobOptions & {
+    onlyFiles?: false;
+}, fs: IFileSystem): Promise<FileSystemEntry[]>;
+//# sourceMappingURL=glob.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../../../src/platform/filesystem/glob/glob.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAIlE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAG9C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,GAAG,EAAE,YAAY,CAAA;CAClB;AAED,wBAAsB,IAAI,CACxB,OAAO,EAAE,WAAW,GAAG;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE,EAC1C,EAAE,EAAE,WAAW,GACd,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;AAC1B,wBAAsB,IAAI,CACxB,OAAO,EAAE,WAAW,GAAG;IAAE,SAAS,CAAC,EAAE,KAAK,CAAA;CAAE,EAC5C,EAAE,EAAE,WAAW,GACd,OAAO,CAAC,eAAe,EAAE,CAAC,CAAA"}

package/dist/platform/filesystem/glob/glob.js

@@ -0,0 +1,57 @@
+import { assert } from "../../../basic/index.js";
+import { Task } from "../../../task/index.js";
+import { AbsolutePath } from "../AbsolutePath.js";
+import { parseGlob } from "./parseGlob.js";
+export async function glob(options, fs) {
+    const cwd = options.cwd;
+    const chunks = parseGlob(options.pattern);
+    const entries = await matchGlobWalker(chunks, cwd, fs, new Set());
+    if (options.onlyFiles) {
+        return entries.filter((e) => e.type === "file").map((e) => e.path);
+    }
+    return entries;
+}
+async function matchGlobWalker(chunks, cwd, fs, visited) {
+    const cwdEntry = await fs.get(cwd);
+    assert(!!cwdEntry, `${cwd.path} does not exist`);
+    const [chunk, ...rest] = chunks;
+    if (!chunk) {
+        // @note: it's important that writing and checking 'visited' happens is not interrupted by async operation
+        const alreadyVisited = visited.has(cwd.path);
+        if (alreadyVisited) {
+            return [];
+        }
+        visited.add(cwd.path);
+        return [cwdEntry];
+    }
+    if (cwdEntry.type === "file") {
+        return [];
+    }
+    switch (chunk.type) {
+        case "literal": {
+            const newCwd = cwd.join(chunk.value);
+            if ((await fs.get(newCwd)) !== undefined) {
+                return matchGlobWalker(rest, newCwd, fs, visited);
+            }
+            return [];
+        }
+        case "pattern": {
+            const entities = (await fs.listDirectory(cwd)).unwrap();
+            const newCwds = entities
+                .filter((entity) => chunk.pattern.test(entity.path.getName()))
+                .map((m) => m.path);
+            const results = await Task.all(newCwds.map((newCwd) => () => matchGlobWalker(rest, newCwd, fs, visited)), { concurrency: "unbounded" });
+            return results.flat();
+        }
+        case "globstar": {
+            const entities = (await fs.listDirectory(cwd)).unwrap();
+            const newCwds = entities.map((m) => m.path);
+            const results = await Task.all([
+                () => matchGlobWalker(rest, cwd, fs, visited),
+                ...newCwds.map((newCwd) => () => matchGlobWalker(rest, newCwd, fs, visited)), // without nesting
+                ...newCwds.map((newCwd) => () => matchGlobWalker(chunks, newCwd, fs, visited)), // with nesting
+            ], { concurrency: "unbounded" });
+            return results.flat();
+        }
+    }
+}

package/dist/platform/filesystem/glob/parseGlob.d.ts

@@ -0,0 +1,11 @@
+export type GlobChunk = {
+    type: "literal";
+    value: string;
+} | {
+    type: "pattern";
+    pattern: RegExp;
+} | {
+    type: "globstar";
+};
+export declare function parseGlob(pattern: string): GlobChunk[];
+//# sourceMappingURL=parseGlob.d.ts.map

package/dist/platform/filesystem/glob/parseGlob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseGlob.d.ts","sourceRoot":"","sources":["../../../../src/platform/filesystem/glob/parseGlob.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAA;AAExB,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAItD"}

package/dist/platform/filesystem/glob/parseGlob.js

@@ -0,0 +1,61 @@
+import { assert } from "../../../basic/index.js";
+export function parseGlob(pattern) {
+    const chunks = pattern.split("/").map(parseChunk);
+    return combineLiteralChunks(chunks);
+}
+function parseChunk(chunk) {
+    if (chunk === "**") {
+        return { type: "globstar" };
+    }
+    if (specialCharacters.some((c) => chunk.includes(c))) {
+        return { type: "pattern", pattern: globPatternToRegex(chunk) };
+    }
+    return { type: "literal", value: chunk };
+}
+const specialCharacters = ["*", "?", "{", "["];
+function globPatternToRegex(globPattern) {
+    let regexString = "";
+    for (let i = 0; i < globPattern.length; i++) {
+        const c = globPattern[i];
+        if (c === "*") {
+            regexString += ".*";
+        }
+        else if (c === ".") {
+            regexString += "\\.";
+        }
+        else if (c === "?") {
+            regexString += ".";
+        }
+        else if (c === "{") {
+            const closingBracketIndex = globPattern.indexOf("}", i + 1);
+            assert(closingBracketIndex !== -1, `Glob pattern ${globPattern} incorrect: unbalanced {}`);
+            const optionsString = globPattern.slice(i + 1, closingBracketIndex);
+            const options = optionsString.split(",").map((s) => escapeRegex(s.trim()));
+            regexString += `(${options.join("|")})`;
+            i = closingBracketIndex;
+        }
+        else if (c === "[") {
+            assert(false, "[] not supported yet");
+        }
+        else {
+            regexString += c;
+        }
+    }
+    return new RegExp(`^${regexString}$`);
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function combineLiteralChunks(chunks) {
+    return chunks.reduce((acc, chunk) => {
+        if (chunk.type === "literal" && acc.length > 0) {
+            const lastChunk = acc[acc.length - 1];
+            if (lastChunk.type === "literal") {
+                lastChunk.value += "/" + chunk.value;
+                return acc;
+            }
+        }
+        acc.push(chunk);
+        return acc;
+    }, []);
+}

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

@@ -0,0 +1,5 @@
+export { type IFileSystem } from "./IFileSystem";
+export { FileSystem } from "./FileSystem";
+export { MemoryFileSystem } from "./MemoryFileSystem";
+export { AbsolutePath } from "./AbsolutePath";
+//# sourceMappingURL=index.d.ts.map