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

package/dist/cjs/test/TestGrantStore.js

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TestGrantStore_exports = {};
+__export(TestGrantStore_exports, {
+  layerAllow: () => layerAllow,
+  layerDeny: () => layerDeny,
+  layerScripted: () => layerScripted
+});
+module.exports = __toCommonJS(TestGrantStore_exports);
+var import_Permission = require("@smthrs/capability/Permission");
+var import_effect = require("effect");
+var import_GrantStore = require("../GrantStore.js");
+var import_GrantStore2 = require("../GrantStore.js");
+const layerAllow = import_GrantStore2.layerNoop;
+const layerDeny = (reason = "denied by test") => {
+  const service = import_GrantStore2.GrantStore.of({
+    policy: import_GrantStore.emptyPolicy,
+    check: import_effect.Effect.fn("GrantStore.check")((capability) => import_effect.Effect.fail((0, import_Permission.permissionDenied)(capability, reason))),
+    reply: import_effect.Effect.fn("GrantStore.reply")(() => import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "request_not_found" }))),
+    list: import_effect.Effect.fn("GrantStore.list")(() => import_effect.Effect.succeed([]))(),
+    grantEnvelope: import_effect.Effect.fn("GrantStore.grantEnvelope")(() => import_effect.Effect.void)
+  });
+  return import_effect.Layer.succeed(import_GrantStore2.GrantStore)(service);
+};
+const layerScripted = (replies) => import_effect.Layer.effect(
+  import_GrantStore2.GrantStore,
+  import_effect.Effect.sync(() => {
+    let index = 0;
+    const service = import_GrantStore2.GrantStore.of({
+      policy: import_GrantStore.emptyPolicy,
+      check: import_effect.Effect.fn("GrantStore.check")(
+        (capability) => import_effect.Effect.suspend(() => {
+          const reply = replies[index++];
+          return reply !== void 0 && reply !== "deny" ? import_effect.Effect.void : import_effect.Effect.fail(
+            (0, import_Permission.permissionDenied)(
+              capability,
+              reply === void 0 ? "permission reply script exhausted" : "permission request denied"
+            )
+          );
+        })
+      ),
+      reply: import_effect.Effect.fn("GrantStore.reply")(() => import_effect.Effect.fail(new import_Permission.GrantStoreError({ code: "request_not_found" }))),
+      list: import_effect.Effect.fn("GrantStore.list")(() => import_effect.Effect.succeed([]))(),
+      grantEnvelope: import_effect.Effect.fn("GrantStore.grantEnvelope")(() => import_effect.Effect.void)
+    });
+    return service;
+  })
+);
+//# sourceMappingURL=TestGrantStore.js.map

