@savvy-web/silk-effects 4.2.4 → 4.2.6

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

@@ -1,6 +1,6 @@
 import { VERSION_RE } from "../../schemas/dependency-table.js";
 import { RULE_DOCS } from "../../constants.js";
-import { getHeadingLevel, getHeadingText } from "./utils.js";
+import { getHeadingLevel, getHeadingText, unescapeMarkdown } from "./utils.js";
 
 //#region src/changesets/markdownlint/rules/dependency-table-format.ts
 const EM_DASH = "—";
@@ -31,13 +31,13 @@ const EXPECTED_HEADERS = [
 * The `tableContent` token has a `.text` property with the cell value.
 *
 * @param cell - A GFM table cell token (header or data)
-* @returns The trimmed text content of the cell, or an empty string
+* @returns The trimmed, escape-resolved text content of the cell, or an empty string
 *
 * @internal
 */
 function getCellText(cell) {
 	const content = cell.children.find((c) => c.type === "tableContent");
-	return content ? content.text.trim() : "";
+	return content ? unescapeMarkdown(content.text.trim()) : "";
 }
 /**
 * Extract all cell texts from a `tableRow` token.

package/changesets/markdownlint/rules/utils.js

@@ -14,8 +14,38 @@ function getHeadingLevel(heading) {
 	return sequence ? sequence.text.length : 0;
 }
 /**
+* CommonMark backslash escapes: a backslash is literal unless it precedes an
+* ASCII punctuation character, in which case the pair denotes that character.
+*/
+const BACKSLASH_ESCAPE_RE = /\\([!-/:-@[-`{-~])/g;
+/**
+* Resolve CommonMark backslash escapes in raw micromark source text.
+*
+* @remarks
+* Every rule in this directory has a sibling remark implementation that reads
+* the parsed mdast tree, where the parser has already resolved escapes, via
+* `mdast-util-to-string`. Micromark tokens instead carry RAW source. Comparing
+* raw text against a value the parsed form would produce makes the two
+* implementations of one documented rule disagree about the same file
+* (issue #367).
+*
+* Applied at the shared extractors below so both implementations judge the
+* value a reader actually sees, rather than per-rule where the next extractor
+* added would silently reintroduce the split.
+*
+* @internal
+*/
+function unescapeMarkdown(raw) {
+	return raw.replace(BACKSLASH_ESCAPE_RE, "$1");
+}
+/**
 * Get the plain text content of an `atxHeading` token.
 *
+* @remarks
+* Escape-resolved, so a heading compares equal to the same heading as the
+* remark rules see it. `getHeadingLevel` needs no equivalent — it counts
+* sequence characters rather than reading text.
+*
 * @param heading - The `atxHeading` micromark token
 * @returns The heading text, or empty string if no text token found
 *
@@ -23,8 +53,8 @@ function getHeadingLevel(heading) {
 */
 function getHeadingText(heading) {
 	const textToken = heading.children.find((c) => c.type === "atxHeadingText");
-	return textToken ? textToken.text : "";
+	return textToken ? unescapeMarkdown(textToken.text) : "";
 }
 
 //#endregion
-export { RULE_DOCS, getHeadingLevel, getHeadingText };
+export { RULE_DOCS, getHeadingLevel, getHeadingText, unescapeMarkdown };

package/changesets/services/config-inspector.js

@@ -272,20 +272,25 @@ function readRawPackageJson(fs, pkgDir) {
 }
 /**
 * Build resolved scopes from the discovered workspace packages, keeping only
-* those that are a release surface (declare publishConfig that yields at least
-* one publish target). Used both when `.changeset/config.json` declares no
-* explicit `packages` record AND to augment an explicit record with the
-* remaining workspace packages it does not list (so the record annotates the
-* listed packages without shrinking the release surface). The changeset
-* `ignore` list is intentionally NOT consulted here — an ignored package still
-* declares publishConfig and remains a valid changeset target.
+* those that are a release surface: a package that declares publishConfig
+* yielding at least one publish target, OR — when the changeset config sets
+* `privatePackages.version: true` (`versionPrivate`) — any workspace package
+* at all, since changesets versions private packages too in that mode (#360:
+* a private single-root repo with `privatePackages.version: true` previously
+* produced an empty release surface and left every file unmapped). Used both
+* when `.changeset/config.json` declares no explicit `packages` record AND to
+* augment an explicit record with the remaining workspace packages it does
+* not list (so the record annotates the listed packages without shrinking the
+* release surface). The changeset `ignore` list is intentionally NOT
+* consulted here — an ignored package still declares publishConfig and
+* remains a valid changeset target.
 */
-function buildFallbackScopes(fs, workspaces) {
+function buildFallbackScopes(fs, workspaces, versionPrivate) {
 	return Effect.forEach(workspaces, (ws) => Effect.gen(function* () {
 		const raw = yield* readRawPackageJson(fs, ws.path);
 		if (raw === null) return [];
 		const binding = yield* readTargetsBinding(fs, ws.path);
-		if (SilkPublishability.detect(ws.name, raw, binding).length === 0) return [];
+		if (SilkPublishability.detect(ws.name, raw, binding).length === 0 && !versionPrivate) return [];
 		return [{
 			name: ws.name,
 			workspaceDir: ws.path,
@@ -391,6 +396,8 @@ function makeShape(reader, discovery, fs) {
 			version: w.version
 		}));
 		const hasExplicitPackages = Object.keys(decodedOptions.packages ?? {}).length > 0;
+		const privatePackages = config.privatePackages;
+		const versionPrivate = privatePackages !== void 0 && privatePackages !== false && privatePackages.version === true;
 		let scopes;
 		if (hasExplicitPackages) {
 			const explicitScopes = yield* buildResolvedScopes({
@@ -406,9 +413,9 @@ function makeShape(reader, discovery, fs) {
 				throw e;
 			}
 			const explicitNames = new Set(explicitScopes.map((s) => s.name));
-			const discoveredScopes = yield* buildFallbackScopes(fs, workspaces.filter((w) => !explicitNames.has(w.name)));
+			const discoveredScopes = yield* buildFallbackScopes(fs, workspaces.filter((w) => !explicitNames.has(w.name)), versionPrivate);
 			scopes = [...explicitScopes, ...discoveredScopes];
-		} else scopes = yield* buildFallbackScopes(fs, workspaces);
+		} else scopes = yield* buildFallbackScopes(fs, workspaces, versionPrivate);
 		const inspected = {
 			configPath,
 			projectDir,
@@ -442,12 +449,19 @@ function makeShape(reader, discovery, fs) {
 function classifyOne(inspected, path) {
 	const abs = resolve(inspected.projectDir, path);
 	let bestWorkspace = null;
-	for (const s of inspected.packages) if (isInside(s.workspaceDir, abs)) {
-		const depth = s.workspaceDir.length;
-		if (!bestWorkspace || depth > bestWorkspace.depth) bestWorkspace = {
-			pkg: s.name,
-			depth
-		};
+	let rootScope = null;
+	for (const s of inspected.packages) {
+		if (s.workspaceDir === inspected.projectDir) {
+			rootScope = s.name;
+			continue;
+		}
+		if (isInside(s.workspaceDir, abs)) {
+			const depth = s.workspaceDir.length;
+			if (!bestWorkspace || depth > bestWorkspace.depth) bestWorkspace = {
+				pkg: s.name,
+				depth
+			};
+		}
 	}
 	if (bestWorkspace) return {
 		path,
@@ -474,6 +488,11 @@ function classifyOne(inspected, path) {
 			glob: vf.glob
 		}
 	};
+	if (rootScope && isInside(inspected.projectDir, abs)) return {
+		path,
+		package: rootScope,
+		reason: "workspace"
+	};
 	return {
 		path,
 		package: null,

package/changesets/utils/dep-diff.js

@@ -11,10 +11,23 @@ const DEP_TYPE_MAP = [
 	["optionalDependencies", "optionalDependency"]
 ];
 /**
-* Resolve a specifier against the snapshot it belongs to, falling back to
-* the raw specifier string when the snapshot cannot resolve it.
+* Resolve a specifier against the snapshot it belongs to, scoped to the
+* importer that declared it, falling back to the raw specifier string when
+* the snapshot cannot resolve it.
+*
+* @remarks
+* Uses `resolveIn` rather than the workspace-wide `resolve`. Both consult the
+* ref's own lockfile importer entries when a `catalog:` specifier is not in the
+* catalog set — which is what makes hook-injected catalogs (`catalog:effect:peers`,
+* injected by a config-dependency pnpmfile and recorded in neither
+* `pnpm-workspace.yaml` nor the lockfile's `catalogs:` block) resolvable at all.
+* The workspace-wide form abstains whenever two importers disagree on a
+* dependency's version, which in a multi-package repo reproduces the original
+* defect: both sides fall back to the identical raw specifier, compare equal,
+* and emit no row. Scoping to the declaring importer answers precisely where
+* the workspace-wide form cannot.
 */
-const resolveOrRaw = (snapshot, dep, spec) => Option.getOrElse(snapshot.resolve(dep, spec), () => spec);
+const resolveOrRaw = (snapshot, importerPath, dep, spec) => Option.getOrElse(snapshot.resolveIn(importerPath, dep, spec), () => spec);
 /**
 * Drop no-net-change field moves: the same dependency removed from one field
 * and added to another with an equal resolved version (e.g. a dep promoted
@@ -59,13 +72,15 @@ function computeWorkspaceDependencyDiffs(before, after) {
 	for (const afterPkg of after.packages) {
 		const beforePkg = Option.getOrNull(before.package(afterPkg.name));
 		const rows = [];
+		const afterImporter = afterPkg.relativePath;
+		const beforeImporter = beforePkg?.relativePath ?? afterImporter;
 		for (const [field, type] of DEP_TYPE_MAP) {
 			const beforeRecord = beforePkg?.[field] ?? {};
 			const afterRecord = afterPkg[field];
 			const seen = /* @__PURE__ */ new Set();
 			for (const [name, beforeSpec] of Object.entries(beforeRecord)) {
 				seen.add(name);
-				const from = resolveOrRaw(before, name, beforeSpec);
+				const from = resolveOrRaw(before, beforeImporter, name, beforeSpec);
 				const afterSpec = afterRecord[name];
 				if (afterSpec === void 0) {
 					rows.push({
@@ -77,7 +92,7 @@ function computeWorkspaceDependencyDiffs(before, after) {
 					});
 					continue;
 				}
-				const to = resolveOrRaw(after, name, afterSpec);
+				const to = resolveOrRaw(after, afterImporter, name, afterSpec);
 				if (from !== to) rows.push({
 					dependency: name,
 					type,
@@ -93,7 +108,7 @@ function computeWorkspaceDependencyDiffs(before, after) {
 					type,
 					action: "added",
 					from: EM_DASH,
-					to: resolveOrRaw(after, name, afterSpec)
+					to: resolveOrRaw(after, afterImporter, name, afterSpec)
 				});
 			}
 		}

package/changesets/utils/dependency-table.js

@@ -1,8 +1,6 @@
+import { literalText, stringifyMarkdown } from "./remark-pipeline.js";
 import { DependencyTableRowSchema } from "../schemas/dependency-table.js";
 import { Schema } from "effect";
-import remarkGfm from "remark-gfm";
-import remarkStringify from "remark-stringify";
-import { unified } from "unified";
 import { toString } from "mdast-util-to-string";
 
 //#region src/changesets/utils/dependency-table.ts
@@ -102,6 +100,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`.
+*
 * @param text - The cell text content
 * @returns An MDAST `TableCell` node
 *
@@ -110,10 +114,7 @@ function parseDependencyTable(table) {
 function makeCell(text) {
 	return {
 		type: "tableCell",
-		children: [{
-			type: "text",
-			value: text
-		}]
+		children: [literalText(text)]
 	};
 }
 /**
@@ -188,11 +189,10 @@ function serializeDependencyTable(rows) {
 * @internal
 */
 function serializeDependencyTableToMarkdown(rows) {
-	const tree = {
+	return stringifyMarkdown({
 		type: "root",
 		children: [serializeDependencyTable(rows)]
-	};
-	return unified().use(remarkGfm).use(remarkStringify).stringify(tree).trim();
+	}).trim();
 }
 /**
 * Sort priority for dependency actions: removed first, then updated, then added.

package/changesets/utils/remark-pipeline.js

@@ -5,6 +5,80 @@ 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.
 *
@@ -12,7 +86,8 @@ import { unified } from "unified";
 * 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
+* 3. `remark-stringify` — MDAST back to markdown, with the
+*    {@link literalText} handler override
 *
 * @privateRemarks
 * Return type is intentionally inferred because the unified `Processor`
@@ -23,7 +98,7 @@ import { unified } from "unified";
 * @internal
 */
 function createRemarkProcessor() {
-	return unified().use(remarkParse).use(remarkGfm).use(remarkStringify);
+	return unified().use(remarkParse).use(remarkGfm).use(remarkStringify, { handlers: literalTextHandlers });
 }
 /**
 * Parse a markdown string into an MDAST AST synchronously.
@@ -76,4 +151,4 @@ function stringifyMarkdown(tree) {
 }
 
 //#endregion
-export { createRemarkProcessor, parseMarkdown, stringifyMarkdown };
+export { LITERAL_TEXT_MARKER, createRemarkProcessor, literalText, parseMarkdown, stringifyMarkdown };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/silk-effects",
-	"version": "4.2.4",
+	"version": "4.2.6",
 	"private": false,
 	"description": "Shared Effect library for Silk Suite conventions",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/silk-effects",
@@ -33,13 +33,13 @@
 		"@changesets/config": "^4.0.0-next.6",
 		"@changesets/get-github-info": "^1.0.0-next.3",
 		"@changesets/get-release-plan": "^5.0.0-next.7",
-		"@effected/git": "^0.4.2",
+		"@effected/git": "^0.5.0",
 		"@effected/glob": "^0.2.1",
 		"@effected/jsonc": "^0.5.1",
-		"@effected/package-json": "^0.5.1",
+		"@effected/package-json": "^0.5.2",
 		"@effected/walker": "^0.3.2",
-		"@effected/workspaces": "^0.6.2",
-		"@effected/yaml": "^0.5.1",
+		"@effected/workspaces": "^0.8.0",
+		"@effected/yaml": "^0.6.0",
 		"@manypkg/get-packages": "^3.1.0",
 		"mdast-util-heading-range": "^4.0.0",
 		"mdast-util-to-string": "^4.0.0",