koin.js 1.0.16 → 1.1.16

package/dist/index.js

@@ -334,9 +334,11 @@ var en = {
     cheats: "Cheats",
     retroAchievements: "RetroAchievements",
     shortcuts: "Shortcuts",
-    exit: "Exit",
+    exit: "Exit Game",
     language: "Language",
-    selectLanguage: "Select Language"
+    selectLanguage: "Select Language",
+    haptics: "Haptic Feedback",
+    enableHaptics: "Vibration"
   },
   overlay: {
     play: "PLAY",
@@ -413,13 +415,16 @@ var en = {
     },
     cheats: {
       title: "Cheats",
-      addCheat: "Add Cheat",
-      available: "{{count}} cheat{{s}} available",
-      emptyTitle: "No cheats available",
-      emptyDesc: "No cheat codes found for this game",
-      copy: "Copy code",
-      active: "{{count}} cheat{{s}} active",
-      toggleHint: "Click a cheat to toggle it on/off"
+      addCheat: "Add Manual Cheat",
+      available: "Available Cheats",
+      emptyTitle: "No Cheats Available",
+      emptyDesc: "This game does not have any known cheats.",
+      copy: "Copy",
+      active: "Active",
+      toggleHint: "Click to toggle",
+      codePlaceholder: "Enter cheat code (e.g. 00C-048-E6E)",
+      descPlaceholder: "Cheat description (optional)",
+      add: "Add Cheat"
     },
     saveSlots: {
       title: "Save States",
@@ -2592,7 +2597,8 @@ function useTouchHandlers({
   onPress,
   onPressDown,
   onRelease,
-  onPositionChange
+  onPositionChange,
+  hapticsEnabled = true
 }) {
   const isDraggingRef = React2.useRef(false);
   const drag = useDrag({
@@ -2618,7 +2624,7 @@ function useTouchHandlers({
       const touch = e.touches[0];
       e.preventDefault();
       e.stopPropagation();
-      if (navigator.vibrate) {
+      if (hapticsEnabled && navigator.vibrate) {
         navigator.vibrate(8);
       }
       if (isSystemButton) {
@@ -2855,7 +2861,11 @@ var VirtualButton = React2__default.default.memo(function VirtualButton2({
   customPosition,
   onPositionChange,
   isLandscape = false,
-  console: console2 = ""
+  console: console2 = "",
+  hapticsEnabled = true,
+  mode = "normal",
+  isHeld = false,
+  isInTurbo = false
 }) {
   const t = useKoinTranslation();
   const buttonRef = React2.useRef(null);
@@ -2882,7 +2892,9 @@ var VirtualButton = React2__default.default.memo(function VirtualButton2({
     onPress,
     onPressDown,
     onRelease,
-    onPositionChange
+    onPositionChange,
+    hapticsEnabled
+    // Pass haptics setting
   });
   useTouchEvents(buttonRef, {
     onTouchStart: handleTouchStart,
@@ -2910,7 +2922,7 @@ var VirtualButton = React2__default.default.memo(function VirtualButton2({
       width = `${config.size * 2}px`;
     }
   }
-  return /* @__PURE__ */ jsxRuntime.jsx(
+  return /* @__PURE__ */ jsxRuntime.jsxs(
     "button",
     {
       ref: buttonRef,
@@ -2950,48 +2962,364 @@ var VirtualButton = React2__default.default.memo(function VirtualButton2({
       },
       "aria-label": label,
       onContextMenu: (e) => e.preventDefault(),
-      children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "drop-shadow-md", children: label })
+      children: [
+        (mode !== "normal" || isHeld || isInTurbo) && /* @__PURE__ */ jsxRuntime.jsx(
+          "span",
+          {
+            className: "absolute -top-1 -right-1 rounded-full flex items-center justify-center",
+            style: {
+              width: "16px",
+              height: "16px",
+              backgroundColor: isHeld ? "#22c55e" : isInTurbo ? "#fbbf24" : "rgba(255,255,255,0.2)",
+              animation: isInTurbo ? "pulse 0.5s infinite" : "none"
+            },
+            children: isHeld ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Hand, { size: 10, color: "white", strokeWidth: 3 }) : isInTurbo ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Zap, { size: 10, color: "white", fill: "white" }) : mode === "hold" ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Hand, { size: 10, color: "white" }) : mode === "turbo" ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Zap, { size: 10, color: "white" }) : null
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "drop-shadow-md", children: label })
+      ]
     }
   );
 });
 var VirtualButton_default = VirtualButton;
+var CENTER_TOUCH_RADIUS = 0.35;
+var Dpad = React2__default.default.memo(function Dpad2({
+  size = 180,
+  x,
+  y,
+  containerWidth,
+  containerHeight,
+  systemColor = "#00FF41",
+  isLandscape = false,
+  customPosition,
+  onPositionChange,
+  hapticsEnabled = true,
+  onButtonDown,
+  onButtonUp
+}) {
+  const dpadRef = React2.useRef(null);
+  const activeTouchRef = React2.useRef(null);
+  const activeDirectionsRef = React2.useRef(/* @__PURE__ */ new Set());
+  const upPathRef = React2.useRef(null);
+  const downPathRef = React2.useRef(null);
+  const leftPathRef = React2.useRef(null);
+  const rightPathRef = React2.useRef(null);
+  const centerCircleRef = React2.useRef(null);
+  const displayX = customPosition ? customPosition.x : x;
+  const displayY = customPosition ? customPosition.y : y;
+  const releaseAllDirections = React2.useCallback(() => {
+    activeDirectionsRef.current.forEach((dir) => onButtonUp(dir));
+    activeDirectionsRef.current = /* @__PURE__ */ new Set();
+  }, [onButtonUp]);
+  const drag = useDrag({
+    elementSize: size,
+    displayX,
+    displayY,
+    containerWidth,
+    containerHeight,
+    onPositionChange,
+    centerThreshold: CENTER_TOUCH_RADIUS,
+    onDragStart: () => {
+      releaseAllDirections();
+      updateVisuals(/* @__PURE__ */ new Set());
+    }
+  });
+  const getDirectionsFromTouch = React2.useCallback((touchX, touchY, rect) => {
+    const centerX = rect.left + rect.width / 2;
+    const centerY = rect.top + rect.height / 2;
+    const dx = touchX - centerX;
+    const dy = touchY - centerY;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const deadZone = rect.width / 2 * 0.15;
+    if (distance < deadZone) return /* @__PURE__ */ new Set();
+    const directions = /* @__PURE__ */ new Set();
+    const angle = Math.atan2(dy, dx) * (180 / Math.PI);
+    if (angle >= -150 && angle <= -30) directions.add("up");
+    if (angle >= 30 && angle <= 150) directions.add("down");
+    if (angle >= 120 || angle <= -120) directions.add("left");
+    if (angle >= -60 && angle <= 60) directions.add("right");
+    return directions;
+  }, []);
+  const updateVisuals = React2.useCallback((directions) => {
+    const activeFill = `${systemColor}80`;
+    const inactiveFill = "rgba(255, 255, 255, 0.05)";
+    const activeStroke = systemColor;
+    const inactiveStroke = "rgba(255, 255, 255, 0.2)";
+    const glow = `0 0 15px ${systemColor}`;
+    const updatePart = (ref, isActive) => {
+      if (ref.current) {
+        ref.current.style.fill = isActive ? activeFill : inactiveFill;
+        ref.current.style.stroke = isActive ? activeStroke : inactiveStroke;
+        ref.current.style.filter = isActive ? `drop-shadow(${glow})` : "none";
+        ref.current.style.transform = isActive ? "scale(0.98)" : "scale(1)";
+        ref.current.style.transformOrigin = "center";
+      }
+    };
+    updatePart(upPathRef, directions.has("up"));
+    updatePart(downPathRef, directions.has("down"));
+    updatePart(leftPathRef, directions.has("left"));
+    updatePart(rightPathRef, directions.has("right"));
+    if (centerCircleRef.current) {
+      const isAny = directions.size > 0;
+      centerCircleRef.current.style.fill = isAny ? systemColor : "rgba(0,0,0,0.5)";
+      centerCircleRef.current.style.stroke = isAny ? "#fff" : "rgba(255,255,255,0.3)";
+    }
+  }, [systemColor]);
+  const updateDirections = React2.useCallback((newDirections) => {
+    const prev = activeDirectionsRef.current;
+    prev.forEach((dir) => {
+      if (!newDirections.has(dir)) {
+        onButtonUp(dir);
+      }
+    });
+    newDirections.forEach((dir) => {
+      if (!prev.has(dir)) {
+        if (hapticsEnabled && navigator.vibrate) navigator.vibrate(5);
+        onButtonDown(dir);
+      }
+    });
+    activeDirectionsRef.current = newDirections;
+    updateVisuals(newDirections);
+  }, [updateVisuals, onButtonDown, onButtonUp, hapticsEnabled]);
+  const handleTouchStart = React2.useCallback((e) => {
+    e.preventDefault();
+    if (activeTouchRef.current !== null) return;
+    const touch = e.changedTouches[0];
+    activeTouchRef.current = touch.identifier;
+    const rect = dpadRef.current?.getBoundingClientRect();
+    if (!rect) return;
+    if (onPositionChange) {
+      drag.checkDragStart(touch.clientX, touch.clientY, rect);
+    }
+    if (!drag.isDragging) {
+      updateDirections(getDirectionsFromTouch(touch.clientX, touch.clientY, rect));
+    }
+  }, [getDirectionsFromTouch, updateDirections, onPositionChange, drag]);
+  const handleTouchMove = React2.useCallback((e) => {
+    e.preventDefault();
+    let touch = null;
+    for (let i = 0; i < e.changedTouches.length; i++) {
+      if (e.changedTouches[i].identifier === activeTouchRef.current) {
+        touch = e.changedTouches[i];
+        break;
+      }
+    }
+    if (!touch) return;
+    if (drag.isDragging) {
+      drag.handleDragMove(touch.clientX, touch.clientY);
+    } else if (onPositionChange) {
+      const startedDrag = drag.checkMoveThreshold(touch.clientX, touch.clientY);
+      if (!startedDrag) {
+        drag.clearDragTimer();
+        const rect = dpadRef.current?.getBoundingClientRect();
+        if (rect) {
+          updateDirections(getDirectionsFromTouch(touch.clientX, touch.clientY, rect));
+        }
+      }
+    } else {
+      const rect = dpadRef.current?.getBoundingClientRect();
+      if (rect) {
+        updateDirections(getDirectionsFromTouch(touch.clientX, touch.clientY, rect));
+      }
+    }
+  }, [drag, getDirectionsFromTouch, updateDirections, onPositionChange]);
+  const handleTouchEnd = React2.useCallback((e) => {
+    e.preventDefault();
+    drag.clearDragTimer();
+    let touchEnded = false;
+    for (let i = 0; i < e.changedTouches.length; i++) {
+      if (e.changedTouches[i].identifier === activeTouchRef.current) {
+        touchEnded = true;
+        break;
+      }
+    }
+    if (touchEnded) {
+      activeTouchRef.current = null;
+      if (drag.isDragging) {
+        drag.handleDragEnd();
+      } else {
+        activeDirectionsRef.current.forEach((dir) => onButtonUp(dir));
+        activeDirectionsRef.current = /* @__PURE__ */ new Set();
+        updateVisuals(/* @__PURE__ */ new Set());
+      }
+    }
+  }, [updateVisuals, drag, onButtonUp]);
+  useTouchEvents(dpadRef, {
+    onTouchStart: handleTouchStart,
+    onTouchMove: handleTouchMove,
+    onTouchEnd: handleTouchEnd,
+    onTouchCancel: handleTouchEnd
+  }, { cleanup: drag.clearDragTimer });
+  const leftPx = displayX / 100 * containerWidth - size / 2;
+  const topPx = displayY / 100 * containerHeight - size / 2;
+  const dUp = "M 35,5 L 65,5 L 65,35 L 50,50 L 35,35 Z";
+  const dRight = "M 65,35 L 95,35 L 95,65 L 65,65 L 50,50 Z";
+  const dDown = "M 65,65 L 65,95 L 35,95 L 35,65 L 50,50 Z";
+  const dLeft = "M 35,65 L 5,65 L 5,35 L 35,35 L 50,50 Z";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref: dpadRef,
+      className: `absolute pointer-events-auto touch-manipulation select-none ${drag.isDragging ? "opacity-60" : ""}`,
+      style: {
+        top: 0,
+        left: 0,
+        transform: `translate3d(${leftPx}px, ${topPx}px, 0)${drag.isDragging ? " scale(1.05)" : ""}`,
+        width: size,
+        height: size,
+        opacity: isLandscape ? 0.75 : 0.9,
+        WebkitTouchCallout: "none",
+        WebkitUserSelect: "none",
+        touchAction: "none",
+        transition: drag.isDragging ? "none" : "transform 0.1s ease-out"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: `absolute inset-0 rounded-full bg-black/40 backdrop-blur-md border shadow-lg ${drag.isDragging ? "border-white/50 ring-2 ring-white/30" : "border-white/10"}` }),
+        /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "100%", height: "100%", viewBox: "0 0 100 100", className: "drop-shadow-xl relative z-10", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("path", { ref: upPathRef, d: dUp, fill: "rgba(255,255,255,0.05)", stroke: "rgba(255,255,255,0.2)", strokeWidth: "1", className: "transition-all duration-75" }),
+          /* @__PURE__ */ jsxRuntime.jsx("path", { ref: rightPathRef, d: dRight, fill: "rgba(255,255,255,0.05)", stroke: "rgba(255,255,255,0.2)", strokeWidth: "1", className: "transition-all duration-75" }),
+          /* @__PURE__ */ jsxRuntime.jsx("path", { ref: downPathRef, d: dDown, fill: "rgba(255,255,255,0.05)", stroke: "rgba(255,255,255,0.2)", strokeWidth: "1", className: "transition-all duration-75" }),
+          /* @__PURE__ */ jsxRuntime.jsx("path", { ref: leftPathRef, d: dLeft, fill: "rgba(255,255,255,0.05)", stroke: "rgba(255,255,255,0.2)", strokeWidth: "1", className: "transition-all duration-75" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "circle",
+            {
+              ref: centerCircleRef,
+              cx: "50",
+              cy: "50",
+              r: "12",
+              fill: drag.isDragging ? systemColor : "rgba(0,0,0,0.5)",
+              stroke: drag.isDragging ? "#fff" : "rgba(255,255,255,0.3)",
+              strokeWidth: drag.isDragging ? 2 : 1
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M 50,15 L 50,25 M 45,20 L 50,15 L 55,20", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", fill: "none", opacity: "0.8", pointerEvents: "none" }),
+          /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M 50,85 L 50,75 M 45,80 L 50,85 L 55,80", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", fill: "none", opacity: "0.8", pointerEvents: "none" }),
+          /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M 15,50 L 25,50 M 20,45 L 15,50 L 20,55", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", fill: "none", opacity: "0.8", pointerEvents: "none" }),
+          /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M 85,50 L 75,50 M 80,45 L 85,50 L 80,55", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", fill: "none", opacity: "0.8", pointerEvents: "none" })
+        ] })
+      ]
+    }
+  );
+});
+var Dpad_default = Dpad;
 
