@savvy-web/silk 1.1.1 → 1.2.0

package/packages/silk-effects/dist/dev/pkg/changesets/schemas/release-plan.cjs

@@ -0,0 +1,63 @@
+let effect = require("effect");
+
+//#region ../silk-effects/dist/dev/pkg/changesets/schemas/release-plan.js
+/**
+* Result schemas for the {@link ReleasePlanner} service — the structured
+* preview of pending releases and the result of a native apply.
+*
+* @packageDocumentation
+*/
+/** A semantic-version bump level (the `"none"` plan type is filtered out upstream). @public */
+const BumpTypeSchema = effect.Schema.Literal("major", "minor", "patch");
+/** One package's previewed release: version transition + rendered changelog block. @public */
+const PreviewReleaseSchema = effect.Schema.Struct({
+	name: effect.Schema.String,
+	type: BumpTypeSchema,
+	oldVersion: effect.Schema.String,
+	newVersion: effect.Schema.String,
+	changesetIds: effect.Schema.Array(effect.Schema.String),
+	changelogEntry: effect.Schema.String
+}).annotations({ identifier: "PreviewRelease" });
+/** A parsed pending changeset (id + summary + the packages it bumps). @public */
+const PendingChangesetSchema = effect.Schema.Struct({
+	id: effect.Schema.String,
+	summary: effect.Schema.String,
+	releases: effect.Schema.Array(effect.Schema.Struct({
+		name: effect.Schema.String,
+		type: BumpTypeSchema
+	}))
+}).annotations({ identifier: "PendingChangeset" });
+/** Read-only preview of what the next release would produce. @public */
+const ChangesetPreviewSchema = effect.Schema.Struct({
+	preMode: effect.Schema.NullOr(effect.Schema.Literal("exit", "pre")),
+	releases: effect.Schema.Array(PreviewReleaseSchema),
+	changesets: effect.Schema.Array(PendingChangesetSchema)
+}).annotations({ identifier: "ChangesetPreview" });
+/** One applied package release (version transition). @public */
+const AppliedReleaseEntrySchema = effect.Schema.Struct({
+	name: effect.Schema.String,
+	type: BumpTypeSchema,
+	oldVersion: effect.Schema.String,
+	newVersion: effect.Schema.String
+}).annotations({ identifier: "AppliedReleaseEntry" });
+/** A single versionFiles update applied (or planned, when dry). @public */
+const VersionFileUpdateRecordSchema = effect.Schema.Struct({
+	filePath: effect.Schema.String,
+	version: effect.Schema.String
+}).annotations({ identifier: "VersionFileUpdateRecord" });
+/** Result of {@link ReleasePlanner.apply}. @public */
+const AppliedReleaseSchema = effect.Schema.Struct({
+	dryRun: effect.Schema.Boolean,
+	touchedFiles: effect.Schema.Array(effect.Schema.String),
+	releases: effect.Schema.Array(AppliedReleaseEntrySchema),
+	versionFileUpdates: effect.Schema.Array(VersionFileUpdateRecordSchema)
+}).annotations({ identifier: "AppliedRelease" });
+
+//#endregion
+exports.AppliedReleaseEntrySchema = AppliedReleaseEntrySchema;
+exports.AppliedReleaseSchema = AppliedReleaseSchema;
+exports.BumpTypeSchema = BumpTypeSchema;
+exports.ChangesetPreviewSchema = ChangesetPreviewSchema;
+exports.PendingChangesetSchema = PendingChangesetSchema;
+exports.PreviewReleaseSchema = PreviewReleaseSchema;
+exports.VersionFileUpdateRecordSchema = VersionFileUpdateRecordSchema;

package/packages/silk-effects/dist/dev/pkg/changesets/schemas/release-plan.js

