@savvy-web/silk-effects 1.3.1 → 1.5.0

package/changesets/categories/types.js

@@ -16,7 +16,6 @@ import { Schema } from "effect";
 * @see {@link resolveCommitType} for mapping commit types to categories
 * @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
 *
-* @packageDocumentation
 */
 /**
 * Schema for a section category that defines how changes are grouped in release notes.

package/changesets/changelog/index.js

@@ -56,8 +56,6 @@ import { Effect, Layer } from "effect";
 *
 * @see {@link getReleaseLine} in `./getReleaseLine.ts` for individual changeset formatting
 * @see {@link getDependencyReleaseLine} in `./getDependencyReleaseLine.ts` for dependency table formatting
-*
-* @packageDocumentation
 */
 /**
 * Combined layer providing all services needed by the formatters.

package/changesets/constants.js

@@ -16,7 +16,6 @@
 * - `CSH005` -- Frontmatter validation
 *
 * @internal
-* @packageDocumentation
 */
 /** Base URL for rule documentation on GitHub. */
 const DOCS_BASE = "https://github.com/savvy-web/changesets/blob/main/docs/rules";

package/changesets/errors.js

@@ -16,7 +16,6 @@ import { Data } from "effect";
 *
 * @see {@link https://effect.website/docs/data-types/data#taggerror | Effect TaggedError documentation}
 *
-* @packageDocumentation
 */
 /**
 * Base class for {@link ChangesetValidationError}.
@@ -300,6 +299,30 @@ var GitError = class extends GitErrorBase {
 		return `git command failed in ${this.cwd}: ${this.command}\n${this.reason}`;
 	}
 };
+/**
+* Base class for {@link ReleasePlanError}.
+*
+* @privateRemarks
+* Required export for api-extractor (anonymous Data.TaggedError base). Do not delete.
+*
+* @internal
+*/
+const ReleasePlanErrorBase = Data.TaggedError("ReleasePlanError");
+/**
+* Release planning, preview, or apply failure.
+*
+* @remarks
+* Wraps any failure from the underlying `@changesets/*` machinery
+* (`getReleasePlan`, `applyReleasePlan`, config resolution) into a typed
+* Effect error, tagged with the phase that failed.
+*
+* @public
+*/
+var ReleasePlanError = class extends ReleasePlanErrorBase {
+	get message() {
+		return `Release plan error (${this.phase}): ${this.reason}`;
+	}
+};
 
 //#endregion
-export { ChangesetValidationError, ChangesetValidationErrorBase, ConfigurationError, ConfigurationErrorBase, GitError, GitErrorBase, GitHubApiError, GitHubApiErrorBase, MarkdownParseError, MarkdownParseErrorBase, VersionFileError, VersionFileErrorBase };
+export { ChangesetValidationError, ChangesetValidationErrorBase, ConfigurationError, ConfigurationErrorBase, GitError, GitErrorBase, GitHubApiError, GitHubApiErrorBase, MarkdownParseError, MarkdownParseErrorBase, ReleasePlanError, ReleasePlanErrorBase, VersionFileError, VersionFileErrorBase };

package/changesets/index.js

@@ -1,6 +1,6 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { Categories } from "./api/categories.js";
-import { ChangesetValidationError, ChangesetValidationErrorBase, ConfigurationError, ConfigurationErrorBase, GitError, GitErrorBase, GitHubApiError, GitHubApiErrorBase, MarkdownParseError, MarkdownParseErrorBase, VersionFileError, VersionFileErrorBase } from "./errors.js";
+import { ChangesetValidationError, ChangesetValidationErrorBase, ConfigurationError, ConfigurationErrorBase, GitError, GitErrorBase, GitHubApiError, GitHubApiErrorBase, MarkdownParseError, MarkdownParseErrorBase, ReleasePlanError, ReleasePlanErrorBase, VersionFileError, VersionFileErrorBase } from "./errors.js";
 import { JsonPathSchema, LegacyVersionFileConfigSchema, LegacyVersionFilesSchema, VersionFileConfigSchema, VersionFilesSchema } from "./schemas/version-files.js";
 import { GlobSchema, PackageScopeSchema, PackagesRecordSchema } from "./schemas/package-scope.js";
 import { ChangesetOptionsSchema, RepoSchema } from "./schemas/options.js";
@@ -28,13 +28,15 @@ import { ChangelogTransformer } from "./api/transformer.js";
 import { ClassificationReasonSchema, ClassificationSchema, ConfigInspector, ConfigInspectorBase, ConfigInspectorLive, InspectedConfigSchema, ResolvedPackageScopeSchema, ResolvedVersionFileSchema, makeConfigInspectorTest } from "./services/config-inspector.js";
 import { BranchAnalysisSchema, BranchAnalyzer, BranchAnalyzerBase, BranchAnalyzerLive, BranchFileEntrySchema, FileStatusSchema, makeBranchAnalyzerTest } from "./services/branch-analyzer.js";
 import { ChangelogService, ChangelogServiceBase } from "./services/changelog.js";
+import { VersionFiles } from "./utils/version-files.js";
+import { ReleasePlanner, ReleasePlannerBase, ReleasePlannerLive, makeReleasePlannerTest } from "./services/release-planner.js";
 import { WorkspaceSnapshotReader, WorkspaceSnapshotReaderBase, WorkspaceSnapshotReaderLive } from "./services/workspace-snapshot.js";
 import { SectionCategorySchema } from "./categories/types.js";
 import { CommitHashSchema, VersionTypeSchema } from "./schemas/git.js";
 import { ChangesetSchema, ChangesetSummarySchema, DependencyTypeSchema, DependencyUpdateSchema } from "./schemas/changeset.js";
+import { AppliedReleaseEntrySchema, AppliedReleaseSchema, BumpTypeSchema, ChangesetPreviewSchema, PendingChangesetSchema, PreviewReleaseSchema, VersionFileUpdateRecordSchema } from "./schemas/release-plan.js";
 import { computeWorkspaceDependencyDiffs } from "./utils/dep-diff.js";
 import { listPublishablePackageNames } from "./utils/publishability.js";
-import { VersionFiles } from "./utils/version-files.js";
 import { gitMergeBase, snapshotFromWorktree } from "./utils/worktree-snapshot.js";
 import { ContentStructureRule as ContentStructureRule$1 } from "./markdownlint/rules/content-structure.js";
 import { DependencyTableFormatRule } from "./markdownlint/rules/dependency-table-format.js";
@@ -49,11 +51,14 @@ import { SilkChangesetPreset, SilkChangesetTransformPreset } from "./remark/pres
 //#region src/changesets/index.ts
 var changesets_exports = /* @__PURE__ */ __exportAll({
 	AggregateDependencyTablesPlugin: () => AggregateDependencyTablesPlugin,
+	AppliedReleaseEntrySchema: () => AppliedReleaseEntrySchema,
+	AppliedReleaseSchema: () => AppliedReleaseSchema,
 	BranchAnalysisSchema: () => BranchAnalysisSchema,
 	BranchAnalyzer: () => BranchAnalyzer,
 	BranchAnalyzerBase: () => BranchAnalyzerBase,
 	BranchAnalyzerLive: () => BranchAnalyzerLive,
 	BranchFileEntrySchema: () => BranchFileEntrySchema,
+	BumpTypeSchema: () => BumpTypeSchema,
 	Categories: () => Categories,
 	Changelog: () => Changelog,
 	ChangelogService: () => ChangelogService,
@@ -61,6 +66,7 @@ var changesets_exports = /* @__PURE__ */ __exportAll({
 	ChangelogTransformer: () => ChangelogTransformer,
 	ChangesetLinter: () => ChangesetLinter,
 	ChangesetOptionsSchema: () => ChangesetOptionsSchema,
+	ChangesetPreviewSchema: () => ChangesetPreviewSchema,
 	ChangesetSchema: () => ChangesetSchema,
 	ChangesetSummarySchema: () => ChangesetSummarySchema,
 	ChangesetValidationError: () => ChangesetValidationError,
@@ -116,7 +122,14 @@ var changesets_exports = /* @__PURE__ */ __exportAll({
 	NormalizeFormatPlugin: () => NormalizeFormatPlugin,
 	PackageScopeSchema: () => PackageScopeSchema,
 	PackagesRecordSchema: () => PackagesRecordSchema,
+	PendingChangesetSchema: () => PendingChangesetSchema,
 	PositiveInteger: () => PositiveInteger,
+	PreviewReleaseSchema: () => PreviewReleaseSchema,
+	ReleasePlanError: () => ReleasePlanError,
+	ReleasePlanErrorBase: () => ReleasePlanErrorBase,
+	ReleasePlanner: () => ReleasePlanner,
+	ReleasePlannerBase: () => ReleasePlannerBase,
+	ReleasePlannerLive: () => ReleasePlannerLive,
 	ReorderSectionsPlugin: () => ReorderSectionsPlugin,
 	RepoSchema: () => RepoSchema,
 	RequiredSectionsRule: () => RequiredSectionsRule,
@@ -132,6 +145,7 @@ var changesets_exports = /* @__PURE__ */ __exportAll({
 	VersionFileConfigSchema: () => VersionFileConfigSchema,
 	VersionFileError: () => VersionFileError,
 	VersionFileErrorBase: () => VersionFileErrorBase,
+	VersionFileUpdateRecordSchema: () => VersionFileUpdateRecordSchema,
 	VersionFiles: () => VersionFiles,
 	VersionFilesSchema: () => VersionFilesSchema,
 	VersionOrEmptySchema: () => VersionOrEmptySchema,
@@ -146,6 +160,7 @@ var changesets_exports = /* @__PURE__ */ __exportAll({
 	makeBranchAnalyzerTest: () => makeBranchAnalyzerTest,
 	makeConfigInspectorTest: () => makeConfigInspectorTest,
 	makeGitHubTest: () => makeGitHubTest,
+	makeReleasePlannerTest: () => makeReleasePlannerTest,
 	serializeDependencyTableToMarkdown: () => serializeDependencyTableToMarkdown,
 	snapshotFromWorktree: () => snapshotFromWorktree
 });

package/changesets/markdownlint/rules/dependency-table-format.js

@@ -3,7 +3,7 @@ import { getHeadingLevel, getHeadingText } from "./utils.js";
 
 //#region src/changesets/markdownlint/rules/dependency-table-format.ts
 const EM_DASH = "—";
-const VALID_TYPES = new Set([
+const VALID_TYPES = /* @__PURE__ */ new Set([
 	"dependency",
 	"devDependency",
 	"peerDependency",
@@ -11,7 +11,7 @@ const VALID_TYPES = new Set([
 	"workspace",
 	"config"
 ]);
-const VALID_ACTIONS = new Set([
+const VALID_ACTIONS = /* @__PURE__ */ new Set([
 	"added",
 	"updated",
 	"removed"

package/changesets/remark/rules/uncategorized-content.js

@@ -7,7 +7,7 @@ import { lintRule } from "unified-lint-rule";
 *
 * @internal
 */
-const IGNORED_TYPES = new Set(["html"]);
+const IGNORED_TYPES = /* @__PURE__ */ new Set(["html"]);
 /**
 * Determine whether a node is substantive content (not a heading or ignored type).
 *

package/changesets/schemas/changeset.js

@@ -16,7 +16,6 @@ import { Schema } from "effect";
 * @see {@link https://github.com/changesets/changesets | Changesets documentation}
 * @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
 *
-* @packageDocumentation
 */
 /**
 * Schema for a changeset summary (1--1000 characters).

package/changesets/schemas/dependency-table.js

@@ -21,7 +21,6 @@ import { Schema } from "effect";
 * @see {@link DependencyUpdateSchema} for the simpler Changesets API format
 * @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
 *
-* @packageDocumentation
 */
 /**
 * Valid dependency table actions.

package/changesets/schemas/git.js

@@ -6,7 +6,6 @@ import { Schema } from "effect";
 *
 * @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
 *
-* @packageDocumentation
 */
 /**
 * Schema for a git commit hash (at least 7 lowercase hex characters).

package/changesets/schemas/github.js

@@ -13,7 +13,6 @@ import { Schema } from "effect";
 *
 * @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
 *
-* @packageDocumentation
 */
 /**
 * Test whether a string is a valid URL.

package/changesets/schemas/options.js

@@ -21,7 +21,6 @@ import { Effect, Schema } from "effect";
 * @see {@link https://github.com/changesets/changesets/blob/main/docs/config-file-options.md | Changesets config docs}
 * @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
 *
-* @packageDocumentation
 */
 /** Regex for `owner/repo` format, shared between schema and validation. */
 const REPO_PATTERN = /^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/;

package/changesets/schemas/package-scope.js

@@ -40,7 +40,6 @@ import { Schema } from "effect";
 * @see {@link VersionFileConfigSchema} for the version-file entry shape
 * @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
 *
-* @packageDocumentation
 */
 /**
 * Schema for a single repo-relative glob pattern.

package/changesets/schemas/primitives.js

@@ -12,7 +12,6 @@ import { Schema } from "effect";
 *
 * @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
 *
-* @packageDocumentation
 */
 /**
 * A non-empty string schema.

package/changesets/schemas/release-plan.js

@@ -0,0 +1,56 @@
+import { Schema } from "effect";
+
+//#region src/changesets/schemas/release-plan.ts
+/**
+* Result schemas for the {@link ReleasePlanner} service — the structured
+* preview of pending releases and the result of a native apply.
+*
+*/
+/** 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/changesets/schemas/version-files.js

@@ -26,7 +26,6 @@ import { Schema } from "effect";
 * @see {@link PackageScopeSchema} for the new per-package container
 * @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
 *
-* @packageDocumentation
 */
 /**
 * Schema for a JSONPath expression starting with `$.`.

package/changesets/services/branch-analyzer.js

@@ -43,7 +43,6 @@ import { execFileSync } from "node:child_process";
 * @see {@link BranchAnalyzerLive} for the production layer
 * @see {@link ConfigInspector} for the underlying classification service
 *
-* @packageDocumentation
 */
 /** Git diff status as reported by `--name-status`. @public */
 const FileStatusSchema = Schema.Literal("added", "modified", "deleted", "renamed", "copied", "typechange", "unmerged", "unknown").annotations({ identifier: "FileStatus" });

package/changesets/services/config-inspector.js

@@ -41,7 +41,6 @@ import { WorkspaceDiscovery } from "workspaces-effect";
 * @see {@link ConfigInspector} for the Effect service tag
 * @see {@link ConfigInspectorLive} for the production layer
 *
-* @packageDocumentation
 */
 /** A `versionFiles` entry expanded to its absolute target paths. @public */
 const ResolvedVersionFileSchema = Schema.Struct({
@@ -454,7 +453,7 @@ function classifyOne(inspected, path) {
 /**
 * Live layer for {@link ConfigInspector}.
 *
-* Requires {@link ChangesetConfigReader} and {@link WorkspaceDiscovery}
+* Requires {@link ChangesetConfigReader} and `WorkspaceDiscovery`
 * in the environment.
 *
 * @public

package/changesets/services/release-planner.js

@@ -0,0 +1,251 @@
+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 { 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 applyReleasePlan from "@changesets/apply-release-plan";
+import { read } from "@changesets/config";
+import getReleasePlan from "@changesets/get-release-plan";
+import { getPackages } from "@manypkg/get-packages";
+
+//#region src/changesets/services/release-planner.ts
+/**
+* `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.
+*
+*/
+/** Single workspace-discovery seam; swap to an Effect-native stack later here. */
+const buildPackages = (root) => getPackages(root);
+const errMsg = (e) => e instanceof Error ? e.message : String(e);
+const _tag = Context.Tag("ReleasePlanner");
+/**
+* Base class for {@link ReleasePlanner}.
+*
+* @privateRemarks Required export for api-extractor (anonymous Context.Tag base). Do not delete.
+* @internal
+*/
+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) {
+	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 };

package/changesets/services/workspace-snapshot.js

@@ -22,7 +22,6 @@ import { execFileSync } from "node:child_process";
 * @see {@link WorkspaceSnapshotReader} for the service tag
 * @see {@link WorkspaceSnapshotReaderLive} for the production layer
 *
-* @packageDocumentation
 */
 const _tag = Context.Tag("WorkspaceSnapshotReader");
 /**

package/changesets/utils/publishability.js

@@ -7,18 +7,17 @@ import { PublishabilityDetector } from "workspaces-effect";
 *
 * @remarks
 * Provides `listPublishablePackageNames`, a convenience wrapper around
-* {@link PublishabilityDetector} that returns a `Set<string>` of
+* {@link SilkPublishability} that returns a `Set<string>` of
 * publishable package names. Used by the `deps detect` and `deps regen`
 * commands to filter out workspace packages whose dependency changes
 * would never reach a release.
 *
-* @packageDocumentation
 */
 /**
 * Compute the set of currently-publishable workspace package names.
 *
 * @remarks
-* Uses the currently-active {@link PublishabilityDetector} — wire the
+* Uses the currently-active {@link SilkPublishability} — wire the
 * {@link SilkPublishabilityDetectorLive} layer to get silk semantics.
 *
 * @param packages - The workspace packages to evaluate

package/changesets/utils/worktree-snapshot.js

@@ -81,7 +81,7 @@ function normalizeWorkspaceGlob(glob) {
 */
 function snapshotFromWorktree(cwd) {
 	const snapshots = [];
-	const dirs = new Set([cwd]);
+	const dirs = /* @__PURE__ */ new Set([cwd]);
 	for (const dir of expandWorkspaceDirs(cwd)) dirs.add(dir);
 	for (const dir of dirs) try {
 		const pkgJson = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));

package/commitlint/config/factory.js

@@ -26,7 +26,7 @@ function createConfig(options) {
 	const cwd = options.cwd ?? process.cwd();
 	const dco = process.env.COMMITLINT_SKIP_DCO === "1" || process.env.COMMITLINT_SKIP_DCO === "true" ? false : options.dco ?? detectDCO(cwd);
 	const scopes = options.scopes ?? [];
-	const allScopes = [...new Set([...scopes, ...options.additionalScopes ?? []])].sort();
+	const allScopes = [.../* @__PURE__ */ new Set([...scopes, ...options.additionalScopes ?? []])].sort();
 	const rules = {
 		"body-max-line-length": [
 			2,

package/commitlint/hook/diagnostics/package-manager.js

@@ -11,7 +11,7 @@ import { readFile } from "node:fs/promises";
 *
 * @internal
 */
-const VALID_PMS = new Set([
+const VALID_PMS = /* @__PURE__ */ new Set([
 	"pnpm",
 	"yarn",
 	"bun",

package/commitlint/index.js

@@ -41,7 +41,6 @@ import { verbosityRule } from "./hook/rules/verbosity.js";
 * const config = Commitlint.CommitlintConfig.silk();
 * ```
 *
-* @packageDocumentation
 */
 var commitlint_exports = /* @__PURE__ */ __exportAll({
 	COMMIT_TYPES: () => COMMIT_TYPES,