@effected/workspaces 0.4.1 → 0.5.0

package/ConfigDependencyHooks.js

@@ -98,9 +98,13 @@ var ConfigDependencyHooks = class ConfigDependencyHooks extends Context.Service(
 	* `hooks`-source `CatalogAssemblyError`, never a silent skip.
 	*
 	* @remarks
-	* Node-coupled by design — the `node:fs` / `node:path` / `node:url` imports are
-	* the sanctioned Node-only overlay, matching the other seams here. Only ever
-	* wired by `WorkspaceCatalogs.layerWithConfigDependencies`.
+	* Runtime-coupled by design, not node-exclusive. The `import()` below loads
+	* **and executes** a config dependency's pnpmfile in-process — code execution,
+	* not IO, so no `FileSystem` / `Path` service abstracts it. The `node:path` and
+	* `node:url` imports (`join`, `pathToFileURL`) exist only to build the URL that
+	* `import()` consumes; node and bun both implement those builtins and dynamic
+	* import, so this layer runs on either runtime. Only ever wired by
+	* `WorkspaceCatalogs.layerWithConfigDependencies`.
 	*/
 	static layerLive = Layer.succeed(ConfigDependencyHooks, { inject: (root, configDependencies, seed) => Effect.gen(function* () {
 		const names = Object.keys(configDependencies);

package/WorkspaceDiscovery.js

@@ -184,6 +184,7 @@ var WorkspaceDiscovery = class WorkspaceDiscovery extends Context.Service()("@ef
 				path: directory,
 				packageJsonPath,
 				relativePath,
+				workspaceRoot: root,
 				manifestRecord: raw,
 				...typeof raw.private === "boolean" ? { private: raw.private } : {},
 				...isStringRecord(raw.dependencies) ? { dependencies: raw.dependencies } : {},
@@ -341,6 +342,7 @@ var WorkspaceDiscovery = class WorkspaceDiscovery extends Context.Service()("@ef
 	*         path: "/repo/packages/utils",
 	*         packageJsonPath: "/repo/packages/utils/package.json",
 	*         relativePath: "packages/utils",
+	*         workspaceRoot: "/repo",
 	*       }),
 	*     ]),
 	* });

package/WorkspacePackage.js

@@ -78,10 +78,12 @@ var WorkspaceManifestError = class extends Schema.TaggedErrorClass()("WorkspaceM
 *   path: "/repo/packages/utils",
 *   packageJsonPath: "/repo/packages/utils/package.json",
 *   relativePath: "packages/utils",
+*   workspaceRoot: "/repo",
 * });
 *
 * pkg.isRootWorkspace; // false
 * pkg.unscopedName;    // "utils"
