@xandreed/core 0.12.0 → 0.14.0

package/dist/workspace/file-system.conformance.js

@@ -0,0 +1,254 @@
+import { Effect } from "effect";
+import { check, expect, fail } from "../conformance.functions.js";
+const show = (value) => JSON.stringify(value), decoded = (bytes) => new TextDecoder().decode(bytes), entries = (listed) => listed.map((entry) => `${entry.name}:${entry.kind}`).join("|"), under = (root, relative) => root.endsWith("/") ? `${root}${relative}` : `${root}/${relative}`, refuses = (id, what, effect, reason, path) => Effect.result(effect).pipe(Effect.flatMap((result) => {
+  if (result._tag === "Success")
+    return fail(id, `${what} succeeded; it must fail with ${reason}`);
+  const error = result.failure;
+  return expect(id, error._tag === "FsError" && error.reason === reason && (path === void 0 || error.path === path), `${what} failed with ${show({ tag: error._tag, reason: error.reason, path: error.path })}, not ${reason}${path === void 0 ? "" : ` for ${path}`}`);
+})), globTree = ({ fs, root, symlink }) => Effect.gen(function* () {
+  const files = [
+    ".hidden/h.ts",
+    "docs/x.md",
+    "file1.txt",
+    "file2.txt",
+    "file10.txt",
+    "node_modules/m/i.ts",
+    "top.ts",
+    "src/.dot.ts",
+    "src/a.ts",
+    "src/b.ts",
+    "src/c.js",
+    "src/deep/d.ts",
+    "src/deep/deeper/e.ts"
+  ];
+  yield* Effect.forEach(files, (file) => fs.write(under(root, file), file, { createParents: !0 }), { discard: !0 });
+  yield* symlink(under(root, "top.ts"), under(root, "link.ts"));
+  yield* symlink(under(root, "src"), under(root, "linked"));
+});
+export const fileSystemConformance = (subject) => {
+  const fsCheck = (name, id, body) => check(name, id, () => Effect.timeoutOrElse(Effect.scoped(subject.open.pipe(Effect.flatMap((fixture) => body(fixture, (relative) => under(fixture.root, relative))))), {
+    duration: "30 seconds",
+    orElse: () => fail(id, "the check did not finish in 30 seconds")
+  })), globs = (id, fixture) => (pattern, options, expected, truncated = !1) => fixture.fs.glob(pattern, { ...options, cwd: fixture.root }).pipe(Effect.flatMap((result) => expect(id, result.paths.join("|") === expected.join("|") && result.truncated === truncated, `glob ${show(pattern)} ${show(options)} gave ${show(result)}, not ${show({ paths: expected, truncated })}`)));
+  return [
+    fsCheck("text and bytes read back exactly as written, UTF-8 included, and a write replaces the whole file", "read-write", ({ fs }, at) => Effect.gen(function* () {
+      const sample = `h\xE9llo \u2713 \u65E5\u672C\u8A9E \uD83D\uDE80
+second line
+`;
+      yield* fs.write(at("text.txt"), sample);
+      const back = yield* fs.read(at("text.txt"));
+      yield* expect("read-write", back === sample, `read ${show(back)} after writing ${show(sample)}`);
+      yield* fs.write(at("text.txt"), "short");
+      const replaced = yield* fs.read(at("text.txt"));
+      yield* expect("read-write", replaced === "short", `a shorter second write left ${show(replaced)}`);
+      const binary = Uint8Array.from([0, 255, 128, 10, 13, 0, 7]);
+      yield* fs.write(at("data.bin"), binary);
+      const raw = yield* fs.readBytes(at("data.bin"));
+      yield* expect("read-write", raw.join() === binary.join(), `readBytes returned [${raw.join()}] after writing [${binary.join()}]`);
+      const textBytes = yield* fs.readBytes(at("text.txt"));
+      yield* expect("read-write", decoded(textBytes) === "short", `readBytes of a text file returned ${show(decoded(textBytes))}`);
+      yield* fs.mkdir(at("dir"));
+      yield* refuses("read-write", "reading a missing file", fs.read(at("missing.txt")), "NotFound", at("missing.txt"));
+      yield* refuses("read-write", "reading a directory", fs.read(at("dir")), "IsDirectory", at("dir"));
+      yield* refuses("read-write", "writing over a directory", fs.write(at("dir"), "x"), "IsDirectory", at("dir"));
+      yield* fs.write(at("plain"), "a file");
+      yield* refuses("read-write", "writing below a file", fs.write(at("plain/inner.txt"), "x"), "NotDirectory", at("plain/inner.txt"));
+    })),
+    fsCheck("without createParents a missing directory fails with NotFound; with it, write and append create every directory on the way", "create-parents", ({ fs }, at) => Effect.gen(function* () {
+      yield* refuses("create-parents", "writing into a missing directory", fs.write(at("a/b/c.txt"), "x"), "NotFound", at("a/b/c.txt"));
+      yield* refuses("create-parents", "appending into a missing directory", fs.append(at("a/b/c.txt"), "x"), "NotFound", at("a/b/c.txt"));
+      yield* fs.write(at("a/b/c.txt"), "deep", { createParents: !0 });
+      const deep = yield* fs.read(at("a/b/c.txt")), listed = yield* fs.list(at("a"));
+      yield* expect("create-parents", deep === "deep" && entries(listed) === "b:directory", `after a createParents write: ${show(deep)}, a/ lists ${entries(listed)}`);
+      yield* fs.write(at("a/b/c.txt"), "again", { createParents: !0 });
+      yield* fs.append(at("x/y/log.txt"), "1", { createParents: !0 });
+      const both = [yield* fs.read(at("a/b/c.txt")), yield* fs.read(at("x/y/log.txt"))];
+      yield* expect("create-parents", both.join() === "again,1", `createParents over existing directories, and on append, gave ${show(both)}`);
+    })),
+    fsCheck("readBytes returns the range asked for, what there is of a range past the end, and refuses a negative offset", "read-bytes", ({ fs }, at) => Effect.gen(function* () {
+      yield* fs.write(at("digits.txt"), "0123456789");
+      const ranges = [{ offset: 2, length: 3 }, { offset: 8 }, { offset: 5, length: 100 }, { offset: 20 }, { offset: 3, length: 0 }, { length: 4 }, {}], read = yield* Effect.forEach(ranges, (range) => fs.readBytes(at("digits.txt"), range).pipe(Effect.map(decoded))), expected = ["234", "89", "56789", "", "", "0123", "0123456789"];
+      yield* expect("read-bytes", read.join("|") === expected.join("|"), `ranges ${show(ranges)} read ${show(read)}, not ${show(expected)}`);
+      yield* refuses("read-bytes", "a negative offset", fs.readBytes(at("digits.txt"), { offset: -1 }), "Invalid", at("digits.txt"));
+      yield* refuses("read-bytes", "readBytes of a missing file", fs.readBytes(at("missing.bin")), "NotFound", at("missing.bin"));
+      yield* fs.mkdir(at("dir"));
+      yield* refuses("read-bytes", "readBytes of a directory", fs.readBytes(at("dir")), "IsDirectory", at("dir"));
+    })),
+    fsCheck("append creates a missing file and adds text and bytes at the end, in order", "append", ({ fs }, at) => Effect.gen(function* () {
+      yield* fs.append(at("log.txt"), `one
+`);
+      yield* fs.append(at("log.txt"), `tw\xF6
+`);
+      yield* fs.append(at("log.txt"), new TextEncoder().encode(`three
+`));
+      const log = yield* fs.read(at("log.txt"));
+      yield* expect("append", log === `one
+tw\xF6
+three
+`, `three appends gave ${show(log)}`);
+      yield* fs.write(at("written.txt"), "start");
+      yield* fs.append(at("written.txt"), "+end");
+      const written = yield* fs.read(at("written.txt"));
+      yield* expect("append", written === "start+end", `an append after a write gave ${show(written)}`);
+      yield* fs.mkdir(at("dir"));
+      yield* refuses("append", "appending to a directory", fs.append(at("dir"), "x"), "IsDirectory", at("dir"));
+    })),
+    fsCheck("rename moves a file, replaces an existing file at the target, moves a directory with what it holds, moves a link (not its target), and names the side a failure came from", "rename", ({ fs, symlink }, at) => Effect.gen(function* () {
+      yield* fs.write(at("from.txt"), "moved");
+      yield* fs.rename(at("from.txt"), at("to.txt"));
+      const moved = [yield* fs.exists(at("from.txt")), yield* fs.read(at("to.txt"))];
+      yield* expect("rename", show(moved) === show([!1, "moved"]), `after rename: source exists ${show(moved[0])}, target reads ${show(moved[1])}`);
+      yield* fs.write(at("new.txt"), "newer");
+      yield* fs.rename(at("new.txt"), at("to.txt"));
+      const replaced = [yield* fs.exists(at("new.txt")), yield* fs.read(at("to.txt"))];
+      yield* expect("rename", show(replaced) === show([!1, "newer"]), `renaming over an existing file: source exists ${show(replaced[0])}, target reads ${show(replaced[1])}`);
+      yield* fs.write(at("tree/inner/leaf.txt"), "leaf", { createParents: !0 });
+      yield* fs.rename(at("tree"), at("moved-tree"));
+      const tree = [yield* fs.exists(at("tree")), yield* fs.read(at("moved-tree/inner/leaf.txt"))];
+      yield* expect("rename", show(tree) === show([!1, "leaf"]), `renaming a directory: old exists ${show(tree[0])}, moved leaf reads ${show(tree[1])}`);
+      yield* fs.write(at("target.txt"), "target");
+      yield* symlink(at("target.txt"), at("link"));
+      yield* fs.rename(at("link"), at("moved-link"));
+      const link = [yield* fs.exists(at("link")), (yield* fs.stat(at("moved-link"), { followSymlinks: !1 })).kind, yield* fs.read(at("moved-link")), yield* fs.read(at("target.txt"))];
+      yield* expect("rename", show(link) === show([!1, "symlink", "target", "target"]), `renaming a link: old exists ${show(link[0])}, the new path is a ${show(link[1])} reading ${show(link[2])}, its target reads ${show(link[3])}`);
+      yield* refuses("rename", "renaming a missing file", fs.rename(at("missing.txt"), at("elsewhere.txt")), "NotFound", at("missing.txt"));
+      yield* refuses("rename", "renaming into a missing directory", fs.rename(at("to.txt"), at("missing/to.txt")), "NotFound", at("missing/to.txt"));
+      yield* refuses("rename", "renaming a file over a directory", fs.rename(at("to.txt"), at("moved-tree")), "IsDirectory", at("moved-tree"));
+      yield* refuses("rename", "renaming a directory over a file", fs.rename(at("moved-tree/inner"), at("to.txt")), "NotDirectory", at("to.txt"));
+      yield* fs.mkdir(at("other"));
+      yield* refuses("rename", "renaming a directory over one with entries", fs.rename(at("other"), at("moved-tree")), "NotEmpty", at("moved-tree"));
+    })),
+    fsCheck("stat reports kind, size and time, follows links unless told not to, and a missing path fails with NotFound", "stat", ({ fs, symlink }, at) => Effect.gen(function* () {
+      yield* fs.write(at("file.txt"), "h\xE9llo");
+      yield* fs.mkdir(at("dir"));
+      yield* symlink(at("file.txt"), at("link"));
+      const file = yield* fs.stat(at("file.txt"));
+      yield* expect("stat", file.kind === "file" && file.size === 6 && file.path === at("file.txt") && Number.isFinite(file.mtimeMs), `stat of a 6-byte file gave ${show({ ...file, mode: void 0 })}`);
+      const dir = yield* fs.stat(at("dir"));
+      yield* expect("stat", dir.kind === "directory", `stat of a directory gave kind ${dir.kind}`);
+      const followed = yield* fs.stat(at("link")), link = yield* fs.stat(at("link"), { followSymlinks: !1 });
+      yield* expect("stat", followed.kind === "file" && followed.size === 6 && link.kind === "symlink", `stat of a link to a file gave ${followed.kind} (${followed.size} bytes), and without following ${link.kind}`);
+      yield* refuses("stat", "stat of a missing path", fs.stat(at("missing")), "NotFound", at("missing"));
+    })),
+    fsCheck("exists is true for files and directories and false, never an error, for missing paths and dangling links", "exists", ({ fs, symlink }, at) => Effect.gen(function* () {
+      yield* fs.write(at("file.txt"), "x");
+      yield* fs.mkdir(at("dir"));
+      yield* symlink(at("nowhere"), at("dangling"));
+      const found = yield* Effect.forEach(["file.txt", "dir", "missing", "missing/below", "dangling"], (path) => fs.exists(at(path)));
+      yield* expect("exists", show(found) === show([!0, !0, !1, !1, !1]), `exists for file, dir, missing, missing/below, dangling link: ${show(found)}`);
+    })),
+    fsCheck("list returns entries sorted by name with their kinds, links unfollowed; a file fails with NotDirectory and a missing path with NotFound", "list", ({ fs, symlink }, at) => Effect.gen(function* () {
+      yield* Effect.forEach(["b.txt", "C.txt", "a.txt", ".hidden"], (name) => fs.write(at(`dir/${name}`), name, { createParents: !0 }), { discard: !0 });
+      yield* fs.mkdir(at("dir/a"));
+      yield* symlink(at("dir/a"), at("dir/link"));
+      const listed = yield* fs.list(at("dir")), expected = ".hidden:file|C.txt:file|a:directory|a.txt:file|b.txt:file|link:symlink";
+      yield* expect("list", entries(listed) === expected, `list gave ${entries(listed)}, not ${expected}`);
+      const empty = yield* fs.list(at("dir/a")), throughLink = yield* fs.list(at("dir/link"));
+      yield* expect("list", empty.length === 0 && throughLink.length === 0, `an empty directory listed ${show(empty)}, and through a link ${show(throughLink)}`);
+      yield* refuses("list", "listing a file", fs.list(at("dir/b.txt")), "NotDirectory", at("dir/b.txt"));
+      yield* refuses("list", "listing a missing directory", fs.list(at("missing")), "NotFound", at("missing"));
+    })),
+    fsCheck("glob matches *, ?, classes and braces within a segment, in depth-first order by name", "glob", (fixture) => Effect.gen(function* () {
+      yield* globTree(fixture);
+      const globbed = globs("glob", fixture);
+      yield* globbed("*.ts", { onlyFiles: !0 }, ["top.ts"]);
+      yield* globbed("file?.txt", {}, ["file1.txt", "file2.txt"]);
+      yield* globbed("file[0-1]*.txt", {}, ["file1.txt", "file10.txt"]);
+      yield* globbed("src/[!a]*.ts", {}, ["src/b.ts"]);
+      yield* globbed("src/{a,c}.*", {}, ["src/a.ts", "src/c.js"]);
+      yield* globbed("{top,src/{b,a}}.ts", {}, ["src/a.ts", "src/b.ts", "top.ts"]);
+      yield* globbed("./docs/*.md", {}, ["docs/x.md"]);
+    })),
+    fsCheck("glob ** crosses directories but never enters a linked directory, and exclude prunes names and paths", "glob-recursive", (fixture) => Effect.gen(function* () {
+      yield* globTree(fixture);
+      const globbed = globs("glob-recursive", fixture);
+      yield* globbed("**/*.ts", { onlyFiles: !0 }, ["node_modules/m/i.ts", "src/a.ts", "src/b.ts", "src/deep/d.ts", "src/deep/deeper/e.ts", "top.ts"]);
+      yield* globbed("**/*.ts", { onlyFiles: !0, exclude: ["node_modules", "deeper"] }, ["src/a.ts", "src/b.ts", "src/deep/d.ts", "top.ts"]);
+      yield* globbed("**", { onlyFiles: !0, exclude: ["node_modules", "*.txt", "src/deep"] }, ["docs/x.md", "src/a.ts", "src/b.ts", "src/c.js", "top.ts"]);
+      yield* globbed("linked/**", { onlyFiles: !0 }, []);
+      yield* globbed("src/deep/**", {}, ["src/deep", "src/deep/d.ts", "src/deep/deeper", "src/deep/deeper/e.ts"]);
+    })),
+    fsCheck("glob skips dot entries unless dot is set or the pattern names them with a literal dot", "glob-dot", (fixture) => Effect.gen(function* () {
+      yield* globTree(fixture);
+      const globbed = globs("glob-dot", fixture);
+      yield* globbed("**/*.ts", { onlyFiles: !0, exclude: ["node_modules"], dot: !0 }, [".hidden/h.ts", "src/.dot.ts", "src/a.ts", "src/b.ts", "src/deep/d.ts", "src/deep/deeper/e.ts", "top.ts"]);
+      yield* globbed("src/*", { onlyFiles: !0, dot: !1 }, ["src/a.ts", "src/b.ts", "src/c.js"]);
+      yield* globbed(".hidden/*.ts", {}, [".hidden/h.ts"]);
+      yield* globbed("src/.*", {}, ["src/.dot.ts"]);
+    })),
+    fsCheck("glob onlyFiles keeps regular files only; without it directories and links that match are listed", "glob-only-files", (fixture) => Effect.gen(function* () {
+      yield* globTree(fixture);
+      const globbed = globs("glob-only-files", fixture);
+      yield* globbed("src/*", {}, ["src/a.ts", "src/b.ts", "src/c.js", "src/deep"]);
+      yield* globbed("src/*", { onlyFiles: !0 }, ["src/a.ts", "src/b.ts", "src/c.js"]);
+      yield* globbed("*.ts", {}, ["link.ts", "top.ts"]);
+      yield* globbed("l*", {}, ["link.ts", "linked"]);
+    })),
+    fsCheck("glob stops at limit, keeping the first paths in walk order, and reports truncated only when more matched", "glob-limit", (fixture) => Effect.gen(function* () {
+      yield* globTree(fixture);
+      const globbed = globs("glob-limit", fixture), options = { onlyFiles: !0, exclude: ["node_modules"] };
+      yield* globbed("**/*.ts", { ...options, limit: 2 }, ["src/a.ts", "src/b.ts"], !0);
+      yield* globbed("**/*.ts", { ...options, limit: 5 }, ["src/a.ts", "src/b.ts", "src/deep/d.ts", "src/deep/deeper/e.ts", "top.ts"]);
+      yield* globbed("**/*.ts", { ...options, limit: 0 }, [], !0);
+      yield* globbed("*.none", { limit: 0 }, []);
+    })),
+    fsCheck("glob of a missing cwd fails with NotFound, and an absolute or escaping pattern with Invalid", "glob-errors", ({ fs }, at) => Effect.gen(function* () {
+      yield* refuses("glob-errors", "glob in a missing cwd", fs.glob("*", { cwd: at("missing") }), "NotFound", at("missing"));
+      yield* fs.mkdir(at("dir"));
+      yield* refuses("glob-errors", "an absolute pattern", fs.glob("/etc/*", { cwd: at("dir") }), "Invalid");
+      yield* refuses("glob-errors", "a pattern with ..", fs.glob("../*", { cwd: at("dir") }), "Invalid");
+    })),
+    fsCheck("mkdir creates one directory, or with recursive every missing one (idempotently); otherwise an existing path fails with Exists and a missing parent with NotFound", "mkdir", ({ fs }, at) => Effect.gen(function* () {
+      yield* fs.mkdir(at("one"));
+      yield* refuses("mkdir", "mkdir of an existing directory", fs.mkdir(at("one")), "Exists", at("one"));
+      yield* refuses("mkdir", "mkdir with a missing parent", fs.mkdir(at("two/three")), "NotFound", at("two/three"));
+      yield* fs.mkdir(at("two/three/four"), { recursive: !0 });
+      yield* fs.mkdir(at("two/three/four"), { recursive: !0 });
+      yield* fs.mkdir(at("one"), { recursive: !0 });
+      const kinds = yield* Effect.forEach(["one", "two", "two/three", "two/three/four"], (path) => fs.stat(at(path)).pipe(Effect.map((info) => info.kind)));
+      yield* expect("mkdir", kinds.every((kind) => kind === "directory"), `after mkdir the paths are ${show(kinds)}`);
+      yield* fs.write(at("file"), "x");
+      yield* refuses("mkdir", "a recursive mkdir over a file", fs.mkdir(at("file"), { recursive: !0 }), "Exists", at("file"));
+    })),
+    fsCheck("realPath resolves every link on the way to the canonical path, and a missing path fails with NotFound", "real-path", ({ fs, symlink }, at) => Effect.gen(function* () {
+      yield* fs.write(at("target/inner/file.txt"), "x", { createParents: !0 });
+      yield* symlink(at("target"), at("abs-link"));
+      yield* symlink("target/inner", at("rel-link"));
+      const root = yield* fs.realPath(at("")), resolved = yield* Effect.forEach(["abs-link/inner/file.txt", "rel-link/file.txt", "target"], (path) => fs.realPath(at(path))), expected = [under(root, "target/inner/file.txt"), under(root, "target/inner/file.txt"), under(root, "target")];
+      yield* expect("real-path", show(resolved) === show(expected), `realPath gave ${show(resolved)}, not ${show(expected)}`);
+      yield* refuses("real-path", "realPath of a missing path", fs.realPath(at("missing")), "NotFound", at("missing"));
+    })),
+    fsCheck("remove: a missing path is a no-op, an empty directory goes without recursive, a full one needs it, and a link goes without its target", "remove", ({ fs, symlink }, at) => Effect.gen(function* () {
+      yield* fs.remove(at("missing"));
+      yield* fs.remove(at("missing/below"), { recursive: !0 });
+      yield* fs.write(at("file.txt"), "x");
+      yield* fs.remove(at("file.txt"));
+      yield* fs.mkdir(at("empty"));
+      yield* fs.remove(at("empty"));
+      yield* fs.write(at("full/inner/leaf.txt"), "leaf", { createParents: !0 });
+      yield* refuses("remove", "removing a directory with entries without recursive", fs.remove(at("full")), "NotEmpty", at("full"));
+      const kept = yield* fs.read(at("full/inner/leaf.txt"));
+      yield* symlink(at("full"), at("link"));
+      yield* fs.remove(at("link"));
+      const afterLink = yield* fs.exists(at("full/inner/leaf.txt"));
+      yield* fs.remove(at("full"), { recursive: !0 });
+      const gone = yield* Effect.forEach(["file.txt", "empty", "full", "link"], (path) => fs.exists(at(path)));
+      yield* expect("remove", kept === "leaf" && afterLink && gone.every((exists) => !exists), `refused removal kept ${show(kept)}, removing the link kept its target ${show(afterLink)}, removed paths exist ${show(gone)}`);
+    })),
+    fsCheck("remove acts on the last name as written: a link named with a trailing slash goes without its target, links in the parent are followed, and a path ending in . or .. fails with Invalid", "remove-paths", ({ fs, symlink }, at) => Effect.gen(function* () {
+      yield* fs.write(at("dir/sub/leaf.txt"), "leaf", { createParents: !0 });
+      yield* fs.write(at("dir/other/kept.txt"), "kept", { createParents: !0 });
+      yield* symlink(at("dir"), at("link"));
+      yield* symlink(at("dir"), at("recursive-link"));
+      yield* symlink(at("dir"), at("via"));
+      yield* refuses("remove-paths", "removing a path ending in ..", fs.remove(at("dir/sub/.."), { recursive: !0 }), "Invalid", at("dir/sub/.."));
+      yield* refuses("remove-paths", "removing a path ending in .", fs.remove(at("dir/sub/."), { recursive: !0 }), "Invalid", at("dir/sub/."));
+      yield* refuses("remove-paths", "removing a link's parent through ..", fs.remove(at("link/.."), { recursive: !0 }), "Invalid", at("link/.."));
+      yield* fs.remove(at("link/"));
+      yield* fs.remove(at("recursive-link/"), { recursive: !0 });
+      yield* fs.remove(at("via/sub"), { recursive: !0 });
+      const links = yield* Effect.forEach(["link", "recursive-link"], (name) => Effect.result(fs.stat(at(name), { followSymlinks: !1 })).pipe(Effect.map((result) => result._tag === "Success" ? result.success.kind : result.failure.reason))), left = [yield* fs.exists(at("dir/sub")), yield* fs.read(at("dir/other/kept.txt")), (yield* fs.stat(at("via"), { followSymlinks: !1 })).kind];
+      yield* expect("remove-paths", show(links) === show(["NotFound", "NotFound"]) && show(left) === show([!1, "kept", "symlink"]), `after removing link/ and recursive-link/ they are ${show(links)}; after removing via/sub, dir/sub exists ${show(left[0])}, dir/other/kept.txt reads ${show(left[1])} and via is a ${show(left[2])}`);
+    }))
+  ];
+};

