@featherk/icons 0.15.8 → 0.16.1

package/dist/fontawesome/setup.mjs

@@ -1,10 +1,10 @@
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import { resolve, relative } from "node:path";
+import { existsSync, readFileSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { resolve } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { parseArgs } from "node:util";
 import { fontAwesomeCatalog, resolveFontAwesomeKeys } from "./catalog.mjs";
-import { r as readFontAwesomeManifest } from "./chunks/manifest-BB3q10t1.mjs";
+import { f as fontAwesomeProSourcesDir, i as isFontAwesomeIsolated, r as readFontAwesomeManifest, a as fontAwesomeManifestKeys } from "./chunks/manifest-CF473fsM.mjs";
 const tokenVariable = "FONTAWESOME_PACKAGE_TOKEN";
 const tokenPlaceholder = `\${${tokenVariable}}`;
 const registry = "https://npm.fontawesome.com/";
@@ -23,30 +23,29 @@ const workspaceVariables = [
   "NPM_CONFIG_WORKSPACES"
 ];
 const usage = `Usage:
-  featherk-fontawesome-setup (--manifest <icons.json> | --keys <a,b>) [--free-only]
-  featherk-fontawesome-setup --source-root <dir> [--refresh-lock]
-  featherk-fontawesome-setup --source-root <dir> --init (--manifest <icons.json> | --keys <a,b>) [--force]
+  featherk-fontawesome-setup --manifest <icons.json> [--free-only]
+  featherk-fontawesome-setup
 
-Default (Free + Pro): run once from the application root on a developer
-machine. Adds the @fortawesome registry lines to .npmrc (token placeholder
-only) and installs exact pins for all selected keys as devDependencies.
-Commit .npmrc, package.json, and package-lock.json. Later installs, including
-CI, give ${tokenVariable} only to "npm ci --ignore-scripts", then run any
-needed install scripts (npm rebuild for dependencies, plus the app's own) and
-builds without it. Do not export the token persistently.
+Run from the application root. The manifest contains
+{ "free": [keys], "pro": [keys] }, the same file the Vite plugin reads.
 
---free-only: Free keys only from public npm. No .npmrc changes, no token.
+--manifest (default): installs exact Free pins into the app's devDependencies
+from public npm, and writes exact Pro pins into an isolated private source
+project, ${fontAwesomeProSourcesDir}/, then installs it with the token. The
+app's own install never needs the token. Rerun after changing the manifest.
+Commit package.json, package-lock.json, and ${fontAwesomeProSourcesDir}/
+(its node_modules is ignored).
 
---source-root <dir>: install licensed packages into an isolated private
-source project instead (npm ci when its lockfile exists). --init scaffolds
-that project; with --force, a lockfile for different dependencies is removed
-so the next install regenerates it. --refresh-lock runs npm install to update
-the lockfile after editing package.json by hand. In CI, --init and
---refresh-lock are refused and a lockfile is required.
+No arguments: installs ${fontAwesomeProSourcesDir}/ from its committed
+lockfile with the token, for CI and fresh clones. Run it after the app's own
+"npm ci".
+
+--free-only: Free keys only from public npm. No token, no source project.
 
 The token comes from ${tokenVariable} or a hidden prompt in an interactive
-terminal. App-root setup changes package.json and is refused in CI
-(CI, TEAMCITY_VERSION, or GITHUB_ACTIONS is set).`;
+terminal. --manifest setup changes package.json and is refused in CI
+(CI, TEAMCITY_VERSION, or GITHUB_ACTIONS is set). Do not export the token
+persistently.`;
 function promptForTerminalToken() {
   const input = process.stdin;
   if (!input.isTTY || typeof input.setRawMode !== "function") {
@@ -125,19 +124,13 @@ function requireNpm(context) {
   return npmCli;
 }
 async function readKeys(values, context) {
-  if (values.keys && values.manifest) {
-    throw new Error("Provide either --keys or --manifest, not both.");
-  }
-  if (values.keys) {
-    return values.keys.split(",").map((key) => key.trim()).filter(Boolean);
-  }
   if (!values.manifest) {
-    throw new Error("Provide --manifest or --keys. Use --help for usage.");
+    throw new Error("Provide --manifest. Use --help for usage.");
   }
-  const { free, pro } = await readFontAwesomeManifest(
+  const manifest = await readFontAwesomeManifest(
     resolve(context.cwd, values.manifest)
   );
-  return [...free, ...pro];
+  return fontAwesomeManifestKeys(manifest);
 }
 function resolvePins(keys) {
   const tiers = new Map(
@@ -192,54 +185,10 @@ function checkNpmrc(config, file) {
   }
   return { fontAwesomeRegistry, hasAuth };
 }
-async function setupAppRoot(values, context) {
-  const { log } = context;
-  if (context.isCi) {
-    throw new Error(
-      `App-root setup changes package.json and is a local, one-time step. In CI, give ${tokenVariable} only to "npm ci --ignore-scripts", then run needed install scripts and the build without it.`
-    );
-  }
-  const appRoot = context.cwd;
-  if (!existsSync(resolve(appRoot, "package.json"))) {
-    throw new Error(
-      "Run this command from the application root (package.json not found)."
-    );
-  }
-  const freeOnly = Boolean(values["free-only"]);
-  const pins = resolvePins(await readKeys(values, context));
-  const proPins = [...pins.values()].filter((pin) => pin.tier === "pro");
-  if (freeOnly && proPins.length) {
-    throw new Error(
-      `--free-only cannot install Pro keys: ${proPins.map((pin) => pin.key).join(", ")}.`
-    );
-  }
-  if (!pins.size) {
-    throw new Error("No Font Awesome keys selected.");
-  }
-  const npmrcPath = resolve(appRoot, ".npmrc");
-  const config = existsSync(npmrcPath) ? readFileSync(npmrcPath, "utf8") : "";
-  const { fontAwesomeRegistry, hasAuth } = checkNpmrc(config, ".npmrc");
-  if (freeOnly && fontAwesomeRegistry) {
-    throw new Error(
-      `.npmrc routes @fortawesome to ${fontAwesomeRegistry}, so this app is set up for Pro. Run without --free-only.`
-    );
-  }
+function installFreeIntoApp(pins, context) {
   const npmCli = requireNpm(context);
   const environment = { ...context.env };
-  if (!freeOnly) {
-    environment[tokenVariable] = await readToken(context);
-    const missing = [];
-    if (!fontAwesomeRegistry) missing.push(npmrcLines[0], npmrcLines[1]);
-    if (!hasAuth) missing.push(npmrcLines[2], npmrcLines[3]);
-    if (missing.length) {
-      const separator = config && !config.endsWith("\n") ? "\n" : "";
-      writeFileSync(npmrcPath, `${config}${separator}${missing.join("\n")}
-`);
-      log(
-        `${config ? "Updated" : "Created"} .npmrc with the Font Awesome registry and token placeholder.`
-      );
-    }
-  }
+  delete environment[tokenVariable];
   const specs = [...pins].map(([name, pin]) => `${name}@${pin.spec}`);
   const status = context.runNpm({
     npmCli,
@@ -250,27 +199,17 @@ async function setupAppRoot(values, context) {
       "--ignore-scripts",
       "--no-audit",
       "--no-fund",
-      ...freeOnly ? [] : [pinRegistry],
       ...specs
     ],
-    cwd: appRoot,
+    cwd: context.cwd,
     env: environment
   });
-  if (status !== 0) return status;
-  log(`Installed ${specs.length} Font Awesome package(s): ${specs.join(" ")}`);
-  log(
-    "Lifecycle scripts were skipped. If needed, run npm rebuild for dependency scripts and the app's own scripts (e.g. npm run prepare --if-present)."
-  );
-  if (freeOnly) {
-    log(
-      "Next: commit package.json and package-lock.json. Keep the Vite plugin's allowPro unset (Free only); no CI token is needed."
-    );
-  } else {
-    log(
-      `Next: commit .npmrc, package.json, and package-lock.json. Set allowPro: true in the Vite plugin (no sourceRoot). Later installs, including CI, give ${tokenVariable} only to "npm ci --ignore-scripts"; run needed install scripts and builds without it. See LICENSING.md for the TeamCity setup.`
+  if (status === 0) {
+    context.log(
+      `Installed ${specs.length} Font Awesome package(s) into the app: ${specs.join(" ")}`
     );
   }
-  return 0;
+  return status;
 }
 function readDependencies(packageJsonPath) {
   try {
@@ -284,109 +223,61 @@ function readDependencies(packageJsonPath) {
     return void 0;
   }
 }
-async function initSourceProject(sourceRoot, values, context) {
-  const { log, display } = context;
-  if (context.isCi) {
-    throw new Error(
-      "--init is a local, one-time step. Commit the scaffolded source project instead of generating it in CI."
-    );
-  }
-  const pins = resolvePins(await readKeys(values, context));
-  const dependencies = {};
-  const skipped = [];
-  for (const [name, pin] of pins) {
-    if (pin.tier === "pro") dependencies[name] = pin.spec;
-    else skipped.push(pin.key);
-  }
-  if (!Object.keys(dependencies).length) {
-    throw new Error(
-      "No Pro keys selected. Free packages belong in the application's own devDependencies."
-    );
-  }
-  const sortedDependencies = Object.fromEntries(
-    Object.entries(dependencies).sort()
+function writeSourceProject(sourceRoot, proPins, context) {
+  const dependencies = Object.fromEntries(
+    [...proPins].map(([name, pin]) => [name, pin.spec]).sort()
   );
+  const created = !existsSync(resolve(sourceRoot, "package.json"));
+  const lockfilePath = resolve(sourceRoot, "package-lock.json");
+  const removeStaleLockfile = existsSync(lockfilePath) && readDependencies(resolve(sourceRoot, "package.json")) !== JSON.stringify(dependencies);
   const files = {
     ".npmrc": `${npmrcLines.join("\n")}
 `,
     ".gitignore": "node_modules/\n",
     "package.json": `${JSON.stringify(
       {
-        name: "fontawesome-pro-sources",
+        name: fontAwesomeProSourcesDir,
         version: "0.0.0",
         private: true,
-        dependencies: sortedDependencies
+        dependencies
       },
       null,
       2
     )}
 `
   };
-  const existing = Object.keys(files).filter(
-    (name) => existsSync(resolve(sourceRoot, name))
-  );
-  if (existing.length && !values.force) {
-    throw new Error(
-      `${display(sourceRoot)} already contains ${existing.join(", ")}. Use --force to overwrite.`
-    );
-  }
-  const lockfilePath = resolve(sourceRoot, "package-lock.json");
-  const removeStaleLockfile = existsSync(lockfilePath) && readDependencies(resolve(sourceRoot, "package.json")) !== JSON.stringify(sortedDependencies);
   mkdirSync(sourceRoot, { recursive: true });
   for (const [name, content] of Object.entries(files)) {
     writeFileSync(resolve(sourceRoot, name), content);
   }
   if (removeStaleLockfile) rmSync(lockfilePath);
-  if (skipped.length) {
-    log(
-      `Skipped Free keys (install them in the application instead): ${skipped.join(", ")}`
-    );
-  }
-  log(
-    `Scaffolded ${display(sourceRoot)} with ${Object.keys(dependencies).length} Pro package(s).`
+  context.log(
+    `${created ? "Created" : "Updated"} ${fontAwesomeProSourcesDir}/ with ${proPins.size} Pro package(s).`
   );
   if (removeStaleLockfile) {
-    log(
-      `Removed ${display(sourceRoot)}/package-lock.json because the dependencies changed; the next install regenerates it.`
+    context.log(
+      `Removed ${fontAwesomeProSourcesDir}/package-lock.json because the Pro pins changed; this install regenerates it.`
     );
   }
-  log(
-    "Next: run this command with --source-root and without --init, then commit the source project and its package-lock.json."
-  );
-  return 0;
 }
-async function installSourceProject(sourceRoot, values, context) {
-  const { log, display } = context;
+async function installSourceProject(sourceRoot, token, context) {
   const npmCli = requireNpm(context);
-  for (const name of ["package.json", ".npmrc"]) {
-    if (!existsSync(resolve(sourceRoot, name))) {
-      throw new Error(
-        `${display(sourceRoot)}/${name} was not found. Check --source-root, or scaffold the project with --init.`
-      );
-    }
-  }
-  const npmrc = `${display(sourceRoot)}/.npmrc`;
+  const npmrc = `${fontAwesomeProSourcesDir}/.npmrc`;
   const { fontAwesomeRegistry, hasAuth } = checkNpmrc(
     readFileSync(resolve(sourceRoot, ".npmrc"), "utf8"),
     npmrc
   );
   if (!fontAwesomeRegistry || !hasAuth) {
     throw new Error(
-      `${npmrc} must contain @fortawesome:registry=${registry} and ${authKey}=${tokenPlaceholder}. Scaffold it with --init.`
-    );
-  }
-  const hasLockfile = existsSync(resolve(sourceRoot, "package-lock.json"));
-  if (context.isCi && !hasLockfile) {
-    throw new Error(
-      `${display(sourceRoot)}/package-lock.json is required in CI. Install locally first and commit the lockfile.`
+      `${npmrc} must contain @fortawesome:registry=${registry} and ${authKey}=${tokenPlaceholder}. Rerun with --manifest to rewrite it.`
     );
   }
-  if (context.isCi && values["refresh-lock"]) {
+  const locked = existsSync(resolve(sourceRoot, "package-lock.json"));
+  if (context.isCi && !locked) {
     throw new Error(
-      "--refresh-lock updates the lockfile and is a local step. In CI, install from the committed lockfile."
+      `${fontAwesomeProSourcesDir}/package-lock.json is required in CI. Run setup with --manifest locally first and commit the lockfile.`
     );
   }
-  const locked = hasLockfile && !values["refresh-lock"];
   const environment = {
     ...context.env,
     [tokenVariable]: await readToken(context)
@@ -406,12 +297,87 @@ async function installSourceProject(sourceRoot, values, context) {
     env: environment
   });
   if (status !== 0) return status;
-  const lockfile = `${display(sourceRoot)}/package-lock.json`;
-  log(
+  const lockfile = `${fontAwesomeProSourcesDir}/package-lock.json`;
+  context.log(
     locked ? `Pro sources installed from ${lockfile}.` : `Pro sources installed. Review and commit ${lockfile}.`
   );
+  context.log(
+    "Restart any running Vite dev server so it includes the installed Pro icons."
+  );
+  return 0;
+}
+async function setupFromManifest(values, context) {
+  const { log } = context;
+  const freeOnly = Boolean(values["free-only"]);
+  if (context.isCi) {
+    throw new Error(
+      `--manifest setup changes package.json and is a local step. In CI, run the app's own "npm ci", then featherk-fontawesome-setup without arguments to install ${fontAwesomeProSourcesDir}/.`
+    );
+  }
+  const appRoot = context.cwd;
+  if (!existsSync(resolve(appRoot, "package.json"))) {
+    throw new Error(
+      "Run this command from the application root (package.json not found)."
+    );
+  }
+  const pins = resolvePins(await readKeys(values, context));
+  if (!pins.size) {
+    throw new Error("No Font Awesome keys selected.");
+  }
+  const freePins = new Map([...pins].filter(([, pin]) => pin.tier !== "pro"));
+  const proPins = new Map([...pins].filter(([, pin]) => pin.tier === "pro"));
+  if (freeOnly && proPins.size) {
+    throw new Error(
+      `--free-only cannot install Pro keys: ${[...proPins.values()].map((pin) => pin.key).join(", ")}.`
+    );
+  }
+  const npmrcPath = resolve(appRoot, ".npmrc");
+  const config = existsSync(npmrcPath) ? readFileSync(npmrcPath, "utf8") : "";
+  const { fontAwesomeRegistry } = checkNpmrc(config, ".npmrc");
+  const sourceRoot = resolve(appRoot, fontAwesomeProSourcesDir);
+  const isolated = isFontAwesomeIsolated(appRoot);
+  if (fontAwesomeRegistry) {
+    throw new Error(
+      `.npmrc routes @fortawesome to ${fontAwesomeRegistry}, which installs Pro packages in the app itself; that layout is not supported. Remove the Font Awesome lines from .npmrc and any @fortawesome/pro-* packages from the app's devDependencies, then rerun.`
+    );
+  }
+  if (freeOnly && isolated) {
+    throw new Error(
+      `${fontAwesomeProSourcesDir}/ exists, so this app uses Pro. Run without --free-only, or remove ${fontAwesomeProSourcesDir}/ first.`
+    );
+  }
+  if (freePins.size) {
+    const status2 = installFreeIntoApp(freePins, context);
+    if (status2 !== 0) return status2;
+    log(lifecycleNote);
+  }
+  if (!proPins.size) {
+    if (isolated) {
+      log(
+        `The manifest has no Pro keys; ${fontAwesomeProSourcesDir}/ is no longer needed and can be removed.`
+      );
+    }
+    log(
+      "Next: commit package.json and package-lock.json. Configure the Vite plugin with { manifest }; no token is needed."
+    );
+    return 0;
+  }
+  writeSourceProject(sourceRoot, proPins, context);
+  const status = await installSourceProject(sourceRoot, void 0, context);
+  if (status !== 0) return status;
+  log(
+    `Next: commit package.json, package-lock.json, and ${fontAwesomeProSourcesDir}/. Configure the Vite plugin with { manifest }; builds include Pro icons wherever ${fontAwesomeProSourcesDir}/ is installed. In CI, run the app's "npm ci" without the token, then featherk-fontawesome-setup with ${tokenVariable}, then the normal build.`
+  );
   return 0;
 }
