@qvac/sdk 0.14.1 → 0.15.0

package/electron-forge/index.cjs

@@ -9,12 +9,12 @@
  * prebuilds are arch-specific. Build darwin-arm64 and darwin-x64 separately.
  */
 
-"use strict";
+'use strict'
 
-const { PluginBase } = require("@electron-forge/plugin-base");
-const { createRequire } = require("module");
-const path = require("path");
-const fs = require("fs");
+const { PluginBase } = require('@electron-forge/plugin-base')
+const { createRequire } = require('module')
+const path = require('path')
+const fs = require('fs')
 
 // ============================================
 // Errors
@@ -26,9 +26,9 @@ const fs = require("fs");
  */
 class QvacForgePluginError extends Error {
   constructor(message) {
-    super(message);
-    this.name = "QvacForgePluginError";
-    this.stack = `${this.name}: ${this.message}`;
+    super(message)
+    this.name = 'QvacForgePluginError'
+    this.stack = `${this.name}: ${this.message}`
   }
 }
 
@@ -36,84 +36,79 @@ class QvacForgePluginError extends Error {
 // Logger
 // ============================================
 
-const PREFIX = "[qvac:electron-forge]";
+const PREFIX = '[qvac:electron-forge]'
 
-const EXPECTED_FS_ERROR_CODES = new Set([
-  "ENOENT",
-  "EACCES",
-  "EPERM",
-  "ENOTDIR",
-]);
+const EXPECTED_FS_ERROR_CODES = new Set(['ENOENT', 'EACCES', 'EPERM', 'ENOTDIR'])
 
 const LOG_LEVELS = {
   off: 0,
   error: 1,
   warn: 2,
   info: 3,
-  debug: 4,
-};
+  debug: 4
+}
 
 function getDefaultLevel() {
-  const level = process.env.QVAC_LOG_LEVEL?.toLowerCase();
-  return level && level in LOG_LEVELS ? level : "info";
+  const level = process.env.QVAC_LOG_LEVEL?.toLowerCase()
+  return level && level in LOG_LEVELS ? level : 'info'
 }
 
-let currentLevel = LOG_LEVELS[getDefaultLevel()];
+let currentLevel = LOG_LEVELS[getDefaultLevel()]
 
 function setLogLevel(level) {
   if (!(level in LOG_LEVELS)) {
     console.warn(
-      `${PREFIX} Invalid log level "${level}", using "info". Valid: ${Object.keys(LOG_LEVELS).join(", ")}`,
-    );
-    currentLevel = LOG_LEVELS.info;
-    return;
+      `${PREFIX} Invalid log level "${level}", using "info". Valid: ${Object.keys(LOG_LEVELS).join(', ')}`
+    )
+    currentLevel = LOG_LEVELS.info
+    return
   }
-  currentLevel = LOG_LEVELS[level];
+  currentLevel = LOG_LEVELS[level]
 }
 
 const logger = {
   error(msg) {
-    if (currentLevel >= LOG_LEVELS.error) console.error(PREFIX, msg);
+    if (currentLevel >= LOG_LEVELS.error) console.error(PREFIX, msg)
   },
   warn(msg) {
-    if (currentLevel >= LOG_LEVELS.warn) console.warn(PREFIX, msg);
+    if (currentLevel >= LOG_LEVELS.warn) console.warn(PREFIX, msg)
   },
   info(msg) {
-    if (currentLevel >= LOG_LEVELS.info) console.log(PREFIX, msg);
+    if (currentLevel >= LOG_LEVELS.info) console.log(PREFIX, msg)
   },
   debug(msg) {
-    if (currentLevel >= LOG_LEVELS.debug) console.log(PREFIX, msg);
+    if (currentLevel >= LOG_LEVELS.debug) console.log(PREFIX, msg)
   },
   fsError(context, err) {
-    if (err && EXPECTED_FS_ERROR_CODES.has(err.code)) return;
-    this.warn(`Unexpected error in ${context}: ${err?.message || err}`);
-  },
-};
+    if (err && EXPECTED_FS_ERROR_CODES.has(err.code)) return
+    this.warn(`Unexpected error in ${context}: ${err?.message || err}`)
+  }
+}
 
 // ============================================
 // SDK Package Resolution (for addon discovery)
 // ============================================
 
-const SDK_PACKAGE_NAMES = ["@qvac/sdk"];
+const SDK_PACKAGE_NAMES = ['@qvac/sdk']
 
 function resolveSDKPackage(startDir) {
   for (const name of SDK_PACKAGE_NAMES) {
     try {
-      const pkgPath = require.resolve(`${name}/package`, { paths: [startDir] });
-      return { name, path: pkgPath };
+      const pkgPath = require.resolve(`${name}/package`, { paths: [startDir] })
+      return { name, path: pkgPath }
     } catch {
       // Try next package name
     }
   }
-  return null;
+  return null
 }
 
 function isDir(dirPath) {
   try {
-    return fs.statSync(dirPath).isDirectory();
+    return fs.statSync(dirPath).isDirectory()
   } catch (err) {
-    logger.fsError("isDir", err);
-    return false;
+    logger.fsError('isDir', err)
+    return false
   }
 }
 
