@savvy-web/silk-effects 9.5.4 → 9.5.5

package/changesets/changelog/getReleaseLine.js

@@ -1,56 +1,23 @@
 import { resolveCommitType } from "../categories/index.js";
 import { GitHubService } from "../services/github.js";
 import { logWarning } from "../utils/logger.js";
-import { parseMarkdown, stringifyMarkdown } from "../utils/remark-pipeline.js";
+import { emitKitMarkdown, parseKitMarkdown } from "../utils/markdown-emit.js";
 import { GitHubInfoSchema } from "../schemas/github.js";
 import { parseCommitMessage } from "../utils/commit-parser.js";
 import { parseIssueReferences } from "../utils/issue-refs.js";
-import { parseChangesetSections } from "../utils/section-parser.js";
+import { sectionsOf } from "../utils/section-parser.js";
 import { formatChangelogEntry, formatPRAndUserAttribution } from "./formatting.js";
-import { Effect, Schema } from "effect";
+import { Effect, Result, Schema } from "effect";
+import { Markdown, MarkdownTransform, Paragraph, Text } from "@effected/markdown";
 
 //#region src/changesets/changelog/getReleaseLine.ts
 /**
-* Core formatter: getReleaseLine.
-*
-* Formats a single changeset into a changelog entry. This is the primary
-* formatting function in the changelog pipeline, responsible for transforming
-* a `NewChangesetWithCommit` into structured markdown output.
-*
-* @remarks
-* The formatter supports two distinct input modes:
-*
-* 1. **Section-aware changesets** — When the changeset summary contains h2
-*    headings (e.g., `## Features`, `## Bug Fixes`), each section is rendered
-*    as an h3 heading with list items beneath it. This mode
-*    produces multi-line output suitable for rich changelogs.
-*
-* 2. **Flat-text changesets** — When the summary is plain text without section
-*    headings, the formatter falls back to backward-compatible single-line
-*    output. The conventional commit type is resolved via `resolveCommitType`
-*    to determine the changelog category.
-*
-* In both modes, the formatter:
-* - Fetches GitHub metadata (PR number, author) via {@link GitHubService}
-* - Extracts and renders issue references (Closes, Fixes, Refs)
-* - Appends PR and user attribution when available
-*
-* @see {@link formatChangelogEntry} for the low-level entry formatting
-* @see {@link formatPRAndUserAttribution} for attribution suffix generation
-* @see {@link getDependencyReleaseLine} for the companion dependency formatter
-*
-* @internal
-*/
-/**
-* Stringify a single MDAST block node back to markdown, trimmed.
+* Stringify a single block node back to markdown, trimmed.
 *
 * @internal
 */
 function stringifyNode(node) {
-	return stringifyMarkdown({
-		type: "root",
-		children: [node]
-	}).trimEnd();
+	return emitKitMarkdown(node).trimEnd();
 }
 /**
 * Render one top-level section content node to markdown.
@@ -77,13 +44,7 @@ function renderSectionNode(node) {
 		const [first, ...rest] = stringifyNode(node).split("\n");
 		return [`- ${first}`, ...rest.map((line) => line.length > 0 ? `  ${line}` : line)].join("\n");
 	}
-	if (node.type === "heading") {
-		const heading = node;
-		return stringifyNode({
-			...heading,
-			depth: Math.min(Math.max(heading.depth + 1, 4), 6)
-		});
-	}
+	if (node.type === "heading") return stringifyNode(MarkdownTransform.shiftHeadings(node, 1, { min: 4 }));
 	return stringifyNode(node);
 }
 /**
@@ -96,12 +57,9 @@ function renderSectionNode(node) {
 function attributionPhrasing(attribution) {
 	const trimmed = attribution.trim();
 	if (trimmed === "") return void 0;
-	const first = parseMarkdown(trimmed).children[0];
-	if (first?.type !== "paragraph") return void 0;
-	return [{
-		type: "text",
-		value: " "
-	}, ...first.children];
+	const parsed = Markdown.parsePhrasingResult(trimmed);
+	if (Result.isFailure(parsed) || parsed.success.length === 0) return void 0;
+	return [new Text({ value: " " }), ...parsed.success];
 }
 /**
 * Find the paragraph of a list's FINAL RENDERED bullet: the last paragraph
@@ -178,7 +136,8 @@ function getReleaseLine(changeset, versionType, options) {
 			commit: changeset.commit,
 			repo: options.repo
 		}).pipe(Effect.flatMap((raw) => Schema.decodeUnknownEffect(GitHubInfoSchema)(raw).pipe(Effect.map(() => raw), Effect.catch(() => Effect.succeed(raw)))), Effect.catch((error) => logWarning("Could not fetch GitHub info for commit:", changeset.commit ?? "", String(error)).pipe(Effect.as(null))));
-		const parsed = parseChangesetSections(changeset.summary);
+		const tree = parseKitMarkdown(changeset.summary);
+		let parsed = sectionsOf(tree, changeset.summary);
 		const firstLine = changeset.summary.split("\n")[0];
 		const commitMsg = parseCommitMessage(firstLine);
 		const bodyText = changeset.summary.split("\n").slice(1).join("\n");
@@ -190,8 +149,13 @@ function getReleaseLine(changeset, versionType, options) {
 			let standaloneAttribution;
 			if (phrasing) {
 				const target = findAttributionTarget(parsed.sections);
-				if (target) target.children.push(...phrasing);
-				else standaloneAttribution = attribution.trim();
+				if (target) {
+					const attributed = MarkdownTransform.map(tree, { paragraph: (para) => para === target ? new Paragraph({
+						...para,
+						children: [...para.children, ...phrasing]
+					}) : para });
+					parsed = sectionsOf(attributed, changeset.summary);
+				} else standaloneAttribution = attribution.trim();
 			}
 			const blocks = [];
 			if (parsed.preamble) blocks.push(parsed.preamble);

package/changesets/utils/markdown-emit.js

@@ -1,5 +1,5 @@
 import { Result } from "effect";
-import { Markdown, Mdast } from "@effected/markdown";
+import { Code, Markdown, MarkdownTransform, Mdast } from "@effected/markdown";
 
 //#region src/changesets/utils/markdown-emit.ts
 /**
@@ -37,26 +37,16 @@ function unwrap(result, context) {
 * 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.
+* boundary. `MarkdownTransform.map` rebuilds only the paths to a changed
+* code node; every other subtree 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,
+	return MarkdownTransform.map(node, { code: (code) => code.lang === void 0 && code.fenceChar === void 0 ? new Code({
+		...code,
 		fenceChar: "`"
-	};
-	return result;
+	}) : code });
 }
 /**
 * Serialize a plain MDAST tree to canonical markdown.
@@ -81,6 +71,40 @@ 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");
 }
+/**
+* Parse markdown text straight into `@effected/markdown`'s node classes (GFM
+* dialect, frontmatter capture off).
+*
+* @remarks
+* Synchronous for the same reason as {@link emitMarkdown}; the kit's parser
+* is total over text, so a failure here is a defect (the nesting-depth
+* hardening guard), not an operational condition.
+*
+* @param text - The markdown source
+* @returns The parsed kit root
+*
+* @internal
+*/
+function parseKitMarkdown(text) {
+	const parsed = unwrap(Markdown.parseResult(text), "markdown parse: canonical parse failed");
+	return unwrap(Mdast.fromMdastResult(Mdast.toMdast(parsed)), "markdown parse: fidelity strip failed");
+}
+/**
+* Serialize a kit root, or a single kit block node, to canonical markdown.
+*
+* @remarks
+* The kit-tree twin of {@link emitMarkdown}: the same fence normalization,
+* then `Markdown.stringifyResult`. A lone block node emits byte-identically
+* to a one-child root, trailing newline included.
+*
+* @param node - The kit root or block node to serialize
+* @returns Canonical markdown text
+*
+* @internal
+*/
+function emitKitMarkdown(node) {
+	return unwrap(Markdown.stringifyResult(ensureFencedCode(node)), "markdown emit: canonical stringify failed");
+}
 
 //#endregion