package/dist/workspace/file-system.conformance.test.d.ts

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

package/dist/workspace/file-system.memory.adapter.d.ts

@@ -0,0 +1,23 @@
+import { Effect, Layer } from "effect";
+import type { Context } from "effect";
+import { FsError } from "../domain/file-system.entity.js";
+import { FileSystem } from "../ports/file-system.port.js";
+/** What a seeded path holds: text or bytes (a file), or a symbolic link to `symlink`. */
+export type MemorySeed = string | Uint8Array | {
+    readonly symlink: string;
+};
+/** The in-memory backend: the port, and a way to make the symbolic links a real disk would have. */
+export type MemoryFileSystem = Context.Service.Shape<typeof FileSystem> & {
+    /** Create a symbolic link at `path` to `target` (absolute, or relative to the link's directory), as `ln -s target path` does. */
+    readonly symlink: (target: string, path: string) => Effect.Effect<void, FsError>;
+};
+/**
+ * A file system held in memory, with the semantics `fileSystemConformance`
+ * checks: for tests, and for hosts that give an agent a scratch workspace
+ * that never touches disk. Paths are absolute and POSIX; the tree starts
+ * with `/` and the `initial` entries (parents created). Times come from the
+ * Effect `Clock`; files report no `mode`.
+ */
+export declare const makeMemoryFileSystem: (initial?: Readonly<Record<string, MemorySeed>>) => Effect.Effect<MemoryFileSystem, FsError>;
+/** An empty in-memory `FileSystem` (see `makeMemoryFileSystem`). */
+export declare const FileSystemMemoryLive: Layer.Layer<FileSystem>;

