wyvrnpm 2.21.1 → 2.21.2

package/bin/wyvrnpm.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 'use strict';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyvrnpm",
-  "version": "2.21.1",
+  "version": "2.21.2",
   "description": "A simple, static-hosting-compatible C++ package manager",
   "keywords": [
     "c++",

package/src/commands/link.js

@@ -122,11 +122,21 @@ function registerGlobal(manifestPath, argv) {
 /**
  * Link a package into the current project's wyvrn_internal directory.
  *
+ * The junction always points at `sourcePath` (the install tree, so the
+ * consumer's `find_package(<name> CONFIG)` resolves). The wyvrn.lock entry,
+ * however, records `manifestPath` when given — the package's source root, which
+ * carries wyvrn.json. The install tree carries no manifest, so without this the
+ * resolver can't read the dep's declared options or transitive deps. The two
+ * are deliberately decoupled: link against the build output, resolve metadata
+ * from the source.
+ *
  * @param {string} name - Package name to link.
- * @param {string} sourcePath - Source directory path (absolute or relative).
+ * @param {string} sourcePath - Junction target (install tree, absolute or relative).
  * @param {string} rootDir - Project root directory.
+ * @param {string} [manifestPath] - Source root recorded in the lock for manifest
+ *   resolution. Defaults to `sourcePath` when omitted (direct-path links).
  */
-function linkToProject(name, sourcePath, rootDir) {
+function linkToProject(name, sourcePath, rootDir, manifestPath = null) {
   const absoluteSource = path.resolve(sourcePath);
 
   if (!fs.existsSync(absoluteSource)) {
@@ -144,6 +154,11 @@ function linkToProject(name, sourcePath, rootDir) {
   const versionFile = path.join(linkPath, '.wyvrn-version');
   fs.writeFileSync(versionFile, 'linked', 'utf8');
 
+  // Record the manifest location in the lock — the source root when known (it
+  // carries wyvrn.json), else the junction target. Decoupled from the junction
+  // so the resolver reads metadata from source while CMake links the build.
+  const lockTarget = manifestPath ? path.resolve(manifestPath) : absoluteSource;
+
   // Update the lock file to record the link
   const lockPath = path.join(rootDir, 'wyvrn.lock');
   let lockData = { packages: {} };
@@ -155,11 +170,14 @@ function linkToProject(name, sourcePath, rootDir) {
     }
   }
   lockData.packages = lockData.packages || {};
-  lockData.packages[name] = `linked:${absoluteSource}`;
+  lockData.packages[name] = `linked:${lockTarget}`;
   lockData.generatedAt = new Date().toISOString();
   fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2) + '\n', 'utf8');
 
-  log.info(`Linked: ${name} → ${absoluteSource}`);
+  log.info(
+    `Linked: ${name} → ${absoluteSource}` +
+    (lockTarget !== absoluteSource ? ` (manifest: ${lockTarget})` : ''),
+  );
 }
 
 /**
@@ -348,7 +366,10 @@ async function link(argv) {
     effectivePath = getEffectivePath(entry);
   }
 
-  linkToProject(argv.name, effectivePath, rootDir);
+  // entry.path is the package's source root (where wyvrn.json was read at
+  // registration) — record it as the lock's manifest path while the junction
+  // targets the install tree (effectivePath).
+  linkToProject(argv.name, effectivePath, rootDir, entry.path);
 }
 
 /**

package/src/resolve.js

@@ -50,6 +50,33 @@ function readLocalManifest(packagePath) {
   return null;
 }
 
+/**
+ * Resolve a linked package's source-root (manifest) directory from the global
+ * link registry.
+ *
+ * A consumer's wyvrn.lock records a linked dep as `linked:<path>`. Since the
+ * link-install-dir change, `<path>` is the package's install tree
+ * (`build/wyvrn-<profile>/install`), which carries no wyvrn.json — only built
+ * headers/libs/CMake config. When the manifest can't be read from the lock
+ * path, this returns the source root recorded in `config.linkedPackages[name]`,
+ * where wyvrn.json actually lives, so the resolver can still read the dep's
+ * declared options + transitive deps. Returns null when the package isn't in
+ * the registry (e.g. a direct-path `wyvrnpm link <name> <path>`).
+ *
+ * @param {string} name
+ * @returns {string|null}
+ */
+function linkedRegistrySourcePath(name) {
+  try {
+    const { readConfig } = require('./config');
+    const entry = readConfig().linkedPackages?.[name];
+    if (!entry) return null;
+    return typeof entry === 'string' ? entry : (entry.path ?? null);
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Compares two version strings of the form "major.minor.patch.build".
  * Each missing component is treated as 0.
@@ -447,8 +474,22 @@ async function resolveDependencies(
     // Handle linked packages: read local manifest instead of fetching from remote
     let manifest;
     if (isLinkedVersion(version)) {
-      const localPath = getLinkedPath(version);
+      let localPath = getLinkedPath(version);
       manifest = readLocalManifest(localPath);
+      if (!manifest) {
+        // The lock path may be the install tree (no wyvrn.json). Fall back to
+        // the package's source root from the global link registry, where the
+        // manifest lives — so declared options + transitive deps still resolve
+        // without re-linking.
+        const sourceRoot = linkedRegistrySourcePath(name);
+        if (sourceRoot && sourceRoot !== localPath) {
+          const fromSource = readLocalManifest(sourceRoot);
+          if (fromSource) {
+            manifest  = fromSource;
+            localPath = sourceRoot;
+          }
+        }
+      }
       if (manifest) {
         log.info(`Linked: ${name} → ${localPath}`);
       } else {