-// src/lib/controls/types.ts
-var DPAD_BUTTONS2 = ["up", "down", "left", "right"];
-var FACE_BUTTONS = ["a", "b", "x", "y"];
-var SHOULDER_BUTTONS = ["l", "r"];
-var TRIGGER_BUTTONS = ["l2", "r2"];
-var STICK_BUTTONS = ["l3", "r3"];
-var SYSTEM_BUTTONS = ["start", "select"];
-var ALL_BUTTONS = [
-  ...DPAD_BUTTONS2,
-  ...FACE_BUTTONS,
-  ...SHOULDER_BUTTONS,
-  ...TRIGGER_BUTTONS,
-  ...STICK_BUTTONS,
-  ...SYSTEM_BUTTONS
-];
-
-// src/lib/controls/defaults.ts
-var STANDARD_GAMEPAD_BUTTONS = {
-  // Face buttons (Xbox/PlayStation layout)
-  a: 0,
-  // A / Cross (bottom)
-  b: 1,
-  // B / Circle (right)
-  x: 2,
-  // X / Square (left)
-  y: 3,
-  // Y / Triangle (top)
-  // Shoulders
-  l: 4,
-  // LB / L1
-  r: 5,
-  // RB / R1
-  // Triggers
-  l2: 6,
-  // LT / L2
-  r2: 7,
+// src/components/VirtualController/positioning.ts
+function adjustButtonPosition(config, context) {
+  const sizeMultiplier = context.isFullscreen ? 1.1 : 1;
+  return {
+    ...config,
+    size: Math.floor(config.size * sizeMultiplier)
+  };
+}
+var STORAGE_KEY = "virtual-button-positions";
+function useButtonPositions() {
+  const [landscapePositions, setLandscapePositions] = React2.useState({});
+  const [portraitPositions, setPortraitPositions] = React2.useState({});
+  React2.useEffect(() => {
+    try {
+      const stored = localStorage.getItem(STORAGE_KEY);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (parsed.landscape && parsed.portrait) {
+          setLandscapePositions(parsed.landscape);
+          setPortraitPositions(parsed.portrait);
+        } else {
+          setLandscapePositions(parsed);
+        }
+      }
+    } catch (e) {
+      console.error("Failed to load button positions:", e);
+    }
+  }, []);
+  const savePosition = React2.useCallback((buttonType, x, y, isLandscape) => {
+    if (isLandscape) {
+      setLandscapePositions((prev) => {
+        const updated = { ...prev, [buttonType]: { x, y } };
+        try {
+          const stored = {
+            landscape: updated,
+            portrait: portraitPositions
+          };
+          localStorage.setItem(STORAGE_KEY, JSON.stringify(stored));
+        } catch (e) {
+          console.error("Failed to save button position:", e);
+        }
+        return updated;
+      });
+    } else {
+      setPortraitPositions((prev) => {
+        const updated = { ...prev, [buttonType]: { x, y } };
+        try {
+          const stored = {
+            landscape: landscapePositions,
+            portrait: updated
+          };
+          localStorage.setItem(STORAGE_KEY, JSON.stringify(stored));
+        } catch (e) {
+          console.error("Failed to save button position:", e);
+        }
+        return updated;
+      });
+    }
+  }, [landscapePositions, portraitPositions]);
+  const getPosition = React2.useCallback((buttonType, isLandscape) => {
+    const positions = isLandscape ? landscapePositions : portraitPositions;
+    return positions[buttonType] || null;
+  }, [landscapePositions, portraitPositions]);
+  const resetPositions = React2.useCallback(() => {
+    setLandscapePositions({});
+    setPortraitPositions({});
+    try {
+      localStorage.removeItem(STORAGE_KEY);
+    } catch (e) {
+      console.error("Failed to reset button positions:", e);
+    }
+  }, []);
+  return {
+    landscapePositions,
+    portraitPositions,
+    savePosition,
+    getPosition,
+    resetPositions
+  };
+}
+
+// src/lib/controls/types.ts
+var DPAD_BUTTONS2 = ["up", "down", "left", "right"];
+var FACE_BUTTONS = ["a", "b", "x", "y"];
+var SHOULDER_BUTTONS = ["l", "r"];
+var TRIGGER_BUTTONS = ["l2", "r2"];
+var STICK_BUTTONS = ["l3", "r3"];
+var SYSTEM_BUTTONS = ["start", "select"];
+var ALL_BUTTONS = [
+  ...DPAD_BUTTONS2,
+  ...FACE_BUTTONS,
+  ...SHOULDER_BUTTONS,
+  ...TRIGGER_BUTTONS,
+  ...STICK_BUTTONS,
+  ...SYSTEM_BUTTONS
+];
+
+// src/lib/controls/defaults.ts
+var STANDARD_GAMEPAD_BUTTONS = {
+  // Face buttons (Xbox/PlayStation layout)
+  a: 0,
+  // A / Cross (bottom)
+  b: 1,
+  // B / Circle (right)
+  x: 2,
+  // X / Square (left)
+  y: 3,
+  // Y / Triangle (top)
+  // Shoulders
+  l: 4,
+  // LB / L1
+  r: 5,
+  // RB / R1
+  // Triggers
+  l2: 6,
+  // LT / L2
+  r2: 7,
   // RT / R2
   // System
   select: 8,
@@ -3541,351 +3869,6 @@ function getKeyboardCode(buttonType, controls) {
   }
   return DEFAULT_CONTROLS[key] ?? null;
 }
