@effected/workspaces 0.3.1 → 0.4.1

package/README.md

@@ -3,7 +3,7 @@
 [![npm](https://img.shields.io/npm/v/@effected%2Fworkspaces?label=npm&color=cb3837)](https://www.npmjs.com/package/@effected/workspaces)
 [![License: MIT](https://img.shields.io/badge/License-MIT-4caf50.svg)](https://opensource.org/licenses/MIT)
 [![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
-[![TypeScript 6.0](https://img.shields.io/badge/TypeScript-6.0-3178c6.svg)](https://www.typescriptlang.org/)
+[![TypeScript 7.0](https://img.shields.io/badge/TypeScript-7.0-3178c6.svg)](https://www.typescriptlang.org/)
 
 Monorepo workspace tooling for [Effect](https://effect.website) v4: find the workspace root, enumerate its packages, walk the dependency graph, detect the package manager, resolve pnpm catalogs, read the lockfile and work out which packages a git range touches. Every capability is a service you provide at the edge and swap in tests. Works with npm, pnpm, yarn Berry and bun.
 
@@ -151,7 +151,7 @@ const options = {
   path, // node:path satisfies SyncPath verbatim
 };
 
-const root = findWorkspaceRootSync(options);
+const root = findWorkspaceRootSync(process.cwd(), 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
@@ -180,12 +180,38 @@ 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. `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`.
 
+## Testing
+
+Every service here can be replaced with `Layer.succeed` and a hand-built value, and `WorkspaceDiscovery` ships that pattern ready-made: `WorkspaceDiscovery.layerTest(overrides)` provides an in-memory double where a test stubs only the methods it exercises. The defaults model an empty workspace, and the derived methods run over the effective `listPackages`, so stubbing that one method keeps `getPackage`, `importerMap` and `resolveFile` answering consistently:
+
+```ts
+import { WorkspaceDiscovery, WorkspacePackage } from "@effected/workspaces";
+import { Effect } from "effect";
+
+// Bind to a const — layers memoize by reference.
+const TestDiscovery = WorkspaceDiscovery.layerTest({
+  listPackages: () =>
+    Effect.succeed([
+      WorkspacePackage.make({
+        name: "@my-org/utils",
+        version: "1.0.0",
+        path: "/repo/packages/utils",
+        packageJsonPath: "/repo/packages/utils/package.json",
+        relativePath: "packages/utils",
+      }),
+    ]),
+});
+// program.pipe(Effect.provide(TestDiscovery))
+```
+
+A name miss in the derived `getPackage` fails with the service's own typed `PackageNotFoundError`, exactly as the live implementation does. Two deliberate edges: `info()` has no honest default (a fabricated root path would leak into consumer path logic), so it dies with an explanatory defect unless stubbed, and the derived file-ownership methods assume POSIX paths, so pass your own `resolveFile` for win32 fixtures. `WorkspaceDiscovery.makeTest(overrides)` returns the bare service shape when you want the double without a layer.
+
 ## 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.
+- `WorkspaceDiscovery` — package enumeration with a bounded descent for segment-crossing `packages/**` patterns, per-package lookup and the `makeTest` / `layerTest` in-memory test doubles.
 - `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.

package/WorkspaceDiscovery.js

@@ -304,6 +304,109 @@ var WorkspaceDiscovery = class WorkspaceDiscovery extends Context.Service()("@ef
 	*/
 	static layer = (options) => Layer.effect(WorkspaceDiscovery, WorkspaceDiscovery.make(options));
 	/**
+	* An in-memory test double of the service shape, with every method
+	* defaulted so a test stubs only what it exercises.
+	*
+	* @remarks
+	* The defaults model an **empty workspace**, and the derived methods run
+	* over the *effective* `listPackages` — the override when one is supplied —
+	* so stubbing only `listPackages` yields a consistent double:
+	*
+	* - `listPackages` — succeeds with `[]`.
+	* - `importerMap` — derived: the packages keyed by `relativePath`.
+	* - `getPackage` — derived: a name lookup that fails with the service's own
+	*   typed {@link PackageNotFoundError} on a miss, exactly as the live
+	*   implementation does.
+	* - `resolveFile` / `resolveFiles` — derived: longest-prefix ownership over
+	*   `pkg.path`, POSIX-terminated (`"/"`); supply a win32 double explicitly
+	*   if your fixture paths are win32.
+	* - `refresh` — a no-op (`Effect.void`); there is nothing memoized to drop.
+	* - `info` — **dies** with an explanatory defect. No honest default exists
+	*   (a fabricated root path would leak into consumer path logic), so an
+	*   unstubbed `info()` call is a test-wiring mistake and fails loudly as a
+	*   defect rather than succeeding with a lie or failing with a dishonest
+	*   typed error.
+	*
+	* @example
+	* ```ts
+	* import { WorkspaceDiscovery, WorkspacePackage } from "@effected/workspaces";
+	* import { Effect } from "effect";
+	*
+	* const double = WorkspaceDiscovery.makeTest({
+	*   listPackages: () =>
+	*     Effect.succeed([
+	*       WorkspacePackage.make({
+	*         name: "@my-org/utils",
+	*         version: "1.0.0",
+	*         path: "/repo/packages/utils",
+	*         packageJsonPath: "/repo/packages/utils/package.json",
+	*         relativePath: "packages/utils",
+	*       }),
+	*     ]),
+	* });
+	* // `getPackage`, `importerMap`, `resolveFile(s)` now answer consistently.
+	* ```
+	*/
+	static makeTest = (overrides = {}) => {
+		const listPackages = overrides.listPackages ?? (() => Effect.succeed([]));
+		const ownerOf = (filePath, all) => {
+			let best;
+			let bestLength = 0;
+			for (const pkg of all) {
+				const prefix = pkg.path.endsWith("/") ? pkg.path : `${pkg.path}/`;
+				if (filePath.startsWith(prefix) && prefix.length > bestLength) {
+					best = pkg;
+					bestLength = prefix.length;
+				}
+			}
+			return Option.fromUndefinedOr(best);
+		};
+		return {
+			listPackages,
+			info: () => Effect.die(/* @__PURE__ */ new Error("WorkspaceDiscovery.makeTest: info() was called but not stubbed — no honest default WorkspaceInfo exists for a test double; pass an `info` override.")),
+			importerMap: () => Effect.map(listPackages(), (all) => new Map(all.map((pkg) => [pkg.relativePath, pkg]))),
+			getPackage: (name) => Effect.flatMap(listPackages(), (all) => {
+				const found = all.find((pkg) => pkg.name === name);
+				return found !== void 0 ? Effect.succeed(found) : Effect.fail(new PackageNotFoundError({
+					name,
+					available: all.map((pkg) => pkg.name)
+				}));
+			}),
+			resolveFile: (filePath) => Effect.map(listPackages(), (all) => ownerOf(filePath, all)),
+			resolveFiles: (filePaths) => Effect.map(listPackages(), (all) => {
+				const seen = /* @__PURE__ */ new Map();
+				for (const filePath of filePaths) {
+					const owner = ownerOf(filePath, all);
+					if (Option.isSome(owner)) seen.set(owner.value.name, owner.value);
+				}
+				return [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
+			}),
+			refresh: () => Effect.void,
+			...overrides
+		};
+	};
+	/**
+	* The test layer: {@link WorkspaceDiscovery.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 { WorkspaceDiscovery } from "@effected/workspaces";
+	* import { Effect } from "effect";
+	*
+	* const TestDiscovery = WorkspaceDiscovery.layerTest({
+	*   listPackages: () => Effect.succeed([]),
+	* });
+	* // program.pipe(Effect.provide(TestDiscovery))
+	* ```
+	*/
+	static layerTest = (overrides = {}) => Layer.succeed(WorkspaceDiscovery, WorkspaceDiscovery.makeTest(overrides));
+	/**
 	* The real implementation of `@effected/npm`'s `WorkspaceResolver` contract
 	* — the one `@effected/package-json` declares but cannot fill.
 	*

package/WorkspacesSync.js

@@ -38,20 +38,28 @@ const isDirectory = (fileSystem, dir) => {
 /** Whether `dir` holds a `package.json`. */
 const isPackage = (options, dir) => options.fileSystem.exists(options.path.join(dir, "package.json"));
 /**
-* The nearest workspace root at or above `options.cwd`, or `null`.
+* The nearest workspace root at or above `cwd`, or `null`.
 *
 * @remarks
 * **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
+* ({@link WorkspacesSyncOptions}); this module imports no `node:*` and
 * assumes no posix.
 *
+* The signature is path-first, options second — the same shape as
+* {@link getWorkspacePackagesSync} and the rest of the kit's sync facades
+* (`TsconfigLoaderSync.load(configPath, options)`). `cwd` is required and
+* positional: the earlier options-bag form defaulted it to an ambient
+* `process.cwd()` read, which both broke the symmetry with its sibling and
+* was the module's one platform assumption.
+*
 * Markers match the async service exactly: a `pnpm-workspace.yaml`, or a
 * `package.json` carrying a `workspaces` field.
 *
-* @param options - The consumer-supplied file and path operations, plus the
-*   optional `cwd` to start from (defaulting to `process.cwd()`).
+* @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.
 *
 * @example
 * ```ts
@@ -59,7 +67,7 @@ const isPackage = (options, dir) => options.fileSystem.exists(options.path.join(
 * import * as path from "node:path";
 * import { findWorkspaceRootSync } from "@effected/workspaces";
 *
-* const root = findWorkspaceRootSync({
+* const root = findWorkspaceRootSync(process.cwd(), {
 * 	fileSystem: {
 * 		exists: existsSync,
 * 		readFile: (p) => readFileSync(p, "utf8"),
@@ -72,9 +80,9 @@ const isPackage = (options, dir) => options.fileSystem.exists(options.path.join(
 *
 * @public
 */
-const findWorkspaceRootSync = (options) => {
+const findWorkspaceRootSync = (cwd, options) => {
 	const { fileSystem, path } = options;
-	let current = path.resolve(options.cwd ?? process.cwd());
+	let current = path.resolve(cwd);
 	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"));
@@ -173,7 +181,7 @@ const readPackageSync = (options, directory, relativePath) => {
 * 	},
 * 	path,
 * };
-* const root = findWorkspaceRootSync(ops);
+* const root = findWorkspaceRootSync(process.cwd(), ops);
 * const packages = root === null ? [] : getWorkspacePackagesSync(root, ops);
 * ```
 *

package/index.d.ts

@@ -440,6 +440,72 @@ declare class WorkspaceDiscovery extends WorkspaceDiscovery_base {
    * rather than calling `layer(...)` at each composition site.
    */
   static readonly layer: (options?: WorkspaceDiscoveryOptions) => Layer.Layer<WorkspaceDiscovery, never, WorkspaceRoot | FileSystem.FileSystem | Path.Path>;
+  /**
+   * An in-memory test double of the service shape, with every method
+   * defaulted so a test stubs only what it exercises.
+   *
+   * @remarks
+   * The defaults model an **empty workspace**, and the derived methods run
+   * over the *effective* `listPackages` — the override when one is supplied —
+   * so stubbing only `listPackages` yields a consistent double:
+   *
+   * - `listPackages` — succeeds with `[]`.
+   * - `importerMap` — derived: the packages keyed by `relativePath`.
+   * - `getPackage` — derived: a name lookup that fails with the service's own
+   *   typed {@link PackageNotFoundError} on a miss, exactly as the live
+   *   implementation does.
+   * - `resolveFile` / `resolveFiles` — derived: longest-prefix ownership over
+   *   `pkg.path`, POSIX-terminated (`"/"`); supply a win32 double explicitly
+   *   if your fixture paths are win32.
+   * - `refresh` — a no-op (`Effect.void`); there is nothing memoized to drop.
+   * - `info` — **dies** with an explanatory defect. No honest default exists
+   *   (a fabricated root path would leak into consumer path logic), so an
+   *   unstubbed `info()` call is a test-wiring mistake and fails loudly as a
+   *   defect rather than succeeding with a lie or failing with a dishonest
+   *   typed error.
+   *
+   * @example
+   * ```ts
+   * import { WorkspaceDiscovery, WorkspacePackage } from "@effected/workspaces";
+   * import { Effect } from "effect";
+   *
+   * const double = WorkspaceDiscovery.makeTest({
+   *   listPackages: () =>
+   *     Effect.succeed([
+   *       WorkspacePackage.make({
+   *         name: "@my-org/utils",
+   *         version: "1.0.0",
+   *         path: "/repo/packages/utils",
+   *         packageJsonPath: "/repo/packages/utils/package.json",
+   *         relativePath: "packages/utils",
+   *       }),
+   *     ]),
+   * });
+   * // `getPackage`, `importerMap`, `resolveFile(s)` now answer consistently.
+   * ```
+   */
+  static readonly makeTest: (overrides?: Partial<WorkspaceDiscoveryShape>) => WorkspaceDiscoveryShape;
+  /**
+   * The test layer: {@link WorkspaceDiscovery.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 { WorkspaceDiscovery } from "@effected/workspaces";
+   * import { Effect } from "effect";
+   *
+   * const TestDiscovery = WorkspaceDiscovery.layerTest({
+   *   listPackages: () => Effect.succeed([]),
+   * });
+   * // program.pipe(Effect.provide(TestDiscovery))
+   * ```
+   */
+  static readonly layerTest: (overrides?: Partial<WorkspaceDiscoveryShape>) => Layer.Layer<WorkspaceDiscovery>;
   /**
    * The real implementation of `@effected/npm`'s `WorkspaceResolver` contract
    * — the one `@effected/package-json` declares but cannot fill.
@@ -1608,34 +1674,28 @@ interface WorkspacesSyncOptions {
   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`.
+ * The nearest workspace root at or above `cwd`, or `null`.
  *
  * @remarks
  * **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
+ * ({@link WorkspacesSyncOptions}); this module imports no `node:*` and
  * assumes no posix.
  *
+ * The signature is path-first, options second — the same shape as
+ * {@link getWorkspacePackagesSync} and the rest of the kit's sync facades
+ * (`TsconfigLoaderSync.load(configPath, options)`). `cwd` is required and
+ * positional: the earlier options-bag form defaulted it to an ambient
+ * `process.cwd()` read, which both broke the symmetry with its sibling and
+ * was the module's one platform assumption.
+ *
  * Markers match the async service exactly: a `pnpm-workspace.yaml`, or a
  * `package.json` carrying a `workspaces` field.
  *
- * @param options - The consumer-supplied file and path operations, plus the
- *   optional `cwd` to start from (defaulting to `process.cwd()`).
+ * @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.
  *
  * @example
  * ```ts
@@ -1643,7 +1703,7 @@ interface FindWorkspaceRootSyncOptions extends WorkspacesSyncOptions {
  * import * as path from "node:path";
  * import { findWorkspaceRootSync } from "@effected/workspaces";
  *
- * const root = findWorkspaceRootSync({
+ * const root = findWorkspaceRootSync(process.cwd(), {
  * 	fileSystem: {
  * 		exists: existsSync,
  * 		readFile: (p) => readFileSync(p, "utf8"),
@@ -1656,7 +1716,7 @@ interface FindWorkspaceRootSyncOptions extends WorkspacesSyncOptions {
  *
  * @public
  */
-declare const findWorkspaceRootSync: (options: FindWorkspaceRootSyncOptions) => string | null;
+declare const findWorkspaceRootSync: (cwd: string, options: WorkspacesSyncOptions) => string | null;
 /**
  * Options for {@link getWorkspacePackagesSync}: the required consumer-supplied
  * operations plus the traversal bound.
@@ -1714,7 +1774,7 @@ interface GetWorkspacePackagesSyncOptions extends WorkspacesSyncOptions {
  * 	},
  * 	path,
  * };
- * const root = findWorkspaceRootSync(ops);
+ * const root = findWorkspaceRootSync(process.cwd(), ops);
  * const packages = root === null ? [] : getWorkspacePackagesSync(root, ops);
  * ```
  *
@@ -1722,5 +1782,5 @@ interface GetWorkspacePackagesSyncOptions extends WorkspacesSyncOptions {
  */
 declare const getWorkspacePackagesSync: (root: string, options: GetWorkspacePackagesSyncOptions) => ReadonlyArray<WorkspacePackage>;
 //#endregion
-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 PublishabilityDetectorShape, 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 };
+export { 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, type PublishabilityDetectorShape, 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/node-sync.d.ts

@@ -106,7 +106,9 @@ declare const nodePath: SyncPath;
 /**
  * The complete Node-bound options bag for `findWorkspaceRootSync` and
  * `getWorkspacePackagesSync` — {@link nodeFileSystem} plus {@link nodePath}.
- * Spread it to add the per-call extras: `{ ...nodeSyncOps, cwd }`.
+ * Both helpers take their path positionally, so this bag usually passes
+ * through verbatim; spread it only to add `getWorkspacePackagesSync`'s
+ * traversal extras: `{ ...nodeSyncOps, maxDepth }`.
  *
  * @public
  */

package/node-sync.js

@@ -21,7 +21,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 * import { findWorkspaceRootSync, getWorkspacePackagesSync } from "@effected/workspaces";
 * import { nodeSyncOps } from "@effected/workspaces/node-sync";
 *
-* const root = findWorkspaceRootSync(nodeSyncOps);
+* const root = findWorkspaceRootSync(process.cwd(), nodeSyncOps);
 * const packages = root === null ? [] : getWorkspacePackagesSync(root, nodeSyncOps);
 * ```
 *
@@ -54,7 +54,9 @@ const nodePath = path;
 /**
 * The complete Node-bound options bag for `findWorkspaceRootSync` and
 * `getWorkspacePackagesSync` — {@link nodeFileSystem} plus {@link nodePath}.
-* Spread it to add the per-call extras: `{ ...nodeSyncOps, cwd }`.
+* Both helpers take their path positionally, so this bag usually passes
+* through verbatim; spread it only to add `getWorkspacePackagesSync`'s
+* traversal extras: `{ ...nodeSyncOps, maxDepth }`.
 *
 * @public
 */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/workspaces",
-	"version": "0.3.1",
+	"version": "0.4.1",
 	"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": [
@@ -35,30 +35,32 @@
 	"exports": {
 		".": {
 			"types": "./index.d.ts",
-			"import": "./index.js"
+			"import": "./index.js",
+			"default": "./index.js"
 		},
 		"./node-sync": {
 			"types": "./node-sync.d.ts",
-			"import": "./node-sync.js"
+			"import": "./node-sync.js",
+			"default": "./node-sync.js"
 		},
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/git": "0.4.0",
-		"@effected/glob": "0.1.1",
-		"@effected/lockfiles": "0.1.3",
-		"@effected/npm": "0.2.0",
-		"@effected/package-json": "0.3.0",
-		"@effected/semver": "0.1.0",
-		"@effected/walker": "0.2.1",
-		"@effected/yaml": "0.3.0",
+		"@effected/git": "0.4.1",
+		"@effected/glob": "0.1.2",
+		"@effected/lockfiles": "0.1.5",
+		"@effected/npm": "0.2.1",
+		"@effected/package-json": "0.3.1",
+		"@effected/semver": "0.1.1",
+		"@effected/walker": "0.2.2",
+		"@effected/yaml": "0.4.0",
 		"@pnpm/catalogs.config": "^1100.0.0",
 		"@pnpm/catalogs.protocol-parser": "^1100.0.0",
 		"@pnpm/catalogs.resolver": "^1100.0.0",
 		"@pnpm/catalogs.types": "^1100.0.0"
 	},
 	"peerDependencies": {
-		"effect": "4.0.0-beta.98"
+		"effect": "4.0.0-beta.99"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.10"
+      "packageVersion": "7.58.11"
     }
   ]
 }