19 files changed, 463 insertions, 297 deletions

diff --git a/packages/main/src/controllers/__tests__/initConfig.spec.ts b/packages/main/src/controllers/__tests__/initConfig.spec.ts
index dc00b9d..fdd22c9 100644
--- a/packages/main/src/controllers/__tests__/initConfig.spec.ts
+++ b/packages/main/src/controllers/__tests__/initConfig.spec.ts
@@ -20,16 +20,15 @@
 
 import { jest } from '@jest/globals';
 import { mocked } from 'jest-mock';
-import { getSnapshot } from 'mobx-state-tree';
 import ms from 'ms';
 
 import type ConfigPersistence from '../../infrastructure/ConfigPersistence';
-import { Config, config as configModel } from '../../stores/Config';
+import { sharedStore, SharedStore } from '../../stores/SharedStore';
 import type Disposer from '../../utils/Disposer';
 import { silenceLogger } from '../../utils/log';
 import initConfig from '../initConfig';
 
-let config: Config;
+let store: SharedStore;
 const persistenceService: ConfigPersistence = {
   readConfig: jest.fn(),
   writeConfig: jest.fn(),
@@ -44,7 +43,7 @@ beforeAll(() => {
 });
 
 beforeEach(() => {
-  config = configModel.create();
+  store = sharedStore.create();
 });
 
 describe('when initializing', () => {
@@ -56,7 +55,7 @@ describe('when initializing', () => {
     });
 
     it('should create a new config file', async () => {
-      await initConfig(config, persistenceService);
+      await initConfig(store, persistenceService);
       expect(persistenceService.writeConfig).toHaveBeenCalledTimes(1);
     });
 
@@ -65,7 +64,7 @@ describe('when initializing', () => {
         new Error('boo'),
       );
       await expect(() =>
-        initConfig(config, persistenceService),
+        initConfig(store, persistenceService),
       ).rejects.toBeInstanceOf(Error);
     });
   });
@@ -76,16 +75,16 @@ describe('when initializing', () => {
         found: true,
         data: {
           // Use a default empty config file to not trigger config rewrite.
-          ...getSnapshot(config),
+          ...store.config,
           themeSource: 'dark',
         },
       });
     });
 
     it('should read the existing config file is there is one', async () => {
-      await initConfig(config, persistenceService);
+      await initConfig(store, persistenceService);
       expect(persistenceService.writeConfig).not.toHaveBeenCalled();
-      expect(config.themeSource).toBe('dark');
+      expect(store.settings.themeSource).toBe('dark');
     });
 
     it('should bail if it cannot set up a watcher', async () => {
@@ -93,7 +92,7 @@ describe('when initializing', () => {
         throw new Error('boo');
       });
       await expect(() =>
-        initConfig(config, persistenceService),
+        initConfig(store, persistenceService),
       ).rejects.toBeInstanceOf(Error);
     });
   });
@@ -108,7 +107,7 @@ describe('when initializing', () => {
         },
       },
     });
-    await initConfig(config, persistenceService);
+    await initConfig(store, persistenceService);
     expect(persistenceService.writeConfig).toHaveBeenCalledTimes(1);
   });
 
@@ -119,15 +118,15 @@ describe('when initializing', () => {
         themeSource: -1,
       },
     });
-    await initConfig(config, persistenceService);
-    expect(config.themeSource).not.toBe(-1);
+    await initConfig(store, persistenceService);
+    expect(store.settings.themeSource).not.toBe(-1);
     expect(persistenceService.writeConfig).not.toHaveBeenCalled();
   });
 
   it('should bail if it cannot determine whether there is a config file', async () => {
     mocked(persistenceService.readConfig).mockRejectedValue(new Error('boo'));
     await expect(() =>
-      initConfig(config, persistenceService),
+      initConfig(store, persistenceService),
     ).rejects.toBeInstanceOf(Error);
   });
 });