@@ -0,0 +1,57 @@
+import { Schema } from "effect";
+
+//#region ../silk-effects/dist/dev/pkg/changesets/schemas/release-plan.js
+/**
+* Result schemas for the {@link ReleasePlanner} service — the structured
+* preview of pending releases and the result of a native apply.
+*
+* @packageDocumentation
+*/
+/** A semantic-version bump level (the `"none"` plan type is filtered out upstream). @public */
+const BumpTypeSchema = Schema.Literal("major", "minor", "patch");
+/** One package's previewed release: version transition + rendered changelog block. @public */
+const PreviewReleaseSchema = Schema.Struct({
+	name: Schema.String,
+	type: BumpTypeSchema,
+	oldVersion: Schema.String,
+	newVersion: Schema.String,
+	changesetIds: Schema.Array(Schema.String),
+	changelogEntry: Schema.String
+}).annotations({ identifier: "PreviewRelease" });
+/** A parsed pending changeset (id + summary + the packages it bumps). @public */
+const PendingChangesetSchema = Schema.Struct({
+	id: Schema.String,
+	summary: Schema.String,
+	releases: Schema.Array(Schema.Struct({
+		name: Schema.String,
+		type: BumpTypeSchema
+	}))
+}).annotations({ identifier: "PendingChangeset" });
+/** Read-only preview of what the next release would produce. @public */
+const ChangesetPreviewSchema = Schema.Struct({
+	preMode: Schema.NullOr(Schema.Literal("exit", "pre")),
+	releases: Schema.Array(PreviewReleaseSchema),
+	changesets: Schema.Array(PendingChangesetSchema)
+}).annotations({ identifier: "ChangesetPreview" });
+/** One applied package release (version transition). @public */
+const AppliedReleaseEntrySchema = Schema.Struct({
+	name: Schema.String,
+	type: BumpTypeSchema,
+	oldVersion: Schema.String,
+	newVersion: Schema.String
+}).annotations({ identifier: "AppliedReleaseEntry" });
+/** A single versionFiles update applied (or planned, when dry). @public */
+const VersionFileUpdateRecordSchema = Schema.Struct({
+	filePath: Schema.String,
+	version: Schema.String
+}).annotations({ identifier: "VersionFileUpdateRecord" });
+/** Result of {@link ReleasePlanner.apply}. @public */
+const AppliedReleaseSchema = Schema.Struct({
+	dryRun: Schema.Boolean,
+	touchedFiles: Schema.Array(Schema.String),
+	releases: Schema.Array(AppliedReleaseEntrySchema),
+	versionFileUpdates: Schema.Array(VersionFileUpdateRecordSchema)
+}).annotations({ identifier: "AppliedRelease" });
+
+//#endregion
+export { AppliedReleaseEntrySchema, AppliedReleaseSchema, BumpTypeSchema, ChangesetPreviewSchema, PendingChangesetSchema, PreviewReleaseSchema, VersionFileUpdateRecordSchema };

package/packages/silk-effects/dist/dev/pkg/changesets/services/release-planner.cjs

