@effected/workspaces 0.8.0 → 0.9.1

package/PackageManagerName.js

@@ -103,7 +103,11 @@ const CHECKED = [
 	"bun.lock",
 	"bun.lockb",
 	"yarn.lock",
-	"package.json#workspaces"
+	"package.json#workspaces",
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"package.json#packageManager",
+	"package.json#devEngines.packageManager"
 ];
 /**
 * Detects which package manager owns a workspace root.
@@ -217,7 +221,8 @@ var PackageManagerDetector = class PackageManagerDetector extends Context.Servic
 				version: versionFor(hints, "pnpm"),
 				runtime: "node"
 			});
-			if (((yield* has(root, "bun.lock")) || (yield* has(root, "bun.lockb"))) && namesManager(hints, "bun")) return DetectedPackageManager.make({
+			const bunLock = (yield* has(root, "bun.lock")) || (yield* has(root, "bun.lockb"));
+			if (bunLock && namesManager(hints, "bun")) return DetectedPackageManager.make({
 				name: "bun",
 				version: versionFor(hints, "bun"),
 				runtime: "bun"
@@ -233,6 +238,35 @@ var PackageManagerDetector = class PackageManagerDetector extends Context.Servic
 				version: versionFor(hints, "npm"),
 				runtime: "node"
 			});
+			if (yield* has(root, "pnpm-lock.yaml")) return DetectedPackageManager.make({
+				name: "pnpm",
+				version: versionFor(hints, "pnpm"),
+				runtime: "node"
+			});
+			if (bunLock && namesManager(hints, "bun")) return DetectedPackageManager.make({
+				name: "bun",
+				version: versionFor(hints, "bun"),
+				runtime: "bun"
+			});
+			if ((yield* has(root, "yarn.lock")) && namesManager(hints, "yarn")) return DetectedPackageManager.make({
+				name: "yarn",
+				version: versionFor(hints, "yarn"),
+				runtime: "node"
+			});
+			if (yield* has(root, "package-lock.json")) return DetectedPackageManager.make({
+				name: "npm",
+				version: versionFor(hints, "npm"),
+				runtime: "node"
+			});
+			const declared = declaredName(hints);
+			if (Option.isSome(declared)) {
+				const name = declared.value;
+				if (name === "pnpm" || name === "npm" || name === "yarn" || name === "bun") return DetectedPackageManager.make({
+					name,
+					version: versionFor(hints, name),
+					runtime: name === "bun" ? "bun" : "node"
+				});
+			}
 			return yield* Effect.fail(new PackageManagerDetectionError({
 				root,
 				checked: CHECKED
@@ -242,6 +276,58 @@ var PackageManagerDetector = class PackageManagerDetector extends Context.Servic
 	});
 	/** The live layer. */
 	static layer = Layer.effect(PackageManagerDetector, PackageManagerDetector.make);
+	/**
+	* The sanctioned in-memory double.
+	*
+	* @remarks
+	* **`detect` has no honest default, so an unstubbed call dies** — the
+	* `WorkspaceDiscovery.info` posture, for the same reason. A stand-in that
+	* answered `"pnpm"` would hand a consumer a fact nothing established, and it
+	* would contradict the very service it stands in for: the live detector's
+	* defining property is that it [refuses to
+	* guess](https://github.com/spencerbeggs/effected) when no evidence matches.
+	* A double that guesses is worse than no double.
+	*
+	* Failing typed would be the subtler mistake: `PackageManagerDetectionError`
+	* reads as a legitimate "no manager here" answer, so a consumer would branch
+	* on it and proceed, never learning that the test simply forgot to stub.
+	*
+	* The defect is also not absorbed by `Effect.catch` or any typed-error
+	* handler — deliberately, so code under test with a best-effort `catch`
+	* around detection cannot make the mandatory stub look optional; the
+	* unstubbed call still fails the test.
+	*
+	* @param overrides - Members to supply; anything omitted dies on use.
+	*
+	* @example
+	* ```ts
+	* import { DetectedPackageManager, PackageManagerDetector } from "@effected/workspaces";
+	* import { Effect, Option } from "effect";
+	*
+	* const TestDetector = PackageManagerDetector.layerTest({
+	*   detect: () =>
+	*     Effect.succeed(
+	*       DetectedPackageManager.make({ name: "pnpm", version: Option.none(), runtime: "node" }),
+	*     ),
+	* });
+	* ```
+	*/
+	static makeTest = (overrides = {}) => ({
+		detect: () => Effect.die(/* @__PURE__ */ new Error("PackageManagerDetector.makeTest: detect() was called but not stubbed — no honest default DetectedPackageManager exists for a test double; pass a `detect` override.")),
+		...overrides
+	});
+	/**
+	* {@link PackageManagerDetector.makeTest} behind `Layer.succeed`.
+	*
+	* @remarks
+	* A parameterized layer factory mints a **fresh reference per call**, and
+	* layers memoize by reference — bind the result to a `const` and reuse it
+	* rather than calling `layerTest(...)` at each composition site.
+	*
+	* Pairs with `WorkspaceRoot.layerTest` and `WorkspaceDiscovery.layerTest` to
+	* stand up the whole discovery path with no filesystem at all.
+	*/
+	static layerTest = (overrides = {}) => Layer.succeed(PackageManagerDetector, PackageManagerDetector.makeTest(overrides));
 };
 
 //#endregion