-function getKeyName(code) {
-  if (code.startsWith("Key")) return code.slice(3).toLowerCase();
-  if (code.startsWith("Arrow")) return code.slice(5);
-  if (code === "Enter") return "Enter";
-  if (code === "ShiftRight" || code === "ShiftLeft") return "Shift";
-  return code;
-}
-function getCanvas() {
-  return document.querySelector(".game-canvas-container canvas") || document.querySelector("canvas");
-}
-function dispatchKeyboardEvent(type, code) {
-  const canvas = getCanvas();
-  if (!canvas) {
-    return false;
-  }
-  const event = new KeyboardEvent(type, {
-    code,
-    key: getKeyName(code),
-    bubbles: true,
-    cancelable: true
-  });
-  canvas.dispatchEvent(event);
-  return true;
-}
-var CENTER_TOUCH_RADIUS = 0.35;
-var Dpad = React2__default.default.memo(function Dpad2({
-  size = 180,
-  x,
-  y,
-  containerWidth,
-  containerHeight,
-  controls,
-  systemColor = "#00FF41",
-  isLandscape = false,
-  customPosition,
-  onPositionChange
-}) {
-  const dpadRef = React2.useRef(null);
-  const activeTouchRef = React2.useRef(null);
-  const activeDirectionsRef = React2.useRef(/* @__PURE__ */ new Set());
-  const upPathRef = React2.useRef(null);
-  const downPathRef = React2.useRef(null);
-  const leftPathRef = React2.useRef(null);
-  const rightPathRef = React2.useRef(null);
-  const centerCircleRef = React2.useRef(null);
-  const displayX = customPosition ? customPosition.x : x;
-  const displayY = customPosition ? customPosition.y : y;
-  const releaseAllDirections = React2.useCallback((getKeyCode2) => {
-    activeDirectionsRef.current.forEach((dir) => {
-      const keyCode = getKeyCode2(dir);
-      if (keyCode) dispatchKeyboardEvent("keyup", keyCode);
-    });
-    activeDirectionsRef.current = /* @__PURE__ */ new Set();
-  }, []);
-  const getKeyCode = React2.useCallback((direction) => {
-    if (!controls) {
-      const defaults = {
-        up: "ArrowUp",
-        down: "ArrowDown",
-        left: "ArrowLeft",
-        right: "ArrowRight"
-      };
-      return defaults[direction];
-    }
-    return controls[direction] || "";
-  }, [controls]);
-  const drag = useDrag({
-    elementSize: size,
-    displayX,
-    displayY,
-    containerWidth,
-    containerHeight,
-    onPositionChange,
-    centerThreshold: CENTER_TOUCH_RADIUS,
-    onDragStart: () => {
-      releaseAllDirections(getKeyCode);
-      updateVisuals(/* @__PURE__ */ new Set());
-    }
-  });
-  const getDirectionsFromTouch = React2.useCallback((touchX, touchY, rect) => {
-    const centerX = rect.left + rect.width / 2;
-    const centerY = rect.top + rect.height / 2;
-    const dx = touchX - centerX;
-    const dy = touchY - centerY;
-    const distance = Math.sqrt(dx * dx + dy * dy);
-    const deadZone = rect.width / 2 * 0.15;
-    if (distance < deadZone) return /* @__PURE__ */ new Set();
-    const directions = /* @__PURE__ */ new Set();
-    const angle = Math.atan2(dy, dx) * (180 / Math.PI);
-    if (angle >= -150 && angle <= -30) directions.add("up");
-    if (angle >= 30 && angle <= 150) directions.add("down");
-    if (angle >= 120 || angle <= -120) directions.add("left");
-    if (angle >= -60 && angle <= 60) directions.add("right");
-    return directions;
-  }, []);
-  const updateVisuals = React2.useCallback((directions) => {
-    const activeFill = `${systemColor}80`;
-    const inactiveFill = "rgba(255, 255, 255, 0.05)";
-    const activeStroke = systemColor;
-    const inactiveStroke = "rgba(255, 255, 255, 0.2)";
-    const glow = `0 0 15px ${systemColor}`;
-    const updatePart = (ref, isActive) => {
-      if (ref.current) {
-        ref.current.style.fill = isActive ? activeFill : inactiveFill;
-        ref.current.style.stroke = isActive ? activeStroke : inactiveStroke;
-        ref.current.style.filter = isActive ? `drop-shadow(${glow})` : "none";
-        ref.current.style.transform = isActive ? "scale(0.98)" : "scale(1)";
-        ref.current.style.transformOrigin = "center";
-      }
-    };
-    updatePart(upPathRef, directions.has("up"));
-    updatePart(downPathRef, directions.has("down"));
-    updatePart(leftPathRef, directions.has("left"));
-    updatePart(rightPathRef, directions.has("right"));
-    if (centerCircleRef.current) {
-      const isAny = directions.size > 0;
-      centerCircleRef.current.style.fill = isAny ? systemColor : "rgba(0,0,0,0.5)";
-      centerCircleRef.current.style.stroke = isAny ? "#fff" : "rgba(255,255,255,0.3)";
-    }
-  }, [systemColor]);
-  const updateDirections = React2.useCallback((newDirections) => {
-    const prev = activeDirectionsRef.current;
-    prev.forEach((dir) => {
-      if (!newDirections.has(dir)) {
-        const keyCode = getKeyCode(dir);
-        if (keyCode) dispatchKeyboardEvent("keyup", keyCode);
-      }
-    });
-    newDirections.forEach((dir) => {
-      if (!prev.has(dir)) {
-        const keyCode = getKeyCode(dir);
-        if (keyCode) {
-          if (navigator.vibrate) navigator.vibrate(5);
-          dispatchKeyboardEvent("keydown", keyCode);
-        }
-      }
-    });
-    activeDirectionsRef.current = newDirections;
-    updateVisuals(newDirections);
-  }, [getKeyCode, updateVisuals]);
-  const handleTouchStart = React2.useCallback((e) => {
-    e.preventDefault();
-    if (activeTouchRef.current !== null) return;
-    const touch = e.changedTouches[0];
-    activeTouchRef.current = touch.identifier;
-    const rect = dpadRef.current?.getBoundingClientRect();
-    if (!rect) return;
-    if (onPositionChange) {
-      drag.checkDragStart(touch.clientX, touch.clientY, rect);
-    }
-    if (!drag.isDragging) {
-      updateDirections(getDirectionsFromTouch(touch.clientX, touch.clientY, rect));
-    }
-  }, [getDirectionsFromTouch, updateDirections, onPositionChange, drag]);
-  const handleTouchMove = React2.useCallback((e) => {
-    e.preventDefault();
-    let touch = null;
-    for (let i = 0; i < e.changedTouches.length; i++) {
-      if (e.changedTouches[i].identifier === activeTouchRef.current) {
-        touch = e.changedTouches[i];
-        break;
-      }
-    }
-    if (!touch) return;
-    if (drag.isDragging) {
-      drag.handleDragMove(touch.clientX, touch.clientY);
-    } else if (onPositionChange) {
-      const startedDrag = drag.checkMoveThreshold(touch.clientX, touch.clientY);
-      if (!startedDrag) {
-        drag.clearDragTimer();
-        const rect = dpadRef.current?.getBoundingClientRect();
-        if (rect) {
-          updateDirections(getDirectionsFromTouch(touch.clientX, touch.clientY, rect));
-        }
-      }
-    } else {
-      const rect = dpadRef.current?.getBoundingClientRect();
-      if (rect) {
-        updateDirections(getDirectionsFromTouch(touch.clientX, touch.clientY, rect));
-      }
-    }
-  }, [drag, getDirectionsFromTouch, updateDirections, onPositionChange]);
-  const handleTouchEnd = React2.useCallback((e) => {
-    e.preventDefault();
-    drag.clearDragTimer();
-    let touchEnded = false;
-    for (let i = 0; i < e.changedTouches.length; i++) {
-      if (e.changedTouches[i].identifier === activeTouchRef.current) {
-        touchEnded = true;
-        break;
-      }
-    }
-    if (touchEnded) {
-      activeTouchRef.current = null;
-      if (drag.isDragging) {
-        drag.handleDragEnd();
-      } else {
-        activeDirectionsRef.current.forEach((dir) => {
-          const keyCode = getKeyCode(dir);
-          if (keyCode) dispatchKeyboardEvent("keyup", keyCode);
-        });
-        activeDirectionsRef.current = /* @__PURE__ */ new Set();
-        updateVisuals(/* @__PURE__ */ new Set());
-      }
-    }
-  }, [getKeyCode, updateVisuals, drag]);
-  useTouchEvents(dpadRef, {
-    onTouchStart: handleTouchStart,
-    onTouchMove: handleTouchMove,
-    onTouchEnd: handleTouchEnd,
-    onTouchCancel: handleTouchEnd
-  }, { cleanup: drag.clearDragTimer });
-  const leftPx = displayX / 100 * containerWidth - size / 2;
-  const topPx = displayY / 100 * containerHeight - size / 2;
-  const dUp = "M 35,5 L 65,5 L 65,35 L 50,50 L 35,35 Z";
-  const dRight = "M 65,35 L 95,35 L 95,65 L 65,65 L 50,50 Z";
-  const dDown = "M 65,65 L 65,95 L 35,95 L 35,65 L 50,50 Z";
-  const dLeft = "M 35,65 L 5,65 L 5,35 L 35,35 L 50,50 Z";
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "div",
-    {
-      ref: dpadRef,
-      className: `absolute pointer-events-auto touch-manipulation select-none ${drag.isDragging ? "opacity-60" : ""}`,
-      style: {
-        top: 0,
-        left: 0,
-        transform: `translate3d(${leftPx}px, ${topPx}px, 0)${drag.isDragging ? " scale(1.05)" : ""}`,
-        width: size,
-        height: size,
-        opacity: isLandscape ? 0.75 : 0.9,
-        WebkitTouchCallout: "none",
-        WebkitUserSelect: "none",
-        touchAction: "none",
-        transition: drag.isDragging ? "none" : "transform 0.1s ease-out"
-      },
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: `absolute inset-0 rounded-full bg-black/40 backdrop-blur-md border shadow-lg ${drag.isDragging ? "border-white/50 ring-2 ring-white/30" : "border-white/10"}` }),
-        /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "100%", height: "100%", viewBox: "0 0 100 100", className: "drop-shadow-xl relative z-10", children: [
-          /* @__PURE__ */ jsxRuntime.jsx("path", { ref: upPathRef, d: dUp, fill: "rgba(255,255,255,0.05)", stroke: "rgba(255,255,255,0.2)", strokeWidth: "1", className: "transition-all duration-75" }),
-          /* @__PURE__ */ jsxRuntime.jsx("path", { ref: rightPathRef, d: dRight, fill: "rgba(255,255,255,0.05)", stroke: "rgba(255,255,255,0.2)", strokeWidth: "1", className: "transition-all duration-75" }),
-          /* @__PURE__ */ jsxRuntime.jsx("path", { ref: downPathRef, d: dDown, fill: "rgba(255,255,255,0.05)", stroke: "rgba(255,255,255,0.2)", strokeWidth: "1", className: "transition-all duration-75" }),
-          /* @__PURE__ */ jsxRuntime.jsx("path", { ref: leftPathRef, d: dLeft, fill: "rgba(255,255,255,0.05)", stroke: "rgba(255,255,255,0.2)", strokeWidth: "1", className: "transition-all duration-75" }),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            "circle",
-            {
-              ref: centerCircleRef,
-              cx: "50",
-              cy: "50",
-              r: "12",
-              fill: drag.isDragging ? systemColor : "rgba(0,0,0,0.5)",
-              stroke: drag.isDragging ? "#fff" : "rgba(255,255,255,0.3)",
-              strokeWidth: drag.isDragging ? 2 : 1
-            }
-          ),
-          /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M 50,15 L 50,25 M 45,20 L 50,15 L 55,20", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", fill: "none", opacity: "0.8", pointerEvents: "none" }),
-          /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M 50,85 L 50,75 M 45,80 L 50,85 L 55,80", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", fill: "none", opacity: "0.8", pointerEvents: "none" }),
-          /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M 15,50 L 25,50 M 20,45 L 15,50 L 20,55", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", fill: "none", opacity: "0.8", pointerEvents: "none" }),
-          /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M 85,50 L 75,50 M 80,45 L 85,50 L 80,55", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", fill: "none", opacity: "0.8", pointerEvents: "none" })
-        ] })
-      ]
-    }
-  );
-});
-var Dpad_default = Dpad;
-
-// src/components/VirtualController/positioning.ts
-function adjustButtonPosition(config, context) {
-  const sizeMultiplier = context.isFullscreen ? 1.1 : 1;
-  return {
-    ...config,
-    size: Math.floor(config.size * sizeMultiplier)
-  };
-}
-var STORAGE_KEY = "virtual-button-positions";
-function useButtonPositions() {
-  const [landscapePositions, setLandscapePositions] = React2.useState({});
-  const [portraitPositions, setPortraitPositions] = React2.useState({});
-  React2.useEffect(() => {
-    try {
-      const stored = localStorage.getItem(STORAGE_KEY);
-      if (stored) {
-        const parsed = JSON.parse(stored);
-        if (parsed.landscape && parsed.portrait) {
-          setLandscapePositions(parsed.landscape);
-          setPortraitPositions(parsed.portrait);
-        } else {
-          setLandscapePositions(parsed);
-        }
-      }
-    } catch (e) {
-      console.error("Failed to load button positions:", e);
-    }
-  }, []);
-  const savePosition = React2.useCallback((buttonType, x, y, isLandscape) => {
-    if (isLandscape) {
-      setLandscapePositions((prev) => {
-        const updated = { ...prev, [buttonType]: { x, y } };
-        try {
-          const stored = {
-            landscape: updated,
-            portrait: portraitPositions
-          };
-          localStorage.setItem(STORAGE_KEY, JSON.stringify(stored));
-        } catch (e) {
-          console.error("Failed to save button position:", e);
-        }
-        return updated;
-      });
-    } else {
-      setPortraitPositions((prev) => {
-        const updated = { ...prev, [buttonType]: { x, y } };
-        try {
-          const stored = {
-            landscape: landscapePositions,
-            portrait: updated
-          };
-          localStorage.setItem(STORAGE_KEY, JSON.stringify(stored));
-        } catch (e) {
-          console.error("Failed to save button position:", e);
-        }
-        return updated;
-      });
-    }
-  }, [landscapePositions, portraitPositions]);
-  const getPosition = React2.useCallback((buttonType, isLandscape) => {
-    const positions = isLandscape ? landscapePositions : portraitPositions;
-    return positions[buttonType] || null;
-  }, [landscapePositions, portraitPositions]);
-  const resetPositions = React2.useCallback(() => {
-    setLandscapePositions({});
-    setPortraitPositions({});
-    try {
-      localStorage.removeItem(STORAGE_KEY);
-    } catch (e) {
-      console.error("Failed to reset button positions:", e);
-    }
-  }, []);
-  return {
-    landscapePositions,
-    portraitPositions,
-    savePosition,
-    getPosition,
-    resetPositions
-  };
-}
 var STORAGE_KEY2 = "koin-controls-hint-shown";
 function ControlsHint({ isVisible }) {
   const [show, setShow] = React2.useState(false);
@@ -3970,7 +3953,7 @@ function LockButton({
     "button",
     {
       onClick: onToggle,
-      className: "fixed top-4 left-1/2 -translate-x-1/2 z-40 pointer-events-auto p-2 rounded-full backdrop-blur-sm transition-all active:scale-95",
+      className: "pointer-events-auto p-2 rounded-full backdrop-blur-sm transition-all active:scale-95",
       style: {
         backgroundColor: isLocked ? "rgba(0,0,0,0.6)" : `${systemColor}20`,
         border: `1px solid ${isLocked ? "rgba(255,255,255,0.2)" : systemColor}`
@@ -3984,18 +3967,164 @@ function LockButton({
         }
       )
     }
-  );
+  );
+}
+function HoldButton({
+  isActive,
+  onToggle,
+  systemColor = "#00FF41"
+}) {
+  const Icon = isActive ? lucideReact.StopCircle : lucideReact.Hand;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      onClick: onToggle,
+      className: "pointer-events-auto p-2 rounded-full backdrop-blur-sm transition-all active:scale-95",
+      style: {
+        backgroundColor: isActive ? "rgba(0,0,0,0.6)" : `${systemColor}20`,
+        border: `1px solid ${isActive ? "rgba(255,255,255,0.4)" : systemColor}`
+      },
+      "aria-label": isActive ? "Disable Hold Mode" : "Enable Button Hold Mode",
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        Icon,
+        {
+          size: 18,
+          style: { color: isActive ? "#fff" : systemColor }
+        }
+      )
+    }
+  );
+}
+function TurboButton({
+  isActive,
+  onToggle,
+  systemColor = "#00FF41"
+}) {
+  const Icon = isActive ? lucideReact.ZapOff : lucideReact.Zap;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      onClick: onToggle,
+      className: "pointer-events-auto p-2 rounded-full backdrop-blur-sm transition-all active:scale-95",
+      style: {
+        backgroundColor: isActive ? "rgba(255,200,0,0.3)" : `${systemColor}20`,
+        border: `1px solid ${isActive ? "rgba(255,200,0,0.6)" : systemColor}`
+      },
+      "aria-label": isActive ? "Disable Turbo Mode" : "Enable Turbo Fire Mode",
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        Icon,
+        {
+          size: 18,
+          style: { color: isActive ? "#FFC800" : systemColor }
+        }
+      )
+    }
+  );
+}
+var MODE_CONFIG = {
+  hold: {
+    Icon: lucideReact.Hand,
+    title: "Hold Mode",
+    instruction: "Tap a button to hold it",
+    buttonIcon: lucideReact.Hand,
+    buttonColor: "#22c55e"
+    // green
+  },
+  turbo: {
+    Icon: lucideReact.Zap,
+    title: "Turbo Mode",
+    instruction: "Tap a button for rapid fire",
+    buttonIcon: lucideReact.Zap,
+    buttonColor: "#fbbf24"
+    // yellow
+  }
+};
+function ModeOverlay({
+  mode,
+  heldButtons,
+  turboButtons,
+  systemColor = "#00FF41",
+  onExit
+}) {
+  if (!mode) return null;
+  const config = MODE_CONFIG[mode];
+  const buttons = mode === "hold" ? heldButtons : turboButtons;
+  const buttonArray = Array.from(buttons);
+  const { Icon, buttonIcon: ButtonIcon } = config;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "fixed top-0 left-0 right-0 z-40 flex justify-center pt-4 pointer-events-none", children: /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: "relative px-5 py-3 rounded-2xl backdrop-blur-md border pointer-events-auto",
+      style: {
+        backgroundColor: "rgba(0,0,0,0.85)",
+        borderColor: `${systemColor}60`,
+        boxShadow: `0 4px 20px ${systemColor}30`
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: onExit,
+            className: "absolute -top-2 -right-2 w-7 h-7 rounded-full flex items-center justify-center transition-transform active:scale-90",
+            style: {
+              backgroundColor: "#ef4444",
+              border: "2px solid rgba(255,255,255,0.3)"
+            },
+            "aria-label": "Exit mode",
+            children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { size: 14, color: "white", strokeWidth: 3 })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              className: "w-10 h-10 rounded-full flex items-center justify-center flex-shrink-0",
+              style: { backgroundColor: `${systemColor}30` },
+              children: /* @__PURE__ */ jsxRuntime.jsx(Icon, { size: 20, style: { color: systemColor } })
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-left", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-white font-bold text-sm", children: config.title }),
+            /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-white/60 text-xs", children: config.instruction })
+          ] })
+        ] }),
+        buttonArray.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-wrap gap-1.5 justify-center mt-2 pt-2 border-t border-white/10", children: buttonArray.map((button) => /* @__PURE__ */ jsxRuntime.jsxs(
+          "span",
+          {
+            className: "px-2 py-0.5 rounded-full text-[10px] font-bold uppercase flex items-center gap-1",
+            style: {
+              backgroundColor: `${config.buttonColor}25`,
+              color: config.buttonColor
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(ButtonIcon, { size: 10 }),
+              button
+            ]
+          },
+          button
+        )) })
+      ]
+    }
+  ) });
 }
 var LOCK_KEY = "koin-controls-locked";
 function VirtualController({
   system,
   isRunning,
   controls,
-  systemColor = "#00FF41"
+  systemColor = "#00FF41",
   // Default retro green
+  hapticsEnabled = true,
+  onButtonDown,
+  onButtonUp,
+  onPause,
+  onResume
 }) {
   const { isMobile, isLandscape, isPortrait } = useMobile();
   const [pressedButtons, setPressedButtons] = React2.useState(/* @__PURE__ */ new Set());
+  const pressedButtonsRef = React2.useRef(/* @__PURE__ */ new Set());
+  const [heldButtons, setHeldButtons] = React2.useState(/* @__PURE__ */ new Set());
+  const [isHoldMode, setIsHoldMode] = React2.useState(false);
   const [containerSize, setContainerSize] = React2.useState({ width: 0, height: 0 });
   const [isFullscreenState, setIsFullscreenState] = React2.useState(false);
   const [isLocked, setIsLocked] = React2.useState(true);
@@ -4013,6 +4142,28 @@ function VirtualController({
       return newValue;
     });
   }, []);
