@effected/workspaces 0.7.0 → 0.9.0

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/WorkspaceCatalogs.js

@@ -283,6 +283,8 @@ const validatePnpmWorkspaceCatalogs = (document) => {
 		catalogs: "catalogs"
 	}));
 };
+/** A defect naming the unstubbed test-double method — a test-wiring mistake, not a typed failure. */
+const unstubbed = (method) => Effect.die(/* @__PURE__ */ new Error(`WorkspaceCatalogs.makeTest: ${method}() was called but not stubbed — pass a \`${method}\` override.`));
 /**
 * Assembles a workspace's catalogs, package-manager-aware.
 *
@@ -426,6 +428,70 @@ var WorkspaceCatalogs = class WorkspaceCatalogs extends Context.Service()("@effe
 	*/
 	static layerWithConfigDependencies = (options) => Layer.effect(WorkspaceCatalogs, WorkspaceCatalogs.make(options)).pipe(Layer.provide(ConfigDependencyHooks.layerLive));
 	/**
+	* A test double satisfying the full {@link WorkspaceCatalogsShape} with no
+	* filesystem, lockfile read, or hook replay.
+	*
+	* @remarks
+	* There is **no honest default catalog set**: an empty `CatalogSet` that
+	* looks like a legitimate answer is the "every dependency looks newly added"
+	* failure class the live assembler hard-fails to prevent, so every method
+	* **dies** with an instructive defect until stubbed — a test-wiring mistake
+	* fails loudly as a defect rather than succeeding with a lie or failing with
+	* a dishonest typed error.
+	*
+	* The one derivation mirrors `WorkspaceDiscovery.makeTest`'s
+	* derived-from-the-primary rule: when a `set` override is supplied,
+	* `resolveSpecifier` answers from that `CatalogSet`'s own
+	* {@link CatalogSet.resolveSpecifier} — exactly what the live service runs
+	* over its assembled set — so the two stay consistent by construction.
+	* `releaseAgeGate` and `importerVersions` are **not** derivable from a
+	* catalog set (the gate comes from release-age keys and hook contributions,
+	* the importer index from the lockfile's importer blocks — neither is in a
+	* `CatalogSet`) and always die unless stubbed.
+	*
+	* @example
+	* ```ts
+	* import { CatalogSet, WorkspaceCatalogs } from "@effected/workspaces";
+	* import { Effect } from "effect";
+	*
+	* const double = WorkspaceCatalogs.makeTest({
+	*   set: () => Effect.succeed(CatalogSet.fromCatalogs({ default: { effect: "4.0.0" } })),
+	* });
+	* // `resolveSpecifier` now answers consistently from that set.
+	* ```
+	*/
+	static makeTest = (overrides = {}) => {
+		const set = overrides.set;
+		return {
+			set: () => unstubbed("set"),
+			resolveSpecifier: set !== void 0 ? (dependency, specifier) => Effect.map(set(), (catalogs) => catalogs.resolveSpecifier(dependency, specifier)) : () => unstubbed("resolveSpecifier"),
+			releaseAgeGate: () => unstubbed("releaseAgeGate"),
+			importerVersions: () => unstubbed("importerVersions"),
+			...overrides
+		};
+	};
+	/**
+	* The test layer: {@link WorkspaceCatalogs.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 { CatalogSet, WorkspaceCatalogs } from "@effected/workspaces";
+	* import { Effect } from "effect";
+	*
+	* const TestCatalogs = WorkspaceCatalogs.layerTest({
+	*   set: () => Effect.succeed(CatalogSet.empty()),
+	* });
+	* // program.pipe(Effect.provide(TestCatalogs))
+	* ```
+	*/
+	static layerTest = (overrides = {}) => Layer.succeed(WorkspaceCatalogs, WorkspaceCatalogs.makeTest(overrides));
+	/**
 	* The real implementation of `@effected/npm`'s `CatalogResolver` contract —
 	* the one `@effected/package-json` declares but cannot fill.
 	*

package/Workspaces.js

@@ -3,183 +3,250 @@ import { WorkspaceDiscovery } from "./WorkspaceDiscovery.js";
 import { ChangeDetector } from "./ChangeDetector.js";
 import { PackageManagerDetector } from "./PackageManagerName.js";
 import { LockfileReader } from "./LockfileReader.js";
-import { PublishabilityDetector } from "./Publishability.js";
 import { WorkspaceCatalogs } from "./WorkspaceCatalogs.js";
 import { WorkspaceSnapshots } from "./WorkspaceSnapshots.js";
 import { Git } from "@effected/git";
-import { Effect, Layer } from "effect";
+import { Effect, Layer, Option } from "effect";
+import { ExecContext, LocalExec, LocalExecError } from "@effected/commands";
 
 //#region src/Workspaces.ts
-/**
-* Every service that needs only a filesystem: root, package-manager detection,
-* discovery, lockfile reading, catalogs and publishability.
-*
-* @remarks
-* Requires core `FileSystem` and `Path`, which the consumer provides at the
-* edge (`@effect/platform-node`, `@effect/platform-bun`, or a test's
-* `FileSystem.layerNoop`).
-*
-* **Bind the result to a `const`.** This is a parameterized factory and layers
-* memoize by reference, so calling it twice builds everything twice.
-*
-* @example
-* ```ts
-* import { Workspaces } from "@effected/workspaces";
-* import { Layer } from "effect";
-*
-* const WorkspacesLayer = Workspaces.layer();
-* const AppLayer = Layer.provide(WorkspacesLayer, PlatformLayer);
-* ```
-*
-* @public
-*/
 const compose = (options, catalogsFactory) => {
 	const roots = WorkspaceRoot.layer;
 	const detector = PackageManagerDetector.layer;
 	const discovery = WorkspaceDiscovery.layer(options).pipe(Layer.provide(roots));
 	const lockfiles = LockfileReader.layer(options).pipe(Layer.provide(roots), Layer.provide(detector), Layer.provide(discovery));
 	const catalogs = catalogsFactory(options).pipe(Layer.provide(roots), Layer.provide(lockfiles));
-	return Layer.mergeAll(roots, detector, discovery, lockfiles, catalogs, PublishabilityDetector.layer);
+	return Layer.mergeAll(roots, detector, discovery, lockfiles, catalogs);
 };
 const layer = (options) => compose(options, WorkspaceCatalogs.layer);