-export { emitMarkdown };
+export { emitKitMarkdown, emitMarkdown, parseKitMarkdown };

package/changesets/utils/remark-pipeline.js

@@ -5,53 +5,6 @@ import { unified } from "unified";
 
 //#region src/changesets/utils/remark-pipeline.ts
 /**
-* 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.)
-*
-* The processor carries no compiler: stringification goes through
-* {@link stringifyMarkdown}, never `processor.stringify`.
-*
-* @privateRemarks
-* Return type is intentionally inferred because the unified `Processor`
-* generic signature is complex and parameterized by the plugin chain.
-*
-* @returns A configured unified processor
-*
-* @internal
-*/
-function createRemarkProcessor() {
-	return unified().use(remarkParse).use(remarkGfm);
-}
-/**
-* Parse a markdown string into an MDAST AST synchronously.
-*
-* @remarks
-* Uses {@link createRemarkProcessor} internally. The returned tree
-* includes GFM extensions (tables, strikethrough, etc.) thanks to
-* the remark-gfm plugin.
-*
-* @param content - Raw markdown string
-* @returns The parsed MDAST root node
-*
-* @example
-* ```typescript
-* import { parseMarkdown } from "../utils/remark-pipeline.js";
-*
-* const tree = parseMarkdown("## Version 1.0.0\n\nInitial release.");
-* // tree.type === "root"
-* // tree.children[0].type === "heading"
-* ```
-*
-* @internal
-*/
-function parseMarkdown(content) {
-	return createRemarkProcessor().parse(content);
-}
-/**
 * Stringify an MDAST AST back to markdown text synchronously.
 *
 * @remarks
@@ -80,4 +33,4 @@ function stringifyMarkdown(tree) {
 }
 
 //#endregion
-export { createRemarkProcessor, parseMarkdown, stringifyMarkdown };
+export { stringifyMarkdown };

package/changesets/utils/section-parser.js

@@ -1,96 +1,66 @@
 import { fromHeading } from "../categories/index.js";
-import { parseMarkdown, stringifyMarkdown } from "./remark-pipeline.js";
-import { toString } from "mdast-util-to-string";
+import { emitKitMarkdown } from "./markdown-emit.js";
+import { MarkdownTransform, Mdast, Root } from "@effected/markdown";
 
 //#region src/changesets/utils/section-parser.ts
 /**
-* Parse a changeset summary into structured sections.
+* Slice an already-parsed changeset tree into categorized sections.
 *
 * @remarks
-* The algorithm works in three steps:
-* 1. Parse the summary markdown into an MDAST tree via {@link parseMarkdown}
-* 2. Scan `tree.children` for h2 (`depth === 2`) headings, recording their
-*    indices
-* 3. For each h2, extract the heading text, resolve it to a
-*    {@link SectionCategory} via `fromHeading()`, and collect all nodes
-*    between this h2 and the next h2 (or end of document) as the section
-*    content
+* Split from {@link parseChangesetSections} so a caller can transform the
+* tree (the renderer appends attribution with `MarkdownTransform.map`) and
+* re-slice it without re-parsing. A section runs from its h2 to the next
+* root-level h2 (or the end of the summary); a stray h1 inside a section stays
+* in that section's content, as it always has.
 *
-* If the summary contains h2 (`##`) headings, they are mapped to categories
-* via `fromHeading()`. Content between headings becomes the section content.
-* Content before the first h2 becomes the preamble.
-*
-* If no h2 headings are present, the entire content is returned as the preamble
-* with an empty sections array (backward-compatible flat-text mode).
-*
-* Unknown headings (those not recognized by `fromHeading()`) are silently
-* skipped; validation of heading names is the responsibility of Layer 1
-* (remark-lint).
-*
-* @param summary - The changeset summary markdown
+* @param tree - The parsed summary
+* @param summary - The summary source, returned verbatim as the preamble in
+*   flat-text mode
 * @returns Parsed sections and optional preamble
 *
-* @example
-* ```typescript
-* import { parseChangesetSections } from "../utils/section-parser.js";
-*
-* const result = parseChangesetSections("## Features\n\n- New API\n\n## Bug Fixes\n\n- Fixed crash");
-* // result.sections.length === 2
-* // result.sections[0].category === "Features"
-* // result.preamble === undefined
-* ```
-*
 * @internal
 */
