refactoring

app/ui-quiz-bank.js

@@ -0,0 +1,947 @@
+/* ui-quiz-bank.js — Built-in quiz question bank generation */
+(function () {
+  "use strict";
+
+  function toTitleCase(value) {
+    const text = String(value || "").trim().toLowerCase();
+    if (!text) {
+      return "";
+    }
+    return text.charAt(0).toUpperCase() + text.slice(1);
+  }
+
+  function normalizeOption(value) {
+    return String(value || "").trim();
+  }
+
+  function normalizeKey(value) {
+    return normalizeOption(value).toLowerCase();
+  }
+
+  function toUniqueOptionList(values) {
+    const seen = new Set();
+    const unique = [];
+
+    (values || []).forEach((value) => {
+      const formatted = normalizeOption(value);
+      if (!formatted) {
+        return;
+      }
+
+      const key = normalizeKey(formatted);
+      if (seen.has(key)) {
+        return;
+      }
+
+      seen.add(key);
+      unique.push(formatted);
+    });
+
+    return unique;
+  }
+
+  function resolveDifficultyValue(valueByDifficulty, difficulty = "normal") {
+    if (valueByDifficulty == null) {
+      return "";
+    }
+
+    if (typeof valueByDifficulty !== "object" || Array.isArray(valueByDifficulty)) {
+      return valueByDifficulty;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(valueByDifficulty, difficulty)) {
+      return valueByDifficulty[difficulty];
+    }
+
+    if (Object.prototype.hasOwnProperty.call(valueByDifficulty, "normal")) {
+      return valueByDifficulty.normal;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(valueByDifficulty, "easy")) {
+      return valueByDifficulty.easy;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(valueByDifficulty, "hard")) {
+      return valueByDifficulty.hard;
+    }
+
+    return "";
+  }
+
+  function createQuestionTemplate(payload, poolValues) {
+    const key = String(payload?.key || "").trim();
+    const promptByDifficulty = payload?.promptByDifficulty ?? payload?.prompt;
+    const answerByDifficulty = payload?.answerByDifficulty ?? payload?.answer;
+    const poolByDifficulty = poolValues;
+    const categoryId = String(payload?.categoryId || "").trim();
+    const category = String(payload?.category || "Correspondence").trim();
+
+    const defaultPrompt = String(resolveDifficultyValue(promptByDifficulty, "normal") || "").trim();
+    const defaultAnswer = normalizeOption(resolveDifficultyValue(answerByDifficulty, "normal"));
+    const defaultPool = toUniqueOptionList(resolveDifficultyValue(poolByDifficulty, "normal") || []);
+
+    if (!key || !defaultPrompt || !defaultAnswer || !categoryId || !category) {
+      return null;
+    }
+
+    if (!defaultPool.some((value) => normalizeKey(value) === normalizeKey(defaultAnswer))) {
+      defaultPool.push(defaultAnswer);
+    }
+
+    const distractorCount = defaultPool.filter((value) => normalizeKey(value) !== normalizeKey(defaultAnswer)).length;
+    if (distractorCount < 3) {
+      return null;
+    }
+
+    return {
+      key,
+      categoryId,
+      category,
+      promptByDifficulty,
+      answerByDifficulty,
+      poolByDifficulty
+    };
+  }
+
+  function buildQuestionBank(referenceData, magickDataset, dynamicCategoryRegistry) {
+    const grouped = magickDataset?.grouped || {};
+    const alphabets = grouped.alphabets || {};
+    const englishLetters = Array.isArray(alphabets?.english) ? alphabets.english : [];
+    const hebrewLetters = Array.isArray(alphabets?.hebrew) ? alphabets.hebrew : [];
+    const kabbalahTree = grouped?.kabbalah?.["kabbalah-tree"] || {};
+    const treePaths = Array.isArray(kabbalahTree?.paths) ? kabbalahTree.paths : [];
+    const treeSephiroth = Array.isArray(kabbalahTree?.sephiroth) ? kabbalahTree.sephiroth : [];
+    const sephirotById = grouped?.kabbalah?.sephirot && typeof grouped.kabbalah.sephirot === "object"
+      ? grouped.kabbalah.sephirot
+      : {};
+    const cube = grouped?.kabbalah?.cube && typeof grouped.kabbalah.cube === "object"
+      ? grouped.kabbalah.cube
+      : {};
+    const cubeWalls = Array.isArray(cube?.walls) ? cube.walls : [];
+    const cubeEdges = Array.isArray(cube?.edges) ? cube.edges : [];
+    const cubeCenter = cube?.center && typeof cube.center === "object" ? cube.center : null;
+    const playingCardsData = grouped?.["playing-cards-52"];
+    const playingCards = Array.isArray(playingCardsData)
+      ? playingCardsData
+      : (Array.isArray(playingCardsData?.entries) ? playingCardsData.entries : []);
+    const signs = Array.isArray(referenceData?.signs) ? referenceData.signs : [];
+    const planetsById = referenceData?.planets && typeof referenceData.planets === "object"
+      ? referenceData.planets
+      : {};
+    const planets = Object.values(planetsById);
+    const decansBySign = referenceData?.decansBySign && typeof referenceData.decansBySign === "object"
+      ? referenceData.decansBySign
+      : {};
+
+    const normalizeId = (value) => String(value || "").trim().toLowerCase();
+
+    const toRomanNumeral = (value) => {
+      const numeric = Number(value);
+      if (!Number.isFinite(numeric) || numeric <= 0) {
+        return String(value || "");
+      }
+
+      const intValue = Math.trunc(numeric);
+      const lookup = [
+        [1000, "M"],
+        [900, "CM"],
+        [500, "D"],
+        [400, "CD"],
+        [100, "C"],
+        [90, "XC"],
+        [50, "L"],
+        [40, "XL"],
+        [10, "X"],
+        [9, "IX"],
+        [5, "V"],
+        [4, "IV"],
+        [1, "I"]
+      ];
+
+      let current = intValue;
+      let result = "";
+      lookup.forEach(([size, symbol]) => {
+        while (current >= size) {
+          result += symbol;
+          current -= size;
+        }
+      });
+
+      return result || String(intValue);
+    };
+
+    const labelFromId = (value) => {
+      const id = String(value || "").trim();
+      if (!id) {
+        return "";
+      }
+      return id
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .split(" ")
+        .map((part) => part ? part.charAt(0).toUpperCase() + part.slice(1) : "")
+        .join(" ");
+    };
+
+    const getPlanetLabelById = (planetId) => {
+      const normalized = normalizeId(planetId);
+      if (!normalized) {
+        return "";
+      }
+
+      const directPlanet = planetsById[normalized];
+      if (directPlanet?.name) {
+        return directPlanet.name;
+      }
+
+      if (normalized === "primum-mobile") {
+        return "Primum Mobile";
+      }
+      if (normalized === "olam-yesodot") {
+        return "Earth / Elements";
+      }
+
+      return labelFromId(normalized);
+    };
+
+    const hebrewById = new Map(
+      hebrewLetters
+        .filter((entry) => entry?.hebrewLetterId)
+        .map((entry) => [normalizeId(entry.hebrewLetterId), entry])
+    );
+
+    const formatHebrewLetterLabel = (entry, fallbackId = "") => {
+      if (entry?.name && entry?.char) {
+        return `${entry.name} (${entry.char})`;
+      }
+      if (entry?.name) {
+        return entry.name;
+      }
+      if (entry?.char) {
+        return entry.char;
+      }
+      return labelFromId(fallbackId);
+    };
+
+    const sephiraNameByNumber = new Map(
+      treeSephiroth
+        .filter((entry) => Number.isFinite(Number(entry?.number)) && entry?.name)
+        .map((entry) => [Math.trunc(Number(entry.number)), String(entry.name)])
+    );
+
+    const sephiraNameById = new Map(
+      treeSephiroth
+        .filter((entry) => entry?.sephiraId && entry?.name)
+        .map((entry) => [normalizeId(entry.sephiraId), String(entry.name)])
+    );
+
+    const getSephiraName = (numberValue, idValue) => {
+      const numberKey = Number(numberValue);
+      if (Number.isFinite(numberKey)) {
+        const byNumber = sephiraNameByNumber.get(Math.trunc(numberKey));
+        if (byNumber) {
+          return byNumber;
+        }
+      }
+
+      const byId = sephiraNameById.get(normalizeId(idValue));
+      if (byId) {
+        return byId;
+      }
+
+      if (Number.isFinite(numberKey)) {
+        return `Sephira ${Math.trunc(numberKey)}`;
+      }
+
+      return labelFromId(idValue);
+    };
+
+    const formatPathLetter = (path) => {
+      const transliteration = String(path?.hebrewLetter?.transliteration || "").trim();
+      const glyph = String(path?.hebrewLetter?.char || "").trim();
+
+      if (transliteration && glyph) {
+        return `${transliteration} (${glyph})`;
+      }
+      if (transliteration) {
+        return transliteration;
+      }
+      if (glyph) {
+        return glyph;
+      }
+      return "";
+    };
+
+    const flattenDecans = Object.values(decansBySign)
+      .flatMap((entries) => (Array.isArray(entries) ? entries : []));
+
+    const signNameById = new Map(
+      signs
+        .filter((entry) => entry?.id && entry?.name)
+        .map((entry) => [normalizeId(entry.id), String(entry.name)])
+    );
+
+    const formatDecanLabel = (decan) => {
+      const signName = signNameById.get(normalizeId(decan?.signId)) || labelFromId(decan?.signId);
+      const index = Number(decan?.index);
+      if (!signName || !Number.isFinite(index)) {
+        return "";
+      }
+      return `${signName} Decan ${toRomanNumeral(index)}`;
+    };
+
+    const bank = [];
+
+    const englishGematriaPool = englishLetters
+      .map((item) => (Number.isFinite(Number(item?.pythagorean)) ? String(item.pythagorean) : ""))
+      .filter(Boolean);
+
+    const hebrewNumerologyPool = hebrewLetters
+      .map((item) => (Number.isFinite(Number(item?.numerology)) ? String(item.numerology) : ""))
+      .filter(Boolean);
+
+    const hebrewNameAndCharPool = hebrewLetters
+      .filter((item) => item?.name && item?.char)
+      .map((item) => `${item.name} (${item.char})`);
+
+    const hebrewCharPool = hebrewLetters
+      .map((item) => item?.char)
+      .filter(Boolean);
+
+    const planetNamePool = planets
+      .map((planet) => planet?.name)
+      .filter(Boolean);
+
+    const planetWeekdayPool = planets
+      .map((planet) => planet?.weekday)
+      .filter(Boolean);
+
+    const zodiacElementPool = signs
+      .map((sign) => toTitleCase(sign?.element))
+      .filter(Boolean);
+
+    const zodiacTarotPool = signs
+      .map((sign) => sign?.tarot?.majorArcana)
+      .filter(Boolean);
+
+    const pathNumberPool = toUniqueOptionList(
+      treePaths
+        .map((path) => {
+          const pathNo = Number(path?.pathNumber);
+          return Number.isFinite(pathNo) ? String(Math.trunc(pathNo)) : "";
+        })
+    );
+
+    const pathLetterPool = toUniqueOptionList(treePaths.map((path) => formatPathLetter(path)));
+    const pathTarotPool = toUniqueOptionList(treePaths.map((path) => normalizeOption(path?.tarot?.card)));
+
+    const decanLabelPool = toUniqueOptionList(flattenDecans.map((decan) => formatDecanLabel(decan)));
+    const decanRulerPool = toUniqueOptionList(
+      flattenDecans.map((decan) => getPlanetLabelById(decan?.rulerPlanetId))
+    );
+
+    const cubeWallLabelPool = toUniqueOptionList(
+      cubeWalls.map((wall) => `${String(wall?.name || labelFromId(wall?.id)).trim()} Wall`)
+    );
+
+    const cubeEdgeLabelPool = toUniqueOptionList(
+      cubeEdges.map((edge) => `${String(edge?.name || labelFromId(edge?.id)).trim()} Edge`)
+    );
+
+    const cubeLocationPool = toUniqueOptionList([
+      ...cubeWallLabelPool,
+      ...cubeEdgeLabelPool,
+      "Center"
+    ]);
+
+    const cubeHebrewLetterPool = toUniqueOptionList([
+      ...cubeWalls.map((wall) => {
+        const hebrew = hebrewById.get(normalizeId(wall?.hebrewLetterId));
+        return formatHebrewLetterLabel(hebrew, wall?.hebrewLetterId);
+      }),
+      ...cubeEdges.map((edge) => {
+        const hebrew = hebrewById.get(normalizeId(edge?.hebrewLetterId));
+        return formatHebrewLetterLabel(hebrew, edge?.hebrewLetterId);
+      }),
+      formatHebrewLetterLabel(hebrewById.get(normalizeId(cubeCenter?.hebrewLetterId)), cubeCenter?.hebrewLetterId)
+    ]);
+
+    const playingTarotPool = toUniqueOptionList(
+      playingCards.map((entry) => normalizeOption(entry?.tarotCard))
+    );
+
+    englishLetters.forEach((entry) => {
+      if (!entry?.letter || !Number.isFinite(Number(entry?.pythagorean))) {
+        return;
+      }
+
+      const template = createQuestionTemplate(
+        {
+          key: `english-gematria:${entry.letter}`,
+          categoryId: "english-gematria",
+          category: "English Gematria",
+          promptByDifficulty: `${entry.letter} has a simple gematria value of`,
+          answerByDifficulty: String(entry.pythagorean)
+        },
+        englishGematriaPool
+      );
+
+      if (template) {
+        bank.push(template);
+      }
+    });
+
+    hebrewLetters.forEach((entry) => {
+      if (!entry?.name || !entry?.char || !Number.isFinite(Number(entry?.numerology))) {
+        return;
+      }
+
+      const template = createQuestionTemplate(
+        {
+          key: `hebrew-number:${entry.hebrewLetterId || entry.name}`,
+          categoryId: "hebrew-numerology",
+          category: "Hebrew Gematria",
+          promptByDifficulty: {
+            easy: `${entry.name} (${entry.char}) has a gematria value of`,
+            normal: `${entry.name} (${entry.char}) has a gematria value of`,
+            hard: `${entry.char} has a gematria value of`
+          },
+          answerByDifficulty: String(entry.numerology)
+        },
+        hebrewNumerologyPool
+      );
+
+      if (template) {
+        bank.push(template);
+      }
+    });
+
+    englishLetters.forEach((entry) => {
+      if (!entry?.letter || !entry?.hebrewLetterId) {
+        return;
+      }
+
+      const mappedHebrew = hebrewById.get(normalizeId(entry.hebrewLetterId));
+      if (!mappedHebrew?.name || !mappedHebrew?.char) {
+        return;
+      }
+
+      const template = createQuestionTemplate(
+        {
+          key: `english-hebrew:${entry.letter}`,
+          categoryId: "english-hebrew-mapping",
+          category: "Alphabet Mapping",
+          promptByDifficulty: {
+            easy: `${entry.letter} maps to which Hebrew letter`,
+            normal: `${entry.letter} maps to which Hebrew letter`,
+            hard: `${entry.letter} maps to which Hebrew glyph`
+          },
+          answerByDifficulty: {
+            easy: `${mappedHebrew.name} (${mappedHebrew.char})`,
+            normal: `${mappedHebrew.name} (${mappedHebrew.char})`,
+            hard: mappedHebrew.char
+          }
+        },
+        {
+          easy: hebrewNameAndCharPool,
+          normal: hebrewNameAndCharPool,
+          hard: hebrewCharPool
+        }
+      );
+
+      if (template) {
+        bank.push(template);
+      }
+    });
+
+    signs.forEach((entry) => {
+      if (!entry?.name || !entry?.rulingPlanetId) {
+        return;
+      }
+
+      const rulerName = planetsById[normalizeId(entry.rulingPlanetId)]?.name;
+      if (!rulerName) {
+        return;
+      }
+
+      const template = createQuestionTemplate(
+        {
+          key: `zodiac-ruler:${entry.id || entry.name}`,
+          categoryId: "zodiac-rulers",
+          category: "Zodiac Rulers",
+          promptByDifficulty: `${entry.name} is ruled by`,
+          answerByDifficulty: rulerName
+        },
+        planetNamePool
+      );
+
+      if (template) {
+        bank.push(template);
+      }
+    });
+
+    signs.forEach((entry) => {
+      if (!entry?.name || !entry?.element) {
+        return;
+      }
+
+      const template = createQuestionTemplate(
+        {
+          key: `zodiac-element:${entry.id || entry.name}`,
+          categoryId: "zodiac-elements",
+          category: "Zodiac Elements",
+          promptByDifficulty: `${entry.name} is`,
+          answerByDifficulty: toTitleCase(entry.element)
+        },
+        zodiacElementPool
+      );
+
+      if (template) {
+        bank.push(template);
+      }
+    });
+
+    planets.forEach((entry) => {
+      if (!entry?.name || !entry?.weekday) {
+        return;
+      }
+
+      const template = createQuestionTemplate(
+        {
+          key: `planet-weekday:${entry.id || entry.name}`,
+          categoryId: "planetary-weekdays",
+          category: "Planetary Weekdays",
+          promptByDifficulty: `${entry.name} corresponds to`,
+          answerByDifficulty: entry.weekday
+        },
+        planetWeekdayPool
+      );
+
+      if (template) {
+        bank.push(template);
+      }
+    });
+
+    signs.forEach((entry) => {
+      if (!entry?.name || !entry?.tarot?.majorArcana) {
+        return;
+      }
+
+      const template = createQuestionTemplate(
+        {
+          key: `zodiac-tarot:${entry.id || entry.name}`,
+          categoryId: "zodiac-tarot",
+          category: "Zodiac ↔ Tarot",
+          promptByDifficulty: `${entry.name} corresponds to`,
+          answerByDifficulty: entry.tarot.majorArcana
+        },
+        zodiacTarotPool
+      );
+
+      if (template) {
+        bank.push(template);
+      }
+    });
+
+    treePaths.forEach((path) => {
+      const pathNo = Number(path?.pathNumber);
+      if (!Number.isFinite(pathNo)) {
+        return;
+      }
+
+      const pathNumberLabel = String(Math.trunc(pathNo));
+      const fromNo = Number(path?.connects?.from);
+      const toNo = Number(path?.connects?.to);
+      const fromName = getSephiraName(fromNo, path?.connectIds?.from);
+      const toName = getSephiraName(toNo, path?.connectIds?.to);
+      const pathLetter = formatPathLetter(path);
+      const tarotCard = normalizeOption(path?.tarot?.card);
+
+      if (fromName && toName) {
+        const template = createQuestionTemplate(
+          {
+            key: `kabbalah-path-between:${pathNumberLabel}`,
+            categoryId: "kabbalah-path-between-sephirot",
+            category: "Kabbalah Paths",
+            promptByDifficulty: {
+              easy: `Which path is between ${fromName} and ${toName}`,
+              normal: `What path connects ${fromName} and ${toName}`,
+              hard: `${fromName} ↔ ${toName} is which path`
+            },
+            answerByDifficulty: pathNumberLabel
+          },
+          pathNumberPool
+        );
+
+        if (template) {
+          bank.push(template);
+        }
+      }
+
+      if (pathLetter) {
+        const numberToLetterTemplate = createQuestionTemplate(
+          {
+            key: `kabbalah-path-letter:${pathNumberLabel}`,
+            categoryId: "kabbalah-path-letter",
+            category: "Kabbalah Paths",
+            promptByDifficulty: {
+              easy: `Which letter is on Path ${pathNumberLabel}`,
+              normal: `Path ${pathNumberLabel} carries which Hebrew letter`,
+              hard: `Letter on Path ${pathNumberLabel}`
+            },
+            answerByDifficulty: pathLetter
+          },
+          pathLetterPool
+        );
+
+        if (numberToLetterTemplate) {
+          bank.push(numberToLetterTemplate);
+        }
+
+        const letterToNumberTemplate = createQuestionTemplate(
+          {
+            key: `kabbalah-letter-path-number:${pathNumberLabel}`,
+            categoryId: "kabbalah-path-letter",
+            category: "Kabbalah Paths",
+            promptByDifficulty: {
+              easy: `${pathLetter} belongs to which path`,
+              normal: `${pathLetter} corresponds to Path`,
+              hard: `${pathLetter} is on Path`
+            },
+            answerByDifficulty: pathNumberLabel
+          },
+          pathNumberPool
+        );
+
+        if (letterToNumberTemplate) {
+          bank.push(letterToNumberTemplate);
+        }
+      }
+
+      if (tarotCard) {
+        const pathToTarotTemplate = createQuestionTemplate(
+          {
+            key: `kabbalah-path-tarot:${pathNumberLabel}`,
+            categoryId: "kabbalah-path-tarot",
+            category: "Kabbalah ↔ Tarot",
+            promptByDifficulty: {
+              easy: `Path ${pathNumberLabel} corresponds to which Tarot trump`,
+              normal: `Which Tarot trump is on Path ${pathNumberLabel}`,
+              hard: `Tarot trump on Path ${pathNumberLabel}`
+            },
+            answerByDifficulty: tarotCard
+          },
+          pathTarotPool
+        );
+
+        if (pathToTarotTemplate) {
+          bank.push(pathToTarotTemplate);
+        }
+
+        const tarotToPathTemplate = createQuestionTemplate(
+          {
+            key: `tarot-trump-path:${pathNumberLabel}`,
+            categoryId: "kabbalah-path-tarot",
+            category: "Tarot ↔ Kabbalah",
+            promptByDifficulty: {
+              easy: `${tarotCard} is on which path`,
+              normal: `Which path corresponds to ${tarotCard}`,
+              hard: `${tarotCard} corresponds to Path`
+            },
+            answerByDifficulty: pathNumberLabel
+          },
+          pathNumberPool
+        );
+
+        if (tarotToPathTemplate) {
+          bank.push(tarotToPathTemplate);
+        }
+      }
+    });
+
+    Object.values(sephirotById).forEach((sephira) => {
+      const sephiraName = String(sephira?.name?.roman || sephira?.name?.en || "").trim();
+      const planetLabel = getPlanetLabelById(sephira?.planetId);
+      if (!sephiraName || !planetLabel) {
+        return;
+      }
+
+      const template = createQuestionTemplate(
+        {
+          key: `sephirot-planet:${normalizeId(sephira?.id || sephiraName)}`,
+          categoryId: "sephirot-planets",
+          category: "Sephirot ↔ Planet",
+          promptByDifficulty: {
+            easy: `${sephiraName} corresponds to which planet`,
+            normal: `Planetary correspondence of ${sephiraName}`,
+            hard: `${sephiraName} corresponds to`
+          },
+          answerByDifficulty: planetLabel
+        },
+        toUniqueOptionList(Object.values(sephirotById).map((entry) => getPlanetLabelById(entry?.planetId)))
+      );
+
+      if (template) {
+        bank.push(template);
+      }
+    });
+
+    flattenDecans.forEach((decan) => {
+      const decanId = String(decan?.id || "").trim();
+      const card = normalizeOption(decan?.tarotMinorArcana);
+      const decanLabel = formatDecanLabel(decan);
+      const rulerLabel = getPlanetLabelById(decan?.rulerPlanetId);
+
+      if (!decanId || !card) {
+        return;
+      }
+
+      if (decanLabel) {
+        const template = createQuestionTemplate(
+          {
+            key: `tarot-decan-sign:${decanId}`,
+            categoryId: "tarot-decan-sign",
+            category: "Tarot Decans",
+            promptByDifficulty: {
+              easy: `${card} belongs to which decan`,
+              normal: `Which decan contains ${card}`,
+              hard: `${card} is in`
+            },
+            answerByDifficulty: decanLabel
+          },
+          decanLabelPool
+        );
+
+        if (template) {
+          bank.push(template);
+        }
+      }
+
+      if (rulerLabel) {
+        const template = createQuestionTemplate(
+          {
+            key: `tarot-decan-ruler:${decanId}`,
+            categoryId: "tarot-decan-ruler",
+            category: "Tarot Decans",
+            promptByDifficulty: {
+              easy: `The decan of ${card} is ruled by`,
+              normal: `Who rules the decan for ${card}`,
+              hard: `${card} decan ruler`
+            },
+            answerByDifficulty: rulerLabel
+          },
+          decanRulerPool
+        );
+
+        if (template) {
+          bank.push(template);
+        }
+      }
+    });
+
+    cubeWalls.forEach((wall) => {
+      const wallName = String(wall?.name || labelFromId(wall?.id)).trim();
+      const wallLabel = wallName ? `${wallName} Wall` : "";
+      const tarotCard = normalizeOption(wall?.associations?.tarotCard);
+      const hebrew = hebrewById.get(normalizeId(wall?.hebrewLetterId));
+      const hebrewLabel = formatHebrewLetterLabel(hebrew, wall?.hebrewLetterId);
+
+      if (tarotCard && wallLabel) {
+        const template = createQuestionTemplate(
+          {
+            key: `tarot-cube-wall:${normalizeId(wall?.id || wallName)}`,
+            categoryId: "tarot-cube-location",
+            category: "Tarot ↔ Cube",
+            promptByDifficulty: {
+              easy: `${tarotCard} is on which Cube wall`,
+              normal: `Where is ${tarotCard} on the Cube`,
+              hard: `${tarotCard} location on Cube`
+            },
+            answerByDifficulty: wallLabel
+          },
+          cubeLocationPool
+        );
+
+        if (template) {
+          bank.push(template);
+        }
+      }
+
+      if (wallLabel && hebrewLabel) {
+        const template = createQuestionTemplate(
+          {
+            key: `cube-wall-letter:${normalizeId(wall?.id || wallName)}`,
+            categoryId: "cube-hebrew-letter",
+            category: "Cube ↔ Hebrew",
+            promptByDifficulty: {
+              easy: `${wallLabel} corresponds to which Hebrew letter`,
+              normal: `Which Hebrew letter is on ${wallLabel}`,
+              hard: `${wallLabel} letter`
+            },
+            answerByDifficulty: hebrewLabel
+          },
+          cubeHebrewLetterPool
+        );
+
+        if (template) {
+          bank.push(template);
+        }
+      }
+    });
+
+    cubeEdges.forEach((edge) => {
+      const edgeName = String(edge?.name || labelFromId(edge?.id)).trim();
+      const edgeLabel = edgeName ? `${edgeName} Edge` : "";
+      const hebrew = hebrewById.get(normalizeId(edge?.hebrewLetterId));
+      const hebrewLabel = formatHebrewLetterLabel(hebrew, edge?.hebrewLetterId);
+      const tarotCard = normalizeOption(hebrew?.tarot?.card);
+
+      if (tarotCard && edgeLabel) {
+        const template = createQuestionTemplate(
+          {
+            key: `tarot-cube-edge:${normalizeId(edge?.id || edgeName)}`,
+            categoryId: "tarot-cube-location",
+            category: "Tarot ↔ Cube",
+            promptByDifficulty: {
+              easy: `${tarotCard} is on which Cube edge`,
+              normal: `Where is ${tarotCard} on the Cube edges`,
+              hard: `${tarotCard} edge location`
+            },
+            answerByDifficulty: edgeLabel
+          },
+          cubeLocationPool
+        );
+
+        if (template) {
+          bank.push(template);
+        }
+      }
+
+      if (edgeLabel && hebrewLabel) {
+        const template = createQuestionTemplate(
+          {
+            key: `cube-edge-letter:${normalizeId(edge?.id || edgeName)}`,
+            categoryId: "cube-hebrew-letter",
+            category: "Cube ↔ Hebrew",
+            promptByDifficulty: {
+              easy: `${edgeLabel} corresponds to which Hebrew letter`,
+              normal: `Which Hebrew letter is on ${edgeLabel}`,
+              hard: `${edgeLabel} letter`
+            },
+            answerByDifficulty: hebrewLabel
+          },
+          cubeHebrewLetterPool
+        );
+
+        if (template) {
+          bank.push(template);
+        }
+      }
+    });
+
+    if (cubeCenter) {
+      const centerTarot = normalizeOption(cubeCenter?.associations?.tarotCard || cubeCenter?.tarotCard);
+      const centerHebrew = hebrewById.get(normalizeId(cubeCenter?.hebrewLetterId));
+      const centerHebrewLabel = formatHebrewLetterLabel(centerHebrew, cubeCenter?.hebrewLetterId);
+
+      if (centerTarot) {
+        const template = createQuestionTemplate(
+          {
+            key: "tarot-cube-center",
+            categoryId: "tarot-cube-location",
+            category: "Tarot ↔ Cube",
+            promptByDifficulty: {
+              easy: `${centerTarot} is located at which Cube position`,
+              normal: `Where is ${centerTarot} on the Cube`,
+              hard: `${centerTarot} Cube location`
+            },
+            answerByDifficulty: "Center"
+          },
+          cubeLocationPool
+        );
+
+        if (template) {
+          bank.push(template);
+        }
+      }
+
+      if (centerHebrewLabel) {
+        const template = createQuestionTemplate(
+          {
+            key: "cube-center-letter",
+            categoryId: "cube-hebrew-letter",
+            category: "Cube ↔ Hebrew",
+            promptByDifficulty: {
+              easy: "The Cube center corresponds to which Hebrew letter",
+              normal: "Which Hebrew letter is at the Cube center",
+              hard: "Cube center letter"
+            },
+            answerByDifficulty: centerHebrewLabel
+          },
+          cubeHebrewLetterPool
+        );
+
+        if (template) {
+          bank.push(template);
+        }
+      }
+    }
+
+    playingCards.forEach((entry) => {
+      const cardId = String(entry?.id || "").trim();
+      const rankLabel = normalizeOption(entry?.rankLabel || entry?.rank);
+      const suitLabel = normalizeOption(entry?.suitLabel || labelFromId(entry?.suit));
+      const tarotCard = normalizeOption(entry?.tarotCard);
+
+      if (!cardId || !rankLabel || !suitLabel || !tarotCard) {
+        return;
+      }
+
+      const template = createQuestionTemplate(
+        {
+          key: `playing-card-tarot:${cardId}`,
+          categoryId: "playing-card-tarot",
+          category: "Playing Card ↔ Tarot",
+          promptByDifficulty: {
+            easy: `${rankLabel} of ${suitLabel} maps to which Tarot card`,
+            normal: `${rankLabel} of ${suitLabel} corresponds to`,
+            hard: `${rankLabel} of ${suitLabel} maps to`
+          },
+          answerByDifficulty: tarotCard
+        },
+        playingTarotPool
+      );
+
+      if (template) {
+        bank.push(template);
+      }
+    });
+
+    (dynamicCategoryRegistry || []).forEach(({ builder }) => {
+      try {
+        const dynamicTemplates = builder(referenceData, magickDataset);
+        if (Array.isArray(dynamicTemplates)) {
+          dynamicTemplates.forEach((template) => {
+            if (template) {
+              bank.push(template);
+            }
+          });
+        }
+      } catch (_error) {
+        // Skip broken plugins silently to preserve quiz availability.
+      }
+    });
+
+    return bank;
+  }
+
+  window.QuizQuestionBank = {
+    buildQuestionBank,
+    createQuestionTemplate,
+    normalizeKey,
+    normalizeOption,
+    toTitleCase,
+    toUniqueOptionList
+  };
+})();