-/**
-* The git-free composite plus {@link ChangeDetector} and
-* {@link WorkspaceSnapshots}, over `@effected/git`'s `Git` service.
-*
-* @remarks
-* The extra requirement is core's `ChildProcessSpawner` (behind `Git`), which
-* is why it is a separate layer rather than a flag: a consumer that never
-* detects changes or reads at a ref should not have to be able to spawn a
-* subprocess. The consumer provides `ChildProcessSpawner` once at the edge
-* (`@effect/platform-node`'s `NodeServices.layer`); a test provides
-* `Layer.succeed(Git, …)` and needs no repository on disk.
-*
-* @public
-*/
 const layerWithGit = (options) => {
 	const core = layer(options);
 	const git = Git.layer;
 	return Layer.mergeAll(core, git, ChangeDetector.layer.pipe(Layer.provide(git), Layer.provide(core)), WorkspaceSnapshots.layer(options).pipe(Layer.provide(git), Layer.provide(core)));
 };
-/**
-* The two `@effected/npm` resolver contracts, implemented for real.
-*
-* @remarks
-* Provide this alongside `@effected/package-json`'s `Package.resolve` and a
-* manifest's `catalog:` and `workspace:` specifiers resolve against the actual
-* workspace instead of the no-op layers' `Option.none()`.
-*
-* @example
-* ```ts
-* import { Package } from "@effected/package-json";
-* import { Workspaces } from "@effected/workspaces";
-* import { Layer } from "effect";
-*
-* const WorkspacesLayer = Workspaces.layer();
-* const Resolvers = Workspaces.resolvers.pipe(Layer.provide(WorkspacesLayer));
-* ```
-*
-* @public
-*/
 const resolvers = Layer.mergeAll(WorkspaceCatalogs.catalogResolver, WorkspaceDiscovery.workspaceResolver);
-/**
-* The git-free composite, but with catalog assembly that **replays config
-* dependency `pnpmfile.cjs` hooks** — {@link WorkspaceCatalogs.layerWithConfigDependencies}
-* in place of the default no-op catalogs layer.
-*
-* @remarks
-* Identical requirement set to {@link Workspaces.layer}; the only difference is
-* that config-dependency code is executed in process. Opt in deliberately — the
-* default {@link Workspaces.layer} never executes config-dependency code.
-*
-* **Bind the result to a `const`.**
-*
-* @public
-*/
 const layerWithConfigDependencies = (options) => compose(options, WorkspaceCatalogs.layerWithConfigDependencies);
