@effected/workspaces 0.21.1 → 0.22.1

package/DuplicateCheck.js

@@ -0,0 +1,293 @@
+import { indexInstances, rootInstances } from "./internal/roots.js";
+import { Schema } from "effect";
+
+//#region src/DuplicateCheck.ts
+/**
+* Who pulls one resolved instance into the graph.
+*
+* @remarks
+* A tagged union a renderer narrows with `switch (dependent._tag)`:
+*
+* - `"importer"` — a workspace importer takes the instance directly; `path`
+*   is the importer path (`"."` for the root).
+* - `"package"` — a resolved package's own dependency edge points at the
+*   instance; `name` and `version` are that package's.
+*
+* An importer's dependencies are attributed to the importer by path even when
+* the lockfile records a workspace row for it — that row IS the importer, and
+* reporting it as a `"package"` would name a directory with a placeholder
+* version rather than the project that took the dependency.
+*
+* @public
+*/
+const Dependent = Schema.Union([Schema.TaggedStruct("importer", { path: Schema.NonEmptyString }), Schema.TaggedStruct("package", {
+	name: Schema.NonEmptyString,
+	version: Schema.String
+})]);
+/**
+* One resolved instance of a duplicated version, with everything that pulls it.
+*
+* @remarks
+* `dependents` is deduplicated and in lockfile order: importers first, in the
+* order the lockfile lists them, then packages in the order the lockfile lists
+* them. Two instances of one `name@version` that differ only by peer suffix
+* each get their own row, so the dependents of each variant stay attributed to
+* the variant they actually took.
+*
+* @public
+*/
+var DuplicateInstance = class extends Schema.Class("DuplicateInstance")({
+	/** The opaque instance id, as `@effected/lockfiles` records it. */
+	instanceId: Schema.NonEmptyString,
+	/** Every importer and package that pulls THIS copy. */
+	dependents: Schema.Array(Dependent)
+}) {};
+/**
+* One version a duplicated package resolved at.
+*
+* @public
+*/
+var DuplicatedVersion = class extends Schema.Class("DuplicatedVersion")({
+	/** The resolved version. */
+	version: Schema.String,
+	/** Every instance at this version — more than one when peer suffixes differ. */
+	instances: Schema.Array(DuplicateInstance)
+}) {};
+/**
+* One package name reached at two or more distinct versions.
+*
+* @remarks
+* `versions` always has at least two entries: a name resolved at one version
+* is never a duplicate, however many peer-suffix instances that version has.
+* Two instances of the same version load identical code and cannot produce the
+* type-identity skew this check exists to catch, so counting them would report
+* a problem nobody has.
+*
+* @public
+*/
+var DuplicatedPackage = class extends Schema.Class("DuplicatedPackage")({
+	/** The package name. */
+	name: Schema.NonEmptyString,
+	/** Every version it resolved at, in lockfile order. Never fewer than two. */
+	versions: Schema.Array(DuplicatedVersion)
+}) {};
+/**
+* The result of checking a lockfile for packages resolved at more than one
+* version.
+*
+* @remarks
+* A report rather than a bare array, for the reason `PeerCheck` is one: an
+* empty array is indistinguishable from "this importer could not be looked
+* at". `unresolvedImporters` makes that difference legible.
+*
+* Pure and total — construct it with {@link DuplicateCheck.run}, which never
+* fails.
+*
+* @example
+* ```ts
+* import { DuplicateCheck } from "@effected/workspaces";
+* import { Lockfile } from "@effected/lockfiles";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   const lockfile = yield* Lockfile.parse(text, { format: "pnpm" });
+*   const report = DuplicateCheck.run(lockfile, { names: DuplicateCheck.kit });
+*   for (const pkg of report.duplicates) {
+*     for (const version of pkg.versions) {
+*       for (const instance of version.instances) {
+*         console.log(pkg.name, version.version, instance.dependents);
+*       }
+*     }
+*   }
+*   return report.isClean;
+* });
+* ```
+*
+* @public
+*/
+var DuplicateCheck = class DuplicateCheck extends Schema.Class("DuplicateCheck")({
+	/**
+	* Every reported name resolved at two or more distinct versions, in
+	* lockfile order.
+	*/
+	duplicates: Schema.Array(DuplicatedPackage),
+	/**
+	* Importers whose dependencies could not be resolved to instances, so
+	* nothing reachable only through them was counted.
+	*
+	* @remarks
+	* In practice this is the **root importer under npm and bun**: neither
+	* records a resolved version per importer dependency, and neither emits a
+	* package row for the root, so there is nothing to join on. pnpm records a
+	* version per importer dependency and is unaffected. The same limitation
+	* `PeerCheck` reports, measured by the same code.
+	*
+	* Reported rather than silently skipped: a gate that sees no duplicates is
+	* entitled to know whether that means "clean" or "not looked at".
+	*/
+	unresolvedImporters: Schema.Array(Schema.String)
+}) {
+	/**
+	* Whether no reported name is duplicated.
+	*
+	* @remarks
+	* Answers for the names asked about, not for the whole graph: with a
+	* `names` filter, a duplicated name the filter rejects does not make the
+	* report unclean. It says nothing about `unresolvedImporters` — a gate
+	* wanting a proven-clean answer checks both.
+	*/
+	get isClean() {
+		return this.duplicates.length === 0;
+	}
+	/**
+	* The names every consumer of this kit asks about: `effect` itself and every
+	* `@effected/*` package.
+	*
+	* @remarks
+	* Exactly those — not `@effect/*`, and not names merely starting with
+	* `effect`. A duplicated kit package presents as a `Layer` requirement that
+	* looks provided yet cannot be satisfied, at the entry point, naming neither
+	* the package nor the skew (issue #298); this predicate is the check that
+	* names both.
+	*
+	* @param name - a package name
+	* @returns whether the name belongs to the kit
+	*/
+	static kit(name) {
+		return name === "effect" || name.startsWith("@effected/");
+	}
+	/**
+	* Compute which packages a parsed lockfile resolves at more than one
+	* version, and who pulls each copy.
+	*
+	* @remarks
+	* Pure, total and format-free: no IO, no error channel, and no knowledge of
+	* which package manager wrote the file.
+	*
+	* The walk starts at each importer's resolved dependencies and follows
+	* `resolved` edges, so only instances some importer actually reaches are
+	* counted — a stale row the lockfile still carries but nothing depends on is
+	* not a duplicate. A name is a duplicate when the walk reaches it at **two
+	* or more distinct versions**; peer-suffix instances of one version are
+	* listed under that version but never make a name a duplicate on their own.
+	*
+	* Each instance's `dependents` are every importer whose roots include it and
+	* every reached package whose `resolved` map points at it, deduplicated, in
+	* lockfile order. `options.names` narrows what is reported, never what is
+	* walked, so a filtered-out package still appears as a dependent where it
+	* pulls a reported copy.
+	*
+	* The one limit it does not paper over is the npm and bun root importer
+	* (see `unresolvedImporters`).
+	*
+	* @param lockfile - a lockfile parsed by `@effected/lockfiles`
+	* @param options - see {@link DuplicateCheckOptions}
+	* @returns the report; never fails
+	*/
+	static run(lockfile, options) {
+		const names = options?.names ?? (() => true);
+		const index = indexInstances(lockfile);
+		const { byId } = index;
+		const importerRoots = /* @__PURE__ */ new Map();
+		const unresolved = [];
+		const queue = [];
+		for (const importer of lockfile.importers) {
+			const roots = rootInstances(lockfile, importer.path, index);
+			if (roots === void 0) {
+				unresolved.push(importer.path);
+				continue;
+			}
+			if (roots._tag === "own") {
+				queue.push(roots.instance);
+				continue;
+			}
+			for (const instance of roots.instances) {
+				const paths = importerRoots.get(instance.instanceId) ?? [];
+				paths.push(importer.path);
+				importerRoots.set(instance.instanceId, paths);
+				queue.push(instance);
+			}
+		}
+		const reached = /* @__PURE__ */ new Set();
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (current === void 0) break;
+			if (reached.has(current.instanceId)) continue;
+			reached.add(current.instanceId);
+			for (const targetId of Object.values(current.resolved)) {
+				const next = byId.get(targetId);
+				if (next !== void 0 && !reached.has(targetId)) queue.push(next);
+			}
+		}
+		const dependents = /* @__PURE__ */ new Map();
+		const seen = /* @__PURE__ */ new Set();
+		const record = (targetId, dependent) => {
+			const key = `${targetId}${renderKey(dependent)}`;
+			if (seen.has(key)) return;
+			seen.add(key);
+			const list = dependents.get(targetId) ?? [];
+			list.push(dependent);
+			dependents.set(targetId, list);
+		};
+		for (const importer of lockfile.importers) for (const [instanceId, paths] of importerRoots) if (paths.includes(importer.path)) record(instanceId, {
+			_tag: "importer",
+			path: importer.path
+		});
+		for (const pkg of lockfile.packages) {
+			if (!reached.has(pkg.instanceId)) continue;
+			const from = dependentOf(pkg);
+			for (const targetId of Object.values(pkg.resolved)) if (byId.has(targetId)) record(targetId, from);
+		}
+		const byName = /* @__PURE__ */ new Map();
+		for (const pkg of lockfile.packages) {
+			if (!reached.has(pkg.instanceId)) continue;
+			const versions = byName.get(pkg.name) ?? /* @__PURE__ */ new Map();
+			const instances = versions.get(pkg.version) ?? [];
+			instances.push(pkg);
+			versions.set(pkg.version, instances);
+			byName.set(pkg.name, versions);
+		}
+		const duplicates = [];
+		for (const [name, versions] of byName) {
+			if (versions.size < 2) continue;
+			if (!names(name)) continue;
+			duplicates.push(DuplicatedPackage.make({
+				name,
+				versions: [...versions].map(([version, instances]) => DuplicatedVersion.make({
+					version,
+					instances: instances.map((instance) => DuplicateInstance.make({
+						instanceId: instance.instanceId,
+						dependents: dependents.get(instance.instanceId) ?? []
+					}))
+				}))
+			}));
+		}
+		return DuplicateCheck.make({
+			duplicates,
+			unresolvedImporters: unresolved
+		});
+	}
+};
+/**
+* The dependent an edge leaving `from` is attributed to.
+*
+* A workspace row standing for an importer is that importer: its edges are the
+* project's own dependencies, so they are attributed by path. A workspace row
+* the lockfile records without a path (npm can) falls back to the package
+* form, which is at least truthful about the name.
+*
+* @internal
+*/
+const dependentOf = (from) => from.isWorkspace && from.relativePath !== void 0 ? {
+	_tag: "importer",
+	path: from.relativePath
+} : {
+	_tag: "package",
+	name: from.name,
+	version: from.version
+};
+/** @internal */
+const renderKey = (dependent) => dependent._tag === "importer" ? `importer${dependent.path}` : `package${dependent.name}${dependent.version}`;
+
+//#endregion
+export { Dependent, DuplicateCheck, DuplicateInstance, DuplicatedPackage, DuplicatedVersion };

