@effected/lockfiles 0.6.0 → 0.6.1

package/internal/pnpm.js

@@ -135,6 +135,31 @@ const resolveLinkTarget = (importerPath, target) => {
 	}
 	return segments.length === 0 ? void 0 : segments.join("/");
 };
+/** The specifier protocol pnpm resolves through the workspace itself. @internal */
+const WORKSPACE_PREFIX = "workspace:";
+/**
+* The importer a `link:` target lands INSIDE, longest path first.
+*
+* pnpm's `publishConfig.linkDirectory` makes a workspace link point at the
+* package's publish directory rather than its root — `link:../bundler/dist/dev/pkg`
+* where `packages/bundler` is the importer — so the target itself is a build
+* output that is no importer and never will be. The owning importer is the
+* longest ancestor of the target that IS one; longest-first so a nested importer
+* beats its parent.
+*
+* The root importer (`"."`) is deliberately unreachable here: it is an ancestor
+* of every path in the workspace, so admitting it would resolve every stray link
+* to the root rather than leaving it unnamed.
+*
+* @internal
+*/
+const owningImporter = (target, importerPaths) => {
+	const segments = target.split("/");
+	for (let end = segments.length - 1; end > 0; end--) {
+		const candidate = segments.slice(0, end).join("/");
+		if (importerPaths.has(candidate)) return candidate;
+	}
+};
 /**
 * Resolve one importer's outgoing edges. pnpm records `{ specifier, version }`
 * per importer dependency, where the version is either a registry version (the
@@ -142,9 +167,22 @@ const resolveLinkTarget = (importerPath, target) => {
 * naming another importer — normalized against this importer's own path. Both
 * are checked against the lockfile's instance ids before being emitted.
 *
+* A `link:` target that is no importer gets one further chance, and only under
+* a `workspace:` SPECIFIER: pnpm resolved that edge through the workspace, so
+* the target directory is known to belong to a workspace package, and
+* {@link owningImporter} names it. The specifier is what makes this a
+* resolution rather than a guess — a hand-written `link:../vendor/stub`
+* specifier names a directory pnpm never claimed was a workspace package, and
+* attributing it to whichever importer happens to contain it would answer with
+* the wrong package's peers instead of admitting it could not name the edge.
+*
+* The snapshot path ({@link resolveEdges}) deliberately does NOT do this: a
+* snapshot body records `name: link:<path>` with no specifier beside it, so the
+* evidence this rule turns on is not available there.
+*
 * @internal
 */
-const resolveImporterEdges = (importer, importerPath, instanceIds) => {
+const resolveImporterEdges = (importer, importerPath, instanceIds, importerPaths) => {
 	const edges = /* @__PURE__ */ new Map();
 	const unnameable = /* @__PURE__ */ new Set();
 	for (const group of importerDepGroups(importer)) {
@@ -153,7 +191,8 @@ const resolveImporterEdges = (importer, importerPath, instanceIds) => {
 			if (name === "") continue;
 			if (info.version.startsWith(LINK_PREFIX)) {
 				const target = resolveLinkTarget(importerPath, info.version.slice(5));
-				if (target !== void 0 && instanceIds.has(target)) edges.set(name, target);
+				const owner = target === void 0 ? void 0 : instanceIds.has(target) ? target : info.specifier.startsWith(WORKSPACE_PREFIX) ? owningImporter(target, importerPaths) : void 0;
+				if (owner !== void 0) edges.set(name, owner);
 				else unnameable.add(name);
 				continue;
 			}
@@ -213,6 +252,7 @@ const toFields = (raw) => Effect.gen(function* () {
 		...raw.packages ? Object.keys(raw.packages) : [],
 		...Object.keys(raw.importers)
 	]);
+	const importerPaths = new Set(Object.keys(raw.importers).filter((path) => path !== "." && path !== ""));
 	const emitted = /* @__PURE__ */ new Set();
 	for (const [importerPath, importer] of Object.entries(raw.importers)) {
 		if (importerPath === "." || importerPath === "") continue;
@@ -222,7 +262,7 @@ const toFields = (raw) => Effect.gen(function* () {
 			instanceId: importerPath,
 			isWorkspace: true,
 			relativePath: importerPath,
-			...resolveImporterEdges(importer, importerPath, instanceIds)
+			...resolveImporterEdges(importer, importerPath, instanceIds, importerPaths)
 		}));
 	}
 	const emit = (instanceId, meta, edges) => Effect.gen(function* () {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/lockfiles",
-	"version": "0.6.0",
+	"version": "0.6.1",
 	"private": false,
 	"description": "Pure lockfile parsing for bun, npm, pnpm and yarn Berry into one unified Effect schema model, with pure integrity checking against workspace manifests.",
 	"keywords": [