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

package/dist/cjs/ChildProcessSpawner.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Permission-aware process spawning.
+ *
+ * Smithers has no shell service of its own — process execution is Effect's
+ * `effect/unstable/process`. The only thing the kernel adds is the
+ * `proc:spawn` capability check and the host confinement wrapper, applied to
+ * the one primitive every other helper is derived from.
+ *
+ * There is no kernel spawner interface and no kernel spawner tag. Effect owns
+ * both, and its tag fixes the error channel to `PlatformError`, so this module
+ * is only the middleware: a `Layer` over Effect's own tag. A denied command is
+ * projected into `PlatformError` by `Permission.toPlatformError`, which keeps
+ * the structured kernel failure on the error's `cause`. Because the channel
+ * stays `PlatformError`, the full six-method surface is derived from the one
+ * guarded `spawn` through Effect's own `ChildProcessSpawner.make` without a
+ * cast.
+ *
+ * Governing design:
+ * `docs/specs/Concepts/Permission Kernel.md` and
+ * `docs/specs/Concepts/Host Adapters.md`.
+ *
+ * @since 1.0.0-rc.0
+ */
+import { Layer, Path } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { GrantStore } from "./GrantStore.ts";
+import { Workspace } from "./Workspace.ts";
+/**
+ * Effect's own process spawner tag, unchanged. Re-exported so the kernel
+ * namespace stays one-stop; it is the *same* tag, never a second one.
+ *
+ * @category services
+ * @since 1.0.0-rc.0
+ */
+export { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+/**
+ * Derives the full six-method surface from one `spawn`, so `exitCode`,
+ * `string`, `lines`, and both `stream*` helpers can never bypass whatever
+ * `spawn` was given.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export { make } from "effect/unstable/process/ChildProcessSpawner";
+/**
+ * Constructs an unavailable spawner stub.
+ *
+ * Every derived helper reports the missing host as a `NotFound`
+ * `PlatformError` naming the command line, so an unconfigured capability
+ * answers rather than vanishing.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const makeNoop: (overrides?: Partial<ChildProcessSpawner["Service"]>) => ChildProcessSpawner["Service"];
+/**
+ * Provides an unavailable spawner stub.
+ *
+ * @category layers
+ * @since 1.0.0-rc.0
+ */
+export declare const layerNoop: (overrides?: Partial<ChildProcessSpawner["Service"]>) => Layer.Layer<ChildProcessSpawner>;
+/**
+ * Decorates the process spawner in place with a `proc:spawn` capability check.
+ *
+ * The check is suspended into the spawn itself, so building a `Command` or a
+ * stream neither requests permission nor starts a process; only running one
+ * does. Every pipeline stage is checked as its own capability, left to right,
+ * and no stage starts until all pass. A stage's resource is
+ * `CommandLine.resource`: the command line `CommandLine.render` produces, with
+ * a `shell: true` line that holds shell control syntax marked as
+ * `sh -c '<line>'`, any environment variable the child would not inherit from
+ * this process named in an `env <NAME>… -- ` prefix, and a working directory
+ * outside `Workspace.root` named in a `cwd <path> -- ` prefix. Custom shell
+ * paths are included explicitly in the resource; browser and remote adapters
+ * reject them rather than silently substituting a different shell.
+ *
+ * Every approved stage requires `ProcessConfinement` in the host context.
+ * A missing service refuses spawning; its `layerNoop` is the explicit choice
+ * for an unconfined host.
+ *
+ * Pipeline `from`/`to` routing remains outside the grant. The working
+ * directory and overridden environment names also reach attended surfaces as
+ * display metadata; environment values never leave the command.
+ *
+ * The layer provides the tag it also requires: compose it over a host spawner
+ * layer with `Layer.provide` and a `ChildProcess.Command` run as a plain
+ * `Effect` is checked too.
+ *
+ * A command with no `cwd`, or a relative one, runs in `Workspace.root`, never
+ * the process's own directory; the check sees that resolved directory. When
+ * the host filesystem is in the layer's context, the working directory and
+ * `Workspace.root` are compared by real path, so a symlink inside the
+ * workspace that leads out of it is named, as its target, in the `cwd` prefix.
+ *
+ * @category layers
+ * @since 1.0.0-rc.0
+ */
+export declare const layer: Layer.Layer<ChildProcessSpawner, never, ChildProcessSpawner | GrantStore | Path.Path | Workspace>;
+//# sourceMappingURL=ChildProcessSpawner.d.ts.map

package/dist/cjs/ChildProcessSpawner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChildProcessSpawner.d.ts","sourceRoot":"","sources":["../../src/ChildProcessSpawner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAsB,KAAK,EAAU,IAAI,EAAc,MAAM,QAAQ,CAAA;AAG5E,OAAO,EAAE,mBAAmB,EAAuB,MAAM,6CAA6C,CAAA;AAEtG,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAK5C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAgK1C;;;;;;GAMG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAA;AAEjF;;;;;;;GAOG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,6CAA6C,CAAA;AAElE;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GACnB,YAAW,OAAO,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAM,KACtD,mBAAmB,CAAC,SAAS,CAY9B,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GACpB,YAAW,OAAO,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAM,KACtD,KAAK,CAAC,KAAK,CAAC,mBAAmB,CAA4D,CAAA;AAE9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAC7B,mBAAmB,EACnB,KAAK,EACL,mBAAmB,GAAG,UAAU,GAAG,IAAI,CAAC,IAAI,GAAG,SAAS,CA4HzD,CAAA"}

package/dist/cjs/ChildProcessSpawner.js

@@ -0,0 +1,291 @@
+"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 __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 ChildProcessSpawner_exports = {};
+__export(ChildProcessSpawner_exports, {
+  ChildProcessSpawner: () => import_ChildProcessSpawner2.ChildProcessSpawner,
+  layer: () => layer,
+  layerNoop: () => layerNoop,
+  make: () => import_ChildProcessSpawner3.make,
+  makeNoop: () => makeNoop
+});
+module.exports = __toCommonJS(ChildProcessSpawner_exports);
+var import_Permission = require("@smthrs/capability/Permission");
+var import_effect = require("effect");
+var import_PlatformError = require("effect/PlatformError");
+var ChildProcess = __toESM(require("effect/unstable/process/ChildProcess"), 1);
+var import_ChildProcessSpawner = require("effect/unstable/process/ChildProcessSpawner");
+var CommandLine = __toESM(require("./CommandLine.js"), 1);
+var import_GrantStore = require("./GrantStore.js");
+var Containment = __toESM(require("./internal/Containment.js"), 1);
+var import_makeCapability = require("./internal/makeCapability.js");
+var ProcessConfinement = __toESM(require("./ProcessConfinement.js"), 1);
+var Rooted = __toESM(require("./Rooted.js"), 1);
+var import_Workspace = require("./Workspace.js");
+var import_ChildProcessSpawner2 = require("effect/unstable/process/ChildProcessSpawner");
+var import_ChildProcessSpawner3 = require("effect/unstable/process/ChildProcessSpawner");
+const data = (value, name) => {
+  const descriptor = Object.getOwnPropertyDescriptor(value, name);
+  if (descriptor === void 0 || !("value" in descriptor)) {
+    throw new TypeError(`command ${String(name)} must be a data property`);
+  }
+  return descriptor.value;
+};
+const optionalData = (value, name) => {
+  const descriptor = Object.getOwnPropertyDescriptor(value, name);
+  if (descriptor === void 0) return void 0;
+  if (!("value" in descriptor)) throw new TypeError(`command ${String(name)} must be a data property`);
+  return descriptor.value;
+};
+const snapshotRecord = (value) => {
+  if (value === void 0) return void 0;
+  const snapshot = /* @__PURE__ */ Object.create(null);
+  for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (!descriptor.enumerable) continue;
+    if (!("value" in descriptor) || descriptor.value !== void 0 && typeof descriptor.value !== "string") {
+      throw new TypeError("command environment must contain string data properties");
+    }
+    snapshot[name] = descriptor.value;
+  }
+  return Object.freeze(snapshot);
+};
+const snapshotStreamConfig = (value) => {
+  if (typeof value !== "object" || value === null) return value;
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  if (descriptors.stream === void 0) return value;
+  if (!("value" in descriptors.stream)) throw new TypeError("command stream must be a data property");
+  const snapshot = { stream: descriptors.stream.value };
+  for (const name of ["endOnDone", "encoding"]) {
+    const descriptor = descriptors[name];
+    if (descriptor !== void 0) {
+      if (!("value" in descriptor)) throw new TypeError(`command ${name} must be a data property`);
+      snapshot[name] = descriptor.value;
+    }
+  }
+  return Object.freeze(snapshot);
+};
+const snapshotAdditionalFds = (value) => {
+  if (value === void 0) return void 0;
+  const snapshot = {};
+  for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (!descriptor.enumerable) continue;
+    if (!("value" in descriptor) || typeof descriptor.value !== "object" || descriptor.value === null) {
+      throw new TypeError("additional file descriptors must be data records");
+    }
+    const config = descriptor.value;
+    const type = data(config, "type");
+    if (type === "input") {
+      const stream = Object.getOwnPropertyDescriptor(config, "stream");
+      snapshot[name] = Object.freeze({
+        type,
+        ...stream === void 0 ? {} : "value" in stream ? { stream: stream.value } : (() => {
+          throw new TypeError("additional fd stream must be a data property");
+        })()
+      });
+    } else if (type === "output") {
+      const sink = Object.getOwnPropertyDescriptor(config, "sink");
+      snapshot[name] = Object.freeze({
+        type,
+        ...sink === void 0 ? {} : "value" in sink ? { sink: sink.value } : (() => {
+          throw new TypeError("additional fd sink must be a data property");
+        })()
+      });
+    } else {
+      throw new TypeError("additional file descriptor type is invalid");
+    }
+  }
+  return Object.freeze(snapshot);
+};
+const snapshotOptions = (options) => Object.freeze({
+  killSignal: options.killSignal,
+  forceKillAfter: options.forceKillAfter,
+  cwd: options.cwd,
+  env: snapshotRecord(options.env),
+  extendEnv: options.extendEnv,
+  shell: options.shell,
+  detached: options.detached,
+  windowsHide: options.windowsHide,
+  stdin: snapshotStreamConfig(options.stdin),
+  stdout: snapshotStreamConfig(options.stdout),
+  stderr: snapshotStreamConfig(options.stderr),
+  additionalFds: snapshotAdditionalFds(options.additionalFds)
+});
+const snapshotCommand = (command) => {
+  const tag = data(command, "_tag");
+  if (tag === "StandardCommand") {
+    const executable = data(command, "command");
+    const args = data(command, "args");
+    const options = data(command, "options");
+    if (typeof executable !== "string" || !Array.isArray(args) || !args.every((arg) => typeof arg === "string")) {
+      throw new TypeError("standard command executable and arguments are invalid");
+    }
+    if (typeof options !== "object" || options === null) throw new TypeError("command options are invalid");
+    return ChildProcess.make(
+      executable,
+      Object.freeze([...args]),
+      snapshotOptions(options)
+    );
+  }
+  if (tag === "PipedCommand") {
+    const left = data(command, "left");
+    const right = data(command, "right");
+    const options = data(command, "options");
+    if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) {
+      throw new TypeError("pipeline commands are invalid");
+    }
+    if (typeof options !== "object" || options === null) throw new TypeError("pipeline options are invalid");
+    const from = optionalData(options, "from");
+    const to = optionalData(options, "to");
+    return ChildProcess.pipeTo(
+      snapshotCommand(right),
+      Object.freeze({
+        ...from === void 0 ? {} : { from },
+        ...to === void 0 ? {} : { to }
+      })
+    )(snapshotCommand(left));
+  }
+  throw new TypeError("unsupported command shape");
+};
+const maximumEnvironmentNames = 64;
+const ambientEnvironment = () => globalThis.process?.env ?? {};
+const environmentNames = (command) => {
+  const environment = command.options.env;
+  if (environment === void 0) return void 0;
+  const names = Object.entries(environment).filter(([, value]) => value !== void 0).map(([name]) => name).sort();
+  if (names.length === 0) return void 0;
+  return names.length <= maximumEnvironmentNames ? names : [...names.slice(0, maximumEnvironmentNames), `+${names.length - maximumEnvironmentNames} more`];
+};
+const makeNoop = (overrides = {}) => ({
+  ...(0, import_ChildProcessSpawner.make)(
+    (command) => import_effect.Effect.fail(
+      (0, import_PlatformError.systemError)({
+        _tag: "NotFound",
+        module: "ChildProcessSpawner",
+        method: "spawn",
+        description: `no process host for \`${CommandLine.render(command)}\``
+      })
+    )
+  ),
+  ...overrides
+});
+const layerNoop = (overrides = {}) => import_effect.Layer.succeed(import_ChildProcessSpawner.ChildProcessSpawner)(makeNoop(overrides));
+const layer = import_effect.Layer.effect(
+  import_ChildProcessSpawner.ChildProcessSpawner,
+  import_effect.Effect.gen(function* () {
+    const spawner = yield* import_ChildProcessSpawner.ChildProcessSpawner;
+    const grants = yield* import_GrantStore.GrantStore;
+    const confinement = yield* import_effect.Effect.serviceOption(ProcessConfinement.ProcessConfinement);
+    const path = yield* import_effect.Path.Path;
+    const rooted = Rooted.path(path, path.resolve((yield* import_Workspace.Workspace).root));
+    const root = rooted.resolve(".");
+    const fileSystem = yield* import_effect.Effect.serviceOption(import_effect.FileSystem.FileSystem);
+    const real = (directory) => import_effect.Option.match(fileSystem, {
+      onNone: () => import_effect.Effect.succeed(directory),
+      onSome: (fs) => fs.realPath(directory).pipe(import_effect.Effect.orElseSucceed(() => directory))
+    });
+    const within = (base) => (directory) => {
+      const relative = path.relative(base, directory);
+      return relative.split(path.sep)[0] !== ".." && !path.isAbsolute(relative);
+    };
+    const checkStage = (stage) => import_effect.Effect.gen(function* () {
+      const cwd = stage.options.cwd;
+      const realRoot = yield* real(root);
+      const resolvedCwd = yield* real(cwd);
+      const contains = resolvedCwd === cwd ? (directory) => within(root)(directory) || within(realRoot)(directory) : within(realRoot);
+      return yield* checkResolved(
+        stage,
+        CommandLine.resource(stage, {
+          ambient: ambientEnvironment(),
+          contains,
+          resolvedCwd
+        })
+      );
+    });
+    const checkResolved = (stage, rendered) => {
+      const environment = environmentNames(stage);
+      return (0, import_makeCapability.makeCapability)("proc:spawn", rendered).pipe(
+        import_effect.Effect.flatMap(
+          (capability) => grants.check(capability, {
+            cwd: stage.options.cwd,
+            ...environment === void 0 ? {} : { env: environment }
+          })
+        ),
+        import_effect.Effect.mapError(
+          (error) => (0, import_Permission.toPlatformError)({
+            module: "ChildProcessSpawner",
+            method: "spawn",
+            pathOrDescriptor: rendered,
+            error
+          })
+        )
+      );
+    };
+    const check = (command) => import_effect.Effect.forEach(CommandLine.stages(command), checkStage, { discard: true });
+    const confine = (command) => import_effect.Option.match(confinement, {
+      onNone: () => import_effect.Effect.fail((0, import_PlatformError.systemError)({
+        _tag: "NotFound",
+        module: "ProcessConfinement",
+        method: "confine",
+        description: "process confinement is required; use ProcessConfinement.layerNoop to explicitly run unconfined"
+      })),
+      onSome: (service) => import_effect.Effect.gen(function* () {
+        const profile = yield* ProcessConfinement.profile(grants, root, path).pipe(
+          import_effect.Effect.mapError((error) => (0, import_Permission.toPlatformError)({ module: "ChildProcessSpawner", method: "spawn", error }))
+        );
+        const wrap = (command2) => command2._tag === "StandardCommand" ? service.confine(command2, profile) : import_effect.Effect.gen(function* () {
+          const left = yield* wrap(command2.left);
+          const right = yield* wrap(command2.right);
+          return ChildProcess.pipeTo(right, command2.options)(left);
+        });
+        return yield* wrap(command);
+      })
+    });
+    return Containment.inherit(
+      spawner,
+      (0, import_ChildProcessSpawner.make)(
+        import_effect.Effect.fn("ChildProcessSpawner.spawn")(
+          (command) => import_effect.Effect.try({
+            try: () => snapshotCommand(command),
+            catch: () => (0, import_PlatformError.systemError)({
+              _tag: "InvalidData",
+              module: "ChildProcessSpawner",
+              method: "spawn",
+              description: "command must be an immutable supported process description"
+            })
+          }).pipe(
+            import_effect.Effect.map((snapshot) => Rooted.command(snapshot, rooted)),
+            import_effect.Effect.flatMap(
+              (rooted2) => check(rooted2).pipe(import_effect.Effect.andThen(confine(rooted2)), import_effect.Effect.flatMap(spawner.spawn))
+            )
+          )
+        )
+      )
+    );
+  })
+);
+//# sourceMappingURL=ChildProcessSpawner.js.map