package/Publishability.js

@@ -84,9 +84,35 @@ var PublishTarget = class extends Schema.Class("PublishTarget")({
 *
 * @public
 */
-var PublishabilityDetector = class PublishabilityDetector extends Context.Service()("@effected/workspaces/PublishabilityDetector") {
-	/** Standard npm publishing semantics. Pure — no filesystem, no platform services. */
-	static layer = Layer.succeed(PublishabilityDetector, { detect: (pkg) => Effect.sync(() => {
+var PublishabilityDetector = class extends Context.Service()("@effected/workspaces/PublishabilityDetector") {
+	/**
+	* Standard npm publishing semantics, **as a value**. Pure — no filesystem,
+	* no platform services.
+	*
+	* @remarks
+	* Exposed as a shape and not only as a layer, because a consumer composing
+	* *around* these rules cannot reach them through a layer without re-entering
+	* the very tag it is replacing. `@savvy-web/silk-effects` had to write
+	* `Effect.provide(PublishabilityDetector, PublishabilityDetector.layer)`
+	* **inside its own implementation of that tag** to get at this function for
+	* its pass-through branch; with the value exposed that becomes
+	* `PublishabilityDetector.npm.detect(pkg)`.
+	*
+	* @example
+	* ```ts
+	* import { PublishabilityDetector } from "@effected/workspaces";
+	* import { Effect, Layer } from "effect";
+	*
+	* // A policy that defers to npm semantics for everything it does not veto.
+	* const withVeto = Layer.succeed(PublishabilityDetector, {
+	*   detect: (pkg) =>
+	*     pkg.name.endsWith("-private")
+	*       ? Effect.succeed([])
+	*       : PublishabilityDetector.npm.detect(pkg),
+	* });
+	* ```
+	*/
+	static npm = { detect: (pkg) => Effect.sync(() => {
 		const config = pkg.publishConfig;
 		const access = config?.access;
 		if (pkg.private && access === void 0) return [];
@@ -97,7 +123,40 @@ var PublishabilityDetector = class PublishabilityDetector extends Context.Servic
 			access: access ?? "public",
 			provenance: false
 		})];
-	}) });
+	}) };
+	/** Nothing publishes. */
+	static none = { detect: () => Effect.succeed([]) };
+	/**
+	* {@link PublishabilityDetector.npm} as a layer.
+	*
+	* @remarks
+	* Named for its policy rather than called `layer`, deliberately. **No
+	* composite in this package provides a publishability detector**: a
+	* `Workspaces.layer()` that quietly supplied npm semantics made the choice
+	* invisible, and worse, made a naively-ordered override lose to it in
+	* silence — `Layer.mergeAll(myDetector, Workspaces.layer())` resolved to the
+	* default, because `mergeAll` is last-wins. For a service that decides
+	* whether a package publishes and to which registry, that silent revert was
+	* the worst available failure.
+	*
+	* The composites do not *require* a detector either — nothing inside them
+	* asks a publishability question, so their `R` stays `FileSystem | Path`.
+	* The requirement instead surfaces in the `R` of each operation that asks
+	* (`VersioningStrategy.detect`, e.g.): a program that asks and never wires
+	* a detector fails to compile where that operation's `R` must close — which
+	* can be far from the layer-wiring site — and a program that never asks
+	* never supplies a publish policy at all.
+	*/
+	static layerNpm = Layer.succeed(this, this.npm);
+	/**
+	* {@link PublishabilityDetector.none} as a layer: a workspace where nothing
+	* publishes.
+	*
+	* @remarks
+	* For dry runs, and for a release tool whose configuration disables
+	* publishing wholesale — silk's changeset `mode: "none"` is exactly this.
+	*/
+	static layerNone = Layer.succeed(this, this.none);
 };
 
 //#endregion

