@savvy-web/silk-effects 9.5.5 → 9.6.0

package/services/SilkPublishability.js

@@ -1,10 +1,10 @@
 import { ChangesetConfig } from "./ChangesetConfig.js";
-import { PublishTargetBindingError, trimTrailingSlashes } from "@savvy-web/silk-core";
+import { PublishTargetBindingError, ReleaseChannelError, trimTrailingSlashes } from "@savvy-web/silk-core";
 import { Effect, FileSystem, Layer } from "effect";
 import { isAbsolute, join, relative } from "node:path";
 import { PublishTarget, PublishabilityDetector, WorkspaceDiscovery } from "@effected/workspaces";
 
-//#region src/services/SilkPublishability.ts
+// src/services/SilkPublishability.ts
 const NPM_DEFAULT = "https://registry.npmjs.org/";
 /**
 * Default registry endpoints for the well-known target keys. Kept in sync with the
@@ -79,17 +79,18 @@ var SilkPublishability = class SilkPublishability {
 					registry: t.registry,
 					directory: dirByGroup.get(t.group) ?? `dist/prod/${t.group}/pkg`,
 					access,
-					provenance: provenanceForRegistry(t.registry)
+					provenance: t.provenance ?? declaredProvenanceOf(targets, t.id) ?? provenanceForRegistry(t.registry)
 				}));
 			}
 			return Object.entries(targets).map(([id, target]) => {
-				const registry = typeof target === "object" && target !== null && typeof target.registry === "string" ? target.registry : DEFAULT_REGISTRIES[id] ?? pc?.registry ?? NPM_DEFAULT;
+				const object = typeof target === "object" && target !== null ? target : void 0;
+				const registry = typeof object?.registry === "string" ? object.registry : DEFAULT_REGISTRIES[id] ?? pc?.registry ?? NPM_DEFAULT;
 				return new PublishTarget({
 					name: pkgName,
 					registry,
 					directory: `dist/prod/${id}/pkg`,
 					access,
-					provenance: provenanceForRegistry(registry)
+					provenance: typeof object?.provenance === "boolean" ? object.provenance : provenanceForRegistry(registry)
 				});
 			});
 		}
@@ -157,6 +158,81 @@ var SilkPublishability = class SilkPublishability {
 		});
 	}
 	/**
+	* True when a version carries a SemVer prerelease suffix (`1.2.0-rc.1`). Build metadata is ignored.
+	*/
+	static isPrerelease(version) {
+		return prereleaseOf(version) !== void 0;
+	}
+	/**
+	* The npm dist-tag a version publishes under.
+	*
+	* @remarks
+	* A final version is `latest`. A prerelease takes its first prerelease identifier (`beta` for
+	* `2.0.0-beta.3`, `rc` for `2.0.0-rc.1`), or `next` when that identifier is empty or would
+	* parse as a SemVer range (`2.0.0-0`, `2.0.0-x.1`, `2.0.0-v2.1`), since npm rejects such a
+	* dist-tag. A `latest` identifier (`2.0.0-latest.1`) also takes `next`, so a prerelease never
+	* becomes the version a bare install resolves. The range check is `v*` followed by digits or a
+	* lone `x`/`X`, matching what `semver.validRange` accepts for a prerelease identifier.
+	*/
+	static distTagFor(version) {
+		const prerelease = prereleaseOf(version);
+		if (prerelease === void 0) return "latest";
+		const first = prerelease.split(".")[0] ?? "";
+		return first === "" || first === "latest" || /^v*(?:\d+|[xX])$/.test(first) ? "next" : first;
+	}
+	/** Whether a target with this {@link ReleaseChannel} receives the given version. */
+	static receives(releases, version) {
+		if (releases === "all") return true;
+		return SilkPublishability.isPrerelease(version) === (releases === "prerelease");
+	}
+	/**
+	* Every resolved publish target judged against a specific version: {@link SilkPublishability.resolveTargets},
+	* each paired with its target key, its `releases` filter, whether it `receives` the version, and the dist-tag.
+	*
+	* @remarks
+	* A strict superset of `resolveTargets`, which it calls first, so the private-directory filter
+	* and the `PublishTargetBindingError` integrity check apply unchanged. The release filter runs
+	* here rather than in the `PublishabilityDetector` layer because the kit's
+	* `VersioningStrategy.detect` counts publishable packages through the detector, and a package
+	* whose only target skips this version is still a publishable package.
+	*
+	* Each detected target is joined back to its declaration: through `dist/prod/targets.json` by
+	* group directory and registry after the prod build, or by its placeholder directory
+	* (`dist/prod/<id>/pkg`) against `publishConfig.targets` before it. A binding entry with no
+	* `releases` (written by a bundler older than the field) takes the filter declared on
+	* `publishConfig.targets[id]`, so upgrading the publisher before the bundler never widens it. A target with no keyed
+	* declaration (the `access`/`private` fallbacks) has no filter and receives every version.
+	* Filtered targets are returned with `receives: false`, never dropped, so a publisher reports the
+	* skip from the same join it publishes from. A result with no `receives: true` entry means this
+	* version publishes nowhere, which is not an error. A declared `releases` that is not a known
+	* channel fails with `ReleaseChannelError` rather than defaulting, since both sources are
+	* read from disk and may have been edited by hand.
+	*/
+	static resolveReleaseTargets(pkg, version) {
+		return Effect.gen(function* () {
+			const targets = yield* SilkPublishability.resolveTargets(pkg, pkg.workspaceRoot);
+			const fs = yield* FileSystem.FileSystem;
+			const binding = yield* readTargetsBinding(fs, pkg.path);
+			const declared = (yield* readRaw(fs, pkg.packageJsonPath))?.publishConfig?.targets;
+			const join = binding !== null ? joinByBinding(binding) : joinByPlaceholder(declared);
+			const distTag = SilkPublishability.distTagFor(version);
+			const out = [];
+			for (const target of targets) {
+				const joined = join(normalizeDir(isAbsolute(target.directory) ? relative(pkg.path, target.directory) : target.directory), target.registry);
+				const id = joined.id;
+				const releases = yield* releaseChannelOf(pkg.name, id, joined.releases ?? declaredReleasesOf(declared, id));
+				out.push({
+					target,
+					id,
+					releases,
+					receives: SilkPublishability.receives(releases, version),
+					distTag
+				});
+			}
+			return out;
+		});
+	}
+	/**
 	* The publishable, non-ignored packages, resolved through the single
 	* {@link SilkPublishability} (which already honors changeset ignore in adaptive mode).
 	*/