package/PeerCheck.js

@@ -1,3 +1,4 @@
+import { indexInstances, rootInstances } from "./internal/roots.js";
 import { Result, Schema } from "effect";
 import { Range, SemVer } from "@effected/semver";
 
@@ -196,19 +197,18 @@ var PeerCheck = class PeerCheck extends Schema.Class("PeerCheck")({
 			unresolvedImporters: [],
 			unverified
 		});
-		const byId = new Map(lockfile.packages.map((pkg) => [pkg.instanceId, pkg]));
-		const workspaceByPath = /* @__PURE__ */ new Map();
-		for (const pkg of lockfile.packages) if (pkg.isWorkspace && pkg.relativePath !== void 0) workspaceByPath.set(pkg.relativePath, pkg);
+		const index = indexInstances(lockfile);
+		const { byId } = index;
 		const rows = [];
 		const unresolved = [];
 		const seen = /* @__PURE__ */ new Set();
 		for (const importer of lockfile.importers) {
-			const roots = rootInstances(lockfile, importer.path, workspaceByPath, byId);
+			const roots = rootInstances(lockfile, importer.path, index);
 			if (roots === void 0) {
 				unresolved.push(importer.path);
 				continue;
 			}
-			collect(importer.path, roots, byId, rows, seen, allowed);
+			collect(importer.path, walksFrom(roots), byId, rows, seen, allowed);
 		}
 		if (lockfile.packages.some((pkg) => pkg.unresolvedEdges.length > 0)) unverified.push("unresolvedEdge");
 		return PeerCheck.make({
@@ -220,40 +220,24 @@ var PeerCheck = class PeerCheck extends Schema.Class("PeerCheck")({
 	}
 };
 /**
-* The instances an importer's dependencies resolved to, plus the importer's own
-* workspace row when the lockfile records one.
+* An importer's roots as walk nodes with their `parents` chain started.
 *
-* Returns `undefined` when the importer cannot be resolved at all, which the
-* caller reports rather than treating as "no problems here".
+* The importer's own row is the walk's first node with an empty chain — its
+* peers are the importer's own. A dependency instance joined from the importer
+* entry starts the chain with itself, as `pnpm peers check` reports it.
 *
 * @internal
 */
-const rootInstances = (lockfile, importerPath, workspaceByPath, byId) => {
-	const own = workspaceByPath.get(importerPath);
-	if (own !== void 0) return [{
-		instance: own,
-		path: []
-	}];
-	const importer = lockfile.importer(importerPath);
-	if (importer._tag === "None") return void 0;
-	const walks = [];
-	let resolvable = false;
-	for (const dep of importer.value.dependencies) {
-		if (dep.version === void 0) continue;
-		const composed = byId.get(`${dep.name}@${dep.version}${dep.peerSuffix ?? ""}`);
-		if (composed === void 0) continue;
-		resolvable = true;
-		walks.push({
-			instance: composed,
-			path: [PeerParent.make({
-				name: composed.name,
-				version: composed.version
-			})]
-		});
-	}
-	if (!resolvable && importer.value.dependencies.length > 0) return void 0;
-	return walks;
-};
+const walksFrom = (roots) => roots._tag === "own" ? [{
+	instance: roots.instance,
+	path: []
+}] : roots.instances.map((instance) => ({
+	instance,
+	path: [PeerParent.make({
+		name: instance.name,
+		version: instance.version
+	})]
+}));
 /**
 * Walk the resolution graph from an importer's roots, emitting a row for every
 * unsatisfied peer declared anywhere along the way.

package/index.d.ts

@@ -1211,6 +1211,225 @@ export declare class DependencyGraph extends DependencyGraph_base {
   toMermaid(): string;
 }
 //#endregion
+//#region src/DuplicateCheck.d.ts
+/**
+ * Options for {@link DuplicateCheck.run}.
+ *
+ * @public
+ */
+interface DuplicateCheckOptions {
+  /**
+   * Which package names to REPORT on. Defaults to every name.
+   *
+   * @remarks
+   * The predicate narrows the report, never the walk: a package it rejects is
+   * still followed and still appears as a dependent wherever it pulls a copy
+   * of a package it accepts. Pruning the walk instead would drop exactly the
+   * culprit a consumer needs named — the untouched third package holding the
+   * stale copy. {@link DuplicateCheck.kit} is the predicate every consumer of
+   * this kit wants.
+   */
+  readonly names?: (name: string) => boolean;
+}
+/**
+ * Who pulls one resolved instance into the graph.
+ *
+ * @remarks
+ * A tagged union a renderer narrows with `switch (dependent._tag)`:
+ *
+ * - `"importer"` — a workspace importer takes the instance directly; `path`
+ *   is the importer path (`"."` for the root).
+ * - `"package"` — a resolved package's own dependency edge points at the
+ *   instance; `name` and `version` are that package's.
+ *
+ * An importer's dependencies are attributed to the importer by path even when
+ * the lockfile records a workspace row for it — that row IS the importer, and
+ * reporting it as a `"package"` would name a directory with a placeholder
+ * version rather than the project that took the dependency.
+ *
+ * @public
+ */
+export declare const Dependent: Schema.Union<readonly [Schema.TaggedStruct<"importer", {
+  readonly path: Schema.NonEmptyString;
+}>, Schema.TaggedStruct<"package", {
+  readonly name: Schema.NonEmptyString;
+  readonly version: Schema.String;
+}>]>;
+/**
+ * The decoded form of {@link (Dependent:variable)}: who pulls one resolved
+ * instance, as a tagged union a renderer narrows with `switch (dependent._tag)`.
+ *
+ * @public
+ */
+export type Dependent = typeof Dependent.Type;
+declare const DuplicateInstance_base: Schema.Class<DuplicateInstance, Schema.Struct<{
+  /** The opaque instance id, as `@effected/lockfiles` records it. */
+  readonly instanceId: Schema.NonEmptyString;
+  /** Every importer and package that pulls THIS copy. */
+  readonly dependents: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"importer", {
+    readonly path: Schema.NonEmptyString;
+  }>, Schema.TaggedStruct<"package", {
+    readonly name: Schema.NonEmptyString;
+    readonly version: Schema.String;
+  }>]>>;
+}>, {}>;
+/**
+ * One resolved instance of a duplicated version, with everything that pulls it.
+ *
+ * @remarks
+ * `dependents` is deduplicated and in lockfile order: importers first, in the
+ * order the lockfile lists them, then packages in the order the lockfile lists
+ * them. Two instances of one `name@version` that differ only by peer suffix
+ * each get their own row, so the dependents of each variant stay attributed to
+ * the variant they actually took.
+ *
+ * @public
+ */
+export declare class DuplicateInstance extends DuplicateInstance_base {}
+declare const DuplicatedVersion_base: Schema.Class<DuplicatedVersion, Schema.Struct<{
+  /** The resolved version. */
+  readonly version: Schema.String;
+  /** Every instance at this version — more than one when peer suffixes differ. */
+  readonly instances: Schema.$Array<typeof DuplicateInstance>;
+}>, {}>;
+/**
+ * One version a duplicated package resolved at.
+ *
+ * @public
+ */
+export declare class DuplicatedVersion extends DuplicatedVersion_base {}
+declare const DuplicatedPackage_base: Schema.Class<DuplicatedPackage, Schema.Struct<{
+  /** The package name. */
+  readonly name: Schema.NonEmptyString;
+  /** Every version it resolved at, in lockfile order. Never fewer than two. */
+  readonly versions: Schema.$Array<typeof DuplicatedVersion>;
+}>, {}>;
+/**
+ * One package name reached at two or more distinct versions.
+ *
+ * @remarks
+ * `versions` always has at least two entries: a name resolved at one version
+ * is never a duplicate, however many peer-suffix instances that version has.
+ * Two instances of the same version load identical code and cannot produce the
+ * type-identity skew this check exists to catch, so counting them would report
+ * a problem nobody has.
+ *
+ * @public
+ */
+export declare class DuplicatedPackage extends DuplicatedPackage_base {}
+declare const DuplicateCheck_base: Schema.Class<DuplicateCheck, Schema.Struct<{
+  /**
+   * Every reported name resolved at two or more distinct versions, in
+   * lockfile order.
+   */
+  readonly duplicates: Schema.$Array<typeof DuplicatedPackage>;
+  /**
+   * Importers whose dependencies could not be resolved to instances, so
+   * nothing reachable only through them was counted.
+   *
+   * @remarks
+   * In practice this is the **root importer under npm and bun**: neither
+   * records a resolved version per importer dependency, and neither emits a
+   * package row for the root, so there is nothing to join on. pnpm records a
+   * version per importer dependency and is unaffected. The same limitation
+   * `PeerCheck` reports, measured by the same code.
+   *
+   * Reported rather than silently skipped: a gate that sees no duplicates is
+   * entitled to know whether that means "clean" or "not looked at".
+   */
+  readonly unresolvedImporters: Schema.$Array<Schema.String>;
+}>, {}>;
+/**
+ * The result of checking a lockfile for packages resolved at more than one
+ * version.
+ *
+ * @remarks
+ * A report rather than a bare array, for the reason `PeerCheck` is one: an
+ * empty array is indistinguishable from "this importer could not be looked
+ * at". `unresolvedImporters` makes that difference legible.
+ *
+ * Pure and total — construct it with {@link DuplicateCheck.run}, which never
+ * fails.
+ *
+ * @example
+ * ```ts
+ * import { DuplicateCheck } from "@effected/workspaces";
+ * import { Lockfile } from "@effected/lockfiles";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const lockfile = yield* Lockfile.parse(text, { format: "pnpm" });
+ *   const report = DuplicateCheck.run(lockfile, { names: DuplicateCheck.kit });
+ *   for (const pkg of report.duplicates) {
+ *     for (const version of pkg.versions) {
+ *       for (const instance of version.instances) {
+ *         console.log(pkg.name, version.version, instance.dependents);
+ *       }
+ *     }
+ *   }
+ *   return report.isClean;
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare class DuplicateCheck extends DuplicateCheck_base {
+  /**
+   * Whether no reported name is duplicated.
+   *
+   * @remarks
+   * Answers for the names asked about, not for the whole graph: with a
+   * `names` filter, a duplicated name the filter rejects does not make the
+   * report unclean. It says nothing about `unresolvedImporters` — a gate
+   * wanting a proven-clean answer checks both.
+   */
+  get isClean(): boolean;
+  /**
+   * The names every consumer of this kit asks about: `effect` itself and every
+   * `@effected/*` package.
+   *
+   * @remarks
+   * Exactly those — not `@effect/*`, and not names merely starting with
+   * `effect`. A duplicated kit package presents as a `Layer` requirement that
+   * looks provided yet cannot be satisfied, at the entry point, naming neither
+   * the package nor the skew (issue #298); this predicate is the check that
+   * names both.
+   *
+   * @param name - a package name
+   * @returns whether the name belongs to the kit
+   */
+  static kit(name: string): boolean;
+  /**
+   * Compute which packages a parsed lockfile resolves at more than one
+   * version, and who pulls each copy.
+   *
+   * @remarks
+   * Pure, total and format-free: no IO, no error channel, and no knowledge of
+   * which package manager wrote the file.
+   *
+   * The walk starts at each importer's resolved dependencies and follows
+   * `resolved` edges, so only instances some importer actually reaches are
+   * counted — a stale row the lockfile still carries but nothing depends on is
+   * not a duplicate. A name is a duplicate when the walk reaches it at **two
+   * or more distinct versions**; peer-suffix instances of one version are
+   * listed under that version but never make a name a duplicate on their own.
+   *
+   * Each instance's `dependents` are every importer whose roots include it and
+   * every reached package whose `resolved` map points at it, deduplicated, in
+   * lockfile order. `options.names` narrows what is reported, never what is
+   * walked, so a filtered-out package still appears as a dependent where it
+   * pulls a reported copy.
+   *
+   * The one limit it does not paper over is the npm and bun root importer
+   * (see `unresolvedImporters`).
+   *
+   * @param lockfile - a lockfile parsed by `@effected/lockfiles`
+   * @param options - see {@link DuplicateCheckOptions}
+   * @returns the report; never fails
+   */
+  static run(lockfile: Lockfile, options?: DuplicateCheckOptions): DuplicateCheck;
+}
+//#endregion
 //#region src/PackageManagerName.d.ts
 /**
  * The four package managers this package understands.
@@ -3873,5 +4092,5 @@ interface GetWorkspacePackagesSyncOptions extends WorkspacesSyncOptions {
  */
 export declare const getWorkspacePackagesSync: (root: string, options: GetWorkspacePackagesSyncOptions) => ReadonlyArray<WorkspacePackage>;
 //#endregion