package/dist/workspace/file-system.memory.adapter.js

@@ -0,0 +1,132 @@
+import { Clock, Effect, Layer, Option, Ref, Result } from "effect";
+import { FsError } from "../domain/file-system.entity.js";
+import { FileSystem } from "../ports/file-system.port.js";
+import { walkGlob } from "../domain/file-system.entity.functions.js";
+const kinds = { File: "file", Directory: "directory", Symlink: "symlink" }, encoder = new TextEncoder, decoder = new TextDecoder, maxHops = 40, failure = (path, reason, message) => new FsError({ path, reason, message }), segmentsOf = (path) => path.split("/").filter((segment) => segment.length > 0 && segment !== "."), parentOf = (path) => {
+  const at = path.lastIndexOf("/");
+  return at <= 0 ? "/" : path.slice(0, at);
+}, join = (dir, name) => dir === "/" ? `/${name}` : `${dir}/${name}`, endsInDots = (path) => {
+  const last = path.split("/").filter((segment) => segment.length > 0).at(-1);
+  return last === "." || last === "..";
+}, writtenParent = (path) => parentOf(`/${segmentsOf(path).join("/")}`), bytesOf = (content) => typeof content === "string" ? encoder.encode(content) : Uint8Array.from(content), concat = (left, right) => {
+  const joined = new Uint8Array(left.length + right.length);
+  joined.set(left);
+  joined.set(right, left.length);
+  return joined;
+}, sizeOf = (node) => node._tag === "File" ? node.bytes.length : node._tag === "Symlink" ? encoder.encode(node.target).length : 0, withNode = (tree, path, node) => new Map([...tree, [path, node]]), inside = (tree, dir) => [...tree.keys()].filter((key) => key.startsWith(dir === "/" ? "/" : `${dir}/`) && key !== dir), resolveIn = (tree, asked, followLast) => {
+  if (!asked.startsWith("/"))
+    return Result.fail(failure(asked, "Invalid", "paths must be absolute"));
+  const step = (current, rest, hops) => {
+    const [name, ...tail] = rest;
+    if (name === void 0)
+      return Result.succeed(current);
+    if (name === "..")
+      return step(parentOf(current), tail, hops);
+    const next = join(current, name), node = tree.get(next);
+    if (node === void 0)
+      return tail.length === 0 ? Result.succeed(next) : Result.fail(failure(asked, "NotFound", `no such file or directory: ${next}`));
+    if (node._tag === "Symlink" && (tail.length > 0 || followLast)) {
+      if (hops >= maxHops)
+        return Result.fail(failure(asked, "Invalid", "too many levels of symbolic links"));
+      return step("/", [...segmentsOf(node.target.startsWith("/") ? node.target : join(current, node.target)), ...tail], hops + 1);
+    }
+    if (tail.length > 0 && node._tag === "File")
+      return Result.fail(failure(asked, "NotDirectory", `not a directory: ${next}`));
+    return step(next, tail, hops);
+  };
+  return step("/", segmentsOf(asked), 0);
+}, refused = (tree, error) => [Result.fail(error), tree];
+export const makeMemoryFileSystem = (initial = {}) => Effect.gen(function* () {
+  const tree = yield* Ref.make(new Map([["/", { _tag: "Directory", mtimeMs: yield* Clock.currentTimeMillis }]])), change = (apply) => Clock.currentTimeMillis.pipe(Effect.flatMap((now) => Ref.modify(tree, (all) => apply(all, now))), Effect.flatMap(Effect.fromResult)), look = (read) => Ref.get(tree).pipe(Effect.flatMap((all) => Effect.fromResult(read(all)))), nodeAt = (all, asked, followLast = !0) => Result.flatMap(resolveIn(all, asked, followLast), (real) => Option.match(Option.fromNullishOr(all.get(real)), {
+    onNone: () => Result.fail(failure(asked, "NotFound", `no such file or directory: ${asked}`)),
+    onSome: (node) => Result.succeed({ real, node })
+  })), fileAt = (all, asked) => Result.flatMap(nodeAt(all, asked), ({ node }) => node._tag === "File" ? Result.succeed(node.bytes) : Result.fail(failure(asked, "IsDirectory", `is a directory: ${asked}`))), makeDirectories = (asked, retried = !1) => change((all, now) => Result.match(resolveIn(all, asked, !1), {
+    onFailure: (error) => error.reason === "NotFound" && !retried ? [Result.succeed("parent-missing"), all] : refused(all, error),
+    onSuccess: (place) => Option.match(Option.fromNullishOr(all.get(place)), {
+      onNone: () => [Result.succeed("done"), withNode(all, place, { _tag: "Directory", mtimeMs: now })],
+      onSome: (node) => node._tag === "Directory" ? [Result.succeed("done"), all] : node._tag === "File" ? refused(all, failure(asked, "Exists", `exists and is not a directory: ${asked}`)) : Result.match(nodeAt(all, place), {
+        onFailure: (error) => refused(all, failure(asked, error.reason, error.reason === "NotFound" ? `a symbolic link to a missing directory: ${asked}` : error.message)),
+        onSuccess: (target) => target.node._tag === "Directory" ? [Result.succeed("done"), all] : refused(all, failure(asked, "Exists", `exists and is not a directory: ${asked}`))
+      })
+    })
+  })).pipe(Effect.flatMap((outcome) => outcome === "done" ? Effect.void : makeDirectories(writtenParent(asked)).pipe(Effect.andThen(makeDirectories(asked, !0))))), put = (asked, content, options, append) => (options?.createParents === !0 ? makeDirectories(writtenParent(asked)) : Effect.void).pipe(Effect.andThen(change((all, now) => Result.match(resolveIn(all, asked, !0), {
+    onFailure: (error) => refused(all, error),
+    onSuccess: (real) => {
+      const existing = all.get(real);
+      if (existing?._tag === "Directory")
+        return refused(all, failure(asked, "IsDirectory", `is a directory: ${asked}`));
+      const before = append && existing?._tag === "File" ? existing.bytes : new Uint8Array;
+      return [Result.succeed(void 0), withNode(all, real, { _tag: "File", bytes: concat(before, bytesOf(content)), mtimeMs: now })];
+    }
+  })))), list = (asked) => look((all) => Result.flatMap(nodeAt(all, asked), ({ real, node }) => node._tag !== "Directory" ? Result.fail(failure(asked, "NotDirectory", `not a directory: ${asked}`)) : Result.succeed(inside(all, real).filter((key) => parentOf(key) === real).map((key) => ({ name: key.slice(key.lastIndexOf("/") + 1), kind: kinds[all.get(key)?._tag ?? "File"] })).toSorted((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0)))), readBytes = (asked, range) => {
+    const offset = range?.offset ?? 0;
+    return Number.isInteger(offset) && offset >= 0 && (range?.length === void 0 || Number.isInteger(range.length) && range.length >= 0) ? look((all) => Result.map(fileAt(all, asked), (bytes) => bytes.slice(offset, range?.length === void 0 ? void 0 : offset + range.length))) : Effect.fail(failure(asked, "Invalid", `offset and length must be whole numbers of at least 0, not ${JSON.stringify(range)}`));
+  }, rename = (from, to) => change((all, now) => {
+    const source = nodeAt(all, from, !1), target = resolveIn(all, to, !1);
+    if (Result.isFailure(source))
+      return refused(all, source.failure);
+    if (Result.isFailure(target))
+      return refused(all, target.failure);
+    const { real, node } = source.success, destination = target.success;
+    if (real === "/" || destination === "/")
+      return refused(all, failure(real === "/" ? from : to, "Invalid", "the root cannot be moved or replaced"));
+    if (destination === real)
+      return [Result.succeed(void 0), all];
+    if (destination.startsWith(`${real}/`))
+      return refused(all, failure(to, "Invalid", `cannot move ${from} into itself`));
+    const existing = all.get(destination);
+    if (existing !== void 0 && node._tag !== "Directory" && existing._tag === "Directory")
+      return refused(all, failure(to, "IsDirectory", `is a directory: ${to}`));
+    if (existing !== void 0 && node._tag === "Directory" && existing._tag !== "Directory")
+      return refused(all, failure(to, "NotDirectory", `not a directory: ${to}`));
+    if (existing?._tag === "Directory" && inside(all, destination).length > 0)
+      return refused(all, failure(to, "NotEmpty", `directory not empty: ${to}`));
+    const moved = [real, ...node._tag === "Directory" ? inside(all, real) : []], kept = [...all].filter(([key]) => !moved.includes(key) && key !== destination), placed = moved.map((key) => [`${destination}${key.slice(real.length)}`, key === real ? { ...node, mtimeMs: now } : all.get(key) ?? node]);
+    return [Result.succeed(void 0), new Map([...kept, ...placed])];
+  }), stat = (asked, options) => look((all) => Result.map(nodeAt(all, asked, options?.followSymlinks !== !1), ({ node }) => ({
+    path: asked,
+    kind: kinds[node._tag],
+    size: sizeOf(node),
+    mtimeMs: node.mtimeMs,
+    mode: Option.none()
+  }))), remove = (asked, options) => endsInDots(asked) ? Effect.fail(failure(asked, "Invalid", `a path whose last segment is . or .. is never removed: ${asked}`)) : change((all) => Result.match(resolveIn(all, asked, !1), {
+    onFailure: (error) => error.reason === "NotFound" ? [Result.succeed(void 0), all] : refused(all, error),
+    onSuccess: (real) => {
+      const node = all.get(real);
+      if (node === void 0)
+        return [Result.succeed(void 0), all];
+      if (real === "/")
+        return refused(all, failure(asked, "Invalid", "the root cannot be removed"));
+      const below = node._tag === "Directory" ? inside(all, real) : [];
+      if (below.length > 0 && options?.recursive !== !0)
+        return refused(all, failure(asked, "NotEmpty", `directory not empty: ${asked}`));
+      const gone = new Set([real, ...below]);
+      return [Result.succeed(void 0), new Map([...all].filter(([key]) => !gone.has(key)))];
+    }
+  })), symlink = (target, asked) => change((all, now) => Result.match(resolveIn(all, asked, !1), {
+    onFailure: (error) => refused(all, error),
+    onSuccess: (real) => all.has(real) ? refused(all, failure(asked, "Exists", `already exists: ${asked}`)) : [Result.succeed(void 0), withNode(all, real, { _tag: "Symlink", target, mtimeMs: now })]
+  })), fs = {
+    read: (asked) => look((all) => Result.map(fileAt(all, asked), (bytes) => decoder.decode(bytes))),
+    readBytes,
+    write: (asked, content, options) => put(asked, content, options, !1),
+    append: (asked, content, options) => put(asked, content, options, !0),
+    rename,
+    stat,
+    exists: (asked) => look((all) => Result.match(nodeAt(all, asked), {
+      onFailure: (error) => error.reason === "NotFound" || error.reason === "NotDirectory" ? Result.succeed(!1) : Result.fail(error),
+      onSuccess: () => Result.succeed(!0)
+    })),
+    list,
+    glob: (pattern, options) => walkGlob(list, pattern, options),
+    mkdir: (asked, options) => options?.recursive === !0 ? makeDirectories(asked) : change((all, now) => Result.match(resolveIn(all, asked, !1), {
+      onFailure: (error) => refused(all, error),
+      onSuccess: (real) => all.has(real) ? refused(all, failure(asked, "Exists", `already exists: ${asked}`)) : [Result.succeed(void 0), withNode(all, real, { _tag: "Directory", mtimeMs: now })]
+    })),
+    realPath: (asked) => look((all) => Result.map(nodeAt(all, asked), ({ real }) => real)),
+    remove,
+    symlink
+  };
+  yield* Effect.forEach(Object.entries(initial).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0), ([path, seed]) => typeof seed === "string" || seed instanceof Uint8Array ? fs.write(path, seed, { createParents: !0 }) : makeDirectories(writtenParent(path)).pipe(Effect.andThen(symlink(seed.symlink, path))), { discard: !0 });
+  return fs;
+}), FileSystemMemoryLive = Layer.effect(FileSystem, Effect.orDie(makeMemoryFileSystem()));

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@xandreed/core",
-  "version": "0.12.0",
+  "version": "0.14.0",
+  "engines": {
+    "node": ">=24",
+    "bun": ">=1.3.0"
+  },
   "private": false,
   "type": "module",
   "description": "The agent kernel of the new line: entities, ports, the provider-agnostic agent loop, and the session chassis — pure Effect, no IO, no provider SDKs.",
