@almadar/ui 5.35.0 → 5.37.0

package/dist/runtime/index.cjs

@@ -7,9 +7,6 @@ var tailwindMerge = require('tailwind-merge');
 var providers = require('@almadar/ui/providers');
 var logger = require('@almadar/logger');
 var LucideIcons2 = require('lucide-react');
-var PhosphorIcons = require('@phosphor-icons/react');
-var TablerIcons = require('@tabler/icons-react');
-var FaIcons = require('react-icons/fa');
 var reactDom = require('react-dom');
 var hooks = require('@almadar/ui/hooks');
 var evaluator = require('@almadar/evaluator');
@@ -70,9 +67,6 @@ function _interopNamespace(e) {
 
 var React82__namespace = /*#__PURE__*/_interopNamespace(React82);
 var LucideIcons2__namespace = /*#__PURE__*/_interopNamespace(LucideIcons2);
-var PhosphorIcons__namespace = /*#__PURE__*/_interopNamespace(PhosphorIcons);
-var TablerIcons__namespace = /*#__PURE__*/_interopNamespace(TablerIcons);
-var FaIcons__namespace = /*#__PURE__*/_interopNamespace(FaIcons);
 var ELK__default = /*#__PURE__*/_interopDefault(ELK);
 var SyntaxHighlighter__default = /*#__PURE__*/_interopDefault(SyntaxHighlighter);
 var dark__default = /*#__PURE__*/_interopDefault(dark);
@@ -578,6 +572,41 @@ function kebabToPascal(name) {
     return part.charAt(0).toUpperCase() + part.slice(1);
   }).join("");
 }