package/README.md

@@ -232,7 +232,9 @@ A name miss in the derived `getPackage` fails with the service's own typed `Pack
 - `WorkspaceCatalogs` — pnpm catalog assembly and `catalog:` resolution, on pnpm's own catalog packages; `releaseAgeGate()` assembles the effective `@effected/npm` `ReleaseAgeGate` from inline `pnpm-workspace.yaml` release-age keys and replayed hook contributions, strictest-wins, in the same pass as the catalogs.
 - `LockfileReader` — locate and parse the workspace's lockfile through `@effected/lockfiles`.
 - `ChangeDetector` — git-range change detection over `@effected/git`'s `Git` service; swap the layer to mock it with no repository.
-- `PublishabilityDetector` — whether a package publishes and to where, as a `PublishTarget` (registry, directory, access, provenance). The default layer implements npm's semantics; swap the layer if yours differ.
+- `PublishabilityDetector` — whether a package publishes and to where, as a `PublishTarget` (registry, directory, access, provenance). No composite provides one: pick `PublishabilityDetector.layerNpm` (standard npm semantics) or `.layerNone` (nothing publishes) and provide it explicitly.
+- `ReleaseTag` / `TrackingTag` — release-tag formatting (`ReleaseTag.single` / `.scoped`, strict SemVer by default with no `v` prefix) and the floating major/minor alias derivation GitHub Actions-style consumers expect (`v1`, `v1.2`), plus `classifyTag` to tell a release tag from a tracking alias.
+- `VersioningStrategy` — classify a workspace as `single`, `fixed-group` or `independent` from package names and fixed groups, or detect it live against `PublishabilityDetector`, and produce the release tags for a batch with `tagsFor`.
 - `findWorkspaceRootSync` / `getWorkspacePackagesSync` — the synchronous escape hatch for config-time callers that cannot await, over file and path operations you supply.
 - `@effected/workspaces/node-sync` — a second entry point holding the Node bindings for those operations (`nodeFileSystem`, `nodePath` and the `nodeSyncOps` bag), kept off the main entry so `node:*` never reaches a consumer that supplies its own.
 

package/ReleaseTag.js