@@ -122,33 +117,32 @@ function isDir(dirPath) {
  * Handles monorepos, workspaces, and hoisted layouts.
  */
 function findQvacScopeDir(startDir) {
-  const sdkPkg = resolveSDKPackage(startDir);
+  const sdkPkg = resolveSDKPackage(startDir)
   if (!sdkPkg) {
     throw new QvacForgePluginError(
-      `Could not find QVAC SDK. ` +
-        `Ensure one of [${SDK_PACKAGE_NAMES.join(", ")}] is installed.`,
-    );
+      `Could not find QVAC SDK. ` + `Ensure one of [${SDK_PACKAGE_NAMES.join(', ')}] is installed.`
+    )
   }
 
-  logger.debug(`Resolved SDK package: ${sdkPkg.name}`);
+  logger.debug(`Resolved SDK package: ${sdkPkg.name}`)
 
-  const baseDir = path.resolve(startDir);
-  const req = createRequire(path.join(baseDir, "package.json"));
-  const nodeModulesDirs = req.resolve.paths(sdkPkg.name) || [];
+  const baseDir = path.resolve(startDir)
+  const req = createRequire(path.join(baseDir, 'package.json'))
+  const nodeModulesDirs = req.resolve.paths(sdkPkg.name) || []
 
   for (const nodeModulesDir of nodeModulesDirs) {
-    const scopeDir = path.join(nodeModulesDir, "@qvac");
-    if (isDir(scopeDir)) return scopeDir;
+    const scopeDir = path.join(nodeModulesDir, '@qvac')
+    if (isDir(scopeDir)) return scopeDir
   }
 
   // Fallback: derive from SDK path for flat node_modules layouts.
-  const derived = path.dirname(path.dirname(sdkPkg.path));
-  if (path.basename(derived) === "@qvac" && isDir(derived)) return derived;
+  const derived = path.dirname(path.dirname(sdkPkg.path))
+  if (path.basename(derived) === '@qvac' && isDir(derived)) return derived
 
   throw new QvacForgePluginError(
     `Could not find @qvac packages. ` +
-      `Ensure dependencies are installed under node_modules (PnP is not supported).`,
-  );
+      `Ensure dependencies are installed under node_modules (PnP is not supported).`
+  )
 }
 
 /**
@@ -156,43 +150,43 @@ function findQvacScopeDir(startDir) {
  * for packages that have `addon: true` in package.json.
  */
 function discoverQvacAddonPackages(projectDir) {
-  let scopeDir;
+  let scopeDir
   try {
-    scopeDir = findQvacScopeDir(projectDir);
+    scopeDir = findQvacScopeDir(projectDir)
   } catch (err) {
-    logger.warn(err.message);
-    return [];
+    logger.warn(err.message)
+    return []
   }
 
-  let entries;
+  let entries
   try {
-    entries = fs.readdirSync(scopeDir);
+    entries = fs.readdirSync(scopeDir)
   } catch (err) {
-    logger.fsError("discoverQvacAddonPackages", err);
-    return [];
+    logger.fsError('discoverQvacAddonPackages', err)
+    return []
   }
 
-  const discovered = [];
+  const discovered = []
 
   for (const name of entries) {
-    const pkgDir = path.join(scopeDir, name);
-    if (!isDir(pkgDir)) continue;
+    const pkgDir = path.join(scopeDir, name)
+    if (!isDir(pkgDir)) continue
 
-    const pkgJsonPath = path.join(pkgDir, "package.json");
-    if (!fs.existsSync(pkgJsonPath)) continue;
+    const pkgJsonPath = path.join(pkgDir, 'package.json')
+    if (!fs.existsSync(pkgJsonPath)) continue
 
     try {
-      const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+      const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'))
       if (pkg.addon === true) {
-        discovered.push(`@qvac/${name}`);
+        discovered.push(`@qvac/${name}`)
       }
     } catch (err) {
-      logger.warn(`Failed to parse ${pkgJsonPath}: ${err.message}`);
+      logger.warn(`Failed to parse ${pkgJsonPath}: ${err.message}`)
     }
   }
 
-  discovered.sort();
-  return discovered;
+  discovered.sort()
+  return discovered
 }
 
 /**
@@ -200,12 +194,12 @@ function discoverQvacAddonPackages(projectDir) {
  * Exposed for unit testing.
  */
 function diffAddons(installed, required) {
-  const requiredSet = new Set(required);
-  const exclusions = [];
+  const requiredSet = new Set(required)
+  const exclusions = []
   for (const pkg of installed) {
-    if (!requiredSet.has(pkg)) exclusions.push(pkg);
+    if (!requiredSet.has(pkg)) exclusions.push(pkg)
   }
-  return exclusions;
+  return exclusions
 }
 
 /**
@@ -213,26 +207,24 @@ function diffAddons(installed, required) {
  * Logs include/exclude decisions for each discovered package.
  */
 function computeExclusions(required, projectDir) {
-  const installed = discoverQvacAddonPackages(projectDir);
+  const installed = discoverQvacAddonPackages(projectDir)
 
   if (installed.length === 0) {
-    logger.warn(
-      "No @qvac addon packages discovered. Skipping addon exclusions.",
-    );
-    return [];
+    logger.warn('No @qvac addon packages discovered. Skipping addon exclusions.')
+    return []
   }
 
-  const requiredSet = new Set(required);
-  const exclusions = [];
+  const requiredSet = new Set(required)
+  const exclusions = []
   for (const pkg of installed) {
     if (requiredSet.has(pkg)) {
-      logger.info(`Including required addon: ${pkg}`);
+      logger.info(`Including required addon: ${pkg}`)
     } else {
-      logger.info(`Excluding unused addon: ${pkg}`);
-      exclusions.push(pkg);
+      logger.info(`Excluding unused addon: ${pkg}`)
+      exclusions.push(pkg)
     }
   }
-  return exclusions;
+  return exclusions
 }
 
 // ============================================
