@savvy-web/silk 2.0.0 → 2.1.0

package/packages/silk-effects/dist/dev/pkg/changesets/services/release-planner.js

@@ -1,348 +0,0 @@
-import { ReleasePlanError } from "../errors.js";
-import { ChangelogTransformer } from "../api/transformer.js";
-import { ConfigInspector } from "./config-inspector.js";
-import { deriveMaintenanceReason } from "./maintenance-reason.js";
-import { VersionFiles } from "../utils/version-files.js";
-import { getPackages } from "../../../../../../../node_modules/.pnpm/@manypkg_get-packages@3.1.0/node_modules/@manypkg/get-packages/dist/manypkg-get-packages.js";
-import { readConfig } from "../../../../../../../node_modules/.pnpm/@changesets_config@4.0.0-next.6/node_modules/@changesets/config/dist/index.js";
-import { applyReleasePlan } from "../../../../../../../node_modules/.pnpm/@changesets_apply-release-plan@8.0.0-next.7/node_modules/@changesets/apply-release-plan/dist/index.js";
-import { getReleasePlan } from "../../../../../../../node_modules/.pnpm/@changesets_get-release-plan@5.0.0-next.7/node_modules/@changesets/get-release-plan/dist/index.js";
-import { Context, Effect, Layer } from "effect";
-import { FileSystem } from "@effect/platform";
-import { dirname, isAbsolute, join, relative } from "node:path";
-
-//#region ../silk-effects/dist/dev/pkg/changesets/services/release-planner.js
-/**
-* `ReleasePlanner` service — drive the genuine changesets release engine to
-* compute a plan, render a read-only preview, or natively apply a release.
-*
-* @remarks
-* `preview` and `apply` both run the real `@changesets/apply-release-plan`;
-* `preview` redirects every write into a throwaway temp directory by handing
-* the engine a `@manypkg`-shaped `Packages` object whose `dir`s point at temp,
-* then reads the generated CHANGELOG blocks back. No changesets-internal logic
-* (e.g. `getChangelogEntry`) is re-implemented.
-*
-*/
-const errMsg = (e) => e instanceof Error ? e.message : String(e);
-/**
-* Read the changesets config, surfacing non-throwing `readConfig` errors as a
-* thrown `Error` so callers inside `Effect.tryPromise` land on the existing
-* `ReleasePlanError` mapping. Warnings are returned alongside the config so
-* the caller can log them via the Effect runtime rather than console output.
-*/
-async function loadConfig(root, packages) {
-	const configResult = await readConfig(root, packages);
-	if (configResult.config === void 0) throw new Error(`Invalid changeset config:\n${configResult.errors.join("\n")}`);
-	return {
-		config: configResult.config,
-		warnings: configResult.warnings
-	};
-}
-/**
-* Base class for {@link ReleasePlanner}.
-*
-* @privateRemarks Required export for api-extractor (anonymous Context.Tag base). Do not delete.
-* @internal
-*/
-const ReleasePlannerBase = Context.Tag("ReleasePlanner")();
-/** Effect service tag for the release planner. @public */
-var ReleasePlanner = class extends ReleasePlannerBase {};
-/** Build the service shape over a resolved {@link ConfigInspector} and {@link FileSystem.FileSystem}. */
-function makeShape(inspector, fs) {
-	const plan = (root) => Effect.tryPromise({
-		try: () => getReleasePlan(root),
-		catch: (e) => new ReleasePlanError({
-			phase: "plan",
-			reason: errMsg(e)
-		})
-	});
-	const preview = (root) => previewEffect(root, fs);
-	const apply = (root, options) => applyEffect(root, options?.dryRun ?? false, options?.changelogModules, inspector, fs);
-	return {
-		plan,
-		preview,
-		apply
-	};
-}
-/** Production layer. Requires {@link ConfigInspector} (used by `apply`) and `FileSystem`. @public */
-const ReleasePlannerLive = Layer.effect(ReleasePlanner, Effect.gen(function* () {
-	return makeShape(yield* ConfigInspector, yield* FileSystem.FileSystem);
-}));
-/**
-* Test factory — supply fixed results for any subset of methods. Unsupplied
-* methods fail with a `ReleasePlanError`.
-*
-* @public
-*/
-function makeReleasePlannerTest(fixed) {
-	const fail = (phase) => Effect.fail(new ReleasePlanError({
-		phase,
-		reason: "not provided in test layer"
-	}));
-	return Layer.succeed(ReleasePlanner, {
-		plan: () => fixed.plan ? Effect.succeed(fixed.plan) : fail("plan"),
-		preview: () => fixed.preview ? Effect.succeed(fixed.preview) : fail("preview"),
-		apply: () => fixed.apply ? Effect.succeed(fixed.apply) : fail("apply")
-	});
-}
-/** Extract the `## <version>` block (down to the next H2 or EOF) from a changelog. */
-function extractVersionBlock(changelog, version) {
-	const lines = changelog.split("\n");
-	const start = lines.findIndex((l) => l.trim() === `## ${version}`);
-	if (start === -1) return "";
-	let end = lines.length;
-	for (let i = start + 1; i < lines.length; i++) if (/^## /.test(lines[i])) {
-		end = i;
-		break;
-	}
-	return lines.slice(start, end).join("\n").trim();
-}
-/** Maintenance reasons for every changeset-less release in the plan, keyed by package name. */
-function maintenanceReasons(plan, config) {
-	const reasons = /* @__PURE__ */ new Map();
-	for (const r of plan.releases) {
-		if (r.type === "none") continue;
-		const reason = deriveMaintenanceReason(r, plan, config);
-		if (reason) reasons.set(r.name, reason);
-	}
-	return reasons;
-}
-/**
-* Render a non-destructive preview by redirecting every write into a
-* scope-managed temp directory (cleaned up automatically when the scope
-* closes) and reading the generated CHANGELOG blocks back.
-*/
-function previewEffect(root, fs) {
-	const program = Effect.gen(function* () {
-		const [plan, packages] = yield* Effect.tryPromise({
-			try: () => Promise.all([getReleasePlan(root), getPackages(root)]),
-			catch: (e) => new ReleasePlanError({
-				phase: "preview",
-				reason: errMsg(e)
-			})
-		});
-		if (!packages.rootPackage) return yield* Effect.fail(new ReleasePlanError({
-			phase: "preview",
-			reason: `Workspace root has no package.json: ${root}`
-		}));
-		const rootPackage = packages.rootPackage;
-		const { config, warnings } = yield* Effect.tryPromise({
-			try: () => loadConfig(root, packages),
-			catch: (e) => new ReleasePlanError({
-				phase: "preview",
-				reason: errMsg(e)
-			})
-		});
-		yield* Effect.forEach(warnings, (w) => Effect.logWarning(w));
-		const reasonByName = maintenanceReasons(plan, config);
-		const preMode = plan.preState ? plan.preState.mode : null;
-		const changesets = plan.changesets.map((cs) => ({
-			id: cs.id,
-			summary: cs.summary,
-			releases: cs.releases.filter((r) => r.type !== "none").map((r) => ({
-				name: r.name,
-				type: r.type
-			}))
-		}));
-		const releasesToRender = plan.releases.filter((r) => r.type !== "none");
-		if (releasesToRender.length === 0) return {
-			preMode,
-			releases: [],
-			changesets
-		};
-		const tempRoot = yield* fs.makeTempDirectoryScoped({ prefix: "silk-preview-" });
-		const mapDir = (dir) => {
-			const rel = relative(packages.rootDir, dir);
-			if (rel.startsWith("..") || isAbsolute(rel)) return Effect.fail(new ReleasePlanError({
-				phase: "preview",
-				reason: `Package directory is outside the workspace root: ${dir}`
-			}));
-			return Effect.succeed(join(tempRoot, rel));
-		};
-		const tempDirs = yield* Effect.forEach(packages.packages, (p) => mapDir(p.dir));
-		const tempPackages = {
-			tool: packages.tool,
-			rootDir: tempRoot,
-			rootPackage: {
-				dir: tempRoot,
-				packageJson: structuredClone(rootPackage.packageJson)
-			},
-			packages: packages.packages.map((p, i) => ({
-				dir: tempDirs[i],
-				packageJson: structuredClone(p.packageJson)
-			}))
-		};
-		yield* fs.makeDirectory(join(tempRoot, ".changeset"), { recursive: true });
-		yield* fs.copyFile(join(root, "package.json"), join(tempRoot, "package.json"));
-		const preJson = join(root, ".changeset", "pre.json");
-		if (yield* fs.exists(preJson)) yield* fs.copyFile(preJson, join(tempRoot, ".changeset", "pre.json"));
-		for (let i = 0; i < packages.packages.length; i++) {
-			const p = packages.packages[i];
-			const tDir = tempDirs[i];
-			yield* fs.makeDirectory(tDir, { recursive: true });
-			yield* fs.copyFile(join(p.dir, "package.json"), join(tDir, "package.json"));
-			const realCl = join(p.dir, "CHANGELOG.md");
-			if (yield* fs.exists(realCl)) yield* fs.copyFile(realCl, join(tDir, "CHANGELOG.md"));
-		}
-		const rootCl = join(packages.rootDir, "CHANGELOG.md");
-		if (yield* fs.exists(rootCl)) yield* fs.copyFile(rootCl, join(tempRoot, "CHANGELOG.md"));
-		yield* Effect.tryPromise({
-			try: () => applyReleasePlan(plan, tempPackages, config, void 0, root),
-			catch: (e) => new ReleasePlanError({
-				phase: "preview",
-				reason: errMsg(e)
-			})
-		});
-		const dirByName = /* @__PURE__ */ new Map();
-		for (const p of tempPackages.packages) dirByName.set(p.packageJson.name, p.dir);
-		if (tempPackages.rootPackage?.packageJson.name) dirByName.set(tempPackages.rootPackage.packageJson.name, tempRoot);
-		const releases = [];
-		for (const r of releasesToRender) {
-			const dir = dirByName.get(r.name);
-			if (!dir) continue;
-			const clPath = join(dir, "CHANGELOG.md");
-			if (!(yield* fs.exists(clPath))) continue;
-			const reason = reasonByName.get(r.name);
-			yield* Effect.try({
-				try: () => ChangelogTransformer.transformFile(clPath, reason ? { maintenance: {
-					version: r.newVersion,
-					reason
-				} } : void 0),
-				catch: (e) => new ReleasePlanError({
-					phase: "preview",
-					reason: errMsg(e)
-				})
-			});
-			const content = yield* fs.readFileString(clPath);
-			releases.push({
-				name: r.name,
-				type: r.type,
-				oldVersion: r.oldVersion,
-				newVersion: r.newVersion,
-				changesetIds: [...r.changesets],
-				changelogEntry: extractVersionBlock(content, r.newVersion)
-			});
-		}
-		return {
-			preMode,
-			releases,
-			changesets
-		};
-	});
-	return Effect.scoped(program).pipe(Effect.mapError((e) => e instanceof ReleasePlanError ? e : new ReleasePlanError({
-		phase: "preview",
-		reason: errMsg(e)
-	})));
-}
-/** Re-read a package's version from disk (post-bump) to feed versionFiles; unreadable/unparseable falls back. */
-function diskVersion(workspaceDir, fallback, fs) {
-	return fs.readFileString(join(workspaceDir, "package.json")).pipe(Effect.flatMap((raw) => Effect.try(() => JSON.parse(raw).version ?? fallback)), Effect.orElseSucceed(() => fallback));
-}
-function applyEffect(root, dryRun, changelogModules, inspector, fs) {
-	return Effect.gen(function* () {
-		const { plan, packages, config, warnings } = yield* Effect.tryPromise({
-			try: async () => {
-				const [plan, packages] = await Promise.all([getReleasePlan(root), getPackages(root)]);
-				const { config, warnings } = await loadConfig(root, packages);
-				return {
-					plan,
-					packages,
-					config,
-					warnings
-				};
-			},
-			catch: (e) => new ReleasePlanError({
-				phase: "apply",
-				reason: errMsg(e)
-			})
-		});
-		yield* Effect.forEach(warnings, (w) => Effect.logWarning(w));
-		let engineConfig = config;
-		if (changelogModules) {
-			engineConfig = {
-				...config,
-				format: false
-			};
-			if (Array.isArray(config.changelog)) {
-				const configuredId = config.changelog[0];
-				const mapped = changelogModules[configuredId];
-				if (mapped === void 0) {
-					const supported = Object.keys(changelogModules).join(", ");
-					return yield* Effect.fail(new ReleasePlanError({
-						phase: "apply",
-						reason: `changelog id "${configuredId}" is not in changelogModules (supported: ${supported})`
-					}));
-				}
-				engineConfig = {
-					...engineConfig,
-					changelog: [mapped, config.changelog[1]]
-				};
-			}
-		}
-		const releases = plan.releases.filter((r) => r.type !== "none").map((r) => ({
-			name: r.name,
-			type: r.type,
-			oldVersion: r.oldVersion,
-			newVersion: r.newVersion
-		}));
-		let touchedFiles = [];
-		if (!dryRun) {
-			const reasonByName = maintenanceReasons(plan, 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);
-			if (packages.rootPackage?.packageJson.name) nameByDir.set(packages.rootDir, packages.rootPackage.packageJson.name);
-			touchedFiles = yield* Effect.tryPromise({
-				try: async () => {
-					const touched = await applyReleasePlan(plan, packages, engineConfig);
-					for (const f of touched) {
-						if (!f.endsWith("CHANGELOG.md")) continue;
-						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);
-					}
-					return touched;
-				},
-				catch: (e) => new ReleasePlanError({
-					phase: "apply",
-					reason: errMsg(e)
-				})
-			});
-		}
-		const newVersionByName = new Map(plan.releases.map((r) => [r.name, r.newVersion]));
-		const inspected = yield* inspector.inspect(root).pipe(Effect.catchAll((error) => Effect.logWarning(`Skipping versionFiles update: ${errMsg(error)}`).pipe(Effect.as(null))));
-		let versionFileUpdates = [];
-		if (inspected) {
-			const candidates = inspected.packages.filter((p) => p.versionFiles.length > 0);
-			const freshVersions = yield* Effect.forEach(candidates, (p) => dryRun ? Effect.succeed(newVersionByName.get(p.name) ?? p.version) : diskVersion(p.workspaceDir, p.version, fs));
-			const scopes = candidates.map((p, i) => {
-				const fresh = freshVersions[i];
-				return fresh !== p.version ? {
-					...p,
-					version: fresh
-				} : p;
-			});
-			versionFileUpdates = yield* Effect.try({
-				try: () => scopes.length > 0 ? VersionFiles.processResolvedVersionFiles(scopes, dryRun) : [],
-				catch: (e) => new ReleasePlanError({
-					phase: "apply",
-					reason: errMsg(e)
-				})
-			});
-		}
-		return {
-			dryRun,
-			touchedFiles,
-			releases,
-			versionFileUpdates
-		};
-	});
-}
-
-//#endregion
-export { ReleasePlanner, ReleasePlannerBase, ReleasePlannerLive, extractVersionBlock, makeReleasePlannerTest };

