@smthrs/kernel 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/FileSystem.js

@@ -0,0 +1,890 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FileSystem_exports = {};
+__export(FileSystem_exports, {
+  AtomicFileSystemTypeId: () => AtomicFileSystemTypeId,
+  FileSystemFault: () => FileSystemFault,
+  FileSystemFaultCode: () => FileSystemFaultCode,
+  canonicalResource: () => canonicalResource,
+  confined: () => confined,
+  confinedRoot: () => confinedRoot,
+  isConfinable: () => isConfinable,
+  layer: () => layer,
+  requireConfinable: () => requireConfinable,
+  systemTemporaryDirectoryName: () => systemTemporaryDirectoryName,
+  withAtomicFileSystem: () => withAtomicFileSystem,
+  withIsolatedFileSystem: () => withIsolatedFileSystem
+});
+module.exports = __toCommonJS(FileSystem_exports);
+var import_Permission = require("@smthrs/capability/Permission");
+var import_effect = require("effect");
+var Batch = __toESM(require("./FileSystemBatch.js"), 1);
+var import_GrantStore = require("./GrantStore.js");
+var import_makeCapability = require("./internal/makeCapability.js");
+var import_Workspace = require("./Workspace.js");
+__reExport(FileSystem_exports, require("./FileSystemBatch.js"), module.exports);
+const systemTemporaryDirectoryName = "<system-temp>";
+const AtomicFileSystemTypeId = /* @__PURE__ */ Symbol.for("@smthrs/kernel/AtomicFileSystem");
+const withAtomicFileSystem = (fileSystem, atomic) => Object.assign(fileSystem, { [AtomicFileSystemTypeId]: atomic });
+const FileSystemFaultCode = import_effect.Schema.Literals([
+  "executor_already_present",
+  "isolated_operation_unsupported",
+  "workspace_identity_changed"
+]);
+class FileSystemFault extends import_effect.Schema.TaggedError()("@smthrs/kernel/FileSystemFault", {
+  code: FileSystemFaultCode,
+  message: import_effect.Schema.String
+}) {
+  name = "FileSystemFault";
+}
+const withIsolatedFileSystem = (fileSystem) => {
+  if (AtomicFileSystemTypeId in fileSystem) {
+    throw new FileSystemFault({
+      code: "executor_already_present",
+      message: "filesystem already carries a descriptor-relative executor; attesting whole-filesystem isolation would replace it"
+    });
+  }
+  return withAtomicFileSystem(fileSystem, {
+    isolated: fileSystem,
+    execute: dispatch({
+      exists: (request) => fileSystem.exists(request.path),
+      chmod: (request) => fileSystem.chmod(request.path, request.options.mode),
+      chown: (request) => fileSystem.chown(request.path, request.options.uid, request.options.gid),
+      glob: (request) => fileSystem.glob(request.pattern, { ...request.options, root: request.root }),
+      makeDirectory: (request) => fileSystem.makeDirectory(request.path, request.options),
+      readDirectory: (request) => fileSystem.readDirectory(request.path, request.options),
+      readFile: (request) => fileSystem.readFile(request.path),
+      readFileString: (request) => fileSystem.readFileString(request.path, request.encoding),
+      readLink: (request) => fileSystem.readLink(request.path),
+      realPath: (request) => fileSystem.realPath(request.path),
+      // Authorization asks `resolve` only of an executor that claims
+      // `noFollowAuthorization`, which an attested volume never does.
+      resolve: (request) => unsupportedIsolated(request.operation),
+      remove: (request) => fileSystem.remove(request.path, request.options),
+      rename: (request) => fileSystem.rename(request.from, request.to),
+      stat: (request) => fileSystem.stat(request.path),
+      writeFile: (request) => import_effect.Encoding.decodeBase64(request.data).pipe(
+        import_effect.Effect.fromResult,
+        import_effect.Effect.orDie,
+        import_effect.Effect.flatMap((data) => fileSystem.writeFile(request.path, data, request.options))
+      ),
+      writeFileString: (request) => fileSystem.writeFileString(request.path, request.data, request.options),
+      // An attested volume advertises no `batchLimits`, so the guarded layer
+      // never frames a batch for this executor.
+      batch: (request) => unsupportedIsolated(request.operation)
+    })
+  });
+};
+const unsupportedIsolated = (operation) => import_effect.Effect.die(
+  new FileSystemFault({
+    code: "isolated_operation_unsupported",
+    message: `unsupported isolated filesystem operation: ${operation}`
+  })
+);
+const dispatch = (handlers) => {
+  const table = handlers;
+  return (request) => {
+    const handler = table[request.operation];
+    return handler === void 0 ? unsupportedIsolated(request.operation) : handler(request);
+  };
+};
+const identifyRoot = (atomic, fileSystem, path) => atomic.identifyRoot === void 0 ? import_effect.Effect.map(fileSystem.stat(path), (info) => import_effect.Option.map(info.ino, (ino) => `${info.dev}:${ino}`)) : import_effect.Effect.map(atomic.identifyRoot(path), import_effect.Option.some);
+const pinned = (atomic, root) => (request) => atomic.execute({ ...request, ...root });
+const unconfinedDescription = "host does not provide descriptor-relative, no-follow filesystem isolation";
+const unconfined = (method, pathOrDescriptor) => import_effect.PlatformError.systemError({
+  _tag: "PermissionDenied",
+  module: "FileSystem",
+  method,
+  pathOrDescriptor,
+  description: unconfinedDescription
+});
+const ConfinedFileSystemTypeId = /* @__PURE__ */ Symbol.for("@smthrs/kernel/ConfinedFileSystem");
+const isConfinable = (fileSystem) => ConfinedFileSystemTypeId in fileSystem || AtomicFileSystemTypeId in fileSystem;
+const confinedRoot = (fileSystem) => fileSystem[ConfinedFileSystemTypeId];
+const requireConfinable = (fileSystem, root) => isConfinable(fileSystem) ? import_effect.Effect.void : import_effect.Effect.fail(unconfined("confined", root));
+const confined = (fileSystem, root) => import_effect.Effect.gen(function* () {
+  const path = yield* import_effect.Path.Path;
+  const logicalRoot = path.resolve(root === "" ? "." : root);
+  if (confinedRoot(fileSystem) === logicalRoot) return fileSystem;
+  const atomic = fileSystem[AtomicFileSystemTypeId];
+  if (atomic === void 0) return yield* import_effect.Effect.fail(unconfined("confined", logicalRoot));
+  if (atomic.isolated !== void 0) return fileSystem;
+  const boundaryRoot = yield* fileSystem.realPath(logicalRoot);
+  const rootIdentity = yield* identifyRoot(atomic, fileSystem, boundaryRoot);
+  if (import_effect.Option.isNone(rootIdentity)) return yield* import_effect.Effect.fail(unconfined("confined", logicalRoot));
+  const run = pinned(atomic, { boundaryRoot, logicalRoot, rootIdentity: rootIdentity.value });
+  const normalize = (value) => path.resolve(logicalRoot, value);
+  const refuse = (method, value) => import_effect.Effect.fail(unconfined(method, normalize(value)));
+  const view = {
+    ...import_effect.FileSystem.make({
+      access: (value) => refuse("access", value),
+      copy: (from) => refuse("copy", from),
+      copyFile: (from) => refuse("copyFile", from),
+      chmod: (value, mode) => run({ operation: "chmod", path: normalize(value), options: { mode } }),
+      chown: (value, uid, gid) => run({ operation: "chown", path: normalize(value), options: { uid, gid } }),
+      glob: (pattern, options) => {
+        const base = options?.root === void 0 ? logicalRoot : normalize(options.root);
+        return run({
+          operation: "glob",
+          pattern: path.resolve(base, pattern),
+          root: base,
+          options: options === void 0 ? void 0 : { exclude: options.exclude ?? [] }
+        });
+      },
+      link: (from) => refuse("link", from),
+      makeDirectory: (value, options) => run({
+        operation: "makeDirectory",
+        path: normalize(value),
+        options
+      }),
+      makeTempDirectory: () => refuse("makeTempDirectory", logicalRoot),
+      makeTempDirectoryScoped: () => refuse("makeTempDirectoryScoped", logicalRoot),
+      makeTempFile: () => refuse("makeTempFile", logicalRoot),
+      makeTempFileScoped: () => refuse("makeTempFileScoped", logicalRoot),
+      open: (value) => refuse("open", value),
+      readDirectory: (value, options) => run({
+        operation: "readDirectory",
+        path: normalize(value),
+        options
+      }),
+      readFile: (value) => run({ operation: "readFile", path: normalize(value) }),
+      readLink: (value) => run({ operation: "readLink", path: normalize(value) }),
+      realPath: (value) => run({ operation: "realPath", path: normalize(value) }),
+      remove: (value, options) => run({
+        operation: "remove",
+        path: normalize(value),
+        options
+      }),
+      rename: (from, to) => run({ operation: "rename", from: normalize(from), to: normalize(to) }),
+      stat: (value) => run({ operation: "stat", path: normalize(value) }),
+      symlink: (_from, to) => refuse("symlink", to),
+      truncate: (value) => refuse("truncate", value),
+      utimes: (value) => refuse("utimes", value),
+      watch: (value) => import_effect.Stream.fail(unconfined("watch", normalize(value))),
+      writeFile: (value, data, options) => {
+        const limit = atomic.contentLimit;
+        if (limit !== void 0 && data.byteLength > limit) {
+          return import_effect.Effect.fail(import_effect.PlatformError.badArgument({
+            module: "FileSystem",
+            method: "writeFile",
+            description: `writeFile payload of ${data.byteLength} bytes exceeds the ${limit} byte limit advertised by the host`
+          }));
+        }
+        return run({
+          operation: "writeFile",
+          path: normalize(value),
+          data: import_effect.Encoding.encodeBase64(data),
+          options
+        });
+      }
+    }),
+    exists: (value) => run({ operation: "exists", path: normalize(value) }),
+    readFileString: (value, encoding) => run({ operation: "readFileString", path: normalize(value), encoding }),
+    writeFileString: (value, data, options) => run({
+      operation: "writeFileString",
+      path: normalize(value),
+      data,
+      options
+    })
+  };
+  return Object.assign(view, { [ConfinedFileSystemTypeId]: logicalRoot });
+});
+const readableOpenFlags = /* @__PURE__ */ new Set([
+  "r",
+  "r+",
+  "w+",
+  "wx+",
+  "a+",
+  "ax+"
+]);
+const writableOpenFlags = /* @__PURE__ */ new Set([
+  "r+",
+  "w",
+  "wx",
+  "w+",
+  "wx+",
+  "a",
+  "ax",
+  "a+",
+  "ax+"
+]);
+const isInside = (path, root, candidate) => {
+  const relative = path.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+};
+const identityOf = (info) => info.type === "File" ? import_effect.Option.map(info.ino, (ino) => `${info.dev}:${ino}`) : import_effect.Option.none();
+const canonicalResource = (fileSystem, path, workspaceRoot, value) => {
+  const normalizedRoot = path.normalize(workspaceRoot);
+  const normalizedValue = path.normalize(
+    path.isAbsolute(value) ? value : path.resolve(normalizedRoot, value)
+  );
+  const resolveExistingAncestor = (candidate, symlinkDepth = 0) => fileSystem.realPath(candidate).pipe(
+    import_effect.Effect.catch((error) => {
+      const resolveParent = () => {
+        const parent = path.dirname(candidate);
+        if (parent === candidate) {
+          return import_effect.Effect.fail(error);
+        }
+        return resolveExistingAncestor(parent, symlinkDepth).pipe(
+          import_effect.Effect.map((resolvedParent) => path.join(resolvedParent, path.basename(candidate)))
+        );
+      };
+      return fileSystem.readLink(candidate).pipe(
+        import_effect.Effect.matchEffect({
+          onFailure: resolveParent,
+          onSuccess: (target) => symlinkDepth >= 40 ? import_effect.Effect.fail(error) : resolveExistingAncestor(
+            path.isAbsolute(target) ? target : path.resolve(path.dirname(candidate), target),
+            symlinkDepth + 1
+          )
+        })
+      );
+    })
+  );
+  return import_effect.Effect.all([
+    fileSystem.realPath(normalizedRoot),
+    resolveExistingAncestor(normalizedValue)
+  ]).pipe(
+    import_effect.Effect.map(
+      ([canonicalRoot, canonicalValue]) => isInside(path, canonicalRoot, canonicalValue) ? path.normalize(path.join(normalizedRoot, path.relative(canonicalRoot, canonicalValue))) : path.normalize(canonicalValue)
+    )
+  );
+};
+const uninspectable = "path component could not be inspected without following it";
+const pinnedPath = (path, root, value) => {
+  const base = isInside(path, root.logicalRoot, value) ? root.logicalRoot : isInside(path, root.boundaryRoot, value) ? root.boundaryRoot : void 0;
+  return base === void 0 ? void 0 : path.join(root.boundaryRoot, path.relative(base, value));
+};
+const segmentsBelow = (path, root, value) => path.relative(root, value).split(path.sep).filter((segment) => segment !== "");
+const globAuthorizationPath = (path, root, value, glob) => {
+  const requested = glob ? pinnedPath(path, root, value) : void 0;
+  if (requested === void 0) return { prefix: value, suffix: [] };
+  const parts = segmentsBelow(path, root.boundaryRoot, requested);
+  const wildcard = parts.findIndex((part) => /[*?[{]|[@+!]\(/.test(part));
+  return wildcard < 0 ? { prefix: value, suffix: [] } : { prefix: path.join(root.logicalRoot, ...parts.slice(0, wildcard)), suffix: parts.slice(wildcard) };
+};
+const confinedResource = (run, path, root, value, refuse, symlinkDepth = 0) => {
+  const requested = pinnedPath(path, root, value);
+  if (requested === void 0) {
+    return import_effect.Effect.succeed(value);
+  }
+  return run({ operation: "resolve", path: requested }).pipe(
+    import_effect.Effect.matchEffect({
+      onFailure: (cause) => refuse(logicalPath(path, root, requested), uninspectable, cause),
+      onSuccess: (resolution) => followResolution(run, path, root, requested, resolution, refuse, symlinkDepth)
+    })
+  );
+};
+const logicalPath = (path, root, canonical) => path.normalize(path.join(root.logicalRoot, path.relative(root.boundaryRoot, canonical)));
+const followResolution = (run, path, root, requested, resolution, refuse, symlinkDepth) => {
+  const resolved = path.normalize(resolution.path);
+  if (!isInside(path, root.boundaryRoot, resolved)) {
+    return refuse(logicalPath(path, root, requested), "path resolves outside the pinned root");
+  }
+  if (resolution.target === null) {
+    return import_effect.Effect.succeed(logicalPath(path, root, resolved));
+  }
+  if (symlinkDepth >= 40) {
+    return refuse(logicalPath(path, root, resolved), "too many levels of symbolic links");
+  }
+  const rest = segmentsBelow(path, root.boundaryRoot, requested).slice(
+    segmentsBelow(path, root.boundaryRoot, resolved).length
+  );
+  return confinedResource(
+    run,
+    path,
+    root,
+    path.resolve(path.dirname(resolved), resolution.target, ...rest),
+    refuse,
+    symlinkDepth + 1
+  );
+};
+const publicValue = (resource, result) => import_effect.Result.isFailure(result) || result.success.operation !== "resolve" ? result : import_effect.Result.fail(import_effect.PlatformError.systemError({
+  _tag: "PermissionDenied",
+  module: "FileSystem",
+  method: "batch",
+  pathOrDescriptor: resource,
+  description: "executor answered a batch read with a resolution"
+}));
+const layer = import_effect.Layer.effect(
+  import_effect.FileSystem.FileSystem,
+  import_effect.Effect.gen(function* () {
+    const fileSystem = yield* import_effect.FileSystem.FileSystem;
+    const path = yield* import_effect.Path.Path;
+    const workspace = yield* import_Workspace.Workspace;
+    const grants = yield* import_GrantStore.GrantStore;
+    const atomic = fileSystem[AtomicFileSystemTypeId];
+    const normalizeFrom = (base, value) => path.normalize(path.isAbsolute(value) ? value : path.resolve(base, value));
+    const logicalRoot = path.normalize(path.resolve(workspace.root));
+    const normalize = (value) => normalizeFrom(logicalRoot, value);
+    const boundaryRoot = yield* fileSystem.realPath(logicalRoot);
+    const rootIdentity = atomic === void 0 || atomic.isolated !== void 0 && atomic.batchLimits === void 0 ? import_effect.Option.none() : yield* identifyRoot(atomic, fileSystem, boundaryRoot);
+    const root = { boundaryRoot, logicalRoot, rootIdentity: import_effect.Option.getOrUndefined(rootIdentity) };
+    const refuse = (method, resource) => (error) => (0, import_Permission.toPlatformError)({ module: "FileSystem", method, pathOrDescriptor: resource, error });
+    const deny = (action, method, resource, reason, cause) => (0, import_makeCapability.makeCapability)(action, resource).pipe(
+      import_effect.Effect.flatMap((capability) => {
+        const failure = (0, import_Permission.permissionDenied)(capability, reason);
+        if (cause !== void 0) Object.defineProperty(failure, "cause", { value: cause });
+        return import_effect.Effect.fail(failure);
+      }),
+      import_effect.Effect.mapError(refuse(method, resource)),
+      import_effect.Effect.mapError(
+        (failure) => cause?.reason.description === void 0 ? failure : import_effect.PlatformError.systemError({
+          ...failure.reason,
+          _tag: "PermissionDenied",
+          description: cause.reason.description,
+          cause: failure.reason.cause
+        })
+      )
+    );
+    const insideWorkspace = (action, method) => (resource) => isInside(path, logicalRoot, resource) ? import_effect.Effect.succeed(resource) : deny(action, method, resource, "path is outside the workspace");
+    const resolvedResource = (action, method, value, glob = false) => {
+      const normalized = normalize(value);
+      if (atomic?.noFollowAuthorization === true) {
+        const { prefix, suffix } = globAuthorizationPath(path, root, normalized, glob);
+        return confinedResource(
+          pinned(atomic, root),
+          path,
+          root,
+          prefix,
+          (resource, reason, cause) => deny(action, method, resource, reason, cause)
+        ).pipe(
+          import_effect.Effect.map((resource) => suffix.length === 0 ? resource : path.join(resource, ...suffix)),
+          import_effect.Effect.flatMap(insideWorkspace(action, method))
+        );
+      }
+      return canonicalResource(fileSystem, path, logicalRoot, normalized).pipe(
+        import_effect.Effect.flatMap(
+          (resource) => fileSystem.stat(normalized).pipe(
+            import_effect.Effect.matchEffect({
+              onFailure: () => import_effect.Effect.succeed(resource),
+              onSuccess: (info) => {
+                const hardLinked = info.type === "File" && import_effect.Option.isSome(info.nlink) && info.nlink.value > 1;
+                return hardLinked ? deny(action, method, resource, "hard-linked files cannot be confined to the workspace") : import_effect.Effect.succeed(resource);
+              }
+            })
+          )
+        )
+      );
+    };
+    const resolvedResources = (values) => {
+      const refuseRead = (resource, reason, cause) => deny("fs:read", "read", resource, reason, cause);
+      if (atomic?.noFollowAuthorization !== true || atomic.batchLimits === void 0) {
+        return import_effect.Effect.forEach(
+          values,
+          (value) => import_effect.Effect.result(resolvedResource("fs:read", "read", value.path, value.operation === "glob")),
+          {
+            concurrency: Batch.fallbackConcurrency
+          }
+        );
+      }
+      const run = pinned(atomic, root);
+      const parts = values.map(
+        (value) => globAuthorizationPath(path, root, normalize(value.path), value.operation === "glob")
+      );
+      const requested = parts.map(({ prefix }) => pinnedPath(path, root, prefix));
+      const members = [];
+      const memberOf = requested.map(
+        (value) => value === void 0 ? void 0 : members.push({ operation: "resolve", path: value }) - 1
+      );
+      const answered = members.length === 0 ? import_effect.Effect.succeed([]) : import_effect.Effect.map(run({ operation: "batch", requests: members }), (response) => response.entries);
+      return import_effect.Effect.flatMap(answered, (entries) => {
+        const results = new Map(entries.map((entry) => [entry.index, entry.result]));
+        return import_effect.Effect.forEach(values, (value, index) => {
+          const member = memberOf[index];
+          const resource = member === void 0 ? import_effect.Effect.succeed(normalize(value.path)) : import_effect.Effect.suspend(() => {
+            const pinnedValue = members[member].path;
+            const result = results.get(member);
+            return result === void 0 || import_effect.Result.isFailure(result) || result.success.operation !== "resolve" ? refuseRead(
+              logicalPath(path, root, pinnedValue),
+              uninspectable,
+              result !== void 0 && import_effect.Result.isFailure(result) ? result.failure : void 0
+            ) : followResolution(run, path, root, pinnedValue, result.success.resolution, refuseRead, 0);
+          });
+          return import_effect.Effect.result(resource.pipe(
+            import_effect.Effect.map(
+              (resolved) => parts[index].suffix.length === 0 ? resolved : path.join(resolved, ...parts[index].suffix)
+            ),
+            import_effect.Effect.flatMap(insideWorkspace("fs:read", "read"))
+          ));
+        }, { concurrency: Batch.fallbackConcurrency });
+      });
+    };
+    const guard = (action, value, glob = false) => {
+      const method = action === "fs:read" ? "read" : "write";
+      return resolvedResource(action, method, value, glob).pipe(
+        import_effect.Effect.flatMap(
+          (resource) => (0, import_makeCapability.makeCapability)(action, resource).pipe(
+            import_effect.Effect.flatMap((capability) => grants.check(capability)),
+            import_effect.Effect.mapError(refuse(method, resource)),
+            // The grant decision can suspend — an attended request waiting for
+            // a human, a journal-backed store doing IO. What was authorized is
+            // the resource the path named at check time, so the path must
+            // still name it when the decision arrives: a symlink or rename
+            // swapped in during the wait is refused, never followed.
+            import_effect.Effect.andThen(resolvedResource(action, method, value, glob)),
+            import_effect.Effect.flatMap(
+              (settled) => settled === resource ? import_effect.Effect.void : deny(action, method, resource, "path no longer names the resource that was authorized")
+            )
+          )
+        )
+      );
+    };
+    const read = (value) => guard("fs:read", value);
+    const write = (value) => guard("fs:write", value);
+    const atomicUnavailable = (action, value, method) => deny(
+      action,
+      method,
+      normalize(value),
+      unconfinedDescription
+    );
+    const atomicOne = (action, value, method, request) => atomic === void 0 ? atomicUnavailable(action, value, method) : guard(action, value, request.operation === "glob").pipe(import_effect.Effect.andThen(pinned(atomic, root)(request)));
+    const atomicTwo = (first, second, method, request) => atomic === void 0 ? atomicUnavailable(first[0], first[1], method) : guard(first[0], first[1]).pipe(
+      import_effect.Effect.andThen(guard(second[0], second[1])),
+      import_effect.Effect.andThen(pinned(atomic, root)(request))
+    );
+    const isolatedOne = (action, value, method, use) => atomic?.isolated === void 0 ? atomicUnavailable(action, value, method) : guard(action, value).pipe(import_effect.Effect.andThen(use(atomic.isolated)));
+    const isolatedTwo = (first, second, method, use) => atomic?.isolated === void 0 ? atomicUnavailable(first[0], first[1], method) : guard(first[0], first[1]).pipe(
+      import_effect.Effect.andThen(guard(second[0], second[1])),
+      import_effect.Effect.andThen(use(atomic.isolated))
+    );
+    const temp = (directory) => directory === void 0 ? write(path.resolve(workspace.root, "..", systemTemporaryDirectoryName)) : write(directory);
+    const snapshotOptions = (value) => {
+      if (Array.isArray(value)) return Object.freeze(value.map(snapshotOptions));
+      if (typeof value !== "object" || value === null) return value;
+      const snapshot = {};
+      for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+        if (!descriptor.enumerable) continue;
+        if (!("value" in descriptor)) throw new TypeError("filesystem options must contain only data properties");
+        snapshot[name] = snapshotOptions(descriptor.value);
+      }
+      return Object.freeze(snapshot);
+    };
+    const normalizeTempOptions = (options) => options?.directory === void 0 ? options : { ...options, directory: normalize(options.directory) };
+    const openChecks = (value, flag) => {
+      const readable = readableOpenFlags.has(flag);
+      const writable = writableOpenFlags.has(flag);
+      return readable && writable ? read(value).pipe(import_effect.Effect.andThen(write(value))) : writable ? write(value) : read(value);
+    };
+    const descriptorRefusal = (action, value) => deny(
+      action,
+      action === "fs:read" ? "read" : "write",
+      normalize(value),
+      "descriptor no longer names the resource at its authorized path"
+    );
+    const verifyDescriptor = (host, action, value, identity) => import_effect.Option.match(identity, {
+      onNone: () => import_effect.Effect.void,
+      onSome: (bound) => host.stat(normalize(value)).pipe(
+        import_effect.Effect.matchEffect({
+          onFailure: () => descriptorRefusal(action, value),
+          onSuccess: (info) => import_effect.Option.match(identityOf(info), {
+            onNone: () => descriptorRefusal(action, value),
+            onSome: (current) => current === bound ? import_effect.Effect.void : descriptorRefusal(action, value)
+          })
+        })
+      )
+    });
+    const wrapFile = (host, file, value, identity) => {
+      const readable = import_effect.Effect.suspend(
+        () => read(value).pipe(import_effect.Effect.andThen(verifyDescriptor(host, "fs:read", value, identity)))
+      );
+      const writable = import_effect.Effect.suspend(
+        () => write(value).pipe(import_effect.Effect.andThen(verifyDescriptor(host, "fs:write", value, identity)))
+      );
+      return {
+        [import_effect.FileSystem.FileTypeId]: import_effect.FileSystem.FileTypeId,
+        stat: import_effect.Effect.fn("FileSystem.File.stat")(() => readable.pipe(import_effect.Effect.andThen(file.stat)))(),
+        seek: import_effect.Effect.fn("FileSystem.File.seek")(file.seek),
+        sync: import_effect.Effect.fn("FileSystem.File.sync")(() => writable.pipe(import_effect.Effect.andThen(file.sync)))(),
+        read: import_effect.Effect.fn("FileSystem.File.read")((buffer) => readable.pipe(import_effect.Effect.andThen(file.read(buffer)))),
+        readAlloc: import_effect.Effect.fn("FileSystem.File.readAlloc")(
+          (size) => readable.pipe(import_effect.Effect.andThen(file.readAlloc(size)))
+        ),
+        truncate: import_effect.Effect.fn("FileSystem.File.truncate")(
+          (length) => writable.pipe(import_effect.Effect.andThen(file.truncate(length)))
+        ),
+        write: import_effect.Effect.fn("FileSystem.File.write")((buffer) => writable.pipe(import_effect.Effect.andThen(file.write(buffer)))),
+        writeAll: import_effect.Effect.fn("FileSystem.File.writeAll")(
+          (buffer) => writable.pipe(import_effect.Effect.andThen(file.writeAll(buffer)))
+        )
+      };
+    };
+    const guarded = {
+      ...import_effect.FileSystem.make({
+        access: import_effect.Effect.fn("FileSystem.access")((value, options) => {
+          const captured = snapshotOptions(options);
+          return isolatedOne("fs:read", value, "access", (host) => host.access(normalize(value), captured));
+        }),
+        copy: import_effect.Effect.fn("FileSystem.copy")((from, to, options) => {
+          const captured = snapshotOptions(options);
+          return isolatedTwo(
+            ["fs:read", from],
+            ["fs:write", to],
+            "copy",
+            (host) => host.copy(normalize(from), normalize(to), captured)
+          );
+        }),
+        copyFile: import_effect.Effect.fn("FileSystem.copyFile")(
+          (from, to) => isolatedTwo(
+            ["fs:read", from],
+            ["fs:write", to],
+            "copyFile",
+            (host) => host.copyFile(normalize(from), normalize(to))
+          )
+        ),
+        chmod: import_effect.Effect.fn("FileSystem.chmod")(
+          (value, mode) => atomicOne("fs:write", value, "chmod", { operation: "chmod", path: normalize(value), options: { mode } })
+        ),
+        chown: import_effect.Effect.fn("FileSystem.chown")(
+          (value, uid, gid) => atomicOne("fs:write", value, "chown", {
+            operation: "chown",
+            path: normalize(value),
+            options: { uid, gid }
+          })
+        ),
+        glob: import_effect.Effect.fn("FileSystem.glob")((pattern, options) => {
+          const captured = snapshotOptions(options);
+          const root2 = captured?.root === void 0 ? workspace.root : normalize(captured.root);
+          const normalizedPattern = normalizeFrom(root2, pattern);
+          return atomicOne("fs:read", normalizedPattern, "glob", {
+            operation: "glob",
+            pattern: normalizedPattern,
+            root: root2,
+            options: captured === void 0 ? void 0 : { exclude: captured.exclude ?? [] }
+          });
+        }),
+        link: import_effect.Effect.fn("FileSystem.link")(
+          (from, to) => isolatedTwo(["fs:read", from], ["fs:write", to], "link", (host) => host.link(normalize(from), normalize(to)))
+        ),
+        makeDirectory: import_effect.Effect.fn("FileSystem.makeDirectory")((value, options) => {
+          const captured = snapshotOptions(options);
+          return atomicOne("fs:write", value, "makeDirectory", {
+            operation: "makeDirectory",
+            path: normalize(value),
+            options: captured
+          });
+        }),
+        makeTempDirectory: import_effect.Effect.fn("FileSystem.makeTempDirectory")((options) => {
+          const captured = snapshotOptions(options);
+          return atomic?.isolated === void 0 ? atomicUnavailable(
+            "fs:write",
+            captured?.directory ?? `../${systemTemporaryDirectoryName}`,
+            "makeTempDirectory"
+          ) : temp(captured?.directory).pipe(
+            import_effect.Effect.andThen(atomic.isolated.makeTempDirectory(normalizeTempOptions(captured)))
+          );
+        }),
+        makeTempDirectoryScoped: import_effect.Effect.fn("FileSystem.makeTempDirectoryScoped")((options) => {
+          const captured = snapshotOptions(options);
+          return atomic?.isolated === void 0 ? atomicUnavailable(
+            "fs:write",
+            captured?.directory ?? `../${systemTemporaryDirectoryName}`,
+            "makeTempDirectoryScoped"
+          ) : temp(captured?.directory).pipe(
+            import_effect.Effect.andThen(atomic.isolated.makeTempDirectoryScoped(normalizeTempOptions(captured)))
+          );
+        }),
+        makeTempFile: import_effect.Effect.fn("FileSystem.makeTempFile")((options) => {
+          const captured = snapshotOptions(options);
+          return atomic?.isolated === void 0 ? atomicUnavailable(
+            "fs:write",
+            captured?.directory ?? `../${systemTemporaryDirectoryName}`,
+            "makeTempFile"
+          ) : temp(captured?.directory).pipe(
+            import_effect.Effect.andThen(atomic.isolated.makeTempFile(normalizeTempOptions(captured)))
+          );
+        }),
+        makeTempFileScoped: import_effect.Effect.fn("FileSystem.makeTempFileScoped")((options) => {
+          const captured = snapshotOptions(options);
+          return atomic?.isolated === void 0 ? atomicUnavailable(
+            "fs:write",
+            captured?.directory ?? `../${systemTemporaryDirectoryName}`,
+            "makeTempFileScoped"
+          ) : temp(captured?.directory).pipe(
+            import_effect.Effect.andThen(atomic.isolated.makeTempFileScoped(normalizeTempOptions(captured)))
+          );
+        }),
+        open: import_effect.Effect.fn("FileSystem.open")((value, options) => {
+          const captured = snapshotOptions(options);
+          const flag = captured?.flag ?? "r";
+          const isolated = atomic?.isolated;
+          return isolated === void 0 ? atomicUnavailable("fs:read", value, "open") : openChecks(value, flag).pipe(
+            import_effect.Effect.andThen(isolated.open(normalize(value), captured)),
+            // fstat the handle the moment it exists: the authorization the
+            // open checks granted binds to THIS resource identity, and every
+            // later handle operation verifies the authorized path still
+            // names it before delegating to the descriptor.
+            import_effect.Effect.flatMap(
+              (file) => file.stat.pipe(
+                import_effect.Effect.map((info) => wrapFile(isolated, file, value, identityOf(info)))
+              )
+            )
+          );
+        }),
+        readDirectory: import_effect.Effect.fn("FileSystem.readDirectory")((value, options) => {
+          const captured = snapshotOptions(options);
+          return atomicOne("fs:read", value, "readDirectory", {
+            operation: "readDirectory",
+            path: normalize(value),
+            options: captured
+          });
+        }),
+        readFile: import_effect.Effect.fn("FileSystem.readFile")(
+          (value) => atomicOne("fs:read", value, "readFile", {
+            operation: "readFile",
+            path: normalize(value)
+          })
+        ),
+        readLink: import_effect.Effect.fn("FileSystem.readLink")(
+          (value) => atomicOne("fs:read", value, "readLink", {
+            operation: "readLink",
+            path: normalize(value)
+          })
+        ),
+        realPath: import_effect.Effect.fn("FileSystem.realPath")(
+          (value) => atomicOne("fs:read", value, "realPath", {
+            operation: "realPath",
+            path: normalize(value)
+          })
+        ),
+        remove: import_effect.Effect.fn("FileSystem.remove")((value, options) => {
+          const captured = snapshotOptions(options);
+          return atomicOne("fs:write", value, "remove", {
+            operation: "remove",
+            path: normalize(value),
+            options: captured
+          });
+        }),
+        rename: import_effect.Effect.fn("FileSystem.rename")(
+          (from, to) => atomicTwo(["fs:write", from], ["fs:write", to], "rename", {
+            operation: "rename",
+            from: normalize(from),
+            to: normalize(to)
+          })
+        ),
+        stat: import_effect.Effect.fn("FileSystem.stat")(
+          (value) => atomicOne("fs:read", value, "stat", {
+            operation: "stat",
+            path: normalize(value)
+          })
+        ),
+        symlink: import_effect.Effect.fn("FileSystem.symlink")(
+          (from, to) => isolatedOne("fs:write", to, "symlink", (host) => host.symlink(from, normalize(to)))
+        ),
+        truncate: import_effect.Effect.fn("FileSystem.truncate")(
+          (value, length) => isolatedOne("fs:write", value, "truncate", (host) => host.truncate(normalize(value), length))
+        ),
+        utimes: import_effect.Effect.fn("FileSystem.utimes")(
+          (value, atime, mtime) => isolatedOne("fs:write", value, "utimes", (host) => host.utimes(normalize(value), atime, mtime))
+        ),
+        watch: (value) => import_effect.Stream.unwrap(
+          import_effect.Effect.fn("FileSystem.watch")(
+            () => import_effect.Effect.suspend(
+              () => atomic?.isolated === void 0 ? atomicUnavailable("fs:read", value, "watch") : read(value).pipe(import_effect.Effect.map(() => atomic.isolated.watch(normalize(value))))
+            )
+          )()
+        ),
+        writeFile: import_effect.Effect.fn("FileSystem.writeFile")((value, data, options) => {
+          const captured = snapshotOptions(options);
+          const bytes = data.slice();
+          if (atomic?.isolated !== void 0) {
+            return isolatedOne(
+              "fs:write",
+              value,
+              "writeFile",
+              (host) => host.writeFile(normalize(value), bytes, captured)
+            );
+          }
+          const limit = atomic?.contentLimit;
+          if (limit !== void 0 && bytes.byteLength > limit) {
+            return import_effect.Effect.fail(import_effect.PlatformError.badArgument({
+              module: "FileSystem",
+              method: "writeFile",
+              description: `writeFile payload of ${bytes.byteLength} bytes exceeds the ${limit} byte limit advertised by the host`
+            }));
+          }
+          return atomicOne("fs:write", value, "writeFile", {
+            operation: "writeFile",
+            path: normalize(value),
+            data: import_effect.Encoding.encodeBase64(bytes),
+            options: captured
+          });
+        })
+      }),
+      exists: import_effect.Effect.fn("FileSystem.exists")(
+        (value) => atomicOne("fs:read", value, "exists", {
+          operation: "exists",
+          path: normalize(value)
+        })
+      ),
+      readFileString: import_effect.Effect.fn("FileSystem.readFileString")(
+        (value, encoding) => atomicOne("fs:read", value, "readFileString", {
+          operation: "readFileString",
+          path: normalize(value),
+          encoding
+        })
+      ),
+      sink: (value, options) => {
+        const captured = snapshotOptions(options);
+        return import_effect.Sink.unwrap(
+          import_effect.Effect.fn("FileSystem.sink")(
+            () => import_effect.Effect.suspend(
+              () => atomic?.isolated === void 0 ? atomicUnavailable("fs:write", value, "sink") : write(value).pipe(import_effect.Effect.map(() => atomic.isolated.sink(normalize(value), captured)))
+            )
+          )()
+        );
+      },
+      stream: (value, options) => {
+        const captured = snapshotOptions(options);
+        return import_effect.Stream.unwrap(
+          import_effect.Effect.fn("FileSystem.stream")(
+            () => import_effect.Effect.suspend(
+              () => atomic?.isolated === void 0 ? atomicUnavailable("fs:read", value, "stream") : read(value).pipe(import_effect.Effect.map(() => atomic.isolated.stream(normalize(value), captured)))
+            )
+          )()
+        );
+      },
+      writeFileString: import_effect.Effect.fn("FileSystem.writeFileString")((value, data, options) => {
+        const captured = snapshotOptions(options);
+        return atomicOne("fs:write", value, "writeFileString", {
+          operation: "writeFileString",
+          path: normalize(value),
+          data,
+          options: captured
+        });
+      })
+    };
+    Object.assign(guarded, { [ConfinedFileSystemTypeId]: logicalRoot });
+    if (atomic === void 0 || atomic.batchLimits === void 0) {
+      return guarded;
+    } else {
+      const limits = atomic.batchLimits;
+      const executeBatch = import_effect.Effect.fn("FileSystem.batch")(function* (requests) {
+        if (requests.length === 0 || requests.length > Math.min(limits.size, Batch.maxBatchSize)) {
+          return yield* import_effect.Effect.fail(
+            import_effect.PlatformError.badArgument({
+              module: "FileSystem",
+              method: "batch",
+              description: `batch must contain 1 to ${Math.min(limits.size, Batch.maxBatchSize)} operations`
+            })
+          );
+        }
+        if (import_effect.Option.isNone(rootIdentity)) {
+          return yield* atomicUnavailable("fs:read", logicalRoot, "batch");
+        }
+        const captured = snapshotOptions(requests).map((request) => ({
+          ...request,
+          path: request.operation === "glob" ? normalizeFrom(normalize(request.root), request.path) : normalize(request.path),
+          ...request.operation === "glob" ? { root: normalize(request.root) } : {}
+        }));
+        const rootChanged = (cause) => import_effect.PlatformError.systemError({
+          _tag: "Busy",
+          module: "FileSystem",
+          method: "batch",
+          pathOrDescriptor: logicalRoot,
+          description: "batch root no longer names the authorized descriptor",
+          cause
+        });
+        const expectedRoot = rootIdentity.value;
+        const verifyRoot = () => identifyRoot(atomic, fileSystem, logicalRoot).pipe(
+          import_effect.Effect.mapError(rootChanged),
+          import_effect.Effect.flatMap(
+            (current2) => import_effect.Option.isSome(current2) && current2.value === expectedRoot ? import_effect.Effect.void : import_effect.Effect.fail(rootChanged(
+              new FileSystemFault({
+                code: "workspace_identity_changed",
+                message: "workspace descriptor identity changed"
+              })
+            ))
+          )
+        );
+        yield* verifyRoot();
+        const resources = yield* resolvedResources(captured);
+        const admitted = [];
+        const indexes = [];
+        const entries = [];
+        const granted = [];
+        for (const [index, request] of captured.entries()) {
+          const resource = resources[index];
+          const checked = import_effect.Result.isFailure(resource) ? import_effect.Result.fail(resource.failure) : yield* import_effect.Effect.result(
+            (0, import_makeCapability.makeCapability)("fs:read", resource.success).pipe(
+              import_effect.Effect.flatMap((capability) => grants.check(capability)),
+              import_effect.Effect.mapError(refuse("read", resource.success))
+            )
+          );
+          if (import_effect.Result.isFailure(checked)) {
+            entries.push({ index, path: request.path, result: import_effect.Result.fail(checked.failure) });
+          } else granted.push({ request, index, resource: import_effect.Result.getOrThrow(resource) });
+        }
+        const current = granted.length === 0 ? [] : yield* resolvedResources(granted.map(({ request }) => request));
+        const settled = yield* import_effect.Effect.forEach(granted, ({ resource }, position) => {
+          const now = current[position];
+          return import_effect.Effect.result(
+            import_effect.Result.isFailure(now) ? import_effect.Effect.fail(now.failure) : now.success === resource ? import_effect.Effect.void : deny("fs:read", "read", resource, "path no longer names the resource that was authorized")
+          );
+        });
+        for (const [position, member] of granted.entries()) {
+          const checked = settled[position];
+          if (import_effect.Result.isFailure(checked)) {
+            entries.push({ index: member.index, path: member.request.path, result: import_effect.Result.fail(checked.failure) });
+          } else {
+            admitted.push(member.request);
+            indexes.push(member.index);
+          }
+        }
+        yield* verifyRoot();
+        if (admitted.length > 0) {
+          const measured = yield* atomic.execute({
+            operation: "batch",
+            boundaryRoot,
+            logicalRoot,
+            rootIdentity: rootIdentity.value,
+            requests: admitted
+          });
+          for (const entry of measured.entries) {
+            entries.push({
+              index: indexes[entry.index],
+              path: entry.path,
+              result: publicValue(entry.path, entry.result)
+            });
+          }
+        }
+        entries.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.index - b.index);
+        return { rootIdentity: rootIdentity.value, entries };
+      });
+      return Object.assign(guarded, {
+        [Batch.FileSystemBatchTypeId]: {
+          maxSize: Math.min(limits.size, Batch.maxBatchSize),
+          maxResponseBytes: limits.response,
+          execute: executeBatch
+        }
+      });
+    }
+  })
+);
+//# sourceMappingURL=FileSystem.js.map