@savvy-web/silk-effects 5.1.0 → 5.1.3

package/README.md

@@ -107,6 +107,17 @@ const tags = strategy.tagsFor([{ name: "@savvy-web/silk-effects", version: "1.0.
 
 `WorkspaceAnalysis.versioning` and `WorkspaceAnalysis.tagStrategy` carry those kit types directly.
 
+#### ChangesetLinter
+
+Validate a changeset file against the Silk section rules. `ChangesetLinter.validateContent(content, filePath?)` and `ChangesetLinter.validateFile(filePath)` are static and synchronous, returning `LintMessage[]` — no Effect, no layers. Rules cover the valid section headings, structural constraints, and the dependency-table format, so a `## Dependencies` section written as prose or a bullet list is reported rather than accepted.
+
+```typescript
+import { Changesets } from "@savvy-web/silk-effects";
+
+const messages = Changesets.ChangesetLinter.validateFile(".changeset/quiet-moons-render.md");
+// => [] when the file is valid, otherwise one LintMessage per violation
+```
+
 ---
 
 ### FileSystem layer required
@@ -258,10 +269,68 @@ const result = await Effect.runPromise(
 // => { updated: true, skipped: false, current: "2.0.0" }
 ```
 
+#### ConfigInspector
+
+Resolve `.changeset/config.json` into a fully attributed view of the workspace: the configured changelog, base branch, access and ignore list, plus one scope per package carrying its `workspaceDir`, version, `additionalScopes` and resolved `versionFiles`. `inspect(cwd)` returns that view and `classify` maps arbitrary file paths to the package that owns them, which is how a branch diff becomes a per-package attribution. `refresh()` clears the per-root cache, which a long-lived host needs in order to see config edits made between calls.
+
+`Changesets.ConfigInspectorLive` requires `ChangesetConfigReader`, `WorkspaceDiscovery` from [`@effected/workspaces`](https://www.npmjs.com/package/@effected/workspaces) and `FileSystem`.
+
+#### ReleasePlanner
+
+Drive the genuine changesets engine rather than shelling out to the `changeset` binary. Three members:
+
+- `plan(root)` computes the in-memory release plan. It renders nothing, so it resolves no changelog module.
+- `preview(root, options?)` renders a non-destructive preview, running the real engine against a scope-managed temp directory and reading the generated CHANGELOG blocks back. The repository is never mutated.
+- `apply(root, options?)` performs the release — version bumps, CHANGELOG writes and configured version-file updates. Pass `dryRun` to compute without writing.
+
+Both `preview` and `apply` accept `changelogModules`, mapping the changelog id configured in `.changeset/config.json` to an absolute module path. Reach for it when running somewhere the configured id cannot be resolved — a bundled GitHub Action with no `node_modules`, for instance. When set, the configured id must be a key of the map, an unmapped id fails with a `ReleasePlanError` naming the supported keys, and the engine's formatter integration is disabled so the caller owns formatting.
+
+```typescript
+const preview = yield* planner.preview(root, {
+  changelogModules: { "@savvy-web/changelog": changelogModulePath },
+});
+// => ChangesetPreview: per-release changelogEntry, versions and changeset ids
+```
+
+`Changesets.ReleasePlannerLive` requires `ConfigInspector` and `FileSystem`.
+
 ---
 
 ### FileSystem + process layer required
 
+#### BranchAnalyzer
+
+`analyzeBranch` classifies a branch's diff by the package that owns each file, applying `ConfigInspector` attribution over the git range. This is what answers "what changed on this branch, and which package releases because of it", including the unmapped files that belong to no package.
+
+`Changesets.BranchAnalyzerLive` requires `ConfigInspector` and the platform process spawner.
+
+#### DepsRegen
+
+Own dependency-changeset orchestration, split so that detection and regeneration share one code path: `plan(options)` computes a complete, side-effect-free `RegenPlan` — target filenames, each row's from/to version, and any stale pure-dependency changesets marked for deletion — and `execute(plan)` applies exactly what the plan describes. A dry run is `plan()` plus rendering.
+
+Both sides of the diff are snapshotted at their own git ref, so `catalog:` and `workspace:` specifiers resolve per side before the comparison. A specifier that changes protocol without changing its resolved version produces no row.
+
+`Changesets.DepsRegenDefault` is the batteries-included layer, composing the full graph with silk's opinionated defaults and leaving only the platform services open. Because snapshots read git history, provide a spawn-capable layer such as `NodeServices.layer` rather than a filesystem-only one.
+
+```typescript
+import { Effect } from "effect";
+import { NodeServices } from "@effect/platform-node";
+import { Changesets } from "@savvy-web/silk-effects";
+
+const plan = await Effect.runPromise(
+  Effect.gen(function* () {
+    const regen = yield* Changesets.DepsRegen;
+    return yield* regen.plan({});
+  }).pipe(
+    Effect.provide(Changesets.DepsRegenDefault),
+    Effect.provide(NodeServices.layer),
+  ),
+);
+// => RegenPlan: files to write, rows per package, changesets to delete
+```
+
+`Changesets.DepsRegenLive` is the seam for callers injecting their own dependencies; it requires `WorkspaceSnapshots`, `ConfigInspector`, `WorkspaceDiscovery`, `PublishabilityDetector`, `ChangesetConfig`, `Git` and `FileSystem`.
+
 #### TurboInspector
 
 Read-only Turborepo inspection. Every method shells out to `turbo` with `--dry=json`, so no task ever runs. `diagnoseCache(task, cwd)` reports a per-package cache HIT/MISS breakdown for a task, `taskGraph(cwd, task?)` derives the task graph and its critical path and `affected(cwd, base?)` lists the packages affected relative to `base` (default `main`). It resolves the `turbo` binary through `ToolDiscovery` from [`@effected/commands`](https://www.npmjs.com/package/@effected/commands) and fails with a tagged error when `turbo` is missing or the directory is not a Turborepo. The service tag and its layer are exported under the `Turbo` namespace.

package/changesets/changelog/getDependencyReleaseLine.js

@@ -78,6 +78,22 @@ function inferDependencyType(dep) {
 	return "dependency";
 }
 /**
+* Narrow a dependency update to one with both version endpoints present.
+*
+* `@changesets/types` only guarantees `oldVersion`/`newVersion` on the
+* `major`/`minor`/`patch` arms of `ComprehensiveRelease`; a `type: "none"`
+* entry may carry neither. The table's `From`/`To` columns are validated
+* version strings, so an entry missing either endpoint has no row to render.
+*
+* @param dep - The dependency update to test
+* @returns `true` when both `oldVersion` and `newVersion` are present
+*
+* @internal
+*/
+function isVersioned(dep) {
+	return dep.oldVersion !== void 0 && dep.newVersion !== void 0;
+}
+/**
 * Format dependency release lines as a structured markdown table.
 *
 * This is the core Effect program that implements the `getDependencyReleaseLine`
@@ -88,8 +104,9 @@ function inferDependencyType(dep) {
 * The function maps each `ModCompWithPackage` entry to a `DependencyTableRow`,
 * inferring the dependency type from the consuming package's `package.json`,
 * then delegates to `serializeDependencyTableToMarkdown` for GFM table
-* rendering, prefixed with a `### Dependencies` heading. Returns an empty
-* string when no dependencies were updated.
+* rendering, prefixed with a `### Dependencies` heading. Entries missing
+* either version endpoint are dropped by {@link isVersioned}; the function
+* returns an empty string when no rows survive.
 *
 * The `_changesets` and `_options` parameters are part of the Changesets API
 * contract but are not used in the table format. They are retained for
@@ -98,19 +115,21 @@ function inferDependencyType(dep) {
 * @param _changesets - Changesets that caused the dependency updates (unused in table format)
 * @param dependenciesUpdated - The list of dependencies that were updated, including old/new versions
 * @param _options - Validated configuration options (unused in table format)
-* @returns An `Effect` that resolves to a `### Dependencies` heading followed by a formatted markdown table string, or empty string if no dependencies were updated
+* @returns An `Effect` that resolves to a `### Dependencies` heading followed by a formatted markdown table string, or empty string if no dependencies with both version endpoints were updated
 */
 function getDependencyReleaseLine(_changesets, dependenciesUpdated, _options) {
 	return Effect.gen(function* () {
 		if (dependenciesUpdated.length === 0) return "";
 		yield* GitHubService;
-		return `### Dependencies\n\n${serializeDependencyTableToMarkdown(dependenciesUpdated.map((dep) => ({
+		const rows = dependenciesUpdated.filter(isVersioned).map((dep) => ({
 			dependency: dep.name,
 			type: inferDependencyType(dep),
 			action: "updated",
 			from: dep.oldVersion,
 			to: dep.newVersion
-		})))}`;
+		}));
+		if (rows.length === 0) return "";
+		return `### Dependencies\n\n${serializeDependencyTableToMarkdown(rows)}`;
 	});
 }
 

package/changesets/services/maintenance-reason.js

@@ -44,6 +44,10 @@ const MaintenanceReasonSchema = Schema.Struct({
 * will not match here; the release then degrades gracefully to the
 * `"unspecified"` fallback sentence instead of naming its triggers.
 *
+* Co-members releasing as `type: "none"` are never triggers — they carry no
+* version bump (and, per `@changesets/types`, no guaranteed `newVersion`), so
+* naming one would print an unchanged version as the cause of the release.
+*
 * @public
 */
 function deriveMaintenanceReason(release, plan, config) {
@@ -51,7 +55,7 @@ function deriveMaintenanceReason(release, plan, config) {
 	const groupKinds = [["fixed", config.fixed], ["linked", config.linked]];
 	for (const [kind, groups] of groupKinds) for (const group of groups) {
 		if (!group.some((pattern) => ChangesetConfig.matches(release.name, pattern))) continue;
-		const triggers = plan.releases.filter((r) => r.name !== release.name && r.changesets.length > 0 && group.some((pattern) => ChangesetConfig.matches(r.name, pattern))).map((r) => ({
+		const triggers = plan.releases.filter((r) => r.name !== release.name && r.type !== "none" && r.changesets.length > 0 && group.some((pattern) => ChangesetConfig.matches(r.name, pattern))).map((r) => ({
 			name: r.name,
 			version: r.newVersion
 		}));

package/index.d.ts

@@ -289,7 +289,7 @@ declare class Categories {
   static isValidHeading(heading: string): boolean;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@changesets+types@7.0.0-next.7/node_modules/@changesets/types/dist/index.d.mts
+//#region ../../node_modules/.pnpm/@changesets+types@7.0.0-next.8/node_modules/@changesets/types/dist/index.d.mts
 //#region src/index.d.ts
 type MaybePromise<T> = T | Promise<T>;
 type VersionType$1 = "major" | "minor" | "patch" | "none";
@@ -298,13 +298,34 @@ type Release = {
   name: string;
   type: VersionType$1;
 };
-type ComprehensiveRelease = {
+interface ComprehensiveReleaseBase {
   name: string;
-  type: VersionType$1;
+  type: "major" | "minor" | "patch" | "none";
+  changesets: string[];
+  oldVersion: string | undefined;
+  newVersion: string | undefined;
+}
+interface ComprehensiveMajorRelease extends ComprehensiveReleaseBase {
+  type: "major";
   oldVersion: string;
   newVersion: string;
-  changesets: string[];
-};
+}
+interface ComprehensiveMinorRelease extends ComprehensiveReleaseBase {
+  type: "minor";
+  oldVersion: string;
+  newVersion: string;
+}
+interface ComprehensivePatchRelease extends ComprehensiveReleaseBase {
+  type: "patch";
+  oldVersion: string;
+  newVersion: string;
+}
+interface ComprehensiveNoneRelease extends ComprehensiveReleaseBase {
+  type: "none";
+  oldVersion: string | undefined;
+  newVersion: string | undefined;
+}
+type ComprehensiveRelease = ComprehensiveMajorRelease | ComprehensiveMinorRelease | ComprehensivePatchRelease | ComprehensiveNoneRelease;
 type Changeset$1 = {
   summary: string;
   releases: Array<Release>;
@@ -2163,6 +2184,10 @@ type MaintenanceReason = typeof MaintenanceReasonSchema.Type;
  * will not match here; the release then degrades gracefully to the
  * `"unspecified"` fallback sentence instead of naming its triggers.
  *
+ * Co-members releasing as `type: "none"` are never triggers — they carry no
+ * version bump (and, per `@changesets/types`, no guaranteed `newVersion`), so
+ * naming one would print an unchanged version as the cause of the release.
+ *
  * @public
  */
 declare function deriveMaintenanceReason(release: ComprehensiveRelease, plan: ReleasePlan, config: Config): MaintenanceReason | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/silk-effects",
-	"version": "5.1.0",
+	"version": "5.1.3",
 	"private": false,
 	"description": "Shared Effect library for Silk Suite conventions",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/silk-effects",
@@ -29,18 +29,18 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@changesets/apply-release-plan": "^8.0.0-next.7",
+		"@changesets/apply-release-plan": "^8.0.0-next.9",
 		"@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/commands": "^0.1.0",
+		"@changesets/get-github-info": "^1.0.0-next.4",
+		"@changesets/get-release-plan": "^5.0.0-next.9",
+		"@effected/commands": "^0.2.0",
 		"@effected/git": "^0.5.1",
 		"@effected/glob": "^0.2.1",
 		"@effected/jsonc": "^0.5.1",
-		"@effected/package-json": "^0.6.0",
+		"@effected/package-json": "^0.6.1",
 		"@effected/templates": "^0.1.0",
 		"@effected/walker": "^0.3.3",
-		"@effected/workspaces": "^0.9.0",
+		"@effected/workspaces": "^0.9.1",
 		"@effected/yaml": "^0.6.0",
 		"@manypkg/get-packages": "^3.1.0",
 		"mdast-util-heading-range": "^4.0.0",