@@ -240,34 +232,27 @@ function computeExclusions(required, projectDir) {
 // ============================================
 
 /** Mobile prebuild patterns to always exclude in desktop builds. */
-const MOBILE_PREBUILD_PATTERNS = [
-  /[\\/]prebuilds[\\/]android-/,
-  /[\\/]prebuilds[\\/]ios-/,
-];
+const MOBILE_PREBUILD_PATTERNS = [/[\\/]prebuilds[\\/]android-/, /[\\/]prebuilds[\\/]ios-/]
 
 /** Forge's default output dir — always exclude to avoid recursive packaging. */
-const OUT_DIR_PATTERN = /^\/out\//;
+const OUT_DIR_PATTERN = /^\/out\//
 
 function toArray(value) {
-  if (value === undefined) return [];
-  return Array.isArray(value) ? value : [value];
+  if (value === undefined) return []
+  return Array.isArray(value) ? value : [value]
 }
 
 function escapeRegExp(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
 function createAddonIgnorePatterns(exclusions) {
-  const patterns = [];
+  const patterns = []
   for (const addon of exclusions) {
-    const parts = addon.split("/").map(escapeRegExp);
-    patterns.push(
-      new RegExp(
-        `[\\\\/]node_modules[\\\\/]${parts.join("[\\\\/]")}([\\\\/]|$)`,
-      ),
-    );
-  }
-  return patterns;
+    const parts = addon.split('/').map(escapeRegExp)
+    patterns.push(new RegExp(`[\\\\/]node_modules[\\\\/]${parts.join('[\\\\/]')}([\\\\/]|$)`))
+  }
+  return patterns
 }
 
 /**
@@ -276,28 +261,28 @@ function createAddonIgnorePatterns(exclusions) {
  * ignore (function or regex array).
  */
 function createIgnore(exclusions, existingIgnore) {
-  const addonIgnorePatterns = createAddonIgnorePatterns(exclusions);
+  const addonIgnorePatterns = createAddonIgnorePatterns(exclusions)
 
-  if (typeof existingIgnore === "function") {
+  if (typeof existingIgnore === 'function') {
     return (filePath) => {
-      if (existingIgnore(filePath)) return true;
-      if (OUT_DIR_PATTERN.test(filePath)) return true;
+      if (existingIgnore(filePath)) return true
+      if (OUT_DIR_PATTERN.test(filePath)) return true
       for (const pattern of addonIgnorePatterns) {
-        if (pattern.test(filePath)) return true;
+        if (pattern.test(filePath)) return true
       }
       for (const pattern of MOBILE_PREBUILD_PATTERNS) {
-        if (pattern.test(filePath)) return true;
+        if (pattern.test(filePath)) return true
       }
-      return false;
-    };
+      return false
+    }
   }
 
   return [
     ...toArray(existingIgnore),
     OUT_DIR_PATTERN,
     ...MOBILE_PREBUILD_PATTERNS,
-    ...addonIgnorePatterns,
-  ];
+    ...addonIgnorePatterns
+  ]
 }
 
 // ============================================
