wyvrnpm 2.21.1 → 2.21.3

package/bin/wyvrnpm.js

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

package/cmake/variables.cmake

@@ -161,6 +161,128 @@ else()
     message(STATUS "Unknown architecture")
 endif()
 
+# ── CPU architecture detection ────────────────────────────────────────────────
+# A parallel tier to WYVRN_PLATFORM_* above. CPU family is orthogonal to OS
+# family (an ARM Mac and an x86 Mac are both DARWIN), so it is detected on its
+# own axis rather than nested under any platform. Same idiom as the platform
+# tier: default every leaf to FALSE, derive from the environment, then emit the
+# survivors as compile definitions.
+#
+#   WYVRN_CPU_X86_FAMILY  – x86 / x86_64 (Intel/AMD)
+#   WYVRN_CPU_ARM_FAMILY  – ARM / AArch64
+#
+# Derived vector-intrinsics selector — the SSE-vs-NEON switch a VectorRegister
+# dispatch header keys off:
+#
+#   WYVRN_ENABLE_VECTORINTRINSICS       – SSE/AVX path available (x86 family)
+#   WYVRN_ENABLE_VECTORINTRINSICS_NEON  – NEON path available (64-bit ARM)
+
+set(WYVRN_CPU_X86_FAMILY FALSE)
+set(WYVRN_CPU_ARM_FAMILY FALSE)
+set(WYVRN_ENABLE_VECTORINTRINSICS FALSE)
+set(WYVRN_ENABLE_VECTORINTRINSICS_NEON FALSE)
+
+# CMAKE_SYSTEM_PROCESSOR is valid post-project(); its spelling varies by host
+# (AMD64 on MSVC, x86_64 on Linux/Mac, ARM64 on Windows-on-ARM, aarch64 on
+# Linux, arm64 on Apple). Lower-case before matching so one pattern covers all.
+string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" _wyvrn_cpu_lc)
+if(_wyvrn_cpu_lc MATCHES "^(x86_64|amd64|x64|em64t|i[3-6]86|x86)$")
+    set(WYVRN_CPU_X86_FAMILY TRUE)
+elseif(_wyvrn_cpu_lc MATCHES "^(arm64|aarch64|armv8|armv7|arm)")
+    set(WYVRN_CPU_ARM_FAMILY TRUE)
+endif()
+
+if(WYVRN_CPU_X86_FAMILY)
+    set(WYVRN_ENABLE_VECTORINTRINSICS TRUE)
+elseif(WYVRN_CPU_ARM_FAMILY AND WYVRN_64)
+    # 32-bit ARM makes NEON optional; only the 64-bit baseline guarantees it.
+    set(WYVRN_ENABLE_VECTORINTRINSICS_NEON TRUE)
+endif()
+
+# ── x86 minimum CPU architecture opt-in (analogue of UBT's -MinCpuArchX64) ────
+# Raises the compile-time SIMD floor for the WHOLE build. Off by default (None)
+# so produced binaries run on the broadest x86_64 baseline (SSE2). Selecting a
+# level does two coupled things that MUST stay in lockstep:
+#   (a) emits the matching /arch (MSVC) or -m flags (Clang/GCC) so every
+#       translation unit is actually codegen'd for that ISA, and
+#   (b) raises WYVRN_ALWAYS_HAS_AVX[2|512]/_FMA3 so headers may assume the ISA
+#       unconditionally, with no runtime CPUID guard.
+# Applied globally (add_compile_options / add_compile_definitions) because the
+# macro and the codegen flag must agree across every TU — a header that emits an
+# AVX intrinsic under WYVRN_ALWAYS_HAS_AVX must never reach a TU built without
+# /arch:AVX. Runtime detection (GetCPUVendor / HasAVX2) is the separate,
+# portable-dispatch mechanism and is unaffected by this floor.
+# MINSPEC WARNING: a binary built with AVX2 will fault (#UD/SIGILL) on any CPU
+# that lacks it. Raise this only when the deploy target's minimum spec
+# guarantees the level.
+set(WYVRN_MIN_CPU_ARCH_X64 "None" CACHE STRING
+    "Minimum x86_64 SIMD ISA the build may assume unconditionally (None|AVX|AVX2|AVX512)")
+set_property(CACHE WYVRN_MIN_CPU_ARCH_X64 PROPERTY STRINGS None AVX AVX2 AVX512)
+
+set(WYVRN_ALWAYS_HAS_AVX    0)
+set(WYVRN_ALWAYS_HAS_AVX2   0)
+set(WYVRN_ALWAYS_HAS_AVX512 0)
+set(WYVRN_ALWAYS_HAS_FMA3   0)
+
+if(WYVRN_CPU_X86_FAMILY AND NOT WYVRN_MIN_CPU_ARCH_X64 STREQUAL "None")
+    if(NOT WYVRN_MIN_CPU_ARCH_X64 MATCHES "^(AVX|AVX2|AVX512)$")
+        message(FATAL_ERROR "WYVRN_MIN_CPU_ARCH_X64 must be one of None|AVX|AVX2|AVX512 (got '${WYVRN_MIN_CPU_ARCH_X64}')")
+    endif()
+
+    set(_wyvrn_arch_flags)
+    if(MSVC)
+        # MSVC /arch is cumulative: /arch:AVX2 implies AVX, /arch:AVX512 implies AVX2.
+        list(APPEND _wyvrn_arch_flags /arch:${WYVRN_MIN_CPU_ARCH_X64})
+    else()
+        # Clang/GCC -m flags are not cumulative — name each level explicitly.
+        # FMA3 ships with Haswell-era AVX2, so -mfma rides along from AVX2 up.
+        if(WYVRN_MIN_CPU_ARCH_X64 STREQUAL "AVX")
+            list(APPEND _wyvrn_arch_flags -mavx)
+        elseif(WYVRN_MIN_CPU_ARCH_X64 STREQUAL "AVX2")
+            list(APPEND _wyvrn_arch_flags -mavx2 -mfma)
+        elseif(WYVRN_MIN_CPU_ARCH_X64 STREQUAL "AVX512")
+            list(APPEND _wyvrn_arch_flags -mavx512f -mavx2 -mfma)
+        endif()
+    endif()
+    add_compile_options(${_wyvrn_arch_flags})
+
+    # Raise the cumulative WYVRN_ALWAYS_HAS_* floor. FMA3 is guaranteed only from
+    # AVX2 up (both MSVC /arch:AVX2 and GCC/Clang -mfma).
+    set(WYVRN_ALWAYS_HAS_AVX 1)
+    if(WYVRN_MIN_CPU_ARCH_X64 STREQUAL "AVX2" OR WYVRN_MIN_CPU_ARCH_X64 STREQUAL "AVX512")
+        set(WYVRN_ALWAYS_HAS_AVX2 1)
+        set(WYVRN_ALWAYS_HAS_FMA3 1)
+    endif()
+    if(WYVRN_MIN_CPU_ARCH_X64 STREQUAL "AVX512")
+        set(WYVRN_ALWAYS_HAS_AVX512 1)
+    endif()
+endif()
+
+# -- Emit WYVRN_CPU_* + vector-intrinsics selector compile definitions --
+foreach(_cpu X86_FAMILY ARM_FAMILY)
+    if(WYVRN_CPU_${_cpu})
+        add_compile_definitions(WYVRN_CPU_${_cpu}=1)
+    endif()
+endforeach()
+if(WYVRN_ENABLE_VECTORINTRINSICS)
+    add_compile_definitions(WYVRN_ENABLE_VECTORINTRINSICS=1)
+endif()
+if(WYVRN_ENABLE_VECTORINTRINSICS_NEON)
+    add_compile_definitions(WYVRN_ENABLE_VECTORINTRINSICS_NEON=1)
+endif()
+
+# The AVX floor is always emitted (0 or 1) so headers can `#if WYVRN_ALWAYS_HAS_AVX`
+# without an #ifdef guard, mirroring UE's PLATFORM_ALWAYS_HAS_AVX.
+add_compile_definitions(
+    WYVRN_ALWAYS_HAS_AVX=${WYVRN_ALWAYS_HAS_AVX}
+    WYVRN_ALWAYS_HAS_AVX2=${WYVRN_ALWAYS_HAS_AVX2}
+    WYVRN_ALWAYS_HAS_AVX512=${WYVRN_ALWAYS_HAS_AVX512}
+    WYVRN_ALWAYS_HAS_FMA3=${WYVRN_ALWAYS_HAS_FMA3}
+)
+
+message(STATUS "CPU family     : X86=${WYVRN_CPU_X86_FAMILY} ARM=${WYVRN_CPU_ARM_FAMILY} (processor='${CMAKE_SYSTEM_PROCESSOR}')")
+message(STATUS "CPU intrinsics : VECTORINTRINSICS=${WYVRN_ENABLE_VECTORINTRINSICS} NEON=${WYVRN_ENABLE_VECTORINTRINSICS_NEON} MIN_CPU_ARCH_X64=${WYVRN_MIN_CPU_ARCH_X64} (AVX=${WYVRN_ALWAYS_HAS_AVX} AVX2=${WYVRN_ALWAYS_HAS_AVX2} AVX512=${WYVRN_ALWAYS_HAS_AVX512} FMA3=${WYVRN_ALWAYS_HAS_FMA3})")
+
 # Put compiled artefacts inside the CMake binary dir so `wyvrnpm clean --all`
 # (which sweeps `<binaryDirRoot>/wyvrn-*/`) catches them. Pre-2.17 wyvrnpm
 # put these under `${CMAKE_SOURCE_DIR}/output/<bin|lib>${WYVRN_ARCH_SUFFIX}/`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyvrnpm",
-  "version": "2.21.1",
+  "version": "2.21.3",
   "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 {