+const lifecycleNote = "Lifecycle scripts were skipped. If needed, run npm rebuild for dependency scripts and the app's own scripts (e.g. npm run prepare --if-present).";
+const removedFlags = [
+  "--keys",
+  "--source-root",
+  "--init",
+  "--force",
+  "--refresh-lock"
+];
 async function runFontAwesomeSetup(args, io = {}) {
   const cwd = io.cwd ?? process.cwd();
   const env = io.env ?? process.env;
@@ -423,20 +389,26 @@ async function runFontAwesomeSetup(args, io = {}) {
     isCi: Boolean(env.CI) && env.CI !== "false" || Boolean(env.TEAMCITY_VERSION || env.GITHUB_ACTIONS),
     log: io.stdout ?? console.log,
     promptForToken: io.promptForToken ?? promptForTerminalToken,
-    runNpm: io.runNpm ?? spawnNpm,
-    display: (path) => relative(cwd, path) || "."
+    runNpm: io.runNpm ?? spawnNpm
   };
+  const hasFlag = (flag) => args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
   try {
+    const removed = removedFlags.find(hasFlag);
+    if (removed) {
+      throw new Error(
+        `${removed} was removed in 0.16.0. Run setup with --manifest; Pro sources always live in ${fontAwesomeProSourcesDir}/, and rerunning with --manifest updates them. Use --help for usage.`
+      );
+    }
+    if (hasFlag("--pro-in-app")) {
+      throw new Error(
+        `--pro-in-app was removed. Pro packages always install into ${fontAwesomeProSourcesDir}/, so the app's own install never needs the token. Run setup with --manifest.`
+      );
+    }
     const { values } = parseArgs({
       args: [...args],
       options: {
-        "source-root": { type: "string" },
         "free-only": { type: "boolean" },
-        init: { type: "boolean" },
-        keys: { type: "string" },
         manifest: { type: "string" },
-        force: { type: "boolean" },
-        "refresh-lock": { type: "boolean" },
         help: { type: "boolean", short: "h" }
       },
       strict: true,
@@ -446,26 +418,22 @@ async function runFontAwesomeSetup(args, io = {}) {
       context.log(usage);
       return 0;
     }
-    if (values["source-root"] === void 0) {
-      if (values.init || values.force || values["refresh-lock"]) {
-        throw new Error(
-          "--init, --force, and --refresh-lock apply only with --source-root."
-        );
-      }
-      return await setupAppRoot(values, context);
+    if (values.manifest !== void 0) {
+      return await setupFromManifest(values, context);
     }
     if (values["free-only"]) {
-      throw new Error(
-        "--free-only applies only to app-root setup; an isolated source project holds Pro packages."
-      );
+      throw new Error("--free-only requires --manifest.");
     }
-    if (values.init && values["refresh-lock"]) {
+    if (!isFontAwesomeIsolated(cwd)) {
       throw new Error(
-        "--refresh-lock applies to the install step, not --init."
+        `${fontAwesomeProSourcesDir}/package.json was not found. Run from the application root; for first-time setup, run with --manifest <icons.json>.`
       );
     }
-    const sourceRoot = resolve(cwd, values["source-root"]);
-    return values.init ? await initSourceProject(sourceRoot, values, context) : await installSourceProject(sourceRoot, values, context);
+    return await installSourceProject(
+      resolve(cwd, fontAwesomeProSourcesDir),
+      void 0,
+      context
+    );
   } catch (error) {
     stderr(error instanceof Error ? error.message : "Unknown error");
     return 1;

package/dist/fontawesome/vite.cjs

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const node_path = require("node:path");
 const promises = require("node:fs/promises");
-const fontawesome_catalog = require("./catalog.cjs");
-const generate = require("./chunks/generate-BBurrhLv.cjs");
+const generate = require("./chunks/generate-B_FxftR7.cjs");
+const manifest = require("./chunks/manifest-DEhGKvmi.cjs");
 const virtualId = "virtual:featherk/fontawesome";
 const resolvedId = `\0${virtualId}`;
 function dependencyKey(file) {
@@ -11,20 +11,56 @@ function dependencyKey(file) {
   return process.platform === "win32" ? path.toLowerCase() : path;
 }
 function featherkFontAwesome(options) {
+  const legacy = options;
+  if (legacy.keys !== void 0 || legacy.allowPro !== void 0) {
+    throw new Error(
+      'Font Awesome Vite options "keys" and "allowPro" were removed in 0.16.0. List the keys in a { free, pro } manifest and pass { manifest: "fontawesome.keys.json" }.'
+    );
+  }
+  if (legacy.sourceRoot !== void 0 || legacy.proMode !== void 0) {
+    throw new Error(
+      `Font Awesome Vite options "sourceRoot" and "proMode" were removed in 0.16.0. Pro sources always live in ${manifest.fontAwesomeProSourcesDir}/ and are used wherever it is installed; pass only { manifest }.`
+    );
+  }
+  if (typeof options.manifest !== "string" || !options.manifest.trim()) {
+    throw new Error(
+      'Font Awesome Vite options require a manifest path, such as { manifest: "fontawesome.keys.json" }'
+    );
+  }
   let root = node_path.resolve(options.root ?? process.cwd());
+  let logger;
   let generation;
   let dependencies = /* @__PURE__ */ new Set();
-  function regenerate() {
-    generation = generate.generateFaIcons({
-      keys: options.keys,
-      root,
-      sourceRoot: options.sourceRoot,
-      allowPro: options.allowPro,
-      virtualTypesFile: options.virtualTypesFile === false ? void 0 : options.virtualTypesFile ?? "src/featherk-fontawesome.d.ts"
-    }).then((result) => {
-      dependencies = new Set(result.dependencies.map(dependencyKey));
+  let watchFiles = [];
+  async function resolveSelection() {
+    const manifestFile = node_path.resolve(root, options.manifest);
+    const manifest$1 = await manifest.readFontAwesomeManifest(manifestFile).catch(
+      (error) => {
+        throw new Error(
+          `Cannot read Font Awesome manifest ${node_path.relative(root, manifestFile) || manifestFile}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    );
+    return {
+      ...manifest.selectFontAwesomeManifestKeys(manifest$1, root),
+      // Match the real paths that handleHotUpdate compares against.
+      manifestFile: await promises.realpath(manifestFile)
+    };
+  }
+  function regenerate(selection) {
+    generation = (async () => {
+      const selected = selection ?? await resolveSelection();
+      const result = await generate.generateFaIcons({
+        keys: selected.keys,
+        root,
+        sourceRoot: selected.sourceRoot,
+        allowPro: selected.allowPro,
+        virtualTypesFile: options.virtualTypesFile === false ? void 0 : options.virtualTypesFile ?? "src/featherk-fontawesome.d.ts"
+      });
+      watchFiles = [...result.dependencies, selected.manifestFile];
+      dependencies = new Set(watchFiles.map(dependencyKey));
       return result;
-    });
+    })();
     return generation;
   }
   return {
@@ -32,20 +68,12 @@ function featherkFontAwesome(options) {
     enforce: "pre",
     async configResolved(config) {
       root = node_path.resolve(config.root, options.root ?? ".");
-      const installCommand = options.keys === void 0 ? void 0 : fontawesome_catalog.getFontAwesomeInstallCommand(options.keys, {
-        allowPro: options.allowPro
-      });
-      if (installCommand) {
-        console.info(
-          `[featherk-fontawesome] Install selected source packages with:
-${installCommand}`
-        );
-      }
-      await regenerate();
+      if (config.command === "build") logger = config.logger;
+      await regenerate(await resolveSelection());
     },
     async buildStart() {
-      const result = await regenerate();
-      for (const file of result.dependencies) this.addWatchFile(file);
+      await regenerate();
+      for (const file of watchFiles) this.addWatchFile(file);
     },
     resolveId(id) {
       return id === virtualId ? resolvedId : void 0;
@@ -55,14 +83,14 @@ ${installCommand}`
       return (await (generation ?? regenerate())).moduleCode;
     },
     async configureServer(server) {
-      const result = await (generation ?? regenerate());
-      server.watcher.add(result.dependencies);
+      await (generation ?? regenerate());
+      server.watcher.add(watchFiles);
     },
     async handleHotUpdate(context) {
       const file = await promises.realpath(context.file).catch(() => context.file);
       if (!dependencies.has(dependencyKey(file))) return void 0;
-      const result = await regenerate();
-      context.server.watcher.add(result.dependencies);
+      await regenerate();
+      context.server.watcher.add(watchFiles);
       const module2 = context.server.moduleGraph.getModuleById(resolvedId);
       if (module2) context.server.moduleGraph.invalidateModule(module2);
       context.server.ws.send({ type: "full-reload" });
@@ -77,6 +105,14 @@ ${installCommand}`
           source: result.notices
         });
       }
+    },
+    async closeBundle() {
+      const result = await generation?.catch(() => void 0);
+      if (logger && result) {
+        logger.info(
+          `[featherk-fontawesome] Generated ${generate.summarizeFaIcons(result.provenance)}`
+        );
+      }
     }
   };
 }

package/dist/fontawesome/vite.d.ts

@@ -1,13 +1,33 @@
 import type { Plugin } from "vite";
-import type { FontAwesomeOptions } from "./types";
-/** Configuration for the Font Awesome virtual module plugin. */
-export interface FontAwesomeViteOptions extends FontAwesomeOptions {
+/**
+ * Configuration for the Font Awesome virtual module plugin. Selections come
+ * from the same keys-only `{ free, pro }` manifest used by
+ * `featherk-fontawesome-setup`.
+ *
+ * The `free` keys come from the project's own installed packages. The `pro`
+ * keys are generated from the `fontawesome-pro-sources/` source project, only
+ * in builds where that project is installed.
+ */
+export interface FontAwesomeViteOptions {
+    /** Keys-only manifest path, relative to the project root. */
+    manifest: string;
+    /** Project root, relative to Vite's root. */
+    root?: string;
     virtualTypesFile?: string | false;
+    /** Removed in 0.16.0; list keys in the manifest instead. */
+    keys?: never;
+    /** Removed in 0.16.0; Pro selection follows the manifest and layout. */
+    allowPro?: never;
+    /** Removed in 0.16.0; Pro sources always live in `fontawesome-pro-sources/`. */
+    sourceRoot?: never;
 }
 /**
  * Creates the Vite plugin for `virtual:featherk/fontawesome`.
  *
- * Catalog keys are resolved during Vite config setup, and their license
- * notices are emitted into production builds.
+ * Keys are read from the manifest and resolved during Vite config setup, and
+ * their license notices are emitted into production builds. Mode gating
+ * selects which keys to generate; it is not license authorization.
+ *
+ * @throws If `manifest` is missing or a removed option is provided.
  */
 export declare function featherkFontAwesome(options: FontAwesomeViteOptions): Plugin;