@effected/workspaces 0.28.0-next-20260927071821 → 0.29.0

package/internal/configDependencyFetch.js

@@ -1,10 +1,11 @@
 import { carries, manifestVersion, messageOf, sideLabel } from "./configDependencyShared.js";
 import { splitConfigDependencySpec } from "./configDependencySpecGrammar.js";
-import { Duration, Effect } from "effect";
+import { Duration, Effect, Predicate } from "effect";
 import { IntegrityHash } from "@effected/npm";
+import { Yaml } from "@effected/yaml";
 import { Run } from "@effected/commands";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { copyFile, mkdtemp, readFile, realpath, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
 
@@ -47,12 +48,36 @@ const expectedIntegrity = (request) => Effect.gen(function* () {
 	if (integrity === void 0) return yield* Effect.fail(fetchFailure("integrityUnavailable", `config dependency ${key} must be fetched, but ${sideLabel(side)} records no integrity for it (no inline integrity in pnpm-workspace.yaml and no pnpm-lock.yaml entry for that version), so a fetched copy could not be verified and nothing was fetched.`));
 	return integrity;
 });
+/** The {@link RegistrySettings} of a parsed `pnpm-workspace.yaml` document. */
+const registrySettingsOf = (document) => {
+	if (!Predicate.isObject(document)) return { registries: {} };
+	const registries = {};
+	if (Predicate.isObject(document.registries)) {
+		for (const [scope, url] of Object.entries(document.registries)) if (typeof url === "string") registries[scope] = url;
+	}
+	return typeof document.registry === "string" ? {
+		registry: document.registry,
+		registries
+	} : { registries };
+};
 /**
-* The scratch workspace's `pnpm-workspace.yaml`. Every scalar is a
+* The scratch workspace's `pnpm-workspace.yaml`: the one config dependency,
+* plus the declaring workspace's registry settings. Every key and scalar is a
 * JSON-quoted string, which YAML reads verbatim, so no declared text can
 * change the document's structure.
 */
-const scratchWorkspaceYaml = (name, version) => `configDependencies:\n  ${JSON.stringify(name)}: ${JSON.stringify(version)}\n`;
+const scratchWorkspaceYaml = (name, version, settings = { registries: {} }) => {
+	const lines = ["configDependencies:", `  ${JSON.stringify(name)}: ${JSON.stringify(version)}`];
+	if (settings.registry !== void 0) lines.push(`registry: ${JSON.stringify(settings.registry)}`);
+	const scopes = Object.entries(settings.registries);
+	if (scopes.length > 0) {
+		lines.push("registries:");
+		for (const [scope, url] of scopes) lines.push(`  ${JSON.stringify(scope)}: ${JSON.stringify(url)}`);
+	}
+	return `${lines.join("\n")}\n`;
+};
+/** Whether `error` is a node filesystem "no such file" failure. */
+const isNotFound = (error) => Predicate.isObject(error) && error.code === "ENOENT";
 /**
 * The scratch workspace's `pnpm-lock.yaml`: the env preamble pnpm 11 and 12
 * write for a lone config dependency, pinned to `integrity`, followed by the
@@ -123,14 +148,22 @@ const makeFetchConfigDependency = (spawner) => (request) => Effect.scoped(Effect
 		catch: (cause) => failed(`${what} failed: ${messageOf(cause)}`, cause)
 	});
 	const integrity = yield* expectedIntegrity(request);
+	const rootYaml = yield* io("reading the workspace pnpm-workspace.yaml", () => readFile(join(request.root, "pnpm-workspace.yaml"), "utf8").catch((error) => {
+		if (isNotFound(error)) return void 0;
+		throw error;
+	}));
+	const settings = rootYaml === void 0 ? registrySettingsOf(void 0) : registrySettingsOf(yield* Yaml.parse(rootYaml).pipe(Effect.mapError((cause) => failed(`reading the workspace pnpm-workspace.yaml failed: ${messageOf(cause)}`, cause))));
 	const scratch = yield* Effect.acquireRelease(io("creating a scratch workspace", () => mkdtemp(join(tmpdir(), "effected-config-dependency-"))), (dir) => Effect.promise(() => rm(dir, {
 		recursive: true,
 		force: true
 	}).catch(() => void 0)));
 	const lockfile = scratchLockfile(name, version, integrity);
 	yield* io("writing the scratch workspace", async () => {
-		await writeFile(join(scratch, "pnpm-workspace.yaml"), scratchWorkspaceYaml(name, version));
+		await writeFile(join(scratch, "pnpm-workspace.yaml"), scratchWorkspaceYaml(name, version, settings));
 		await writeFile(join(scratch, "pnpm-lock.yaml"), lockfile);
+		await copyFile(join(request.root, ".npmrc"), join(scratch, ".npmrc")).catch((error) => {
+			if (!isNotFound(error)) throw error;
+		});
 	});
 	const command = ChildProcess.make("pnpm", fetchArgs(scratch, request.stores), { cwd: scratch });
 	yield* Run.text(command, { timeout: FETCH_TIMEOUT }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.mapError((cause) => failed(`fetching ${key} with \`pnpm ${fetchArgs("<scratch>", request.stores).join(" ")}\` failed: ${messageOf(cause)}`, cause)));
@@ -143,4 +176,4 @@ const makeFetchConfigDependency = (spawner) => (request) => Effect.scoped(Effect
 }));
 
 //#endregion
-export { expectedIntegrity, fetchArgs, makeFetchConfigDependency, storeDirArgument };
+export { expectedIntegrity, fetchArgs, makeFetchConfigDependency, registrySettingsOf, scratchWorkspaceYaml, storeDirArgument };

package/internal/configDependencyResolution.js

@@ -266,6 +266,7 @@ const resolveDirectory = (root, entry, stores, locks, options) => Effect.gen(fun
 	if (options.fetch === void 0) return yield* Effect.fail(notInstalled(Option.none()));
 	return {
 		dir: yield* options.fetch({
+			root,
 			name,
 			version: declared,
 			spec: entry.spec,

package/internal/layerRoot.js

@@ -0,0 +1,14 @@
+import { Effect } from "effect";
+
+//#region src/internal/layerRoot.ts
+/**
+* Resolve the workspace root a layer's options name. `Effect.suspend` so the
+* ambient `process.cwd()` is read at first use, not at layer construction.
+*/
+const findLayerRoot = (roots, options) => Effect.suspend(() => {
+	const stopAt = options?.stopAt;
+	return roots.find(options?.cwd ?? process.cwd(), stopAt === void 0 ? void 0 : { stopAt });
+});
+
+//#endregion
+export { findLayerRoot };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/workspaces",
-	"version": "0.28.0-next-20260927071821",
+	"version": "0.29.0",
 	"private": false,
 	"description": "Monorepo workspace tooling as Effect services — root discovery, package enumeration, the dependency graph, package-manager detection, pnpm catalog resolution, lockfile IO and git-based change detection.",
 	"keywords": [
@@ -55,9 +55,9 @@
 		"@effected/git": "^0.17.0",
 		"@effected/glob": "^0.8.0",
 		"@effected/jsonc": "^0.13.0",
-		"@effected/lockfiles": "^0.12.0-next-20260927071821",
-		"@effected/npm": "^0.17.0-next-20260927071821",
-		"@effected/package-json": "^0.18.0-next-20260927071821",
+		"@effected/lockfiles": "^0.13.0",
+		"@effected/npm": "^0.18.0",
+		"@effected/package-json": "^0.18.1",
 		"@effected/semver": "^0.9.0",
 		"@effected/walker": "^0.12.0",
 		"@effected/yaml": "^0.17.0",

package/testing.d.ts

@@ -652,6 +652,11 @@ interface WorkspaceDiscoveryOptions {
    * directory the caller names, which a single layer-level ceiling cannot
    * sensibly bound, so they ascend unbounded as before.
    *
+   * `LockfileReader`, `WorkspaceCatalogs` and `WorkspaceSnapshots` each
+   * take the same option; give them the same
+   * value when wiring by hand, or let a `Workspaces.*` composite forward one
+   * `stopAt` to all of them, so no service adopts a root another refused.
+   *
    * @defaultValue no ceiling — the ascent runs to the filesystem root.
    */
   readonly stopAt?: string | undefined;