@effected/workspaces 0.7.0 → 0.9.0

package/LockfileReader.js

@@ -27,6 +27,8 @@ var LockfileReadError = class extends Schema.TaggedErrorClass()("LockfileReadErr
 		return `Cannot read ${this.format} lockfile at ${this.lockfilePath}`;
 	}
 };
+/** A defect naming the unstubbed test-double method — a test-wiring mistake, not a typed failure. */
+const unstubbed = (method) => Effect.die(/* @__PURE__ */ new Error(`LockfileReader.makeTest: ${method}() was called but not stubbed — pass a \`${method}\` override.`));
 /**
 * Reads and parses the workspace's lockfile.
 *
@@ -112,6 +114,74 @@ var LockfileReader = class LockfileReader extends Context.Service()("@effected/w
 	* `const` and reuse it.
 	*/
 	static layer = (options) => Layer.effect(LockfileReader, LockfileReader.make(options));
+	/**
+	* A test double satisfying the full {@link LockfileReaderShape} with no
+	* filesystem, root walk, or package-manager detection.
+	*
+	* @remarks
+	* There is **no honest default lockfile**: an empty one that looks like a
+	* legitimate answer is indistinguishable from "this workspace resolves
+	* nothing" — the silent-empty failure class this package documents on the
+	* live paths — so `read` **dies** with an instructive defect until stubbed.
+	*
+	* The one derivation mirrors `WorkspaceDiscovery.makeTest`'s
+	* derived-from-the-primary rule: when a `read` override is supplied,
+	* `resolvedVersion` answers as the live service does — the **first** entry
+	* of `lockfile.packagesNamed(name)` in lockfile order, `Option.none()` on a
+	* miss — so the two stay consistent by construction. `integrity` is **not**
+	* derivable: the live method compares the lockfile against the workspace
+	* manifests discovery enumerates, and the double has no discovery to ask, so
+	* it dies unless stubbed.
+	*
+	* `refresh` defaults to `Effect.void` honestly: the live contract is "drop
+	* the memoized read so the next call re-reads", and this double memoizes
+	* nothing — every `read()` call re-invokes the override — so there is
+	* nothing to drop and the no-op is truthful, the same reasoning as
+	* `WorkspaceDiscovery.makeTest`'s `refresh`.
+	*
+	* @example
+	* ```ts
+	* import { Lockfile } from "@effected/lockfiles";
+	* import { LockfileReader } from "@effected/workspaces";
+	* import { Effect } from "effect";
+	*
+	* const double = LockfileReader.makeTest({
+	*   read: () =>
+	*     Effect.succeed(
+	*       Lockfile.make({ format: "pnpm", lockfileVersion: "9.0", packages: [], workspaceDependencies: [] }),
+	*     ),
+	* });
+	* // `resolvedVersion` now answers consistently from that lockfile.
+	* ```
+	*/
+	static makeTest = (overrides = {}) => {
+		const read = overrides.read;
+		return {
+			read: () => unstubbed("read"),
+			resolvedVersion: read !== void 0 ? (packageName) => Effect.map(read(), (lockfile) => Option.fromUndefinedOr(lockfile.packagesNamed(packageName)[0])) : () => unstubbed("resolvedVersion"),
+			integrity: () => unstubbed("integrity"),
+			refresh: () => Effect.void,
+			...overrides
+		};
+	};
+	/**
+	* The test layer: {@link LockfileReader.makeTest} behind `Layer.succeed`, so
+	* a suite provides only the methods it exercises.
+	*
+	* @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.
+	*
+	* @example
+	* ```ts
+	* import { LockfileReader } from "@effected/workspaces";
+	*
+	* const TestLockfiles = LockfileReader.layerTest();
+	* // program.pipe(Effect.provide(TestLockfiles)) — dies loudly if touched.
+	* ```
+	*/
+	static layerTest = (overrides = {}) => Layer.succeed(LockfileReader, LockfileReader.makeTest(overrides));
 };
 
 //#endregion

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,53 @@ 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.
+	*
+	* @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,33 @@ 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 requirement now sits in `R`, so the
+	* choice is made once, explicitly, and unmade wiring does not compile.
+	*/
+	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

@@ -134,7 +134,21 @@ A specifier the workspace cannot answer fails typed as `UnresolvedDependencyErro
 
 ## The synchronous escape hatch
 
-Vitest's config-time project discovery cannot await. Two functions exist for exactly that case, and they run synchronously over file and path operations you supply — the module itself imports nothing platform-shaped, and Node's built-ins satisfy the operations one-liner each:
+Vitest's config-time project discovery cannot await. Two functions exist for exactly that case, and they run synchronously over file and path operations you supply. On Node you do not have to write them: the `@effected/workspaces/node-sync` subpath exports `nodeSyncOps`, the ready-made `node:fs` and `node:path` bindings, so adopting the sync path is one extra import.
+
+```ts
+import { findWorkspaceRootSync, getWorkspacePackagesSync } from "@effected/workspaces";
+import { nodeSyncOps } from "@effected/workspaces/node-sync";
+
+const root = findWorkspaceRootSync(process.cwd(), nodeSyncOps);
+const packages = root === null ? [] : getWorkspacePackagesSync(root, nodeSyncOps);
+// root: the workspace root path, or null when none is found above the cwd
+// packages: the discovered workspace packages, empty when there is no root
+```
+
+Both entry points take their path positionally, so the bag usually passes through verbatim; spread it to add `getWorkspacePackagesSync`'s traversal extras — `{ ...nodeSyncOps, maxDepth }`. The bindings are a separate subpath deliberately: the main entry imports nothing platform-shaped, and re-exporting them from it would drag `node:*` into every consumer, including the ones supplying their own operations. `nodePath` is the running platform's `node:path`, so on Windows the paths handed back are win32 paths.
+
+Write the operations yourself when Node's built-ins are not the platform you mean — a Bun or Deno binding, a test fake, or `node:path/win32` to pin a dialect rather than follow the running platform. Each one is a one-liner:
 
 ```ts
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
@@ -157,7 +171,7 @@ const packages = root === null ? [] : getWorkspacePackagesSync(root, options);
 // packages: the discovered workspace packages, empty when there is no root
 ```
 
-Windows correctness is the operations you pass — `node:path` on Windows is already win32-appropriate. Both entry points drive one traversal state machine (the same dequeue order, depth rule, visit budget and `node_modules` prune), so the sync and Effect surfaces can never disagree about what a pattern means. The one deliberate difference is at a bound: the Effect enumerator fails typed, the sync one truncates. Prefer the Effect API everywhere you can run one.
+Windows correctness is therefore the operations you pass, and nothing else. Both entry points drive one traversal state machine (the same dequeue order, depth rule, visit budget and `node_modules` prune), so the sync and Effect surfaces can never disagree about what a pattern means. The one deliberate difference is at a bound: the Effect enumerator fails typed, the sync one truncates. Prefer the Effect API everywhere you can run one.
 
 ## Error handling
 
@@ -220,6 +234,7 @@ A name miss in the derived `getPackage` fails with the service's own typed `Pack
 - `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.
 - `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.
 
 ## License
 

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 };