@@ -248,6 +324,72 @@ const normalizeDir = (dir) => {
 	const normalized = trimTrailingSlashes(withoutPrefix);
 	return normalized === "" ? "." : normalized;
 };
+/** The prerelease part of a version (after the first `-`, before any `+build`), or `undefined` for a final version. */
+const prereleaseOf = (version) => {
+	const plus = version.indexOf("+");
+	const core = plus === -1 ? version : version.slice(0, plus);
+	const dash = core.indexOf("-");
+	return dash === -1 ? void 0 : core.slice(dash + 1);
+};
+const RELEASE_CHANNELS = [
+	"all",
+	"stable",
+	"prerelease"
+];
+/** An absent `releases` is `"all"`; a present one must be a known channel. */
+const releaseChannelOf = (pkg, id, releases) => {
+	if (releases === void 0) return Effect.succeed("all");
+	if (RELEASE_CHANNELS.includes(releases)) return Effect.succeed(releases);
+	return Effect.fail(new ReleaseChannelError({
+		pkg,
+		id: id ?? "(unkeyed)",
+		value: JSON.stringify(releases) ?? String(releases)
+	}));
+};
+/**
+* Join detected targets to the binding by group directory and registry. Each binding target is
+* consumed once, so two keys sharing a group and a registry still map one-to-one in order.
+*/
+const joinByBinding = (binding) => {
+	const dirByGroup = new Map(binding.groups.map((g) => [g.id, normalizeDir(g.dir)]));
+	const remaining = [...binding.targets];
+	return (relativeDir, registry) => {
+		const index = remaining.findIndex((t) => t.registry === registry && (dirByGroup.get(t.group) ?? `dist/prod/${t.group}/pkg`) === relativeDir);
+		if (index === -1) return {
+			id: void 0,
+			releases: void 0
+		};
+		const [match] = remaining.splice(index, 1);
+		return {
+			id: match?.id,
+			releases: match?.releases
+		};
+	};
+};
+/** Pre-build join: a placeholder target sits at `dist/prod/<id>/pkg`, so read its declaration by key. */
+const joinByPlaceholder = (declared) => (relativeDir) => {
+	const id = /^dist\/prod\/([^/]+)\/pkg$/.exec(relativeDir)?.[1];
+	if (id === void 0 || declared === void 0 || !Object.hasOwn(declared, id)) return {
+		id: void 0,
+		releases: void 0
+	};
+	return {
+		id,
+		releases: declaredReleasesOf(declared, id)
+	};
+};
+/** The `releases` declared on `publishConfig.targets[id]`, or `undefined` when there is none. */
+const declaredReleasesOf = (declared, id) => {
+	if (id === void 0 || declared === void 0 || !Object.hasOwn(declared, id)) return void 0;
+	const value = declared[id];
+	return typeof value === "object" && value !== null ? value.releases : void 0;
+};
+/** The boolean `provenance` declared on `publishConfig.targets[id]`, or `undefined` when there is none. */
+const declaredProvenanceOf = (declared, id) => {
+	if (declared === void 0 || !Object.hasOwn(declared, id)) return void 0;
+	const value = declared[id];
+	return typeof value === "object" && value !== null && typeof value.provenance === "boolean" ? value.provenance : void 0;
+};
 /** True when a built target directory's package.json is `private: true`. Missing/unreadable/malformed → false. */
 const isTargetPrivate = (fs, targetDir) => fs.readFileString(join(targetDir, "package.json")).pipe(Effect.flatMap((content) => Effect.try({
 	try: () => JSON.parse(content).private === true,
@@ -276,5 +418,4 @@ const readTargetsBinding = (fs, pkgPath) => fs.readFileString(join(pkgPath, "dis
 	catch: () => /* @__PURE__ */ new Error("invalid targets.json")
 })), Effect.orElseSucceed(() => null));
 
-//#endregion
 export { SilkPublishability, readTargetsBinding };

package/services/SilkWorkspaceAnalyzer.js

@@ -5,7 +5,7 @@ import { AnalyzedWorkspace, WorkspaceAnalysis, WorkspaceAnalysisError } from "@s
 import { Context, Effect, FileSystem, Layer, Option } from "effect";
 import { DependencyGraph, PackageManagerDetector, VersioningStrategy, WorkspaceDiscovery } from "@effected/workspaces";
 
-//#region src/services/SilkWorkspaceAnalyzer.ts
+// src/services/SilkWorkspaceAnalyzer.ts
 /**
 * Service that performs a full workspace analysis — discovering packages,
 * detecting publishability, computing versioning/tag strategies, and
@@ -206,5 +206,4 @@ function computeReleaseStatus(pkgName, isPrivate, isPublishable, config) {
 	};
 }
 
-//#endregion
 export { SilkWorkspaceAnalyzer };

package/turbo/digest.js

@@ -1,4 +1,4 @@
-//#region src/turbo/digest.ts
+// src/turbo/digest.ts
 /**
 * Pure transforms from decoded turbo dry-run JSON to digested result shapes.
 * No dependency injection — directly unit-testable.
@@ -123,5 +123,4 @@ var TurboDigest = class TurboDigest {
 	}
 };
 
-//#endregion
 export { TurboDigest };

package/turbo/errors.js

@@ -1,6 +1,6 @@
 import { Data } from "effect";
 
-//#region src/turbo/errors.ts
+// src/turbo/errors.ts
 /**
 * Raised when the turbo CLI cannot be resolved or executed.
 *
@@ -44,5 +44,4 @@ var TurboExecError = class extends Data.TaggedError("TurboExecError") {
 	}
 };
 
-//#endregion
 export { DryRunParseError, NotATurboRepoError, TurboExecError, TurboNotInstalledError };

package/turbo/index.js

@@ -5,7 +5,7 @@ import { TurboCache, TurboDryRun, TurboDryTask, TurboEnvVars, TurboGlobalCacheIn
 import { AffectedResult, CacheDiagnosis, GlobalHashSummary, GraphNode, MissExplanation, PackageCacheStatus, TaskGraphResult } from "./schemas/results.js";
 import { TurboInspector } from "./services/TurboInspector.js";
 
-//#region src/turbo/index.ts
+// src/turbo/index.ts
 var turbo_exports = /* @__PURE__ */ __exportAll({
 	AffectedResult: () => AffectedResult,
 	CacheDiagnosis: () => CacheDiagnosis,
@@ -27,5 +27,4 @@ var turbo_exports = /* @__PURE__ */ __exportAll({
 	TurboNotInstalledError: () => TurboNotInstalledError
 });
 
-//#endregion
 export { AffectedResult, CacheDiagnosis, DryRunParseError, GlobalHashSummary, GraphNode, MissExplanation, NotATurboRepoError, PackageCacheStatus, TaskGraphResult, TurboCache, TurboDigest, TurboDryRun, TurboDryTask, TurboEnvVars, TurboExecError, TurboGlobalCacheInputs, TurboInspector, TurboNotInstalledError, turbo_exports };

package/turbo/schemas/DryRun.js

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
 
-//#region src/turbo/schemas/DryRun.ts
+// src/turbo/schemas/DryRun.ts
 /** turbo's per-target cache descriptor in `--dry=json`. */
 const TurboCache = Schema.Struct({
 	local: Schema.Boolean,
@@ -47,5 +47,4 @@ const TurboDryRun = Schema.Struct({
 	tasks: Schema.Array(TurboDryTask)
 }).annotate({ identifier: "TurboDryRun" });
 
-//#endregion
 export { TurboCache, TurboDryRun, TurboDryTask, TurboEnvVars, TurboGlobalCacheInputs };

package/turbo/schemas/results.js

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
 
-//#region src/turbo/schemas/results.ts
+// src/turbo/schemas/results.ts
 /** Per-package cache outcome for one task. */
 const PackageCacheStatus = Schema.Struct({
 	package: Schema.String,
@@ -57,5 +57,4 @@ const AffectedResult = Schema.Struct({
 	dependents: Schema.Array(Schema.String)
 }).annotate({ identifier: "AffectedResult" });
 
-//#endregion
 export { AffectedResult, CacheDiagnosis, GlobalHashSummary, GraphNode, MissExplanation, PackageCacheStatus, TaskGraphResult };

package/turbo/services/TurboInspector.js

@@ -6,7 +6,7 @@ import { Git } from "@effected/git";
 import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { Run, Tool, ToolDiscovery } from "@effected/commands";
 
-//#region src/turbo/services/TurboInspector.ts
+// src/turbo/services/TurboInspector.ts
 /**
 * Read-only Turborepo inspector. All operations use `--dry` and never execute tasks.
 * Surfaced through the MCP `turbo_inspect` tool.
@@ -104,5 +104,4 @@ const DEFAULT_BUILD_TASK = "build:dev";
 /** Default git ref `affected` compares against — matches Turborepo's own `--affected` default. */
 const DEFAULT_AFFECTED_BASE = "main";
 
-//#endregion
 export { TurboInspector };