@effected/workspaces 0.28.0 → 0.29.0

package/WorkspaceDiscovery.js

@@ -548,7 +548,8 @@ var WorkspaceDiscovery = class WorkspaceDiscovery extends Context.Service()("@ef
 				const version = index.get(packageName);
 				return version === void 0 ? Effect.fail(new DependencyResolutionError({
 					specifier,
-					cause: /* @__PURE__ */ new Error(`Workspace member "${packageName}" declares no version`)
+					reason: "no-version",
+					cause: void 0
 				})) : Effect.succeed(Option.some(version));
 			}));
 		} };

package/WorkspaceSnapshots.js

@@ -52,10 +52,10 @@ const snapshotOf = (content, relativePath) => {
 	const parsed = parseJsonObject(content.value);
 	const name = parsed.name;
 	if (typeof name !== "string" || name.length === 0) return Option.none();
-	const version = typeof parsed.version === "string" ? parsed.version : "";
+	const version = parsed.version;
 	return Option.some(PackageStateSnapshot.make({
 		name,
-		version,
+		...typeof version === "string" && version !== "" ? { version } : {},
 		relativePath,
 		...isStringRecord(parsed.dependencies) ? { dependencies: parsed.dependencies } : {},
 		...isStringRecord(parsed.devDependencies) ? { devDependencies: parsed.devDependencies } : {},
@@ -233,7 +233,7 @@ var WorkspaceSnapshots = class WorkspaceSnapshots extends Context.Service()("@ef
 				const hookReplays = yield* catalogsService.hookReplays();
 				const snapshotPackages = packages.map((pkg) => PackageStateSnapshot.make({
 					name: pkg.name,
-					version: pkg.version ?? "",
+					...pkg.version === void 0 ? {} : { version: pkg.version },
 					relativePath: pkg.relativePath,
 					dependencies: pkg.dependencies,
 					devDependencies: pkg.devDependencies,

package/WorkspaceStateSnapshot.js

@@ -1,12 +1,27 @@
 import { unanimousVersionOf } from "./internal/importerVersions.js";
 import { CatalogSet } from "./WorkspaceCatalogs.js";
-import { Effect, Exit, Layer, Option, Schema } from "effect";
+import { Effect, Exit, Layer, Option, Schema, SchemaTransformation } from "effect";
 import { CatalogResolver, DependencyResolutionError, DependencySpecifier, WorkspaceResolver } from "@effected/npm";
 
 //#region src/WorkspaceStateSnapshot.ts
 const EMPTY = Object.freeze(Object.create(null));
 const DependencyMap = Schema.Record(Schema.String, Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed(EMPTY)), Schema.withConstructorDefault(Effect.succeed(EMPTY)));
 /**
+* A snapshot's `version` field: absent when the manifest declared none, and
+* never `""`.
+*
+* @remarks
+* The Type side is a `NonEmptyString`, so `make` rejects `""` outright. The
+* encoded side stays a plain optional string for one reason only: snapshots
+* serialized while `""` was the "declared no version" sentinel must still
+* decode, and they decode to the absent key they always meant — so an old
+* stored value and a fresh capture of the same manifest compare equal.
+*/
+const SnapshotVersion = Schema.optionalKey(Schema.String).pipe(Schema.decodeTo(Schema.optionalKey(Schema.NonEmptyString), SchemaTransformation.transformOptional({
+	decode: (encoded) => Option.filter(encoded, (version) => version !== ""),
+	encode: (version) => version
+})));
+/**
 * One workspace member as captured in a {@link WorkspaceStateSnapshot} — the
 * serializable slice a snapshot diff reads: identity, version, location, and the
 * four dependency records.
@@ -24,23 +39,24 @@ var PackageStateSnapshot = class extends Schema.Class("PackageStateSnapshot")({
 	/** The package name. */
 	name: Schema.NonEmptyString,
 	/**
-	* The raw `version` string, as recorded at the captured moment — or `""` for
+	* The raw `version` string, as recorded at the captured moment — absent for
 	* a manifest that declared none.
 	*
 	* @remarks
-	* `WorkspacePackage.version` is optional and a version-less member is an
-	* ordinary pnpm shape, but this field stays a plain required string because a
-	* snapshot is a serialized value someone stores and diffs: an absent key and
-	* a present one would read as a change the moment one side of a diff was
-	* captured by a different code path. **`""` is therefore the sentinel for
-	* "the manifest declared no version", not a version anyone can use** — both
-	* `snapshotOf` at a ref and the worktree snapshot write it, so the two sides
-	* agree. Every resolution surface treats it as absence:
-	* {@link WorkspaceStateSnapshot.resolve} answers `Option.none()` for a
-	* `workspace:` specifier against it, because `some("")` would rewrite
-	* `workspace:^` as a bare `"^"`.
+	* Optional exactly as `WorkspacePackage.version` is: a version-less member is
+	* an ordinary pnpm shape. Both capture paths — `WorkspaceSnapshots.at(ref)`
+	* and `WorkspaceSnapshots.worktree()` — omit the key for such a member, so
+	* the two sides of a diff agree without a placeholder. Never `""`: `make`
+	* rejects it, and a snapshot serialized when `""` was the "no version"
+	* sentinel decodes to the absent key.
+	*
+	* A version-less member is still a member: it appears in `packages` and
+	* answers {@link WorkspaceStateSnapshot.package}, but is absent from
+	* {@link WorkspaceStateSnapshot.versions}, resolves a `workspace:` specifier
+	* to `Option.none()`, and fails its snapshot-bound `WorkspaceResolver`'s
+	* `versionOf` typed.
 	*/
-	version: Schema.String,
+	version: SnapshotVersion,
 	/** POSIX path relative to the workspace root; `"."` for the root package. */
 	relativePath: Schema.String,
 	/** Production dependencies. */
@@ -166,7 +182,11 @@ var WorkspaceStateSnapshot = class WorkspaceStateSnapshot extends Schema.Class("
 	#workspaceResolver;
 	#resolvers;
 	#versions() {
-		if (this.#versionIndex === void 0) this.#versionIndex = new Map(this.packages.map((pkg) => [pkg.name, pkg.version]));
+		if (this.#versionIndex === void 0) {
+			const index = /* @__PURE__ */ new Map();
+			for (const pkg of this.packages) if (pkg.version !== void 0) index.set(pkg.name, pkg.version);
+			this.#versionIndex = index;
+		}
 		return this.#versionIndex;
 	}
 	#packages() {
@@ -174,15 +194,13 @@ var WorkspaceStateSnapshot = class WorkspaceStateSnapshot extends Schema.Class("
 		return this.#packageIndex;
 	}
 	/**
-	* Every captured package's name → version. Total; O(1) after the first call.
+	* Every captured package's name → version, for the packages that declared
+	* one. Total; O(1) after the first call.
 	*
 	* @remarks
-	* Values are `PackageStateSnapshot.version` verbatim, so a member whose
-	* manifest declared no version maps to the **`""` sentinel** rather than
-	* being absent from the map — presence here answers membership, not
-	* "has a usable version". A caller reading a version out of this map owes
-	* the `""` check itself; {@link WorkspaceStateSnapshot.resolve} already
-	* makes it.
+	* A member whose manifest declared no version is **absent** from this map,
+	* so every value is a real version and presence answers "has a version",
+	* not membership — ask {@link WorkspaceStateSnapshot.package} for that.
 	*/
 	get versions() {
 		return this.#versions();
@@ -268,10 +286,7 @@ var WorkspaceStateSnapshot = class WorkspaceStateSnapshot extends Schema.Class("
 				const fromCatalogs = this.#catalogRange(dependency, classified.name);
 				return Option.isSome(fromCatalogs) ? fromCatalogs : onUnresolvedCatalog();
 			}
-			case "workspace": {
-				const version = this.#versions().get(dependency);
-				return version === void 0 || version === "" ? Option.none() : Option.some(version);
-			}
+			case "workspace": return Option.fromUndefinedOr(this.#versions().get(dependency));
 			default: return Option.none();
 		}
 	}
@@ -422,11 +437,13 @@ var WorkspaceStateSnapshot = class WorkspaceStateSnapshot extends Schema.Class("
 	*/
 	get workspaceResolver() {
 		if (this.#workspaceResolver === void 0) this.#workspaceResolver = Layer.succeed(WorkspaceResolver, { versionOf: (packageName) => {
-			const version = this.#versions().get(packageName);
-			if (version === void 0) return Effect.succeed(Option.none());
-			if (version === "") return Effect.fail(new DependencyResolutionError({
+			const member = this.#packages().get(packageName);
+			if (member === void 0) return Effect.succeed(Option.none());
+			const version = member.version;
+			if (version === void 0) return Effect.fail(new DependencyResolutionError({
 				specifier: `workspace:${packageName}`,
-				cause: /* @__PURE__ */ new Error(`Workspace member "${packageName}" declares no version`)
+				reason: "no-version",
+				cause: void 0
 			}));
 			return Effect.succeed(Option.some(version));
 		} });

package/WorkspacesSync.js

@@ -120,9 +120,17 @@ const isPackage = (options, dir) => options.fileSystem.exists(options.path.join(
 * Markers match the async service exactly: a `pnpm-workspace.yaml`, or a
 * `package.json` carrying a `workspaces` field.
 *
+* The ascent is unbounded unless `options.stopAt` names a ceiling
+* ({@link FindWorkspaceRootSyncOptions.stopAt}), with the Effect surface's
+* semantics: inclusive, resolved at lookup time. Where `WorkspaceRoot.find`
+* fails `WorkspaceRootNotFoundError` carrying the resolved ceiling, this
+* returns `null` — the facade is total and has no error channel, and the
+* caller already holds the ceiling it passed.
+*
 * @param cwd - Where to start the ascent (typically `process.cwd()`),
 *   matching the Effect layers' `{ cwd }` option.
-* @param options - The consumer-supplied file and path operations.
+* @param options - The consumer-supplied file and path operations, plus an
+*   optional `stopAt` ceiling.
 *
 * @example
 * ```ts
@@ -146,10 +154,12 @@ const isPackage = (options, dir) => options.fileSystem.exists(options.path.join(
 const findWorkspaceRootSync = (cwd, options) => {
 	const { fileSystem, path } = options;
 	let current = path.resolve(cwd);
+	const ceiling = options.stopAt === void 0 ? void 0 : path.resolve(options.stopAt);
 	for (let depth = 0; depth < 32 * 8; depth++) {
 		if (fileSystem.exists(path.join(current, "pnpm-workspace.yaml"))) return current;
 		const manifest = readJson(fileSystem, path.join(current, "package.json"));
 		if (manifest?.workspaces !== void 0 && manifest.workspaces !== null) return current;
+		if (ceiling !== void 0 && current === ceiling) return null;
 		const parent = path.dirname(current);
 		if (parent === current) return null;
 		current = parent;