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

package/dist/cjs/EgressHttpClient.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/EgressHttpClient.ts"],
+  "sourcesContent": ["/**\n * The outbound HTTP client a Node process should use, read off its environment.\n *\n * `@effect/platform-node` ships `NodeHttpClient.layerUndici`, and its\n * dispatcher is a bare Undici `Agent`. A bare `Agent` dials every origin\n * directly: it does not read `HTTP_PROXY`, `HTTPS_PROXY` or `NO_PROXY`, and\n * nothing at the call site says so. That is invisible on a developer machine\n * with open egress and fatal inside a sandbox whose egress is default-deny\n * behind a named proxy \u2014 the request leaves for the origin, the firewall drops\n * it, and the only symptom is a transport failure far from the composition\n * that chose the client.\n *\n * This module is the one place that decision is made. {@link layer} is the\n * client every Node host composition installs; it honours the proxy the\n * environment names. Requests without a web destination use a shared pool;\n * web requests receive a fresh pinned dispatcher.\n *\n * The rule for loopback is fixed here, not by the environment: `localhost`,\n * `127.0.0.1` and `[::1]` are always reached directly, even when the\n * environment names a proxy and no exclusion, and every other origin follows\n * `NO_PROXY`. A proxy is how a process leaves its machine, and\n * `--remote http://127.0.0.1:3000` is not leaving it. The exemption is those\n * three names and nothing wider: Undici matches `NO_PROXY` entries by name,\n * never by resolved address, so `127.0.0.2` or a hostname that resolves to\n * loopback is an origin like any other and goes through the proxy.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as NodeHttpClient from \"@effect/platform-node/NodeHttpClient\"\nimport type * as Undici from \"@effect/platform-node/Undici\"\nimport { GrantStore } from \"@smthrs/kernel/GrantStore\"\nimport * as KernelHttpClient from \"@smthrs/kernel/HttpClient\"\nimport { Destination, withDestinationPinning } from \"@smthrs/kernel/HttpClient\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport * as Layer from \"effect/Layer\"\nimport * as Schema from \"effect/Schema\"\nimport * as Scope from \"effect/Scope\"\nimport * as Semaphore from \"effect/Semaphore\"\nimport { HttpClient } from \"effect/unstable/http/HttpClient\"\nimport * as EffectHttpClient from \"effect/unstable/http/HttpClient\"\nimport * as HttpClientError from \"effect/unstable/http/HttpClientError\"\nimport * as HttpClientRequest from \"effect/unstable/http/HttpClientRequest\"\nimport { isIP } from \"node:net\"\n\n/**\n * A pinned connection asked for an address family none of the authorized\n * addresses has. It is the `cause` of the `TransportError` the request fails\n * with; `code` is always `no_approved_address`.\n *\n * @category errors\n * @since 1.0.0\n */\nexport class EgressAddressError extends Schema.TaggedError<EgressAddressError>()(\n  \"@smthrs/platform-node/EgressAddressError\",\n  { code: Schema.Literal(\"no_approved_address\"), message: Schema.String }\n) {\n  override readonly name = \"EgressAddressError\"\n}\n\n/**\n * The hosts a proxy is never for. A proxy is how a process leaves its machine;\n * these names are the machine itself. Matched by name, the way Undici matches\n * every `NO_PROXY` entry, so the list is exactly these three and not\n * `127.0.0.0/8`.\n */\nconst loopback = [\"localhost\", \"127.0.0.1\", \"::1\"] as const\n\n/**\n * The exclusion list to hand Undici, given the one the environment names.\n *\n * Undici proxies *every* origin when `NO_PROXY` is empty \u2014 `#shouldProxy`\n * returns early with \"Always proxy if NO_PROXY is not set or empty\" \u2014 so a host\n * that names a proxy to reach the internet would also send `smthrs --remote\n * http://127.0.0.1:3000` and a local Ollama at `http://localhost:11434` to it.\n * Nothing in this repository has ever needed `NO_PROXY=127.0.0.1`, because the\n * client these compositions used before ignored the proxy variables outright.\n * So loopback is always excluded, the way Go's `net/http.ProxyFromEnvironment`\n * excludes it, and the environment's own entries are kept beside it.\n *\n * `*` is returned untouched: Undici recognises the wildcard only as the entire\n * value, and it already means every origin is direct.\n */\nconst exclusions = (declared: string): string =>\n  declared === \"*\" ? declared : [declared, ...loopback].filter((entry) => entry !== \"\").join(\",\")\n\n// Split ESM bundles expose CommonJS Undici through default, without synthetic\n// named exports. Node and Bun also expose its constructors through default.\n// Its typings declare `default` as a namespace without them, and `bundler`\n// resolution reads that, so the value is typed as the module it carries.\nconst loadUndici = Effect.promise(\n  async () => (await import(\"undici/index.js\")).default as unknown as typeof Undici\n)\n\n/**\n * An Undici dispatcher that routes through the egress proxy the supplied\n * environment names, or a direct one when it names none.\n *\n * The proxy variables are read in the order Undici itself reads them,\n * lowercase first, and passed explicitly rather than left to\n * `EnvHttpProxyAgent`'s own ambient lookup: a host serving a guest's\n * environment is not the guest, and the pool has to follow the record it was\n * handed. Loopback is always direct; see {@link exclusions}. Each dispatcher is\n * acquired in the caller's scope and destroyed with it, so a composition that\n * builds several still owns every pool it opened.\n *\n * @param environment the environment record whose proxy variables decide the route\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const dispatcher = (\n  environment: Readonly<Record<string, string | undefined>>\n): Effect.Effect<Undici.Dispatcher, never, Scope.Scope> =>\n  Effect.suspend(() => {\n    const httpProxy = environment.http_proxy ?? environment.HTTP_PROXY ?? \"\"\n    const httpsProxy = environment.https_proxy ?? environment.HTTPS_PROXY ?? \"\"\n    const noProxy = exclusions(environment.no_proxy ?? environment.NO_PROXY ?? \"\")\n    // Explicit empty values prevent Undici from falling back to a different\n    // ambient environment. Each replacement pool uses the same proxy policy.\n    //\n    // Undici is loaded here rather than imported at the top, the way\n    // `NodeHttpClient.makeDispatcher` loads it, because this module is imported\n    // by `NodeHost` and every bundle built on it. A static import pulls the\n    // whole of Undici into any process that merely composes a host, whose\n    // side effects a host bundle must not carry: it reddened the Node host's\n    // own `FileSystem` contract case, which never makes a request. The explicit\n    // package entry also avoids Bun's incomplete built-in \"undici\" substitute.\n    return Effect.acquireRelease(\n      Effect.map(\n        loadUndici,\n        (undici) => new undici.EnvHttpProxyAgent({ httpProxy, httpsProxy, noProxy })\n      ),\n      (dispatcher) => Effect.promise(() => dispatcher.destroy())\n    )\n  })\n\n/**\n * The Undici `HttpClient` to install, given the environment the process runs in.\n *\n * Use this wherever `NodeHttpClient.layerUndici` would otherwise be provided\n * under a layer that takes `HttpClient` from context \u2014 a model transport, a\n * judge, a fetch rule, a host bundle. The two differ only in whether the pool\n * honours `HTTP_PROXY`/`HTTPS_PROXY`/`NO_PROXY`, which is the difference\n * between a request that reaches the gateway from inside a default-deny\n * sandbox and one the firewall drops.\n *\n * @param environment the environment record whose proxy variables decide the route\n * @category layers\n * @since 1.0.0-rc.0\n */\nexport const layer = (\n  environment: Readonly<Record<string, string | undefined>>\n): Layer.Layer<HttpClient> =>\n  Layer.effect(\n    HttpClient,\n    Effect.gen(function*() {\n      const shared = yield* dispatcher(environment)\n      const ordinary = yield* NodeHttpClient.makeUndici.pipe(Effect.provideService(NodeHttpClient.Dispatcher, shared))\n      return withDestinationPinning(EffectHttpClient.transform(ordinary, (execute, request) =>\n        Effect.gen(function*() {\n          const destination = yield* Destination\n          if (destination === undefined) return yield* execute\n          const url = new URL(request.url)\n          if (\n            url.origin !== destination.origin || destination.addresses.length === 0 ||\n            destination.addresses.some((address) => isIP(address) === 0)\n          ) {\n            return yield* Effect.fail(\n              new HttpClientError.HttpClientError({\n                reason: new HttpClientError.TransportError({\n                  request,\n                  description: \"Invalid pinned HTTP destination\"\n                })\n              })\n            )\n          }\n          const proxies = [\n            environment.http_proxy ?? environment.HTTP_PROXY,\n            environment.https_proxy ?? environment.HTTPS_PROXY\n          ]\n          // The record is read per request, and a live one such as NodeHost's\n          // `process.env` can name an unparsable proxy after the shared pool\n          // was built from it; that is a refusal here, never a thrown URL error.\n          const validProxies = proxies.every((proxy) => {\n            if (!proxy) return true\n            try {\n              return [\"http:\", \"https:\"].includes(new URL(proxy).protocol)\n            } catch {\n              return false\n            }\n          })\n          if (!validProxies) {\n            return yield* Effect.fail(\n              new HttpClientError.HttpClientError({\n                reason: new HttpClientError.TransportError({\n                  request,\n                  description: \"Pinned HTTP requests require HTTP or HTTPS proxies\"\n                })\n              })\n            )\n          }\n          const undici = yield* loadUndici\n          const addresses = destination.addresses.map((address) => ({ address, family: isIP(address) }))\n          // Construction and its disposal are one uninterruptible step: an\n          // interruption that lands after the agent exists but before the request\n          // owns it would otherwise leave the agent neither destroyed nor closed.\n          return yield* Effect.uninterruptibleMask((restore) => {\n            const pinned = new undici.EnvHttpProxyAgent({\n              httpProxy: environment.http_proxy ?? environment.HTTP_PROXY ?? \"\",\n              httpsProxy: environment.https_proxy ?? environment.HTTPS_PROXY ?? \"\",\n              noProxy: exclusions(environment.no_proxy ?? environment.NO_PROXY ?? \"\"),\n              // Tunnelling HTTP too prevents the proxy resolving the target hostname.\n              proxyTunnel: true,\n              connect: {\n                lookup: (_hostname, options, callback) => {\n                  const candidates = options.family\n                    ? addresses.filter((item) => item.family === options.family)\n                    : addresses\n                  const first = candidates[0]\n                  if (first === undefined) {\n                    return callback(\n                      new EgressAddressError({\n                        code: \"no_approved_address\",\n                        message: \"No approved address for family\"\n                      }),\n                      \"\",\n                      4\n                    )\n                  }\n                  if (options.all) callback(null, candidates)\n                  else callback(null, first.address, first.family)\n                }\n              },\n              clientFactory: (origin, options) => {\n                const proxy = new undici.Pool(origin, options)\n                const connect = proxy.connect.bind(proxy)\n                // EnvHttpProxyAgent selects the route using the ORIGINAL hostname.\n                // Only the proxy tunnel destination changes; endpoint TLS still uses\n                // the original hostname for SNI and certificate verification.\n                proxy.connect = (options: Undici.Dispatcher.ConnectOptions) => {\n                  const address = addresses[0]!.address\n                  const host = isIP(address) === 6 ? `[${address}]` : address\n                  const authority = `${host}:${url.port || (url.protocol === \"https:\" ? \"443\" : \"80\")}`\n                  return connect({ ...options, path: authority, headers: { ...options.headers, host: authority } })\n                }\n                return proxy\n              }\n            })\n            const pinnedRequest = request.pipe(\n              HttpClientRequest.setHeader(\"host\", url.host),\n              HttpClientRequest.removeHeader(\"proxy-authorization\"),\n              HttpClientRequest.removeHeader(\"connection\"),\n              HttpClientRequest.removeHeader(\"transfer-encoding\"),\n              HttpClientRequest.removeHeader(\"content-length\")\n            )\n            return restore(NodeHttpClient.makeUndici.pipe(\n              Effect.provideService(NodeHttpClient.Dispatcher, pinned),\n              Effect.flatMap((client) => client.execute(pinnedRequest))\n            )).pipe(Effect.onExit((exit) =>\n              Exit.isFailure(exit)\n                ? Effect.promise(() => pinned.destroy())\n                // close prevents reuse immediately, but lets the active body drain.\n                : Effect.sync(() => {\n                  void pinned.close().catch(() => pinned.destroy())\n                })\n            ))\n          })\n        })))\n    })\n  )\n\n/**\n * Owns one replaceable Undici pool in the caller's scope. Each replacement\n * receives the same middleware and closes the previous pool.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const rebuildableTransport = (\n  acquire: Effect.Effect<Undici.Dispatcher, never, Scope.Scope>,\n  decorate: (client: HttpClient) => Effect.Effect<HttpClient> = Effect.succeed\n): Effect.Effect<\n  {\n    readonly client: HttpClient\n    readonly rebuild: Effect.Effect<HttpClient>\n  },\n  never,\n  Scope.Scope\n> =>\n  Effect.gen(function*() {\n    const scope = yield* Scope.Scope\n    const gate = yield* Semaphore.make(1)\n    let held: Scope.Closeable | undefined = undefined\n    const rebuild = gate.withPermit(Effect.uninterruptibleMask((restore) =>\n      Effect.gen(function*() {\n        const owned = yield* Scope.fork(scope)\n        const client = yield* restore(NodeHttpClient.makeUndici.pipe(\n          Effect.provideServiceEffect(NodeHttpClient.Dispatcher, acquire),\n          Effect.flatMap(decorate),\n          Effect.provideService(Scope.Scope, owned)\n        )).pipe(Effect.onExit((exit) => Exit.isSuccess(exit) ? Effect.void : Scope.close(owned, exit)))\n        const previous = held\n        held = owned\n        if (previous !== undefined) yield* Scope.close(previous, Exit.void)\n        return client\n      })\n    ))\n    return { client: yield* rebuild, rebuild }\n  })\n\n/**\n * A model transport whose replacements retain the caller's grant store and\n * environment proxy policy. Pass it to RequestExecutor.makeWith in the host scope.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const guardedTransport = (environment: Readonly<Record<string, string | undefined>>) =>\n  Effect.gen(function*() {\n    const grants = yield* GrantStore\n    return yield* rebuildableTransport(dispatcher(environment), (client) =>\n      HttpClient.pipe(Effect.provide(KernelHttpClient.layer.pipe(\n        Layer.provide(Layer.succeed(HttpClient)(client)),\n        Layer.provide(Layer.succeed(GrantStore)(grants))\n      ))))\n  })\n"],
+  "mappings": "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",
+  "names": ["import_HttpClient", "dispatcher", "options"]
+}

