@effected/workspaces 0.11.2 → 0.13.0

package/ConfigDependencyHooks.js

@@ -293,7 +293,10 @@ var ConfigDependencyHooks = class ConfigDependencyHooks extends Context.Service(
 				const candidatePath = join(root, "node_modules", ".pnpm-config", name, filename);
 				const candidateUrl = pathToFileURL(candidatePath).href;
 				const result = yield* Effect.result(Effect.tryPromise({
-					try: () => import(candidateUrl),
+					try: () => import(
+						/* webpackIgnore: true */
+						candidateUrl
+),
 					catch: (cause) => cause
 				}));
 				if (Result.isSuccess(result)) {

package/DependencyGraph.js

@@ -1,6 +1,6 @@
 import { WorkspacePackage } from "./WorkspacePackage.js";
 import { PackageNotFoundError } from "./WorkspaceDiscovery.js";
-import { Effect, Schema } from "effect";
+import { Effect, Graph, Schema } from "effect";
 
 //#region src/DependencyGraph.ts
 /**
@@ -8,9 +8,10 @@ import { Effect, Schema } from "effect";
 * because it contains a cycle.
 *
 * @remarks
-* `cycle` lists every package still carrying unsatisfied dependencies when
-* Kahn's algorithm stalls — the strongly-connected residue, sorted. It is the
-* set to break, not necessarily a single ordered loop.
+* `cycle` names the actual cycle members — the sorted union of every strongly
+* connected component with more than one package. Packages merely downstream
+* of a cycle are excluded, so it is exactly the set to break, not necessarily
+* a single ordered loop.
 *
 * @public
 */
@@ -165,7 +166,11 @@ packages: Schema.Array(WorkspacePackage) }) {
 	* the whole adjacency map per processed node. Each level is sorted
 	* lexicographically, so the output is deterministic.
 	*/
-	levels = Effect.fn("DependencyGraph.levels")(() => Effect.suspend(() => Effect.succeed(kahn(this.#index()))).pipe(Effect.flatMap((result) => result.stalled.length > 0 ? Effect.fail(new CyclicDependencyError({ cycle: result.stalled })) : Effect.succeed(result.levels))));
+	levels = Effect.fn("DependencyGraph.levels")(() => Effect.suspend(() => {
+		const edges = this.#index();
+		const result = kahn(edges);
+		return result.stalled.length > 0 ? Effect.fail(new CyclicDependencyError({ cycle: cycleMembers(edges) })) : Effect.succeed(result.levels);
+	}));
 	/** The flattened topological order — `levels()` concatenated. */
 	sort = Effect.fn("DependencyGraph.sort")(() => this.levels().pipe(Effect.map((levels) => levels.flat())));
 	/**
@@ -195,17 +200,78 @@ packages: Schema.Array(WorkspacePackage) }) {
 			subForward.set(node, deps);
 			for (const dep of deps) subReverse.get(dep)?.add(node);
 		}
-		const result = kahn({
+		const subEdges = {
 			forward: subForward,
 			reverse: subReverse
-		});
-		return result.stalled.length > 0 ? Effect.fail(new CyclicDependencyError({ cycle: result.stalled })) : Effect.succeed(result.levels.flat());
+		};
+		const result = kahn(subEdges);
+		return result.stalled.length > 0 ? Effect.fail(new CyclicDependencyError({ cycle: cycleMembers(subEdges) })) : Effect.succeed(result.levels.flat());
 	}));
+	/**
+	* The graph rendered as a Mermaid `flowchart TD`. Total.
+	*
+	* @remarks
+	* Renders through core's `Graph.toMermaid` over a transient graph built from
+	* the edge index. Node IDs are numeric indexes assigned in sorted-name order
+	* and package names appear only inside quoted labels, so scoped names
+	* (`@scope/a`) never break Mermaid syntax. Nodes and each node's edges are
+	* emitted in sorted order — the output is deterministic regardless of
+	* manifest key order.
+	*/
+	toMermaid() {
+		return Graph.toMermaid(materialize(this.#index()).graph, { edgeLabel: () => "" });
+	}
+};
+/**
+* Materializes the forward map into a transient core `Graph`: nodes in
+* sorted-name order (so `NodeIndex` *i* is `names[i]`) and each node's edges
+* in sorted-target order, making the graph — and everything derived from it —
+* deterministic for a given edge index.
+*/
+const materialize = (edges) => {
+	const names = [...edges.forward.keys()].sort();
+	return {
+		graph: Graph.directed((mutable) => {
+			const indexOf = /* @__PURE__ */ new Map();
+			for (const name of names) indexOf.set(name, Graph.addNode(mutable, name));
+			for (const name of names) {
+				const source = indexOf.get(name);
+				if (source === void 0) continue;
+				for (const dependency of [...edges.forward.get(name) ?? []].sort()) {
+					const target = indexOf.get(dependency);
+					if (target !== void 0) Graph.addEdge(mutable, source, target, "");
+				}
+			}
+		}),
+		names
+	};
+};
+/**
+* The packages participating in a dependency cycle — the sorted union of every
+* strongly connected component with more than one member, via core's
+* `Graph.stronglyConnectedComponents`. Self-edges are dropped at index time,
+* so a single-member component is never cyclic here.
+*/
+const cycleMembers = (edges) => {
+	const { graph, names } = materialize(edges);
+	const members = /* @__PURE__ */ new Set();
+	for (const component of Graph.stronglyConnectedComponents(graph)) {
+		if (component.length < 2) continue;
+		for (const index of component) {
+			const name = names[index];
+			if (name !== void 0) members.add(name);
+		}
+	}
+	return [...members].sort();
 };
 /**
 * Kahn's algorithm. `forward[A] = {B}` reads "A depends on B", so level 0 is
 * the set with an out-degree of zero and each completed level decrements its
 * dependents through the reverse index.
+*
+* A non-empty `stalled` only signals *that* a cycle exists — it holds every
+* unprocessed node, including ones merely downstream of a cycle. The error
+* payload names the actual members via `cycleMembers`.
 */
 const kahn = (edges) => {
 	const remaining = /* @__PURE__ */ new Map();

package/PackageManagerName.js

@@ -15,6 +15,35 @@ const PackageManagerName = Schema.Literals([
 	"bun"
 ]);
 /**
+* The markers {@link PackageManagerDetector} probes, in the priority order it
+* probes them.
+*
+* @remarks
+* One vocabulary serves both halves of the detection contract: the failure path
+* reports every member as `PackageManagerDetectionError.checked`, and the
+* success path reports the one that fired as
+* `DetectedPackageManager.evidence`. A closed literal union rather than
+* free text, so a consumer logging *why* a workspace was classified asserts
+* against the kit's vocabulary instead of re-deriving the probe with its own
+* filesystem reads.
+*
+* The `package.json#…` spellings name manifest *fields*; the rest are marker
+* files at the workspace root.
+*
+* @public
+*/
+const PackageManagerEvidence = Schema.Literals([
+	"pnpm-workspace.yaml",
+	"bun.lock",
+	"bun.lockb",
+	"yarn.lock",
+	"package.json#workspaces",
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"package.json#devEngines.packageManager",
+	"package.json#packageManager"
+]);
+/**
 * The outcome of package-manager detection at a workspace root.
 *
 * @remarks
@@ -25,6 +54,15 @@ const PackageManagerName = Schema.Literals([
 * `devEngines.packageManager`; see {@link PackageManagerDetector} for the
 * precedence between them.
 *
+* `evidence` is the rung of the priority order that decided the **name** — the
+* verdict's provenance, in the same vocabulary the failure path reports as
+* `PackageManagerDetectionError.checked`. For the bun and yarn rungs the
+* lockfile is the recorded signal even though the rung is a conjunction (the
+* lockfile *plus* a manifest field naming the manager): the manifest field alone
+* would have resolved in the declaration tier, so the lockfile is what this rung
+* added. The version's provenance is deliberately not carried — it follows the
+* two-field precedence above, which is a rule, not a probe.
+*
 * @public
 */
 var DetectedPackageManager = class extends Schema.Class("DetectedPackageManager")({
@@ -33,7 +71,9 @@ var DetectedPackageManager = class extends Schema.Class("DetectedPackageManager"
 	/** Its version, when a manifest field agrees on the manager and carries one. */
 	version: Schema.Option(Schema.String),
 	/** The JavaScript runtime the manager implies. */
-	runtime: Schema.Literals(["node", "bun"])
+	runtime: Schema.Literals(["node", "bun"]),
+	/** The rung of the priority order that decided the name. */
+	evidence: PackageManagerEvidence
 }) {};
 /** Whether `value` is a non-null, non-array object — corepack's own shape test. */
 const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -97,18 +137,11 @@ var PackageManagerDetectionError = class extends Schema.TaggedError()("PackageMa
 		return `No package manager detected at ${this.root} (checked ${this.checked.join(", ")})`;
 	}
 };
-/** The markers probed, in priority order. Exposed on the error so the contract is not prose-only. */
-const CHECKED = [
-	"pnpm-workspace.yaml",
-	"bun.lock",
-	"bun.lockb",
-	"yarn.lock",
-	"package.json#workspaces",
-	"pnpm-lock.yaml",
-	"package-lock.json",
-	"package.json#packageManager",
-	"package.json#devEngines.packageManager"
-];
+/**
+* The markers probed, in priority order. Derived from the evidence vocabulary so
+* the failure path's `checked` and the success path's `evidence` cannot drift.
+*/
+const CHECKED = PackageManagerEvidence.literals;
 /**
 * Detects which package manager owns a workspace root.
 *
@@ -219,44 +252,52 @@ var PackageManagerDetector = class PackageManagerDetector extends Context.Servic
 			if (yield* has(root, "pnpm-workspace.yaml")) return DetectedPackageManager.make({
 				name: "pnpm",
 				version: versionFor(hints, "pnpm"),
-				runtime: "node"
+				runtime: "node",
+				evidence: "pnpm-workspace.yaml"
 			});
-			const bunLock = (yield* has(root, "bun.lock")) || (yield* has(root, "bun.lockb"));
-			if (bunLock && namesManager(hints, "bun")) return DetectedPackageManager.make({
+			const bunLock = (yield* has(root, "bun.lock")) ? Option.some("bun.lock") : (yield* has(root, "bun.lockb")) ? Option.some("bun.lockb") : Option.none();
+			if (Option.isSome(bunLock) && namesManager(hints, "bun")) return DetectedPackageManager.make({
 				name: "bun",
 				version: versionFor(hints, "bun"),
-				runtime: "bun"
+				runtime: "bun",
+				evidence: bunLock.value
 			});
 			if ((yield* has(root, "yarn.lock")) && namesManager(hints, "yarn")) return DetectedPackageManager.make({
 				name: "yarn",
 				version: versionFor(hints, "yarn"),
-				runtime: "node"
+				runtime: "node",
+				evidence: "yarn.lock"
 			});
 			const workspaces = Option.map(manifest, (fields) => fields.workspaces);
 			if (Option.isSome(workspaces) && workspaces.value !== void 0 && workspaces.value !== null) return DetectedPackageManager.make({
 				name: "npm",
 				version: versionFor(hints, "npm"),
-				runtime: "node"
+				runtime: "node",
+				evidence: "package.json#workspaces"
 			});
 			if (yield* has(root, "pnpm-lock.yaml")) return DetectedPackageManager.make({
 				name: "pnpm",
 				version: versionFor(hints, "pnpm"),
-				runtime: "node"
+				runtime: "node",
+				evidence: "pnpm-lock.yaml"
 			});
-			if (bunLock && namesManager(hints, "bun")) return DetectedPackageManager.make({
+			if (Option.isSome(bunLock) && namesManager(hints, "bun")) return DetectedPackageManager.make({
 				name: "bun",
 				version: versionFor(hints, "bun"),
-				runtime: "bun"
+				runtime: "bun",
+				evidence: bunLock.value
 			});
 			if ((yield* has(root, "yarn.lock")) && namesManager(hints, "yarn")) return DetectedPackageManager.make({
 				name: "yarn",
 				version: versionFor(hints, "yarn"),
-				runtime: "node"
+				runtime: "node",
+				evidence: "yarn.lock"
 			});
 			if (yield* has(root, "package-lock.json")) return DetectedPackageManager.make({
 				name: "npm",
 				version: versionFor(hints, "npm"),
-				runtime: "node"
+				runtime: "node",
+				evidence: "package-lock.json"
 			});
 			const declared = declaredName(hints);
 			if (Option.isSome(declared)) {
@@ -264,7 +305,8 @@ var PackageManagerDetector = class PackageManagerDetector extends Context.Servic
 				if (name === "pnpm" || name === "npm" || name === "yarn" || name === "bun") return DetectedPackageManager.make({
 					name,
 					version: versionFor(hints, name),
-					runtime: name === "bun" ? "bun" : "node"
+					runtime: name === "bun" ? "bun" : "node",
+					evidence: Option.isSome(hints.devEngines) ? "package.json#devEngines.packageManager" : "package.json#packageManager"
 				});
 			}
 			return yield* Effect.fail(new PackageManagerDetectionError({
@@ -307,7 +349,12 @@ var PackageManagerDetector = class PackageManagerDetector extends Context.Servic
 	* const TestDetector = PackageManagerDetector.layerTest({
 	*   detect: () =>
 	*     Effect.succeed(
-	*       DetectedPackageManager.make({ name: "pnpm", version: Option.none(), runtime: "node" }),
+	*       DetectedPackageManager.make({
+	*         name: "pnpm",
+	*         version: Option.none(),
+	*         runtime: "node",
+	*         evidence: "pnpm-workspace.yaml",
+	*       }),
 	*     ),
 	* });
 	* ```
@@ -331,4 +378,4 @@ var PackageManagerDetector = class PackageManagerDetector extends Context.Servic
 };
 
 //#endregion
-export { DetectedPackageManager, PackageManagerDetectionError, PackageManagerDetector, PackageManagerName };
+export { DetectedPackageManager, PackageManagerDetectionError, PackageManagerDetector, PackageManagerEvidence, PackageManagerName };

package/README.md

@@ -70,7 +70,17 @@ Effect.runPromise(program.pipe(Effect.provide(WorkspacesLayer))).then(console.lo
 // [ [ ...names with no workspace dependencies ], [ ...names that depend only on level 0 ], ... ]
 ```
 
-`DependencyGraph` is a value class, not a service: build it from packages you already have. A cycle fails with `CyclicDependencyError` naming the packages that could not be ordered.
+`DependencyGraph` is a value class, not a service: build it from packages you already have. A cycle fails with `CyclicDependencyError`, whose `cycle` field names the packages actually in the cycle — the members of the strongly-connected components — and not the ones merely stalled behind it, which is the difference between a fix list and a suspect list.
+
+`toMermaid()` renders the same graph for a job summary, an issue or a design doc. It is total, deterministic (nodes and edges both in sorted order) and safe for scoped names, which appear only inside quoted labels:
+
+```ts
+console.log(graph.toMermaid());
+// flowchart TD
+//   0["@acme/app"]
+//   1["@acme/utils"]
+//   0 --> 1
+```
 
 ## Change detection
 
@@ -228,7 +238,7 @@ A name miss in the derived `getPackage` fails with the service's own typed `Pack
 - `WorkspaceRoot` — root discovery from a `cwd`, over `WORKSPACE_MARKERS`.
 - `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.
+- `DependencyGraph` — a value class over discovered packages: `levels()` for parallel build tiers, the flattened topological order, `toMermaid()` for a deterministic Mermaid `flowchart TD` of the whole graph, and `CyclicDependencyError` — naming the cycle's actual members — when there is no order.
 - `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; `releaseAgeGate()` assembles the effective `@effected/npm` `ReleaseAgeGate` from inline `pnpm-workspace.yaml` release-age keys and replayed hook contributions, strictest-wins, in the same pass as the catalogs.
 - `LockfileReader` — locate and parse the workspace's lockfile through `@effected/lockfiles`.

package/index.d.ts

@@ -960,9 +960,10 @@ declare const CyclicDependencyError_base: Schema.Class<CyclicDependencyError, Sc
  * because it contains a cycle.
  *
  * @remarks
- * `cycle` lists every package still carrying unsatisfied dependencies when
- * Kahn's algorithm stalls — the strongly-connected residue, sorted. It is the
- * set to break, not necessarily a single ordered loop.
+ * `cycle` names the actual cycle members — the sorted union of every strongly
+ * connected component with more than one package. Packages merely downstream
+ * of a cycle are excluded, so it is exactly the set to break, not necessarily
+ * a single ordered loop.
  *
  * @public
  */
@@ -1041,6 +1042,18 @@ declare class DependencyGraph extends DependencyGraph_base {
    * dependencies — the build order for a subset.
    */
   readonly sortSubset: (names: readonly string[]) => Effect.Effect<readonly string[], CyclicDependencyError | PackageNotFoundError, never>;
+  /**
+   * The graph rendered as a Mermaid `flowchart TD`. Total.
+   *
+   * @remarks
+   * Renders through core's `Graph.toMermaid` over a transient graph built from
+   * the edge index. Node IDs are numeric indexes assigned in sorted-name order
+   * and package names appear only inside quoted labels, so scoped names
+   * (`@scope/a`) never break Mermaid syntax. Nodes and each node's edges are
+   * emitted in sorted order — the output is deterministic regardless of
+   * manifest key order.
+   */
+  toMermaid(): string;
 }
 //#endregion
 //#region src/PackageManagerName.d.ts
@@ -1056,6 +1069,32 @@ declare const PackageManagerName: Schema.Literals<readonly ["npm", "pnpm", "yarn
  * @public
  */
 type PackageManagerName = typeof PackageManagerName.Type;
+/**
+ * The markers {@link PackageManagerDetector} probes, in the priority order it
+ * probes them.
+ *
+ * @remarks
+ * One vocabulary serves both halves of the detection contract: the failure path
+ * reports every member as `PackageManagerDetectionError.checked`, and the
+ * success path reports the one that fired as
+ * `DetectedPackageManager.evidence`. A closed literal union rather than
+ * free text, so a consumer logging *why* a workspace was classified asserts
+ * against the kit's vocabulary instead of re-deriving the probe with its own
+ * filesystem reads.
+ *
+ * The `package.json#…` spellings name manifest *fields*; the rest are marker
+ * files at the workspace root.
+ *
+ * @public
+ */
+declare const PackageManagerEvidence: Schema.Literals<readonly ["pnpm-workspace.yaml", "bun.lock", "bun.lockb", "yarn.lock", "package.json#workspaces", "pnpm-lock.yaml", "package-lock.json", "package.json#devEngines.packageManager", "package.json#packageManager"]>;
+/**
+ * The decoded type of {@link (PackageManagerEvidence:variable)}: the marker
+ * that decided a detection.
+ *
+ * @public
+ */
+type PackageManagerEvidence = typeof PackageManagerEvidence.Type;
 declare const DetectedPackageManager_base: Schema.Class<DetectedPackageManager, Schema.Struct<{
   /** The detected manager. */
   readonly name: Schema.Literals<readonly ["npm", "pnpm", "yarn", "bun"]>;
@@ -1063,6 +1102,8 @@ declare const DetectedPackageManager_base: Schema.Class<DetectedPackageManager,
   readonly version: Schema.Option<Schema.String>;
   /** The JavaScript runtime the manager implies. */
   readonly runtime: Schema.Literals<readonly ["node", "bun"]>;
+  /** The rung of the priority order that decided the name. */
+  readonly evidence: Schema.Literals<readonly ["pnpm-workspace.yaml", "bun.lock", "bun.lockb", "yarn.lock", "package.json#workspaces", "pnpm-lock.yaml", "package-lock.json", "package.json#devEngines.packageManager", "package.json#packageManager"]>;
 }>, {}>;
 /**
  * The outcome of package-manager detection at a workspace root.
@@ -1075,6 +1116,15 @@ declare const DetectedPackageManager_base: Schema.Class<DetectedPackageManager,
  * `devEngines.packageManager`; see {@link PackageManagerDetector} for the
  * precedence between them.
  *
+ * `evidence` is the rung of the priority order that decided the **name** — the
+ * verdict's provenance, in the same vocabulary the failure path reports as
+ * `PackageManagerDetectionError.checked`. For the bun and yarn rungs the
+ * lockfile is the recorded signal even though the rung is a conjunction (the
+ * lockfile *plus* a manifest field naming the manager): the manifest field alone
+ * would have resolved in the declaration tier, so the lockfile is what this rung
+ * added. The version's provenance is deliberately not carried — it follows the
+ * two-field precedence above, which is a rule, not a probe.
+ *
  * @public
  */
 declare class DetectedPackageManager extends DetectedPackageManager_base {}
@@ -1196,7 +1246,12 @@ declare class PackageManagerDetector extends PackageManagerDetector_base {
    * const TestDetector = PackageManagerDetector.layerTest({
    *   detect: () =>
    *     Effect.succeed(
-   *       DetectedPackageManager.make({ name: "pnpm", version: Option.none(), runtime: "node" }),
+   *       DetectedPackageManager.make({
+   *         name: "pnpm",
+   *         version: Option.none(),
+   *         runtime: "node",
+   *         evidence: "pnpm-workspace.yaml",
+   *       }),
    *     ),
    * });
    * ```
@@ -3017,5 +3072,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, type ClassifyOptions, ConfigDependencyHooks, type ConfigDependencyHooksShape, CyclicDependencyError, type DependencyDiff, DependencyGraph, DetectedPackageManager, type FindWorkspaceRootOptions, type GetWorkspacePackagesSyncOptions, type HookInjection, type ImporterVersions, LockfileReadError, type LockfileReadFailure, LockfileReader, type LockfileReaderOptions, type LockfileReaderShape, PackageManagerDetectionError, type PackageManagerDetectionFailure, PackageManagerDetector, type PackageManagerDetectorShape, PackageManagerName, PackageNotFoundError, type PackageRelease, PackageStateSnapshot, PublishConfig, PublishTarget, PublishabilityDetector, type PublishabilityDetectorShape, ReleaseTag, type SyncFileSystem, type SyncPath, type TagClassification, type TagFormatOptions, TagStyle, TrackingTag, type TrackingTagOptions, type VersioningDetectOptions, VersioningStrategy, VersioningStrategyType, 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, classifyTag, findWorkspaceRootSync, getWorkspacePackagesSync };
+export { type CatalogAssemblyFailure, CatalogSet, ChangeDetectionError, type ChangeDetectionFailure, ChangeDetectionOptions, ChangeDetector, type ChangeDetectorShape, type ClassifyOptions, ConfigDependencyHooks, type ConfigDependencyHooksShape, CyclicDependencyError, type DependencyDiff, DependencyGraph, DetectedPackageManager, type FindWorkspaceRootOptions, type GetWorkspacePackagesSyncOptions, type HookInjection, type ImporterVersions, LockfileReadError, type LockfileReadFailure, LockfileReader, type LockfileReaderOptions, type LockfileReaderShape, PackageManagerDetectionError, type PackageManagerDetectionFailure, PackageManagerDetector, type PackageManagerDetectorShape, PackageManagerEvidence, PackageManagerName, PackageNotFoundError, type PackageRelease, PackageStateSnapshot, PublishConfig, PublishTarget, PublishabilityDetector, type PublishabilityDetectorShape, ReleaseTag, type SyncFileSystem, type SyncPath, type TagClassification, type TagFormatOptions, TagStyle, TrackingTag, type TrackingTagOptions, type VersioningDetectOptions, VersioningStrategy, VersioningStrategyType, 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, classifyTag, findWorkspaceRootSync, getWorkspacePackagesSync };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -4,7 +4,7 @@ import { PackageNotFoundError, WorkspaceDiscovery, WorkspaceDiscoveryError, Work
 import { CyclicDependencyError, DependencyGraph } from "./DependencyGraph.js";
 import { ChangeDetectionError, ChangeDetectionOptions, ChangeDetector } from "./ChangeDetector.js";
 import { ConfigDependencyHooks } from "./ConfigDependencyHooks.js";
-import { DetectedPackageManager, PackageManagerDetectionError, PackageManagerDetector, PackageManagerName } from "./PackageManagerName.js";
+import { DetectedPackageManager, PackageManagerDetectionError, PackageManagerDetector, PackageManagerEvidence, PackageManagerName } from "./PackageManagerName.js";
 import { LockfileReadError, LockfileReader } from "./LockfileReader.js";
 import { PublishTarget, PublishabilityDetector } from "./Publishability.js";
 import { ReleaseTag, TagStyle, TrackingTag, classifyTag } from "./ReleaseTag.js";
@@ -15,4 +15,4 @@ import { WorkspaceSnapshots } from "./WorkspaceSnapshots.js";
 import { Workspaces } from "./Workspaces.js";
 import { findWorkspaceRootSync, getWorkspacePackagesSync } from "./WorkspacesSync.js";
 
-export { CatalogSet, ChangeDetectionError, ChangeDetectionOptions, ChangeDetector, ConfigDependencyHooks, CyclicDependencyError, DependencyGraph, DetectedPackageManager, LockfileReadError, LockfileReader, PackageManagerDetectionError, PackageManagerDetector, PackageManagerName, PackageNotFoundError, PackageStateSnapshot, PublishConfig, PublishTarget, PublishabilityDetector, ReleaseTag, TagStyle, TrackingTag, VersioningStrategy, VersioningStrategyType, WORKSPACE_MARKERS, WorkspaceCatalogs, WorkspaceDiscovery, WorkspaceDiscoveryError, WorkspaceInfo, WorkspaceManifestError, WorkspacePackage, WorkspacePatternError, WorkspaceRoot, WorkspaceRootNotFoundError, WorkspaceSnapshots, WorkspaceStateSnapshot, Workspaces, classifyTag, findWorkspaceRootSync, getWorkspacePackagesSync };
+export { CatalogSet, ChangeDetectionError, ChangeDetectionOptions, ChangeDetector, ConfigDependencyHooks, CyclicDependencyError, DependencyGraph, DetectedPackageManager, LockfileReadError, LockfileReader, PackageManagerDetectionError, PackageManagerDetector, PackageManagerEvidence, PackageManagerName, PackageNotFoundError, PackageStateSnapshot, PublishConfig, PublishTarget, PublishabilityDetector, ReleaseTag, TagStyle, TrackingTag, VersioningStrategy, VersioningStrategyType, WORKSPACE_MARKERS, WorkspaceCatalogs, WorkspaceDiscovery, WorkspaceDiscoveryError, WorkspaceInfo, WorkspaceManifestError, WorkspacePackage, WorkspacePatternError, WorkspaceRoot, WorkspaceRootNotFoundError, WorkspaceSnapshots, WorkspaceStateSnapshot, Workspaces, classifyTag, findWorkspaceRootSync, getWorkspacePackagesSync };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/workspaces",
-	"version": "0.11.2",
+	"version": "0.13.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,11 +47,11 @@
 	},
 	"dependencies": {
 		"@effected/commands": "^0.4.0",
-		"@effected/git": "^0.7.0",
+		"@effected/git": "^0.8.0",
 		"@effected/glob": "^0.3.0",
 		"@effected/lockfiles": "^0.4.1",
 		"@effected/npm": "^0.9.0",
-		"@effected/package-json": "^0.8.0",
+		"@effected/package-json": "^0.9.0",
 		"@effected/semver": "^0.4.0",
 		"@effected/walker": "^0.4.0",
 		"@effected/yaml": "^0.8.0",