figma-cache-toolchain 2.0.5 → 2.0.7

package/scripts/generate-icon-insets-from-batch.cjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Generate iconInsets.<cacheKey>.generated.ts for each batch item.
+ * Output directory defaults to the target component directory (dirname(target)).
+ *
+ * Usage:
+ *   node scripts/generate-icon-insets-from-batch.cjs --batch=./figma-e2e-batch.json
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const ROOT = process.cwd();
+const DEFAULT_INDEX_ABS = path.join(ROOT, "figma-cache", "index.json");
+
+function normalizeNodeId(input) {
+  const value = String(input || "").trim();
+  if (!value) return "";
+  return value.includes(":") ? value : value.replace(/-/g, ":");
+}
+
+function cacheKeyFromItem(item) {
+  const fileKey = String(item && item.fileKey ? item.fileKey : "").trim();
+  const nodeId = String(item && item.nodeId ? item.nodeId : "").trim();
+  if (!fileKey || !nodeId) return "";
+  return `${fileKey}#${normalizeNodeId(nodeId)}`;
+}
+
+function normalizeCacheKey(input) {
+  const value = String(input || "").trim();
+  if (!value) return "";
+  const parts = value.split("#");
+  if (parts.length !== 2) return value;
+  return `${parts[0]}#${normalizeNodeId(parts[1])}`;
+}
+
+function toRelatedCacheKeys(item) {
+  const raw = item && item.relatedCacheKeys;
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw.map(normalizeCacheKey).filter(Boolean);
+  if (typeof raw === "string") {
+    return raw
+      .split(",")
+      .map((s) => normalizeCacheKey(s))
+      .filter(Boolean);
+  }
+  return [];
+}
+
+function extractCacheKeyFromFigmaUrl(url) {
+  const input = String(url || "").trim();
+  if (!input) return "";
+  // Matches:
+  // https://www.figma.com/design/<fileKey>/... ?node-id=9277-28552
+  // https://www.figma.com/file/<fileKey>/... ?node-id=9277%3A28552
+  const fileKeyMatch = input.match(/figma\.com\/(?:design|file)\/([^/]+)/i);
+  const nodeIdMatch = input.match(/[?&]node-id=([^&]+)/i);
+  if (!fileKeyMatch || !nodeIdMatch) return "";
+  const fileKey = String(fileKeyMatch[1] || "").trim();
+  const decodedNode = decodeURIComponent(String(nodeIdMatch[1] || "").trim());
+  const nodeId = normalizeNodeId(decodedNode);
+  if (!fileKey || !nodeId) return "";
+  return `${fileKey}#${nodeId}`;
+}
+
+function toRelatedUrls(item) {
+  const raw = item && item.relatedUrls;
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw.map((u) => String(u || "").trim()).filter(Boolean);
+  if (typeof raw === "string") {
+    return raw
+      .split(",")
+      .map((s) => String(s || "").trim())
+      .filter(Boolean);
+  }
+  return [];
+}
+
+function safeReadJson(absPath) {
+  try {
+    return JSON.parse(fs.readFileSync(absPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function relatedFromFlowIndex(cacheKey) {
+  const enabled = process.env.FIGMA_UI_RELATED_FROM_FLOW !== "0";
+  if (!enabled) return [];
+  const index = safeReadJson(DEFAULT_INDEX_ABS);
+  if (!index || typeof index !== "object" || !index.flows) return [];
+  const flows = index.flows;
+  const related = new Set();
+  Object.keys(flows).forEach((flowId) => {
+    const flow = flows[flowId];
+    const nodes = flow && Array.isArray(flow.nodes) ? flow.nodes : [];
+    if (!nodes.includes(cacheKey)) return;
+    nodes.forEach((k) => {
+      if (k && k !== cacheKey) related.add(normalizeCacheKey(k));
+    });
+  });
+  return Array.from(related).filter(Boolean);
+}
+
+function resolveTargetAbs(rawTarget) {
+  const trimmed = String(rawTarget || "").trim();
+  if (!trimmed) return "";
+  return path.isAbsolute(trimmed) ? path.normalize(trimmed) : path.join(ROOT, trimmed);
+}
+
+function parseArgs(argv) {
+  const out = {
+    batch: path.join(ROOT, "figma-e2e-batch.json"),
+    maxBox: 24,
+    toolchainGenerateScript: path.join(__dirname, "generate-icon-insets.cjs"),
+  };
+  argv.slice(2).forEach((arg) => {
+    if (arg.startsWith("--batch=")) out.batch = arg.split("=").slice(1).join("=").trim();
+    if (arg.startsWith("--max-box=")) out.maxBox = Number(arg.split("=").slice(1).join("=").trim());
+  });
+  return out;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const batchAbs = path.isAbsolute(args.batch) ? args.batch : path.join(ROOT, args.batch);
+  if (!fs.existsSync(batchAbs)) {
+    console.error(`[generate-icon-insets-from-batch] batch not found: ${batchAbs}`);
+    process.exit(2);
+  }
+  const payload = JSON.parse(fs.readFileSync(batchAbs, "utf8"));
+  if (!Array.isArray(payload) || payload.length === 0) {
+    console.error("[generate-icon-insets-from-batch] batch must be a non-empty array");
+    process.exit(2);
+  }
+
+  const genAbs = args.toolchainGenerateScript;
+  if (!fs.existsSync(genAbs)) {
+    console.error(`[generate-icon-insets-from-batch] missing generator: ${genAbs}`);
+    process.exit(2);
+  }
+
+  const outputs = [];
+  payload.forEach((item, idx) => {
+    const cacheKey = String(item && (item.cacheKey || cacheKeyFromItem(item)) || "").trim();
+    const targetAbs = resolveTargetAbs(item && item.target);
+    const relatedCacheKeysExplicit = toRelatedCacheKeys(item);
+    const relatedCacheKeysFromUrls = toRelatedUrls(item)
+      .map(extractCacheKeyFromFigmaUrl)
+      .map(normalizeCacheKey)
+      .filter(Boolean);
+    const relatedCacheKeysFromFlow = relatedFromFlowIndex(cacheKey);
+    const relatedCacheKeys = Array.from(
+      new Set([...relatedCacheKeysExplicit, ...relatedCacheKeysFromUrls, ...relatedCacheKeysFromFlow])
+    ).filter(Boolean);
+    if (!cacheKey) {
+      console.error(`[generate-icon-insets-from-batch] case[${idx}] missing cacheKey or (fileKey+nodeId)`);
+      process.exit(2);
+    }
+    if (!targetAbs) {
+      console.error(`[generate-icon-insets-from-batch] case[${idx}] missing target`);
+      process.exit(2);
+    }
+    const targetDir = path.dirname(targetAbs);
+    const rawArgs = [cacheKey, ...relatedCacheKeys]
+      .map((ck) => {
+        const [fk, nid] = String(ck).split("#");
+        const safeNodeDir = String(nid || "").replace(/:/g, "-");
+        const rawAbs = path.join(ROOT, "figma-cache", "files", fk, "nodes", safeNodeDir, "raw.json");
+        if (!fs.existsSync(rawAbs)) {
+          console.error(`[generate-icon-insets-from-batch] raw.json not found for ${ck}: ${rawAbs}`);
+          process.exit(2);
+        }
+        return `--raw="${rawAbs}"`;
+      })
+      .join(" ");
+
+    execSync(`node "${genAbs}" ${rawArgs} --out-dir="${targetDir}" --cacheKey="${cacheKey}" --max-box=${args.maxBox}`, {
+      cwd: ROOT,
+      stdio: "pipe",
+    });
+    outputs.push({ cacheKey, outDir: targetDir });
+  });
+
+  console.log(
+    `[generate-icon-insets-from-batch] ok (${outputs.length} cases)`
+  );
+}
+
+main();
+

package/scripts/generate-icon-insets.cjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Toolchain-provided icon inset exporter.
+ * Reads raw.json.iconMetrics and emits a TS mapping file for machine consumption.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+function parseArgs(argv) {
+  const out = {
+    raw: [],
+    out: "",
+    maxBox: 24,
+    cacheKey: "",
+    outDir: "",
+  };
+  argv.slice(2).forEach((arg) => {
+    if (arg.startsWith("--raw=")) out.raw.push(arg.split("=").slice(1).join("=").trim());
+    if (arg.startsWith("--out=")) out.out = arg.split("=").slice(1).join("=").trim();
+    if (arg.startsWith("--out-dir=")) out.outDir = arg.split("=").slice(1).join("=").trim();
+    if (arg.startsWith("--cacheKey=")) out.cacheKey = arg.split("=").slice(1).join("=").trim();
+    if (arg.startsWith("--max-box=")) out.maxBox = Number(arg.split("=").slice(1).join("=").trim());
+  });
+  return out;
+}
+
+function readJson(absPath) {
+  return JSON.parse(fs.readFileSync(absPath, "utf8"));
+}
+
+function formatNumber(n) {
+  const num = Number(n);
+  if (!Number.isFinite(num)) return "0";
+  return String(Number(num.toFixed(4))).replace(/\.0+$/, "");
+}
+
+function buildTs(mapping) {
+  const lines = [];
+  lines.push(`export type InsetsPx = { top: number; right: number; bottom: number; left: number };`);
+  lines.push("");
+  lines.push("/**");
+  lines.push(" * AUTO-GENERATED.");
+  lines.push(" * Source: raw.json.iconMetrics (derived from get_design_context inset percentages)");
+  lines.push(" */");
+  lines.push("export const ICON_INSETS_PX: Record<string, InsetsPx> = {");
+  Object.keys(mapping)
+    .sort()
+    .forEach((key) => {
+      const v = mapping[key];
+      lines.push(
+        `  "${key}": { top: ${formatNumber(v.top)}, right: ${formatNumber(v.right)}, bottom: ${formatNumber(
+          v.bottom
+        )}, left: ${formatNumber(v.left)} },`
+      );
+    });
+  lines.push("};");
+  lines.push("");
+  return `${lines.join("\n")}\n`;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  if (!args.raw.length || (!args.out && !(args.outDir && args.cacheKey))) {
+    console.error(
+      "Usage: node scripts/generate-icon-insets.cjs --raw=<raw.json> [--raw=<raw2.json> ...] (--out=<out.ts> | --out-dir=<dir> --cacheKey=<cacheKey>) [--max-box=24]"
+    );
+    process.exit(2);
+  }
+  const computedOut = args.out
+    ? args.out
+    : path.join(
+        args.outDir,
+        `iconInsets.${String(args.cacheKey || "")
+          .replace(/[^a-zA-Z0-9._-]+/g, "_")
+          .slice(0, 120)}.generated.ts`
+      );
+  const outAbs = path.isAbsolute(computedOut) ? computedOut : path.join(process.cwd(), computedOut);
+
+  const mapping = {};
+  args.raw.forEach((rawPath) => {
+    const rawAbs = path.isAbsolute(rawPath) ? rawPath : path.join(process.cwd(), rawPath);
+    const data = readJson(rawAbs);
+    const list = Array.isArray(data && data.iconMetrics) ? data.iconMetrics : [];
+    list.forEach((item) => {
+      if (!item || typeof item !== "object") return;
+      const nodeId = String(item.nodeId || "").trim();
+      const boxPx = Number(item.boxPx);
+      const insetPx = item.insetPx;
+      if (!nodeId) return;
+      if (!Number.isFinite(boxPx) || boxPx <= 0 || boxPx > args.maxBox) return;
+      if (!insetPx || typeof insetPx !== "object") return;
+      // First write wins to keep stable precedence: primary cacheKey first, related next.
+      if (mapping[nodeId]) return;
+      mapping[nodeId] = {
+        top: Number(insetPx.top || 0),
+        right: Number(insetPx.right || 0),
+        bottom: Number(insetPx.bottom || 0),
+        left: Number(insetPx.left || 0),
+      };
+    });
+  });
+
+  fs.mkdirSync(path.dirname(outAbs), { recursive: true });
+  fs.writeFileSync(outAbs, buildTs(mapping), "utf8");
+  console.log(`[generate-icon-insets] wrote ${Object.keys(mapping).length} entries -> ${outAbs}`);
+}
+
+main();
+

package/scripts/import-mcp-raw-evidence.cjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Import MCP raw evidence files into figma-cache node directory and generate a manifest.
+ *
+ * This is the toolchain-friendly way to implement: "call MCP once -> cache evidence".
+ *
+ * Usage:
+ *   node scripts/import-mcp-raw-evidence.cjs \
+ *     --cacheKey=<fileKey#nodeId> \
+ *     --design-context=<path/to/get_design_context.txt> \
+ *     --metadata=<path/to/get_metadata.txt> \
+ *     --variable-defs=<path/to/get_variable_defs.json>
+ *
+ * Notes:
+ * - Writes to: figma-cache/files/<fileKey>/nodes/<safeNodeId>/mcp-raw/
+ * - Generates: mcp-raw-manifest.json with sha256 + byte sizes
+ */
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+function sha256Utf8(text) {
+  return crypto.createHash("sha256").update(String(text || ""), "utf8").digest("hex");
+}
+
+function sizeUtf8(text) {
+  return Buffer.byteLength(String(text || ""), "utf8");
+}
+
+function readUtf8(absPath) {
+  return fs.readFileSync(absPath, "utf8");
+}
+
+function resolveAbs(p) {
+  const v = String(p || "").trim();
+  if (!v) return "";
+  return path.isAbsolute(v) ? v : path.join(process.cwd(), v);
+}
+
+function normalizeNodeId(input) {
+  const value = String(input || "").trim();
+  if (!value) return "";
+  return value.includes(":") ? value : value.replace(/-/g, ":");
+}
+
+function parseArgs(argv) {
+  const out = {
+    cacheKey: "",
+    designContext: "",
+    metadata: "",
+    variableDefs: "",
+  };
+  argv.slice(2).forEach((arg) => {
+    if (arg.startsWith("--cacheKey=")) out.cacheKey = arg.split("=").slice(1).join("=").trim();
+    if (arg.startsWith("--design-context="))
+      out.designContext = arg.split("=").slice(1).join("=").trim();
+    if (arg.startsWith("--metadata=")) out.metadata = arg.split("=").slice(1).join("=").trim();
+    if (arg.startsWith("--variable-defs="))
+      out.variableDefs = arg.split("=").slice(1).join("=").trim();
+  });
+  return out;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  if (!args.cacheKey || !args.designContext || !args.metadata || !args.variableDefs) {
+    console.error(
+      "Usage: node scripts/import-mcp-raw-evidence.cjs --cacheKey=<fileKey#nodeId> --design-context=<txt> --metadata=<txt> --variable-defs=<json>"
+    );
+    process.exit(2);
+  }
+
+  const cacheKey = String(args.cacheKey).trim();
+  const [fileKey, nodeIdRaw] = cacheKey.split("#");
+  const nodeId = normalizeNodeId(nodeIdRaw);
+  if (!fileKey || !nodeId) {
+    console.error(`[import-mcp-raw-evidence] invalid cacheKey: ${cacheKey}`);
+    process.exit(2);
+  }
+
+  const safeNodeDir = nodeId.replace(/:/g, "-");
+  const mcpRawDir = path.join(
+    process.cwd(),
+    "figma-cache",
+    "files",
+    fileKey,
+    "nodes",
+    safeNodeDir,
+    "mcp-raw"
+  );
+  fs.mkdirSync(mcpRawDir, { recursive: true });
+
+  const srcDesign = resolveAbs(args.designContext);
+  const srcMeta = resolveAbs(args.metadata);
+  const srcVars = resolveAbs(args.variableDefs);
+  if (!fs.existsSync(srcDesign) || !fs.existsSync(srcMeta) || !fs.existsSync(srcVars)) {
+    console.error("[import-mcp-raw-evidence] missing input file(s)");
+    process.exit(2);
+  }
+
+  const files = {
+    get_design_context: "mcp-raw-get-design-context.txt",
+    get_metadata: "mcp-raw-get-metadata.txt",
+    get_variable_defs: "mcp-raw-get-variable-defs.json",
+  };
+
+  const contents = {
+    get_design_context: readUtf8(srcDesign),
+    get_metadata: readUtf8(srcMeta),
+    get_variable_defs: readUtf8(srcVars),
+  };
+
+  fs.writeFileSync(path.join(mcpRawDir, files.get_design_context), contents.get_design_context, "utf8");
+  fs.writeFileSync(path.join(mcpRawDir, files.get_metadata), contents.get_metadata, "utf8");
+  fs.writeFileSync(path.join(mcpRawDir, files.get_variable_defs), contents.get_variable_defs, "utf8");
+
+  const manifest = {
+    mcpServer: "plugin-figma-figma",
+    fileKey,
+    nodeId,
+    files,
+    fileHashes: Object.fromEntries(Object.entries(contents).map(([k, v]) => [k, sha256Utf8(v)])),
+    fileSizes: Object.fromEntries(Object.entries(contents).map(([k, v]) => [k, sizeUtf8(v)])),
+  };
+
+  fs.writeFileSync(
+    path.join(mcpRawDir, "mcp-raw-manifest.json"),
+    `${JSON.stringify(manifest, null, 2)}\n`,
+    "utf8"
+  );
+
+  console.log(
+    `[import-mcp-raw-evidence] ok -> ${path.join(mcpRawDir, "mcp-raw-manifest.json")}`
+  );
+}
+
+main();
+

package/scripts/merge-figma-geometry-metrics.cjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Merge figma-geometry-metrics.json into raw.json as layoutMetrics[].
+ *
+ * Geometry file shape:
+ * {
+ *   "version": 1,
+ *   "source": "figma_plugin_absoluteBoundingBox",
+ *   "metrics": [ { "id": "...", "kind": "spacer_between_nodes_y", "fromNodeId": "...", "toNodeId": "...", "spacerPx": 26, ... } ]
+ * }
+ *
+ * Usage:
+ *   node scripts/merge-figma-geometry-metrics.cjs --raw=<raw.json> --geometry=<figma-geometry-metrics.json>
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { mergeLayoutMetricsFromGeometry } = require("../figma-cache/js/raw-derivatives");
+
+function safeReadJson(absPath) {
+  try {
+    return JSON.parse(fs.readFileSync(absPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(absPath, value) {
+  fs.mkdirSync(path.dirname(absPath), { recursive: true });
+  fs.writeFileSync(absPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function parseArgs(argv) {
+  const out = { raw: "", geometry: "" };
+  argv.slice(2).forEach((arg) => {
+    if (arg.startsWith("--raw=")) out.raw = arg.split("=").slice(1).join("=").trim();
+    if (arg.startsWith("--geometry=")) out.geometry = arg.split("=").slice(1).join("=").trim();
+  });
+  return out;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const rawAbs = path.isAbsolute(args.raw) ? args.raw : path.join(process.cwd(), args.raw);
+  const geoAbs = path.isAbsolute(args.geometry) ? args.geometry : path.join(process.cwd(), args.geometry);
+  if (!args.raw || !args.geometry) {
+    console.error(
+      "Usage: node scripts/merge-figma-geometry-metrics.cjs --raw=<raw.json> --geometry=<figma-geometry-metrics.json>"
+    );
+    process.exit(2);
+  }
+  if (!fs.existsSync(rawAbs)) {
+    console.error(`[merge-figma-geometry-metrics] raw not found: ${rawAbs}`);
+    process.exit(2);
+  }
+  if (!fs.existsSync(geoAbs)) {
+    console.error(`[merge-figma-geometry-metrics] geometry not found: ${geoAbs}`);
+    process.exit(2);
+  }
+
+  const raw = safeReadJson(rawAbs);
+  const geo = safeReadJson(geoAbs);
+  if (!raw || typeof raw !== "object") {
+    console.error(`[merge-figma-geometry-metrics] invalid raw: ${rawAbs}`);
+    process.exit(2);
+  }
+  if (!geo || typeof geo !== "object" || !Array.isArray(geo.metrics)) {
+    console.error(`[merge-figma-geometry-metrics] invalid geometry (need .metrics[]): ${geoAbs}`);
+    process.exit(2);
+  }
+
+  mergeLayoutMetricsFromGeometry(raw, geo);
+  writeJson(rawAbs, raw);
+  console.log(
+    `[merge-figma-geometry-metrics] ok merged=${geo.metrics.length} -> ${rawAbs}`
+  );
+}
+
+main();

package/scripts/ui-1to1-audit.js

@@ -16,6 +16,23 @@ const DEFAULT_MIN_SCORE = 85;
 const DEFAULT_RECIPES_DIR = "figma-cache/adapters/recipes";
 const FAIL_EXIT_CODE = 2;
 
+function parseBoolEnv(value, fallback) {
+  if (value == null) return fallback;
+  const v = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(v)) return true;
+  if (["0", "false", "no", "off"].includes(v)) return false;
+  return fallback;
+}
+
+function filterRemoteFigmaAssetRefs(input) {
+  const text = String(input || "");
+  // Mask Figma MCP asset URLs (often require auth; non-deterministic in runtime).
+  // This keeps audits stable when teams choose to not ship remote figma assets.
+  return text
+    .replace(/https:\/\/www\.figma\.com\/api\/mcp\/asset\/[a-z0-9-]+/gi, "__FIGMA_MCP_ASSET__")
+    .replace(/\bimg[A-Za-z0-9_]*\s*=\s*['"]https:\/\/www\.figma\.com\/api\/mcp\/asset\/[a-z0-9-]+['"]/gi, "img__=__FIGMA_MCP_ASSET__");
+}
+
 function normalizeSlash(input) {
   return String(input || "").replace(/\\/g, "/");
 }
@@ -51,6 +68,7 @@ function parseArgs(argv) {
     reportPath: DEFAULT_REPORT_PATH,
     minScore: DEFAULT_MIN_SCORE,
     recipesDir: DEFAULT_RECIPES_DIR,
+    filterRemoteFigmaAssets: parseBoolEnv(process.env.FIGMA_UI_FILTER_REMOTE_FIGMA_ASSETS, true),
     unknownArgs: [],
   };
 
@@ -80,6 +98,10 @@ function parseArgs(argv) {
       options.recipesDir = arg.split("=").slice(1).join("=").trim() || DEFAULT_RECIPES_DIR;
       return;
     }
+    if (arg === "--no-filter-remote-figma-assets") {
+      options.filterRemoteFigmaAssets = false;
+      return;
+    }
     options.unknownArgs.push(arg);
   });
 
@@ -170,7 +192,7 @@ function detectMatchedRecipes(recipes, contextText, statesInCache) {
 }
 
 function scoreItem(params) {
-  const { cacheKey, item, contract, targetCode, recipes } = params;
+  const { cacheKey, item, contract, targetCode, recipes, options } = params;
   const blocking = [];
   const warnings = [];
   const diffs = [];
@@ -261,9 +283,13 @@ function scoreItem(params) {
   }
 
   const hasTodo = normalizedFacts.hasPlaceholder;
+  const effectiveTargetCode =
+    options && options.filterRemoteFigmaAssets
+      ? filterRemoteFigmaAssetRefs(targetCode)
+      : String(targetCode || "");
   const matchedRecipes = detectMatchedRecipes(
     recipes,
-    `${specText}\n${stateMapText}\n${JSON.stringify(rawJson || {})}\n${targetCode}`,
+    `${specText}\n${stateMapText}\n${JSON.stringify(rawJson || {})}\n${effectiveTargetCode}`,
     statesInCache
   );
   if (!matchedRecipes.length) {
@@ -283,11 +309,11 @@ function scoreItem(params) {
     : textFacts.length;
   const tokenCodeHits = hasTargetCode
     ? tokenFacts.filter((fact) =>
-        targetCode.toUpperCase().includes(String(normalizeHexColor(fact.value || "")).toUpperCase())
+        effectiveTargetCode.toUpperCase().includes(String(normalizeHexColor(fact.value || "")).toUpperCase())
       ).length
     : tokenFacts.length;
   const stateCodeHits = hasTargetCode
-    ? statesInCache.filter((state) => targetCode.toLowerCase().includes(state)).length
+    ? statesInCache.filter((state) => effectiveTargetCode.toLowerCase().includes(state)).length
     : statesInCache.length;
 
   const layoutScore = entryReady ? 100 : 20;
@@ -361,6 +387,7 @@ function run() {
       contract,
       targetCode,
       recipes,
+      options,
     })
   );
 
@@ -409,6 +436,7 @@ function run() {
       contractPath: normalizeSlash(contractPath),
       reportPath: normalizeSlash(reportPath),
       recipesDir: normalizeSlash(recipesDir),
+      filterRemoteFigmaAssets: options.filterRemoteFigmaAssets,
     },
     blocking,
     warnings,