@savvy-web/silk-effects 3.3.1 → 4.0.1

package/services/SilkWorkspaceAnalyzer.js

@@ -5,9 +5,8 @@ import { WorkspaceAnalysisError } from "../errors/WorkspaceAnalysisError.js";
 import { AnalyzedWorkspace, WorkspaceAnalysis } from "../schemas/WorkspaceAnalysisSchemas.js";
 import { TagStrategy } from "./TagStrategy.js";
 import { VersioningStrategy } from "./VersioningStrategy.js";
-import { Context, Effect, Layer, Option } from "effect";
-import { FileSystem } from "@effect/platform";
-import { PackageManagerDetector, TopologicalSorter, WorkspaceDiscovery } from "workspaces-effect";
+import { Context, Effect, FileSystem, Layer, Option } from "effect";
+import { DependencyGraph, PackageManagerDetector, WorkspaceDiscovery } from "@effected/workspaces";
 
 //#region src/services/SilkWorkspaceAnalyzer.ts
 /**
@@ -37,7 +36,7 @@ import { PackageManagerDetector, TopologicalSorter, WorkspaceDiscovery } from "w
 * @since 0.2.0
 * @public
 */
-var SilkWorkspaceAnalyzer = class extends Context.Tag("@savvy-web/silk-effects/SilkWorkspaceAnalyzer")() {};
+var SilkWorkspaceAnalyzer = class extends Context.Service()("@savvy-web/silk-effects/SilkWorkspaceAnalyzer") {};
 /**
 * Read the raw package.json from disk as an untyped record.
 *
@@ -115,7 +114,6 @@ function computeReleaseStatus(pkgName, isPrivate, isPublishable, config) {
 const SilkWorkspaceAnalyzerLive = Layer.effect(SilkWorkspaceAnalyzer, Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const discovery = yield* WorkspaceDiscovery;
-	const sorter = yield* TopologicalSorter;
 	const pmDetector = yield* PackageManagerDetector;
 	const configReader = yield* ChangesetConfigReader;
 	const versioningStrategy = yield* VersioningStrategy;
@@ -125,11 +123,11 @@ const SilkWorkspaceAnalyzerLive = Layer.effect(SilkWorkspaceAnalyzer, Effect.gen
 			root,
 			reason: `Package manager detection failed: ${String(err)}`
 		})));
-		const packages = yield* discovery.listPackages(root).pipe(Effect.mapError((err) => new WorkspaceAnalysisError({
+		const packages = yield* discovery.listPackages().pipe(Effect.mapError((err) => new WorkspaceAnalysisError({
 			root,
 			reason: `Workspace discovery failed: ${String(err)}`
 		})));
-		const topoOrder = yield* sorter.sort().pipe(Effect.mapError((err) => new WorkspaceAnalysisError({
+		const topoOrder = yield* DependencyGraph.make({ packages }).sort().pipe(Effect.mapError((err) => new WorkspaceAnalysisError({
 			root,
 			reason: `Cyclic dependency detected: ${String(err)}`
 		})));
@@ -199,8 +197,8 @@ const SilkWorkspaceAnalyzerLive = Layer.effect(SilkWorkspaceAnalyzer, Effect.gen
 			root,
 			runtime: pm.runtime,
 			packageManager: {
-				type: pm.type,
-				version: pm.version
+				type: pm.name,
+				...Option.isSome(pm.version) ? { version: pm.version.value } : {}
 			},
 			workspaces: analyzedWorkspaces,
 			changesetConfig,

package/services/TagStrategy.js

@@ -25,7 +25,7 @@ import { Context, Effect, Layer } from "effect";
 * @since 0.1.0
 * @public
 */
-var TagStrategy = class extends Context.Tag("@savvy-web/silk-effects/TagStrategy")() {};
+var TagStrategy = class extends Context.Service()("@savvy-web/silk-effects/TagStrategy") {};
 /**
 * Live implementation of {@link TagStrategy} with no external dependencies.
 *
@@ -35,7 +35,7 @@ var TagStrategy = class extends Context.Tag("@savvy-web/silk-effects/TagStrategy
 * @since 0.1.0
 * @public
 */
