@savvy-web/silk-effects 3.3.1 → 4.0.1

package/changesets/utils/version-files.js

@@ -1,10 +1,11 @@
 import { LegacyVersionFilesSchema } from "../schemas/version-files.js";
 import { jsonPathGet, jsonPathResolve, parseJsonPath } from "./jsonpath.js";
-import { Effect, Schema } from "effect";
+import { Effect, Option, Path, Schema } from "effect";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join, relative, resolve } from "node:path";
-import { globSync } from "tinyglobby";
-import { applyEdits, modify, parse } from "jsonc-effect";
+import { GlobPattern } from "@effected/glob";
+import { descend } from "@effected/walker";
+import { Jsonc, JsoncEdit, JsoncFormattingOptions, JsoncModifier } from "@effected/jsonc";
 
 //#region src/changesets/utils/version-files.ts
 /**
@@ -42,13 +43,14 @@ import { applyEdits, modify, parse } from "jsonc-effect";
 *
 * @example
 * ```typescript
+* import { Effect } from "effect";
 * import { VersionFiles } from "../utils/version-files.js";
 *
 * const configs = VersionFiles.extractVersionFiles(parsedConfig);
 * if (configs) {
-*   const updates = VersionFiles.processVersionFiles("/path/to/project", configs);
+*   const updates = yield* VersionFiles.processVersionFiles("/path/to/project", configs);
 *   for (const update of updates) {
-*     console.log(`Updated ${update.filePath} to ${update.version}`);
+*     yield* Effect.log(`Updated ${update.filePath} to ${update.version}`);
 *   }
 * }
 * ```
@@ -159,25 +161,24 @@ var VersionFiles = class VersionFiles {
 	* Resolve glob patterns to absolute file paths.
 	*
 	* @remarks
-	* Uses `tinyglobby` to expand each config's glob pattern relative to
-	* `cwd`. The `node_modules` directory is always ignored. Returns
-	* tuples pairing each resolved absolute path with its originating config.
+	* Compiles each config's glob with `@effected/glob` and expands it against
+	* a filesystem walk rooted at `cwd` via `@effected/walker`'s `descend`
+	* (literal patterns fast-path a direct stat; magic patterns walk from
+	* their literal prefix). The `node_modules` and `.git` directories are
+	* always ignored. Returns tuples pairing each resolved absolute path with
+	* its originating config, per-glob results sorted by relative path.
 	*
 	* @param configs - Version file configurations
 	* @param cwd - Project root directory
-	* @returns Array of `[filePath, config]` tuples
+	* @returns Effect of `[filePath, config]` tuples
 	*/
 	static resolveGlobs(configs, cwd) {
-		const results = [];
-		const resolvedCwd = resolve(cwd);
-		for (const config of configs) {
-			const matches = globSync(config.glob, {
-				cwd: resolvedCwd,
-				ignore: ["**/node_modules/**"]
-			});
-			for (const match of matches) results.push([join(resolvedCwd, match), config]);
-		}
-		return results;
+		return Effect.gen(function* () {
+			const results = [];
+			const resolvedCwd = resolve(cwd);
+			for (const config of configs) for (const match of yield* expandGlob(config.glob, resolvedCwd)) results.push([join(resolvedCwd, match), config]);
+			return results;
+		});
 	}
 	/**
 	* Detect indentation from file content.
@@ -252,7 +253,7 @@ var VersionFiles = class VersionFiles {
 	*/
 	static computeUpdate(original, jsonPaths, version) {
 		let content = original;
-		const obj = Effect.runSync(parse(content));
+		const obj = Effect.runSync(Jsonc.parse(content));
 		const previousValues = jsonPaths.flatMap((jp) => jsonPathGet(obj, jp));
 		const indent = VersionFiles.detectIndent(content);
 		const eol = content.includes("\r\n") ? "\r\n" : "\n";
@@ -286,9 +287,9 @@ var VersionFiles = class VersionFiles {
 	* the updated document, or `undefined` when nothing changed.
 	*
 	* @remarks
-	* Delegates to `jsonc-effect`'s {@link modify} + {@link applyEdits}
-	* (requires `jsonc-effect >= 0.3.1`, whose edit spans touch only the target
-	* value), so every other byte of the document is preserved. When the leaf
+	* Delegates to `@effected/jsonc`'s `JsoncModifier.modify` +
+	* `JsoncEdit.applyAll` (whose edit spans touch only the target value), so
+	* every other byte of the document is preserved. When the leaf
 	* of a wildcard-free path does not exist, `modify` inserts the property
 	* after the last sibling using the supplied formatting options — the only
 	* case where the detected indent matters. A path whose parent is missing or
@@ -304,11 +305,11 @@ var VersionFiles = class VersionFiles {
 	*/
 	static applyVersionEdit(content, concretePath, version, indentUnit, eol) {
 		const insertSpaces = !indentUnit.includes("	");
-		const program = modify(content, [...concretePath], version, { formattingOptions: {
+		const program = JsoncModifier.modify(content, [...concretePath], version, { formattingOptions: JsoncFormattingOptions.make({
 			insertSpaces,
 			tabSize: insertSpaces ? indentUnit.length : 1,
 			eol
-		} }).pipe(Effect.flatMap((edits) => applyEdits(content, edits)), Effect.map((updated) => updated === content ? void 0 : updated), Effect.catchTag("JsoncModificationError", () => Effect.succeed(void 0)));
+		}) }).pipe(Effect.map((edits) => JsoncEdit.applyAll(content, edits)), Effect.map((updated) => updated === content ? void 0 : updated), Effect.catchTag("JsoncModificationError", () => Effect.succeed(void 0)));
 		return Effect.runSync(program);
 	}
 	/**
@@ -323,36 +324,39 @@ var VersionFiles = class VersionFiles {
 	* @param cwd - Project root directory
 	* @param configs - Validated version file configurations
 	* @param dryRun - If true, do not write files (default: `false`)
-	* @returns Array of update results
-	* @throws If any file cannot be read or parsed
+	* @returns Effect of update results; a file that cannot be read or parsed
+	*   is a defect (the legacy path treats it as a caller bug, as the
+	*   previous synchronous `throw` did)
 	*/
 	static processVersionFiles(cwd, configs, dryRun = false, packages = []) {
-		const workspaces = VersionFiles.discoverVersions(cwd, packages);
-		const rootVersion = workspaces.find((ws) => ws.path === resolve(cwd))?.version ?? "0.0.0";
-		const resolved = VersionFiles.resolveGlobs(configs, cwd);
-		const updates = [];
-		for (const [filePath, config] of resolved) {
-			const jsonPaths = config.paths ?? ["$.version"];
-			const version = config.package ? workspaces.find((ws) => ws.name === config.package)?.version ?? rootVersion : VersionFiles.resolveVersion(filePath, workspaces, rootVersion);
-			try {
-				if (dryRun) {
-					const content = readFileSync(filePath, "utf-8");
-					const { previousValues, totalChanged } = VersionFiles.computeUpdate(content, jsonPaths, version);
-					if (totalChanged > 0) updates.push({
-						filePath,
-						jsonPaths,
-						version,
-						previousValues
-					});
-				} else {
-					const result = VersionFiles.updateFile(filePath, jsonPaths, version);
-					if (result) updates.push(result);
+		return Effect.gen(function* () {
+			const workspaces = VersionFiles.discoverVersions(cwd, packages);
+			const rootVersion = workspaces.find((ws) => ws.path === resolve(cwd))?.version ?? "0.0.0";
+			const resolved = yield* VersionFiles.resolveGlobs(configs, cwd);
+			const updates = [];
+			for (const [filePath, config] of resolved) {
+				const jsonPaths = config.paths ?? ["$.version"];
+				const version = config.package ? workspaces.find((ws) => ws.name === config.package)?.version ?? rootVersion : VersionFiles.resolveVersion(filePath, workspaces, rootVersion);
+				try {
+					if (dryRun) {
+						const content = readFileSync(filePath, "utf-8");
+						const { previousValues, totalChanged } = VersionFiles.computeUpdate(content, jsonPaths, version);
+						if (totalChanged > 0) updates.push({
+							filePath,
+							jsonPaths,
+							version,
+							previousValues
+						});
+					} else {
+						const result = VersionFiles.updateFile(filePath, jsonPaths, version);
+						if (result) updates.push(result);
+					}
+				} catch (error) {
+					throw new Error(`Failed to update ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
 				}
-			} catch (error) {
-				throw new Error(`Failed to update ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
 			}
-		}
-		return updates;
+			return updates;
+		});
 	}
 	/**
 	* Apply version-file updates from the resolved (post-`ConfigInspector`)
@@ -401,6 +405,36 @@ var VersionFiles = class VersionFiles {
 	}
 };
 /**
+* Expand a glob pattern against the filesystem, returning matching FILE paths
+* relative to `cwd` (POSIX separators), sorted by relative path.
+*
+* @remarks
+* The walk is `@effected/walker`'s `descend` (literal fast path,
+* `enumerationPrefix` bounding, `node_modules`/`.git` pruning), with
+* `onUnreadable: "skip"` preserving this module's silent-skip policy for
+* unreadable directories. Matching semantics are minimatch DEFAULTS via the
+* compiled pattern — notably, wildcards do not match dotfiles, same as the
+* previous `tinyglobby` defaults. An uncompilable pattern expands to no
+* matches. `descend`'s `Path` requirement is satisfied internally with the
+* core POSIX `Path.layer` — this module already speaks POSIX relative match
+* paths and node-bound absolute paths throughout.
+*
+* @param source - The glob pattern, repo-relative
+* @param cwd - Absolute directory the pattern is resolved against
+* @returns Effect of relative paths of matching files, sorted
+*
+* @internal
+*/
+function expandGlob(source, cwd) {
+	return Effect.option(GlobPattern.compile(source)).pipe(Effect.flatMap(Option.match({
+		onNone: () => Effect.succeed([]),
+		onSome: (pattern) => descend(pattern, {
+			cwd,
+			onUnreadable: "skip"
+		})
+	})), Effect.provide(Path.layer));
+}
+/**
 * Read the `version` field from a `package.json` in the given directory.
 *
 * @param dir - Absolute path to the directory containing `package.json`

package/commitlint/config/schema.js

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import { Effect, Schema } from "effect";
 
 //#region src/commitlint/config/schema.ts
 /**
@@ -11,7 +11,11 @@ import { Schema } from "effect";
 *
 * @internal
 */
-const ReleaseFormatSchema = Schema.Literal("semver", "packages", "scoped");
+const ReleaseFormatSchema = Schema.Literals([
+	"semver",
+	"packages",
+	"scoped"
+]);
 /**
 * Effect Schema for validating {@link ConfigOptions}.
 *
@@ -26,9 +30,9 @@ const ConfigOptionsSchema = Schema.Struct({
 	scopes: Schema.optional(Schema.Array(Schema.String)),
 	additionalScopes: Schema.optional(Schema.Array(Schema.String)),
 	releaseFormat: Schema.optional(ReleaseFormatSchema),
-	emojis: Schema.optionalWith(Schema.Boolean, { default: () => false }),
-	bodyMaxLineLength: Schema.optionalWith(Schema.Number.pipe(Schema.positive()), { default: () => 300 }),
-	noMarkdown: Schema.optionalWith(Schema.Boolean, { default: () => true }),
+	emojis: Schema.Boolean.pipe(Schema.withDecodingDefaultType(Effect.succeed(false))),
+	bodyMaxLineLength: Schema.Number.check(Schema.isGreaterThan(0)).pipe(Schema.withDecodingDefaultType(Effect.succeed(300))),
+	noMarkdown: Schema.Boolean.pipe(Schema.withDecodingDefaultType(Effect.succeed(true))),
 	cwd: Schema.optional(Schema.String)
 });
 /**

package/commitlint/detection/scopes.js

@@ -1,13 +1,8 @@
 import { Effect } from "effect";
-import { WorkspaceDiscovery } from "workspaces-effect";
+import { WorkspaceDiscovery } from "@effected/workspaces";
 
 //#region src/commitlint/detection/scopes.ts
 /**
-* Workspace scope detection module.
-*
-* @internal
-*/
-/**
 * Extract scope-friendly name from a package name.
 *
 * @param name - Package name (e.g., `@scope/package-name` or `package-name`)
@@ -23,7 +18,7 @@ function extractScopeName(name) {
 * Detect package scopes from workspace configuration.
 *
 * @remarks
-* Uses workspaces-effect to find all packages in the workspace and extracts
+* Uses `@effected/workspaces` to find all packages in the workspace and extracts
 * their names as potential commit scopes. For scoped packages like
 * `@scope/package-name`, only the package name portion is used as the scope.
 *

package/commitlint/formatter/messages.js

@@ -1,10 +1,5 @@
 //#region src/commitlint/formatter/messages.ts
 /**
-* Error message templates for the formatter.
-*
-* @internal
-*/
-/**
 * Detailed error explanations for common rule failures.
 *
 * @remarks

package/commitlint/hook/diagnostics/branch.js

@@ -1,30 +1,30 @@
-import { Effect } from "effect";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { Effect, Option } from "effect";
+import { Git } from "@effected/git";
 
 //#region src/commitlint/hook/diagnostics/branch.ts
 /**
 * Branch and inferred-ticket detection.
 *
+* @remarks
+* Branch lookup runs through `@effected/git`'s `currentBranch` (Option-shaped:
+* a detached `HEAD` is `Option.none`, not the literal string `"HEAD"`). Any
+* git failure degrades to the `{ branch: null }` fallback, preserving the
+* never-fails contract of the v3 implementation.
+*
 * @internal
 */
-const execFileP = promisify(execFile);
 const TICKET_RE = /^[a-z]+\/(\d+)[-/_]/;
 function inferTicketId(branch) {
 	const m = branch.match(TICKET_RE);
 	return m ? Number(m[1]) : null;
 }
 function readBranchInfo() {
-	return Effect.tryPromise(async () => {
-		const { stdout } = await execFileP("git", [
-			"rev-parse",
-			"--abbrev-ref",
-			"HEAD"
-		]);
-		const branch = stdout.trim();
+	return Effect.gen(function* () {
+		const branchOption = yield* (yield* Git).currentBranch(process.cwd());
+		const branch = Option.getOrNull(branchOption);
 		return {
 			branch,
-			inferredTicketId: inferTicketId(branch)
+			inferredTicketId: branch === null ? null : inferTicketId(branch)
 		};
 	}).pipe(Effect.orElseSucceed(() => ({
 		branch: null,

package/commitlint/hook/diagnostics/open-issues.js

@@ -1,15 +1,20 @@
 import { readCache, writeCache } from "./cache.js";
 import { Effect } from "effect";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 
 //#region src/commitlint/hook/diagnostics/open-issues.ts
 /**
 * Open-issue lookup via gh CLI, cached on disk.
 *
+* @remarks
+* The `gh` invocations are not git, so they stay hand-rolled — the spawn
+* mechanism moved from promisified `node:child_process.execFile` onto
+* `effect/unstable/process` `ChildProcess`. Any failure (gh missing, not
+* logged in, no repo, malformed JSON) degrades to `null`, preserving the
+* never-fails contract of the v3 implementation.
+*
 * @internal
 */
-const execFileP = promisify(execFile);
 const ISSUES_CACHE_TTL_SECONDS = 600;
 /** Relative path under CLAUDE_PROJECT_DIR where the open-issues cache lives. */
 const ISSUES_CACHE_RELATIVE_PATH = ".claude/cache/issues.json";
@@ -18,16 +23,17 @@ function readOpenIssuesFromCache(cachePath, ttlSeconds = 600) {
 }
 function fetchAndCacheOpenIssues(cachePath) {
 	return Effect.gen(function* () {
-		const repo = (yield* Effect.tryPromise(() => execFileP("gh", [
+		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+		const repo = (yield* spawner.string(ChildProcess.make("gh", [
 			"repo",
 			"view",
 			"--json",
 			"nameWithOwner",
 			"-q",
 			".nameWithOwner"
-		]))).stdout.trim();
+		]))).trim();
 		if (!repo) return null;
-		const listResult = yield* Effect.tryPromise(() => execFileP("gh", [
+		const listStdout = yield* spawner.string(ChildProcess.make("gh", [
 			"issue",
 			"list",
 			"--repo",
@@ -39,7 +45,7 @@ function fetchAndCacheOpenIssues(cachePath) {
 			"--json",
 			"number,title"
 		]));
-		const parsed = JSON.parse(listResult.stdout);
+		const parsed = yield* Effect.try(() => JSON.parse(listStdout));
 		yield* writeCache(cachePath, parsed);
 		return parsed;
 	}).pipe(Effect.orElseSucceed(() => null));

package/commitlint/hook/diagnostics/signing.js

@@ -1,15 +1,23 @@
-import { Effect } from "effect";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { Effect, Option } from "effect";
+import { Git } from "@effected/git";
 import { stat } from "node:fs/promises";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 
 //#region src/commitlint/hook/diagnostics/signing.ts
 /**
 * GPG / SSH signing diagnostic.
 *
+* @remarks
+* The `git config` reads run through `@effected/git`'s `configGet`
+* (Option-shaped: an unset key is `Option.none`). The `gpg` /
+* `gpg-connect-agent` probes are not git, so they stay hand-rolled on
+* `effect/unstable/process` `ChildProcess`; every probe degrades to its v3
+* fallback value (`keyResolves: false`, `agentResponsive: false`) on any
+* failure, and the diagnostic as a whole degrades to
+* {@link FALLBACK_DIAGNOSTIC}, preserving the never-fails contract.
+*
 * @internal
 */
-const execFileP = promisify(execFile);
 function parseGpgKeyExpiry(colonsOutput) {
 	for (const line of colonsOutput.split("\n")) {
 		if (!line.startsWith("sec:")) continue;
@@ -38,19 +46,6 @@ function buildSigningDiagnostic(raw) {
 		warnings
 	};
 }
-async function gitConfig(key) {
-	try {
-		const { stdout } = await execFileP("git", [
-			"config",
-			"--get",
-			key
-		]);
-		const v = stdout.trim();
-		return v.length > 0 ? v : null;
-	} catch {
-		return null;
-	}
-}
 const FALLBACK_DIAGNOSTIC = {
 	format: "none",
 	autoSignEnabled: false,
@@ -59,38 +54,36 @@ const FALLBACK_DIAGNOSTIC = {
 	agentResponsive: false,
 	warnings: ["signing diagnostic unavailable"]
 };
+/** `git config --get <key>`, degraded to null when unset or unreadable. */
+const gitConfig = (key) => Effect.gen(function* () {
+	const value = yield* (yield* Git).configGet(process.cwd(), key);
+	return Option.getOrNull(value);
+}).pipe(Effect.orElseSucceed(() => null));
 function readSigningDiagnostic() {
-	return Effect.tryPromise(async () => {
-		const gpgFormat = await gitConfig("gpg.format");
-		const commitGpgsign = await gitConfig("commit.gpgsign");
-		const signingKey = await gitConfig("user.signingkey");
-		const sshAllowedSignersFile = await gitConfig("gpg.ssh.allowedSignersFile");
+	return Effect.gen(function* () {
+		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+		const gpgFormat = yield* gitConfig("gpg.format");
+		const commitGpgsign = yield* gitConfig("commit.gpgsign");
+		const signingKey = yield* gitConfig("user.signingkey");
+		const sshAllowedSignersFile = yield* gitConfig("gpg.ssh.allowedSignersFile");
 		const isSsh = gpgFormat === "ssh";
 		let keyResolves = false;
 		let keyExpiry = null;
-		if (signingKey) if (isSsh) try {
+		if (signingKey) if (isSsh) keyResolves = yield* Effect.tryPromise(async () => {
 			await stat(signingKey);
-			keyResolves = true;
-		} catch {
-			keyResolves = false;
-		}
-		else try {
-			const { stdout } = await execFileP("gpg", [
+			return true;
+		}).pipe(Effect.orElseSucceed(() => false));
+		else {
+			const stdout = yield* spawner.string(ChildProcess.make("gpg", [
 				"--list-secret-keys",
 				"--with-colons",
 				signingKey
-			]);
+			])).pipe(Effect.orElseSucceed(() => ""));
 			keyResolves = stdout.trim().length > 0;
 			keyExpiry = parseGpgKeyExpiry(stdout);
-		} catch {
-			keyResolves = false;
 		}
 		let agentResponsive = true;
-		if (!isSsh) try {
-			await execFileP("gpg-connect-agent", ["/bye"], { timeout: 1e3 });
-		} catch {
-			agentResponsive = false;
-		}
+		if (!isSsh) agentResponsive = yield* spawner.exitCode(ChildProcess.make("gpg-connect-agent", ["/bye"])).pipe(Effect.timeout("1 second"), Effect.map((code) => code === 0), Effect.orElseSucceed(() => false));
 		return buildSigningDiagnostic({
 			gpgFormat,
 			commitGpgsign,

package/commitlint/hook/envelope.js

@@ -14,18 +14,12 @@ import { Schema } from "effect";
 const PreToolUseEnvelope = Schema.Struct({
 	hook_event_name: Schema.Literal("PreToolUse"),
 	tool_name: Schema.String,
-	tool_input: Schema.Record({
-		key: Schema.String,
-		value: Schema.Unknown
-	})
+	tool_input: Schema.Record(Schema.String, Schema.Unknown)
 });
 const PostToolUseEnvelope = Schema.Struct({
 	hook_event_name: Schema.Literal("PostToolUse"),
 	tool_name: Schema.String,
-	tool_input: Schema.Record({
-		key: Schema.String,
-		value: Schema.Unknown
-	}),
+	tool_input: Schema.Record(Schema.String, Schema.Unknown),
 	tool_response: Schema.Struct({
 		interrupted: Schema.optional(Schema.Boolean),
 		exit_code: Schema.optional(Schema.Number),

package/commitlint/hook/silence-logger.js

@@ -1,4 +1,4 @@
-import { Layer, LogLevel, Logger } from "effect";
+import { Layer, Logger, References } from "effect";
 
 //#region src/commitlint/hook/silence-logger.ts
 /**
@@ -7,13 +7,13 @@ import { Layer, LogLevel, Logger } from "effect";
 * @remarks
 * Hook subcommands reserve stdout for the JSON envelope they emit to Claude
 * Code. Effect's default logger writes messages to stdout via `console.log`,
-* which pollutes that contract (e.g., workspaces-effect emits "Workspace root
-* found" on every CLI invocation). This Layer combines two protections:
+* which pollutes that contract (e.g., workspace discovery may log on every
+* CLI invocation). This Layer combines two protections:
 *
-* 1. {@link Logger.minimumLogLevel} at `Warning` silences routine Info/Debug
+* 1. `References.MinimumLogLevel` at `Warn` silences routine Info/Debug
 *    traffic so the common case never reaches the logger at all.
-* 2. A default-logger replacement that routes anything which *does* fire to
-*    stderr, so even Warning/Error output cannot corrupt the stdout envelope.
+* 2. A logger-set replacement that routes anything which *does* fire to
+*    stderr, so even Warn/Error output cannot corrupt the stdout envelope.
 *
 * Only the hook command wrappers provide this Layer, so regular `savvy`
 * commands keep their stdout output intact.
@@ -21,16 +21,18 @@ import { Layer, LogLevel, Logger } from "effect";
 * @internal
 */
 /**
-* Replacement for the default logger that writes every message to stderr,
-* leaving stdout reserved for the hook's JSON envelope.
+* Replacement logger that writes every message to stderr, leaving stdout
+* reserved for the hook's JSON envelope. `Logger.layer` without
+* `mergeWithExisting` REPLACES the current logger set, so the default
+* stdout logger never fires.
 */
-const StderrLogger = Logger.replace(Logger.defaultLogger, Logger.make(({ message }) => {
+const StderrLogger = Logger.layer([Logger.make(({ message }) => {
 	process.stderr.write(`${JSON.stringify(message)}\n`);
-}));
+})]);
 /** Minimum log level layer that suppresses Info and below. */
-const MinLogLevel = Logger.minimumLogLevel(LogLevel.Warning);
+const MinLogLevel = Layer.succeed(References.MinimumLogLevel, "Warn");
 /**
-* Combined hook logger layer: stderr redirect merged with the Warning minimum
+* Combined hook logger layer: stderr redirect merged with the Warn minimum
 * log level. Provided by hook command wrappers to keep stdout corruption-proof.
 */
 const HookSilencer = Layer.merge(StderrLogger, MinLogLevel);