package/packages/silk-effects/dist/dev/pkg/changesets/utils/commit-parser.cjs

@@ -1,81 +0,0 @@
-
-//#region ../silk-effects/dist/dev/pkg/changesets/utils/commit-parser.js
-/**
-* Conventional commit message parsing.
-*
-* Implements a parser for the
-* {@link https://www.conventionalcommits.org/ | Conventional Commits}
-* specification, extracting type, scope, breaking-change indicator,
-* description, and body from commit messages.
-*
-* @remarks
-* The parser uses a single regex pass for the first line, then splits
-* remaining lines to extract the body. Non-conventional messages are
-* returned with only the `description` field populated (set to the
-* full message text).
-*
-* @see {@link Changelog} for the public API that consumes parsed commits
-*
-* @internal
-*/
-/**
-* Matches conventional commit format: `type(scope)!: description`.
-*
-* Capture groups:
-* - `[1]` — commit type (e.g., `feat`, `fix`)
-* - `[2]` — optional scope (e.g., `api`, `ui`)
-* - `[3]` — optional `!` breaking-change indicator
-* - `[4]` — description text after the colon
-*
-* @internal
-*/
-const CONVENTIONAL_COMMIT_PATTERN = /^(\w+)(?:\(([^)]+)\))?(!)?\s*:\s*(.+)/;
-/**
-* Parse a commit message following the Conventional Commits specification.
-*
-* Supports the full format: `type(scope)!: description\n\nbody`
-*
-* @remarks
-* The algorithm first attempts to match the first line against the
-* conventional commit pattern. If matched, the type, optional scope,
-* optional breaking indicator, and description are extracted. The body
-* is everything after the first line, trimmed. If the message does not
-* match, a fallback result with only the `description` set to the raw
-* message is returned.
-*
-* @param message - The commit message to parse
-* @returns Parsed components; only `description` is guaranteed present
-*
-* @example
-* ```typescript
-* import { parseCommitMessage } from "../utils/commit-parser.js";
-*
-* const result = parseCommitMessage("feat(api)!: add v2 routes\n\nBREAKING CHANGE: v1 removed");
-* // result.type === "feat"
-* // result.scope === "api"
-* // result.breaking === true
-* // result.description === "add v2 routes"
-* // result.body === "BREAKING CHANGE: v1 removed"
-* ```
-*
-* @internal
-*/
-function parseCommitMessage(message) {
-	const match = CONVENTIONAL_COMMIT_PATTERN.exec(message);
-	if (match) {
-		const [, type, scope, bang, description] = match;
-		const body = message.split("\n").slice(1).join("\n").trim();
-		const result = {
-			type,
-			description: description.trim()
-		};
-		if (scope) result.scope = scope;
-		if (bang === "!") result.breaking = true;
-		if (body) result.body = body;
-		return result;
-	}
-	return { description: message };
-}
-
-//#endregion
-exports.parseCommitMessage = parseCommitMessage;