@@ -312,112 +297,112 @@ function createIgnore(exclusions, existingIgnore) {
  * cross-platform prebuilds that would otherwise ship in the packaged app.
  */
 function findPrebuildsDirs(rootPath) {
-  const results = [];
+  const results = []
 
   function walk(dir) {
-    let entries;
+    let entries
     try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
+      entries = fs.readdirSync(dir, { withFileTypes: true })
     } catch (err) {
-      logger.fsError("findPrebuildsDirs", err);
-      return;
+      logger.fsError('findPrebuildsDirs', err)
+      return
     }
 
     for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const fullPath = path.join(dir, entry.name);
+      if (!entry.isDirectory()) continue
+      const fullPath = path.join(dir, entry.name)
 
-      if (entry.name === "prebuilds") {
-        results.push(fullPath);
+      if (entry.name === 'prebuilds') {
+        results.push(fullPath)
         // Don't recurse into prebuilds — its children are arch-keyed leaves.
-        continue;
+        continue
       }
 
-      walk(fullPath);
+      walk(fullPath)
     }
   }
 
-  walk(rootPath);
-  return results;
+  walk(rootPath)
+  return results
 }
 
 function getDirSize(dirPath) {
-  let size = 0;
+  let size = 0
 
   function walk(dir) {
-    let entries;
+    let entries
     try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
+      entries = fs.readdirSync(dir, { withFileTypes: true })
     } catch (err) {
-      logger.fsError("getDirSize", err);
-      return;
+      logger.fsError('getDirSize', err)
+      return
     }
 
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path.join(dir, entry.name)
       if (entry.isDirectory()) {
-        walk(fullPath);
+        walk(fullPath)
       } else {
         try {
-          size += fs.statSync(fullPath).size;
+          size += fs.statSync(fullPath).size
         } catch (err) {
-          logger.fsError("getDirSize.stat", err);
+          logger.fsError('getDirSize.stat', err)
         }
       }
     }
   }
 
-  walk(dirPath);
-  return size;
+  walk(dirPath)
+  return size
 }
 
 /** Prunes prebuilds for a given path, keeping only target platform-arch. */
 function prunePrebuildsForPath(buildPath, platform, arch) {
-  const nodeModulesPath = path.join(buildPath, "node_modules");
+  const nodeModulesPath = path.join(buildPath, 'node_modules')
 
   if (!fs.existsSync(nodeModulesPath)) {
-    logger.debug("No node_modules found, skipping prebuild pruning.");
-    return { deleted: 0, bytes: 0 };
+    logger.debug('No node_modules found, skipping prebuild pruning.')
+    return { deleted: 0, bytes: 0 }
   }
 
-  const keepPrefix = `${platform}-${arch}`;
-  logger.debug(`Keeping prefix: ${keepPrefix}`);
+  const keepPrefix = `${platform}-${arch}`
+  logger.debug(`Keeping prefix: ${keepPrefix}`)
 
-  const prebuildsDirs = findPrebuildsDirs(nodeModulesPath);
-  let totalDeleted = 0;
-  let totalBytes = 0;
+  const prebuildsDirs = findPrebuildsDirs(nodeModulesPath)
+  let totalDeleted = 0
+  let totalBytes = 0
 
   for (const prebuildsDir of prebuildsDirs) {
-    let entries;
+    let entries
     try {
-      entries = fs.readdirSync(prebuildsDir, { withFileTypes: true });
+      entries = fs.readdirSync(prebuildsDir, { withFileTypes: true })
     } catch (err) {
-      logger.fsError("prunePrebuildsForPath", err);
-      continue;
+      logger.fsError('prunePrebuildsForPath', err)
+      continue
     }
 
     for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
+      if (!entry.isDirectory()) continue
 
       // Prefix match catches musl variants etc. (e.g. linux-x64-musl).
-      const shouldKeep = entry.name.startsWith(keepPrefix);
+      const shouldKeep = entry.name.startsWith(keepPrefix)
 
       if (!shouldKeep) {
-        const fullPath = path.join(prebuildsDir, entry.name);
+        const fullPath = path.join(prebuildsDir, entry.name)
         try {
-          const size = getDirSize(fullPath);
-          totalBytes += size;
-          fs.rmSync(fullPath, { recursive: true, force: true });
-          totalDeleted++;
-          logger.debug(`Deleted: ${entry.name}`);
+          const size = getDirSize(fullPath)
+          totalBytes += size
+          fs.rmSync(fullPath, { recursive: true, force: true })
+          totalDeleted++
+          logger.debug(`Deleted: ${entry.name}`)
         } catch (err) {
-          logger.warn(`Failed to delete ${fullPath}: ${err.message}`);
+          logger.warn(`Failed to delete ${fullPath}: ${err.message}`)
         }
       }
     }
   }
 