package/dist/cjs/test/TestGrantStore.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/test/TestGrantStore.ts"],
+  "sourcesContent": ["/**\n * Deterministic grant-store layers for tests.\n *\n * @since 1.0.0-rc.0\n */\n\nimport { GrantStoreError, permissionDenied } from \"@smthrs/capability/Permission\"\nimport { Effect, Layer } from \"effect\"\nimport { emptyPolicy as closedPolicy } from \"../GrantStore.ts\"\nimport { GrantStore, layerNoop, type Resolution, type Service } from \"../GrantStore.ts\"\n\n/**\n * An allow-all grant store.\n *\n * @category layers\n * @since 1.0.0-rc.0\n */\nexport const layerAllow: Layer.Layer<GrantStore> = layerNoop\n\n/**\n * Provides a grant store that denies every capability.\n *\n * @category layers\n * @since 1.0.0-rc.0\n */\nexport const layerDeny = (reason = \"denied by test\"): Layer.Layer<GrantStore> => {\n  const service = GrantStore.of({\n    policy: closedPolicy,\n    check: Effect.fn(\"GrantStore.check\")((capability) => Effect.fail(permissionDenied(capability, reason))),\n    reply: Effect.fn(\"GrantStore.reply\")(() => Effect.fail(new GrantStoreError({ code: \"request_not_found\" }))),\n    list: Effect.fn(\"GrantStore.list\")(() => Effect.succeed([]))(),\n    grantEnvelope: Effect.fn(\"GrantStore.grantEnvelope\")(() => Effect.void)\n  })\n  return Layer.succeed(GrantStore)(service)\n}\n\n/**\n * Provides a grant store whose checks consume a deterministic sequence of\n * attended-style replies. `once`, `run`, and `remembered` allow the check;\n * `deny` rejects it. Exhausting the script rejects further checks.\n *\n * @category layers\n * @since 1.0.0-rc.0\n */\nexport const layerScripted = (\n  replies: ReadonlyArray<Resolution>\n): Layer.Layer<GrantStore> =>\n  Layer.effect(\n    GrantStore,\n    Effect.sync(() => {\n      let index = 0\n      const service: Service = GrantStore.of({\n        policy: closedPolicy,\n        check: Effect.fn(\"GrantStore.check\")((capability) =>\n          Effect.suspend(() => {\n            const reply = replies[index++]\n            return reply !== undefined && reply !== \"deny\"\n              ? Effect.void\n              : Effect.fail(\n                permissionDenied(\n                  capability,\n                  reply === undefined ? \"permission reply script exhausted\" : \"permission request denied\"\n                )\n              )\n          })\n        ),\n        reply: Effect.fn(\"GrantStore.reply\")(() => Effect.fail(new GrantStoreError({ code: \"request_not_found\" }))),\n        list: Effect.fn(\"GrantStore.list\")(() => Effect.succeed([]))(),\n        grantEnvelope: Effect.fn(\"GrantStore.grantEnvelope\")(() => Effect.void)\n      })\n      return service\n    })\n  )\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,wBAAkD;AAClD,oBAA8B;AAC9B,wBAA4C;AAC5C,IAAAA,qBAAqE;AAQ9D,MAAM,aAAsC;AAQ5C,MAAM,YAAY,CAAC,SAAS,qBAA8C;AAC/E,QAAM,UAAU,8BAAW,GAAG;AAAA,IAC5B,QAAQ,kBAAAC;AAAA,IACR,OAAO,qBAAO,GAAG,kBAAkB,EAAE,CAAC,eAAe,qBAAO,SAAK,oCAAiB,YAAY,MAAM,CAAC,CAAC;AAAA,IACtG,OAAO,qBAAO,GAAG,kBAAkB,EAAE,MAAM,qBAAO,KAAK,IAAI,kCAAgB,EAAE,MAAM,oBAAoB,CAAC,CAAC,CAAC;AAAA,IAC1G,MAAM,qBAAO,GAAG,iBAAiB,EAAE,MAAM,qBAAO,QAAQ,CAAC,CAAC,CAAC,EAAE;AAAA,IAC7D,eAAe,qBAAO,GAAG,0BAA0B,EAAE,MAAM,qBAAO,IAAI;AAAA,EACxE,CAAC;AACD,SAAO,oBAAM,QAAQ,6BAAU,EAAE,OAAO;AAC1C;AAUO,MAAM,gBAAgB,CAC3B,YAEA,oBAAM;AAAA,EACJ;AAAA,EACA,qBAAO,KAAK,MAAM;AAChB,QAAI,QAAQ;AACZ,UAAM,UAAmB,8BAAW,GAAG;AAAA,MACrC,QAAQ,kBAAAA;AAAA,MACR,OAAO,qBAAO,GAAG,kBAAkB;AAAA,QAAE,CAAC,eACpC,qBAAO,QAAQ,MAAM;AACnB,gBAAM,QAAQ,QAAQ,OAAO;AAC7B,iBAAO,UAAU,UAAa,UAAU,SACpC,qBAAO,OACP,qBAAO;AAAA,gBACP;AAAA,cACE;AAAA,cACA,UAAU,SAAY,sCAAsC;AAAA,YAC9D;AAAA,UACF;AAAA,QACJ,CAAC;AAAA,MACH;AAAA,MACA,OAAO,qBAAO,GAAG,kBAAkB,EAAE,MAAM,qBAAO,KAAK,IAAI,kCAAgB,EAAE,MAAM,oBAAoB,CAAC,CAAC,CAAC;AAAA,MAC1G,MAAM,qBAAO,GAAG,iBAAiB,EAAE,MAAM,qBAAO,QAAQ,CAAC,CAAC,CAAC,EAAE;AAAA,MAC7D,eAAe,qBAAO,GAAG,0BAA0B,EAAE,MAAM,qBAAO,IAAI;AAAA,IACxE,CAAC;AACD,WAAO;AAAA,EACT,CAAC;AACH;",
+  "names": ["import_GrantStore", "closedPolicy"]
+}