+* pkg.workspaceRoot;   // "/repo"
 * ```
 *
 * @public
@@ -97,6 +99,21 @@ var WorkspacePackage = class WorkspacePackage extends Schema.Class("WorkspacePac
 	packageJsonPath: Schema.NonEmptyString,
 	/** POSIX path relative to the workspace root; `"."` for the root package. */
 	relativePath: Schema.String,
+	/**
+	* Absolute path to the workspace root this package was discovered under.
+	*
+	* @remarks
+	* Carried, not derived. Whoever built this value already knew the root —
+	* `WorkspaceDiscovery` resolved it before enumerating, and the sync entry
+	* point is handed it — so dropping it forced every consumer into per-package
+	* root arithmetic (counting `relativePath` segments and re-ascending that
+	* many `..`). That reconstruction is exact only while `path` and
+	* `relativePath` agree, and it re-derives something the kit never had to
+	* lose.
+	*
+	* For the root package this equals `path`, and `relativePath` is `"."`.
+	*/
+	workspaceRoot: Schema.NonEmptyString,
 	/** Whether the package is marked private. */
 	private: Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect.succeed(false)), Schema.withConstructorDefault(Effect.succeed(false))),
 	/** Production dependencies. */

package/WorkspaceRoot.js

@@ -21,11 +21,22 @@ var WorkspaceRootNotFoundError = class extends Schema.TaggedErrorClass()("Worksp
 	/** The directory the ascent started from. */
 	searchPath: Schema.String,
 	/** The marker filenames probed at each ancestor. */
-	markers: Schema.Array(Schema.String)
+	markers: Schema.Array(Schema.String),
+	/**
+	* The resolved ceiling the ascent was bounded by, when one was supplied.
+	*
+	* @remarks
+	* Absent means the ascent ran to the filesystem root. Its presence is what
+	* lets a caller tell "there is no workspace root anywhere above me" from
+	* "there is none below the ceiling I set" — two failures that otherwise
+	* render identically.
+	*/
+	stopAt: Schema.optionalKey(Schema.String)
 }) {
-	/** Renders the search path and probed markers into a one-line message. */
+	/** Renders the search path, probed markers and any ceiling into a one-line message. */
 	get message() {
-		return `No workspace root above ${this.searchPath} (looked for ${this.markers.join(", ")})`;
+		const bound = this.stopAt === void 0 ? "" : ` up to ${this.stopAt}`;
+		return `No workspace root above ${this.searchPath}${bound} (looked for ${this.markers.join(", ")})`;
 	}
 };
 /**
@@ -48,6 +59,12 @@ const isWorkspaceRoot = (dir) => Effect.gen(function* () {
 	}).pipe(Effect.orElseSucceed(() => ({})));
 	return parsed.workspaces !== void 0 && parsed.workspaces !== null;
 });
+/** Whether `descendant` is `ancestor` itself or lies beneath it, on POSIX or win32 separators. */
+const isAtOrBelow = (descendant, ancestor) => {
+	if (descendant === ancestor) return true;
+	const prefix = ancestor.endsWith("/") || ancestor.endsWith("\\") ? ancestor : `${ancestor}/`;
+	return descendant.startsWith(prefix) || descendant.startsWith(prefix.replace(/\/$/, "\\"));
+};
 /**
 * Locates the workspace root by ascending from a starting directory.
 *
@@ -62,6 +79,20 @@ const isWorkspaceRoot = (dir) => Effect.gen(function* () {
 * });
 * ```
 *
+* @example
+* Bounded: an unmarked fixture directory fails typed instead of escaping into
+* the enclosing repository.
+*
+* ```ts
+* import { WorkspaceRoot } from "@effected/workspaces";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   const roots = yield* WorkspaceRoot;
+*   return yield* roots.find("/tmp/fixture/packages/a", { stopAt: "/tmp/fixture" });
+* });
+* ```
+*
 * @public
 */
 var WorkspaceRoot = class WorkspaceRoot extends Context.Service()("@effected/workspaces/WorkspaceRoot") {
@@ -69,21 +100,92 @@ var WorkspaceRoot = class WorkspaceRoot extends Context.Service()("@effected/wor
 	static make = Effect.gen(function* () {
 		const fs = yield* FileSystem.FileSystem;
 		const path = yield* Path.Path;
-		const find = Effect.fn("WorkspaceRoot.find")(function* (cwd) {
+		const find = Effect.fn("WorkspaceRoot.find")(function* (cwd, options) {
 			const start = path.resolve(cwd);
-			const chain = yield* Walker.ascend(start);
+			const ceiling = options?.stopAt === void 0 ? void 0 : path.resolve(options.stopAt);
+			const chain = yield* Walker.ascend(start, {
+				...ceiling === void 0 ? {} : { stopAt: ceiling },
+				...options?.maxDepth === void 0 ? {} : { maxDepth: options.maxDepth }
+			});
 			const found = yield* Walker.findRoot(chain, isWorkspaceRoot);
 			if (Option.isNone(found)) return yield* Effect.fail(new WorkspaceRootNotFoundError({
 				searchPath: start,
-				markers: WORKSPACE_MARKERS
+				markers: WORKSPACE_MARKERS,
+				...ceiling === void 0 ? {} : { stopAt: ceiling }
 			}));
 			yield* Effect.logDebug("Workspace root found").pipe(Effect.annotateLogs("workspace.root", found.value));
 			return found.value;
 		});
-		return { find: (cwd) => find(cwd).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path)) };
+		return { find: (cwd, options) => find(cwd, options).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path)) };
 	});
 	/** The live layer. */
 	static layer = Layer.effect(WorkspaceRoot, WorkspaceRoot.make);
