@tastic/shell 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,1636 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_APP_SETTINGS: () => DEFAULT_APP_SETTINGS,
+  DEFAULT_OPPONENT: () => DEFAULT_OPPONENT,
+  HomeScreen: () => HomeScreen,
+  LoadoutRoute: () => LoadoutRoute,
+  PREVIEW_ASPECT: () => PREVIEW_ASPECT,
+  PackProvider: () => PackProvider,
+  PlayRoute: () => PlayRoute,
+  ProfilesProvider: () => ProfilesProvider,
+  ProfilesRoute: () => ProfilesRoute,
+  RootLayout: () => RootLayout,
+  SettingsDialog: () => SettingsDialog,
+  StatsScreen: () => StatsScreen,
+  appSettingsActions: () => appSettingsActions,
+  appSettingsReducer: () => appSettingsSlice_default,
+  createGameGuideSlice: () => createGameGuideSlice,
+  createGameStats: () => createGameStats,
+  createPackStore: () => createPackStore,
+  createPlayerSettings: () => createPlayerSettings,
+  createSeatColorsReducer: () => createSeatColorsReducer,
+  createShellReducers: () => createShellReducers,
+  defaultProfileSelectionState: () => defaultProfileSelectionState,
+  defaultSeatColorsState: () => defaultSeatColorsState,
+  forgetProfileAchievements: () => forgetProfileAchievements,
+  humanSeatsFor: () => humanSeatsFor,
+  imageGameIcon: () => imageGameIcon,
+  liveplayActions: () => liveplayActions,
+  liveplayReducer: () => liveplaySlice_default,
+  onProfileRemoved: () => onProfileRemoved,
+  opponentActions: () => opponentActions,
+  opponentReducer: () => opponentSlice_default,
+  profileSelectionActions: () => profileSelectionActions,
+  profileSelectionReducer: () => profileSelectionSlice_default,
+  roundModeFor: () => roundModeFor,
+  safeBack: () => import_core8.safeBack,
+  seatColorsActions: () => seatColorsActions,
+  seatPlayerKey: () => seatPlayerKey,
+  seatTwoFor: () => seatTwoFor,
+  useActiveRound: () => useActiveRound,
+  useAppSettings: () => useAppSettings,
+  useGameGuide: () => useGameGuide,
+  useOpponent: () => useOpponent,
+  usePack: () => usePack,
+  usePackGame: () => usePackGame,
+  useProfiles: () => useProfiles,
+  useSeatColors: () => useSeatColors
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/PackContext.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var PackContext = (0, import_react.createContext)(null);
+function PackProvider({ pack, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PackContext.Provider, { value: pack, children });
+}
+function usePack() {
+  const pack = (0, import_react.useContext)(PackContext);
+  if (!pack) throw new Error("usePack must be used within a PackProvider");
+  return pack;
+}
+function usePackGame(id) {
+  return usePack().games.find((g) => g.id === id);
+}
+
+// src/RootLayout.tsx
+var import_auto_paper2 = require("@rific/auto-paper");
+var import_feedback_press2 = require("@rific/feedback-press");
+var import_toaster2 = require("@rific/toaster");
+var import_core6 = require("@tastic/core");
+var import_hud2 = require("@tastic/hud");
+var Haptics = __toESM(require("expo-haptics"));
+var import_expo_router = require("expo-router");
+var import_expo_sensors = require("expo-sensors");
+var import_react9 = require("react");
+var import_react_native2 = require("react-native");
+var import_react_native_gesture_handler = require("react-native-gesture-handler");
+var RNPaper2 = __toESM(require("react-native-paper"));
+var import_react_native_safe_area_context = require("react-native-safe-area-context");
+
+// src/components/Fonts.tsx
+var import_vector_icons = require("@expo/vector-icons");
+var import_expo_constants = __toESM(require("expo-constants"));
+var import_expo_font = require("expo-font");
+var import_head = __toESM(require("expo-router/head"));
+var import_react_native = require("react-native");
+
+// src/splashGate.ts
+var import_splash_gate = require("@rific/splash-gate");
+var { markReady: markSplashReady, useReady: useSplashReady, pendingGates: pendingSplashGates, Gate: SplashGate } = (0, import_splash_gate.createGate)(["theme", "fonts", "profiles"]);
+
+// src/components/Fonts.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function Fonts({ children }) {
+  const pack = usePack();
+  const [loaded, error] = (0, import_expo_font.useFonts)({ ...pack.fonts, ...import_vector_icons.MaterialCommunityIcons.font });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+    import_react_native.Platform.OS === "web" && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_head.default, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("title", { children: import_expo_constants.default.expoConfig?.name }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SplashGate, { gate: "fonts", ready: loaded || !!error, children })
+  ] });
+}
+
+// src/components/GuideHost.tsx
+var import_core = require("@tastic/core");
+var import_guide = require("@tastic/hud/guide");
+var import_react2 = require("react");
+var import_react_redux = require("react-redux");
+
+// src/types.ts
+function roundModeFor(seatTwo) {
+  return seatTwo === "person" ? "twoPlayer" : seatTwo === "nobody" ? "solo" : "vsCpu";
+}
+function seatTwoFor(saved, choices) {
+  if (!choices) return "nobody";
+  return choices.includes(saved) ? saved : "cpu";
+}
+function humanSeatsFor(mode) {
+  return mode === "twoPlayer" ? [1, 2] : [1];
+}
+
+// src/components/GuideHost.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var GameGuideContext = (0, import_react2.createContext)(null);
+function GuideHost({ children }) {
+  const pack = usePack();
+  const [gameId, setGameId] = (0, import_react2.useState)(pack.games[0].id);
+  const game = pack.games.find((g) => g.id === gameId) ?? pack.games[0];
+  const rotation = (0, import_core.useRotation)();
+  const touch = (0, import_core.useIsTouchPrimaryDevice)();
+  const seatTwo = (0, import_react_redux.useSelector)((state) => state.opponent.seatTwo);
+  const input = (0, import_react_redux.useSelector)((state) => game.guide.selectInput(state), import_react_redux.shallowEqual);
+  const seenVersion = (0, import_react_redux.useSelector)((state) => game.guide.selectVersionSeen(state));
+  const dispatch = (0, import_react_redux.useDispatch)();
+  const mode = roundModeFor(seatTwoFor(seatTwo, game.seatTwo));
+  const steps = (0, import_react2.useMemo)(() => game.guide.getSteps(input, { touch, mode }), [game, input, touch, mode]);
+  const onSeen = (0, import_react2.useCallback)((version) => dispatch(game.guide.markSeen(version)), [dispatch, game]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_guide.GuideProvider, { steps, currentVersion: game.guide.version, seenVersion, onSeen, rotation, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(GameGuideBridge, { onPick: setGameId, children }) });
+}
+function GameGuideBridge({ onPick, children }) {
+  const pack = usePack();
+  const store = (0, import_react_redux.useStore)();
+  const { isOpen, open } = (0, import_guide.useGuide)();
+  const pendingNext = (0, import_react2.useRef)(null);
+  const wasOpen = (0, import_react2.useRef)(false);
+  (0, import_react2.useEffect)(() => {
+    if (wasOpen.current && !isOpen && pendingNext.current) {
+      const next = pendingNext.current;
+      pendingNext.current = null;
+      next();
+    }
+    wasOpen.current = isOpen;
+  }, [isOpen]);
+  const openFor = (0, import_react2.useCallback)(
+    (gameId) => {
+      onPick(gameId);
+      open();
+    },
+    [onPick, open]
+  );
+  const openFirstTime = (0, import_react2.useCallback)(
+    (gameId, next) => {
+      const game = pack.games.find((g) => g.id === gameId);
+      if (!game || game.guide.selectVersionSeen(store.getState()) >= game.guide.version) {
+        next();
+        return;
+      }
+      pendingNext.current = next;
+      openFor(gameId);
+    },
+    [pack, store, openFor]
+  );
+  const value = (0, import_react2.useMemo)(() => ({ openFirstTime, openFor }), [openFirstTime, openFor]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(GameGuideContext.Provider, { value, children });
+}
+function useGameGuide() {
+  const ctx = (0, import_react2.useContext)(GameGuideContext);
+  if (!ctx) throw new Error("useGameGuide must be used within a GuideHost");
+  return ctx;
+}
+
+// src/components/Providers.tsx
+var import_core2 = require("@rific/core");
+var import_feedback_press = require("@rific/feedback-press");
+var import_audio = require("@rific/feedback-press/audio");
+var import_edge_guard = require("@tastic/edge-guard");
+var ExpoKeepAwake = __toESM(require("expo-keep-awake"));
+var import_react3 = require("react");
+var RNPaper = __toESM(require("react-native-paper"));
+var import_react_redux2 = require("react-redux");
+var import_react4 = require("redux-persist/integration/react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var FeedbackBridge = ({ children }) => {
+  const haptic = (0, import_react_redux2.useSelector)((state) => state.haptic);
+  const sound = (0, import_react_redux2.useSelector)((state) => state.sound);
+  const dispatch = (0, import_react_redux2.useDispatch)();
+  const onChange = (0, import_react3.useCallback)((next) => dispatch(import_feedback_press.hapticActions.initialize(next)), [dispatch]);
+  const onSoundChange = (0, import_react3.useCallback)((next) => dispatch(import_feedback_press.soundActions.initialize(next)), [dispatch]);
+  const playSelection = (0, import_audio.useAudioPool)(require("./select-MLBNNA4N.wav"));
+  const playNotification = (0, import_audio.useAudioPool)(require("./notification-CGGFPYK7.wav"));
+  const bridgeProps = (0, import_feedback_press.useFeedbackBridgeProps)({ initialValue: haptic, onChange, soundInitialValue: sound, onSoundChange, sound: { selection: playSelection, notification: playNotification } });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_feedback_press.FeedbackPressProvider, { ...bridgeProps, paper: RNPaper, children });
+};
+var EdgeGuardBridge = ({ children }) => {
+  const deferBottomEdgeGestures = (0, import_react_redux2.useSelector)((state) => state.appSettings.deferBottomEdgeGestures);
+  const activelyPlaying = (0, import_react_redux2.useSelector)((state) => state.liveplay.activelyPlaying);
+  (0, import_edge_guard.useEdgeGestureGuard)(deferBottomEdgeGestures && activelyPlaying);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, { children });
+};
+var KeepAwakeBridge = ({ children }) => {
+  const keepAwake = (0, import_react_redux2.useSelector)((state) => state.keepAwake);
+  const dispatch = (0, import_react_redux2.useDispatch)();
+  const onChange = (0, import_react3.useCallback)((settings) => dispatch(import_core2.keepAwakeActions.initialize(settings)), [dispatch]);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_core2.KeepAwakeProvider, { expoKeepAwake: ExpoKeepAwake, initialValue: keepAwake, onChange, children });
+};
+function Providers({ store, persistor, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_redux2.Provider, { store, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react4.PersistGate, { persistor, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(EdgeGuardBridge, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FeedbackBridge, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(KeepAwakeBridge, { children }) }) }) }) });
+}
+
+// src/components/Theme.tsx
+var import_masked_view = __toESM(require("@react-native-masked-view/masked-view"));
+var import_auto_paper = require("@rific/auto-paper");
+var ExpoBlur = __toESM(require("expo-blur"));
+var SplashScreen = __toESM(require("expo-splash-screen"));
+var import_react5 = require("react");
+var import_react_native_reanimated = __toESM(require("react-native-reanimated"));
+var import_react_redux3 = require("react-redux");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+SplashScreen.preventAutoHideAsync();
+SplashScreen.setOptions({ fade: true, duration: 400 });
+function Theme({ children }) {
+  const { fontFamily } = usePack();
+  const settings = (0, import_react_redux3.useSelector)((state) => state.theme, import_react_redux3.shallowEqual);
+  const dispatch = (0, import_react_redux3.useDispatch)();
+  const onReady = (0, import_react5.useCallback)(() => markSplashReady("theme"), []);
+  const onChange = (0, import_react5.useCallback)((next) => dispatch(import_auto_paper.themeActions.initialize(next)), [dispatch]);
+  const bridgeProps = (0, import_auto_paper.useThemeBridgeProps)({ initialValue: settings, onChange, onReady });
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_auto_paper.Provider, { ...bridgeProps, expoBlur: ExpoBlur, maskedView: import_masked_view.default, statusBar: false, reanimated: import_react_native_reanimated.default, fontFamily, children });
+}
+
+// src/components/UpdateDialog.tsx
+var import_toaster = require("@rific/toaster");
+var import_core3 = require("@tastic/core");
+var import_hud = require("@tastic/hud");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function UpdateDialog() {
+  const onError = (0, import_toaster.useUpdateErrorToast)();
+  const rotation = (0, import_core3.useRotation)();
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_hud.UpdateDialog, { onError, rotation });
+}
+
+// src/hooks/useAppSettings.ts
+var import_react6 = require("react");
+var import_react_redux4 = require("react-redux");
+
+// src/redux/appSettingsSlice.ts
+var import_core4 = require("@rific/core");
+var DEFAULT_APP_SETTINGS = {
+  lockOrientation: false,
+  deferBottomEdgeGestures: false
+};
+var { actions, reducer } = (0, import_core4.createSettingsSlice)("appSettings", {
+  initialState: DEFAULT_APP_SETTINGS,
+  initializeMode: "merge",
+  fieldSetters: []
+});
+var appSettingsActions = actions;
+var appSettingsSlice_default = reducer;
+
+// src/hooks/useAppSettings.ts
+function useAppSettings() {
+  const settings = (0, import_react_redux4.useSelector)((state) => state.appSettings);
+  const dispatch = (0, import_react_redux4.useDispatch)();
+  const setSettings = (0, import_react6.useCallback)(
+    (patch) => {
+      dispatch(appSettingsActions.initialize(patch));
+    },
+    [dispatch]
+  );
+  return { settings, setSettings };
+}
+
+// src/hooks/useLastActiveGame.tsx
+var import_react7 = require("react");
+var import_react_redux5 = require("react-redux");
+
+// src/redux/lastActiveGameSlice.ts
+var import_core5 = require("@rific/core");
+var { actions: actions2, reducer: reducer2 } = (0, import_core5.createSettingsSlice)("lastActiveGame", { initialState: { gameId: null } });
+var lastActiveGameActions = actions2;
+var lastActiveGameSlice_default = reducer2;
+
+// src/hooks/useLastActiveGame.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var LastActiveGameContext = (0, import_react7.createContext)(null);
+function LastActiveGameProvider({ children }) {
+  const store = (0, import_react_redux5.useStore)();
+  const dispatch = (0, import_react_redux5.useDispatch)();
+  const [initial] = (0, import_react7.useState)(() => store.getState().lastActiveGame?.gameId ?? null);
+  const pendingResume = (0, import_react7.useRef)(initial);
+  const persisted = (0, import_react7.useRef)(initial);
+  const value = (0, import_react7.useMemo)(
+    () => ({
+      consumeResumeGame: () => {
+        const game = pendingResume.current;
+        pendingResume.current = null;
+        return game;
+      },
+      setLastActiveGame: (gameId) => {
+        pendingResume.current = null;
+        if (persisted.current === gameId) return;
+        persisted.current = gameId;
+        dispatch(lastActiveGameActions.setGameId(gameId));
+      },
+      // Called from the play route's unmount cleanup (screens/GameRoute.tsx) - it fires on the play
+      // screen's own back, hardware back, or a browser back, but not on mere app backgrounding, where
+      // the screen stays mounted. That's exactly "explicitly back out."
+      clearLastActiveGame: () => {
+        pendingResume.current = null;
+        if (persisted.current === null) return;
+        persisted.current = null;
+        dispatch(lastActiveGameActions.setGameId(null));
+      }
+    }),
+    [dispatch]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(LastActiveGameContext.Provider, { value, children });
+}
+function useLastActiveGame() {
+  const ctx = (0, import_react7.useContext)(LastActiveGameContext);
+  if (!ctx) throw new Error("useLastActiveGame must be used within a LastActiveGameProvider");
+  return ctx;
+}
+
+// src/hooks/useProfiles.tsx
+var import_profile2 = require("@tastic/profile");
+var import_react8 = require("react");
+var import_react_redux6 = require("react-redux");
+
+// src/redux/profileSelectionSlice.ts
+var import_profile = require("@tastic/profile");
+var defaultProfileSelectionState = { 1: null, 2: null };
+var { actions: actions3, reducer: reducer3 } = (0, import_profile.createProfileSelectionSlice)("pack", defaultProfileSelectionState);
+var profileSelectionActions = actions3;
+var profileSelectionSlice_default = reducer3;
+
+// src/hooks/useProfiles.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var SHARED_GROUP_ID = "group.com.infinitetoken.tastic";
+var ProfilesContext = (0, import_react8.createContext)(null);
+function ProfilesProvider({ children }) {
+  const profiles = (0, import_react_redux6.useSelector)((state) => state.profiles);
+  const lastSelected = (0, import_react_redux6.useSelector)((state) => state.profileSelection);
+  const dispatch = (0, import_react_redux6.useDispatch)();
+  const [loaded, setLoaded] = (0, import_react8.useState)(false);
+  (0, import_react8.useEffect)(() => {
+    let cancelled = false;
+    (0, import_profile2.resolveInitialProfiles)(SHARED_GROUP_ID, profiles).then((resolved) => {
+      if (cancelled) return;
+      dispatch(import_profile2.profilesActions.setAll(resolved));
+      dispatch(profileSelectionActions.pruneToRoster(resolved.map((p) => p.id)));
+      setLoaded(true);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const { syncToShared } = (0, import_profile2.useSharedProfilesSync)({
+    groupId: SHARED_GROUP_ID,
+    onRemoteChange: (0, import_react8.useCallback)(
+      (remote) => {
+        dispatch(import_profile2.profilesActions.setAll(remote));
+        dispatch(profileSelectionActions.pruneToRoster(remote.map((p) => p.id)));
+      },
+      [dispatch]
+    )
+  });
+  const createProfile = (0, import_react8.useCallback)(
+    (input) => {
+      const record = (0, import_profile2.createProfileRecord)(input);
+      dispatch(import_profile2.profilesActions.add(record));
+      syncToShared([...profiles, record]);
+      return record;
+    },
+    [profiles, dispatch, syncToShared]
+  );
+  const updateProfile = (0, import_react8.useCallback)(
+    (id, patch) => {
+      dispatch(import_profile2.profilesActions.update({ id, patch }));
+      syncToShared(profiles.map((p) => p.id === id ? { ...p, ...patch, updatedAt: Date.now() } : p));
+    },
+    [profiles, dispatch, syncToShared]
+  );
+  const deleteProfile = (0, import_react8.useCallback)(
+    (id) => {
+      dispatch(import_profile2.profilesActions.remove(id));
+      syncToShared(profiles.filter((p) => p.id !== id));
+      dispatch(profileSelectionActions.clearProfile(id));
+    },
+    [profiles, dispatch, syncToShared]
+  );
+  const selectProfile = (0, import_react8.useCallback)(
+    (seat, profileId) => {
+      dispatch(profileSelectionActions.select({ profileId, seat }));
+    },
+    [dispatch]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ProfilesContext.Provider, { value: { profiles, lastSelected, loaded, createProfile, updateProfile, deleteProfile, selectProfile }, children });
+}
+function useProfiles() {
+  const ctx = (0, import_react8.useContext)(ProfilesContext);
+  if (!ctx) throw new Error("useProfiles must be used within a ProfilesProvider");
+  return ctx;
+}
+
+// src/RootLayout.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var PLAY_OPTIONS = { statusBarHidden: true };
+function AppStack() {
+  const { dark } = (0, import_auto_paper2.useAutoPaperTheme)();
+  const rootBackground = (0, import_core6.useThemedRootBackground)(dark, false);
+  const statusBar = (0, import_core6.useRotationAwareStatusBar)();
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_expo_router.Stack, { screenOptions: { ...rootBackground, ...statusBar }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_expo_router.Stack.Screen, { name: "index" }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_expo_router.Stack.Screen, { name: "play/[game]", options: PLAY_OPTIONS })
+  ] });
+}
+function OrientationBridge({ children }) {
+  const { settings, setSettings } = useAppSettings();
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_core6.OrientationProvider, { deviceMotion: import_expo_sensors.DeviceMotion, freezeWhileLocked: true, lockInitialValue: { locked: settings.lockOrientation, rotation: settings.lockedRotation }, onLockChange: (next) => setSettings({ lockOrientation: next.locked, lockedRotation: next.rotation }), children });
+}
+function GatedApp({ children }) {
+  const { loaded } = useProfiles();
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(SplashGate, { gate: "profiles", ready: loaded, children });
+}
+function HapticGatedToastProvider({ children }) {
+  const { settings } = (0, import_feedback_press2.useHapticSettings)();
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_toaster2.ToastProvider, { haptics: settings.vibrate ? Haptics : void 0, paper: RNPaper2, children });
+}
+function RotatingToaster() {
+  const renderFrame = (0, import_react9.useCallback)(
+    (toasts) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_hud2.RotatedFrame, { rotatedSafeArea: true, passThrough: true, children: toasts }),
+    []
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_toaster2.Toaster, { historyButton: null, clearButton: null, limit: 3, renderFrame });
+}
+function GameProviders({ games, children }) {
+  return games.reduceRight((inner, game) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(game.Provider, { children: inner }, game.id), children);
+}
+function RootLayout({ pack, store, persistor }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_react_native_gesture_handler.GestureHandlerRootView, { style: styles.root, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_react_native_safe_area_context.SafeAreaProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(PackProvider, { pack, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Fonts, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Providers, { store, persistor, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Theme, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(ProfilesProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(LastActiveGameProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(GameProviders, { games: pack.games, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(GatedApp, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(OrientationBridge, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(HapticGatedToastProvider, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(GuideHost, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(AppStack, {}) }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(RotatingToaster, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(UpdateDialog, {})
+  ] }) }) }) }) }) }) }) }) }) }) }) });
+}
+var styles = import_react_native2.StyleSheet.create({
+  root: { flex: 1 }
+});
+
+// src/screens/GameRoute.tsx
+var import_expo_router5 = require("expo-router");
+var import_react14 = require("react");
+
+// src/screens/LoadoutScreen.tsx
+var import_auto_paper4 = require("@rific/auto-paper");
+var import_core10 = require("@tastic/core");
+var import_hud5 = require("@tastic/hud");
+var import_split_screen = require("@tastic/split-screen");
+var import_expo_router4 = require("expo-router");
+var import_react13 = require("react");
+var import_react_native4 = require("react-native");
+var import_react_native_reanimated2 = __toESM(require("react-native-reanimated"));
+var import_react_native_safe_area_context2 = require("react-native-safe-area-context");
+var import_react_redux9 = require("react-redux");
+
+// src/components/SeatTwoPanel.tsx
+var import_hud3 = require("@tastic/hud");
+var import_profile3 = require("@tastic/profile");
+var import_react10 = require("react");
+var import_react_native3 = require("react-native");
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var CPU_PREFIX = "cpu:";
+var PROFILE_PREFIX = "profile:";
+var NOBODY = "nobody";
+var GUEST = "guest";
+var GUEST_ICON = "account-outline";
+var NOBODY_ICON = "account-off-outline";
+var CPU_ICON = "robot";
+function getSeatTwoPopoverId(idPrefix) {
+  return `${idPrefix}-seat`;
+}
+function SeatTwoPanel({ idPrefix, host, choices, seatTwo, onSeatTwoChange, cpuDifficulty, profiles, selectedProfileId, onProfileSelect, color, onColorChange, swatches, takenColor, allowSwapTaken, colorCaption, dark, secondPicker, secondPickerId, ready, onToggleReady, showReadyButton = true }) {
+  const isPerson = seatTwo === "person";
+  const selectedProfile = isPerson ? profiles.find((p) => p.id === selectedProfileId) ?? null : null;
+  const cpuOptions = cpuDifficulty?.options;
+  const options = (0, import_react10.useMemo)(() => {
+    const list = [];
+    if (choices.includes("cpu")) list.push(...cpuOptions ? cpuOptions.map((o) => ({ value: `${CPU_PREFIX}${o.value}`, label: o.label, icon: o.icon })) : [{ value: CPU_PREFIX, label: "CPU", icon: CPU_ICON }]);
+    if (choices.includes("nobody")) list.push({ value: NOBODY, label: "Nobody", icon: NOBODY_ICON });
+    if (choices.includes("person")) {
+      list.push({ value: GUEST, label: "Player 2", icon: GUEST_ICON });
+      list.push(...[...profiles].sort((a, b) => a.name.localeCompare(b.name)).map((p) => ({ value: `${PROFILE_PREFIX}${p.id}`, label: p.name, icon: "account", color: p.color })));
+    }
+    return list;
+  }, [choices, cpuOptions, profiles]);
+  const value = seatTwo === "cpu" ? `${CPU_PREFIX}${cpuDifficulty?.value ?? ""}` : seatTwo === "nobody" ? NOBODY : selectedProfile ? `${PROFILE_PREFIX}${selectedProfile.id}` : GUEST;
+  const icon = seatTwo === "cpu" ? CPU_ICON : seatTwo === "nobody" ? NOBODY_ICON : selectedProfile ? "account" : GUEST_ICON;
+  const handleChange = (next) => {
+    if (next.startsWith(CPU_PREFIX)) {
+      cpuDifficulty?.onChange(next.slice(CPU_PREFIX.length));
+      onSeatTwoChange("cpu");
+    } else if (next === NOBODY) {
+      onSeatTwoChange("nobody");
+    } else {
+      onProfileSelect(next.startsWith(PROFILE_PREFIX) ? next.slice(PROFILE_PREFIX.length) : null);
+      onSeatTwoChange("person");
+    }
+  };
+  const colorSection = seatTwo === "nobody" ? void 0 : { value: color, onChange: onColorChange, swatches, takenValue: takenColor, allowSwapTaken, caption: selectedProfile ? colorCaption : void 0 };
+  const pickerId = getSeatTwoPopoverId(idPrefix);
+  const size = (0, import_profile3.getOptionPickerContentSize)(options.length, colorSection);
+  const align = (0, import_hud3.useZoneClampedAlign)(host.openId === pickerId, size.width, size.height);
+  const ownPopoverOpen = host.openId?.startsWith(`${idPrefix}-`) ?? false;
+  const pickerRowOpen = secondPickerId !== void 0 && host.openId === secondPickerId;
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_react_native3.View, { style: [styles2.panel, ownPopoverOpen && styles2.panelOpen], children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_profile3.OptionPicker, { id: pickerId, host, options, value, onChange: handleChange, color, dark, icon, colorSection, alignOverride: align }),
+    isPerson && secondPicker && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_react_native3.View, { style: [styles2.pickerRow, pickerRowOpen && styles2.pickerRowOpen], children: secondPicker }),
+    isPerson && showReadyButton && onToggleReady && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_hud3.ReadyButton, { color, ready: ready ?? false, onToggleReady })
+  ] });
+}
+var styles2 = import_react_native3.StyleSheet.create({
+  panel: {
+    alignItems: "center",
+    gap: 12
+  },
+  // A popover escaping this panel needs the panel itself elevated to paint above a later sibling.
+  panelOpen: {
+    zIndex: 100
+  },
+  pickerRow: {
+    alignItems: "center",
+    flexDirection: "row",
+    gap: 12
+  },
+  // Lifts the controls picker's popover above the Ready button below it (each View is its own
+  // stacking context on the web).
+  pickerRowOpen: {
+    zIndex: 100
+  }
+});
+
+// src/components/SettingsDialog.tsx
+var import_toaster3 = require("@rific/toaster");
+var import_hud4 = require("@tastic/hud");
+var import_jsx_runtime11 = require("react/jsx-runtime");
+function SettingsDialog({ visible, onDismiss, rotation = 0, onShowHowToPlay, children }) {
+  const onUpdateError = (0, import_toaster3.useUpdateErrorToast)();
+  const { settings, setSettings } = useAppSettings();
+  const { otaVersion, SettingsSections } = usePack();
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_hud4.BaseSettingsDialog, { visible, onDismiss, rotation, version: otaVersion, lockOrientation: settings.lockOrientation, onLockOrientationChange: (value) => setSettings({ lockOrientation: value }), deferBottomEdgeGestures: settings.deferBottomEdgeGestures, onDeferBottomEdgeGestures: (value) => setSettings({ deferBottomEdgeGestures: value }), onUpdateError, onShowHowToPlay, children: [
+    children,
+    SettingsSections && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(SettingsSections, {})
+  ] });
+}
+
+// src/hooks/useOpponent.ts
+var import_react11 = require("react");
+var import_react_redux7 = require("react-redux");
+
+// src/redux/opponentSlice.ts
+var import_core7 = require("@rific/core");
+var DEFAULT_OPPONENT = { seatTwo: "cpu" };
+var { actions: actions4, reducer: reducer4 } = (0, import_core7.createSettingsSlice)("opponent", {
+  initialState: DEFAULT_OPPONENT
+});
+var opponentActions = actions4;
+var opponentSlice_default = reducer4;
+
+// src/hooks/useOpponent.ts
+function useOpponent() {
+  const seatTwo = (0, import_react_redux7.useSelector)((state) => state.opponent.seatTwo);
+  const dispatch = (0, import_react_redux7.useDispatch)();
+  const setSeatTwo = (0, import_react11.useCallback)((next) => dispatch(opponentActions.setSeatTwo(next)), [dispatch]);
+  return { seatTwo, setSeatTwo };
+}
+
+// src/hooks/useSeatColors.ts
+var import_auto_paper3 = require("@rific/auto-paper");
+var import_profile5 = require("@tastic/profile");
+var import_expo_router2 = require("expo-router");
+var import_react12 = require("react");
+var import_react_redux8 = require("react-redux");
+
+// src/redux/seatColorsSlice.ts
+var import_profile4 = require("@tastic/profile");
+function defaultSeatColorsState(seatColors) {
+  return { lastGuestColor: { 1: seatColors[1], 2: seatColors[2] }, lastCpuColor: seatColors[2], profileColors: {} };
+}
+function createSeatColorsReducer(seatColors) {
+  return (0, import_profile4.createSeatColorsSlice)("pack", defaultSeatColorsState(seatColors)).reducer;
+}
+var seatColorsActions = (0, import_profile4.createSeatColorsSlice)("pack", defaultSeatColorsState({ 1: "", 2: "" })).actions;
+
+// src/hooks/useSeatColors.ts
+function useSeatColors(p2IsHuman) {
+  const { colors: themeColors } = (0, import_auto_paper3.useAutoPaperTheme)();
+  const { set: setThemeColor } = (0, import_auto_paper3.useThemeSettings)();
+  const p1Color = themeColors.primary;
+  const p2Color = themeColors.secondary;
+  const { profiles, lastSelected } = useProfiles();
+  const { seatColors } = usePack();
+  const seatDefaultColors = [seatColors[1], seatColors[2]];
+  const dispatch = (0, import_react_redux8.useDispatch)();
+  const guestColors = (0, import_react_redux8.useSelector)((state) => state.seatColors.lastGuestColor);
+  const cpuColor = (0, import_react_redux8.useSelector)((state) => state.seatColors.lastCpuColor);
+  const profileColors = (0, import_react_redux8.useSelector)((state) => state.seatColors.profileColors);
+  const p1Profile = profiles.find((p) => p.id === lastSelected[1]) ?? null;
+  const p2Profile = p2IsHuman ? profiles.find((p) => p.id === lastSelected[2]) ?? null : null;
+  const p1ProfileRef = (0, import_react12.useRef)(p1Profile);
+  const p2ProfileRef = (0, import_react12.useRef)(p2Profile);
+  const guestColorsRef = (0, import_react12.useRef)(guestColors);
+  const cpuColorRef = (0, import_react12.useRef)(cpuColor);
+  const profileColorsRef = (0, import_react12.useRef)(profileColors);
+  (0, import_react12.useEffect)(() => {
+    p1ProfileRef.current = p1Profile;
+  }, [p1Profile]);
+  (0, import_react12.useEffect)(() => {
+    p2ProfileRef.current = p2Profile;
+  }, [p2Profile]);
+  (0, import_react12.useEffect)(() => {
+    guestColorsRef.current = guestColors;
+  }, [guestColors]);
+  (0, import_react12.useEffect)(() => {
+    cpuColorRef.current = cpuColor;
+  }, [cpuColor]);
+  (0, import_react12.useEffect)(() => {
+    profileColorsRef.current = profileColors;
+  }, [profileColors]);
+  (0, import_react12.useEffect)(() => {
+    const nextP1 = p1Profile ? (0, import_profile5.profileSeatColor)(p1Profile, profileColors) : guestColors[1];
+    const nextP2 = (0, import_profile5.avoidSeatColorClash)(nextP1, p2Profile ? (0, import_profile5.profileSeatColor)(p2Profile, profileColors) : p2IsHuman ? guestColors[2] : cpuColor, seatDefaultColors);
+    if (nextP1.toLowerCase() === p1Color.toLowerCase() && nextP2.toLowerCase() === p2Color.toLowerCase()) return;
+    setThemeColor({ color: { primary: nextP1, secondary: nextP2, tertiary: (0, import_auto_paper3.getThirdColor)(nextP1, nextP2) } });
+  }, [lastSelected[1], lastSelected[2], p2IsHuman, guestColors, cpuColor, profileColors, profiles.length]);
+  (0, import_expo_router2.useFocusEffect)(
+    (0, import_react12.useCallback)(() => {
+      const guest = guestColorsRef.current;
+      const cpu = cpuColorRef.current;
+      const p1Prof = p1ProfileRef.current;
+      const p2Prof = p2ProfileRef.current;
+      const picks = profileColorsRef.current;
+      const nextP1 = p1Prof ? (0, import_profile5.profileSeatColor)(p1Prof, picks) : guest[1];
+      const nextP2 = (0, import_profile5.avoidSeatColorClash)(nextP1, p2Prof ? (0, import_profile5.profileSeatColor)(p2Prof, picks) : p2IsHuman ? guest[2] : cpu, seatDefaultColors);
+      setThemeColor({ color: { primary: nextP1, secondary: nextP2, tertiary: (0, import_auto_paper3.getThirdColor)(nextP1, nextP2) } });
+    }, [lastSelected[1], lastSelected[2], p2IsHuman, setThemeColor])
+  );
+  const persistSeatColor = (0, import_react12.useCallback)(
+    (seat, hex) => {
+      const profile = seat === 1 ? p1Profile : p2Profile;
+      if (profile) {
+        dispatch(seatColorsActions.setProfileColor({ profile, color: hex }));
+        return;
+      }
+      if (seat === 2 && !p2IsHuman) {
+        dispatch(seatColorsActions.setLastCpuColor(hex));
+        return;
+      }
+      dispatch(seatColorsActions.setLastGuestColor({ seat, color: hex }));
+    },
+    [p1Profile, p2Profile, p2IsHuman, dispatch]
+  );
+  const handleP1ColorChange = (0, import_react12.useCallback)(
+    (hex) => {
+      const swapped = hex.toLowerCase() === p2Color.toLowerCase();
+      const nextP2 = swapped ? p1Color : p2Color;
+      setThemeColor({ color: { primary: hex, secondary: nextP2, tertiary: (0, import_auto_paper3.getThirdColor)(hex, nextP2) } });
+      persistSeatColor(1, hex);
+      if (swapped) persistSeatColor(2, nextP2);
+    },
+    [setThemeColor, p1Color, p2Color, persistSeatColor]
+  );
+  const handleP2ColorChange = (0, import_react12.useCallback)(
+    (hex) => {
+      const swapped = hex.toLowerCase() === p1Color.toLowerCase();
+      const nextP1 = swapped ? p2Color : p1Color;
+      setThemeColor({ color: { primary: nextP1, secondary: hex, tertiary: (0, import_auto_paper3.getThirdColor)(nextP1, hex) } });
+      persistSeatColor(2, hex);
+      if (swapped) persistSeatColor(1, nextP1);
+    },
+    [setThemeColor, p1Color, p2Color, persistSeatColor]
+  );
+  return { p1Color, p2Color, handleP1ColorChange, handleP2ColorChange };
+}
+
+// src/navigation.ts
+var import_core8 = require("@rific/core");
+var import_expo_router3 = require("expo-router");
+(0, import_core8.configureNavigation)({ router: import_expo_router3.router });
+
+// src/redux/liveplaySlice.ts
+var import_core9 = require("@rific/core");
+var { actions: actions5, reducer: reducer5 } = (0, import_core9.createSettingsSlice)("liveplay", {
+  initialState: { activelyPlaying: false, activeRound: null }
+});
+var liveplayActions = actions5;
+var liveplaySlice_default = reducer5;
+
+// src/screens/LoadoutScreen.tsx
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var PANEL_SWAP_FADE_MS = 180;
+function LoadoutScreen({ game }) {
+  const pack = usePack();
+  const { seatTwo: savedSeatTwo, setSeatTwo } = useOpponent();
+  const seatTwo = seatTwoFor(savedSeatTwo, game.seatTwo);
+  const mode = roundModeFor(seatTwo);
+  const humanSeats = (0, import_react13.useMemo)(() => humanSeatsFor(mode), [mode]);
+  const p2IsHuman = mode === "twoPlayer";
+  const p2Exists = mode !== "solo";
+  const loadout = game.useLoadout(mode);
+  const { openFor } = useGameGuide();
+  const { profiles, lastSelected, selectProfile } = useProfiles();
+  const { orientationMode, p1OnRight, upsideDown, resolved: p1OnRightResolved } = (0, import_core10.useOrientationState)();
+  const fixedSeats = p2IsHuman && (!!game.twoPlayerSeats?.faceToFaceOnWeb || import_react_native4.Platform.OS !== "web");
+  const fixedUpsideDown = !!game.twoPlayerSeats?.followUpsideDown && orientationMode === "faceToFace" && upsideDown;
+  const { panelLayout, panelFadeStyle } = (0, import_split_screen.useDualZoneLayout)(fixedSeats ? "faceToFace" : orientationMode, fixedSeats ? true : p1OnRight, fixedSeats || p1OnRightResolved, fixedSeats ? fixedUpsideDown : upsideDown, PANEL_SWAP_FADE_MS);
+  const [settingsOpen, setSettingsOpen] = (0, import_react13.useState)(false);
+  const rotation = (0, import_core10.getViewRotation)(panelLayout.orientationMode, panelLayout.p1OnRight, panelLayout.upsideDown);
+  const insets = (0, import_core10.rotateInsets)((0, import_react_native_safe_area_context2.useSafeAreaInsets)(), rotation);
+  const { colors: themeColors, dark } = (0, import_auto_paper4.useAutoPaperTheme)();
+  const { p1Color, p2Color, handleP1ColorChange, handleP2ColorChange } = useSeatColors(p2IsHuman);
+  const dispatch = (0, import_react_redux9.useDispatch)();
+  const handleP1ProfileSelect = (0, import_react13.useCallback)((profile) => selectProfile(1, profile?.id ?? null), [selectProfile]);
+  const handleP2ProfileSelect = (0, import_react13.useCallback)((profileId) => selectProfile(2, profileId), [selectProfile]);
+  const [ready, setReady] = (0, import_react13.useState)({ 1: false, 2: false });
+  (0, import_expo_router4.useFocusEffect)(
+    (0, import_react13.useCallback)(() => {
+      setReady({ 1: false, 2: false });
+    }, [setReady])
+  );
+  const changeSeatTwo = (0, import_react13.useCallback)(
+    (next) => {
+      setReady({ 1: false, 2: false });
+      setSeatTwo(next);
+    },
+    [setSeatTwo, setReady]
+  );
+  const roundSettingsRef = (0, import_react13.useRef)(loadout.roundSettings);
+  (0, import_react13.useEffect)(() => {
+    roundSettingsRef.current = loadout.roundSettings;
+  }, [loadout.roundSettings]);
+  (0, import_react13.useEffect)(() => {
+    if (!humanSeats.every((s) => ready[s])) return;
+    dispatch(liveplayActions.setActiveRound({ game: game.id, mode, settings: roundSettingsRef.current }));
+    import_expo_router4.router.push({ pathname: "/play/[game]", params: { game: game.id } });
+  }, [ready, humanSeats, game.id, mode, dispatch]);
+  const bg = dark ? "#000000" : "#FFFFFF";
+  const fg = dark ? "#FFFFFF" : "#000000";
+  const fgMuted = dark ? "rgba(255,255,255,0.5)" : "rgba(0,0,0,0.5)";
+  const isPortrait = panelLayout.orientationMode === "faceToFace";
+  const showMetaInSharedBand = (0, import_split_screen.needsSharedNeutralZone)(panelLayout.orientationMode, humanSeats.length);
+  const p2ZoneStyle = p2IsHuman ? isPortrait ? styles3.p2ZoneTop : panelLayout.p1OnRight ? styles3.p2ZoneLeft : styles3.p2ZoneRight : null;
+  const showReadyButton = p2IsHuman;
+  const controlsHost = (0, import_hud5.usePopoverHost)();
+  const p2PanelHost = (0, import_hud5.usePopoverHost)();
+  const p2Host = p2IsHuman ? p2PanelHost : controlsHost;
+  const anyPlayerPickerOpen = !!(controlsHost.openId?.startsWith("p1-") || controlsHost.openId?.startsWith("p2-"));
+  const optionsRow = loadout.options({
+    host: controlsHost,
+    rotation,
+    accentColor: themeColors.tertiary,
+    mutedColor: fgMuted,
+    onAccentColor: themeColors.onTertiary,
+    dark,
+    // Left out (the row's own actions unrendered) whenever the shared band below carries them.
+    onRandomize: showMetaInSharedBand ? void 0 : loadout.randomize,
+    onReset: showMetaInSharedBand ? void 0 : loadout.reset
+  });
+  const optionsPopoverOpen = controlsHost.openId !== null && loadout.optionIds.includes(controlsHost.openId);
+  const sharedControls = showMetaInSharedBand ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_hud5.SharedActionBand, { onBack: import_core8.safeBack, onSettings: () => setSettingsOpen(true), onRandomize: loadout.randomize, onReset: loadout.reset, fg, popoverOpen: optionsPopoverOpen, children: optionsRow }) : optionsRow;
+  const controlLook = { accentColor: themeColors.tertiary, mutedColor: fgMuted, dark, rotation };
+  const p1Control = loadout.seatControl(1, controlsHost, { ...controlLook, seatColor: p1Color });
+  const p1Panel = /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_hud5.PlayerSetupPanel, { idPrefix: "p1", host: controlsHost, color: p1Color, onColorChange: handleP1ColorChange, swatches: import_auto_paper4.defaultColors, takenColor: p2Exists ? p2Color : void 0, allowSwapTaken: mode === "vsCpu", colorCaption: pack.colorCaption, isHuman: true, ready: ready[1], onToggleReady: () => setReady((r) => ({ ...r, 1: !r[1] })), dark, showReadyButton, secondPicker: p1Control, secondPickerId: p1Control ? "p1-control" : void 0, profiles, selectedProfileId: lastSelected[1], takenProfileId: p2IsHuman ? lastSelected[2] : null, guestLabel: "P1", onProfileSelect: handleP1ProfileSelect, onManageProfiles: () => import_expo_router4.router.push("/profiles") });
+  const p2Control = p2IsHuman ? loadout.seatControl(2, p2Host, { ...controlLook, seatColor: p2Color }) : void 0;
+  const p2Panel = game.seatTwo && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(SeatTwoPanel, { idPrefix: "p2", host: p2Host, choices: game.seatTwo, seatTwo, onSeatTwoChange: changeSeatTwo, cpuDifficulty: loadout.cpuDifficulty, profiles, selectedProfileId: lastSelected[2], onProfileSelect: handleP2ProfileSelect, color: p2Color, onColorChange: handleP2ColorChange, swatches: import_auto_paper4.defaultColors, takenColor: p1Color, allowSwapTaken: mode === "vsCpu", colorCaption: pack.colorCaption, dark, secondPicker: p2Control, secondPickerId: p2Control ? "p2-control" : void 0, ready: ready[2], onToggleReady: () => setReady((r) => ({ ...r, 2: !r[2] })), showReadyButton });
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_react_native4.View, { style: [styles3.container, { backgroundColor: bg }], children: [
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_core10.FakeLandscapeView, { orientationMode: panelLayout.orientationMode, p1OnRight: panelLayout.p1OnRight, upsideDown: panelLayout.upsideDown, style: styles3.rotatable, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_hud5.PressAwayOverlay, { active: controlsHost.openId !== null, onPress: controlsHost.close }),
+      p2ZoneStyle && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_hud5.PressAwayOverlay, { active: controlsHost.openId !== null || p2Host.openId !== null, onPress: p2Host.close, style: p2ZoneStyle }),
+      !showMetaInSharedBand && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_hud5.CornerActionButtons, { onBack: import_core8.safeBack, onSettings: () => setSettingsOpen(true), fg, insets }),
+      p2IsHuman ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+        import_split_screen.DualZoneLayout,
+        {
+          panelLayout,
+          panelFadeStyle,
+          p1: p1Panel,
+          p2: p2Panel,
+          shared: sharedControls,
+          p1Elevated: controlsHost.openId?.startsWith("p1-") ?? false,
+          p2Elevated: p2Host.openId !== null,
+          sharedElevated: optionsPopoverOpen
+        }
+      ) : /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_react_native4.View, { style: styles3.stackedZone, children: [
+        sharedControls,
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_react_native_reanimated2.default.View, { style: [styles3.playersRow, anyPlayerPickerOpen && styles3.playersRowOpen, panelFadeStyle], children: [
+          !isPortrait && panelLayout.p1OnRight ? p2Panel : p1Panel,
+          !isPortrait && panelLayout.p1OnRight ? p1Panel : p2Panel
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_hud5.ReadyButton, { color: p1Color, ready: ready[1], onToggleReady: () => setReady((r) => ({ ...r, 1: !r[1] })), style: anyPlayerPickerOpen && styles3.readyButtonHidden })
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(SettingsDialog, { visible: settingsOpen, onDismiss: () => setSettingsOpen(false), rotation, onShowHowToPlay: () => openFor(game.id) })
+  ] });
+}
+var styles3 = import_react_native4.StyleSheet.create({
+  container: {
+    flex: 1
+  },
+  p2ZoneLeft: {
+    bottom: 0,
+    left: 0,
+    position: "absolute",
+    top: 0,
+    width: "50%"
+  },
+  p2ZoneRight: {
+    bottom: 0,
+    position: "absolute",
+    right: 0,
+    top: 0,
+    width: "50%"
+  },
+  p2ZoneTop: {
+    height: "50%",
+    left: 0,
+    position: "absolute",
+    right: 0,
+    top: 0
+  },
+  // The one-human row: seat 1's panel and seat 2's button read as one evenly spaced row of buttons,
+  // at PlayerSetupPanel's own pickerRow gap (12).
+  playersRow: {
+    flexDirection: "row",
+    gap: 12
+  },
+  playersRowOpen: {
+    zIndex: 100
+  },
+  // See anyPlayerPickerOpen: opacity 0 (not display:'none') keeps the button's layout space, and
+  // pointerEvents:'none' keeps the sliver an open menu doesn't cover from being a hidden tap target.
+  readyButtonHidden: {
+    opacity: 0,
+    pointerEvents: "none"
+  },
+  // A real full-bleed box for FakeLandscapeView to size its absolutely-positioned children against.
+  rotatable: {
+    alignItems: "center",
+    flex: 1,
+    gap: 32,
+    justifyContent: "center",
+    paddingHorizontal: 16
+  },
+  stackedZone: {
+    alignItems: "center",
+    gap: 28
+  }
+});
+
+// src/screens/GameRoute.tsx
+var import_jsx_runtime13 = require("react/jsx-runtime");
+function LoadoutRoute() {
+  const { game: id } = (0, import_expo_router5.useLocalSearchParams)();
+  const game = usePackGame(id);
+  if (!game) return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_expo_router5.Redirect, { href: "/" });
+  if (!hasLoadout(game)) return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_expo_router5.Redirect, { href: { pathname: "/play/[game]", params: { game: game.id } } });
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(LoadoutScreen, { game }, game.id);
+}
+function hasLoadout(game) {
+  return !!game.useLoadout;
+}
+function PlayRoute() {
+  const { game: id } = (0, import_expo_router5.useLocalSearchParams)();
+  const game = usePackGame(id);
+  useResumePoint(game?.resumable ? game.id : null);
+  if (!game) return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_expo_router5.Redirect, { href: "/" });
+  const { PlayScreen } = game;
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(PlayScreen, {}, game.id);
+}
+function useResumePoint(gameId) {
+  const { setLastActiveGame, clearLastActiveGame } = useLastActiveGame();
+  (0, import_react14.useEffect)(() => {
+    if (!gameId) return;
+    setLastActiveGame(gameId);
+    return clearLastActiveGame;
+  }, [gameId, setLastActiveGame, clearLastActiveGame]);
+}
+
+// src/screens/HomeScreen.tsx
+var import_auto_paper5 = require("@rific/auto-paper");
+var import_feedback_press3 = require("@rific/feedback-press");
+var import_core12 = require("@tastic/core");
+var import_hud6 = require("@tastic/hud");
+var import_profile6 = require("@tastic/profile");
+var import_expo_router6 = require("expo-router");
+var import_react16 = require("react");
+var import_react_native5 = require("react-native");
+var import_react_native_paper = require("react-native-paper");
+
+// src/hooks/useFrozenWhileHidden.ts
+var import_react15 = require("react");
+function useFrozenWhileHidden(value, hidden) {
+  const [prevHidden, setPrevHidden] = (0, import_react15.useState)(hidden);
+  const [prevValue, setPrevValue] = (0, import_react15.useState)(value);
+  const [frozen, setFrozen] = (0, import_react15.useState)(value);
+  if (hidden !== prevHidden) {
+    setPrevHidden(hidden);
+    if (hidden) setFrozen(prevValue);
+  }
+  if (value !== prevValue) {
+    setPrevValue(value);
+  }
+  return hidden ? frozen : value;
+}
+
+// src/screens/homeLayout.ts
+var import_core11 = require("@tastic/core");
+var import_react_native_safe_area_context3 = require("react-native-safe-area-context");
+var PREVIEW_ASPECT = 360 / 200;
+var ROW_PREVIEW_WIDTH = 92;
+var HOME_WIDE_EDGE_PADDING = 16;
+var HOME_WIDE_PANE_GAP = 16;
+var HOME_WIDE_RIGHT_GUTTER = 56;
+var HOME_WIDE_MAX_CONTENT_WIDTH = 1100;
+var HOME_LEFT_PANE_FRACTION = 0.38;
+var HOME_LEFT_PANE_MIN = 260;
+var HOME_LEFT_PANE_MAX = 340;
+var HOME_GRID_GAP = 12;
+var HOME_MIN_TILE_WIDTH = 140;
+var HOME_MAX_COLUMNS = 3;
+var HOME_TILE_PADDING = 10;
+var HOME_TOP_BAND = 56;
+var HOME_LEFT_PANE_PICKER_HEIGHT = 44;
+var HOME_LEFT_PANE_PICKER_GAP = 12;
+var HOME_LEFT_PANE_BOTTOM_PADDING = 16;
+var HOME_HERO_SIDE_ROOM = 16;
+function computeHomeLayout(windowWidth, windowHeight, insets) {
+  const isWide = windowWidth > windowHeight;
+  if (!isWide) {
+    return { isWide, windowWidth, windowHeight, insets, paddingLeft: 0, paddingRight: 0, leftPaneWidth: 0, rightPaneWidth: 0, columns: 1, tileWidth: 0, previewWidth: 0, heroFit: void 0 };
+  }
+  const usable = windowWidth - insets.left - insets.right;
+  const inner = Math.max(0, usable - HOME_WIDE_EDGE_PADDING - HOME_WIDE_RIGHT_GUTTER);
+  const content = Math.min(inner, HOME_WIDE_MAX_CONTENT_WIDTH);
+  const slack = (inner - content) / 2;
+  const leftPaneWidth = Math.min((0, import_core11.clamp)(Math.round(HOME_LEFT_PANE_FRACTION * content), HOME_LEFT_PANE_MIN, HOME_LEFT_PANE_MAX), Math.max(0, content - HOME_WIDE_PANE_GAP - HOME_MIN_TILE_WIDTH));
+  const rightPaneWidth = Math.max(0, content - HOME_WIDE_PANE_GAP - leftPaneWidth);
+  const columns = (0, import_core11.clamp)(Math.floor((rightPaneWidth + HOME_GRID_GAP) / (HOME_MIN_TILE_WIDTH + HOME_GRID_GAP)), 1, HOME_MAX_COLUMNS);
+  const tileWidth = Math.max(0, Math.floor((rightPaneWidth - (columns - 1) * HOME_GRID_GAP) / columns));
+  const previewWidth = Math.max(0, tileWidth - 2 * HOME_TILE_PADDING);
+  const heroFit = {
+    width: Math.max(0, leftPaneWidth - HOME_HERO_SIDE_ROOM),
+    height: Math.max(0, windowHeight - insets.top - insets.bottom - HOME_TOP_BAND - HOME_LEFT_PANE_PICKER_GAP - HOME_LEFT_PANE_PICKER_HEIGHT - HOME_LEFT_PANE_BOTTOM_PADDING)
+  };
+  return {
+    isWide,
+    windowWidth,
+    windowHeight,
+    insets,
+    paddingLeft: insets.left + HOME_WIDE_EDGE_PADDING + slack,
+    paddingRight: insets.right + HOME_WIDE_RIGHT_GUTTER + slack,
+    leftPaneWidth,
+    rightPaneWidth,
+    columns,
+    tileWidth,
+    previewWidth,
+    heroFit
+  };
+}
+function useHomeLayout() {
+  const { width, height } = (0, import_core11.useRotatedWindowDimensions)();
+  const rotation = (0, import_core11.useRotation)();
+  const insets = (0, import_core11.rotateInsets)((0, import_react_native_safe_area_context3.useSafeAreaInsets)(), rotation);
+  return computeHomeLayout(width, height, insets);
+}
+
+// src/screens/HomeScreen.tsx
+var import_jsx_runtime14 = require("react/jsx-runtime");
+function HomeScreen() {
+  const pack = usePack();
+  const { consumeResumeGame } = useLastActiveGame();
+  const [resumeGame] = (0, import_react16.useState)(() => {
+    const id = consumeResumeGame();
+    return pack.games.find((g) => g.id === id && g.resumable) ?? null;
+  });
+  if (resumeGame) return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_expo_router6.Redirect, { href: { pathname: "/play/[game]", params: { game: resumeGame.id } } });
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(HomeMenu, {});
+}
+function HomeMenu() {
+  const pack = usePack();
+  const rotation = (0, import_core12.useRotation)();
+  const layout = useHomeLayout();
+  const { insets } = layout;
+  const { dark } = (0, import_auto_paper5.useAutoPaperTheme)();
+  const { openFirstTime, openFor } = useGameGuide();
+  const [settingsOpen, setSettingsOpen] = (0, import_react16.useState)(false);
+  const isFocused = (0, import_expo_router6.useIsFocused)();
+  const [appState, setAppState] = (0, import_react16.useState)(import_react_native5.AppState.currentState);
+  (0, import_react16.useEffect)(() => {
+    const subscription = import_react_native5.AppState.addEventListener("change", setAppState);
+    return () => subscription.remove();
+  }, []);
+  const heroActive = isFocused && appState === "active";
+  const { profiles, lastSelected, selectProfile } = useProfiles();
+  const { seatTwo } = useOpponent();
+  const { p1Color, p2Color, handleP1ColorChange } = useSeatColors(seatTwo === "person");
+  const pickerHost = (0, import_hud6.usePopoverHost)();
+  const selectedProfile = profiles.find((p) => p.id === lastSelected[1]) ?? null;
+  const tiled = pack.games.some((game) => game.Preview);
+  const isWide = useFrozenWhileHidden(tiled && layout.isWide, !isFocused);
+  const [previewsRevealed, setPreviewsRevealed] = (0, import_react16.useState)(false);
+  (0, import_react16.useEffect)(() => {
+    if (!tiled) return;
+    const id = requestAnimationFrame(() => setPreviewsRevealed(true));
+    return () => cancelAnimationFrame(id);
+  }, [tiled]);
+  const closePicker = pickerHost.close;
+  (0, import_react16.useEffect)(() => {
+    closePicker();
+  }, [isWide, closePicker]);
+  const bg = dark ? "#000000" : "#FFFFFF";
+  const fg = dark ? "#FFFFFF" : "#000000";
+  const openGame = (0, import_react16.useCallback)((game) => openFirstTime(game.id, () => import_expo_router6.router.push(game.useLoadout ? { pathname: "/loadout/[game]", params: { game: game.id } } : { pathname: "/play/[game]", params: { game: game.id } })), [openFirstTime]);
+  const picker = /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_profile6.ProfilePicker, { idPrefix: "home-p1", host: pickerHost, profiles, selectedId: lastSelected[1], color: p1Color, dark, guestLabel: "P1", onSelect: (profile) => selectProfile(1, profile?.id ?? null), onManage: () => import_expo_router6.router.push("/profiles"), colorSection: { value: p1Color, onChange: handleP1ColorChange, swatches: import_auto_paper5.defaultColors, caption: selectedProfile ? pack.colorCaption : void 0 } });
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_react_native5.View, { style: [styles4.container, { backgroundColor: bg }], children: [
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_core12.FakeLandscapeView, { style: styles4.rotatable, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_hud6.PressAwayOverlay, { active: pickerHost.openId !== null, onPress: pickerHost.close }),
+      isWide ? /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native5.ScrollView, { style: [styles4.wideRightPane, { left: layout.paddingLeft + layout.leftPaneWidth + HOME_WIDE_PANE_GAP }], contentContainerStyle: { paddingTop: 16 + insets.top, paddingBottom: 16 + insets.bottom, paddingRight: layout.paddingRight }, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native5.View, { style: [styles4.grid, { width: layout.rightPaneWidth }], children: pack.games.map((game) => /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(GameTile, { game, width: layout.tileWidth, previewWidth: layout.previewWidth, previewRevealed: previewsRevealed, dark, p1Color, p2Color, onPress: () => openGame(game), onRules: () => openFor(game.id) }, game.id)) }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_react_native5.View, { style: [styles4.wideLeftPane, { left: layout.paddingLeft, width: layout.leftPaneWidth, paddingTop: HOME_TOP_BAND + insets.top, paddingBottom: 16 + insets.bottom }, pickerHost.openId !== null && styles4.pickerOpen], children: [
+          /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(pack.HeroTitle, { words: pack.wordmark, color: fg, p1Color, p2Color, active: heroActive, fit: layout.heroFit }),
+          /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native5.View, { style: styles4.widePicker, children: picker })
+        ] })
+      ] }) : /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_react_native5.ScrollView, { style: styles4.scroll, contentContainerStyle: [styles4.content, { paddingTop: 56 + insets.top, paddingBottom: 24 + insets.bottom, paddingLeft: 16 + insets.left, paddingRight: 16 + insets.right }], children: [
+        /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(pack.HeroTitle, { words: pack.wordmark, color: fg, p1Color, p2Color, active: heroActive }),
+        /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native5.View, { style: [styles4.picker, pickerHost.openId !== null && styles4.pickerOpen], children: picker }),
+        /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native5.View, { style: styles4.list, children: pack.games.map((game) => /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(GameRow, { game, dark, p1Color, p2Color, previewRevealed: previewsRevealed, onPress: () => openGame(game), onRules: () => openFor(game.id) }, game.id)) })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_feedback_press3.IconButton, { icon: "trophy", iconColor: fg, size: 24, style: [styles4.corner, { top: 8 + insets.top, left: 8 + insets.left }], onPress: () => import_expo_router6.router.push("/stats"), accessibilityLabel: "Stats & Achievements" }),
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_feedback_press3.IconButton, { icon: "cog", iconColor: fg, size: 24, style: [styles4.corner, { top: 8 + insets.top, right: 8 + insets.right }], onPress: () => setSettingsOpen(true), accessibilityLabel: "Settings" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(SettingsDialog, { visible: settingsOpen, onDismiss: () => setSettingsOpen(false), rotation })
+  ] });
+}
+function GameRow({ game, dark, p1Color, p2Color, previewRevealed, onPress, onRules }) {
+  const well = (0, import_hud6.useWellColors)();
+  const GameIcon = game.icon;
+  return (
+    // The rules button sits beside the row's own button, laid over its end, not inside it: a button
+    // inside a button is invalid on the web.
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_react_native5.View, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_feedback_press3.Pressable, { onPress, style: [styles4.row, { backgroundColor: well.bg }], accessibilityRole: "button", accessibilityLabel: game.title, children: [
+        game.Preview ? /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(PreviewBox, { game, width: ROW_PREVIEW_WIDTH, revealed: previewRevealed, dark, p1Color, p2Color }) : /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native5.View, { style: [styles4.rowIcon, { backgroundColor: dark ? ICON_DARK_BG : ICON_LIGHT_BG }], children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(GameIcon, { size: ROW_ICON_SIZE, p1Color, p2Color, dark }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_react_native5.View, { style: styles4.rowText, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native_paper.Text, { variant: "titleLarge", style: [styles4.rowTitle, { color: well.fg }], numberOfLines: 1, children: game.title }),
+          /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native_paper.Text, { variant: "bodyMedium", style: { color: well.fgMuted }, numberOfLines: 2, children: game.blurb })
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_feedback_press3.Pressable, { onPress: onRules, style: styles4.rulesButton, hitSlop: 12, accessibilityRole: "button", accessibilityLabel: `${game.title} rules`, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native_paper.Icon, { source: "information-outline", size: 22, color: well.fgMuted }) })
+    ] })
+  );
+}
+function GameTile({ game, width, previewWidth, dark, p1Color, p2Color, previewRevealed, onPress, onRules }) {
+  const well = (0, import_hud6.useWellColors)();
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_react_native5.View, { style: { width }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_feedback_press3.Pressable, { onPress, style: [styles4.tile, { backgroundColor: well.bg }], accessibilityRole: "button", accessibilityLabel: game.title, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(PreviewBox, { game, width: previewWidth, revealed: previewRevealed, dark, p1Color, p2Color }),
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native_paper.Text, { variant: "titleMedium", style: [styles4.rowTitle, { color: well.fg }], numberOfLines: 1, children: game.title }),
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native_paper.Text, { variant: "bodySmall", style: { color: well.fgMuted }, numberOfLines: 3, children: game.blurb })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_feedback_press3.Pressable, { onPress: onRules, style: styles4.tileRulesButton, hitSlop: 12, accessibilityRole: "button", accessibilityLabel: `${game.title} rules`, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native_paper.Icon, { source: "information-outline", size: 20, color: "#FFFFFF" }) })
+  ] });
+}
+function PreviewBox({ game, width, revealed, dark, p1Color, p2Color }) {
+  const height = Math.round(width / PREVIEW_ASPECT);
+  const { Preview, icon: GameIcon } = game;
+  const iconSize = Math.min(height, ROW_ICON_SIZE);
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native5.View, { style: [styles4.preview, { width, height, backgroundColor: dark ? ICON_DARK_BG : ICON_LIGHT_BG }], children: Preview ? revealed && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(Preview, { width, height, p1Color, p2Color, dark }) : /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_native5.View, { style: [styles4.previewIcon, { width: iconSize, height: iconSize, borderRadius: iconSize * 0.22 }], children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(GameIcon, { size: iconSize, p1Color, p2Color, dark }) }) });
+}
+var ROW_ICON_SIZE = 56;
+var ICON_LIGHT_BG = "#FAFAFA";
+var ICON_DARK_BG = "#050505";
+var RULES_BUTTON_SPACE = 44;
+var styles4 = import_react_native5.StyleSheet.create({
+  container: {
+    flex: 1
+  },
+  content: {
+    alignItems: "center",
+    gap: 24
+  },
+  corner: {
+    position: "absolute"
+  },
+  // The wide layout's tiles: wrapped rows of tiles the layout sizes to fill the pane's width.
+  grid: {
+    flexDirection: "row",
+    flexWrap: "wrap",
+    gap: HOME_GRID_GAP
+  },
+  // Solitaire's list: one column, never wider than a phone's, centred on a wide screen.
+  list: {
+    gap: 14,
+    maxWidth: 480,
+    width: "100%"
+  },
+  picker: {
+    alignItems: "center"
+  },
+  pickerOpen: {
+    zIndex: 100
+  },
+  // The preview's own rounding, clipping whatever it draws to the box.
+  preview: {
+    alignItems: "center",
+    borderRadius: 8,
+    justifyContent: "center",
+    overflow: "hidden"
+  },
+  previewIcon: {
+    overflow: "hidden"
+  },
+  rotatable: {
+    flex: 1
+  },
+  // A well (@tastic/hud's wellSurface): the theme's surface on MD3's level-1 shadow, the same surface
+  // as Solitaire's game rows, the stats screen's sections and every dialog.
+  row: {
+    alignItems: "center",
+    borderRadius: 12,
+    boxShadow: import_hud6.WELL_SHADOW,
+    flexDirection: "row",
+    gap: 14,
+    padding: 14,
+    paddingRight: RULES_BUTTON_SPACE
+  },
+  rowIcon: {
+    borderRadius: ROW_ICON_SIZE * 0.22,
+    height: ROW_ICON_SIZE,
+    overflow: "hidden",
+    width: ROW_ICON_SIZE
+  },
+  rowText: {
+    flex: 1,
+    gap: 2
+  },
+  rowTitle: {
+    fontWeight: "bold"
+  },
+  rulesButton: {
+    bottom: 0,
+    justifyContent: "center",
+    position: "absolute",
+    right: 14,
+    top: 0
+  },
+  scroll: {
+    flex: 1
+  },
+  // The same well as a row, turned on its side.
+  tile: {
+    borderRadius: 12,
+    boxShadow: import_hud6.WELL_SHADOW,
+    gap: 6,
+    padding: HOME_TILE_PADDING
+  },
+  // A small translucent disc over the preview's top-right corner, so the white icon reads on whatever
+  // the preview draws. hitSlop (on the Pressable) grows its touch area.
+  tileRulesButton: {
+    alignItems: "center",
+    backgroundColor: "rgba(0, 0, 0, 0.35)",
+    borderRadius: 14,
+    height: 28,
+    justifyContent: "center",
+    position: "absolute",
+    right: HOME_TILE_PADDING + 4,
+    top: HOME_TILE_PADDING + 4,
+    width: 28
+  },
+  // The two panes are absolutely positioned siblings of the press-away overlay, each placed by the
+  // offsets homeLayout.ts computes.
+  wideLeftPane: {
+    alignItems: "center",
+    bottom: 0,
+    justifyContent: "center",
+    pointerEvents: "box-none",
+    position: "absolute",
+    top: 0
+  },
+  widePicker: {
+    marginTop: HOME_LEFT_PANE_PICKER_GAP
+  },
+  wideRightPane: {
+    bottom: 0,
+    position: "absolute",
+    right: 0,
+    top: 0
+  }
+});
+
+// src/screens/ProfilesRoute.tsx
+var import_auto_paper6 = require("@rific/auto-paper");
+var import_profile7 = require("@tastic/profile");
+var import_jsx_runtime15 = require("react/jsx-runtime");
+function ProfilesRoute() {
+  const { profiles, createProfile, updateProfile, deleteProfile } = useProfiles();
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_profile7.ProfilesScreen, { profiles, defaultColor: import_auto_paper6.defaultColors[0].value, onCreate: (patch) => createProfile(patch), onSave: (id, patch) => updateProfile(id, patch), onDelete: deleteProfile, onBack: import_core8.safeBack });
+}
+
+// src/screens/StatsScreen.tsx
+var import_auto_paper7 = require("@rific/auto-paper");
+var import_core13 = require("@tastic/core");
+var import_hud7 = require("@tastic/hud");
+var import_profile8 = require("@tastic/profile");
+var import_react17 = require("react");
+var import_react_native6 = require("react-native");
+var import_react_native_paper2 = require("react-native-paper");
+var import_react_native_safe_area_context4 = require("react-native-safe-area-context");
+var import_react_redux10 = require("react-redux");
+var import_jsx_runtime16 = require("react/jsx-runtime");
+var TABS = [
+  { value: "stats", label: "Stats", icon: "chart-box-outline" },
+  { value: "achievements", label: "Achievements", icon: "trophy-outline" }
+];
+var EVERYONE = "__everyone__";
+var ALL_GAMES = "__all__";
+var PLAYER_PICKER_ID = "stats-player";
+var GAME_PICKER_ID = "stats-game";
+function StatsScreen() {
+  const pack = usePack();
+  const { dark, colors } = (0, import_auto_paper7.useAutoPaperTheme)();
+  const rotation = (0, import_core13.useRotation)();
+  const insets = (0, import_core13.rotateInsets)((0, import_react_native_safe_area_context4.useSafeAreaInsets)(), rotation);
+  const { profiles } = useProfiles();
+  const dispatch = (0, import_react_redux10.useDispatch)();
+  const pickerHost = (0, import_hud7.usePopoverHost)();
+  const [tab, setTab] = (0, import_react17.useState)("stats");
+  const [gameId, setGameId] = (0, import_react17.useState)(ALL_GAMES);
+  const [selectedProfileId, setSelectedProfileId] = (0, import_react17.useState)(null);
+  const profileId = selectedProfileId && profiles.some((p) => p.id === selectedProfileId) ? selectedProfileId : null;
+  const games = gameId === ALL_GAMES ? pack.games : pack.games.filter((g) => g.id === gameId);
+  const playerOptions = (0, import_react17.useMemo)(() => [{ value: EVERYONE, label: "Everyone", icon: "account-group" }, ...profiles.map((p) => ({ value: p.id, label: p.name, icon: "account", color: p.color }))], [profiles]);
+  const gameOptions = (0, import_react17.useMemo)(() => [{ value: ALL_GAMES, label: "All Games", icon: "view-grid-outline" }, ...pack.games.map((g) => ({ value: g.id, label: g.title }))], [pack.games]);
+  const resetScope = games.length === 1 ? games[0].title : "every game";
+  const onReset = () => games.forEach((g) => dispatch(g.resetStats()));
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_core13.FakeLandscapeView, { style: styles5.rotatable, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_hud7.BaseStatsScreen, { title: tab === "stats" ? "Stats" : "Achievements", onBack: import_core8.safeBack, insets, onReset, resetLabel: games.length === 1 ? `Reset ${resetScope} Stats` : "Reset All Stats", resetConfirmTitle: "Reset Stats?", resetConfirmBody: `Erases every player's stats and achievements in ${resetScope}. This cannot be undone.`, rotation, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_hud7.PressAwayOverlay, { active: pickerHost.openId !== null, onPress: pickerHost.close, style: styles5.pressAway }),
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_react_native_paper2.SegmentedButtons, { value: tab, onValueChange: (value) => setTab(value), buttons: TABS, style: styles5.tabs }),
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_react_native6.View, { style: [styles5.filters, pickerHost.openId !== null && styles5.filtersOpen], children: [
+      profiles.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_profile8.OptionPicker, { id: PLAYER_PICKER_ID, host: pickerHost, options: playerOptions, value: profileId ?? EVERYONE, onChange: (value) => setSelectedProfileId(value === EVERYONE ? null : value), color: colors.primary, dark, icon: profileId ? "account" : "account-group" }),
+      /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_profile8.OptionPicker, { id: GAME_PICKER_ID, host: pickerHost, options: gameOptions, value: gameId, onChange: setGameId, color: colors.primary, dark, icon: "view-grid-outline" })
+    ] }),
+    tab === "stats" && pack.StatsSections && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(pack.StatsSections, { profileId, gameId: gameId === ALL_GAMES ? null : gameId }),
+    games.map((game) => /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(GameStats, { game, tab, profileId, showTitle: games.length > 1 }, game.id))
+  ] }) });
+}
+function GameStats({ game, tab, profileId, showTitle }) {
+  const { colors } = (0, import_auto_paper7.useAutoPaperTheme)();
+  const { StatsSections, AchievementList } = game;
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_react_native6.View, { style: styles5.game, children: [
+    showTitle && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_react_native_paper2.Text, { variant: "titleLarge", style: [styles5.gameTitle, { color: colors.onBackground }], children: game.title }),
+    tab === "stats" ? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(StatsSections, { profileId }) : /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(AchievementList, { profileId })
+  ] });
+}
+var styles5 = import_react_native6.StyleSheet.create({
+  filters: {
+    flexDirection: "row",
+    flexWrap: "wrap",
+    gap: 12,
+    justifyContent: "center"
+  },
+  filtersOpen: {
+    zIndex: 100
+  },
+  game: {
+    gap: 16
+  },
+  gameTitle: {
+    fontWeight: "bold",
+    marginTop: 8
+  },
+  pressAway: {
+    zIndex: 50
+  },
+  // A real full-bleed box for FakeLandscapeView to size its turned content against.
+  rotatable: {
+    flex: 1
+  },
+  // SegmentedButtons' own rounding.
+  tabs: {
+    borderRadius: 20
+  }
+});
+
+// src/components/imageGameIcon.tsx
+var import_react_native7 = require("react-native");
+var import_jsx_runtime17 = require("react/jsx-runtime");
+function imageGameIcon(images) {
+  return function ImageGameIcon({ size, dark }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_react_native7.Image, { source: dark ? images.dark : images.light, style: { height: size, width: size }, accessibilityIgnoresInvertColors: true });
+  };
+}
+
+// src/hooks/useActiveRound.ts
+var import_react_redux11 = require("react-redux");
+function useActiveRound(game, defaults) {
+  const round = (0, import_react_redux11.useSelector)((state) => state.liveplay.activeRound);
+  const seated = !!usePackGame(game)?.seatTwo;
+  if (!round || round.game !== game) return { mode: seated ? "vsCpu" : "solo", settings: defaults };
+  return { mode: round.mode, settings: { ...defaults, ...round.settings } };
+}
+
+// src/redux/createPackStore.ts
+var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"));
+var import_toolkit = require("@reduxjs/toolkit");
+var import_redux_persist = require("redux-persist");
+
+// src/redux/shellState.ts
+var import_auto_paper8 = require("@rific/auto-paper");
+var import_core14 = require("@rific/core");
+var import_feedback_press4 = require("@rific/feedback-press");
+var import_profile9 = require("@tastic/profile");
+var initialSoundSettings = { ...import_feedback_press4.defaultSoundSettings, enabled: !__DEV__ };
+var appSoundReducer = (state = initialSoundSettings, action) => (0, import_feedback_press4.soundReducer)(state, action);
+function createShellReducers({ seatColors, appearance = "system" }) {
+  return {
+    // Explicit primary/secondary triad (rather than a single seed expanded via harmony) so the pack's
+    // identity is pinned exactly instead of drifting with whatever hue math a harmony offset would
+    // produce. Primary/secondary ARE player 1/player 2's own default colors (PackDefinition.seatColors),
+    // so the theme and the default guest colors (seatColorsSlice.ts) can never drift apart. Tertiary is
+    // derived, not picked, via getThirdColor: the hue maximally distant from both (see
+    // @rific/auto-paper's README "Explicit triad" section). The appearance is the pack's ('system',
+    // createThemeReducer's own default, when it sets none).
+    theme: (0, import_auto_paper8.createThemeReducer)({ appearance, color: { primary: seatColors[1], secondary: seatColors[2], tertiary: (0, import_auto_paper8.getThirdColor)(seatColors[1], seatColors[2]) } }),
+    haptic: import_feedback_press4.hapticReducer,
+    sound: appSoundReducer,
+    // @rific/core's Keep Awake setting (see Providers.tsx's KeepAwakeBridge), under the namespace its
+    // REHYDRATE handling expects.
+    keepAwake: import_core14.keepAwakeReducer,
+    // The shared App Group roster (see @tastic/profile's resolveInitialProfiles/
+    // useSharedProfilesSync, wired in hooks/useProfiles.tsx) is layered on top of this as a separate
+    // sync target - this slice persisting normally via redux-persist is what gives it local-fallback
+    // behavior where the shared store isn't available, with no separate AsyncStorage path.
+    profiles: import_profile9.profilesReducer,
+    profileSelection: profileSelectionSlice_default,
+    // The loadout's "remember this color for next time" memory (guest, CPU, and each profile's pick
+    // in this pack) - separate from `theme` above, which always reflects whatever's live right now.
+    seatColors: createSeatColorsReducer(seatColors),
+    appSettings: appSettingsSlice_default,
+    opponent: opponentSlice_default,
+    // Transient per-round state, the one key blacklisted from persistence (see liveplaySlice.ts).
+    liveplay: liveplaySlice_default
+  };
+}
+
+// src/redux/createPackStore.ts
+var hasError = (action) => typeof action === "object" && action !== null && "error" in action && Boolean(action.error);
+var errorMiddleware = () => (next) => (action) => {
+  if (!hasError(action)) return next(action);
+  return action;
+};
+function createPackStore(pack, { keyPrefix, migrate }) {
+  const gameReducers = Object.assign({}, ...pack.games.map((game) => game.reducers));
+  const resumeReducers = pack.games.some((game) => game.resumable) ? { lastActiveGame: lastActiveGameSlice_default } : {};
+  const rootReducer = (0, import_toolkit.combineReducers)({ ...createShellReducers(pack), ...resumeReducers, ...pack.reducers, ...gameReducers });
+  const persistedReducer = (0, import_redux_persist.persistReducer)(
+    {
+      key: "root",
+      keyPrefix,
+      storage: import_async_storage.default,
+      // redux-persist defaults `timeout` to 5000ms: a failsafe setTimeout scheduled on every PERSIST
+      // dispatch to force-resolve rehydrate if storage never responds. It's never cleared once
+      // rehydrate resolves normally (only guarded by an internal `_sealed` flag), so it sits as a
+      // pending timer for up to 5s after every store creation - under Jest that's a real open handle
+      // ("A worker process has failed to exit gracefully"). Disabling it (falsy timeout skips the
+      // setTimeout call entirely) is redux-persist's own documented way to opt out; AsyncStorage reads
+      // failing to ever resolve at all isn't a failure mode worth a 5s failsafe for.
+      timeout: 0,
+      // liveplay is per-round state that must never survive a relaunch (see liveplaySlice.ts).
+      blacklist: ["liveplay"],
+      migrate
+    },
+    rootReducer
+  );
+  const store = (0, import_toolkit.configureStore)({
+    middleware: (getDefaultMiddleware) => {
+      const defaultMiddleware = getDefaultMiddleware({
+        immutableCheck: false,
+        serializableCheck: {
+          ignoredActions: [import_redux_persist.FLUSH, import_redux_persist.REHYDRATE, import_redux_persist.PAUSE, import_redux_persist.PERSIST, import_redux_persist.PURGE, import_redux_persist.REGISTER]
+        }
+      });
+      return defaultMiddleware.concat(errorMiddleware);
+    },
+    reducer: persistedReducer
+  });
+  const persistor = (0, import_redux_persist.persistStore)(store);
+  return { store, persistor };
+}
+
+// src/redux/gameGuideSlice.ts
+var REHYDRATE2 = "persist/REHYDRATE";
+function createGameGuideSlice(mountKey) {
+  const MARK_SEEN = `${mountKey}/markSeen`;
+  const initialState = { versionSeen: 0 };
+  function markSeen(version) {
+    return { type: MARK_SEEN, payload: version };
+  }
+  function reducer6(state = initialState, action) {
+    if (action.type === REHYDRATE2) {
+      const persisted = action.payload?.[mountKey];
+      return typeof persisted?.versionSeen === "number" ? { versionSeen: persisted.versionSeen } : state;
+    }
+    if (action.type === MARK_SEEN && typeof action.payload === "number") {
+      return { versionSeen: Math.max(state.versionSeen, action.payload) };
+    }
+    return state;
+  }
+  function selectVersionSeen(rootState) {
+    return rootState[mountKey]?.versionSeen ?? 0;
+  }
+  return { actions: { markSeen }, reducer: reducer6, selectVersionSeen };
+}
+
+// src/redux/onProfileRemoved.ts
+var import_achievements = require("@tastic/achievements");
+var import_profile10 = require("@tastic/profile");
+function onProfileRemoved(reducer6, forget) {
+  return (state, action) => {
+    const next = reducer6(state, action);
+    return import_profile10.profilesActions.remove.match(action) ? forget(next, action.payload) : next;
+  };
+}
+function forgetProfileAchievements(dropStats) {
+  return (state, profileId) => {
+    const stats = dropStats(state.stats, profileId);
+    const unlocked = (0, import_achievements.removeProfileUnlocks)(state.unlocked, profileId);
+    return stats === state.stats && unlocked === state.unlocked ? state : { ...state, stats, unlocked };
+  };
+}
+
+// src/gameStats.tsx
+var import_achievements2 = require("@tastic/achievements");
+var import_react18 = require("react");
+var import_jsx_runtime18 = require("react/jsx-runtime");
+var SEATS = [1, 2];
+function createGameStats({ key, defaultStats, isValidStats, catalog, getProfileStatsView }) {
+  const { actions: actions6, reducer: sliceReducer } = (0, import_achievements2.createAchievementsSlice)({
+    key,
+    defaultStats,
+    isValidStats,
+    // Backfills `profiles` onto stats saved without it.
+    migrateStats: (stored) => ({ ...stored, profiles: stored.profiles ?? {} })
+  });
+  const dropProfileStats = (stats, profileId) => {
+    if (!(profileId in stats.profiles)) return stats;
+    const { [profileId]: _removed, ...rest } = stats.profiles;
+    return { ...stats, profiles: rest };
+  };
+  const reducer6 = onProfileRemoved(sliceReducer, forgetProfileAchievements(dropProfileStats));
+  const profileViews = (stats) => Object.fromEntries(Object.entries(stats.profiles).map(([profileId, bucket]) => [profileId, getProfileStatsView(bucket)]));
+  const Context = (0, import_react18.createContext)(null);
+  function Provider({ children }) {
+    const { stats, unlockedAchievements, recordOutcome, resetAll } = (0, import_achievements2.useAchievements)({
+      catalog,
+      select: (state) => state[key],
+      actions: actions6,
+      profileViews
+    });
+    const record = (0, import_react18.useCallback)(
+      (update, profileIds) => {
+        const result = recordOutcome(update);
+        return { device: result.device, profiles: (0, import_achievements2.mapUnlocksBySeat)(SEATS, profileIds, result.profiles) };
+      },
+      [recordOutcome]
+    );
+    const value = (0, import_react18.useMemo)(() => ({ stats, unlockedAchievements, record, resetAll }), [stats, unlockedAchievements, record, resetAll]);
+    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(Context.Provider, { value, children });
+  }
+  function useStats() {
+    const ctx = (0, import_react18.useContext)(Context);
+    if (!ctx) throw new Error(`The ${key} stats are read within their game's Provider`);
+    return ctx;
+  }
+  return { reducer: reducer6, actions: actions6, Provider, useStats };
+}
+
+// src/playerSettings.ts
+var import_react19 = require("react");
+var import_react_redux12 = require("react-redux");
+var SEATS2 = [1, 2];
+function seatPlayerKey(selection, seat) {
+  return selection[seat] ?? `guest:${seat}`;
+}
+function createPlayerSettings({ id, defaults, distinctControls }) {
+  const settingsKey = `${id}Settings`;
+  const controlsKey = `${id}Controls`;
+  const PATCH = `${settingsKey}/patch`;
+  const SET_CONTROL = `${controlsKey}/set`;
+  const patch = (player, changes) => ({ type: PATCH, payload: { player, changes } });
+  const setControl = (player, control) => ({ type: SET_CONTROL, payload: { player, control } });
+  function forget(state, profileId) {
+    if (!(profileId in state)) return state;
+    const { [profileId]: _removed, ...rest } = state;
+    return rest;
+  }
+  const settingsReducer = onProfileRemoved((state = {}, action) => {
+    if (action.type !== PATCH) return state;
+    const { player, changes } = action.payload;
+    return { ...state, [player]: { ...state[player], ...changes } };
+  }, forget);
+  const controlsReducer = onProfileRemoved((state = {}, action) => {
+    if (action.type !== SET_CONTROL) return state;
+    const { player, control } = action.payload;
+    return state[player] === control ? state : { ...state, [player]: control };
+  }, forget);
+  function compose(saved, controls, selection, seatTwoIsPerson) {
+    const control1 = controls?.[seatPlayerKey(selection, 1)] ?? defaults.controlScheme[1];
+    let control2 = (seatTwoIsPerson ? controls?.[seatPlayerKey(selection, 2)] : void 0) ?? defaults.controlScheme[2];
+    if (distinctControls && control2 === control1) control2 = distinctControls.find((c) => c !== control1) ?? control2;
+    return { ...defaults, ...saved?.[seatPlayerKey(selection, 1)], controlScheme: { 1: control1, 2: control2 } };
+  }
+  function select(state) {
+    const root = state;
+    return compose(root[settingsKey], root[controlsKey], state.profileSelection, state.opponent.seatTwo === "person");
+  }
+  function useSettings() {
+    const selection = (0, import_react_redux12.useSelector)((state) => state.profileSelection);
+    const seatTwoIsPerson = (0, import_react_redux12.useSelector)((state) => state.opponent.seatTwo === "person");
+    const saved = (0, import_react_redux12.useSelector)((state) => state[settingsKey]);
+    const controls = (0, import_react_redux12.useSelector)((state) => state[controlsKey]);
+    const dispatch = (0, import_react_redux12.useDispatch)();
+    const settings = (0, import_react19.useMemo)(() => compose(saved, controls, selection, seatTwoIsPerson), [saved, controls, selection, seatTwoIsPerson]);
+    const setSettings = (0, import_react19.useCallback)(
+      (next) => {
+        const { controlScheme, ...changes } = next;
+        if (Object.keys(changes).length > 0) dispatch(patch(seatPlayerKey(selection, 1), changes));
+        if (!controlScheme) return;
+        for (const seat of SEATS2) {
+          if (seat === 2 && !seatTwoIsPerson) continue;
+          if (controlScheme[seat] !== settings.controlScheme[seat]) dispatch(setControl(seatPlayerKey(selection, seat), controlScheme[seat]));
+        }
+      },
+      [dispatch, selection, seatTwoIsPerson, settings.controlScheme]
+    );
+    return { settings, setSettings };
+  }
+  return { reducers: { [settingsKey]: settingsReducer, [controlsKey]: controlsReducer }, settingsReducer, controlsReducer, actions: { patch, setControl }, compose, select, useSettings };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_APP_SETTINGS,
+  DEFAULT_OPPONENT,
+  HomeScreen,
+  LoadoutRoute,
+  PREVIEW_ASPECT,
+  PackProvider,
+  PlayRoute,
+  ProfilesProvider,
+  ProfilesRoute,
+  RootLayout,
+  SettingsDialog,
+  StatsScreen,
+  appSettingsActions,
+  appSettingsReducer,
+  createGameGuideSlice,
+  createGameStats,
+  createPackStore,
+  createPlayerSettings,
+  createSeatColorsReducer,
+  createShellReducers,
+  defaultProfileSelectionState,
+  defaultSeatColorsState,
+  forgetProfileAchievements,
+  humanSeatsFor,
+  imageGameIcon,
+  liveplayActions,
+  liveplayReducer,
+  onProfileRemoved,
+  opponentActions,
+  opponentReducer,
+  profileSelectionActions,
+  profileSelectionReducer,
+  roundModeFor,
+  safeBack,
+  seatColorsActions,
+  seatPlayerKey,
+  seatTwoFor,
+  useActiveRound,
+  useAppSettings,
+  useGameGuide,
+  useOpponent,
+  usePack,
+  usePackGame,
+  useProfiles,
+  useSeatColors
+});