package/dist/cjs/HostLiveness.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Answers whether a recorded run owner is still alive on this host.
+ *
+ * @since 0.1.0
+ */
+import * as Effect from "effect/Effect";
+/**
+ * The owner identity fields liveness is decided from.
+ *
+ * Structural on purpose: `@smthrs/journal`'s `OwnerId` is exactly this shape
+ * plus a nonce, so an `OwnerId` is accepted here without this package taking a
+ * dependency on the journal to name a type.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Owner {
+    /** The host the owner ran on. */
+    readonly hostId: string;
+    /** The operating-system process id that held the run. */
+    readonly pid: number;
+}
+/**
+ * Liveness configuration.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Options {
+    /** The host id this process answers for. */
+    readonly hostId: string;
+    /**
+     * How the probe asks the operating system. Default `process.kill`, which
+     * delivers nothing for signal 0 and only reports whether the pid is
+     * signalable.
+     */
+    readonly signal?: ((pid: number, signal: 0) => void) | undefined;
+}
+/**
+ * Builds the liveness probe `EngineStore` consults before it steals a run.
+ *
+ * The engine asks this before taking a run whose recorded owner it is not, so
+ * a wrong `true` strands a run and a wrong `false` runs it twice. The rule is
+ * therefore asymmetric on purpose:
+ *
+ * - An owner from a **different host** is alive. A pid means nothing across
+ *   machines, and the process table this probe reads is only this machine's.
+ * - An owner from **this host** is dead only when the signal-0 probe reports
+ *   `ESRCH`. Every other result preserves liveness.
+ *
+ * The residual risk is pid reuse. An owner whose pid was recycled by an
+ * unrelated program reads as alive and its run waits for an operator, which is
+ * the safe direction: nothing about a recycled pid can tell this process
+ * whether the run is still being driven, and the cost of guessing wrong the
+ * other way is two hosts executing one run.
+ *
+ * A multi-process deployment with a supervisor or a lease system knows better
+ * than any pid probe and should answer from that instead.
+ *
+ * `@smthrs/run-store`'s `Ownership.sameHostPidProbe` fills the same
+ * `LivenessCheck`. Both probes use the same `ESRCH`-only death rule.
+ * `EPERM`, `EINVAL`, and unknown signal errors preserve liveness.
+ *
+ * The cross-host policy differs. `sameHostPidProbe` compares the owner's
+ * `hostId` with `context.claimant.hostId` and returns `false` for a foreign
+ * host, leaving the expired lease to govern reclaiming the run. This probe
+ * compares with the configured `hostId` and returns `true` for a foreign
+ * host, so a permanently dead foreign host's runs wait for an operator.
+ *
+ * Which answer a deployment gets depends on the entry point it used:
+ * `@smthrs/flows`' `NodeRuntime` defaults to this function, while
+ * `@smthrs/cli`'s `NodeControl` passes `sameHostPidProbe`. This function
+ * returns a one-argument function, which is structurally accepted as an
+ * `Ownership.LivenessCheck` and ignores its `context` argument. Pick the
+ * probe for its cross-host policy and source of host identity.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const isAlive: (options: Options) => (owner: Owner) => Effect.Effect<boolean>;
+//# sourceMappingURL=HostLiveness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HostLiveness.d.ts","sourceRoot":"","sources":["../../src/HostLiveness.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,WAAW,KAAK;IACpB,iCAAiC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,yDAAyD;IACzD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;CACjE;AAgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,OAAO,GAAI,SAAS,OAAO,KAAG,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAKjF,CAAA"}

package/dist/cjs/HostLiveness.js

@@ -0,0 +1,49 @@
+"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 HostLiveness_exports = {};
+__export(HostLiveness_exports, {
+  isAlive: () => isAlive
+});
+module.exports = __toCommonJS(HostLiveness_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+const signalable = (send, pid) => {
+  try {
+    send(pid, 0);
+    return true;
+  } catch (cause) {
+    return cause?.code !== "ESRCH";
+  }
+};
+const isAlive = (options) => {
+  const send = options.signal ?? ((pid, signal) => {
+    process.kill(pid, signal);
+  });
+  return (owner) => Effect.sync(() => owner.hostId !== options.hostId || signalable(send, owner.pid));
+};
+//# sourceMappingURL=HostLiveness.js.map

package/dist/cjs/HostLiveness.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/HostLiveness.ts"],
+  "sourcesContent": ["/**\n * Answers whether a recorded run owner is still alive on this host.\n *\n * @since 0.1.0\n */\n\nimport * as Effect from \"effect/Effect\"\n\n/**\n * The owner identity fields liveness is decided from.\n *\n * Structural on purpose: `@smthrs/journal`'s `OwnerId` is exactly this shape\n * plus a nonce, so an `OwnerId` is accepted here without this package taking a\n * dependency on the journal to name a type.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Owner {\n  /** The host the owner ran on. */\n  readonly hostId: string\n  /** The operating-system process id that held the run. */\n  readonly pid: number\n}\n\n/**\n * Liveness configuration.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Options {\n  /** The host id this process answers for. */\n  readonly hostId: string\n  /**\n   * How the probe asks the operating system. Default `process.kill`, which\n   * delivers nothing for signal 0 and only reports whether the pid is\n   * signalable.\n   */\n  readonly signal?: ((pid: number, signal: 0) => void) | undefined\n}\n\nconst signalable = (send: (pid: number, signal: 0) => void, pid: number): boolean => {\n  try {\n    send(pid, 0)\n    return true\n  } catch (cause) {\n    // ESRCH means the process is gone. EPERM means it exists and belongs to\n    // another user, which is still a live owner this host must not rob. A throw\n    // that is not an object at all carries no code, and reading through it\n    // rather than off it is what stops that crashing the probe: a thrown string\n    // or `null` is an answer nobody gave, which is a live owner.\n    return (cause as { readonly code?: string } | null | undefined)?.code !== \"ESRCH\"\n  }\n}\n\n/**\n * Builds the liveness probe `EngineStore` consults before it steals a run.\n *\n * The engine asks this before taking a run whose recorded owner it is not, so\n * a wrong `true` strands a run and a wrong `false` runs it twice. The rule is\n * therefore asymmetric on purpose:\n *\n * - An owner from a **different host** is alive. A pid means nothing across\n *   machines, and the process table this probe reads is only this machine's.\n * - An owner from **this host** is dead only when the signal-0 probe reports\n *   `ESRCH`. Every other result preserves liveness.\n *\n * The residual risk is pid reuse. An owner whose pid was recycled by an\n * unrelated program reads as alive and its run waits for an operator, which is\n * the safe direction: nothing about a recycled pid can tell this process\n * whether the run is still being driven, and the cost of guessing wrong the\n * other way is two hosts executing one run.\n *\n * A multi-process deployment with a supervisor or a lease system knows better\n * than any pid probe and should answer from that instead.\n *\n * `@smthrs/run-store`'s `Ownership.sameHostPidProbe` fills the same\n * `LivenessCheck`. Both probes use the same `ESRCH`-only death rule.\n * `EPERM`, `EINVAL`, and unknown signal errors preserve liveness.\n *\n * The cross-host policy differs. `sameHostPidProbe` compares the owner's\n * `hostId` with `context.claimant.hostId` and returns `false` for a foreign\n * host, leaving the expired lease to govern reclaiming the run. This probe\n * compares with the configured `hostId` and returns `true` for a foreign\n * host, so a permanently dead foreign host's runs wait for an operator.\n *\n * Which answer a deployment gets depends on the entry point it used:\n * `@smthrs/flows`' `NodeRuntime` defaults to this function, while\n * `@smthrs/cli`'s `NodeControl` passes `sameHostPidProbe`. This function\n * returns a one-argument function, which is structurally accepted as an\n * `Ownership.LivenessCheck` and ignores its `context` argument. Pick the\n * probe for its cross-host policy and source of host identity.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const isAlive = (options: Options): (owner: Owner) => Effect.Effect<boolean> => {\n  const send = options.signal ?? ((pid, signal) => {\n    process.kill(pid, signal)\n  })\n  return (owner) => Effect.sync(() => owner.hostId !== options.hostId || signalable(send, owner.pid))\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,aAAwB;AAoCxB,MAAM,aAAa,CAAC,MAAwC,QAAyB;AACnF,MAAI;AACF,SAAK,KAAK,CAAC;AACX,WAAO;AAAA,EACT,SAAS,OAAO;AAMd,WAAQ,OAAyD,SAAS;AAAA,EAC5E;AACF;AA2CO,MAAM,UAAU,CAAC,YAA+D;AACrF,QAAM,OAAO,QAAQ,WAAW,CAAC,KAAK,WAAW;AAC/C,YAAQ,KAAK,KAAK,MAAM;AAAA,EAC1B;AACA,SAAO,CAAC,UAAU,OAAO,KAAK,MAAM,MAAM,WAAW,QAAQ,UAAU,WAAW,MAAM,MAAM,GAAG,CAAC;AACpG;",
+  "names": []
+}