+	/**
+	* A test double resolving every `find` to `root`, with no filesystem.
+	*
+	* @remarks
+	* The nine-copies-of-a-four-line-mock case — a `Layer.succeed` over a `find`
+	* that ignores its arguments and succeeds with a fixed root is what consumers
+	* were writing by hand. The difference is that this double **honours
+	* `stopAt`**: a hand-rolled `find` that ignores the ceiling makes a bounded
+	* call pass under test and fail against the live service, which is the
+	* failure mode the option exists to catch. A `root` above the ceiling fails
+	* here exactly as it would live, with the same
+	* {@link WorkspaceRootNotFoundError}.
+	*
+	* The ceiling is `path.resolve`d through the injected `Path` service before
+	* the comparison, exactly as the live `make` path does — so a `stopAt`
+	* carrying `..` segments bounds the double identically to the live service,
+	* not by raw string. This is why `makeTest` yields an `Effect` requiring
+	* `Path`: it captures the service once at construction, the same shape as
+	* `make`. Consumers reach for {@link WorkspaceRoot.layerTest}, which provides
+	* `Path.layer` internally, so the requirement never surfaces at their call
+	* site.
+	*
+	* `maxDepth` is deliberately NOT modelled: the double does not walk, so it has
+	* no depth to cap, and pretending otherwise would encode a fiction. A suite
+	* exercising the depth guard wants the live service over a fixture tree.
+	*
+	* @param root - The root every unbounded `find` resolves to.
+	*/
+	static makeTest = (root) => Effect.gen(function* () {
+		const path = yield* Path.Path;
+		return { find: (cwd, options) => options?.stopAt !== void 0 && !isAtOrBelow(root, path.resolve(options.stopAt)) ? Effect.fail(new WorkspaceRootNotFoundError({
+			searchPath: cwd,
+			markers: WORKSPACE_MARKERS,
+			stopAt: options.stopAt
+		})) : Effect.succeed(root) };
+	});
+	/**
+	* The test layer: {@link WorkspaceRoot.makeTest} with `Path.layer` provided.
+	*
+	* @remarks
+	* `makeTest` requires `Path` to normalize the `stopAt` ceiling; this layer
+	* supplies core's `Path.layer` internally, so the requirement never reaches a
+	* consumer — the published type stays `Layer.Layer<WorkspaceRoot>`.
+	*
+	* 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.
+	*
+	* Pair it with `WorkspaceDiscovery.layerTest` to stand up the whole discovery
+	* path without a filesystem; between them there is nothing left for a
+	* module-level mock of `@effected/workspaces` to do, and a provided layer
+	* keeps the service graph — and its typed errors — intact.
+	*
+	* @example
+	* ```ts
+	* import { WorkspaceDiscovery, WorkspaceRoot } from "@effected/workspaces";
+	* import { Effect } from "effect";
+	*
+	* const TestRoot = WorkspaceRoot.layerTest("/repo");
+	* const TestDiscovery = WorkspaceDiscovery.layerTest({
+	*   listPackages: () => Effect.succeed([]),
+	* });
+	* // program.pipe(Effect.provide(TestRoot), Effect.provide(TestDiscovery))
+	* ```
+	*/
+	static layerTest = (root) => Layer.effect(WorkspaceRoot, WorkspaceRoot.makeTest(root)).pipe(Layer.provide(Path.layer));
 };
 
 //#endregion

package/WorkspacesSync.js

@@ -113,7 +113,7 @@ const readPatternsSync = (options, root) => {
 	return manifestPatternsOf(readJson(fileSystem, path.join(root, "package.json")) ?? {});
 };
 /** Build a `WorkspacePackage` from a directory, or `null` if its manifest is unusable. */
