@tastic/shell 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jay Deaton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,155 @@
-# Temporary Holding Version
+# @tastic/shell
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The app around a pack of React Native games: Home, each game's loadout, the stats screen, Profiles
+and Settings, the pack's one Redux store, and every provider the games run under. An app hands it one
+`PackDefinition` (its name, its games, its seat colors, its hero) and keeps only its games, its hero
+and a handful of thin expo-router routes. Two-seat duels and games for one player alike: a game can
+leave out its seat 2 and its loadout, come back on a cold launch, and show a preview on Home.
+
+Built from the shell PuckTastic and DuelTastic each carried in `src/shell/` (made identical on
+2026-10-28), so the packs and the next ones (CardTastic) share one copy. Part of the `@tastic`
+package ecosystem, on [`@tastic/hud`](https://github.com/jayrdeaton/react-native-hud),
+[`@tastic/profile`](https://github.com/jayrdeaton/react-native-game-profile) and
+[`@tastic/core`](https://github.com/jayrdeaton/react-native-game-core).
+
+## What's in here
+
+- **`RootLayout`**: the root of the app (gesture root, safe area, fonts, Redux and its persist gate,
+  the theme, profiles, every game's own provider, the splash gates, the shared orientation reading,
+  toasts, How to Play, the OTA update dialog) around expo-router's stack.
+- **Screens** for the routes: `HomeScreen` (the pack's hero, seat 1's button, a row per game, or a
+  grid of preview tiles on a wide screen), `LoadoutRoute` and `PlayRoute` (`loadout/[game]`,
+  `play/[game]`), `ProfilesRoute` and `StatsScreen`.
+- **The store**: `createPackStore(pack, { keyPrefix, migrate })` builds one persisted store from the
+  shell's keys (theme, haptics, sound, Keep Awake, profiles, seat selection, seat colors, app settings,
+  seat 2, the never-saved `liveplay`, and `lastActiveGame` in a pack with a resumable game), the
+  pack's own `reducers` and every game's own `reducers`.
+- **What a game builds on**: `createPlayerSettings` (its settings and controls, kept per player),
+  `createGameStats` (its stats and achievements), `createGameGuideSlice` (which version of its How to
+  Play a player has seen), `onProfileRemoved` (forget a deleted profile), `useActiveRound`,
+  `useProfiles`, `useSeatColors`, `SettingsDialog`, `safeBack` and `imageGameIcon`.
+
+## Install
+
+```bash
+npm install @tastic/shell
+```
+
+The shell is an Expo Router app's own code, so it needs every peer below in the app's `dependencies`.
+
+## Use
+
+`src/pack.ts` describes the pack and builds its store:
+
+```ts
+import { createPackStore, type GameDefinition, type PackDefinition } from '@tastic/shell'
+
+export const games: readonly GameDefinition[] = [lightCycles, turf, tag, snake]
+
+export const pack: PackDefinition = {
+  name: 'DuelTastic',
+  wordmark: ['Duel', 'Tastic'],
+  colorCaption: 'DuelTastic only',
+  games,
+  seatColors: { 1: '#2196f3', 2: '#f44336' },
+  appearance: 'dark',
+  HeroTitle,
+  fonts: HERO_FONTS,
+  fontFamily: MONO_FONT,
+  otaVersion: release.otaVersion
+}
+
+// Never change the prefix or a key once the pack ships: every player would start over.
+export const { store, persistor } = createPackStore(pack, { keyPrefix: 'dueltastic:' })
+```
+
+and `src/app/` holds six thin routes:
+
+```tsx
+// _layout.tsx
+export default function Layout() {
+  return <RootLayout pack={pack} store={store} persistor={persistor} />
+}
+
+// index.tsx, profiles.tsx, stats.tsx
+export default HomeScreen // ProfilesRoute, StatsScreen
+
+// loadout/[game].tsx and play/[game].tsx (PlayRoute): the web build is a static export
+export function generateStaticParams() {
+  return games.map((g) => ({ game: g.id }))
+}
+export default LoadoutRoute
+```
+
+The game id comes second in a route, never first: expo-router strips the web build's base path off
+the front of an in-app link, so a route starting with a game id equal to the base path
+(`boxhockey/loadout` under `/boxhockey`) would lose that segment.
+
+### `PackDefinition`
+
+| Field | |
+| --- | --- |
+| `name`, `wordmark`, `colorCaption` | The pack's name, Home's two-line wordmark, and the caption under a seat's Color row while a profile is in it ("DuelTastic only"). |
+| `games` | Every `GameDefinition`, in Home's order. |
+| `seatColors` | Player 1's and player 2's default colors: the theme's primary and secondary, and a fresh install's guest and CPU colors. |
+| `appearance?` | The theme's appearance on a fresh install (`'system'` when unset). |
+| `HeroTitle` | Home's wordmark, drawn by the pack (`HeroTitleProps`: `words`, `color`, `p1Color`, `p2Color`, `active`, false while Home is covered or the app is in the background, and `fit`, the box it has beside the preview grid on a wide screen, undefined at its own size). |
+| `fonts?` | Fonts the pack's own art needs, loaded behind the splash screen beside the icon font. |
+| `fontFamily?` | The typeface on every Paper text variant. Unset is Paper's own. |
+| `otaVersion` | The version label in Settings. |
+| `SettingsSections?` | The pack's own Settings sections, in every Settings dialog, under the shell's rows and any a play screen adds. |
+| `reducers?` | The pack's own store keys (what `SettingsSections` saves), beside the shell's and the games'. Never a key either already mounts. |
+| `StatsSections?` | A section across the pack's games (a calendar of play), first on the stats screen's Stats tab, handed its two filters (`PackStatsSectionsProps`: `profileId`, null for Everyone, and `gameId`, null for All Games). |
+
+### `GameDefinition`
+
+Each game is one object: its `id`, `title`, `blurb` and `icon` (a component drawn in the seats'
+colors, or `imageGameIcon({ light, dark })` for a light and dark pair of pictures), its seat 2
+choices (`seatTwo`: `'cpu'`, `'person'`, `'nobody'`) and how 2 Player seats its players
+(`twoPlayerSeats`), the store `reducers` it mounts, its root `Provider`, its `useLoadout(mode)`, its
+`PlayScreen`, its `StatsSections` and `AchievementList`, `resetStats`, and its How to Play `guide`.
+See `src/types.ts` for every field.
+
+What a game can leave out or add, each optional, so a two-seat game sets none of them:
+
+| Field | |
+| --- | --- |
+| no `seatTwo` (nor `twoPlayerSeats`) | A game for one player: its loadout has no seat 2 button, every round is solo (`useActiveRound` falls back to `'solo'`), and its How to Play describes a solo round. |
+| no `useLoadout` | Nothing to set up first: Home opens its play screen straight away, after its How to Play the first time, and a link to its loadout plays it. Its rule variants go in its play screen's Settings: `<SettingsDialog>` takes `children`. |
+| no `cpuDifficulty` (in `GameLoadout`) | A CPU with no levels: seat 2's menu offers one plain CPU. |
+| `resumable` | A cold launch drops the player back into its play screen if they left the app there rather than backing out of it. The shell remembers only which game (`lastActiveGame`); the game saves and restores its own board. |
+| `Preview` | Drawn on Home in place of the icon (`GamePreviewProps`: `width`, `height`, the seats' colors, `dark`), in a box of `PREVIEW_ASPECT` (360:200), a frame after Home first paints. While any game has one, Home shows tiles: rows upright, and on a wide screen a grid beside the hero and seat 1's button. A game without one keeps its icon. |
+
+A game never imports another game, and the shell never imports a game: games reach the shell only
+through the pack (`usePack()`).
+
+## Peer dependencies
+
+None are bundled. The floors are the versions PuckTastic and DuelTastic ran the shell on when it
+became a package (the lower of the two where they differ).
+
+| Peer | Floor | Used for |
+| --- | --- | --- |
+| `react`, `react-native` | >=19.3.0, >=0.88.0 | everything |
+| `expo-router` | >=58.0.26 | the stack, the routes, `safeBack`, focus effects, the web tab title |
+| `expo-font`, `@expo/vector-icons` | >=58.0.10, >=15.1.1 | the icon font and the pack's `fonts`, behind the splash screen |
+| `expo-splash-screen`, `@rific/splash-gate` | >=58.0.11, >=0.2.3 | holding the splash screen until the theme, fonts and profiles are ready |
+| `expo-constants` | >=58.0.13 | the web tab title |
+| `expo-blur`, `@react-native-masked-view/masked-view` | >=58.0.5, >=0.3.2 | auto-paper's blur and its scroll fade |
+| `expo-haptics`, `expo-keep-awake`, `expo-sensors` | >=58.0.7, >=58.0.3, >=58.0.4 | the toaster's haptics, Keep Awake, the orientation reading |
+| `react-native-gesture-handler`, `react-native-reanimated`, `react-native-safe-area-context` | >=3.3.0, >=4.7.1, >=5.10.1 | the gesture root, auto-paper's dialogs and the loadout's fades, insets |
+| `react-native-paper` | >=5.15.3 | text, icons, the toaster and feedback-press |
+| `@reduxjs/toolkit`, `redux`, `react-redux`, `redux-persist`, `@react-native-async-storage/async-storage` | >=2.13.0, >=5.0.1, >=9.3.0, >=6.0.0, >=2.2.0 | the store and where it's saved |
+| `@rific/auto-paper` | >=0.13.4 | the theme |
+| `@rific/core` | >=0.5.0 | settings slices, Keep Awake, `safeBack` |
+| `@rific/feedback-press` | >=0.13.1 | haptic and sound settings, the UI sounds |
+| `@rific/toaster` | >=0.10.1 | toasts (DuelTastic runs 0.12, PuckTastic 0.10) |
+| `@tastic/core` | >=0.14.0 | orientation, rotation, the status bar and root background |
+| `@tastic/hud` | >=0.25.1 | Settings, the stats screen, the loadout's panels, How to Play |
+| `@tastic/profile` | >=0.17.0 | profiles, the seat buttons, seat colors |
+| `@tastic/achievements` | >=0.6.0 | `createGameStats`, `forgetProfileAchievements` |
+| `@tastic/split-screen` | >=0.5.5 | the 2 Player loadout's two halves |
+| `@tastic/edge-guard` | >=0.1.5 | Edge Guard during play |
+
+The two UI sounds every button plays (`assets/sounds/select.wav` and `notification.wav`) ship with the
+package.

package/dist/index.d.mts

@@ -0,0 +1,487 @@
+import * as react from 'react';
+import { ComponentType, ReactNode } from 'react';
+import * as _rific_auto_paper from '@rific/auto-paper';
+import { ThemeAppearance } from '@rific/auto-paper';
+import { ViewRotation } from '@tastic/core';
+import { PopoverHost, MenuOption } from '@tastic/hud';
+import { GuideStep } from '@tastic/hud/guide';
+import { FontSource } from 'expo-font';
+import * as redux from 'redux';
+import { Reducer, Action } from 'redux';
+import * as _rific_core from '@rific/core';
+export { safeBack } from '@rific/core';
+import * as _tastic_profile from '@tastic/profile';
+import { profilesReducer, Profile, CreateProfileInput, SeatColorsState as SeatColorsState$1 } from '@tastic/profile';
+import * as _rific_feedback_press from '@rific/feedback-press';
+import { SoundSettings } from '@rific/feedback-press';
+import * as redux_persist from 'redux-persist';
+import { PersistedState, Persistor } from 'redux-persist';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as redux_thunk from 'redux-thunk';
+import * as redux_persist_es_persistReducer from 'redux-persist/es/persistReducer';
+import { ImageSourcePropType } from 'react-native';
+import * as _tastic_achievements from '@tastic/achievements';
+import { UnlockedAchievementsState, AchievementDefinition, AchievementsState } from '@tastic/achievements';
+
+interface ActiveRound {
+    game: string;
+    mode: RoundMode;
+    settings: object;
+}
+type LiveplaySliceState = {
+    activelyPlaying: boolean;
+    activeRound: ActiveRound | null;
+};
+declare const reducer$3: _rific_core.SettingsReducer<LiveplaySliceState>;
+declare const liveplayActions: {
+    initialize: {
+        (payload: LiveplaySliceState): _rific_core.SettingsAction<LiveplaySliceState>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<LiveplaySliceState>;
+    };
+} & {
+    setActivelyPlaying: {
+        (payload: boolean): _rific_core.SettingsAction<boolean>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<boolean>;
+    };
+    setActiveRound: {
+        (payload: ActiveRound | null): _rific_core.SettingsAction<ActiveRound | null>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<ActiveRound | null>;
+    };
+};
+
+interface OpponentState {
+    seatTwo: SeatTwo;
+}
+declare const DEFAULT_OPPONENT: OpponentState;
+declare const reducer$2: _rific_core.SettingsReducer<OpponentState>;
+declare const opponentActions: {
+    initialize: {
+        (payload: OpponentState): _rific_core.SettingsAction<OpponentState>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<OpponentState>;
+    };
+} & {
+    setSeatTwo: {
+        (payload: SeatTwo): _rific_core.SettingsAction<SeatTwo>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<SeatTwo>;
+    };
+};
+
+interface AppSettings {
+    lockOrientation: boolean;
+    lockedRotation?: ViewRotation;
+    deferBottomEdgeGestures: boolean;
+}
+declare const DEFAULT_APP_SETTINGS: AppSettings;
+declare const reducer$1: _rific_core.SettingsReducer<AppSettings>;
+declare const appSettingsActions: {
+    initialize: {
+        (payload: Partial<AppSettings>): _rific_core.SettingsAction<Partial<AppSettings>>;
+        type: string;
+        match: (action: {
+            type: string;
+        }) => action is _rific_core.SettingsAction<Partial<AppSettings>>;
+    };
+} & {};
+
+type LastActiveGameState = {
+    gameId: string | null;
+};
+
+declare function createShellReducers({ seatColors, appearance }: Pick<PackDefinition, 'seatColors' | 'appearance'>): {
+    theme: _rific_core.SettingsReducer<_rific_auto_paper.ThemeState>;
+    haptic: _rific_core.SettingsReducer<_rific_feedback_press.HapticSettings>;
+    sound: (state: SoundSettings | undefined, action: {
+        type: string;
+    }) => SoundSettings;
+    keepAwake: _rific_core.SettingsReducer<_rific_core.KeepAwakeSettings>;
+    profiles: typeof profilesReducer;
+    profileSelection: (state: _tastic_profile.ProfileSelectionState<Seat> | undefined, action: {
+        type: string;
+        payload?: unknown;
+    }) => _tastic_profile.ProfileSelectionState<Seat>;
+    seatColors: (state: _tastic_profile.SeatColorsState<Seat> | undefined, action: {
+        type: string;
+        payload?: unknown;
+    }) => _tastic_profile.SeatColorsState<Seat>;
+    appSettings: _rific_core.SettingsReducer<AppSettings>;
+    opponent: _rific_core.SettingsReducer<OpponentState>;
+    liveplay: _rific_core.SettingsReducer<LiveplaySliceState>;
+};
+type ShellReducers = ReturnType<typeof createShellReducers>;
+type ShellState = {
+    [K in keyof ShellReducers]: ReturnType<ShellReducers[K]>;
+} & {
+    lastActiveGame?: LastActiveGameState;
+};
+
+type Seat = 1 | 2;
+type SeatTwo = 'cpu' | 'person' | 'nobody';
+type RoundMode = 'vsCpu' | 'twoPlayer' | 'solo';
+declare function roundModeFor(seatTwo: SeatTwo): RoundMode;
+declare function seatTwoFor(saved: SeatTwo, choices: readonly SeatTwo[] | undefined): SeatTwo;
+declare function humanSeatsFor(mode: RoundMode): Seat[];
+interface LoadoutOptionsProps {
+    host: PopoverHost;
+    rotation: ViewRotation;
+    accentColor: string;
+    mutedColor: string;
+    onAccentColor: string;
+    dark: boolean;
+    onRandomize?: () => void;
+    onReset?: () => void;
+}
+interface SeatControlLook {
+    accentColor: string;
+    seatColor: string;
+    mutedColor: string;
+    dark: boolean;
+    rotation: ViewRotation;
+}
+interface GameLoadout {
+    roundSettings: object;
+    options: (props: LoadoutOptionsProps) => ReactNode;
+    optionIds: readonly string[];
+    randomize: () => void;
+    reset: () => void;
+    seatControl: (seat: Seat, host: PopoverHost, look: SeatControlLook) => ReactNode | undefined;
+    cpuDifficulty?: {
+        value: string;
+        options: MenuOption<string>[];
+        onChange: (value: string) => void;
+    };
+}
+interface GameGuide {
+    version: number;
+    selectVersionSeen: (state: ShellState) => number;
+    markSeen: (version: number) => Action;
+    selectInput: (state: ShellState) => object;
+    getSteps: (input: object, context: {
+        touch: boolean;
+        mode: RoundMode;
+    }) => GuideStep[];
+}
+interface GameIconProps {
+    size: number;
+    p1Color: string;
+    p2Color: string;
+    dark: boolean;
+}
+interface GamePreviewProps {
+    width: number;
+    height: number;
+    p1Color: string;
+    p2Color: string;
+    dark: boolean;
+}
+interface GameDefinition {
+    id: string;
+    title: string;
+    blurb: string;
+    icon: ComponentType<GameIconProps>;
+    Preview?: ComponentType<GamePreviewProps>;
+    seatTwo?: readonly SeatTwo[];
+    twoPlayerSeats?: {
+        faceToFaceOnWeb: boolean;
+        followUpsideDown: boolean;
+    };
+    reducers: Record<string, Reducer>;
+    Provider: ComponentType<{
+        children: ReactNode;
+    }>;
+    useLoadout?: (mode: RoundMode) => GameLoadout;
+    PlayScreen: ComponentType;
+    resumable?: boolean;
+    StatsSections: ComponentType<{
+        profileId: string | null;
+    }>;
+    AchievementList: ComponentType<{
+        profileId: string | null;
+    }>;
+    resetStats: () => Action;
+    guide: GameGuide;
+}
+interface HeroTitleProps {
+    words: readonly [string, string];
+    color: string;
+    p1Color: string;
+    p2Color: string;
+    active: boolean;
+    fit?: {
+        width: number;
+        height: number;
+    };
+}
+interface PackStatsSectionsProps {
+    profileId: string | null;
+    gameId: string | null;
+}
+interface PackDefinition {
+    name: string;
+    wordmark: readonly [string, string];
+    colorCaption: string;
+    games: readonly GameDefinition[];
+    seatColors: Record<Seat, string>;
+    appearance?: ThemeAppearance;
+    HeroTitle: ComponentType<HeroTitleProps>;
+    fonts?: Record<string, FontSource>;
+    fontFamily?: string;
+    otaVersion: number;
+    SettingsSections?: ComponentType;
+    reducers?: Record<string, Reducer>;
+    StatsSections?: ComponentType<PackStatsSectionsProps>;
+}
+
+declare function PackProvider({ pack, children }: {
+    pack: PackDefinition;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function usePack(): PackDefinition;
+declare function usePackGame(id: string | undefined): GameDefinition | undefined;
+
+interface PackStoreConfig {
+    keyPrefix: string;
+    migrate?: (state: PersistedState, version: number) => Promise<PersistedState>;
+}
+type PackStoreSource = Pick<PackDefinition, 'seatColors' | 'appearance' | 'reducers'> & {
+    games: readonly Pick<GameDefinition, 'reducers' | 'resumable'>[];
+};
+declare function createPackStore(pack: PackStoreSource, { keyPrefix, migrate }: PackStoreConfig): {
+    store: _reduxjs_toolkit.EnhancedStore<{
+        theme: _rific_auto_paper.ThemeState;
+        haptic: _rific_feedback_press.HapticSettings;
+        sound: _rific_feedback_press.SoundSettings;
+        keepAwake: _rific_core.KeepAwakeSettings;
+        profiles: _tastic_profile.Profile[];
+        profileSelection: _tastic_profile.ProfileSelectionState<Seat>;
+        seatColors: _tastic_profile.SeatColorsState<Seat>;
+        appSettings: AppSettings;
+        opponent: OpponentState;
+        liveplay: LiveplaySliceState;
+    } & redux_persist_es_persistReducer.PersistPartial, {
+        type: string;
+        payload?: unknown;
+    } | {
+        type: string;
+        payload?: unknown;
+    } | {
+        type: string;
+    } | {
+        type: string;
+    } | {
+        type: string;
+    }, _reduxjs_toolkit.Tuple<[redux.StoreEnhancer<{
+        dispatch: redux_thunk.ThunkDispatch<{
+            theme: _rific_auto_paper.ThemeState;
+            haptic: _rific_feedback_press.HapticSettings;
+            sound: _rific_feedback_press.SoundSettings;
+            keepAwake: _rific_core.KeepAwakeSettings;
+            profiles: _tastic_profile.Profile[];
+            profileSelection: _tastic_profile.ProfileSelectionState<Seat>;
+            seatColors: _tastic_profile.SeatColorsState<Seat>;
+            appSettings: AppSettings;
+            opponent: OpponentState;
+            liveplay: LiveplaySliceState;
+        } & redux_persist_es_persistReducer.PersistPartial, undefined, redux.UnknownAction>;
+    }>, redux.StoreEnhancer]>>;
+    persistor: redux_persist.Persistor;
+};
+type PackStore = ReturnType<typeof createPackStore>['store'];
+
+interface RootLayoutProps {
+    pack: PackDefinition;
+    store: PackStore;
+    persistor: Persistor;
+}
+declare function RootLayout({ pack, store, persistor }: RootLayoutProps): react.JSX.Element;
+
+declare function LoadoutRoute(): react.JSX.Element;
+declare function PlayRoute(): react.JSX.Element;
+
+declare function HomeScreen(): react.JSX.Element;
+
+declare const PREVIEW_ASPECT: number;
+
+declare function ProfilesRoute(): react.JSX.Element;
+
+declare function StatsScreen(): react.JSX.Element;
+
+interface GameGuideContextValue {
+    openFirstTime: (gameId: string, next: () => void) => void;
+    openFor: (gameId: string) => void;
+}
+declare function useGameGuide(): GameGuideContextValue;
+
+declare function imageGameIcon(images: {
+    light: ImageSourcePropType;
+    dark: ImageSourcePropType;
+}): ComponentType<GameIconProps>;
+
+interface SettingsDialogProps {
+    visible: boolean;
+    onDismiss: () => void;
+    rotation?: ViewRotation;
+    onShowHowToPlay?: () => void;
+    children?: ReactNode;
+}
+declare function SettingsDialog({ visible, onDismiss, rotation, onShowHowToPlay, children }: SettingsDialogProps): react.JSX.Element;
+
+declare function useActiveRound<S extends object>(game: string, defaults: S): {
+    mode: RoundMode;
+    settings: S;
+};
+
+declare function useAppSettings(): {
+    settings: AppSettings;
+    setSettings: (patch: Partial<AppSettings>) => void;
+};
+
+declare function useOpponent(): {
+    seatTwo: SeatTwo;
+    setSeatTwo: (seatTwo: SeatTwo) => void;
+};
+
+interface ProfilesContextValue {
+    profiles: Profile[];
+    lastSelected: Record<Seat, string | null>;
+    loaded: boolean;
+    createProfile: (input: CreateProfileInput) => Profile;
+    updateProfile: (id: string, patch: Partial<CreateProfileInput>) => void;
+    deleteProfile: (id: string) => void;
+    selectProfile: (seat: Seat, profileId: string | null) => void;
+}
+interface Props {
+    children: ReactNode;
+}
+declare function ProfilesProvider({ children }: Props): react.JSX.Element;
+declare function useProfiles(): ProfilesContextValue;
+
+declare function useSeatColors(p2IsHuman: boolean): {
+    p1Color: string;
+    p2Color: string;
+    handleP1ColorChange: (hex: string) => void;
+    handleP2ColorChange: (hex: string) => void;
+};
+
+interface GameGuideState {
+    versionSeen: number;
+}
+declare function createGameGuideSlice(mountKey: string): {
+    actions: {
+        markSeen: (version: number) => {
+            type: string;
+            payload: number;
+        };
+    };
+    reducer: (state: GameGuideState | undefined, action: Action & {
+        payload?: unknown;
+    }) => GameGuideState;
+    selectVersionSeen: (rootState: object) => number;
+};
+
+declare function onProfileRemoved<S>(reducer: Reducer<S>, forget: (state: S, profileId: string) => S): Reducer<S>;
+declare function forgetProfileAchievements<T, S extends {
+    stats: T;
+    unlocked: UnlockedAchievementsState;
+}>(dropStats: (stats: T, profileId: string) => T): (state: S, profileId: string) => S;
+
+type ProfileSelectionState = Record<Seat, string | null>;
+declare const defaultProfileSelectionState: ProfileSelectionState;
+declare const reducer: (state: _tastic_profile.ProfileSelectionState<Seat> | undefined, action: {
+    type: string;
+    payload?: unknown;
+}) => _tastic_profile.ProfileSelectionState<Seat>;
+declare const profileSelectionActions: _tastic_profile.ProfileSelectionActions<Seat>;
+
+type SeatColorsState = SeatColorsState$1<Seat>;
+declare function defaultSeatColorsState(seatColors: Record<Seat, string>): SeatColorsState;
+declare function createSeatColorsReducer(seatColors: Record<Seat, string>): (state: SeatColorsState$1<Seat> | undefined, action: {
+    type: string;
+    payload?: unknown;
+}) => SeatColorsState$1<Seat>;
+declare const seatColorsActions: _tastic_profile.SeatColorsActions<Seat>;
+
+interface RecordResult<TStats> {
+    device: AchievementDefinition<TStats>[];
+    profiles: Partial<Record<Seat, AchievementDefinition<TStats>[]>>;
+}
+interface GameStatsContextValue<TStats> {
+    stats: TStats;
+    unlockedAchievements: UnlockedAchievementsState;
+    record: (update: (prev: TStats) => TStats, profileIds?: Partial<Record<Seat, string>>) => RecordResult<TStats>;
+    resetAll: () => void;
+}
+interface GameStatsOptions<TStats, TBucket> {
+    key: string;
+    defaultStats: TStats;
+    isValidStats?: (value: unknown) => boolean;
+    catalog: AchievementDefinition<TStats>[];
+    getProfileStatsView: (bucket: TBucket) => TStats;
+}
+declare function createGameStats<TStats extends {
+    profiles: Record<string, TBucket>;
+}, TBucket>({ key, defaultStats, isValidStats, catalog, getProfileStatsView }: GameStatsOptions<TStats, TBucket>): {
+    reducer: redux.Reducer<AchievementsState<TStats>>;
+    actions: _tastic_achievements.AchievementsActions<TStats>;
+    Provider: ({ children }: {
+        children: ReactNode;
+    }) => react.JSX.Element;
+    useStats: () => GameStatsContextValue<TStats>;
+};
+
+declare function seatPlayerKey(selection: Record<Seat, string | null>, seat: Seat): string;
+type WithControls<C> = {
+    controlScheme: Record<Seat, C>;
+};
+type PlayerSettingsState<S> = Record<string, Partial<Omit<S, 'controlScheme'>>>;
+type PlayerControlsState<C> = Record<string, C>;
+interface PlayerSettingsOptions<S extends WithControls<C>, C> {
+    id: string;
+    defaults: S;
+    distinctControls?: readonly C[];
+}
+declare function createPlayerSettings<S extends WithControls<C>, C>({ id, defaults, distinctControls }: PlayerSettingsOptions<S, C>): {
+    reducers: {
+        [x: string]: redux.Reducer<PlayerSettingsState<S>> | redux.Reducer<PlayerControlsState<C>>;
+    };
+    settingsReducer: redux.Reducer<PlayerSettingsState<S>>;
+    controlsReducer: redux.Reducer<PlayerControlsState<C>>;
+    actions: {
+        patch: (player: string, changes: Partial<Omit<S, "controlScheme">>) => {
+            type: string;
+            payload: {
+                player: string;
+                changes: Partial<Omit<S, "controlScheme">>;
+            };
+        };
+        setControl: (player: string, control: C) => {
+            type: string;
+            payload: {
+                player: string;
+                control: C;
+            };
+        };
+    };
+    compose: (saved: PlayerSettingsState<S> | undefined, controls: PlayerControlsState<C> | undefined, selection: Record<Seat, string | null>, seatTwoIsPerson: boolean) => S;
+    select: (state: ShellState) => S;
+    useSettings: () => {
+        settings: S;
+        setSettings: (patch: Partial<S>) => void;
+    };
+};
+
+export { type ActiveRound, type AppSettings, DEFAULT_APP_SETTINGS, DEFAULT_OPPONENT, type GameDefinition, type GameGuide, type GameGuideState, type GameIconProps, type GameLoadout, type GamePreviewProps, type HeroTitleProps, HomeScreen, type LiveplaySliceState, type LoadoutOptionsProps, LoadoutRoute, type OpponentState, PREVIEW_ASPECT, type PackDefinition, PackProvider, type PackStatsSectionsProps, type PackStore, type PackStoreConfig, type PackStoreSource, PlayRoute, type PlayerControlsState, type PlayerSettingsState, type ProfileSelectionState, ProfilesProvider, ProfilesRoute, type RecordResult, RootLayout, type RoundMode, type Seat, type SeatColorsState, type SeatControlLook, type SeatTwo, SettingsDialog, type SettingsDialogProps, type ShellState, StatsScreen, appSettingsActions, reducer$1 as appSettingsReducer, createGameGuideSlice, createGameStats, createPackStore, createPlayerSettings, createSeatColorsReducer, createShellReducers, defaultProfileSelectionState, defaultSeatColorsState, forgetProfileAchievements, humanSeatsFor, imageGameIcon, liveplayActions, reducer$3 as liveplayReducer, onProfileRemoved, opponentActions, reducer$2 as opponentReducer, profileSelectionActions, reducer as profileSelectionReducer, roundModeFor, seatColorsActions, seatPlayerKey, seatTwoFor, useActiveRound, useAppSettings, useGameGuide, useOpponent, usePack, usePackGame, useProfiles, useSeatColors };