package/dist/cjs/NodeHost.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Aggregate Node.js Host bundle.
+ *
+ * This module defines the `NodeHost` service union and a single `layer` that
+ * provides the closed Host surface backed by Node: `@effect/platform-node`'s
+ * filesystem, child-process spawner, Undici `HttpClient`, native `Path`,
+ * and the Node `Jj` adapter from its own package. Use the layer when a Node
+ * program wants every host capability from one place; use the individual
+ * modules when a program should only be able to reach part of the host. The
+ * bundle also supplies native `ProcessConfinement` for the kernel spawner.
+ *
+ * There is no Node HTTP module either: outgoing requests are Effect's
+ * `HttpClient`, and `@effect/platform-node` already ships the Undici-backed
+ * implementation. Undici follows no redirect unless a redirect interceptor is
+ * installed, so every hop stays visible to `@smthrs/kernel`'s decorator.
+ *
+ * There is no Node shell module: running a command is Effect's
+ * `ChildProcessSpawner`, and `@effect/platform-node` already ships the
+ * implementation.
+ *
+ * @since 0.1.0
+ */
+import * as NodeChildProcessSpawner from "../vendor/cjs/node/NodeChildProcessSpawner.js";
+import * as NodeCrypto from "../vendor/cjs/node/NodeCrypto.js";
+import * as NodeFileSystem from "../vendor/cjs/node/NodeFileSystem.js";
+import * as NodeHttpClient from "../vendor/cjs/node/NodeHttpClient.js";
+import type { Jj, JjError } from "@smthrs/jj";
+import type { HostServiceIds } from "@smthrs/kernel/HostServices";
+import type * as KernelProcessConfinement from "@smthrs/kernel/ProcessConfinement";
+import type * as ProcessLedger from "@smthrs/kernel/ProcessLedger";
+import type { FileSystem } from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import type * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import type { HttpClient } from "effect/unstable/http/HttpClient";
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import * as AtomicFileSystem from "./AtomicFileSystem.ts";
+import * as EgressHttpClient from "./EgressHttpClient.ts";
+import * as ProcessReaper from "./ProcessReaper.ts";
+/**
+ * The Node platform modules Effect ships, re-exported so a program that wants
+ * only part of the host has one place to reach for them. `NodeJj` belongs to
+ * `@smthrs/jj`; import it from there.
+ *
+ * `NodeCrypto` is here for a different reason than the rest. `Crypto` is not a
+ * Host service — it carries no host authority the kernel could attenuate, so
+ * it is not in {@link NodeHost} and not in the closed list — but every durable
+ * composition needs one, and a program that already depends on this package
+ * for its host should not have to add a second dependency for the digest.
+ *
+ * @category re-exports
+ * @since 0.1.0
+ */
+export { AtomicFileSystem, EgressHttpClient, NodeChildProcessSpawner, NodeCrypto, NodeFileSystem, NodeHttpClient, ProcessReaper };
+/**
+ * The union of host services provided by the Node host layer.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type NodeHost = FileSystem | Path.Path | ChildProcessSpawner | Jj | HttpClient | KernelProcessConfinement.ProcessConfinement;
+declare const NodeHostError_base: Schema.Class<NodeHostError, Schema.TaggedStruct<"@smthrs/platform-node/NodeHostError", {
+    readonly code: Schema.Literal<"invalid_repository_root">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Invalid repository-root configuration, refused before layer construction.
+ * @category errors
+ * @since 1.0.0-rc.0
+ */
+export declare class NodeHostError extends NodeHostError_base {
+    readonly name = "NodeHostError";
+}
+/**
+ * Stable implementation identities for the raw bundle's five Host slots.
+ * Contained POSIX factories replace its spawner with {@link ProcessReaper.layerSpawner}.
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export declare const implementationIds: Readonly<Record<(typeof HostServiceIds)[number], string>>;
+/**
+ * What a caller may configure about a contained Node host.
+ *
+ * `platform` is deliberately absent. `ContainedSpawner.Options` declares it so a
+ * caller that supplies its own spawner can describe one, but this native host
+ * detaches by `process.platform` whatever a record claims. A caller-supplied
+ * `"win32"` on a POSIX host would therefore
+ * record `pgid: null` for a child that really does lead a group, and
+ * {@link ProcessReaper.reap} would retire that record as `no-group` and leave
+ * the orphan running forever — a durable lie rather than a compile error.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type ContainedOptions = ProcessReaper.SpawnerOptions & ProcessReaper.Options;
+/**
+ * Provides the default Node implementations for the whole closed Host surface.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<NodeHost, JjError>;
+/**
+ * Provides the Node host with `Jj` bound to one absolute repository root.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layerAt: (repositoryRoot: string) => Layer.Layer<NodeHost, JjError>;
+/**
+ * Provides the Node host with process containment turned on.
+ *
+ * The difference from {@link layer} is what happens to a spawned process when
+ * its run stops. Under {@link layer} a child is signalled when its scope
+ * closes and then waited for, forever if it ignores `SIGTERM`, and a host that
+ * dies without closing its scopes abandons every child it started. This layer
+ * gives each child an escalation deadline and records it in the
+ * `ProcessLedger`, then sweeps the records a previous incarnation of the same
+ * host left behind before it hands the host over
+ * ({@link ProcessReaper.reap}).
+ *
+ * jj is contained here too: `layerContained` builds the `Jj` service over the
+ * same spawner rather than letting it start its own children, so a `jj`
+ * invocation a crashed host left running is a record the next incarnation
+ * reaps like any other.
+ *
+ * The ledger is a requirement rather than a default because the durable half
+ * of containment is only as good as the journal underneath it:
+ * `ProcessLedger.layer` inherits a crashed incarnation's processes,
+ * `ProcessLedger.layerMemory` contains this incarnation and nothing more, and
+ * the choice belongs to the program that knows which it has.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerContained: (options?: ContainedOptions) => Layer.Layer<NodeHost, JjError, ProcessLedger.ProcessLedger>;
+/**
+ * Provides the contained Node host with `Jj` bound to one absolute repository
+ * root.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layerContainedAt: (repositoryRoot: string, options?: ContainedOptions) => Layer.Layer<NodeHost, JjError, ProcessLedger.ProcessLedger>;
+//# sourceMappingURL=NodeHost.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NodeHost.d.ts","sourceRoot":"","sources":["../../src/NodeHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,uBAAuB,MAAM,+CAA+C,CAAA;AACxF,OAAO,KAAK,UAAU,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,cAAc,MAAM,sCAAsC,CAAA;AACtE,OAAO,KAAK,cAAc,MAAM,sCAAsC,CAAA;AAEtE,OAAO,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAE7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AACjE,OAAO,KAAK,KAAK,wBAAwB,MAAM,mCAAmC,CAAA;AAClF,OAAO,KAAK,KAAK,aAAa,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAA;AAEtF,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAEzD,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;;;;;;;;;;;GAaG;AACH,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,uBAAuB,EACvB,UAAU,EACV,cAAc,EACd,cAAc,EACd,aAAa,EACd,CAAA;AAcD;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAChB,UAAU,GACV,IAAI,CAAC,IAAI,GACT,mBAAmB,GACnB,EAAE,GACF,UAAU,GACV,wBAAwB,CAAC,kBAAkB,CAAA;;;;;AAE/C;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,kBAGjC;IACA,SAAkB,IAAI,mBAAkB;CACzC;AAYD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAMvF,CAAA;AAKD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,cAAc,GAAG,aAAa,CAAC,OAAO,CAAA;AAQnF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,CAMhD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,gBAAgB,MAAM,KAAG,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,CAO3E,CAAA;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,GACzB,UAAU,gBAAgB,KACzB,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,aAAa,CAgB5D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC3B,gBAAgB,MAAM,EACtB,UAAU,gBAAgB,KACzB,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,aAAa,CAW5D,CAAA"}

package/dist/cjs/NodeHost.js

@@ -0,0 +1,128 @@
+"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 NodeHost_exports = {};
+__export(NodeHost_exports, {
+  AtomicFileSystem: () => AtomicFileSystem,
+  EgressHttpClient: () => EgressHttpClient,
+  NodeChildProcessSpawner: () => NodeChildProcessSpawner,
+  NodeCrypto: () => NodeCrypto,
+  NodeFileSystem: () => NodeFileSystem,
+  NodeHostError: () => NodeHostError,
+  NodeHttpClient: () => NodeHttpClient,
+  ProcessReaper: () => ProcessReaper,
+  implementationIds: () => implementationIds,
+  layer: () => layer,
+  layerAt: () => layerAt,
+  layerContained: () => layerContained,
+  layerContainedAt: () => layerContainedAt
+});
+module.exports = __toCommonJS(NodeHost_exports);
+var NodeChildProcessSpawner = __toESM(require("../vendor/cjs/node/NodeChildProcessSpawner.js"), 1);
+var NodeCrypto = __toESM(require("../vendor/cjs/node/NodeCrypto.js"), 1);
+var NodeFileSystem = __toESM(require("../vendor/cjs/node/NodeFileSystem.js"), 1);
+var NodeHttpClient = __toESM(require("../vendor/cjs/node/NodeHttpClient.js"), 1);
+var NodePath = __toESM(require("../vendor/cjs/node/NodePath.js"), 1);
+var NodeJj = __toESM(require("@smthrs/jj/node/NodeJj"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_node_path = require("node:path");
+var AtomicFileSystem = __toESM(require("./AtomicFileSystem.js"), 1);
+var EgressHttpClient = __toESM(require("./EgressHttpClient.js"), 1);
+var ProcessConfinement = __toESM(require("./ProcessConfinement.js"), 1);
+var ProcessReaper = __toESM(require("./ProcessReaper.js"), 1);
+const httpClient = EgressHttpClient.layer(process.env);
+class NodeHostError extends Schema.TaggedError()("@smthrs/platform-node/NodeHostError", {
+  code: Schema.Literal("invalid_repository_root"),
+  message: Schema.String
+}) {
+  name = "NodeHostError";
+}
+const absoluteRoot = (root) => {
+  if ((0, import_node_path.isAbsolute)(root)) return root;
+  throw new NodeHostError({
+    code: "invalid_repository_root",
+    message: `NodeHost requires an absolute repository root, got ${JSON.stringify(Array.from(root).slice(0, 64).join(""))}`
+  });
+};
+const implementationIds = {
+  "effect/FileSystem": "@smthrs/platform-node/AtomicFileSystem",
+  "effect/Path": "@effect/platform-node/NodePath",
+  "effect/process/ChildProcessSpawner": "@effect/platform-node/NodeChildProcessSpawner",
+  "@smthrs/jj/Jj": "@smthrs/jj/node/NodeJj",
+  "effect/HttpClient": "@smthrs/platform-node/EgressHttpClient"
+};
+const platform = Layer.mergeAll(AtomicFileSystem.layer, NodePath.layer);
+const reaping = (options) => ({
+  ownerPid: options?.ownerPid,
+  system: options?.system
+});
+const layer = Layer.mergeAll(
+  ProcessConfinement.layer(),
+  platform,
+  Layer.provide(NodeChildProcessSpawner.layer, platform),
+  httpClient,
+  NodeJj.layer
+);
+const layerAt = (repositoryRoot) => Layer.mergeAll(
+  ProcessConfinement.layer(),
+  platform,
+  Layer.provide(NodeChildProcessSpawner.layer, platform),
+  httpClient,
+  NodeJj.layerAt(absoluteRoot(repositoryRoot))
+);
+const layerContained = (options) => {
+  const spawner = Layer.provide(
+    ProcessReaper.layerSpawner({ graceMs: options?.graceMs }),
+    Layer.provide(NodeChildProcessSpawner.layer, platform)
+  );
+  return Layer.mergeAll(
+    ProcessConfinement.layer(),
+    platform,
+    httpClient,
+    // jj goes through the CONTAINED spawner here, not around it. `NodeJj.layer`
+    // spawns its own children, which is right for a host that has no spawner
+    // to offer, but under containment it would mean a `jj` that leads no
+    // recorded process group, appears in no ledger, and survives the
+    // incarnation that started it.
+    Layer.provideMerge(NodeJj.layerSpawner, spawner)
+  ).pipe(Layer.provideMerge(ProcessReaper.layer(reaping(options))));
+};
+const layerContainedAt = (repositoryRoot, options) => {
+  const spawner = Layer.provide(
+    ProcessReaper.layerSpawner({ graceMs: options?.graceMs }),
+    Layer.provide(NodeChildProcessSpawner.layer, platform)
+  );
+  return Layer.mergeAll(
+    ProcessConfinement.layer(),
+    platform,
+    httpClient,
+    Layer.provideMerge(NodeJj.layerSpawnerAt(absoluteRoot(repositoryRoot)), spawner)
+  ).pipe(Layer.provideMerge(ProcessReaper.layer(reaping(options))));
+};
+//# sourceMappingURL=NodeHost.js.map

package/dist/cjs/NodeHost.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/NodeHost.ts"],
+  "sourcesContent": ["/**\n * Aggregate Node.js Host bundle.\n *\n * This module defines the `NodeHost` service union and a single `layer` that\n * provides the closed Host surface backed by Node: `@effect/platform-node`'s\n * filesystem, child-process spawner, Undici `HttpClient`, native `Path`,\n * and the Node `Jj` adapter from its own package. Use the layer when a Node\n * program wants every host capability from one place; use the individual\n * modules when a program should only be able to reach part of the host. The\n * bundle also supplies native `ProcessConfinement` for the kernel spawner.\n *\n * There is no Node HTTP module either: outgoing requests are Effect's\n * `HttpClient`, and `@effect/platform-node` already ships the Undici-backed\n * implementation. Undici follows no redirect unless a redirect interceptor is\n * installed, so every hop stays visible to `@smthrs/kernel`'s decorator.\n *\n * There is no Node shell module: running a command is Effect's\n * `ChildProcessSpawner`, and `@effect/platform-node` already ships the\n * implementation.\n *\n * @since 0.1.0\n */\n\nimport * as NodeChildProcessSpawner from \"@effect/platform-node/NodeChildProcessSpawner\"\nimport * as NodeCrypto from \"@effect/platform-node/NodeCrypto\"\nimport * as NodeFileSystem from \"@effect/platform-node/NodeFileSystem\"\nimport * as NodeHttpClient from \"@effect/platform-node/NodeHttpClient\"\nimport * as NodePath from \"@effect/platform-node/NodePath\"\nimport type { Jj, JjError } from \"@smthrs/jj\"\nimport * as NodeJj from \"@smthrs/jj/node/NodeJj\"\nimport type { HostServiceIds } from \"@smthrs/kernel/HostServices\"\nimport type * as KernelProcessConfinement from \"@smthrs/kernel/ProcessConfinement\"\nimport type * as ProcessLedger from \"@smthrs/kernel/ProcessLedger\"\nimport type { FileSystem } from \"effect/FileSystem\"\nimport * as Layer from \"effect/Layer\"\nimport type * as Path from \"effect/Path\"\nimport * as Schema from \"effect/Schema\"\nimport type { HttpClient } from \"effect/unstable/http/HttpClient\"\nimport type { ChildProcessSpawner } from \"effect/unstable/process/ChildProcessSpawner\"\nimport { isAbsolute } from \"node:path\"\nimport * as AtomicFileSystem from \"./AtomicFileSystem.ts\"\nimport * as EgressHttpClient from \"./EgressHttpClient.ts\"\nimport * as ProcessConfinement from \"./ProcessConfinement.ts\"\nimport * as ProcessReaper from \"./ProcessReaper.ts\"\n\n/**\n * The Node platform modules Effect ships, re-exported so a program that wants\n * only part of the host has one place to reach for them. `NodeJj` belongs to\n * `@smthrs/jj`; import it from there.\n *\n * `NodeCrypto` is here for a different reason than the rest. `Crypto` is not a\n * Host service \u2014 it carries no host authority the kernel could attenuate, so\n * it is not in {@link NodeHost} and not in the closed list \u2014 but every durable\n * composition needs one, and a program that already depends on this package\n * for its host should not have to add a second dependency for the digest.\n *\n * @category re-exports\n * @since 0.1.0\n */\nexport {\n  AtomicFileSystem,\n  EgressHttpClient,\n  NodeChildProcessSpawner,\n  NodeCrypto,\n  NodeFileSystem,\n  NodeHttpClient,\n  ProcessReaper\n}\n\n/**\n * The `HttpClient` every bundle below installs: Undici through the egress\n * proxy this process's environment names, and a direct Undici pool when it\n * names none.\n *\n * `NodeHttpClient.layerUndici` is the direct pool unconditionally. It is still\n * re-exported above for a program composing its own services, but a bundle\n * that spans a whole host has to work inside a sandbox whose only way out is a\n * proxy, so the bundles read the environment. See {@link EgressHttpClient}.\n */\nconst httpClient = EgressHttpClient.layer(process.env)\n\n/**\n * The union of host services provided by the Node host layer.\n *\n * @category models\n * @since 0.1.0\n */\nexport type NodeHost =\n  | FileSystem\n  | Path.Path\n  | ChildProcessSpawner\n  | Jj\n  | HttpClient\n  | KernelProcessConfinement.ProcessConfinement\n\n/**\n * Invalid repository-root configuration, refused before layer construction.\n * @category errors\n * @since 1.0.0-rc.0\n */\nexport class NodeHostError extends Schema.TaggedError<NodeHostError>()(\"@smthrs/platform-node/NodeHostError\", {\n  code: Schema.Literal(\"invalid_repository_root\"),\n  message: Schema.String\n}) {\n  override readonly name = \"NodeHostError\"\n}\n\nconst absoluteRoot = (root: string): string => {\n  if (isAbsolute(root)) return root\n  throw new NodeHostError({\n    code: \"invalid_repository_root\",\n    message: `NodeHost requires an absolute repository root, got ${\n      JSON.stringify(Array.from(root).slice(0, 64).join(\"\"))\n    }`\n  })\n}\n\n/**\n * Stable implementation identities for the raw bundle's five Host slots.\n * Contained POSIX factories replace its spawner with {@link ProcessReaper.layerSpawner}.\n * @category models\n * @since 1.0.0-rc.0\n */\nexport const implementationIds: Readonly<Record<(typeof HostServiceIds)[number], string>> = {\n  \"effect/FileSystem\": \"@smthrs/platform-node/AtomicFileSystem\",\n  \"effect/Path\": \"@effect/platform-node/NodePath\",\n  \"effect/process/ChildProcessSpawner\": \"@effect/platform-node/NodeChildProcessSpawner\",\n  \"@smthrs/jj/Jj\": \"@smthrs/jj/node/NodeJj\",\n  \"effect/HttpClient\": \"@smthrs/platform-node/EgressHttpClient\"\n}\n\n/** The two services `NodeChildProcessSpawner` resolves paths and files with. */\nconst platform = Layer.mergeAll(AtomicFileSystem.layer, NodePath.layer)\n\n/**\n * What a caller may configure about a contained Node host.\n *\n * `platform` is deliberately absent. `ContainedSpawner.Options` declares it so a\n * caller that supplies its own spawner can describe one, but this native host\n * detaches by `process.platform` whatever a record claims. A caller-supplied\n * `\"win32\"` on a POSIX host would therefore\n * record `pgid: null` for a child that really does lead a group, and\n * {@link ProcessReaper.reap} would retire that record as `no-group` and leave\n * the orphan running forever \u2014 a durable lie rather than a compile error.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type ContainedOptions = ProcessReaper.SpawnerOptions & ProcessReaper.Options\n\n/** The reaper half of {@link ContainedOptions}. */\nconst reaping = (options?: ContainedOptions): ProcessReaper.Options => ({\n  ownerPid: options?.ownerPid,\n  system: options?.system\n})\n\n/**\n * Provides the default Node implementations for the whole closed Host surface.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<NodeHost, JjError> = Layer.mergeAll(\n  ProcessConfinement.layer(),\n  platform,\n  Layer.provide(NodeChildProcessSpawner.layer, platform),\n  httpClient,\n  NodeJj.layer\n)\n\n/**\n * Provides the Node host with `Jj` bound to one absolute repository root.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layerAt = (repositoryRoot: string): Layer.Layer<NodeHost, JjError> =>\n  Layer.mergeAll(\n    ProcessConfinement.layer(),\n    platform,\n    Layer.provide(NodeChildProcessSpawner.layer, platform),\n    httpClient,\n    NodeJj.layerAt(absoluteRoot(repositoryRoot))\n  )\n\n/**\n * Provides the Node host with process containment turned on.\n *\n * The difference from {@link layer} is what happens to a spawned process when\n * its run stops. Under {@link layer} a child is signalled when its scope\n * closes and then waited for, forever if it ignores `SIGTERM`, and a host that\n * dies without closing its scopes abandons every child it started. This layer\n * gives each child an escalation deadline and records it in the\n * `ProcessLedger`, then sweeps the records a previous incarnation of the same\n * host left behind before it hands the host over\n * ({@link ProcessReaper.reap}).\n *\n * jj is contained here too: `layerContained` builds the `Jj` service over the\n * same spawner rather than letting it start its own children, so a `jj`\n * invocation a crashed host left running is a record the next incarnation\n * reaps like any other.\n *\n * The ledger is a requirement rather than a default because the durable half\n * of containment is only as good as the journal underneath it:\n * `ProcessLedger.layer` inherits a crashed incarnation's processes,\n * `ProcessLedger.layerMemory` contains this incarnation and nothing more, and\n * the choice belongs to the program that knows which it has.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerContained = (\n  options?: ContainedOptions\n): Layer.Layer<NodeHost, JjError, ProcessLedger.ProcessLedger> => {\n  const spawner = Layer.provide(\n    ProcessReaper.layerSpawner({ graceMs: options?.graceMs }),\n    Layer.provide(NodeChildProcessSpawner.layer, platform)\n  )\n  return Layer.mergeAll(\n    ProcessConfinement.layer(),\n    platform,\n    httpClient,\n    // jj goes through the CONTAINED spawner here, not around it. `NodeJj.layer`\n    // spawns its own children, which is right for a host that has no spawner\n    // to offer, but under containment it would mean a `jj` that leads no\n    // recorded process group, appears in no ledger, and survives the\n    // incarnation that started it.\n    Layer.provideMerge(NodeJj.layerSpawner, spawner)\n  ).pipe(Layer.provideMerge(ProcessReaper.layer(reaping(options))))\n}\n\n/**\n * Provides the contained Node host with `Jj` bound to one absolute repository\n * root.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layerContainedAt = (\n  repositoryRoot: string,\n  options?: ContainedOptions\n): Layer.Layer<NodeHost, JjError, ProcessLedger.ProcessLedger> => {\n  const spawner = Layer.provide(\n    ProcessReaper.layerSpawner({ graceMs: options?.graceMs }),\n    Layer.provide(NodeChildProcessSpawner.layer, platform)\n  )\n  return Layer.mergeAll(\n    ProcessConfinement.layer(),\n    platform,\n    httpClient,\n    Layer.provideMerge(NodeJj.layerSpawnerAt(absoluteRoot(repositoryRoot)), spawner)\n  ).pipe(Layer.provideMerge(ProcessReaper.layer(reaping(options))))\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,8BAAyC;AACzC,iBAA4B;AAC5B,qBAAgC;AAChC,qBAAgC;AAChC,eAA0B;AAE1B,aAAwB;AAKxB,YAAuB;AAEvB,aAAwB;AAGxB,uBAA2B;AAC3B,uBAAkC;AAClC,uBAAkC;AAClC,yBAAoC;AACpC,oBAA+B;AAoC/B,MAAM,aAAa,iBAAiB,MAAM,QAAQ,GAAG;AAqB9C,MAAM,sBAAsB,OAAO,YAA2B,EAAE,uCAAuC;AAAA,EAC5G,MAAM,OAAO,QAAQ,yBAAyB;AAAA,EAC9C,SAAS,OAAO;AAClB,CAAC,EAAE;AAAA,EACiB,OAAO;AAC3B;AAEA,MAAM,eAAe,CAAC,SAAyB;AAC7C,UAAI,6BAAW,IAAI,EAAG,QAAO;AAC7B,QAAM,IAAI,cAAc;AAAA,IACtB,MAAM;AAAA,IACN,SAAS,sDACP,KAAK,UAAU,MAAM,KAAK,IAAI,EAAE,MAAM,GAAG,EAAE,EAAE,KAAK,EAAE,CAAC,CACvD;AAAA,EACF,CAAC;AACH;AAQO,MAAM,oBAA+E;AAAA,EAC1F,qBAAqB;AAAA,EACrB,eAAe;AAAA,EACf,sCAAsC;AAAA,EACtC,iBAAiB;AAAA,EACjB,qBAAqB;AACvB;AAGA,MAAM,WAAW,MAAM,SAAS,iBAAiB,OAAO,SAAS,KAAK;AAmBtE,MAAM,UAAU,CAAC,aAAuD;AAAA,EACtE,UAAU,SAAS;AAAA,EACnB,QAAQ,SAAS;AACnB;AAQO,MAAM,QAAwC,MAAM;AAAA,EACzD,mBAAmB,MAAM;AAAA,EACzB;AAAA,EACA,MAAM,QAAQ,wBAAwB,OAAO,QAAQ;AAAA,EACrD;AAAA,EACA,OAAO;AACT;AAQO,MAAM,UAAU,CAAC,mBACtB,MAAM;AAAA,EACJ,mBAAmB,MAAM;AAAA,EACzB;AAAA,EACA,MAAM,QAAQ,wBAAwB,OAAO,QAAQ;AAAA,EACrD;AAAA,EACA,OAAO,QAAQ,aAAa,cAAc,CAAC;AAC7C;AA4BK,MAAM,iBAAiB,CAC5B,YACgE;AAChE,QAAM,UAAU,MAAM;AAAA,IACpB,cAAc,aAAa,EAAE,SAAS,SAAS,QAAQ,CAAC;AAAA,IACxD,MAAM,QAAQ,wBAAwB,OAAO,QAAQ;AAAA,EACvD;AACA,SAAO,MAAM;AAAA,IACX,mBAAmB,MAAM;AAAA,IACzB;AAAA,IACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,MAAM,aAAa,OAAO,cAAc,OAAO;AAAA,EACjD,EAAE,KAAK,MAAM,aAAa,cAAc,MAAM,QAAQ,OAAO,CAAC,CAAC,CAAC;AAClE;AASO,MAAM,mBAAmB,CAC9B,gBACA,YACgE;AAChE,QAAM,UAAU,MAAM;AAAA,IACpB,cAAc,aAAa,EAAE,SAAS,SAAS,QAAQ,CAAC;AAAA,IACxD,MAAM,QAAQ,wBAAwB,OAAO,QAAQ;AAAA,EACvD;AACA,SAAO,MAAM;AAAA,IACX,mBAAmB,MAAM;AAAA,IACzB;AAAA,IACA;AAAA,IACA,MAAM,aAAa,OAAO,eAAe,aAAa,cAAc,CAAC,GAAG,OAAO;AAAA,EACjF,EAAE,KAAK,MAAM,aAAa,cAAc,MAAM,QAAQ,OAAO,CAAC,CAAC,CAAC;AAClE;",
+  "names": []
+}