+  const toggleHoldMode = React2.useCallback(() => {
+    setIsHoldMode((prev) => {
+      if (prev) {
+        onResume();
+      } else {
+        onPause();
+      }
+      return !prev;
+    });
+  }, [onPause, onResume]);
+  const [isTurboMode, setIsTurboMode] = React2.useState(false);
+  const [turboButtons, setTurboButtons] = React2.useState(/* @__PURE__ */ new Set());
+  const toggleTurboMode = React2.useCallback(() => {
+    setIsTurboMode((prev) => {
+      if (prev) {
+        onResume();
+      } else {
+        onPause();
+      }
+      return !prev;
+    });
+  }, [onPause, onResume]);
   const layout = getLayoutForSystem(system);
   const visibleButtons = layout.buttons.filter((btn) => {
     if (isPortrait) {
@@ -4082,9 +4233,9 @@ function VirtualController({
         return;
       }
       setPressedButtons((prev) => new Set(prev).add(buttonType));
-      dispatchKeyboardEvent("keydown", keyboardCode);
+      onButtonDown(buttonType);
       setTimeout(() => {
-        dispatchKeyboardEvent("keyup", keyboardCode);
+        onButtonUp(buttonType);
         setPressedButtons((prev) => {
           const next = new Set(prev);
           next.delete(buttonType);
@@ -4092,7 +4243,7 @@ function VirtualController({
         });
       }, 100);
     },
-    [isRunning, getButtonKeyboardCode]
+    [isRunning, getButtonKeyboardCode, onButtonDown, onButtonUp]
   );
   const handlePressDown = React2.useCallback(
     (buttonType) => {
@@ -4101,15 +4252,70 @@ function VirtualController({
       if (isSystemButton) return;
       const keyboardCode = getButtonKeyboardCode(buttonType);
       if (!keyboardCode) return;
+      if (isHoldMode) {
+        const isHeld = heldButtons.has(buttonType);
+        if (isHeld) {
+          setHeldButtons((prev) => {
+            const next = new Set(prev);
+            next.delete(buttonType);
+            return next;
+          });
+          onButtonUp(buttonType);
+          if (hapticsEnabled && navigator.vibrate) navigator.vibrate(10);
+        } else {
+          setHeldButtons((prev) => {
+            setTurboButtons((turboPrev) => {
+              if (turboPrev.has(buttonType)) {
+                const nextTurbo = new Set(turboPrev);
+                nextTurbo.delete(buttonType);
+                return nextTurbo;
+              }
+              return turboPrev;
+            });
+            return new Set(prev).add(buttonType);
+          });
+          onButtonDown(buttonType);
+          if (hapticsEnabled && navigator.vibrate) navigator.vibrate([10, 30, 10]);
+        }
+        return;
+      }
+      if (isTurboMode) {
+        const isTurbo = turboButtons.has(buttonType);
+        if (isTurbo) {
+          setTurboButtons((prev) => {
+            const next = new Set(prev);
+            next.delete(buttonType);
+            return next;
+          });
+          if (hapticsEnabled && navigator.vibrate) navigator.vibrate(10);
+        } else {
+          setTurboButtons((prev) => {
+            setHeldButtons((holdPrev) => {
+              if (holdPrev.has(buttonType)) {
+                const nextHold = new Set(holdPrev);
+                nextHold.delete(buttonType);
+                onButtonUp(buttonType);
+                return nextHold;
+              }
+              return holdPrev;
+            });
+            return new Set(prev).add(buttonType);
+          });
+          if (hapticsEnabled && navigator.vibrate) navigator.vibrate([5, 10, 5]);
+        }
+        return;
+      }
       setPressedButtons((prev) => {
         if (prev.has(buttonType)) return prev;
         const next = new Set(prev);
         next.add(buttonType);
         return next;
       });
-      dispatchKeyboardEvent("keydown", keyboardCode);
+      if (!heldButtons.has(buttonType)) {
+        onButtonDown(buttonType);
+      }
     },
-    [isRunning, getButtonKeyboardCode]
+    [isRunning, getButtonKeyboardCode, isHoldMode, isTurboMode, heldButtons, hapticsEnabled, onButtonDown, onButtonUp]
   );
   const handleRelease = React2.useCallback(
     (buttonType) => {
@@ -4117,15 +4323,29 @@ function VirtualController({
       if (isSystemButton) return;
       const keyboardCode = getButtonKeyboardCode(buttonType);
       if (!keyboardCode) return;
+      if (isHoldMode) return;
+      if (heldButtons.has(buttonType)) {
+        if (!isHoldMode) {
+          setHeldButtons((prev) => {
+            const next = new Set(prev);
+            next.delete(buttonType);
+            return next;
+          });
+          onButtonUp(buttonType);
+          if (hapticsEnabled && navigator.vibrate) navigator.vibrate(10);
+        }
+        return;
+      }
+      if (isTurboMode) return;
       setPressedButtons((prev) => {
         if (!prev.has(buttonType)) return prev;
         const next = new Set(prev);
         next.delete(buttonType);
         return next;
       });
-      dispatchKeyboardEvent("keyup", keyboardCode);
+      onButtonUp(buttonType);
     },
-    [getButtonKeyboardCode]
+    [getButtonKeyboardCode, isHoldMode, isTurboMode, heldButtons, hapticsEnabled, onButtonUp]
   );
   React2.useEffect(() => {
     if (!isRunning && pressedButtons.size > 0) {
@@ -4137,6 +4357,22 @@ function VirtualController({
       setPressedButtons(/* @__PURE__ */ new Set());
     }
   }, [isRunning, pressedButtons, handleRelease]);
+  const TURBO_RATE = 15;
+  React2.useEffect(() => {
+    pressedButtonsRef.current = pressedButtons;
+  }, [pressedButtons]);
+  React2.useEffect(() => {
+    if (isTurboMode || turboButtons.size === 0) return;
+    const interval = setInterval(() => {
+      turboButtons.forEach((buttonType) => {
+        if (pressedButtonsRef.current.has(buttonType)) {
+          onButtonDown(buttonType);
+          setTimeout(() => onButtonUp(buttonType), 25);
+        }
+      });
+    }, 1e3 / TURBO_RATE);
+    return () => clearInterval(interval);
+  }, [isTurboMode, turboButtons, onButtonDown, onButtonUp]);
   const memoizedButtonElements = React2.useMemo(() => {
     const width = containerSize.width || (typeof window !== "undefined" ? window.innerWidth : 0);
     const height = containerSize.height || (typeof window !== "undefined" ? window.innerHeight : 0);
@@ -4167,14 +4403,32 @@ function VirtualController({
       className: "fixed inset-0 z-30 pointer-events-none",
       style: { touchAction: "none" },
       children: [
-        /* @__PURE__ */ jsxRuntime.jsx(
-          LockButton,
-          {
-            isLocked,
-            onToggle: toggleLock,
-            systemColor
-          }
-        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "fixed top-4 left-1/2 -translate-x-1/2 z-40 flex gap-4", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            LockButton,
+            {
+              isLocked,
+              onToggle: toggleLock,
+              systemColor
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            HoldButton,
+            {
+              isActive: isHoldMode,
+              onToggle: toggleHoldMode,
+              systemColor
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            TurboButton,
+            {
+              isActive: isTurboMode,
+              onToggle: toggleTurboMode,
+              systemColor
+            }
+          )
+        ] }),
         /* @__PURE__ */ jsxRuntime.jsx(
           Dpad_default,
           {
@@ -4183,18 +4437,20 @@ function VirtualController({
             y: finalDpadY,
             containerWidth: containerSize.width || window.innerWidth,
             containerHeight: containerSize.height || window.innerHeight,
-            controls,
             systemColor,
             isLandscape,
             customPosition: getPosition("up", isLandscape),
-            onPositionChange: isLocked ? void 0 : (x, y) => savePosition("up", x, y, isLandscape)
+            onPositionChange: isLocked ? void 0 : (x, y) => savePosition("up", x, y, isLandscape),
+            hapticsEnabled,
+            onButtonDown,
+            onButtonUp
           }
         ),
         memoizedButtonElements.filter(({ buttonConfig }) => !DPAD_TYPES.includes(buttonConfig.type)).map(({ buttonConfig, adjustedConfig, customPosition, width, height }) => /* @__PURE__ */ jsxRuntime.jsx(
           VirtualButton_default,
           {
             config: adjustedConfig,
-            isPressed: pressedButtons.has(buttonConfig.type),
+            isPressed: pressedButtons.has(buttonConfig.type) || heldButtons.has(buttonConfig.type),
             onPress: handlePress,
             onPressDown: handlePressDown,
             onRelease: handleRelease,
@@ -4203,10 +4459,24 @@ function VirtualController({
             customPosition,
             onPositionChange: isLocked ? void 0 : (x, y) => savePosition(buttonConfig.type, x, y, isLandscape),
             isLandscape,
-            console: layout.console
+            console: layout.console,
+            hapticsEnabled,
+            mode: isHoldMode ? "hold" : isTurboMode ? "turbo" : "normal",
+            isHeld: heldButtons.has(buttonConfig.type),
+            isInTurbo: turboButtons.has(buttonConfig.type)
           },
           buttonConfig.type
         )),
+        (isHoldMode || isTurboMode) && /* @__PURE__ */ jsxRuntime.jsx(
+          ModeOverlay,
+          {
+            mode: isHoldMode ? "hold" : "turbo",
+            heldButtons,
+            turboButtons,
+            systemColor,
+            onExit: isHoldMode ? toggleHoldMode : toggleTurboMode
+          }
+        ),
         /* @__PURE__ */ jsxRuntime.jsx(ControlsHint, { isVisible: isRunning })
       ]
     }
@@ -4893,7 +5163,8 @@ function CheatModal({
   cheats,
   activeCheats,
   onToggle,
-  onClose
+  onClose,
+  onAddManualCheat
 }) {
   const t = useKoinTranslation();
   const [copiedId, setCopiedId] = React2__default.default.useState(null);
@@ -4911,54 +5182,111 @@ function CheatModal({
       subtitle: t.modals.cheats.available.replace("{{count}}", cheats.length.toString()),
       icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Code, { size: 24, className: "text-purple-400" }),
       footer: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs text-gray-500 text-center w-full", children: activeCheats.size > 0 ? t.modals.cheats.active.replace("{{count}}", activeCheats.size.toString()) : t.modals.cheats.toggleHint }),
-      children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4 space-y-2 max-h-[400px] overflow-y-auto", children: cheats.length === 0 ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-center py-12 text-gray-500", children: [
-        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Code, { size: 48, className: "mx-auto mb-3 opacity-50" }),
-        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "font-medium", children: t.modals.cheats.emptyTitle }),
-        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm mt-1", children: t.modals.cheats.emptyDesc })
-      ] }) : cheats.map((cheat) => {
-        const isActive = activeCheats.has(cheat.id);
-        return /* @__PURE__ */ jsxRuntime.jsxs(
-          "div",
-          {
-            className: `
-                                    group flex items-start gap-4 p-4 rounded-lg border transition-all cursor-pointer
-                                    ${isActive ? "border-purple-500/50 bg-purple-500/10" : "border-white/10 bg-white/5 hover:border-white/20 hover:bg-white/10"}
-                                `,
-            onClick: () => onToggle(cheat.id),
-            children: [
-              /* @__PURE__ */ jsxRuntime.jsx(
-                "div",
-                {
-                  className: `
-                                        flex-shrink-0 w-6 h-6 rounded border-2 flex items-center justify-center transition-all
-                                        ${isActive ? "border-purple-500 bg-purple-500" : "border-gray-600 group-hover:border-gray-400"}
-                                    `,
-                  children: isActive && /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { size: 14, className: "text-white" })
+      children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-4 space-y-4 max-h-[400px] overflow-y-auto", children: [
+        onAddManualCheat && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-3 bg-white/5 rounded-lg border border-white/10 space-y-3", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex gap-2", children: /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              type: "text",
+              placeholder: t.modals.cheats.codePlaceholder || "Enter cheat code",
+              className: "flex-1 bg-black/50 border border-white/20 rounded px-3 py-2 text-sm text-white placeholder-gray-500 focus:outline-none focus:border-purple-500",
+              onKeyDown: (e) => {
+                if (e.key === "Enter") {
+                  const input = e.currentTarget;
+                  const code = input.value.trim();
+                  if (code) {
+                    const descInput = input.parentElement?.nextElementSibling?.querySelector("input");
+                    const desc = descInput?.value.trim() || "Custom Cheat";
+                    onAddManualCheat(code, desc);
+                    input.value = "";
+                    if (descInput) descInput.value = "";
+                  }
                 }
-              ),
-              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1 min-w-0", children: [
-                /* @__PURE__ */ jsxRuntime.jsx("p", { className: `font-medium ${isActive ? "text-purple-300" : "text-white"}`, children: cheat.description }),
-                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 mt-2", children: [
-                  /* @__PURE__ */ jsxRuntime.jsx("code", { className: "px-2 py-1 bg-black/50 rounded text-xs font-mono text-gray-400 truncate max-w-[200px]", children: cheat.code }),
-                  /* @__PURE__ */ jsxRuntime.jsx(
-                    "button",
-                    {
-                      onClick: (e) => {
-                        e.stopPropagation();
-                        handleCopy(cheat.code, cheat.id);
-                      },
-                      className: "p-1.5 rounded hover:bg-white/10 text-gray-500 hover:text-white transition-colors",
-                      title: t.modals.cheats.copy,
-                      children: copiedId === cheat.id ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { size: 14, className: "text-green-400" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Copy, { size: 14 })
-                    }
-                  )
+              }
+            }
+          ) }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "input",
+              {
+                type: "text",
+                placeholder: t.modals.cheats.descPlaceholder || "Description (optional)",
+                className: "flex-1 bg-black/50 border border-white/20 rounded px-3 py-2 text-sm text-white placeholder-gray-500 focus:outline-none focus:border-purple-500"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                onClick: (e) => {
+                  const descInput = e.currentTarget.previousElementSibling;
+                  const codeInput = e.currentTarget.parentElement?.previousElementSibling?.querySelector("input");
+                  const code = codeInput?.value.trim();
+                  const desc = descInput?.value.trim() || "Custom Cheat";
+                  if (code) {
+                    onAddManualCheat(code, desc);
+                    codeInput.value = "";
+                    descInput.value = "";
+                  }
+                },
+                className: "px-3 py-2 bg-purple-600 hover:bg-purple-500 text-white text-sm rounded transition-colors",
+                children: t.modals.cheats.add || "Add"
+              }
+            )
+          ] })
+        ] }),
+        cheats.length === 0 ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-center py-12 text-gray-500", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Code, { size: 48, className: "mx-auto mb-3 opacity-50" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "font-medium", children: t.modals.cheats.emptyTitle }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm mt-1", children: t.modals.cheats.emptyDesc })
+        ] }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2", children: cheats.map((cheat) => {
+          const isActive = activeCheats.has(cheat.id);
+          const isManual = cheat.source === "manual";
+          return /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              className: `
+                                        group flex items-start gap-4 p-4 rounded-lg border transition-all cursor-pointer
+                                        ${isActive ? "border-purple-500/50 bg-purple-500/10" : "border-white/10 bg-white/5 hover:border-white/20 hover:bg-white/10"}
+                                    `,
+              onClick: () => onToggle(cheat.id),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "div",
+                  {
+                    className: `
+                                            flex-shrink-0 w-6 h-6 rounded border-2 flex items-center justify-center transition-all
+                                            ${isActive ? "border-purple-500 bg-purple-500" : "border-gray-600 group-hover:border-gray-400"}
+                                        `,
+                    children: isActive && /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { size: 14, className: "text-white" })
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1 min-w-0", children: [
+                  /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+                    isManual && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs bg-purple-500/20 text-purple-300 px-1.5 py-0.5 rounded border border-purple-500/30", children: "USER" }),
+                    /* @__PURE__ */ jsxRuntime.jsx("p", { className: `font-medium ${isActive ? "text-purple-300" : "text-white"}`, children: cheat.description })
+                  ] }),
+                  /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 mt-2", children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("code", { className: "px-2 py-1 bg-black/50 rounded text-xs font-mono text-gray-400 truncate max-w-[200px]", children: cheat.code }),
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      "button",
+                      {
+                        onClick: (e) => {
+                          e.stopPropagation();
+                          handleCopy(cheat.code, cheat.id);
+                        },
+                        className: "p-1.5 rounded hover:bg-white/10 text-gray-500 hover:text-white transition-colors",
+                        title: t.modals.cheats.copy,
+                        children: copiedId === cheat.id ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { size: 14, className: "text-green-400" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Copy, { size: 14 })
+                      }
+                    )
+                  ] })
                 ] })
