@featherk/icons 0.15.7 → 0.16.0

package/dist/fontawesome/setup.mjs

@@ -0,0 +1,482 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, 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 { f as fontAwesomeProSourcesDir, i as isFontAwesomeIsolated, r as readFontAwesomeManifest, a as fontAwesomeManifestKeys } from "./chunks/manifest-CSRIDvaR.mjs";
+const tokenVariable = "FONTAWESOME_PACKAGE_TOKEN";
+const tokenPlaceholder = `\${${tokenVariable}}`;
+const registry = "https://npm.fontawesome.com/";
+const authKey = "//npm.fontawesome.com/:_authToken";
+const pinRegistry = `--@fortawesome:registry=${registry}`;
+const npmrcLines = [
+  "# Route @fortawesome packages to the Font Awesome Pro registry.",
+  `@fortawesome:registry=${registry}`,
+  "# Authenticate using the token from the environment; never commit a token.",
+  `${authKey}=${tokenPlaceholder}`
+];
+const workspaceVariables = [
+  "npm_config_workspace",
+  "npm_config_workspaces",
+  "NPM_CONFIG_WORKSPACE",
+  "NPM_CONFIG_WORKSPACES"
+];
+const usage = `Usage:
+  featherk-fontawesome-setup --manifest <icons.json> [--free-only | --pro-in-app]
+  featherk-fontawesome-setup
+
+Run from the application root. The manifest contains
+{ "free": [keys], "pro": [keys] }, the same file the Vite plugin reads.
+
+--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).
+
+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.
+
+--pro-in-app: installs Free and Pro pins into the app's own devDependencies
+and routes @fortawesome to the Pro registry in the app's .npmrc (token
+placeholder only). Every install of the app, including CI, then needs the
+token for "npm ci --ignore-scripts". Use only when the isolated project is not
+an option.
+
+The token comes from ${tokenVariable} or a hidden prompt in an interactive
+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") {
+    throw new Error(
+      `${tokenVariable} is not set and this is not an interactive terminal. Provide it through an approved CI secret environment.`
+    );
+  }
+  emitKeypressEvents(input);
+  process.stdout.write("Font Awesome Pro Package Token (input hidden): ");
+  const wasRaw = input.isRaw;
+  input.setRawMode(true);
+  input.resume();
+  return new Promise((resolveToken, rejectToken) => {
+    const characters = [];
+    const finish = (error) => {
+      input.off("keypress", onKeypress);
+      input.setRawMode(wasRaw);
+      input.pause();
+      process.stdout.write("\n");
+      if (error) rejectToken(error);
+      else resolveToken(characters.join(""));
+    };
+    const onKeypress = (character, key = {}) => {
+      if (key.ctrl && key.name === "c") {
+        finish(new Error("Token entry cancelled."));
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        finish();
+        return;
+      }
+      if (key.name === "backspace") {
+        if (characters.length) {
+          characters.pop();
+          process.stdout.write("\b \b");
+        }
+        return;
+      }
+      if (!key.ctrl && !key.meta && character && !character.startsWith("\x1B")) {
+        for (const item of character) {
+          if (item >= " " && item <= "~") {
+            characters.push(item);
+            process.stdout.write("*");
+          }
+        }
+      }
+    };
+    input.on("keypress", onKeypress);
+  });
+}
+const spawnNpm = ({ npmCli, args, cwd, env }) => {
+  const result = spawnSync(process.execPath, [npmCli, ...args], {
+    cwd,
+    env,
+    stdio: "inherit"
+  });
+  if (result.error) throw result.error;
+  return result.status ?? 1;
+};
+async function readToken(context) {
+  const token = context.env[tokenVariable] || await context.promptForToken();
+  if (!token) {
+    throw new Error(
+      "A Font Awesome Pro Package Token is required to install Pro packages."
+    );
+  }
+  return token;
+}
+function requireNpm(context) {
+  const npmCli = context.env.npm_execpath;
+  if (!npmCli) {
+    throw new Error(
+      "Run this command through an npm script or npx so npm is available."
+    );
+  }
+  return npmCli;
+}
+async function readKeys(values, context) {
+  if (!values.manifest) {
+    throw new Error("Provide --manifest. Use --help for usage.");
+  }
+  const manifest = await readFontAwesomeManifest(
+    resolve(context.cwd, values.manifest)
+  );
+  return fontAwesomeManifestKeys(manifest);
+}
+function resolvePins(keys) {
+  const tiers = new Map(
+    fontAwesomeCatalog.map((entry) => [entry.key, entry.tier])
+  );
+  const pins = /* @__PURE__ */ new Map();
+  for (const selection of resolveFontAwesomeKeys(keys, { allowPro: true })) {
+    const spec = selection.package === selection.registryPackage ? selection.version : `npm:${selection.registryPackage}@${selection.version}`;
+    const existing = pins.get(selection.package);
+    if (existing && existing.spec !== spec) {
+      throw new Error(
+        `Conflicting pins for ${selection.package}: ${existing.spec} and ${spec}.`
+      );
+    }
+    if (!existing) {
+      pins.set(selection.package, {
+        tier: tiers.get(selection.key),
+        spec,
+        key: selection.key
+      });
+    }
+  }
+  return pins;
+}
+function checkNpmrc(config, file) {
+  let fontAwesomeRegistry;
+  let hasAuth = false;
+  for (const raw of config.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+    const separator = line.indexOf("=");
+    const key = (separator < 0 ? line : line.slice(0, separator)).trim();
+    const value = separator < 0 ? "" : line.slice(separator + 1).trim();
+    if (key === "@fortawesome:registry") {
+      fontAwesomeRegistry = value;
+    } else if (key === authKey && value === tokenPlaceholder) {
+      hasAuth = true;
+    } else if (key.includes("npm.fontawesome.com")) {
+      throw new Error(
+        `${file} may configure npm.fontawesome.com only as ${authKey}=${tokenPlaceholder}; remove "${key}".`
+      );
+    } else if (line.includes(tokenVariable)) {
+      throw new Error(
+        `${file} references ${tokenVariable} in "${key}"; the token may only authenticate npm.fontawesome.com.`
+      );
+    }
+  }
+  if (fontAwesomeRegistry !== void 0 && fontAwesomeRegistry.replace(/\/?$/, "/") !== registry) {
+    throw new Error(
+      `${file} routes @fortawesome to ${fontAwesomeRegistry}; the Pro token may only be sent to ${registry}.`
+    );
+  }
+  return { fontAwesomeRegistry, hasAuth };
+}
+function installIntoApp(pins, pro, token, context) {
+  const npmCli = requireNpm(context);
+  const environment = { ...context.env };
+  delete environment[tokenVariable];
+  if (pro && token) environment[tokenVariable] = token;
+  const specs = [...pins].map(([name, pin]) => `${name}@${pin.spec}`);
+  const status = context.runNpm({
+    npmCli,
+    args: [
+      "install",
+      "--save-dev",
+      "--save-exact",
+      "--ignore-scripts",
+      "--no-audit",
+      "--no-fund",
+      ...pro ? [pinRegistry] : [],
+      ...specs
+    ],
+    cwd: context.cwd,
+    env: environment
+  });
+  if (status === 0) {
+    context.log(
+      `Installed ${specs.length} Font Awesome package(s) into the app: ${specs.join(" ")}`
+    );
+  }
+  return status;
+}
+function readDependencies(packageJsonPath) {
+  try {
+    const { dependencies = {} } = JSON.parse(
+      readFileSync(packageJsonPath, "utf8")
+    );
+    return JSON.stringify(
+      Object.fromEntries(Object.entries(dependencies).sort())
+    );
+  } catch {
+    return void 0;
+  }
+}
+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: fontAwesomeProSourcesDir,
+        version: "0.0.0",
+        private: true,
+        dependencies
+      },
+      null,
+      2
+    )}
+`
+  };
+  mkdirSync(sourceRoot, { recursive: true });
+  for (const [name, content] of Object.entries(files)) {
+    writeFileSync(resolve(sourceRoot, name), content);
+  }
+  if (removeStaleLockfile) rmSync(lockfilePath);
+  context.log(
+    `${created ? "Created" : "Updated"} ${fontAwesomeProSourcesDir}/ with ${proPins.size} Pro package(s).`
+  );
+  if (removeStaleLockfile) {
+    context.log(
+      `Removed ${fontAwesomeProSourcesDir}/package-lock.json because the Pro pins changed; this install regenerates it.`
+    );
+  }
+}
+async function installSourceProject(sourceRoot, token, context) {
+  const npmCli = requireNpm(context);
+  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}. Rerun with --manifest to rewrite it.`
+    );
+  }
+  const locked = existsSync(resolve(sourceRoot, "package-lock.json"));
+  if (context.isCi && !locked) {
+    throw new Error(
+      `${fontAwesomeProSourcesDir}/package-lock.json is required in CI. Run setup with --manifest locally first and commit the lockfile.`
+    );
+  }
+  const environment = {
+    ...context.env,
+    [tokenVariable]: await readToken(context)
+  };
+  for (const name of workspaceVariables) delete environment[name];
+  const status = context.runNpm({
+    npmCli,
+    args: [
+      locked ? "ci" : "install",
+      "--workspaces=false",
+      "--ignore-scripts",
+      "--no-audit",
+      "--no-fund",
+      pinRegistry
+    ],
+    cwd: sourceRoot,
+    env: environment
+  });
+  if (status !== 0) return status;
+  const lockfile = `${fontAwesomeProSourcesDir}/package-lock.json`;
+  context.log(
+    locked ? `Pro sources installed from ${lockfile}.` : `Pro sources installed. Review and commit ${lockfile}.`
+  );
+  return 0;
+}
+async function setupFromManifest(values, context) {
+  const { log } = context;
+  const freeOnly = Boolean(values["free-only"]);
+  const proInApp = Boolean(values["pro-in-app"]);
+  if (freeOnly && proInApp) {
+    throw new Error("Use either --free-only or --pro-in-app, not both.");
+  }
+  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, hasAuth } = checkNpmrc(config, ".npmrc");
+  const sourceRoot = resolve(appRoot, fontAwesomeProSourcesDir);
+  const isolated = isFontAwesomeIsolated(appRoot);
+  if (proInApp && isolated) {
+    throw new Error(
+      `${fontAwesomeProSourcesDir}/ exists, so this app keeps Pro in the isolated source project. Run without --pro-in-app, or remove ${fontAwesomeProSourcesDir}/ first.`
+    );
+  }
+  if (!proInApp && fontAwesomeRegistry) {
+    throw new Error(
+      `.npmrc routes @fortawesome to ${fontAwesomeRegistry}, so this app installs Pro in the app itself. Rerun with --pro-in-app.`
+    );
+  }
+  if (freeOnly && isolated) {
+    throw new Error(
+      `${fontAwesomeProSourcesDir}/ exists, so this app uses Pro. Run without --free-only, or remove ${fontAwesomeProSourcesDir}/ first.`
+    );
+  }
+  if (proInApp) {
+    const token = proPins.size ? await readToken(context) : void 0;
+    if (proPins.size) {
+      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.`
+        );
+      }
+    }
+    const status2 = installIntoApp(pins, proPins.size > 0, token, context);
+    if (status2 !== 0) return status2;
+    log(lifecycleNote);
+    log(
+      `Next: commit .npmrc, package.json, and package-lock.json. Configure the Vite plugin with { manifest }. Every later install, including CI, gives ${tokenVariable} only to "npm ci --ignore-scripts"; run needed install scripts and builds without it.`
+    );
+    return 0;
+  }
+  if (freePins.size) {
+    const status2 = installIntoApp(freePins, false, void 0, 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;
+  const stderr = io.stderr ?? console.error;
+  const context = {
+    cwd,
+    env,
+    // TeamCity and GitHub Actions are detected directly; TeamCity does not set CI.
+    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
+  };
+  try {
+    const removed = removedFlags.find(
+      (flag) => args.some((arg) => arg === flag || arg.startsWith(`${flag}=`))
+    );
+    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.`
+      );
+    }
+    const { values } = parseArgs({
+      args: [...args],
+      options: {
+        "free-only": { type: "boolean" },
+        "pro-in-app": { type: "boolean" },
+        manifest: { type: "string" },
+        help: { type: "boolean", short: "h" }
+      },
+      strict: true,
+      allowPositionals: false
+    });
+    if (values.help) {
+      context.log(usage);
+      return 0;
+    }
+    if (values.manifest !== void 0) {
+      return await setupFromManifest(values, context);
+    }
+    if (values["free-only"] || values["pro-in-app"]) {
+      throw new Error("--free-only and --pro-in-app require --manifest.");
+    }
+    if (!isFontAwesomeIsolated(cwd)) {
+      throw new Error(
+        `${fontAwesomeProSourcesDir}/package.json was not found. Run from the application root; for first-time setup, run with --manifest <icons.json>.`
+      );
+    }
+    return await installSourceProject(
+      resolve(cwd, fontAwesomeProSourcesDir),
+      void 0,
+      context
+    );
+  } catch (error) {
+    stderr(error instanceof Error ? error.message : "Unknown error");
+    return 1;
+  }
+}
+export {
+  checkNpmrc,
+  runFontAwesomeSetup
+};

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-Yjw62jxG.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,34 @@
 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`.
+ *
+ * When the project has a `fontawesome-pro-sources/` source project (the
+ * default setup), the manifest's `pro` keys are generated from it only in
+ * builds where that project is installed. Otherwise every key comes from the
+ * project's own installed packages.
+ */
+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;