-export type { CatalogAssemblyFailure, ChangeDetectionFailure, ChangeDetectorShape, ClassifyOptions, ConfigDependencyHooksShape, DependencyDiff, FindWorkspaceRootOptions, GetWorkspacePackagesSyncOptions, HookInjection, ImporterVersions, LockfileReadFailure, LockfileReaderOptions, LockfileReaderShape, PackageManagerDetectionFailure, PackageManagerDetectorShape, PackageRelease, PeerCheckOptions, PeerDependencyRules, PublishabilityDetectorShape, SyncDirectoryEntry, SyncFileSystem, SyncPath, TagClassification, TagFormatOptions, TrackingTagOptions, UnverifiedReason, VersioningDetectOptions, WorkspaceCatalogsOptions, WorkspaceCatalogsShape, WorkspaceDiscoveryFailure, WorkspaceDiscoveryOptions, WorkspaceDiscoveryShape, WorkspaceDiscoverySkip, WorkspaceDiscoverySkipKind, WorkspaceLookupFailure, WorkspaceRootShape, WorkspaceSnapshotAtFailure, WorkspaceSnapshotWorktreeFailure, WorkspaceSnapshotsOptions, WorkspaceSnapshotsShape, WorkspacesGitOptions, WorkspacesOptions, WorkspacesServices, WorkspacesSyncOptions };
+export type { CatalogAssemblyFailure, ChangeDetectionFailure, ChangeDetectorShape, ClassifyOptions, ConfigDependencyHooksShape, DependencyDiff, DuplicateCheckOptions, FindWorkspaceRootOptions, GetWorkspacePackagesSyncOptions, HookInjection, ImporterVersions, LockfileReadFailure, LockfileReaderOptions, LockfileReaderShape, PackageManagerDetectionFailure, PackageManagerDetectorShape, PackageRelease, PeerCheckOptions, PeerDependencyRules, PublishabilityDetectorShape, SyncDirectoryEntry, SyncFileSystem, SyncPath, TagClassification, TagFormatOptions, TrackingTagOptions, UnverifiedReason, VersioningDetectOptions, WorkspaceCatalogsOptions, WorkspaceCatalogsShape, WorkspaceDiscoveryFailure, WorkspaceDiscoveryOptions, WorkspaceDiscoveryShape, WorkspaceDiscoverySkip, WorkspaceDiscoverySkipKind, WorkspaceLookupFailure, WorkspaceRootShape, WorkspaceSnapshotAtFailure, WorkspaceSnapshotWorktreeFailure, WorkspaceSnapshotsOptions, WorkspaceSnapshotsShape, WorkspacesGitOptions, WorkspacesOptions, WorkspacesServices, WorkspacesSyncOptions };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -4,6 +4,7 @@ import { PackageNotFoundError, WorkspaceDiscovery, WorkspaceDiscoveryError, Work
 import { CyclicDependencyError, DependencyGraph } from "./DependencyGraph.js";
 import { ChangeDetectionError, ChangeDetectionOptions, ChangeDetector } from "./ChangeDetector.js";
 import { ConfigDependencyHooks, NoPeerDependencyRules } from "./ConfigDependencyHooks.js";
+import { Dependent, DuplicateCheck, DuplicateInstance, DuplicatedPackage, DuplicatedVersion } from "./DuplicateCheck.js";
 import { DetectedPackageManager, PackageManagerDetectionError, PackageManagerDetector, PackageManagerEvidence, PackageManagerName } from "./PackageManagerName.js";
 import { LockfileReadError, LockfileReader } from "./LockfileReader.js";
 import { PeerCheck, PeerParent, UnsatisfiedPeer } from "./PeerCheck.js";
@@ -16,4 +17,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, NoPeerDependencyRules, PackageManagerDetectionError, PackageManagerDetector, PackageManagerEvidence, PackageManagerName, PackageNotFoundError, PackageStateSnapshot, PeerCheck, PeerParent, PublishConfig, PublishTarget, PublishabilityDetector, ReleaseTag, TagStyle, TrackingTag, UnsatisfiedPeer, 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, Dependent, DetectedPackageManager, DuplicateCheck, DuplicateInstance, DuplicatedPackage, DuplicatedVersion, LockfileReadError, LockfileReader, NoPeerDependencyRules, PackageManagerDetectionError, PackageManagerDetector, PackageManagerEvidence, PackageManagerName, PackageNotFoundError, PackageStateSnapshot, PeerCheck, PeerParent, PublishConfig, PublishTarget, PublishabilityDetector, ReleaseTag, TagStyle, TrackingTag, UnsatisfiedPeer, VersioningStrategy, VersioningStrategyType, WORKSPACE_MARKERS, WorkspaceCatalogs, WorkspaceDiscovery, WorkspaceDiscoveryError, WorkspaceInfo, WorkspaceManifestError, WorkspacePackage, WorkspacePatternError, WorkspaceRoot, WorkspaceRootNotFoundError, WorkspaceSnapshots, WorkspaceStateSnapshot, Workspaces, classifyTag, findWorkspaceRootSync, getWorkspacePackagesSync };