package/dist/cjs/ChildProcessSpawner.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ChildProcessSpawner.ts"],
+  "sourcesContent": ["/**\n * Permission-aware process spawning.\n *\n * Smithers has no shell service of its own \u2014 process execution is Effect's\n * `effect/unstable/process`. The only thing the kernel adds is the\n * `proc:spawn` capability check and the host confinement wrapper, applied to\n * the one primitive every other helper is derived from.\n *\n * There is no kernel spawner interface and no kernel spawner tag. Effect owns\n * both, and its tag fixes the error channel to `PlatformError`, so this module\n * is only the middleware: a `Layer` over Effect's own tag. A denied command is\n * projected into `PlatformError` by `Permission.toPlatformError`, which keeps\n * the structured kernel failure on the error's `cause`. Because the channel\n * stays `PlatformError`, the full six-method surface is derived from the one\n * guarded `spawn` through Effect's own `ChildProcessSpawner.make` without a\n * cast.\n *\n * Governing design:\n * `docs/specs/Concepts/Permission Kernel.md` and\n * `docs/specs/Concepts/Host Adapters.md`.\n *\n * @since 1.0.0-rc.0\n */\n\nimport { toPlatformError } from \"@smthrs/capability/Permission\"\nimport { Effect, FileSystem, Layer, Option, Path, type Scope } from \"effect\"\nimport { type PlatformError, systemError } from \"effect/PlatformError\"\nimport * as ChildProcess from \"effect/unstable/process/ChildProcess\"\nimport { ChildProcessSpawner, make as makeSpawner } from \"effect/unstable/process/ChildProcessSpawner\"\nimport * as CommandLine from \"./CommandLine.ts\"\nimport { GrantStore } from \"./GrantStore.ts\"\nimport * as Containment from \"./internal/Containment.ts\"\nimport { makeCapability } from \"./internal/makeCapability.ts\"\nimport * as ProcessConfinement from \"./ProcessConfinement.ts\"\nimport * as Rooted from \"./Rooted.ts\"\nimport { Workspace } from \"./Workspace.ts\"\n\nconst data = (value: object, name: PropertyKey): unknown => {\n  const descriptor = Object.getOwnPropertyDescriptor(value, name)\n  if (descriptor === undefined || !(\"value\" in descriptor)) {\n    throw new TypeError(`command ${String(name)} must be a data property`)\n  }\n  return descriptor.value\n}\n\nconst optionalData = (value: object, name: PropertyKey): unknown => {\n  const descriptor = Object.getOwnPropertyDescriptor(value, name)\n  if (descriptor === undefined) return undefined\n  if (!(\"value\" in descriptor)) throw new TypeError(`command ${String(name)} must be a data property`)\n  return descriptor.value\n}\n\nconst snapshotRecord = (\n  value: Readonly<Record<string, string | undefined>> | undefined\n): Record<string, string | undefined> | undefined => {\n  if (value === undefined) return undefined\n  const snapshot: Record<string, string | undefined> = Object.create(null)\n  for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {\n    if (!descriptor.enumerable) continue\n    if (!(\"value\" in descriptor) || (descriptor.value !== undefined && typeof descriptor.value !== \"string\")) {\n      throw new TypeError(\"command environment must contain string data properties\")\n    }\n    snapshot[name] = descriptor.value\n  }\n  return Object.freeze(snapshot)\n}\n\nconst snapshotStreamConfig = <A>(value: A): A => {\n  if (typeof value !== \"object\" || value === null) return value\n  const descriptors = Object.getOwnPropertyDescriptors(value)\n  if (descriptors.stream === undefined) return value\n  if (!(\"value\" in descriptors.stream)) throw new TypeError(\"command stream must be a data property\")\n  const snapshot: Record<string, unknown> = { stream: descriptors.stream.value }\n  for (const name of [\"endOnDone\", \"encoding\"] as const) {\n    const descriptor = descriptors[name]\n    if (descriptor !== undefined) {\n      if (!(\"value\" in descriptor)) throw new TypeError(`command ${name} must be a data property`)\n      snapshot[name] = descriptor.value\n    }\n  }\n  return Object.freeze(snapshot) as A\n}\n\nconst snapshotAdditionalFds = (\n  value: ChildProcess.CommandOptions[\"additionalFds\"]\n): ChildProcess.CommandOptions[\"additionalFds\"] => {\n  if (value === undefined) return undefined\n  const snapshot: Record<`fd${number}`, ChildProcess.AdditionalFdConfig> = {}\n  for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {\n    if (!descriptor.enumerable) continue\n    if (!(\"value\" in descriptor) || typeof descriptor.value !== \"object\" || descriptor.value === null) {\n      throw new TypeError(\"additional file descriptors must be data records\")\n    }\n    const config = descriptor.value as ChildProcess.AdditionalFdConfig\n    const type = data(config, \"type\")\n    if (type === \"input\") {\n      const stream = Object.getOwnPropertyDescriptor(config, \"stream\")\n      snapshot[name as `fd${number}`] = Object.freeze({\n        type,\n        ...(stream === undefined ? {} : \"value\" in stream ? { stream: stream.value } : (() => {\n          throw new TypeError(\"additional fd stream must be a data property\")\n        })())\n      })\n    } else if (type === \"output\") {\n      const sink = Object.getOwnPropertyDescriptor(config, \"sink\")\n      snapshot[name as `fd${number}`] = Object.freeze({\n        type,\n        ...(sink === undefined ? {} : \"value\" in sink ? { sink: sink.value } : (() => {\n          throw new TypeError(\"additional fd sink must be a data property\")\n        })())\n      })\n    } else {\n      throw new TypeError(\"additional file descriptor type is invalid\")\n    }\n  }\n  return Object.freeze(snapshot)\n}\n\nconst snapshotOptions = (options: ChildProcess.CommandOptions): ChildProcess.CommandOptions =>\n  Object.freeze({\n    killSignal: options.killSignal,\n    forceKillAfter: options.forceKillAfter,\n    cwd: options.cwd,\n    env: snapshotRecord(options.env),\n    extendEnv: options.extendEnv,\n    shell: options.shell,\n    detached: options.detached,\n    windowsHide: options.windowsHide,\n    stdin: snapshotStreamConfig(options.stdin),\n    stdout: snapshotStreamConfig(options.stdout),\n    stderr: snapshotStreamConfig(options.stderr),\n    additionalFds: snapshotAdditionalFds(options.additionalFds)\n  })\n\nconst snapshotCommand = (command: ChildProcess.Command): ChildProcess.Command => {\n  const tag = data(command, \"_tag\")\n  if (tag === \"StandardCommand\") {\n    const executable = data(command, \"command\")\n    const args = data(command, \"args\")\n    const options = data(command, \"options\")\n    if (typeof executable !== \"string\" || !Array.isArray(args) || !args.every((arg) => typeof arg === \"string\")) {\n      throw new TypeError(\"standard command executable and arguments are invalid\")\n    }\n    if (typeof options !== \"object\" || options === null) throw new TypeError(\"command options are invalid\")\n    return ChildProcess.make(\n      executable,\n      Object.freeze([...args]),\n      snapshotOptions(options)\n    )\n  }\n  if (tag === \"PipedCommand\") {\n    const left = data(command, \"left\")\n    const right = data(command, \"right\")\n    const options = data(command, \"options\")\n    if (typeof left !== \"object\" || left === null || typeof right !== \"object\" || right === null) {\n      throw new TypeError(\"pipeline commands are invalid\")\n    }\n    if (typeof options !== \"object\" || options === null) throw new TypeError(\"pipeline options are invalid\")\n    const from = optionalData(options, \"from\")\n    const to = optionalData(options, \"to\")\n    return ChildProcess.pipeTo(\n      snapshotCommand(right as ChildProcess.Command),\n      Object.freeze({\n        ...(from === undefined ? {} : { from: from as ChildProcess.PipeFromOption }),\n        ...(to === undefined ? {} : { to: to as ChildProcess.PipeToOption })\n      })\n    )(snapshotCommand(left as ChildProcess.Command))\n  }\n  throw new TypeError(\"unsupported command shape\")\n}\n\nconst maximumEnvironmentNames = 64\n\n/**\n * The environment this process holds, which a child built with\n * `ChildProcessEnvironment.make` inherits its bootstrap names from. Empty on a\n * host with no process environment, so every declared bootstrap name counts\n * as an override there.\n */\nconst ambientEnvironment = (): Readonly<Record<string, string | undefined>> =>\n  (globalThis as { readonly process?: { readonly env?: Record<string, string | undefined> } }).process?.env ?? {}\n\nconst environmentNames = (command: ChildProcess.StandardCommand): ReadonlyArray<string> | undefined => {\n  const environment = command.options.env\n  if (environment === undefined) return undefined\n  const names = Object.entries(environment)\n    .filter(([, value]) => value !== undefined)\n    .map(([name]) => name)\n    .sort()\n  if (names.length === 0) return undefined\n  return names.length <= maximumEnvironmentNames\n    ? names\n    : [...names.slice(0, maximumEnvironmentNames), `+${names.length - maximumEnvironmentNames} more`]\n}\n\n/**\n * Effect's own process spawner tag, unchanged. Re-exported so the kernel\n * namespace stays one-stop; it is the *same* tag, never a second one.\n *\n * @category services\n * @since 1.0.0-rc.0\n */\nexport { ChildProcessSpawner } from \"effect/unstable/process/ChildProcessSpawner\"\n\n/**\n * Derives the full six-method surface from one `spawn`, so `exitCode`,\n * `string`, `lines`, and both `stream*` helpers can never bypass whatever\n * `spawn` was given.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport { make } from \"effect/unstable/process/ChildProcessSpawner\"\n\n/**\n * Constructs an unavailable spawner stub.\n *\n * Every derived helper reports the missing host as a `NotFound`\n * `PlatformError` naming the command line, so an unconfigured capability\n * answers rather than vanishing.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const makeNoop = (\n  overrides: Partial<ChildProcessSpawner[\"Service\"]> = {}\n): ChildProcessSpawner[\"Service\"] => ({\n  ...makeSpawner((command) =>\n    Effect.fail(\n      systemError({\n        _tag: \"NotFound\",\n        module: \"ChildProcessSpawner\",\n        method: \"spawn\",\n        description: `no process host for \\`${CommandLine.render(command)}\\``\n      })\n    )\n  ),\n  ...overrides\n})\n\n/**\n * Provides an unavailable spawner stub.\n *\n * @category layers\n * @since 1.0.0-rc.0\n */\nexport const layerNoop = (\n  overrides: Partial<ChildProcessSpawner[\"Service\"]> = {}\n): Layer.Layer<ChildProcessSpawner> => Layer.succeed(ChildProcessSpawner)(makeNoop(overrides))\n\n/**\n * Decorates the process spawner in place with a `proc:spawn` capability check.\n *\n * The check is suspended into the spawn itself, so building a `Command` or a\n * stream neither requests permission nor starts a process; only running one\n * does. Every pipeline stage is checked as its own capability, left to right,\n * and no stage starts until all pass. A stage's resource is\n * `CommandLine.resource`: the command line `CommandLine.render` produces, with\n * a `shell: true` line that holds shell control syntax marked as\n * `sh -c '<line>'`, any environment variable the child would not inherit from\n * this process named in an `env <NAME>\u2026 -- ` prefix, and a working directory\n * outside `Workspace.root` named in a `cwd <path> -- ` prefix. Custom shell\n * paths are included explicitly in the resource; browser and remote adapters\n * reject them rather than silently substituting a different shell.\n *\n * Every approved stage requires `ProcessConfinement` in the host context.\n * A missing service refuses spawning; its `layerNoop` is the explicit choice\n * for an unconfined host.\n *\n * Pipeline `from`/`to` routing remains outside the grant. The working\n * directory and overridden environment names also reach attended surfaces as\n * display metadata; environment values never leave the command.\n *\n * The layer provides the tag it also requires: compose it over a host spawner\n * layer with `Layer.provide` and a `ChildProcess.Command` run as a plain\n * `Effect` is checked too.\n *\n * A command with no `cwd`, or a relative one, runs in `Workspace.root`, never\n * the process's own directory; the check sees that resolved directory. When\n * the host filesystem is in the layer's context, the working directory and\n * `Workspace.root` are compared by real path, so a symlink inside the\n * workspace that leads out of it is named, as its target, in the `cwd` prefix.\n *\n * @category layers\n * @since 1.0.0-rc.0\n */\nexport const layer: Layer.Layer<\n  ChildProcessSpawner,\n  never,\n  ChildProcessSpawner | GrantStore | Path.Path | Workspace\n> = Layer.effect(\n  ChildProcessSpawner,\n  Effect.gen(function*() {\n    const spawner = yield* ChildProcessSpawner\n    const grants = yield* GrantStore\n    const confinement = yield* Effect.serviceOption(ProcessConfinement.ProcessConfinement)\n    const path = yield* Path.Path\n    const rooted = Rooted.path(path, path.resolve((yield* Workspace).root))\n    const root = rooted.resolve(\".\")\n    // The raw host filesystem this layer is composed over, when there is one.\n    // A symlink inside the workspace can lead out of it, so containment is\n    // judged on real paths; a directory that cannot be resolved (it does not\n    // exist, or the host has no filesystem) is judged lexically.\n    const fileSystem = yield* Effect.serviceOption(FileSystem.FileSystem)\n    const real = (directory: string) =>\n      Option.match(fileSystem, {\n        onNone: () => Effect.succeed(directory),\n        onSome: (fs) => fs.realPath(directory).pipe(Effect.orElseSucceed(() => directory))\n      })\n    const within = (base: string) => (directory: string) => {\n      const relative = path.relative(base, directory)\n      return relative.split(path.sep)[0] !== \"..\" && !path.isAbsolute(relative)\n    }\n    const checkStage = (stage: ChildProcess.StandardCommand) =>\n      Effect.gen(function*() {\n        // Rooted.command gives every stage an absolute cwd.\n        const cwd = stage.options.cwd!\n        const realRoot = yield* real(root)\n        const resolvedCwd = yield* real(cwd)\n        const contains = resolvedCwd === cwd\n          ? (directory: string) => within(root)(directory) || within(realRoot)(directory)\n          : within(realRoot)\n        return yield* checkResolved(\n          stage,\n          CommandLine.resource(stage, {\n            ambient: ambientEnvironment(),\n            contains,\n            resolvedCwd\n          })\n        )\n      })\n    const checkResolved = (stage: ChildProcess.StandardCommand, rendered: string) => {\n      const environment = environmentNames(stage)\n      return makeCapability(\"proc:spawn\", rendered).pipe(\n        Effect.flatMap((capability) =>\n          grants.check(capability, {\n            cwd: stage.options.cwd,\n            ...(environment === undefined ? {} : { env: environment })\n          })\n        ),\n        Effect.mapError((error) =>\n          toPlatformError({\n            module: \"ChildProcessSpawner\",\n            method: \"spawn\",\n            pathOrDescriptor: rendered,\n            error\n          })\n        )\n      )\n    }\n    const check = (command: ChildProcess.Command) =>\n      Effect.forEach(CommandLine.stages(command), checkStage, { discard: true })\n    const confine = (\n      command: ChildProcess.Command\n    ): Effect.Effect<\n      ChildProcess.Command,\n      PlatformError,\n      Scope.Scope\n    > =>\n      Option.match(confinement, {\n        onNone: () =>\n          Effect.fail(systemError({\n            _tag: \"NotFound\",\n            module: \"ProcessConfinement\",\n            method: \"confine\",\n            description:\n              \"process confinement is required; use ProcessConfinement.layerNoop to explicitly run unconfined\"\n          })),\n        onSome: (service) =>\n          Effect.gen(function*() {\n            const profile = yield* ProcessConfinement.profile(grants, root, path).pipe(\n              Effect.mapError((error) => toPlatformError({ module: \"ChildProcessSpawner\", method: \"spawn\", error }))\n            )\n            const wrap = (\n              command: ChildProcess.Command\n            ): Effect.Effect<\n              ChildProcess.Command,\n              PlatformError,\n              Scope.Scope\n            > =>\n              command._tag === \"StandardCommand\"\n                ? service.confine(command, profile)\n                : Effect.gen(function*() {\n                  const left = yield* wrap(command.left)\n                  const right = yield* wrap(command.right)\n                  return ChildProcess.pipeTo(right, command.options)(left)\n                })\n            return yield* wrap(command)\n          })\n      })\n    return Containment.inherit(\n      spawner,\n      makeSpawner(\n        Effect.fn(\"ChildProcessSpawner.spawn\")((command: ChildProcess.Command) =>\n          Effect.try({\n            try: () => snapshotCommand(command),\n            catch: () =>\n              systemError({\n                _tag: \"InvalidData\",\n                module: \"ChildProcessSpawner\",\n                method: \"spawn\",\n                description: \"command must be an immutable supported process description\"\n              })\n          }).pipe(\n            Effect.map((snapshot) => Rooted.command(snapshot, rooted)),\n            Effect.flatMap((rooted) =>\n              check(rooted).pipe(Effect.andThen(confine(rooted)), Effect.flatMap(spawner.spawn))\n            )\n          )\n        )\n      )\n    )\n  })\n)\n"],
+  "mappings": "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",
+  "names": ["import_ChildProcessSpawner", "makeSpawner", "command", "rooted"]
+}

