@savvy-web/silk-effects 1.5.2 → 2.0.0

package/changesets/services/deps-regen.js

@@ -0,0 +1,367 @@
+import { ChangesetIOError } from "../errors.js";
+import { serializeDependencyTableToMarkdown, sortDependencyRows } from "../utils/dependency-table.js";
+import { ChangesetConfigReaderLive } from "../../services/ChangesetConfigReader.js";
+import { ChangesetConfig, ChangesetConfigLive } from "../../services/ChangesetConfig.js";
+import { PublishabilityDetectorAdaptiveLive } from "../../services/SilkPublishability.js";
+import { ConfigInspector, ConfigInspectorLive } from "./config-inspector.js";
+import { computeWorkspaceDependencyDiffs } from "../utils/dep-diff.js";
+import { gitMergeBase } from "../utils/git.js";
+import { listPublishablePackageNames } from "../utils/publishability.js";
+import { Context, Effect, Layer, Option } from "effect";
+import { join, resolve } from "node:path";
+import { FileSystem } from "@effect/platform";
+import { PointInTimeWorkspace, PointInTimeWorkspaceLive, PublishabilityDetector, WorkspaceDiscovery, WorkspaceDiscoveryLive, WorkspaceRootLive } from "workspaces-effect";
+
+//#region src/changesets/services/deps-regen.ts
+/**
+* `Changesets.DepsRegen` service — lift the `deps regen` / `deps detect`
+* orchestration out of the CLI into a `Context.Tag` service with a
+* `plan()` / `execute()` split.
+*
+* @remarks
+* `plan()` computes the cumulative dependency diff (merge-base → working
+* tree by default, or between two explicit refs) by snapshotting both
+* sides through `PointInTimeWorkspace`, which resolves `catalog:` /
+* `workspace:` specifiers against each ref's own catalogs and package
+* versions before diffing. It drops `devDependency` rows (unless
+* `includeDevDeps`), and returns a complete {@link RegenPlan}
+* (target filenames + stale-changeset deletes) WITHOUT touching the
+* filesystem. `execute()` applies a plan — writing the fresh changesets
+* first, then deleting the stale pure-dependency ones (so an interrupted
+* run loses nothing and is safely re-runnable).
+*
+* This is the single source of truth for regen/detect: the CLI commands
+* and MCP tools are thin adapters over this service.
+*
+* @see {@link DepsRegen} for the service tag
+* @see {@link DepsRegenLive} for the production layer
+*
+*/
+const ADJECTIVES = [
+	"brave",
+	"clever",
+	"swift",
+	"silver",
+	"lucky",
+	"happy",
+	"calm",
+	"bright",
+	"quiet",
+	"wild"
+];
+const NOUNS = [
+	"dogs",
+	"cats",
+	"wolves",
+	"foxes",
+	"cups",
+	"ships",
+	"trees",
+	"owls",
+	"cranes",
+	"hills"
+];
+const VERBS = [
+	"laugh",
+	"dream",
+	"fly",
+	"sing",
+	"dance",
+	"wander",
+	"soar",
+	"rest",
+	"leap",
+	"ponder"
+];
+function pickRandomTriplet() {
+	return `${ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)]}-${NOUNS[Math.floor(Math.random() * NOUNS.length)]}-${VERBS[Math.floor(Math.random() * VERBS.length)]}`;
+}
+/**
+* Pick a `<adjective>-<noun>-<verb>` filename slug that does not collide
+* with an existing `.changeset/*.md` OR with a slug already claimed
+* earlier in the same {@link RegenPlan.toWrite} computation. `plan()`
+* never writes to disk, so an on-disk existence check alone cannot see
+* slugs chosen moments earlier in the same call — the `chosen` set closes
+* that gap. The triplet space is 1,000 combinations, so a busy repo can
+* plausibly exhaust it across runs; fall back to a timestamp suffix after
+* 20 unlucky picks.
+*
+* @param fileExists - Effectful on-disk existence check (never fails; a
+*   filesystem error is treated as "does not exist" so filename selection
+*   degrades gracefully rather than blocking the plan).
+* @param changesetDir - Directory checked for on-disk collisions.
+* @param chosen - Basenames (without extension) already picked within this plan;
+*   the picked candidate is added to this set before returning.
+* @internal
+*/
+function randomFilename(fileExists, changesetDir, chosen) {
+	return Effect.gen(function* () {
+		for (let i = 0; i < 20; i++) {
+			const candidate = pickRandomTriplet();
+			if (!chosen.has(candidate) && !(yield* fileExists(join(changesetDir, `${candidate}.md`)))) {
+				chosen.add(candidate);
+				return candidate;
+			}
+		}
+		let attempt = 0;
+		let fallback = `${pickRandomTriplet()}-${Date.now()}`;
+		while (chosen.has(fallback) || (yield* fileExists(join(changesetDir, `${fallback}.md`)))) fallback = `${pickRandomTriplet()}-${Date.now()}-${++attempt}`;
+		chosen.add(fallback);
+		return fallback;
+	});
+}
+/**
+* Strict detection of "pure dependency changesets" per the documented
+* rules: single-package frontmatter, single `## Dependencies` heading,
+* no other body content beyond that section.
+*
+* @param content - Raw `.changeset/*.md` file contents.
+* @returns `{ isPure, package }` — `isPure` is `true` only for a
+*   single-package, Dependencies-only changeset; `package` is the sole
+*   frontmatter package name (or `null` when not pure).
+*
+* @public
+*/
+function isPureDependencyChangeset(content) {
+	const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+	if (!fmMatch) return {
+		isPure: false,
+		package: null
+	};
+	const frontmatter = fmMatch[1];
+	const body = (fmMatch[2] ?? "").trim();
+	const fmLines = frontmatter.split(/\r?\n/).filter((l) => l.trim().length > 0 && !/^\s*#/.test(l));
+	if (fmLines.length !== 1) return {
+		isPure: false,
+		package: null
+	};
+	const pkgMatch = fmLines[0].match(/^\s*["']?([^"':\s]+)["']?\s*:\s*([a-z]+)\s*$/);
+	if (!pkgMatch) return {
+		isPure: false,
+		package: null
+	};
+	const pkg = pkgMatch[1];
+	const bodyTrimmed = body.replace(/^\s+/, "");
+	if (!/^## Dependencies\b/.test(bodyTrimmed)) return {
+		isPure: false,
+		package: null
+	};
+	if ((bodyTrimmed.match(/^## /gm) ?? []).length !== 1) return {
+		isPure: false,
+		package: null
+	};
+	if (/^# /m.test(bodyTrimmed)) return {
+		isPure: false,
+		package: null
+	};
+	return {
+		isPure: true,
+		package: pkg
+	};
+}
+/**
+* List `.changeset/*.md` files (excluding `README.md`) in `changesetDir`.
+* A missing directory is today's behavior for "no changesets yet" and
+* resolves to an empty list; any OTHER failure (e.g. a directory that
+* exists but cannot be read) is a loud {@link ChangesetIOError} — an
+* unreadable `.changeset` dir must not silently masquerade as "no
+* changesets".
+*/
+const listChangesetFiles = (fs, changesetDir) => fs.readDirectory(changesetDir).pipe(Effect.map((names) => names.filter((f) => f.endsWith(".md") && f !== "README.md").map((f) => join(changesetDir, f))), Effect.catchAll((e) => e._tag === "SystemError" && e.reason === "NotFound" ? Effect.succeed([]) : Effect.fail(new ChangesetIOError({
+	path: changesetDir,
+	operation: "list",
+	reason: String(e)
+}))));
+/**
+* Pure-dependency changesets found in `changesetDir`. An individual file
+* that cannot be read (e.g. removed mid-scan, permission race) is skipped —
+* today's semantics — while a failure to list the directory itself
+* propagates as a loud {@link ChangesetIOError}.
+*/
+const findPureDependencyChangesets = (fs, changesetDir) => Effect.gen(function* () {
+	const files = yield* listChangesetFiles(fs, changesetDir);
+	const result = [];
+	for (const file of files) {
+		const content = yield* fs.readFileString(file).pipe(Effect.option);
+		if (Option.isNone(content)) continue;
+		const detection = isPureDependencyChangeset(content.value);
+		if (detection.isPure && detection.package) result.push({
+			file,
+			package: detection.package
+		});
+	}
+	return result;
+});
+/**
+* Mixed dependency changesets (have a `## Dependencies` heading but fail
+* the strict pure-changeset test) found in `changesetDir`. Same
+* skip-unreadable-file / loud-list-failure semantics as
+* {@link findPureDependencyChangesets}.
+*/
+const findMixedDependencyChangesets = (fs, changesetDir) => Effect.gen(function* () {
+	const files = yield* listChangesetFiles(fs, changesetDir);
+	const result = [];
+	for (const file of files) {
+		const content = yield* fs.readFileString(file).pipe(Effect.option);
+		if (Option.isNone(content)) continue;
+		if (/^## Dependencies\b/m.test(content.value) && !isPureDependencyChangeset(content.value).isPure) result.push(file);
+	}
+	return result;
+});
+/**
+* Render a single-package, patch-bump changeset for a diff whose rows are
+* already resolved (per-side, inside {@link computeWorkspaceDependencyDiffs})
+* and devDep-filtered.
+*/
+function renderChangesetContent(diff) {
+	return `${`---\n"${diff.package}": patch\n---`}\n\n## Dependencies\n\n${serializeDependencyTableToMarkdown([...diff.rows])}\n`;
+}
+const _tag = Context.Tag("Changesets/DepsRegen");
+/**
+* @internal
+*/
+const DepsRegenBase = _tag();
+/**
+* Effect service tag for {@link DepsRegenShape}.
+*
+* @example
+* ```typescript
+* import { Effect } from "effect";
+* import { Changesets } from "@savvy-web/silk-effects";
+*
+* const program = Effect.gen(function* () {
+*   const svc = yield* Changesets.DepsRegen;
+*   const plan = yield* svc.plan({ cwd: process.cwd() });
+*   return yield* svc.execute(plan);
+* });
+* ```
+*
+* @public
+*/
+var DepsRegen = class extends DepsRegenBase {};
+/**
+* Build a {@link DepsRegenShape} that closes over already-resolved service
+* implementations, keeping the public `plan`/`execute` signatures
+* requirement-free (`R = never`).
+*/
+function makeShape(pit, inspector, discovery, detector, config, fs) {
+	const provideDetector = Layer.succeed(PublishabilityDetector, detector);
+	const fileExists = (p) => fs.exists(p).pipe(Effect.orElseSucceed(() => false));
+	const plan = (options) => Effect.gen(function* () {
+		const resolvedCwd = resolve(options.cwd);
+		const changesetDir = join(resolvedCwd, ".changeset");
+		let fromRef = options.from;
+		if (!fromRef) {
+			let baseBranch = options.base;
+			if (!baseBranch) baseBranch = (yield* inspector.inspect(resolvedCwd).pipe(Effect.catchTag("ConfigurationError", () => Effect.succeed({ baseBranch: "main" })))).baseBranch;
+			fromRef = yield* gitMergeBase(resolvedCwd, baseBranch);
+		}
+		const rawDiffs = computeWorkspaceDependencyDiffs(yield* pit.at(fromRef, { cwd: resolvedCwd }), options.to ? yield* pit.at(options.to, { cwd: resolvedCwd }) : yield* pit.worktree({ cwd: resolvedCwd }));
+		const targetPkg = options.package;
+		const livePackages = yield* discovery.listPackages(resolvedCwd);
+		const publishable = yield* listPublishablePackageNames(livePackages, resolvedCwd).pipe(Effect.provide(provideDetector));
+		const versionPrivate = yield* config.versionPrivate(resolvedCwd);
+		const inScope = /* @__PURE__ */ new Set();
+		for (const pkg of livePackages) {
+			if (yield* config.isIgnored(pkg.name, resolvedCwd)) continue;
+			if (publishable.has(pkg.name) || versionPrivate) inScope.add(pkg.name);
+		}
+		const targetIgnored = targetPkg ? yield* config.isIgnored(targetPkg, resolvedCwd) : false;
+		const keepDevDeps = options.includeDevDeps === true;
+		const scoped = targetPkg ? targetIgnored ? [] : rawDiffs.filter((d) => d.package === targetPkg) : rawDiffs.filter((d) => inScope.has(d.package));
+		const resolved = [];
+		for (const diff of scoped) {
+			const rows = keepDevDeps ? [...diff.rows] : diff.rows.filter((r) => r.type !== "devDependency");
+			if (rows.length > 0) resolved.push({
+				...diff,
+				rows: sortDependencyRows(rows)
+			});
+		}
+		const existingPure = yield* findPureDependencyChangesets(fs, changesetDir);
+		const skippedMixed = yield* findMixedDependencyChangesets(fs, changesetDir);
+		const toDelete = targetPkg ? targetIgnored ? [] : existingPure.filter((p) => p.package === targetPkg) : existingPure.filter((p) => inScope.has(p.package));
+		const chosenFilenames = /* @__PURE__ */ new Set();
+		const toWrite = [];
+		for (const diff of resolved) {
+			const filename = yield* randomFilename(fileExists, changesetDir, chosenFilenames);
+			toWrite.push({
+				file: join(changesetDir, `${filename}.md`),
+				package: diff.package,
+				diff
+			});
+		}
+		return {
+			toDelete,
+			toWrite,
+			skippedMixed
+		};
+	});
+	const execute = (plan) => Effect.gen(function* () {
+		const deleted = [];
+		const written = [];
+		for (const entry of plan.toWrite) {
+			yield* fs.writeFileString(entry.file, renderChangesetContent(entry.diff)).pipe(Effect.mapError((e) => new ChangesetIOError({
+				path: entry.file,
+				operation: "write",
+				reason: String(e)
+			})));
+			written.push(entry.file);
+		}
+		for (const entry of plan.toDelete) if (yield* Effect.isSuccess(fs.remove(entry.file))) deleted.push(entry.file);
+		return {
+			deleted,
+			written,
+			skippedMixed: plan.skippedMixed
+		};
+	});
+	return {
+		plan,
+		execute
+	};
+}
+/**
+* Live layer for {@link DepsRegen}.
+*
+* Requires `PointInTimeWorkspace`, `WorkspaceDiscovery`,
+* `PublishabilityDetector` (all from `workspaces-effect`),
+* {@link ConfigInspector}, {@link ChangesetConfig}, and
+* `FileSystem.FileSystem` (resolved once at construction and closed over by
+* the shape, keeping `plan`/`execute` themselves requirement-free).
+*
+* @public
+*/
+const DepsRegenLive = Layer.effect(DepsRegen, Effect.gen(function* () {
+	return makeShape(yield* PointInTimeWorkspace, yield* ConfigInspector, yield* WorkspaceDiscovery, yield* PublishabilityDetector, yield* ChangesetConfig, yield* FileSystem.FileSystem);
+}));
+const WorkspaceGraph = Layer.mergeAll(WorkspaceRootLive, WorkspaceDiscoveryLive.pipe(Layer.provide(WorkspaceRootLive)));
+const ConfigGraph = ChangesetConfigLive.pipe(Layer.provide(ChangesetConfigReaderLive));
+/**
+* Batteries-included {@link DepsRegen} layer: silk's opinionated default
+* composition of the full dependency graph. Only the platform services
+* remain — note that {@link PointInTimeWorkspace} reads git history, so
+* this layer genuinely requires `CommandExecutor` in addition to
+* `FileSystem`/`Path`: provide a git-capable platform layer
+* (`NodeContext.layer`), not a bare filesystem-only layer.
+*
+* Gating uses silk's adaptive publishability detector
+* ({@link PublishabilityDetectorAdaptiveLive}), so the default semantics
+* are "versionable minus ignored" — identical to the savvy CLI and MCP
+* runtimes. Consumers who need to swap any dependency (test detectors,
+* alternate config sources) should keep composing {@link DepsRegenLive}
+* directly; this layer is purely additive.
+*
+* @example
+* ```typescript
+* import { NodeContext } from "@effect/platform-node";
+* import { Layer } from "effect";
+* import { Changesets } from "@savvy-web/silk-effects";
+*
+* const depsRegen = Changesets.DepsRegenDefault.pipe(Layer.provide(NodeContext.layer));
+* ```
+*
+* @public
+*/
+const DepsRegenDefault = DepsRegenLive.pipe(Layer.provide(PointInTimeWorkspaceLive.pipe(Layer.provide(WorkspaceGraph))), Layer.provide(ConfigInspectorLive.pipe(Layer.provide(Layer.mergeAll(ChangesetConfigReaderLive, WorkspaceGraph)))), Layer.provide(PublishabilityDetectorAdaptiveLive.pipe(Layer.provide(ConfigGraph))), Layer.provide(ConfigGraph), Layer.provide(WorkspaceGraph));
+
+//#endregion
+export { DepsRegen, DepsRegenBase, DepsRegenDefault, DepsRegenLive, isPureDependencyChangeset };

package/changesets/services/release-planner.js

@@ -3,9 +3,8 @@ import { ChangelogTransformer } from "../api/transformer.js";
 import { ConfigInspector } from "./config-inspector.js";
 import { VersionFiles } from "../utils/version-files.js";
 import { Context, Effect, Layer } from "effect";
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
-import { tmpdir } from "node:os";
+import { FileSystem } from "@effect/platform";
 import applyReleasePlan from "@changesets/apply-release-plan";
 import { read } from "@changesets/config";
 import getReleasePlan from "@changesets/get-release-plan";
@@ -37,8 +36,8 @@ const _tag = Context.Tag("ReleasePlanner");
 const ReleasePlannerBase = _tag();
 /** Effect service tag for the release planner. @public */
 var ReleasePlanner = class extends ReleasePlannerBase {};
-/** Build the service shape over a resolved {@link ConfigInspector}. */
-function makeShape(inspector) {
+/** Build the service shape over a resolved {@link ConfigInspector} and {@link FileSystem.FileSystem}. */
+function makeShape(inspector, fs) {
 	const plan = (root) => Effect.tryPromise({
 		try: () => getReleasePlan(root),
 		catch: (e) => new ReleasePlanError({
@@ -46,23 +45,17 @@ function makeShape(inspector) {
 			reason: errMsg(e)
 		})
 	});
-	const preview = (root) => Effect.tryPromise({
-		try: () => previewImpl(root),
-		catch: (e) => new ReleasePlanError({
-			phase: "preview",
-			reason: errMsg(e)
-		})
-	});
-	const apply = (root, options) => applyEffect(root, options?.dryRun ?? false, inspector);
+	const preview = (root) => previewEffect(root, fs);
+	const apply = (root, options) => applyEffect(root, options?.dryRun ?? false, inspector, fs);
 	return {
 		plan,
 		preview,
 		apply
 	};
 }
-/** Production layer. Requires {@link ConfigInspector} (used by `apply`). @public */
+/** Production layer. Requires {@link ConfigInspector} (used by `apply`) and `FileSystem`. @public */
 const ReleasePlannerLive = Layer.effect(ReleasePlanner, Effect.gen(function* () {
-	return makeShape(yield* ConfigInspector);
+	return makeShape(yield* ConfigInspector, yield* FileSystem.FileSystem);
 }));
 /**
 * Test factory — supply fixed results for any subset of methods. Unsupplied
@@ -93,31 +86,52 @@ function extractVersionBlock(changelog, version) {
 	}
 	return lines.slice(start, end).join("\n").trim();
 }
-async function previewImpl(root) {
-	const [plan, packages] = await Promise.all([getReleasePlan(root), buildPackages(root)]);
-	const config = await read(root, packages);
-	const preMode = plan.preState ? plan.preState.mode : null;
-	const changesets = plan.changesets.map((cs) => ({
-		id: cs.id,
-		summary: cs.summary,
-		releases: cs.releases.filter((r) => r.type !== "none").map((r) => ({
-			name: r.name,
-			type: r.type
-		}))
-	}));
-	const releasesToRender = plan.releases.filter((r) => r.type !== "none");
-	if (releasesToRender.length === 0) return {
-		preMode,
-		releases: [],
-		changesets
-	};
-	const tempRoot = mkdtempSync(join(tmpdir(), "silk-preview-"));
-	try {
+/**
+* Render a non-destructive preview by redirecting every write into a
+* scope-managed temp directory (cleaned up automatically when the scope
+* closes) and reading the generated CHANGELOG blocks back.
+*/
+function previewEffect(root, fs) {
+	const program = Effect.gen(function* () {
+		const [plan, packages] = yield* Effect.tryPromise({
+			try: () => Promise.all([getReleasePlan(root), buildPackages(root)]),
+			catch: (e) => new ReleasePlanError({
+				phase: "preview",
+				reason: errMsg(e)
+			})
+		});
+		const config = yield* Effect.tryPromise({
+			try: () => read(root, packages),
+			catch: (e) => new ReleasePlanError({
+				phase: "preview",
+				reason: errMsg(e)
+			})
+		});
+		const preMode = plan.preState ? plan.preState.mode : null;
+		const changesets = plan.changesets.map((cs) => ({
+			id: cs.id,
+			summary: cs.summary,
+			releases: cs.releases.filter((r) => r.type !== "none").map((r) => ({
+				name: r.name,
+				type: r.type
+			}))
+		}));
+		const releasesToRender = plan.releases.filter((r) => r.type !== "none");
+		if (releasesToRender.length === 0) return {
+			preMode,
+			releases: [],
+			changesets
+		};
+		const tempRoot = yield* fs.makeTempDirectoryScoped({ prefix: "silk-preview-" });
 		const mapDir = (dir) => {
 			const rel = relative(packages.root.dir, dir);
-			if (rel.startsWith("..") || isAbsolute(rel)) throw new Error(`Package directory is outside the workspace root: ${dir}`);
-			return join(tempRoot, rel);
+			if (rel.startsWith("..") || isAbsolute(rel)) return Effect.fail(new ReleasePlanError({
+				phase: "preview",
+				reason: `Package directory is outside the workspace root: ${dir}`
+			}));
+			return Effect.succeed(join(tempRoot, rel));
 		};
+		const tempDirs = yield* Effect.forEach(packages.packages, (p) => mapDir(p.dir));
 		const tempPackages = {
 			tool: packages.tool,
 			root: {
@@ -125,26 +139,33 @@ async function previewImpl(root) {
 				dir: tempRoot,
 				packageJson: structuredClone(packages.root.packageJson)
 			},
-			packages: packages.packages.map((p) => ({
+			packages: packages.packages.map((p, i) => ({
 				...p,
-				dir: mapDir(p.dir),
+				dir: tempDirs[i],
 				packageJson: structuredClone(p.packageJson)
 			}))
 		};
-		mkdirSync(join(tempRoot, ".changeset"), { recursive: true });
-		cpSync(join(root, "package.json"), join(tempRoot, "package.json"));
+		yield* fs.makeDirectory(join(tempRoot, ".changeset"), { recursive: true });
+		yield* fs.copyFile(join(root, "package.json"), join(tempRoot, "package.json"));
 		const preJson = join(root, ".changeset", "pre.json");
-		if (existsSync(preJson)) cpSync(preJson, join(tempRoot, ".changeset", "pre.json"));
-		for (const p of packages.packages) {
-			const tDir = mapDir(p.dir);
-			mkdirSync(tDir, { recursive: true });
-			cpSync(join(p.dir, "package.json"), join(tDir, "package.json"));
+		if (yield* fs.exists(preJson)) yield* fs.copyFile(preJson, join(tempRoot, ".changeset", "pre.json"));
+		for (let i = 0; i < packages.packages.length; i++) {
+			const p = packages.packages[i];
+			const tDir = tempDirs[i];
+			yield* fs.makeDirectory(tDir, { recursive: true });
+			yield* fs.copyFile(join(p.dir, "package.json"), join(tDir, "package.json"));
 			const realCl = join(p.dir, "CHANGELOG.md");
-			if (existsSync(realCl)) cpSync(realCl, join(tDir, "CHANGELOG.md"));
+			if (yield* fs.exists(realCl)) yield* fs.copyFile(realCl, join(tDir, "CHANGELOG.md"));
 		}
 		const rootCl = join(packages.root.dir, "CHANGELOG.md");
-		if (existsSync(rootCl)) cpSync(rootCl, join(tempRoot, "CHANGELOG.md"));
-		await applyReleasePlan(plan, tempPackages, config, void 0, root);
+		if (yield* fs.exists(rootCl)) yield* fs.copyFile(rootCl, join(tempRoot, "CHANGELOG.md"));
+		yield* Effect.tryPromise({
+			try: () => applyReleasePlan(plan, tempPackages, config, void 0, root),
+			catch: (e) => new ReleasePlanError({
+				phase: "preview",
+				reason: errMsg(e)
+			})
+		});
 		const dirByName = /* @__PURE__ */ new Map();
 		for (const p of tempPackages.packages) dirByName.set(p.packageJson.name, p.dir);
 		if (tempPackages.root.packageJson.name) dirByName.set(tempPackages.root.packageJson.name, tempRoot);
@@ -153,9 +174,15 @@ async function previewImpl(root) {
 			const dir = dirByName.get(r.name);
 			if (!dir) continue;
 			const clPath = join(dir, "CHANGELOG.md");
-			if (!existsSync(clPath)) continue;
-			ChangelogTransformer.transformFile(clPath);
-			const content = readFileSync(clPath, "utf-8");
+			if (!(yield* fs.exists(clPath))) continue;
+			yield* Effect.try({
+				try: () => ChangelogTransformer.transformFile(clPath),
+				catch: (e) => new ReleasePlanError({
+					phase: "preview",
+					reason: errMsg(e)
+				})
+			});
+			const content = yield* fs.readFileString(clPath);
 			releases.push({
 				name: r.name,
 				type: r.type,
@@ -170,22 +197,17 @@ async function previewImpl(root) {
 			releases,
 			changesets
 		};
-	} finally {
-		rmSync(tempRoot, {
-			recursive: true,
-			force: true
-		});
-	}
+	});
+	return Effect.scoped(program).pipe(Effect.mapError((e) => e instanceof ReleasePlanError ? e : new ReleasePlanError({
+		phase: "preview",
+		reason: errMsg(e)
+	})));
 }
-/** Re-read a package's version from disk (post-bump) to feed versionFiles. */
-function diskVersion(workspaceDir, fallback) {
-	try {
-		return JSON.parse(readFileSync(join(workspaceDir, "package.json"), "utf-8")).version ?? fallback;
-	} catch {
-		return fallback;
-	}
+/** Re-read a package's version from disk (post-bump) to feed versionFiles; unreadable/unparseable falls back. */
+function diskVersion(workspaceDir, fallback, fs) {
+	return fs.readFileString(join(workspaceDir, "package.json")).pipe(Effect.flatMap((raw) => Effect.try(() => JSON.parse(raw).version ?? fallback)), Effect.orElseSucceed(() => fallback));
 }
-function applyEffect(root, dryRun, inspector) {
+function applyEffect(root, dryRun, inspector, fs) {
 	return Effect.gen(function* () {
 		const { plan, packages, config } = yield* Effect.tryPromise({
 			try: async () => {
@@ -222,22 +244,24 @@ function applyEffect(root, dryRun, inspector) {
 		const newVersionByName = new Map(plan.releases.map((r) => [r.name, r.newVersion]));
 		const inspected = yield* inspector.inspect(root).pipe(Effect.catchAll((error) => Effect.logWarning(`Skipping versionFiles update: ${errMsg(error)}`).pipe(Effect.as(null))));
 		let versionFileUpdates = [];
-		if (inspected) versionFileUpdates = yield* Effect.try({
-			try: () => {
-				const scopes = inspected.packages.filter((p) => p.versionFiles.length > 0).map((p) => {
-					const fresh = dryRun ? newVersionByName.get(p.name) ?? p.version : diskVersion(p.workspaceDir, p.version);
-					return fresh !== p.version ? {
-						...p,
-						version: fresh
-					} : p;
-				});
-				return scopes.length > 0 ? VersionFiles.processResolvedVersionFiles(scopes, dryRun) : [];
-			},
-			catch: (e) => new ReleasePlanError({
-				phase: "apply",
-				reason: errMsg(e)
-			})
-		});
+		if (inspected) {
+			const candidates = inspected.packages.filter((p) => p.versionFiles.length > 0);
+			const freshVersions = yield* Effect.forEach(candidates, (p) => dryRun ? Effect.succeed(newVersionByName.get(p.name) ?? p.version) : diskVersion(p.workspaceDir, p.version, fs));
+			const scopes = candidates.map((p, i) => {
+				const fresh = freshVersions[i];
+				return fresh !== p.version ? {
+					...p,
+					version: fresh
+				} : p;
+			});
+			versionFileUpdates = yield* Effect.try({
+				try: () => scopes.length > 0 ? VersionFiles.processResolvedVersionFiles(scopes, dryRun) : [],
+				catch: (e) => new ReleasePlanError({
+					phase: "apply",
+					reason: errMsg(e)
+				})
+			});
+		}
 		return {
 			dryRun,
 			touchedFiles,