@@ -140,10 +139,10 @@ describe('when it has loaded the config', () => {
   beforeEach(async () => {
     mocked(persistenceService.readConfig).mockResolvedValueOnce({
       found: true,
-      data: getSnapshot(config),
+      data: store.config,
     });
     mocked(persistenceService.watchConfig).mockReturnValueOnce(watcherDisposer);
-    sutDisposer = await initConfig(config, persistenceService, throttleMs);
+    sutDisposer = await initConfig(store, persistenceService, throttleMs);
     [[configChangedCallback]] = mocked(
       persistenceService.watchConfig,
     ).mock.calls;
@@ -152,16 +151,16 @@ describe('when it has loaded the config', () => {
 
   it('should throttle saving changes to the config file', () => {
     mocked(persistenceService.writeConfig).mockResolvedValue();
-    config.setThemeSource('dark');
+    store.settings.setThemeSource('dark');
     jest.advanceTimersByTime(lessThanThrottleMs);
-    config.setThemeSource('light');
+    store.settings.setThemeSource('light');
     jest.advanceTimersByTime(throttleMs);
     expect(persistenceService.writeConfig).toHaveBeenCalledTimes(1);
   });
 
   it('should handle config writing errors gracefully', () => {
     mocked(persistenceService.writeConfig).mockRejectedValue(new Error('boo'));
-    config.setThemeSource('dark');
+    store.settings.setThemeSource('dark');
     jest.advanceTimersByTime(throttleMs);
     expect(persistenceService.writeConfig).toHaveBeenCalledTimes(1);
   });
@@ -171,14 +170,14 @@ describe('when it has loaded the config', () => {
       found: true,
       data: {
         // Use a default empty config file to not trigger config rewrite.
-        ...getSnapshot(config),
+        ...store.config,
         themeSource: 'dark',
       },
     });
     await configChangedCallback();
     // Do not write back the changes we have just read.
     expect(persistenceService.writeConfig).not.toHaveBeenCalled();
-    expect(config.themeSource).toBe('dark');
+    expect(store.settings.themeSource).toBe('dark');
   });
 
   it('should update the config file if new details are added', async () => {
@@ -203,7 +202,7 @@ describe('when it has loaded the config', () => {
       },
     });
     await configChangedCallback();
-    expect(config.themeSource).not.toBe(-1);
+    expect(store.settings.themeSource).not.toBe(-1);
     expect(persistenceService.writeConfig).not.toHaveBeenCalled();
   });
 
@@ -222,7 +221,7 @@ describe('when it has loaded the config', () => {
     });
 
     it('should not listen to store changes any more', () => {
-      config.setThemeSource('dark');
+      store.settings.setThemeSource('dark');
       jest.advanceTimersByTime(2 * throttleMs);
       expect(persistenceService.writeConfig).not.toHaveBeenCalled();
     });
diff --git a/packages/main/src/controllers/__tests__/initNativeTheme.spec.ts b/packages/main/src/controllers/__tests__/initNativeTheme.spec.ts
index 16acca5..9107c78 100644
--- a/packages/main/src/controllers/__tests__/initNativeTheme.spec.ts
+++ b/packages/main/src/controllers/__tests__/initNativeTheme.spec.ts
@@ -21,7 +21,7 @@
 import { jest } from '@jest/globals';
 import { mocked } from 'jest-mock';
 
-import { createMainStore, MainStore } from '../../stores/MainStore';
+import { sharedStore, SharedStore } from '../../stores/SharedStore';
 import type Disposer from '../../utils/Disposer';
 
 let shouldUseDarkColors = false;
@@ -40,11 +40,11 @@ jest.unstable_mockModule('electron', () => ({
 const { nativeTheme } = await import('electron');
 const { default: initNativeTheme } = await import('../initNativeTheme');
 
-let store: MainStore;
+let store: SharedStore;
 let disposeSut: Disposer;
 
 beforeEach(() => {
-  store = createMainStore();
+  store = sharedStore.create();
   disposeSut = initNativeTheme(store);
 });
 
@@ -53,7 +53,7 @@ it('should register a nativeTheme updated listener', () => {
 });
 
 it('should synchronize themeSource changes to the nativeTheme', () => {
-  store.config.setThemeSource('dark');
+  store.settings.setThemeSource('dark');
   expect(nativeTheme.themeSource).toBe('dark');
 });
 
@@ -63,7 +63,7 @@ it('should synchronize shouldUseDarkColors changes to the store', () => {
   )![1];
   shouldUseDarkColors = true;
   listener();
-  expect(store.shared.shouldUseDarkColors).toBe(true);
+  expect(store.shouldUseDarkColors).toBe(true);
 });
 
 it('should remove the listener on dispose', () => {
diff --git a/packages/main/src/controllers/initConfig.ts b/packages/main/src/controllers/initConfig.ts
index c8cd335..55bf6df 100644
--- a/packages/main/src/controllers/initConfig.ts
+++ b/packages/main/src/controllers/initConfig.ts
@@ -20,11 +20,11 @@
 
 import deepEqual from 'deep-equal';
 import { debounce } from 'lodash-es';
-import { getSnapshot, onSnapshot } from 'mobx-state-tree';
+import { reaction } from 'mobx';
 import ms from 'ms';
 
 import type ConfigPersistence from '../infrastructure/ConfigPersistence';
-import { Config, ConfigFileIn, ConfigSnapshotOut } from '../stores/Config';
+import { Config, SharedStore } from '../stores/SharedStore';
 import type Disposer from '../utils/Disposer';
 import { getLogger } from '../utils/log';
 
@@ -33,18 +33,18 @@ const DEFAULT_CONFIG_DEBOUNCE_TIME = ms('1s');
 const log = getLogger('config');
 
 export default async function initConfig(
-  config: Config,
+  sharedStore: SharedStore,
   persistenceService: ConfigPersistence,
   debounceTime: number = DEFAULT_CONFIG_DEBOUNCE_TIME,
 ): Promise<Disposer> {
   log.trace('Initializing config controller');
 
-  let lastSnapshotOnDisk: ConfigSnapshotOut | undefined;
+  let lastConfigOnDisk: Config | undefined;
 
   async function writeConfig(): Promise<void> {
-    const snapshot = getSnapshot(config);
-    await persistenceService.writeConfig(snapshot);
-    lastSnapshotOnDisk = snapshot;
+    const { config } = sharedStore;
+    await persistenceService.writeConfig(config);
+    lastConfigOnDisk = config;
   }
 
   async function readConfig(): Promise<boolean> {
@@ -53,13 +53,13 @@ export default async function initConfig(
       try {
         // This cast is unsound if the config file is invalid,
         // but we'll throw an error in the end anyways.
-        config.loadFromConfigFile(result.data as ConfigFileIn);
+        sharedStore.loadConfig(result.data as Config);
       } catch (error) {
         log.error('Failed to apply config snapshot', result.data, error);
         return true;
       }
-      lastSnapshotOnDisk = getSnapshot(config);
-      if (!deepEqual(result.data, lastSnapshotOnDisk, { strict: true })) {
+      lastConfigOnDisk = sharedStore.config;
+      if (!deepEqual(result.data, lastConfigOnDisk, { strict: true })) {
         await writeConfig();
       }
     }
@@ -72,11 +72,11 @@ export default async function initConfig(
     log.info('Created config file');
   }
 
-  const disposeOnSnapshot = onSnapshot(
-    config,
-    debounce((snapshot) => {
+  const disposeReaction = reaction(
+    () => sharedStore.config,
+    debounce((config) => {
       // We can compare snapshots by reference, since it is only recreated on store changes.
-      if (lastSnapshotOnDisk !== snapshot) {
+      if (lastConfigOnDisk !== config) {
         writeConfig().catch((error) => {
           log.error('Failed to write config on config change', error);
         });
@@ -95,6 +95,6 @@ export default async function initConfig(
   return () => {
     log.trace('Disposing config controller');
     disposeWatcher();
-    disposeOnSnapshot();
+    disposeReaction();
   };
 }
diff --git a/packages/main/src/controllers/initNativeTheme.ts b/packages/main/src/controllers/initNativeTheme.ts
index d2074ab..ce7972a 100644
--- a/packages/main/src/controllers/initNativeTheme.ts
+++ b/packages/main/src/controllers/initNativeTheme.ts
@@ -21,18 +21,18 @@
 import { nativeTheme } from 'electron';
 import { autorun } from 'mobx';
 
-import type { MainStore } from '../stores/MainStore';
+import type { SharedStore } from '../stores/SharedStore';
 import type Disposer from '../utils/Disposer';
 import { getLogger } from '../utils/log';
 
 const log = getLogger('nativeTheme');
 
-export default function initNativeTheme(store: MainStore): Disposer {
+export default function initNativeTheme(store: SharedStore): Disposer {
   log.trace('Initializing nativeTheme controller');
 
   const disposeThemeSourceReaction = autorun(() => {
-    nativeTheme.themeSource = store.config.themeSource;
-    log.debug('Set theme source:', store.config.themeSource);
+    nativeTheme.themeSource = store.settings.themeSource;
+    log.debug('Set theme source:', store.settings.themeSource);
   });
 
   store.setShouldUseDarkColors(nativeTheme.shouldUseDarkColors);
diff --git a/packages/main/src/index.ts b/packages/main/src/index.ts
index 66405ea..0978cd9 100644
--- a/packages/main/src/index.ts
+++ b/packages/main/src/index.ts
@@ -270,13 +270,13 @@ async function createWindow(): Promise<unknown> {
       const actionToDispatch = action.parse(rawAction);
       switch (actionToDispatch.action) {
         case 'set-selected-service-id':
-          store.setSelectedServiceId(actionToDispatch.serviceId);
+          store.shared.setSelectedServiceId(actionToDispatch.serviceId);
           break;
         case 'set-browser-view-bounds':
           store.setBrowserViewBounds(actionToDispatch.browserViewBounds);
           break;
         case 'set-theme-source':
-          store.config.setThemeSource(actionToDispatch.themeSource);
+          store.settings.setThemeSource(actionToDispatch.themeSource);
           break;
         case 'reload-all-services':
           reloadServiceInject().catch((error) => {
diff --git a/packages/main/src/infrastructure/ConfigPersistence.ts b/packages/main/src/infrastructure/ConfigPersistence.ts
index 4b96f01..184fa8d 100644
--- a/packages/main/src/infrastructure/ConfigPersistence.ts
+++ b/packages/main/src/infrastructure/ConfigPersistence.ts
@@ -18,7 +18,7 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import type { ConfigSnapshotOut } from '../stores/Config';
+import type { Config } from '../stores/SharedStore';
 import type Disposer from '../utils/Disposer';
 
 export type ReadConfigResult =
@@ -28,7 +28,7 @@ export type ReadConfigResult =
 export default interface ConfigPersistence {
   readConfig(): Promise<ReadConfigResult>;
 
-  writeConfig(configSnapshot: ConfigSnapshotOut): Promise<void>;
+  writeConfig(config: Config): Promise<void>;
 
   watchConfig(callback: () => Promise<void>, throttleMs: number): Disposer;
 }
diff --git a/packages/main/src/infrastructure/impl/FileBasedConfigPersistence.ts b/packages/main/src/infrastructure/impl/FileBasedConfigPersistence.ts
index 06e3fab..88d8bf8 100644
--- a/packages/main/src/infrastructure/impl/FileBasedConfigPersistence.ts
+++ b/packages/main/src/infrastructure/impl/FileBasedConfigPersistence.ts
@@ -24,7 +24,7 @@ import path from 'node:path';
 import JSON5 from 'json5';
 import throttle from 'lodash-es/throttle';
 
-import type { ConfigSnapshotOut } from '../../stores/Config';
+import type { Config } from '../../stores/SharedStore';
 import type Disposer from '../../utils/Disposer';
 import { getLogger } from '../../utils/log';
 import type ConfigPersistence from '../ConfigPersistence';
@@ -65,7 +65,7 @@ export default class FileBasedConfigPersistence implements ConfigPersistence {
     };
   }
 
-  async writeConfig(configSnapshot: ConfigSnapshotOut): Promise<void> {
+  async writeConfig(configSnapshot: Config): Promise<void> {
     const configJson = JSON5.stringify(configSnapshot, {
       space: 2,
     });
diff --git a/packages/main/src/init.ts b/packages/main/src/init.ts
index 236a075..fd8dd94 100644
--- a/packages/main/src/init.ts
+++ b/packages/main/src/init.ts
@@ -31,10 +31,10 @@ export default async function init(store: MainStore): Promise<Disposer> {
     app.getPath('userData'),
   );
   const disposeConfigController = await initConfig(
-    store.config,
+    store.shared,
     configPersistenceService,
   );
-  const disposeNativeThemeController = initNativeTheme(store);
+  const disposeNativeThemeController = initNativeTheme(store.shared);
 
   return () => {
     disposeNativeThemeController();
diff --git a/packages/main/src/stores/Config.ts b/packages/main/src/stores/Config.ts
deleted file mode 100644
index e7fc360..0000000
--- a/packages/main/src/stores/Config.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (C)  2021-2022 Kristóf Marussy <kristof@marussy.com>
- *
- * This file is part of Sophie.
- *
- * Sophie is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-import { config as originalConfig, ThemeSource } from '@sophie/shared';
-import { applySnapshot, Instance, SnapshotIn } from 'mobx-state-tree';
-
-import { addMissingProfileIds, PartialProfileSnapshotIn } from './Profile';
-import {
-  addMissingServiceIdsAndProfiles,
-  PartialServiceSnapshotIn,
-} from './Service';
-
-export const config = originalConfig.actions((self) => ({
-  loadFromConfigFile(snapshot: ConfigFileIn): void {
-    const profiles = addMissingProfileIds(snapshot.profiles);
-    const services = addMissingServiceIdsAndProfiles(
-      snapshot.services,
-      profiles,
-    );
-    applySnapshot(self, {
-      ...snapshot,
-      profiles,
-      services,
-    });
-  },
-  setThemeSource(mode: ThemeSource): void {
-    self.themeSource = mode;
-  },
-}));
-
-export interface Config extends Instance<typeof config> {}
-
-export interface ConfigSnapshotIn extends SnapshotIn<typeof config> {}
-
-export interface ConfigFileIn
-  extends Omit<ConfigSnapshotIn, 'profiles' | 'services'> {
-  profiles?: PartialProfileSnapshotIn[] | undefined;
-  services?: PartialServiceSnapshotIn[] | undefined;
-}
-
-export type { ConfigSnapshotOut } from '@sophie/shared';
diff --git a/packages/main/src/stores/GlobalSettings.ts b/packages/main/src/stores/GlobalSettings.ts
new file mode 100644
index 0000000..1eb13b3
--- /dev/null
+++ b/packages/main/src/stores/GlobalSettings.ts
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import {
+  globalSettings as originalGlobalSettings,
+  ThemeSource,
+} from '@sophie/shared';
+import { Instance } from 'mobx-state-tree';
+
+export const globalSettings = originalGlobalSettings.actions((self) => ({
+  setThemeSource(mode: ThemeSource): void {
+    self.themeSource = mode;
+  },
+}));
+
+export interface GlobalSettings extends Instance<typeof globalSettings> {}
+
+export type {
+  GlobalSettingsSnapshotIn,
+  GlobalSettingsSnapshotOut,
+} from '@sophie/shared';
diff --git a/packages/main/src/stores/MainStore.ts b/packages/main/src/stores/MainStore.ts
index f0d6472..18f5bf9 100644
--- a/packages/main/src/stores/MainStore.ts
+++ b/packages/main/src/stores/MainStore.ts
@@ -18,21 +18,14 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { BrowserViewBounds, service } from '@sophie/shared';
-import {
-  applySnapshot,
-  Instance,
-  resolveIdentifier,
-  types,
-} from 'mobx-state-tree';
+import type { BrowserViewBounds } from '@sophie/shared';
+import { applySnapshot, Instance, types } from 'mobx-state-tree';
 
-import { getLogger } from '../utils/log';
-
-import type { Config } from './Config.js';
+import { GlobalSettings } from './GlobalSettings';
+import { Profile } from './Profile';
+import { Service } from './Service';
 import { sharedStore } from './SharedStore';
 
-const log = getLogger('mainStore');
-
 export const mainStore = types
   .model('MainStore', {
     browserViewBounds: types.optional(
@@ -47,26 +40,20 @@ export const mainStore = types
     shared: types.optional(sharedStore, {}),
   })
   .views((self) => ({
-    get config(): Config {
-      return self.shared.config;
+    get settings(): GlobalSettings {
+      return self.shared.settings;
+    },
+    get profiles(): Profile[] {
+      return self.shared.profiles;
+    },
+    get services(): Service[] {
+      return self.shared.services;
     },
   }))
   .actions((self) => ({
-    setSelectedServiceId(serviceId: string): void {
-      const serviceInstance = resolveIdentifier(service, self, serviceId);
-      if (serviceInstance === undefined) {
-        log.warn('Trying to select unknown service', serviceId);
-        return;
-      }
-      self.shared.selectedService = serviceInstance;
-      log.debug('Selected service', serviceId);
-    },
     setBrowserViewBounds(bounds: BrowserViewBounds): void {
       applySnapshot(self.browserViewBounds, bounds);
     },
-    setShouldUseDarkColors(shouldUseDarkColors: boolean): void {
-      self.shared.shouldUseDarkColors = shouldUseDarkColors;
-    },
   }));
 
 export interface MainStore extends Instance<typeof mainStore> {}
diff --git a/packages/main/src/stores/Profile.ts b/packages/main/src/stores/Profile.ts
index 4705862..eaf23c4 100644
--- a/packages/main/src/stores/Profile.ts
+++ b/packages/main/src/stores/Profile.ts
@@ -18,34 +18,39 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import type { ProfileSnapshotIn } from '@sophie/shared';
+import {
+  profile as originalProfile,
+  ProfileSettingsSnapshotIn,
+} from '@sophie/shared';
+import { getSnapshot, Instance } from 'mobx-state-tree';
 
+import SettingsWithId from '../utils/SettingsWithId';
 import generateId from '../utils/generateId';
 
-export interface PartialProfileSnapshotIn
-  extends Omit<ProfileSnapshotIn, 'id'> {
+export interface ProfileConfig extends ProfileSettingsSnapshotIn {
   id?: string | undefined;
 }
 
+export const profile = originalProfile.views((self) => ({
+  get config(): ProfileConfig {
+    const { id, settings } = self;
+    return { ...getSnapshot(settings), id };
+  },
+}));
+
+export interface Profile extends Instance<typeof profile> {}
+
+export type ProfileSettingsSnapshotWithId =
+  SettingsWithId<ProfileSettingsSnapshotIn>;
+
 export function addMissingProfileIds(
-  partialProfiles: PartialProfileSnapshotIn[] | undefined,
-): ProfileSnapshotIn[] {
-  return (partialProfiles ?? []).map((profile) => {
-    const { name } = profile;
-    let { id } = profile;
-    if (typeof id === 'undefined') {
-      id = generateId(name);
-    }
+  profileConfigs: ProfileConfig[] | undefined,
+): ProfileSettingsSnapshotWithId[] {
+  return (profileConfigs ?? []).map((profileConfig) => {
+    const { id, ...settings } = profileConfig;
     return {
-      ...profile,
-      id,
+      id: typeof id === 'undefined' ? generateId(settings.name) : id,
+      settings,
     };
   });
 }
-
-export type {
-  Profile,
-  ProfileSnapshotOut,
-  ProfileSnapshotIn,
-} from '@sophie/shared';
-export { profile } from '@sophie/shared';
diff --git a/packages/main/src/stores/RuntimeService.ts b/packages/main/src/stores/RuntimeService.ts
deleted file mode 100644
index ecb1942..0000000
--- a/packages/main/src/stores/RuntimeService.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
- *
- * This file is part of Sophie.
- *
- * Sophie is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-import { UnreadCount } from '@sophie/service-shared';
-import { runtimeService as originalRuntimeService } from '@sophie/shared';
-import { Instance } from 'mobx-state-tree';
-
-export const runtimeService = originalRuntimeService.actions((self) => ({
-  setLocation({
-    url,
-    canGoBack,
-    canGoForward,
-  }: {
-    url: string;
-    canGoBack: boolean;
-    canGoForward: boolean;
-  }): void {
-    self.url = url;
-    self.canGoBack = canGoBack;
-    self.canGoForward = canGoForward;
-  },
-  setTitle(title: string): void {
-    self.title = title;
-  },
-  hibernated(): void {
-    self.canGoBack = false;
-    self.canGoForward = false;
-    self.state = 'hibernated';
-  },
-  startedLoading(): void {
-    self.state = 'loading';
-  },
-  finishedLoading(): void {
-    if (self.state === 'loading') {
-      // Do not overwrite crashed state if the service haven't been reloaded yet.
-      self.state = 'loaded';
-    }
-  },
-  crashed(): void {
-    self.state = 'crashed';
-  },
-  setUnreadCount({ direct, indirect }: UnreadCount): void {
-    if (direct !== undefined) {
-      self.directMessageCount = direct;
-    }
-    if (indirect !== undefined) {
-      self.indirectMessageCount = indirect;
-    }
-  },
-}));
-
-export interface RuntimeService extends Instance<typeof runtimeService> {}
-
-export type {
-  RuntimeServiceSnapshotIn,
-  RuntimeServiceSnapshotOut,
-} from '@sophie/shared';
diff --git a/packages/main/src/stores/Service.ts b/packages/main/src/stores/Service.ts
index 9bc6a43..78c57cb 100644
--- a/packages/main/src/stores/Service.ts
+++ b/packages/main/src/stores/Service.ts
@@ -18,46 +18,95 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import type { ServiceSnapshotIn } from '@sophie/shared';
+import type { UnreadCount } from '@sophie/service-shared';
+import {
+  service as originalService,
+  ServiceSettingsSnapshotIn,
+} from '@sophie/shared';
+import { Instance, getSnapshot, ReferenceIdentifier } from 'mobx-state-tree';
 
+import SettingsWithId from '../utils/SettingsWithId';
 import generateId from '../utils/generateId';
+import overrideProps from '../utils/overrideProps';
 
-import type { ProfileSnapshotIn } from './Profile';
+import { ProfileSettingsSnapshotWithId } from './Profile';
+import { serviceSettings } from './ServiceSettings';
 
-export interface PartialServiceSnapshotIn
-  extends Omit<ServiceSnapshotIn, 'id' | 'profile'> {
+export interface ServiceConfig
+  extends Omit<ServiceSettingsSnapshotIn, 'profile'> {
   id?: string | undefined;
-  profile?: string | undefined;
+
+  profile?: ReferenceIdentifier | undefined;
 }
 
+export const service = overrideProps(originalService, {
+  settings: serviceSettings,
+})
+  .views((self) => ({
+    get config(): ServiceConfig {
+      const { id, settings } = self;
+      return { ...getSnapshot(settings), id };
+    },
+  }))
+  .actions((self) => ({
+    setLocation({
+      url,
+      canGoBack,
+      canGoForward,
+    }: {
+      url: string;
+      canGoBack: boolean;
+      canGoForward: boolean;
+    }): void {
+      self.currentUrl = url;
+      self.canGoBack = canGoBack;
+      self.canGoForward = canGoForward;
+    },
+    setTitle(title: string): void {
+      self.title = title;
+    },
+    startedLoading(): void {
+      self.state = 'loading';
+    },
+    finishedLoading(): void {
+      if (self.state === 'loading') {
+        // Do not overwrite crashed state if the service haven't been reloaded yet.
+        self.state = 'loaded';
+      }
+    },
+    crashed(): void {
+      self.state = 'crashed';
+    },
+    setUnreadCount({ direct, indirect }: UnreadCount): void {
+      if (direct !== undefined) {
+        self.directMessageCount = direct;
+      }
+      if (indirect !== undefined) {
+        self.indirectMessageCount = indirect;
+      }
+    },
+  }));
+
+export interface Service extends Instance<typeof service> {}
+
+export type ServiceSettingsSnapshotWithId =
+  SettingsWithId<ServiceSettingsSnapshotIn>;
+
 export function addMissingServiceIdsAndProfiles(
-  partialServices: PartialServiceSnapshotIn[] | undefined,
-  profiles: ProfileSnapshotIn[],
-): ServiceSnapshotIn[] {
-  return (partialServices ?? []).map((service) => {
-    const { name } = service;
-    let { id, profile } = service;
-    if (typeof id === 'undefined') {
-      id = generateId(name);
-    }
-    if (typeof profile === 'undefined') {
-      profile = generateId(name);
-      profiles.push({
-        id: profile,
-        name: service.name,
-      });
+  serviceConfigs: ServiceConfig[] | undefined,
+  profiles: ProfileSettingsSnapshotWithId[],
+): ServiceSettingsSnapshotWithId[] {
+  return (serviceConfigs ?? []).map((serviceConfig) => {
+    const { id, ...settings } = serviceConfig;
+    const { name } = settings;
+    let { profile: profileId } = settings;
+    if (profileId === undefined) {
+      profileId = generateId(name);
+      profiles.push({ id: profileId, settings: { name } });
     }
     return {
-      ...service,
-      id,
-      profile,
+      id: id === undefined ? generateId(name) : id,
+      settings: { ...settings, profile: profileId },
     };
   });
 }
-
-export type {
-  Service,
-  ServiceSnapshotOut,
-  ServiceSnapshotIn,
-} from '@sophie/shared';
-export { service } from '@sophie/shared';
diff --git a/packages/main/src/stores/ServiceSettings.ts b/packages/main/src/stores/ServiceSettings.ts
new file mode 100644
index 0000000..960de9b
--- /dev/null
+++ b/packages/main/src/stores/ServiceSettings.ts
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { serviceSettings as originalServiceSettings } from '@sophie/shared';
+import { Instance, types } from 'mobx-state-tree';
+
+import overrideProps from '../utils/overrideProps';
+
+import { profile } from './Profile';
+
+export const serviceSettings = overrideProps(originalServiceSettings, {
+  profile: types.reference(profile),
+});
+
+export interface ServiceSettings extends Instance<typeof serviceSettings> {}
+
+export type {
+  ServiceSettingsSnapshotIn,
+  ServiceSettingsSnapshotOut,
+} from '@sophie/shared';
diff --git a/packages/main/src/stores/SharedStore.ts b/packages/main/src/stores/SharedStore.ts
index 76ce05c..861c8ce 100644
--- a/packages/main/src/stores/SharedStore.ts
+++ b/packages/main/src/stores/SharedStore.ts
@@ -19,19 +19,111 @@
  */
 
 import { sharedStore as originalSharedStore } from '@sophie/shared';
-import { Instance, types } from 'mobx-state-tree';
+import {
+  applySnapshot,
+  getSnapshot,
+  Instance,
+  resolveIdentifier,
+  types,
+} from 'mobx-state-tree';
 
-import { config } from './Config';
-import { runtimeService } from './RuntimeService';
+import SettingsWithId from '../utils/SettingsWithId';
+import { getLogger } from '../utils/log';
+import overrideProps from '../utils/overrideProps';
+
+import { globalSettings, GlobalSettingsSnapshotIn } from './GlobalSettings';
+import { addMissingProfileIds, profile, ProfileConfig } from './Profile';
+import {
+  addMissingServiceIdsAndProfiles,
+  service,
+  ServiceConfig,
+} from './Service';
+
+const log = getLogger('sharedStore');
+
+export interface Config extends GlobalSettingsSnapshotIn {
+  profiles?: ProfileConfig[] | undefined;
+
+  services?: ServiceConfig[] | undefined;
+}
+
+function getConfigs<T>(models: { config: T }[]): T[] | undefined {
+  return models.length === 0 ? undefined : models.map((model) => model.config);
+}
+
+function reconcileSettings<T>(
+  originalSnapshots: SettingsWithId<T>[],
+  settingsSnapshotsWithId: SettingsWithId<T>[],
+): SettingsWithId<T>[] {
+  const idToOriginalSnapshots = new Map(
+    originalSnapshots.map((originalSnapshot) => [
+      originalSnapshot.id,
+      originalSnapshot,
+    ]),
+  );
+  return settingsSnapshotsWithId.map(({ id, settings }) => ({
+    ...idToOriginalSnapshots.get(id),
+    id,
+    settings,
+  }));
+}
+
+export const sharedStore = overrideProps(originalSharedStore, {
+  settings: types.optional(globalSettings, {}),
+  profiles: types.array(profile),
+  services: types.array(service),
+  selectedService: types.safeReference(service),
+})
+  .views((self) => ({
+    get config(): Config {
+      const { settings, profiles, services } = self;
+      const globalSettingsConfig = getSnapshot(settings);
+      return {
+        ...globalSettingsConfig,
+        profiles: getConfigs(profiles),
+        services: getConfigs(services),
+      };
+    },
+  }))
+  .actions((self) => ({
+    loadConfig(config: Config): void {
+      const snapshot = getSnapshot(self);
+      const { profiles, services, ...settings } = config;
+      const profileSettingsSnapshots = addMissingProfileIds(profiles);
+      const serviceSettingsSnapshots = addMissingServiceIdsAndProfiles(
+        services,
+        profileSettingsSnapshots,
+      );
+      applySnapshot(self, {
+        ...snapshot,
+        settings,
+        profiles: reconcileSettings(
+          snapshot.profiles,
+          profileSettingsSnapshots,
+        ),
+        services: reconcileSettings(
+          snapshot.services,
+          serviceSettingsSnapshots,
+        ),
+      });
+    },
+    setShouldUseDarkColors(shouldUseDarkColors: boolean): void {
+      self.shouldUseDarkColors = shouldUseDarkColors;
+    },
+    setSelectedServiceId(serviceId: string): void {
+      const serviceInstance = resolveIdentifier(service, self, serviceId);
+      if (serviceInstance === undefined) {
+        log.warn('Trying to select unknown service', serviceId);
+        return;
+      }
+      self.selectedService = serviceInstance;
+      log.debug('Selected service', serviceId);
+    },
+  }));
+
+export interface SharedStore extends Instance<typeof sharedStore> {}
 
 export type {
   SharedStoreSnapshotIn,
   SharedStoreSnapshotOut,
 } from '@sophie/shared';
-
-export const sharedStore = originalSharedStore.props({
-  config: types.optional(config, {}),
-  runtimeServices: types.map(runtimeService),
-});
-
-export interface SharedStore extends Instance<typeof sharedStore> {}
diff --git a/packages/main/src/stores/__tests__/Config.spec.ts b/packages/main/src/stores/__tests__/SharedStore.spec.ts
index 22ccbc7..3ea187c 100644
--- a/packages/main/src/stores/__tests__/Config.spec.ts
+++ b/packages/main/src/stores/__tests__/SharedStore.spec.ts
@@ -18,28 +18,28 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { config, Config, ConfigFileIn } from '../Config';
-import type { PartialProfileSnapshotIn } from '../Profile';
-import type { PartialServiceSnapshotIn } from '../Service';
+import type { ProfileConfig } from '../Profile';
+import type { ServiceConfig } from '../Service';
+import { Config, sharedStore, SharedStore } from '../SharedStore';
 
-const profileProps: PartialProfileSnapshotIn = {
+const profileProps: ProfileConfig = {
   name: 'Test profile',
 };
 
-const serviceProps: PartialServiceSnapshotIn = {
+const serviceProps: ServiceConfig = {
   name: 'Test service',
   url: 'https://example.com',
 };
 
-let sut: Config;
+let sut: SharedStore;
 
 beforeEach(() => {
-  sut = config.create();
+  sut = sharedStore.create();
 });
 
-describe('preprocessConfigFile', () => {
+describe('loadConfig', () => {
   it('should load profiles with an ID', () => {
-    sut.loadFromConfigFile({
+    sut.loadConfig({
       profiles: [
         {
           id: 'someId',
@@ -51,14 +51,14 @@ describe('preprocessConfigFile', () => {
   });
 
   it('should generate an ID for profiles without and ID', () => {
-    sut.loadFromConfigFile({
+    sut.loadConfig({
       profiles: [profileProps],
     });
     expect(sut.profiles[0].id).toBeDefined();
   });
 
   it('should load services with an ID and a profile', () => {
-    sut.loadFromConfigFile({
+    sut.loadConfig({
       profiles: [
         {
           id: 'someProfileId',
@@ -74,12 +74,12 @@ describe('preprocessConfigFile', () => {
       ],
     });
     expect(sut.services[0].id).toBe('someServiceId');
-    expect(sut.services[0].profile).toBe(sut.profiles[0]);
+    expect(sut.services[0].settings.profile).toBe(sut.profiles[0]);
   });
 
   it('should refuse to load a profile without a name', () => {
     expect(() => {
-      sut.loadFromConfigFile({
+      sut.loadConfig({
         profiles: [
           {
             id: 'someProfileId',
@@ -87,13 +87,13 @@ describe('preprocessConfigFile', () => {
             name: undefined,
           },
         ],
-      } as unknown as ConfigFileIn);
+      } as unknown as Config);
     }).toThrow();
     expect(sut.profiles).toHaveLength(0);
   });
 
   it('should load services without an ID but with a profile', () => {
-    sut.loadFromConfigFile({
+    sut.loadConfig({
       profiles: [
         {
           id: 'someProfileId',
@@ -108,11 +108,11 @@ describe('preprocessConfigFile', () => {
       ],
     });
     expect(sut.services[0].id).toBeDefined();
-    expect(sut.services[0].profile).toBe(sut.profiles[0]);
+    expect(sut.services[0].settings.profile).toBe(sut.profiles[0]);
   });
 
   it('should create a profile for a service with an ID but no profile', () => {
-    sut.loadFromConfigFile({
+    sut.loadConfig({
       services: [
         {
           id: 'someServiceId',
@@ -121,12 +121,14 @@ describe('preprocessConfigFile', () => {
       ],
     });
     expect(sut.services[0].id).toBe('someServiceId');
-    expect(sut.services[0].profile).toBeDefined();
-    expect(sut.services[0].profile.name).toBe(serviceProps.name);
+    expect(sut.services[0].settings.profile).toBeDefined();
+    expect(sut.services[0].settings.profile.settings.name).toBe(
+      serviceProps.name,
+    );
   });
 
   it('should create a profile for a service without an ID or profile', () => {
-    sut.loadFromConfigFile({
+    sut.loadConfig({
       services: [
         {
           ...serviceProps,
@@ -134,13 +136,15 @@ describe('preprocessConfigFile', () => {
       ],
     });
     expect(sut.services[0].id).toBeDefined();
-    expect(sut.services[0].profile).toBeDefined();
-    expect(sut.services[0].profile.name).toBe(serviceProps.name);
+    expect(sut.services[0].settings.profile).toBeDefined();
+    expect(sut.services[0].settings.profile.settings.name).toBe(
+      serviceProps.name,
+    );
   });
 
   it('should refuse to load a service without a name', () => {
     expect(() => {
-      sut.loadFromConfigFile({
+      sut.loadConfig({
         services: [
           {
             id: 'someServiceId',
@@ -148,7 +152,7 @@ describe('preprocessConfigFile', () => {
             name: undefined,
           },
         ],
-      } as unknown as ConfigFileIn);
+      } as unknown as Config);
     }).toThrow();
     expect(sut.profiles).toHaveLength(0);
     expect(sut.services).toHaveLength(0);
diff --git a/packages/main/src/utils/SettingsWithId.ts b/packages/main/src/utils/SettingsWithId.ts
new file mode 100644
index 0000000..fde3e86
--- /dev/null
+++ b/packages/main/src/utils/SettingsWithId.ts
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+export default interface SettingsWithId<T> {
+  id: string;
+
+  settings: T;
+}
diff --git a/packages/main/src/utils/overrideProps.ts b/packages/main/src/utils/overrideProps.ts
new file mode 100644
index 0000000..c626408
--- /dev/null
+++ b/packages/main/src/utils/overrideProps.ts
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+/**
+ * @file This file implements a technique to force-override properties of a model.
+ *
+ * The overridden properties must conform to the SnapshotIt and SnapshotOut format
+ * of the original model. Essentially, this means that only views and actions can
+ * be added safely.
+ *
+ * @see https://github.com/mobxjs/mobx-state-tree/issues/1403#issuecomment-940843087
+ */
+
+import {
+  IAnyModelType,
+  IModelType,
+  ModelProperties,
+  SnapshotIn,
+  SnapshotOut,
+} from 'mobx-state-tree';
+
+export type IUnsafeOverriddenModelType<
+  BASE extends IAnyModelType,
+  PROPS extends ModelProperties,
+> = BASE extends IModelType<infer P, infer O, infer CC, infer CS>
+  ? IModelType<Omit<P, keyof PROPS> & PROPS, O, CC, CS>
+  : never;
+
+export type IOverriddenModelType<
+  BASE extends IAnyModelType,
+  PROPS extends ModelProperties,
+> = SnapshotIn<BASE> extends SnapshotIn<IUnsafeOverriddenModelType<BASE, PROPS>>
+  ? SnapshotOut<
+      IUnsafeOverriddenModelType<BASE, PROPS>
+    > extends SnapshotOut<BASE>
+    ? IUnsafeOverriddenModelType<BASE, PROPS>
+    : never
+  : never;
+
+export default function overrideProps<
+  BASE extends IAnyModelType,
+  PROPS extends ModelProperties,
+>(base: BASE, props: PROPS): IOverriddenModelType<BASE, PROPS> {
+  return base.props(props) as IOverriddenModelType<BASE, PROPS>;
+}