@@ -0,0 +1,255 @@
+const require_errors = require('../errors.cjs');
+const require_transformer = require('../api/transformer.cjs');
+const require_config_inspector = require('./config-inspector.cjs');
+const require_version_files = require('../utils/version-files.cjs');
+const require_get_packages_cjs$1 = require('../../../../../../../node_modules/.pnpm/@manypkg_get-packages@1.1.3/node_modules/@manypkg/get-packages/dist/get-packages.cjs.cjs');
+const require_changesets_config_esm = require('../../../../../../../node_modules/.pnpm/@changesets_config@3.1.4/node_modules/@changesets/config/dist/changesets-config.esm.cjs');
+const require_changesets_apply_release_plan_esm = require('../../../../../../../node_modules/.pnpm/@changesets_apply-release-plan@7.1.1/node_modules/@changesets/apply-release-plan/dist/changesets-apply-release-plan.esm.cjs');
+const require_changesets_get_release_plan_esm = require('../../../../../../../node_modules/.pnpm/@changesets_get-release-plan@4.0.16/node_modules/@changesets/get-release-plan/dist/changesets-get-release-plan.esm.cjs');
+let effect = require("effect");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+let node_os = require("node:os");
+
+//#region ../silk-effects/dist/dev/pkg/changesets/services/release-planner.js
+var import_get_packages_cjs = require_get_packages_cjs$1.default;
+/**
+* `ReleasePlanner` service — drive the genuine changesets release engine to
+* compute a plan, render a read-only preview, or natively apply a release.
+*
+* @remarks
+* `preview` and `apply` both run the real `@changesets/apply-release-plan`;
+* `preview` redirects every write into a throwaway temp directory by handing
+* the engine a `@manypkg`-shaped `Packages` object whose `dir`s point at temp,
+* then reads the generated CHANGELOG blocks back. No changesets-internal logic
+* (e.g. `getChangelogEntry`) is re-implemented.
+*
+* @packageDocumentation
+*/
+/** Single workspace-discovery seam; swap to an Effect-native stack later here. */
+const buildPackages = (root) => (0, import_get_packages_cjs.getPackages)(root);
+const errMsg = (e) => e instanceof Error ? e.message : String(e);
+/**
+* Base class for {@link ReleasePlanner}.
+*
+* @privateRemarks Required export for api-extractor (anonymous Context.Tag base). Do not delete.
+* @internal
+*/
+const ReleasePlannerBase = effect.Context.Tag("ReleasePlanner")();
+/** 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) {
+	const plan = (root) => effect.Effect.tryPromise({
+		try: () => require_changesets_get_release_plan_esm.getReleasePlan(root),
+		catch: (e) => new require_errors.ReleasePlanError({
+			phase: "plan",
+			reason: errMsg(e)
+		})
+	});
+	const preview = (root) => effect.Effect.tryPromise({
+		try: () => previewImpl(root),
+		catch: (e) => new require_errors.ReleasePlanError({
+			phase: "preview",
+			reason: errMsg(e)
+		})
+	});
+	const apply = (root, options) => applyEffect(root, options?.dryRun ?? false, inspector);
+	return {
+		plan,
+		preview,
+		apply
+	};
+}
+/** Production layer. Requires {@link ConfigInspector} (used by `apply`). @public */
+const ReleasePlannerLive = effect.Layer.effect(ReleasePlanner, effect.Effect.gen(function* () {
+	return makeShape(yield* require_config_inspector.ConfigInspector);
+}));
+/**
+* Test factory — supply fixed results for any subset of methods. Unsupplied
+* methods fail with a `ReleasePlanError`.
+*
+* @public
+*/
+function makeReleasePlannerTest(fixed) {
+	const fail = (phase) => effect.Effect.fail(new require_errors.ReleasePlanError({
+		phase,
+		reason: "not provided in test layer"
+	}));
+	return effect.Layer.succeed(ReleasePlanner, {
+		plan: () => fixed.plan ? effect.Effect.succeed(fixed.plan) : fail("plan"),
+		preview: () => fixed.preview ? effect.Effect.succeed(fixed.preview) : fail("preview"),
+		apply: () => fixed.apply ? effect.Effect.succeed(fixed.apply) : fail("apply")
+	});
+}
+/** Extract the `## <version>` block (down to the next H2 or EOF) from a changelog. */
+function extractVersionBlock(changelog, version) {
+	const lines = changelog.split("\n");
+	const start = lines.findIndex((l) => l.trim() === `## ${version}`);
+	if (start === -1) return "";
+	let end = lines.length;
+	for (let i = start + 1; i < lines.length; i++) if (/^## /.test(lines[i])) {
+		end = i;
+		break;
+	}
+	return lines.slice(start, end).join("\n").trim();
+}
+async function previewImpl(root) {
+	const [plan, packages] = await Promise.all([require_changesets_get_release_plan_esm.getReleasePlan(root), buildPackages(root)]);
+	const config = await require_changesets_config_esm.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 = (0, node_fs.mkdtempSync)((0, node_path.join)((0, node_os.tmpdir)(), "silk-preview-"));
+	try {
+		const mapDir = (dir) => {
+			const rel = (0, node_path.relative)(packages.root.dir, dir);
+			if (rel.startsWith("..") || (0, node_path.isAbsolute)(rel)) throw new Error(`Package directory is outside the workspace root: ${dir}`);
+			return (0, node_path.join)(tempRoot, rel);
+		};
+		const tempPackages = {
+			tool: packages.tool,
+			root: {
+				...packages.root,
+				dir: tempRoot,
+				packageJson: structuredClone(packages.root.packageJson)
+			},
+			packages: packages.packages.map((p) => ({
+				...p,
+				dir: mapDir(p.dir),
+				packageJson: structuredClone(p.packageJson)
+			}))
+		};
+		(0, node_fs.mkdirSync)((0, node_path.join)(tempRoot, ".changeset"), { recursive: true });
+		(0, node_fs.cpSync)((0, node_path.join)(root, "package.json"), (0, node_path.join)(tempRoot, "package.json"));
+		const preJson = (0, node_path.join)(root, ".changeset", "pre.json");
+		if ((0, node_fs.existsSync)(preJson)) (0, node_fs.cpSync)(preJson, (0, node_path.join)(tempRoot, ".changeset", "pre.json"));
+		for (const p of packages.packages) {
+			const tDir = mapDir(p.dir);
+			(0, node_fs.mkdirSync)(tDir, { recursive: true });
+			(0, node_fs.cpSync)((0, node_path.join)(p.dir, "package.json"), (0, node_path.join)(tDir, "package.json"));
+			const realCl = (0, node_path.join)(p.dir, "CHANGELOG.md");
+			if ((0, node_fs.existsSync)(realCl)) (0, node_fs.cpSync)(realCl, (0, node_path.join)(tDir, "CHANGELOG.md"));
+		}
+		const rootCl = (0, node_path.join)(packages.root.dir, "CHANGELOG.md");
+		if ((0, node_fs.existsSync)(rootCl)) (0, node_fs.cpSync)(rootCl, (0, node_path.join)(tempRoot, "CHANGELOG.md"));
+		await require_changesets_apply_release_plan_esm.applyReleasePlan(plan, tempPackages, config, void 0, root);
+		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);
+		const releases = [];
+		for (const r of releasesToRender) {
+			const dir = dirByName.get(r.name);
+			if (!dir) continue;
+			const clPath = (0, node_path.join)(dir, "CHANGELOG.md");
+			if (!(0, node_fs.existsSync)(clPath)) continue;
+			require_transformer.ChangelogTransformer.transformFile(clPath);
+			const content = (0, node_fs.readFileSync)(clPath, "utf-8");
+			releases.push({
+				name: r.name,
+				type: r.type,
+				oldVersion: r.oldVersion,
+				newVersion: r.newVersion,
+				changesetIds: [...r.changesets],
+				changelogEntry: extractVersionBlock(content, r.newVersion)
+			});
+		}
+		return {
+			preMode,
+			releases,
+			changesets
+		};
+	} finally {
+		(0, node_fs.rmSync)(tempRoot, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** Re-read a package's version from disk (post-bump) to feed versionFiles. */
+function diskVersion(workspaceDir, fallback) {
+	try {
+		return JSON.parse((0, node_fs.readFileSync)((0, node_path.join)(workspaceDir, "package.json"), "utf-8")).version ?? fallback;
+	} catch {
+		return fallback;
+	}
+}
+function applyEffect(root, dryRun, inspector) {
+	return effect.Effect.gen(function* () {
+		const { plan, packages, config } = yield* effect.Effect.tryPromise({
+			try: async () => {
+				const [plan, packages] = await Promise.all([require_changesets_get_release_plan_esm.getReleasePlan(root), buildPackages(root)]);
+				return {
+					plan,
+					packages,
+					config: await require_changesets_config_esm.read(root, packages)
+				};
+			},
+			catch: (e) => new require_errors.ReleasePlanError({
+				phase: "apply",
+				reason: errMsg(e)
+			})
+		});
+		const releases = plan.releases.filter((r) => r.type !== "none").map((r) => ({
+			name: r.name,
+			type: r.type,
+			oldVersion: r.oldVersion,
+			newVersion: r.newVersion
+		}));
+		let touchedFiles = [];
+		if (!dryRun) touchedFiles = yield* effect.Effect.tryPromise({
+			try: async () => {
+				const touched = await require_changesets_apply_release_plan_esm.applyReleasePlan(plan, packages, config);
+				for (const f of touched) if (f.endsWith("CHANGELOG.md")) require_transformer.ChangelogTransformer.transformFile(f);
+				return touched;
+			},
+			catch: (e) => new require_errors.ReleasePlanError({
+				phase: "apply",
+				reason: errMsg(e)
+			})
+		});
+		const newVersionByName = new Map(plan.releases.map((r) => [r.name, r.newVersion]));
+		const inspected = yield* inspector.inspect(root).pipe(effect.Effect.catchAll((error) => effect.Effect.logWarning(`Skipping versionFiles update: ${errMsg(error)}`).pipe(effect.Effect.as(null))));
+		let versionFileUpdates = [];
+		if (inspected) versionFileUpdates = yield* effect.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 ? require_version_files.VersionFiles.processResolvedVersionFiles(scopes, dryRun) : [];
+			},
+			catch: (e) => new require_errors.ReleasePlanError({
+				phase: "apply",
+				reason: errMsg(e)
+			})
+		});
+		return {
+			dryRun,
+			touchedFiles,
+			releases,
+			versionFileUpdates
+		};
+	});
+}
+
+//#endregion
+exports.ReleasePlanner = ReleasePlanner;
+exports.ReleasePlannerBase = ReleasePlannerBase;
+exports.ReleasePlannerLive = ReleasePlannerLive;
+exports.makeReleasePlannerTest = makeReleasePlannerTest;