@@ -12,7 +16,7 @@
     }
   },
   "dependencies": {
-    "effect": "4.0.0-rc.118"
+    "effect": "4.0.7"
   },
   "types": "./dist/index.d.ts",
   "files": [
@@ -22,9 +26,5 @@
     "README.md",
     "LICENSE"
   ],
-  "engines": {
-    "node": ">=24",
-    "bun": ">=1.3.0"
-  },
   "license": "MIT"
 }

package/dist/harness/session.entity.d.ts

@@ -1,33 +0,0 @@
-import { Schema } from "effect";
-export declare const SessionRecord: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "ConversationId">;
-    readonly workspace: Schema.String;
-    readonly profile: Schema.String;
-    readonly createdAt: Schema.Number;
-    readonly parent: Schema.optional<Schema.brand<Schema.String, "ConversationId">>;
-}>;
-export type SessionRecord = typeof SessionRecord.Type;
-export declare const EventBody: Schema.Struct<{
-    readonly name: Schema.NonEmptyString;
-    readonly runId: Schema.optional<Schema.String>;
-    readonly data: Schema.$Record<Schema.String, Schema.Unknown>;
-}>;
-export type EventBody = typeof EventBody.Type;
-export declare const SessionEvent: Schema.Struct<{
-    readonly version: Schema.Literal<1>;
-    readonly id: Schema.String;
-    readonly sessionId: Schema.brand<Schema.String, "ConversationId">;
-    readonly seq: Schema.Int;
-    readonly at: Schema.Number;
-    readonly name: Schema.NonEmptyString;
-    readonly runId: Schema.optional<Schema.String>;
-    readonly data: Schema.$Record<Schema.String, Schema.Unknown>;
-}>;
-export type SessionEvent = typeof SessionEvent.Type;
-export declare const MemoryEntry: Schema.Struct<{
-    readonly id: Schema.String;
-    readonly workspace: Schema.String;
-    readonly text: Schema.String;
-    readonly createdAt: Schema.Number;
-}>;
-export type MemoryEntry = typeof MemoryEntry.Type;

