@maple-dev/changesets 0.0.0-stage → 0.1.0

package/dist/cli-_8EGJc1S.mjs

@@ -0,0 +1,2566 @@
+import { Config, Console, Context, Effect, FileSystem, Glob, Layer, Option, Path, Predicate, Random, Result, Schema, SemVer, SemVerRange, Stream } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+import { Command, Flag, Prompt } from "effect/cli";
+// src/semver.ts
+/**
+* The handful of node-semver operations changesets relies on, over `effect/SemVer` and
+* `effect/SemVerRange`. `rangeComparators` re-implements node-semver's desugaring for the two
+* places where changesets reads a range's structure instead of only matching against it.
+*/
+const parseVersion = (version) => version === void 0 ? Result.failVoid : Result.mapError(SemVer.parse(version.trim()), () => void 0);
+const isValidRange = (range) => Result.isSuccess(SemVerRange.parse(range.trim()));
+/** `semver.satisfies`: an invalid version or range never satisfies. */
+const satisfies = (version, range) => {
+	if (range === void 0) return false;
+	const parsedVersion = parseVersion(version);
+	const parsedRange = SemVerRange.parse(range.trim());
+	return Result.isSuccess(parsedVersion) && Result.isSuccess(parsedRange) && SemVerRange.matches(parsedRange.success, parsedVersion.success);
+};
+const bumps = {
+	major: SemVer.bumpMajor,
+	minor: SemVer.bumpMinor,
+	patch: SemVer.bumpPatch
+};
+/** `semver.inc` for the three release types; `undefined` for an invalid version, like `null` there. */
+const increment = (version, type) => {
+	const parsed = parseVersion(version);
+	return Result.isSuccess(parsed) ? SemVer.format(bumps[type](parsed.success)) : void 0;
+};
+const isPrerelease = (version) => {
+	const parsed = parseVersion(version);
+	return Result.isSuccess(parsed) && SemVer.isPrerelease(parsed.success);
+};
+const greaterThan = (a, b) => {
+	const left = parseVersion(a);
+	const right = parseVersion(b);
+	return Result.isSuccess(left) && Result.isSuccess(right) && SemVer.isGreaterThan(left.success, right.success);
+};
+const lessThan = (a, b) => {
+	const left = parseVersion(a);
+	const right = parseVersion(b);
+	return Result.isSuccess(left) && Result.isSuccess(right) && SemVer.isLessThan(left.success, right.success);
+};
+const isX = (part) => part === void 0 || part === "x" || part === "X" || part === "*";
+const partialPattern = /^v?(\d+|[xX*])?(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+const operatorPattern = /^(<=|>=|<|>|=|~>|~|\^)?(.*)$/;
+const desugarToken = (operator, version) => {
+	const match = partialPattern.exec(version);
+	if (match === null) return [{
+		operator,
+		value: version
+	}];
+	const [, major, minor, patch, pre] = match;
+	if (isX(major)) return operator === "<" || operator === ">" ? [{
+		operator: "<",
+		value: "<0.0.0-0"
+	}] : [];
+	const M = Number(major);
+	const m = Number(minor);
+	const full = `${major}.${minor}.${patch}${pre === void 0 ? "" : `-${pre}`}`;
+	switch (operator) {
+		case ">": return isX(minor) ? [{
+			operator: ">=",
+			value: `>=${M + 1}.0.0`
+		}] : isX(patch) ? [{
+			operator: ">=",
+			value: `>=${M}.${m + 1}.0`
+		}] : [{
+			operator: ">",
+			value: `>${full}`
+		}];
+		case ">=": {
+			const value = isX(minor) ? `>=${M}.0.0` : isX(patch) ? `>=${M}.${m}.0` : `>=${full}`;
+			return value === ">=0.0.0" ? [] : [{
+				operator: ">=",
+				value
+			}];
+		}
+		case "<": return [{
+			operator: "<",
+			value: isX(minor) ? `<${M}.0.0-0` : isX(patch) ? `<${M}.${m}.0-0` : `<${full}`
+		}];
+		case "<=": return isX(minor) ? [{
+			operator: "<",
+			value: `<${M + 1}.0.0-0`
+		}] : isX(patch) ? [{
+			operator: "<",
+			value: `<${M}.${m + 1}.0-0`
+		}] : [{
+			operator: "<=",
+			value: `<=${full}`
+		}];
+		case "":
+		case "=": return isX(minor) || isX(patch) ? [{
+			operator: ">=",
+			value: ">="
+		}, {
+			operator: "<",
+			value: "<"
+		}] : [{
+			operator: "",
+			value: full
+		}];
+		default: return [{
+			operator: ">=",
+			value: ">="
+		}, {
+			operator: "<",
+			value: "<"
+		}];
+	}
+};
+const tokens = (set) => {
+	return set.trim().split(/\s+/).filter((part) => part.length > 0).reduce((merged, part) => {
+		const previous = merged.at(-1);
+		return previous !== void 0 && /^(<=|>=|<|>|=|~>|~|\^)$/.test(previous) ? [...merged.slice(0, -1), `${previous}${part}`] : [...merged, part];
+	}, []);
+};
+/** The comparators node-semver builds for one `||`-free comparator set. */
+const setComparators = (set) => {
+	const parts = tokens(set);
+	if (parts.length === 3 && parts[1] === "-") return isX(partialPattern.exec(parts[0])?.[1]) && isX(partialPattern.exec(parts[2])?.[1]) ? [] : [{
+		operator: ">=",
+		value: ">="
+	}, {
+		operator: "<=",
+		value: "<="
+	}];
+	return parts.flatMap((part) => {
+		const [, operator = "", version = ""] = operatorPattern.exec(part) ?? [];
+		return desugarToken(operator, version);
+	});
+};
+/** `new Range(range).range === ""`: some alternative accepts every version. */
+const isAnyRange = (range) => range.split("||").some((set) => setComparators(set).length === 0);
+/** `new Range(range).set`: one comparator list per `||` alternative. */
+const rangeComparators = (range) => range.split("||").map(setComparators);
+// src/changelog.ts
+/**
+* CHANGELOG.md entries byte-for-byte as `@changesets/apply-release-plan` writes them with the
+* default `@changesets/cli/changelog` (which is `@changesets/changelog-git`).
+*/
+const shortCommit = (commit) => commit ? commit.slice(0, 7) : void 0;
+/** `@changesets/changelog-git`. */
+const gitChangelog = {
+	getReleaseLine: (changeset) => {
+		const [firstLine, ...futureLines] = changeset.summary.split("\n").map((line) => line.trimEnd());
+		const commit = shortCommit(changeset.commit);
+		const head = `- ${commit === void 0 ? "" : `${commit}: `}${firstLine}`;
+		return Effect.succeed(futureLines.length > 0 ? `${head}\n${futureLines.map((line) => `  ${line}`).join("\n")}` : head);
+	},
+	getDependencyReleaseLine: (changesets, dependenciesUpdated) => {
+		if (dependenciesUpdated.length === 0) return Effect.succeed("");
+		const links = changesets.map((changeset) => {
+			const commit = shortCommit(changeset.commit);
+			return `- Updated dependencies${commit === void 0 ? "" : ` [${commit}]`}`;
+		});
+		const list = dependenciesUpdated.map((dependency) => `  - ${dependency.name}@${dependency.newVersion}`);
+		return Effect.succeed([...links, ...list].join("\n"));
+	}
+};
+const bumpLevel = {
+	none: 0,
+	patch: 1,
+	minor: 2,
+	major: 3
+};
+/** `shouldUpdateDependencyBasedOnConfig`. */
+const shouldUpdateDependency = (release, depVersionRange, depType, options) => {
+	if (release.newVersion === void 0) return false;
+	const workspace = depVersionRange.startsWith("workspace:");
+	const stripped = workspace ? depVersionRange.slice(10) : depVersionRange;
+	if (workspace && stripped === "*") return true;
+	if (workspace && stripped !== "^" && stripped !== "~" && !isValidRange(stripped)) return normalizePath(stripped) === release.relativeDir;
+	const range = workspace && (stripped === "^" || stripped === "~") ? `${stripped}${release.oldVersion}` : stripped;
+	if (!satisfies(release.newVersion, range)) return true;
+	if (depType === "peerDependencies") return !options.onlyUpdatePeerDependentsWhenOutOfRange;
+	return bumpLevel[release.type] >= bumpLevel[options.updateInternalDependencies];
+};
+const normalizePath = (path) => path.split("/").reduce((parts, part) => {
+	if (part === "" || part === ".") return parts;
+	if (part === ".." && parts.length > 0 && parts.at(-1) !== "..") return parts.slice(0, -1);
+	return [...parts, part];
+}, []).join("/") || ".";
+const capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+/** `generateMarkdownForVersionType`: joins release lines, keeping at most one blank line between them. */
+const markdownForType = (type, lines) => {
+	const releaseLines = lines.filter((line) => line);
+	if (releaseLines.length === 0) return void 0;
+	return releaseLines.reduce(({ content, newLines }, line) => {
+		const leading = newLines + (/^\n*/.exec(line)?.[0].length ?? 0);
+		return {
+			content: content + "\n".repeat(Math.min(Math.max(leading, 1), 2)) + line.trim(),
+			newLines: /\n*$/.exec(line)?.[0].length ?? 0
+		};
+	}, {
+		content: `### ${capitalize(type)} Changes`,
+		newLines: 2
+	}).content;
+};
+/** `getChangelogEntry` for one release; `undefined` for a release that does not bump. */
+const changelogEntry = Effect.fn("changelogEntry")(function* (release, releases, changesets, functions, functionOptions, options) {
+	if (release.type === "none") return void 0;
+	const linesOf = (type) => Effect.forEach(changesets.flatMap((changeset) => {
+		const own = changeset.releases.find((r) => r.name === release.name);
+		return own !== void 0 && own.type === type ? [changeset] : [];
+	}), (changeset) => functions.getReleaseLine(changeset, type, functionOptions));
+	const dependentReleases = releases.filter((rel) => {
+		const dependencyRange = release.packageJson.dependencies?.[rel.name];
+		const peerRange = release.packageJson.peerDependencies?.[rel.name];
+		const versionRange = dependencyRange || peerRange;
+		return versionRange !== void 0 && versionRange !== "" && (versionRange.startsWith("workspace:") || isValidRange(versionRange)) && shouldUpdateDependency(rel, versionRange, dependencyRange ? "dependencies" : "peerDependencies", options);
+	});
+	const relevantIds = new Set(dependentReleases.flatMap((rel) => rel.changesets));
+	const major = yield* linesOf("major");
+	const minor = yield* linesOf("minor");
+	const patch = yield* linesOf("patch");
+	const dependencyLine = yield* functions.getDependencyReleaseLine(changesets.filter((changeset) => relevantIds.has(changeset.id)), dependentReleases, functionOptions);
+	const rendered = [
+		`## ${release.newVersion}`,
+		markdownForType("major", major),
+		markdownForType("minor", minor),
+		markdownForType("patch", [...patch, dependencyLine])
+	].filter((line) => line !== void 0 && line !== "");
+	return (rendered.length === 1 ? [...rendered, "No changes in this release."] : rendered).join("\n\n");
+});
+/** `updateChangelog`: the new entry goes above the first version heading, or under the title. */
+const prependEntry = (existing, entry, packageName) => {
+	const template = `\n\n${entry.trim()}\n`;
+	if (existing === void 0 || existing === "") return `# ${packageName}${template}`;
+	const firstVersionHeading = existing.search(/^#{1,6}\s+\d+\.\d+/m);
+	if (firstVersionHeading >= 0) return existing.slice(0, firstVersionHeading) + template.trimStart() + "\n" + existing.slice(firstVersionHeading);
+	const newline = existing.indexOf("\n");
+	return newline === -1 ? existing + template : existing.slice(0, newline) + template + existing.slice(newline + 1);
+};
+// src/types.ts
+const DEPENDENCY_TYPES = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+// src/dependents.ts
+/** `@changesets/get-dependents-graph`: which workspace packages depend on which. */
+const allDependencies = (json, ignoreDevDependencies) => DEPENDENCY_TYPES.reduce((all, type) => {
+	Object.entries(json[type] ?? {}).forEach(([name, range]) => {
+		if (type === "devDependencies" && (ignoreDevDependencies || range.startsWith("link:") || range.startsWith("file:"))) return;
+		all.set(name, range);
+	});
+	return all;
+}, /* @__PURE__ */ new Map());
+const isProtocolRange = (range) => range.includes(":");
+const isUsableRange = (range) => !isProtocolRange(range) && isValidRange(range);
+const normalizePosix = (path) => path.split("/").reduce((parts, part) => {
+	if (part === "" || part === ".") return parts;
+	if (part === ".." && parts.length > 0 && parts.at(-1) !== "..") return parts.slice(0, -1);
+	return [...parts, part];
+}, []).join("/") || ".";
+const relativeDirOf = (rootDir, pkg) => pkg.dir === rootDir ? "." : pkg.dir.slice(rootDir.length + 1).replaceAll("\\", "/");
+const workspacePathMatches = (range, rootDir, pkg) => normalizePosix(range) === relativeDirOf(rootDir, pkg);
+const dependenciesOf = (pkg, byName, rootDir, options, invalid) => [...allDependencies(pkg.packageJson, options.ignoreDevDependencies ?? false)].flatMap(([name, rawRange]) => {
+	const match = byName.get(name);
+	if (match === void 0) return [];
+	const expected = match.packageJson.version;
+	const report = () => {
+		invalid.push(`Package ${pkg.packageJson.name} must depend on the current version of ${name}: ${expected} vs ${rawRange}`);
+		return [];
+	};
+	if (rawRange.startsWith("workspace:")) {
+		const range = rawRange.slice(10);
+		if (range === "*" || range === "^" || range === "~") return [name];
+		if (workspacePathMatches(range, rootDir, match)) return [name];
+		if (!isUsableRange(range)) return report();
+		return satisfies(expected, range) ? [name] : report();
+	}
+	if (options.bumpVersionsWithWorkspaceProtocolOnly === true) return [];
+	if (isProtocolRange(rawRange)) return report();
+	if (!isUsableRange(rawRange)) return [];
+	return satisfies(expected, rawRange) ? [name] : report();
+});
+const dependentsGraph = (packages, options = {}) => {
+	const byName = new Map([[packages.rootPackage.packageJson.name, packages.rootPackage], ...packages.packages.map((pkg) => [pkg.packageJson.name, pkg])]);
+	const invalid = [];
+	const graph = new Map([[packages.rootPackage.packageJson.name, []], ...packages.packages.map((pkg) => [pkg.packageJson.name, []])]);
+	dependenciesOf(packages.rootPackage, byName, packages.rootDir, options, invalid);
+	packages.packages.forEach((pkg) => {
+		dependenciesOf(pkg, byName, packages.rootDir, options, invalid).forEach((dependency) => graph.get(dependency)?.push(pkg.packageJson.name));
+	});
+	return {
+		graph,
+		invalid
+	};
+};
+// src/config.ts
+/** `.changeset/config.json`: the written schema, its defaults, and the `@changesets/config` rules. */
+const ModuleTuple = Schema.Tuple([Schema.String, Schema.NullOr(Schema.Record(Schema.String, Schema.Unknown))]);
+const WrittenConfig = Schema.Struct({
+	baseBranch: Schema.optionalKey(Schema.String),
+	access: Schema.optionalKey(Schema.Literals(["public", "restricted"])),
+	changedFilePatterns: Schema.optionalKey(Schema.Array(Schema.String)),
+	format: Schema.optionalKey(Schema.Literals([
+		"auto",
+		"prettier",
+		"oxfmt",
+		"deno",
+		"dprint",
+		false
+	])),
+	ignore: Schema.optionalKey(Schema.Array(Schema.String)),
+	fixed: Schema.optionalKey(Schema.Array(Schema.Array(Schema.String))),
+	linked: Schema.optionalKey(Schema.Array(Schema.Array(Schema.String))),
+	updateInternalDependencies: Schema.optionalKey(Schema.Literals(["minor", "patch"])),
+	privatePackages: Schema.optionalKey(Schema.Union([Schema.Struct({
+		version: Schema.optionalKey(Schema.Boolean),
+		tag: Schema.optionalKey(Schema.Boolean)
+	}), Schema.Boolean])),
+	bumpVersionsWithWorkspaceProtocolOnly: Schema.optionalKey(Schema.Boolean),
+	snapshot: Schema.optionalKey(Schema.Struct({
+		useCalculatedVersion: Schema.optionalKey(Schema.Boolean),
+		prereleaseTemplate: Schema.optionalKey(Schema.String)
+	})),
+	changelog: Schema.optionalKey(Schema.Union([
+		Schema.Literal(false),
+		Schema.String,
+		ModuleTuple
+	])),
+	commit: Schema.optionalKey(Schema.Union([
+		Schema.Boolean,
+		Schema.String,
+		ModuleTuple
+	])),
+	___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH: Schema.optionalKey(Schema.Struct({
+		onlyUpdatePeerDependentsWhenOutOfRange: Schema.optionalKey(Schema.Boolean),
+		updateInternalDependents: Schema.optionalKey(Schema.Literals(["always", "out-of-range"]))
+	}))
+});
+/** A picomatch-style matcher: a `!pattern` matches what `pattern` does not. */
+const matcher = (pattern) => {
+	const negated = pattern.startsWith("!");
+	const glob = Glob.make(negated ? pattern.slice(1) : pattern);
+	return {
+		negated,
+		test: (value) => negated !== Glob.match(glob, value)
+	};
+};
+/** changesets' glob reduction: a positive pattern admits, a later `!pattern` it matches takes back. */
+const matchesPatterns = (value, patterns) => patterns.map(matcher).reduce((passed, m) => passed ? !(m.negated && !m.test(value)) : !m.negated && m.test(value), false);
+const globMatch = (names, patterns) => names.filter((name) => matchesPatterns(name, patterns));
+const moduleReference = (value, fallback) => {
+	if (value === void 0) return fallback;
+	if (typeof value === "string") return [value, null];
+	if (value === true) return ["@changesets/cli/commit", { skipCI: "version" }];
+	return value;
+};
+/** `normalizeWrittenConfig`: fills defaults and expands package-name globs. */
+const normalizeConfig = (written, packageNames) => ({
+	baseBranch: written.baseBranch ?? "main",
+	access: written.access ?? "restricted",
+	changedFilePatterns: written.changedFilePatterns ?? ["**"],
+	format: written.format ?? "auto",
+	ignore: globMatch(packageNames, written.ignore ?? []),
+	fixed: (written.fixed ?? []).map((group) => globMatch(packageNames, group)),
+	linked: (written.linked ?? []).map((group) => globMatch(packageNames, group)),
+	updateInternalDependencies: written.updateInternalDependencies ?? "patch",
+	privatePackages: typeof written.privatePackages === "boolean" ? {
+		version: written.privatePackages,
+		tag: written.privatePackages
+	} : {
+		version: written.privatePackages?.version ?? false,
+		tag: written.privatePackages?.tag ?? false
+	},
+	bumpVersionsWithWorkspaceProtocolOnly: written.bumpVersionsWithWorkspaceProtocolOnly ?? false,
+	snapshot: {
+		useCalculatedVersion: written.snapshot?.useCalculatedVersion ?? false,
+		prereleaseTemplate: written.snapshot?.prereleaseTemplate
+	},
+	changelog: moduleReference(written.changelog, ["@changesets/cli/changelog", null]),
+	commit: moduleReference(written.commit, false),
+	onlyUpdatePeerDependentsWhenOutOfRange: written.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH?.onlyUpdatePeerDependentsWhenOutOfRange ?? false,
+	updateInternalDependents: written.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH?.updateInternalDependents ?? "out-of-range"
+});
+/** `shouldSkipPackage`: ignored, private without `privatePackages.version`, or versionless. */
+const shouldSkipPackage = ({ packageJson }, { ignore, allowPrivatePackages }) => ignore.includes(packageJson.name) || packageJson.private === true && !allowPrivatePackages || !packageJson.version;
+const skipOptions = (config) => ({
+	ignore: config.ignore,
+	allowPrivatePackages: config.privatePackages.version
+});
+const picomatchNote = `Note that glob expressions must be defined according to https://npmx.dev/picomatch.`;
+const unmatched = (patterns, names) => patterns.filter((pattern) => !names.some((name) => matcher(pattern).test(name)));
+const duplicates = (groups) => {
+	const flat = groups.flat();
+	return [...new Set(flat.filter((name, index) => flat.indexOf(name) !== index))];
+};
+/** The `@changesets/config` validation rules, in the same order and wording. */
+const validateConfig = (config, written, packages) => {
+	const names = packages.packages.map((pkg) => pkg.packageJson.name);
+	const groupWarnings = (kind, groups) => config[kind].length === 0 ? [] : (groups ?? []).flatMap((group) => unmatched(group, names).map((pattern) => `${kind}: Invalid path: The package or glob "${pattern}" does not match any package in the project. ${picomatchNote}`));
+	const groupErrors = (kind) => duplicates(config[kind]).map((name) => `${kind}: Invalid group: The package or glob "${name}" is defined in multiple groups of ${kind} packages. Packages can only be belong to a single group. ${picomatchNote}`);
+	const linkedNames = new Set(config.linked.flat());
+	const fixedAndLinked = config.fixed.length === 0 || config.linked.length === 0 ? [] : [...new Set(config.fixed.flat())].filter((name) => linkedNames.has(name)).map((name) => `Invalid group: The package "${name}" can be found in both fixed and linked groups. A package can only be either fixed or linked.`);
+	const skipped = config.ignore.length === 0 && config.privatePackages.version ? [] : skippedDependentErrors(packages, config).map(({ dependent, skipped }) => `Invalid tree: "${dependent}" depends on the skipped package "${skipped}", but "${dependent}" is not skipped. Please add "${dependent}" to the "ignore" option.`);
+	const privateTag = config.privatePackages.version === false && config.privatePackages.tag === true ? [`privatePackages: Invalid combination: "tag" is set to "true" but "version" is set to "false".`] : [];
+	return {
+		warnings: [...groupWarnings("fixed", written.fixed), ...groupWarnings("linked", written.linked)],
+		errors: [
+			...groupErrors("fixed"),
+			...groupErrors("linked"),
+			...fixedAndLinked,
+			...skipped,
+			...privateTag
+		]
+	};
+};
+/** Public packages that depend (outside devDependencies) on a package changesets skips. */
+const skippedDependentErrors = (packages, config) => {
+	const graph = dependentsGraph(packages, {
+		ignoreDevDependencies: true,
+		bumpVersionsWithWorkspaceProtocolOnly: config.bumpVersionsWithWorkspaceProtocolOnly
+	}).graph;
+	const byName = new Map(packages.packages.map((pkg) => [pkg.packageJson.name, pkg]));
+	return packages.packages.filter((pkg) => shouldSkipPackage(pkg, skipOptions(config))).flatMap((pkg) => (graph.get(pkg.packageJson.name) ?? []).flatMap((dependent) => {
+		const dependentPkg = byName.get(dependent);
+		return dependentPkg === void 0 || shouldSkipPackage(dependentPkg, skipOptions(config)) || dependentPkg.packageJson.private === true ? [] : [{
+			dependent,
+			skipped: pkg.packageJson.name
+		}];
+	}));
+};
+// src/dependency-edits.ts
+/** Which internal dependency ranges `changeset version` rewrites, and to what. */
+const rangeType = (range) => {
+	if (range.startsWith("^")) return "^";
+	if (range.startsWith("~")) return "~";
+	if (range.startsWith(">=")) return ">=";
+	if (range.startsWith("<=")) return "<=";
+	if (range.startsWith(">")) return ">";
+	return "";
+};
+/** `getNewDependencyRange`: keep the range's operator, or move both bounds of `>=a <b`. */
+const newDependencyRange = (range, newVersion, type) => {
+	const sets = rangeComparators(range);
+	const comparators = sets.length === 1 ? sets[0] ?? [] : [];
+	if (comparators.length === 2 && range.includes(">") && range.includes("<")) {
+		const lower = comparators.find(({ operator }) => operator.startsWith(">"));
+		const upper = comparators.find(({ operator }) => operator.startsWith("<"));
+		if (lower !== void 0 && upper !== void 0) {
+			const newUpper = satisfies(newVersion, upper.value) ? upper.value : `<${increment(newVersion, type)}`;
+			return comparators[0] === lower ? `>=${newVersion} ${newUpper}` : `${newUpper} >=${newVersion}`;
+		}
+	}
+	return `${rangeType(range)}${newVersion}`;
+};
+/** `getDependencyVersionEdits` for one manifest against every release in the plan. */
+const dependencyEdits = (packageJson, releases, options) => DEPENDENCY_TYPES.flatMap((depType) => {
+	const deps = packageJson[depType];
+	if (deps === void 0) return [];
+	return releases.flatMap((release) => {
+		const { name, newVersion, type } = release;
+		if (newVersion === void 0 || type === "none") return [];
+		const current = deps[name];
+		if (!current || current.startsWith("file:") || current.startsWith("link:") || !shouldUpdateDependency(release, current, depType, options)) return [];
+		const workspace = current.startsWith("workspace:");
+		if (!workspace && (options.bumpVersionsWithWorkspaceProtocolOnly || !isValidRange(current))) return [];
+		const range = workspace ? current.slice(10) : current;
+		if (workspace && (range === "*" || range === "^" || range === "~" || !isValidRange(range))) return [];
+		if (isAnyRange(range) && !isPrerelease(newVersion)) return [];
+		const next = newDependencyRange(range, newVersion, type);
+		return [{
+			keys: [depType, name],
+			value: workspace ? `workspace:${next}` : next
+		}];
+	});
+});
+// src/errors.ts
+/** A `.changeset/*.md` file that changesets itself would also reject. */
+var ChangesetParseError = class extends Schema.TaggedError()("@maple-dev/changesets/ChangesetParseError", {
+	message: Schema.String,
+	file: Schema.String
+}) {};
+/** `.changeset/config.json` is missing, malformed, or breaks one of the config rules. */
+var ConfigError = class extends Schema.TaggedError()("@maple-dev/changesets/ConfigError", {
+	message: Schema.String,
+	problems: Schema.Array(Schema.String)
+}) {};
+/** The workspace root or one of its package manifests could not be read. */
+var WorkspaceError = class extends Schema.TaggedError()("@maple-dev/changesets/WorkspaceError", {
+	message: Schema.String,
+	path: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/** The changesets and the workspace disagree, e.g. a changeset names an unknown package. */
+var ReleasePlanError = class extends Schema.TaggedError()("@maple-dev/changesets/ReleasePlanError", { message: Schema.String }) {};
+var GitError = class extends Schema.TaggedError()("@maple-dev/changesets/GitError", {
+	message: Schema.String,
+	args: Schema.Array(Schema.String),
+	stderr: Schema.String
+}) {};
+var FormatterError = class extends Schema.TaggedError()("@maple-dev/changesets/FormatterError", {
+	message: Schema.String,
+	formatter: Schema.String,
+	stderr: Schema.String
+}) {};
+var JsonEditError = class extends Schema.TaggedError()("@maple-dev/changesets/JsonEditError", {
+	message: Schema.String,
+	file: Schema.String
+}) {};
+var ChangelogError = class extends Schema.TaggedError()("@maple-dev/changesets/ChangelogError", {
+	message: Schema.String,
+	module: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/** A changesets feature this tool deliberately does not implement (pre mode, snapshots, commit). */
+var UnsupportedFeatureError = class extends Schema.TaggedError()("@maple-dev/changesets/UnsupportedFeatureError", {
+	message: Schema.String,
+	feature: Schema.String
+}) {};
+/** An expected non-zero exit that changesets reports the same way, e.g. "No unreleased changesets found." */
+var CommandExit = class extends Schema.TaggedError()("@maple-dev/changesets/CommandExit", {
+	message: Schema.String,
+	code: Schema.Number
+}) {};
+// src/formatter.ts
+/**
+* `@changesets/format`: with `format: "auto"`, changesets formats the CHANGELOG.md files it
+* wrote (and new changeset files) with the project's formatter, run through the package manager.
+* Detection walks up from the root: config files first, then an installed formatter package.
+*/
+const formatters = {
+	dprint: {
+		packageName: "dprint",
+		configFiles: [
+			"dprint.json",
+			"dprint.jsonc",
+			".dprint.json",
+			".dprint.jsonc"
+		],
+		args: (files) => [
+			"dprint",
+			"fmt",
+			"--allow-no-files",
+			...files
+		]
+	},
+	deno: {
+		packageName: void 0,
+		configFiles: [
+			"deno.json",
+			"deno.jsonc",
+			{
+				file: "deno.json",
+				key: "fmt"
+			}
+		],
+		args: (files) => [
+			"fmt",
+			"--permit-no-files",
+			...files
+		]
+	},
+	oxfmt: {
+		packageName: "oxfmt",
+		configFiles: [
+			".oxfmtrc.json",
+			".oxfmtrc.jsonc",
+			"oxfmt.config.ts",
+			"oxfmt.config.mts"
+		],
+		args: (files) => [
+			"oxfmt",
+			"--write",
+			"--no-error-on-unmatched-pattern",
+			...files
+		]
+	},
+	prettier: {
+		packageName: "prettier",
+		configFiles: [
+			".prettierrc",
+			...[
+				"json",
+				"yml",
+				"yaml",
+				"json5",
+				"js",
+				"ts",
+				"mjs",
+				"mts",
+				"cjs",
+				"cts",
+				"toml"
+			].map((ext) => `.prettierrc.${ext}`),
+			...[
+				"js",
+				"ts",
+				"mjs",
+				"mts",
+				"cjs",
+				"cts"
+			].map((ext) => `prettier.config.${ext}`),
+			{
+				file: "package.json",
+				key: "prettier"
+			}
+		],
+		args: (files) => [
+			"prettier",
+			"--write",
+			"--no-error-on-unmatched-pattern",
+			...files
+		]
+	}
+};
+const detectOrder = [
+	"dprint",
+	"deno",
+	"oxfmt",
+	"prettier"
+];
+const locks = [
+	["bun.lock", "bun"],
+	["bun.lockb", "bun"],
+	["deno.lock", "deno"],
+	["pnpm-lock.yaml", "pnpm"],
+	["pnpm-workspace.yaml", "pnpm"],
+	["yarn.lock", "yarn"],
+	["package-lock.json", "npm"],
+	["npm-shrinkwrap.json", "npm"]
+];
+const executeLocal = (agent, args) => {
+	switch (agent) {
+		case "bun": return ["bun", ["x", ...args]];
+		case "pnpm": return ["pnpm", ["exec", ...args]];
+		case "yarn": return ["yarn", ["exec", ...args]];
+		case "deno": return ["deno", [
+			"task",
+			"--eval",
+			...args
+		]];
+		case "npm": return ["npx", args];
+	}
+};
+const PackageManagerField = Schema.Struct({ packageManager: Schema.optionalKey(Schema.String) });
+const decodeKeys = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown)));
+const decodePackageManager = Schema.decodeUnknownOption(Schema.fromJsonString(PackageManagerField));
+var Formatter = class extends Context.Service()("@maple-dev/changesets/Formatter", { make: Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const exists = (file) => fs.exists(file).pipe(Effect.orElseSucceed(() => false));
+	const readText = (file) => fs.readFileString(file).pipe(Effect.option);
+	const ancestors = (dir) => {
+		const parent = path.dirname(dir);
+		return parent === dir ? [dir] : [dir, ...ancestors(parent)];
+	};
+	const firstSome = (items, f) => {
+		const [head, ...rest] = items;
+		if (head === void 0) return Effect.succeed(Option.none());
+		return Effect.flatMap(f(head), (found) => Option.isSome(found) ? Effect.succeed(found) : firstSome(rest, f));
+	};
+	const hasConfig = (dir, configFile) => typeof configFile === "string" ? exists(path.join(dir, configFile)) : Effect.map(readText(path.join(dir, configFile.file)), (text) => Option.isSome(Option.flatMap(text, decodeKeys).pipe(Option.filter((keys) => configFile.key in keys))));
+	const byConfig = (dir) => firstSome(detectOrder, (name) => Effect.map(Effect.forEach(formatters[name].configFiles, (configFile) => hasConfig(dir, configFile)), (found) => found.some(Boolean) ? Option.some(name) : Option.none()));
+	const byPackage = (dir) => firstSome(detectOrder, (name) => {
+		const packageName = formatters[name].packageName;
+		return packageName === void 0 ? Effect.succeed(Option.none()) : Effect.map(exists(path.join(dir, "node_modules", packageName)), (found) => found ? Option.some(name) : Option.none());
+	});
+	const detect = Effect.fn("Formatter.detect")(function* (format, rootDir) {
+		if (format === false) return Option.none();
+		if (format !== "auto") return Option.some(format);
+		const dirs = ancestors(path.resolve(rootDir));
+		const configured = yield* firstSome(dirs, byConfig);
+		return Option.isSome(configured) ? configured : yield* firstSome(dirs, byPackage);
+	});
+	const packageManagerIn = (dir) => Effect.map(readText(path.join(dir, "package.json")), (text) => Option.flatMap(Option.flatMap(text, decodePackageManager), (json) => Option.fromNullishOr(json.packageManager?.split("@")[0]).pipe(Option.filter((agent) => [
+		"bun",
+		"deno",
+		"pnpm",
+		"yarn",
+		"npm"
+	].includes(agent)))));
+	const agentFor = (rootDir) => Effect.map(firstSome(ancestors(path.resolve(rootDir)), (dir) => Effect.gen(function* () {
+		const lock = yield* firstSome(locks.map(([file]) => file), (file) => Effect.map(exists(path.join(dir, file)), (found) => found ? Option.some(file) : Option.none()));
+		const declared = yield* packageManagerIn(dir);
+		if (Option.isSome(lock)) {
+			const fromLock = locks.find(([file]) => file === lock.value)?.[1] ?? "npm";
+			return Option.some(Option.getOrElse(declared, () => fromLock));
+		}
+		return declared;
+	})), Option.getOrElse(() => "npm"));
+	return {
+		detect,
+		format: Effect.fn("Formatter.format")(function* (config, rootDir, files) {
+			const name = yield* detect(config, rootDir);
+			if (Option.isNone(name) || files.length === 0) return;
+			const spec = formatters[name.value];
+			const [command, args] = name.value === "deno" ? ["deno", spec.args(files)] : executeLocal(yield* agentFor(rootDir), spec.args(files));
+			const result = yield* Effect.scoped(Effect.gen(function* () {
+				const handle = yield* spawner.spawn(ChildProcess.make(command, [...args], { cwd: rootDir }));
+				const [, stderr, exitCode] = yield* Effect.all([
+					Stream.runDrain(handle.stdout),
+					Stream.mkString(Stream.decodeText(handle.stderr)),
+					handle.exitCode
+				], { concurrency: "unbounded" });
+				return {
+					stderr,
+					exitCode: Number(exitCode)
+				};
+			})).pipe(Effect.mapError((cause) => new FormatterError({
+				message: `Could not run ${command}: ${cause.message}`,
+				formatter: name.value,
+				stderr: ""
+			})));
+			if (result.exitCode !== 0) return yield* new FormatterError({
+				message: `${[command, ...args.slice(0, 2)].join(" ")} exited with code ${result.exitCode}`,
+				formatter: name.value,
+				stderr: result.stderr
+			});
+		})
+	};
+}) }) {
+	static layer = Layer.effect(this, this.make);
+};
+// src/frontmatter.ts
+/**
+* `@changesets/parse` without a YAML dependency. The frontmatter grammar covers what changesets
+* accepts in practice: a block or flow mapping of plain, single- or double-quoted package names to
+* release types, with comments and folded values. Anything else is reported as invalid YAML.
+*/
+const isSpace = (char) => /^\s$/.test(char);
+/** For each index, the first index at or after it whose character is not whitespace (or `length`). */
+const nextNonSpaceIndex = (text) => Array.from({ length: text.length }, (_, i) => i).reduceRight((next, i) => {
+	next[i] = isSpace(text.charAt(i)) ? next[i + 1] ?? text.length : i;
+	return next;
+}, Array(text.length + 1).fill(text.length));
+/**
+* `@changesets/parse`'s `/\s*---([^]*?)\r?\n\s*---(\s*(?:\n|$)[^]*)/` as one linear scan.
+* Only the first `---` can open a match: a later one has a subset of the same closing lines.
+* The closing line is the first `\n` (or `\r\n`) then optional whitespace then `---`, followed
+* by whitespace that holds a newline or runs to the end.
+*/
+const splitFrontmatter = (text) => {
+	const opener = text.indexOf("---");
+	if (opener === -1) return void 0;
+	const start = opener + 3;
+	const nextNonSpace = nextNonSpaceIndex(text);
+	const closes = (e) => {
+		const lineStart = text.startsWith("\r\n", e) ? e + 2 : text.charAt(e) === "\n" ? e + 1 : -1;
+		if (lineStart === -1) return void 0;
+		const dashes = nextNonSpace[lineStart] ?? text.length;
+		if (!text.startsWith("---", dashes)) return void 0;
+		const after = dashes + 3;
+		const end = nextNonSpace[after] ?? text.length;
+		const newline = text.indexOf("\n", after);
+		return end === text.length || newline !== -1 && newline < end ? after : void 0;
+	};
+	const close = Array.from({ length: Math.max(text.length - start, 0) }, (_, i) => start + i).find((e) => closes(e) !== void 0);
+	if (close === void 0) return void 0;
+	return {
+		releases: text.slice(start, close),
+		summary: text.slice(closes(close))
+	};
+};
+const EXAMPLE_FORMAT = `---\n"package-name": patch\n---`;
+const validVersionTypes = [
+	"major",
+	"minor",
+	"patch",
+	"none"
+];
+const truncate = (s, max = 200) => s.length > max ? s.slice(0, max) + "..." : s;
+const resolvePlain = (text) => {
+	if (/^(~|null|Null|NULL)?$/.test(text)) return null;
+	if (/^(true|True|TRUE)$/.test(text)) return true;
+	if (/^(false|False|FALSE)$/.test(text)) return false;
+	if (/^[-+]?[0-9]+$/.test(text)) return Number.parseInt(text, 10);
+	if (/^0o[0-7]+$/.test(text)) return Number.parseInt(text.slice(2), 8);
+	if (/^0x[0-9a-fA-F]+$/.test(text)) return Number.parseInt(text.slice(2), 16);
+	if (/^[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?$/.test(text)) return Number.parseFloat(text);
+	if (/^[-+]?\.(inf|Inf|INF)$/.test(text)) return text.startsWith("-") ? -Infinity : Infinity;
+	if (/^\.(nan|NaN|NAN)$/.test(text)) return NaN;
+	return text;
+};
+const escapes = /* @__PURE__ */ new Map([
+	["0", "\0"],
+	["a", "\x07"],
+	["b", "\b"],
+	["t", "	"],
+	["	", "	"],
+	["n", "\n"],
+	["v", "\v"],
+	["f", "\f"],
+	["r", "\r"],
+	["e", "\x1B"],
+	[" ", " "],
+	["\"", "\""],
+	["/", "/"],
+	["\\", "\\"],
+	["N", "…"],
+	["_", "\xA0"],
+	["L", "\u2028"],
+	["P", "\u2029"]
+]);
+/** Reads a quoted scalar starting at `text[0]`; returns the value and the rest of the line. */
+const readQuoted = (text) => {
+	const quote = text[0];
+	const chars = Array.from(text.slice(1));
+	const read = (index, value) => {
+		const char = chars[index];
+		if (char === void 0) return Result.fail("Missing closing quote");
+		if (quote === "'") {
+			if (char !== "'") return read(index + 1, value + char);
+			return chars[index + 1] === "'" ? read(index + 2, value + "'") : Result.succeed({
+				value,
+				rest: chars.slice(index + 1).join("")
+			});
+		}
+		if (char === "\"") return Result.succeed({
+			value,
+			rest: chars.slice(index + 1).join("")
+		});
+		if (char !== "\\") return read(index + 1, value + char);
+		const escape = chars[index + 1] ?? "";
+		const hexLength = escape === "x" ? 2 : escape === "u" ? 4 : escape === "U" ? 8 : 0;
+		if (hexLength > 0) {
+			const hex = chars.slice(index + 2, index + 2 + hexLength).join("");
+			return new RegExp(`^[0-9a-fA-F]{${hexLength}}$`).test(hex) ? read(index + 2 + hexLength, value + String.fromCodePoint(Number.parseInt(hex, 16))) : Result.fail("Invalid escape sequence");
+		}
+		const replacement = escapes.get(escape);
+		return replacement === void 0 ? Result.fail(`Invalid escape sequence \\${escape}`) : read(index + 2, value + replacement);
+	};
+	return read(0, "");
+};
+const stripComment = (text) => {
+	const at = text.search(/(?:^|\s)#/);
+	return (at === -1 ? text : text.slice(0, at)).trim();
+};
+const isQuote = (text) => text.startsWith("\"") || text.startsWith("'");
+const readValue = (raw) => {
+	const text = raw.trim();
+	if (isQuote(text)) return Result.flatMap(readQuoted(text), ({ value, rest }) => stripComment(rest) === "" ? Result.succeed(value) : Result.fail("Unexpected content after a quoted scalar"));
+	if (text.startsWith("[") || text.startsWith("{")) return Result.succeed("object");
+	if (/^[&*!|>%@`]/.test(text)) return Result.fail(`Unsupported YAML syntax: ${truncate(text, 40)}`);
+	const plain = stripComment(text);
+	return /:(\s|$)/.test(plain) ? Result.fail("Nested mappings are not allowed in compact mappings") : Result.succeed(resolvePlain(plain));
+};
+/** Reads `key:` at the start of `line`; `undefined` when the line is not a mapping entry. */
+const readKey = (line) => {
+	if (isQuote(line)) return Result.map(readQuoted(line), ({ value, rest }) => {
+		const colon = /^\s*:(\s|$)/.exec(rest);
+		return colon === null ? void 0 : {
+			key: value,
+			rest: rest.slice(colon[0].length)
+		};
+	});
+	const colon = /:(\s|$)/.exec(line);
+	if (colon === null) return Result.succeed(void 0);
+	const key = line.slice(0, colon.index).trim();
+	if (/^[&*!|>%@`[\]{},#]/.test(key) || /^[-?:]\s/.test(key)) return Result.fail(`Plain value cannot start with reserved character ${key[0]}`);
+	const resolved = resolvePlain(key);
+	return Result.succeed({
+		key: resolved === null ? "" : String(resolved),
+		rest: line.slice(colon.index + 1)
+	});
+};
+const readFlowValue = (text) => {
+	if (isQuote(text)) return Result.map(readQuoted(text), ({ value, rest }) => ({
+		value,
+		after: rest
+	}));
+	const comma = text.indexOf(",");
+	const end = comma === -1 ? text.length : comma;
+	return Result.succeed({
+		value: resolvePlain(text.slice(0, end).trim()),
+		after: text.slice(end)
+	});
+};
+const parseFlowEntries = (rest, entries) => Result.gen(function* () {
+	const trimmed = rest.trimStart();
+	if (trimmed === "") return entries;
+	const keyed = yield* readKey(trimmed.replace(/^([^"',]*?):(?=[^\s])/, "$1: "));
+	if (keyed === void 0) return yield* Result.fail("Expected a key in the flow mapping");
+	const { value, after } = yield* readFlowValue(keyed.rest.trimStart());
+	const tail = after.trimStart();
+	if (tail !== "" && !tail.startsWith(",")) return yield* Result.fail("Expected , in the flow mapping");
+	return yield* parseFlowEntries(tail.slice(1), [...entries, {
+		key: keyed.key,
+		value
+	}]);
+});
+const parseFlowMapping = (text) => {
+	const body = text.trim();
+	return body.endsWith("}") ? parseFlowEntries(body.slice(1, -1), []) : Result.fail("Unterminated flow mapping");
+};
+const indentOf = (line) => /^[ \t]*/.exec(line)?.[0].length ?? 0;
+const readNestedValue = (nested) => Result.gen(function* () {
+	const first = nested[0]?.trim() ?? "";
+	if (first.startsWith("- ") || (yield* readKey(first)) !== void 0) return "object";
+	return yield* readValue(nested.map((line) => line.trim()).join(" "));
+});
+const parseBlockMapping = (lines) => {
+	const baseIndent = indentOf(lines[0] ?? "");
+	const step = (index, entries) => Result.gen(function* () {
+		const line = lines[index];
+		if (line === void 0) return entries;
+		if (indentOf(line) !== baseIndent) return yield* Result.fail("Bad indentation of a mapping entry");
+		const keyed = yield* readKey(line.trim());
+		if (keyed === void 0) return yield* Result.fail("Implicit map keys need to be followed by map values");
+		const end = lines.slice(index + 1).findIndex((next) => indentOf(next) <= baseIndent);
+		const nested = lines.slice(index + 1, end === -1 ? lines.length : index + 1 + end);
+		const inline = stripComment(keyed.rest) === "" ? "" : keyed.rest;
+		if (inline !== "" && nested.length > 0) return yield* Result.fail("Bad indentation of a mapping entry");
+		const value = nested.length === 0 ? yield* readValue(inline) : yield* readNestedValue(nested);
+		return yield* step(index + 1 + nested.length, [...entries, {
+			key: keyed.key,
+			value
+		}]);
+	});
+	return step(0, []);
+};
+const parseDocument$1 = (text) => Result.gen(function* () {
+	const lines = text.split(/\r?\n/).map((line) => line.replace(/\r$/, "")).filter((line) => line.trim() !== "" && !line.trim().startsWith("#"));
+	const first = lines[0]?.trim();
+	if (first === void 0) return { _tag: "Empty" };
+	if (first.startsWith("{")) return {
+		_tag: "Map",
+		entries: yield* parseFlowMapping(lines.map(stripComment).join(" "))
+	};
+	if (first.startsWith("- ") || first === "-" || first.startsWith("[")) return { _tag: "Other" };
+	if (lines.length === 1 && (yield* readKey(first)) === void 0) {
+		yield* readValue(first);
+		return { _tag: "Other" };
+	}
+	return {
+		_tag: "Map",
+		entries: yield* parseBlockMapping(lines)
+	};
+});
+const typeName = (value) => value === null || value === "object" ? "object" : typeof value;
+const validateReleases = (entries, contents) => {
+	const [first] = entries.flatMap((entry) => {
+		if (entry.key.trim() === "") return [`could not parse changeset - invalid package name in frontmatter.\nExpected a non-empty string for package name, but got: ${JSON.stringify(entry.key)}\nChangeset contents:\n${truncate(contents)}`];
+		if (typeof entry.value !== "string" || entry.value === "object") return [`could not parse changeset - invalid release type for package "${entry.key}".\nExpected a string for release type, but got: ${typeName(entry.value)}\nChangeset contents:\n${truncate(contents)}`];
+		if (!validVersionTypes.includes(entry.value)) return [`could not parse changeset - invalid version type ${JSON.stringify(entry.value)} for package "${entry.key}".\nValid version types are: ${validVersionTypes.join(", ")}\nChangeset contents:\n${truncate(contents)}`];
+		return [];
+	});
+	if (first !== void 0) return Result.fail(first);
+	return Result.succeed(entries.flatMap((entry) => entry.value === "major" || entry.value === "minor" || entry.value === "patch" || entry.value === "none" ? [{
+		name: entry.key,
+		type: entry.value
+	}] : []));
+};
+const readDocument = (yaml) => Result.flatMap(parseDocument$1(yaml), (document) => {
+	if (document._tag !== "Map") return Result.succeed(document);
+	const keys = document.entries.map((entry) => entry.key);
+	return new Set(keys).size === keys.length ? Result.succeed(document) : Result.fail("Map keys must be unique");
+});
+/** Parses one changeset file; the failure is the message changesets would print. */
+const parseChangesetFile = (contents) => {
+	const trimmedContents = contents.trim();
+	if (!trimmedContents) return Result.fail(`could not parse changeset - file is empty.\nChangesets must have frontmatter with package names and version types.\nExample:\n${EXAMPLE_FORMAT}\n\nYour changeset summary here.`);
+	const split = splitFrontmatter(contents);
+	if (split === void 0) return Result.fail(`could not parse changeset - missing or invalid frontmatter.\nChangesets must start with frontmatter delimited by "---".\nExample:\n${EXAMPLE_FORMAT}\n\nYour changeset summary here.\nReceived content:\n${truncate(trimmedContents)}`);
+	const { releases: roughReleases, summary: roughSummary } = split;
+	const summary = roughSummary.trim();
+	const document = readDocument(roughReleases);
+	if (Result.isFailure(document)) return Result.fail(`could not parse changeset - invalid YAML in frontmatter.\nThe frontmatter between the "---" delimiters must be valid YAML.\nYAML error: ${document.failure}\nFrontmatter content:\n${roughReleases}`);
+	if (document.success._tag === "Other") return Result.fail(`could not parse changeset - frontmatter must be an object mapping package names to version types.\nExpected format:\n${EXAMPLE_FORMAT}\nReceived:\n${roughReleases}`);
+	const entries = document.success._tag === "Empty" ? [] : document.success.entries;
+	return Result.map(validateReleases(entries, contents), (releases) => ({
+		releases,
+		summary
+	}));
+};
+// src/git.ts
+/** The git queries changesets makes (`@changesets/git`), over `effect/process`. */
+var Git = class extends Context.Service()("@maple-dev/changesets/Git", { make: Effect.gen(function* () {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const run = (args, cwd) => Effect.scoped(Effect.gen(function* () {
+		const handle = yield* spawner.spawn(ChildProcess.make("git", [...args], { cwd }));
+		const [stdout, stderr, exitCode] = yield* Effect.all([
+			Stream.mkString(Stream.decodeText(handle.stdout)),
+			Stream.mkString(Stream.decodeText(handle.stderr)),
+			handle.exitCode
+		], { concurrency: "unbounded" });
+		return {
+			exitCode: Number(exitCode),
+			stdout,
+			stderr
+		};
+	})).pipe(Effect.mapError((cause) => new GitError({
+		message: `Could not run git: ${cause.message}`,
+		args: [...args],
+		stderr: ""
+	})));
+	const runOk = (args, cwd, message) => Effect.flatMap(run(args, cwd), (result) => result.exitCode === 0 ? Effect.succeed(result.stdout) : Effect.fail(new GitError({
+		message,
+		args: [...args],
+		stderr: result.stderr
+	})));
+	const isShallow = Effect.fn("Git.isShallow")(function* (cwd) {
+		const output = (yield* run(["rev-parse", "--is-shallow-repository"], cwd)).stdout.trim();
+		if (output !== "--is-shallow-repository") return output === "true";
+		const gitDir = (yield* run(["rev-parse", "--git-dir"], cwd)).stdout.trim();
+		return yield* fs.exists(path.join(path.resolve(cwd, gitDir), "shallow")).pipe(Effect.orElseSucceed(() => false));
+	});
+	const lookup = (paths, cwd, found) => Effect.gen(function* () {
+		const infos = yield* Effect.forEach(paths, (gitPath) => Effect.map(run([
+			"log",
+			"--diff-filter=AC",
+			"--follow",
+			"--max-count=1",
+			"--pretty=format:%H:%p",
+			gitPath
+		], cwd), ({ stdout }) => {
+			const [commitSha = "", parentSha = ""] = stdout.split(":");
+			return {
+				gitPath,
+				commitSha,
+				parentSha
+			};
+		}), { concurrency: 8 });
+		const resolved = new Map(found);
+		infos.forEach((info) => {
+			if (info.commitSha && info.parentSha) resolved.set(info.gitPath, info.commitSha);
+		});
+		const missingParents = infos.filter((info) => info.commitSha && !info.parentSha);
+		if (missingParents.length === 0) return resolved;
+		if (yield* isShallow(cwd)) {
+			yield* runOk(["fetch", "--deepen=50"], cwd, "Could not deepen the shallow clone");
+			return yield* lookup(missingParents.map((info) => info.gitPath), cwd, resolved);
+		}
+		missingParents.forEach((info) => resolved.set(info.gitPath, info.commitSha));
+		return resolved;
+	});
+	const commitsThatAddFiles = Effect.fn("Git.commitsThatAddFiles")(function* (paths, cwd) {
+		const commits = yield* lookup(paths, cwd, /* @__PURE__ */ new Map());
+		return paths.map((gitPath) => commits.get(gitPath));
+	});
+	const divergedCommit = (ref, cwd) => Effect.map(runOk([
+		"merge-base",
+		ref,
+		"HEAD"
+	], cwd, `Failed to find where HEAD diverged from "${ref}". Does "${ref}" exist and it's synced with remote?`), (stdout) => stdout.trim());
+	return {
+		run,
+		commitsThatAddFiles,
+		changedFilesSince: Effect.fn("Git.changedFilesSince")(function* (ref, cwd) {
+			const diverged = yield* divergedCommit(ref, cwd);
+			const files = (yield* runOk([
+				"diff",
+				"--name-only",
+				"--no-relative",
+				diverged
+			], cwd, `Failed to diff against ${diverged}. Is ${diverged} a valid ref?`)).trim().split("\n").filter((file) => file);
+			const cdup = (yield* runOk(["rev-parse", "--show-cdup"], cwd, "Could not find the git root")).trim();
+			const repoRoot = path.resolve(cwd, cdup.replace(/\n|\r/g, ""));
+			return files.map((file) => path.resolve(repoRoot, file));
+		}),
+		changedChangesetFilesSince: Effect.fn("Git.changedChangesetFilesSince")(function* (ref, cwd) {
+			const diverged = yield* divergedCommit(ref, cwd);
+			return (yield* runOk([
+				"diff",
+				"--name-only",
+				"--diff-filter=d",
+				"--no-relative",
+				diverged
+			], cwd, `Failed to diff against ${diverged}`)).trim().split("\n").filter((file) => /\.changeset\/[^/]+\.md$/.test(file) || /\.changeset\/pre\/[^/]+\.md$/.test(file));
+		})
+	};
+}) }) {
+	static layer = Layer.effect(this, this.make);
+};
+// src/human-id.ts
+/** `adjective-nouns-verb` file names in the style of `human-id`, which changesets uses. */
+const adjectives = [
+	"brave",
+	"bright",
+	"calm",
+	"clean",
+	"clever",
+	"cool",
+	"cuddly",
+	"curly",
+	"cute",
+	"dirty",
+	"dry",
+	"eager",
+	"early",
+	"easy",
+	"empty",
+	"fair",
+	"fancy",
+	"fast",
+	"fluffy",
+	"free",
+	"fresh",
+	"friendly",
+	"funny",
+	"fuzzy",
+	"gentle",
+	"giant",
+	"good",
+	"great",
+	"green",
+	"happy",
+	"heavy",
+	"honest",
+	"hot",
+	"huge",
+	"kind",
+	"large",
+	"lazy",
+	"light",
+	"little",
+	"long",
+	"loud",
+	"lovely",
+	"lucky",
+	"mean",
+	"modern",
+	"neat",
+	"nice",
+	"odd",
+	"old",
+	"plenty",
+	"polite",
+	"proud",
+	"purple",
+	"quick",
+	"quiet",
+	"rare",
+	"red",
+	"rich",
+	"rotten",
+	"rude",
+	"shaggy",
+	"sharp",
+	"shiny",
+	"short",
+	"shy",
+	"silent",
+	"silly",
+	"slimy",
+	"slow",
+	"small",
+	"smart",
+	"smooth",
+	"soft",
+	"sour",
+	"spicy",
+	"strong",
+	"sweet",
+	"tall",
+	"tame",
+	"tasty",
+	"thick",
+	"thin",
+	"tidy",
+	"tiny",
+	"tough",
+	"twelve",
+	"violet",
+	"warm",
+	"weak",
+	"wet",
+	"whole",
+	"wicked",
+	"wide",
+	"wild",
+	"wise",
+	"witty",
+	"young"
+];
+const nouns = [
+	"ants",
+	"apes",
+	"apples",
+	"bags",
+	"bananas",
+	"bars",
+	"baths",
+	"beans",
+	"bears",
+	"beds",
+	"bees",
+	"berries",
+	"bikes",
+	"birds",
+	"boats",
+	"bobcats",
+	"books",
+	"boxes",
+	"buckets",
+	"bugs",
+	"buses",
+	"buttons",
+	"cameras",
+	"candles",
+	"carrots",
+	"cars",
+	"cats",
+	"chairs",
+	"cheetahs",
+	"chefs",
+	"cherries",
+	"chicken",
+	"clocks",
+	"clouds",
+	"coats",
+	"coins",
+	"cooks",
+	"cougars",
+	"cows",
+	"crabs",
+	"crews",
+	"cups",
+	"dancers",
+	"deer",
+	"dodos",
+	"dogs",
+	"dolls",
+	"donkeys",
+	"doors",
+	"dots",
+	"dragons",
+	"drinks",
+	"ducks",
+	"eagles",
+	"eels",
+	"eggs",
+	"experts",
+	"falcons",
+	"fans",
+	"feet",
+	"files",
+	"fireants",
+	"fish",
+	"flies",
+	"flowers",
+	"forks",
+	"foxes",
+	"frogs",
+	"garlics",
+	"geckos",
+	"geese",
+	"ghosts",
+	"gifts",
+	"goats",
+	"grapes",
+	"guests",
+	"hairs",
+	"hats",
+	"hornets",
+	"horses",
+	"houses",
+	"icons",
+	"insects",
+	"islands",
+	"jars",
+	"jeans",
+	"jobs",
+	"keys",
+	"kids",
+	"kings",
+	"kiwis",
+	"knives",
+	"ladybugs",
+	"lamps",
+	"laws",
+	"lemons",
+	"lies",
+	"lights",
+	"lions",
+	"lizards",
+	"llamas",
+	"maps",
+	"masks",
+	"meals",
+	"melons",
+	"mice",
+	"mirrors",
+	"moles",
+	"monkeys",
+	"moons",
+	"moose",
+	"mugs",
+	"mules",
+	"nails",
+	"news",
+	"nights",
+	"numbers",
+	"olives",
+	"onions",
+	"oranges",
+	"otters",
+	"owls",
+	"pandas",
+	"pans",
+	"pants",
+	"papayas",
+	"parents",
+	"parrots",
+	"paths",
+	"peaches",
+	"pears",
+	"peas",
+	"pens",
+	"pets",
+	"phones",
+	"pianos",
+	"pigs",
+	"pillows",
+	"planes",
+	"planets",
+	"plants",
+	"plums",
+	"points",
+	"poets",
+	"pots",
+	"pugs",
+	"queens",
+	"rabbits",
+	"radios",
+	"rats",
+	"ravens",
+	"rice",
+	"rings",
+	"rivers",
+	"rocks",
+	"roses",
+	"rules",
+	"schools",
+	"seals",
+	"seas",
+	"sheep",
+	"shirts",
+	"shoes",
+	"shrimps",
+	"singers",
+	"sloths",
+	"snails",
+	"snakes",
+	"socks",
+	"spiders",
+	"spies",
+	"spoons",
+	"squids",
+	"stamps",
+	"stars",
+	"steaks",
+	"suits",
+	"swans",
+	"tables",
+	"teachers",
+	"teams",
+	"teeth",
+	"terms",
+	"ties",
+	"tigers",
+	"toes",
+	"tools",
+	"towns",
+	"toys",
+	"trains",
+	"trees",
+	"turkeys",
+	"turtles",
+	"vans",
+	"walls",
+	"wasps",
+	"waves",
+	"ways",
+	"weeks",
+	"windows",
+	"wings",
+	"wolves",
+	"worms",
+	"zebras"
+];
+const verbs = [
+	"accept",
+	"add",
+	"admire",
+	"agree",
+	"allow",
+	"appear",
+	"argue",
+	"arrive",
+	"attack",
+	"attend",
+	"bake",
+	"bathe",
+	"battle",
+	"beam",
+	"beg",
+	"begin",
+	"behave",
+	"bet",
+	"boil",
+	"bow",
+	"brake",
+	"breathe",
+	"brush",
+	"build",
+	"burn",
+	"buy",
+	"call",
+	"camp",
+	"care",
+	"carry",
+	"change",
+	"cheat",
+	"check",
+	"cheer",
+	"chew",
+	"clap",
+	"clean",
+	"collect",
+	"compare",
+	"compete",
+	"complain",
+	"confess",
+	"construct",
+	"cough",
+	"count",
+	"cover",
+	"crash",
+	"cross",
+	"cry",
+	"dance",
+	"deliver",
+	"deny",
+	"design",
+	"destroy",
+	"develop",
+	"draw",
+	"dream",
+	"dress",
+	"drive",
+	"drop",
+	"eat",
+	"enjoy",
+	"exercise",
+	"explain",
+	"fail",
+	"fetch",
+	"film",
+	"fix",
+	"flash",
+	"float",
+	"fly",
+	"fold",
+	"fry",
+	"give",
+	"glow",
+	"greet",
+	"grin",
+	"grow",
+	"guess",
+	"hammer",
+	"hang",
+	"happen",
+	"heal",
+	"hear",
+	"help",
+	"hide",
+	"hope",
+	"hug",
+	"hunt",
+	"impress",
+	"invent",
+	"invite",
+	"itch",
+	"jam",
+	"jog",
+	"join",
+	"joke",
+	"judge",
+	"juggle",
+	"jump",
+	"kick",
+	"kiss",
+	"kneel",
+	"knock",
+	"know",
+	"laugh",
+	"lay",
+	"lead",
+	"learn",
+	"leave",
+	"lick",
+	"lie",
+	"listen",
+	"live",
+	"look",
+	"love",
+	"make",
+	"march",
+	"marry",
+	"matter",
+	"melt",
+	"mix",
+	"move",
+	"nail",
+	"notice",
+	"obey",
+	"occur",
+	"own",
+	"pay",
+	"peel",
+	"perform",
+	"play",
+	"poke",
+	"pretend",
+	"promise",
+	"provide",
+	"pull",
+	"punch",
+	"push",
+	"raise",
+	"rescue",
+	"rest",
+	"retire",
+	"return",
+	"rhyme",
+	"roll",
+	"rule",
+	"run",
+	"rush",
+	"say",
+	"scream",
+	"search",
+	"sell",
+	"serve",
+	"shake",
+	"share",
+	"shave",
+	"shine",
+	"shop",
+	"shout",
+	"sin",
+	"sing",
+	"sink",
+	"sip",
+	"sit",
+	"sleep",
+	"slide",
+	"smash",
+	"smell",
+	"smile",
+	"smoke",
+	"sneeze",
+	"sniff",
+	"sort",
+	"speak",
+	"spend",
+	"sparkle",
+	"stand",
+	"stare",
+	"start",
+	"stay",
+	"suffer",
+	"swim",
+	"switch",
+	"talk",
+	"taste",
+	"teach",
+	"tell",
+	"thank",
+	"think",
+	"tickle",
+	"trade",
+	"travel",
+	"try",
+	"turn",
+	"type",
+	"unite",
+	"vanish",
+	"visit",
+	"wait",
+	"walk",
+	"warn",
+	"wash",
+	"watch",
+	"wave",
+	"whisper",
+	"win",
+	"wink",
+	"wonder",
+	"work",
+	"worry",
+	"yawn",
+	"yell"
+];
+const pick = (words) => Effect.map(Random.nextIntBetween(0, words.length), (i) => words[i] ?? words[0] ?? "");
+const humanId = Effect.all([
+	pick(adjectives),
+	pick(nouns),
+	pick(verbs)
+]).pipe(Effect.map((parts) => parts.join("-")));
+// src/json-edit.ts
+/**
+* Formatting-preserving `package.json` edits, as `@changesets/apply-release-plan` does with
+* jsonc-parser: each edit replaces only the text of an existing value with `JSON.stringify(value)`.
+*/
+const skipWhitespace = (text, at) => {
+	return at + (/^[ \t\n\r]*/.exec(text.slice(at))?.[0].length ?? 0);
+};
+const stringPattern = /^"(?:[^"\\\u0000-\u001f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"/;
+const literalPattern = /^(?:true|false|null|-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][-+]?[0-9]+)?)/;
+const parseString = (text, at) => {
+	const match = stringPattern.exec(text.slice(at));
+	return match === null ? Result.fail(`Invalid string at offset ${at}`) : Result.succeed({
+		value: JSON.parse(match[0]),
+		end: at + match[0].length
+	});
+};
+const parseMembers = (text, at, close, member, members) => Result.gen(function* () {
+	const parsed = yield* member(skipWhitespace(text, at));
+	const next = skipWhitespace(text, parsed.end);
+	const all = [...members, parsed.value];
+	if (text[next] === ",") return yield* parseMembers(text, next + 1, close, member, all);
+	if (text[next] === close) return {
+		value: all,
+		end: next + 1
+	};
+	return yield* Result.fail(`Expected "," or "${close}" at offset ${next}`);
+});
+const parseValue = (text, at) => Result.gen(function* () {
+	const char = text[at];
+	if (char === "{") {
+		const first = skipWhitespace(text, at + 1);
+		if (text[first] === "}") return {
+			offset: at,
+			length: first + 1 - at,
+			properties: []
+		};
+		const members = yield* parseMembers(text, first, "}", (start) => parseProperty(text, start), []);
+		return {
+			offset: at,
+			length: members.end - at,
+			properties: members.value
+		};
+	}
+	if (char === "[") {
+		const first = skipWhitespace(text, at + 1);
+		if (text[first] === "]") return {
+			offset: at,
+			length: first + 1 - at,
+			properties: void 0
+		};
+		return {
+			offset: at,
+			length: (yield* parseMembers(text, first, "]", (start) => parseItem(text, start), [])).end - at,
+			properties: void 0
+		};
+	}
+	if (char === "\"") return {
+		offset: at,
+		length: (yield* parseString(text, at)).end - at,
+		properties: void 0
+	};
+	const literal = literalPattern.exec(text.slice(at));
+	if (literal === null) return yield* Result.fail(`Unexpected token at offset ${at}`);
+	return {
+		offset: at,
+		length: literal[0].length,
+		properties: void 0
+	};
+});
+const parseItem = (text, at) => Result.map(parseValue(text, at), (node) => ({
+	value: node,
+	end: node.offset + node.length
+}));
+const parseProperty = (text, at) => Result.gen(function* () {
+	const key = yield* parseString(text, at);
+	const colon = skipWhitespace(text, key.end);
+	if (text[colon] !== ":") return yield* Result.fail(`Expected ":" at offset ${colon}`);
+	const node = yield* parseValue(text, skipWhitespace(text, colon + 1));
+	return {
+		value: {
+			key: key.value,
+			node
+		},
+		end: node.offset + node.length
+	};
+});
+const parseDocument = (text) => Result.gen(function* () {
+	const root = yield* parseValue(text, skipWhitespace(text, 0));
+	const end = skipWhitespace(text, root.offset + root.length);
+	if (end !== text.length) return yield* Result.fail(`Unexpected content at offset ${end}`);
+	return root;
+});
+const valueNode = (root, keys) => keys.reduce((node, key) => node?.properties?.find((property) => property.key === key)?.node, root);
+/** Applies every edit to `json`; fails when the JSON is invalid or a key path is missing. */
+const editJson = (json, edits) => Result.gen(function* () {
+	const root = yield* parseDocument(json);
+	return (yield* Result.all(edits.map((edit) => {
+		const node = valueNode(root, edit.keys);
+		return node === void 0 ? Result.fail(`Key path "${edit.keys.join(".")}" not found in JSON`) : Result.succeed({
+			node,
+			content: JSON.stringify(edit.value)
+		});
+	}))).toSorted((a, b) => b.node.offset - a.node.offset).reduce((text, { node, content }) => text.slice(0, node.offset) + content + text.slice(node.offset + node.length), json);
+});
+// src/plan.ts
+/**
+* `@changesets/assemble-release-plan` outside pre mode and snapshots: flatten changesets into
+* releases, then bump dependents and apply fixed/linked groups until nothing changes.
+* Release order is insertion order, which decides changelog and status output order.
+*/
+const rank = {
+	major: 3,
+	minor: 2,
+	patch: 1,
+	none: 0
+};
+const newVersionOf = (release) => release.type === "none" ? release.oldVersion : increment(release.oldVersion, release.type);
+const highestType = (releases) => releases.reduce((highest, release) => rank[release.type] > rank[highest] ? release.type : highest, "none");
+const highestVersion = (group, byName) => group.reduce((highest, name) => {
+	const version = byName.get(name)?.packageJson.version;
+	return version !== void 0 && (highest === void 0 || greaterThan(version, highest)) ? version : highest;
+}, void 0);
+const flattenReleases = (changesets, byName, config) => changesets.reduce((releases, changeset) => {
+	changeset.releases.forEach(({ name, type }) => {
+		const pkg = byName.get(name);
+		if (pkg === void 0 || shouldSkipPackage(pkg, skipOptions(config))) return;
+		const release = releases.get(name);
+		if (release === void 0) {
+			releases.set(name, {
+				name,
+				type,
+				oldVersion: pkg.packageJson.version,
+				changesets: [changeset.id]
+			});
+			return;
+		}
+		if (rank[type] > rank[release.type]) release.type = type;
+		release.changesets.push(changeset.id);
+	});
+	return releases;
+}, /* @__PURE__ */ new Map());
+const dependencyRanges = (rootDir, dependent, release, dependency) => DEPENDENCY_TYPES.flatMap((depType) => {
+	const raw = dependent.packageJson[depType]?.[release.name];
+	if (!raw) return [];
+	if (!raw.startsWith("workspace:")) return [{
+		depType,
+		versionRange: raw
+	}];
+	const range = raw.slice(10);
+	if (range === "*") return [{
+		depType,
+		versionRange: release.oldVersion
+	}];
+	if (range === "^" || range === "~") return [{
+		depType,
+		versionRange: `${range}${release.oldVersion}`
+	}];
+	if (isValidRange(range)) return [{
+		depType,
+		versionRange: range
+	}];
+	return workspacePathMatches(range, rootDir, dependency) ? [{
+		depType,
+		versionRange: release.oldVersion
+	}] : [];
+});
+const dependentType = (ctx, dependentPkg, next) => {
+	if (shouldSkipPackage(dependentPkg, skipOptions(ctx.config))) return "none";
+	const dependency = ctx.byName.get(next.name);
+	if (dependency === void 0 || next.type === "none") return void 0;
+	const existing = ctx.releases.get(dependentPkg.packageJson.name);
+	return dependencyRanges(ctx.rootDir, dependentPkg, next, dependency).reduce((type, { depType, versionRange }) => {
+		if (!((existing === void 0 || existing.type === "none") && (ctx.config.updateInternalDependents === "always" || !satisfies(newVersionOf(next), versionRange)))) return type;
+		if (depType === "devDependencies") return type !== "major" && type !== "minor" && type !== "patch" ? "none" : type;
+		return type !== "major" && type !== "minor" ? "patch" : type;
+	}, void 0);
+};
+const determineDependents = (ctx) => {
+	const visit = (queue, updated) => {
+		const [next, ...rest] = queue;
+		if (next === void 0) return updated;
+		const found = (ctx.graph.get(next.name) ?? []).flatMap((dependent) => {
+			const dependentPkg = ctx.byName.get(dependent);
+			if (dependentPkg === void 0) return [];
+			const computed = dependentType(ctx, dependentPkg, next);
+			const type = ctx.releases.get(dependent)?.type === computed ? void 0 : computed;
+			return type === void 0 ? [] : [{
+				name: dependent,
+				type,
+				oldVersion: dependentPkg.packageJson.version
+			}];
+		});
+		const added = found.flatMap(({ name, type, oldVersion }) => {
+			const existing = ctx.releases.get(name);
+			if (existing !== void 0 && type === "major" && existing.type !== "major") {
+				existing.type = "major";
+				return [existing];
+			}
+			const release = {
+				name,
+				type,
+				oldVersion,
+				changesets: []
+			};
+			ctx.releases.set(name, release);
+			return [release];
+		});
+		return visit([...rest, ...added], updated || found.length > 0);
+	};
+	return visit([...ctx.releases.values()], false);
+};
+const matchFixedConstraint = (ctx) => ctx.config.fixed.reduce((updated, group) => {
+	const releasing = [...ctx.releases.values()].filter((r) => group.includes(r.name) && r.type !== "none");
+	if (releasing.length === 0) return updated;
+	const type = highestType(releasing);
+	const version = highestVersion(group, ctx.byName);
+	return group.reduce((changed, name) => {
+		const pkg = ctx.byName.get(name);
+		if (pkg === void 0 || shouldSkipPackage(pkg, skipOptions(ctx.config))) return changed;
+		const release = ctx.releases.get(name);
+		if (release === void 0) {
+			ctx.releases.set(name, {
+				name,
+				type,
+				oldVersion: version,
+				changesets: []
+			});
+			return true;
+		}
+		const differs = release.type !== type || release.oldVersion !== version;
+		release.type = type;
+		release.oldVersion = version;
+		return changed || differs;
+	}, updated);
+}, false);
+const applyLinks = (ctx) => ctx.config.linked.reduce((updated, group) => {
+	const releasing = [...ctx.releases.values()].filter((r) => group.includes(r.name) && r.type !== "none");
+	if (releasing.length === 0) return updated;
+	const type = highestType(releasing);
+	const version = highestVersion(group, ctx.byName);
+	return releasing.reduce((changed, release) => {
+		const differs = release.type !== type || release.oldVersion !== version;
+		release.type = type;
+		release.oldVersion = version;
+		return changed || differs;
+	}, updated);
+}, false);
+/** Rejects a changeset naming an unknown package, or mixing skipped and released packages. */
+const relevantChangesets = (changesets, byName, config) => {
+	const [first] = changesets.flatMap((changeset) => {
+		const unknown = changeset.releases.find((release) => !byName.has(release.name));
+		if (unknown !== void 0) return [`Found changeset ${changeset.id} for package ${unknown.name} which is not in the workspace`];
+		const skipped = changeset.releases.filter((r) => {
+			const pkg = byName.get(r.name);
+			return pkg !== void 0 && shouldSkipPackage(pkg, skipOptions(config));
+		});
+		const kept = changeset.releases.filter((r) => !skipped.includes(r));
+		return skipped.length > 0 && kept.length > 0 ? [`Found mixed changeset ${changeset.id}\nFound ignored packages: ${skipped.map((r) => r.name).join(" ")}\nFound not ignored packages: ${kept.map((r) => r.name).join(" ")}\nMixed changesets that contain both ignored and not ignored packages are not allowed`] : [];
+	});
+	return first === void 0 ? Result.succeed(changesets) : Result.fail(first);
+};
+const assembleReleasePlan = (changesets, packages, config) => {
+	const byName = new Map(packages.packages.map((pkg) => [pkg.packageJson.name, pkg]));
+	return Result.map(relevantChangesets(changesets, byName, config), (relevant) => {
+		const ctx = {
+			releases: flattenReleases(relevant, byName, config),
+			byName,
+			rootDir: packages.rootDir,
+			graph: dependentsGraph(packages, { bumpVersionsWithWorkspaceProtocolOnly: config.bumpVersionsWithWorkspaceProtocolOnly }).graph,
+			config
+		};
+		const settle = () => {
+			const dependentAdded = determineDependents(ctx);
+			const fixedUpdated = matchFixedConstraint(ctx);
+			const linksUpdated = applyLinks(ctx);
+			if (dependentAdded || fixedUpdated || linksUpdated) settle();
+		};
+		settle();
+		return {
+			changesets: relevant,
+			releases: [...ctx.releases.values()].map((release) => ({
+				name: release.name,
+				type: release.type,
+				oldVersion: release.oldVersion,
+				changesets: release.changesets,
+				newVersion: newVersionOf(release)
+			}))
+		};
+	});
+};
+// src/workspace.ts
+/**
+* Workspace discovery as `@manypkg/get-packages` does it for package.json `workspaces` with a
+* bun, yarn or npm lockfile: the nearest such ancestor is the root, else the nearest package.json
+* is a single-package root. Packages are the matching dirs with a package.json, sorted by path.
+*/
+const Ranges = Schema.optionalKey(Schema.Record(Schema.String, Schema.String));
+const Manifest = Schema.Struct({
+	name: Schema.optionalKey(Schema.String),
+	version: Schema.optionalKey(Schema.String),
+	private: Schema.optionalKey(Schema.Boolean),
+	workspaces: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Struct({ packages: Schema.optionalKey(Schema.Array(Schema.String)) })])),
+	dependencies: Ranges,
+	devDependencies: Ranges,
+	peerDependencies: Ranges,
+	optionalDependencies: Ranges
+});
+const decodeManifest = Schema.decodeUnknownEffect(Schema.fromJsonString(Manifest));
+const isList = (value) => Array.isArray(value);
+const workspaceGlobs = ({ workspaces }) => workspaces === void 0 ? void 0 : isList(workspaces) ? workspaces : workspaces.packages ?? [];
+const toPackageJson = (manifest, name) => ({
+	...manifest,
+	name
+});
+const readManifest = Effect.fn("readManifest")(function* (dir) {
+	const fs = yield* FileSystem.FileSystem;
+	const file = (yield* Path.Path).join(dir, "package.json");
+	const text = yield* fs.readFileString(file);
+	return yield* decodeManifest(text).pipe(Effect.mapError((cause) => new WorkspaceError({
+		message: `Could not read ${file}: ${cause.message}`,
+		path: file,
+		cause
+	})));
+});
+const manifestIn = (dir) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	return (yield* fs.exists(path.join(dir, "package.json"))) ? Option.some(yield* readManifest(dir)) : Option.none();
+});
+const isWorkspaceRoot = (dir, manifest) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	if (manifest.workspaces === void 0) return false;
+	const has = (file) => fs.exists(path.join(dir, file));
+	if ((yield* has("bun.lock")) || (yield* has("bun.lockb")) || (yield* has("yarn.lock"))) return true;
+	return isList(manifest.workspaces) && (yield* has("package-lock.json"));
+});
+const findRoot = (dir, nearest) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const manifest = yield* manifestIn(dir);
+	if (Option.isSome(manifest) && (yield* isWorkspaceRoot(dir, manifest.value))) return Option.some({
+		dir,
+		manifest: manifest.value
+	});
+	const nextNearest = Option.isNone(nearest) && Option.isSome(manifest) ? Option.some({
+		dir,
+		manifest: manifest.value
+	}) : nearest;
+	const parent = path.dirname(dir);
+	return parent === dir ? nextNearest : yield* findRoot(parent, nextNearest);
+});
+const expandGlobs = Effect.fn("expandGlobs")(function* (globs, rootDir) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const exclude = ["**/node_modules", ...globs.filter((g) => g.startsWith("!")).map((g) => g.slice(1))];
+	const matched = yield* Effect.forEach(globs.filter((g) => !g.startsWith("!")), (glob) => fs.glob(glob.replace(/\/+$/, ""), {
+		root: rootDir,
+		exclude
+	}));
+	const candidates = [...new Set(matched.flat().map((relative) => path.resolve(rootDir, relative)))].toSorted();
+	return (yield* Effect.forEach(candidates, (dir) => Effect.gen(function* () {
+		if ((yield* fs.stat(dir)).type !== "Directory") return Option.none();
+		const manifest = yield* manifestIn(dir);
+		return Option.map(manifest, (value) => ({
+			dir,
+			manifest: value
+		}));
+	}))).flatMap(Option.toArray);
+});
+/** Finds the workspace containing `cwd` and reads every package manifest in it. */
+const getPackages = Effect.fn("getPackages")(function* (cwd) {
+	const path = yield* Path.Path;
+	const start = path.resolve(cwd);
+	const root = yield* findRoot(start, Option.none());
+	if (Option.isNone(root)) return yield* new WorkspaceError({
+		message: `No package.json found from ${start} upwards`,
+		path: start
+	});
+	const rootDir = root.value.dir;
+	const rootPackage = {
+		dir: rootDir,
+		relativeDir: ".",
+		packageJson: toPackageJson(root.value.manifest, root.value.manifest.name ?? "")
+	};
+	const globs = workspaceGlobs(root.value.manifest);
+	if (globs === void 0) return {
+		rootDir,
+		rootPackage,
+		packages: [rootPackage]
+	};
+	const found = yield* expandGlobs(globs, rootDir);
+	const unnamed = found.filter(({ manifest }) => manifest.name === void 0);
+	if (unnamed.length > 0) return yield* new WorkspaceError({
+		message: `The following package.jsons are missing the "name" field:\n${unnamed.map(({ dir }) => path.join(path.relative(rootDir, dir), "package.json")).toSorted().join("\n")}`,
+		path: rootDir
+	});
+	return {
+		rootDir,
+		rootPackage,
+		packages: found.map(({ dir, manifest }) => ({
+			dir,
+			relativeDir: path.relative(rootDir, dir),
+			packageJson: toPackageJson(manifest, manifest.name ?? "")
+		}))
+	};
+});
+// src/changesets.ts
+/**
+* The `add`, `version` and `status` commands of `@changesets/cli` 3.x, reading and writing the
+* same files. Pre mode, snapshots, `commit` and `publish` are out of scope and fail loudly.
+*/
+const ignoredMarkdown = (file) => /^README\.md$/i.test(file) || file === "AGENTS.md" || file === "CLAUDE.md" || file === "GEMINI.md";
+const encoder = new TextEncoder();
+/** libuv's `scandir` order (`strcmp` on UTF-8), which is what `fs.readdir` returns under Node. */
+const byteOrder = (a, b) => {
+	const left = encoder.encode(a);
+	const right = encoder.encode(b);
+	const index = left.findIndex((byte, i) => byte !== right[i]);
+	if (index === -1) return left.length - right.length;
+	return (left[index] ?? 0) - (right[index] ?? -1);
+};
+const readSorted = (fs, dir) => Effect.map(fs.readDirectory(dir), (entries) => entries.toSorted(byteOrder));
+const builtinChangelogs = /* @__PURE__ */ new Set(["@changesets/cli/changelog", "@changesets/changelog-git"]);
+const decodeConfig = Schema.decodeUnknownEffect(Schema.fromJsonString(WrittenConfig));
+var Changesets = class extends Context.Service()("@maple-dev/changesets/Changesets", { make: Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const git = yield* Git;
+	const formatter = yield* Formatter;
+	const workspaceError = (file) => (cause) => new WorkspaceError({
+		message: `Could not access ${file}: ${cause.message}`,
+		path: file,
+		cause
+	});
+	const changesetDir = (packages) => path.join(packages.rootDir, ".changeset");
+	const ensureChangesetFolder = (packages) => Effect.flatMap(fs.exists(changesetDir(packages)).pipe(Effect.mapError(workspaceError(changesetDir(packages)))), (exists) => exists ? Effect.void : Effect.fail(new CommandExit({
+		code: 1,
+		message: "There is no .changeset folder.\nIf this is the first time Changesets have been used in this project, run `changeset init` to get set up.\nIf you expected there to be changesets, you should check git history for when the folder was removed to ensure you do not lose any configuration."
+	})));
+	/** Reads the workspace and `.changeset/config.json`; config rule violations fail. */
+	const load = Effect.fn("Changesets.load")(function* (cwd) {
+		const packages = yield* getPackages(cwd).pipe(Effect.catchTag("PlatformError", (e) => workspaceError(cwd)(e)));
+		yield* ensureChangesetFolder(packages);
+		const file = path.join(changesetDir(packages), "config.json");
+		const text = yield* fs.readFileString(file).pipe(Effect.mapError(workspaceError(file)));
+		const written = yield* decodeConfig(text).pipe(Effect.mapError((cause) => new ConfigError({
+			message: `Found issues in your config:\n- ${cause.message}`,
+			problems: [cause.message]
+		})));
+		const config = normalizeConfig(written, packages.packages.map((pkg) => pkg.packageJson.name));
+		const { errors, warnings } = validateConfig(config, written, packages);
+		if (errors.length > 0) return yield* new ConfigError({
+			message: `Found issues in your config:\n- ${[...warnings, ...errors].join("\n- ")}`,
+			problems: [...warnings, ...errors]
+		});
+		return {
+			packages,
+			config,
+			warnings
+		};
+	});
+	const refuseUnsupported = Effect.fn("Changesets.refuseUnsupported")(function* (project) {
+		const preState = path.join(changesetDir(project.packages), "pre.json");
+		if (yield* fs.exists(preState).pipe(Effect.mapError(workspaceError(preState)))) return yield* new UnsupportedFeatureError({
+			feature: "pre",
+			message: "Pre mode (.changeset/pre.json) is not supported by this changesets implementation."
+		});
+		if (project.config.commit !== false) return yield* new UnsupportedFeatureError({
+			feature: "commit",
+			message: "The \"commit\" option is not supported by this changesets implementation; set it to false."
+		});
+	});
+	/** `@changesets/read`: every changeset in `.changeset` and `.changeset/pre`, in directory order. */
+	const readChangesets = Effect.fn("Changesets.readChangesets")(function* (packages, since) {
+		const base = changesetDir(packages);
+		const top = yield* readSorted(fs, base).pipe(Effect.mapError(workspaceError(base)));
+		const preDir = path.join(base, "pre");
+		const pre = (yield* fs.exists(preDir).pipe(Effect.mapError(workspaceError(preDir)))) ? (yield* readSorted(fs, preDir).pipe(Effect.mapError(workspaceError(preDir)))).map((f) => `pre/${f}`) : [];
+		const changed = since === void 0 ? void 0 : (yield* git.changedChangesetFilesSince(since, base)).map((file) => file.replace(/^.*\.changeset\//, ""));
+		const files = [...top, ...pre].filter((file) => changed === void 0 || changed.includes(file)).filter((file) => {
+			const name = path.basename(file);
+			return !name.startsWith(".") && name.endsWith(".md") && !ignoredMarkdown(name);
+		});
+		return yield* Effect.forEach(files, (file) => Effect.gen(function* () {
+			const full = path.join(base, file);
+			const contents = yield* fs.readFileString(full).pipe(Effect.mapError(workspaceError(full)));
+			const parsed = parseChangesetFile(contents);
+			if (Result.isFailure(parsed)) return yield* new ChangesetParseError({
+				message: parsed.failure,
+				file: full
+			});
+			return {
+				...parsed.success,
+				id: file.replace(/\.md$/, "")
+			};
+		}));
+	});
+	const plan = (changesets, packages, config) => {
+		const result = assembleReleasePlan(changesets, packages, config);
+		return Result.isSuccess(result) ? Effect.succeed(result.success) : Effect.fail(new ReleasePlanError({ message: result.failure }));
+	};
+	const logGraphWarnings = (packages, config) => Effect.forEach(dependentsGraph(packages, { bumpVersionsWithWorkspaceProtocolOnly: config.bumpVersionsWithWorkspaceProtocolOnly }).invalid, (line) => Console.error(line), { discard: true });
+	const changelogFunctions = Effect.fn("Changesets.changelogFunctions")(function* (reference, packages) {
+		const [specifier] = reference;
+		if (builtinChangelogs.has(specifier)) return gitChangelog;
+		if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) return yield* new UnsupportedFeatureError({
+			feature: "changelog",
+			message: `Changelog module "${specifier}" is not supported; use "@changesets/cli/changelog", false, or a path relative to .changeset.`
+		});
+		const file = path.resolve(changesetDir(packages), specifier);
+		const loaded = yield* Effect.tryPromise({
+			try: () => import(file),
+			catch: (cause) => new ChangelogError({
+				message: `Could not load ${file}`,
+				module: specifier,
+				cause
+			})
+		});
+		return yield* changelogFromModule(loaded, specifier);
+	});
+	const applyPlan = Effect.fn("Changesets.applyPlan")(function* (releasePlan, packages, config) {
+		const byName = new Map(packages.packages.map((pkg) => [pkg.packageJson.name, pkg]));
+		const releases = releasePlan.releases.flatMap((release) => {
+			const pkg = byName.get(release.name);
+			return pkg === void 0 ? [] : [{
+				...release,
+				...pkg,
+				relativeDir: relativeDirOf(packages.rootDir, pkg)
+			}];
+		});
+		const updateOptions = {
+			rootDir: packages.rootDir,
+			updateInternalDependencies: config.updateInternalDependencies,
+			onlyUpdatePeerDependentsWhenOutOfRange: config.onlyUpdatePeerDependentsWhenOutOfRange
+		};
+		const changelogs = yield* changelogsFor(releasePlan, releases, packages, config, updateOptions);
+		const editOptions = {
+			...updateOptions,
+			bumpVersionsWithWorkspaceProtocolOnly: config.bumpVersionsWithWorkspaceProtocolOnly
+		};
+		const written = yield* Effect.forEach(releases, (release, index) => Effect.gen(function* () {
+			const versionEdit = release.newVersion === void 0 ? [] : [{
+				keys: ["version"],
+				value: release.newVersion
+			}];
+			yield* updatePackageJson(release, [...dependencyEdits(release.packageJson, releases, editOptions), ...versionEdit]);
+			const changelog = changelogs[index];
+			if (changelog === void 0 || changelog.length === 0) return Option.none();
+			const file = path.resolve(release.dir, "CHANGELOG.md");
+			const existing = yield* fs.readFileString(file).pipe(Effect.map(Option.some), Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(Option.none())), Effect.mapError(workspaceError(file)));
+			yield* fs.writeFileString(file, prependEntry(Option.getOrUndefined(existing), changelog, release.name)).pipe(Effect.mapError(workspaceError(file)));
+			return Option.some(file);
+		}));
+		yield* updatePackageJson(packages.rootPackage, dependencyEdits(packages.rootPackage.packageJson, releases, editOptions));
+		yield* formatter.format(config.format, packages.rootDir, written.flatMap(Option.toArray));
+		yield* Effect.forEach(releasePlan.changesets, (changeset) => Effect.gen(function* () {
+			const file = path.resolve(changesetDir(packages), `${changeset.id}.md`);
+			if (changeset.releases.some((r) => {
+				const pkg = byName.get(r.name);
+				return pkg !== void 0 && shouldSkipPackage(pkg, skipOptions(config));
+			}) || !(yield* fs.exists(file).pipe(Effect.mapError(workspaceError(file))))) return;
+			yield* fs.remove(file, { force: true }).pipe(Effect.mapError(workspaceError(file)));
+		}), { discard: true });
+	});
+	const changelogsFor = Effect.fn("Changesets.changelogsFor")(function* (releasePlan, releases, packages, config, options) {
+		if (config.changelog === false) return releases.map(() => void 0);
+		const functions = yield* changelogFunctions(config.changelog, packages);
+		const commits = yield* git.commitsThatAddFiles(releasePlan.changesets.map((changeset) => `.changeset/${changeset.id}.md`), packages.rootDir);
+		const withCommits = releasePlan.changesets.map((changeset, i) => ({
+			...changeset,
+			commit: commits[i]
+		}));
+		return yield* Effect.forEach(releases, (release) => changelogEntry(release, releases, withCommits, functions, config.changelog === false ? null : config.changelog[1], options));
+	});
+	const updatePackageJson = (pkg, edits) => Effect.gen(function* () {
+		if (edits.length === 0) return;
+		const file = path.resolve(pkg.dir, "package.json");
+		const text = yield* fs.readFileString(file).pipe(Effect.mapError(workspaceError(file)));
+		const edited = editJson(text, edits);
+		if (Result.isFailure(edited)) return yield* new JsonEditError({
+			message: edited.failure,
+			file
+		});
+		yield* fs.writeFileString(file, edited.success).pipe(Effect.mapError(workspaceError(file)));
+	});
+	/** `changeset version [--ignore pkg]`. */
+	const version = Effect.fn("Changesets.version")(function* (options) {
+		const project = yield* load(options.cwd);
+		yield* Effect.forEach(project.warnings, (warning) => Console.warn(warning), { discard: true });
+		const { packages } = project;
+		const messages = [];
+		const cliIgnore = options.ignore !== void 0 && options.ignore.length > 0 ? options.ignore : void 0;
+		if (cliIgnore !== void 0 && project.config.ignore.length > 0) messages.push("It looks like you are trying to use the `--ignore` option while ignore is defined in the config file. This is currently not allowed, you can only use one of them at a time.");
+		const config = {
+			...project.config,
+			ignore: cliIgnore ?? project.config.ignore
+		};
+		const names = new Set(packages.packages.map((pkg) => pkg.packageJson.name));
+		(cliIgnore ?? []).filter((name) => !names.has(name)).forEach((name) => messages.push(`The package ${name} is passed to the \`--ignore\` option but it is not found in the project. You may have misspelled the package name.`));
+		skippedDependentErrors(packages, config).forEach(({ dependent, skipped }) => messages.push(`The package ${dependent} depends on the skipped package ${skipped} (either by \`ignore\` option or by \`privatePackages.version\`), but ${dependent} is not being skipped. Please pass ${dependent} to the --ignore flag.`));
+		if (messages.length > 0) return yield* new CommandExit({
+			code: 1,
+			message: messages.join("\n")
+		});
+		yield* refuseUnsupported(project);
+		const changesets = yield* readChangesets(packages);
+		if (changesets.length === 0) return yield* new CommandExit({
+			code: 1,
+			message: "No unreleased changesets found."
+		});
+		yield* logGraphWarnings(packages, config);
+		const releasePlan = yield* plan(changesets, packages, config);
+		yield* applyPlan(releasePlan, packages, config);
+		return releasePlan;
+	});
+	/** Workspace packages changed since `ref` that changesets would version. */
+	const changedPackages = Effect.fn("Changesets.changedPackages")(function* (project, ref) {
+		const files = [...yield* git.changedFilesSince(ref ?? project.config.baseBranch, project.packages.rootDir)];
+		return project.packages.packages.toSorted((a, b) => b.dir.length - a.dir.length).filter((pkg) => {
+			const owned = files.filter((file) => !path.relative(pkg.dir, file).startsWith(".."));
+			owned.forEach((file) => files.splice(files.indexOf(file), 1));
+			const relative = owned.map((file) => file.slice(pkg.dir.length + 1));
+			return relative.length > 0 && matchesSome(relative, project.config.changedFilePatterns);
+		}).filter((pkg) => !shouldSkipPackage(pkg, skipOptions(project.config)));
+	});
+	return {
+		load,
+		refuseUnsupported,
+		readChangesets,
+		version,
+		status: Effect.fn("Changesets.status")(function* (options) {
+			const project = yield* load(options.cwd);
+			yield* refuseUnsupported(project);
+			const changesets = yield* readChangesets(project.packages, options.since);
+			const releasePlan = yield* plan(changesets, project.packages, project.config);
+			if ((yield* changedPackages(project, options.since)).length > 0 && releasePlan.changesets.length === 0) return yield* new CommandExit({
+				code: 1,
+				message: "Some packages have been changed but no changesets were found. Run `changeset add` to resolve this error.\nIf this change doesn't need a release, run `changeset add --empty`."
+			});
+			if (options.output !== void 0) {
+				const file = path.resolve(options.cwd, options.output);
+				yield* fs.writeFileString(file, JSON.stringify(releasePlan, void 0, 2)).pipe(Effect.mapError(workspaceError(file)));
+			}
+			return releasePlan;
+		}),
+		changedPackages,
+		writeChangeset: Effect.fn("Changesets.writeChangeset")(function* (project, changeset) {
+			const base = changesetDir(project.packages);
+			const pickId = Effect.flatMap(humanId, (id) => Effect.flatMap(fs.exists(path.join(base, `${id}.md`)).pipe(Effect.mapError(workspaceError(base))), (taken) => taken ? pickId : Effect.succeed(id)));
+			const id = yield* pickId;
+			const file = path.join(base, `${id}.md`);
+			const contents = `---\n${changeset.releases.map((r) => `"${r.name}": ${r.type}`).join("\n")}\n---\n\n${changeset.summary}\n`;
+			yield* fs.makeDirectory(base, { recursive: true }).pipe(Effect.mapError(workspaceError(base)));
+			yield* fs.writeFileString(file, contents).pipe(Effect.mapError(workspaceError(file)));
+			yield* formatter.format(project.config.format, project.packages.rootDir, [file]);
+			return {
+				id,
+				file
+			};
+		})
+	};
+}) }) {
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide([Git.layer, Formatter.layer]));
+};
+const matchesSome = (paths, patterns) => paths.some((file) => matchesPatterns(file.replaceAll("\\", "/"), patterns));
+const isModuleFunction = (value) => typeof value === "function";
+const findFunctions = (module, depth) => {
+	if (Predicate.hasProperty(module, "default") && module.default && depth < 2) return findFunctions(module.default, depth + 1);
+	return Predicate.hasProperty(module, "getReleaseLine") && Predicate.hasProperty(module, "getDependencyReleaseLine") && isModuleFunction(module.getReleaseLine) && isModuleFunction(module.getDependencyReleaseLine) ? Option.some({
+		getReleaseLine: module.getReleaseLine,
+		getDependencyReleaseLine: module.getDependencyReleaseLine
+	}) : Option.none();
+};
+const callModule = (fn, args, specifier) => Effect.tryPromise({
+	try: () => Promise.resolve(fn(...args)),
+	catch: (cause) => new ChangelogError({
+		message: `Changelog module ${specifier} failed`,
+		module: specifier,
+		cause
+	})
+}).pipe(Effect.map((line) => typeof line === "string" ? line : String(line ?? "")));
+/** Adapts a changelog module (`getReleaseLine`, `getDependencyReleaseLine`) to Effects. */
+const changelogFromModule = (module, specifier) => Option.match(findFunctions(module, 0), {
+	onNone: () => Effect.fail(new ChangelogError({
+		message: "Could not resolve changelog generation functions",
+		module: specifier
+	})),
+	onSome: ({ getReleaseLine, getDependencyReleaseLine }) => Effect.succeed({
+		getReleaseLine: (changeset, type, options) => callModule(getReleaseLine, [
+			changeset,
+			type,
+			options
+		], specifier),
+		getDependencyReleaseLine: (changesets, dependencies, options) => callModule(getDependencyReleaseLine, [
+			changesets,
+			dependencies,
+			options
+		], specifier)
+	})
+});
+// src/cli.ts
+/**
+* The `changeset` command line: `add` (also the default), `version` and `status` with the
+* `@changesets/cli` 3.x flags. Editors are spawned without a shell, `$EDITOR` split on whitespace.
+*/
+const version = "0.1.0";
+const listFlag = (name, description) => Flag.String(name).pipe(Flag.withDescription(description), Flag.atLeast(0), Flag.map((values) => values.flatMap((value) => value.split(",").map((part) => part.trim()).filter(Boolean))));
+const addFlags = {
+	empty: Flag.Boolean("empty").pipe(Flag.withDescription("Add an empty changeset"), Flag.withDefault(false)),
+	open: Flag.Boolean("open").pipe(Flag.withDescription("Open the changeset in $VISUAL or $EDITOR after creating it"), Flag.withDefault(false)),
+	since: Flag.String("since").pipe(Flag.withDescription("Detect changed packages since the provided git ref"), Flag.optional),
+	message: Flag.String("message").pipe(Flag.withAlias("m"), Flag.withDescription("Directly provide a message to the changeset"), Flag.optional),
+	major: listFlag("major", "Package(s) to major bump (comma-separated)"),
+	minor: listFlag("minor", "Package(s) to minor bump (comma-separated)"),
+	patch: listFlag("patch", "Package(s) to patch bump (comma-separated)")
+};
+const cwd = Effect.gen(function* () {
+	return (yield* Path.Path).resolve(".");
+});
+const success = (message) => Console.log(`🦋  ${message}`);
+const warn = (message) => Console.warn(`🦋  warn ${message.split("\n").join("\n🦋  warn ")}`);
+const ask = (prompt) => Prompt.run(prompt).pipe(Effect.catchTag("QuitError", () => Effect.fail(new CommandExit({
+	code: 0,
+	message: "Canceled... 👋"
+}))));
+const editorCommand = Effect.gen(function* () {
+	const visual = yield* Config.option(Config.String("VISUAL"));
+	const editor = yield* Config.option(Config.String("EDITOR"));
+	return Option.orElse(visual, () => editor).pipe(Option.map((value) => value.trim().split(/\s+/)), Option.filter((parts) => parts.length > 0 && parts[0] !== ""));
+}).pipe(Effect.orElseSucceed(() => Option.none()));
+/** Opens `file` in the user's editor and waits for it to exit. */
+const openInEditor = (file) => Effect.gen(function* () {
+	const command = yield* editorCommand;
+	if (Option.isNone(command)) return false;
+	const [bin = "", ...args] = command.value;
+	const exit = yield* (yield* ChildProcessSpawner.ChildProcessSpawner).exitCode(ChildProcess.make(bin, [...args, file], {
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit"
+	}));
+	return Number(exit) === 0;
+}).pipe(Effect.orElseSucceed(() => false));
+const summaryFromEditor = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const dir = yield* fs.makeTempDirectory();
+	const file = path.join(dir, "changeset.md");
+	yield* fs.writeFileString(file, "\n\n# Please enter a summary for your changes.\n# An empty message aborts the editor.");
+	const contents = (yield* openInEditor(file)) ? yield* fs.readFileString(file) : "";
+	yield* fs.remove(dir, { recursive: true });
+	return contents.replace(/^#.*\n?/gm, "").replace(/\n+$/g, "").trim();
+}).pipe(Effect.orElseSucceed(() => ""));
+const askSummary = Effect.gen(function* () {
+	const typed = yield* ask(Prompt.String({ message: "Please enter a summary for this change (this will be in the changelogs). (submit nothing to open an external editor)" }));
+	if (typed.length > 0) return typed;
+	const edited = yield* summaryFromEditor;
+	if (edited.length > 0) return edited;
+	return yield* ask(Prompt.String({
+		message: "Did not find a summary in the edited file. Please enter one:",
+		validate: (value) => value.length === 0 ? Effect.fail("Can't be empty.") : Effect.succeed(value)
+	}));
+});
+const confirmMajor = (pkg) => pkg.packageJson.version !== void 0 && lessThan(pkg.packageJson.version, "1.0.0") ? ask(Prompt.Confirm({
+	message: `The major version of ${pkg.packageJson.name} will be its first major release (1.0.0). Are you sure you want to release the first major version of ${pkg.packageJson.name}?`,
+	initial: true
+})) : Effect.succeed(true);
+const releasesFromFlags = (options, packages) => {
+	const names = new Set(packages.map((pkg) => pkg.packageJson.name));
+	const byType = [
+		["major", [...new Set(options.major)]],
+		["minor", [...new Set(options.minor)]],
+		["patch", [...new Set(options.patch)]]
+	];
+	const unknown = byType.flatMap(([type, list]) => list.filter((name) => !names.has(name)).map((name) => `The package ${name} is passed to the \`--${type}\` option but it is not found in the project. You may have misspelled the package name.`));
+	const duplicated = [...names].flatMap((name) => {
+		const flags = byType.filter(([, list]) => list.includes(name)).map(([type]) => `\`--${type}\``);
+		return flags.length > 1 ? [`The package ${name} is passed to multiple release type options: ${flags.join(", ")}. Please select only one release type for this package.`] : [];
+	});
+	const problems = [...unknown, ...duplicated];
+	return problems.length > 0 ? Effect.fail(new CommandExit({
+		code: 1,
+		message: problems.join("\n")
+	})) : Effect.succeed(byType.flatMap(([type, list]) => list.map((name) => ({
+		name,
+		type
+	}))));
+};
+const pickReleases = Effect.fn("pickReleases")(function* (changed, packages) {
+	const byName = new Map(packages.map((pkg) => [pkg.packageJson.name, pkg]));
+	const label = (name) => `${name}@${byName.get(name)?.packageJson.version ?? ""}`;
+	const [only, ...others] = packages;
+	if (only !== void 0 && others.length === 0) {
+		const pkg = only;
+		const type = yield* ask(Prompt.Select({
+			message: `What kind of change is this for ${pkg.packageJson.name}? (current version is ${pkg.packageJson.version})`,
+			choices: [
+				{
+					title: "patch",
+					value: "patch"
+				},
+				{
+					title: "minor",
+					value: "minor"
+				},
+				{
+					title: "major",
+					value: "major"
+				}
+			]
+		}));
+		if (type === "major" && !(yield* confirmMajor(pkg))) return yield* new CommandExit({
+			code: 1,
+			message: "Aborted."
+		});
+		return [{
+			name: pkg.packageJson.name,
+			type
+		}];
+	}
+	const sorted = packages.toSorted((a, b) => a.packageJson.name.localeCompare(b.packageJson.name));
+	const ordered = [...sorted.filter((pkg) => changed.includes(pkg.packageJson.name)), ...sorted.filter((pkg) => !changed.includes(pkg.packageJson.name))];
+	const chosen = (yield* ask(Prompt.MultiSelect({
+		message: "Which packages were affected by the changes you made?",
+		min: 1,
+		choices: ordered.map((pkg) => ({
+			title: pkg.packageJson.name + (pkg.packageJson.private === true ? " (private)" : ""),
+			value: pkg.packageJson.name,
+			description: changed.includes(pkg.packageJson.name) ? "changed" : void 0
+		}))
+	}))).toSorted((a, b) => a.localeCompare(b));
+	const majorPicked = yield* ask(Prompt.MultiSelect({
+		message: "Which packages should have a major (X.0.0) bump?",
+		choices: chosen.map((name) => ({
+			title: label(name),
+			value: name
+		}))
+	}));
+	const majors = yield* Effect.filter(majorPicked, (name) => {
+		const pkg = byName.get(name);
+		return pkg === void 0 ? Effect.succeed(false) : confirmMajor(pkg);
+	});
+	const afterMajor = chosen.filter((name) => !majors.includes(name));
+	const minors = afterMajor.length === 0 ? [] : yield* ask(Prompt.MultiSelect({
+		message: "Which packages should have a minor (0.X.0) bump?",
+		choices: afterMajor.map((name) => ({
+			title: label(name),
+			value: name
+		}))
+	}));
+	const patches = afterMajor.filter((name) => !minors.includes(name));
+	if (patches.length > 0) yield* success(`The following packages will be patch (0.0.X) bumped:\n${patches.map(label).join(", ")}`);
+	return [
+		...majors.map((name) => ({
+			name,
+			type: "major"
+		})),
+		...minors.map((name) => ({
+			name,
+			type: "minor"
+		})),
+		...patches.map((name) => ({
+			name,
+			type: "patch"
+		}))
+	];
+});
+const changedNames = (changesets, project, since) => changesets.changedPackages(project, Option.getOrUndefined(since)).pipe(Effect.map((packages) => packages.map((pkg) => pkg.packageJson.name)), Effect.catch((error) => Effect.as(warn(`Failed to identify which packages have changed since the ${Option.isSome(since) ? "ref" : "base branch"} due to an error:\n${error.message}`), [])));
+const add = Effect.fn("add")(function* (options) {
+	const changesets = yield* Changesets;
+	const project = yield* changesets.load(yield* cwd);
+	yield* changesets.refuseUnsupported(project);
+	const versionable = project.packages.packages.filter((pkg) => !shouldSkipPackage(pkg, skipOptions(project.config)));
+	if (project.packages.packages.length === 0 || versionable.length === 0) return yield* new CommandExit({
+		code: 1,
+		message: "No versionable packages found\n  Ensure the packages to version are not ignored by the config\n  Ensure that relevant package.json files have a `version` field"
+	});
+	const fromFlags = options.major.length + options.minor.length + options.patch.length > 0;
+	const releases = options.empty ? [] : fromFlags ? yield* releasesFromFlags(options, versionable) : yield* pickReleases(yield* changedNames(changesets, project, options.since), versionable);
+	const summary = Option.isSome(options.message) ? options.message.value : options.empty ? "" : yield* askSummary;
+	if (!options.empty) {
+		const summaryLines = [
+			"major",
+			"minor",
+			"patch"
+		].flatMap((type) => {
+			const names = releases.filter((r) => r.type === type).map((r) => r.name);
+			return names.length > 0 ? [`${type}:  ${names.join(", ")}`] : [];
+		});
+		yield* success(["Summary of changesets:", ...summaryLines].join("\n"));
+	}
+	const { file } = yield* changesets.writeChangeset(project, {
+		releases,
+		summary
+	});
+	const relative = (yield* Path.Path).relative(yield* cwd, file);
+	if (releases.some((r) => r.type === "major")) yield* warn("This Changeset includes a major change and we STRONGLY recommend adding more information to the changeset:\n  WHAT the breaking change is\n  WHY the change was made\n  HOW a consumer should update their code");
+	yield* success(`${options.empty ? "Empty " : ""}Changeset added - you can now commit it!\n${relative}`);
+	if (options.open) yield* openInEditor(relative);
+});
+const printStatus = (releases, verbose) => {
+	const sorted = releases.toSorted((a, b) => a.name.localeCompare(b.name));
+	const groups = [
+		"major",
+		"minor",
+		"patch"
+	].flatMap((type) => {
+		const group = sorted.filter((r) => r.type === type);
+		if (group.length === 0) return [];
+		return [`- ${type}`, ...group.flatMap((r) => [`  - ${r.name}${verbose ? ` -> ${r.newVersion}` : ""}`, ...verbose ? r.changesets.map((id) => `    - .changeset/${id}.md`) : []])];
+	});
+	return Console.log(`🦋  info Packages to be bumped:\n${groups.join("\n")}`.trim());
+};
+const unsupported = (name) => Command.make(name, {}, () => Effect.fail(new UnsupportedFeatureError({
+	feature: name,
+	message: `\`changeset ${name}\` is not part of this changesets implementation. Only add, version and status are.`
+}))).pipe(Command.withDescription(`Not supported (use @changesets/cli for ${name})`));
+const addCommand = Command.make("add", addFlags, add).pipe(Command.withDescription("Add a new changeset (default)"));
+const versionCommand = Command.make("version", {
+	ignore: listFlag("ignore", "Packages to ignore"),
+	snapshot: Flag.String("snapshot").pipe(Flag.withDescription("Not supported"), Flag.optional)
+}, (options) => Effect.gen(function* () {
+	if (Option.isSome(options.snapshot)) return yield* new UnsupportedFeatureError({
+		feature: "snapshot",
+		message: "Snapshot releases are not supported."
+	});
+	yield* (yield* Changesets).version({
+		cwd: yield* cwd,
+		ignore: options.ignore
+	});
+	yield* success("All files have been updated. Review them and commit at your leisure");
+})).pipe(Command.withDescription("Version packages and create changelogs"));
+const statusCommand = Command.make("status", {
+	since: Flag.String("since").pipe(Flag.withDescription("Show changesets since the provided git ref"), Flag.optional),
+	verbose: Flag.Boolean("verbose").pipe(Flag.withAlias("v"), Flag.withDescription("Show more information about the changesets"), Flag.withDefault(false)),
+	output: Flag.String("output").pipe(Flag.withAlias("o"), Flag.withDescription("Output the status as JSON to a file"), Flag.withFallbackConfig(Config.String("CHANGESETS_OUTPUT")), Flag.optional)
+}, (options) => Effect.gen(function* () {
+	const plan = yield* (yield* Changesets).status({
+		cwd: yield* cwd,
+		since: Option.getOrUndefined(options.since),
+		output: Option.getOrUndefined(options.output)
+	});
+	if (Option.isNone(options.output)) yield* printStatus(plan.releases, options.verbose);
+})).pipe(Command.withDescription("Show the changesets that currently exist"));
+const changesetCommand = Command.make("changeset", addFlags, add).pipe(Command.withDescription("Manage versioning and changelogs with changesets"), Command.withSubcommands([
+	addCommand,
+	versionCommand,
+	statusCommand,
+	...[
+		"init",
+		"publish",
+		"publish-plan",
+		"pack",
+		"pre",
+		"git-tag",
+		"tag"
+	].map(unsupported)
+]));
+const ownError = (error) => Predicate.hasProperty(error, "_tag") && typeof error._tag === "string" && (error._tag.startsWith("@maple-dev/changesets/") || error._tag === "PlatformError") && Predicate.hasProperty(error, "message") && typeof error.message === "string";
+/** Runs the CLI; expected failures print their message once and exit non-zero. */
+const main = Command.run(changesetCommand, { version }).pipe(Effect.catch((error) => {
+	if (!ownError(error)) return Effect.fail(error);
+	if (error._tag === "@maple-dev/changesets/CommandExit" && error.message.startsWith("Canceled")) return Console.log(error.message);
+	return Effect.andThen(Console.error(`🦋  error ${error.message.split("\n").join("\n🦋  error ")}`), Effect.fail(error));
+}));
+export { parseChangesetFile as a, CommandExit as c, GitError as d, JsonEditError as f, WorkspaceError as h, assembleReleasePlan as i, ConfigError as l, UnsupportedFeatureError as m, main as n, ChangelogError as o, ReleasePlanError as p, Changesets as r, ChangesetParseError as s, changesetCommand as t, FormatterError as u };