-function parseChangesetSections(summary) {
-	const tree = parseMarkdown(summary);
-	const h2Indices = [];
-	for (let i = 0; i < tree.children.length; i++) {
-		const node = tree.children[i];
-		if (node.type === "heading" && node.depth === 2) h2Indices.push(i);
-	}
-	if (h2Indices.length === 0) return {
+function sectionsOf(tree, summary) {
+	const spans = MarkdownTransform.sections(tree, { depth: 2 });
+	if (spans.length === 0) return {
 		preamble: summary.trim(),
 		sections: []
 	};
 	const result = { sections: [] };
-	if (h2Indices[0] > 0) result.preamble = stringifyAstSlice(tree.children.slice(0, h2Indices[0]));
-	for (let i = 0; i < h2Indices.length; i++) {
-		const headingIndex = h2Indices[i];
-		const headingNode = tree.children[headingIndex];
-		const headingText = toString(headingNode);
-		const nextIndex = i + 1 < h2Indices.length ? h2Indices[i + 1] : tree.children.length;
-		const contentNodes = tree.children.slice(headingIndex + 1, nextIndex);
-		const content = stringifyAstSlice(contentNodes);
+	if (spans[0].headingIndex > 0) result.preamble = stringifyAstSlice(tree.children.slice(0, spans[0].headingIndex));
+	for (let i = 0; i < spans.length; i++) {
+		const span = spans[i];
+		const headingText = Mdast.toText(span.heading);
+		const end = i + 1 < spans.length ? spans[i + 1].headingIndex : tree.children.length;
+		const contentNodes = tree.children.slice(span.headingIndex + 1, end).filter(isFlowContent);
 		const category = fromHeading(headingText);
 		if (category) result.sections.push({
 			category,
 			heading: headingText,
-			content,
+			content: stringifyAstSlice(contentNodes),
 			contentNodes
 		});
 	}
 	return result;
 }
 /**
-* Stringify a slice of MDAST nodes back to markdown.
+* Narrow a root child to block content (frontmatter capture is off and the
+* dialect is GFM, so this only ever drops nothing).
 *
-* @remarks
-* Wraps the nodes in a synthetic root node and delegates to
-* {@link stringifyMarkdown}. Returns an empty string for empty slices.
-*
-* @param nodes - Array of MDAST content nodes
-* @returns Trimmed markdown string, or empty string if no nodes
+* @internal
+*/
+function isFlowContent(node) {
+	return node.type !== "frontmatter" && node.type !== "mdxjsEsm";
+}
+/**
+* Stringify a slice of root children back to trimmed markdown.
 *
 * @internal
 */
 function stringifyAstSlice(nodes) {
 	if (nodes.length === 0) return "";
-	return stringifyMarkdown({
-		type: "root",
-		children: nodes
-	}).trim();
+	return emitKitMarkdown(new Root({ children: nodes })).trim();
 }
 
 //#endregion
-export { parseChangesetSections };
+export { sectionsOf };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/silk-effects",
-	"version": "9.5.4",
+	"version": "9.5.5",
 	"private": false,
 	"description": "Shared Effect library for Silk Suite conventions",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/silk-effects",
@@ -40,14 +40,13 @@
 		"@effected/github-references": "^0.10.0",
 		"@effected/glob": "^0.13.0",
 		"@effected/jsonc": "^0.18.0",
-		"@effected/markdown": "^0.18.0",
+		"@effected/markdown": "^0.19.0",
 		"@effected/package-json": "^0.23.0",
 		"@effected/toml": "^0.14.0",
 		"@effected/walker": "^0.18.0",
 		"@effected/yaml": "^0.22.0",
 		"@manypkg/get-packages": "^3.1.0",
 		"@savvy-web/silk-core": "0.4.14",
-		"mdast-util-heading-range": "^4.0.0",
 		"mdast-util-to-string": "^4.0.0",
 		"remark-gfm": "^4.0.1",
 		"remark-parse": "^11.0.0",