@effect-vfs/memory 0.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2023 Effectful Technologies Inc
+Copyright (c) 2026 Lloyd Richards
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,207 @@
+# @effect-vfs/memory
+
+`@effect-vfs/memory` provides Effect's `FileSystem` service without touching the
+host filesystem. Existing programs can keep using `effect/FileSystem`; provide
+the memory layer when you want isolated, disposable filesystem state for tests,
+build previews, code generators, or browser tools.
+
+The adapter supports regular files, directories, symbolic links, hard links,
+file handles, temporary resources, globbing, and watch streams. Filesystem state
+and POSIX behavior come from `@effect-vfs/core`. This package presents that state
+through Effect's string-based `FileSystem` API.
+
+## Install
+
+```sh
+npm install @effect-vfs/memory effect@4.0.0-rc.112
+```
+
+The binding and snapshot examples below import `@effect-vfs/core` directly. Add it as a direct dependency when using
+those APIs:
+
+```sh
+npm install @effect-vfs/core
+```
+
+Version `0.1.0` targets exactly `effect@4.0.0-rc.112`. Effect v4 is still a
+release candidate, so a later Effect release may require a matching version of
+this package.
+
+## Replace the host filesystem
+
+Write application code against Effect's `FileSystem` service, then choose the
+implementation when you run it. The same program can use a platform filesystem
+in production and an isolated in-memory filesystem in tests or tools.
+
+This complete program creates a small build artifact without writing to disk:
+
+```ts
+import { MemoryFileSystem } from "@effect-vfs/memory"
+import { Effect, FileSystem } from "effect"
+
+const buildManifest = Effect.gen(function*() {
+  const fs = yield* FileSystem.FileSystem
+
+  yield* fs.makeDirectory("/dist", { recursive: true })
+  yield* fs.writeFileString(
+    "/dist/manifest.json",
+    JSON.stringify({ files: ["index.js", "index.css"] }, null, 2)
+  )
+
+  return yield* fs.readFileString("/dist/manifest.json")
+})
+
+const manifest = await Effect.runPromise(
+  buildManifest.pipe(Effect.provide(MemoryFileSystem.layer))
+)
+
+console.log(manifest)
+```
+
+`MemoryFileSystem.layer` creates a fresh volume containing `/tmp` and uses `/`
+as its working directory. `MemoryFileSystem.make` returns the service directly
+when a layer is unnecessary.
+
+## Choose isolated or shared state
+
+Each execution of `MemoryFileSystem.make` creates independent storage. Use
+`MemoryFileSystem.bind` when several callers need to see the same files through
+an existing `@effect-vfs/core` volume.
+
+```ts
+import { VirtualFileSystem as Vfs } from "@effect-vfs/core"
+import { MemoryFileSystem } from "@effect-vfs/memory"
+import { Effect } from "effect"
+
+const program = Effect.gen(function*() {
+  const isolatedA = yield* MemoryFileSystem.make
+  const isolatedB = yield* MemoryFileSystem.make
+
+  yield* isolatedA.writeFileString("/private.txt", "only in A")
+
+  const volume = yield* Vfs.make()
+  const sharedA = yield* MemoryFileSystem.bind(volume)
+  const sharedB = yield* MemoryFileSystem.bind(volume)
+
+  yield* sharedA.writeFileString("/shared.txt", "visible to both")
+
+  return {
+    isolatedBHasFile: yield* isolatedB.exists("/private.txt"),
+    sharedContents: yield* sharedB.readFileString("/shared.txt")
+  }
+})
+
+console.log(await Effect.runPromise(program))
+// { isolatedBHasFile: false, sharedContents: "visible to both" }
+```
+
+Bindings share file and directory changes. Each binding still has its own
+caller, descriptor table, file cursors, and resource scopes. A binding does not
+create `/tmp` or otherwise change the supplied volume. Its caller defaults to a
+privileged uid and gid of `0` with umask `0`.
+
+Reusing `MemoryFileSystem.layer` within one layer graph shares the service
+because Effect memoizes layers. Wrap it with `Layer.fresh` when separate parts
+of the same graph must receive independent filesystems.
+
+## Save and restore a volume
+
+Snapshots let a test or tool capture a prepared filesystem and restore clean,
+independent copies. Snapshot operations live in `@effect-vfs/core`, so keep the
+core volume and expose it through `MemoryFileSystem.bind`.
+
+```ts
+import { VirtualFileSystem as Vfs } from "@effect-vfs/core"
+import { MemoryFileSystem } from "@effect-vfs/memory"
+import { Effect } from "effect"
+
+const decodeLimits = {
+  maxEncodedBytes: 1_000_000,
+  maxRecords: 10_000,
+  maxEntries: 10_000,
+  maxDecodedBytes: 1_000_000
+}
+
+const program = Effect.gen(function*() {
+  const volume = yield* Vfs.make()
+  const fs = yield* MemoryFileSystem.bind(volume)
+
+  yield* fs.writeFileString("/config.json", "version 1")
+  const encoded = yield* Vfs.encodeSnapshot(yield* volume.snapshot)
+
+  yield* fs.writeFileString("/config.json", "version 2")
+
+  const snapshot = yield* Vfs.decodeSnapshot(encoded, decodeLimits)
+  const restoredVolume = yield* Vfs.fromSnapshot(snapshot)
+  const restoredFs = yield* MemoryFileSystem.bind(restoredVolume)
+
+  return {
+    current: yield* fs.readFileString("/config.json"),
+    restored: yield* restoredFs.readFileString("/config.json")
+  }
+})
+
+console.log(await Effect.runPromise(program))
+// { current: "version 2", restored: "version 1" }
+```
+
+A snapshot contains the reachable namespace, file contents, and metadata. It
+does not contain bindings, callers, open handles, file cursors, watches, or
+unlinked content. `/tmp` is restored only when it existed in the snapshot.
+
+## Resource lifetimes
+
+`FileSystem.open`, temporary resources, and watch subscriptions are scoped.
+Keep the owning `Effect.scoped` workflow alive while the resource is in use.
+Closing the scope closes its handles and subscriptions.
+
+Bindings keep their own Effect-compatible file cursors. Watch streams receive
+changes made through any binding and changes made by direct core callers on the
+same volume.
+
+## Globbing
+
+Glob patterns are relative to the selected root and use `/` separators. The
+adapter supports `*`, `?`, character classes, `**`, and brace alternatives.
+Wildcards do not match a leading `.` unless that segment starts with a literal
+dot. Empty, `.` and `..` path segments are rejected. Brace expansion is limited
+to 256 alternatives.
+
+## Limits
+
+This package provides Effect's `FileSystem` service. It cannot intercept
+`node:fs`, child processes, native extensions, or any code that accesses the
+host filesystem directly. Relative paths resolve from virtual `/`, not the host
+process working directory.
+
+The implementation is ESM-only and does not depend on Node or Bun runtime APIs.
+It can run in a browser when the rest of the application supports Effect and
+ESM.
+
+The core implements a bounded POSIX profile, not a mounted or persistent
+filesystem. It does not provide FUSE mounts, host-tree import or export, special
+files, advisory locks, descriptor duplication, crash durability, or
+copy-on-write snapshot optimization. Recursive adapter operations run as a
+sequence of core operations rather than one transaction. See the
+[implemented profile](https://github.com/lloydrichards/effect-virtual-fs/blob/main/.docs/context/implemented-profile.md)
+for the exact behavior and exclusions.
+
+## Compatibility
+
+The package is experimental. Its public API may change between minor releases
+while Effect v4 remains a release candidate.
+
+The test suite checks the portable `FileSystem` contract and the core-backed
+adapter. Release checks also compile the NodeNext import path, bundle a browser
+consumer, and run a Node import smoke test.
+
+The API began in [Effect PR #6573](https://github.com/Effect-TS/effect/pull/6573).
+The portable contract suite began in
+[Effect PR #6555](https://github.com/Effect-TS/effect/pull/6555).
+
+## Credits
+
+The original implementation was based on earlier work in
+[effect-smol PR #456](https://github.com/Effect-TS/effect-smol/pull/456).
+
+Licensed under the MIT License.

package/dist/MemoryFileSystem.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Provides an in-memory implementation of Effect's `FileSystem` service.
+ *
+ * The service uses `@effect-vfs/core` for filesystem state and exposes that
+ * state through Effect's path-based `FileSystem` interface. It is intended for
+ * tests, build tools, and programs that need filesystem behavior without host
+ * filesystem I/O.
+ *
+ * @since 0.1.0
+ */
+import type * as Vfs from "@effect-vfs/core/VirtualFileSystem";
+import type * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Layer from "effect/Layer";
+/**
+ * Creates a `FileSystem.FileSystem` service backed by a fresh in-memory volume.
+ *
+ * **When to use**
+ *
+ * Use when you need the service value directly. The volume
+ * starts with an empty `/tmp` directory and uses `/` as its working directory.
+ *
+ * @see {@link layer} for providing the service as a Layer.
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: Effect.Effect<FileSystem.FileSystem>;
+/**
+ * Provides a `FileSystem.FileSystem` backed by a fresh in-memory volume.
+ *
+ * **When to use**
+ *
+ * Use when you need to replace the host filesystem in an Effect program.
+ *
+ * **Gotchas**
+ *
+ * Reusing this layer value in one layer graph shares the volume through layer
+ * memoization. Wrap it with `Layer.fresh` when each use needs separate state.
+ *
+ * @see {@link make} for constructing the service directly.
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<FileSystem.FileSystem>;
+/**
+ * Creates a `FileSystem.FileSystem` service backed by an existing core volume.
+ *
+ * **Details**
+ *
+ * The binding creates its own root caller and file-descriptor table. It does not
+ * add `/tmp` or otherwise modify the volume. Use this when an adapter and direct
+ * core callers must share filesystem state. Bindings share namespace and content
+ * changes, but keep independent caller state, descriptors, and file cursors.
+ *
+ * The caller defaults to a privileged uid and gid of `0` with umask `0`. Invalid
+ * caller options fail with `VirtualFileSystem.ConfigurationError`. Filesystem
+ * operations translate core failures to Effect `PlatformError` values.
+ *
+ * @see {@link make} for a service backed by a fresh volume with `/tmp`.
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const bind: (volume: Vfs.Volume, options?: Vfs.RootCallerOptions) => Effect.Effect<FileSystem.FileSystem, Vfs.ConfigurationError>;
+//# sourceMappingURL=MemoryFileSystem.d.ts.map

package/dist/MemoryFileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryFileSystem.d.ts","sourceRoot":"","sources":["../src/MemoryFileSystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,KAAK,GAAG,MAAM,oCAAoC,CAAA;AAC9D,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,UAAU,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAG1C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,CAAiB,CAAA;AAEvE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,UAAU,CAAkB,CAAA;AAEvE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,IAAI,EAAE,CACjB,MAAM,EAAE,GAAG,CAAC,MAAM,EAClB,OAAO,CAAC,EAAE,GAAG,CAAC,iBAAiB,KAC5B,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,GAAG,CAAC,kBAAkB,CAAiB,CAAA"}

package/dist/MemoryFileSystem.js

@@ -0,0 +1,10 @@
+import {
+  bind,
+  layer,
+  make
+} from "./chunk-GXCMBMOL.js";
+export {
+  bind,
+  layer,
+  make
+};

package/dist/chunk-GXCMBMOL.js

@@ -0,0 +1,813 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/MemoryFileSystem.ts
+var MemoryFileSystem_exports = {};
+__export(MemoryFileSystem_exports, {
+  bind: () => bind2,
+  layer: () => layer2,
+  make: () => make4
+});
+
+// src/internal/memoryFileSystem.ts
+import { VirtualFileSystem as Vfs } from "@effect-vfs/core";
+import * as DateTime from "effect/DateTime";
+import * as Effect2 from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { badArgument as badArgument2, systemError } from "effect/PlatformError";
+import * as Semaphore from "effect/Semaphore";
+import * as Stream from "effect/Stream";
+
+// src/internal/glob.ts
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import { badArgument } from "effect/PlatformError";
+var argumentError = (method, description) => badArgument({ module: "FileSystem", method, description });
+var MAX_BRACE_EXPANSIONS = 256;
+var GlobToken = Data.taggedEnum();
+var globSyntaxCharacters = /* @__PURE__ */ new Set(["*", "?", "[", "]", "{", "}", ",", "\\"]);
+var findBraceExpansion = (pattern) => {
+  for (let start = 0; start < pattern.length; start++) {
+    if (pattern[start] === "\\") {
+      start += 1;
+      continue;
+    }
+    if (pattern[start] !== "{") continue;
+    let depth = 1;
+    let characterClass = false;
+    let closed = false;
+    const commas = [];
+    for (let end = start + 1; end < pattern.length; end++) {
+      if (pattern[end] === "\\") {
+        end += 1;
+        continue;
+      }
+      if (pattern[end] === "[") {
+        characterClass = true;
+      } else if (pattern[end] === "]") {
+        characterClass = false;
+      } else if (!characterClass && pattern[end] === "{") {
+        depth += 1;
+      } else if (!characterClass && pattern[end] === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          closed = true;
+          if (commas.length === 0) {
+            const nested = findBraceExpansion(pattern.slice(start + 1, end));
+            if (nested !== void 0) {
+              return {
+                start: start + nested.start + 1,
+                end: start + nested.end + 1,
+                alternatives: nested.alternatives
+              };
+            }
+            start = end;
+            break;
+          }
+          const alternatives = [];
+          let alternativeStart = start + 1;
+          for (const comma of [...commas, end]) {
+            alternatives.push(pattern.slice(alternativeStart, comma));
+            alternativeStart = comma + 1;
+          }
+          return { start, end, alternatives };
+        }
+      } else if (!characterClass && pattern[end] === "," && depth === 1) {
+        commas.push(end);
+      }
+    }
+    if (!closed) return void 0;
+  }
+  return void 0;
+};
+var expandBraces = (method, pattern) => {
+  let patterns = [pattern];
+  while (true) {
+    const index = patterns.findIndex((pattern2) => findBraceExpansion(pattern2) !== void 0);
+    if (index === -1) return Effect.succeed(patterns);
+    const current = patterns[index];
+    const expansion = findBraceExpansion(current);
+    if (expansion === void 0) return Effect.succeed(patterns);
+    if (patterns.length - 1 + expansion.alternatives.length > MAX_BRACE_EXPANSIONS) {
+      return Effect.fail(argumentError(method, `brace expansion exceeds ${MAX_BRACE_EXPANSIONS} alternatives`));
+    }
+    patterns = [
+      ...patterns.slice(0, index),
+      ...expansion.alternatives.map(
+        (alternative) => `${current.slice(0, expansion.start)}${alternative}${current.slice(expansion.end + 1)}`
+      ),
+      ...patterns.slice(index + 1)
+    ];
+  }
+};
+var parseCharacterClass = (method, segment, start) => {
+  let index = start + 1;
+  const negated = segment[index] === "!";
+  if (negated) index += 1;
+  const characters = [];
+  while (index < segment.length) {
+    if (segment[index] === "]" && characters.length > 0) break;
+    let escaped = false;
+    if (segment[index] === "\\") {
+      escaped = true;
+      index += 1;
+      if (index === segment.length) {
+        return argumentError(method, "character classes must not end with an escape");
+      }
+    }
+    characters.push({ value: segment.charAt(index), escaped });
+    index += 1;
+  }
+  if (index === segment.length || characters.length === 0) {
+    return argumentError(method, "character classes must be closed and non-empty");
+  }
+  const literals = [];
+  const ranges = [];
+  for (let characterIndex = 0; characterIndex < characters.length; characterIndex++) {
+    const character = characters[characterIndex];
+    if (characterIndex + 2 < characters.length && characters[characterIndex + 1].value === "-" && !characters[characterIndex + 1].escaped && characters[characterIndex + 2].value !== "-") {
+      const end = characters[characterIndex + 2].value;
+      if (character.value > end) {
+        return argumentError(method, "character class ranges must be ascending");
+      }
+      ranges.push([character.value, end]);
+      characterIndex += 2;
+    } else {
+      literals.push(character.value);
+    }
+  }
+  return Effect.succeed([GlobToken.CharacterClass({ negated, ranges, literals }), index + 1]);
+};
+var parseGlobSegment = Effect.fnUntraced(function* (method, segment) {
+  if (segment === "**") return { _tag: "Globstar" };
+  const tokens = [];
+  let index = 0;
+  while (index < segment.length) {
+    const character = segment.charAt(index);
+    if (character === "\\") {
+      index += 1;
+      if (index === segment.length) {
+        return yield* argumentError(method, "patterns must not end with an escape");
+      }
+      const value = segment.charAt(index);
+      if (globSyntaxCharacters.has(value)) {
+        tokens.push(GlobToken.Literal({ value }));
+      } else {
+        tokens.push(GlobToken.Literal({ value: "\\" }));
+        index -= 1;
+      }
+    } else if (character === "*") {
+      tokens.push(GlobToken.Star());
+    } else if (character === "?") {
+      tokens.push(GlobToken.One());
+    } else if (character === "[") {
+      const parsed = yield* parseCharacterClass(method, segment, index);
+      tokens.push(parsed[0]);
+      index = parsed[1] - 1;
+    } else {
+      tokens.push(GlobToken.Literal({ value: character }));
+    }
+    index += 1;
+  }
+  return {
+    _tag: "Segment",
+    tokens,
+    startsWithDot: tokens[0]?._tag === "Literal" && tokens[0].value === "." || tokens[0]?._tag === "CharacterClass" && !tokens[0].negated && (tokens[0].literals.includes(".") || tokens[0].ranges.some(([start, end]) => start <= "." && "." <= end))
+  };
+});
+var compileGlobPattern = Effect.fnUntraced(function* (method, pattern) {
+  if (pattern.length === 0 || pattern.includes("\0") || pattern.startsWith("/")) {
+    return yield* argumentError(method, "pattern must be a root-relative POSIX glob");
+  }
+  const directoryOnly = pattern.endsWith("/");
+  const path = directoryOnly ? pattern.slice(0, -1) : pattern;
+  const segments = path.split("/");
+  if (segments.includes("") || segments.includes(".") || segments.includes("..")) {
+    return yield* argumentError(method, "pattern must not contain empty or dot path segments");
+  }
+  const compiled = yield* Effect.forEach(segments, (segment) => parseGlobSegment(method, segment));
+  return { segments: compiled, directoryOnly };
+});
+var compileGlobPatterns = Effect.fnUntraced(function* (method, pattern) {
+  const expanded = yield* expandBraces(method, pattern);
+  return yield* Effect.forEach(expanded, (alternative) => compileGlobPattern(method, alternative));
+});
+var matchesGlobToken = (token, value) => GlobToken.$match(token, {
+  Literal: (token2) => token2.value === value,
+  Star: () => false,
+  One: () => true,
+  CharacterClass: (token2) => {
+    const matches = token2.literals.includes(value) || token2.ranges.some(([start, end]) => start <= value && value <= end);
+    return token2.negated ? !matches : matches;
+  }
+});
+var matchesGlobSegment = (pattern, value) => {
+  if (value.startsWith(".") && !pattern.startsWithDot) return false;
+  let patternIndex = 0;
+  let valueIndex = 0;
+  let starIndex = -1;
+  let starValueIndex = -1;
+  while (valueIndex < value.length) {
+    const token = pattern.tokens[patternIndex];
+    if (token !== void 0 && token._tag !== "Star" && matchesGlobToken(token, value.charAt(valueIndex))) {
+      patternIndex += 1;
+      valueIndex += 1;
+    } else if (token?._tag === "Star") {
+      starIndex = patternIndex;
+      starValueIndex = valueIndex;
+      patternIndex += 1;
+    } else if (starIndex !== -1) {
+      patternIndex = starIndex + 1;
+      starValueIndex += 1;
+      valueIndex = starValueIndex;
+    } else {
+      return false;
+    }
+  }
+  while (pattern.tokens[patternIndex]?._tag === "Star") {
+    patternIndex += 1;
+  }
+  return patternIndex === pattern.tokens.length;
+};
+var matchesGlob = (pattern, path, directory) => {
+  if (pattern.directoryOnly && !directory) return false;
+  let next = Array.from({ length: path.length + 1 }, (_, index) => index === path.length);
+  for (let patternIndex = pattern.segments.length - 1; patternIndex >= 0; patternIndex--) {
+    const current = Array.from({ length: path.length + 1 }, () => false);
+    const segment = pattern.segments[patternIndex];
+    if (segment._tag === "Globstar") {
+      for (let pathIndex = path.length; pathIndex >= 0; pathIndex--) {
+        current[pathIndex] = next[pathIndex] || pathIndex < path.length && !path[pathIndex].startsWith(".") && current[pathIndex + 1];
+      }
+    } else {
+      for (let pathIndex = path.length - 1; pathIndex >= 0; pathIndex--) {
+        current[pathIndex] = matchesGlobSegment(segment, path[pathIndex]) && next[pathIndex + 1];
+      }
+    }
+    next = current;
+  }
+  return next[0];
+};
+
+// src/internal/memoryFileSystem.ts
+var argumentError2 = (method, description) => badArgument2({ module: "FileSystem", method, description });
+var resourceError = (method, pathOrDescriptor, description) => systemError({
+  module: "FileSystem",
+  method,
+  pathOrDescriptor,
+  _tag: "BadResource",
+  ...description === void 0 ? {} : { description }
+});
+var translate = (error, method, pathOrDescriptor) => {
+  if (error.code === "InvalidArgument") return argumentError2(method, error.code);
+  const tags = {
+    NotFound: "NotFound",
+    AlreadyExists: "AlreadyExists",
+    AccessDenied: "PermissionDenied",
+    InvalidPathEncoding: "InvalidData",
+    UnrepresentableName: "InvalidData",
+    PathTooLong: "InvalidData"
+  };
+  return systemError({
+    module: "FileSystem",
+    method,
+    pathOrDescriptor,
+    _tag: tags[error.code] ?? "BadResource",
+    description: error.code
+  });
+};
+var mapped = (effect2, method, path) => effect2.pipe(Effect2.mapError((error) => translate(error, method, path)));
+var info = Effect2.fnUntraced(function* (value, pathOrDescriptor) {
+  const date = (field) => {
+    const result2 = DateTime.make(Number(value[field] / 1000000n));
+    return Option.isSome(result2) ? Effect2.succeed(Option.some(DateTime.toDateUtc(result2.value))) : Effect2.fail(systemError({
+      module: "FileSystem",
+      method: "stat",
+      pathOrDescriptor,
+      _tag: "InvalidData",
+      description: `${field} cannot be represented as a JavaScript Date`
+    }));
+  };
+  return {
+    type: value.kind === "file" ? "File" : value.kind === "directory" ? "Directory" : "SymbolicLink",
+    ino: Option.some(Number(value.ino)),
+    dev: 0,
+    mode: value.mode | (value.kind === "file" ? 32768 : value.kind === "directory" ? 16384 : 40960),
+    uid: Option.some(value.uid),
+    gid: Option.some(value.gid),
+    nlink: Option.some(value.nlink),
+    rdev: Option.some(0),
+    size: FileSystem.Size(value.size),
+    blksize: Option.none(),
+    blocks: Option.none(),
+    atime: yield* date("atimeNs"),
+    mtime: yield* date("mtimeNs"),
+    birthtime: yield* date("birthtimeNs")
+  };
+});
+var validateMode = (mode, method) => mode === void 0 || Number.isInteger(mode) && mode >= 0 && mode <= 4294967295 ? Effect2.void : Effect2.fail(argumentError2(method, "mode must be an unsigned 32-bit integer"));
+var sizeInput = (size, method) => {
+  const number = Number(size ?? 0);
+  return Number.isSafeInteger(number) && number >= 0 ? Effect2.succeed(BigInt(number)) : Effect2.fail(argumentError2(method, "size must be a non-negative safe integer"));
+};
+var openOptions = Effect2.fnUntraced(function* (flag, mode, method) {
+  if (!["r", "r+", "w", "wx", "w+", "wx+", "a", "ax", "a+", "ax+"].includes(flag)) {
+    return yield* argumentError2(method, "Unsupported open flag");
+  }
+  yield* validateMode(mode, method);
+  const create = flag.startsWith("w") || flag.startsWith("a");
+  return {
+    access: flag === "r" ? "read" : flag.endsWith("+") ? "readWrite" : "write",
+    create: create ? flag.includes("x") ? "exclusive" : "ifMissing" : "never",
+    ...create ? { mode: (mode ?? 420) & 4095 } : {},
+    append: flag.startsWith("a"),
+    truncate: flag.startsWith("w")
+  };
+});
+var childPath = (parent, name) => parent === "/" ? `/${name}` : `${parent}/${name}`;
+var textPath = Effect2.fnUntraced(function* (path, method) {
+  const bytes = yield* Vfs.pathToBytes(path);
+  return yield* Effect2.try({
+    try: () => new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes),
+    catch: () => new Vfs.FsError({ code: "UnrepresentableName", operation: method })
+  });
+});
+var bind = Effect2.fn("MemoryFileSystem.bind")(function* (volume, options) {
+  const caller = yield* volume.caller({ ...options, umask: options?.umask ?? 0 });
+  let nextDescriptor = 3;
+  let nextTemporary = 1;
+  const makeDirectory = Effect2.fn("MemoryFileSystem.makeDirectory")(
+    function* (path, options2) {
+      yield* validateMode(options2?.mode, "makeDirectory");
+      const mode = (options2?.mode ?? 493) & 4095;
+      if (!options2?.recursive) return yield* mapped(caller.mkdir(path, { mode }), "makeDirectory", path);
+      return yield* mapped(
+        Effect2.scoped(Effect2.gen(function* () {
+          if (path === "") return yield* new Vfs.FsError({ code: "NotFound", operation: "makeDirectory" });
+          let base = yield* caller.openDirectory("/");
+          const components = path.split("/").filter((part) => part.length > 0);
+          for (const [index, name] of components.entries()) {
+            const result2 = yield* Effect2.result(caller.mkdir(name, { relativeTo: base, mode }));
+            if (result2._tag === "Failure" && result2.failure.code !== "AlreadyExists") return yield* result2.failure;
+            const next = yield* caller.openDirectory(name, { relativeTo: base }).pipe(
+              Effect2.mapError(
+                (error) => error.code === "NotDirectory" && index === components.length - 1 ? new Vfs.FsError({ code: "AlreadyExists", operation: "makeDirectory" }) : error
+              )
+            );
+            yield* base.close;
+            base = next;
+          }
+        })),
+        "makeDirectory",
+        path
+      );
+    }
+  );
+  const open = Effect2.fn("MemoryFileSystem.open")(function* (path, options2) {
+    const chosen = yield* openOptions(options2?.flag ?? "r", options2?.mode, "open");
+    const handle = yield* mapped(caller.open(path, chosen), "open", path);
+    const fd = nextDescriptor++;
+    let position = 0n;
+    let closed = false;
+    const gate = Semaphore.makeUnsafe(1);
+    const locked = (effect2) => gate.withPermit(Effect2.uninterruptible(effect2));
+    yield* Effect2.addFinalizer(
+      () => locked(Effect2.sync(() => {
+        closed = true;
+      }))
+    );
+    const read = Effect2.fnUntraced(function* (length, method) {
+      if (closed) return yield* resourceError(method, fd);
+      if (length > 0 && (position < 0n || position > BigInt(Number.MAX_SAFE_INTEGER))) {
+        return yield* resourceError(method, fd, "Invalid file position");
+      }
+      const bytes = yield* mapped(handle.pread(length, length === 0 ? 0n : position), method, fd);
+      position += BigInt(bytes.length);
+      return bytes;
+    });
+    const write = Effect2.fnUntraced(function* (input, method, all) {
+      const bytes = new Uint8Array(input);
+      return yield* locked(Effect2.gen(function* () {
+        if (closed) return yield* resourceError(method, fd);
+        if (bytes.length > 0 && (position < 0n || position > BigInt(Number.MAX_SAFE_INTEGER))) {
+          return yield* resourceError(method, fd, "Invalid file position");
+        }
+        let total = 0;
+        do {
+          const part = bytes.subarray(total);
+          const written = yield* mapped(
+            chosen.append ? handle.write(part) : handle.pwrite(part, bytes.length === 0 ? 0n : position),
+            method,
+            fd
+          );
+          total += written;
+          if (!chosen.append) position += BigInt(written);
+        } while (all && total < bytes.length);
+        return FileSystem.Size(total);
+      }));
+    });
+    return {
+      [FileSystem.FileTypeId]: FileSystem.FileTypeId,
+      stat: mapped(handle.stat, "stat", fd).pipe(Effect2.flatMap((value) => info(value, fd))),
+      sync: mapped(handle.sync, "sync", fd),
+      seek: Effect2.fn("MemoryFile.seek")(function* (offset, from) {
+        return yield* locked(Effect2.sync(() => {
+          if (closed) return FileSystem.Size(0);
+          position = from === "start" ? FileSystem.Size(offset) : position + FileSystem.Size(offset);
+          return FileSystem.Size(position);
+        }));
+      }),
+      read: Effect2.fn("MemoryFile.read")(function* (buffer) {
+        return yield* locked(Effect2.gen(function* () {
+          const bytes = yield* read(buffer.length, "read");
+          buffer.set(bytes);
+          return FileSystem.Size(bytes.length);
+        }));
+      }),
+      readAlloc: Effect2.fn("MemoryFile.readAlloc")(function* (size) {
+        const length = yield* sizeInput(size, "readAlloc");
+        return yield* locked(
+          Effect2.map(
+            read(Number(length), "readAlloc"),
+            (bytes) => bytes.length === 0 ? Option.none() : Option.some(bytes)
+          )
+        );
+      }),
+      truncate: Effect2.fn("MemoryFile.truncate")(function* (length) {
+        const size = yield* sizeInput(length, "truncate");
+        return yield* locked(Effect2.gen(function* () {
+          yield* mapped(handle.truncate(size), "truncate", fd);
+          if (!chosen.append && position > size) position = size;
+        }));
+      }),
+      write: (buffer) => write(buffer, "write", false),
+      writeAll: (buffer) => Effect2.asVoid(write(buffer, "writeAll", true))
+    };
+  });
+  const walk = Effect2.fnUntraced(function* (path) {
+    const root = yield* caller.openDirectory(path);
+    const pending = [{ base: root, prefix: "" }];
+    const output = [];
+    while (pending.length > 0) {
+      const next = pending.pop();
+      if (next === void 0) break;
+      const names = yield* caller.readDirectory(".", { relativeTo: next.base });
+      for (const name of names) {
+        const relative = next.prefix === "" ? name : `${next.prefix}/${name}`;
+        const metadata = yield* caller.lstat(name, { relativeTo: next.base });
+        output.push({ relative, base: next.base, name, metadata });
+        if (metadata.kind === "directory") {
+          pending.push({ base: yield* caller.openDirectory(name, { relativeTo: next.base }), prefix: relative });
+        }
+      }
+    }
+    return output;
+  });
+  const remove = Effect2.fn("MemoryFileSystem.remove")(function* (path, options2) {
+    const name = path.split("/").filter((part) => part.length > 0).at(-1);
+    if (name === void 0 || name === "." || name === "..") {
+      return yield* resourceError("remove", path, "Cannot remove root or dot entries");
+    }
+    const action = Effect2.scoped(Effect2.gen(function* () {
+      const node = yield* caller.lstat(path);
+      if (node.kind !== "directory") return yield* caller.unlink(path);
+      if (options2?.recursive) {
+        const entries = yield* walk(path);
+        for (let i = entries.length - 1; i >= 0; i--) {
+          const entry = entries[i];
+          if (entry === void 0) continue;
+          const relative = { relativeTo: entry.base };
+          yield* entry.metadata.kind === "directory" ? caller.rmdir(entry.name, relative) : caller.unlink(entry.name, relative);
+        }
+      }
+      yield* caller.rmdir(path);
+    }));
+    return yield* mapped(
+      options2?.force ? action.pipe(Effect2.catchIf((error) => error.code === "NotFound", () => Effect2.void)) : action,
+      "remove",
+      path
+    );
+  });
+  const readDirectory = Effect2.fn("MemoryFileSystem.readDirectory")(
+    function* (path, options2) {
+      return yield* mapped(
+        options2?.recursive ? Effect2.scoped(walk(path)).pipe(Effect2.map((entries) => entries.map((entry) => entry.relative).sort())) : caller.readDirectory(path).pipe(Effect2.map((names) => [...names].sort())),
+        "readDirectory",
+        path
+      );
+    }
+  );
+  const writeCopiedFile = (destination, bytes, mode, options2) => caller.writeFile(destination, bytes, {
+    ...options2,
+    access: "write",
+    truncate: true,
+    mode,
+    finalMode: mode
+  });
+  const copy = Effect2.fn("MemoryFileSystem.copy")(
+    function* (source, destination, options2) {
+      return yield* mapped(
+        Effect2.scoped(Effect2.gen(function* () {
+          const sourceNode = yield* caller.lstat(source);
+          const existing = yield* Effect2.result(caller.lstat(destination));
+          if (existing._tag === "Failure" && existing.failure.code !== "NotFound") return yield* existing.failure;
+          if (existing._tag === "Success" && existing.success.ino === sourceNode.ino) {
+            return yield* new Vfs.FsError({ code: "InvalidArgument", operation: "copy" });
+          }
+          if (existing._tag === "Success" && !options2?.overwrite) {
+            return yield* new Vfs.FsError({ code: "AlreadyExists", operation: "copy" });
+          }
+          if (sourceNode.kind === "file") {
+            const bytes = yield* caller.readFile(source);
+            yield* writeCopiedFile(destination, bytes, sourceNode.mode, {
+              create: options2?.overwrite ? "ifMissing" : "exclusive",
+              replaceFinalSymlink: true
+            });
+          } else if (sourceNode.kind === "symlink") {
+            if (existing._tag === "Success") {
+              yield* caller.unlink(destination);
+            }
+            yield* caller.symlink(yield* caller.readLink(source), destination);
+          } else {
+            const canonicalSource = yield* caller.realPath(source);
+            const trimmed = destination.replace(/\/+$/, "") || "/";
+            const slash = trimmed.lastIndexOf("/");
+            const parentPath = slash <= 0 ? "/" : trimmed.slice(0, slash);
+            const parent = yield* caller.realPath(parentPath);
+            if (parent === canonicalSource || parent.startsWith(`${canonicalSource}/`)) {
+              return yield* new Vfs.FsError({ code: "InvalidArgument", operation: "copy" });
+            }
+            const entries = yield* walk(source);
+            if (existing._tag === "Failure") {
+              yield* caller.mkdir(destination, { mode: sourceNode.mode });
+            } else if (existing.success.kind !== "directory") {
+              return yield* new Vfs.FsError({ code: "NotDirectory", operation: "copy" });
+            }
+            const copiedNodes = /* @__PURE__ */ new Map();
+            const directoryTimes = [];
+            const bases = /* @__PURE__ */ new Map([["", yield* caller.openDirectory(destination)]]);
+            for (const entry of entries) {
+              const split = entry.relative.lastIndexOf("/");
+              const parent2 = bases.get(split < 0 ? "" : entry.relative.slice(0, split));
+              if (parent2 === void 0) {
+                return yield* new Vfs.FsError({ code: "NotFound", operation: "copy" });
+              }
+              const relative = { relativeTo: parent2 };
+              if (entry.metadata.kind === "directory") {
+                const made = yield* Effect2.result(caller.mkdir(entry.name, { ...relative, mode: entry.metadata.mode }));
+                if (made._tag === "Failure" && (!options2?.overwrite || made.failure.code !== "AlreadyExists")) {
+                  return yield* made.failure;
+                }
+                bases.set(entry.relative, yield* caller.openDirectory(entry.name, relative));
+              } else if (entry.metadata.kind === "file") {
+                const previous = copiedNodes.get(entry.metadata.ino);
+                const existing2 = yield* Effect2.result(caller.lstat(entry.name, relative));
+                if (previous !== void 0 && existing2._tag === "Failure" && existing2.failure.code === "NotFound") {
+                  yield* caller.link(previous.name, entry.name, {
+                    sourceRelativeTo: previous.base,
+                    destinationRelativeTo: parent2
+                  });
+                } else {
+                  yield* writeCopiedFile(
+                    entry.name,
+                    yield* caller.readFile(entry.name, { relativeTo: entry.base }),
+                    entry.metadata.mode,
+                    {
+                      ...relative,
+                      create: options2?.overwrite ? "ifMissing" : "exclusive",
+                      replaceFinalSymlink: true
+                    }
+                  );
+                  copiedNodes.set(entry.metadata.ino, { base: parent2, name: entry.name });
+                }
+              } else {
+                const previous = copiedNodes.get(entry.metadata.ino);
+                const existing2 = yield* Effect2.result(caller.lstat(entry.name, relative));
+                if (existing2._tag === "Success") {
+                  if (!options2?.overwrite) {
+                    return yield* new Vfs.FsError({ code: "AlreadyExists", operation: "copy" });
+                  }
+                  yield* caller.unlink(entry.name, relative);
+                } else if (existing2.failure.code !== "NotFound") return yield* existing2.failure;
+                if (previous !== void 0) {
+                  yield* caller.link(previous.name, entry.name, {
+                    sourceRelativeTo: previous.base,
+                    destinationRelativeTo: parent2
+                  });
+                } else {
+                  yield* caller.symlink(
+                    yield* caller.readLink(entry.name, { relativeTo: entry.base }),
+                    entry.name,
+                    relative
+                  );
+                  copiedNodes.set(entry.metadata.ino, { base: parent2, name: entry.name });
+                }
+              }
+              if (options2?.preserveTimestamps && entry.metadata.kind === "directory") {
+                directoryTimes.push({ base: parent2, name: entry.name, metadata: entry.metadata });
+              }
+              if (options2?.preserveTimestamps && entry.metadata.kind !== "directory") {
+                yield* caller.utimes(entry.name, {
+                  access: { kind: "value", nanoseconds: entry.metadata.atimeNs },
+                  modification: { kind: "value", nanoseconds: entry.metadata.mtimeNs }
+                }, { ...relative, followFinalSymlink: false });
+              }
+            }
+            for (const directory of directoryTimes.reverse()) {
+              yield* caller.utimes(directory.name, {
+                access: { kind: "value", nanoseconds: directory.metadata.atimeNs },
+                modification: { kind: "value", nanoseconds: directory.metadata.mtimeNs }
+              }, { relativeTo: directory.base });
+            }
+          }
+          if (options2?.preserveTimestamps) {
+            yield* caller.utimes(destination, {
+              access: { kind: "value", nanoseconds: sourceNode.atimeNs },
+              modification: { kind: "value", nanoseconds: sourceNode.mtimeNs }
+            }, { followFinalSymlink: false });
+          }
+        })),
+        "copy",
+        source
+      );
+    }
+  );
+  const copyFile = Effect2.fn("MemoryFileSystem.copyFile")(
+    function* (source, destination) {
+      return yield* mapped(
+        Effect2.gen(function* () {
+          const metadata = yield* caller.stat(source);
+          if (metadata.kind !== "file") return yield* new Vfs.FsError({ code: "IsDirectory", operation: "copyFile" });
+          const target = yield* Effect2.result(caller.stat(destination));
+          if (target._tag === "Success" && target.success.ino === metadata.ino) return;
+          yield* writeCopiedFile(destination, yield* caller.readFile(source), metadata.mode, { create: "ifMissing" });
+        }),
+        "copyFile",
+        source
+      );
+    }
+  );
+  const temp = Effect2.fnUntraced(
+    function* (method, file, options2) {
+      for (const value of [options2?.prefix ?? "", options2?.suffix ?? ""]) {
+        if (value.includes("/") || value.includes("\0")) {
+          return yield* argumentError2(method, "temporary fragments cannot contain separators");
+        }
+      }
+      const parent = yield* mapped(caller.realPath(options2?.directory ?? "/tmp"), method, options2?.directory ?? "/tmp");
+      while (true) {
+        const directory = childPath(
+          parent,
+          `${options2?.prefix ?? ""}${(nextTemporary++).toString(36).padStart(8, "0")}`
+        );
+        const result2 = yield* Effect2.result(caller.mkdir(directory));
+        if (result2._tag === "Failure") {
+          if (result2.failure.code === "AlreadyExists") continue;
+          return yield* translate(result2.failure, method, directory);
+        }
+        if (!file) return directory;
+        const path = childPath(directory, `${(nextTemporary++).toString(36).padStart(8, "0")}${options2?.suffix ?? ""}`);
+        yield* mapped(
+          caller.writeFile(path, new Uint8Array(0), { access: "write", create: "exclusive", mode: 420 }),
+          method,
+          path
+        ).pipe(Effect2.onError(() => remove(directory, { recursive: true, force: true }).pipe(Effect2.orDie)));
+        return path;
+      }
+    }
+  );
+  return FileSystem.make({
+    access: (path) => mapped(Effect2.asVoid(caller.stat(path)), "access", path),
+    stat: (path) => mapped(caller.stat(path), "stat", path).pipe(Effect2.flatMap((value) => info(value, path))),
+    chmod: Effect2.fn("MemoryFileSystem.chmod")(function* (path, mode) {
+      yield* validateMode(mode, "chmod");
+      yield* mapped(caller.chmod(path, mode & 4095), "chmod", path);
+    }),
+    chown: Effect2.fn("MemoryFileSystem.chown")(function* (path, uid, gid) {
+      if (![uid, gid].every((id) => Number.isInteger(id) && id >= 0 && id <= 4294967295)) {
+        return yield* argumentError2("chown", "owner IDs must be unsigned 32-bit integers");
+      }
+      yield* mapped(caller.chown(path, { uid, gid }), "chown", path);
+    }),
+    utimes: Effect2.fn("MemoryFileSystem.utimes")(function* (path, atime, mtime) {
+      const access = typeof atime === "number" ? atime * 1e3 : atime.getTime();
+      const modification = typeof mtime === "number" ? mtime * 1e3 : mtime.getTime();
+      if (![access, modification].every((value) => Number.isFinite(value) && Math.abs(value) <= 864e13)) {
+        return yield* argumentError2("utimes", "timestamps must be valid dates");
+      }
+      yield* mapped(
+        caller.utimes(path, {
+          access: { kind: "value", nanoseconds: BigInt(Math.trunc(access)) * 1000000n },
+          modification: { kind: "value", nanoseconds: BigInt(Math.trunc(modification)) * 1000000n }
+        }),
+        "utimes",
+        path
+      );
+    }),
+    open,
+    makeDirectory,
+    readDirectory,
+    remove,
+    copy,
+    copyFile,
+    readFile: (path) => mapped(caller.readFile(path), "readFile", path),
+    writeFile: Effect2.fn("MemoryFileSystem.writeFile")(function* (path, data, options2) {
+      const bytes = new Uint8Array(data);
+      const chosen = yield* openOptions(options2?.flag ?? "w", options2?.mode, "writeFile");
+      yield* mapped(caller.writeFile(path, bytes, chosen), "writeFile", path);
+    }),
+    readLink: (path) => mapped(caller.readLink(path), "readLink", path),
+    realPath: (path) => mapped(caller.realPath(path), "realPath", path),
+    rename: Effect2.fn("MemoryFileSystem.rename")(
+      function* (source, destination) {
+        const sourceInfo = yield* caller.lstat(source);
+        const target = sourceInfo.kind === "directory" && destination.endsWith("/") ? destination.replace(/\/+$/, "") || "/" : destination;
+        yield* caller.rename(source, target);
+      },
+      (effect2, source) => mapped(effect2, "rename", source)
+    ),
+    link: (source, destination) => mapped(caller.link(source, destination), "link", source),
+    symlink: (target, path) => mapped(caller.symlink(target, path), "symlink", path),
+    truncate: Effect2.fn("MemoryFileSystem.truncate")(function* (path, length) {
+      yield* mapped(caller.truncate(path, yield* sizeInput(length, "truncate")), "truncate", path);
+    }),
+    makeTempDirectory: (options2) => temp("makeTempDirectory", false, options2),
+    makeTempFile: (options2) => temp("makeTempFile", true, options2),
+    makeTempDirectoryScoped: (options2) => Effect2.acquireRelease(
+      temp("makeTempDirectoryScoped", false, options2),
+      (path) => remove(path, { recursive: true, force: true }).pipe(Effect2.orDie)
+    ),
+    makeTempFileScoped: (options2) => Effect2.acquireRelease(
+      temp("makeTempFileScoped", true, options2),
+      (path) => remove(path.slice(0, path.lastIndexOf("/")), { recursive: true, force: true }).pipe(Effect2.orDie)
+    ),
+    watch: (path, options2) => Stream.unwrap(Effect2.gen(function* () {
+      const stream = yield* volume.watch;
+      const resolved = yield* mapped(caller.realPath(path), "stat", path);
+      const prefix = new TextEncoder().encode(resolved);
+      return stream.pipe(
+        Stream.filterEffect(
+          (event) => mapped(Vfs.pathToBytes(event.path), "watch", path).pipe(Effect2.map((bytes) => {
+            if (!prefix.every((byte, index) => bytes[index] === byte)) return false;
+            if (bytes.length === prefix.length) return true;
+            const start = resolved === "/" ? 1 : prefix.length + 1;
+            if (resolved !== "/" && bytes[prefix.length] !== 47) return false;
+            return options2?.recursive === true || !bytes.subarray(start).includes(47);
+          }))
+        ),
+        Stream.mapEffect(
+          (event) => mapped(textPath(event.path, "watch"), "watch", path).pipe(
+            Effect2.map((name) => ({ _tag: event._tag, path: name }))
+          )
+        )
+      );
+    })),
+    glob: Effect2.fn("MemoryFileSystem.glob")(function* (pattern, options2) {
+      const include = yield* compileGlobPatterns("glob", pattern);
+      const exclude = (yield* Effect2.forEach(options2?.exclude ?? [], (pattern2) => compileGlobPatterns("glob", pattern2))).flat();
+      return yield* mapped(
+        Effect2.scoped(Effect2.gen(function* () {
+          const entries = yield* walk(options2?.root ?? "/");
+          if (exclude.some((pattern2) => matchesGlob(pattern2, [], true))) return [];
+          const output = include.some((pattern2) => matchesGlob(pattern2, [], true)) ? ["."] : [];
+          const excludedDirectories = [];
+          for (const entry of entries) {
+            const parts = entry.relative.split("/");
+            const directory = entry.metadata.kind === "directory";
+            const excluded = excludedDirectories.some((prefix) => entry.relative.startsWith(`${prefix}/`)) || exclude.some((pattern2) => matchesGlob(pattern2, parts, directory));
+            if (excluded) {
+              if (directory) excludedDirectories.push(entry.relative);
+              continue;
+            }
+            if (include.some((pattern2) => matchesGlob(pattern2, parts, directory))) output.push(entry.relative);
+          }
+          return output.sort();
+        })),
+        "glob",
+        options2?.root ?? "/"
+      );
+    })
+  });
+});
+var make3 = Effect2.gen(function* () {
+  const volume = yield* Vfs.fromFixture({ entries: [{ kind: "directory", path: "/tmp" }] });
+  return yield* bind(volume);
+}).pipe(Effect2.orDie);
+var layer = Layer.effect(FileSystem.FileSystem, make3);
+
+// src/MemoryFileSystem.ts
+var make4 = make3;
+var layer2 = layer;
+var bind2 = bind;
+
+export {
+  make4 as make,
+  layer2 as layer,
+  bind2 as bind,
+  MemoryFileSystem_exports
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * In-memory `FileSystem` constructors and layers.
+ *
+ * @category modules
+ * @since 0.1.0
+ */
+export * as MemoryFileSystem from "./MemoryFileSystem.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA"}

package/dist/index.js

@@ -0,0 +1,6 @@
+import {
+  MemoryFileSystem_exports
+} from "./chunk-GXCMBMOL.js";
+export {
+  MemoryFileSystem_exports as MemoryFileSystem
+};

package/dist/internal/glob.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Compiles and matches the bounded POSIX glob syntax used by the memory adapter.
+ *
+ * @internal
+ */
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+interface GlobLiteral {
+    readonly _tag: "Literal";
+    readonly value: string;
+}
+interface GlobStar {
+    readonly _tag: "Star";
+}
+interface GlobOne {
+    readonly _tag: "One";
+}
+interface GlobCharacterClass {
+    readonly _tag: "CharacterClass";
+    readonly negated: boolean;
+    readonly ranges: ReadonlyArray<readonly [string, string]>;
+    readonly literals: ReadonlyArray<string>;
+}
+type GlobToken = GlobLiteral | GlobStar | GlobOne | GlobCharacterClass;
+declare const GlobToken: {
+    readonly $is: <Tag extends "CharacterClass" | "Literal" | "One" | "Star">(tag: Tag) => (u: unknown) => u is Extract<GlobCharacterClass, {
+        readonly _tag: Tag;
+    }> | Extract<GlobLiteral, {
+        readonly _tag: Tag;
+    }> | Extract<GlobOne, {
+        readonly _tag: Tag;
+    }> | Extract<GlobStar, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends { readonly [Tag in "CharacterClass" | "Literal" | "One" | "Star"]: (args: Extract<GlobToken, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: GlobToken) => import("effect/Unify").Unify<ReturnType<Cases["CharacterClass" | "Literal" | "One" | "Star"]>>;
+        <Cases extends { readonly [Tag in "CharacterClass" | "Literal" | "One" | "Star"]: (args: Extract<GlobToken, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: GlobToken, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["CharacterClass" | "Literal" | "One" | "Star"]>>;
+    };
+    readonly CharacterClass: Data.TaggedEnum.ConstructorFrom<GlobCharacterClass, "_tag">;
+    readonly Literal: Data.TaggedEnum.ConstructorFrom<GlobLiteral, "_tag">;
+    readonly One: Data.TaggedEnum.ConstructorFrom<GlobOne, "_tag">;
+    readonly Star: Data.TaggedEnum.ConstructorFrom<GlobStar, "_tag">;
+};
+interface GlobSegment {
+    readonly _tag: "Segment";
+    readonly tokens: ReadonlyArray<GlobToken>;
+    readonly startsWithDot: boolean;
+}
+interface GlobGlobstar {
+    readonly _tag: "Globstar";
+}
+type CompiledGlobSegment = GlobSegment | GlobGlobstar;
+interface CompiledGlobPattern {
+    readonly segments: ReadonlyArray<CompiledGlobSegment>;
+    readonly directoryOnly: boolean;
+}
+/** @internal */
+export declare const compileGlobPatterns: (method: string, pattern: string) => Effect.Effect<{
+    segments: ({
+        _tag: "Globstar";
+        tokens?: never;
+        startsWithDot?: never;
+    } | {
+        _tag: "Segment";
+        tokens: GlobToken[];
+        startsWithDot: boolean;
+    })[];
+    directoryOnly: boolean;
+}[], import("effect/PlatformError").PlatformError, never>;
+/** @internal */
+export declare const matchesGlob: (pattern: CompiledGlobPattern, path: ReadonlyArray<string>, directory: boolean) => boolean;
+export {};
+//# sourceMappingURL=glob.d.ts.map

package/dist/internal/glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../src/internal/glob.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAOvC,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED,UAAU,QAAQ;IAChB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,UAAU,OAAO;IACf,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CACrB;AAED,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACzD,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACzC;AAED,KAAK,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,OAAO,GAAG,kBAAkB,CAAA;AAEtE,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;CAA+B,CAAA;AAE9C,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;IACzC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;CAChC;AAED,UAAU,YAAY;IACpB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAC1B;AAED,KAAK,mBAAmB,GAAG,WAAW,GAAG,YAAY,CAAA;AAErD,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAA;IACrD,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;CAChC;AA+LD,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;yDAG9B,CAAA;AA2CF,gBAAgB;AAChB,eAAO,MAAM,WAAW,YAAa,mBAAmB,QAAQ,aAAa,CAAC,MAAM,CAAC,aAAa,OAAO,KAAG,OAsB3G,CAAA"}

package/dist/internal/memoryFileSystem.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Implements the Effect `FileSystem` adapter over `@effect-vfs/core`.
+ *
+ * This module owns string-path conversion, Effect cursor compatibility, error
+ * translation, recursive helpers, temporary resources, globbing, and watches.
+ *
+ * @internal
+ */
+import { VirtualFileSystem as Vfs } from "@effect-vfs/core";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+/** @internal */
+export declare const bind: (volume: Vfs.Volume, options?: {
+    readonly identity?: {
+        readonly uid: number;
+        readonly gid: number;
+        readonly groups: readonly number[];
+        readonly privileged: boolean;
+    };
+    readonly umask?: number;
+} | undefined) => Effect.Effect<FileSystem.FileSystem, Vfs.ConfigurationError, never>;
+/** @internal */
+export declare const make: Effect.Effect<FileSystem.FileSystem>;
+/** @internal */
+export declare const layer: Layer.Layer<FileSystem.FileSystem, never, never>;
+//# sourceMappingURL=memoryFileSystem.d.ts.map

package/dist/internal/memoryFileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryFileSystem.d.ts","sourceRoot":"","sources":["../../src/internal/memoryFileSystem.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,iBAAiB,IAAI,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAE3D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAuGrC,gBAAgB;AAChB,eAAO,MAAM,IAAI;;;;;;;;qFAgef,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,CAGjC,CAAA;AAErB,gBAAgB;AAChB,eAAO,MAAM,KAAK,kDAA4C,CAAA"}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@effect-vfs/memory",
+  "version": "0.0.1",
+  "description": "An in-memory implementation of Effect's FileSystem service.",
+  "homepage": "https://github.com/lloydrichards/effect-virtual-fs#readme",
+  "bugs": {
+    "url": "https://github.com/lloydrichards/effect-virtual-fs/issues"
+  },
+  "keywords": ["effect", "filesystem", "memory", "testing", "typescript"],
+  "type": "module",
+  "sideEffects": false,
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./MemoryFileSystem": {
+      "types": "./dist/MemoryFileSystem.d.ts",
+      "import": "./dist/MemoryFileSystem.js"
+    },
+    "./internal/*": null,
+    "./index": null,
+    "./*/index": null,
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/**",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lloydrichards/effect-virtual-fs.git",
+    "directory": "packages/memory"
+  },
+  "scripts": {
+    "build": "tsup && tsc --project tsconfig.build.json && tsc --project compatibility/node-next/tsconfig.json && bun build compatibility/browser/index.ts --target=browser --outdir=.cache/browser && node compatibility/browser/check.mjs",
+    "clean": "git clean -xdf .cache .turbo dist node_modules tsconfig.tsbuildinfo",
+    "test": "vitest run",
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-rc.112"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-rc.112",
+    "@repo/config-typescript": "workspace:*",
+    "effect": "4.0.0-rc.112",
+    "tsup": "8.5.1"
+  },
+  "dependencies": {
+    "@effect-vfs/core": "^0.0.1"
+  }
+}