@effected/workspaces 0.1.0 → 0.2.0

package/ChangeDetector.js

@@ -1,7 +1,7 @@
 import { WorkspaceDiscovery } from "./WorkspaceDiscovery.js";
 import { DependencyGraph } from "./DependencyGraph.js";
-import { Context, Effect, Layer, Schema } from "effect";
 import { Git } from "@effected/git";
+import { Context, Effect, Layer, Schema } from "effect";
 
 //#region src/ChangeDetector.ts
 /**

package/ConfigDependencyHooks.js

@@ -1,6 +1,6 @@
-import { CatalogAssemblyError } from "./CatalogAssemblyError.js";
 import { normalize } from "./internal/catalogs.js";
 import { Context, Effect, Layer, Predicate, Result } from "effect";
+import { CatalogAssemblyError } from "@effected/npm";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 
@@ -95,7 +95,7 @@ var ConfigDependencyHooks = class ConfigDependencyHooks extends Context.Service(
 	* (in process, no subprocess) and replays its `updateConfig` hook over the
 	* seed, in declaration order. A dependency without a `pnpmfile.cjs` contributes
 	* nothing; a dependency whose file fails to load or replay fails typed with a
-	* `hooks`-source {@link CatalogAssemblyError}, never a silent skip.
+	* `hooks`-source `CatalogAssemblyError`, never a silent skip.
 	*
 	* @remarks
 	* Node-coupled by design — the `node:fs` / `node:path` / `node:url` imports are

package/README.md

@@ -110,20 +110,52 @@ const Resolvers = Workspaces.resolvers.pipe(Layer.provide(WorkspacesLayer));
 // Layer<CatalogResolver | WorkspaceResolver, never, FileSystem | Path>
 ```
 
+`Workspaces.resolverLayer(options?)` is that wiring in one call: the two contracts over a full workspace stack, needing only `FileSystem` and `Path` from you. A fresh layer per call is the point — root discovery re-runs each time, including the `process.cwd()` read when `options.cwd` is omitted, so a build tool that changes directory between manifests stays correct. It wires the config-dependency replay path; compose `Workspaces.resolvers` with `Workspaces.layer` yourself if config-dependency code must not run.
+
+For whole manifests, `Workspaces.resolveManifest` is the one-shot path over `@effected/npm`'s tolerant `Manifest` model:
+
+```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();
+});
+// needsResolution is pure — checking it first skips catalog assembly entirely
+// when no dependency field carries a catalog: or workspace: specifier
+```
+
+A specifier the workspace cannot answer fails typed as `UnresolvedDependencyError`: at the manifest level "no catalog entry" means the manifest cannot be projected to concrete ranges.
+
 ## The synchronous escape hatch
 
-Vitest's config-time project discovery cannot await. Two functions exist for exactly that case, and they are **Node-only and synchronous**:
+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:
 
 ```ts
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import * as path from "node:path";
 import { findWorkspaceRootSync, getWorkspacePackagesSync } from "@effected/workspaces";
 
-const root = findWorkspaceRootSync();
-const packages = root === null ? [] : getWorkspacePackagesSync(root);
+const options = {
+  fileSystem: {
+    exists: existsSync,
+    readFile: (p: string) => readFileSync(p, "utf8"),
+    readDirectory: (p: string) => readdirSync(p),
+    isDirectory: (p: string) => statSync(p).isDirectory(),
+  },
+  path, // node:path satisfies SyncPath verbatim
+};
+
+const root = findWorkspaceRootSync(options);
+const packages = root === null ? [] : getWorkspacePackagesSync(root, options);
 // 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 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 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.
 
 ## Error handling
 
@@ -144,21 +176,22 @@ const program = Effect.gen(function* () {
 );
 ```
 
-`WorkspaceRootNotFoundError`, `WorkspaceDiscoveryError`, `WorkspacePatternError`, `PackageNotFoundError`, `WorkspaceManifestError`, `PackageManagerDetectionError`, `CatalogAssemblyError`, `LockfileReadError`, `CyclicDependencyError` and `ChangeDetectionError` each name one thing that can actually go wrong, and each method's error channel is narrowed to the ones it can produce. Change detection additionally surfaces `@effected/git`'s typed git errors, such as `NotARepositoryError`.
+`WorkspaceRootNotFoundError`, `WorkspaceDiscoveryError`, `WorkspacePatternError`, `PackageNotFoundError`, `WorkspaceManifestError`, `PackageManagerDetectionError`, `CatalogAssemblyError`, `LockfileReadError`, `CyclicDependencyError` and `ChangeDetectionError` each name one thing that can actually go wrong, and each method's error channel is narrowed to the ones it can produce. `CatalogAssemblyError` is defined in `@effected/npm`, beside the resolver contract that names it in its channel — import it from there. Change detection additionally surfaces `@effected/git`'s typed git errors, such as `NotARepositoryError`.
 
 ## Features
 
 - `Workspaces.layer` / `Workspaces.layerWithGit` / `Workspaces.resolvers` — the composite layers, split on requirements rather than feature flags: a filesystem, a filesystem plus a subprocess, and the two `@effected/npm` resolver contracts.
+- `Workspaces.resolverLayer` / `Workspaces.resolveManifest` — the one-call manifest-resolution path: a fresh, unmemoized layer per call so root discovery follows your cwd, and one-shot resolution of a whole `Manifest` against the real workspace.
 - `WorkspaceRoot` — root discovery from a `cwd`, over `WORKSPACE_MARKERS`.
 - `WorkspaceDiscovery` — package enumeration with a bounded descent for segment-crossing `packages/**` patterns, plus per-package lookup.
-- `WorkspacePackage` — a deliberately tolerant manifest model, so one member with an odd version cannot fail discovery for the whole repo. `WorkspacePackage.manifest(pkg)` is the opt-in bridge to `@effected/package-json`'s strict `Package`.
+- `WorkspacePackage` — a deliberately tolerant manifest model, so one member with an odd version cannot fail discovery for the whole repo. `manifestRecord` keeps the as-read `package.json` for tolerant access to fields outside the typed slice without a second read; `WorkspacePackage.manifest(pkg)` re-reads and is the opt-in bridge to `@effected/package-json`'s strict `Package`.
 - `DependencyGraph` — a value class over discovered packages: `levels()` for parallel build tiers, the flattened topological order, and `CyclicDependencyError` when there isn't one.
 - `PackageManagerDetector` — npm, pnpm, yarn or bun from lockfiles and the `packageManager` field.
 - `WorkspaceCatalogs` — pnpm catalog assembly and `catalog:` resolution, on pnpm's own catalog packages.
 - `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.
-- `findWorkspaceRootSync` / `getWorkspacePackagesSync` — the Node-only synchronous escape hatch for config-time callers that cannot await.
+- `findWorkspaceRootSync` / `getWorkspacePackagesSync` — the synchronous escape hatch for config-time callers that cannot await, over file and path operations you supply.
 
 ## License
 

package/WorkspaceCatalogs.js

@@ -1,10 +1,9 @@
-import { CatalogAssemblyError } from "./CatalogAssemblyError.js";
 import { WorkspaceRoot } from "./WorkspaceRoot.js";
 import { inlineCatalogs, merge, normalize, rangeOf } from "./internal/catalogs.js";
 import { ConfigDependencyHooks } from "./ConfigDependencyHooks.js";
 import { LockfileReader } from "./LockfileReader.js";
 import { Context, Duration, Effect, Exit, FileSystem, Layer, Option, Path, PlatformError, Schema } from "effect";
-import { CatalogResolver, DependencyResolutionError } from "@effected/npm";
+import { CatalogAssemblyError, CatalogResolver, DependencyResolutionError } from "@effected/npm";
 import { Yaml } from "@effected/yaml";
 
 //#region src/WorkspaceCatalogs.ts
@@ -99,7 +98,7 @@ entries: Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.String
 	* load-bearing for: a present-but-malformed `workspaces` shape (a number, a
 	* string, an object with a malformed `packages` / `catalog` / `catalogs`), or
 	* the default catalog declared twice — once as `workspaces.catalog` and again
-	* as `workspaces.catalogs.default` — fails with {@link CatalogAssemblyError}
+	* as `workspaces.catalogs.default` — fails with `CatalogAssemblyError`
 	* naming what was wrong. An absent `workspaces` field, one explicitly `null`,
 	* or the plain array form (npm/yarn patterns, which carry no catalogs) yields
 	* the empty set. Presence is checked structurally, so an explicitly-declared
@@ -269,7 +268,7 @@ const validatePnpmWorkspaceCatalogs = (document) => {
 * within a catalog. An unreadable or absent lockfile degrades to no lockfile
 * catalogs rather than failing (the inline declaration is the source of truth, the
 * lockfile a record of what was installed); a malformed inline source **fails
-* typed** with {@link CatalogAssemblyError}, because a silently-empty catalog read
+* typed** with `CatalogAssemblyError`, because a silently-empty catalog read
 * is the "every dependency looks newly added" bug.
 *
 * Assembly is deferred to the first call and memoized success-only, matching
@@ -372,19 +371,22 @@ var WorkspaceCatalogs = class WorkspaceCatalogs extends Context.Service()("@effe
 	*
 	* @remarks
 	* `rangeOf` returns `Option.none()` for a dependency no catalog declares, per
-	* the contract's convention; `DependencyResolutionError` is reserved for a
-	* failure of the resolution *mechanism* — an unfindable workspace root, an
-	* unreadable or malformed `pnpm-workspace.yaml`.
+	* the contract's convention. A failed catalog *assembly* — an unreadable or
+	* malformed `pnpm-workspace.yaml`, a broken config-dependency hook — passes
+	* through **typed** as the contract's `CatalogAssemblyError` (it used to be
+	* folded into `DependencyResolutionError`'s defect `cause`, which forced
+	* consumers to `_tag`-sniff `unknown`); only the remaining mechanism failure,
+	* an unfindable workspace root, is wrapped as `DependencyResolutionError`.
 	*/
 	static catalogResolver = Layer.effect(CatalogResolver, Effect.gen(function* () {
 		const catalogs = yield* WorkspaceCatalogs;
-		return { rangeOf: (packageName, catalog) => catalogs.set().pipe(Effect.map((set) => set.rangeOf(packageName, catalog)), Effect.mapError((cause) => new DependencyResolutionError({
+		return { rangeOf: (packageName, catalog) => catalogs.set().pipe(Effect.map((set) => set.rangeOf(packageName, catalog)), Effect.catchTag("WorkspaceRootNotFoundError", (cause) => Effect.fail(new DependencyResolutionError({
 			specifier: Option.match(catalog, {
 				onNone: () => "catalog:",
 				onSome: (name) => `catalog:${name}`
 			}),
 			cause
-		}))) };
+		})))) };
 	}));
 };
 