-/**
-* The one-call resolver factory: {@link Workspaces.resolvers} pre-wired over
-* {@link Workspaces.layerWithConfigDependencies}, so the two `@effected/npm`
-* contracts (`CatalogResolver`, `WorkspaceResolver`) need only a platform
-* (`FileSystem` + `Path`) from the consumer.
-*
-* @remarks
-* This is deliberately a **parameterized layer function, and the fresh layer
-* per call is the feature**: layers memoize by reference, so each call mints
-* an unmemoized layer whose root discovery re-runs — including a per-call
-* `process.cwd()` read when `options.cwd` is omitted. A build tool that
-* changes directory between manifests gets a correct re-discovery each time
-* precisely because nothing is shared across calls. When you *want* sharing,
-* bind one call's result to a `const` and provide that; the memoization rule
-* is unchanged, this factory just refuses to hide it.
-*
-* Catalog assembly replays config-dependency `pnpmfile` hooks (the
-* `layerWithConfigDependencies` path) — the semantics a real pnpm install
-* has. Compose {@link Workspaces.resolvers} with {@link Workspaces.layer}
-* yourself if config-dependency code must not run in process.
-*
-* @example
-* ```ts
-* import { Workspaces } from "@effected/workspaces";
-* import { Effect } from "effect";
-*
-* const program = doSomethingWithResolvers.pipe(
-*   Effect.provide(Workspaces.resolverLayer()),
-* );
-* ```
-*
-* @public
-*/
 const resolverLayer = (options) => resolvers.pipe(Layer.provide(layerWithConfigDependencies(options)));
-/**
-* Resolve every `catalog:` and `workspace:` specifier in one `Manifest`
-* against the real workspace, in one call — the 90% path. Decode stays at the
-* consumer's edge: build the `Manifest` with `Manifest.decode` (from
-* `@effected/npm`), hand it here, and get a new `Manifest` back with concrete
-* ranges; `toRecord()` returns to the wire shape.
-*
-* @remarks
-* Composes `manifest.resolve()` with a fresh {@link Workspaces.resolverLayer}
-* per call, so the workspace root is re-discovered from `options.cwd` (or the
-* current `process.cwd()`) on every invocation. Consumers processing many
-* manifests should check `manifest.needsResolution` first and skip the call
-* entirely when no dependency field carries a `catalog:`/`workspace:`
-* specifier — that predicate is pure and avoids catalog assembly altogether.
-*
-* A specifier the workspace cannot answer fails typed as
-* `UnresolvedDependencyError`; assembly and mechanism failures surface as
-* `CatalogAssemblyError` / `DependencyResolutionError`.
-*
-* @example
-* ```ts
-* import { Manifest } from "@effected/npm";
-* import { Workspaces } from "@effected/workspaces";
-* import { Effect } from "effect";
-*
-* const program = Effect.gen(function* () {
-*   const manifest = yield* Manifest.decode({ dependencies: { effect: "catalog:" } });
-*   const resolved = manifest.needsResolution ? yield* Workspaces.resolveManifest(manifest) : manifest;
-*   return resolved.toRecord();
-* });
-* ```
-*
-* @public
-*/
 const resolveManifest = Effect.fn("Workspaces.resolveManifest")(function* (manifest, options) {
 	return yield* manifest.resolve().pipe(Effect.provide(resolverLayer(options)));
 });
+const localExecLayer = (options) => Layer.effect(LocalExec, Effect.gen(function* () {
+	const roots = yield* WorkspaceRoot;
+	const detector = yield* PackageManagerDetector;
+	return { context: Effect.gen(function* () {
+		const cwd = options?.cwd ?? globalThis.process?.cwd?.() ?? "/";
+		const root = yield* roots.find(cwd).pipe(Effect.asSome, Effect.orElseSucceed(Option.none));
+		if (Option.isNone(root)) return Option.none();
+		const detected = yield* detector.detect(root.value).pipe(Effect.asSome, Effect.catchTag("PackageManagerDetectionError", () => Effect.succeed(Option.none())), Effect.mapError((cause) => new LocalExecError({
+			directory: root.value,
+			cause
+		})));
+		if (Option.isNone(detected)) return Option.none();
+		const { prefix, dlxPrefix } = LocalExec.prefixes(detected.value.name);
+		return Option.some(ExecContext.make({
+			label: detected.value.name,
+			prefix,
+			dlxPrefix,
+			directory: root.value
+		}));
+	}) };
+}));
 /**
 * The composite layers.
 *
 * @public
 */