-  return { deleted: totalDeleted, bytes: totalBytes };
+  return { deleted: totalDeleted, bytes: totalBytes }
 }
 
 /**
@@ -428,31 +413,31 @@ function prunePrebuildsForPath(buildPath, platform, arch) {
  * the packaged tree matches the manifest exactly. Idempotent.
  */
 function removeExcludedAddonDirs(buildPath, exclusions) {
-  const nodeModulesPath = path.join(buildPath, "node_modules");
+  const nodeModulesPath = path.join(buildPath, 'node_modules')
 
   if (!fs.existsSync(nodeModulesPath)) {
-    return { removed: 0, bytes: 0 };
+    return { removed: 0, bytes: 0 }
   }
 
-  let removed = 0;
-  let bytes = 0;
+  let removed = 0
+  let bytes = 0
 
   for (const name of exclusions) {
-    const pkgDir = path.join(nodeModulesPath, name);
-    if (!fs.existsSync(pkgDir)) continue;
+    const pkgDir = path.join(nodeModulesPath, name)
+    if (!fs.existsSync(pkgDir)) continue
 
     try {
-      const size = getDirSize(pkgDir);
-      bytes += size;
-      fs.rmSync(pkgDir, { recursive: true, force: true });
-      removed += 1;
-      logger.debug(`Removed excluded addon dir: ${name}`);
+      const size = getDirSize(pkgDir)
+      bytes += size
+      fs.rmSync(pkgDir, { recursive: true, force: true })
+      removed += 1
+      logger.debug(`Removed excluded addon dir: ${name}`)
     } catch (err) {
-      logger.warn(`Failed to remove ${pkgDir}: ${err.message}`);
+      logger.warn(`Failed to remove ${pkgDir}: ${err.message}`)
     }
   }
 
-  return { removed, bytes };
+  return { removed, bytes }
 }
 
 // ============================================
