@savvy-web/silk-effects 7.0.1 → 7.1.0

package/changesets/services/deps-regen.js

@@ -201,6 +201,85 @@ const findPureDependencyChangesets = (fs, changesetDir) => Effect.gen(function*
 	return result;
 });
 /**
+* Every package name a changeset's YAML frontmatter releases, parsed with the
+* same lenient `"@pkg": bump` line grammar {@link isPureDependencyChangeset}
+* uses. A file with no frontmatter, or one whose lines all fail the grammar,
+* yields an empty list — this feeds an informational surface, so lenient
+* degradation beats a typed failure.
+*
+* @param content - Raw `.changeset/*.md` file contents.
+*
+* @public
+*/
+function parseChangesetPackages(content) {
+	const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+	if (!fmMatch) return [];
+	const packages = [];
+	for (const line of fmMatch[1].split(/\r?\n/)) {
+		if (line.trim().length === 0 || /^\s*#/.test(line)) continue;
+		const m = line.match(/^\s*["']?([^"':\s]+)["']?\s*:\s*([a-z]+)\s*$/);
+		if (m) packages.push(m[1]);
+	}
+	return packages;
+}
+/**
+* Whether `content` carries a `## Dependencies` heading OUTSIDE fenced code
+* blocks. A prose changeset that DOCUMENTS the changeset format quotes the
+* heading inside a ``` fence; a fence-blind regex misreads that file as a
+* dependency changeset (classified mixed, dropped from the coexisting
+* bucket). Tracks CommonMark fence state: an opening run of 3+ backticks or
+* tildes (a backtick fence's info string may not contain a backtick) is
+* closed only by a run of the same character, at least as long, with nothing
+* else on the line.
+*/
+function containsDependenciesHeading(content) {
+	let fence = null;
+	for (const line of content.split(/\r?\n/)) {
+		const match = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+		if (match) {
+			const run = match[1];
+			const char = run.charAt(0);
+			const trailing = match[2];
+			if (fence === null) {
+				if (char === "~" || !trailing.includes("`")) {
+					fence = {
+						char,
+						length: run.length
+					};
+					continue;
+				}
+			} else if (char === fence.char && run.length >= fence.length && trailing.trim() === "") {
+				fence = null;
+				continue;
+			}
+		}
+		if (fence === null && /^## Dependencies\b/.test(line)) return true;
+	}
+	return false;
+}
+/**
+* Prose-only changesets (no `## Dependencies` heading at all) found in
+* `changesetDir`, each with the packages its frontmatter releases. These are
+* the files a regen run never touches — surfaced so the result can account
+* for them instead of leaving them invisible (#279). Same
+* skip-unreadable-file / loud-list-failure semantics as
+* {@link findPureDependencyChangesets}.
+*/
+const findProseChangesets = (fs, changesetDir) => Effect.gen(function* () {
+	const files = yield* listChangesetFiles(fs, changesetDir);
+	const result = [];
+	for (const file of files) {
+		const content = yield* fs.readFileString(file).pipe(Effect.option);
+		if (Option.isNone(content)) continue;
+		if (containsDependenciesHeading(content.value)) continue;
+		result.push({
+			file,
+			packages: parseChangesetPackages(content.value)
+		});
+	}
+	return result;
+});
+/**
 * Mixed dependency changesets (have a `## Dependencies` heading but fail
 * the strict pure-changeset test) found in `changesetDir`. Same
 * skip-unreadable-file / loud-list-failure semantics as
@@ -212,7 +291,7 @@ const findMixedDependencyChangesets = (fs, changesetDir) => Effect.gen(function*
 	for (const file of files) {
 		const content = yield* fs.readFileString(file).pipe(Effect.option);
 		if (Option.isNone(content)) continue;
-		if (/^## Dependencies\b/m.test(content.value) && !isPureDependencyChangeset(content.value).isPure) result.push(file);
+		if (containsDependenciesHeading(content.value) && !isPureDependencyChangeset(content.value).isPure) result.push(file);
 	}
 	return result;
 });
@@ -305,10 +384,15 @@ function makeShape(snapshots, inspector, discovery, detector, config, fs, provid
 		}
 		const inScopeFor = (name) => explicitTargets.size > 0 ? activeTargets.has(name) : inScope.has(name) && !excluded.has(name);
 		const keepDevDeps = options.includeDevDeps === true;
+		const releaseNeutral = /* @__PURE__ */ new Set([
+			"devDependency",
+			"runtime",
+			"packageManager"
+		]);
 		const scoped = rawDiffs.filter((d) => inScopeFor(d.package));
 		const resolved = [];
 		for (const diff of scoped) {
-			const rows = keepDevDeps ? [...diff.rows] : diff.rows.filter((r) => r.type !== "devDependency");
+			const rows = keepDevDeps ? [...diff.rows] : diff.rows.filter((r) => !releaseNeutral.has(r.type));
 			if (rows.length > 0) resolved.push({
 				...diff,
 				rows: sortDependencyRows(rows)
@@ -316,6 +400,10 @@ function makeShape(snapshots, inspector, discovery, detector, config, fs, provid
 		}
 		const existingPure = yield* findPureDependencyChangesets(fs, changesetDir);
 		const skippedMixed = yield* findMixedDependencyChangesets(fs, changesetDir);
+		const coexisting = (yield* findProseChangesets(fs, changesetDir)).map((p) => ({
+			file: p.file,
+			packages: p.packages.filter(inScopeFor)
+		})).filter((p) => p.packages.length > 0);
 		const rewrittenPackages = new Set(resolved.map((d) => d.package));
 		const atMergeBase = yield* gitListChangesetFilesAtRef(resolvedCwd, fromRef).pipe(Effect.provide(provideGit));
 		const authoredOnBranch = (file) => !atMergeBase.has(basename(file));
@@ -333,7 +421,8 @@ function makeShape(snapshots, inspector, discovery, detector, config, fs, provid
 		return {
 			toDelete,
 			toWrite,
-			skippedMixed
+			skippedMixed,
+			coexisting
 		};
 	});
 	const execute = (plan) => Effect.gen(function* () {
@@ -351,7 +440,8 @@ function makeShape(snapshots, inspector, discovery, detector, config, fs, provid
 		return {
 			deleted,
 			written,
-			skippedMixed: plan.skippedMixed
+			skippedMixed: plan.skippedMixed,
+			coexisting: plan.coexisting
 		};
 	});
 	return {
@@ -372,15 +462,21 @@ const ConfigGraph = ChangesetConfig.layer.pipe(Layer.provide(ChangesetConfigRead
 * lazily); pass an explicit `cwd` when planning against a different root
 * (fixtures, multi-repo hosts).
 *
-* `Workspaces.layerWithGit` mints a fresh layer reference per call, so the
-* graph is bound ONCE per builder call and shared across every internal
-* branch — layer memoization by reference constructs each kit service
-* exactly once.
+* The graph is `Workspaces.layerWithGitAndConfigDependenciesSubprocess` —
+* `layerWithGit`'s service set with config-dependency hook replay in catalog
+* assembly, so hook-injected catalogs resolve to ranges (#539). The subprocess
+* replay is chosen over the in-process one because silk's consumers (the
+* `savvy` CLI, the `savvy-mcp` server) are bundled, and a bundler compiles the
+* in-process replay's computed dynamic `import()` into a context module that
+* cannot resolve at runtime. The kit mints a fresh layer reference per call,
+* so the graph is bound ONCE per builder call and shared across every internal
+* branch — layer memoization by reference constructs each kit service exactly
+* once.
 *
 * @public
 */
 function makeDepsRegenDefault(options) {
-	const kitGraph = Workspaces.layerWithGit(options);
+	const kitGraph = Workspaces.layerWithGitAndConfigDependenciesSubprocess(options);
 	return DepsRegen.layer.pipe(Layer.provide(ConfigInspector.layer.pipe(Layer.provide(Layer.mergeAll(ChangesetConfigReader.layer, kitGraph)))), Layer.provide(SilkPublishability.layerAdaptive.pipe(Layer.provide(Layer.mergeAll(ConfigGraph, kitGraph)))), Layer.provide(ConfigGraph), Layer.provide(kitGraph));
 }
 /**
@@ -413,4 +509,4 @@ function makeDepsRegenDefault(options) {
 const DepsRegenDefault = makeDepsRegenDefault();
 
 //#endregion
-export { DepsRegen, DepsRegenDefault, isPureDependencyChangeset, makeDepsRegenDefault };
+export { DepsRegen, DepsRegenDefault, isPureDependencyChangeset, makeDepsRegenDefault, parseChangesetPackages };

package/changesets/services/release-planner.js

@@ -129,6 +129,19 @@ function extractVersionBlock(changelog, version) {
 	}
 	return lines.slice(start, end).join("\n").trim();
 }
+/**
+* Read the `thanks` changelog option from the changesets config tuple
+* (`"changelog": ["@savvy-web/changelog", { "thanks": false }]`), if set.
+* A missing or non-boolean value returns `undefined` so the transformer's
+* default (`true`) applies.
+*/
+function thanksOption(config) {
+	if (!Array.isArray(config.changelog)) return void 0;
+	const opts = config.changelog[1];
+	if (typeof opts !== "object" || opts === null) return void 0;
+	const thanks = opts.thanks;
+	return typeof thanks === "boolean" ? thanks : void 0;
+}
 /** Maintenance reasons for every changeset-less release in the plan, keyed by package name. */
 function maintenanceReasons(plan, config) {
 	const reasons = /* @__PURE__ */ new Map();
@@ -236,11 +249,15 @@ function previewEffect(root, changelogModules, fs) {
 			const clPath = join(dir, "CHANGELOG.md");
 			if (!(yield* fs.exists(clPath))) continue;
 			const reason = reasonByName.get(r.name);
+			const thanks = thanksOption(config);
 			yield* Effect.try({
-				try: () => ChangelogTransformer.transformFile(clPath, reason ? { maintenance: {
-					version: r.newVersion,
-					reason
-				} } : void 0),
+				try: () => ChangelogTransformer.transformFile(clPath, {
+					...reason ? { maintenance: {
+						version: r.newVersion,
+						reason
+					} } : {},
+					...thanks !== void 0 ? { thanks } : {}
+				}),
 				catch: (e) => new ReleasePlanError({
 					phase: "preview",
 					reason: errMsg(e)
@@ -300,6 +317,7 @@ function applyEffect(root, dryRun, changelogModules, inspector, fs) {
 		let touchedFiles = [];
 		if (!dryRun) {
 			const reasonByName = maintenanceReasons(plan, config);
+			const thanks = thanksOption(config);
 			const versionByPkgName = new Map(plan.releases.map((r) => [r.name, r.newVersion]));
 			const nameByDir = /* @__PURE__ */ new Map();
 			for (const p of packages.packages) nameByDir.set(p.dir, p.packageJson.name);
@@ -312,10 +330,13 @@ function applyEffect(root, dryRun, changelogModules, inspector, fs) {
 						const pkgName = nameByDir.get(dirname(f));
 						const reason = pkgName ? reasonByName.get(pkgName) : void 0;
 						const newVersion = pkgName ? versionByPkgName.get(pkgName) : void 0;
-						ChangelogTransformer.transformFile(f, reason && newVersion ? { maintenance: {
-							version: newVersion,
-							reason
-						} } : void 0);
+						ChangelogTransformer.transformFile(f, {
+							...reason && newVersion ? { maintenance: {
+								version: newVersion,
+								reason
+							} } : {},
+							...thanks !== void 0 ? { thanks } : {}
+						});
 					}
 					return touched;
 				},

package/changesets/utils/dep-diff.js

@@ -1,7 +1,35 @@
 import { sortDependencyRows } from "./dependency-table.js";
 import { Option } from "effect";
+import { WorkspaceStateSnapshot } from "@effected/workspaces";
 
 //#region src/changesets/utils/dep-diff.ts
+/**
+* Compute per-workspace-package dependency-table rows from two
+* {@link WorkspaceStateSnapshot}s, resolving `catalog:` / `workspace:`
+* specifiers against each side's own catalogs and package versions BEFORE
+* comparing.
+*
+* @remarks
+* Operates on declared dependencies only (the `dependencies` /
+* `devDependencies` / `peerDependencies` / `optionalDependencies` fields
+* of each workspace's `package.json`). Lockfile-only movements
+* (resolved versions changing while declared ranges stay put) are
+* intentionally excluded — those happen on every `pnpm install` and
+* would generate constant noise.
+*
+* Each side carries its own catalogs and package versions, so a specifier
+* is resolved against the snapshot it belongs to: `catalog:silk` resolves
+* to that ref's `silk` catalog entry, `workspace:*` to that ref's target
+* package version. A row is emitted iff the two RESOLVED values differ (or
+* the dependency was added/removed) — a package that merely adopted a
+* `catalog:` specifier without changing the concrete version produces NO
+* row. When a side cannot resolve a specifier (no matching catalog entry,
+* plain range, etc.) it falls back to the raw specifier string.
+*
+* @see {@link DependencyTableRow} for the row schema
+* @see {@link WorkspaceStateSnapshot} for the input shape
+*
+*/
 /** The em-dash sentinel (U+2014) used for added ("from") / removed ("to") cells. */
 const EM_DASH = "—";
 const DEP_TYPE_MAP = [
@@ -69,8 +97,9 @@ const collapseFieldMoves = (rows) => {
 */
 function computeWorkspaceDependencyDiffs(before, after) {
 	const result = [];
-	for (const afterPkg of after.packages) {
-		const beforePkg = Option.getOrNull(before.package(afterPkg.name));
+	const [seededBefore, seededAfter] = WorkspaceStateSnapshot.crossSeed(before, after);
+	for (const afterPkg of seededAfter.packages) {
+		const beforePkg = Option.getOrNull(seededBefore.package(afterPkg.name));
 		const rows = [];
 		const afterImporter = afterPkg.relativePath;
 		const beforeImporter = beforePkg?.relativePath ?? afterImporter;
@@ -80,7 +109,7 @@ function computeWorkspaceDependencyDiffs(before, after) {
 			const seen = /* @__PURE__ */ new Set();
 			for (const [name, beforeSpec] of Object.entries(beforeRecord)) {
 				seen.add(name);
-				const from = resolveOrRaw(before, beforeImporter, name, beforeSpec);
+				const from = resolveOrRaw(seededBefore, beforeImporter, name, beforeSpec);
 				const afterSpec = afterRecord[name];
 				if (afterSpec === void 0) {
 					rows.push({
@@ -92,7 +121,7 @@ function computeWorkspaceDependencyDiffs(before, after) {
 					});
 					continue;
 				}
-				const to = resolveOrRaw(after, afterImporter, name, afterSpec);
+				const to = resolveOrRaw(seededAfter, afterImporter, name, afterSpec);
 				if (from !== to) rows.push({
 					dependency: name,
 					type,
@@ -108,7 +137,7 @@ function computeWorkspaceDependencyDiffs(before, after) {
 					type,
 					action: "added",
 					from: EM_DASH,
-					to: resolveOrRaw(after, afterImporter, name, afterSpec)
+					to: resolveOrRaw(seededAfter, afterImporter, name, afterSpec)
 				});
 			}
 		}

package/changesets/utils/dependency-section.js

@@ -0,0 +1,34 @@
+//#region src/changesets/utils/dependency-section.ts
+/**
+* Scan a `## Dependencies` section starting at the node AFTER its heading.
+*
+* Collects every content block until the next heading (any depth) or end of
+* input, and selects the first table found anywhere among them. See the module
+* remarks for the semantics this encodes and why they live in one place.
+*
+* @param nodes - The sibling node list containing the section (root children
+*   for mdast, the top-level token list for micromark)
+* @param startIndex - Index of the first node after the section heading
+* @param adapter - Engine-specific node predicates
+* @returns The section's blocks and its first table, if any
+*
+* @internal
+*/
+function scanDependencySection(nodes, startIndex, adapter) {
+	const blocks = [];
+	let table;
+	for (let i = startIndex; i < nodes.length; i++) {
+		const node = nodes[i];
+		if (adapter.isSkippable?.(node)) continue;
+		if (adapter.isHeading(node)) break;
+		blocks.push(node);
+		if (table === void 0 && adapter.isTable(node)) table = node;
+	}
+	return {
+		blocks,
+		table
+	};
+}
+
+//#endregion
+export { scanDependencySection };

package/changesets/utils/dependency-table.js

@@ -1,5 +1,5 @@
 import { DependencyTableRowSchema } from "../schemas/dependency-table.js";
-import { literalText, stringifyMarkdown } from "./remark-pipeline.js";
+import { stringifyMarkdown } from "./remark-pipeline.js";
 import { Schema } from "effect";
 import { toString } from "mdast-util-to-string";
 
@@ -101,10 +101,12 @@ function parseDependencyTable(table) {
 * Create a table cell with a text node.
 *
 * @remarks
-* The cell text is marked literal, so stringification writes it verbatim
-* instead of escaping characters that could open a markdown construct. See
-* {@link literalText} — without it `~0.2.1` is written as `\~0.2.1` and
-* `some_pkg` as `some\_pkg`.
+* The cell holds a plain text node; the canonical stringifier escapes any
+* character that could open a markdown construct (`~0.2.1` is written as
+* `\~0.2.1`, `some_pkg` as `some\_pkg`, `|` as `\|`). Parsing consumes the
+* escapes, so cell VALUES round-trip byte-identically through
+* parse-and-reserialize — the escaping is a raw-byte spelling, never a
+* value change, and it cannot compound across cycles.
 *
 * @param text - The cell text content
 * @returns An MDAST `TableCell` node
@@ -114,7 +116,10 @@ function parseDependencyTable(table) {
 function makeCell(text) {
 	return {
 		type: "tableCell",
-		children: [literalText(text)]
+		children: [{
+			type: "text",
+			value: text
+		}]
 	};
 }
 /**
@@ -167,9 +172,9 @@ function serializeDependencyTable(rows) {
 * Serialize dependency table rows to a markdown table string.
 *
 * @remarks
-* Combines {@link serializeDependencyTable} with unified/remark-gfm/remark-stringify
-* to produce a ready-to-use GFM markdown table string. The result is trimmed
-* of leading/trailing whitespace.
+* Combines {@link serializeDependencyTable} with the canonical
+* `@effected/markdown` emit boundary to produce a ready-to-use GFM markdown
+* table string. The result is trimmed of leading/trailing whitespace.
 *
 * @param rows - Array of `DependencyTableRow` objects
 * @returns Markdown table string (GFM format)

package/changesets/utils/markdown-emit.js

@@ -0,0 +1,86 @@
+import { Result } from "effect";
+import { Markdown, Mdast } from "@effected/markdown";
+
+//#region src/changesets/utils/markdown-emit.ts
+/**
+* Unwrap a `Result` from the kit's emit boundary, converting a typed failure
+* into a defect.
+*
+* @remarks
+* The trees this pipeline emits are either parsed by our own remark pipeline
+* or synthesized by our own plugins, so a decode or stringify failure is a
+* programmer error, not an operational condition — the sync call sites treat
+* it as a defect with the typed error preserved as `cause`.
+*
+* @internal
+*/
+function unwrap(result, context) {
+	if (Result.isFailure(result)) {
+		const error = result.failure;
+		throw new Error(`${context}: ${error.message}`, { cause: error });
+	}
+	return result.success;
+}
+/**
+* Default `fenceChar` on language-less code nodes so they emit FENCED.
+*
+* @remarks
+* The kit's canonical form emits a code node carrying neither `lang` nor
+* `fenceChar` as an INDENTED block — and `lang: null` is exactly what
+* remark-parse produces for a ``` fence with no info string, so without this
+* pass every language-less snippet in changelog content would change shape.
+* Worse, the indented default is neighbor-dependent: the serializer takes a
+* representability escape back to a backtick fence when the indented form
+* would misparse (e.g. code immediately after a list), so the same node
+* spells differently depending on what precedes it — inconsistent raw
+* output. House policy is fenced code everywhere, so the ONE emit boundary defaults
+* the kit's own per-node fidelity field, `fenceChar`, post-decode. It has to
+* happen post-decode: `Mdast.fromMdast` drops non-mdast fields from foreign
+* trees, so a `fenceChar` set on the plain tree would never survive the
+* boundary. Nodes are copied only where a default is applied; everything
+* else is returned by reference.
+*
+* @internal
+*/
+function ensureFencedCode(node) {
+	let result = node;
+	const children = node.children;
+	if (children !== void 0) {
+		const mapped = children.map(ensureFencedCode);
+		if (mapped.some((child, index) => child !== children[index])) result = {
+			...node,
+			children: mapped
+		};
+	}
+	if (result.type === "code" && result.lang === void 0 && result.fenceChar === void 0) return {
+		...result,
+		fenceChar: "`"
+	};
+	return result;
+}
+/**
+* Serialize a plain MDAST tree to canonical markdown.
+*
+* @remarks
+* The single emit chokepoint for the changesets pipeline: decodes the plain
+* mdast tree into `@effected/markdown`'s node classes via
+* `Mdast.fromMdastResult` and serializes it with `Markdown.stringifyResult`.
+* Synchronous on purpose — every call site is a sync string pipeline — and
+* failures (an undecodable node type, the nesting-depth hardening guard) are
+* defects on self-built trees, so they throw rather than surface typed.
+*
+* The output always ends with exactly one trailing newline, matching the
+* kit's document-level canonical rule.
+*
+* @param tree - The plain mdast root to serialize
+* @returns Canonical markdown text
+*
+* @internal
+*/
+function emitMarkdown(tree) {
+	const fenced = ensureFencedCode(unwrap(Mdast.fromMdastResult(tree), "markdown emit: mdast tree failed to decode"));
+	return unwrap(Markdown.stringifyResult(fenced), "markdown emit: canonical stringify failed");
+}
+
+//#endregion
+export { emitMarkdown };

package/changesets/utils/remark-pipeline.js

@@ -1,93 +1,19 @@
+import { emitMarkdown } from "./markdown-emit.js";
 import remarkGfm from "remark-gfm";
 import remarkParse from "remark-parse";
-import remarkStringify from "remark-stringify";
 import { unified } from "unified";
 
 //#region src/changesets/utils/remark-pipeline.ts
 /**
-* Marker set on the `data` of a text node whose value must be written to
-* markdown verbatim rather than escaped.
-*
-* @remarks
-* `remark-stringify` escapes any character that could open a markdown
-* construct. Inside a dependency table that is always wrong: with
-* `remark-gfm` enabled `~` is the strikethrough delimiter, so the specifier
-* `~0.2.1` is written as `\~0.2.1`, and `_` in a package name becomes `\_`.
-* The corruption compounds on every re-serialization, and dependency-table
-* cells round-trip through consolidation and PR-body reconstruction.
-*
-* The marker is deliberately narrow. It is set only by the dependency-table
-* cell builder, whose cell vocabulary is closed — package name, dependency
-* type, action, version specifier, and the em-dash sentinel — and none of
-* those can legitimately carry markdown. Prose elsewhere in a changeset keeps
-* the default escaping.
-*
-* @internal
-*/
-const LITERAL_TEXT_MARKER = "silkLiteralText";
-/**
-* Mark a text node so {@link createRemarkProcessor} writes it verbatim.
-*
-* @param value - The literal cell text
-* @returns An MDAST `Text` node carrying the literal marker
-*
-* @internal
-*/
-function literalText(value) {
-	return {
-		type: "text",
-		value,
-		data: { [LITERAL_TEXT_MARKER]: true }
-	};
-}
-/**
-* Whether a text node was marked by {@link literalText}.
-*
-* @internal
-*/
-function isLiteralText(node) {
-	return node.data?.[LITERAL_TEXT_MARKER] === true;
-}
-/**
-* Escape the two characters that would otherwise corrupt the table grid.
-*
-* @remarks
-* A `|` would close the cell early and a `\` would be read as an escape
-* introducer, so both are escaped to keep the written cell parseable back to
-* its exact input. Every other character is emitted as-is. Because parsing
-* consumes the backslash, a value that already carries a legacy `\~` from the
-* old escaping path re-parses to its clean form rather than accumulating
-* another layer.
-*
-* @internal
-*/
-function escapeCellLiteral(value) {
-	return value.replace(/[\\|]/g, "\\$&");
-}
-/**
-* `mdast-util-to-markdown` handler overrides used by the shared processor.
-*
-* @remarks
-* Replaces the default `text` handler — which is `state.safe(node.value, info)`
-* — with one that bypasses escaping for nodes marked by {@link literalText}
-* and delegates to the default behavior for everything else.
-*
-* @internal
-*/
-const literalTextHandlers = { text: (node, _parent, state, info) => {
-	const text = node;
-	return isLiteralText(text) ? escapeCellLiteral(text.value) : state.safe(text.value, info);
-} };
-/**
-* Create a unified processor configured with remark-parse, remark-gfm,
-* and remark-stringify.
+* Create a unified processor configured with remark-parse and remark-gfm.
 *
 * @remarks
 * Each call creates a fresh processor instance. The plugin chain is:
 * 1. `remark-parse` — markdown to MDAST
 * 2. `remark-gfm` — GitHub Flavored Markdown extensions (tables, etc.)
-* 3. `remark-stringify` — MDAST back to markdown, with the
-*    {@link literalText} handler override
+*
+* The processor carries no compiler: stringification goes through
+* {@link stringifyMarkdown}, never `processor.stringify`.
 *
 * @privateRemarks
 * Return type is intentionally inferred because the unified `Processor`
@@ -98,7 +24,7 @@ const literalTextHandlers = { text: (node, _parent, state, info) => {
 * @internal
 */
 function createRemarkProcessor() {
-	return unified().use(remarkParse).use(remarkGfm).use(remarkStringify, { handlers: literalTextHandlers });
+	return unified().use(remarkParse).use(remarkGfm);
 }
 /**
 * Parse a markdown string into an MDAST AST synchronously.
@@ -126,11 +52,14 @@ function parseMarkdown(content) {
 	return createRemarkProcessor().parse(content);
 }
 /**
-* Stringify an MDAST AST back to a markdown string synchronously.
+* Stringify an MDAST AST back to markdown text synchronously.
 *
 * @remarks
-* Uses {@link createRemarkProcessor} internally. GFM constructs
-* (tables, etc.) are serialized correctly thanks to the remark-gfm plugin.
+* Delegates to the canonical `@effected/markdown` emit boundary
+* (`emitMarkdown`), so the output is the kit's canonical form — ATX
+* headings, `-` bullets, `*`/`**` emphasis, `***` thematic breaks, one
+* blank line between blocks, a single trailing newline. GFM constructs
+* (tables, strikethrough) are serialized natively.
 *
 * @param tree - The MDAST root node
 * @returns The serialized markdown string
@@ -147,8 +76,8 @@ function parseMarkdown(content) {
 * @internal
 */
 function stringifyMarkdown(tree) {
-	return createRemarkProcessor().stringify(tree);
+	return emitMarkdown(tree);
 }
 
 //#endregion
-export { LITERAL_TEXT_MARKER, createRemarkProcessor, literalText, parseMarkdown, stringifyMarkdown };
+export { createRemarkProcessor, parseMarkdown, stringifyMarkdown };

package/changesets/utils/section-parser.js

@@ -60,12 +60,14 @@ function parseChangesetSections(summary) {
 		const headingNode = tree.children[headingIndex];
 		const headingText = toString(headingNode);
 		const nextIndex = i + 1 < h2Indices.length ? h2Indices[i + 1] : tree.children.length;
-		const content = stringifyAstSlice(tree.children.slice(headingIndex + 1, nextIndex));
+		const contentNodes = tree.children.slice(headingIndex + 1, nextIndex);
+		const content = stringifyAstSlice(contentNodes);
 		const category = fromHeading(headingText);
 		if (category) result.sections.push({
 			category,
 			heading: headingText,
-			content
+			content,
+			contentNodes
 		});
 	}
 	return result;