devendra-skill-package 1.0.2

package/.github/skills/clean-architecture-generator/references/platform-react-native.md

@@ -0,0 +1,590 @@
+# Platform File — React Native
+
+Read `architecture-core.md` first. This file supplies the React Native-specific implementation of
+the universal layers: folder tree, DI mechanism, state/HTTP/storage/navigation patterns, naming
+extensions, and anti-patterns. Everything under "Stack Fingerprint Defaults" applies **only** when
+Phase 1 detection (see `SKILL.md`) found nothing in the target repo — if the repo already uses a
+different state library, HTTP client, storage, or navigation library, generate against what's
+already there instead.
+
+---
+
+## Stack Fingerprint Defaults (greenfield only)
+
+| Concern | Detect first (search for) | Default if nothing detected |
+|---|---|---|
+| Language | — | TypeScript, strict mode |
+| State management | `createSlice(`, `create(` from `'zustand'`, `makeAutoObservable(`/`observable(` (mobx), `useReducer`+`createContext` | Redux Toolkit (`createSlice`, `createAsyncThunk`) + RTK Query (`createApi`) |
+| HTTP client | `axios.create(`, `fetch(`, `createApi(`, React Query hooks | Axios with interceptors |
+| Local storage | `MMKV`, `AsyncStorage`, `react-native-keychain` | MMKV (`SafeMMKV` wrapper) for general data; Keychain for secrets/tokens |
+| Navigation | `@react-navigation/native`, `expo-router`, `react-native-navigation` (Wix) | React Navigation v6+, native-stack |
+| DI mechanism | existing `di/[feature]Container.ts` or `di/[feature]DI.ts` files | manual DI — Pattern A or B below |
+| Test runner | `jest.config.*`, test script in `package.json` | Jest |
+
+---
+
+## Folder Tree
+
+```
+src/
+├── app/                        # App bootstrap — orchestration only
+│   ├── AppWrapper.tsx          # Root component, cache hydration, offline overlay
+│   ├── index.ts
+│   ├── NetworkMonitor.tsx
+│   ├── NoInternetScreen.tsx
+│   ├── useNetworkStatus.ts
+│   ├── di/
+│   │   ├── container.ts        # Global DI container — wires all feature containers
+│   │   └── index.ts
+│   ├── environment/
+│   │   ├── authConfig.ts       # OAuth / auth provider config
+│   │   ├── env.ts              # Environment variable accessors (no raw process.env)
+│   │   └── index.ts
+│   ├── offline/
+│   │   ├── OfflineOverlayController.tsx
+│   │   ├── offlineOverlayTypes.ts
+│   │   └── index.ts
+│   ├── routing/
+│   │   ├── AppNavigator.tsx    # Top-level (decides auth vs main)
+│   │   ├── RootNavigator.tsx   # Authenticated root
+│   │   ├── MainTabsNavigator.tsx
+│   │   ├── TabsNavigator.tsx
+│   │   └── index.ts
+│   └── state/
+│       └── store.ts            # Redux store configuration
+│
+├── core/                       # Infrastructure — shared by all features
+│   ├── api/
+│   │   ├── axiosClient.ts      # Singleton Axios instance + interceptors + SSL pinning
+│   │   ├── apiErrorHandler.ts
+│   │   ├── AppError.ts         # Typed error class hierarchy
+│   │   ├── tokenProvider.ts    # Token getter/setter (prevents circular deps)
+│   │   ├── unauthorizedHandler.ts
+│   │   ├── requestUtils.ts     # Header builders, nonce generation
+│   │   └── index.ts
+│   ├── cache/
+│   │   ├── baseApiSlice.ts     # Single createApi instance for the whole app
+│   │   ├── axiosBaseQuery.ts
+│   │   ├── CacheConfig.ts
+│   │   ├── hydrateCacheOnStart.ts
+│   │   ├── persistenceMiddleware.ts
+│   │   └── persistenceRegistry.ts
+│   ├── config/
+│   │   ├── constants.ts
+│   │   └── index.ts
+│   ├── device/
+│   │   ├── smsComposer.ts
+│   │   └── index.ts
+│   ├── error/
+│   │   ├── errorHandler.ts
+│   │   └── index.ts
+│   ├── logging/
+│   │   ├── loggerService.ts
+│   │   ├── auditLogger.ts
+│   │   ├── correlationId.ts
+│   │   └── index.ts
+│   ├── permissions/
+│   │   ├── permissionsService.ts
+│   │   └── index.ts
+│   ├── resilience/
+│   │   ├── offlineModeService.ts
+│   │   ├── resilienceService.ts
+│   │   └── index.ts
+│   ├── security/
+│   │   ├── EncryptionService.ts
+│   │   ├── DeviceSecurityCheck.ts
+│   │   ├── entitlementService.ts
+│   │   ├── SSLPinningAdapter.ts
+│   │   └── index.ts
+│   ├── storage/
+│   │   ├── mmkvStorageService.ts
+│   │   ├── SafeMMKV.ts
+│   │   ├── keychainService.ts
+│   │   ├── authTokenStorage.ts
+│   │   ├── storageService.ts
+│   │   └── index.ts
+│   ├── store/
+│   │   └── hooks.ts            # useAppDispatch, useAppSelector
+│   ├── streaming/
+│   │   ├── websocket.ts
+│   │   └── index.ts
+│   └── analytics/
+│       ├── eventTracker.ts
+│       ├── pushNotificationService.ts
+│       └── index.ts
+│
+├── features/                   # One folder per feature, fully self-contained
+│   └── [feature-name]/
+│       ├── domain/              # Pure TypeScript — ZERO framework imports
+│       │   ├── entities/
+│       │   ├── usecases/
+│       │   ├── repositories/    # Interfaces only (I-prefixed)
+│       │   └── index.ts
+│       ├── data/
+│       │   ├── api/             # Feature-specific Axios API client class
+│       │   ├── dtos/             # Raw API response shapes
+│       │   ├── mappers/          # mapTo pure functions
+│       │   ├── repositories/     # Concrete implementations
+│       │   ├── cache/            # Optional feature cache helpers
+│       │   ├── config/           # Feature API base URLs, endpoint paths
+│       │   ├── mock/             # Static mock responses (dev/test only)
+│       │   └── index.ts
+│       ├── presentation/
+│       │   ├── screens/
+│       │   ├── components/
+│       │   ├── hooks/
+│       │   ├── navigation/       # Typed route param lists + navigators
+│       │   ├── state/            # Redux slices, thunks, selectors (or detected equivalent)
+│       │   ├── viewmodels/
+│       │   ├── styles/
+│       │   ├── config/           # Use case singleton instances, constants
+│       │   ├── utils/
+│       │   ├── validation/
+│       │   ├── providers/
+│       │   └── index.ts
+│       ├── di/
+│       │   └── [Feature]Container.ts
+│       ├── assets/
+│       ├── __tests__/
+│       └── index.ts             # Public API — barrel exports everything public
+│
+├── shared/
+│   └── theme/                   # Design tokens only — NO logic, NO components
+│
+├── services/
+│   └── [ExternalServiceHelper].ts
+│
+├── constants/
+│   ├── [eventNames].ts
+│   └── [propertyKeys].ts
+│
+└── types/
+    ├── env.d.ts
+    └── thirdParty.d.ts
+```
+
+### Monorepo variant (Yarn Workspaces) — only when the target repo already uses one
+
+```
+packages/
+├── common-domain/      # Pure TypeScript: BaseEntity, BaseUseCase, Result monad, error types
+├── common-data/        # HTTP infrastructure, storage adapters, base repository impl
+└── common-presentation/ # Reusable UI: components, theme, hooks, icons
+```
+
+---
+
+## Dependency Rules (RN-specific detail on top of architecture-core.md)
+
+```
+packages/common-domain       ← no external deps
+packages/common-data         ← imports common-domain only
+packages/common-presentation ← imports common-domain, common-data
+
+core/                        ← imports packages/* only; MUST NOT import features/*
+features/[x]/domain/         ← imports common-domain ONLY; zero React/Redux/Axios
+features/[x]/data/           ← imports core/, common-data, own domain/
+features/[x]/presentation/   ← imports core/, packages/*, own domain/, own data/
+features/[x]/di/             ← imports all layers of own feature + core/
+app/                          ← imports all features/* (orchestration only)
+shared/                       ← no imports from features/ or core/
+```
+
+## TypeScript Path Aliases
+
+Read `tsconfig.json` for existing paths before inventing any. If none exist, propose (and confirm
+with the user before writing):
+
+```json
+{
+  "compilerOptions": {
+    "baseUrl": "./src",
+    "paths": {
+      "@/*": ["./*"],
+      "@core/*": ["./core/*"],
+      "@features/*": ["./features/*"],
+      "@app": ["./app/index"],
+      "@app/*": ["./app/*"],
+      "@shared/*": ["./shared/*"],
+      "@services/*": ["./services/*"]
+    }
+  }
+}
+```
+
+Mirror any alias exactly in `babel.config.js` via the `module-resolver` plugin.
+
+---
+
+## Naming Extensions (RN-specific, on top of architecture-core.md)
+
+| Artifact | Convention | Example |
+|----------|------------|---------|
+| Feature folder | kebab-case | `portfolio-summary`, `user-profile` |
+| Entity file | PascalCase | `HoldingEntity.ts` |
+| Repository interface | `I` + PascalCase + `Repository` | `IHoldingRepository.ts` |
+| Repository implementation | PascalCase + `RepositoryImpl` | `HoldingRepositoryImpl.ts` |
+| Use case file | PascalCase + `UseCase` | `GetHoldingSummaryUseCase.ts` |
+| API client class | PascalCase + `ApiClient` | `HoldingApiClient.ts` |
+| DTO file | PascalCase + `DTO` | `HoldingSummaryDTO.ts` |
+| Mapper function | `mapTo` prefix | `mapHoldingDTOToDomain` |
+| Redux slice file | camelCase + `Slice` | `holdingSlice.ts` |
+| Redux thunks file | camelCase + `Thunks` | `holdingThunks.ts` |
+| Selectors file | camelCase + `Selectors` (optional) | `holdingSelectors.ts` |
+| Screen file | PascalCase + `Screen` | `HoldingDetailScreen.tsx` |
+| Hook file | `use` + PascalCase | `useHoldingSummary.ts` |
+| ViewModel hook | `use` + PascalCase + `ViewModel` | `useHoldingViewModel.ts` |
+| Navigator param list | PascalCase + `StackParamList` | `HoldingStackParamList` |
+| Route names file | camelCase + `Routes` | `holdingRoutes.ts` |
+| DI container (getter pattern) | camelCase + `Container` | `holdingContainer.ts` |
+| DI container (factory pattern) | camelCase + `DI` | `holdingDI.ts` |
+| Selector function | `select` + PascalCase | `selectHoldingTotal` |
+| Mock file | `.mock.ts` suffix or `/mock/` folder | `holdingResponse.mock.ts` |
+| Test file | `.test.ts` or `.spec.ts` | `HoldingRepositoryImpl.test.ts` |
+| ThunkExtra interface | PascalCase + `ThunkExtra` | `HoldingThunkExtra` |
+| Loading state | `'idle' \| 'loading' \| 'succeeded' \| 'failed'` string union | never a `boolean` |
+
+---
+
+## DI Pattern A — Lazy Getter Object (most features)
+
+```ts
+// src/features/[feature]/di/[feature]Container.ts
+import { [Feature]ApiClient } from '../data/api/[Feature]ApiClient';
+import { [Feature]RepositoryImpl } from '../data/repositories/[Feature]RepositoryImpl';
+import { Get[Item]UseCase } from '../domain/usecases/Get[Item]UseCase';
+
+let _apiClient: [Feature]ApiClient | null = null;
+let _repo: [Feature]RepositoryImpl | null = null;
+
+function getApiClient(): [Feature]ApiClient {
+  if (!_apiClient) _apiClient = new [Feature]ApiClient();
+  return _apiClient;
+}
+
+function getRepository(): [Feature]RepositoryImpl {
+  if (!_repo) _repo = new [Feature]RepositoryImpl(getApiClient());
+  return _repo;
+}
+
+export const [feature]Container = {
+  get get[Item]UseCase() {
+    return new Get[Item]UseCase(getRepository());
+  },
+};
+```
+
+## DI Pattern B — Factory Function (features with multiple ThunkExtra types)
+
+```ts
+// src/features/[feature]/di/[feature]DI.ts
+import { [Feature]DataSource } from '../data/datasources/[Feature]DataSource';
+import { [Feature]RepositoryImpl } from '../data/repositories/[Feature]RepositoryImpl';
+import { Get[Item]UseCase } from '../domain/useCases/[Feature]UseCases';
+import type { [Feature]ThunkExtra } from '../presentation/state/[concern]Thunks';
+
+export function create[Feature]ThunkExtra(): [Feature]ThunkExtra {
+  const dataSource = new [Feature]DataSource();
+  const repository = new [Feature]RepositoryImpl(dataSource);
+  const get[Item]UseCase = new Get[Item]UseCase(repository);
+  return { get[Item]UseCase };
+}
+```
+
+## Auth — Special Case
+
+Auth does not use either container pattern. Creates module-level singletons in
+`presentation/config/useCaseInstances.ts` and re-exports from `app/di/container.ts`.
+
+**Token getter pattern (prevents circular imports):**
+
+```ts
+// src/core/api/tokenProvider.ts
+let _getToken: (() => string | null) | null = null;
+export const setTokenGetter = (fn: () => string | null) => { _getToken = fn; };
+export const getToken = (): string | null => _getToken?.() ?? null;
+
+// Auth feature registers during session restore:
+setTokenGetter(() => authCache.getAccessToken());
+
+// Axios interceptor reads it:
+const token = getToken();
+if (token) config.headers.Authorization = `Bearer ${token}`;
+```
+
+---
+
+## Redux Store Configuration
+
+```ts
+// src/app/state/store.ts
+import { configureStore } from '@reduxjs/toolkit';
+import { setupListeners } from '@reduxjs/toolkit/query';
+import { baseApiSlice } from '@core/cache/baseApiSlice';
+import { createPersistenceMiddleware } from '@core/cache/persistenceMiddleware';
+import persistenceRegistry from '@core/cache/persistenceRegistry';
+import { [feature]Reducer } from '@features/[feature]/presentation/state';
+import { [feature]Container } from '@features/[feature]/di/[Feature]Container';
+
+export const store = configureStore({
+  reducer: {
+    [feature]: [feature]Reducer,
+    [baseApiSlice.reducerPath]: baseApiSlice.reducer,
+  },
+  middleware: (getDefault) =>
+    getDefault({
+      thunk: { extraArgument: { ...[feature]Container } },
+      serializableCheck: { ignoredActions: [], ignoredPaths: [] },
+    })
+      .concat(baseApiSlice.middleware)
+      .concat(createPersistenceMiddleware(persistenceRegistry)),
+});
+
+setupListeners(store.dispatch);
+
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+```
+
+## Redux Slice Pattern
+
+```ts
+// src/features/[feature]/presentation/state/[concern]Slice.ts
+import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+import { fetch[Concern] } from './[concern]Thunks';
+import type { [Concern]Entity } from '../../domain/entities';
+
+export type LoadingState = 'idle' | 'loading' | 'succeeded' | 'failed';
+
+interface [Concern]State {
+  data: [Concern]Entity | null;
+  loading: LoadingState;
+  error: string | null;
+}
+
+const initialState: [Concern]State = { data: null, loading: 'idle', error: null };
+
+const [concern]Slice = createSlice({
+  name: '[feature]/[concern]',
+  initialState,
+  reducers: {
+    reset[Concern]: () => initialState,
+    set[Concern]: (state, action: PayloadAction<[Concern]Entity>) => {
+      state.data = action.payload;
+    },
+  },
+  extraReducers: (builder) => {
+    builder
+      .addCase(fetch[Concern].pending, (state) => { state.loading = 'loading'; state.error = null; })
+      .addCase(fetch[Concern].fulfilled, (state, action) => { state.loading = 'succeeded'; state.data = action.payload; })
+      .addCase(fetch[Concern].rejected, (state, action) => { state.loading = 'failed'; state.error = action.error.message ?? 'Unknown error'; });
+  },
+});
+
+export const { reset[Concern], set[Concern] } = [concern]Slice.actions;
+export const [concern]Reducer = [concern]Slice.reducer;
+```
+
+## Redux Thunk Pattern
+
+```ts
+// src/features/[feature]/presentation/state/[concern]Thunks.ts
+import { createAsyncThunk } from '@reduxjs/toolkit';
+import type { Get[Concern]UseCase } from '../../domain/usecases/Get[Concern]UseCase';
+
+// ThunkExtra interface defined HERE — not in the DI container file
+export interface [Feature]ThunkExtra {
+  get[Concern]UseCase: Get[Concern]UseCase;
+}
+
+export const fetch[Concern] = createAsyncThunk(
+  '[feature]/fetch[Concern]',
+  async (args: [RequestArgs], thunkAPI) => {
+    const { get[Concern]UseCase } = thunkAPI.extra as [Feature]ThunkExtra;
+    return get[Concern]UseCase.execute(args);
+  },
+);
+```
+
+## Selector Pattern
+
+```ts
+// [concern]Selectors.ts — raw state reads
+import type { RootState } from '@app/state/store';
+
+export const select[Concern]Data = (state: RootState) => state.[feature].[concern].data;
+export const select[Concern]Loading = (state: RootState) => state.[feature].[concern].loading;
+export const select[Concern]Error = (state: RootState) => state.[feature].[concern].error;
+
+// [concern]ViewModelSelectors.ts — composed selectors for screens
+import { createSelector } from '@reduxjs/toolkit';
+export const select[Concern]ViewModel = createSelector(
+  [select[Concern]Data, select[Concern]Loading, select[Concern]Error],
+  (data, loading, error) => ({ data, loading, error }),
+);
+```
+
+## RTK Query Endpoint Pattern
+
+```ts
+// src/features/[feature]/data/api/[feature]ApiSlice.ts
+import { baseApiSlice } from '@core/cache/baseApiSlice';
+import type { [Item]DTO } from '../dtos/[Item]DTO';
+import type { [Item]Entity } from '../../domain/entities';
+import { map[Item]DTOToDomain } from '../mappers/[feature]Mappers';
+
+export const [feature]ApiSlice = baseApiSlice.injectEndpoints({
+  endpoints: (build) => ({
+    get[Item]: build.query<[Item]Entity, [RequestArgs]>({
+      query: (args) => ({ url: '/[endpoint]', method: 'POST', data: args }),
+      transformResponse: (raw: [Item]DTO) => map[Item]DTOToDomain(raw),
+      keepUnusedDataFor: 300,
+    }),
+  }),
+  overrideExisting: false,
+});
+
+export const { useGet[Item]Query } = [feature]ApiSlice;
+```
+
+## Domain Layer Pattern
+
+```ts
+// domain/repositories/I[Feature]Repository.ts
+export interface I[Feature]Repository {
+  get[Item](args: [RequestArgs]): Promise<[Item]Entity>;
+}
+
+// domain/usecases/Get[Item]UseCase.ts
+export class Get[Item]UseCase {
+  constructor(private readonly repository: I[Feature]Repository) {}
+  async execute(args: [RequestArgs]): Promise<[Item]Entity> {
+    return this.repository.get[Item](args);
+  }
+}
+```
+
+## Data Layer Pattern
+
+```ts
+// data/api/[Feature]ApiClient.ts
+import { axiosClient } from '@core/api/axiosClient';
+
+export class [Feature]ApiClient {
+  async get[Item](args: [RequestArgs]): Promise<[Item]DTO> {
+    const response = await axiosClient.post('/[endpoint]', args);
+    return response.data;
+  }
+}
+
+// data/repositories/[Feature]RepositoryImpl.ts
+import type { I[Feature]Repository } from '../../domain/repositories/I[Feature]Repository';
+import type { [Feature]ApiClient } from '../api/[Feature]ApiClient';
+import { map[Item]DTOToDomain } from '../mappers/[feature]Mappers';
+
+export class [Feature]RepositoryImpl implements I[Feature]Repository {
+  constructor(private readonly apiClient: [Feature]ApiClient) {}
+  async get[Item](args: [RequestArgs]): Promise<[Item]Entity> {
+    const dto = await this.apiClient.get[Item](args);
+    return map[Item]DTOToDomain(dto);
+  }
+}
+```
+
+## Navigation Pattern
+
+```ts
+// presentation/navigation/[feature]Routes.ts
+import type { NativeStackScreenProps } from '@react-navigation/native-stack';
+
+export type [Feature]StackParamList = {
+  [Feature]Main: undefined;
+  [Feature]Detail: { id: string; entrySource?: 'list' | 'search' };
+};
+
+export type [Feature]MainScreenProps = NativeStackScreenProps<[Feature]StackParamList, '[Feature]Main'>;
+export type [Feature]DetailScreenProps = NativeStackScreenProps<[Feature]StackParamList, '[Feature]Detail'>;
+```
+
+Tab bar visibility: call `getFocusedRouteNameFromRoute()` in `MainTabsNavigator` to hide the tab bar
+when a detail screen is focused.
+
+## Typed Store Hooks
+
+```ts
+// src/core/store/hooks.ts
+import { useDispatch, useSelector } from 'react-redux';
+import type { RootState, AppDispatch } from '@app/state/store';
+
+export const useAppDispatch = () => useDispatch<AppDispatch>();
+export const useAppSelector = <T>(selector: (state: RootState) => T): T => useSelector(selector);
+```
+
+---
+
+## Offline Resilience Rules
+
+1. RTK Query global: `refetchOnReconnect: true` + call `setupListeners(store.dispatch)` after store creation.
+2. Mutating operations when `NetInfo.isConnected === false` → enqueue in offline queue service.
+3. Offline queue persists to MMKV (survives app kills).
+4. `OfflineOverlayController` intercepts Android hardware back button to dismiss overlay, not navigate.
+5. On reconnect, queue flushes automatically — UI does not trigger it.
+
+## Security Rules (mobile-specific — on top of architecture-core.md)
+
+1. All tokens in MMKV with AES-256 encryption — never AsyncStorage.
+2. Every outbound request signed with nonce (UUID v4) and correlation ID header.
+3. Authorization header: `Bearer <token>`.
+4. Device security check (root/jailbreak) runs at app boot before any network calls.
+5. SSL pinning applied at the Axios adapter layer — never `rejectUnauthorized: false`.
+6. Encryption keys managed via native Keychain/Keystore — never in the JS bundle.
+
+---
+
+## Anti-Patterns (RN-specific, on top of architecture-core.md)
+
+- **Never** use `useDispatch` / `useSelector` directly — always use `useAppDispatch` / `useAppSelector`.
+- **Never** use a `boolean` for loading state in a Redux slice — use `'idle' | 'loading' | 'succeeded' | 'failed'`.
+- **Never** define `ThunkExtra` inside the DI container file — define it in the thunks file alongside the thunks that use it.
+- **Never** call `.get[Feature]HookDependencies()` from inside a thunk — cast `thunkAPI.extra` directly to the `ThunkExtra` type.
+- **Never** use the class-based `getInstance()` singleton pattern for feature DI containers — use module-level lazy variables with getter objects (Pattern A) or factory functions (Pattern B).
+- **Never** create use cases as module-level singletons in a feature container (except auth) — use ES6 getter properties that create a fresh instance per access.
+- **Never** store secrets or tokens in `AsyncStorage` — use MMKV with AES-256 encryption or Keychain/Keystore.
+- **Never** store encryption keys in the JS bundle — use native Keychain/Keystore.
+- **Never** bypass SSL pinning in production code — even for testing.
+- **Never** use `rejectUnauthorized: false` in Axios config.
+
+---
+
+## Worked Example
+
+**Request**: "Add a watchlist feature with ability to fetch and display watchlist items."
+
+**Artifacts**:
+- Domain: `WatchlistItemEntity`, `IWatchlistRepository`, `GetWatchlistUseCase`
+- Data: `WatchlistApiClient`, `WatchlistItemDTO`, `mapWatchlistDTOToDomain`, `WatchlistRepositoryImpl`
+- Presentation: `watchlistSlice`, `watchlistThunks`, `watchlistSelectors`, `WatchlistScreen`
+- DI: `watchlistContainer` (Pattern A)
+
+**Output**:
+```
+Created:
+  src/features/watchlist/domain/entities/WatchlistItemEntity.ts
+  src/features/watchlist/domain/repositories/IWatchlistRepository.ts
+  src/features/watchlist/domain/usecases/GetWatchlistUseCase.ts
+  src/features/watchlist/data/api/WatchlistApiClient.ts
+  src/features/watchlist/data/dtos/WatchlistItemDTO.ts
+  src/features/watchlist/data/mappers/watchlistMappers.ts
+  src/features/watchlist/data/repositories/WatchlistRepositoryImpl.ts
+  src/features/watchlist/presentation/state/watchlistSlice.ts
+  src/features/watchlist/presentation/state/watchlistThunks.ts
+  src/features/watchlist/presentation/state/watchlistSelectors.ts
+  src/features/watchlist/presentation/screens/WatchlistScreen.tsx
+  src/features/watchlist/di/watchlistContainer.ts
+  src/features/watchlist/index.ts
+
+Updated:
+  src/app/state/store.ts  (added reducer + container to extraArgument)
+
+Dependency check: PASS — no layer boundary violations detected
+```