@@ -473,19 +458,19 @@ function removeExcludedAddonDirs(buildPath, exclusions) {
  */
 async function loadSdkCommands() {
   try {
-    return await import("@qvac/sdk/commands");
+    return await import('@qvac/sdk/commands')
   } catch (err) {
     throw new QvacForgePluginError(
       `Could not load @qvac/sdk/commands: ${err?.message || err}. ` +
         `Ensure @qvac/sdk is installed and exposes the ./commands subpath ` +
-        `(requires SDK >= 0.12.0).`,
-    );
+        `(requires SDK >= 0.12.0).`
+    )
   }
 }
 
 /** Defaults to verifying against the host running Forge. */
 function defaultHosts() {
-  return [`${process.platform}-${process.arch}`];
+  return [`${process.platform}-${process.arch}`]
 }
 
 /**
@@ -499,9 +484,7 @@ function defaultHosts() {
  * @returns {string[]}
  */
 function resolveHosts(explicitHosts) {
-  return Array.isArray(explicitHosts) && explicitHosts.length > 0
-    ? explicitHosts
-    : defaultHosts();
+  return Array.isArray(explicitHosts) && explicitHosts.length > 0 ? explicitHosts : defaultHosts()
 }
 
 /**
@@ -519,38 +502,38 @@ function resolveHosts(explicitHosts) {
  * @returns {string[]|null}
  */
 function detectTargetHosts(forgeConfig, argv = process.argv.slice(2)) {
-  let platform = forgeConfig?.packagerConfig?.platform || null;
-  let archSpec = forgeConfig?.packagerConfig?.arch || null;
+  let platform = forgeConfig?.packagerConfig?.platform || null
+  let archSpec = forgeConfig?.packagerConfig?.arch || null
 
   for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
+    const arg = argv[i]
 
-    if (arg === "--platform" || arg === "-p") {
-      platform = argv[i + 1] || platform;
-      continue;
+    if (arg === '--platform' || arg === '-p') {
+      platform = argv[i + 1] || platform
+      continue
     }
-    if (typeof arg === "string" && arg.startsWith("--platform=")) {
-      platform = arg.slice("--platform=".length) || platform;
-      continue;
+    if (typeof arg === 'string' && arg.startsWith('--platform=')) {
+      platform = arg.slice('--platform='.length) || platform
+      continue
     }
-    if (arg === "--arch" || arg === "-a") {
-      archSpec = argv[i + 1] || archSpec;
-      continue;
+    if (arg === '--arch' || arg === '-a') {
+      archSpec = argv[i + 1] || archSpec
+      continue
     }
-    if (typeof arg === "string" && arg.startsWith("--arch=")) {
-      archSpec = arg.slice("--arch=".length) || archSpec;
+    if (typeof arg === 'string' && arg.startsWith('--arch=')) {
+      archSpec = arg.slice('--arch='.length) || archSpec
     }
   }
 
-  if (!platform && !archSpec) return null;
+  if (!platform && !archSpec) return null
 
-  const p = platform || process.platform;
+  const p = platform || process.platform
   const archs = (archSpec || process.arch)
-    .split(",")
+    .split(',')
     .map((s) => s.trim())
-    .filter(Boolean);
+    .filter(Boolean)
 
-  return archs.length > 0 ? archs.map((a) => `${p}-${a}`) : null;
+  return archs.length > 0 ? archs.map((a) => `${p}-${a}`) : null
 }
 
 /**
@@ -566,61 +549,52 @@ function detectTargetHosts(forgeConfig, argv = process.argv.slice(2)) {
  * @returns {Promise<{ addons: string[], bundlePath: string, manifestPath: string }>}
  */
 async function runBundleAndVerify(commands, projectDir, options) {
-  const { bundleSdk, verifyBundle, hasErrors, formatVerifyBundleResult } =
-    commands;
+  const { bundleSdk, verifyBundle, hasErrors, formatVerifyBundleResult } = commands
 
-  const hosts = resolveHosts(options.hosts);
+  const hosts = resolveHosts(options.hosts)
 
-  logger.info(`Running bundleSdk (hosts: ${hosts.join(", ")})...`);
-  let bundleResult;
+  logger.info(`Running bundleSdk (hosts: ${hosts.join(', ')})...`)
+  let bundleResult
   try {
-    const bundleOpts = { projectRoot: projectDir, hosts };
-    if (options.configPath) bundleOpts.configPath = options.configPath;
-    bundleResult = await bundleSdk(bundleOpts);
+    const bundleOpts = { projectRoot: projectDir, hosts }
+    if (options.configPath) bundleOpts.configPath = options.configPath
+    bundleResult = await bundleSdk(bundleOpts)
   } catch (err) {
-    throw new QvacForgePluginError(
-      `bundleSdk failed: ${err?.message || err}`,
-    );
+    throw new QvacForgePluginError(`bundleSdk failed: ${err?.message || err}`)
   }
 
-  const addonCount = bundleResult.addons.length;
-  logger.info(
-    `bundleSdk: ${addonCount} native addon${addonCount === 1 ? "" : "s"} in bundle`,
-  );
+  const addonCount = bundleResult.addons.length
+  logger.info(`bundleSdk: ${addonCount} native addon${addonCount === 1 ? '' : 's'} in bundle`)
 
-  logger.info(`Running verifyBundle (hosts: ${hosts.join(", ")})...`);
-  let verifyResult;
+  logger.info(`Running verifyBundle (hosts: ${hosts.join(', ')})...`)
+  let verifyResult
   try {
     const verifyOpts = {
       projectRoot: projectDir,
       addonsSource: bundleResult.bundlePath,
-      hosts,
-    };
-    if (options.configPath) verifyOpts.configPath = options.configPath;
-    verifyResult = await verifyBundle(verifyOpts);
+      hosts
+    }
+    if (options.configPath) verifyOpts.configPath = options.configPath
+    verifyResult = await verifyBundle(verifyOpts)
   } catch (err) {
-    throw new QvacForgePluginError(
-      `verifyBundle threw: ${err?.message || err}`,
-    );
+    throw new QvacForgePluginError(`verifyBundle threw: ${err?.message || err}`)
   }
 
   if (hasErrors(verifyResult)) {
     throw new QvacForgePluginError(
-      `verifyBundle reported errors:\n${formatVerifyBundleResult(verifyResult)}`,
-    );
+      `verifyBundle reported errors:\n${formatVerifyBundleResult(verifyResult)}`
+    )
   }
 
   if (verifyResult.issues.length > 0) {
-    logger.warn(
-      `verifyBundle produced warnings:\n${formatVerifyBundleResult(verifyResult)}`,
-    );
+    logger.warn(`verifyBundle produced warnings:\n${formatVerifyBundleResult(verifyResult)}`)
   } else {
     logger.info(
-      `verifyBundle: ${verifyResult.addons.length} addon${verifyResult.addons.length === 1 ? "" : "s"} OK`,
-    );
+      `verifyBundle: ${verifyResult.addons.length} addon${verifyResult.addons.length === 1 ? '' : 's'} OK`
+    )
   }
 
-  return bundleResult;
+  return bundleResult
 }
 
 // ============================================