@@ -0,0 +1,260 @@
+import { Schema } from "effect";
+
+//#region src/ReleaseTag.ts
+/**
+* Whether one shared tag names a whole release, or one tag names each package.
+*
+* @remarks
+* `single` is the shape of a single-package repo and of a monorepo whose
+* publishable packages all version in lockstep; `scoped` is the shape of
+* independent versioning, where a shared tag would be ambiguous.
+*
+* @public
+*/
+const TagStyle = Schema.Literals(["single", "scoped"]);
+/** Digits only, and no leading zeros beyond `0` itself — SemVer's numeric identifier. */
+const NUMERIC_IDENTIFIER = /^(?:0|[1-9]\d*)$/;
+/**
+* Read a version's numeric core, or nothing when it is not `X.Y.Z[-pre][+build]`.
+*
+* Build metadata is stripped **before** the prerelease test: `+build` carries
+* no precedence meaning in SemVer, so `1.2.3+sha.abc` is the stable `1.2.3`,
+* and treating any `-`-or-`+` suffix as a prerelease is the obvious wrong
+* reading.
+*/
+const versionCore = (version) => {
+	const withoutBuild = version.split("+", 1)[0] ?? "";
+	const dash = withoutBuild.indexOf("-");
+	const prerelease = dash !== -1;
+	const segments = (prerelease ? withoutBuild.slice(0, dash) : withoutBuild).split(".");
+	if (segments.length !== 3) return void 0;
+	if (!segments.every((segment) => NUMERIC_IDENTIFIER.test(segment))) return void 0;
+	return {
+		major: Number(segments[0]),
+		minor: Number(segments[1]),
+		prerelease
+	};
+};
+/**
+* A floating alias tag — `v1`, `v1.2` — that a repo re-points at its newest
+* matching release.
+*
+* @remarks
+* This is the GitHub Actions distribution convention: a consumer writes
+* `uses: owner/repo@v1` and receives whatever 1.x the repo last pointed `v1` at.
+*
+* **Deliberately not SemVer, and deliberately not a {@link (TagStyle:variable)}.**
+* A release tag names one immutable version; a tracking tag is an alias derived
+* *from* a version, carrying a truncated number that is not a version at all.
+* Folding it into `ReleaseTag` as a third style would put a mutable pointer and
+* an immutable name behind one type.
+*
+* Everything here is derivation, formatting and parsing. **Actually moving a
+* git tag is not this package's business** — a consumer does that through git,
+* and the deliberate omission is what keeps this module a pure leaf.
+*
+* @example
+* ```ts
+* import { TrackingTag } from "@effected/workspaces";
+*
+* TrackingTag.forVersion("1.2.3").map((t) => t.value);        // ["v1", "v1.2"]
+* TrackingTag.forVersion("1.0.0-beta.3");                     // [] — never float onto a beta
+* TrackingTag.forVersion("1.2.3", { packageName: "@acme/cli" });
+* // ["@acme/cli@v1", "@acme/cli@v1.2"]
+* ```
+*
+* @public
+*/
+var TrackingTag = class TrackingTag extends Schema.Class("TrackingTag")({
+	/** The tag string exactly as it appears in git. */
+	value: Schema.NonEmptyString,
+	/** The package the alias namespaces; absent on a bare `v1`. */
+	packageName: Schema.optionalKey(Schema.NonEmptyString),
+	/** The major version the alias tracks. */
+	major: Schema.Int,
+	/** The minor version, on a `v1.2`-precision alias; absent on `v1`. */
+	minor: Schema.optionalKey(Schema.Int)
+}) {
+	/** Whether this alias tracks a whole major line, or one minor line inside it. */
+	get precision() {
+		return this.minor === void 0 ? "major" : "minor";
+	}
+	/**
+	* The tracking tags a release of `version` should be pointed at.
+	*
+	* @remarks
+	* **A prerelease derives nothing.** Anyone depending on `owner/repo@v1` is
+	* asking for the newest *stable* 1.x, so re-pointing that alias at
+	* `1.0.0-beta.3` would ship a prerelease to every such consumer with no
+	* signal at all. `includePrerelease` exists for callers who genuinely mean
+	* it — a prerelease-only distribution channel — and should be rare.
+	*
+	* **Total, never throwing.** A version that is not `X.Y.Z` derives nothing
+	* rather than failing: this is a query about a version, not a validation of
+	* one, and `WorkspacePackage.version` is deliberately tolerant, so odd
+	* versions reach here routinely.
+	*
+	* 0.x versions DO derive aliases. Floating `v0` across 0.x minors is a real
+	* hazard, but which aliases to publish is the caller's policy, decided where
+	* the tags are moved — not something a derivation should quietly withhold.
+	*
+	* @param version - The version being released.
+	* @param options - Package prefix, precision and the prerelease override.
+	* @returns The aliases, broadest first; empty when none apply.
+	*/
+	static forVersion(version, options) {
+		const core = versionCore(version);
+		if (core === void 0) return [];
+		if (core.prerelease && options?.includePrerelease !== true) return [];
+		const packageName = options?.packageName;
+		const prefix = packageName === void 0 ? "" : `${packageName}@`;
+		const named = (suffix, fields) => TrackingTag.make({
+			value: `${prefix}v${suffix}`,
+			...packageName !== void 0 && { packageName },
+			major: fields.major,
+			...fields.minor !== void 0 && { minor: fields.minor }
+		});
+		const major = named(`${core.major}`, { major: core.major });
+		if (options?.precision === "major") return [major];
+		return [major, named(`${core.major}.${core.minor}`, {
+			major: core.major,
+			minor: core.minor
+		})];
+	}
+};
+/** A tag string split into an optional package prefix and the version part. */
+const splitTag = (tag) => {
+	const at = tag.lastIndexOf("@");
+	if (at === -1) return { rest: tag };
+	const packageName = tag.slice(0, at);
+	const rest = tag.slice(at + 1);
+	if (packageName === "" || rest === "") return void 0;
+	return {
+		packageName,
+		rest
+	};
+};
+/**
+* Decide whether a tag string is a release tag, a tracking alias, or neither.
+*
+* @remarks
+* The two families are told apart by **segment count**, not by the `v` prefix:
+* three numeric segments is a version (so `1.0.0` and `v1.0.0` are both release
+* tags), while one or two segments is a truncated alias. The `v` *is* required
+* on an alias — a bare `1` is neither valid SemVer nor the tracking convention,
+* and accepting it would make this function guess.
+*
+* The package prefix splits at the **last** `@`, so a leading npm scope
+* survives: `@scope/pkg@1.0.0` is package `@scope/pkg` at version `1.0.0`.
+*
+* Round-tripping is a tested property: every tag {@link ReleaseTag} and
+* {@link TrackingTag} format classifies back to the family that produced it,
+* with its fields intact.
+*
+* @param tag - Any tag string.
+* @returns The classification.
+*
+* @public
+*/
+const classifyTag = (tag) => {
+	const split = splitTag(tag);
+	if (split === void 0) return { kind: "unrecognized" };
+	const { packageName, rest } = split;
+	const withoutV = rest.startsWith("v") ? rest.slice(1) : rest;
+	const hasV = rest.startsWith("v");
+	if (versionCore(withoutV) !== void 0) return {
+		kind: "release",
+		tag: ReleaseTag.make({
+			value: tag,
+			...packageName !== void 0 && { packageName },
+			version: withoutV,
+			style: packageName === void 0 ? "single" : "scoped"
+		})
+	};
+	if (!hasV) return { kind: "unrecognized" };
+	const segments = withoutV.split(".");
+	if (segments.length > 2 || !segments.every((segment) => NUMERIC_IDENTIFIER.test(segment))) return { kind: "unrecognized" };
+	const major = Number(segments[0]);
+	const minor = segments.length === 2 ? Number(segments[1]) : void 0;
+	return {
+		kind: "tracking",
+		tag: TrackingTag.make({
+			value: tag,
+			...packageName !== void 0 && { packageName },
+			major,
+			...minor !== void 0 && { minor }
+		})
+	};
+};
+/**
+* A git tag naming a release, and the parts it was built from.
+*
+* @remarks
+* `value` is the tag exactly as it appears in git; `version` stays **bare**
+* even when `value` carries a prefix, so a consumer comparing versions never
+* has to strip one back off.
+*
+* Formatting is **total**: there is no error channel, because the only failure
+* v3 modelled — an empty version — is caught by `Schema.NonEmptyString` when
+* the value is constructed. A bad version reaching these statics is developer
+* wiring rather than untrusted input, so it dies as a defect, the same posture
+* as an uncompilable glob literal in `WorkspacePackage.matchesDependency`.
+*
+* @example
+* ```ts
+* import { ReleaseTag } from "@effected/workspaces";
+*
+* ReleaseTag.single("1.2.3").value;               // "1.2.3"
+* ReleaseTag.scoped("@acme/cli", "1.2.3").value;  // "@acme/cli@1.2.3"
+* ReleaseTag.scoped("cli", "1.2.3").value;        // "cli@1.2.3"
+* ReleaseTag.scoped("cli", "1.2.3", { versionPrefix: "v" }).value; // "cli@v1.2.3"
+* ```
+*
+* @public
+*/
+var ReleaseTag = class ReleaseTag extends Schema.Class("ReleaseTag")({
+	/** The tag string exactly as it appears in git. */
+	value: Schema.NonEmptyString,
+	/** The package the tag names; absent on a workspace-wide single tag. */
+	packageName: Schema.optionalKey(Schema.NonEmptyString),
+	/** The version the tag names, without any prefix. */
+	version: Schema.NonEmptyString,
+	/** Which style produced it. */
+	style: TagStyle
+}) {
+	/**
+	* One shared tag for a whole release: `1.2.3`.
+	*
+	* @param version - The version being released. Must not be empty.
+	* @param options - Formatting overrides.
+	*/
+	static single(version, options) {
+		const prefix = options?.versionPrefix ?? "";
+		return ReleaseTag.make({
+			value: `${prefix}${version}`,
+			version,
+			style: "single"
+		});
+	}
+	/**
+	* A per-package tag: `<packageName>@<version>` — `@scope/pkg@1.2.3` for a
+	* scoped name, `pkg@1.2.3` for an unscoped one, uniformly, unless
+	* `options.versionPrefix` says otherwise.
+	*
+	* @param packageName - The package being released. Must not be empty.
+	* @param version - The version being released. Must not be empty.
+	* @param options - Formatting overrides.
+	*/
+	static scoped(packageName, version, options) {
+		const prefix = options?.versionPrefix ?? "";
+		return ReleaseTag.make({
+			value: `${packageName}@${prefix}${version}`,
+			packageName,
+			version,
+			style: "scoped"
+		});
+	}
+};
+
+//#endregion
+export { ReleaseTag, TagStyle, TrackingTag, classifyTag };

