@opencode-ai/util 0.0.0-bootstrap.0 → 0.0.0-next-15994

package/dist/flock.js

@@ -0,0 +1,273 @@
+import path from "path";
+import os from "os";
+import { randomBytes, randomUUID } from "crypto";
+import { mkdir, readFile, rm, stat, utimes, writeFile } from "fs/promises";
+import { Hash } from "./hash.js";
+import { Effect } from "effect";
+export var Flock;
+(function (Flock) {
+    let global;
+    function setGlobal(g) {
+        global = g;
+    }
+    Flock.setGlobal = setGlobal;
+    const root = () => {
+        if (!global)
+            throw new Error("Flock global not set");
+        return path.join(global.state, "locks");
+    };
+    // Defaults for callers that do not provide timing options.
+    const defaultOpts = {
+        staleMs: 60_000,
+        timeoutMs: 5 * 60_000,
+        baseDelayMs: 100,
+        maxDelayMs: 2_000,
+    };
+    function code(err) {
+        if (typeof err !== "object" || err === null || !("code" in err))
+            return;
+        const value = err.code;
+        if (typeof value !== "string")
+            return;
+        return value;
+    }
+    function sleep(ms, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                reject(signal.reason ?? new Error("Aborted"));
+                return;
+            }
+            let timer;
+            const done = () => {
+                signal?.removeEventListener("abort", abort);
+                resolve();
+            };
+            const abort = () => {
+                if (timer) {
+                    clearTimeout(timer);
+                }
+                signal?.removeEventListener("abort", abort);
+                reject(signal?.reason ?? new Error("Aborted"));
+            };
+            signal?.addEventListener("abort", abort, { once: true });
+            timer = setTimeout(done, ms);
+        });
+    }
+    function jitter(ms) {
+        const j = Math.floor(ms * 0.3);
+        const d = Math.floor(Math.random() * (2 * j + 1)) - j;
+        return Math.max(0, ms + d);
+    }
+    function mono() {
+        return performance.now();
+    }
+    function wall() {
+        return performance.timeOrigin + mono();
+    }
+    async function stats(file) {
+        try {
+            return await stat(file);
+        }
+        catch (err) {
+            const errCode = code(err);
+            if (errCode === "ENOENT" || errCode === "ENOTDIR")
+                return;
+            throw err;
+        }
+    }
+    async function stale(lockDir, heartbeatPath, metaPath, staleMs) {
+        // Stale detection allows automatic recovery after crashed owners.
+        const now = wall();
+        const heartbeat = await stats(heartbeatPath);
+        if (heartbeat) {
+            return now - heartbeat.mtimeMs > staleMs;
+        }
+        const meta = await stats(metaPath);
+        if (meta) {
+            return now - meta.mtimeMs > staleMs;
+        }
+        const dir = await stats(lockDir);
+        if (!dir) {
+            return false;
+        }
+        return now - dir.mtimeMs > staleMs;
+    }
+    async function tryAcquireLockDir(lockDir, opts) {
+        const token = randomUUID?.() ?? randomBytes(16).toString("hex");
+        const metaPath = path.join(lockDir, "meta.json");
+        const heartbeatPath = path.join(lockDir, "heartbeat");
+        try {
+            await mkdir(lockDir, { mode: 0o700 });
+        }
+        catch (err) {
+            if (code(err) !== "EEXIST") {
+                throw err;
+            }
+            if (!(await stale(lockDir, heartbeatPath, metaPath, opts.staleMs))) {
+                return { acquired: false };
+            }
+            const breakerPath = lockDir + ".breaker";
+            try {
+                await mkdir(breakerPath, { mode: 0o700 });
+            }
+            catch (claimErr) {
+                const errCode = code(claimErr);
+                if (errCode === "EEXIST") {
+                    const breaker = await stats(breakerPath);
+                    if (breaker && wall() - breaker.mtimeMs > opts.staleMs) {
+                        await rm(breakerPath, { recursive: true, force: true }).catch(() => undefined);
+                    }
+                    return { acquired: false };
+                }
+                if (errCode === "ENOENT" || errCode === "ENOTDIR") {
+                    return { acquired: false };
+                }
+                throw claimErr;
+            }
+            try {
+                // Breaker ownership ensures only one contender performs stale cleanup.
+                if (!(await stale(lockDir, heartbeatPath, metaPath, opts.staleMs))) {
+                    return { acquired: false };
+                }
+                await rm(lockDir, { recursive: true, force: true });
+                try {
+                    await mkdir(lockDir, { mode: 0o700 });
+                }
+                catch (retryErr) {
+                    const errCode = code(retryErr);
+                    if (errCode === "EEXIST" || errCode === "ENOTEMPTY") {
+                        return { acquired: false };
+                    }
+                    throw retryErr;
+                }
+            }
+            finally {
+                await rm(breakerPath, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        const meta = {
+            token,
+            pid: process.pid,
+            hostname: os.hostname(),
+            createdAt: new Date().toISOString(),
+        };
+        await writeFile(heartbeatPath, "", { flag: "wx" }).catch(async () => {
+            await rm(lockDir, { recursive: true, force: true });
+            throw new Error("Lock acquired but heartbeat already existed (possible compromise).");
+        });
+        await writeFile(metaPath, JSON.stringify(meta, null, 2), { flag: "wx" }).catch(async () => {
+            await rm(lockDir, { recursive: true, force: true });
+            throw new Error("Lock acquired but meta.json already existed (possible compromise).");
+        });
+        let timer;
+        const startHeartbeat = (intervalMs = Math.max(100, Math.floor(opts.staleMs / 3))) => {
+            if (timer)
+                return;
+            // Heartbeat prevents long critical sections from being evicted as stale.
+            timer = setInterval(() => {
+                const t = new Date();
+                void utimes(heartbeatPath, t, t).catch(() => undefined);
+            }, intervalMs);
+            timer.unref?.();
+        };
+        const release = async () => {
+            if (timer) {
+                clearInterval(timer);
+                timer = undefined;
+            }
+            const current = await readFile(metaPath, "utf8")
+                .then((raw) => {
+                const parsed = JSON.parse(raw);
+                if (!parsed || typeof parsed !== "object")
+                    return {};
+                return {
+                    token: "token" in parsed && typeof parsed.token === "string" ? parsed.token : undefined,
+                };
+            })
+                .catch((err) => {
+                const errCode = code(err);
+                if (errCode === "ENOENT" || errCode === "ENOTDIR") {
+                    throw new Error("Refusing to release: lock is compromised (metadata missing).");
+                }
+                if (err instanceof SyntaxError) {
+                    throw new Error("Refusing to release: lock is compromised (metadata invalid).");
+                }
+                throw err;
+            });
+            // Token check prevents deleting a lock that was re-acquired by another process.
+            if (current.token !== token) {
+                throw new Error("Refusing to release: lock token mismatch (not the owner).");
+            }
+            await rm(lockDir, { recursive: true, force: true });
+        };
+        return {
+            acquired: true,
+            startHeartbeat,
+            release,
+        };
+    }
+    async function acquireLockDir(lockDir, input, opts) {
+        const stop = mono() + opts.timeoutMs;
+        let attempt = 0;
+        let waited = 0;
+        let delay = opts.baseDelayMs;
+        while (true) {
+            input.signal?.throwIfAborted();
+            const res = await tryAcquireLockDir(lockDir, opts);
+            if (res.acquired) {
+                return res;
+            }
+            if (mono() > stop) {
+                throw new Error(`Timed out waiting for lock: ${input.key}`);
+            }
+            attempt += 1;
+            const ms = jitter(delay);
+            await input.onWait?.({
+                key: input.key,
+                attempt,
+                delay: ms,
+                waited,
+            });
+            await sleep(ms, input.signal);
+            waited += ms;
+            delay = Math.min(opts.maxDelayMs, Math.floor(delay * 1.7));
+        }
+    }
+    async function acquire(key, input = {}) {
+        input.signal?.throwIfAborted();
+        const cfg = {
+            staleMs: input.staleMs ?? defaultOpts.staleMs,
+            timeoutMs: input.timeoutMs ?? defaultOpts.timeoutMs,
+            baseDelayMs: input.baseDelayMs ?? defaultOpts.baseDelayMs,
+            maxDelayMs: input.maxDelayMs ?? defaultOpts.maxDelayMs,
+        };
+        const dir = input.dir ?? root();
+        await mkdir(dir, { recursive: true });
+        const lockfile = path.join(dir, Hash.fast(key) + ".lock");
+        const lock = await acquireLockDir(lockfile, {
+            key,
+            onWait: input.onWait,
+            signal: input.signal,
+        }, cfg);
+        lock.startHeartbeat();
+        const release = () => lock.release();
+        return {
+            release,
+            [Symbol.asyncDispose]() {
+                return release();
+            },
+        };
+    }
+    Flock.acquire = acquire;
+    async function withLock(key, fn, input = {}) {
+        await using _ = await acquire(key, input);
+        input.signal?.throwIfAborted();
+        return await fn();
+    }
+    Flock.withLock = withLock;
+    Flock.effect = Effect.fn("Flock.effect")(function* (key, input = {}) {
+        return yield* Effect.acquireRelease(Effect.promise((signal) => Flock.acquire(key, { ...input, signal })).pipe(Effect.withSpan("Flock.acquire", {
+            attributes: { key },
+        })), (lock) => Effect.promise(() => lock.release()).pipe(Effect.withSpan("Flock.release"))).pipe(Effect.asVoid);
+    });
+})(Flock || (Flock = {}));

package/dist/fs-util.d.ts

@@ -0,0 +1,139 @@
+import { Context, Effect, FileSystem, Layer, Schema } from "effect";
+import type { PlatformError } from "effect/PlatformError";
+import { Glob } from "./glob.js";
+export declare namespace FSUtil {
+    const FileSystemError_base: Schema.Class<FileSystemError, Schema.TaggedStruct<"FileSystemError", {
+        readonly method: Schema.String;
+        readonly cause: Schema.optional<Schema.Defect>;
+    }>, import("effect/Cause").YieldableError>;
+    export class FileSystemError extends FileSystemError_base {
+        get message(): string;
+    }
+    export type Error = PlatformError | FileSystemError;
+    export interface DirEntry {
+        readonly name: string;
+        readonly type: "file" | "directory" | "symlink" | "other";
+    }
+    export interface Interface extends FileSystem.FileSystem {
+        readonly isDir: (path: string) => Effect.Effect<boolean>;
+        readonly isFile: (path: string) => Effect.Effect<boolean>;
+        readonly existsSafe: (path: string) => Effect.Effect<boolean>;
+        readonly readFileStringSafe: (path: string) => Effect.Effect<string | undefined, Error>;
+        readonly readJson: (path: string) => Effect.Effect<unknown, Error>;
+        readonly writeJson: (path: string, data: unknown, mode?: number) => Effect.Effect<void, Error>;
+        readonly ensureDir: (path: string) => Effect.Effect<void, Error>;
+        readonly writeWithDirs: (path: string, content: string | Uint8Array, mode?: number) => Effect.Effect<void, Error>;
+        readonly readDirectoryEntries: (path: string) => Effect.Effect<DirEntry[], Error>;
+        readonly resolve: (path: string) => Effect.Effect<string>;
+        readonly findUp: (target: string, start: string, stop?: string) => Effect.Effect<string[], Error>;
+        readonly up: (options: {
+            targets: string[];
+            start: string;
+            stop?: string;
+        }) => Effect.Effect<string[], Error>;
+        readonly globUp: (pattern: string, start: string, stop?: string) => Effect.Effect<string[], Error>;
+        readonly scan: (pattern: string, options?: Glob.Options) => Effect.Effect<string[], Error>;
+        readonly globMatch: (pattern: string, filepath: string) => boolean;
+    }
+    const Service_base: Context.ServiceClass<Service, "@opencode/FileSystem", Interface>;
+    export class Service extends Service_base {
+    }
+    export const use: {
+        readonly isDir: (path: string) => Effect.Effect<boolean, never, Service>;
+        readonly isFile: (path: string) => Effect.Effect<boolean, never, Service>;
+        readonly existsSafe: (path: string) => Effect.Effect<boolean, never, Service>;
+        readonly readFileStringSafe: (path: string) => Effect.Effect<string | undefined, Error, Service>;
+        readonly readJson: (path: string) => Effect.Effect<unknown, Error, Service>;
+        readonly writeJson: (path: string, data: unknown, mode?: number | undefined) => Effect.Effect<void, Error, Service>;
+        readonly ensureDir: (path: string) => Effect.Effect<void, Error, Service>;
+        readonly writeWithDirs: (path: string, content: string | Uint8Array<ArrayBufferLike>, mode?: number | undefined) => Effect.Effect<void, Error, Service>;
+        readonly readDirectoryEntries: (path: string) => Effect.Effect<DirEntry[], Error, Service>;
+        readonly resolve: (path: string) => Effect.Effect<string, never, Service>;
+        readonly findUp: (target: string, start: string, stop?: string | undefined) => Effect.Effect<string[], Error, Service>;
+        readonly up: (options: {
+            targets: string[];
+            start: string;
+            stop?: string;
+        }) => Effect.Effect<string[], Error, Service>;
+        readonly globUp: (pattern: string, start: string, stop?: string | undefined) => Effect.Effect<string[], Error, Service>;
+        readonly scan: (pattern: string, options?: Glob.Options | undefined) => Effect.Effect<string[], Error, Service>;
+        readonly access: (path: string, options?: {
+            readonly ok?: boolean | undefined;
+            readonly readable?: boolean | undefined;
+            readonly writable?: boolean | undefined;
+        } | undefined) => Effect.Effect<void, PlatformError, Service>;
+        readonly copy: (fromPath: string, toPath: string, options?: {
+            readonly overwrite?: boolean | undefined;
+            readonly preserveTimestamps?: boolean | undefined;
+        } | undefined) => Effect.Effect<void, PlatformError, Service>;
+        readonly copyFile: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError, Service>;
+        readonly chmod: (path: string, mode: number) => Effect.Effect<void, PlatformError, Service>;
+        readonly chown: (path: string, uid: number, gid: number) => Effect.Effect<void, PlatformError, Service>;
+        readonly glob: (pattern: string, options?: {
+            readonly root?: string | undefined;
+            readonly exclude?: ReadonlyArray<string> | undefined;
+        } | undefined) => Effect.Effect<string[], PlatformError, Service>;
+        readonly exists: (path: string) => Effect.Effect<boolean, PlatformError, Service>;
+        readonly link: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError, Service>;
+        readonly makeDirectory: (path: string, options?: {
+            readonly recursive?: boolean | undefined;
+            readonly mode?: number | undefined;
+        } | undefined) => Effect.Effect<void, PlatformError, Service>;
+        readonly makeTempDirectory: (options?: {
+            readonly directory?: string | undefined;
+            readonly prefix?: string | undefined;
+        } | undefined) => Effect.Effect<string, PlatformError, Service>;
+        readonly makeTempDirectoryScoped: (options?: {
+            readonly directory?: string | undefined;
+            readonly prefix?: string | undefined;
+        } | undefined) => Effect.Effect<string, PlatformError, import("effect/Scope").Scope | Service>;
+        readonly makeTempFile: (options?: {
+            readonly directory?: string | undefined;
+            readonly prefix?: string | undefined;
+            readonly suffix?: string | undefined;
+        } | undefined) => Effect.Effect<string, PlatformError, Service>;
+        readonly makeTempFileScoped: (options?: {
+            readonly directory?: string | undefined;
+            readonly prefix?: string | undefined;
+            readonly suffix?: string | undefined;
+        } | undefined) => Effect.Effect<string, PlatformError, import("effect/Scope").Scope | Service>;
+        readonly open: (path: string, options?: {
+            readonly flag?: FileSystem.OpenFlag | undefined;
+            readonly mode?: number | undefined;
+        } | undefined) => Effect.Effect<FileSystem.File, PlatformError, import("effect/Scope").Scope | Service>;
+        readonly readDirectory: (path: string, options?: {
+            readonly recursive?: boolean | undefined;
+        } | undefined) => Effect.Effect<string[], PlatformError, Service>;
+        readonly readFile: (path: string) => Effect.Effect<Uint8Array<ArrayBufferLike>, PlatformError, Service>;
+        readonly readFileString: (path: string, encoding?: string | undefined) => Effect.Effect<string, PlatformError, Service>;
+        readonly readLink: (path: string) => Effect.Effect<string, PlatformError, Service>;
+        readonly realPath: (path: string) => Effect.Effect<string, PlatformError, Service>;
+        readonly remove: (path: string, options?: {
+            readonly recursive?: boolean | undefined;
+            readonly force?: boolean | undefined;
+        } | undefined) => Effect.Effect<void, PlatformError, Service>;
+        readonly rename: (oldPath: string, newPath: string) => Effect.Effect<void, PlatformError, Service>;
+        readonly stat: (path: string) => Effect.Effect<FileSystem.File.Info, PlatformError, Service>;
+        readonly symlink: (fromPath: string, toPath: string) => Effect.Effect<void, PlatformError, Service>;
+        readonly truncate: (path: string, length?: FileSystem.SizeInput | undefined) => Effect.Effect<void, PlatformError, Service>;
+        readonly utimes: (path: string, atime: number | Date, mtime: number | Date) => Effect.Effect<void, PlatformError, Service>;
+        readonly writeFile: (path: string, data: Uint8Array<ArrayBufferLike>, options?: {
+            readonly flag?: FileSystem.OpenFlag | undefined;
+            readonly mode?: number | undefined;
+        } | undefined) => Effect.Effect<void, PlatformError, Service>;
+        readonly writeFileString: (path: string, data: string, options?: {
+            readonly flag?: FileSystem.OpenFlag | undefined;
+            readonly mode?: number | undefined;
+        } | undefined) => Effect.Effect<void, PlatformError, Service>;
+    };
+    export const layer: Layer.Layer<Service, never, FileSystem.FileSystem>;
+    export const node: import("./effect/layer-node.js").Node<Service, never, import("./effect/layer-node.js").Tag<"global">>;
+    export function mimeType(p: string): string;
+    export function normalizePath(p: string): string;
+    export function normalizePathPattern(p: string): string;
+    export function resolve(p: string): string;
+    export function windowsPath(p: string): string;
+    export function overlaps(a: string, b: string): boolean;
+    export function contains(parent: string, child: string): boolean;
+    export {};
+}

package/dist/fs-util.js

@@ -0,0 +1,224 @@
+import { NodeFileSystem } from "@effect/platform-node";
+import path, { dirname, isAbsolute, join, relative, sep } from "path";
+import { realpathSync } from "fs";
+import { readdir } from "fs/promises";
+import { lookup } from "mime-types";
+import { Context, Effect, FileSystem, Layer, Schema } from "effect";
+import { Glob } from "./glob.js";
+import { serviceUse } from "./effect/service-use.js";
+import { makeGlobalNode } from "./effect/app-node.js";
+import { filesystem } from "./effect/app-node-platform.js";
+export var FSUtil;
+(function (FSUtil) {
+    class FileSystemError extends Schema.TaggedErrorClass()("FileSystemError", {
+        method: Schema.String,
+        cause: Schema.optional(Schema.Defect()),
+    }) {
+        get message() {
+            const detail = this.cause instanceof Error ? this.cause.message : this.cause && String(this.cause);
+            return `Filesystem operation failed: ${this.method}${detail ? `: ${detail}` : ""}`;
+        }
+    }
+    FSUtil.FileSystemError = FileSystemError;
+    class Service extends Context.Service()("@opencode/FileSystem") {
+    }
+    FSUtil.Service = Service;
+    FSUtil.use = serviceUse(Service);
+    // Exported so simulation can wrap this layer and override the methods that
+    // bypass the injected FileSystem (readDirectoryEntries, scan, globUp).
+    FSUtil.layer = Layer.effect(Service, Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const existsSafe = Effect.fn("FileSystem.existsSafe")(function* (path) {
+            return yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false));
+        });
+        const readFileStringSafe = Effect.fn("FileSystem.readFileStringSafe")(function* (path) {
+            return yield* fs.readFileString(path).pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined)), Effect.catchReason("PlatformError", "PermissionDenied", () => Effect.succeed(undefined)));
+        });
+        const isDir = Effect.fn("FileSystem.isDir")(function* (path) {
+            const info = yield* fs.stat(path).pipe(Effect.catch(() => Effect.void));
+            return info?.type === "Directory";
+        });
+        const isFile = Effect.fn("FileSystem.isFile")(function* (path) {
+            const info = yield* fs.stat(path).pipe(Effect.catch(() => Effect.void));
+            return info?.type === "File";
+        });
+        const readDirectoryEntries = Effect.fn("FileSystem.readDirectoryEntries")(function* (dirPath) {
+            return yield* Effect.tryPromise({
+                try: async () => {
+                    const entries = await readdir(dirPath, { withFileTypes: true });
+                    return entries.map((e) => ({
+                        name: e.name,
+                        type: e.isDirectory() ? "directory" : e.isSymbolicLink() ? "symlink" : e.isFile() ? "file" : "other",
+                    }));
+                },
+                catch: (cause) => new FileSystemError({ method: "readDirectoryEntries", cause }),
+            });
+        });
+        const resolve = Effect.fn("FileSystem.resolve")(function* (input) {
+            const resolved = path.resolve(windowsPath(input));
+            return yield* fs.realPath(resolved).pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(resolved)), Effect.orDie);
+        });
+        const readJson = Effect.fn("FileSystem.readJson")(function* (path) {
+            const text = yield* fs.readFileString(path);
+            return yield* Effect.try({
+                try: () => JSON.parse(text),
+                catch: (cause) => new FileSystemError({ method: "readJson", cause }),
+            });
+        });
+        const writeJson = Effect.fn("FileSystem.writeJson")(function* (path, data, mode) {
+            const content = JSON.stringify(data, null, 2);
+            yield* fs.writeFileString(path, content);
+            if (mode)
+                yield* fs.chmod(path, mode);
+        });
+        const ensureDir = Effect.fn("FileSystem.ensureDir")(function* (path) {
+            yield* fs.makeDirectory(path, { recursive: true }).pipe(
+            // Bun on Windows can throw EEXIST here despite recursive mode.
+            // https://github.com/oven-sh/bun/issues/21901
+            Effect.catchIf((error) => error.reason._tag === "AlreadyExists", (error) => isDir(path).pipe(Effect.flatMap((exists) => (exists ? Effect.void : Effect.fail(error))))));
+        });
+        const writeWithDirs = Effect.fn("FileSystem.writeWithDirs")(function* (path, content, mode) {
+            const write = typeof content === "string" ? fs.writeFileString(path, content) : fs.writeFile(path, content);
+            yield* write.pipe(Effect.catchIf((e) => e.reason._tag === "NotFound", () => Effect.gen(function* () {
+                yield* fs.makeDirectory(dirname(path), { recursive: true });
+                yield* write;
+            })));
+            if (mode)
+                yield* fs.chmod(path, mode);
+        });
+        const scan = Effect.fn("FileSystem.scan")(function* (pattern, options) {
+            return yield* Effect.tryPromise({
+                try: () => Glob.scan(pattern, options),
+                catch: (cause) => new FileSystemError({ method: "glob", cause }),
+            });
+        });
+        const findUp = Effect.fn("FileSystem.findUp")(function* (target, start, stop) {
+            const result = [];
+            let current = start;
+            while (true) {
+                const search = join(current, target);
+                if (yield* fs.exists(search))
+                    result.push(search);
+                if (stop === current)
+                    break;
+                const parent = dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+            return result;
+        });
+        const up = Effect.fn("FileSystem.up")(function* (options) {
+            const result = [];
+            let current = options.start;
+            while (true) {
+                for (const target of options.targets) {
+                    const search = join(current, target);
+                    if (yield* fs.exists(search))
+                        result.push(search);
+                }
+                if (options.stop === current)
+                    break;
+                const parent = dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+            return result;
+        });
+        const globUp = Effect.fn("FileSystem.globUp")(function* (pattern, start, stop) {
+            const result = [];
+            let current = start;
+            while (true) {
+                const matches = yield* scan(pattern, { cwd: current, absolute: true, include: "file", dot: true }).pipe(Effect.catch(() => Effect.succeed([])));
+                result.push(...matches);
+                if (stop === current)
+                    break;
+                const parent = dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+            return result;
+        });
+        return Service.of({
+            ...fs,
+            existsSafe,
+            readFileStringSafe,
+            isDir,
+            isFile,
+            readDirectoryEntries,
+            resolve,
+            readJson,
+            writeJson,
+            ensureDir,
+            writeWithDirs,
+            findUp,
+            up,
+            globUp,
+            scan,
+            globMatch: Glob.match,
+        });
+    }));
+    FSUtil.node = makeGlobalNode({ service: Service, layer: FSUtil.layer, deps: [filesystem] });
+    // Pure helpers that don't need Effect (path manipulation, sync operations)
+    function mimeType(p) {
+        return lookup(p) || "application/octet-stream";
+    }
+    FSUtil.mimeType = mimeType;
+    function normalizePath(p) {
+        if (process.platform !== "win32")
+            return p;
+        const resolved = path.resolve(windowsPath(p));
+        try {
+            return realpathSync.native(resolved);
+        }
+        catch {
+            return resolved;
+        }
+    }
+    FSUtil.normalizePath = normalizePath;
+    function normalizePathPattern(p) {
+        if (process.platform !== "win32")
+            return p;
+        if (p === "*")
+            return p;
+        const match = p.match(/^(.*)[\\/]\*$/);
+        if (!match)
+            return normalizePath(p);
+        const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1];
+        return join(normalizePath(dir), "*");
+    }
+    FSUtil.normalizePathPattern = normalizePathPattern;
+    function resolve(p) {
+        const resolved = path.resolve(windowsPath(p));
+        try {
+            return normalizePath(realpathSync(resolved));
+        }
+        catch (e) {
+            if (e?.code === "ENOENT")
+                return normalizePath(resolved);
+            throw e;
+        }
+    }
+    FSUtil.resolve = resolve;
+    function windowsPath(p) {
+        if (process.platform !== "win32")
+            return p;
+        return p
+            .replace(/^\/([a-zA-Z]):(?:[\\/]|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+            .replace(/^\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+            .replace(/^\/cygdrive\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+            .replace(/^\/mnt\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`);
+    }
+    FSUtil.windowsPath = windowsPath;
+    function overlaps(a, b) {
+        return contains(a, b) || contains(b, a);
+    }
+    FSUtil.overlaps = overlaps;
+    function contains(parent, child) {
+        const result = relative(parent, child);
+        return result === "" || (!isAbsolute(result) && result !== ".." && !result.startsWith(`..${sep}`));
+    }
+    FSUtil.contains = contains;
+})(FSUtil || (FSUtil = {}));

package/dist/glob.d.ts

@@ -0,0 +1,12 @@
+export declare namespace Glob {
+    interface Options {
+        cwd?: string;
+        absolute?: boolean;
+        include?: "file" | "all";
+        dot?: boolean;
+        symlink?: boolean;
+    }
+    function scan(pattern: string, options?: Options): Promise<string[]>;
+    function scanSync(pattern: string, options?: Options): string[];
+    function match(pattern: string, filepath: string): boolean;
+}

package/dist/glob.js

@@ -0,0 +1,26 @@
+import { glob, globSync } from "glob";
+import { minimatch } from "minimatch";
+export var Glob;
+(function (Glob) {
+    function toGlobOptions(options) {
+        return {
+            cwd: options.cwd,
+            absolute: options.absolute,
+            dot: options.dot,
+            follow: options.symlink ?? false,
+            nodir: options.include !== "all",
+        };
+    }
+    async function scan(pattern, options = {}) {
+        return glob(pattern, toGlobOptions(options));
+    }
+    Glob.scan = scan;
+    function scanSync(pattern, options = {}) {
+        return globSync(pattern, toGlobOptions(options));
+    }
+    Glob.scanSync = scanSync;
+    function match(pattern, filepath) {
+        return minimatch(filepath, pattern, { dot: true });
+    }
+    Glob.match = match;
+})(Glob || (Glob = {}));