@effected/workspaces 0.1.0

package/WorkspaceDiscovery.js

@@ -0,0 +1,338 @@
+import { enumerate } from "./internal/enumerate.js";
+import { readPatterns } from "./internal/patterns.js";
+import { WorkspacePackage } from "./WorkspacePackage.js";
+import { WorkspaceRoot } from "./WorkspaceRoot.js";
+import { Context, Duration, Effect, Exit, FileSystem, Layer, Option, Path, Schema } from "effect";
+import { GlobSet } from "@effected/glob";
+import { DependencyResolutionError, WorkspaceResolver } from "@effected/npm";
+
+//#region src/WorkspaceDiscovery.ts
+/**
+* Raised when a workspace member's `package.json` cannot be read, parsed, or
+* used — it is missing, malformed, or lacks a `name` or `version`.
+*
+* @remarks
+* `kind` is the discriminant a caller branches on; `cause` preserves the
+* originating failure rather than flattening it into a sentence.
+*
+* @public
+*/
+var WorkspaceDiscoveryError = class extends Schema.TaggedErrorClass()("WorkspaceDiscoveryError", {
+	/** The workspace root discovery was running against. */
+	root: Schema.String,
+	/** The file that failed. */
+	path: Schema.String,
+	/** What went wrong with it. */
+	kind: Schema.Literals([
+		"read",
+		"invalidJson",
+		"invalidShape",
+		"invalidYaml",
+		"missingName",
+		"missingVersion"
+	]),
+	/** The originating failure, if there was one. */
+	cause: Schema.Defect()
+}) {
+	/** Renders the failing file and kind into a one-line message. */
+	get message() {
+		return `Workspace discovery failed at ${this.path} (${this.kind})`;
+	}
+};
+/**
+* Raised when a `packages:` pattern cannot be enumerated: its base directory is
+* absent (usually a typo), the descent exceeded its depth cap, or the visit
+* budget was exhausted.
+*
+* @public
+*/
+var WorkspacePatternError = class extends Schema.TaggedErrorClass()("WorkspacePatternError", {
+	/** The workspace root the patterns were expanded against. */
+	root: Schema.String,
+	/** The offending pattern, verbatim. */
+	pattern: Schema.String,
+	/** Why it could not be enumerated. */
+	kind: Schema.Literals([
+		"missingBaseDir",
+		"uncompilable",
+		"depthExceeded",
+		"budgetExceeded",
+		"unreadableDirectory"
+	]),
+	/** A short, structured detail — the missing directory, or the bound exceeded. */
+	detail: Schema.String
+}) {
+	/** Renders the pattern and failure kind into a one-line message. */
+	get message() {
+		return `Workspace pattern "${this.pattern}" could not be enumerated (${this.kind}: ${this.detail})`;
+	}
+};
+/**
+* Raised when a workspace package is requested by a name no member carries.
+*
+* @remarks
+* `available` lists every known member, which is what makes the error
+* actionable — a typo is obvious next to the list it missed.
+*
+* @public
+*/
+var PackageNotFoundError = class extends Schema.TaggedErrorClass()("PackageNotFoundError", {
+	/** The name that was requested. */
+	name: Schema.String,
+	/** Every workspace package name that does exist. */
+	available: Schema.Array(Schema.String)
+}) {
+	/** Renders the requested name into a one-line message. */
+	get message() {
+		return `No workspace package named "${this.name}"`;
+	}
+};
+/**
+* Top-level facts about a workspace: where it is, what manages it, and the
+* patterns that define its membership.
+*
+* @public
+*/
+var WorkspaceInfo = class extends Schema.Class("WorkspaceInfo")({
+	/** Absolute path to the workspace root. */
+	root: Schema.String,
+	/** The `packages:` patterns, verbatim. */
+	patterns: Schema.Array(Schema.String)
+}) {};
+/** The enumeration failure kinds map straight onto the pattern-error kinds. */
+const patternKindOf = (kind) => kind;
+/**
+* Discovers the packages of a workspace.
+*
+* @remarks
+* Layer construction is O(1): the root walk, pattern read, enumeration and
+* per-package decode all happen on the first method call and are memoized for
+* the lifetime of the layer. A Vitest reporter that builds the layer per call
+* site and never queries it pays nothing.
+*
+* The memo is **success-only**. `Effect.cached` memoizes the first `Exit`,
+* *including an interrupt* — an init interrupted by an unrelated timeout would
+* otherwise brick the layer permanently with a cause outside its declared error
+* channel. A failure or interrupt is therefore retried on the next call, which
+* is a deliberate behaviour change from the v3 library.
+*
+* @example
+* ```ts
+* import { WorkspaceDiscovery } from "@effected/workspaces";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   const discovery = yield* WorkspaceDiscovery;
+*   const packages = yield* discovery.listPackages();
+*   return packages.map((p) => p.name);
+* });
+* ```
+*
+* @public
+*/
+var WorkspaceDiscovery = class WorkspaceDiscovery extends Context.Service()("@effected/workspaces/WorkspaceDiscovery") {
+	/**
+	* Builds the service. Root resolution is one explicit concern: `cwd` is an
+	* option here, never an ambient `process.cwd()` read inside a method.
+	*/
+	static make = (options) => Effect.gen(function* () {
+		const roots = yield* WorkspaceRoot;
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		/** Read one `package.json` into the tolerant discovery projection. */
+		const readPackage = (root, directory, relativePath) => Effect.gen(function* () {
+			const packageJsonPath = path.join(directory, "package.json");
+			const content = yield* fs.readFileString(packageJsonPath).pipe(Effect.mapError((cause) => new WorkspaceDiscoveryError({
+				root,
+				path: packageJsonPath,
+				kind: "read",
+				cause
+			})));
+			const parsed = yield* Effect.try({
+				try: () => JSON.parse(content),
+				catch: (cause) => new WorkspaceDiscoveryError({
+					root,
+					path: packageJsonPath,
+					kind: "invalidJson",
+					cause
+				})
+			});
+			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return yield* Effect.fail(new WorkspaceDiscoveryError({
+				root,
+				path: packageJsonPath,
+				kind: "invalidShape",
+				cause: /* @__PURE__ */ new Error("package.json is not a JSON object")
+			}));
+			const raw = parsed;
+			const name = raw.name;
+			if (typeof name !== "string" || name.length === 0) return yield* Effect.fail(new WorkspaceDiscoveryError({
+				root,
+				path: packageJsonPath,
+				kind: "missingName",
+				cause: void 0
+			}));
+			const version = raw.version;
+			if (typeof version !== "string" || version.length === 0) return yield* Effect.fail(new WorkspaceDiscoveryError({
+				root,
+				path: packageJsonPath,
+				kind: "missingVersion",
+				cause: void 0
+			}));
+			return yield* Schema.decodeUnknownEffect(WorkspacePackage)({
+				name,
+				version,
+				path: directory,
+				packageJsonPath,
+				relativePath,
+				...typeof raw.private === "boolean" ? { private: raw.private } : {},
+				...isStringRecord(raw.dependencies) ? { dependencies: raw.dependencies } : {},
+				...isStringRecord(raw.devDependencies) ? { devDependencies: raw.devDependencies } : {},
+				...isStringRecord(raw.peerDependencies) ? { peerDependencies: raw.peerDependencies } : {},
+				...isStringRecord(raw.optionalDependencies) ? { optionalDependencies: raw.optionalDependencies } : {},
+				...raw.publishConfig !== void 0 && raw.publishConfig !== null ? { publishConfig: raw.publishConfig } : {}
+			}).pipe(Effect.catchTag("SchemaError", (cause) => new WorkspaceDiscoveryError({
+				root,
+				path: packageJsonPath,
+				kind: "invalidShape",
+				cause
+			})));
+		});
+		const discover = Effect.gen(function* () {
+			const root = yield* Effect.suspend(() => roots.find(options?.cwd ?? process.cwd()));
+			const patterns = yield* readPatterns(root).pipe(Effect.mapError((failure) => new WorkspaceDiscoveryError({
+				root,
+				path: failure.path,
+				kind: failure.kind,
+				cause: failure.cause
+			})));
+			const directories = yield* enumerate(root, yield* GlobSet.compile(patterns).pipe(Effect.mapError((error) => new WorkspacePatternError({
+				root,
+				pattern: error.pattern,
+				kind: "uncompilable",
+				detail: error.message
+			}))), { maxDepth: options?.maxDepth ?? 32 }).pipe(Effect.mapError((failure) => new WorkspacePatternError({
+				root,
+				pattern: failure.pattern,
+				kind: patternKindOf(failure.kind),
+				detail: failure.detail
+			})));
+			const members = yield* Effect.forEach(directories.filter((entry) => entry.relativePath !== "." && entry.path !== root), (entry) => readPackage(root, entry.path, entry.relativePath), { concurrency: 10 });
+			const packages = [yield* readPackage(root, root, "."), ...members];
+			yield* Effect.logDebug("Workspace packages discovered").pipe(Effect.annotateLogs({
+				"workspace.root": root,
+				"workspace.packages.count": packages.length
+			}));
+			return {
+				info: WorkspaceInfo.make({
+					root,
+					patterns
+				}),
+				packages
+			};
+		}).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
+		const [resolveOnce, invalidate] = yield* Effect.cachedInvalidateWithTTL(discover, Duration.infinity);
+		const memo = Effect.onExit(resolveOnce, (exit) => Exit.isSuccess(exit) ? Effect.void : invalidate);
+		const packages = memo.pipe(Effect.map((state) => state.packages));
+		/**
+		* The longest-prefix index, built once per package list.
+		*
+		* Keyed on the package array's identity: the memo hands back the *same*
+		* array on every call, so this is a hit for the whole life of the memo, and
+		* `refresh()` produces a fresh array — a cache miss — which is exactly the
+		* invalidation we want. No staleness is representable.
+		*/
+		const ownerIndexes = /* @__PURE__ */ new WeakMap();
+		const owners = (all) => {
+			const cached = ownerIndexes.get(all);
+			if (cached !== void 0) return cached;
+			const index = all.map((pkg) => ({
+				prefix: pkg.path.endsWith(path.sep) ? pkg.path : pkg.path + path.sep,
+				package: pkg
+			})).sort((a, b) => b.prefix.length - a.prefix.length);
+			ownerIndexes.set(all, index);
+			return index;
+		};
+		const ownerOf = (filePath, index) => {
+			for (const entry of index) if (filePath.startsWith(entry.prefix)) return Option.some(entry.package);
+			return Option.none();
+		};
+		return {
+			info: Effect.fn("WorkspaceDiscovery.info")(function* () {
+				return (yield* memo).info;
+			}),
+			listPackages: Effect.fn("WorkspaceDiscovery.listPackages")(function* () {
+				return yield* packages;
+			}),
+			importerMap: Effect.fn("WorkspaceDiscovery.importerMap")(function* () {
+				const all = yield* packages;
+				return new Map(all.map((pkg) => [pkg.relativePath, pkg]));
+			}),
+			getPackage: Effect.fn("WorkspaceDiscovery.getPackage")(function* (name) {
+				const all = yield* packages;
+				const found = all.find((pkg) => pkg.name === name);
+				if (found !== void 0) return found;
+				return yield* Effect.fail(new PackageNotFoundError({
+					name,
+					available: all.map((pkg) => pkg.name)
+				}));
+			}),
+			resolveFile: Effect.fn("WorkspaceDiscovery.resolveFile")(function* (filePath) {
+				const all = yield* packages;
+				return ownerOf(filePath, owners(all));
+			}),
+			resolveFiles: Effect.fn("WorkspaceDiscovery.resolveFiles")(function* (filePaths) {
+				const all = yield* packages;
+				const index = owners(all);
+				const seen = /* @__PURE__ */ new Map();
+				for (const filePath of filePaths) {
+					const owner = ownerOf(filePath, index);
+					if (Option.isSome(owner)) seen.set(owner.value.name, owner.value);
+				}
+				return [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
+			}),
+			refresh: () => invalidate
+		};
+	});
+	/**
+	* The live layer.
+	*
+	* @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 `layer(...)` at each composition site.
+	*/
+	static layer = (options) => Layer.effect(WorkspaceDiscovery, WorkspaceDiscovery.make(options));
+	/**
+	* The real implementation of `@effected/npm`'s `WorkspaceResolver` contract
+	* — the one `@effected/package-json` declares but cannot fill.
+	*
+	* @remarks
+	* `versionOf` returns `Option.none()` for a name that is not a workspace
+	* member, per the contract's convention; the `DependencyResolutionError`
+	* channel is reserved for a failure of the resolution *mechanism* (an
+	* unfindable root, an unreadable manifest), never an ordinary miss.
+	*
+	* @example
+	* ```ts
+	* import { Package } from "@effected/package-json";
+	* import { WorkspaceDiscovery } from "@effected/workspaces";
+	* import { Layer } from "effect";
+	*
+	* const resolvers = WorkspaceDiscovery.workspaceResolver.pipe(
+	*   Layer.provide(WorkspaceDiscovery.layer()),
+	* );
+	* // `Package.resolve` now resolves `workspace:*` for real.
+	* ```
+	*/
+	static workspaceResolver = Layer.effect(WorkspaceResolver, Effect.gen(function* () {
+		const discovery = yield* WorkspaceDiscovery;
+		return { versionOf: (packageName) => discovery.listPackages().pipe(Effect.map((all) => Option.fromUndefinedOr(all.find((pkg) => pkg.name === packageName)?.version)), Effect.mapError((cause) => new DependencyResolutionError({
+			specifier: `workspace:${packageName}`,
+			cause
+		}))) };
+	}));
+};
+const isStringRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
+
+//#endregion
+export { PackageNotFoundError, WorkspaceDiscovery, WorkspaceDiscoveryError, WorkspaceInfo, WorkspacePatternError };

package/WorkspacePackage.js

@@ -0,0 +1,247 @@
+import { Effect, FileSystem, Option, Schema } from "effect";
+import { GlobPattern } from "@effected/glob";
+import { WorkspaceManifest } from "@effected/lockfiles";
+import { Package } from "@effected/package-json";
+
+//#region src/WorkspacePackage.ts
+const EMPTY = Object.freeze(Object.create(null));
+/**
+* The `publishConfig` fields workspace tooling reads.
+*
+* @remarks
+* Deliberately narrow. `@effected/package-json` models `publishConfig` as an
+* open `Record<string, unknown>` for round-trip fidelity, which preserves every
+* key but types none of them; this is the typed projection of the four that
+* decide *where and whether* a package publishes. Unknown keys are ignored, not
+* rejected.
+*
+* @public
+*/
+var PublishConfig = class extends Schema.Class("PublishConfig")({
+	/** Scoped-package visibility. Its presence overrides `private`. */
+	access: Schema.optionalKey(Schema.Literals(["public", "restricted"])),
+	/** The registry to publish to. */
+	registry: Schema.optionalKey(Schema.String),
+	/** A subdirectory to publish instead of the package root. */
+	directory: Schema.optionalKey(Schema.String),
+	/** The dist-tag to publish under. */
+	tag: Schema.optionalKey(Schema.String)
+}) {};
+const DependencyMap = Schema.Record(Schema.String, Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed(EMPTY)), Schema.withConstructorDefault(Effect.succeed(EMPTY)));
+/**
+* Raised when a workspace member's `package.json` cannot be read or decoded
+* into the strict `@effected/package-json` `Package` model.
+*
+* @remarks
+* Discovery itself never raises this — it uses the tolerant projection. Only
+* `WorkspacePackage.manifest` does, so opting into the strict model is an
+* explicit, individually recoverable step.
+*
+* @public
+*/
+var WorkspaceManifestError = class extends Schema.TaggedErrorClass()("WorkspaceManifestError", {
+	/** Absolute path to the `package.json` that failed. */
+	packageJsonPath: Schema.String,
+	/** Whether the file could not be read, or read but not decoded. */
+	kind: Schema.Literals(["read", "decode"]),
+	/** The originating failure, preserved rather than flattened to a string. */
+	cause: Schema.Defect()
+}) {
+	/** Renders the path and failure kind into a one-line message. */
+	get message() {
+		return `Failed to ${this.kind} package.json at ${this.packageJsonPath}`;
+	}
+};
+/**
+* A single package inside a workspace: the discovery-relevant slice of its
+* `package.json` plus its filesystem location.
+*
+* @remarks
+* Produced by `WorkspaceDiscovery` for every directory the `packages:` patterns
+* enumerate. The root package is always present with `relativePath` `"."`.
+*
+* @example
+* ```ts
+* import { WorkspacePackage } from "@effected/workspaces";
+*
+* const pkg = WorkspacePackage.make({
+*   name: "@my-org/utils",
+*   version: "1.0.0",
+*   path: "/repo/packages/utils",
+*   packageJsonPath: "/repo/packages/utils/package.json",
+*   relativePath: "packages/utils",
+* });
+*
+* pkg.isRootWorkspace; // false
+* pkg.unscopedName;    // "utils"
+* ```
+*
+* @public
+*/
+var WorkspacePackage = class WorkspacePackage extends Schema.Class("WorkspacePackage")({
+	/** The package name. */
+	name: Schema.NonEmptyString,
+	/** The raw `version` string — deliberately not semver-validated. */
+	version: Schema.String,
+	/** Absolute path to the package directory. */
+	path: Schema.NonEmptyString,
+	/** Absolute path to the package's `package.json`. */
+	packageJsonPath: Schema.NonEmptyString,
+	/** POSIX path relative to the workspace root; `"."` for the root package. */
+	relativePath: Schema.String,
+	/** Whether the package is marked private. */
+	private: Schema.Boolean.pipe(Schema.withDecodingDefaultKey(Effect.succeed(false)), Schema.withConstructorDefault(Effect.succeed(false))),
+	/** Production dependencies. */
+	dependencies: DependencyMap,
+	/** Development dependencies. */
+	devDependencies: DependencyMap,
+	/** Peer dependencies. */
+	peerDependencies: DependencyMap,
+	/** Optional dependencies. */
+	optionalDependencies: DependencyMap,
+	/** The `publishConfig` block, when present. */
+	publishConfig: Schema.optionalKey(PublishConfig)
+}) {
+	/** Whether this is the workspace root package. */
+	get isRootWorkspace() {
+		return this.relativePath === ".";
+	}
+	/** Whether the package is publishable in principle (not marked private). */
+	get isPublic() {
+		return !this.private;
+	}
+	/** The npm scope (`@org`), or `Option.none()` for an unscoped name. */
+	get scope() {
+		const match = /^(@[^/]+)\//.exec(this.name);
+		return match === null ? Option.none() : Option.some(match[1]);
+	}
+	/** The name with any scope stripped. */
+	get unscopedName() {
+		const slash = this.name.indexOf("/");
+		return this.name.startsWith("@") && slash !== -1 ? this.name.slice(slash + 1) : this.name;
+	}
+	/**
+	* Every dependency, merged across the four kinds.
+	*
+	* @remarks
+	* Precedence on a name declared in several kinds runs
+	* `dependencies` \> `devDependencies` \> `peerDependencies` \>
+	* `optionalDependencies`.
+	*/
+	get allDependencies() {
+		return {
+			...this.optionalDependencies,
+			...this.peerDependencies,
+			...this.devDependencies,
+			...this.dependencies
+		};
+	}
+	/** Whether `name` is a production dependency. */
+	hasDependency(name) {
+		return Object.hasOwn(this.dependencies, name);
+	}
+	/** Whether `name` is a development dependency. */
+	hasDevDependency(name) {
+		return Object.hasOwn(this.devDependencies, name);
+	}
+	/** Whether `name` is a peer dependency. */
+	hasPeerDependency(name) {
+		return Object.hasOwn(this.peerDependencies, name);
+	}
+	/** Whether `name` is an optional dependency. */
+	hasOptionalDependency(name) {
+		return Object.hasOwn(this.optionalDependencies, name);
+	}
+	/** Whether `name` appears in any of the four dependency kinds. */
+	hasAnyDependencyOn(name) {
+		return this.hasDependency(name) || this.hasDevDependency(name) || this.hasPeerDependency(name) || this.hasOptionalDependency(name);
+	}
+	/** The declared specifier for `name`, searched across all four kinds. */
+	dependencyVersion(name) {
+		const own = (map) => Object.hasOwn(map, name) ? map[name] : void 0;
+		const version = own(this.dependencies) ?? own(this.devDependencies) ?? own(this.peerDependencies) ?? own(this.optionalDependencies);
+		return version === void 0 ? Option.none() : Option.some(version);
+	}
+	/**
+	* Whether any dependency name matches `pattern` — the `minimatch` runtime
+	* dependency's one call site, now over `@effected/glob`'s vendored engine.
+	*
+	* @remarks
+	* A `GlobPattern` is total and free to test. A `string` is compiled on every
+	* call and an **uncompilable** literal throws: a glob written into a call
+	* site is developer wiring, not untrusted input, so it belongs in the defect
+	* channel rather than widening the typed channel every caller must branch
+	* on. Compile once with `GlobPattern.compile` and pass the result when
+	* testing many packages.
+	*
+	* @param pattern - A compiled pattern, or a source string to compile.
+	*/
+	matchesDependency(pattern) {
+		const compiled = typeof pattern === "string" ? GlobPattern.make({ source: pattern }) : pattern;
+		return Object.keys(this.allDependencies).some((dependency) => compiled.matches(dependency));
+	}
+	/** Compare this package's dependencies against `other`'s. */
+	dependencyDiff(other) {
+		const mine = this.allDependencies;
+		const theirs = other.allDependencies;
+		const added = {};
+		const removed = {};
+		const changed = {};
+		for (const [name, version] of Object.entries(mine)) if (!Object.hasOwn(theirs, name)) added[name] = version;
+		else if (theirs[name] !== version) changed[name] = {
+			from: theirs[name],
+			to: version
+		};
+		for (const [name, version] of Object.entries(theirs)) if (!Object.hasOwn(mine, name)) removed[name] = version;
+		return {
+			added,
+			removed,
+			changed
+		};
+	}
+	/**
+	* Project to `@effected/lockfiles`' `WorkspaceManifest` — the input shape of
+	* `LockfileIntegrity.compare`. Total.
+	*/
+	toWorkspaceManifest() {
+		return WorkspaceManifest.make({
+			name: this.name,
+			dependencies: this.dependencies,
+			devDependencies: this.devDependencies,
+			peerDependencies: this.peerDependencies,
+			optionalDependencies: this.optionalDependencies
+		});
+	}
+	/**
+	* Read and decode this package's `package.json` into the strict
+	* `@effected/package-json` `Package` model — the bridge from the
+	* tolerant discovery projection to the fully typed manifest.
+	*/
+	static manifest = Effect.fn("WorkspacePackage.manifest")(function* (self) {
+		const content = yield* (yield* FileSystem.FileSystem).readFileString(self.packageJsonPath).pipe(Effect.mapError((cause) => new WorkspaceManifestError({
+			packageJsonPath: self.packageJsonPath,
+			kind: "read",
+			cause
+		})));
+		const raw = yield* Effect.try({
+			try: () => JSON.parse(content),
+			catch: (cause) => new WorkspaceManifestError({
+				packageJsonPath: self.packageJsonPath,
+				kind: "decode",
+				cause
+			})
+		});
+		return yield* Package.decode(raw).pipe(Effect.mapError((cause) => new WorkspaceManifestError({
+			packageJsonPath: self.packageJsonPath,
+			kind: "decode",
+			cause
+		})));
+	});
+	/** Instance form of `WorkspacePackage.manifest`. */
+	manifest() {
+		return WorkspacePackage.manifest(this);
+	}
+};
+
+//#endregion
+export { PublishConfig, WorkspaceManifestError, WorkspacePackage };