package/packages/silk-effects/dist/dev/pkg/changesets/utils/commit-parser.js

@@ -1,80 +0,0 @@
-//#region ../silk-effects/dist/dev/pkg/changesets/utils/commit-parser.js
-/**
-* Conventional commit message parsing.
-*
-* Implements a parser for the
-* {@link https://www.conventionalcommits.org/ | Conventional Commits}
-* specification, extracting type, scope, breaking-change indicator,
-* description, and body from commit messages.
-*
-* @remarks
-* The parser uses a single regex pass for the first line, then splits
-* remaining lines to extract the body. Non-conventional messages are
-* returned with only the `description` field populated (set to the
-* full message text).
-*
-* @see {@link Changelog} for the public API that consumes parsed commits
-*
-* @internal
-*/
-/**
-* Matches conventional commit format: `type(scope)!: description`.
-*
-* Capture groups:
-* - `[1]` — commit type (e.g., `feat`, `fix`)
-* - `[2]` — optional scope (e.g., `api`, `ui`)
-* - `[3]` — optional `!` breaking-change indicator
-* - `[4]` — description text after the colon
-*
-* @internal
-*/
-const CONVENTIONAL_COMMIT_PATTERN = /^(\w+)(?:\(([^)]+)\))?(!)?\s*:\s*(.+)/;
-/**
-* Parse a commit message following the Conventional Commits specification.
-*
-* Supports the full format: `type(scope)!: description\n\nbody`
-*
-* @remarks
-* The algorithm first attempts to match the first line against the
-* conventional commit pattern. If matched, the type, optional scope,
-* optional breaking indicator, and description are extracted. The body
-* is everything after the first line, trimmed. If the message does not
-* match, a fallback result with only the `description` set to the raw
-* message is returned.
-*
-* @param message - The commit message to parse
-* @returns Parsed components; only `description` is guaranteed present
-*
-* @example
-* ```typescript
-* import { parseCommitMessage } from "../utils/commit-parser.js";
-*
-* const result = parseCommitMessage("feat(api)!: add v2 routes\n\nBREAKING CHANGE: v1 removed");
-* // result.type === "feat"
-* // result.scope === "api"
-* // result.breaking === true
-* // result.description === "add v2 routes"
-* // result.body === "BREAKING CHANGE: v1 removed"
-* ```
-*
-* @internal
-*/
-function parseCommitMessage(message) {
-	const match = CONVENTIONAL_COMMIT_PATTERN.exec(message);
-	if (match) {
-		const [, type, scope, bang, description] = match;
-		const body = message.split("\n").slice(1).join("\n").trim();
-		const result = {
-			type,
-			description: description.trim()
-		};
-		if (scope) result.scope = scope;
-		if (bang === "!") result.breaking = true;
-		if (body) result.body = body;
-		return result;
-	}
-	return { description: message };
-}
-
-//#endregion
-export { parseCommitMessage };