package/dist/harness/session.entity.js

@@ -1,25 +0,0 @@
-import { Schema } from "effect";
-import { ConversationId } from "../domain/message.entity.js";
-export const SessionRecord = Schema.Struct({
-  id: ConversationId,
-  workspace: Schema.String,
-  profile: Schema.String,
-  createdAt: Schema.Number,
-  parent: Schema.optional(ConversationId)
-}), EventBody = Schema.Struct({
-  name: Schema.NonEmptyString,
-  runId: Schema.optional(Schema.String),
-  data: Schema.Record(Schema.String, Schema.Unknown)
-}), SessionEvent = Schema.Struct({
-  ...EventBody.fields,
-  version: Schema.Literal(1),
-  id: Schema.String,
-  sessionId: ConversationId,
-  seq: Schema.Int,
-  at: Schema.Number
-}), MemoryEntry = Schema.Struct({
-  id: Schema.String,
-  workspace: Schema.String,
-  text: Schema.String,
-  createdAt: Schema.Number
-});

package/dist/harness/skill-files.d.ts

@@ -1,17 +0,0 @@
-import { Effect } from "effect";
-import { SkillDefinition } from "./capability.entity.js";
-import { HarnessError } from "./plugin.entity.js";
-/** One file of a skills tree, as the host read it. */
-export interface SkillFile {
-    /** Relative path, `/`-separated: `<skill>/SKILL.md` or `<skill>/references/<id>.md`. */
-    readonly path: string;
-    readonly text: string;
-}
-/**
- * Skills from markdown files. `<skill>/SKILL.md` carries flat frontmatter —
- * `summary` (required), `id` (defaults to the directory), `version`,
- * `tools` and `permissions` (comma-separated), `always` (`true`) — and its
- * body is the load_skill instructions. Each `<skill>/references/<id>.md` is
- * one reference, titled by its `title` field or first heading.
- */
-export declare const skillsFromFiles: (files: ReadonlyArray<SkillFile>) => Effect.Effect<ReadonlyArray<SkillDefinition>, HarnessError>;