-const TagStrategyLive = Layer.succeed(TagStrategy, TagStrategy.of({
+const TagStrategyLive = Layer.succeed(TagStrategy, {
 	determine: (versioningResult) => {
 		if (versioningResult.type === "independent") return Effect.succeed("scoped");
 		return Effect.succeed("single");
@@ -50,7 +50,7 @@ const TagStrategyLive = Layer.succeed(TagStrategy, TagStrategy.of({
 		if (name.startsWith("@")) return Effect.succeed(`${name}@${version}`);
 		return Effect.succeed(`${name}@${version}`);
 	}
-}));
+});
 
 //#endregion
 export { TagStrategy, TagStrategyLive };

package/services/ToolDiscovery.js

@@ -2,8 +2,8 @@ import { ToolNotFoundError } from "../errors/ToolNotFoundError.js";
 import { ToolResolutionError } from "../errors/ToolResolutionError.js";
 import { ResolvedTool } from "../schemas/ResolvedTool.js";
 import { Context, Effect, Layer, Option, Ref } from "effect";
-import { Command, CommandExecutor } from "@effect/platform";
-import { PackageManagerDetector, WorkspaceRoot } from "workspaces-effect";
+import { PackageManagerDetector, WorkspaceRoot } from "@effected/workspaces";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 
 //#region src/services/ToolDiscovery.ts
 /**
@@ -21,7 +21,7 @@ import { PackageManagerDetector, WorkspaceRoot } from "workspaces-effect";
 *     );
 *   }).pipe(
 *     Effect.provide(ToolDiscoveryLive),
-*     Effect.provide(NodeContext.layer),
+*     Effect.provide(NodeServices.layer),
 *   )
 * );
 * ```
@@ -29,7 +29,7 @@ import { PackageManagerDetector, WorkspaceRoot } from "workspaces-effect";
 * @since 0.2.0
 * @public
 */
-var ToolDiscovery = class extends Context.Tag("@savvy-web/silk-effects/ToolDiscovery")() {};
+var ToolDiscovery = class extends Context.Service()("@savvy-web/silk-effects/ToolDiscovery") {};
 /**
 * Build the PM exec prefix for running a local binary.
 */
@@ -62,14 +62,14 @@ function pmExecArgs(pmType, name) {
 /**
 * Run a command and return its stdout, or `Option.none()` on failure.
 */
-function tryString(cmd) {
-	return Command.string(cmd).pipe(Effect.map((s) => Option.some(s.trim())), Effect.catchAll(() => Effect.succeed(Option.none())));
+function tryString(spawner, cmd) {
+	return spawner.string(cmd).pipe(Effect.map((s) => Option.some(s.trim())), Effect.catch(() => Effect.succeed(Option.none())));
 }
 /**
 * Run a command and return true if it succeeds (exit code 0).
 */
-function tryExists(cmd) {
-	return Command.exitCode(cmd).pipe(Effect.map((code) => code === 0), Effect.catchAll(() => Effect.succeed(false)));
+function tryExists(spawner, cmd) {
+	return spawner.exitCode(cmd).pipe(Effect.map((code) => code === 0), Effect.catch(() => Effect.succeed(false)));
 }
 /**
 * Extract version from command output using a VersionExtractor.
@@ -98,45 +98,46 @@ function extractVersion(output, extractor) {
 * Live implementation of {@link ToolDiscovery}.
 *
 * @remarks
-* Requires `CommandExecutor` from `@effect/platform`, `PackageManagerDetector`
-* and `WorkspaceRoot` from `workspaces-effect`.
+* Requires `ChildProcessSpawner` from `effect/unstable/process` (provide
+* `NodeServices.layer` at the app edge), plus `PackageManagerDetector`
+* and `WorkspaceRoot` from `@effected/workspaces`.
 *
 * @since 0.2.0
 * @public
 */
 const ToolDiscoveryLive = Layer.effect(ToolDiscovery, Effect.gen(function* () {
-	const executor = yield* CommandExecutor.CommandExecutor;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 	const wsRoot = yield* WorkspaceRoot;
 	const pmDetector = yield* PackageManagerDetector;
 	const cache = yield* Ref.make(/* @__PURE__ */ new Map());
 	const resolve = (definition) => Effect.gen(function* () {
 		const hit = (yield* Ref.get(cache)).get(definition.name);
 		if (hit) return hit;
-		const root = yield* wsRoot.find(process.cwd()).pipe(Effect.catchAll(() => Effect.fail(new ToolResolutionError({
+		const root = yield* wsRoot.find(process.cwd()).pipe(Effect.catch(() => Effect.fail(new ToolResolutionError({
 			name: definition.name,
 			reason: "Could not find workspace root"
 		}))));
-		const pmType = (yield* pmDetector.detect(root).pipe(Effect.catchAll(() => Effect.fail(new ToolResolutionError({
+		const pmType = (yield* pmDetector.detect(root).pipe(Effect.catch(() => Effect.fail(new ToolResolutionError({
 			name: definition.name,
 			reason: "Could not detect package manager"
-		}))))).type;
-		const globalExists = yield* Effect.provideService(tryExists(Command.make("sh", "-c", `command -v ${definition.name}`)), CommandExecutor.CommandExecutor, executor);
+		}))))).name;
+		const globalExists = yield* tryExists(spawner, ChildProcess.make("sh", ["-c", `command -v ${definition.name}`]));
 		let globalVersion = Option.none();
 		if (globalExists && definition.versionExtractor._tag !== "None") {
 			const flag = definition.versionExtractor.flag;
-			globalVersion = extractVersion(yield* Effect.provideService(tryString(Command.make(definition.name, flag)), CommandExecutor.CommandExecutor, executor), definition.versionExtractor);
+			globalVersion = extractVersion(yield* tryString(spawner, ChildProcess.make(definition.name, [flag])), definition.versionExtractor);
 		}
 		let localExists = false;
 		let localVersion = Option.none();
 		const [pmBin, ...pmArgs] = pmExecArgs(pmType, definition.name);
 		if (definition.versionExtractor._tag !== "None") {
 			const flag = definition.versionExtractor.flag;
-			const localOutput = yield* Effect.provideService(tryString(Command.make(pmBin, ...pmArgs, flag)), CommandExecutor.CommandExecutor, executor);
+			const localOutput = yield* tryString(spawner, ChildProcess.make(pmBin, [...pmArgs, flag]));
 			if (Option.isSome(localOutput)) {
 				localExists = true;
 				localVersion = extractVersion(localOutput, definition.versionExtractor);
 			}
-		} else localExists = yield* Effect.provideService(tryExists(Command.make(pmBin, ...pmArgs, "--version")), CommandExecutor.CommandExecutor, executor);
+		} else localExists = yield* tryExists(spawner, ChildProcess.make(pmBin, [...pmArgs, "--version"]));
 		if (!globalExists && !localExists) return yield* Effect.fail(new ToolResolutionError({
 			name: definition.name,
 			reason: "Tool not found globally or locally"
@@ -209,15 +210,15 @@ const ToolDiscoveryLive = Layer.effect(ToolDiscovery, Effect.gen(function* () {
 		reason: message ?? err.reason
 	})));
 	const isAvailable = (definition) => Effect.gen(function* () {
-		if (yield* Effect.provideService(tryExists(Command.make("sh", "-c", `command -v ${definition.name}`)), CommandExecutor.CommandExecutor, executor)) return true;
+		if (yield* tryExists(spawner, ChildProcess.make("sh", ["-c", `command -v ${definition.name}`]))) return true;
 		const rootResult = yield* wsRoot.find(process.cwd()).pipe(Effect.option);
 		if (Option.isNone(rootResult)) return false;
 		const pmResult = yield* pmDetector.detect(rootResult.value).pipe(Effect.option);
 		if (Option.isNone(pmResult)) return false;
-		const pmType = pmResult.value.type;
+		const pmType = pmResult.value.name;
 		const probeFlag = definition.versionExtractor._tag !== "None" ? definition.versionExtractor.flag : "--version";
 		const [pmBin, ...pmArgs] = pmExecArgs(pmType, definition.name);
-		return yield* Effect.provideService(tryExists(Command.make(pmBin, ...pmArgs, probeFlag)), CommandExecutor.CommandExecutor, executor);
+		return yield* tryExists(spawner, ChildProcess.make(pmBin, [...pmArgs, probeFlag]));
 	});
 	return {
 		resolve,

package/services/VersioningStrategy.js

@@ -19,7 +19,7 @@ import { Context, Effect, Layer } from "effect";
 *   }).pipe(
 *     Effect.provide(VersioningStrategyLive),
 *     Effect.provide(ChangesetConfigReaderLive),
-*     Effect.provide(NodeContext.layer),
+*     Effect.provide(NodeServices.layer),
 *   )
 * );
 * ```
@@ -27,7 +27,7 @@ import { Context, Effect, Layer } from "effect";
 * @since 0.1.0
 * @public
 */
-var VersioningStrategy = class extends Context.Tag("@savvy-web/silk-effects/VersioningStrategy")() {};
+var VersioningStrategy = class extends Context.Service()("@savvy-web/silk-effects/VersioningStrategy") {};
 /**
 * Live implementation of {@link VersioningStrategy}.
 *

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.9"
+      "packageVersion": "7.58.10"
     }
   ]
 }

package/turbo/schemas/DryRun.js

@@ -5,9 +5,9 @@ import { Schema } from "effect";
 const TurboCache = Schema.Struct({
 	local: Schema.Boolean,
 	remote: Schema.Boolean,
-	status: Schema.Literal("HIT", "MISS"),
+	status: Schema.Literals(["HIT", "MISS"]),
 	timeSaved: Schema.Number
-}).annotations({ identifier: "TurboCache" });
+}).annotate({ identifier: "TurboCache" });
 /** turbo's environment-variable contribution block (per-task and global). */
 const TurboEnvVars = Schema.Struct({
 	specified: Schema.Struct({
@@ -17,7 +17,7 @@ const TurboEnvVars = Schema.Struct({
 	configured: Schema.Array(Schema.String),
 	inferred: Schema.Array(Schema.String),
 	passthrough: Schema.NullOr(Schema.Array(Schema.String))
-}).annotations({ identifier: "TurboEnvVars" });
+}).annotate({ identifier: "TurboEnvVars" });
 /** A single task entry from `turbo run <task> --dry=json`. */
 const TurboDryTask = Schema.Struct({
 	taskId: Schema.String,
@@ -25,33 +25,27 @@ const TurboDryTask = Schema.Struct({
 	package: Schema.String,
 	directory: Schema.String,
 	hash: Schema.String,
-	inputs: Schema.Record({
-		key: Schema.String,
-		value: Schema.String
-	}),
+	inputs: Schema.Record(Schema.String, Schema.String),
 	hashOfExternalDependencies: Schema.String,
 	cache: TurboCache,
 	dependencies: Schema.Array(Schema.String),
 	dependents: Schema.Array(Schema.String),
 	environmentVariables: TurboEnvVars
-}).annotations({ identifier: "TurboDryTask" });
+}).annotate({ identifier: "TurboDryTask" });
 /** The `globalCacheInputs` block — the components of the global hash. */
 const TurboGlobalCacheInputs = Schema.Struct({
 	rootKey: Schema.String,
-	files: Schema.Record({
-		key: Schema.String,
-		value: Schema.String
-	}),
+	files: Schema.Record(Schema.String, Schema.String),
 	hashOfExternalDependencies: Schema.String,
 	hashOfInternalDependencies: Schema.String,
 	environmentVariables: TurboEnvVars
-}).annotations({ identifier: "TurboGlobalCacheInputs" });
+}).annotate({ identifier: "TurboGlobalCacheInputs" });
 /** The subset of `turbo run <task> --dry=json` the Turbo namespace reads. */
 const TurboDryRun = Schema.Struct({
 	turboVersion: Schema.String,
 	globalCacheInputs: TurboGlobalCacheInputs,
 	tasks: Schema.Array(TurboDryTask)
-}).annotations({ identifier: "TurboDryRun" });
+}).annotate({ identifier: "TurboDryRun" });
 
 //#endregion
 export { TurboCache, TurboDryRun, TurboDryTask, TurboEnvVars, TurboGlobalCacheInputs };

package/turbo/schemas/results.js

@@ -6,9 +6,9 @@ const PackageCacheStatus = Schema.Struct({
 	package: Schema.String,
 	taskId: Schema.String,
 	hash: Schema.String,
-	status: Schema.Literal("HIT", "MISS"),
+	status: Schema.Literals(["HIT", "MISS"]),
 	timeSaved: Schema.Number
-}).annotations({ identifier: "PackageCacheStatus" });
+}).annotate({ identifier: "PackageCacheStatus" });
 /** The hash-contributor breakdown explaining a single MISS. */
 const MissExplanation = Schema.Struct({
 	package: Schema.String,
@@ -18,7 +18,7 @@ const MissExplanation = Schema.Struct({
 	hashedEnvVars: Schema.Array(Schema.String),
 	externalDependenciesHash: Schema.String,
 	dependsOn: Schema.Array(Schema.String)
-}).annotations({ identifier: "MissExplanation" });
+}).annotate({ identifier: "MissExplanation" });
 /** Global-hash component summary (every task inherits this). */
 const GlobalHashSummary = Schema.Struct({
 	rootKey: Schema.String,
@@ -26,7 +26,7 @@ const GlobalHashSummary = Schema.Struct({
 	externalDependenciesHash: Schema.String,
 	internalDependenciesHash: Schema.String,
 	globalEnvVars: Schema.Array(Schema.String)
-}).annotations({ identifier: "GlobalHashSummary" });
+}).annotate({ identifier: "GlobalHashSummary" });
 /** Result of `TurboInspector.diagnoseCache`. */
 const CacheDiagnosis = Schema.Struct({
 	task: Schema.String,
@@ -36,26 +36,26 @@ const CacheDiagnosis = Schema.Struct({
 	statuses: Schema.Array(PackageCacheStatus),
 	explanations: Schema.Array(MissExplanation),
 	global: GlobalHashSummary
-}).annotations({ identifier: "CacheDiagnosis" });
+}).annotate({ identifier: "CacheDiagnosis" });
 /** One node in the task graph. */
 const GraphNode = Schema.Struct({
 	taskId: Schema.String,
 	package: Schema.String,
 	dependsOn: Schema.Array(Schema.String)
-}).annotations({ identifier: "GraphNode" });
+}).annotate({ identifier: "GraphNode" });
 /** Result of `TurboInspector.taskGraph`. */
 const TaskGraphResult = Schema.Struct({
 	task: Schema.optional(Schema.String),
 	nodeCount: Schema.Number,
 	nodes: Schema.Array(GraphNode),
 	criticalPath: Schema.Array(Schema.String)
-}).annotations({ identifier: "TaskGraphResult" });
+}).annotate({ identifier: "TaskGraphResult" });
 /** Result of `TurboInspector.affected`. */
 const AffectedResult = Schema.Struct({
 	base: Schema.String,
 	packages: Schema.Array(Schema.String),
 	dependents: Schema.Array(Schema.String)
-}).annotations({ identifier: "AffectedResult" });
+}).annotate({ identifier: "AffectedResult" });
 
 //#endregion
 export { AffectedResult, CacheDiagnosis, GlobalHashSummary, GraphNode, MissExplanation, PackageCacheStatus, TaskGraphResult };

package/turbo/services/TurboInspector.js

@@ -3,8 +3,9 @@ import { ToolDiscovery } from "../../services/ToolDiscovery.js";
 import { TurboDigest } from "../digest.js";
 import { DryRunParseError, NotATurboRepoError, TurboExecError, TurboNotInstalledError } from "../errors.js";
 import { TurboDryRun } from "../schemas/DryRun.js";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Command, CommandExecutor, FileSystem } from "@effect/platform";
+import { Context, Effect, FileSystem, Layer, Schema } from "effect";
+import { Git } from "@effected/git";
+import { ChildProcessSpawner } from "effect/unstable/process";
 
 //#region src/turbo/services/TurboInspector.ts
 /**
@@ -18,7 +19,7 @@ import { Command, CommandExecutor, FileSystem } from "@effect/platform";
 *
 * @since 0.7.0
 */
-var TurboInspector = class extends Context.Tag("@savvy-web/silk-effects/TurboInspector")() {};
+var TurboInspector = class extends Context.Service()("@savvy-web/silk-effects/TurboInspector") {};
 const TURBO = ToolDefinition.make({ name: "turbo" });
 /** Default task used by {@link TurboInspector.taskGraph} and {@link TurboInspector.affected}. */
 const DEFAULT_BUILD_TASK = "build:dev";
@@ -29,41 +30,51 @@ const DEFAULT_AFFECTED_BASE = "main";
 *
 * @remarks
 * Requires {@link ToolDiscovery} to resolve the `turbo` binary, plus
-* `CommandExecutor` and `FileSystem` from `@effect/platform`. Mirrors
-* `ToolDiscoveryLive`: the executor is captured at layer construction and
-* discharged onto each command effect with `Effect.provideService`, keeping
-* the public method effects at `R = never`.
+* `ChildProcessSpawner` and `FileSystem` from core (provide `NodeServices.layer`
+* at the app edge) and `Git` from `@effected/git`. Mirrors `ToolDiscoveryLive`:
+* the spawner is captured at layer construction and discharged onto each command
+* effect with `Effect.provideService`, keeping the public method effects at
+* `R = never`.
 *
 * @since 0.7.0
 */
 const TurboInspectorLive = Layer.effect(TurboInspector, Effect.gen(function* () {
 	const discovery = yield* ToolDiscovery;
-	const executor = yield* CommandExecutor.CommandExecutor;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 	const fs = yield* FileSystem.FileSystem;
+	const git = yield* Git;
 	const runTurbo = (cwd, args, env) => discovery.require(TURBO).pipe(Effect.mapError((e) => new TurboNotInstalledError({ reason: e.reason })), Effect.flatMap((resolved) => {
 		const command = resolved.exec(...args).workingDirectory(cwd);
-		return Effect.provideService((env ? command.env(env) : command).string(), CommandExecutor.CommandExecutor, executor).pipe(Effect.mapError((e) => new TurboExecError({
+		return Effect.provideService((env ? command.env(env) : command).string(), ChildProcessSpawner.ChildProcessSpawner, spawner).pipe(Effect.mapError((e) => new TurboExecError({
 			args: [...args],
 			reason: String(e)
 		})));
 	}));
-	/** Run a read-only `git` command in `cwd` and return its non-empty output lines. */
-	const runGit = (cwd, args) => Effect.provideService(Command.string(Command.workingDirectory(Command.make("git", ...args), cwd)), CommandExecutor.CommandExecutor, executor).pipe(Effect.mapError((e) => new TurboExecError({
-		args: ["git", ...args],
-		reason: String(e)
-	})), Effect.map((stdout) => stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0)));
-	const ensureTurboRepo = (cwd) => fs.exists(`${cwd}/turbo.json`).pipe(Effect.catchAll(() => Effect.succeed(false)), Effect.flatMap((ok) => ok ? Effect.void : Effect.fail(new NotATurboRepoError({ cwd }))));
+	/** The paths changed between `base` and HEAD, via `@effected/git`. */
+	const changedPaths = (cwd, base) => git.changedFiles(cwd, {
+		base,
+		head: "HEAD"
+	}).pipe(Effect.mapError((e) => new TurboExecError({
+		args: [
+			"git",
+			"diff",
+			"--name-only",
+			`${base}...HEAD`
+		],
+		reason: e.message
+	})));
+	const ensureTurboRepo = (cwd) => fs.exists(`${cwd}/turbo.json`).pipe(Effect.catch(() => Effect.succeed(false)), Effect.flatMap((ok) => ok ? Effect.void : Effect.fail(new NotATurboRepoError({ cwd }))));
 	const dryRun = (task, cwd, args, env) => ensureTurboRepo(cwd).pipe(Effect.flatMap(() => runTurbo(cwd, args, env)), Effect.flatMap((stdout) => Effect.try({
 		try: () => JSON.parse(stdout),
 		catch: (e) => new DryRunParseError({
 			task,
 			reason: `invalid JSON: ${String(e)}`
 		})
-	})), Effect.flatMap((json) => Schema.decodeUnknown(TurboDryRun)(json).pipe(Effect.mapError((e) => new DryRunParseError({
+	})), Effect.flatMap((json) => Schema.decodeUnknownEffect(TurboDryRun)(json).pipe(Effect.mapError((e) => new DryRunParseError({
 		task,
 		reason: String(e)
 	})))));
-	return TurboInspector.of({
+	return {
 		diagnoseCache: (task, cwd) => dryRun(task, cwd, [
 			"run",
 			task,
@@ -80,11 +91,7 @@ const TurboInspectorLive = Layer.effect(TurboInspector, Effect.gen(function* ()
 		affected: (cwd, base) => {
 			const ref = base ?? DEFAULT_AFFECTED_BASE;
 			return Effect.all({
-				changedFiles: runGit(cwd, [
-					"diff",
-					"--name-only",
-					`${ref}...HEAD`
-				]),
+				changedFiles: changedPaths(cwd, ref),
 				dry: dryRun(`${DEFAULT_BUILD_TASK} --affected`, cwd, [
 					"run",
 					DEFAULT_BUILD_TASK,
@@ -93,7 +100,7 @@ const TurboInspectorLive = Layer.effect(TurboInspector, Effect.gen(function* ()
 				], { TURBO_SCM_BASE: ref })
 			}).pipe(Effect.map(({ changedFiles, dry }) => TurboDigest.affected(ref, changedFiles, dry)));
 		}
-	});
+	};
 }));
 
 //#endregion

package/utils/ToolCommand.js

@@ -1,10 +1,26 @@
-import { Command } from "@effect/platform";
+import { Effect, Stream } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 
 //#region src/utils/ToolCommand.ts
 /**
-* Wraps `@effect/platform` `Command.Command` with instance method ergonomics.
+* Rebuild a command with patched options.
 *
-* Use `yield* cmd.string()` instead of `yield* Command.string(cmd)`.
+* @remarks
+* `ChildProcess.Command` values are pure data, but core only ships setters for
+* `cwd` and `env`. This helper rebuilds a `StandardCommand` with merged
+* options, recursing into both sides of a `PipedCommand` the same way
+* `ChildProcess.setCwd` does.
+*/
+const patchOptions = (command, patch) => {
+	switch (command._tag) {
+		case "StandardCommand": return ChildProcess.make(command.command, command.args, patch(command.options));
+		case "PipedCommand": return ChildProcess.pipeTo(patchOptions(command.left, patch), patchOptions(command.right, patch), command.options);
+	}
+};
+/**
+* Wraps `effect/unstable/process` `ChildProcess.Command` with instance method ergonomics.
+*
+* Use `yield* cmd.string()` instead of resolving the `ChildProcessSpawner` service by hand.
 *
 * @since 0.2.0
 * @public
@@ -14,26 +30,36 @@ var ToolCommand = class ToolCommand {
 	constructor(command) {
 		this.command = command;
 	}
-	string(encoding) {
-		return Command.string(this.command, encoding);
+	string() {
+		return Effect.flatMap(ChildProcessSpawner.ChildProcessSpawner, (spawner) => spawner.string(this.command));
 	}
 	exitCode() {
-		return Command.exitCode(this.command);
+		return Effect.flatMap(ChildProcessSpawner.ChildProcessSpawner, (spawner) => spawner.exitCode(this.command));
 	}
-	lines(encoding) {
-		return Command.lines(this.command, encoding);
+	lines() {
+		return Effect.flatMap(ChildProcessSpawner.ChildProcessSpawner, (spawner) => spawner.lines(this.command));
 	}
 	stream() {
-		return Command.stream(this.command);
+		return Stream.unwrap(Effect.map(ChildProcessSpawner.ChildProcessSpawner, (spawner) => spawner.streamString(this.command)));
 	}
 	env(environment) {
-		return new ToolCommand(Command.env(this.command, environment));
+		return new ToolCommand(patchOptions(this.command, (options) => ({
+			...options,
+			env: {
+				...options.env,
+				...environment
+			},
+			extendEnv: true
+		})));
 	}
 	workingDirectory(cwd) {
-		return new ToolCommand(Command.workingDirectory(this.command, cwd));
+		return new ToolCommand(ChildProcess.setCwd(this.command, cwd));
 	}
 	stdin(input) {
-		return new ToolCommand(Command.feed(this.command, input));
+		return new ToolCommand(patchOptions(this.command, (options) => ({
+			...options,
+			stdin: Stream.succeed(new TextEncoder().encode(input))
+		})));
 	}
 };