+function loadLib(key, importer) {
+  let p2 = libPromises.get(key);
+  if (!p2) {
+    p2 = importer().then((m) => m);
+    libPromises.set(key, p2);
+  }
+  return p2;
+}
+function lazyFamilyIcon(libKey, importer, pick, fallbackName, family) {
+  const Lazy = React82__namespace.default.lazy(async () => {
+    const lib = await loadLib(libKey, importer);
+    const Comp = pick(lib);
+    if (!Comp) {
+      warnFallback(fallbackName, family);
+      return { default: makeLucideAdapter(fallbackName, true) };
+    }
+    return { default: Comp };
+  });
+  const Wrapped = (props) => /* @__PURE__ */ jsxRuntime.jsx(
+    React82__namespace.default.Suspense,
+    {
+      fallback: /* @__PURE__ */ jsxRuntime.jsx(
+        "span",
+        {
+          "aria-hidden": true,
+          className: props.className,
+          style: { display: "inline-block", ...props.style }
+        }
+      ),
+      children: /* @__PURE__ */ jsxRuntime.jsx(Lazy, { ...props })
+    }
+  );
+  Wrapped.displayName = `Lazy.${libKey}.${fallbackName}`;
+  return Wrapped;
+}
 function resolveLucide(name) {
   if (lucideAliases[name]) return lucideAliases[name];
   const pascal = kebabToPascal(name);
@@ -588,60 +617,81 @@ function resolveLucide(name) {
   if (asIs && typeof asIs === "object") return asIs;
   return LucideIcons2__namespace.HelpCircle;
 }
-function resolvePhosphor(name, weight) {
+function resolvePhosphor(name, weight, family) {
   const target = phosphorAliases[name] ?? kebabToPascal(name);
-  const map = PhosphorIcons__namespace;
-  const PhosphorComp = map[target];
-  if (!PhosphorComp || typeof PhosphorComp !== "object") return null;
-  const Component = PhosphorComp;
-  const Adapter = (props) => /* @__PURE__ */ jsxRuntime.jsx(
-    Component,
-    {
-      weight,
-      className: props.className,
-      style: props.style,
-      size: props.size ?? "1em"
-    }
+  return lazyFamilyIcon(
+    "phosphor",
+    () => import('@phosphor-icons/react'),
+    (lib) => {
+      const PhosphorComp = lib[target];
+      if (!PhosphorComp || typeof PhosphorComp !== "object") return null;
+      const Component = PhosphorComp;
+      const Adapter = (props) => /* @__PURE__ */ jsxRuntime.jsx(
+        Component,
+        {
+          weight,
+          className: props.className,
+          style: props.style,
+          size: props.size ?? "1em"
+        }
+      );
+      Adapter.displayName = `Phosphor.${target}.${weight}`;
+      return Adapter;
+    },
+    name,
+    family
   );
-  Adapter.displayName = `Phosphor.${target}.${weight}`;
-  return Adapter;
 }
-function resolveTabler(name) {
+function resolveTabler(name, family) {
   const suffix = tablerAliases[name] ?? kebabToPascal(name);
   const target = `Icon${suffix}`;
-  const map = TablerIcons__namespace;
-  const TablerComp = map[target];
-  if (!TablerComp || typeof TablerComp !== "object") return null;
-  const Component = TablerComp;
-  const Adapter = (props) => /* @__PURE__ */ jsxRuntime.jsx(
-    Component,
-    {
-      stroke: props.strokeWidth ?? 1.5,
-      className: props.className,
-      style: props.style,
-      size: props.size ?? 24
-    }
+  return lazyFamilyIcon(
+    "tabler",
+    () => import('@tabler/icons-react'),
+    (lib) => {
+      const TablerComp = lib[target];
+      if (!TablerComp || typeof TablerComp !== "object") return null;
+      const Component = TablerComp;
+      const Adapter = (props) => /* @__PURE__ */ jsxRuntime.jsx(
+        Component,
+        {
+          stroke: props.strokeWidth ?? 1.5,
+          className: props.className,
+          style: props.style,
+          size: props.size ?? 24
+        }
+      );
+      Adapter.displayName = `Tabler.${target}`;
+      return Adapter;
+    },
+    name,
+    family
   );
-  Adapter.displayName = `Tabler.${target}`;
-  return Adapter;
 }
-function resolveFa(name) {
+function resolveFa(name, family) {
   const suffix = faAliases[name] ?? kebabToPascal(name);
   const target = `Fa${suffix}`;
-  const map = FaIcons__namespace;
-  const FaComp = map[target];
-  if (!FaComp || typeof FaComp !== "function") return null;
-  const Component = FaComp;
-  const Adapter = (props) => /* @__PURE__ */ jsxRuntime.jsx(
-    Component,
-    {
-      className: props.className,
-      style: props.style,
-      size: props.size ?? "1em"
-    }
+  return lazyFamilyIcon(
+    "fa",
+    () => import('react-icons/fa'),
+    (lib) => {
+      const FaComp = lib[target];
+      if (!FaComp || typeof FaComp !== "function") return null;
+      const Component = FaComp;
+      const Adapter = (props) => /* @__PURE__ */ jsxRuntime.jsx(
+        Component,
+        {
+          className: props.className,
+          style: props.style,
+          size: props.size ?? "1em"
+        }
+      );
+      Adapter.displayName = `Fa.${target}`;
+      return Adapter;
+    },
+    name,
+    family
   );
-  Adapter.displayName = `Fa.${target}`;
-  return Adapter;
 }
 function warnFallback(name, family) {
   const key = `${family}::${name}`;
@@ -675,39 +725,22 @@ function resolveIconForFamily(name, family) {
   switch (family) {
     case "lucide":
       return makeLucideAdapter(name, false);
-    case "phosphor-outline": {
-      const p2 = resolvePhosphor(name, "regular");
-      if (p2) return p2;
-      warnFallback(name, family);
-      return makeLucideAdapter(name, true);
-    }
-    case "phosphor-fill": {
-      const p2 = resolvePhosphor(name, "fill");
-      if (p2) return p2;
-      warnFallback(name, family);
-      return makeLucideAdapter(name, true);
-    }
-    case "phosphor-duotone": {
-      const p2 = resolvePhosphor(name, "duotone");
-      if (p2) return p2;
-      warnFallback(name, family);
-      return makeLucideAdapter(name, true);
-    }
-    case "tabler": {
-      const t = resolveTabler(name);
-      if (t) return t;
-      warnFallback(name, family);
-      return makeLucideAdapter(name, true);
-    }
-    case "fa-solid": {
-      const f3 = resolveFa(name);
-      if (f3) return f3;
-      warnFallback(name, family);
-      return makeLucideAdapter(name, true);
-    }
-  }
-}
-var DEFAULT_FAMILY, VALID_FAMILIES, cachedFamily, listeners, observer, lucideAliases, phosphorAliases, tablerAliases, faAliases, warned;
+    // Non-lucide families resolve to a lazy, Suspense-wrapped component that
+    // dynamic-imports the library on first render and falls back to lucide
+    // internally when the family lacks the icon (see lazyFamilyIcon).
+    case "phosphor-outline":
+      return resolvePhosphor(name, "regular", family);
+    case "phosphor-fill":
+      return resolvePhosphor(name, "fill", family);
+    case "phosphor-duotone":
+      return resolvePhosphor(name, "duotone", family);
+    case "tabler":
+      return resolveTabler(name, family);
+    case "fa-solid":
+      return resolveFa(name, family);
+  }
+}
+var DEFAULT_FAMILY, VALID_FAMILIES, cachedFamily, listeners, observer, libPromises, lucideAliases, phosphorAliases, tablerAliases, faAliases, warned;
 var init_iconFamily = __esm({
   "lib/iconFamily.tsx"() {
     "use client";
@@ -723,6 +756,7 @@ var init_iconFamily = __esm({
     cachedFamily = null;
     listeners = /* @__PURE__ */ new Set();
     observer = null;
+    libPromises = /* @__PURE__ */ new Map();
     lucideAliases = {
       close: LucideIcons2__namespace.X,
       trash: LucideIcons2__namespace.Trash2,
@@ -16988,61 +17022,53 @@ var init_Breadcrumb = __esm({
 function BuilderBoard({
   entity,
   completeEvent = "PUZZLE_COMPLETE",
+  placeEvent,
+  checkEvent,
+  playAgainEvent,
   className
 }) {
   const { emit } = useEventBus();
   const { t } = hooks.useTranslate();
   const resolved = boardEntity(entity);
-  const [placements, setPlacements] = React82.useState({});
   const [headerError, setHeaderError] = React82.useState(false);
-  const [submitted, setSubmitted] = React82.useState(false);
-  const [attempts, setAttempts] = React82.useState(0);
-  const [showHint, setShowHint] = React82.useState(false);
+  const [selectedComponent, setSelectedComponent] = React82.useState(null);
   const components = Array.isArray(resolved?.components) ? resolved.components : [];
   const slots = Array.isArray(resolved?.slots) ? resolved.slots : [];
+  const placements = {};
+  for (const slot of slots) {
+    if (slot.placedComponentId) placements[slot.id] = slot.placedComponentId;
+  }
+  const attempts = num(resolved?.attempts);
+  const result = str(resolved?.result) || "none";
+  const submitted = result === "win";
   const usedComponentIds = new Set(Object.values(placements));
   const availableComponents = components.filter((c) => !usedComponentIds.has(c.id));
-  const [selectedComponent, setSelectedComponent] = React82.useState(null);
-  const allPlaced = Object.keys(placements).length === slots.length;
+  const allPlaced = slots.length > 0 && slots.every((s) => Boolean(placements[s.id]));
   const results = submitted ? slots.map((slot) => ({
     slot,
     placed: placements[slot.id],
-    correct: placements[slot.id] === slot.acceptsComponentId
+    correct: placements[slot.id] === slot.requiredComponentId
   })) : [];
-  const allCorrect = results.length > 0 && results.every((r) => r.correct);
+  const showHint = attempts >= 2 && Boolean(str(resolved?.hint));
   const handlePlaceComponent = (slotId) => {
     if (submitted || !selectedComponent) return;
-    setPlacements((prev) => ({ ...prev, [slotId]: selectedComponent }));
+    if (placeEvent) emit(`UI:${placeEvent}`, { slotId, componentId: selectedComponent });
     setSelectedComponent(null);
   };
   const handleRemoveFromSlot = (slotId) => {
     if (submitted) return;
-    setPlacements((prev) => {
-      const next = { ...prev };
-      delete next[slotId];
-      return next;
-    });
+    if (placeEvent) emit(`UI:${placeEvent}`, { slotId, componentId: "" });
   };
-  const handleSubmit = React82.useCallback(() => {
-    setSubmitted(true);
-    setAttempts((a) => a + 1);
-    const correct = slots.every((slot) => placements[slot.id] === slot.acceptsComponentId);
-    if (correct) {
+  const handleSubmit = () => {
+    if (checkEvent) emit(`UI:${checkEvent}`, {});
+    const solved = slots.length > 0 && slots.every((s) => placements[s.id] === s.requiredComponentId);
+    if (solved && completeEvent) {
       emit(`UI:${completeEvent}`, { success: true, attempts: attempts + 1 });
     }
-  }, [slots, placements, attempts, completeEvent, emit]);
-  const handleReset = () => {
-    setSubmitted(false);
-    if (attempts >= 2 && str(resolved?.hint)) {
-      setShowHint(true);
-    }
   };
-  const handleFullReset = () => {
-    setPlacements({});
-    setSubmitted(false);
+  const handlePlayAgain = () => {
     setSelectedComponent(null);
-    setAttempts(0);
-    setShowHint(false);
+    if (playAgainEvent) emit(`UI:${playAgainEvent}`, {});
   };
   const getComponentById = (id) => components.find((c) => c.id === id);
   if (!resolved) return null;
@@ -17092,13 +17118,13 @@ function BuilderBoard({
           /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "small", weight: "bold", className: "uppercase tracking-wider text-muted-foreground", children: t("builder.blueprint") }),
           /* @__PURE__ */ jsxRuntime.jsx(VStack, { gap: "sm", children: slots.map((slot) => {
             const placedComp = placements[slot.id] ? getComponentById(placements[slot.id]) : null;
-            const result = results.find((r) => r.slot.id === slot.id);
+            const result2 = results.find((r) => r.slot.id === slot.id);
             return /* @__PURE__ */ jsxRuntime.jsxs(
               HStack,
               {
                 gap: "sm",
                 align: "center",
-                className: `p-3 border-2 rounded ${result ? result.correct ? "border-success" : "border-error" : selectedComponent ? "border-dashed border-foreground cursor-pointer" : "border-border"}`,
+                className: `p-3 border-2 rounded ${result2 ? result2.correct ? "border-success" : "border-error" : selectedComponent ? "border-dashed border-foreground cursor-pointer" : "border-border"}`,
                 onClick: () => handlePlaceComponent(slot.id),
                 children: [
                   /* @__PURE__ */ jsxRuntime.jsxs(VStack, { gap: "none", className: "flex-1", children: [
@@ -17113,7 +17139,7 @@ function BuilderBoard({
                       ] }) : null,
                       placedComp.label
                     ] }),
-                    result && /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: result.correct ? LucideIcons2.CheckCircle : LucideIcons2.XCircle, size: "sm", className: result.correct ? "text-success" : "text-error" })
+                    result2 && /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: result2.correct ? LucideIcons2.CheckCircle : LucideIcons2.XCircle, size: "sm", className: result2.correct ? "text-success" : "text-error" })
                   ] }) : /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "caption", className: "text-muted-foreground", children: t("builder.empty") })
                 ]
               },
@@ -17122,16 +17148,16 @@ function BuilderBoard({
           }) })
         ] }) }),
         submitted && /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-4", children: /* @__PURE__ */ jsxRuntime.jsxs(VStack, { gap: "sm", align: "center", children: [
-          /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: allCorrect ? LucideIcons2.CheckCircle : LucideIcons2.XCircle, size: "lg", className: allCorrect ? "text-success" : "text-error" }),
-          /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "body", weight: "bold", children: allCorrect ? str(resolved.successMessage) || t("builder.success") : str(resolved.failMessage) || t("builder.incorrect") })
+          /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: LucideIcons2.CheckCircle, size: "lg", className: "text-success" }),
+          /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "body", weight: "bold", children: str(resolved.successMessage) || t("builder.success") })
         ] }) }),
         showHint && hint && /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-4 border-l-4 border-l-warning", children: /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "body", children: hint }) }),
         /* @__PURE__ */ jsxRuntime.jsxs(HStack, { gap: "sm", justify: "center", children: [
-          !submitted ? /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "primary", onClick: handleSubmit, disabled: !allPlaced, children: [
+          !submitted && /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "primary", onClick: handleSubmit, disabled: !allPlaced, children: [
             /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: LucideIcons2.Wrench, size: "sm" }),
             t("builder.build")
-          ] }) : !allCorrect ? /* @__PURE__ */ jsxRuntime.jsx(Button, { variant: "primary", onClick: handleReset, children: t("builder.tryAgain") }) : null,
-          /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "secondary", onClick: handleFullReset, children: [
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "secondary", onClick: handlePlayAgain, children: [
             /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: LucideIcons2.RotateCcw, size: "sm" }),
             t("builder.reset")
           ] })