@@ -628,7 +602,7 @@ async function runBundleAndVerify(commands, projectDir, options) {
 // ============================================
 
 class QvacForgePlugin extends PluginBase {
-  name = "qvac";
+  name = 'qvac'
 
   /**
    * @param {object} [config]
@@ -638,45 +612,43 @@ class QvacForgePlugin extends PluginBase {
    * @param {"off"|"error"|"warn"|"info"|"debug"} [config.logLevel]
    */
   constructor(config = {}) {
-    super(config);
-    this.projectDir = config.projectDir || process.cwd();
-    this.configPath = config.configPath || null;
-    this.hosts = Array.isArray(config.hosts) ? config.hosts : null;
+    super(config)
+    this.projectDir = config.projectDir || process.cwd()
+    this.configPath = config.configPath || null
+    this.hosts = Array.isArray(config.hosts) ? config.hosts : null
 
-    if (config.logLevel) setLogLevel(config.logLevel);
+    if (config.logLevel) setLogLevel(config.logLevel)
 
     // Cache for resolveForgeConfig double-fire (package + make).
-    this._cache = null;
-    this._pruneHook = null;
+    this._cache = null
+    this._pruneHook = null
 
-    logger.debug("QvacForgePlugin initialized");
-    logger.debug(`Project directory: ${this.projectDir}`);
+    logger.debug('QvacForgePlugin initialized')
+    logger.debug(`Project directory: ${this.projectDir}`)
   }
 
   getHooks() {
     return {
-      resolveForgeConfig: this.configurePackager.bind(this),
-    };
+      resolveForgeConfig: this.configurePackager.bind(this)
+    }
   }
 
   async configurePackager(forgeConfig) {
-    logger.info("Configuring packager for QVAC...");
+    logger.info('Configuring packager for QVAC...')
 
     if (!forgeConfig.packagerConfig) {
-      forgeConfig.packagerConfig = {};
+      forgeConfig.packagerConfig = {}
     }
 
     // 1. Block macOS universal builds early.
-    this.checkForUniversalArch(forgeConfig);
+    this.checkForUniversalArch(forgeConfig)
 
     // 2. Force asar: false (Bare worker can't load from asar). Truthy check
     //    catches both `asar: true` and `asar: { unpack: ... }` object configs.
     if (forgeConfig.packagerConfig.asar) {
-      logger.warn(
-        "asar is enabled — Bare worker may fail to load. Overriding to false.",
-      );
+      logger.warn('asar is enabled — Bare worker may fail to load. Overriding to false.')
     }
-    forgeConfig.packagerConfig.asar = false;
+    forgeConfig.packagerConfig.asar = false
 
     // 3. Bundle + verify (cached across resolveForgeConfig invocations).
     //    `hosts` resolution: explicit config wins, then CLI/config-derived
@@ -685,35 +657,25 @@ class QvacForgePlugin extends PluginBase {
     //    verifyBundle (asserts prebuild availability) — passing different
     //    sets silently produces inconsistent builds.
     if (this._cache === null) {
-      const detected = this.hosts ? null : detectTargetHosts(forgeConfig);
+      const detected = this.hosts ? null : detectTargetHosts(forgeConfig)
       if (detected && !this.hosts) {
-        logger.info(`Detected target hosts from CLI/config: ${detected.join(", ")}`);
+        logger.info(`Detected target hosts from CLI/config: ${detected.join(', ')}`)
       }
-      const commands = await loadSdkCommands();
-      const bundleResult = await runBundleAndVerify(
-        commands,
-        this.projectDir,
-        {
-          configPath: this.configPath,
-          hosts: this.hosts || detected,
-        },
-      );
-      const exclusions = computeExclusions(
-        bundleResult.addons,
-        this.projectDir,
-      );
-      this._cache = { bundleResult, exclusions };
+      const commands = await loadSdkCommands()
+      const bundleResult = await runBundleAndVerify(commands, this.projectDir, {
+        configPath: this.configPath,
+        hosts: this.hosts || detected
+      })
+      const exclusions = computeExclusions(bundleResult.addons, this.projectDir)
+      this._cache = { bundleResult, exclusions }
     } else {
-      logger.debug("Reusing cached bundleSdk result.");
+      logger.debug('Reusing cached bundleSdk result.')
     }
-    const { exclusions } = this._cache;
+    const { exclusions } = this._cache
 
     // 4. Merge ignore patterns to exclude unused addons + mobile prebuilds.
-    const existingIgnore = forgeConfig.packagerConfig.ignore;
-    forgeConfig.packagerConfig.ignore = createIgnore(
-      exclusions,
-      existingIgnore,
-    );
+    const existingIgnore = forgeConfig.packagerConfig.ignore
+    forgeConfig.packagerConfig.ignore = createIgnore(exclusions, existingIgnore)
 
     // 5. afterPrune hook for prebuild pruning + excluded addon dir cleanup.
     //    Forge calls resolveForgeConfig multiple times during `make` (once for
@@ -721,18 +683,15 @@ class QvacForgePlugin extends PluginBase {
     //    must not append the hook on each pass, otherwise Packager's afterPrune
     //    fires it N times and we walk the already-pruned tree on every repeat.
     if (this._pruneHook === null) {
-      this._pruneHook = this.createPruneHook(exclusions);
+      this._pruneHook = this.createPruneHook(exclusions)
     }
-    const existingAfterPrune = toArray(forgeConfig.packagerConfig.afterPrune);
+    const existingAfterPrune = toArray(forgeConfig.packagerConfig.afterPrune)
     if (!existingAfterPrune.includes(this._pruneHook)) {
-      forgeConfig.packagerConfig.afterPrune = [
-        ...existingAfterPrune,
-        this._pruneHook,
-      ];
+      forgeConfig.packagerConfig.afterPrune = [...existingAfterPrune, this._pruneHook]
     }
 
-    logger.debug("Packager configuration complete");
-    return forgeConfig;
+    logger.debug('Packager configuration complete')
+    return forgeConfig
   }
 
   /**
@@ -749,58 +708,56 @@ class QvacForgePlugin extends PluginBase {
     const universalMessage =
       `macOS universal packaging is not supported by @qvac/sdk/electron-forge. ` +
       `Native addon prebuilds are architecture-specific and this plugin currently only supports single-arch packaging. ` +
-      `Build separate darwin-arm64 and darwin-x64 packages instead.`;
+      `Build separate darwin-arm64 and darwin-x64 packages instead.`
 
-    if (forgeConfig?.packagerConfig?.arch === "universal") {
-      throw new QvacForgePluginError(universalMessage);
+    if (forgeConfig?.packagerConfig?.arch === 'universal') {
+      throw new QvacForgePluginError(universalMessage)
     }
 
-    const args = process.argv.slice(2);
-    let arch = null;
+    const args = process.argv.slice(2)
+    let arch = null
     for (let i = 0; i < args.length; i += 1) {
-      const arg = args[i];
+      const arg = args[i]
 
-      if (arg === "--arch" || arg === "-a") {
-        arch = args[i + 1] || null;
-        continue;
+      if (arg === '--arch' || arg === '-a') {
+        arch = args[i + 1] || null
+        continue
       }
 
-      if (typeof arg === "string" && arg.startsWith("--arch=")) {
-        arch = arg.slice("--arch=".length) || null;
-        continue;
+      if (typeof arg === 'string' && arg.startsWith('--arch=')) {
+        arch = arg.slice('--arch='.length) || null
+        continue
       }
     }
 
-    if (arch === "universal") {
-      throw new QvacForgePluginError(universalMessage);
+    if (arch === 'universal') {
+      throw new QvacForgePluginError(universalMessage)
     }
   }
 
   createPruneHook(exclusions = []) {
     return (buildPath, electronVersion, platform, arch, done) => {
-      logger.info(`Pruning prebuilds for ${platform}-${arch}...`);
+      logger.info(`Pruning prebuilds for ${platform}-${arch}...`)
 
       try {
-        const prebuildResult = prunePrebuildsForPath(buildPath, platform, arch);
-        const prebuildMb = (prebuildResult.bytes / 1024 / 1024).toFixed(1);
-        logger.info(
-          `Pruned ${prebuildResult.deleted} prebuild dirs (~${prebuildMb} MB reclaimed)`,
-        );
+        const prebuildResult = prunePrebuildsForPath(buildPath, platform, arch)
+        const prebuildMb = (prebuildResult.bytes / 1024 / 1024).toFixed(1)
+        logger.info(`Pruned ${prebuildResult.deleted} prebuild dirs (~${prebuildMb} MB reclaimed)`)
 
         if (exclusions.length > 0) {
-          const cleanup = removeExcludedAddonDirs(buildPath, exclusions);
-          const cleanupMb = (cleanup.bytes / 1024 / 1024).toFixed(1);
+          const cleanup = removeExcludedAddonDirs(buildPath, exclusions)
+          const cleanupMb = (cleanup.bytes / 1024 / 1024).toFixed(1)
           logger.info(
-            `Removed ${cleanup.removed} excluded addon dir${cleanup.removed === 1 ? "" : "s"} (~${cleanupMb} MB reclaimed)`,
-          );
+            `Removed ${cleanup.removed} excluded addon dir${cleanup.removed === 1 ? '' : 's'} (~${cleanupMb} MB reclaimed)`
+          )
         }
 
-        done();
+        done()
       } catch (err) {
-        logger.error(`Prebuild pruning failed: ${err.message}`);
-        done(err);
+        logger.error(`Prebuild pruning failed: ${err.message}`)
+        done(err)
       }
-    };
+    }
   }
 }
 
@@ -808,13 +765,13 @@ class QvacForgePlugin extends PluginBase {
 // Exports
 // ============================================
 
-module.exports = QvacForgePlugin;
-module.exports.setLogLevel = setLogLevel;
-module.exports.QvacForgePluginError = QvacForgePluginError;
+module.exports = QvacForgePlugin
+module.exports.setLogLevel = setLogLevel
+module.exports.QvacForgePluginError = QvacForgePluginError
 
 // Internal helpers exposed for unit tests. Not part of the stable API.
-module.exports.createIgnore = createIgnore;
-module.exports.diffAddons = diffAddons;
-module.exports.detectTargetHosts = detectTargetHosts;
-module.exports.resolveHosts = resolveHosts;
-module.exports.runBundleAndVerify = runBundleAndVerify;
+module.exports.createIgnore = createIgnore
+module.exports.diffAddons = diffAddons
+module.exports.detectTargetHosts = detectTargetHosts
+module.exports.resolveHosts = resolveHosts
+module.exports.runBundleAndVerify = runBundleAndVerify