package/dist/esm/CapabilitySet.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The shared monotone authority implementation used by declarations and guards.
+ * @since 1.0.0
+ */
+export * from "@smthrs/capability/CapabilitySet";
+//# sourceMappingURL=CapabilitySet.d.ts.map

package/dist/esm/CapabilitySet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilitySet.d.ts","sourceRoot":"","sources":["../../src/CapabilitySet.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,kCAAkC,CAAA"}

package/dist/esm/CapabilitySet.js

@@ -0,0 +1,6 @@
+/**
+ * The shared monotone authority implementation used by declarations and guards.
+ * @since 1.0.0
+ */
+export * from "@smthrs/capability/CapabilitySet";
+//# sourceMappingURL=CapabilitySet.js.map

package/dist/esm/CapabilitySet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilitySet.js","sourceRoot":"","sources":["../../src/CapabilitySet.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,kCAAkC,CAAA","sourcesContent":["/**\n * The shared monotone authority implementation used by declarations and guards.\n * @since 1.0.0\n */\n\nexport * from \"@smthrs/capability/CapabilitySet\"\n"]}

package/dist/esm/ChildProcessEnvironment.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Least-authority environment construction for child processes.
+ *
+ * @since 1.0.0-rc.0
+ */
+/**
+ * Credential-bearing field names shared with the model request boundary.
+ *
+ * `token`, `key` (optionally followed by a separated `id`), and `pat` are
+ * anchored to complete or separator-delimited suffixes so names such as
+ * `TOKEN_COUNT` and `KEYBOARD` remain ordinary diagnostics. Keeping this rule
+ * below the model and process layers gives request validation and child
+ * spawning one definition of a sensitive name.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const credentialNamePattern: RegExp;
+/**
+ * Reports whether a field name conventionally carries credentials.
+ *
+ * @category predicates
+ * @since 1.0.0-rc.0
+ */
+export declare const isCredentialName: (name: string) => boolean;
+/**
+ * Ambient variables a child may inherit for executable lookup, identity,
+ * locale, terminal behavior, temporary files, and its shell.
+ *
+ * Locale category variables are admitted separately by their `LC_` prefix.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const inheritedNames: ReadonlyArray<string>;
+/**
+ * Reports whether a variable belongs to the bootstrap set {@link make}
+ * inherits: one of {@link inheritedNames} or a locale `LC_` category,
+ * compared case-insensitively.
+ *
+ * @category predicates
+ * @since 1.0.0-rc.1
+ */
+export declare const isInheritedName: (name: string) => boolean;
+/**
+ * Selects the bootstrap allowlist from an ambient environment and overlays
+ * caller-declared names.
+ *
+ * Sensitive-looking ambient names are withheld even if a future bootstrap
+ * list grows to include one. A caller declaration is applied last because it
+ * is the explicit authority for that child; an `undefined` declaration
+ * removes an inherited name. The returned null-prototype record is always
+ * suitable as a replacement environment and never asks the spawner to merge
+ * the rest of the host process environment.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export declare const make: (ambient: Readonly<Record<string, string | undefined>>, declared?: Readonly<Record<string, string | undefined>>) => Record<string, string>;
+//# sourceMappingURL=ChildProcessEnvironment.d.ts.map

package/dist/esm/ChildProcessEnvironment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChildProcessEnvironment.d.ts","sourceRoot":"","sources":["../../src/ChildProcessEnvironment.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,QACoR,CAAA;AAEtT;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,OAA2C,CAAA;AAE3F;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,EAAE,aAAa,CAAC,MAAM,CAQ/C,CAAA;AAIF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,OAG9C,CAAA;AASD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,IAAI,GACf,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,EACrD,WAAU,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAM,KAC1D,MAAM,CAAC,MAAM,EAAE,MAAM,CAUvB,CAAA"}

package/dist/esm/ChildProcessEnvironment.js

@@ -0,0 +1,91 @@
+/**
+ * Least-authority environment construction for child processes.
+ *
+ * @since 1.0.0-rc.0
+ */
+/**
+ * Credential-bearing field names shared with the model request boundary.
+ *
+ * `token`, `key` (optionally followed by a separated `id`), and `pat` are
+ * anchored to complete or separator-delimited suffixes so names such as
+ * `TOKEN_COUNT` and `KEYBOARD` remain ordinary diagnostics. Keeping this rule
+ * below the model and process layers gives request validation and child
+ * spawning one definition of a sensitive name.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export const credentialNamePattern = /authorization|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|auth[-_]?token|api[-_]?token|session[-_]?token|bearer|(?:^|[-_])token$|(?:^|[-_])key(?:[-_]id)?$|(?:^|[-_])pat$|secret|credential|password|passphrase|passwd|signature|x-amz-signature|cookie|set[-_]?cookie|chatgpt[-_]?account[-_]?id/i;
+/**
+ * Reports whether a field name conventionally carries credentials.
+ *
+ * @category predicates
+ * @since 1.0.0-rc.0
+ */
+export const isCredentialName = (name) => credentialNamePattern.test(name);
+/**
+ * Ambient variables a child may inherit for executable lookup, identity,
+ * locale, terminal behavior, temporary files, and its shell.
+ *
+ * Locale category variables are admitted separately by their `LC_` prefix.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export const inheritedNames = Object.freeze([
+    "PATH",
+    "HOME",
+    "USER",
+    "LANG",
+    "TERM",
+    "TMPDIR",
+    "SHELL"
+]);
+const inherited = new Set(inheritedNames);
+/**
+ * Reports whether a variable belongs to the bootstrap set {@link make}
+ * inherits: one of {@link inheritedNames} or a locale `LC_` category,
+ * compared case-insensitively.
+ *
+ * @category predicates
+ * @since 1.0.0-rc.1
+ */
+export const isInheritedName = (name) => {
+    const canonical = name.toUpperCase();
+    return inherited.has(canonical) || canonical.startsWith("LC_");
+};
+const remove = (environment, name) => {
+    const canonical = name.toUpperCase();
+    for (const present of Object.keys(environment)) {
+        if (present.toUpperCase() === canonical)
+            delete environment[present];
+    }
+};
+/**
+ * Selects the bootstrap allowlist from an ambient environment and overlays
+ * caller-declared names.
+ *
+ * Sensitive-looking ambient names are withheld even if a future bootstrap
+ * list grows to include one. A caller declaration is applied last because it
+ * is the explicit authority for that child; an `undefined` declaration
+ * removes an inherited name. The returned null-prototype record is always
+ * suitable as a replacement environment and never asks the spawner to merge
+ * the rest of the host process environment.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.0
+ */
+export const make = (ambient, declared = {}) => {
+    const environment = Object.create(null);
+    for (const [name, value] of Object.entries(ambient)) {
+        if (value !== undefined && isInheritedName(name) && !isCredentialName(name))
+            environment[name] = value;
+    }
+    for (const [name, value] of Object.entries(declared)) {
+        remove(environment, name);
+        if (value !== undefined)
+            environment[name] = value;
+    }
+    return environment;
+};
+//# sourceMappingURL=ChildProcessEnvironment.js.map