@@ -20587,57 +20613,84 @@ var init_ChartLegend = __esm({
 function ClassifierBoard({
   entity,
   completeEvent = "PUZZLE_COMPLETE",
+  assignEvent,
+  checkEvent,
+  playAgainEvent,
   className
 }) {
   const { emit } = useEventBus();
   const { t } = hooks.useTranslate();
   const resolved = boardEntity(entity);
-  const [assignments, setAssignments] = React82.useState({});
+  const [localAssignments, setLocalAssignments] = React82.useState({});
   const [headerError, setHeaderError] = React82.useState(false);
-  const [submitted, setSubmitted] = React82.useState(false);
-  const [attempts, setAttempts] = React82.useState(0);
+  const [localSubmitted, setLocalSubmitted] = React82.useState(false);
+  const [localAttempts, setLocalAttempts] = React82.useState(0);
   const [showHint, setShowHint] = React82.useState(false);
   const items = Array.isArray(resolved?.items) ? resolved.items : [];
   const categories = Array.isArray(resolved?.categories) ? resolved.categories : [];
+  const entityResult = str(resolved?.result);
+  const entityDrivesResult = entityResult.length > 0;
+  const entityHasAssignments = items.some((item) => item.assignedCategory != null);
+  const assignments = entityHasAssignments ? items.reduce((acc, item) => {
+    if (item.assignedCategory != null) acc[item.id] = item.assignedCategory;
+    return acc;
+  }, {}) : localAssignments;
+  const attempts = entityDrivesResult ? num(resolved?.attempts) : localAttempts;
+  const submitted = entityDrivesResult || localSubmitted;
   const unassignedItems = items.filter((item) => !assignments[item.id]);
-  const allAssigned = Object.keys(assignments).length === items.length;
+  const allAssigned = items.length > 0 && Object.keys(assignments).length === items.length;
   const results = submitted ? items.map((item) => ({
     item,
     assigned: assignments[item.id],
     correct: assignments[item.id] === item.correctCategory
   })) : [];
-  const allCorrect = results.length > 0 && results.every((r) => r.correct);
+  const allCorrect = entityDrivesResult ? entityResult === "success" : results.length > 0 && results.every((r) => r.correct);
   const correctCount = results.filter((r) => r.correct).length;
   const handleAssign = (itemId, categoryId) => {
     if (submitted) return;
-    setAssignments((prev) => ({ ...prev, [itemId]: categoryId }));
+    if (assignEvent) {
+      emit(`UI:${assignEvent}`, { itemId, categoryId });
+    }
+    if (!entityHasAssignments) {
+      setLocalAssignments((prev) => ({ ...prev, [itemId]: categoryId }));
+    }
   };
   const handleUnassign = (itemId) => {
     if (submitted) return;
-    setAssignments((prev) => {
-      const next = { ...prev };
-      delete next[itemId];
-      return next;
-    });
+    if (!entityHasAssignments) {
+      setLocalAssignments((prev) => {
+        const next = { ...prev };
+        delete next[itemId];
+        return next;
+      });
+    }
   };
   const handleSubmit = React82.useCallback(() => {
-    setSubmitted(true);
-    setAttempts((a) => a + 1);
-    const correct = items.every((item) => assignments[item.id] === item.correctCategory);
-    if (correct) {
-      emit(`UI:${completeEvent}`, { success: true, attempts: attempts + 1 });
+    if (checkEvent) {
+      emit(`UI:${checkEvent}`, {});
+    }
+    if (!entityDrivesResult) {
+      setLocalSubmitted(true);
+      setLocalAttempts((a) => a + 1);
+      const correct = items.every((item) => assignments[item.id] === item.correctCategory);
+      if (correct) {
+        emit(`UI:${completeEvent}`, { success: true, attempts: attempts + 1 });
+      }
     }
-  }, [items, assignments, attempts, completeEvent, emit]);
+  }, [checkEvent, entityDrivesResult, items, assignments, attempts, completeEvent, emit]);
   const handleReset = () => {
-    setSubmitted(false);
+    if (!entityDrivesResult) setLocalSubmitted(false);
     if (attempts >= 2 && str(resolved?.hint)) {
       setShowHint(true);
     }
   };
   const handleFullReset = () => {
-    setAssignments({});
-    setSubmitted(false);
-    setAttempts(0);
+    if (playAgainEvent) {
+      emit(`UI:${playAgainEvent}`, {});
+    }
+    setLocalAssignments({});
+    setLocalSubmitted(false);
+    setLocalAttempts(0);
     setShowHint(false);
   };
   if (!resolved) return null;
@@ -28520,13 +28573,13 @@ var init_MapView = __esm({
         shadowSize: [41, 41]
       });
       L.Marker.prototype.options.icon = defaultIcon;
-      const { useEffect: useEffect73, useRef: useRef67, useCallback: useCallback113, useState: useState107 } = React82__namespace.default;
+      const { useEffect: useEffect74, useRef: useRef68, useCallback: useCallback111, useState: useState107 } = React82__namespace.default;
       const { Typography: Typography2 } = await Promise.resolve().then(() => (init_Typography(), Typography_exports));
       const { useEventBus: useEventBus3 } = await Promise.resolve().then(() => (init_useEventBus(), useEventBus_exports));
       function MapUpdater({ centerLat, centerLng, zoom }) {
         const map = useMap();
-        const prevRef = useRef67({ centerLat, centerLng, zoom });
-        useEffect73(() => {
+        const prevRef = useRef68({ centerLat, centerLng, zoom });
+        useEffect74(() => {
           const prev = prevRef.current;
           if (prev.centerLat !== centerLat || prev.centerLng !== centerLng || prev.zoom !== zoom) {
             map.setView([centerLat, centerLng], zoom);
@@ -28537,7 +28590,7 @@ var init_MapView = __esm({
       }
       function MapClickHandler({ onMapClick }) {
         const map = useMap();
-        useEffect73(() => {
+        useEffect74(() => {
           if (!onMapClick) return;
           const handler = (e) => {
             onMapClick(e.latlng.lat, e.latlng.lng);
@@ -28566,7 +28619,7 @@ var init_MapView = __esm({
       }) {
         const eventBus = useEventBus3();
         const [clickedPosition, setClickedPosition] = useState107(null);
-        const handleMapClick = useCallback113((lat, lng) => {
+        const handleMapClick = useCallback111((lat, lng) => {
           if (showClickedPin) {
             setClickedPosition({ lat, lng });
           }
@@ -28575,7 +28628,7 @@ var init_MapView = __esm({
             eventBus.emit(`UI:${mapClickEvent}`, { latitude: lat, longitude: lng });
           }
         }, [onMapClick, mapClickEvent, eventBus, showClickedPin]);
-        const handleMarkerClick = useCallback113((marker) => {
+        const handleMarkerClick = useCallback111((marker) => {
           onMarkerClick?.(marker);
           if (markerClickEvent) {
             eventBus.emit(`UI:${markerClickEvent}`, { ...marker });
@@ -37797,51 +37850,52 @@ var init_DataTable = __esm({
 function DebuggerBoard({
   entity,
   completeEvent = "PUZZLE_COMPLETE",
+  toggleFlagEvent,
+  checkEvent,
+  playAgainEvent,
   className
 }) {
   const { emit } = useEventBus();
   const { t } = hooks.useTranslate();
   const resolved = boardEntity(entity);
-  const [flaggedLines, setFlaggedLines] = React82.useState(/* @__PURE__ */ new Set());
   const [headerError, setHeaderError] = React82.useState(false);
-  const [submitted, setSubmitted] = React82.useState(false);
-  const [attempts, setAttempts] = React82.useState(0);
   const [showHint, setShowHint] = React82.useState(false);
+  const lines = Array.isArray(resolved?.lines) ? resolved.lines : [];
+  const result = resolved?.result ?? null;
+  const attempts = num(resolved?.attempts);
+  const submitted = result != null;
+  const bugLines = lines.filter((l) => l.isBug);
+  const flaggedLines = lines.filter((l) => l.isFlagged);
+  const correctFlags = lines.filter((l) => l.isBug && l.isFlagged);
+  const falseFlags = lines.filter((l) => !l.isBug && l.isFlagged);
+  const allCorrect = result === "win";
   const toggleLine = (lineId) => {
     if (submitted) return;
-    setFlaggedLines((prev) => {
-      const next = new Set(prev);
-      if (next.has(lineId)) {
-        next.delete(lineId);
-      } else {
-        next.add(lineId);
-      }
-      return next;
-    });
+    if (toggleFlagEvent) {
+      emit(`UI:${toggleFlagEvent}`, { lineId });
+    }
   };
-  const lines = Array.isArray(resolved?.lines) ? resolved.lines : [];
-  const bugLines = lines.filter((l) => l.isBug);
-  const correctFlags = lines.filter((l) => l.isBug && flaggedLines.has(l.id));
-  const falseFlags = lines.filter((l) => !l.isBug && flaggedLines.has(l.id));
-  const allCorrect = submitted && correctFlags.length === bugLines.length && falseFlags.length === 0;
   const handleSubmit = React82.useCallback(() => {
-    setSubmitted(true);
-    setAttempts((a) => a + 1);
+    if (checkEvent) {
+      emit(`UI:${checkEvent}`, {});
+    }
     const correct = correctFlags.length === bugLines.length && falseFlags.length === 0;
     if (correct) {
       emit(`UI:${completeEvent}`, { success: true, attempts: attempts + 1 });
     }
-  }, [correctFlags.length, bugLines.length, falseFlags.length, attempts, completeEvent, emit]);
+  }, [checkEvent, correctFlags.length, bugLines.length, falseFlags.length, attempts, completeEvent, emit]);
   const handleReset = () => {
-    setSubmitted(false);
+    if (playAgainEvent) {
+      emit(`UI:${playAgainEvent}`, {});
+    }
     if (attempts >= 2 && str(resolved?.hint)) {
       setShowHint(true);
     }
   };
   const handleFullReset = () => {
-    setFlaggedLines(/* @__PURE__ */ new Set());
-    setSubmitted(false);
-    setAttempts(0);
+    if (playAgainEvent) {
+      emit(`UI:${playAgainEvent}`, {});
+    }
     setShowHint(false);
   };
   if (!resolved) return null;
@@ -37869,7 +37923,7 @@ function DebuggerBoard({
           /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "caption", className: "text-muted-foreground", children: t("debugger.findBugs", { count: String(num(resolved.bugCount)) }) })
         ] }) }),
         /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-0 overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsx(VStack, { gap: "none", children: lines.map((line, i) => {
-          const isFlagged = flaggedLines.has(line.id);
+          const isFlagged = !!line.isFlagged;
           let lineStyle = "";
           if (submitted) {
             if (line.isBug && isFlagged) lineStyle = "bg-success/10";
@@ -37903,9 +37957,9 @@ function DebuggerBoard({
             /* @__PURE__ */ jsxRuntime.jsx(
               Icon,
               {
-                icon: flaggedLines.has(line.id) ? LucideIcons2.CheckCircle : LucideIcons2.XCircle,
+                icon: line.isFlagged ? LucideIcons2.CheckCircle : LucideIcons2.XCircle,
                 size: "xs",
-                className: flaggedLines.has(line.id) ? "text-success mt-0.5" : "text-warning mt-0.5"
+                className: line.isFlagged ? "text-success mt-0.5" : "text-warning mt-0.5"
               }
             ),
             /* @__PURE__ */ jsxRuntime.jsxs(VStack, { gap: "none", children: [
@@ -37916,7 +37970,7 @@ function DebuggerBoard({
         ] }) }),
         showHint && hint && /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-4 border-l-4 border-l-warning", children: /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "body", children: hint }) }),
         /* @__PURE__ */ jsxRuntime.jsxs(HStack, { gap: "sm", justify: "center", children: [
-          !submitted ? /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "primary", onClick: handleSubmit, disabled: flaggedLines.size === 0, children: [
+          !submitted ? /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "primary", onClick: handleSubmit, disabled: flaggedLines.length === 0, children: [
             /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: LucideIcons2.Send, size: "sm" }),
             t("debugger.submit")
           ] }) : !allCorrect ? /* @__PURE__ */ jsxRuntime.jsx(Button, { variant: "primary", onClick: handleReset, children: t("debugger.tryAgain") }) : null,
@@ -41680,6 +41734,9 @@ function getOpponentAction(strategy, actions, history) {
 function NegotiatorBoard({
   entity,
   completeEvent = "PUZZLE_COMPLETE",
+  playRoundEvent,
+  finishEvent,
+  playAgainEvent,
   className
 }) {
   const { emit } = useEventBus();
@@ -41688,13 +41745,14 @@ function NegotiatorBoard({
   const [history, setHistory] = React82.useState([]);
   const [headerError, setHeaderError] = React82.useState(false);
   const [showHint, setShowHint] = React82.useState(false);
-  const totalRounds = num(resolved?.totalRounds);
+  const totalRounds = num(resolved?.maxRounds);
   const targetScore = num(resolved?.targetScore);
-  const currentRound = history.length;
-  const isComplete = currentRound >= totalRounds;
-  const playerTotal = history.reduce((s, r) => s + r.playerPayoff, 0);
+  const currentRound = num(resolved?.round);
+  const result = str(resolved?.result) || "none";
+  const playerTotal = num(resolved?.score);
+  const isComplete = result !== "none" || totalRounds > 0 && currentRound >= totalRounds;
+  const won = result === "win";
   const opponentTotal = history.reduce((s, r) => s + r.opponentPayoff, 0);
-  const won = isComplete && playerTotal >= targetScore;
   const actions = Array.isArray(resolved?.actions) ? resolved.actions : [];
   const payoffMatrix = Array.isArray(resolved?.payoffMatrix) ? resolved.payoffMatrix : [];
   const handleAction = React82.useCallback((actionId) => {
@@ -41703,29 +41761,45 @@ function NegotiatorBoard({
     const payoff = payoffMatrix.find(
       (p2) => p2.playerAction === actionId && p2.opponentAction === opponentAction
     );
-    const result = {
-      round: currentRound + 1,
-      playerAction: actionId,
-      opponentAction,
-      playerPayoff: payoff?.playerPayoff ?? 0,
-      opponentPayoff: payoff?.opponentPayoff ?? 0
-    };
-    const newHistory = [...history, result];
-    setHistory(newHistory);
-    if (newHistory.length >= totalRounds) {
-      const total = newHistory.reduce((s, r) => s + r.playerPayoff, 0);
-      if (total >= targetScore) {
-        emit(`UI:${completeEvent}`, { success: true, score: total });
-      }
-      if (newHistory.length >= 3 && str(resolved?.hint)) {
+    const playerPayoff = payoff?.playerPayoff ?? 0;
+    setHistory((prev) => [
+      ...prev,
+      {
+        round: prev.length + 1,
+        playerAction: actionId,
+        opponentAction,
+        playerPayoff,
+        opponentPayoff: payoff?.opponentPayoff ?? 0
+      }
+    ]);
+    if (playRoundEvent) {
+      emit(`UI:${playRoundEvent}`, { playerAction: actionId, payoff: playerPayoff });
+    }
+    if (totalRounds > 0 && currentRound + 1 >= totalRounds) {
+      if (finishEvent) {
+        emit(`UI:${finishEvent}`, {});
+      }
+      if (str(resolved?.hint)) {
         setShowHint(true);
       }
     }
-  }, [isComplete, resolved, totalRounds, targetScore, actions, payoffMatrix, history, currentRound, completeEvent, emit]);
-  const handleReset = () => {
+  }, [isComplete, resolved, totalRounds, currentRound, actions, payoffMatrix, history, playRoundEvent, finishEvent, emit]);
+  const handleReset = React82.useCallback(() => {
     setHistory([]);
     setShowHint(false);
-  };
+    if (playAgainEvent) {
+      emit(`UI:${playAgainEvent}`, {});
+    }
+  }, [playAgainEvent, emit]);
+  const completedRef = React82.useRef(false);
+  React82.useEffect(() => {
+    if (result === "win" && !completedRef.current) {
+      completedRef.current = true;
+      emit(`UI:${completeEvent}`, { success: true, score: playerTotal });
+    } else if (result === "none") {
+      completedRef.current = false;
+    }
+  }, [result, playerTotal, completeEvent, emit]);
   const getActionLabel = (id) => actions.find((a) => a.id === id)?.label ?? id;
   if (!resolved) return null;
   const theme = resolved.theme ?? void 0;
@@ -44691,67 +44765,47 @@ var init_SimulationGraph = __esm({
 function SimulatorBoard({
   entity,
   completeEvent = "PUZZLE_COMPLETE",
+  setAEvent,
+  setBEvent,
+  checkEvent,
+  playAgainEvent,
   className
 }) {
   const { emit } = useEventBus();
   const { t } = hooks.useTranslate();
   const resolved = boardEntity(entity);
   const parameters = Array.isArray(resolved?.parameters) ? resolved.parameters : [];
-  const [values, setValues] = React82.useState(() => {
-    const init = {};
-    for (const p2 of parameters) {
-      init[p2.id] = p2.initial;
-    }
-    return init;
-  });
   const [headerError, setHeaderError] = React82.useState(false);
-  const [submitted, setSubmitted] = React82.useState(false);
-  const [attempts, setAttempts] = React82.useState(0);
-  const [showHint, setShowHint] = React82.useState(false);
-  const computeOutput = React82.useCallback((params) => {
-    try {
-      const fn = new Function("params", `return (${str(resolved?.computeExpression)})`);
-      return fn(params);
-    } catch {
-      return 0;
-    }
-  }, [resolved?.computeExpression]);
-  const output = React82.useMemo(() => computeOutput(values) ?? 0, [computeOutput, values]);
-  const targetValue = num(resolved?.targetValue);
-  const targetTolerance = num(resolved?.targetTolerance);
-  const isCorrect = Math.abs(output - targetValue) <= targetTolerance;
-  const handleParameterChange = (id, value) => {
-    if (submitted) return;
-    setValues((prev) => ({ ...prev, [id]: value }));
-  };
-  const handleSubmit = () => {
-    setSubmitted(true);
-    setAttempts((a) => a + 1);
-    if (isCorrect) {
-      emit(`UI:${completeEvent}`, { success: true, attempts: attempts + 1 });
-    }
+  if (!resolved) return null;
+  const paramA = num(resolved.paramA);
+  const paramB = num(resolved.paramB);
+  const output = num(resolved.output);
+  const targetValue = num(resolved.target);
+  const targetTolerance = num(resolved.tolerance);
+  const attempts = num(resolved.attempts);
+  const result = str(resolved.result);
+  const isWin = result === "win";
+  const isComplete = result !== "none" && result !== "";
+  const paramAValue = parameters[0];
+  const paramBValue = parameters[1];
+  const sliderValues = [paramA, paramB];
+  const sliderEvents = [setAEvent, setBEvent];
+  const handleParameterChange = (index, value) => {
+    if (isComplete) return;
+    const ev = sliderEvents[index];
+    if (ev) emit(`UI:${ev}`, { value });
   };
-  const handleReset = () => {
-    setSubmitted(false);
-    if (attempts >= 2 && str(resolved?.hint)) {
-      setShowHint(true);
-    }
+  const handleCheck = () => {
+    if (checkEvent) emit(`UI:${checkEvent}`, {});
   };
-  const handleFullReset = () => {
-    const init = {};
-    for (const p2 of parameters) {
-      init[p2.id] = p2.initial;
-    }
-    setValues(init);
-    setSubmitted(false);
-    setAttempts(0);
-    setShowHint(false);
+  const handlePlayAgain = () => {
+    if (playAgainEvent) emit(`UI:${playAgainEvent}`, {});
   };
-  if (!resolved) return null;
   const theme = resolved.theme ?? void 0;
   const themeBackground = theme?.background;
   const headerImage = str(resolved.headerImage);
   const hint = str(resolved.hint);
+  const showHint = isComplete && !isWin && attempts >= 2 && Boolean(hint);
   const outputLabel = str(resolved.outputLabel);
   const outputUnit = str(resolved.outputUnit);
   return /* @__PURE__ */ jsxRuntime.jsx(
@@ -44771,41 +44825,43 @@ function SimulatorBoard({
         ] }) }),
         /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-4", children: /* @__PURE__ */ jsxRuntime.jsxs(VStack, { gap: "md", children: [
           /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "small", weight: "bold", className: "uppercase tracking-wider text-muted-foreground", children: t("simulator.parameters") }),
-          parameters.map((param) => /* @__PURE__ */ jsxRuntime.jsxs(VStack, { gap: "xs", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs(HStack, { justify: "between", align: "center", children: [
-              /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "body", weight: "medium", children: param.label }),
-              /* @__PURE__ */ jsxRuntime.jsxs(Badge, { size: "sm", children: [
-                values[param.id],
-                " ",
-                param.unit
-              ] })
-            ] }),
-            /* @__PURE__ */ jsxRuntime.jsx(
-              "input",
-              {
-                type: "range",
-                min: param.min,
-                max: param.max,
-                step: param.step,
-                value: values[param.id],
-                onChange: (e) => handleParameterChange(param.id, Number(e.target.value)),
-                disabled: submitted,
-                className: "w-full accent-foreground"
-              }
-            ),
-            /* @__PURE__ */ jsxRuntime.jsxs(HStack, { justify: "between", children: [
-              /* @__PURE__ */ jsxRuntime.jsxs(Typography, { variant: "caption", className: "text-muted-foreground", children: [
-                param.min,
-                " ",
-                param.unit
+          [paramAValue, paramBValue].map(
+            (param, index) => param ? /* @__PURE__ */ jsxRuntime.jsxs(VStack, { gap: "xs", children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(HStack, { justify: "between", align: "center", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "body", weight: "medium", children: param.label }),
+                /* @__PURE__ */ jsxRuntime.jsxs(Badge, { size: "sm", children: [
+                  sliderValues[index],
+                  " ",
+                  param.unit
+                ] })
               ] }),
-              /* @__PURE__ */ jsxRuntime.jsxs(Typography, { variant: "caption", className: "text-muted-foreground", children: [
-                param.max,
-                " ",
-                param.unit
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "input",
+                {
+                  type: "range",
+                  min: param.min,
+                  max: param.max,
+                  step: param.step,
+                  value: sliderValues[index],
+                  onChange: (e) => handleParameterChange(index, Number(e.target.value)),
+                  disabled: isComplete,
+                  className: "w-full accent-foreground"
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsxs(HStack, { justify: "between", children: [
+                /* @__PURE__ */ jsxRuntime.jsxs(Typography, { variant: "caption", className: "text-muted-foreground", children: [
+                  param.min,
+                  " ",
+                  param.unit
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsxs(Typography, { variant: "caption", className: "text-muted-foreground", children: [
+                  param.max,
+                  " ",
+                  param.unit
+                ] })
               ] })
-            ] })
-          ] }, param.id))
+            ] }, param.id ?? index) : null
+          )
         ] }) }),
         /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-4", children: /* @__PURE__ */ jsxRuntime.jsxs(VStack, { gap: "sm", align: "center", children: [
           /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "small", weight: "bold", className: "uppercase tracking-wider text-muted-foreground", children: outputLabel }),
@@ -44814,9 +44870,9 @@ function SimulatorBoard({
             " ",
             outputUnit
           ] }),
-          submitted && /* @__PURE__ */ jsxRuntime.jsxs(HStack, { gap: "xs", align: "center", children: [
-            /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: isCorrect ? LucideIcons2.CheckCircle : LucideIcons2.XCircle, size: "sm", className: isCorrect ? "text-success" : "text-error" }),
-            /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "body", className: isCorrect ? "text-success" : "text-error", children: isCorrect ? str(resolved.successMessage) || t("simulator.correct") : str(resolved.failMessage) || t("simulator.incorrect") })
+          isComplete && /* @__PURE__ */ jsxRuntime.jsxs(HStack, { gap: "xs", align: "center", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: isWin ? LucideIcons2.CheckCircle : LucideIcons2.XCircle, size: "sm", className: isWin ? "text-success" : "text-error" }),
+            /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "body", className: isWin ? "text-success" : "text-error", children: isWin ? str(resolved.successMessage) || t("simulator.correct") : str(resolved.failMessage) || t("simulator.incorrect") })
           ] }),
           /* @__PURE__ */ jsxRuntime.jsxs(Typography, { variant: "caption", className: "text-muted-foreground", children: [
             t("simulator.target"),
@@ -44831,11 +44887,11 @@ function SimulatorBoard({
         ] }) }),
         showHint && hint && /* @__PURE__ */ jsxRuntime.jsx(Card, { className: "p-4 border-l-4 border-l-warning", children: /* @__PURE__ */ jsxRuntime.jsx(Typography, { variant: "body", children: hint }) }),
         /* @__PURE__ */ jsxRuntime.jsxs(HStack, { gap: "sm", justify: "center", children: [
-          !submitted ? /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "primary", onClick: handleSubmit, children: [
+          !isComplete ? /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "primary", onClick: handleCheck, children: [
             /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: LucideIcons2.Play, size: "sm" }),
             t("simulator.simulate")
-          ] }) : !isCorrect ? /* @__PURE__ */ jsxRuntime.jsx(Button, { variant: "primary", onClick: handleReset, children: t("simulator.tryAgain") }) : null,
-          /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "secondary", onClick: handleFullReset, children: [
+          ] }) : null,
+          /* @__PURE__ */ jsxRuntime.jsxs(Button, { variant: "secondary", onClick: handlePlayAgain, children: [
             /* @__PURE__ */ jsxRuntime.jsx(Icon, { icon: LucideIcons2.RotateCcw, size: "sm" }),
             t("simulator.reset")
           ] })