-              ] })
-            ]
-          },
-          cheat.id
-        );
-      }) })
+              ]
+            },
+            cheat.id
+          );
+        }) })
+      ] })
     }
   );
 }
@@ -5290,7 +5618,9 @@ function SettingsModal({
   onClose,
   currentLanguage,
   onLanguageChange,
-  systemColor = "#00FF41"
+  systemColor = "#00FF41",
+  hapticsEnabled,
+  onToggleHaptics
 }) {
   const t = useKoinTranslation();
   const languages = [
@@ -5314,30 +5644,57 @@ function SettingsModal({
           children: t.modals.shortcuts.pressEsc
         }
       ),
-      children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-6 space-y-6", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-3", children: [
-        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-sm font-medium text-gray-400", children: [
-          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Globe, { size: 16 }),
-          /* @__PURE__ */ jsxRuntime.jsx("span", { children: t.settings.language })
+      children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-6 space-y-6", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-3", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-sm font-medium text-gray-400", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Globe, { size: 16 }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { children: t.settings.language })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grid gap-2", children: languages.map((lang) => {
+            const isActive = currentLanguage === lang.code;
+            return /* @__PURE__ */ jsxRuntime.jsxs(
+              "button",
+              {
+                onClick: () => onLanguageChange(lang.code),
+                className: `
+                                        flex items-center justify-between px-4 py-3 rounded-lg border transition-all
+                                        ${isActive ? "bg-white/10 border-white/20 text-white" : "bg-black/20 border-transparent text-gray-400 hover:bg-white/5 hover:text-white"}
+                                    `,
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("span", { children: lang.name }),
+                  isActive && /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { size: 16, style: { color: systemColor } })
+                ]
+              },
+              lang.code
+            );
+          }) })
         ] }),
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grid gap-2", children: languages.map((lang) => {
-          const isActive = currentLanguage === lang.code;
-          return /* @__PURE__ */ jsxRuntime.jsxs(
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-3", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-sm font-medium text-gray-400", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Zap, { size: 16 }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { children: t.settings.haptics })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(
             "button",
             {
-              onClick: () => onLanguageChange(lang.code),
+              onClick: onToggleHaptics,
               className: `
-                                        flex items-center justify-between px-4 py-3 rounded-lg border transition-all
-                                        ${isActive ? "bg-white/10 border-white/20 text-white" : "bg-black/20 border-transparent text-gray-400 hover:bg-white/5 hover:text-white"}
-                                    `,
+                            w-full flex items-center justify-between px-4 py-3 rounded-lg border transition-all
+                            ${hapticsEnabled ? "bg-white/10 border-white/20 text-white" : "bg-black/20 border-transparent text-gray-400 hover:bg-white/5 hover:text-white"}
+                        `,
               children: [
-                /* @__PURE__ */ jsxRuntime.jsx("span", { children: lang.name }),
-                isActive && /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { size: 16, style: { color: systemColor } })
+                /* @__PURE__ */ jsxRuntime.jsx("span", { children: t.settings.enableHaptics }),
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: `w-10 h-6 rounded-full p-1 transition-colors ${hapticsEnabled ? "bg-[#00FF41]" : "bg-gray-700"}`, children: /* @__PURE__ */ jsxRuntime.jsx(
+                  "div",
+                  {
+                    className: `w-4 h-4 rounded-full bg-white transition-transform ${hapticsEnabled ? "translate-x-4" : "translate-x-0"}`
+                  }
+                ) })
               ]
-            },
-            lang.code
-          );
-        }) })
-      ] }) })
+            }
+          )
+        ] })
+      ] })
     }
   );
 }
@@ -5357,6 +5714,7 @@ function GameModals({
   cheats,
   activeCheats,
   onToggleCheat,
+  onAddManualCheat,
   saveModalOpen,
   setSaveModalOpen,
   saveModalMode,
@@ -5376,7 +5734,9 @@ function GameModals({
   settingsModalOpen,
   setSettingsModalOpen,
   currentLanguage,
-  onLanguageChange
+  onLanguageChange,
+  hapticsEnabled,
+  onToggleHaptics
 }) {
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsx(
@@ -5411,6 +5771,7 @@ function GameModals({
         cheats,
         activeCheats,
         onToggle: onToggleCheat,
+        onAddManualCheat,
         onClose: () => {
           setCheatsModalOpen(false);
           onResume();
@@ -5463,7 +5824,9 @@ function GameModals({
         },
         currentLanguage,
         onLanguageChange,
-        systemColor
+        systemColor,
+        hapticsEnabled,
+        onToggleHaptics
       }
     )
   ] });
@@ -6758,6 +7121,11 @@ function useEmulatorCore({
           input_volume_up: "add",
           input_volume_down: "subtract",
           input_audio_mute: "f9",
+          // Cheat hotkeys
+          quick_menu_show_cheats: true,
+          input_cheat_index_plus: "y",
+          input_cheat_index_minus: "t",
+          input_cheat_toggle: "u",
           ...inputConfig,
           ...specificConfig,
           // Apply system-specific optimizations
@@ -6851,18 +7219,15 @@ function useEmulatorCore({
   const restart = React2.useCallback(async () => {
     if (nostalgistRef.current) {
       try {
-        nostalgistRef.current.restart();
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        nostalgistRef.current.resume();
-        setIsPaused(false);
-        setStatus("running");
-      } catch (err) {
-        console.error("[Nostalgist] Restart error:", err);
+        console.log("[Nostalgist] Full restart - stopping, re-preparing with fresh config, starting");
         stop();
+        await prepare();
         await start();
+      } catch (err) {
+        console.error("[Nostalgist] Restart error:", err);
       }
     }
-  }, [stop, start]);
+  }, [stop, prepare, start]);
   const pause = React2.useCallback(() => {
     if (nostalgistRef.current && !isPaused && status === "running") {
       try {
@@ -6955,9 +7320,6 @@ function useEmulatorCore({
       console.error("[Nostalgist] Resize error:", err);
     }
   }, []);
-  React2.useCallback(() => {
-    return nostalgistRef.current;
-  }, []);
   return {
     status,
     setStatus,
@@ -7084,8 +7446,26 @@ function useEmulatorInput({ nostalgistRef }) {
       console.error("[Nostalgist] Press key error:", err);
     }
   }, [nostalgistRef]);
+  const pressDown = React2.useCallback((button) => {
+    if (!nostalgistRef.current) return;
+    try {
+      nostalgistRef.current.pressDown(button);
+    } catch (err) {
+      console.error("[Nostalgist] Press down error:", err);
+    }
+  }, [nostalgistRef]);
+  const pressUp = React2.useCallback((button) => {
+    if (!nostalgistRef.current) return;
+    try {
+      nostalgistRef.current.pressUp(button);
+    } catch (err) {
+      console.error("[Nostalgist] Press up error:", err);
+    }
+  }, [nostalgistRef]);
   return {
-    pressKey
+    pressKey,
+    pressDown,
+    pressUp
   };
 }
 var MIN_SAVE_INTERVAL = 100;
@@ -7352,26 +7732,53 @@ function useEmulatorSaves({ nostalgistRef, isPaused, setIsPaused, setStatus, rew
     stopRewindCapture
   };
 }
-function useEmulatorCheats({ nostalgistRef }) {
-  const applyCheat = React2.useCallback((code) => {
+function useEmulatorCheats({
+  nostalgistRef
+}) {
+  const allocatedPointersRef = React2.useRef([]);
+  const injectCheats = React2.useCallback((cheats) => {
     if (!nostalgistRef.current) return;
-    try {
-      nostalgistRef.current.addCheat(code);
-    } catch (err) {
-      console.error("[Nostalgist] Apply cheat error:", err);
+    const module = nostalgistRef.current.getEmscriptenModule();
+    if (!module) return;
+    if (module._free && allocatedPointersRef.current.length > 0) {
+      allocatedPointersRef.current.forEach((ptr) => {
+        try {
+          module._free(ptr);
+        } catch (e) {
+        }
+      });
+      allocatedPointersRef.current = [];
     }
-  }, [nostalgistRef]);
-  const resetCheats = React2.useCallback(() => {
-    if (!nostalgistRef.current) return;
-    try {
-      nostalgistRef.current.resetCheats();
-    } catch (err) {
-      console.error("[Nostalgist] Reset cheats error:", err);
+    if (module._cmd_cheat_realloc) {
+      module._cmd_cheat_realloc(0);
+      if (cheats.length > 0) {
+        module._cmd_cheat_realloc(cheats.length);
+      }
+    }
+    if (cheats.length > 0 && module.stringToNewUTF8 && module._cmd_cheat_set_code) {
+      cheats.forEach((cheat, index) => {
+        try {
+          const ptr = module.stringToNewUTF8(cheat.code);
+          allocatedPointersRef.current.push(ptr);
+          module._cmd_cheat_set_code(index, ptr);
+          if (module._cmd_cheat_toggle_index) {
+            module._cmd_cheat_toggle_index(index, true);
+          }
+        } catch (err) {
+          console.error("[Cheats] Failed to inject cheat:", index, err);
+        }
+      });
+    }
+    if (module._cmd_cheat_apply_cheats) {
+      module._cmd_cheat_apply_cheats();
     }
   }, [nostalgistRef]);
+  const clearCheats = React2.useCallback(() => {
+    injectCheats([]);
+  }, [injectCheats]);
   return {
-    applyCheat,
-    resetCheats
+    injectCheats,
+    clearCheats
   };
 }
 
@@ -7443,7 +7850,9 @@ var useNostalgist = ({
     initialVolume
   });
   const {
-    pressKey
+    pressKey,
+    pressDown,
+    pressUp
   } = useEmulatorInput({
     nostalgistRef
   });
@@ -7466,8 +7875,8 @@ var useNostalgist = ({
     // Disable manual rewind loop for heavy systems
   });
   const {
-    applyCheat,
-    resetCheats
+    injectCheats,
+    clearCheats
   } = useEmulatorCheats({
     nostalgistRef
   });
@@ -7510,9 +7919,11 @@ var useNostalgist = ({
     toggleMute,
     screenshot,
     pressKey,
+    pressDown,
+    pressUp,
     resize,
-    applyCheat,
-    resetCheats,
+    injectCheats,
+    clearCheats,
     getNostalgistInstance,
     isPerformanceMode
   }), [
@@ -7542,9 +7953,11 @@ var useNostalgist = ({
     toggleMute,
     screenshot,
     pressKey,
+    pressDown,
+    pressUp,
     resize,
-    applyCheat,
-    resetCheats,
+    injectCheats,
+    clearCheats,
     getNostalgistInstance,
     isPerformanceMode
   ]);
@@ -8275,39 +8688,95 @@ function useGameSaves({
     handleAutoSaveToggle
   };
 }
+var generateManualId = () => `manual-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 function useGameCheats({
   nostalgist,
   cheats = [],
-  onToggleCheat
+  onToggleCheat,
+  showToast,
+  romId
 }) {
   const [cheatsModalOpen, setCheatsModalOpen] = React2.useState(false);
   const [activeCheats, setActiveCheats] = React2.useState(/* @__PURE__ */ new Set());
+  const [manualCheatsInternal, setManualCheatsInternal] = React2.useState([]);
+  const [isLoaded, setIsLoaded] = React2.useState(false);
+  const cheatStorageKey = romId ? `koin_cheats_${romId}` : null;
+  React2.useEffect(() => {
+    if (!cheatStorageKey) return;
+    setIsLoaded(false);
+    try {
+      const stored = localStorage.getItem(cheatStorageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (Array.isArray(parsed)) {
+          setManualCheatsInternal(parsed);
+        }
+      }
+    } catch (e) {
+      console.error("[Cheats] Failed to load cheats:", e);
+    } finally {
+      setIsLoaded(true);
+    }
+  }, [cheatStorageKey]);
+  React2.useEffect(() => {
+    if (!cheatStorageKey || !isLoaded) return;
+    localStorage.setItem(cheatStorageKey, JSON.stringify(manualCheatsInternal));
+  }, [manualCheatsInternal, cheatStorageKey, isLoaded]);
+  const allCheats = React2.useMemo(() => {
+    const normalizedExternal = cheats.map((c) => ({
+      id: typeof c.id === "number" ? `db-${c.id}` : c.id,
+      code: c.code,
+      description: c.description,
+      source: "database"
+    }));
+    return [...normalizedExternal, ...manualCheatsInternal];
+  }, [cheats, manualCheatsInternal]);
+  const handleAddManualCheat = (code, description) => {
+    if (!nostalgist) return;
+    const newCheat = {
+      id: generateManualId(),
+      code,
+      description,
+      source: "manual"
+    };
+    setManualCheatsInternal((prev) => [...prev, newCheat]);
+    setActiveCheats((prev) => new Set(prev).add(newCheat.id));
+    setCheatsModalOpen(false);
+    const currentActiveCheats = [...activeCheats, newCheat.id];
+    const cheatsToInject = allCheats.filter((c) => currentActiveCheats.includes(c.id) || c.id === newCheat.id).concat([newCheat]);
+    nostalgist.injectCheats(cheatsToInject.map((c) => ({ code: c.code })));
+    nostalgist.resume();
+    showToast?.("Cheat added!", "success");
+  };
   const handleToggleCheat = (cheatId) => {
     if (!nostalgist) return;
     const newActiveCheats = new Set(activeCheats);
     const isActive = newActiveCheats.has(cheatId);
     if (isActive) {
       newActiveCheats.delete(cheatId);
+      showToast?.("Cheat Disabled");
     } else {
       newActiveCheats.add(cheatId);
+      showToast?.("Cheat Enabled", "success");
     }
     setActiveCheats(newActiveCheats);
-    onToggleCheat?.(cheatId, !isActive);
-    nostalgist.resetCheats();
-    setTimeout(() => {
-      newActiveCheats.forEach((id) => {
-        const cheat = cheats.find((c) => c.id === id);
-        if (cheat) {
-          nostalgist.applyCheat(cheat.code);
-        }
-      });
-    }, 50);
+    if (onToggleCheat) {
+      const numericId = cheatId.startsWith("db-") ? parseInt(cheatId.slice(3), 10) : void 0;
+      if (numericId !== void 0) {
+        onToggleCheat(numericId, !isActive);
+      }
+    }
+    const cheatsToInject = allCheats.filter((c) => newActiveCheats.has(c.id)).map((c) => ({ code: c.code }));
+    nostalgist.injectCheats(cheatsToInject);
   };
   return {
     cheatsModalOpen,
     setCheatsModalOpen,
     activeCheats,
-    handleToggleCheat
+    allCheats,
+    // Unified list - replaces separate cheats + manualCheats
+    handleToggleCheat,
+    handleAddManualCheat
   };
 }
 function useGameRecording({
@@ -8484,10 +8953,13 @@ function useGamePlayer(props) {
     cheatsModalOpen,
     setCheatsModalOpen,
     activeCheats,
-    handleToggleCheat
+    allCheats,
+    handleToggleCheat,
+    handleAddManualCheat
   } = useGameCheats({
     ...props,
-    nostalgist
+    nostalgist,
+    showToast
   });
   const {
     isRecording,
@@ -8543,7 +9015,9 @@ function useGamePlayer(props) {
     hardcoreRestrictions,
     // Cheats
     activeCheats,
+    allCheats,
     handleToggleCheat,
+    handleAddManualCheat,
     // Emulator
     nostalgist,
     volumeState,
@@ -8571,7 +9045,8 @@ var DEFAULT_SETTINGS = {
   muted: false,
   shader: "",
   showPerformanceOverlay: false,
-  showInputDisplay: false
+  showInputDisplay: false,
+  hapticsEnabled: true
 };
 function usePlayerPersistence(onSettingsChange) {
   const [settings, setSettings] = React2.useState(DEFAULT_SETTINGS);
@@ -8678,7 +9153,9 @@ var es = {
     shortcuts: "Atajos",
     exit: "Salir",
     language: "Idioma",
-    selectLanguage: "Seleccionar idioma"
+    selectLanguage: "Seleccionar idioma",
+    haptics: "Vibraci\xF3n",
+    enableHaptics: "Habilitar vibraci\xF3n"
   },
   overlay: {
     play: "JUGAR",
@@ -8761,7 +9238,10 @@ var es = {
       emptyDesc: "No se encontraron c\xF3digos para este juego",
       copy: "Copiar c\xF3digo",
       active: "{{count}} truco{{s}} activo(s)",
-      toggleHint: "Haz clic para activar/desactivar"
+      toggleHint: "Haz clic para activar/desactivar",
+      codePlaceholder: "Introduce c\xF3digo (ej: 00C-048-E6E)",
+      descPlaceholder: "Descripci\xF3n (opcional)",
+      add: "A\xF1adir truco"
     },
     saveSlots: {
       title: "Guardar partida",
@@ -8906,7 +9386,9 @@ var fr = {
     shortcuts: "Raccourcis",
     exit: "Quitter",
     language: "Langue",
-    selectLanguage: "Choisir la langue"
+    selectLanguage: "Choisir la langue",
+    haptics: "Vibration",
+    enableHaptics: "Activer la vibration"
   },
   overlay: {
     play: "JOUER",
@@ -8989,7 +9471,10 @@ var fr = {
       emptyDesc: "Aucun code trouv\xE9 pour ce jeu",
       copy: "Copier",
       active: "{{count}} actif(s)",
-      toggleHint: "Cliquez pour activer/d\xE9sactiver"
+      toggleHint: "Cliquez pour activer/d\xE9sactiver",
+      codePlaceholder: "Entrez le code (ex: 00C-048-E6E)",
+      descPlaceholder: "Description (optionnel)",
+      add: "Ajouter"
     },
     saveSlots: {
       title: "Sauvegardes",
@@ -9162,7 +9647,9 @@ var GamePlayerInner = React2.memo(function GamePlayerInner2(props) {
     hardcoreRestrictions,
     // Cheats
     activeCheats,
+    allCheats,
     handleToggleCheat,
+    handleAddManualCheat,
     // Emulator Instance & State
     nostalgist,
     // Contains start, restart, etc.
@@ -9227,7 +9714,7 @@ var GamePlayerInner = React2.memo(function GamePlayerInner2(props) {
       if (muted !== settings.muted) toggleMute();
     }
   }, [settingsLoaded]);
-  const { system, systemColor = "#00FF41", cheats = [], onExit } = props;
+  const { system, systemColor = "#00FF41", onExit } = props;
   const handlePauseToggle = React2.useCallback(() => {
     status === "ready" ? start() : togglePause();
   }, [status, start, togglePause]);
@@ -9283,6 +9770,9 @@ var GamePlayerInner = React2.memo(function GamePlayerInner2(props) {
   const handleToggleInputDisplay = React2.useCallback(() => {
     updateSettings({ showInputDisplay: !settings.showInputDisplay });
   }, [updateSettings, settings.showInputDisplay]);
+  const handleToggleHaptics = React2.useCallback(() => {
+    updateSettings({ hapticsEnabled: !settings.hapticsEnabled });
+  }, [updateSettings, settings.hapticsEnabled]);
   const handleToggleRecording = React2.useCallback(async () => {
     if (!recordingSupported) {
       console.warn("[Recording] Not supported in this browser");
@@ -9369,7 +9859,12 @@ var GamePlayerInner = React2.memo(function GamePlayerInner2(props) {
               system,
               isRunning: status === "running" || status === "paused",
               controls,
-              systemColor
+              systemColor,
+              hapticsEnabled: settings.hapticsEnabled,
+              onButtonDown: nostalgist.pressDown,
+              onButtonUp: nostalgist.pressUp,
+              onPause: nostalgist.pause,
+              onResume: nostalgist.resume
             }
           ),
           !isFullscreen2 && isMobile && /* @__PURE__ */ jsxRuntime.jsx(
@@ -9524,9 +10019,10 @@ var GamePlayerInner = React2.memo(function GamePlayerInner2(props) {
             systemColor,
             cheatsModalOpen,
             setCheatsModalOpen,
-            cheats,
+            cheats: allCheats,
             activeCheats,
             onToggleCheat: handleToggleCheat,
+            onAddManualCheat: handleAddManualCheat,
             saveModalOpen,
             setSaveModalOpen,
             saveModalMode,
@@ -9546,7 +10042,9 @@ var GamePlayerInner = React2.memo(function GamePlayerInner2(props) {
             settingsModalOpen,
             setSettingsModalOpen,
             currentLanguage: props.currentLanguage,
-            onLanguageChange: props.onLanguageChange
+            onLanguageChange: props.onLanguageChange,
+            hapticsEnabled: settings.hapticsEnabled,
+            onToggleHaptics: handleToggleHaptics
           }
         ),
         !isMobile && /* @__PURE__ */ jsxRuntime.jsx(