-const Workspaces = {
-	layer,
-	layerWithConfigDependencies,
-	layerWithGit,
-	resolveManifest,
-	resolverLayer,
-	resolvers
+var Workspaces = class {
+	constructor() {}
+	/**
+	* Every service that needs only a filesystem: root, package-manager
+	* detection, discovery, lockfile reading, catalogs and publishability.
+	*
+	* @remarks
+	* Requires core `FileSystem` and `Path`, which the consumer provides at the
+	* edge (`@effect/platform-node`, `@effect/platform-bun`, or a test's
+	* `FileSystem.layerNoop`).
+	*
+	* **Bind the result to a `const`.** This is a parameterized factory and
+	* layers memoize by reference, so calling it twice builds everything twice.
+	*
+	* @example
+	* ```ts
+	* import { Workspaces } from "@effected/workspaces";
+	* import { Layer } from "effect";
+	*
+	* const WorkspacesLayer = Workspaces.layer();
+	* const AppLayer = Layer.provide(WorkspacesLayer, PlatformLayer);
+	* ```
+	*/
+	static layer = layer;
+	/**
+	* The git-free composite, but with catalog assembly that **replays config
+	* dependency `pnpmfile.cjs` hooks** —
+	* {@link WorkspaceCatalogs.layerWithConfigDependencies} in place of the
+	* default no-op catalogs layer.
+	*
+	* @remarks
+	* Identical requirement set to {@link Workspaces.layer}; the only
+	* difference is that config-dependency code is executed in process. Opt in
+	* deliberately — the default {@link Workspaces.layer} never executes
+	* config-dependency code.
+	*
+	* **Bind the result to a `const`.**
+	*/
+	static layerWithConfigDependencies = layerWithConfigDependencies;
+	/**
+	* The git-free composite plus {@link ChangeDetector} and
+	* {@link WorkspaceSnapshots}, over `@effected/git`'s `Git` service.
+	*
+	* @remarks
+	* The extra requirement is core's `ChildProcessSpawner` (behind `Git`),
+	* which is why it is a separate layer rather than a flag: a consumer that
+	* never detects changes or reads at a ref should not have to be able to
+	* spawn a subprocess. The consumer provides `ChildProcessSpawner` once at
+	* the edge (`@effect/platform-node`'s `NodeServices.layer`); a test
+	* provides `Layer.succeed(Git, …)` and needs no repository on disk.
+	*/
+	static layerWithGit = layerWithGit;
+	/**
+	* This package's implementation of `@effected/commands`' `LocalExec`
+	* contract: how to run a project-local binary here.
+	*
+	* @remarks
+	* **An inverted contract, the `@effected/npm` `CatalogResolver`
+	* precedent.** Tool discovery needs package-manager detection and
+	* workspace-root resolution, both of which live here — but a direct edge
+	* from `@effected/commands` to this package would make that boundary-tier
+	* package integrated, and through the planned `npm` → `commands` edge
+	* would drag `npm`, `lockfiles` (pure!) and `package-json` up a tier with
+	* it. So `commands` declares the narrow contract and we ship the layer.
+	*
+	* **The argv knowledge is not duplicated.** `LocalExec.prefixes(name)` is
+	* the one home of the four managers' `exec`/`dlx` prefixes; this layer
+	* detects *which* manager owns the directory and asks `commands` what that
+	* manager's argv looks like. Neither package reimplements the other's
+	* half.
+	*
+	* **`None` is success.** Outside any workspace — and inside one whose
+	* manager cannot be identified — the answer is `Option.none()`: "there is
+	* no project-local way to run tools here" is an ordinary fact, not an
+	* exceptional one, and a consumer running in a bare directory should not
+	* have to catch an error to learn it. The contract's typed
+	* `LocalExecError` is reserved for **mechanism** failure — a manifest that
+	* exists but cannot be read or parsed, which means something is broken
+	* rather than absent. That is npm's resolver convention, adopted
+	* verbatim.
+	*
+	* `directory` is the resolved **workspace root**, not the caller's cwd: a
+	* project-local launcher has to run where the workspace is.
+	*
+	* A consumer with no monorepo never needs this layer, and therefore never
+	* installs this package — `LocalExec.layerNone` and `LocalExec.layerFor`
+	* are one-liners in `@effected/commands`.
+	*
+	* **Bind the result to a `const`** — a parameterized layer factory mints a
+	* fresh reference per call and layers memoize by reference.
+	*
+	* @example
+	* ```ts
+	* import { ToolDiscovery } from "@effected/commands";
+	* import { Workspaces } from "@effected/workspaces";
+	* import { Layer } from "effect";
+	*
+	* const AppLayer = ToolDiscovery.layer.pipe(
+	*   Layer.provide(Workspaces.localExecLayer()),
+	*   Layer.provide(Workspaces.layer()),
+	*   Layer.provide(NodeServices.layer),
+	* );
+	* ```
+	*/
+	static localExecLayer = localExecLayer;
+	/**
+	* Resolve every `catalog:` and `workspace:` specifier in one `Manifest`
+	* against the real workspace, in one call — the 90% path. Decode stays at
+	* the consumer's edge: build the `Manifest` with `Manifest.decode` (from
+	* `@effected/npm`), hand it here, and get a new `Manifest` back with
+	* concrete ranges; `toRecord()` returns to the wire shape.
+	*
+	* @remarks
+	* Composes `manifest.resolve()` with a fresh {@link Workspaces.resolverLayer}
+	* per call, so the workspace root is re-discovered from `options.cwd` (or
+	* the current `process.cwd()`) on every invocation. Consumers processing
+	* many manifests should check `manifest.needsResolution` first and skip
+	* the call entirely when no dependency field carries a
+	* `catalog:`/`workspace:` specifier — that predicate is pure and avoids
+	* catalog assembly altogether.
+	*
+	* A specifier the workspace cannot answer fails typed as
+	* `UnresolvedDependencyError`; assembly and mechanism failures surface as
+	* `CatalogAssemblyError` / `DependencyResolutionError`.
+	*
+	* @example
+	* ```ts
+	* import { Manifest } from "@effected/npm";
+	* import { Workspaces } from "@effected/workspaces";
+	* import { Effect } from "effect";
+	*
+	* const program = Effect.gen(function* () {
+	*   const manifest = yield* Manifest.decode({ dependencies: { effect: "catalog:" } });
+	*   const resolved = manifest.needsResolution ? yield* Workspaces.resolveManifest(manifest) : manifest;
+	*   return resolved.toRecord();
+	* });
+	* ```
+	*/
+	static resolveManifest = resolveManifest;
+	/**
+	* The one-call resolver factory: {@link Workspaces.resolvers} pre-wired
+	* over {@link Workspaces.layerWithConfigDependencies}, so the two
+	* `@effected/npm` contracts (`CatalogResolver`, `WorkspaceResolver`) need
+	* only a platform (`FileSystem` + `Path`) from the consumer.
+	*
+	* @remarks
+	* This is deliberately a **parameterized layer function, and the fresh
+	* layer per call is the feature**: layers memoize by reference, so each
+	* call mints an unmemoized layer whose root discovery re-runs — including
+	* a per-call `process.cwd()` read when `options.cwd` is omitted. A build
+	* tool that changes directory between manifests gets a correct
+	* re-discovery each time precisely because nothing is shared across
+	* calls. When you *want* sharing, bind one call's result to a `const` and
+	* provide that; the memoization rule is unchanged, this factory just
+	* refuses to hide it.
+	*
+	* Catalog assembly replays config-dependency `pnpmfile` hooks (the
+	* `layerWithConfigDependencies` path) — the semantics a real pnpm install
+	* has. Compose {@link Workspaces.resolvers} with {@link Workspaces.layer}
+	* yourself if config-dependency code must not run in process.
+	*
+	* @example
+	* ```ts
+	* import { Workspaces } from "@effected/workspaces";
+	* import { Effect } from "effect";
+	*
+	* const program = doSomethingWithResolvers.pipe(
+	*   Effect.provide(Workspaces.resolverLayer()),
+	* );
+	* ```
+	*/
+	static resolverLayer = resolverLayer;
+	/**
+	* The two `@effected/npm` resolver contracts, implemented for real.
+	*
+	* @remarks
+	* Provide this alongside `@effected/package-json`'s `Package.resolve` and
+	* a manifest's `catalog:` and `workspace:` specifiers resolve against the
+	* actual workspace instead of the no-op layers' `Option.none()`.
+	*
+	* @example
+	* ```ts
+	* import { Package } from "@effected/package-json";
+	* import { Workspaces } from "@effected/workspaces";
+	* import { Layer } from "effect";
+	*
+	* const WorkspacesLayer = Workspaces.layer();
+	* const Resolvers = Workspaces.resolvers.pipe(Layer.provide(WorkspacesLayer));
+	* ```
+	*/
+	static resolvers = resolvers;
 };
 
 //#endregion