@tastic/shell 0.0.0-stage → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,1562 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/PackContext.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var PackContext = createContext(null);
+function PackProvider({ pack, children }) {
+  return /* @__PURE__ */ jsx(PackContext.Provider, { value: pack, children });
+}
+function usePack() {
+  const pack = 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
+import { useAutoPaperTheme } from "@rific/auto-paper";
+import { useHapticSettings } from "@rific/feedback-press";
+import { Toaster, ToastProvider } from "@rific/toaster";
+import { OrientationProvider, useRotationAwareStatusBar, useThemedRootBackground } from "@tastic/core";
+import { RotatedFrame } from "@tastic/hud";
+import * as Haptics from "expo-haptics";
+import { Stack } from "expo-router";
+import { DeviceMotion } from "expo-sensors";
+import { useCallback as useCallback6 } from "react";
+import { StyleSheet } from "react-native";
+import { GestureHandlerRootView } from "react-native-gesture-handler";
+import * as RNPaper2 from "react-native-paper";
+import { SafeAreaProvider } from "react-native-safe-area-context";
+
+// src/components/Fonts.tsx
+import { MaterialCommunityIcons } from "@expo/vector-icons";
+import Constants from "expo-constants";
+import { useFonts } from "expo-font";
+import Head from "expo-router/head";
+import { Platform } from "react-native";
+
+// src/splashGate.ts
+import { createGate } from "@rific/splash-gate";
+var { markReady: markSplashReady, useReady: useSplashReady, pendingGates: pendingSplashGates, Gate: SplashGate } = createGate(["theme", "fonts", "profiles"]);
+
+// src/components/Fonts.tsx
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+function Fonts({ children }) {
+  const pack = usePack();
+  const [loaded, error] = useFonts({ ...pack.fonts, ...MaterialCommunityIcons.font });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    Platform.OS === "web" && /* @__PURE__ */ jsx2(Head, { children: /* @__PURE__ */ jsx2("title", { children: Constants.expoConfig?.name }) }),
+    /* @__PURE__ */ jsx2(SplashGate, { gate: "fonts", ready: loaded || !!error, children })
+  ] });
+}
+
+// src/components/GuideHost.tsx
+import { useIsTouchPrimaryDevice, useRotation } from "@tastic/core";
+import { GuideProvider, useGuide } from "@tastic/hud/guide";
+import { createContext as createContext2, useCallback, useContext as useContext2, useEffect, useMemo, useRef, useState } from "react";
+import { shallowEqual, useDispatch, useSelector, useStore } from "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
+import { jsx as jsx3 } from "react/jsx-runtime";
+var GameGuideContext = createContext2(null);
+function GuideHost({ children }) {
+  const pack = usePack();
+  const [gameId, setGameId] = useState(pack.games[0].id);
+  const game = pack.games.find((g) => g.id === gameId) ?? pack.games[0];
+  const rotation = useRotation();
+  const touch = useIsTouchPrimaryDevice();
+  const seatTwo = useSelector((state) => state.opponent.seatTwo);
+  const input = useSelector((state) => game.guide.selectInput(state), shallowEqual);
+  const seenVersion = useSelector((state) => game.guide.selectVersionSeen(state));
+  const dispatch = useDispatch();
+  const mode = roundModeFor(seatTwoFor(seatTwo, game.seatTwo));
+  const steps = useMemo(() => game.guide.getSteps(input, { touch, mode }), [game, input, touch, mode]);
+  const onSeen = useCallback((version) => dispatch(game.guide.markSeen(version)), [dispatch, game]);
+  return /* @__PURE__ */ jsx3(GuideProvider, { steps, currentVersion: game.guide.version, seenVersion, onSeen, rotation, children: /* @__PURE__ */ jsx3(GameGuideBridge, { onPick: setGameId, children }) });
+}
+function GameGuideBridge({ onPick, children }) {
+  const pack = usePack();
+  const store = useStore();
+  const { isOpen, open } = useGuide();
+  const pendingNext = useRef(null);
+  const wasOpen = useRef(false);
+  useEffect(() => {
+    if (wasOpen.current && !isOpen && pendingNext.current) {
+      const next = pendingNext.current;
+      pendingNext.current = null;
+      next();
+    }
+    wasOpen.current = isOpen;
+  }, [isOpen]);
+  const openFor = useCallback(
+    (gameId) => {
+      onPick(gameId);
+      open();
+    },
+    [onPick, open]
+  );
+  const openFirstTime = 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 = useMemo(() => ({ openFirstTime, openFor }), [openFirstTime, openFor]);
+  return /* @__PURE__ */ jsx3(GameGuideContext.Provider, { value, children });
+}
+function useGameGuide() {
+  const ctx = useContext2(GameGuideContext);
+  if (!ctx) throw new Error("useGameGuide must be used within a GuideHost");
+  return ctx;
+}
+
+// src/components/Providers.tsx
+import { keepAwakeActions, KeepAwakeProvider } from "@rific/core";
+import { FeedbackPressProvider, hapticActions, soundActions, useFeedbackBridgeProps } from "@rific/feedback-press";
+import { useAudioPool } from "@rific/feedback-press/audio";
+import { useEdgeGestureGuard } from "@tastic/edge-guard";
+import * as ExpoKeepAwake from "expo-keep-awake";
+import { useCallback as useCallback2 } from "react";
+import * as RNPaper from "react-native-paper";
+import { Provider as ReduxProvider, useDispatch as useDispatch2, useSelector as useSelector2 } from "react-redux";
+import { PersistGate } from "redux-persist/integration/react";
+import { Fragment as Fragment2, jsx as jsx4 } from "react/jsx-runtime";
+var FeedbackBridge = ({ children }) => {
+  const haptic = useSelector2((state) => state.haptic);
+  const sound = useSelector2((state) => state.sound);
+  const dispatch = useDispatch2();
+  const onChange = useCallback2((next) => dispatch(hapticActions.initialize(next)), [dispatch]);
+  const onSoundChange = useCallback2((next) => dispatch(soundActions.initialize(next)), [dispatch]);
+  const playSelection = useAudioPool(__require("./select-MLBNNA4N.wav"));
+  const playNotification = useAudioPool(__require("./notification-CGGFPYK7.wav"));
+  const bridgeProps = useFeedbackBridgeProps({ initialValue: haptic, onChange, soundInitialValue: sound, onSoundChange, sound: { selection: playSelection, notification: playNotification } });
+  return /* @__PURE__ */ jsx4(FeedbackPressProvider, { ...bridgeProps, paper: RNPaper, children });
+};
+var EdgeGuardBridge = ({ children }) => {
+  const deferBottomEdgeGestures = useSelector2((state) => state.appSettings.deferBottomEdgeGestures);
+  const activelyPlaying = useSelector2((state) => state.liveplay.activelyPlaying);
+  useEdgeGestureGuard(deferBottomEdgeGestures && activelyPlaying);
+  return /* @__PURE__ */ jsx4(Fragment2, { children });
+};
+var KeepAwakeBridge = ({ children }) => {
+  const keepAwake = useSelector2((state) => state.keepAwake);
+  const dispatch = useDispatch2();
+  const onChange = useCallback2((settings) => dispatch(keepAwakeActions.initialize(settings)), [dispatch]);
+  return /* @__PURE__ */ jsx4(KeepAwakeProvider, { expoKeepAwake: ExpoKeepAwake, initialValue: keepAwake, onChange, children });
+};
+function Providers({ store, persistor, children }) {
+  return /* @__PURE__ */ jsx4(ReduxProvider, { store, children: /* @__PURE__ */ jsx4(PersistGate, { persistor, children: /* @__PURE__ */ jsx4(EdgeGuardBridge, { children: /* @__PURE__ */ jsx4(FeedbackBridge, { children: /* @__PURE__ */ jsx4(KeepAwakeBridge, { children }) }) }) }) });
+}
+
+// src/components/Theme.tsx
+import MaskedView from "@react-native-masked-view/masked-view";
+import { Provider as AutoPaperProvider, themeActions, useThemeBridgeProps } from "@rific/auto-paper";
+import * as ExpoBlur from "expo-blur";
+import * as SplashScreen from "expo-splash-screen";
+import { useCallback as useCallback3 } from "react";
+import Reanimated from "react-native-reanimated";
+import { shallowEqual as shallowEqual2, useDispatch as useDispatch3, useSelector as useSelector3 } from "react-redux";
+import { jsx as jsx5 } from "react/jsx-runtime";
+SplashScreen.preventAutoHideAsync();
+SplashScreen.setOptions({ fade: true, duration: 400 });
+function Theme({ children }) {
+  const { fontFamily } = usePack();
+  const settings = useSelector3((state) => state.theme, shallowEqual2);
+  const dispatch = useDispatch3();
+  const onReady = useCallback3(() => markSplashReady("theme"), []);
+  const onChange = useCallback3((next) => dispatch(themeActions.initialize(next)), [dispatch]);
+  const bridgeProps = useThemeBridgeProps({ initialValue: settings, onChange, onReady });
+  return /* @__PURE__ */ jsx5(AutoPaperProvider, { ...bridgeProps, expoBlur: ExpoBlur, maskedView: MaskedView, statusBar: false, reanimated: Reanimated, fontFamily, children });
+}
+
+// src/components/UpdateDialog.tsx
+import { useUpdateErrorToast } from "@rific/toaster";
+import { useRotation as useRotation2 } from "@tastic/core";
+import { UpdateDialog as SharedUpdateDialog } from "@tastic/hud";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function UpdateDialog() {
+  const onError = useUpdateErrorToast();
+  const rotation = useRotation2();
+  return /* @__PURE__ */ jsx6(SharedUpdateDialog, { onError, rotation });
+}
+
+// src/hooks/useAppSettings.ts
+import { useCallback as useCallback4 } from "react";
+import { useDispatch as useDispatch4, useSelector as useSelector4 } from "react-redux";
+
+// src/redux/appSettingsSlice.ts
+import { createSettingsSlice } from "@rific/core";
+var DEFAULT_APP_SETTINGS = {
+  lockOrientation: false,
+  deferBottomEdgeGestures: false
+};
+var { actions, reducer } = createSettingsSlice("appSettings", {
+  initialState: DEFAULT_APP_SETTINGS,
+  initializeMode: "merge",
+  fieldSetters: []
+});
+var appSettingsActions = actions;
+var appSettingsSlice_default = reducer;
+
+// src/hooks/useAppSettings.ts
+function useAppSettings() {
+  const settings = useSelector4((state) => state.appSettings);
+  const dispatch = useDispatch4();
+  const setSettings = useCallback4(
+    (patch) => {
+      dispatch(appSettingsActions.initialize(patch));
+    },
+    [dispatch]
+  );
+  return { settings, setSettings };
+}
+
+// src/hooks/useLastActiveGame.tsx
+import { createContext as createContext3, useContext as useContext3, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+import { useDispatch as useDispatch5, useStore as useStore2 } from "react-redux";
+
+// src/redux/lastActiveGameSlice.ts
+import { createSettingsSlice as createSettingsSlice2 } from "@rific/core";
+var { actions: actions2, reducer: reducer2 } = createSettingsSlice2("lastActiveGame", { initialState: { gameId: null } });
+var lastActiveGameActions = actions2;
+var lastActiveGameSlice_default = reducer2;
+
+// src/hooks/useLastActiveGame.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var LastActiveGameContext = createContext3(null);
+function LastActiveGameProvider({ children }) {
+  const store = useStore2();
+  const dispatch = useDispatch5();
+  const [initial] = useState2(() => store.getState().lastActiveGame?.gameId ?? null);
+  const pendingResume = useRef2(initial);
+  const persisted = useRef2(initial);
+  const value = useMemo2(
+    () => ({
+      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__ */ jsx7(LastActiveGameContext.Provider, { value, children });
+}
+function useLastActiveGame() {
+  const ctx = useContext3(LastActiveGameContext);
+  if (!ctx) throw new Error("useLastActiveGame must be used within a LastActiveGameProvider");
+  return ctx;
+}
+
+// src/hooks/useProfiles.tsx
+import { createProfileRecord, profilesActions, resolveInitialProfiles, useSharedProfilesSync } from "@tastic/profile";
+import { createContext as createContext4, useCallback as useCallback5, useContext as useContext4, useEffect as useEffect2, useState as useState3 } from "react";
+import { useDispatch as useDispatch6, useSelector as useSelector5 } from "react-redux";
+
+// src/redux/profileSelectionSlice.ts
+import { createProfileSelectionSlice } from "@tastic/profile";
+var defaultProfileSelectionState = { 1: null, 2: null };
+var { actions: actions3, reducer: reducer3 } = createProfileSelectionSlice("pack", defaultProfileSelectionState);
+var profileSelectionActions = actions3;
+var profileSelectionSlice_default = reducer3;
+
+// src/hooks/useProfiles.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var SHARED_GROUP_ID = "group.com.infinitetoken.tastic";
+var ProfilesContext = createContext4(null);
+function ProfilesProvider({ children }) {
+  const profiles = useSelector5((state) => state.profiles);
+  const lastSelected = useSelector5((state) => state.profileSelection);
+  const dispatch = useDispatch6();
+  const [loaded, setLoaded] = useState3(false);
+  useEffect2(() => {
+    let cancelled = false;
+    resolveInitialProfiles(SHARED_GROUP_ID, profiles).then((resolved) => {
+      if (cancelled) return;
+      dispatch(profilesActions.setAll(resolved));
+      dispatch(profileSelectionActions.pruneToRoster(resolved.map((p) => p.id)));
+      setLoaded(true);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const { syncToShared } = useSharedProfilesSync({
+    groupId: SHARED_GROUP_ID,
+    onRemoteChange: useCallback5(
+      (remote) => {
+        dispatch(profilesActions.setAll(remote));
+        dispatch(profileSelectionActions.pruneToRoster(remote.map((p) => p.id)));
+      },
+      [dispatch]
+    )
+  });
+  const createProfile = useCallback5(
+    (input) => {
+      const record = createProfileRecord(input);
+      dispatch(profilesActions.add(record));
+      syncToShared([...profiles, record]);
+      return record;
+    },
+    [profiles, dispatch, syncToShared]
+  );
+  const updateProfile = useCallback5(
+    (id, patch) => {
+      dispatch(profilesActions.update({ id, patch }));
+      syncToShared(profiles.map((p) => p.id === id ? { ...p, ...patch, updatedAt: Date.now() } : p));
+    },
+    [profiles, dispatch, syncToShared]
+  );
+  const deleteProfile = useCallback5(
+    (id) => {
+      dispatch(profilesActions.remove(id));
+      syncToShared(profiles.filter((p) => p.id !== id));
+      dispatch(profileSelectionActions.clearProfile(id));
+    },
+    [profiles, dispatch, syncToShared]
+  );
+  const selectProfile = useCallback5(
+    (seat, profileId) => {
+      dispatch(profileSelectionActions.select({ profileId, seat }));
+    },
+    [dispatch]
+  );
+  return /* @__PURE__ */ jsx8(ProfilesContext.Provider, { value: { profiles, lastSelected, loaded, createProfile, updateProfile, deleteProfile, selectProfile }, children });
+}
+function useProfiles() {
+  const ctx = useContext4(ProfilesContext);
+  if (!ctx) throw new Error("useProfiles must be used within a ProfilesProvider");
+  return ctx;
+}
+
+// src/RootLayout.tsx
+import { jsx as jsx9, jsxs as jsxs2 } from "react/jsx-runtime";
+var PLAY_OPTIONS = { statusBarHidden: true };
+function AppStack() {
+  const { dark } = useAutoPaperTheme();
+  const rootBackground = useThemedRootBackground(dark, false);
+  const statusBar = useRotationAwareStatusBar();
+  return /* @__PURE__ */ jsxs2(Stack, { screenOptions: { ...rootBackground, ...statusBar }, children: [
+    /* @__PURE__ */ jsx9(Stack.Screen, { name: "index" }),
+    /* @__PURE__ */ jsx9(Stack.Screen, { name: "play/[game]", options: PLAY_OPTIONS })
+  ] });
+}
+function OrientationBridge({ children }) {
+  const { settings, setSettings } = useAppSettings();
+  return /* @__PURE__ */ jsx9(OrientationProvider, { deviceMotion: 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__ */ jsx9(SplashGate, { gate: "profiles", ready: loaded, children });
+}
+function HapticGatedToastProvider({ children }) {
+  const { settings } = useHapticSettings();
+  return /* @__PURE__ */ jsx9(ToastProvider, { haptics: settings.vibrate ? Haptics : void 0, paper: RNPaper2, children });
+}
+function RotatingToaster() {
+  const renderFrame = useCallback6(
+    (toasts) => /* @__PURE__ */ jsx9(RotatedFrame, { rotatedSafeArea: true, passThrough: true, children: toasts }),
+    []
+  );
+  return /* @__PURE__ */ jsx9(Toaster, { historyButton: null, clearButton: null, limit: 3, renderFrame });
+}
+function GameProviders({ games, children }) {
+  return games.reduceRight((inner, game) => /* @__PURE__ */ jsx9(game.Provider, { children: inner }, game.id), children);
+}
+function RootLayout({ pack, store, persistor }) {
+  return /* @__PURE__ */ jsx9(GestureHandlerRootView, { style: styles.root, children: /* @__PURE__ */ jsx9(SafeAreaProvider, { children: /* @__PURE__ */ jsx9(PackProvider, { pack, children: /* @__PURE__ */ jsx9(Fonts, { children: /* @__PURE__ */ jsx9(Providers, { store, persistor, children: /* @__PURE__ */ jsx9(Theme, { children: /* @__PURE__ */ jsx9(ProfilesProvider, { children: /* @__PURE__ */ jsx9(LastActiveGameProvider, { children: /* @__PURE__ */ jsx9(GameProviders, { games: pack.games, children: /* @__PURE__ */ jsx9(GatedApp, { children: /* @__PURE__ */ jsx9(OrientationBridge, { children: /* @__PURE__ */ jsxs2(HapticGatedToastProvider, { children: [
+    /* @__PURE__ */ jsx9(GuideHost, { children: /* @__PURE__ */ jsx9(AppStack, {}) }),
+    /* @__PURE__ */ jsx9(RotatingToaster, {}),
+    /* @__PURE__ */ jsx9(UpdateDialog, {})
+  ] }) }) }) }) }) }) }) }) }) }) }) });
+}
+var styles = StyleSheet.create({
+  root: { flex: 1 }
+});
+
+// src/screens/GameRoute.tsx
+import { Redirect, useLocalSearchParams } from "expo-router";
+import { useEffect as useEffect5 } from "react";
+
+// src/screens/LoadoutScreen.tsx
+import { defaultColors, useAutoPaperTheme as useAutoPaperTheme3 } from "@rific/auto-paper";
+import { FakeLandscapeView, getViewRotation, rotateInsets, useOrientationState } from "@tastic/core";
+import { CornerActionButtons, PlayerSetupPanel, PressAwayOverlay, ReadyButton as ReadyButton2, SharedActionBand, usePopoverHost } from "@tastic/hud";
+import { DualZoneLayout, needsSharedNeutralZone, useDualZoneLayout } from "@tastic/split-screen";
+import { router as router2, useFocusEffect as useFocusEffect2 } from "expo-router";
+import { useCallback as useCallback9, useEffect as useEffect4, useMemo as useMemo4, useRef as useRef4, useState as useState4 } from "react";
+import { Platform as Platform2, StyleSheet as StyleSheet3, View as View2 } from "react-native";
+import Animated from "react-native-reanimated";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { useDispatch as useDispatch9 } from "react-redux";
+
+// src/components/SeatTwoPanel.tsx
+import { ReadyButton, useZoneClampedAlign } from "@tastic/hud";
+import { getOptionPickerContentSize, OptionPicker } from "@tastic/profile";
+import { useMemo as useMemo3 } from "react";
+import { StyleSheet as StyleSheet2, View } from "react-native";
+import { jsx as jsx10, jsxs as jsxs3 } from "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 = useMemo3(() => {
+    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 = getOptionPickerContentSize(options.length, colorSection);
+  const align = 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__ */ jsxs3(View, { style: [styles2.panel, ownPopoverOpen && styles2.panelOpen], children: [
+    /* @__PURE__ */ jsx10(OptionPicker, { id: pickerId, host, options, value, onChange: handleChange, color, dark, icon, colorSection, alignOverride: align }),
+    isPerson && secondPicker && /* @__PURE__ */ jsx10(View, { style: [styles2.pickerRow, pickerRowOpen && styles2.pickerRowOpen], children: secondPicker }),
+    isPerson && showReadyButton && onToggleReady && /* @__PURE__ */ jsx10(ReadyButton, { color, ready: ready ?? false, onToggleReady })
+  ] });
+}
+var styles2 = StyleSheet2.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
+import { useUpdateErrorToast as useUpdateErrorToast2 } from "@rific/toaster";
+import { BaseSettingsDialog } from "@tastic/hud";
+import { jsx as jsx11, jsxs as jsxs4 } from "react/jsx-runtime";
+function SettingsDialog({ visible, onDismiss, rotation = 0, onShowHowToPlay, children }) {
+  const onUpdateError = useUpdateErrorToast2();
+  const { settings, setSettings } = useAppSettings();
+  const { otaVersion, SettingsSections } = usePack();
+  return /* @__PURE__ */ jsxs4(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__ */ jsx11(SettingsSections, {})
+  ] });
+}
+
+// src/hooks/useOpponent.ts
+import { useCallback as useCallback7 } from "react";
+import { useDispatch as useDispatch7, useSelector as useSelector6 } from "react-redux";
+
+// src/redux/opponentSlice.ts
+import { createSettingsSlice as createSettingsSlice3 } from "@rific/core";
+var DEFAULT_OPPONENT = { seatTwo: "cpu" };
+var { actions: actions4, reducer: reducer4 } = createSettingsSlice3("opponent", {
+  initialState: DEFAULT_OPPONENT
+});
+var opponentActions = actions4;
+var opponentSlice_default = reducer4;
+
+// src/hooks/useOpponent.ts
+function useOpponent() {
+  const seatTwo = useSelector6((state) => state.opponent.seatTwo);
+  const dispatch = useDispatch7();
+  const setSeatTwo = useCallback7((next) => dispatch(opponentActions.setSeatTwo(next)), [dispatch]);
+  return { seatTwo, setSeatTwo };
+}
+
+// src/hooks/useSeatColors.ts
+import { getThirdColor, useAutoPaperTheme as useAutoPaperTheme2, useThemeSettings } from "@rific/auto-paper";
+import { avoidSeatColorClash, profileSeatColor } from "@tastic/profile";
+import { useFocusEffect } from "expo-router";
+import { useCallback as useCallback8, useEffect as useEffect3, useRef as useRef3 } from "react";
+import { useDispatch as useDispatch8, useSelector as useSelector7 } from "react-redux";
+
+// src/redux/seatColorsSlice.ts
+import { createSeatColorsSlice } from "@tastic/profile";
+function defaultSeatColorsState(seatColors) {
+  return { lastGuestColor: { 1: seatColors[1], 2: seatColors[2] }, lastCpuColor: seatColors[2], profileColors: {} };
+}
+function createSeatColorsReducer(seatColors) {
+  return createSeatColorsSlice("pack", defaultSeatColorsState(seatColors)).reducer;
+}
+var seatColorsActions = createSeatColorsSlice("pack", defaultSeatColorsState({ 1: "", 2: "" })).actions;
+
+// src/hooks/useSeatColors.ts
+function useSeatColors(p2IsHuman) {
+  const { colors: themeColors } = useAutoPaperTheme2();
+  const { set: setThemeColor } = useThemeSettings();
+  const p1Color = themeColors.primary;
+  const p2Color = themeColors.secondary;
+  const { profiles, lastSelected } = useProfiles();
+  const { seatColors } = usePack();
+  const seatDefaultColors = [seatColors[1], seatColors[2]];
+  const dispatch = useDispatch8();
+  const guestColors = useSelector7((state) => state.seatColors.lastGuestColor);
+  const cpuColor = useSelector7((state) => state.seatColors.lastCpuColor);
+  const profileColors = useSelector7((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 = useRef3(p1Profile);
+  const p2ProfileRef = useRef3(p2Profile);
+  const guestColorsRef = useRef3(guestColors);
+  const cpuColorRef = useRef3(cpuColor);
+  const profileColorsRef = useRef3(profileColors);
+  useEffect3(() => {
+    p1ProfileRef.current = p1Profile;
+  }, [p1Profile]);
+  useEffect3(() => {
+    p2ProfileRef.current = p2Profile;
+  }, [p2Profile]);
+  useEffect3(() => {
+    guestColorsRef.current = guestColors;
+  }, [guestColors]);
+  useEffect3(() => {
+    cpuColorRef.current = cpuColor;
+  }, [cpuColor]);
+  useEffect3(() => {
+    profileColorsRef.current = profileColors;
+  }, [profileColors]);
+  useEffect3(() => {
+    const nextP1 = p1Profile ? profileSeatColor(p1Profile, profileColors) : guestColors[1];
+    const nextP2 = avoidSeatColorClash(nextP1, p2Profile ? 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: getThirdColor(nextP1, nextP2) } });
+  }, [lastSelected[1], lastSelected[2], p2IsHuman, guestColors, cpuColor, profileColors, profiles.length]);
+  useFocusEffect(
+    useCallback8(() => {
+      const guest = guestColorsRef.current;
+      const cpu = cpuColorRef.current;
+      const p1Prof = p1ProfileRef.current;
+      const p2Prof = p2ProfileRef.current;
+      const picks = profileColorsRef.current;
+      const nextP1 = p1Prof ? profileSeatColor(p1Prof, picks) : guest[1];
+      const nextP2 = avoidSeatColorClash(nextP1, p2Prof ? profileSeatColor(p2Prof, picks) : p2IsHuman ? guest[2] : cpu, seatDefaultColors);
+      setThemeColor({ color: { primary: nextP1, secondary: nextP2, tertiary: getThirdColor(nextP1, nextP2) } });
+    }, [lastSelected[1], lastSelected[2], p2IsHuman, setThemeColor])
+  );
+  const persistSeatColor = useCallback8(
+    (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 = useCallback8(
+    (hex) => {
+      const swapped = hex.toLowerCase() === p2Color.toLowerCase();
+      const nextP2 = swapped ? p1Color : p2Color;
+      setThemeColor({ color: { primary: hex, secondary: nextP2, tertiary: getThirdColor(hex, nextP2) } });
+      persistSeatColor(1, hex);
+      if (swapped) persistSeatColor(2, nextP2);
+    },
+    [setThemeColor, p1Color, p2Color, persistSeatColor]
+  );
+  const handleP2ColorChange = useCallback8(
+    (hex) => {
+      const swapped = hex.toLowerCase() === p1Color.toLowerCase();
+      const nextP1 = swapped ? p2Color : p1Color;
+      setThemeColor({ color: { primary: nextP1, secondary: hex, tertiary: getThirdColor(nextP1, hex) } });
+      persistSeatColor(2, hex);
+      if (swapped) persistSeatColor(1, nextP1);
+    },
+    [setThemeColor, p1Color, p2Color, persistSeatColor]
+  );
+  return { p1Color, p2Color, handleP1ColorChange, handleP2ColorChange };
+}
+
+// src/navigation.ts
+import { configureNavigation, safeBack } from "@rific/core";
+import { router } from "expo-router";
+configureNavigation({ router });
+
+// src/redux/liveplaySlice.ts
+import { createSettingsSlice as createSettingsSlice4 } from "@rific/core";
+var { actions: actions5, reducer: reducer5 } = createSettingsSlice4("liveplay", {
+  initialState: { activelyPlaying: false, activeRound: null }
+});
+var liveplayActions = actions5;
+var liveplaySlice_default = reducer5;
+
+// src/screens/LoadoutScreen.tsx
+import { jsx as jsx12, jsxs as jsxs5 } from "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 = useMemo4(() => 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 } = useOrientationState();
+  const fixedSeats = p2IsHuman && (!!game.twoPlayerSeats?.faceToFaceOnWeb || Platform2.OS !== "web");
+  const fixedUpsideDown = !!game.twoPlayerSeats?.followUpsideDown && orientationMode === "faceToFace" && upsideDown;
+  const { panelLayout, panelFadeStyle } = useDualZoneLayout(fixedSeats ? "faceToFace" : orientationMode, fixedSeats ? true : p1OnRight, fixedSeats || p1OnRightResolved, fixedSeats ? fixedUpsideDown : upsideDown, PANEL_SWAP_FADE_MS);
+  const [settingsOpen, setSettingsOpen] = useState4(false);
+  const rotation = getViewRotation(panelLayout.orientationMode, panelLayout.p1OnRight, panelLayout.upsideDown);
+  const insets = rotateInsets(useSafeAreaInsets(), rotation);
+  const { colors: themeColors, dark } = useAutoPaperTheme3();
+  const { p1Color, p2Color, handleP1ColorChange, handleP2ColorChange } = useSeatColors(p2IsHuman);
+  const dispatch = useDispatch9();
+  const handleP1ProfileSelect = useCallback9((profile) => selectProfile(1, profile?.id ?? null), [selectProfile]);
+  const handleP2ProfileSelect = useCallback9((profileId) => selectProfile(2, profileId), [selectProfile]);
+  const [ready, setReady] = useState4({ 1: false, 2: false });
+  useFocusEffect2(
+    useCallback9(() => {
+      setReady({ 1: false, 2: false });
+    }, [setReady])
+  );
+  const changeSeatTwo = useCallback9(
+    (next) => {
+      setReady({ 1: false, 2: false });
+      setSeatTwo(next);
+    },
+    [setSeatTwo, setReady]
+  );
+  const roundSettingsRef = useRef4(loadout.roundSettings);
+  useEffect4(() => {
+    roundSettingsRef.current = loadout.roundSettings;
+  }, [loadout.roundSettings]);
+  useEffect4(() => {
+    if (!humanSeats.every((s) => ready[s])) return;
+    dispatch(liveplayActions.setActiveRound({ game: game.id, mode, settings: roundSettingsRef.current }));
+    router2.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 = needsSharedNeutralZone(panelLayout.orientationMode, humanSeats.length);
+  const p2ZoneStyle = p2IsHuman ? isPortrait ? styles3.p2ZoneTop : panelLayout.p1OnRight ? styles3.p2ZoneLeft : styles3.p2ZoneRight : null;
+  const showReadyButton = p2IsHuman;
+  const controlsHost = usePopoverHost();
+  const p2PanelHost = 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__ */ jsx12(SharedActionBand, { onBack: 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__ */ jsx12(PlayerSetupPanel, { idPrefix: "p1", host: controlsHost, color: p1Color, onColorChange: handleP1ColorChange, swatches: 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: () => router2.push("/profiles") });
+  const p2Control = p2IsHuman ? loadout.seatControl(2, p2Host, { ...controlLook, seatColor: p2Color }) : void 0;
+  const p2Panel = game.seatTwo && /* @__PURE__ */ jsx12(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: 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__ */ jsxs5(View2, { style: [styles3.container, { backgroundColor: bg }], children: [
+    /* @__PURE__ */ jsxs5(FakeLandscapeView, { orientationMode: panelLayout.orientationMode, p1OnRight: panelLayout.p1OnRight, upsideDown: panelLayout.upsideDown, style: styles3.rotatable, children: [
+      /* @__PURE__ */ jsx12(PressAwayOverlay, { active: controlsHost.openId !== null, onPress: controlsHost.close }),
+      p2ZoneStyle && /* @__PURE__ */ jsx12(PressAwayOverlay, { active: controlsHost.openId !== null || p2Host.openId !== null, onPress: p2Host.close, style: p2ZoneStyle }),
+      !showMetaInSharedBand && /* @__PURE__ */ jsx12(CornerActionButtons, { onBack: safeBack, onSettings: () => setSettingsOpen(true), fg, insets }),
+      p2IsHuman ? /* @__PURE__ */ jsx12(
+        DualZoneLayout,
+        {
+          panelLayout,
+          panelFadeStyle,
+          p1: p1Panel,
+          p2: p2Panel,
+          shared: sharedControls,
+          p1Elevated: controlsHost.openId?.startsWith("p1-") ?? false,
+          p2Elevated: p2Host.openId !== null,
+          sharedElevated: optionsPopoverOpen
+        }
+      ) : /* @__PURE__ */ jsxs5(View2, { style: styles3.stackedZone, children: [
+        sharedControls,
+        /* @__PURE__ */ jsxs5(Animated.View, { style: [styles3.playersRow, anyPlayerPickerOpen && styles3.playersRowOpen, panelFadeStyle], children: [
+          !isPortrait && panelLayout.p1OnRight ? p2Panel : p1Panel,
+          !isPortrait && panelLayout.p1OnRight ? p1Panel : p2Panel
+        ] }),
+        /* @__PURE__ */ jsx12(ReadyButton2, { color: p1Color, ready: ready[1], onToggleReady: () => setReady((r) => ({ ...r, 1: !r[1] })), style: anyPlayerPickerOpen && styles3.readyButtonHidden })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx12(SettingsDialog, { visible: settingsOpen, onDismiss: () => setSettingsOpen(false), rotation, onShowHowToPlay: () => openFor(game.id) })
+  ] });
+}
+var styles3 = StyleSheet3.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
+import { jsx as jsx13 } from "react/jsx-runtime";
+function LoadoutRoute() {
+  const { game: id } = useLocalSearchParams();
+  const game = usePackGame(id);
+  if (!game) return /* @__PURE__ */ jsx13(Redirect, { href: "/" });
+  if (!hasLoadout(game)) return /* @__PURE__ */ jsx13(Redirect, { href: { pathname: "/play/[game]", params: { game: game.id } } });
+  return /* @__PURE__ */ jsx13(LoadoutScreen, { game }, game.id);
+}
+function hasLoadout(game) {
+  return !!game.useLoadout;
+}
+function PlayRoute() {
+  const { game: id } = useLocalSearchParams();
+  const game = usePackGame(id);
+  useResumePoint(game?.resumable ? game.id : null);
+  if (!game) return /* @__PURE__ */ jsx13(Redirect, { href: "/" });
+  const { PlayScreen } = game;
+  return /* @__PURE__ */ jsx13(PlayScreen, {}, game.id);
+}
+function useResumePoint(gameId) {
+  const { setLastActiveGame, clearLastActiveGame } = useLastActiveGame();
+  useEffect5(() => {
+    if (!gameId) return;
+    setLastActiveGame(gameId);
+    return clearLastActiveGame;
+  }, [gameId, setLastActiveGame, clearLastActiveGame]);
+}
+
+// src/screens/HomeScreen.tsx
+import { defaultColors as defaultColors2, useAutoPaperTheme as useAutoPaperTheme4 } from "@rific/auto-paper";
+import { IconButton, Pressable } from "@rific/feedback-press";
+import { FakeLandscapeView as FakeLandscapeView2, useRotation as useRotation4 } from "@tastic/core";
+import { PressAwayOverlay as PressAwayOverlay2, usePopoverHost as usePopoverHost2, useWellColors, WELL_SHADOW } from "@tastic/hud";
+import { ProfilePicker } from "@tastic/profile";
+import { Redirect as Redirect2, router as router3, useIsFocused } from "expo-router";
+import { useCallback as useCallback10, useEffect as useEffect6, useState as useState6 } from "react";
+import { AppState, ScrollView, StyleSheet as StyleSheet4, View as View3 } from "react-native";
+import { Icon, Text } from "react-native-paper";
+
+// src/hooks/useFrozenWhileHidden.ts
+import { useState as useState5 } from "react";
+function useFrozenWhileHidden(value, hidden) {
+  const [prevHidden, setPrevHidden] = useState5(hidden);
+  const [prevValue, setPrevValue] = useState5(value);
+  const [frozen, setFrozen] = useState5(value);
+  if (hidden !== prevHidden) {
+    setPrevHidden(hidden);
+    if (hidden) setFrozen(prevValue);
+  }
+  if (value !== prevValue) {
+    setPrevValue(value);
+  }
+  return hidden ? frozen : value;
+}
+
+// src/screens/homeLayout.ts
+import { clamp, rotateInsets as rotateInsets2, useRotatedWindowDimensions, useRotation as useRotation3 } from "@tastic/core";
+import { useSafeAreaInsets as useSafeAreaInsets2 } from "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(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 = 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 } = useRotatedWindowDimensions();
+  const rotation = useRotation3();
+  const insets = rotateInsets2(useSafeAreaInsets2(), rotation);
+  return computeHomeLayout(width, height, insets);
+}
+
+// src/screens/HomeScreen.tsx
+import { Fragment as Fragment3, jsx as jsx14, jsxs as jsxs6 } from "react/jsx-runtime";
+function HomeScreen() {
+  const pack = usePack();
+  const { consumeResumeGame } = useLastActiveGame();
+  const [resumeGame] = useState6(() => {
+    const id = consumeResumeGame();
+    return pack.games.find((g) => g.id === id && g.resumable) ?? null;
+  });
+  if (resumeGame) return /* @__PURE__ */ jsx14(Redirect2, { href: { pathname: "/play/[game]", params: { game: resumeGame.id } } });
+  return /* @__PURE__ */ jsx14(HomeMenu, {});
+}
+function HomeMenu() {
+  const pack = usePack();
+  const rotation = useRotation4();
+  const layout = useHomeLayout();
+  const { insets } = layout;
+  const { dark } = useAutoPaperTheme4();
+  const { openFirstTime, openFor } = useGameGuide();
+  const [settingsOpen, setSettingsOpen] = useState6(false);
+  const isFocused = useIsFocused();
+  const [appState, setAppState] = useState6(AppState.currentState);
+  useEffect6(() => {
+    const subscription = 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 = usePopoverHost2();
+  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] = useState6(false);
+  useEffect6(() => {
+    if (!tiled) return;
+    const id = requestAnimationFrame(() => setPreviewsRevealed(true));
+    return () => cancelAnimationFrame(id);
+  }, [tiled]);
+  const closePicker = pickerHost.close;
+  useEffect6(() => {
+    closePicker();
+  }, [isWide, closePicker]);
+  const bg = dark ? "#000000" : "#FFFFFF";
+  const fg = dark ? "#FFFFFF" : "#000000";
+  const openGame = useCallback10((game) => openFirstTime(game.id, () => router3.push(game.useLoadout ? { pathname: "/loadout/[game]", params: { game: game.id } } : { pathname: "/play/[game]", params: { game: game.id } })), [openFirstTime]);
+  const picker = /* @__PURE__ */ jsx14(ProfilePicker, { idPrefix: "home-p1", host: pickerHost, profiles, selectedId: lastSelected[1], color: p1Color, dark, guestLabel: "P1", onSelect: (profile) => selectProfile(1, profile?.id ?? null), onManage: () => router3.push("/profiles"), colorSection: { value: p1Color, onChange: handleP1ColorChange, swatches: defaultColors2, caption: selectedProfile ? pack.colorCaption : void 0 } });
+  return /* @__PURE__ */ jsxs6(View3, { style: [styles4.container, { backgroundColor: bg }], children: [
+    /* @__PURE__ */ jsxs6(FakeLandscapeView2, { style: styles4.rotatable, children: [
+      /* @__PURE__ */ jsx14(PressAwayOverlay2, { active: pickerHost.openId !== null, onPress: pickerHost.close }),
+      isWide ? /* @__PURE__ */ jsxs6(Fragment3, { children: [
+        /* @__PURE__ */ jsx14(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__ */ jsx14(View3, { style: [styles4.grid, { width: layout.rightPaneWidth }], children: pack.games.map((game) => /* @__PURE__ */ jsx14(GameTile, { game, width: layout.tileWidth, previewWidth: layout.previewWidth, previewRevealed: previewsRevealed, dark, p1Color, p2Color, onPress: () => openGame(game), onRules: () => openFor(game.id) }, game.id)) }) }),
+        /* @__PURE__ */ jsxs6(View3, { 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__ */ jsx14(pack.HeroTitle, { words: pack.wordmark, color: fg, p1Color, p2Color, active: heroActive, fit: layout.heroFit }),
+          /* @__PURE__ */ jsx14(View3, { style: styles4.widePicker, children: picker })
+        ] })
+      ] }) : /* @__PURE__ */ jsxs6(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__ */ jsx14(pack.HeroTitle, { words: pack.wordmark, color: fg, p1Color, p2Color, active: heroActive }),
+        /* @__PURE__ */ jsx14(View3, { style: [styles4.picker, pickerHost.openId !== null && styles4.pickerOpen], children: picker }),
+        /* @__PURE__ */ jsx14(View3, { style: styles4.list, children: pack.games.map((game) => /* @__PURE__ */ jsx14(GameRow, { game, dark, p1Color, p2Color, previewRevealed: previewsRevealed, onPress: () => openGame(game), onRules: () => openFor(game.id) }, game.id)) })
+      ] }),
+      /* @__PURE__ */ jsx14(IconButton, { icon: "trophy", iconColor: fg, size: 24, style: [styles4.corner, { top: 8 + insets.top, left: 8 + insets.left }], onPress: () => router3.push("/stats"), accessibilityLabel: "Stats & Achievements" }),
+      /* @__PURE__ */ jsx14(IconButton, { icon: "cog", iconColor: fg, size: 24, style: [styles4.corner, { top: 8 + insets.top, right: 8 + insets.right }], onPress: () => setSettingsOpen(true), accessibilityLabel: "Settings" })
+    ] }),
+    /* @__PURE__ */ jsx14(SettingsDialog, { visible: settingsOpen, onDismiss: () => setSettingsOpen(false), rotation })
+  ] });
+}
+function GameRow({ game, dark, p1Color, p2Color, previewRevealed, onPress, onRules }) {
+  const well = 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__ */ jsxs6(View3, { children: [
+      /* @__PURE__ */ jsxs6(Pressable, { onPress, style: [styles4.row, { backgroundColor: well.bg }], accessibilityRole: "button", accessibilityLabel: game.title, children: [
+        game.Preview ? /* @__PURE__ */ jsx14(PreviewBox, { game, width: ROW_PREVIEW_WIDTH, revealed: previewRevealed, dark, p1Color, p2Color }) : /* @__PURE__ */ jsx14(View3, { style: [styles4.rowIcon, { backgroundColor: dark ? ICON_DARK_BG : ICON_LIGHT_BG }], children: /* @__PURE__ */ jsx14(GameIcon, { size: ROW_ICON_SIZE, p1Color, p2Color, dark }) }),
+        /* @__PURE__ */ jsxs6(View3, { style: styles4.rowText, children: [
+          /* @__PURE__ */ jsx14(Text, { variant: "titleLarge", style: [styles4.rowTitle, { color: well.fg }], numberOfLines: 1, children: game.title }),
+          /* @__PURE__ */ jsx14(Text, { variant: "bodyMedium", style: { color: well.fgMuted }, numberOfLines: 2, children: game.blurb })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx14(Pressable, { onPress: onRules, style: styles4.rulesButton, hitSlop: 12, accessibilityRole: "button", accessibilityLabel: `${game.title} rules`, children: /* @__PURE__ */ jsx14(Icon, { source: "information-outline", size: 22, color: well.fgMuted }) })
+    ] })
+  );
+}
+function GameTile({ game, width, previewWidth, dark, p1Color, p2Color, previewRevealed, onPress, onRules }) {
+  const well = useWellColors();
+  return /* @__PURE__ */ jsxs6(View3, { style: { width }, children: [
+    /* @__PURE__ */ jsxs6(Pressable, { onPress, style: [styles4.tile, { backgroundColor: well.bg }], accessibilityRole: "button", accessibilityLabel: game.title, children: [
+      /* @__PURE__ */ jsx14(PreviewBox, { game, width: previewWidth, revealed: previewRevealed, dark, p1Color, p2Color }),
+      /* @__PURE__ */ jsx14(Text, { variant: "titleMedium", style: [styles4.rowTitle, { color: well.fg }], numberOfLines: 1, children: game.title }),
+      /* @__PURE__ */ jsx14(Text, { variant: "bodySmall", style: { color: well.fgMuted }, numberOfLines: 3, children: game.blurb })
+    ] }),
+    /* @__PURE__ */ jsx14(Pressable, { onPress: onRules, style: styles4.tileRulesButton, hitSlop: 12, accessibilityRole: "button", accessibilityLabel: `${game.title} rules`, children: /* @__PURE__ */ jsx14(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__ */ jsx14(View3, { style: [styles4.preview, { width, height, backgroundColor: dark ? ICON_DARK_BG : ICON_LIGHT_BG }], children: Preview ? revealed && /* @__PURE__ */ jsx14(Preview, { width, height, p1Color, p2Color, dark }) : /* @__PURE__ */ jsx14(View3, { style: [styles4.previewIcon, { width: iconSize, height: iconSize, borderRadius: iconSize * 0.22 }], children: /* @__PURE__ */ jsx14(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 = StyleSheet4.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: 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: 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
+import { defaultColors as defaultColors3 } from "@rific/auto-paper";
+import { ProfilesScreen } from "@tastic/profile";
+import { jsx as jsx15 } from "react/jsx-runtime";
+function ProfilesRoute() {
+  const { profiles, createProfile, updateProfile, deleteProfile } = useProfiles();
+  return /* @__PURE__ */ jsx15(ProfilesScreen, { profiles, defaultColor: defaultColors3[0].value, onCreate: (patch) => createProfile(patch), onSave: (id, patch) => updateProfile(id, patch), onDelete: deleteProfile, onBack: safeBack });
+}
+
+// src/screens/StatsScreen.tsx
+import { useAutoPaperTheme as useAutoPaperTheme5 } from "@rific/auto-paper";
+import { FakeLandscapeView as FakeLandscapeView3, rotateInsets as rotateInsets3, useRotation as useRotation5 } from "@tastic/core";
+import { BaseStatsScreen, PressAwayOverlay as PressAwayOverlay3, usePopoverHost as usePopoverHost3 } from "@tastic/hud";
+import { OptionPicker as OptionPicker2 } from "@tastic/profile";
+import { useMemo as useMemo5, useState as useState7 } from "react";
+import { StyleSheet as StyleSheet5, View as View4 } from "react-native";
+import { SegmentedButtons, Text as Text2 } from "react-native-paper";
+import { useSafeAreaInsets as useSafeAreaInsets3 } from "react-native-safe-area-context";
+import { useDispatch as useDispatch10 } from "react-redux";
+import { jsx as jsx16, jsxs as jsxs7 } from "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 } = useAutoPaperTheme5();
+  const rotation = useRotation5();
+  const insets = rotateInsets3(useSafeAreaInsets3(), rotation);
+  const { profiles } = useProfiles();
+  const dispatch = useDispatch10();
+  const pickerHost = usePopoverHost3();
+  const [tab, setTab] = useState7("stats");
+  const [gameId, setGameId] = useState7(ALL_GAMES);
+  const [selectedProfileId, setSelectedProfileId] = useState7(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 = useMemo5(() => [{ value: EVERYONE, label: "Everyone", icon: "account-group" }, ...profiles.map((p) => ({ value: p.id, label: p.name, icon: "account", color: p.color }))], [profiles]);
+  const gameOptions = useMemo5(() => [{ 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__ */ jsx16(FakeLandscapeView3, { style: styles5.rotatable, children: /* @__PURE__ */ jsxs7(BaseStatsScreen, { title: tab === "stats" ? "Stats" : "Achievements", onBack: 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__ */ jsx16(PressAwayOverlay3, { active: pickerHost.openId !== null, onPress: pickerHost.close, style: styles5.pressAway }),
+    /* @__PURE__ */ jsx16(SegmentedButtons, { value: tab, onValueChange: (value) => setTab(value), buttons: TABS, style: styles5.tabs }),
+    /* @__PURE__ */ jsxs7(View4, { style: [styles5.filters, pickerHost.openId !== null && styles5.filtersOpen], children: [
+      profiles.length > 0 && /* @__PURE__ */ jsx16(OptionPicker2, { 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__ */ jsx16(OptionPicker2, { 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__ */ jsx16(pack.StatsSections, { profileId, gameId: gameId === ALL_GAMES ? null : gameId }),
+    games.map((game) => /* @__PURE__ */ jsx16(GameStats, { game, tab, profileId, showTitle: games.length > 1 }, game.id))
+  ] }) });
+}
+function GameStats({ game, tab, profileId, showTitle }) {
+  const { colors } = useAutoPaperTheme5();
+  const { StatsSections, AchievementList } = game;
+  return /* @__PURE__ */ jsxs7(View4, { style: styles5.game, children: [
+    showTitle && /* @__PURE__ */ jsx16(Text2, { variant: "titleLarge", style: [styles5.gameTitle, { color: colors.onBackground }], children: game.title }),
+    tab === "stats" ? /* @__PURE__ */ jsx16(StatsSections, { profileId }) : /* @__PURE__ */ jsx16(AchievementList, { profileId })
+  ] });
+}
+var styles5 = StyleSheet5.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
+import { Image } from "react-native";
+import { jsx as jsx17 } from "react/jsx-runtime";
+function imageGameIcon(images) {
+  return function ImageGameIcon({ size, dark }) {
+    return /* @__PURE__ */ jsx17(Image, { source: dark ? images.dark : images.light, style: { height: size, width: size }, accessibilityIgnoresInvertColors: true });
+  };
+}
+
+// src/hooks/useActiveRound.ts
+import { useSelector as useSelector8 } from "react-redux";
+function useActiveRound(game, defaults) {
+  const round = useSelector8((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
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { combineReducers, configureStore } from "@reduxjs/toolkit";
+import { FLUSH, PAUSE, PERSIST, persistReducer, persistStore, PURGE, REGISTER, REHYDRATE } from "redux-persist";
+
+// src/redux/shellState.ts
+import { createThemeReducer, getThirdColor as getThirdColor2 } from "@rific/auto-paper";
+import { keepAwakeReducer } from "@rific/core";
+import { defaultSoundSettings, hapticReducer, soundReducer } from "@rific/feedback-press";
+import { profilesReducer } from "@tastic/profile";
+var initialSoundSettings = { ...defaultSoundSettings, enabled: !__DEV__ };
+var appSoundReducer = (state = initialSoundSettings, action) => 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: createThemeReducer({ appearance, color: { primary: seatColors[1], secondary: seatColors[2], tertiary: getThirdColor2(seatColors[1], seatColors[2]) } }),
+    haptic: hapticReducer,
+    sound: appSoundReducer,
+    // @rific/core's Keep Awake setting (see Providers.tsx's KeepAwakeBridge), under the namespace its
+    // REHYDRATE handling expects.
+    keepAwake: 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: 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 = combineReducers({ ...createShellReducers(pack), ...resumeReducers, ...pack.reducers, ...gameReducers });
+  const persistedReducer = persistReducer(
+    {
+      key: "root",
+      keyPrefix,
+      storage: AsyncStorage,
+      // 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 = configureStore({
+    middleware: (getDefaultMiddleware) => {
+      const defaultMiddleware = getDefaultMiddleware({
+        immutableCheck: false,
+        serializableCheck: {
+          ignoredActions: [FLUSH, REHYDRATE, PAUSE, PERSIST, PURGE, REGISTER]
+        }
+      });
+      return defaultMiddleware.concat(errorMiddleware);
+    },
+    reducer: persistedReducer
+  });
+  const persistor = 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
+import { removeProfileUnlocks } from "@tastic/achievements";
+import { profilesActions as profilesActions2 } from "@tastic/profile";
+function onProfileRemoved(reducer6, forget) {
+  return (state, action) => {
+    const next = reducer6(state, action);
+    return profilesActions2.remove.match(action) ? forget(next, action.payload) : next;
+  };
+}
+function forgetProfileAchievements(dropStats) {
+  return (state, profileId) => {
+    const stats = dropStats(state.stats, profileId);
+    const unlocked = removeProfileUnlocks(state.unlocked, profileId);
+    return stats === state.stats && unlocked === state.unlocked ? state : { ...state, stats, unlocked };
+  };
+}
+
+// src/gameStats.tsx
+import { createAchievementsSlice, mapUnlocksBySeat, useAchievements } from "@tastic/achievements";
+import { createContext as createContext5, useCallback as useCallback11, useContext as useContext5, useMemo as useMemo6 } from "react";
+import { jsx as jsx18 } from "react/jsx-runtime";
+var SEATS = [1, 2];
+function createGameStats({ key, defaultStats, isValidStats, catalog, getProfileStatsView }) {
+  const { actions: actions6, reducer: sliceReducer } = 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 = createContext5(null);
+  function Provider({ children }) {
+    const { stats, unlockedAchievements, recordOutcome, resetAll } = useAchievements({
+      catalog,
+      select: (state) => state[key],
+      actions: actions6,
+      profileViews
+    });
+    const record = useCallback11(
+      (update, profileIds) => {
+        const result = recordOutcome(update);
+        return { device: result.device, profiles: mapUnlocksBySeat(SEATS, profileIds, result.profiles) };
+      },
+      [recordOutcome]
+    );
+    const value = useMemo6(() => ({ stats, unlockedAchievements, record, resetAll }), [stats, unlockedAchievements, record, resetAll]);
+    return /* @__PURE__ */ jsx18(Context.Provider, { value, children });
+  }
+  function useStats() {
+    const ctx = useContext5(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
+import { useCallback as useCallback12, useMemo as useMemo7 } from "react";
+import { useDispatch as useDispatch11, useSelector as useSelector9 } from "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 = useSelector9((state) => state.profileSelection);
+    const seatTwoIsPerson = useSelector9((state) => state.opponent.seatTwo === "person");
+    const saved = useSelector9((state) => state[settingsKey]);
+    const controls = useSelector9((state) => state[controlsKey]);
+    const dispatch = useDispatch11();
+    const settings = useMemo7(() => compose(saved, controls, selection, seatTwoIsPerson), [saved, controls, selection, seatTwoIsPerson]);
+    const setSettings = useCallback12(
+      (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 };
+}
+export {
+  DEFAULT_APP_SETTINGS,
+  DEFAULT_OPPONENT,
+  HomeScreen,
+  LoadoutRoute,
+  PREVIEW_ASPECT,
+  PackProvider,
+  PlayRoute,
+  ProfilesProvider,
+  ProfilesRoute,
+  RootLayout,
+  SettingsDialog,
+  StatsScreen,
+  appSettingsActions,
+  appSettingsSlice_default as appSettingsReducer,
+  createGameGuideSlice,
+  createGameStats,
+  createPackStore,
+  createPlayerSettings,
+  createSeatColorsReducer,
+  createShellReducers,
+  defaultProfileSelectionState,
+  defaultSeatColorsState,
+  forgetProfileAchievements,
+  humanSeatsFor,
+  imageGameIcon,
+  liveplayActions,
+  liveplaySlice_default as liveplayReducer,
+  onProfileRemoved,
+  opponentActions,
+  opponentSlice_default as opponentReducer,
+  profileSelectionActions,
+  profileSelectionSlice_default as profileSelectionReducer,
+  roundModeFor,
+  safeBack,
+  seatColorsActions,
+  seatPlayerKey,
+  seatTwoFor,
+  useActiveRound,
+  useAppSettings,
+  useGameGuide,
+  useOpponent,
+  usePack,
+  usePackGame,
+  useProfiles,
+  useSeatColors
+};