package/dist/cjs/ProcessConfinement.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The kernel's `ProcessConfinement` seam, filled with this host's native
+ * sandbox: bubblewrap on Linux, seatbelt on macOS.
+ *
+ * `@smthrs/kernel`'s `ChildProcessSpawner.layer` hands every stage that passed
+ * its `proc:spawn` check to the confinement in its context, together with the
+ * `ProcessConfinement.Profile` the grants in force admit. This module turns
+ * that profile into a {@link ProcessSandbox.Request}, plans it against the
+ * workspace, and wraps the stage's argv in the mechanism the host has, so an
+ * approved `bash` can write only where an `fs:write` grant says and reach the
+ * network only when a `net:*` grant says. A stage that asked for the platform
+ * shell is spelled out as `/bin/sh -c <line>` first: wrapping a `shell: true`
+ * command line would otherwise leave its redirections and pipes to a shell
+ * outside the sandbox.
+ *
+ * A host with no mechanism is the one decision this module leaves to its
+ * caller: {@link Options.unavailable} either refuses the spawn, so nothing
+ * runs that the profile would not have confined, or runs it unconfined with
+ * a warning, the way every host did before this seam existed. A write set
+ * the mechanism cannot enforce safely, a symbolic link below the workspace
+ * root, is always refused.
+ *
+ * @since 1.0.0-rc.1
+ */
+import * as KernelProcessConfinement from "@smthrs/kernel/ProcessConfinement";
+import * as Layer from "effect/Layer";
+import * as ProcessSandbox from "./ProcessSandbox.ts";
+/**
+ * How the confinement is built.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export interface Options {
+    /**
+     * What happens when this host has no mechanism to enforce a profile with.
+     * `"refuse"` fails the spawn, so a command never runs with more than the
+     * profile allows; `"unconfined"` runs it as given and logs a
+     * warning naming what the host lacks.
+     */
+    readonly unavailable?: "refuse" | "unconfined" | undefined;
+    /** The host facts mechanism selection reads; defaults to the real host. */
+    readonly host?: ProcessSandbox.Host | undefined;
+    /** Where each run's private temporary directory is created; defaults to the OS temporary directory. */
+    readonly temporaryDirectory?: string | undefined;
+}
+/**
+ * Builds the native confinement.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.1
+ */
+export declare const make: (options?: Options) => KernelProcessConfinement.Service;
+/**
+ * Provides the native confinement.
+ *
+ * @category layers
+ * @since 1.0.0-rc.1
+ */
+export declare const layer: (options?: Options) => Layer.Layer<KernelProcessConfinement.ProcessConfinement>;
+//# sourceMappingURL=ProcessConfinement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessConfinement.d.ts","sourceRoot":"","sources":["../../src/ProcessConfinement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,wBAAwB,MAAM,mCAAmC,CAAA;AAE7E,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAOrC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,YAAY,GAAG,SAAS,CAAA;IAC1D,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,CAAC,EAAE,cAAc,CAAC,IAAI,GAAG,SAAS,CAAA;IAC/C,uGAAuG;IACvG,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACjD;AA0FD;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,UAAS,OAAY,KAAG,wBAAwB,CAAC,OA2MrE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,UAAS,OAAY,KAAG,KAAK,CAAC,KAAK,CAAC,wBAAwB,CAAC,kBAAkB,CAC1B,CAAA"}