package/VersioningStrategy.js

@@ -0,0 +1,122 @@
+import { WorkspaceDiscovery } from "./WorkspaceDiscovery.js";
+import { PublishabilityDetector } from "./Publishability.js";
+import { ReleaseTag } from "./ReleaseTag.js";
+import { Effect, Schema } from "effect";
+
+//#region src/VersioningStrategy.ts
+/**
+* How a workspace assigns versions across its publishable packages.
+*
+* @remarks
+* - `single` — zero or one publishable package, so one tag names the release.
+* - `fixed-group` — every publishable package sits inside one group that
+*   versions in lockstep, so one tag still names the release.
+* - `independent` — publishable packages version separately, so a shared tag
+*   would be ambiguous and each package needs its own.
+*
+* @public
+*/
+const VersioningStrategyType = Schema.Literals([
+	"single",
+	"fixed-group",
+	"independent"
+]);
+/**
+* How a workspace versions, and the tagging that follows from it.
+*
+* @remarks
+* Built either purely with {@link VersioningStrategy.classify}, or from a live
+* workspace with {@link VersioningStrategy.detect}.
+*
+* @example
+* ```ts
+* import { VersioningStrategy } from "@effected/workspaces";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   const strategy = yield* VersioningStrategy.detect({ fixedGroups });
+*   return strategy.tagsFor(released).map((tag) => tag.value);
+* });
+* ```
+*
+* @public
+*/
+var VersioningStrategy = class VersioningStrategy extends Schema.Class("VersioningStrategy")({
+	/** The classification. */
+	type: VersioningStrategyType,
+	/** The groups classification was performed against, as supplied. */
+	fixedGroups: Schema.Array(Schema.Array(Schema.String)),
+	/** The publishable package names, sorted and de-duplicated. */
+	publishablePackages: Schema.Array(Schema.String)
+}) {
+	/**
+	* Whether a release needs one tag per package rather than one shared tag.
+	*/
+	get perPackageTags() {
+		return this.type === "independent";
+	}
+	/** The tag style this strategy implies. */
+	get tagStyle() {
+		return this.perPackageTags ? "scoped" : "single";
+	}
+	/**
+	* Classify a workspace from its publishable package names and fixed groups.
+	*
+	* @remarks
+	* Pure and total — no IO, no error channel. `packages` is sorted and
+	* de-duplicated first, so a name listed twice cannot inflate a one-package
+	* repo into an independent one.
+	*/
+	static classify(options) {
+		const fixedGroups = options.fixedGroups ?? [];
+		const packages = [...new Set(options.packages)].sort();
+		const type = packages.length <= 1 ? "single" : fixedGroups.some((group) => packages.every((name) => group.includes(name))) ? "fixed-group" : "independent";
+		return VersioningStrategy.make({
+			type,
+			fixedGroups,
+			publishablePackages: packages
+		});
+	}
+	/**
+	* Classify the ambient workspace: enumerate its packages, keep the ones the
+	* {@link PublishabilityDetector} says publish somewhere, and classify those.
+	*
+	* @remarks
+	* The publishability question is asked through the service precisely so a
+	* consumer with its own rules — honouring a release tool's ignore list, say —
+	* swaps the layer instead of filtering afterwards.
+	*/
+	static detect = Effect.fn("VersioningStrategy.detect")(function* (options) {
+		const discovery = yield* WorkspaceDiscovery;
+		const publishability = yield* PublishabilityDetector;
+		const packages = yield* discovery.listPackages();
+		const publishable = [];
+		for (const candidate of packages) if ((yield* publishability.detect(candidate)).length > 0) publishable.push(candidate.name);
+		return VersioningStrategy.classify({
+			packages: publishable,
+			...options?.fixedGroups !== void 0 && { fixedGroups: options.fixedGroups }
+		});
+	});
+	/**
+	* The tags a release of `releases` produces under this strategy.
+	*
+	* @remarks
+	* Under `independent` this is one {@link ReleaseTag} per release, in the
+	* order given. Under `single` and `fixed-group` it is exactly one shared tag
+	* carrying the **first** release's version — every release in a lockstep
+	* batch shares a version by construction, so the choice is only visible on a
+	* batch that should not exist. Whether a batch actually agreed is a property
+	* of that batch rather than of the workspace, so it stays the caller's
+	* one-line check rather than a field here.
+	*
+	* An empty batch produces no tags under either style.
+	*/
+	tagsFor(releases, options) {
+		if (releases.length === 0) return [];
+		if (this.perPackageTags) return releases.map((release) => ReleaseTag.scoped(release.name, release.version, options));
+		return [ReleaseTag.single(releases[0].version, options)];
+	}
+};
+
+//#endregion
+export { VersioningStrategy, VersioningStrategyType };