package/WorkspaceDiscovery.js

@@ -184,6 +184,7 @@ var WorkspaceDiscovery = class WorkspaceDiscovery extends Context.Service()("@ef
 				path: directory,
 				packageJsonPath,
 				relativePath,
+				manifestRecord: raw,
 				...typeof raw.private === "boolean" ? { private: raw.private } : {},
 				...isStringRecord(raw.dependencies) ? { dependencies: raw.dependencies } : {},
 				...isStringRecord(raw.devDependencies) ? { devDependencies: raw.devDependencies } : {},

package/WorkspacePackage.js

@@ -5,6 +5,7 @@ import { Package } from "@effected/package-json";
 
 //#region src/WorkspacePackage.ts
 const EMPTY = Object.freeze(Object.create(null));
+const EMPTY_MANIFEST = Object.freeze(Object.create(null));
 /**
 * The `publishConfig` fields workspace tooling reads.
 *
@@ -100,7 +101,21 @@ var WorkspacePackage = class WorkspacePackage extends Schema.Class("WorkspacePac
 	/** Optional dependencies. */
 	optionalDependencies: DependencyMap,
 	/** The `publishConfig` block, when present. */
-	publishConfig: Schema.optionalKey(PublishConfig)
+	publishConfig: Schema.optionalKey(PublishConfig),
+	/**
+	* The package's `package.json` as read — tolerant access to every field
+	* outside the typed discovery slice (`scripts`, `exports`, …) without a
+	* second file read.
+	*
+	* @remarks
+	* Values are `unknown` and exactly what discovery parsed; nothing here is
+	* validated beyond being a record. For the strict typed model use
+	* `manifest()`, which deliberately **re-reads** the file — a point-in-time
+	* refresh this captured record cannot provide. Defaults to `{}` for
+	* construction sites and previously-serialized values that predate the
+	* field.
+	*/
+	manifestRecord: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.withDecodingDefaultKey(Effect.succeed(EMPTY_MANIFEST)), Schema.withConstructorDefault(Effect.succeed(EMPTY_MANIFEST)))
 }) {
 	/** Whether this is the workspace root package. */
 	get isRootWorkspace() {

package/WorkspaceStateSnapshot.js

@@ -140,6 +140,12 @@ var WorkspaceStateSnapshot = class extends Schema.Class("WorkspaceStateSnapshot"
 	* THIS snapshot's catalog set — so code written to the contract resolves
 	* `catalog:` specifiers as of this ref. Built once per instance and cached, so
 	* it memoizes by reference.
+	*
+	* @remarks
+	* The contract's error channel (`CatalogAssemblyError` /
+	* `DependencyResolutionError`) is satisfied vacuously: a snapshot's catalogs
+	* were already assembled when it was captured, so this resolver is total —
+	* `rangeOf` never fails.
 	*/
 	get catalogResolver() {
 		if (this.#catalogResolver === void 0) this.#catalogResolver = Layer.succeed(CatalogResolver, { rangeOf: (packageName, catalog) => Effect.succeed(this.catalogs.rangeOf(packageName, catalog)) });

package/Workspaces.js

@@ -6,8 +6,8 @@ import { LockfileReader } from "./LockfileReader.js";
 import { PublishabilityDetector } from "./Publishability.js";
 import { WorkspaceCatalogs } from "./WorkspaceCatalogs.js";
 import { WorkspaceSnapshots } from "./WorkspaceSnapshots.js";
-import { Layer } from "effect";
 import { Git } from "@effected/git";
+import { Effect, Layer } from "effect";
 
 //#region src/Workspaces.ts
 /**
@@ -98,6 +98,77 @@ const resolvers = Layer.mergeAll(WorkspaceCatalogs.catalogResolver, WorkspaceDis
 */
 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)));
+});
+/**
 * The composite layers.
 *
 * @public
@@ -106,6 +177,8 @@ const Workspaces = {
 	layer,
 	layerWithConfigDependencies,
 	layerWithGit,
+	resolveManifest,
+	resolverLayer,
 	resolvers
 };
 

package/WorkspacesSync.js

@@ -4,8 +4,6 @@ import { PublishConfig, WorkspacePackage } from "./WorkspacePackage.js";
 import { Effect, Exit, Schema } from "effect";
 import { GlobSet } from "@effected/glob";
 import { Yaml } from "@effected/yaml";
-import { dirname, join, resolve } from "node:path";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 
 //#region src/WorkspacesSync.ts
 /**
@@ -17,68 +15,84 @@ import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 * only on `undefined` sails straight into `raw.name` and throws a `TypeError`.
 * These functions are documented as total and are reached from a Vitest config,
 * which has nowhere to put a crash: malformed input must be *skipped*, never a
-* defect.
+* defect. A throwing consumer `readFile` lands in the same catch as a JSON
+* syntax error — an unusable manifest either way.
 */