package/dist/cjs/CommandLine.d.ts

@@ -0,0 +1,173 @@
+/**
+ * @since 1.0.0-rc.0
+ *
+ * Rendering an `effect/unstable/process` `Command` back to a shell command
+ * line.
+ *
+ * Two callers need the same string and must agree on it exactly:
+ *
+ *  1. `@smthrs/kernel/ChildProcessSpawner` uses it as the `proc:spawn`
+ *     capability resource, so a grant reads the way an operator wrote it; and
+ *  2. `@smthrs/platform-browser/BrowserChildProcessSpawner` uses it as the line
+ *     it hands to the in-browser bash interpreter, which has no `argv` to spawn
+ *     with.
+ *
+ * A single renderer keeps a granted capability and the command a browser
+ * actually runs from drifting apart.
+ *
+ * The module is pure string handling — no host access — so it stays on the
+ * browser-safe side of the package.
+ */
+import type * as ChildProcess from "effect/unstable/process/ChildProcess";
+/**
+ * Quotes one token for a POSIX shell, leaving obviously safe tokens alone.
+ *
+ * @category rendering
+ * @since 1.0.0-rc.0
+ */
+export declare const quote: (token: string) => string;
+/**
+ * Renders a `Command` as a single shell command line.
+ *
+ * A standard command with `shell: true` renders its tokens verbatim, matching
+ * the line Node and the browser interpreter hand to the default shell. A
+ * custom shell renders as an explicit `<shell> -c <line>` invocation so the
+ * selected executable is part of the permission resource. Without `shell`,
+ * every token is POSIX-quoted to preserve literal argv semantics. These
+ * distinctions are security-sensitive: the rendered value is also the
+ * `proc:spawn` capability resource, so it must describe what will execute.
+ * The rendering is POSIX-only by contract: on Windows, Node invokes the shell
+ * with `/d /s /c` rather than `-c`, so the rendered line describes the POSIX
+ * invocation, not a cmd.exe one.
+ *
+ * The `proc:spawn` capability resource is {@link resource}, which starts from
+ * this line and adds what the line alone cannot show.
+ *
+ * A `PipedCommand` renders with `|` between its sides. That is a faithful
+ * rendering of what the pipeline does, and it is the only form an interpreter
+ * that takes a command line rather than an `argv` can be given. `from`/`to`
+ * pipe options are *not* expressible this way; rendering ignores them, so a
+ * pipeline that redirects `stderr` renders like one that pipes `stdout`.
+ * Capability checks therefore see the commands, never the plumbing.
+ *
+ * @category rendering
+ * @since 1.0.0-rc.0
+ */
+export declare const render: (command: ChildProcess.Command) => string;
+/**
+ * What {@link resource} compares a stage against, supplied by the spawner that
+ * checks it.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export interface ResourceContext {
+    /**
+     * The environment the spawning process itself holds. A bootstrap name
+     * (`PATH`, `HOME`, ...) whose declared value equals the ambient value is the
+     * inherited default and stays out of the resource; one set to anything else
+     * is named. Omitted, every declared bootstrap name is named.
+     */
+    readonly ambient?: Readonly<Record<string, string | undefined>> | undefined;
+    /**
+     * Whether a stage's working directory is inside the directory the flow
+     * already governs. A `cwd` it rejects is named in the resource. Omitted,
+     * every `cwd` a stage sets is named.
+     */
+    readonly contains?: ((directory: string) => boolean) | undefined;
+    /**
+     * The stage `cwd` with every symlink resolved, when the host could resolve
+     * it. It replaces the lexical `cwd` both for `contains` and in the
+     * `cwd <path> -- ` prefix, so a symlink inside the governed directory that
+     * leads out of it is judged, and shown, by where the command really runs.
+     */
+    readonly resolvedCwd?: string | undefined;
+}
+/**
+ * The stages of a command in execution order: the command itself, or every
+ * `StandardCommand` of a pipeline from left to right. The spawner checks each
+ * stage as its own `proc:spawn` capability.
+ *
+ * @category rendering
+ * @since 1.0.0-rc.1
+ */
+export declare const stages: (command: ChildProcess.Command) => ReadonlyArray<ChildProcess.StandardCommand>;
+/**
+ * The `proc:spawn` capability resource for one stage: {@link render}, with
+ * three additions that keep a prefix grant from authorizing code the stage
+ * never named.
+ *
+ *  - A `shell: true` stage whose line holds shell control syntax (`;`, `&`,
+ *    `|`, `` ` ``, `$`, `<`, `>`, `(`, `)`, or a line break) is marked as the
+ *    explicit `sh -c '<line>'` it is. A grant such as `git status *` then
+ *    cannot match `git status; curl x | sh`, while a simple shell line such as
+ *    `git status --short` keeps its verbatim resource. An fd duplication such
+ *    as `2>&1` and a discard to `/dev/null` do not count as control syntax.
+ *  - A stage that sets an environment variable the child would not otherwise
+ *    inherit is prefixed with `env <NAME>… -- `, sorted names only. That is
+ *    every name outside the bootstrap set `ChildProcessEnvironment` inherits
+ *    (`PATH`, `HOME`, `USER`, `LANG`, `TERM`, `TMPDIR`, `SHELL`, `LC_*`), and a
+ *    bootstrap name whose value differs from `context.ambient`. A grant for
+ *    `git status` covers neither `env GIT_SSH_COMMAND -- git status` nor
+ *    `env PATH -- git status`. Values never enter the resource because they
+ *    often carry credentials.
+ *  - A stage whose `cwd` `context.contains` rejects is prefixed with
+ *    `cwd <path> -- `, so a grant does not follow the command into a
+ *    directory whose configuration the flow does not govern. When
+ *    `context.resolvedCwd` is given, that real path is judged and named
+ *    instead of the lexical `cwd`.
+ *
+ * A pipeline has no single resource: the spawner checks every one of its
+ * {@link stages}, so `git status | sh` needs a grant for `sh` too.
+ *
+ * The `env` and `cwd` prefixes share their spelling with a literal command:
+ * `make("env", ["PATH", "--", "git", "status"])` renders as
+ * `env PATH -- git status`, the resource of `git status` with `PATH`
+ * overridden. The alias grants nothing extra. The literal command runs a
+ * program named `PATH` (or `cwd`) from the ambient `PATH`, not `git`. A grant
+ * with `*` inside the prefix, such as `env * -- git status`, also matches
+ * `env -C /x -- git status`, but it already admits any variable name,
+ * including `GIT_SSH_COMMAND` and `LD_PRELOAD`, which run arbitrary code.
+ * Grant a prefixed resource exactly as the request shows it.
+ *
+ * @category rendering
+ * @since 1.0.0-rc.1
+ */
+export declare const resource: (command: ChildProcess.StandardCommand, context?: ResourceContext) => string;
+/**
+ * The executable a command runs, without its arguments.
+ *
+ * A durable record of a spawned process names its program with this rather
+ * than with {@link render}: arguments carry credentials (`curl -u user:pass`,
+ * `mysql -phunter2`), and a journal that keeps them keeps them permanently.
+ * Nothing that reads such a record needs more than the program name; a reaper
+ * matches processes by pid and process group.
+ *
+ * Without `shell`, `command` is the executable itself, spaces and all. With a
+ * shell, the line is what runs, so the program is its first token: both
+ * `make("mysql -phunter2", [], { shell: true })` and
+ * `make("mysql", ["-phunter2"])` yield `mysql`. A pipeline names one
+ * executable per stage, joined the way {@link render} joins the stages.
+ *
+ * @category rendering
+ * @since 1.0.0-rc.0
+ */
+export declare const executable: (command: ChildProcess.Command) => string;
+/**
+ * The working directory a command runs in, taking the leftmost stage of a
+ * pipeline, which is the stage `setCwd` and the spawners agree to treat as the
+ * pipeline's own directory.
+ *
+ * @category rendering
+ * @since 1.0.0-rc.0
+ */
+export declare const cwd: (command: ChildProcess.Command) => string | undefined;
+/**
+ * The environment overrides a command runs with, taking the leftmost stage of
+ * a pipeline for the same reason {@link cwd} does.
+ *
+ * @category rendering
+ * @since 1.0.0-rc.0
+ */
+export declare const env: (command: ChildProcess.Command) => Record<string, string | undefined> | undefined;
+//# sourceMappingURL=CommandLine.d.ts.map

package/dist/cjs/CommandLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandLine.d.ts","sourceRoot":"","sources":["../../src/CommandLine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,KAAK,YAAY,MAAM,sCAAsC,CAAA;AAMzE;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,KAAG,MAC4C,CAAA;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,YAAY,CAAC,OAAO,KAAG,MAOG,CAAA;AAiB1D;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,GAAG,SAAS,CAAA;IAC3E;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,SAAS,CAAA;IAChE;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC1C;AAgBD;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,YAAY,CAAC,OAAO,KAAG,aAAa,CAAC,YAAY,CAAC,eAAe,CACK,CAAA;AAEtG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,QAAQ,GAAI,SAAS,YAAY,CAAC,eAAe,EAAE,UAAS,eAAoB,KAAG,MAW/F,CAAA;AASD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,GAAI,SAAS,YAAY,CAAC,OAAO,KAAG,MAKO,CAAA;AAElE;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG,GAAI,SAAS,YAAY,CAAC,OAAO,KAAG,MAAM,GAAG,SACiB,CAAA;AAE9E;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,GACd,SAAS,YAAY,CAAC,OAAO,KAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,SACsC,CAAA"}