package/packages/silk-effects/dist/dev/pkg/changesets/services/release-planner.js

@@ -0,0 +1,252 @@
+import { ReleasePlanError } from "../errors.js";
+import { ChangelogTransformer } from "../api/transformer.js";
+import { ConfigInspector } from "./config-inspector.js";
+import { VersionFiles } from "../utils/version-files.js";
+import { require_get_packages_cjs } from "../../../../../../../node_modules/.pnpm/@manypkg_get-packages@1.1.3/node_modules/@manypkg/get-packages/dist/get-packages.cjs.js";
+import { read } from "../../../../../../../node_modules/.pnpm/@changesets_config@3.1.4/node_modules/@changesets/config/dist/changesets-config.esm.js";
+import { applyReleasePlan } from "../../../../../../../node_modules/.pnpm/@changesets_apply-release-plan@7.1.1/node_modules/@changesets/apply-release-plan/dist/changesets-apply-release-plan.esm.js";
+import { getReleasePlan } from "../../../../../../../node_modules/.pnpm/@changesets_get-release-plan@4.0.16/node_modules/@changesets/get-release-plan/dist/changesets-get-release-plan.esm.js";
+import { Context, Effect, Layer } from "effect";
+import { isAbsolute, join, relative } from "node:path";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+
+//#region ../silk-effects/dist/dev/pkg/changesets/services/release-planner.js
+var import_get_packages_cjs = require_get_packages_cjs();
+/**
+* `ReleasePlanner` service — drive the genuine changesets release engine to
+* compute a plan, render a read-only preview, or natively apply a release.
+*
+* @remarks
+* `preview` and `apply` both run the real `@changesets/apply-release-plan`;
+* `preview` redirects every write into a throwaway temp directory by handing
+* the engine a `@manypkg`-shaped `Packages` object whose `dir`s point at temp,
+* then reads the generated CHANGELOG blocks back. No changesets-internal logic
+* (e.g. `getChangelogEntry`) is re-implemented.
+*
+* @packageDocumentation
+*/
+/** Single workspace-discovery seam; swap to an Effect-native stack later here. */
+const buildPackages = (root) => (0, import_get_packages_cjs.getPackages)(root);
+const errMsg = (e) => e instanceof Error ? e.message : String(e);
+/**
+* Base class for {@link ReleasePlanner}.
+*
+* @privateRemarks Required export for api-extractor (anonymous Context.Tag base). Do not delete.
+* @internal
+*/
+const ReleasePlannerBase = Context.Tag("ReleasePlanner")();
+/** 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) {
+	const plan = (root) => Effect.tryPromise({
+		try: () => getReleasePlan(root),
+		catch: (e) => new ReleasePlanError({
+			phase: "plan",
+			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);
+	return {
+		plan,
+		preview,
+		apply
+	};
+}
+/** Production layer. Requires {@link ConfigInspector} (used by `apply`). @public */
+const ReleasePlannerLive = Layer.effect(ReleasePlanner, Effect.gen(function* () {
+	return makeShape(yield* ConfigInspector);
+}));
+/**
+* Test factory — supply fixed results for any subset of methods. Unsupplied
+* methods fail with a `ReleasePlanError`.
+*
+* @public
+*/
+function makeReleasePlannerTest(fixed) {
+	const fail = (phase) => Effect.fail(new ReleasePlanError({
+		phase,
+		reason: "not provided in test layer"
+	}));
+	return Layer.succeed(ReleasePlanner, {
+		plan: () => fixed.plan ? Effect.succeed(fixed.plan) : fail("plan"),
+		preview: () => fixed.preview ? Effect.succeed(fixed.preview) : fail("preview"),
+		apply: () => fixed.apply ? Effect.succeed(fixed.apply) : fail("apply")
+	});
+}
+/** Extract the `## <version>` block (down to the next H2 or EOF) from a changelog. */
+function extractVersionBlock(changelog, version) {
+	const lines = changelog.split("\n");
+	const start = lines.findIndex((l) => l.trim() === `## ${version}`);
+	if (start === -1) return "";
+	let end = lines.length;
+	for (let i = start + 1; i < lines.length; i++) if (/^## /.test(lines[i])) {
+		end = i;
+		break;
+	}
+	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 {
+		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);
+		};
+		const tempPackages = {
+			tool: packages.tool,
+			root: {
+				...packages.root,
+				dir: tempRoot,
+				packageJson: structuredClone(packages.root.packageJson)
+			},
+			packages: packages.packages.map((p) => ({
+				...p,
+				dir: mapDir(p.dir),
+				packageJson: structuredClone(p.packageJson)
+			}))
+		};
+		mkdirSync(join(tempRoot, ".changeset"), { recursive: true });
+		cpSync(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"));
+			const realCl = join(p.dir, "CHANGELOG.md");
+			if (existsSync(realCl)) cpSync(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);
+		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);
+		const releases = [];
+		for (const r of releasesToRender) {
+			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");
+			releases.push({
+				name: r.name,
+				type: r.type,
+				oldVersion: r.oldVersion,
+				newVersion: r.newVersion,
+				changesetIds: [...r.changesets],
+				changelogEntry: extractVersionBlock(content, r.newVersion)
+			});
+		}
+		return {
+			preMode,
+			releases,
+			changesets
+		};
+	} finally {
+		rmSync(tempRoot, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** 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;
+	}
+}
+function applyEffect(root, dryRun, inspector) {
+	return Effect.gen(function* () {
+		const { plan, packages, config } = yield* Effect.tryPromise({
+			try: async () => {
+				const [plan, packages] = await Promise.all([getReleasePlan(root), buildPackages(root)]);
+				return {
+					plan,
+					packages,
+					config: await read(root, packages)
+				};
+			},
+			catch: (e) => new ReleasePlanError({
+				phase: "apply",
+				reason: errMsg(e)
+			})
+		});
+		const releases = plan.releases.filter((r) => r.type !== "none").map((r) => ({
+			name: r.name,
+			type: r.type,
+			oldVersion: r.oldVersion,
+			newVersion: r.newVersion
+		}));
+		let touchedFiles = [];
+		if (!dryRun) touchedFiles = yield* Effect.tryPromise({
+			try: async () => {
+				const touched = await applyReleasePlan(plan, packages, config);
+				for (const f of touched) if (f.endsWith("CHANGELOG.md")) ChangelogTransformer.transformFile(f);
+				return touched;
+			},
+			catch: (e) => new ReleasePlanError({
+				phase: "apply",
+				reason: errMsg(e)
+			})
+		});
+		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)
+			})
+		});
+		return {
+			dryRun,
+			touchedFiles,
+			releases,
+			versionFileUpdates
+		};
+	});
+}
+
+//#endregion
+export { ReleasePlanner, ReleasePlannerBase, ReleasePlannerLive, makeReleasePlannerTest };