-const readJson = (file) => {
+const readJson = (fileSystem, file) => {
 	let parsed;
 	try {
-		parsed = JSON.parse(readFileSync(file, "utf8"));
+		parsed = JSON.parse(fileSystem.readFile(file));
 	} catch {
 		return;
 	}
 	return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : void 0;
 };
-/** Whether `dir` is a directory. Never throws. */
-const isDirectory = (dir) => {
+/** Whether `dir` is a directory. Never throws — a throwing consumer op reads as `false`. */
+const isDirectory = (fileSystem, dir) => {
 	try {
-		return statSync(dir).isDirectory();
+		return fileSystem.isDirectory(dir);
 	} catch {
 		return false;
 	}
 };
 /** Whether `dir` holds a `package.json`. */
-const isPackage = (dir) => existsSync(join(dir, "package.json"));
+const isPackage = (options, dir) => options.fileSystem.exists(options.path.join(dir, "package.json"));
 /**
-* The nearest workspace root at or above `cwd`, or `null`.
+* The nearest workspace root at or above `options.cwd`, or `null`.
 *
 * @remarks
-* **Synchronous and Node-only.** The Effect surface is `WorkspaceRoot`; reach
-* for this one only where you genuinely cannot run an Effect — a Vitest config
-* being the motivating case.
+* **Synchronous.** The Effect surface is `WorkspaceRoot`; reach for this one
+* only where you genuinely cannot run an Effect — a Vitest config being the
+* motivating case. The file and path operations are the caller's
+* ({@link FindWorkspaceRootSyncOptions}); this module imports no `node:*` and
+* assumes no posix.
 *
 * Markers match the async service exactly: a `pnpm-workspace.yaml`, or a
 * `package.json` carrying a `workspaces` field.
 *
-* @param cwd - Where to start the ascent. Defaults to `process.cwd()`.
+* @param options - The consumer-supplied file and path operations, plus the
+*   optional `cwd` to start from (defaulting to `process.cwd()`).
 *
 * @example
 * ```ts
+* import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+* import * as path from "node:path";
 * import { findWorkspaceRootSync } from "@effected/workspaces";
 *
-* const root = findWorkspaceRootSync();
+* const root = findWorkspaceRootSync({
+* 	fileSystem: {
+* 		exists: existsSync,
+* 		readFile: (p) => readFileSync(p, "utf8"),
+* 		readDirectory: (p) => readdirSync(p),
+* 		isDirectory: (p) => statSync(p).isDirectory(),
+* 	},
+* 	path,
+* });
 * ```
 *
 * @public
 */
-const findWorkspaceRootSync = (cwd) => {
-	let current = resolve(cwd ?? process.cwd());
+const findWorkspaceRootSync = (options) => {
+	const { fileSystem, path } = options;
+	let current = path.resolve(options.cwd ?? process.cwd());
 	for (let depth = 0; depth < 32 * 8; depth++) {
-		if (existsSync(join(current, "pnpm-workspace.yaml"))) return current;
-		const manifest = readJson(join(current, "package.json"));
+		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;
-		const parent = dirname(current);
+		const parent = path.dirname(current);
 		if (parent === current) return null;
 		current = parent;
 	}
 	return null;
 };
 /** The workspace `packages:` patterns for `root`, matching `internal/patterns.ts`'s precedence. */
-const readPatternsSync = (root) => {
-	const workspaceYaml = join(root, "pnpm-workspace.yaml");
-	if (existsSync(workspaceYaml)) {
+const readPatternsSync = (options, root) => {
+	const { fileSystem, path } = options;
+	const workspaceYaml = path.join(root, "pnpm-workspace.yaml");
+	if (fileSystem.exists(workspaceYaml)) {
 		let text = "";
 		try {
-			text = readFileSync(workspaceYaml, "utf8");
+			text = fileSystem.readFile(workspaceYaml);
 		} catch {
 			text = "";
 		}
@@ -88,12 +102,12 @@ const readPatternsSync = (root) => {
 			if (patterns.length > 0) return patterns;
 		}
 	}
-	return manifestPatternsOf(readJson(join(root, "package.json")) ?? {});
+	return manifestPatternsOf(readJson(fileSystem, path.join(root, "package.json")) ?? {});
 };
 /** Build a `WorkspacePackage` from a directory, or `null` if its manifest is unusable. */
-const readPackageSync = (directory, relativePath) => {
-	const packageJsonPath = join(directory, "package.json");
-	const raw = readJson(packageJsonPath);
+const readPackageSync = (options, directory, relativePath) => {
+	const packageJsonPath = options.path.join(directory, "package.json");
+	const raw = readJson(options.fileSystem, packageJsonPath);
 	if (raw === void 0) return null;
 	const name = raw.name;
 	const version = raw.version;
@@ -113,6 +127,7 @@ const readPackageSync = (directory, relativePath) => {
 		devDependencies: stringRecord(raw.devDependencies) ?? {},
 		peerDependencies: stringRecord(raw.peerDependencies) ?? {},
 		optionalDependencies: stringRecord(raw.optionalDependencies) ?? {},
+		manifestRecord: raw,
 		...config !== void 0 && Exit.isSuccess(config) ? { publishConfig: config.value } : {}
 	});
 };
@@ -120,7 +135,10 @@ const readPackageSync = (directory, relativePath) => {
 * Every workspace package under `root`, root package first.
 *
 * @remarks
-* **Synchronous and Node-only.** The Effect surface is `WorkspaceDiscovery`.
+* **Synchronous.** The Effect surface is `WorkspaceDiscovery`. The file and
+* path operations are the caller's ({@link GetWorkspacePackagesSyncOptions}
+* extends {@link WorkspacesSyncOptions}); this module imports no `node:*` and
+* assumes no posix.
 *
 * Pattern semantics are not merely "shared" with the Effect enumerator — both
 * drive the **same traversal state machine** (`internal/traverse.ts`), so the
@@ -137,54 +155,67 @@ const readPackageSync = (directory, relativePath) => {
 * the enumerator's defect.
 *
 * @param root - The workspace root, from {@link findWorkspaceRootSync}.
-* @param options - Traversal bounds; see {@link GetWorkspacePackagesSyncOptions}.
+* @param options - The consumer-supplied operations and traversal bounds; see
+*   {@link GetWorkspacePackagesSyncOptions}.
 *
 * @example
 * ```ts
+* import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+* import * as path from "node:path";
 * import { findWorkspaceRootSync, getWorkspacePackagesSync } from "@effected/workspaces";
 *
-* const root = findWorkspaceRootSync();
-* const packages = root === null ? [] : getWorkspacePackagesSync(root);
+* const ops = {
+* 	fileSystem: {
+* 		exists: existsSync,
+* 		readFile: (p: string) => readFileSync(p, "utf8"),
+* 		readDirectory: (p: string) => readdirSync(p),
+* 		isDirectory: (p: string) => statSync(p).isDirectory(),
+* 	},
+* 	path,
+* };
+* const root = findWorkspaceRootSync(ops);
+* const packages = root === null ? [] : getWorkspacePackagesSync(root, ops);
 * ```
 *
 * @public
 */
 const getWorkspacePackagesSync = (root, options) => {
-	const maxDepth = options?.maxDepth ?? 32;
+	const { fileSystem, path } = options;
+	const maxDepth = options.maxDepth ?? 32;
 	if (!isValidMaxDepth(maxDepth)) throw new RangeError(`getWorkspacePackagesSync: ${badMaxDepthMessage(maxDepth)}`);
-	const patterns = readPatternsSync(root);
+	const patterns = readPatternsSync(options, root);
 	const compiled = Effect.runSyncExit(GlobSet.compile(patterns));
 	if (Exit.isFailure(compiled)) return [];
 	const globs = compiled.value;
 	const included = /* @__PURE__ */ new Map();
 	for (const literal of globs.literals) {
-		const absolute = join(root, literal);
-		if (isPackage(absolute)) included.set(literal, absolute);
+		const absolute = path.join(root, literal);
+		if (isPackage(options, absolute)) included.set(literal, absolute);
 	}
 	for (const wildcard of globs.wildcards) {
 		const base = wildcard.enumerationPrefix.replace(/\/$/, "");
-		const absoluteBase = join(root, base);
-		if (!isDirectory(absoluteBase)) continue;
+		const absoluteBase = path.join(root, base);
+		if (!isDirectory(fileSystem, absoluteBase)) continue;
 		const traversal = new Traversal(base, absoluteBase, maxDepth);
 		let stopped = false;
 		for (let current = traversal.next(); current !== void 0 && !stopped; current = traversal.next()) {
 			if (traversal.charge() !== void 0) break;
 			let entries = [];
 			try {
-				entries = readdirSync(current.absolute);
+				entries = fileSystem.readDirectory(current.absolute);
 			} catch {
 				continue;
 			}
 			for (const entry of entries) {
 				if (isPruned(entry)) continue;
 				const relative = joinRelative(current.relative, entry);
-				const absolute = join(current.absolute, entry);
-				if (!isDirectory(absolute)) continue;
+				const absolute = path.join(current.absolute, entry);
+				if (!isDirectory(fileSystem, absolute)) continue;
 				if (wildcard.crossesSegments && !traversal.admits(current)) {
 					stopped = true;
 					break;
 				}
-				if (wildcard.matches(relative) && isPackage(absolute)) included.set(relative, absolute);
+				if (wildcard.matches(relative) && isPackage(options, absolute)) included.set(relative, absolute);
 				if (!wildcard.crossesSegments) continue;
 				traversal.push(current, relative, absolute);
 			}
@@ -194,10 +225,10 @@ const getWorkspacePackagesSync = (root, options) => {
 	for (const [relativePath, absolute] of [...included.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
 		if (relativePath === "." || absolute === root) continue;
 		if (globs.excludes.some((exclude) => exclude.matches(relativePath))) continue;
-		const pkg = readPackageSync(absolute, relativePath);
+		const pkg = readPackageSync(options, absolute, relativePath);
 		if (pkg !== null) members.push(pkg);
 	}
-	const rootPackage = readPackageSync(root, ".");
+	const rootPackage = readPackageSync(options, root, ".");
 	return rootPackage === null ? members : [rootPackage, ...members];
 };
 

package/index.d.ts

@@ -1,44 +1,10 @@
-import { Context, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
 import { Git, GitCommandError, NotARepositoryError, UnknownRefError } from "@effected/git";
-import { CatalogResolver, WorkspaceResolver } from "@effected/npm";
+import { Context, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
+import { CatalogAssemblyError, CatalogResolver, DependencyResolutionError, Manifest, UnresolvedDependencyError, WorkspaceResolver } from "@effected/npm";
 import { GlobPattern } from "@effected/glob";
 import { Lockfile, LockfileFramingError, LockfileIntegrity, LockfileParseError, ResolvedPackage, WorkspaceManifest } from "@effected/lockfiles";
 import { Package } from "@effected/package-json";
 import { ChildProcessSpawner } from "effect/unstable/process";
-//#region src/CatalogAssemblyError.d.ts
-declare const CatalogAssemblyError_base: Schema.Class<CatalogAssemblyError, Schema.TaggedStruct<"CatalogAssemblyError", {
-  /**
-   * Which input failed: `manifest` for a file-level or top-level shape problem,
-   * `catalog` for a malformed catalog block or the double-default duplication,
-   * `hooks` for a config-dependency `pnpmfile.cjs` load or replay failure.
-   */
-  readonly source: Schema.Literals<readonly ["manifest", "catalog", "hooks"]>;
-  /** The file, the catalog name, or the config dependency name. */
-  readonly path: Schema.String;
-  /** The originating failure. */
-  readonly cause: Schema.Defect;
-}>, import("effect/Cause").YieldableError>;
-/**
- * Raised when a workspace's catalogs cannot be assembled — a `pnpm-workspace.yaml`
- * that is unreadable or not valid YAML, a root `package.json` `workspaces` field
- * whose shape or catalog blocks are malformed in a way pnpm itself rejects
- * (including the default catalog declared twice), or a config dependency whose
- * `pnpmfile.cjs` cannot be loaded or replayed.
- *
- * @remarks
- * A *missing* `pnpm-workspace.yaml`, an *absent* `workspaces` field, or one
- * explicitly `null` is not an error: there is simply nothing to misread, so
- * assembly yields the empty set. The reader is otherwise **hard-fail by design** —
- * a silently-empty catalog read is the "every dependency looks newly added" bug,
- * because catalog output is load-bearing for snapshot diffing.
- *
- * @public
- */
-declare class CatalogAssemblyError extends CatalogAssemblyError_base {
-  /** Renders the failing source into a one-line message. */
-  get message(): string;
-}
-//#endregion
 //#region src/WorkspacePackage.d.ts
 declare const PublishConfig_base: Schema.Class<PublishConfig, Schema.Struct<{
   /** Scoped-package visibility. Its presence overrides `private`. */
@@ -129,6 +95,20 @@ declare const WorkspacePackage_base: Schema.Class<WorkspacePackage, Schema.Struc
   readonly optionalDependencies: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.String>, never>>;
   /** The `publishConfig` block, when present. */
   readonly publishConfig: Schema.optionalKey<typeof PublishConfig>;
+  /**
+   * The package's `package.json` as read — tolerant access to every field
+   * outside the typed discovery slice (`scripts`, `exports`, …) without a
+   * second file read.
+   *
+   * @remarks
+   * Values are `unknown` and exactly what discovery parsed; nothing here is
+   * validated beyond being a record. For the strict typed model use
+   * `manifest()`, which deliberately **re-reads** the file — a point-in-time
+   * refresh this captured record cannot provide. Defaults to `{}` for
+   * construction sites and previously-serialized values that predate the
+   * field.
+   */
+  readonly manifestRecord: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.$Record<Schema.String, Schema.Unknown>, never>>;
 }>, {}>;
 /**
  * A single package inside a workspace: the discovery-relevant slice of its
@@ -648,7 +628,7 @@ declare class ConfigDependencyHooks extends ConfigDependencyHooks_base {
    * (in process, no subprocess) and replays its `updateConfig` hook over the
    * seed, in declaration order. A dependency without a `pnpmfile.cjs` contributes
    * nothing; a dependency whose file fails to load or replay fails typed with a
-   * `hooks`-source {@link CatalogAssemblyError}, never a silent skip.
+   * `hooks`-source `CatalogAssemblyError`, never a silent skip.
    *
    * @remarks
    * Node-coupled by design — the `node:fs` / `node:path` / `node:url` imports are
@@ -1107,7 +1087,7 @@ declare class CatalogSet extends CatalogSet_base {
    * load-bearing for: a present-but-malformed `workspaces` shape (a number, a
    * string, an object with a malformed `packages` / `catalog` / `catalogs`), or
    * the default catalog declared twice — once as `workspaces.catalog` and again
-   * as `workspaces.catalogs.default` — fails with {@link CatalogAssemblyError}
+   * as `workspaces.catalogs.default` — fails with `CatalogAssemblyError`
    * naming what was wrong. An absent `workspaces` field, one explicitly `null`,
    * or the plain array form (npm/yarn patterns, which carry no catalogs) yields
    * the empty set. Presence is checked structurally, so an explicitly-declared
@@ -1190,7 +1170,7 @@ declare const WorkspaceCatalogs_base: Context.ServiceClass<WorkspaceCatalogs, "@
  * within a catalog. An unreadable or absent lockfile degrades to no lockfile
  * catalogs rather than failing (the inline declaration is the source of truth, the
  * lockfile a record of what was installed); a malformed inline source **fails
- * typed** with {@link CatalogAssemblyError}, because a silently-empty catalog read
+ * typed** with `CatalogAssemblyError`, because a silently-empty catalog read
  * is the "every dependency looks newly added" bug.
  *
  * Assembly is deferred to the first call and memoized success-only, matching
@@ -1229,9 +1209,12 @@ declare class WorkspaceCatalogs extends WorkspaceCatalogs_base {
    *
    * @remarks
    * `rangeOf` returns `Option.none()` for a dependency no catalog declares, per
-   * the contract's convention; `DependencyResolutionError` is reserved for a
-   * failure of the resolution *mechanism* — an unfindable workspace root, an
-   * unreadable or malformed `pnpm-workspace.yaml`.
+   * the contract's convention. A failed catalog *assembly* — an unreadable or
+   * malformed `pnpm-workspace.yaml`, a broken config-dependency hook — passes
+   * through **typed** as the contract's `CatalogAssemblyError` (it used to be
+   * folded into `DependencyResolutionError`'s defect `cause`, which forced
+   * consumers to `_tag`-sniff `unknown`); only the remaining mechanism failure,
+   * an unfindable workspace root, is wrapped as `DependencyResolutionError`.
    */
   static readonly catalogResolver: Layer.Layer<CatalogResolver, never, WorkspaceCatalogs>;
 }
@@ -1342,6 +1325,12 @@ declare class WorkspaceStateSnapshot extends WorkspaceStateSnapshot_base {
    * THIS snapshot's catalog set — so code written to the contract resolves
    * `catalog:` specifiers as of this ref. Built once per instance and cached, so
    * it memoizes by reference.
+   *
+   * @remarks
+   * The contract's error channel (`CatalogAssemblyError` /
+   * `DependencyResolutionError`) is satisfied vacuously: a snapshot's catalogs
+   * were already assembled when it was captured, so this resolver is total —
+   * `rangeOf` never fails.
    */
   get catalogResolver(): Layer.Layer<CatalogResolver>;
   /**
@@ -1365,7 +1354,7 @@ declare class WorkspaceStateSnapshot extends WorkspaceStateSnapshot_base {
  * filesystem, so no `WorkspaceDiscoveryError` / `WorkspacePatternError` appears —
  * and a malformed *lockfile* at the ref degrades to no catalogs (a lockfile is a
  * record, not a source of truth), so only the inline source raises
- * {@link CatalogAssemblyError}.
+ * `CatalogAssemblyError`.
  *
  * @public
  */
@@ -1479,39 +1468,148 @@ declare const Workspaces: {
   readonly layer: (options?: WorkspacesOptions) => Layer.Layer<WorkspacesServices, never, FileSystem.FileSystem | Path.Path>;
   readonly layerWithConfigDependencies: (options?: WorkspacesOptions) => Layer.Layer<WorkspacesServices, never, FileSystem.FileSystem | Path.Path>;
   readonly layerWithGit: (options?: WorkspacesOptions) => Layer.Layer<WorkspacesServices | ChangeDetector | WorkspaceSnapshots | Git, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+  readonly resolveManifest: (manifest: Manifest, options?: WorkspacesOptions) => Effect.Effect<Manifest, CatalogAssemblyError | DependencyResolutionError | UnresolvedDependencyError, FileSystem.FileSystem | Path.Path>;
+  readonly resolverLayer: (options?: WorkspacesOptions) => Layer.Layer<CatalogResolver | WorkspaceResolver, never, FileSystem.FileSystem | Path.Path>;
   readonly resolvers: Layer.Layer<CatalogResolver | WorkspaceResolver, never, WorkspaceCatalogs | WorkspaceDiscovery>;
 };
 //#endregion
 //#region src/WorkspacesSync.d.ts
 /**
- * The nearest workspace root at or above `cwd`, or `null`.
+ * The synchronous file operations the sync entry points need, supplied by the
+ * consumer. Node's built-ins satisfy it directly:
+ *
+ * ```ts
+ * import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+ *
+ * const fileSystem: SyncFileSystem = {
+ * 	exists: existsSync,
+ * 	readFile: (p) => readFileSync(p, "utf8"),
+ * 	readDirectory: (p) => readdirSync(p),
+ * 	isDirectory: (p) => statSync(p).isDirectory(),
+ * };
+ * ```
+ *
+ * `exists` must return a boolean and not throw (Node's `existsSync` never
+ * does). The other three may throw — `statSync` on a missing path, a
+ * permission error mid-read — and every throw is absorbed into the documented
+ * degraded-skip semantics: a throwing `readFile` reads as an unusable
+ * manifest, a throwing `readDirectory` as an unreadable directory, a throwing
+ * `isDirectory` as "not a directory". Nothing propagates.
+ *
+ * @public
+ */
+interface SyncFileSystem {
+  /** Whether a file or directory exists at `path`. Must not throw. */
+  readonly exists: (path: string) => boolean;
+  /** Read the file at `path` as text. May throw; a throw degrades to a skip. */
+  readonly readFile: (path: string) => string;
+  /** The entry names inside the directory at `path`. May throw; a throw skips the directory. */
+  readonly readDirectory: (path: string) => ReadonlyArray<string>;
+  /** Whether `path` is a directory. May throw; a throw reads as `false`. */
+  readonly isDirectory: (path: string) => boolean;
+}
+/**
+ * The synchronous path operations the sync entry points need, supplied by the
+ * consumer. Deliberately a structural subset of `node:path`, so the built-in
+ * module (and its `win32` / `posix` variants, or a Bun / Deno equivalent)
+ * satisfies it verbatim:
+ *
+ * ```ts
+ * import * as path from "node:path";
+ *
+ * const options: WorkspacesSyncOptions = {
+ * 	fileSystem: { exists: existsSync, readFile: (p) => readFileSync(p, "utf8"), readDirectory: (p) => readdirSync(p), isDirectory: (p) => statSync(p).isDirectory() },
+ * 	path, // node:path IS a SyncPath
+ * };
+ * ```
+ *
+ * These operations shape only the ABSOLUTE paths handed back to the consumer
+ * (and to its own `fileSystem`); workspace-relative pattern matching is POSIX
+ * by the `packages:` contract and never routes through here. Windows
+ * correctness comes from supplying a win32-appropriate implementation, not
+ * from anything in this module.
+ *
+ * @public
+ */
+interface SyncPath {
+  /** Join segments with the implementation's separator (like `path.join`). */
+  readonly join: (...segments: ReadonlyArray<string>) => string;
+  /** The directory portion of `p` (like `path.dirname`). */
+  readonly dirname: (p: string) => string;
+  /** Resolve segments to an absolute path (rightmost-wins, like `path.resolve`). */
+  readonly resolve: (...segments: ReadonlyArray<string>) => string;
+}
+/**
+ * The consumer-supplied operations backing one sync call: the file operations
+ * and the path implementation. Both are required — this package never imports
+ * `node:*` and never assumes posix, so the platform binding is entirely the
+ * caller's.
+ *
+ * @public
+ */
+interface WorkspacesSyncOptions {
+  /** The synchronous file operations (Node: `existsSync` / `readFileSync` / `readdirSync` / `statSync`). */
+  readonly fileSystem: SyncFileSystem;
+  /** The synchronous path implementation (Node: the `node:path` module itself). */
+  readonly path: SyncPath;
+}
+/**
+ * Options for {@link findWorkspaceRootSync}: the required consumer-supplied
+ * operations plus where to start the ascent.
+ *
+ * @public
+ */
+interface FindWorkspaceRootSyncOptions extends WorkspacesSyncOptions {
+  /**
+   * Where to start the ascent, matching the Effect layers' `{ cwd }` option.
+   *
+   * @defaultValue `process.cwd()`, read lazily per call.
+   */
+  readonly cwd?: string;
+}
+/**
+ * The nearest workspace root at or above `options.cwd`, or `null`.
  *
  * @remarks
- * **Synchronous and Node-only.** The Effect surface is `WorkspaceRoot`; reach
- * for this one only where you genuinely cannot run an Effect — a Vitest config
- * being the motivating case.
+ * **Synchronous.** The Effect surface is `WorkspaceRoot`; reach for this one
+ * only where you genuinely cannot run an Effect — a Vitest config being the
+ * motivating case. The file and path operations are the caller's
+ * ({@link FindWorkspaceRootSyncOptions}); this module imports no `node:*` and
+ * assumes no posix.
  *
  * Markers match the async service exactly: a `pnpm-workspace.yaml`, or a
  * `package.json` carrying a `workspaces` field.
  *
- * @param cwd - Where to start the ascent. Defaults to `process.cwd()`.
+ * @param options - The consumer-supplied file and path operations, plus the
+ *   optional `cwd` to start from (defaulting to `process.cwd()`).
  *
  * @example
  * ```ts
+ * import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+ * import * as path from "node:path";
  * import { findWorkspaceRootSync } from "@effected/workspaces";
  *
- * const root = findWorkspaceRootSync();
+ * const root = findWorkspaceRootSync({
+ * 	fileSystem: {
+ * 		exists: existsSync,
+ * 		readFile: (p) => readFileSync(p, "utf8"),
+ * 		readDirectory: (p) => readdirSync(p),
+ * 		isDirectory: (p) => statSync(p).isDirectory(),
+ * 	},
+ * 	path,
+ * });
  * ```
  *
  * @public
  */
-declare const findWorkspaceRootSync: (cwd?: string) => string | null;
+declare const findWorkspaceRootSync: (options: FindWorkspaceRootSyncOptions) => string | null;
 /**
- * Options for {@link getWorkspacePackagesSync}.
+ * Options for {@link getWorkspacePackagesSync}: the required consumer-supplied
+ * operations plus the traversal bound.
  *
  * @public
  */
-interface GetWorkspacePackagesSyncOptions {
+interface GetWorkspacePackagesSyncOptions extends WorkspacesSyncOptions {
   /**
    * Descent cap below a wildcard's enumeration prefix, mirroring
    * `WorkspaceDiscovery.layer({ maxDepth })`.
@@ -1524,7 +1622,10 @@ interface GetWorkspacePackagesSyncOptions {
  * Every workspace package under `root`, root package first.
  *
  * @remarks
- * **Synchronous and Node-only.** The Effect surface is `WorkspaceDiscovery`.
+ * **Synchronous.** The Effect surface is `WorkspaceDiscovery`. The file and
+ * path operations are the caller's ({@link GetWorkspacePackagesSyncOptions}
+ * extends {@link WorkspacesSyncOptions}); this module imports no `node:*` and
+ * assumes no posix.
  *
  * Pattern semantics are not merely "shared" with the Effect enumerator — both
  * drive the **same traversal state machine** (`internal/traverse.ts`), so the
@@ -1541,19 +1642,31 @@ interface GetWorkspacePackagesSyncOptions {
  * the enumerator's defect.
  *
  * @param root - The workspace root, from {@link findWorkspaceRootSync}.
- * @param options - Traversal bounds; see {@link GetWorkspacePackagesSyncOptions}.
+ * @param options - The consumer-supplied operations and traversal bounds; see
+ *   {@link GetWorkspacePackagesSyncOptions}.
  *
  * @example
  * ```ts
+ * import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+ * import * as path from "node:path";
  * import { findWorkspaceRootSync, getWorkspacePackagesSync } from "@effected/workspaces";
  *
- * const root = findWorkspaceRootSync();
- * const packages = root === null ? [] : getWorkspacePackagesSync(root);
+ * const ops = {
+ * 	fileSystem: {
+ * 		exists: existsSync,
+ * 		readFile: (p: string) => readFileSync(p, "utf8"),
+ * 		readDirectory: (p: string) => readdirSync(p),
+ * 		isDirectory: (p: string) => statSync(p).isDirectory(),
+ * 	},
+ * 	path,
+ * };
+ * const root = findWorkspaceRootSync(ops);
+ * const packages = root === null ? [] : getWorkspacePackagesSync(root, ops);
  * ```
  *
  * @public
  */
-declare const getWorkspacePackagesSync: (root: string, options?: GetWorkspacePackagesSyncOptions) => ReadonlyArray<WorkspacePackage>;
+declare const getWorkspacePackagesSync: (root: string, options: GetWorkspacePackagesSyncOptions) => ReadonlyArray<WorkspacePackage>;
 //#endregion
-export { CatalogAssemblyError, type CatalogAssemblyFailure, CatalogSet, ChangeDetectionError, type ChangeDetectionFailure, ChangeDetectionOptions, ChangeDetector, type ChangeDetectorShape, ConfigDependencyHooks, type ConfigDependencyHooksShape, CyclicDependencyError, type DependencyDiff, DependencyGraph, DetectedPackageManager, type GetWorkspacePackagesSyncOptions, LockfileReadError, type LockfileReadFailure, LockfileReader, type LockfileReaderOptions, type LockfileReaderShape, PackageManagerDetectionError, type PackageManagerDetectionFailure, PackageManagerDetector, PackageManagerName, PackageNotFoundError, PackageStateSnapshot, PublishConfig, PublishTarget, PublishabilityDetector, WORKSPACE_MARKERS, WorkspaceCatalogs, type WorkspaceCatalogsOptions, type WorkspaceCatalogsShape, WorkspaceDiscovery, WorkspaceDiscoveryError, type WorkspaceDiscoveryFailure, type WorkspaceDiscoveryOptions, type WorkspaceDiscoveryShape, WorkspaceInfo, type WorkspaceLookupFailure, WorkspaceManifestError, WorkspacePackage, WorkspacePatternError, WorkspaceRoot, WorkspaceRootNotFoundError, type WorkspaceSnapshotAtFailure, type WorkspaceSnapshotWorktreeFailure, WorkspaceSnapshots, type WorkspaceSnapshotsOptions, type WorkspaceSnapshotsShape, WorkspaceStateSnapshot, Workspaces, type WorkspacesOptions, type WorkspacesServices, findWorkspaceRootSync, getWorkspacePackagesSync };
+export { type CatalogAssemblyFailure, CatalogSet, ChangeDetectionError, type ChangeDetectionFailure, ChangeDetectionOptions, ChangeDetector, type ChangeDetectorShape, ConfigDependencyHooks, type ConfigDependencyHooksShape, CyclicDependencyError, type DependencyDiff, DependencyGraph, DetectedPackageManager, type FindWorkspaceRootSyncOptions, type GetWorkspacePackagesSyncOptions, LockfileReadError, type LockfileReadFailure, LockfileReader, type LockfileReaderOptions, type LockfileReaderShape, PackageManagerDetectionError, type PackageManagerDetectionFailure, PackageManagerDetector, PackageManagerName, PackageNotFoundError, PackageStateSnapshot, PublishConfig, PublishTarget, PublishabilityDetector, type SyncFileSystem, type SyncPath, WORKSPACE_MARKERS, WorkspaceCatalogs, type WorkspaceCatalogsOptions, type WorkspaceCatalogsShape, WorkspaceDiscovery, WorkspaceDiscoveryError, type WorkspaceDiscoveryFailure, type WorkspaceDiscoveryOptions, type WorkspaceDiscoveryShape, WorkspaceInfo, type WorkspaceLookupFailure, WorkspaceManifestError, WorkspacePackage, WorkspacePatternError, WorkspaceRoot, WorkspaceRootNotFoundError, type WorkspaceSnapshotAtFailure, type WorkspaceSnapshotWorktreeFailure, WorkspaceSnapshots, type WorkspaceSnapshotsOptions, type WorkspaceSnapshotsShape, WorkspaceStateSnapshot, Workspaces, type WorkspacesOptions, type WorkspacesServices, type WorkspacesSyncOptions, findWorkspaceRootSync, getWorkspacePackagesSync };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,4 +1,3 @@
-import { CatalogAssemblyError } from "./CatalogAssemblyError.js";
 import { PublishConfig, WorkspaceManifestError, WorkspacePackage } from "./WorkspacePackage.js";
 import { WORKSPACE_MARKERS, WorkspaceRoot, WorkspaceRootNotFoundError } from "./WorkspaceRoot.js";
 import { PackageNotFoundError, WorkspaceDiscovery, WorkspaceDiscoveryError, WorkspaceInfo, WorkspacePatternError } from "./WorkspaceDiscovery.js";
@@ -14,4 +13,4 @@ import { WorkspaceSnapshots } from "./WorkspaceSnapshots.js";
 import { Workspaces } from "./Workspaces.js";
 import { findWorkspaceRootSync, getWorkspacePackagesSync } from "./WorkspacesSync.js";
 
-export { CatalogAssemblyError, CatalogSet, ChangeDetectionError, ChangeDetectionOptions, ChangeDetector, ConfigDependencyHooks, CyclicDependencyError, DependencyGraph, DetectedPackageManager, LockfileReadError, LockfileReader, PackageManagerDetectionError, PackageManagerDetector, PackageManagerName, PackageNotFoundError, PackageStateSnapshot, PublishConfig, PublishTarget, PublishabilityDetector, WORKSPACE_MARKERS, WorkspaceCatalogs, WorkspaceDiscovery, WorkspaceDiscoveryError, WorkspaceInfo, WorkspaceManifestError, WorkspacePackage, WorkspacePatternError, WorkspaceRoot, WorkspaceRootNotFoundError, WorkspaceSnapshots, WorkspaceStateSnapshot, Workspaces, findWorkspaceRootSync, getWorkspacePackagesSync };
+export { CatalogSet, ChangeDetectionError, ChangeDetectionOptions, ChangeDetector, ConfigDependencyHooks, CyclicDependencyError, DependencyGraph, DetectedPackageManager, LockfileReadError, LockfileReader, PackageManagerDetectionError, PackageManagerDetector, PackageManagerName, PackageNotFoundError, PackageStateSnapshot, PublishConfig, PublishTarget, PublishabilityDetector, WORKSPACE_MARKERS, WorkspaceCatalogs, WorkspaceDiscovery, WorkspaceDiscoveryError, WorkspaceInfo, WorkspaceManifestError, WorkspacePackage, WorkspacePatternError, WorkspaceRoot, WorkspaceRootNotFoundError, WorkspaceSnapshots, WorkspaceStateSnapshot, Workspaces, findWorkspaceRootSync, getWorkspacePackagesSync };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/workspaces",
-	"version": "0.1.0",
+	"version": "0.2.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": [
@@ -42,9 +42,9 @@
 	"dependencies": {
 		"@effected/git": "0.1.0",
 		"@effected/glob": "0.1.0",
-		"@effected/lockfiles": "0.1.0",
-		"@effected/npm": "0.1.0",
-		"@effected/package-json": "0.1.0",
+		"@effected/lockfiles": "0.1.1",
+		"@effected/npm": "0.2.0",
+		"@effected/package-json": "0.2.0",
 		"@effected/walker": "0.1.0",
 		"@effected/yaml": "0.1.0",
 		"@pnpm/catalogs.config": "^1100.0.0",

package/CatalogAssemblyError.js

@@ -1,43 +0,0 @@
-import { Schema } from "effect";
-
-//#region src/CatalogAssemblyError.ts
-/**
-* Raised when a workspace's catalogs cannot be assembled — a `pnpm-workspace.yaml`
-* that is unreadable or not valid YAML, a root `package.json` `workspaces` field
-* whose shape or catalog blocks are malformed in a way pnpm itself rejects
-* (including the default catalog declared twice), or a config dependency whose
-* `pnpmfile.cjs` cannot be loaded or replayed.
-*
-* @remarks
-* A *missing* `pnpm-workspace.yaml`, an *absent* `workspaces` field, or one
-* explicitly `null` is not an error: there is simply nothing to misread, so
-* assembly yields the empty set. The reader is otherwise **hard-fail by design** —
-* a silently-empty catalog read is the "every dependency looks newly added" bug,
-* because catalog output is load-bearing for snapshot diffing.
-*
-* @public
-*/
-var CatalogAssemblyError = class extends Schema.TaggedErrorClass()("CatalogAssemblyError", {
-	/**
-	* Which input failed: `manifest` for a file-level or top-level shape problem,
-	* `catalog` for a malformed catalog block or the double-default duplication,
-	* `hooks` for a config-dependency `pnpmfile.cjs` load or replay failure.
-	*/
-	source: Schema.Literals([
-		"manifest",
-		"catalog",
-		"hooks"
-	]),
-	/** The file, the catalog name, or the config dependency name. */
-	path: Schema.String,
-	/** The originating failure. */
-	cause: Schema.Defect()
-}) {
-	/** Renders the failing source into a one-line message. */
-	get message() {
-		return `Failed to assemble catalogs from ${this.source} ${this.path}`;
-	}
-};
-
-//#endregion
-export { CatalogAssemblyError };