package/internal/roots.js

@@ -0,0 +1,43 @@
+//#region src/internal/roots.ts
+const indexInstances = (lockfile) => {
+	const byId = new Map(lockfile.packages.map((pkg) => [pkg.instanceId, pkg]));
+	const workspaceByPath = /* @__PURE__ */ new Map();
+	for (const pkg of lockfile.packages) if (pkg.isWorkspace && pkg.relativePath !== void 0) workspaceByPath.set(pkg.relativePath, pkg);
+	return {
+		byId,
+		workspaceByPath
+	};
+};
+/**
+* The instances an importer's dependencies resolved to, or the importer's own
+* workspace row when the lockfile records one.
+*
+* Returns `undefined` when the importer cannot be resolved at all, which every
+* caller reports rather than treating as "no problems here".
+*/
+const rootInstances = (lockfile, importerPath, index) => {
+	const own = index.workspaceByPath.get(importerPath);
+	if (own !== void 0) return {
+		_tag: "own",
+		instance: own
+	};
+	const importer = lockfile.importer(importerPath);
+	if (importer._tag === "None") return void 0;
+	const instances = [];
+	let resolvable = false;
+	for (const dep of importer.value.dependencies) {
+		if (dep.version === void 0) continue;
+		const composed = index.byId.get(`${dep.name}@${dep.version}${dep.peerSuffix ?? ""}`);
+		if (composed === void 0) continue;
+		resolvable = true;
+		instances.push(composed);
+	}
+	if (!resolvable && importer.value.dependencies.length > 0) return void 0;
+	return {
+		_tag: "dependencies",
+		instances
+	};
+};
+
+//#endregion
+export { indexInstances, rootInstances };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/workspaces",
-	"version": "0.21.1",
+	"version": "0.22.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": [
@@ -46,15 +46,16 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/commands": "^0.7.0",
-		"@effected/git": "^0.15.1",
-		"@effected/glob": "^0.6.0",
-		"@effected/lockfiles": "^0.9.0",
-		"@effected/npm": "^0.14.0",
-		"@effected/package-json": "^0.15.0",
-		"@effected/semver": "^0.7.0",
-		"@effected/walker": "^0.9.0",
-		"@effected/yaml": "^0.15.1",
+		"@effected/commands": "^0.7.2",
+		"@effected/git": "^0.15.2",
+		"@effected/glob": "^0.6.1",
+		"@effected/jsonc": "^0.11.1",
+		"@effected/lockfiles": "^0.9.1",
+		"@effected/npm": "^0.14.1",
+		"@effected/package-json": "^0.15.1",
+		"@effected/semver": "^0.7.1",
+		"@effected/walker": "^0.9.1",
+		"@effected/yaml": "^0.15.2",
 		"@pnpm/catalogs.config": "^1100.0.5",
 		"@pnpm/catalogs.protocol-parser": "^1100.0.0",
 		"@pnpm/catalogs.resolver": "^1100.0.0",