-const readPackageSync = (options, directory, relativePath) => {
+const readPackageSync = (options, root, directory, relativePath) => {
 	const packageJsonPath = options.path.join(directory, "package.json");
 	const raw = readJson(options.fileSystem, packageJsonPath);
 	if (raw === void 0) return null;
@@ -130,6 +130,7 @@ const readPackageSync = (options, directory, relativePath) => {
 		path: directory,
 		packageJsonPath,
 		relativePath,
+		workspaceRoot: root,
 		private: raw.private === true,
 		dependencies: stringRecord(raw.dependencies) ?? {},
 		devDependencies: stringRecord(raw.devDependencies) ?? {},
@@ -233,10 +234,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(options, absolute, relativePath);
+		const pkg = readPackageSync(options, root, absolute, relativePath);
 		if (pkg !== null) members.push(pkg);
 	}
-	const rootPackage = readPackageSync(options, root, ".");
+	const rootPackage = readPackageSync(options, root, root, ".");
 	return rootPackage === null ? members : [rootPackage, ...members];
 };
 

package/index.d.ts

@@ -90,6 +90,21 @@ declare const WorkspacePackage_base: Schema.Class<WorkspacePackage, Schema.Struc
   readonly packageJsonPath: Schema.NonEmptyString;
   /** POSIX path relative to the workspace root; `"."` for the root package. */
   readonly relativePath: Schema.String;
+  /**
+   * Absolute path to the workspace root this package was discovered under.
+   *
+   * @remarks
+   * Carried, not derived. Whoever built this value already knew the root —
+   * `WorkspaceDiscovery` resolved it before enumerating, and the sync entry
+   * point is handed it — so dropping it forced every consumer into per-package
+   * root arithmetic (counting `relativePath` segments and re-ascending that
+   * many `..`). That reconstruction is exact only while `path` and
+   * `relativePath` agree, and it re-derives something the kit never had to
+   * lose.
+   *
+   * For the root package this equals `path`, and `relativePath` is `"."`.
+   */
+  readonly workspaceRoot: Schema.NonEmptyString;
   /** Whether the package is marked private. */
   readonly private: Schema.withConstructorDefault<Schema.withDecodingDefaultKey<Schema.Boolean, never>>;
   /** Production dependencies. */
@@ -135,10 +150,12 @@ declare const WorkspacePackage_base: Schema.Class<WorkspacePackage, Schema.Struc
  *   path: "/repo/packages/utils",
  *   packageJsonPath: "/repo/packages/utils/package.json",
  *   relativePath: "packages/utils",
+ *   workspaceRoot: "/repo",
  * });
  *
  * pkg.isRootWorkspace; // false
  * pkg.unscopedName;    // "utils"
+ * pkg.workspaceRoot;   // "/repo"
  * ```
  *
  * @public
@@ -212,11 +229,53 @@ declare class WorkspacePackage extends WorkspacePackage_base {
  * @public
  */
 declare const WORKSPACE_MARKERS: ReadonlyArray<string>;
+/**
+ * Options for {@link WorkspaceRoot}'s `find`.
+ *
+ * @remarks
+ * Both bounds are passed straight through to `@effected/walker`'s
+ * `Walker.ascend`; this package does not re-decide either.
+ *
+ * @public
+ */
+interface FindWorkspaceRootOptions {
+  /**
+   * A ceiling directory. The ascent stops after probing it, so an unmarked
+   * `stopAt` fails typed as {@link WorkspaceRootNotFoundError} rather than
+   * silently escaping into an enclosing repository.
+   *
+   * @remarks
+   * Resolved to an absolute path before comparison, exactly as `cwd` is — a
+   * relative or non-normalized ceiling that never string-matched an ancestor
+   * would reintroduce the unbounded ascent it was passed to prevent.
+   */
+  readonly stopAt?: string;
+  /**
+   * Hard cap on the number of directories probed.
+   *
+   * @remarks
+   * A non-integer or non-positive value is a **defect**, not a typed failure —
+   * it is developer wiring, and walker's guard raises it.
+   *
+   * @defaultValue 256
+   */
+  readonly maxDepth?: number;
+}
 declare const WorkspaceRootNotFoundError_base: Schema.Class<WorkspaceRootNotFoundError, Schema.TaggedStruct<"WorkspaceRootNotFoundError", {
   /** The directory the ascent started from. */
   readonly searchPath: Schema.String;
   /** The marker filenames probed at each ancestor. */
   readonly markers: Schema.$Array<Schema.String>;
+  /**
+   * The resolved ceiling the ascent was bounded by, when one was supplied.
+   *
+   * @remarks
+   * Absent means the ascent ran to the filesystem root. Its presence is what
+   * lets a caller tell "there is no workspace root anywhere above me" from
+   * "there is none below the ceiling I set" — two failures that otherwise
+   * render identically.
+   */
+  readonly stopAt: Schema.optionalKey<Schema.String>;
 }>, import("effect/Cause").YieldableError>;
 /**
  * Raised when no workspace root can be found by ascending from a directory.
@@ -228,18 +287,32 @@ declare const WorkspaceRootNotFoundError_base: Schema.Class<WorkspaceRootNotFoun
  * @public
  */
 declare class WorkspaceRootNotFoundError extends WorkspaceRootNotFoundError_base {
-  /** Renders the search path and probed markers into a one-line message. */
+  /** Renders the search path, probed markers and any ceiling into a one-line message. */
   get message(): string;
 }
-declare const WorkspaceRoot_base: Context.ServiceClass<WorkspaceRoot, "@effected/workspaces/WorkspaceRoot", {
+/**
+ * The {@link WorkspaceRoot} service contract.
+ *
+ * @remarks
+ * Named so a consumer can type its own double — or a `Layer.succeed` — against
+ * the contract rather than re-deriving it, exactly as `WorkspaceDiscoveryShape`
+ * does. Prefer {@link WorkspaceRoot.layerTest} to hand-rolling one.
+ *
+ * @public
+ */
+interface WorkspaceRootShape {
   /**
    * The nearest workspace root at or above `cwd`.
    *
    * @param cwd - The directory to start the ascent from; resolved to an
    *   absolute path first.
+   * @param options - Optional ascent bounds. Unbounded by default, which
+   *   walks to the filesystem root and can therefore resolve to an enclosing
+   *   repository's root; pass `stopAt` when the caller knows the ceiling.
    */
-  readonly find: (cwd: string) => Effect.Effect<string, WorkspaceRootNotFoundError>;
-}>;
+  readonly find: (cwd: string, options?: FindWorkspaceRootOptions) => Effect.Effect<string, WorkspaceRootNotFoundError>;
+}
+declare const WorkspaceRoot_base: Context.ServiceClass<WorkspaceRoot, "@effected/workspaces/WorkspaceRoot", WorkspaceRootShape>;
 /**
  * Locates the workspace root by ascending from a starting directory.
  *
@@ -254,15 +327,86 @@ declare const WorkspaceRoot_base: Context.ServiceClass<WorkspaceRoot, "@effected
  * });
  * ```
  *
