@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/internal/AtomicFileSystemTransport.js

@@ -0,0 +1,197 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AtomicFileSystemTransport_exports = {};
+__export(AtomicFileSystemTransport_exports, {
+  inside: () => inside,
+  spawnHelper: () => spawnHelper,
+  started: () => started,
+  usableExecutable: () => usableExecutable
+});
+module.exports = __toCommonJS(AtomicFileSystemTransport_exports);
+var import_effect = require("effect");
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_AtomicFileSystemProtocol = require("./AtomicFileSystemProtocol.js");
+var import_AtomicHelperError = require("./AtomicHelperError.js");
+var import_AtomicHelperFault = require("./AtomicHelperFault.js");
+let startedHelpers = 0;
+const started = () => startedHelpers;
+const inertDirectory = (0, import_node_path.parse)(process.execPath).root;
+const inside = (root, target) => {
+  const path = (0, import_node_path.relative)(root, target);
+  return path === "" || path !== ".." && !path.startsWith(`..${import_node_path.sep}`) && !(0, import_node_path.isAbsolute)(path);
+};
+const executablePath = (configured) => {
+  let current = configured;
+  for (let links = 0; links < 40; links++) {
+    if (current.endsWith("/") || current.endsWith(import_node_path.sep)) {
+      throw new import_AtomicHelperError.AtomicHelperError({
+        code: "helper_path_invalid",
+        message: "atomic helper executable cannot end with a directory separator"
+      });
+    }
+    const parent = import_node_fs.realpathSync.native((0, import_node_path.dirname)(current));
+    const candidate = (0, import_node_path.join)(parent, (0, import_node_path.basename)(current));
+    if (!(0, import_node_fs.lstatSync)(candidate).isSymbolicLink()) return candidate;
+    const target = (0, import_node_fs.readlinkSync)(candidate);
+    current = (0, import_node_path.isAbsolute)(target) ? target : `${parent}/${target}`;
+  }
+  throw new import_AtomicHelperError.AtomicHelperError({
+    code: "helper_path_invalid",
+    message: "atomic helper executable has too many symbolic links"
+  });
+};
+const usableExecutable = (configured, boundaryRoot) => {
+  if (!(0, import_node_path.isAbsolute)(configured)) {
+    throw new import_AtomicHelperError.AtomicHelperError({
+      code: "helper_path_invalid",
+      message: `atomic helper executable must be an absolute path, got ${JSON.stringify(configured)}`
+    });
+  }
+  const resolved = executablePath(configured);
+  if (!(0, import_node_fs.statSync)(resolved).isFile()) {
+    throw new import_AtomicHelperError.AtomicHelperError({
+      code: "helper_not_regular_file",
+      message: `atomic helper executable is not a regular file: ${resolved}`
+    });
+  }
+  (0, import_node_fs.accessSync)(resolved, import_node_fs.constants.X_OK);
+  if (boundaryRoot !== void 0 && inside(boundaryRoot, resolved)) {
+    throw new import_AtomicHelperError.AtomicHelperError({
+      code: "helper_inside_workspace",
+      message: `atomic helper executable must live outside the confined workspace: ${resolved}`
+    });
+  }
+  return resolved;
+};
+const spawnHelper = (request, executable, payload, settings) => import_effect.Effect.callback((resume) => {
+  const limits = settings.limits;
+  let settled = false;
+  const stdout = [];
+  let stdoutBytes = 0;
+  const stderr = [];
+  let stderrBytes = 0;
+  let truncated = false;
+  let writeFailure;
+  let child;
+  try {
+    child = (0, import_node_child_process.spawn)(executable, ["--atomic-fs"], {
+      cwd: inertDirectory,
+      env: {},
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    startedHelpers++;
+  } catch (cause) {
+    resume(import_effect.Effect.fail((0, import_AtomicFileSystemProtocol.failure)(request, cause)));
+    return import_effect.Effect.void;
+  }
+  const closed = new Promise((resolve) => child.once("close", () => resolve()));
+  const cleanup = () => {
+    clearTimeout(deadline);
+    child.stdin.destroy();
+    child.stdout.destroy();
+    child.stderr.destroy();
+    child.kill("SIGKILL");
+  };
+  const complete = (effect) => {
+    if (settled) return;
+    settled = true;
+    cleanup();
+    resume(import_effect.Effect.andThen(import_effect.Effect.promise(() => closed), effect));
+  };
+  const deadline = setTimeout(() => {
+    complete(import_effect.Effect.fail((0, import_AtomicFileSystemProtocol.failure)(
+      request,
+      (0, import_AtomicHelperFault.atomicHelperFault)("helper_timeout", `atomic helper did not answer within ${settings.timeoutMs} ms`)
+    )));
+  }, settings.timeoutMs);
+  deadline.unref();
+  child.stdout.on("data", (chunk) => {
+    const remaining = limits.response + import_AtomicFileSystemProtocol.frameHeaderBytes - stdoutBytes;
+    if (chunk.byteLength > remaining) {
+      if (remaining > 0) {
+        stdout.push(chunk.subarray(0, remaining));
+        stdoutBytes += remaining;
+      }
+      complete(import_effect.Effect.fail((0, import_AtomicFileSystemProtocol.failure)(
+        request,
+        (0, import_AtomicHelperFault.atomicHelperFault)(
+          "response_limit_exceeded",
+          `atomic helper wrote more than ${limits.response} response bytes`
+        )
+      )));
+      return;
+    }
+    stdoutBytes += chunk.byteLength;
+    stdout.push(chunk);
+  });
+  child.stderr.on("data", (chunk) => {
+    const slice = chunk.subarray(0, limits.stderr - stderrBytes);
+    stderrBytes += slice.byteLength;
+    stderr.push(slice);
+    if (stderrBytes >= limits.stderr) {
+      truncated = true;
+      child.stderr.destroy();
+    }
+  });
+  child.on("error", (cause) => complete(import_effect.Effect.fail((0, import_AtomicFileSystemProtocol.failure)(request, cause))));
+  child.stdin.on("error", (cause) => {
+    writeFailure = cause;
+  });
+  child.on("close", (code) => {
+    let envelope;
+    let malformed;
+    try {
+      envelope = (0, import_AtomicFileSystemProtocol.decode)(Buffer.concat(stdout), limits);
+    } catch (cause) {
+      malformed = cause;
+    }
+    if (envelope !== void 0 && !envelope.ok) {
+      complete(import_effect.Effect.fail((0, import_AtomicFileSystemProtocol.failure)(
+        request,
+        (0, import_AtomicHelperFault.atomicHelperFault)("helper_rejected", envelope.message ?? "atomic helper rejected the operation"),
+        envelope
+      )));
+      return;
+    }
+    if (envelope !== void 0 && code === 0) {
+      try {
+        complete((0, import_AtomicFileSystemProtocol.convert)(request, envelope.value, limits));
+      } catch (cause) {
+        complete(import_effect.Effect.fail((0, import_AtomicFileSystemProtocol.failure)(request, cause)));
+      }
+      return;
+    }
+    const text = Buffer.concat(stderr).toString("utf8");
+    complete(import_effect.Effect.fail((0, import_AtomicFileSystemProtocol.failure)(
+      request,
+      text !== "" ? (0, import_AtomicHelperFault.atomicHelperFault)(
+        "helper_exited",
+        `atomic helper exited ${code}: ${text}${truncated ? " (truncated)" : ""}`
+      ) : writeFailure !== void 0 ? writeFailure : malformed !== void 0 ? malformed : (0, import_AtomicHelperFault.atomicHelperFault)("helper_exited", `atomic helper exited ${code}`)
+    )));
+  });
+  child.stdin.end(payload);
+  return import_effect.Effect.promise(async () => {
+    cleanup();
+    await closed;
+  });
+});
+//# sourceMappingURL=AtomicFileSystemTransport.js.map

package/dist/cjs/internal/AtomicFileSystemTransport.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/AtomicFileSystemTransport.ts"],
+  "sourcesContent": ["/**\n * The process transport beneath the atomic filesystem: resolving the\n * configured helper to a file the confined workspace cannot have\n * supplied, and running one isolated, bounded helper process per framed\n * request.\n * @since 1.0.0\n */\n\nimport type * as KernelFileSystem from \"@smthrs/kernel/FileSystem\"\nimport { Effect, type PlatformError } from \"effect\"\nimport { type ChildProcessWithoutNullStreams, spawn } from \"node:child_process\"\nimport { accessSync, constants, lstatSync, readlinkSync, realpathSync, statSync } from \"node:fs\"\nimport { basename, dirname, isAbsolute, join, parse, relative, sep } from \"node:path\"\nimport type { Limits } from \"../AtomicFileSystem.ts\"\nimport { convert, decode, failure, frameHeaderBytes, type HelperResult } from \"./AtomicFileSystemProtocol.ts\"\nimport { AtomicHelperError } from \"./AtomicHelperError.ts\"\nimport { atomicHelperFault } from \"./AtomicHelperFault.ts\"\n\nlet startedHelpers = 0\n\n/**\n * Process-local helper starts, including helpers later cancelled or refused.\n * @private\n * @since 1.0.0\n */\nexport const started = (): number => startedHelpers\n\n/** An inert working directory: nothing the helper could import lives there. */\nconst inertDirectory = parse(process.execPath).root\n\n/**\n * True when `target` is at or below `root`. Both are absolute and already\n * canonical. A different Windows drive produces an absolute relative result.\n * @private\n * @since 1.0.0\n */\nexport const inside = (root: string, target: string): boolean => {\n  const path = relative(root, target)\n  return path === \"\" || (path !== \"..\" && !path.startsWith(`..${sep}`) && !isAbsolute(path))\n}\n\n/** Resolve symlinks without replacing a hard-linked executable's entry name. */\nconst executablePath = (configured: string): string => {\n  let current = configured\n  for (let links = 0; links < 40; links++) {\n    if (current.endsWith(\"/\") || current.endsWith(sep)) {\n      throw new AtomicHelperError({\n        code: \"helper_path_invalid\",\n        message: \"atomic helper executable cannot end with a directory separator\"\n      })\n    }\n    // Bun's macOS realpath can return another hard link to the final inode:\n    // A hard-linked executable can change its entry name during guarded reads.\n    // Directories cannot have those file aliases. Resolve the parent, preserve\n    // the leaf name, and explicitly follow only actual leaf symlinks.\n    const parent = realpathSync.native(dirname(current))\n    const candidate = join(parent, basename(current))\n    if (!lstatSync(candidate).isSymbolicLink()) return candidate\n    const target = readlinkSync(candidate)\n    // Do not normalize `link/..` lexically; realpath must traverse it first.\n    current = isAbsolute(target) ? target : `${parent}/${target}`\n  }\n  throw new AtomicHelperError({\n    code: \"helper_path_invalid\",\n    message: \"atomic helper executable has too many symbolic links\"\n  })\n}\n\n/**\n * Resolves the configured helper to an absolute, executable regular file\n * that the confined workspace cannot have supplied. Every failure throws, and\n * every throw becomes a fail-closed `PermissionDenied`, so a host without a\n * usable helper performs no filesystem operation at all.\n * @private\n * @since 1.0.0\n */\nexport const usableExecutable = (configured: string, boundaryRoot: string | undefined): string => {\n  if (!isAbsolute(configured)) {\n    throw new AtomicHelperError({\n      code: \"helper_path_invalid\",\n      message: `atomic helper executable must be an absolute path, got ${JSON.stringify(configured)}`\n    })\n  }\n  // Resolved first: the checks below have to describe the file that will\n  // actually run, not the name that leads to it.\n  const resolved = executablePath(configured)\n  if (!statSync(resolved).isFile()) {\n    throw new AtomicHelperError({\n      code: \"helper_not_regular_file\",\n      message: `atomic helper executable is not a regular file: ${resolved}`\n    })\n  }\n  accessSync(resolved, constants.X_OK)\n  if (boundaryRoot !== undefined && inside(boundaryRoot, resolved)) {\n    throw new AtomicHelperError({\n      code: \"helper_inside_workspace\",\n      message: `atomic helper executable must live outside the confined workspace: ${resolved}`\n    })\n  }\n  return resolved\n}\n\n/**\n * Runs one helper over one framed request and settles with its converted\n * answer. Every exit path kills the child, releases its pipes, and waits for\n * the operating system to report that the process has closed.\n * @private\n * @since 1.0.0\n */\nexport const spawnHelper = <A>(\n  request: KernelFileSystem.AtomicRequest,\n  executable: string,\n  payload: Buffer,\n  settings: { readonly limits: Limits; readonly timeoutMs: number }\n): Effect.Effect<A, PlatformError.PlatformError> =>\n  Effect.callback<A, PlatformError.PlatformError>((resume) => {\n    const limits = settings.limits\n    let settled = false\n    const stdout: Array<Buffer> = []\n    let stdoutBytes = 0\n    const stderr: Array<Buffer> = []\n    let stderrBytes = 0\n    let truncated = false\n    let writeFailure: unknown\n\n    // The packaged helper runs with an inert cwd and empty environment. The\n    // configured executable is validated outside the confined root first.\n    let child: ChildProcessWithoutNullStreams\n    try {\n      child = spawn(executable, [\"--atomic-fs\"], {\n        cwd: inertDirectory,\n        env: {},\n        stdio: [\"pipe\", \"pipe\", \"pipe\"]\n      })\n      startedHelpers++\n    } catch (cause) {\n      // libuv reports some exec failures \u2014 `ENOEXEC` for a file that is\n      // neither a script nor a binary \u2014 by throwing rather than by emitting an\n      // `error` event, so both arrivals have to end in the same refusal.\n      resume(Effect.fail(failure(request, cause)))\n      return Effect.void\n    }\n    const closed = new Promise<void>((resolve) => child.once(\"close\", () => resolve()))\n    // `deadline` is armed below, after the completion it resumes through\n    // exists. Reading it here is safe because nothing calls `cleanup` before\n    // then: the one earlier exit, a spawn that threw, resumes and returns.\n    const cleanup = () => {\n      clearTimeout(deadline)\n      child.stdin.destroy()\n      child.stdout.destroy()\n      child.stderr.destroy()\n      child.kill(\"SIGKILL\")\n    }\n    const complete = (effect: Effect.Effect<A, PlatformError.PlatformError>) => {\n      if (settled) return\n      settled = true\n      // Every exit path drains and kills, so an overflowing, hung, or already\n      // finished helper leaves no descriptor and no child behind.\n      cleanup()\n      resume(Effect.andThen(Effect.promise(() => closed), effect))\n    }\n    // A wall-clock backstop, independent of every byte ceiling. Those bound\n    // what a helper may SAY; nothing bounds how long it may take to say it, and\n    // a helper that never answers would otherwise hold the fiber until the run\n    // itself is interrupted.\n    const deadline = setTimeout(() => {\n      complete(Effect.fail(failure(\n        request,\n        atomicHelperFault(\"helper_timeout\", `atomic helper did not answer within ${settings.timeoutMs} ms`)\n      )))\n    }, settings.timeoutMs)\n    deadline.unref()\n    // Raw buffers, never decoded strings: a chunk boundary in the middle of a\n    // multi-byte character would otherwise be decoded as two replacement\n    // characters before the JSON parse ever saw it. Concatenating once at the\n    // end also keeps accumulation linear instead of quadratic.\n    // Retained bytes are bounded by the ceiling plus at most one pipe chunk:\n    // an overflowing chunk is sliced before it is retained, so the host never\n    // relies on the stream implementation's chunk-size convention.\n    child.stdout.on(\"data\", (chunk: Buffer) => {\n      const remaining = limits.response + frameHeaderBytes - stdoutBytes\n      if (chunk.byteLength > remaining) {\n        if (remaining > 0) {\n          stdout.push(chunk.subarray(0, remaining))\n          stdoutBytes += remaining\n        }\n        complete(Effect.fail(failure(\n          request,\n          atomicHelperFault(\n            \"response_limit_exceeded\",\n            `atomic helper wrote more than ${limits.response} response bytes`\n          )\n        )))\n        return\n      }\n      stdoutBytes += chunk.byteLength\n      stdout.push(chunk)\n    })\n    // stderr is bounded on its own budget: a helper that says nothing useful\n    // on stdout must not be able to exhaust the host through diagnostics.\n    // Destroying the pipe stops the helper at its next write rather than\n    // letting it produce output nobody will read.\n    child.stderr.on(\"data\", (chunk: Buffer) => {\n      // Sliced to the remaining room rather than kept whole, so the retained\n      // text is exactly the budget and not the budget plus a pipe buffer.\n      const slice = chunk.subarray(0, limits.stderr - stderrBytes)\n      stderrBytes += slice.byteLength\n      stderr.push(slice)\n      if (stderrBytes >= limits.stderr) {\n        truncated = true\n        child.stderr.destroy()\n      }\n    })\n    child.on(\"error\", (cause) => complete(Effect.fail(failure(request, cause))))\n    // A helper that exits before draining stdin \u2014 an unavailable helper,\n    // a rejected request, an interrupt that killed it mid-write \u2014 makes the\n    // request write fail with EPIPE. Without a listener that is an unhandled\n    // `error` event on the pipe, which terminates the host process instead of\n    // failing one filesystem call. It is recorded rather than resumed on, so\n    // that a helper which did manage to report a real errno keeps precedence\n    // over the broken pipe its own exit caused.\n    child.stdin.on(\"error\", (cause) => {\n      writeFailure = cause\n    })\n    child.on(\"close\", (code) => {\n      let envelope: HelperResult | undefined\n      let malformed: unknown\n      try {\n        envelope = decode(Buffer.concat(stdout), limits)\n      } catch (cause) {\n        malformed = cause\n      }\n      if (envelope !== undefined && !envelope.ok) {\n        // The helper's own typed rejection outranks the exit status and any\n        // transport noise: it is the only thing that knows which errno the\n        // syscall produced.\n        complete(Effect.fail(failure(\n          request,\n          atomicHelperFault(\"helper_rejected\", envelope.message ?? \"atomic helper rejected the operation\"),\n          envelope\n        )))\n        return\n      }\n      if (envelope !== undefined && code === 0) {\n        try {\n          complete(convert<A>(request, envelope.value, limits))\n        } catch (cause) {\n          complete(Effect.fail(failure(request, cause)))\n        }\n        return\n      }\n      const text = Buffer.concat(stderr).toString(\"utf8\")\n      complete(Effect.fail(failure(\n        request,\n        text !== \"\"\n          ? atomicHelperFault(\n            \"helper_exited\",\n            `atomic helper exited ${code}: ${text}${truncated ? \" (truncated)\" : \"\"}`\n          )\n          : writeFailure !== undefined\n          ? writeFailure\n          : malformed !== undefined\n          ? malformed\n          : atomicHelperFault(\"helper_exited\", `atomic helper exited ${code}`)\n      )))\n    })\n    child.stdin.end(payload)\n    return Effect.promise(async () => {\n      cleanup()\n      await closed\n    })\n  })\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/internal/AtomicHelperError.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The configuration failures of the atomic filesystem helper: a layer option
+ * outside its bounds, a request that cannot be serialized, and a helper that
+ * cannot be found, is not usable, or is not trusted. A caller classifies one
+ * by `_tag` and `code` instead of reading its message.
+ * @since 1.0.0
+ */
+import { Schema } from "effect";
+/**
+ * Why the atomic helper could not be configured or resolved.
+ * @category models
+ * @since 1.0.0
+ */
+export declare const AtomicHelperErrorCode: Schema.Literals<readonly ["limit_invalid", "concurrency_invalid", "timeout_invalid", "request_not_serializable", "helper_missing", "helper_unusable", "helper_path_invalid", "helper_not_regular_file", "helper_inside_workspace", "staging_directory_not_private", "staging_unavailable"]>;
+/**
+ * The stable code of an {@link AtomicHelperError}.
+ * @category models
+ * @since 1.0.0
+ */
+export type AtomicHelperErrorCode = typeof AtomicHelperErrorCode.Type;
+declare const AtomicHelperError_base: Schema.Class<AtomicHelperError, Schema.TaggedStruct<"@smthrs/platform-node/AtomicHelperError", {
+    readonly code: Schema.Literals<readonly ["limit_invalid", "concurrency_invalid", "timeout_invalid", "request_not_serializable", "helper_missing", "helper_unusable", "helper_path_invalid", "helper_not_regular_file", "helper_inside_workspace", "staging_directory_not_private", "staging_unavailable"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The atomic helper is misconfigured, missing, or untrusted. `message` names
+ * what was searched and how to install the helper where that applies.
+ * @category errors
+ * @since 1.0.0
+ */
+export declare class AtomicHelperError extends AtomicHelperError_base {
+    readonly name = "AtomicHelperError";
+}
+export {};
+//# sourceMappingURL=AtomicHelperError.d.ts.map

package/dist/cjs/internal/AtomicHelperError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AtomicHelperError.d.ts","sourceRoot":"","sources":["../../../src/internal/AtomicHelperError.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,6RAYhC,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAC,IAAI,CAAA;;;;;AAErE;;;;;GAKG;AACH,qBAAa,iBACX,SAAQ,sBAGN;IAEF,SAAkB,IAAI,uBAAsB;CAC7C"}

package/dist/cjs/internal/AtomicHelperError.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AtomicHelperError_exports = {};
+__export(AtomicHelperError_exports, {
+  AtomicHelperError: () => AtomicHelperError,
+  AtomicHelperErrorCode: () => AtomicHelperErrorCode
+});
+module.exports = __toCommonJS(AtomicHelperError_exports);
+var import_effect = require("effect");
+const AtomicHelperErrorCode = import_effect.Schema.Literals([
+  "limit_invalid",
+  "concurrency_invalid",
+  "timeout_invalid",
+  "request_not_serializable",
+  "helper_missing",
+  "helper_unusable",
+  "helper_path_invalid",
+  "helper_not_regular_file",
+  "helper_inside_workspace",
+  "staging_directory_not_private",
+  "staging_unavailable"
+]);
+class AtomicHelperError extends import_effect.Schema.TaggedError()("@smthrs/platform-node/AtomicHelperError", {
+  code: AtomicHelperErrorCode,
+  message: import_effect.Schema.String
+}) {
+  name = "AtomicHelperError";
+}
+//# sourceMappingURL=AtomicHelperError.js.map

package/dist/cjs/internal/AtomicHelperError.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/AtomicHelperError.ts"],
+  "sourcesContent": ["/**\n * The configuration failures of the atomic filesystem helper: a layer option\n * outside its bounds, a request that cannot be serialized, and a helper that\n * cannot be found, is not usable, or is not trusted. A caller classifies one\n * by `_tag` and `code` instead of reading its message.\n * @since 1.0.0\n */\n\nimport { Schema } from \"effect\"\n\n/**\n * Why the atomic helper could not be configured or resolved.\n * @category models\n * @since 1.0.0\n */\nexport const AtomicHelperErrorCode = Schema.Literals([\n  \"limit_invalid\",\n  \"concurrency_invalid\",\n  \"timeout_invalid\",\n  \"request_not_serializable\",\n  \"helper_missing\",\n  \"helper_unusable\",\n  \"helper_path_invalid\",\n  \"helper_not_regular_file\",\n  \"helper_inside_workspace\",\n  \"staging_directory_not_private\",\n  \"staging_unavailable\"\n])\n\n/**\n * The stable code of an {@link AtomicHelperError}.\n * @category models\n * @since 1.0.0\n */\nexport type AtomicHelperErrorCode = typeof AtomicHelperErrorCode.Type\n\n/**\n * The atomic helper is misconfigured, missing, or untrusted. `message` names\n * what was searched and how to install the helper where that applies.\n * @category errors\n * @since 1.0.0\n */\nexport class AtomicHelperError\n  extends Schema.TaggedError<AtomicHelperError>()(\"@smthrs/platform-node/AtomicHelperError\", {\n    code: AtomicHelperErrorCode,\n    message: Schema.String\n  })\n{\n  override readonly name = \"AtomicHelperError\"\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,oBAAuB;AAOhB,MAAM,wBAAwB,qBAAO,SAAS;AAAA,EACnD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAeM,MAAM,0BACH,qBAAO,YAA+B,EAAE,2CAA2C;AAAA,EACzF,MAAM;AAAA,EACN,SAAS,qBAAO;AAClB,CAAC,EACH;AAAA,EACoB,OAAO;AAC3B;",
+  "names": []
+}

package/dist/cjs/internal/AtomicHelperFault.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The atomic helper broke its protocol or its transport failed: a response that
+ * is not framed, a field of the wrong shape, an answer over a bound, a helper
+ * that never answered, or one that exited. `AtomicFileSystemProtocol.failure`
+ * reports one as the `cause` of a `PlatformError`, so a caller classifies it by
+ * `_tag` and `code`. {@link AtomicHelperRejection} carries the errno a helper
+ * itself reported.
+ * @since 1.0.0
+ */
+import { Schema } from "effect";
+/**
+ * Which rule of the helper protocol or transport was broken.
+ * @category models
+ * @since 1.0.0
+ */
+export declare const AtomicHelperFaultCode: Schema.Literals<readonly ["response_unframed", "response_tag_unknown", "response_length_invalid", "response_length_mismatch", "envelope_malformed", "field_malformed", "file_type_unknown", "payload_malformed", "read_limit_exceeded", "entries_malformed", "batch_malformed", "digest_malformed", "result_malformed", "operation_unsupported", "helper_timeout", "response_limit_exceeded", "helper_rejected", "helper_exited"]>;
+/**
+ * The stable code of an {@link AtomicHelperFault}.
+ * @category models
+ * @since 1.0.0
+ */
+export type AtomicHelperFaultCode = typeof AtomicHelperFaultCode.Type;
+declare const AtomicHelperFault_base: Schema.Class<AtomicHelperFault, Schema.TaggedStruct<"@smthrs/platform-node/AtomicHelperFault", {
+    readonly code: Schema.Literals<readonly ["response_unframed", "response_tag_unknown", "response_length_invalid", "response_length_mismatch", "envelope_malformed", "field_malformed", "file_type_unknown", "payload_malformed", "read_limit_exceeded", "entries_malformed", "batch_malformed", "digest_malformed", "result_malformed", "operation_unsupported", "helper_timeout", "response_limit_exceeded", "helper_rejected", "helper_exited"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The helper's response or process broke the protocol. The helper is treated as
+ * untrusted, so the operation fails closed.
+ * @category errors
+ * @since 1.0.0
+ */
+export declare class AtomicHelperFault extends AtomicHelperFault_base {
+    readonly name = "AtomicHelperFault";
+}
+/**
+ * A helper fault with a stable code.
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const atomicHelperFault: (code: AtomicHelperFaultCode, message: string) => AtomicHelperFault;
+declare const AtomicHelperRejection_base: Schema.Class<AtomicHelperRejection, Schema.TaggedStruct<"@smthrs/platform-node/AtomicHelperRejection", {
+    readonly code: Schema.String;
+    readonly syscall: Schema.optional<Schema.String>;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The errno a helper reported for a syscall it ran, in the shape the native
+ * Node adapter's errors carry so callers that read `code` and `syscall` see the
+ * same contract.
+ * @category errors
+ * @since 1.0.0
+ */
+export declare class AtomicHelperRejection extends AtomicHelperRejection_base {
+    readonly name = "AtomicHelperRejection";
+}
+export {};
+//# sourceMappingURL=AtomicHelperFault.d.ts.map

package/dist/cjs/internal/AtomicHelperFault.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AtomicHelperFault.d.ts","sourceRoot":"","sources":["../../../src/internal/AtomicHelperFault.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,oaAmBhC,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAC,IAAI,CAAA;;;;;AAErE;;;;;GAKG;AACH,qBAAa,iBAAkB,SAAQ,sBAGtC;IACC,SAAkB,IAAI,uBAAsB;CAC7C;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,qBAAqB,EAAE,SAAS,MAAM,KAAG,iBACvC,CAAA;;;;;;;AAE1C;;;;;;GAMG;AACH,qBAAa,qBAAsB,SAAQ,0BAQ1C;IACC,SAAkB,IAAI,2BAA0B;CACjD"}

package/dist/cjs/internal/AtomicHelperFault.js

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AtomicHelperFault_exports = {};
+__export(AtomicHelperFault_exports, {
+  AtomicHelperFault: () => AtomicHelperFault,
+  AtomicHelperFaultCode: () => AtomicHelperFaultCode,
+  AtomicHelperRejection: () => AtomicHelperRejection,
+  atomicHelperFault: () => atomicHelperFault
+});
+module.exports = __toCommonJS(AtomicHelperFault_exports);
+var import_effect = require("effect");
+const AtomicHelperFaultCode = import_effect.Schema.Literals([
+  "response_unframed",
+  "response_tag_unknown",
+  "response_length_invalid",
+  "response_length_mismatch",
+  "envelope_malformed",
+  "field_malformed",
+  "file_type_unknown",
+  "payload_malformed",
+  "read_limit_exceeded",
+  "entries_malformed",
+  "batch_malformed",
+  "digest_malformed",
+  "result_malformed",
+  "operation_unsupported",
+  "helper_timeout",
+  "response_limit_exceeded",
+  "helper_rejected",
+  "helper_exited"
+]);
+class AtomicHelperFault extends import_effect.Schema.TaggedError()(
+  "@smthrs/platform-node/AtomicHelperFault",
+  { code: AtomicHelperFaultCode, message: import_effect.Schema.String }
+) {
+  name = "AtomicHelperFault";
+}
+const atomicHelperFault = (code, message) => new AtomicHelperFault({ code, message });
+class AtomicHelperRejection extends import_effect.Schema.TaggedError()(
+  "@smthrs/platform-node/AtomicHelperRejection",
+  {
+    code: import_effect.Schema.String,
+    syscall: import_effect.Schema.optional(import_effect.Schema.String),
+    message: import_effect.Schema.String,
+    cause: import_effect.Schema.optional(import_effect.Schema.Unknown)
+  }
+) {
+  name = "AtomicHelperRejection";
+}
+//# sourceMappingURL=AtomicHelperFault.js.map

package/dist/cjs/internal/AtomicHelperFault.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/AtomicHelperFault.ts"],
+  "sourcesContent": ["/**\n * The atomic helper broke its protocol or its transport failed: a response that\n * is not framed, a field of the wrong shape, an answer over a bound, a helper\n * that never answered, or one that exited. `AtomicFileSystemProtocol.failure`\n * reports one as the `cause` of a `PlatformError`, so a caller classifies it by\n * `_tag` and `code`. {@link AtomicHelperRejection} carries the errno a helper\n * itself reported.\n * @since 1.0.0\n */\n\nimport { Schema } from \"effect\"\n\n/**\n * Which rule of the helper protocol or transport was broken.\n * @category models\n * @since 1.0.0\n */\nexport const AtomicHelperFaultCode = Schema.Literals([\n  \"response_unframed\",\n  \"response_tag_unknown\",\n  \"response_length_invalid\",\n  \"response_length_mismatch\",\n  \"envelope_malformed\",\n  \"field_malformed\",\n  \"file_type_unknown\",\n  \"payload_malformed\",\n  \"read_limit_exceeded\",\n  \"entries_malformed\",\n  \"batch_malformed\",\n  \"digest_malformed\",\n  \"result_malformed\",\n  \"operation_unsupported\",\n  \"helper_timeout\",\n  \"response_limit_exceeded\",\n  \"helper_rejected\",\n  \"helper_exited\"\n])\n\n/**\n * The stable code of an {@link AtomicHelperFault}.\n * @category models\n * @since 1.0.0\n */\nexport type AtomicHelperFaultCode = typeof AtomicHelperFaultCode.Type\n\n/**\n * The helper's response or process broke the protocol. The helper is treated as\n * untrusted, so the operation fails closed.\n * @category errors\n * @since 1.0.0\n */\nexport class AtomicHelperFault extends Schema.TaggedError<AtomicHelperFault>()(\n  \"@smthrs/platform-node/AtomicHelperFault\",\n  { code: AtomicHelperFaultCode, message: Schema.String }\n) {\n  override readonly name = \"AtomicHelperFault\"\n}\n\n/**\n * A helper fault with a stable code.\n * @category constructors\n * @since 1.0.0\n */\nexport const atomicHelperFault = (code: AtomicHelperFaultCode, message: string): AtomicHelperFault =>\n  new AtomicHelperFault({ code, message })\n\n/**\n * The errno a helper reported for a syscall it ran, in the shape the native\n * Node adapter's errors carry so callers that read `code` and `syscall` see the\n * same contract.\n * @category errors\n * @since 1.0.0\n */\nexport class AtomicHelperRejection extends Schema.TaggedError<AtomicHelperRejection>()(\n  \"@smthrs/platform-node/AtomicHelperRejection\",\n  {\n    code: Schema.String,\n    syscall: Schema.optional(Schema.String),\n    message: Schema.String,\n    cause: Schema.optional(Schema.Unknown)\n  }\n) {\n  override readonly name = \"AtomicHelperRejection\"\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,oBAAuB;AAOhB,MAAM,wBAAwB,qBAAO,SAAS;AAAA,EACnD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAeM,MAAM,0BAA0B,qBAAO,YAA+B;AAAA,EAC3E;AAAA,EACA,EAAE,MAAM,uBAAuB,SAAS,qBAAO,OAAO;AACxD,EAAE;AAAA,EACkB,OAAO;AAC3B;AAOO,MAAM,oBAAoB,CAAC,MAA6B,YAC7D,IAAI,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AASlC,MAAM,8BAA8B,qBAAO,YAAmC;AAAA,EACnF;AAAA,EACA;AAAA,IACE,MAAM,qBAAO;AAAA,IACb,SAAS,qBAAO,SAAS,qBAAO,MAAM;AAAA,IACtC,SAAS,qBAAO;AAAA,IAChB,OAAO,qBAAO,SAAS,qBAAO,OAAO;AAAA,EACvC;AACF,EAAE;AAAA,EACkB,OAAO;AAC3B;",
+  "names": []
+}

package/dist/cjs/internal/PipedProcess.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Native I/O ownership for transient commands and prepared process owners.
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as PlatformError from "effect/PlatformError";
+import type * as Scope from "effect/Scope";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import { type ChildProcessHandle } from "effect/unstable/process/ChildProcessSpawner";
+/**
+ * Windows owners receive caller streams above the reserved CRT standard slots.
+ * @private
+ * @since 1.0.0
+ */
+export declare const standardFdsOf: (handle: ChildProcessHandle) => ReadonlyArray<number | "ignore"> | undefined;
+/**
+ * Converts native errors without losing their errno or signal.
+ * @private
+ * @since 1.0.0
+ */
+export declare const failure: (method: string, cause: unknown) => PlatformError.PlatformError;
+/**
+ * Native standard-command I/O, including configured streams and custom pipes.
+ * Lifetime error listeners remain on every owned pipe after any consumer is
+ * interrupted, so a pending native write cannot raise an unhandled late EPIPE.
+ * Consumers still receive the original error through NodeStream/NodeSink.
+ * This adapter also preserves native Windows verbatim arguments.
+ *
+ * It never sends a negative-pid signal. POSIX tree cleanup belongs to the
+ * prepared supervisor, which remains alive while it signals its own group.
+ * @private
+ * @since 1.0.0
+ */
+export declare const spawn: (command: ChildProcess.StandardCommand, windowsVerbatimArguments: boolean | undefined, owner?: boolean) => Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, Scope.Scope>;
+//# sourceMappingURL=PipedProcess.d.ts.map

package/dist/cjs/internal/PipedProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PipedProcess.d.ts","sourceRoot":"","sources":["../../../src/internal/PipedProcess.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,aAAa,MAAM,sBAAsB,CAAA;AACrD,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAG1C,OAAO,KAAK,YAAY,MAAM,sCAAsC,CAAA;AACpE,OAAO,EAAE,KAAK,kBAAkB,EAAmC,MAAM,6CAA6C,CAAA;AAMtH;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,kBAAkB,KAAG,aAAa,CAAC,MAAM,GAAG,QAAQ,CAAC,GAAG,SAChE,CAAA;AAa9B;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAAI,QAAQ,MAAM,EAAE,OAAO,OAAO,KAAG,aAAa,CAAC,aAUtE,CAAA;AAyCD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,KAAK,GAChB,SAAS,YAAY,CAAC,eAAe,EACrC,0BAA0B,OAAO,GAAG,SAAS,EAC7C,eAAa,KACZ,MAAM,CAAC,MAAM,CAAC,kBAAkB,EAAE,aAAa,CAAC,aAAa,EAAE,KAAK,CAAC,KAAK,CAsPzE,CAAA"}