package/dist/esm/ChildProcessEnvironment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChildProcessEnvironment.js","sourceRoot":"","sources":["../../src/ChildProcessEnvironment.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAChC,oTAAoT,CAAA;AAEtT;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAAY,EAAW,EAAE,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAE3F;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAA0B,MAAM,CAAC,MAAM,CAAC;IACjE,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,QAAQ;IACR,OAAO;CACR,CAAC,CAAA;AAEF,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,CAAA;AAEzC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAAY,EAAW,EAAE;IACvD,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,EAAE,CAAA;IACpC,OAAO,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;AAChE,CAAC,CAAA;AAED,MAAM,MAAM,GAAG,CAAC,WAAmC,EAAE,IAAY,EAAQ,EAAE;IACzE,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,EAAE,CAAA;IACpC,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;QAC/C,IAAI,OAAO,CAAC,WAAW,EAAE,KAAK,SAAS;YAAE,OAAO,WAAW,CAAC,OAAO,CAAC,CAAA;IACtE,CAAC;AACH,CAAC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,OAAqD,EACrD,WAAyD,EAAE,EACnC,EAAE;IAC1B,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAA2B,CAAA;IACjE,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACpD,IAAI,KAAK,KAAK,SAAS,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC;YAAE,WAAW,CAAC,IAAI,CAAC,GAAG,KAAK,CAAA;IACxG,CAAC;IACD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACrD,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;QACzB,IAAI,KAAK,KAAK,SAAS;YAAE,WAAW,CAAC,IAAI,CAAC,GAAG,KAAK,CAAA;IACpD,CAAC;IACD,OAAO,WAAW,CAAA;AACpB,CAAC,CAAA","sourcesContent":["/**\n * Least-authority environment construction for child processes.\n *\n * @since 1.0.0-rc.0\n */\n\n/**\n * Credential-bearing field names shared with the model request boundary.\n *\n * `token`, `key` (optionally followed by a separated `id`), and `pat` are\n * anchored to complete or separator-delimited suffixes so names such as\n * `TOKEN_COUNT` and `KEYBOARD` remain ordinary diagnostics. Keeping this rule\n * below the model and process layers gives request validation and child\n * spawning one definition of a sensitive name.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const credentialNamePattern =\n  /authorization|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|auth[-_]?token|api[-_]?token|session[-_]?token|bearer|(?:^|[-_])token$|(?:^|[-_])key(?:[-_]id)?$|(?:^|[-_])pat$|secret|credential|password|passphrase|passwd|signature|x-amz-signature|cookie|set[-_]?cookie|chatgpt[-_]?account[-_]?id/i\n\n/**\n * Reports whether a field name conventionally carries credentials.\n *\n * @category predicates\n * @since 1.0.0-rc.0\n */\nexport const isCredentialName = (name: string): boolean => credentialNamePattern.test(name)\n\n/**\n * Ambient variables a child may inherit for executable lookup, identity,\n * locale, terminal behavior, temporary files, and its shell.\n *\n * Locale category variables are admitted separately by their `LC_` prefix.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const inheritedNames: ReadonlyArray<string> = Object.freeze([\n  \"PATH\",\n  \"HOME\",\n  \"USER\",\n  \"LANG\",\n  \"TERM\",\n  \"TMPDIR\",\n  \"SHELL\"\n])\n\nconst inherited = new Set(inheritedNames)\n\n/**\n * Reports whether a variable belongs to the bootstrap set {@link make}\n * inherits: one of {@link inheritedNames} or a locale `LC_` category,\n * compared case-insensitively.\n *\n * @category predicates\n * @since 1.0.0-rc.1\n */\nexport const isInheritedName = (name: string): boolean => {\n  const canonical = name.toUpperCase()\n  return inherited.has(canonical) || canonical.startsWith(\"LC_\")\n}\n\nconst remove = (environment: Record<string, string>, name: string): void => {\n  const canonical = name.toUpperCase()\n  for (const present of Object.keys(environment)) {\n    if (present.toUpperCase() === canonical) delete environment[present]\n  }\n}\n\n/**\n * Selects the bootstrap allowlist from an ambient environment and overlays\n * caller-declared names.\n *\n * Sensitive-looking ambient names are withheld even if a future bootstrap\n * list grows to include one. A caller declaration is applied last because it\n * is the explicit authority for that child; an `undefined` declaration\n * removes an inherited name. The returned null-prototype record is always\n * suitable as a replacement environment and never asks the spawner to merge\n * the rest of the host process environment.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const make = (\n  ambient: Readonly<Record<string, string | undefined>>,\n  declared: Readonly<Record<string, string | undefined>> = {}\n): Record<string, string> => {\n  const environment = Object.create(null) as Record<string, string>\n  for (const [name, value] of Object.entries(ambient)) {\n    if (value !== undefined && isInheritedName(name) && !isCredentialName(name)) environment[name] = value\n  }\n  for (const [name, value] of Object.entries(declared)) {\n    remove(environment, name)\n    if (value !== undefined) environment[name] = value\n  }\n  return environment\n}\n"]}

package/dist/esm/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/esm/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"}