+ * @example
+ * Bounded: an unmarked fixture directory fails typed instead of escaping into
+ * the enclosing repository.
+ *
+ * ```ts
+ * import { WorkspaceRoot } from "@effected/workspaces";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const roots = yield* WorkspaceRoot;
+ *   return yield* roots.find("/tmp/fixture/packages/a", { stopAt: "/tmp/fixture" });
+ * });
+ * ```
+ *
  * @public
  */
 declare class WorkspaceRoot extends WorkspaceRoot_base {
   /** Builds the service over core `FileSystem` and `Path`. */
-  static readonly make: Effect.Effect<{
-    readonly find: (cwd: string) => Effect.Effect<string, WorkspaceRootNotFoundError>;
-  }, never, FileSystem.FileSystem | Path.Path>;
+  static readonly make: Effect.Effect<WorkspaceRootShape, never, FileSystem.FileSystem | Path.Path>;
   /** The live layer. */
   static readonly layer: Layer.Layer<WorkspaceRoot, never, FileSystem.FileSystem | Path.Path>;
+  /**
+   * A test double resolving every `find` to `root`, with no filesystem.
+   *
+   * @remarks
+   * The nine-copies-of-a-four-line-mock case — a `Layer.succeed` over a `find`
+   * that ignores its arguments and succeeds with a fixed root is what consumers
+   * were writing by hand. The difference is that this double **honours
+   * `stopAt`**: a hand-rolled `find` that ignores the ceiling makes a bounded
+   * call pass under test and fail against the live service, which is the
+   * failure mode the option exists to catch. A `root` above the ceiling fails
+   * here exactly as it would live, with the same
+   * {@link WorkspaceRootNotFoundError}.
+   *
+   * The ceiling is `path.resolve`d through the injected `Path` service before
+   * the comparison, exactly as the live `make` path does — so a `stopAt`
+   * carrying `..` segments bounds the double identically to the live service,
+   * not by raw string. This is why `makeTest` yields an `Effect` requiring
+   * `Path`: it captures the service once at construction, the same shape as
+   * `make`. Consumers reach for {@link WorkspaceRoot.layerTest}, which provides
+   * `Path.layer` internally, so the requirement never surfaces at their call
+   * site.
+   *
+   * `maxDepth` is deliberately NOT modelled: the double does not walk, so it has
+   * no depth to cap, and pretending otherwise would encode a fiction. A suite
+   * exercising the depth guard wants the live service over a fixture tree.
+   *
+   * @param root - The root every unbounded `find` resolves to.
+   */
+  static readonly makeTest: (root: string) => Effect.Effect<WorkspaceRootShape, never, Path.Path>;
+  /**
+   * The test layer: {@link WorkspaceRoot.makeTest} with `Path.layer` provided.
+   *
+   * @remarks
+   * `makeTest` requires `Path` to normalize the `stopAt` ceiling; this layer
+   * supplies core's `Path.layer` internally, so the requirement never reaches a
+   * consumer — the published type stays `Layer.Layer<WorkspaceRoot>`.
+   *
+   * 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.
+   *
+   * Pair it with `WorkspaceDiscovery.layerTest` to stand up the whole discovery
+   * path without a filesystem; between them there is nothing left for a
+   * module-level mock of `@effected/workspaces` to do, and a provided layer
+   * keeps the service graph — and its typed errors — intact.
+   *
+   * @example
+   * ```ts
+   * import { WorkspaceDiscovery, WorkspaceRoot } from "@effected/workspaces";
+   * import { Effect } from "effect";
+   *
+   * const TestRoot = WorkspaceRoot.layerTest("/repo");
+   * const TestDiscovery = WorkspaceDiscovery.layerTest({
+   *   listPackages: () => Effect.succeed([]),
+   * });
+   * // program.pipe(Effect.provide(TestRoot), Effect.provide(TestDiscovery))
+   * ```
+   */
+  static readonly layerTest: (root: string) => Layer.Layer<WorkspaceRoot>;
 }
 //#endregion
 //#region src/WorkspaceDiscovery.d.ts