package/WorkspaceDiscovery.js

@@ -326,7 +326,10 @@ var WorkspaceDiscovery = class WorkspaceDiscovery extends Context.Service()("@ef
 	*   (a fabricated root path would leak into consumer path logic), so an
 	*   unstubbed `info()` call is a test-wiring mistake and fails loudly as a
 	*   defect rather than succeeding with a lie or failing with a dishonest
-	*   typed error.
+	*   typed error. A defect is not absorbed by `Effect.catch` or any
+	*   typed-error handler — deliberately, so code under test with a
+	*   best-effort `catch` cannot make the mandatory stub look optional; the
+	*   unstubbed call still fails the test.
 	*
 	* @example
 	* ```ts

package/WorkspaceSnapshots.js

@@ -175,7 +175,7 @@ var WorkspaceSnapshots = class WorkspaceSnapshots extends Context.Service()("@ef
 		return {
 			at: Effect.fn("WorkspaceSnapshots.at")(function* (ref) {
 				const root = yield* Effect.suspend(() => roots.find(options?.cwd ?? process.cwd()));
-				const key = `${root}${ref}`;
+				const key = `${root}\0${ref}`;
 				let memo = atCaches.get(key);
 				if (memo === void 0) {
 					const [resolveOnce, invalidate] = yield* Effect.cachedInvalidateWithTTL(computeAt(root, ref), Duration.infinity);
@@ -233,6 +233,13 @@ var WorkspaceSnapshots = class WorkspaceSnapshots extends Context.Service()("@ef
 	* test-wiring mistake fails loudly as a defect rather than succeeding with a
 	* lie.
 	*
+	* **A defect is not absorbed by `Effect.catch` or any typed-error handler**,
+	* and that is the point: code under test with a best-effort `catch` around
+	* its snapshot reads cannot make a mandatory stub look optional — the
+	* unstubbed call still fails the test instead of quietly taking the catch
+	* branch. Only defect-level combinators (`Effect.catchDefect`,
+	* `Effect.exit`) would see it.
+	*
 	* @example
 	* ```ts
 	* import { CatalogSet, WorkspaceSnapshots, WorkspaceStateSnapshot } from "@effected/workspaces";