@liiift-studio/sanity-font-manager 2.5.0 → 2.5.1

package/dist/{chunk-646WCBRR.mjs → chunk-TMDE4A54.mjs}

@@ -3460,8 +3460,8 @@ var require_unbrotli = __commonJS({
 });
 
 // src/components/UploadModal.jsx
-import React9, { useReducer as useReducer2, useCallback as useCallback5, useState as useState6, useMemo as useMemo6, useRef as useRef3, useEffect as useEffect4 } from "react";
-import { Dialog, Box as Box8, Flex as Flex9, Text as Text9, Badge as Badge7, Button as Button7 } from "@sanity/ui";
+import React10, { useReducer as useReducer2, useCallback as useCallback6, useState as useState7, useMemo as useMemo7, useRef as useRef3, useEffect as useEffect5 } from "react";
+import { Dialog, Box as Box9, Flex as Flex10, Text as Text10, Badge as Badge8, Button as Button8 } from "@sanity/ui";
 
 // src/utils/planTypes.js
 var FONT_STATUS = {
@@ -4488,14 +4488,14 @@ var extractFontMetadata = (font, title, weightKeywordList, italicKeywordList, pr
     weightName = expandAbbreviations(weightName);
   }
   const fullName = getNameString(font, 4) || (ttfFallbackMeta == null ? void 0 : ttfFallbackMeta.fullName) || "";
-  if ((weightName === "" || weightName.toLowerCase() === "roman") && fullName) {
+  const axes = getVariationAxes(font);
+  const variableFont = axes !== null;
+  if (!variableFont && (weightName === "" || weightName.toLowerCase() === "roman") && fullName) {
     weightName = extractWeightFromFullName(font, title, ttfFallbackMeta);
     if (!preserveShortenedNames) {
       weightName = expandAbbreviations(weightName);
     }
   }
-  const axes = getVariationAxes(font);
-  const variableFont = axes !== null;
   const trimmedTitle = title.trim();
   const nameId4Remainder = fullName ? fullName.replace(trimmedTitle, "").trim() : "";
   const nameId1 = getNameString(font, 1) || (ttfFallbackMeta == null ? void 0 : ttfFallbackMeta.familyName) || "";
@@ -4779,6 +4779,7 @@ async function buildUploadPlan({
   onProgress
 }) {
   const plan = createEmptyPlan(settings);
+  plan.settings.typefaceTitle = typefaceTitle;
   plan.phase = PLAN_PHASE.PROCESSING;
   plan.processingProgress.total = files.length;
   for (let i = 0; i < files.length; i++) {
@@ -5302,10 +5303,11 @@ function ExistingDocumentResolver({ decision, tempId, dispatch }) {
 // src/components/FontReviewCard.jsx
 var STANDARD_TYPES = ["ttf", "otf", "woff", "woff2"];
 var EXTENDED_TYPES = ["eot", "svg", "css", "woff2_subset", "woff2_web"];
-var FontReviewCard = memo(function FontReviewCard2({ entry, dispatch, allExpanded }) {
+var FontReviewCard = memo(function FontReviewCard2({ entry, dispatch, allExpanded, typefaceTitle, price }) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
   const [expanded, setExpanded] = useState2(false);
   const [showAllFileTypes, setShowAllFileTypes] = useState2(false);
+  const [showDocPreview, setShowDocPreview] = useState2(false);
   useEffect(() => {
     setExpanded(allExpanded);
   }, [allExpanded]);
@@ -5513,7 +5515,32 @@ var FontReviewCard = memo(function FontReviewCard2({ entry, dispatch, allExpande
       tempId: entry.tempId,
       dispatch
     }
-  ), /* @__PURE__ */ React3.createElement(Flex3, { justify: "flex-end", gap: 2 }, hasUserOverrides && /* @__PURE__ */ React3.createElement(
+  ), /* @__PURE__ */ React3.createElement(Stack3, { space: 2 }, /* @__PURE__ */ React3.createElement(
+    Button3,
+    {
+      mode: "bleed",
+      fontSize: 0,
+      padding: 1,
+      text: showDocPreview ? "Hide document preview" : "Show document preview",
+      onClick: () => setShowDocPreview((v) => !v),
+      style: { cursor: "pointer", alignSelf: "flex-start" }
+    }
+  ), showDocPreview && /* @__PURE__ */ React3.createElement(Card3, { border: true, padding: 3, radius: 1, style: { fontFamily: "monospace", fontSize: 12 } }, /* @__PURE__ */ React3.createElement(Stack3, { space: 2 }, [
+    ["_id", entry.documentId],
+    ["_type", "font"],
+    ["title", entry.title],
+    ["slug", entry.documentId],
+    ["typefaceName", typefaceTitle || "\u2014"],
+    ["weightName", entry.weightName || "\u2014"],
+    ["weight", entry.weight],
+    ["style", entry.style],
+    ["subfamily", entry.subfamily || "\u2014"],
+    ["variableFont", String(entry.variableFont)],
+    ["price", price ?? "\u2014"],
+    ["sell", price > 0 ? "true" : "false"],
+    ["normalWeight", "true"],
+    ["files", (entry.files || []).map((f) => f.name).join(", ") || "\u2014"]
+  ].map(([key, value]) => /* @__PURE__ */ React3.createElement(Flex3, { key, gap: 2 }, /* @__PURE__ */ React3.createElement(Text3, { size: 0, muted: true, style: { width: 120, flexShrink: 0 } }, key), /* @__PURE__ */ React3.createElement(Text3, { size: 0, style: { wordBreak: "break-all" } }, String(value))))))), /* @__PURE__ */ React3.createElement(Flex3, { justify: "flex-end", gap: 2 }, hasUserOverrides && /* @__PURE__ */ React3.createElement(
     Button3,
     {
       mode: "ghost",
@@ -5922,15 +5949,20 @@ function UploadStep2Review({
       " ",
       sortBy === col.key ? sortDir === "asc" ? "\u2191" : "\u2193" : ""
     ))
-  ), Object.entries(groupedEntries).map(([subfamily, entries]) => /* @__PURE__ */ React6.createElement(Stack4, { key: subfamily, space: 1 }, /* @__PURE__ */ React6.createElement(Card4, { padding: 2, radius: 1, style: { background: "var(--card-muted-bg-color)" } }, /* @__PURE__ */ React6.createElement(Flex6, { align: "center", gap: 2 }, /* @__PURE__ */ React6.createElement(Text6, { size: 1, weight: "semibold" }, subfamily), /* @__PURE__ */ React6.createElement(Badge4, { mode: "outline", fontSize: 0 }, entries.length))), /* @__PURE__ */ React6.createElement(Stack4, { space: 0 }, entries.map((entry) => /* @__PURE__ */ React6.createElement(
-    FontReviewCard_default,
-    {
-      key: entry.tempId,
-      entry,
-      dispatch,
-      allExpanded
-    }
-  ))))), visibleEntries.length === 0 && fontEntries.length > 0 && /* @__PURE__ */ React6.createElement(Card4, { border: true, padding: 4, radius: 2 }, /* @__PURE__ */ React6.createElement(Text6, { size: 1, muted: true, align: "center" }, "No fonts match the current filter")), isReviewing && validationErrors.length > 0 && /* @__PURE__ */ React6.createElement(Card4, { tone: "caution", border: true, padding: 2, radius: 2 }, /* @__PURE__ */ React6.createElement(Stack4, { space: 1 }, validationErrors.map((err, i) => /* @__PURE__ */ React6.createElement(Text6, { key: i, size: 0, tone: "caution" }, "\u2022 ", err)))), isReviewing && processedCount > 0 && /* @__PURE__ */ React6.createElement(Flex6, { justify: "flex-end", gap: 2, style: { position: "sticky", bottom: 0, background: "var(--card-bg-color)", paddingTop: 8, paddingBottom: 4 } }, /* @__PURE__ */ React6.createElement(
+  ), Object.entries(groupedEntries).map(([subfamily, entries]) => /* @__PURE__ */ React6.createElement(Stack4, { key: subfamily, space: 1 }, /* @__PURE__ */ React6.createElement(Card4, { padding: 2, radius: 1, style: { background: "var(--card-muted-bg-color)" } }, /* @__PURE__ */ React6.createElement(Flex6, { align: "center", gap: 2 }, /* @__PURE__ */ React6.createElement(Text6, { size: 1, weight: "semibold" }, subfamily), /* @__PURE__ */ React6.createElement(Badge4, { mode: "outline", fontSize: 0 }, entries.length))), /* @__PURE__ */ React6.createElement(Stack4, { space: 0 }, entries.map((entry) => {
+    var _a2, _b2;
+    return /* @__PURE__ */ React6.createElement(
+      FontReviewCard_default,
+      {
+        key: entry.tempId,
+        entry,
+        dispatch,
+        allExpanded,
+        typefaceTitle: (_a2 = plan.settings) == null ? void 0 : _a2.typefaceTitle,
+        price: (_b2 = plan.settings) == null ? void 0 : _b2.price
+      }
+    );
+  })))), visibleEntries.length === 0 && fontEntries.length > 0 && /* @__PURE__ */ React6.createElement(Card4, { border: true, padding: 4, radius: 2 }, /* @__PURE__ */ React6.createElement(Text6, { size: 1, muted: true, align: "center" }, "No fonts match the current filter")), isReviewing && validationErrors.length > 0 && /* @__PURE__ */ React6.createElement(Card4, { tone: "caution", border: true, padding: 2, radius: 2 }, /* @__PURE__ */ React6.createElement(Stack4, { space: 1 }, validationErrors.map((err, i) => /* @__PURE__ */ React6.createElement(Text6, { key: i, size: 0, tone: "caution" }, "\u2022 ", err)))), isReviewing && processedCount > 0 && /* @__PURE__ */ React6.createElement(Flex6, { justify: "flex-end", gap: 2, style: { position: "sticky", bottom: 0, background: "var(--card-bg-color)", paddingTop: 8, paddingBottom: 4 } }, /* @__PURE__ */ React6.createElement(
     Button5,
     {
       mode: "default",
@@ -6168,6 +6200,169 @@ async function generateFontData({ fileInput, url, fontKit, fontId, client, commi
 
 // src/utils/parseVariableFontInstances.js
 import { nanoid as nanoid3 } from "nanoid";
+var WIDTH_PREFIXES = [
+  "XXXWide",
+  "XXWide",
+  "XWide",
+  "Wide",
+  "XXXNarrow",
+  "XXNarrow",
+  "XNarrow",
+  "Narrow"
+];
+function parseInstanceName(instanceName) {
+  let subfamily = "";
+  let remaining = instanceName.trim();
+  for (const prefix of WIDTH_PREFIXES) {
+    if (remaining.toLowerCase().startsWith(prefix.toLowerCase() + " ") || remaining.toLowerCase() === prefix.toLowerCase()) {
+      subfamily = prefix;
+      remaining = remaining.substring(prefix.length).trim();
+      break;
+    }
+  }
+  let style = "";
+  for (const suffix of ["Backslant", "Slant", "Italic", "Oblique"]) {
+    if (remaining.toLowerCase().endsWith(" " + suffix.toLowerCase()) || remaining.toLowerCase() === suffix.toLowerCase()) {
+      style = suffix;
+      remaining = remaining.substring(0, remaining.length - suffix.length).trim();
+      break;
+    }
+  }
+  return { subfamily, weight: remaining || "Regular", style };
+}
+function filterBySubfamily(staticFonts, instanceSubfamily, typefaceName) {
+  if (!instanceSubfamily) {
+    return staticFonts.filter((sf) => {
+      const sub = (sf.subfamily || "").toLowerCase();
+      if (sub === "" || sub === "regular") return true;
+      const afterTypeface = (sf.title || "").replace(typefaceName, "").trim();
+      return !WIDTH_PREFIXES.some((p) => afterTypeface.toLowerCase().startsWith(p.toLowerCase()));
+    });
+  }
+  const lowerSf = instanceSubfamily.toLowerCase();
+  const expanded = (expandAbbreviations(instanceSubfamily) || "").toLowerCase();
+  return staticFonts.filter((sf) => {
+    const sub = (sf.subfamily || "").toLowerCase();
+    if (sub === lowerSf || expanded && sub === expanded) return true;
+    const afterTypeface = (sf.title || "").replace(typefaceName, "").trim().toLowerCase();
+    if (afterTypeface.startsWith(lowerSf)) return true;
+    if (expanded && afterTypeface.startsWith(expanded)) return true;
+    return false;
+  });
+}
+var WEIGHT_MAP = [
+  { term: "ultra", weight: 950 },
+  { term: "xxlight", weight: 200 },
+  { term: "xlight", weight: 250 },
+  { term: "extralight", weight: 200 },
+  { term: "extra light", weight: 200 },
+  { term: "thin", weight: 100 },
+  { term: "hairline", weight: 100 },
+  { term: "light", weight: 300 },
+  { term: "regular", weight: 400 },
+  { term: "normal", weight: 400 },
+  { term: "medium", weight: 500 },
+  { term: "semibold", weight: 600 },
+  { term: "semi bold", weight: 600 },
+  { term: "extrabold", weight: 800 },
+  { term: "extra bold", weight: 800 },
+  { term: "xbold", weight: 800 },
+  { term: "bold", weight: 700 },
+  { term: "black", weight: 900 },
+  { term: "heavy", weight: 900 }
+];
+function weightFromName(name) {
+  const lower = name.toLowerCase();
+  for (const { term, weight } of WEIGHT_MAP) {
+    if (lower === term || lower.includes(term)) return weight;
+  }
+  return 400;
+}
+var STRATEGIES = [
+  // Pass 1: Exact title match (with typeface prefix)
+  {
+    name: "exact-title",
+    match: (instanceName, parsed, candidates, typefaceName) => {
+      const withPrefix = `${typefaceName} ${instanceName}`;
+      return candidates.find((sf) => sf.title === instanceName || sf.title === withPrefix) || null;
+    }
+  },
+  // Pass 2: Title normalisation — strip typeface name and compare remainder
+  {
+    name: "title-normalised",
+    match: (instanceName, parsed, candidates, typefaceName) => {
+      return candidates.find((sf) => {
+        const sfName = (sf.title || "").replace(typefaceName, "").trim();
+        if (sfName.toLowerCase() === instanceName.toLowerCase()) return true;
+        if (parsed.weight === "Regular" && !parsed.style) {
+          if (sfName.toLowerCase() === parsed.subfamily.toLowerCase()) return true;
+        }
+        return false;
+      }) || null;
+    }
+  },
+  // Pass 3: Abbreviation expansion (XLight → ExtraLight, XBold → ExtraBold)
+  {
+    name: "abbreviation",
+    match: (instanceName, parsed, candidates, typefaceName) => {
+      const expandedFull = instanceName.split(" ").map((w) => expandAbbreviations(w) || w).join(" ");
+      let found = candidates.find((sf) => {
+        const sfName = (sf.title || "").replace(typefaceName, "").trim();
+        return sfName.toLowerCase() === expandedFull.toLowerCase();
+      });
+      if (found) return found;
+      const expandedWeight = expandAbbreviations(parsed.weight) || parsed.weight;
+      const target = [parsed.subfamily, expandedWeight, parsed.style].filter(Boolean).join(" ");
+      return candidates.find((sf) => {
+        const sfName = (sf.title || "").replace(typefaceName, "").trim();
+        return sfName.toLowerCase() === target.toLowerCase();
+      }) || null;
+    }
+  },
+  // Pass 4: fullName metadata comparison
+  {
+    name: "metadata-fullName",
+    match: (instanceName, parsed, candidates, typefaceName) => {
+      return candidates.find((sf) => {
+        var _a;
+        if (!((_a = sf.metaData) == null ? void 0 : _a.fullName)) return false;
+        const typefacePattern = new RegExp(`^${typefaceName}\\s+`, "i");
+        const stylePart = sf.metaData.fullName.replace(typefacePattern, "").trim();
+        return instanceName.toLowerCase() === stylePart.toLowerCase();
+      }) || null;
+    }
+  },
+  // Pass 5: Weight + style matching (numeric, within subfamily)
+  {
+    name: "weight-style",
+    match: (instanceName, parsed, candidates) => {
+      const instanceWeight = weightFromName(parsed.weight);
+      const isBackslant = parsed.style.toLowerCase() === "backslant";
+      const isSlant = parsed.style.toLowerCase() === "slant";
+      const isItalic = parsed.style.toLowerCase() === "italic";
+      return candidates.find((sf) => {
+        var _a, _b;
+        if (Number(sf.weight) !== instanceWeight) return false;
+        if (isBackslant) return sf.style === "Italic" && ((_a = sf.title) == null ? void 0 : _a.toLowerCase().includes("backslant"));
+        if (isSlant) return sf.style === "Italic" && !((_b = sf.title) == null ? void 0 : _b.toLowerCase().includes("backslant"));
+        if (isItalic) return sf.style === "Italic";
+        return sf.style === "Regular";
+      }) || null;
+    }
+  },
+  // Pass 6: weightName string comparison
+  {
+    name: "weightName",
+    match: (instanceName, parsed, candidates) => {
+      const cleanInstance = parsed.weight.toLowerCase().trim();
+      return candidates.find((sf) => {
+        if (!sf.weightName) return false;
+        const cleanWeight = sf.weightName.toLowerCase().replace(/italic|slant|backslant/gi, "").trim();
+        return cleanInstance === cleanWeight;
+      }) || null;
+    }
+  }
+];
 var parseVariableFontInstances = async (font, client) => {
   if (!font.variableFont || !font.variableInstances) return [];
   let variableInstances;
@@ -6182,14 +6377,7 @@ var parseVariableFontInstances = async (font, client) => {
   const typeface = await client.fetch(
     `*[_type == 'typeface' && title == $typefaceName][0]{
 			'fonts': styles.fonts[]-> {
-				_id,
-				title,
-				subfamily,
-				style,
-				weight,
-				weightName,
-				metaData,
-				variableFont
+				_id, title, subfamily, style, weight, weightName, metaData, variableFont
 			}
 		}`,
     { typefaceName: font.typefaceName }
@@ -6201,127 +6389,49 @@ var parseVariableFontInstances = async (font, client) => {
     console.warn("Typeface not found or no fonts in curated list, falling back to all fonts query");
     staticFonts = await client.fetch(
       `*[_type == 'font' && typefaceName == $typefaceName && variableFont != true]{
-				_id,
-				title,
-				subfamily,
-				style,
-				weight,
-				weightName,
-				metaData
+				_id, title, subfamily, style, weight, weightName, metaData
 			}`,
       { typefaceName: font.typefaceName }
     );
   }
-  console.log("Variable font instances:", Object.keys(variableInstances));
-  console.log("Available static fonts:", staticFonts.map((sf) => sf.title));
-  const instanceMappings = [];
-  Object.keys(variableInstances).forEach((instanceName) => {
-    let matchingFont = null;
-    matchingFont = staticFonts.find((sf) => sf.title === instanceName);
-    if (!matchingFont && staticFonts.some((sf) => {
-      var _a;
-      return (_a = sf.metaData) == null ? void 0 : _a.fullName;
-    })) {
-      matchingFont = staticFonts.find((sf) => {
-        var _a, _b, _c, _d;
-        if (!((_a = sf.metaData) == null ? void 0 : _a.fullName)) return false;
-        let fullName = sf.metaData.fullName;
-        const WORDS_TO_REMOVE = ["VF", "var", "variable", "VAR", "vf"];
-        const variableName = (_c = (_b = font.metaData) == null ? void 0 : _b.familyName) == null ? void 0 : _c.replace(new RegExp(`\\b(${WORDS_TO_REMOVE.join("|")})\\b`, "gi"), "").replace(/\s{2,}/g, " ").trim();
-        if (variableName && fullName.startsWith(variableName)) {
-          fullName = fullName.substring(variableName.length).trim();
-        }
-        if (variableName) {
-          const words = variableName.split(/\s+/).map((w) => w.trim()).filter(Boolean);
-          if (words.length > 0) {
-            const regex = new RegExp(`\\b(${words.join("|")})\\b`, "gi");
-            const stripped = fullName.replace(regex, "").replace(/\s{2,}/g, " ").trim();
-            if (stripped !== "") fullName = stripped;
-          }
-        }
-        if (fullName.startsWith(font.typefaceName)) {
-          fullName = fullName.substring(font.typefaceName.length).trim();
-        }
-        if (((_d = sf.style) == null ? void 0 : _d.toLowerCase()) === "italic" && !fullName.toLowerCase().endsWith("italic") && !fullName.toLowerCase().endsWith("slanted")) {
-          fullName = fullName + " Italic";
-        }
-        if (fullName.trim().toLowerCase().endsWith("regular")) {
-          if (instanceName.trim().toLowerCase() + " regular" === fullName.trim().toLowerCase()) return true;
-        }
-        if (fullName.trim().toLowerCase().startsWith("regular")) {
-          if ("regular " + instanceName.trim().toLowerCase() === fullName.trim().toLowerCase()) return true;
-        }
-        if (fullName.trim().toLowerCase().endsWith("italic")) {
-          if (instanceName.trim().toLowerCase().endsWith("italic")) {
-            const k = instanceName.trim().toLowerCase().slice(0, -6).trim() + " regular italic";
-            if (k === fullName.trim().toLowerCase()) return true;
-          }
-        }
-        return fullName.trim().toLowerCase() === instanceName.trim().toLowerCase();
-      });
-    }
-    if (!matchingFont) {
-      const expandedName = instanceName.split(" ").map((word) => expandAbbreviations(word)).join(" ");
-      matchingFont = staticFonts.find((sf) => {
-        const nameWithoutTypeface = sf.title.replace(font.typefaceName, "").trim();
-        return nameWithoutTypeface === expandedName;
-      });
-    }
-    if (!matchingFont) {
-      const isItalic = instanceName.toLowerCase().includes("italic");
-      const weightTerms = [
-        { term: "thin", weight: "100" },
-        { term: "extralight", weight: "200" },
-        { term: "extra light", weight: "200" },
-        { term: "light", weight: "300" },
-        { term: "regular", weight: "400" },
-        { term: "normal", weight: "400" },
-        { term: "medium", weight: "500" },
-        { term: "semibold", weight: "600" },
-        { term: "semi bold", weight: "600" },
-        { term: "bold", weight: "700" },
-        { term: "extrabold", weight: "800" },
-        { term: "extra bold", weight: "800" },
-        { term: "black", weight: "900" },
-        { term: "heavy", weight: "900" }
-      ];
-      let instanceWeight = "400";
-      for (const { term, weight } of weightTerms) {
-        if (instanceName.toLowerCase().includes(term)) {
-          instanceWeight = weight;
-          break;
-        }
+  const instanceNames = Object.keys(variableInstances);
+  console.log("Variable font instances:", instanceNames.length);
+  console.log("Available static fonts:", staticFonts.length);
+  const parsedInstances = instanceNames.map((name) => ({
+    name,
+    parsed: parseInstanceName(name)
+  }));
+  const results = /* @__PURE__ */ new Map();
+  const claimedFontIds = /* @__PURE__ */ new Set();
+  for (const strategy of STRATEGIES) {
+    const unmatched = parsedInstances.filter((inst) => !results.has(inst.name));
+    if (unmatched.length === 0) break;
+    const passMatches = [];
+    for (const inst of unmatched) {
+      const subfamilyCandidates = filterBySubfamily(staticFonts, inst.parsed.subfamily, font.typefaceName).filter((sf) => !claimedFontIds.has(sf._id));
+      const match = strategy.match(inst.name, inst.parsed, subfamilyCandidates, font.typefaceName, font);
+      if (match) {
+        passMatches.push({ instanceName: inst.name, font: match, strategy: strategy.name });
       }
-      matchingFont = staticFonts.find(
-        (sf) => sf.weight === instanceWeight && (isItalic && sf.style === "Italic" || !isItalic && sf.style === "Regular")
-      );
-    }
-    if (!matchingFont) {
-      matchingFont = staticFonts.find((sf) => {
-        if (!sf.weightName) return false;
-        const cleanInstance = instanceName.toLowerCase().replace(/italic/i, "").trim();
-        const cleanWeight = sf.weightName.toLowerCase().replace(/italic/i, "").trim();
-        return cleanInstance === cleanWeight;
-      });
     }
-    if (!matchingFont && staticFonts.some((sf) => {
-      var _a;
-      return (_a = sf.metaData) == null ? void 0 : _a.fullName;
-    })) {
-      matchingFont = staticFonts.find((sf) => {
-        var _a;
-        if (!((_a = sf.metaData) == null ? void 0 : _a.fullName)) return false;
-        const typefacePattern = new RegExp(`^${font.typefaceName}\\s+`, "i");
-        const stylePart = sf.metaData.fullName.replace(typefacePattern, "").trim();
-        return instanceName.toLowerCase() === stylePart.toLowerCase();
-      });
+    for (const m of passMatches) {
+      if (!claimedFontIds.has(m.font._id) && !results.has(m.instanceName)) {
+        results.set(m.instanceName, { fontId: m.font._id, strategy: m.strategy });
+        claimedFontIds.add(m.font._id);
+      }
     }
-    console.log(`Instance "${instanceName}" matched with:`, matchingFont ? matchingFont.title : "No match found");
-    instanceMappings.push({
+  }
+  const matched = [...results.values()].length;
+  console.log(`[parseVariableFontInstances] Matched ${matched}/${instanceNames.length} instances across ${STRATEGIES.length} passes`);
+  const instanceMappings = instanceNames.map((instanceName) => {
+    const result = results.get(instanceName);
+    const matchedFont = result ? staticFonts.find((sf) => sf._id === result.fontId) : null;
+    console.log(`Instance "${instanceName}" \u2192 ${matchedFont ? `${matchedFont.title} (${result.strategy})` : "No match"}`);
+    return {
       key: instanceName,
-      value: matchingFont ? { _type: "reference", _ref: matchingFont._id, _weak: true } : null,
+      value: matchedFont ? { _type: "reference", _ref: matchedFont._id, _weak: true } : null,
       _key: nanoid3()
-    });
+    };
   });
   return instanceMappings;
 };
@@ -6332,9 +6442,20 @@ import { nanoid as nanoid4 } from "nanoid";
 var updateTypefaceDocument = async (doc_id, fontRefs, variableRefs, subfamilies, uniqueSubfamilies, subfamiliesArray, preferredStyleRef, newPreferredStyle, stylesObject, client, setStatus, setError) => {
   console.log("Updating typeface document with new fonts:", { fontRefs, variableRefs, subfamilies, uniqueSubfamilies });
   setStatus("Updating typeface references...");
+  const dedupeRefs = (existing, incoming) => {
+    const merged = [...existing || []];
+    const existingRefs = new Set(merged.map((r) => r._ref).filter(Boolean));
+    incoming.forEach((ref) => {
+      if (ref._ref && !existingRefs.has(ref._ref)) {
+        merged.push(ref);
+        existingRefs.add(ref._ref);
+      }
+    });
+    return merged;
+  };
   let patch = {
-    "styles.fonts": stylesObject.fonts ? [...stylesObject.fonts, ...fontRefs] : [...fontRefs],
-    "styles.variableFont": (stylesObject == null ? void 0 : stylesObject.variableFont) ? [...stylesObject.variableFont, ...variableRefs] : [...variableRefs]
+    "styles.fonts": dedupeRefs(stylesObject.fonts, fontRefs),
+    "styles.variableFont": dedupeRefs(stylesObject == null ? void 0 : stylesObject.variableFont, variableRefs)
   };
   setStatus("Organising font subfamilies...");
   subfamiliesArray = subfamiliesArray || [];
@@ -6539,7 +6660,7 @@ async function executeUploadPlan({
   return result;
 }
 async function executeSingleFont({ entry, plan, client, progress, onProgress }) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  var _a, _b, _c, _d;
   const fontProgress = progress[entry.tempId];
   fontProgress.status = EXECUTION_STATUS.UPLOADING_ASSETS;
   if (onProgress) {
@@ -6656,7 +6777,7 @@ async function executeSingleFont({ entry, plan, client, progress, onProgress })
     _key: nanoid5(),
     title: entry.title,
     slug: { _type: "slug", current: fontDocId },
-    typefaceName: ((_g = (_f = (_e = plan.fonts[entry.tempId]) == null ? void 0 : _e.decisions) == null ? void 0 : _f.title) == null ? void 0 : _g.original) ? entry.title.split(" ").slice(0, -1).join(" ") || entry.title : entry.title,
+    typefaceName: plan.settings.typefaceTitle || entry.title,
     style: entry.style,
     variableFont: entry.variableFont,
     weightName: entry.weightName,
@@ -6667,7 +6788,6 @@ async function executeSingleFont({ entry, plan, client, progress, onProgress })
     normalWeight: true,
     fileInput
   };
-  fontDoc.typefaceName = ((_j = (_i = (_h = Object.values(plan.fonts)[0]) == null ? void 0 : _h.decisions) == null ? void 0 : _i.title) == null ? void 0 : _j.original) ? plan.settings.typefaceTitle || fontDoc.typefaceName : fontDoc.typefaceName;
   if (entry.metaData) fontDoc.metaData = entry.metaData;
   if (entry.metrics) fontDoc.metrics = entry.metrics;
   if (entry.variableAxes) fontDoc.variableAxes = entry.variableAxes;
@@ -6900,10 +7020,295 @@ function UploadStep3Execute({
   }))), execState.error && /* @__PURE__ */ React7.createElement(Card5, { tone: "critical", border: true, padding: 3, radius: 2 }, /* @__PURE__ */ React7.createElement(Text7, { size: 1 }, execState.error)));
 }
 
+// src/components/UploadStep3bInstances.jsx
+import React8, { useState as useState5, useEffect as useEffect4, useCallback as useCallback4, useMemo as useMemo6 } from "react";
+import { Box as Box7, Stack as Stack6, Flex as Flex8, Text as Text8, Card as Card6, Badge as Badge6, Button as Button6, Spinner as Spinner3, Autocomplete } from "@sanity/ui";
+import { CheckmarkCircleIcon as CheckmarkCircleIcon2, CloseCircleIcon, SearchIcon as SearchIcon2 } from "@sanity/icons";
+import { nanoid as nanoid6 } from "nanoid";
+function UploadStep3bInstances({
+  plan,
+  executionResult,
+  client,
+  typefaceTitle,
+  onComplete
+}) {
+  const [loading, setLoading] = useState5(true);
+  const [saving, setSaving] = useState5(false);
+  const [vfMappings, setVfMappings] = useState5({});
+  const [allStaticFonts, setAllStaticFonts] = useState5([]);
+  const [filterUnmatched, setFilterUnmatched] = useState5(false);
+  const vfEntries = useMemo6(
+    () => Object.values(plan.fonts).filter((f) => f.variableFont && f.status !== "error"),
+    [plan.fonts]
+  );
+  const runMatching = useCallback4(async () => {
+    var _a;
+    setLoading(true);
+    const mappings = {};
+    let staticFonts = [];
+    try {
+      const typeface = await client.fetch(
+        `*[_type == 'typeface' && title == $typefaceTitle][0]{
+					'fonts': styles.fonts[]-> {
+						_id, title, subfamily, style, weight, weightName, metaData, variableFont
+					}
+				}`,
+        { typefaceTitle }
+      );
+      if (((_a = typeface == null ? void 0 : typeface.fonts) == null ? void 0 : _a.length) > 0) {
+        staticFonts = typeface.fonts.filter((f) => !f.variableFont);
+      }
+      if (staticFonts.length === 0) {
+        staticFonts = await client.fetch(
+          `*[_type == 'font' && typefaceName == $typefaceTitle && variableFont != true]{
+						_id, title, subfamily, style, weight, weightName, metaData
+					}`,
+          { typefaceTitle }
+        );
+      }
+    } catch (err) {
+      console.error("[InstanceMapper] Failed to fetch static fonts:", err);
+    }
+    const deduped = /* @__PURE__ */ new Map();
+    staticFonts.forEach((f) => {
+      if (f._id && !deduped.has(f._id)) deduped.set(f._id, f);
+    });
+    staticFonts = [...deduped.values()];
+    console.log(`[InstanceMapper] Found ${staticFonts.length} static fonts for "${typefaceTitle}"`);
+    setAllStaticFonts(staticFonts);
+    for (const vf of vfEntries) {
+      try {
+        const vfDoc = await client.fetch(
+          `*[_id == $id][0]{
+						_id, title, typefaceName, variableFont, variableInstances, metaData
+					}`,
+          { id: vf.documentId }
+        );
+        if (!vfDoc) {
+          console.warn(`[InstanceMapper] VF document not found: ${vf.documentId}`);
+          mappings[vf.tempId] = [];
+          continue;
+        }
+        console.log(`[InstanceMapper] Running matcher for VF: ${vfDoc.title}, variableInstances: ${vfDoc.variableInstances ? "present" : "missing"}`);
+        const instanceMappings = await parseVariableFontInstances(vfDoc, client);
+        console.log(`[InstanceMapper] Matched ${instanceMappings.filter((m) => m.value).length}/${instanceMappings.length} instances for ${vfDoc.title}`);
+        mappings[vf.tempId] = instanceMappings.map((m) => {
+          var _a2;
+          return {
+            instanceName: m.key,
+            matchedFontId: ((_a2 = m.value) == null ? void 0 : _a2._ref) || "",
+            matchedFontTitle: "",
+            _key: m._key || nanoid6()
+          };
+        });
+      } catch (err) {
+        console.error(`[InstanceMapper] Error matching VF ${vf.documentId}:`, err);
+        mappings[vf.tempId] = [];
+      }
+    }
+    const allMatchedIds = /* @__PURE__ */ new Set();
+    Object.values(mappings).forEach((m) => m.forEach((i) => {
+      if (i.matchedFontId) allMatchedIds.add(i.matchedFontId);
+    }));
+    if (allMatchedIds.size > 0) {
+      try {
+        const titles = await client.fetch(`*[_id in $ids]{ _id, title }`, { ids: [...allMatchedIds] });
+        const titleMap = {};
+        titles.forEach((t) => {
+          titleMap[t._id] = t.title;
+        });
+        Object.values(mappings).forEach((m) => {
+          m.forEach((i) => {
+            if (i.matchedFontId) i.matchedFontTitle = titleMap[i.matchedFontId] || i.matchedFontId;
+          });
+        });
+      } catch (err) {
+        console.warn("[InstanceMapper] Failed to resolve font titles:", err);
+      }
+    }
+    setVfMappings(mappings);
+    setLoading(false);
+  }, [vfEntries, client, typefaceTitle]);
+  useEffect4(() => {
+    runMatching();
+  }, [runMatching]);
+  const claimedFontIds = useMemo6(() => {
+    const claimed = /* @__PURE__ */ new Set();
+    Object.values(vfMappings).forEach((mappings) => {
+      mappings.forEach((m) => {
+        if (m.matchedFontId) claimed.add(m.matchedFontId);
+      });
+    });
+    return claimed;
+  }, [vfMappings]);
+  const handleMappingChange = useCallback4((vfTempId, instanceKey, fontId) => {
+    const font = allStaticFonts.find((sf) => sf._id === fontId);
+    setVfMappings((prev) => ({
+      ...prev,
+      [vfTempId]: prev[vfTempId].map(
+        (m) => m._key === instanceKey ? { ...m, matchedFontId: fontId, matchedFontTitle: (font == null ? void 0 : font.title) || fontId } : m
+      )
+    }));
+  }, [allStaticFonts]);
+  const handleSave = useCallback4(async () => {
+    setSaving(true);
+    const errors = [];
+    for (const vf of vfEntries) {
+      const mappings = vfMappings[vf.tempId] || [];
+      const references = mappings.filter((m) => m.matchedFontId).map((m) => ({
+        _key: nanoid6(),
+        _type: "object",
+        key: m.instanceName,
+        value: {
+          _type: "reference",
+          _ref: m.matchedFontId,
+          _weak: true
+        }
+      }));
+      try {
+        await client.patch(vf.documentId).set({
+          variableInstanceReferences: references
+        }).commit();
+        console.log(`Patched VF instance mappings: ${vf.documentId} (${references.length} instances)`);
+      } catch (err) {
+        console.error(`Failed to patch VF ${vf.documentId}:`, err);
+        errors.push({ vfTitle: vf.title, error: err.message });
+      }
+    }
+    setSaving(false);
+    onComplete({ success: errors.length === 0, errors });
+  }, [vfEntries, vfMappings, client, onComplete]);
+  const totalInstances = Object.values(vfMappings).reduce((sum, m) => sum + m.length, 0);
+  const matchedInstances = Object.values(vfMappings).reduce(
+    (sum, m) => sum + m.filter((i) => i.matchedFontId).length,
+    0
+  );
+  const unmatchedInstances = totalInstances - matchedInstances;
+  const getAutocompleteOptions = useCallback4((currentFontId) => {
+    return allStaticFonts.filter((sf) => !claimedFontIds.has(sf._id) || sf._id === currentFontId).map((sf) => ({
+      value: sf._id,
+      payload: sf
+    }));
+  }, [allStaticFonts, claimedFontIds]);
+  if (loading) {
+    return /* @__PURE__ */ React8.createElement(Card6, { border: true, padding: 4, radius: 2 }, /* @__PURE__ */ React8.createElement(Flex8, { align: "center", gap: 3, justify: "center" }, /* @__PURE__ */ React8.createElement(Spinner3, null), /* @__PURE__ */ React8.createElement(Text8, { size: 1 }, "Matching variable font instances to static fonts...")));
+  }
+  if (vfEntries.length === 0) {
+    onComplete({ success: true, errors: [] });
+    return null;
+  }
+  return /* @__PURE__ */ React8.createElement(Stack6, { space: 4 }, /* @__PURE__ */ React8.createElement(Stack6, { space: 2 }, /* @__PURE__ */ React8.createElement(Text8, { size: 2, weight: "semibold" }, "Map Variable Font Instances"), /* @__PURE__ */ React8.createElement(Text8, { size: 1, muted: true }, "Review the auto-matched instances below. Each named instance should map to its corresponding static font document.")), /* @__PURE__ */ React8.createElement(Flex8, { gap: 2, align: "center" }, /* @__PURE__ */ React8.createElement(
+    Button6,
+    {
+      mode: "ghost",
+      tone: "primary",
+      icon: SearchIcon2,
+      text: "Re-run Matching",
+      fontSize: 0,
+      padding: 2,
+      onClick: runMatching,
+      disabled: loading,
+      style: { cursor: "pointer" }
+    }
+  ), /* @__PURE__ */ React8.createElement(Badge6, { tone: "positive", fontSize: 0 }, matchedInstances, " matched"), unmatchedInstances > 0 && /* @__PURE__ */ React8.createElement(
+    Badge6,
+    {
+      tone: "critical",
+      fontSize: 0,
+      style: { cursor: "pointer" },
+      onClick: () => setFilterUnmatched((v) => !v)
+    },
+    unmatchedInstances,
+    " unmatched ",
+    filterUnmatched ? "(showing)" : ""
+  ), filterUnmatched && /* @__PURE__ */ React8.createElement(
+    Badge6,
+    {
+      mode: "outline",
+      fontSize: 0,
+      style: { cursor: "pointer" },
+      onClick: () => setFilterUnmatched(false)
+    },
+    "Clear filter"
+  ), /* @__PURE__ */ React8.createElement(Badge6, { mode: "outline", fontSize: 0 }, allStaticFonts.length, " fonts available")), vfEntries.map((vf) => {
+    const mappings = vfMappings[vf.tempId] || [];
+    const displayMappings = filterUnmatched ? mappings.filter((m) => !m.matchedFontId) : mappings;
+    const vfMatched = mappings.filter((m) => m.matchedFontId).length;
+    return /* @__PURE__ */ React8.createElement(Card6, { key: vf.tempId, border: true, padding: 3, radius: 2 }, /* @__PURE__ */ React8.createElement(Stack6, { space: 3 }, /* @__PURE__ */ React8.createElement(Flex8, { align: "center", gap: 2 }, /* @__PURE__ */ React8.createElement(Badge6, { tone: "primary", fontSize: 0 }, "VF"), /* @__PURE__ */ React8.createElement(Text8, { size: 1, weight: "semibold" }, vf.title), /* @__PURE__ */ React8.createElement(Text8, { size: 0, muted: true, style: { marginLeft: "auto" } }, vfMatched, "/", mappings.length, " matched")), /* @__PURE__ */ React8.createElement(Flex8, { align: "center", gap: 2, paddingY: 1, style: { borderBottom: "1px solid var(--card-border-color)" } }, /* @__PURE__ */ React8.createElement(Box7, { style: { width: 20 } }), /* @__PURE__ */ React8.createElement(Text8, { size: 0, weight: "semibold", muted: true, style: { flex: 1 } }, "Instance"), /* @__PURE__ */ React8.createElement(Text8, { size: 0, weight: "semibold", muted: true, style: { flex: 2 } }, "Static Font Document")), /* @__PURE__ */ React8.createElement(Stack6, { space: 1 }, displayMappings.map((mapping) => {
+      const isMatched = !!mapping.matchedFontId;
+      const options = getAutocompleteOptions(mapping.matchedFontId);
+      return /* @__PURE__ */ React8.createElement(
+        Flex8,
+        {
+          key: mapping._key,
+          align: "center",
+          gap: 2,
+          paddingY: 2,
+          style: { borderBottom: "1px solid var(--card-border-color)" }
+        },
+        /* @__PURE__ */ React8.createElement(Box7, { style: { width: 20, flexShrink: 0 } }, isMatched ? /* @__PURE__ */ React8.createElement(CheckmarkCircleIcon2, { style: { color: "#43b649", fontSize: 16 } }) : /* @__PURE__ */ React8.createElement(CloseCircleIcon, { style: { color: "#f03e2f", fontSize: 16 } })),
+        /* @__PURE__ */ React8.createElement(Text8, { size: 1, style: { flex: 1, whiteSpace: "nowrap" } }, mapping.instanceName),
+        /* @__PURE__ */ React8.createElement(Box7, { style: { flex: 2 } }, /* @__PURE__ */ React8.createElement(
+          Autocomplete,
+          {
+            id: `instance-${mapping._key}`,
+            options,
+            value: mapping.matchedFontId,
+            placeholder: "Search for a font...",
+            icon: SearchIcon2,
+            fontSize: 1,
+            filterOption: (query, option) => {
+              var _a, _b, _c, _d;
+              const sf = option.payload;
+              const q = query.toLowerCase();
+              return ((_a = sf.title) == null ? void 0 : _a.toLowerCase().includes(q)) || ((_b = sf._id) == null ? void 0 : _b.toLowerCase().includes(q)) || ((_c = sf.weightName) == null ? void 0 : _c.toLowerCase().includes(q)) || String(sf.weight).includes(q) || ((_d = sf.subfamily) == null ? void 0 : _d.toLowerCase().includes(q));
+            },
+            renderOption: (option) => {
+              const sf = option.payload;
+              const isClaimed = claimedFontIds.has(sf._id) && sf._id !== mapping.matchedFontId;
+              return /* @__PURE__ */ React8.createElement(Card6, { as: "button", padding: 2, style: { opacity: isClaimed ? 0.4 : 1 } }, /* @__PURE__ */ React8.createElement(Flex8, { align: "center", gap: 2 }, /* @__PURE__ */ React8.createElement(Text8, { size: 1 }, sf.title), /* @__PURE__ */ React8.createElement(Text8, { size: 0, muted: true }, sf.weight, " ", sf.style), sf.subfamily && sf.subfamily !== "Regular" && /* @__PURE__ */ React8.createElement(Badge6, { mode: "outline", fontSize: 0 }, sf.subfamily)));
+            },
+            renderValue: (value, option) => {
+              if (option == null ? void 0 : option.payload) return option.payload.title;
+              if (mapping.matchedFontTitle) return mapping.matchedFontTitle;
+              const font = allStaticFonts.find((sf) => sf._id === value);
+              return (font == null ? void 0 : font.title) || value;
+            },
+            onSelect: (value) => handleMappingChange(vf.tempId, mapping._key, value),
+            openButton: true
+          }
+        ))
+      );
+    })), mappings.length === 0 && /* @__PURE__ */ React8.createElement(Text8, { size: 1, muted: true }, "No named instances found in this variable font.")));
+  }), /* @__PURE__ */ React8.createElement(Flex8, { justify: "flex-end", gap: 2, style: { position: "sticky", bottom: 0, background: "var(--card-bg-color)", paddingTop: 8, paddingBottom: 4 } }, /* @__PURE__ */ React8.createElement(
+    Button6,
+    {
+      mode: "ghost",
+      text: "Skip \u2014 I'll map instances later",
+      fontSize: 1,
+      padding: 3,
+      onClick: () => onComplete({ success: true, errors: [], skipped: true }),
+      style: { cursor: "pointer" }
+    }
+  ), /* @__PURE__ */ React8.createElement(
+    Button6,
+    {
+      mode: "default",
+      tone: "positive",
+      text: saving ? "Saving..." : `Save Mappings (${matchedInstances}/${totalInstances})`,
+      fontSize: 1,
+      padding: 3,
+      disabled: saving,
+      onClick: handleSave,
+      style: { cursor: "pointer" }
+    }
+  )));
+}
+
 // src/components/UploadSummary.jsx
-import React8, { useState as useState5, useCallback as useCallback4 } from "react";
-import { Stack as Stack6, Flex as Flex8, Text as Text8, Card as Card6, Badge as Badge6, Button as Button6, Box as Box7, Spinner as Spinner3 } from "@sanity/ui";
-import { CheckmarkCircleIcon as CheckmarkCircleIcon2, WarningOutlineIcon as WarningOutlineIcon2, ResetIcon as ResetIcon2 } from "@sanity/icons";
+import React9, { useState as useState6, useCallback as useCallback5 } from "react";
+import { Stack as Stack7, Flex as Flex9, Text as Text9, Card as Card7, Badge as Badge7, Button as Button7, Box as Box8, Spinner as Spinner4 } from "@sanity/ui";
+import { CheckmarkCircleIcon as CheckmarkCircleIcon3, WarningOutlineIcon as WarningOutlineIcon2, ResetIcon as ResetIcon2 } from "@sanity/icons";
 function UploadSummary({
   plan,
   result,
@@ -6915,12 +7320,12 @@ function UploadSummary({
   preferredStyleRef
 }) {
   var _a;
-  const [retryingPatch, setRetryingPatch] = useState5(false);
-  const [patchRetryResult, setPatchRetryResult] = useState5(null);
+  const [retryingPatch, setRetryingPatch] = useState6(false);
+  const [patchRetryResult, setPatchRetryResult] = useState6(null);
   const hasFailedFonts = ((_a = result == null ? void 0 : result.failedFonts) == null ? void 0 : _a.length) > 0;
   const hasTypefacePatchError = (result == null ? void 0 : result.typefacePatchError) && !(patchRetryResult == null ? void 0 : patchRetryResult.success);
   const allSuccess = (result == null ? void 0 : result.success) && !hasTypefacePatchError;
-  const handleRetryTypefacePatch = useCallback4(async () => {
+  const handleRetryTypefacePatch = useCallback5(async () => {
     var _a2, _b;
     if (!result || !client || !docId) return;
     setRetryingPatch(true);
@@ -6956,11 +7361,11 @@ function UploadSummary({
     }
     setRetryingPatch(false);
   }, [result, client, docId, plan, stylesObject, preferredStyleRef]);
-  return /* @__PURE__ */ React8.createElement(Stack6, { space: 4 }, /* @__PURE__ */ React8.createElement(Flex8, { align: "center", gap: 3, ref: (el) => {
+  return /* @__PURE__ */ React9.createElement(Stack7, { space: 4 }, /* @__PURE__ */ React9.createElement(Flex9, { align: "center", gap: 3, ref: (el) => {
     var _a2;
     return (_a2 = el == null ? void 0 : el.focus) == null ? void 0 : _a2.call(el);
-  }, tabIndex: -1 }, allSuccess ? /* @__PURE__ */ React8.createElement(CheckmarkCircleIcon2, { style: { color: "#43b649", fontSize: 28 } }) : /* @__PURE__ */ React8.createElement(WarningOutlineIcon2, { style: { color: "#f03e2f", fontSize: 28 } }), /* @__PURE__ */ React8.createElement(Text8, { size: 2, weight: "semibold" }, allSuccess ? "Upload Complete" : "Upload Completed with Issues")), result && /* @__PURE__ */ React8.createElement(Card6, { border: true, padding: 4, radius: 2 }, /* @__PURE__ */ React8.createElement(Stack6, { space: 3 }, /* @__PURE__ */ React8.createElement(Flex8, { gap: 2, wrap: "wrap" }, result.created > 0 && /* @__PURE__ */ React8.createElement(Badge6, { tone: "positive", fontSize: 1 }, result.created, " created"), result.updated > 0 && /* @__PURE__ */ React8.createElement(Badge6, { tone: "caution", fontSize: 1 }, result.updated, " updated"), result.failed > 0 && /* @__PURE__ */ React8.createElement(Badge6, { tone: "critical", fontSize: 1 }, result.failed, " failed"), result.skipped > 0 && /* @__PURE__ */ React8.createElement(Badge6, { mode: "outline", fontSize: 1 }, result.skipped, " skipped")))), hasFailedFonts && /* @__PURE__ */ React8.createElement(Stack6, { space: 3 }, /* @__PURE__ */ React8.createElement(Flex8, { align: "center", justify: "space-between" }, /* @__PURE__ */ React8.createElement(Flex8, { align: "center", gap: 2 }, /* @__PURE__ */ React8.createElement(Text8, { size: 1, weight: "semibold" }, "Failed Fonts"), /* @__PURE__ */ React8.createElement(Badge6, { tone: "critical", fontSize: 0 }, result.failedFonts.length)), /* @__PURE__ */ React8.createElement(
-    Button6,
+  }, tabIndex: -1 }, allSuccess ? /* @__PURE__ */ React9.createElement(CheckmarkCircleIcon3, { style: { color: "#43b649", fontSize: 28 } }) : /* @__PURE__ */ React9.createElement(WarningOutlineIcon2, { style: { color: "#f03e2f", fontSize: 28 } }), /* @__PURE__ */ React9.createElement(Text9, { size: 2, weight: "semibold" }, allSuccess ? "Upload Complete" : "Upload Completed with Issues")), result && /* @__PURE__ */ React9.createElement(Card7, { border: true, padding: 4, radius: 2 }, /* @__PURE__ */ React9.createElement(Stack7, { space: 3 }, /* @__PURE__ */ React9.createElement(Flex9, { gap: 2, wrap: "wrap" }, result.created > 0 && /* @__PURE__ */ React9.createElement(Badge7, { tone: "positive", fontSize: 1 }, result.created, " created"), result.updated > 0 && /* @__PURE__ */ React9.createElement(Badge7, { tone: "caution", fontSize: 1 }, result.updated, " updated"), result.failed > 0 && /* @__PURE__ */ React9.createElement(Badge7, { tone: "critical", fontSize: 1 }, result.failed, " failed"), result.skipped > 0 && /* @__PURE__ */ React9.createElement(Badge7, { mode: "outline", fontSize: 1 }, result.skipped, " skipped")))), hasFailedFonts && /* @__PURE__ */ React9.createElement(Stack7, { space: 3 }, /* @__PURE__ */ React9.createElement(Flex9, { align: "center", justify: "space-between" }, /* @__PURE__ */ React9.createElement(Flex9, { align: "center", gap: 2 }, /* @__PURE__ */ React9.createElement(Text9, { size: 1, weight: "semibold" }, "Failed Fonts"), /* @__PURE__ */ React9.createElement(Badge7, { tone: "critical", fontSize: 0 }, result.failedFonts.length)), /* @__PURE__ */ React9.createElement(
+    Button7,
     {
       mode: "ghost",
       tone: "primary",
@@ -6970,8 +7375,8 @@ function UploadSummary({
       padding: 2,
       onClick: () => onRetry(result.failedFonts.map((f) => f.tempId).filter(Boolean))
     }
-  )), /* @__PURE__ */ React8.createElement(Stack6, { space: 2 }, result.failedFonts.map((f, i) => /* @__PURE__ */ React8.createElement(Card6, { key: i, tone: "critical", border: true, padding: 3, radius: 2 }, /* @__PURE__ */ React8.createElement(Stack6, { space: 2 }, /* @__PURE__ */ React8.createElement(Flex8, { align: "center", gap: 2 }, /* @__PURE__ */ React8.createElement(Text8, { size: 1, weight: "semibold" }, f.title), f.failedAt && f.failedAt !== "unknown" && /* @__PURE__ */ React8.createElement(Badge6, { tone: "critical", fontSize: 0, mode: "outline" }, "Failed at: ", f.failedAt)), /* @__PURE__ */ React8.createElement(Text8, { size: 1 }, f.error)))))), hasTypefacePatchError && /* @__PURE__ */ React8.createElement(Card6, { tone: "caution", border: true, padding: 4, radius: 2 }, /* @__PURE__ */ React8.createElement(Stack6, { space: 3 }, /* @__PURE__ */ React8.createElement(Text8, { size: 1, weight: "semibold" }, "Typeface Document Not Updated"), /* @__PURE__ */ React8.createElement(Text8, { size: 1 }, result.created + result.updated, " font document", result.created + result.updated === 1 ? "" : "s", " created/updated successfully, but the typeface document could not be patched to reference them."), /* @__PURE__ */ React8.createElement(Text8, { size: 1, muted: true }, result.typefacePatchError), /* @__PURE__ */ React8.createElement(Flex8, { gap: 2 }, /* @__PURE__ */ React8.createElement(
-    Button6,
+  )), /* @__PURE__ */ React9.createElement(Stack7, { space: 2 }, result.failedFonts.map((f, i) => /* @__PURE__ */ React9.createElement(Card7, { key: i, tone: "critical", border: true, padding: 3, radius: 2 }, /* @__PURE__ */ React9.createElement(Stack7, { space: 2 }, /* @__PURE__ */ React9.createElement(Flex9, { align: "center", gap: 2 }, /* @__PURE__ */ React9.createElement(Text9, { size: 1, weight: "semibold" }, f.title), f.failedAt && f.failedAt !== "unknown" && /* @__PURE__ */ React9.createElement(Badge7, { tone: "critical", fontSize: 0, mode: "outline" }, "Failed at: ", f.failedAt)), /* @__PURE__ */ React9.createElement(Text9, { size: 1 }, f.error)))))), hasTypefacePatchError && /* @__PURE__ */ React9.createElement(Card7, { tone: "caution", border: true, padding: 4, radius: 2 }, /* @__PURE__ */ React9.createElement(Stack7, { space: 3 }, /* @__PURE__ */ React9.createElement(Text9, { size: 1, weight: "semibold" }, "Typeface Document Not Updated"), /* @__PURE__ */ React9.createElement(Text9, { size: 1 }, result.created + result.updated, " font document", result.created + result.updated === 1 ? "" : "s", " created/updated successfully, but the typeface document could not be patched to reference them."), /* @__PURE__ */ React9.createElement(Text9, { size: 1, muted: true }, result.typefacePatchError), /* @__PURE__ */ React9.createElement(Flex9, { gap: 2 }, /* @__PURE__ */ React9.createElement(
+    Button7,
     {
       mode: "default",
       tone: "primary",
@@ -6980,8 +7385,8 @@ function UploadSummary({
       disabled: retryingPatch,
       onClick: handleRetryTypefacePatch
     }
-  ), retryingPatch && /* @__PURE__ */ React8.createElement(Spinner3, null)))), (patchRetryResult == null ? void 0 : patchRetryResult.success) && /* @__PURE__ */ React8.createElement(Card6, { tone: "positive", border: true, padding: 3, radius: 2 }, /* @__PURE__ */ React8.createElement(Text8, { size: 1 }, "Typeface document updated successfully on retry.")), patchRetryResult && !patchRetryResult.success && /* @__PURE__ */ React8.createElement(Card6, { tone: "critical", border: true, padding: 3, radius: 2 }, /* @__PURE__ */ React8.createElement(Text8, { size: 1 }, "Retry failed: ", patchRetryResult.error)), /* @__PURE__ */ React8.createElement(Flex8, { justify: "flex-end" }, /* @__PURE__ */ React8.createElement(
-    Button6,
+  ), retryingPatch && /* @__PURE__ */ React9.createElement(Spinner4, null)))), (patchRetryResult == null ? void 0 : patchRetryResult.success) && /* @__PURE__ */ React9.createElement(Card7, { tone: "positive", border: true, padding: 3, radius: 2 }, /* @__PURE__ */ React9.createElement(Text9, { size: 1 }, "Typeface document updated successfully on retry.")), patchRetryResult && !patchRetryResult.success && /* @__PURE__ */ React9.createElement(Card7, { tone: "critical", border: true, padding: 3, radius: 2 }, /* @__PURE__ */ React9.createElement(Text9, { size: 1 }, "Retry failed: ", patchRetryResult.error)), /* @__PURE__ */ React9.createElement(Flex9, { justify: "flex-end" }, /* @__PURE__ */ React9.createElement(
+    Button7,
     {
       mode: "default",
       tone: "primary",
@@ -6995,7 +7400,8 @@ function UploadSummary({
 var STEPS = [
   { key: 1, label: "Upload Files" },
   { key: 2, label: "Review" },
-  { key: 3, label: "Upload" }
+  { key: 3, label: "Upload" },
+  { key: 4, label: "Map Instances" }
 ];
 function phaseToStep(phase) {
   switch (phase) {
@@ -7028,15 +7434,22 @@ function UploadModal({
   slug
 }) {
   const [plan, dispatch] = useReducer2(planReducer, null, () => createEmptyPlan());
-  const [processingCancelled, setProcessingCancelled] = useState6(false);
-  const [executionResult, setExecutionResult] = useState6(null);
-  const [retryTempIds, setRetryTempIds] = useState6(null);
+  const [processingCancelled, setProcessingCancelled] = useState7(false);
+  const [executionResult, setExecutionResult] = useState7(null);
+  const [retryTempIds, setRetryTempIds] = useState7(null);
+  const [instanceMappingPhase, setInstanceMappingPhase] = useState7(false);
+  const [instanceMappingResult, setInstanceMappingResult] = useState7(null);
   const cancelRef = useRef3(false);
   const focusRef = useRef3(null);
-  const { weightKeywordList, italicKeywordList } = useMemo6(() => generateStyleKeywords(), []);
-  const currentStep = phaseToStep(plan.phase);
+  const { weightKeywordList, italicKeywordList } = useMemo7(() => generateStyleKeywords(), []);
+  const hasVFs = useMemo7(
+    () => Object.values(plan.fonts).some((f) => f.variableFont && f.status !== "error"),
+    [plan.fonts]
+  );
+  const baseStep = phaseToStep(plan.phase);
+  const currentStep = instanceMappingPhase ? 4 : plan.phase === PLAN_PHASE.COMPLETE && !instanceMappingResult ? baseStep : baseStep;
   const isExecuting = plan.phase === PLAN_PHASE.EXECUTING;
-  useEffect4(() => {
+  useEffect5(() => {
     if (!open || !isExecuting) return;
     const handler = (e) => {
       e.preventDefault();
@@ -7045,12 +7458,12 @@ function UploadModal({
     window.addEventListener("beforeunload", handler);
     return () => window.removeEventListener("beforeunload", handler);
   }, [open, isExecuting]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (focusRef.current) {
       focusRef.current.focus();
     }
   }, [currentStep]);
-  const handleClose = useCallback5(() => {
+  const handleClose = useCallback6(() => {
     if (isExecuting) return;
     const hasFonts = Object.keys(plan.fonts).length > 0;
     if (hasFonts && plan.phase !== PLAN_PHASE.COMPLETE) {
@@ -7060,8 +7473,8 @@ function UploadModal({
     setExecutionResult(null);
     onClose();
   }, [plan, isExecuting, onClose]);
-  const handleStartProcessing = useCallback5(async (files, settings) => {
-    dispatch({ type: "SET_SETTINGS", settings });
+  const handleStartProcessing = useCallback6(async (files, settings) => {
+    dispatch({ type: "SET_SETTINGS", settings: { ...settings, typefaceTitle } });
     dispatch({ type: "SET_PHASE", phase: PLAN_PHASE.PROCESSING, totalFiles: files.length });
     cancelRef.current = false;
     setProcessingCancelled(false);
@@ -7094,20 +7507,29 @@ function UploadModal({
       dispatch({ type: "SET_PHASE", phase: PLAN_PHASE.REVIEWING });
     }
   }, [typefaceTitle, docId, client, stylesObject, weightKeywordList, italicKeywordList]);
-  const handleCancelProcessing = useCallback5(() => {
+  const handleCancelProcessing = useCallback6(() => {
     cancelRef.current = true;
     setProcessingCancelled(true);
     dispatch({ type: "SET_PHASE", phase: PLAN_PHASE.IDLE });
   }, []);
-  const handleStartExecution = useCallback5(() => {
+  const handleStartExecution = useCallback6(() => {
     dispatch({ type: "SET_PHASE", phase: PLAN_PHASE.EXECUTING });
   }, []);
-  const handleExecutionComplete = useCallback5((result) => {
+  const handleExecutionComplete = useCallback6((result) => {
     setExecutionResult(result);
-    dispatch({ type: "SET_PHASE", phase: PLAN_PHASE.COMPLETE });
+    if (hasVFs && result.success !== false) {
+      setInstanceMappingPhase(true);
+      dispatch({ type: "SET_PHASE", phase: PLAN_PHASE.COMPLETE });
+    } else {
+      dispatch({ type: "SET_PHASE", phase: PLAN_PHASE.COMPLETE });
+    }
+  }, [hasVFs]);
+  const handleInstanceMappingComplete = useCallback6((result) => {
+    setInstanceMappingResult(result);
+    setInstanceMappingPhase(false);
   }, []);
   if (!open) return null;
-  const handleStepClick = useCallback5((stepKey) => {
+  const handleStepClick = useCallback6((stepKey) => {
     if (isExecuting) return;
     if (stepKey === currentStep) return;
     if (stepKey === 1 && currentStep > 1) {
@@ -7117,16 +7539,16 @@ function UploadModal({
       dispatch({ type: "SET_PHASE", phase: PLAN_PHASE.IDLE });
     }
   }, [currentStep, isExecuting, plan.fonts, dispatch]);
-  return /* @__PURE__ */ React9.createElement(
+  return /* @__PURE__ */ React10.createElement(
     Dialog,
     {
       id: "upload-modal",
-      header: /* @__PURE__ */ React9.createElement(Flex9, { direction: "column", gap: 3, style: { width: "100%" } }, /* @__PURE__ */ React9.createElement(Text9, { weight: "semibold", size: 2 }, "Upload Fonts"), /* @__PURE__ */ React9.createElement(Flex9, { gap: 1, style: { width: "100%" } }, STEPS.map((step, i) => {
+      header: /* @__PURE__ */ React10.createElement(Flex10, { direction: "column", gap: 3, style: { width: "100%" } }, /* @__PURE__ */ React10.createElement(Text10, { weight: "semibold", size: 2 }, "Upload Fonts"), /* @__PURE__ */ React10.createElement(Flex10, { gap: 1, style: { width: "100%" } }, STEPS.filter((step) => step.key !== 4 || hasVFs).map((step, i) => {
         const isActive = currentStep === step.key;
         const isCompleted = currentStep > step.key;
         const isClickable = !isExecuting && step.key < currentStep;
-        return /* @__PURE__ */ React9.createElement(
-          Box8,
+        return /* @__PURE__ */ React10.createElement(
+          Box9,
           {
             key: step.key,
             as: isClickable ? "button" : "div",
@@ -7144,8 +7566,8 @@ function UploadModal({
               opacity: !isActive && !isCompleted ? 0.6 : 1
             }
           },
-          /* @__PURE__ */ React9.createElement(
-            Text9,
+          /* @__PURE__ */ React10.createElement(
+            Text10,
             {
               size: 1,
               weight: isActive ? "bold" : "medium",
@@ -7162,13 +7584,13 @@ function UploadModal({
       onClickOutside: () => {
       }
     },
-    /* @__PURE__ */ React9.createElement(Box8, { padding: 4 }, currentStep === 1 && /* @__PURE__ */ React9.createElement(
+    /* @__PURE__ */ React10.createElement(Box9, { padding: 4 }, currentStep === 1 && /* @__PURE__ */ React10.createElement(
       UploadStep1Settings,
       {
         settings: plan.settings,
         onStartProcessing: handleStartProcessing
       }
-    ), currentStep === 2 && /* @__PURE__ */ React9.createElement(
+    ), currentStep === 2 && /* @__PURE__ */ React10.createElement(
       UploadStep2Review,
       {
         plan,
@@ -7177,7 +7599,7 @@ function UploadModal({
         onStartExecution: handleStartExecution,
         processingCancelled
       }
-    ), currentStep === 3 && plan.phase !== PLAN_PHASE.COMPLETE && /* @__PURE__ */ React9.createElement(
+    ), currentStep === 3 && plan.phase !== PLAN_PHASE.COMPLETE && /* @__PURE__ */ React10.createElement(
       UploadStep3Execute,
       {
         key: retryTempIds ? "retry" : "initial",
@@ -7192,15 +7614,27 @@ function UploadModal({
           handleExecutionComplete(result);
         }
       }
-    ), plan.phase === PLAN_PHASE.COMPLETE && /* @__PURE__ */ React9.createElement(
+    ), plan.phase === PLAN_PHASE.COMPLETE && instanceMappingPhase && /* @__PURE__ */ React10.createElement(
+      UploadStep3bInstances,
+      {
+        plan,
+        executionResult,
+        client,
+        typefaceTitle,
+        onComplete: handleInstanceMappingComplete
+      }
+    ), plan.phase === PLAN_PHASE.COMPLETE && !instanceMappingPhase && /* @__PURE__ */ React10.createElement(
       UploadSummary,
       {
         plan,
         result: executionResult,
+        instanceMappingResult,
         onClose: handleClose,
         onRetry: (failedTempIds) => {
           setRetryTempIds(failedTempIds || null);
           setExecutionResult(null);
+          setInstanceMappingPhase(false);
+          setInstanceMappingResult(null);
           dispatch({ type: "SET_PHASE", phase: PLAN_PHASE.EXECUTING });
         },
         client,
@@ -7271,6 +7705,7 @@ export {
   createInitialExecutionState,
   executionReducer,
   UploadStep3Execute,
+  UploadStep3bInstances,
   UploadSummary,
   UploadModal
 };