package/packages/silk-effects/dist/dev/pkg/changesets/utils/dep-diff.cjs

@@ -1,111 +0,0 @@
-const require_dependency_table = require('./dependency-table.cjs');
-let effect = require("effect");
-
-//#region ../silk-effects/dist/dev/pkg/changesets/utils/dep-diff.js
-/**
-* 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 = [
-	["dependencies", "dependency"],
-	["devDependencies", "devDependency"],
-	["peerDependencies", "peerDependency"],
-	["optionalDependencies", "optionalDependency"]
-];
-/**
-* Resolve a specifier against the snapshot it belongs to, falling back to
-* the raw specifier string when the snapshot cannot resolve it.
-*/
-const resolveOrRaw = (snapshot, dep, spec) => effect.Option.getOrElse(snapshot.resolve(dep, spec), () => spec);
-/**
-* Diff two workspace snapshots and return per-package dependency-table rows,
-* comparing already-resolved specifier values per side.
-*
-* @param before - Snapshot at the older ref (typically the merge base). A
-*   workspace package absent here reports every declared dep as `"added"`.
-* @param after - Snapshot at the newer ref (typically the working tree).
-* @returns One {@link WorkspaceDependencyDiff} entry per workspace package
-*   that has at least one row. Packages with no resolved-value changes are
-*   omitted.
-*
-* @public
-*/
-function computeWorkspaceDependencyDiffs(before, after) {
-	const result = [];
-	for (const afterPkg of after.packages) {
-		const beforePkg = effect.Option.getOrNull(before.package(afterPkg.name));
-		const rows = [];
-		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 afterSpec = afterRecord[name];
-				if (afterSpec === void 0) {
-					rows.push({
-						dependency: name,
-						type,
-						action: "removed",
-						from,
-						to: EM_DASH
-					});
-					continue;
-				}
-				const to = resolveOrRaw(after, name, afterSpec);
-				if (from !== to) rows.push({
-					dependency: name,
-					type,
-					action: "updated",
-					from,
-					to
-				});
-			}
-			for (const [name, afterSpec] of Object.entries(afterRecord)) {
-				if (seen.has(name)) continue;
-				rows.push({
-					dependency: name,
-					type,
-					action: "added",
-					from: EM_DASH,
-					to: resolveOrRaw(after, name, afterSpec)
-				});
-			}
-		}
-		if (rows.length > 0) result.push({
-			package: afterPkg.name,
-			relativePath: afterPkg.relativePath,
-			rows: require_dependency_table.sortDependencyRows(rows)
-		});
-	}
-	return result;
-}
-
-//#endregion
-exports.computeWorkspaceDependencyDiffs = computeWorkspaceDependencyDiffs;