package/WorkspaceRoot.js

@@ -0,0 +1,90 @@
+import { Context, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
+import { Walker } from "@effected/walker";
+
+//#region src/WorkspaceRoot.ts
+/**
+* The marker filenames {@link WorkspaceRoot} probes for, in priority order.
+*
+* @public
+*/
+const WORKSPACE_MARKERS = ["pnpm-workspace.yaml", "package.json"];
+/**
+* Raised when no workspace root can be found by ascending from a directory.
+*
+* @remarks
+* `markers` records what was probed, so the failure names the contract rather
+* than paraphrasing it in prose.
+*
+* @public
+*/
+var WorkspaceRootNotFoundError = class extends Schema.TaggedErrorClass()("WorkspaceRootNotFoundError", {
+	/** The directory the ascent started from. */
+	searchPath: Schema.String,
+	/** The marker filenames probed at each ancestor. */
+	markers: Schema.Array(Schema.String)
+}) {
+	/** Renders the search path and probed markers into a one-line message. */
+	get message() {
+		return `No workspace root above ${this.searchPath} (looked for ${this.markers.join(", ")})`;
+	}
+};
+/**
+* Whether `dir` is a workspace root: it holds a `pnpm-workspace.yaml`, or a
+* `package.json` with a `workspaces` field.
+*
+* A malformed root `package.json` is "not a root", not an error — the ascent
+* continues past it, matching walker's absorption contract.
+*/
+const isWorkspaceRoot = (dir) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	if (yield* fs.exists(path.join(dir, "pnpm-workspace.yaml")).pipe(Effect.orElseSucceed(() => false))) return true;
+	const packageJson = path.join(dir, "package.json");
+	if (!(yield* fs.exists(packageJson).pipe(Effect.orElseSucceed(() => false)))) return false;
+	const content = yield* fs.readFileString(packageJson).pipe(Effect.orElseSucceed(() => "{}"));
+	const parsed = yield* Effect.try({
+		try: () => JSON.parse(content),
+		catch: () => void 0
+	}).pipe(Effect.orElseSucceed(() => ({})));
+	return parsed.workspaces !== void 0 && parsed.workspaces !== null;
+});
+/**
+* Locates the workspace root by ascending from a starting directory.
+*
+* @example
+* ```ts
+* import { WorkspaceRoot } from "@effected/workspaces";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   const root = yield* WorkspaceRoot;
+*   return yield* root.find("/repo/packages/utils/src");
+* });
+* ```
+*
+* @public
+*/
+var WorkspaceRoot = class WorkspaceRoot extends Context.Service()("@effected/workspaces/WorkspaceRoot") {
+	/** Builds the service over core `FileSystem` and `Path`. */
+	static make = Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const find = Effect.fn("WorkspaceRoot.find")(function* (cwd) {
+			const start = path.resolve(cwd);
+			const chain = yield* Walker.ascend(start);
+			const found = yield* Walker.findRoot(chain, isWorkspaceRoot);
+			if (Option.isNone(found)) return yield* Effect.fail(new WorkspaceRootNotFoundError({
+				searchPath: start,
+				markers: WORKSPACE_MARKERS
+			}));
+			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)) };
+	});
+	/** The live layer. */
+	static layer = Layer.effect(WorkspaceRoot, WorkspaceRoot.make);
+};
+
+//#endregion
+export { WORKSPACE_MARKERS, WorkspaceRoot, WorkspaceRootNotFoundError };