@@ -478,6 +622,7 @@ declare class WorkspaceDiscovery extends WorkspaceDiscovery_base {
    *         path: "/repo/packages/utils",
    *         packageJsonPath: "/repo/packages/utils/package.json",
    *         relativePath: "packages/utils",
+   *         workspaceRoot: "/repo",
    *       }),
    *     ]),
    * });
@@ -704,9 +849,13 @@ declare class ConfigDependencyHooks extends ConfigDependencyHooks_base {
    * `hooks`-source `CatalogAssemblyError`, never a silent skip.
    *
    * @remarks
-   * Node-coupled by design — the `node:fs` / `node:path` / `node:url` imports are
-   * the sanctioned Node-only overlay, matching the other seams here. Only ever
-   * wired by `WorkspaceCatalogs.layerWithConfigDependencies`.
+   * Runtime-coupled by design, not node-exclusive. The `import()` below loads
+   * **and executes** a config dependency's pnpmfile in-process — code execution,
+   * not IO, so no `FileSystem` / `Path` service abstracts it. The `node:path` and
+   * `node:url` imports (`join`, `pathToFileURL`) exist only to build the URL that
+   * `import()` consumes; node and bun both implement those builtins and dynamic
+   * import, so this layer runs on either runtime. Only ever wired by
+   * `WorkspaceCatalogs.layerWithConfigDependencies`.
    */
   static readonly layerLive: Layer.Layer<ConfigDependencyHooks>;
 }
@@ -1782,5 +1931,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 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 FindWorkspaceRootOptions, 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 WorkspaceRootShape, 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/workspaces",
-	"version": "0.4.1",
+	"version": "0.5.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": [
@@ -47,13 +47,13 @@
 	},
 	"dependencies": {
 		"@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",
+		"@effected/glob": "0.2.0",
+		"@effected/lockfiles": "0.1.6",
+		"@effected/npm": "0.2.2",
+		"@effected/package-json": "0.4.0",
+		"@effected/semver": "0.2.0",
+		"@effected/walker": "0.3.0",
+		"@effected/yaml": "0.5.0",
 		"@pnpm/catalogs.config": "^1100.0.0",
 		"@pnpm/catalogs.protocol-parser": "^1100.0.0",
 		"@pnpm/catalogs.resolver": "^1100.0.0",