package/dist/harness/skill-files.js

@@ -1,25 +0,0 @@
-import { Effect, Option, Schema } from "effect";
-import { parseFrontmatter } from "../spec/frontmatter.js";
-import { SkillDefinition } from "./capability.entity.js";
-import { HarnessError } from "./plugin.entity.js";
-const invalid = (path, message) => new HarnessError({ code: "skills.files", message: `${path}: ${message}` }), list = (value) => (value ?? "").split(",").map((item) => item.trim()).filter((item) => item.length > 0), headingOf = (body) => Option.fromNullishOr(body.split(`
-`).find((line) => line.startsWith("# "))).pipe(Option.map((line) => line.slice(2).trim()));
-export const skillsFromFiles = (files) => Effect.forEach(files.filter((file) => /^[^/]+\/SKILL\.md$/.test(file.path)), (file) => Effect.gen(function* () {
-  const directory = file.path.split("/")[0] ?? "", parsed = yield* Option.match(parseFrontmatter(file.text), {
-    onNone: () => Effect.fail(invalid(file.path, "missing frontmatter")),
-    onSome: Effect.succeed
-  }), references = yield* Effect.forEach(files.filter((candidate) => candidate.path.startsWith(`${directory}/references/`) && candidate.path.endsWith(".md")), (reference) => {
-    const id = reference.path.slice(`${directory}/references/`.length, -3), document = Option.getOrElse(parseFrontmatter(reference.text), () => ({ fields: {}, body: reference.text })), title = Option.getOrElse(Option.orElse(Option.fromNullishOr(document.fields.title), () => headingOf(document.body)), () => id);
-    return Effect.succeed({ id, title, text: document.body.trim() });
-  }), fields = parsed.fields;
-  return yield* Schema.decodeUnknownEffect(SkillDefinition)({
-    id: fields.id ?? directory,
-    version: fields.version ?? "1",
-    summary: fields.summary ?? "",
-    instructions: parsed.body.trim(),
-    tools: list(fields.tools),
-    always: fields.always === "true",
-    permissions: list(fields.permissions),
-    references
-  }).pipe(Effect.mapError((error) => invalid(file.path, error.message)));
-}));