diff --git a/.vscode/settings.json b/.vscode/settings.json
index 9d82aa1..ed42e20 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,5 +1,18 @@
 {
   "i18n-ally.localesPaths": ["src/renderer/locales"],
   "vitest.disableWorkspaceWarning": true,
-  "i18n-ally.keystyle": "nested"
+  "i18n-ally.keystyle": "nested",
+  "cSpell.words": [
+    "bridgecmdr",
+    "extron",
+    "fgpa",
+    "pinia",
+    "radash",
+    "shinybow",
+    "sindresorhus",
+    "sixxgate",
+    "snes",
+    "vuelidate",
+    "vuetify"
+  ]
 }
diff --git a/package.json b/package.json
index 9235e8d..9769563 100644
--- a/package.json
+++ b/package.json
@@ -109,7 +109,6 @@
     "execa": "^9.5.1",
     "husky": "^9.1.6",
     "ini": "^5.0.0",
-    "js-base64": "^3.7.7",
     "levelup": "^5.1.1",
     "mime": "^4.0.4",
     "npm-check-updates": "^17.1.10",
diff --git a/src/core/base64.ts b/src/core/base64.ts
new file mode 100644
index 0000000..72cdd86
--- /dev/null
+++ b/src/core/base64.ts
@@ -0,0 +1,15 @@
+/** Converts a byte array into a Base64 string. */
+export function toBase64(data: Uint8Array) {
+  return btoa(String.fromCodePoint(...data))
+}
+
+function* codePointsOf(data: string) {
+  for (let i = 0, cp = data.codePointAt(i); cp != null; ++i, cp = data.codePointAt(i)) {
+    yield cp
+  }
+}
+
+/** Coverts a Base64 string into a byte array. */
+export function fromBase64(data: string) {
+  return new Uint8Array([...codePointsOf(atob(data))])
+}
diff --git a/src/core/rpc/transformer.ts b/src/core/rpc/transformer.ts
index 4140ec4..8a096e2 100644
--- a/src/core/rpc/transformer.ts
+++ b/src/core/rpc/transformer.ts
@@ -1,36 +1,78 @@
-import { Base64 } from 'js-base64'
 import { SuperJSON } from 'superjson'
 import { Attachment } from '../attachments'
 import { raiseError } from '../error-handling'
+import { fromBase64, toBase64 } from '@/base64'
 
-export default function useSuperJson() {
-  SuperJSON.registerCustom(
+function useSuperJsonCommon() {
+  const superJson = new SuperJSON()
+
+  // HACK: tRPC and SuperJSON won't serialize functions; but
+  // doesn't filter them out, so the IPC throws an error
+  // if they are passed. They are also not passable via
+  // HTTP JSON serialization. This will ensure any
+  // types with functions won't be usable with
+  // routes, as functions will trigger an
+  // Error with this transformation.
+  superJson.registerCustom(
+    {
+      isApplicable: (v): v is () => undefined => typeof v === 'function',
+      serialize: (_: () => undefined) => raiseError(() => new TypeError('Functions may not be serialized')),
+      deserialize: (_: never) => raiseError(() => new TypeError('Functions may not be serialized'))
+    },
+    'Function'
+  )
+
+  return superJson
+}
+
+/**
+ * Sets up SuperJSON for use over Electron IPC.
+ *
+ * This will attempt to translate data into a form compatible with the limited
+ * structuralClone ability of Electron's IPC channels. This means most
+ * builtin objects and a  very limited set of host objects may be
+ * passed directly through without translation.
+ */
+export function useIpcJson() {
+  const superJson = useSuperJsonCommon()
+  superJson.registerCustom(
     {
       isApplicable: (v) => v instanceof Attachment,
       serialize: (attachment) => ({
         name: attachment.name,
         type: attachment.type,
-        data: Base64.fromUint8Array(attachment)
+        data: new Uint8Array(attachment.buffer) as never
       }),
-      deserialize: (attachment) =>
-        new Attachment(attachment.name, attachment.type, Base64.toUint8Array(attachment.data))
+      deserialize: (attachment) => new Attachment(attachment.name, attachment.type, attachment.data)
     },
     'Attachment'
   )
 
-  // HACK: tRPC won't serialize functions; but doesn't filter
-  // them out, so IPC throws an error if they are passed.
-  // This can also ensure any types with functions
-  // won't be returned as seen in the return
-  // type information for the router.
-  SuperJSON.registerCustom(
+  return superJson
+}
+
+/**
+ * Sets up SuperJSON for use over HTTP.
+ *
+ * This will attempt to translate data into a form compatible with normal JSON.
+ * This means only data allowed in regular JSON may be passed, other types
+ * of data must be translated into the best possible representation.
+ * Binary data will need to be Base64 encoded.
+ */
+export function useWebJson() {
+  const superJson = useSuperJsonCommon()
+  superJson.registerCustom(
     {
-      isApplicable: (v): v is () => undefined => typeof v === 'function',
-      serialize: (_: () => undefined) => raiseError(() => new TypeError('Functions may not be serialized')),
-      deserialize: (_: never) => raiseError(() => new TypeError('Functions may not be serialized'))
+      isApplicable: (v) => v instanceof Attachment,
+      serialize: (attachment) => ({
+        name: attachment.name,
+        type: attachment.type,
+        data: toBase64(attachment)
+      }),
+      deserialize: (attachment) => new Attachment(attachment.name, attachment.type, fromBase64(attachment.data))
     },
-    'Function'
+    'Attachment'
   )
 
-  return SuperJSON
+  return superJson
 }
diff --git a/src/main/dao/devices.ts b/src/main/dao/devices.ts
new file mode 100644
index 0000000..3b4417a
--- /dev/null
+++ b/src/main/dao/devices.ts
@@ -0,0 +1,47 @@
+import { memo } from 'radash'
+import { z } from 'zod'
+import {
+  Database,
+  DocumentId,
+  inferDocumentOf,
+  inferNewDocumentOf,
+  inferUpdatesOf,
+  inferUpsertOf
+} from '../services/database'
+import useTiesDatabase from './ties'
+import type { RevisionId } from '../services/database'
+
+export const DeviceModel = z.object({
+  driverId: DocumentId,
+  title: z.string().min(1),
+  path: z.string().min(1)
+})
+
+const useDevicesDatabase = memo(
+  () =>
+    new (class extends Database.of('devices', DeviceModel) {
+      readonly #ties = useTiesDatabase()
+
+      override async remove(id: DocumentId, rev?: RevisionId) {
+        await super.remove(id, rev)
+
+        const related = await this.#ties.forDevice(id)
+        await Promise.all(
+          related.map(async ({ _id, _rev }) => {
+            await this.#ties.remove(_id, _rev)
+          })
+        )
+      }
+    })()
+)
+
+export type Device = inferDocumentOf<typeof DeviceModel>
+export const Device = inferDocumentOf(DeviceModel)
+export type NewDevice = inferNewDocumentOf<typeof DeviceModel>
+export const NewDevice = inferNewDocumentOf(DeviceModel)
+export type DeviceUpdate = inferUpdatesOf<typeof DeviceModel>
+export const DeviceUpdate = inferUpdatesOf(DeviceModel)
+export type DeviceUpsert = inferUpsertOf<typeof DeviceModel>
+export const DeviceUpsert = inferUpsertOf(DeviceModel)
+
+export default useDevicesDatabase
diff --git a/src/main/dao/sources.ts b/src/main/dao/sources.ts
index 0366897..42b59d0 100644
--- a/src/main/dao/sources.ts
+++ b/src/main/dao/sources.ts
@@ -1,6 +1,6 @@
 import { memo } from 'radash'
 import { z } from 'zod'
-import { Database, inferDocumentOf, inferNewDocumentOf, inferUpdatesOf } from '../services/database'
+import { Database, inferDocumentOf, inferNewDocumentOf, inferUpdatesOf, inferUpsertOf } from '../services/database'
 import useTiesDatabase from './ties'
 import type { DocumentId, RevisionId } from '../services/database'
 
@@ -33,5 +33,7 @@ export type NewSource = inferNewDocumentOf<typeof SourceModel>
 export const NewSource = inferNewDocumentOf(SourceModel)
 export type SourceUpdate = inferUpdatesOf<typeof SourceModel>
 export const SourceUpdate = inferUpdatesOf(SourceModel)
+export type SourceUpsert = inferUpsertOf<typeof SourceModel>
+export const SourceUpsert = inferUpsertOf(SourceModel)
 
 export default useSourcesDatabase
diff --git a/src/main/dao/switches.ts b/src/main/dao/switches.ts
deleted file mode 100644
index 52a84a9..0000000
--- a/src/main/dao/switches.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { memo } from 'radash'
-import { z } from 'zod'
-import { Database, DocumentId, inferDocumentOf, inferNewDocumentOf, inferUpdatesOf } from '../services/database'
-import useTiesDatabase from './ties'
-import type { RevisionId } from '../services/database'
-
-export const SwitchModel = z.object({
-  driverId: DocumentId,
-  title: z.string().min(1),
-  path: z.string().min(1)
-})
-
-const useSwitchesDatabase = memo(
-  () =>
-    new (class extends Database.of('switches', SwitchModel) {
-      readonly #ties = useTiesDatabase()
-
-      override async remove(id: DocumentId, rev?: RevisionId) {
-        await super.remove(id, rev)
-
-        const related = await this.#ties.forSwitch(id)
-        await Promise.all(
-          related.map(async ({ _id, _rev }) => {
-            await this.#ties.remove(_id, _rev)
-          })
-        )
-      }
-    })()
-)
-
-export type Switch = inferDocumentOf<typeof SwitchModel>
-export const Switch = inferDocumentOf(SwitchModel)
-export type NewSwitch = inferNewDocumentOf<typeof SwitchModel>
-export const NewSwitch = inferNewDocumentOf(SwitchModel)
-export type SwitchUpdate = inferUpdatesOf<typeof SwitchModel>
-export const SwitchUpdate = inferUpdatesOf(SwitchModel)
-
-export default useSwitchesDatabase
diff --git a/src/main/dao/ties.ts b/src/main/dao/ties.ts
index 6d48f20..2859dbe 100644
--- a/src/main/dao/ties.ts
+++ b/src/main/dao/ties.ts
@@ -1,10 +1,17 @@
 import { map, memo } from 'radash'
 import { z } from 'zod'
-import { Database, DocumentId, inferDocumentOf, inferNewDocumentOf, inferUpdatesOf } from '../services/database'
+import {
+  Database,
+  DocumentId,
+  inferDocumentOf,
+  inferNewDocumentOf,
+  inferUpdatesOf,
+  inferUpsertOf
+} from '../services/database'
 
 export const TieModel = z.object({
   sourceId: DocumentId,
-  switchId: DocumentId,
+  deviceId: DocumentId,
   inputChannel: z.number().int().nonnegative(),
   outputChannels: z.object({
     video: z.number().int().nonnegative().optional(),
@@ -12,16 +19,16 @@ export const TieModel = z.object({
   })
 })
 
-const indices = { sourceId: ['sourceId'], switchId: ['switchId'] }
+const indices = { sourceId: ['sourceId'], deviceId: ['deviceId'] }
 
 const useTiesDatabase = memo(
   () =>
     new (class extends Database.of('ties', TieModel, indices) {
-      async forSwitch(switchId: DocumentId) {
+      async forDevice(deviceId: DocumentId) {
         return await this.run(
           async (db) =>
             await db
-              .find({ selector: { switchId } })
+              .find({ selector: { deviceId } })
               .then(async (r) => await map(r.docs, async (d) => await this.prepare(d)))
         )
       }
@@ -43,5 +50,7 @@ export type NewTie = inferNewDocumentOf<typeof TieModel>
 export const NewTie = inferNewDocumentOf(TieModel)
 export type TieUpdate = inferUpdatesOf<typeof TieModel>
 export const TieUpdate = inferUpdatesOf(TieModel)
+export type TieUpsert = inferUpsertOf<typeof TieModel>
+export const TieUpsert = inferUpsertOf(TieModel)
 
 export default useTiesDatabase
diff --git a/src/main/main.ts b/src/main/main.ts
index c0c35c4..1743be0 100644
--- a/src/main/main.ts
+++ b/src/main/main.ts
@@ -6,6 +6,7 @@ import Logger from 'electron-log'
 import { sleep } from 'radash'
 import appIcon from '../../resources/icon.png?asset&asarUnpack'
 import { useAppRouter } from './routes/router'
+import useMigrations from './services/migration'
 import { createIpcHandler } from './services/rpc/ipc'
 import { logError } from './utilities'
 import { toError } from '@/error-handling'
@@ -13,7 +14,6 @@ import { toError } from '@/error-handling'
 // In this file you can include the rest of your app"s specific main process
 // code. You can also put them in separate files and require them here.
 
-Logger.initialize({ preload: true, spyRendererConsole: true })
 Logger.transports.console.format = '{h}:{i}:{s}.{ms} [{level}] › {text}'
 Logger.transports.file.level = 'debug'
 Logger.errorHandler.startCatching()
@@ -53,6 +53,26 @@ async function createWindow() {
   const kWait = 2000
   let lastError: unknown
 
+  window.webContents.on('console-message', (_, level, message) => {
+    switch (level) {
+      case 0:
+        Logger.verbose(message)
+        break
+      case 1:
+        Logger.info(message)
+        break
+      case 2:
+        Logger.warn(message)
+        break
+      case 3:
+        Logger.error(message)
+        break
+      default:
+        Logger.log(message)
+        break
+    }
+  })
+
   /* eslint-disable no-await-in-loop -- Retry loop must be serial. */
   for (let tries = 3; tries > 0; --tries) {
     try {
@@ -106,6 +126,11 @@ process.on('SIGTERM', () => {
 // this event occurs.
 await app.whenReady()
 
+const migrate = useMigrations()
+await migrate().catch((cause: unknown) => {
+  Logger.error(cause)
+})
+
 // Set app user model id for windows
 electronApp.setAppUserModelId('org.sleepingcats.BridgeCmdr')
 
diff --git a/src/main/migrations/20241118211400-rename-switches.ts b/src/main/migrations/20241118211400-rename-switches.ts
new file mode 100644
index 0000000..a76860e
--- /dev/null
+++ b/src/main/migrations/20241118211400-rename-switches.ts
@@ -0,0 +1,21 @@
+import { z } from 'zod'
+import { Database, DocumentId } from '../services/database'
+
+export async function migrate() {
+  const Model = z.object({
+    driverId: DocumentId,
+    title: z.string().min(1),
+    path: z.string().min(1)
+  })
+
+  const switches = new Database('switches', Model)
+  const devices = new Database('devices', Model)
+
+  for (const device of await switches.all()) {
+    // eslint-disable-next-line no-await-in-loop
+    await devices.upsert(device)
+  }
+
+  await switches.destroy()
+  await devices.close()
+}
diff --git a/src/main/migrations/20241119202100-rename-switchId.ts b/src/main/migrations/20241119202100-rename-switchId.ts
new file mode 100644
index 0000000..7bf0831
--- /dev/null
+++ b/src/main/migrations/20241119202100-rename-switchId.ts
@@ -0,0 +1,28 @@
+import { z } from 'zod'
+import { Database, DocumentId } from '../services/database'
+
+export async function migrate() {
+  const Model = z.object({}).catchall(z.unknown())
+
+  const OldModel = z
+    .object({
+      _id: DocumentId,
+      sourceId: DocumentId,
+      switchId: DocumentId,
+      inputChannel: z.number().int().nonnegative(),
+      outputChannels: z.object({
+        video: z.number().int().nonnegative().optional(),
+        audio: z.number().int().nonnegative().optional()
+      })
+    })
+    .passthrough()
+
+  const ties = new Database('ties', Model)
+
+  for (const tie of await ties.all()) {
+    const { switchId, ...old } = OldModel.parse(tie)
+
+    // eslint-disable-next-line no-await-in-loop
+    await ties.replace({ ...old, deviceId: switchId })
+  }
+}
diff --git a/src/main/routes/data/devices.ts b/src/main/routes/data/devices.ts
new file mode 100644
index 0000000..62bde72
--- /dev/null
+++ b/src/main/routes/data/devices.ts
@@ -0,0 +1,23 @@
+import useDevicesDatabase, { NewDevice, DeviceUpdate, DeviceUpsert } from '../../dao/devices'
+import { DocumentId } from '../../services/database'
+import { procedure, router } from '../../services/rpc/trpc'
+
+export default function useDevicesRouter() {
+  const devices = useDevicesDatabase()
+  return router({
+    compact: procedure.mutation(async () => {
+      await devices.compact()
+    }),
+    all: procedure.query(async () => await devices.all()),
+    get: procedure.input(DocumentId).query(async ({ input }) => await devices.get(input)),
+    add: procedure.input(NewDevice).mutation(async ({ input }) => await devices.add(input)),
+    update: procedure.input(DeviceUpdate).mutation(async ({ input }) => await devices.update(input)),
+    upsert: procedure.input(DeviceUpsert).mutation(async ({ input }) => await devices.upsert(input)),
+    remove: procedure.input(DocumentId).mutation(async ({ input }) => {
+      await devices.remove(input)
+    }),
+    clear: procedure.mutation(async () => {
+      await devices.clear()
+    })
+  })
+}
diff --git a/src/main/routes/data/sources.ts b/src/main/routes/data/sources.ts
index 956a079..1bf6c29 100644
--- a/src/main/routes/data/sources.ts
+++ b/src/main/routes/data/sources.ts
@@ -1,13 +1,12 @@
 import { z } from 'zod'
-import useSourcesDatabase, { NewSource, SourceUpdate } from '../../dao/sources'
+import useSourcesDatabase, { NewSource, SourceUpdate, SourceUpsert } from '../../dao/sources'
 import { DocumentId } from '../../services/database'
 import { procedure, router } from '../../services/rpc/trpc'
 import { Attachment } from '@/attachments'
 
-export type { Source, NewSource, SourceUpdate } from '../../dao/sources'
-
 const InsertInputs = z.tuple([NewSource]).rest(z.instanceof(Attachment))
 const UpdateInputs = z.tuple([SourceUpdate]).rest(z.instanceof(Attachment))
+const UpsertInputs = z.tuple([SourceUpsert]).rest(z.instanceof(Attachment))
 
 export default function useSourcesRouter() {
   const sources = useSourcesDatabase()
@@ -19,6 +18,7 @@ export default function useSourcesRouter() {
     get: procedure.input(DocumentId).query(async ({ input }) => await sources.get(input)),
     add: procedure.input(InsertInputs).mutation(async ({ input }) => await sources.add(...input)),
     update: procedure.input(UpdateInputs).mutation(async ({ input }) => await sources.update(...input)),
+    upsert: procedure.input(UpsertInputs).mutation(async ({ input }) => await sources.upsert(...input)),
     remove: procedure.input(DocumentId).mutation(async ({ input }) => {
       await sources.remove(input)
     }),
diff --git a/src/main/routes/data/switches.ts b/src/main/routes/data/switches.ts
deleted file mode 100644
index 9bbbb31..0000000
--- a/src/main/routes/data/switches.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import useSwitchesDatabase, { NewSwitch, SwitchUpdate } from '../../dao/switches'
-import { DocumentId } from '../../services/database'
-import { procedure, router } from '../../services/rpc/trpc'
-
-export { Switch, NewSwitch, SwitchUpdate } from '../../dao/switches'
-
-export default function useSourcesRouter() {
-  const switches = useSwitchesDatabase()
-  return router({
-    compact: procedure.mutation(async () => {
-      await switches.compact()
-    }),
-    all: procedure.query(async () => await switches.all()),
-    get: procedure.input(DocumentId).query(async ({ input }) => await switches.get(input)),
-    add: procedure.input(NewSwitch).mutation(async ({ input }) => await switches.add(input)),
-    update: procedure.input(SwitchUpdate).mutation(async ({ input }) => await switches.update(input)),
-    remove: procedure.input(DocumentId).mutation(async ({ input }) => {
-      await switches.remove(input)
-    }),
-    clear: procedure.mutation(async () => {
-      await switches.clear()
-    })
-  })
-}
diff --git a/src/main/routes/data/ties.ts b/src/main/routes/data/ties.ts
index 6532dbc..ef069b7 100644
--- a/src/main/routes/data/ties.ts
+++ b/src/main/routes/data/ties.ts
@@ -1,9 +1,7 @@
-import useTiesDatabase, { NewTie, TieUpdate } from '../../dao/ties'
+import useTiesDatabase, { NewTie, TieUpdate, TieUpsert } from '../../dao/ties'
 import { DocumentId } from '../../services/database'
 import { procedure, router } from '../../services/rpc/trpc'
 
-export type { Tie, NewTie, TieUpdate } from '../../dao/ties'
-
 export default function useTiesRouter() {
   const ties = useTiesDatabase()
   return router({
@@ -14,13 +12,14 @@ export default function useTiesRouter() {
     get: procedure.input(DocumentId).query(async ({ input }) => await ties.get(input)),
     add: procedure.input(NewTie).mutation(async ({ input }) => await ties.add(input)),
     update: procedure.input(TieUpdate).mutation(async ({ input }) => await ties.update(input)),
+    upsert: procedure.input(TieUpsert).mutation(async ({ input }) => await ties.upsert(input)),
     remove: procedure.input(DocumentId).mutation(async ({ input }) => {
       await ties.remove(input)
     }),
     clear: procedure.mutation(async () => {
       await ties.clear()
     }),
-    forSwitch: procedure.input(DocumentId).query(async ({ input }) => await ties.forSwitch(input)),
+    forDevice: procedure.input(DocumentId).query(async ({ input }) => await ties.forDevice(input)),
     forSource: procedure.input(DocumentId).query(async ({ input }) => await ties.forSource(input))
   })
 }
diff --git a/src/main/routes/drivers.ts b/src/main/routes/drivers.ts
index 4d0c409..58f781e 100644
--- a/src/main/routes/drivers.ts
+++ b/src/main/routes/drivers.ts
@@ -12,7 +12,7 @@ const useDriversRouter = memo(function useDriversRoute() {
   const drivers = useDrivers()
 
   return router({
-    all: procedure.query(drivers.allInfo),
+    all: procedure.query(async () => await drivers.allInfo()),
     get: procedure.input(z.string().uuid()).query(async ({ input }) => {
       await drivers.get(input)
     }),
diff --git a/src/main/routes/migration.ts b/src/main/routes/migration.ts
new file mode 100644
index 0000000..cbb0553
--- /dev/null
+++ b/src/main/routes/migration.ts
@@ -0,0 +1,15 @@
+import { memo } from 'radash'
+import useMigrations from '../services/migration'
+import { procedure, router } from '../services/rpc/trpc'
+
+const useMigrationRouter = memo(function useMigrationRouter() {
+  const migrate = useMigrations()
+
+  return router({
+    migrate: procedure.mutation(async () => {
+      await migrate()
+    })
+  })
+})
+
+export default useMigrationRouter
diff --git a/src/main/routes/ports.ts b/src/main/routes/ports.ts
index a9541e1..a37c4c5 100644
--- a/src/main/routes/ports.ts
+++ b/src/main/routes/ports.ts
@@ -7,7 +7,7 @@ const useSerialPortRouter = memo(function useSerialPortRouter() {
   const ports = useSerialPorts()
 
   return router({
-    list: procedure.query(ports.listPorts),
+    list: procedure.query(async () => await ports.listPorts()),
     isPort: procedure.input(z.string()).query(async ({ input }) => await ports.isValidPort(input))
   })
 })
diff --git a/src/main/routes/router.ts b/src/main/routes/router.ts
index 28ac076..4493b02 100644
--- a/src/main/routes/router.ts
+++ b/src/main/routes/router.ts
@@ -2,11 +2,12 @@ import { memo } from 'radash'
 import useAppInfo from '../services/app'
 import { procedure, router } from '../services/rpc/trpc'
 import useUserInfo from '../services/user'
+import useDevicesRouter from './data/devices'
 import useSourcesRouter from './data/sources'
 import useUserStoreRouter from './data/storage'
-import useSwitchesRouter from './data/switches'
 import useTiesRouter from './data/ties'
 import useDriversRouter from './drivers'
+import useMigrationRouter from './migration'
 import useSerialPortRouter from './ports'
 import useStartupRouter from './startup'
 import useSystemRouter from './system'
@@ -23,9 +24,10 @@ export const useAppRouter = memo(() =>
     system: useSystemRouter(),
     drivers: useDriversRouter(),
     // Data service routes
+    migration: useMigrationRouter(),
     storage: useUserStoreRouter(),
     ties: useTiesRouter(),
-    switches: useSwitchesRouter(),
+    devices: useDevicesRouter(),
     sources: useSourcesRouter(),
     updates: useUpdaterRouter()
   })
diff --git a/src/main/services/database.ts b/src/main/services/database.ts
index 27c0ecb..2562e00 100644
--- a/src/main/services/database.ts
+++ b/src/main/services/database.ts
@@ -81,6 +81,18 @@ export function inferUpdatesOf<Schema extends z.AnyZodObject>(schema: Schema) {
   )
 }
 
+export type inferUpsertOf<Schema> = Schema extends z.AnyZodObject
+  ? Simplify<z.infer<ReturnType<typeof inferUpsertOf<Schema>>>>
+  : never
+export function inferUpsertOf<Schema extends z.AnyZodObject>(schema: Schema) {
+  return schema.and(
+    z.object({
+      _id: DocumentId,
+      _attachments: z.array(z.instanceof(Attachment)).optional()
+    })
+  )
+}
+
 PouchDb.plugin(useLevelAdapter())
 PouchDb.plugin(find)
 
@@ -95,9 +107,10 @@ export class Database<RawSchema extends z.AnyZodObject> {
   declare readonly __raw__: z.infer<RawSchema>
   /** The database document that is retrieved from the database. */
   declare readonly __document__: inferDocumentOf<RawSchema>
-  // typeof this.__raw__ & { _id: DocumentId, _rev: RevisionId, _attachments: Attachment[] }
   /** The possible document updates. */
   declare readonly __updates__: inferUpdatesOf<RawSchema>
+  /** The raw document is a predefined ID. */
+  declare readonly __upsert__: inferUpsertOf<RawSchema>
 
   /**
    * Initializes a new instance of the Database class.
@@ -233,10 +246,34 @@ export class Database<RawSchema extends z.AnyZodObject> {
     })
   }
 
+  /** Updates an existing document, or inserts a new one, with the given ID. */
+  async upsert(document: Simplify<typeof this.__upsert__>, ...attachments: Attachment[]) {
+    return await this.run(async (db) => {
+      const id = document._id.toUpperCase()
+      const old = await this.getDoc(id).catch(() => ({ _rev: undefined, _attachments: undefined }))
+      const doc = old._rev
+        ? { ...this.#schema.parse(document), _id: id, _rev: old._rev }
+        : { ...this.#schema.parse(document), _id: id }
+
+      const result = await db.put(doc)
+      /* v8 ignore next 1 */ // Likely trigger by database corruption.
+      if (!result.ok) throw new Error(`Failed to insert document "${doc._id}"`)
+      if (attachments.length > 0) {
+        await this.addAttachments(result.id, result.rev, attachments)
+      } else if (document._attachments != null && document._attachments.length > 0) {
+        await this.addAttachments(result.id, result.rev, document._attachments)
+      } else if (old._attachments != null) {
+        await this.addAttachments(result.id, result.rev, await prepareAttachments(old._attachments))
+      }
+
+      return await this.get(id)
+    })
+  }
+
   /** Updates an existing document in the database. */
   async update(document: Simplify<typeof this.__updates__>, ...attachments: Attachment[]) {
     return await this.run(async (db) => {
-      const id = document._id
+      const id = document._id.toUpperCase()
       const old = await this.getDoc(id)
       const doc = { ...this.#schema.parse({ ...old, ...document }), _id: id, _rev: old._rev }
 
@@ -255,6 +292,29 @@ export class Database<RawSchema extends z.AnyZodObject> {
     })
   }
 
+  /** Replaces an existing document, or inserts a new one, with the given ID  */
+  async replace(document: Simplify<typeof this.__upsert__>, ...attachments: Attachment[]) {
+    return await this.run(async (db) => {
+      const id = document._id.toUpperCase()
+      const old = await this.getDoc(id).catch(() => ({ _rev: undefined, _attachments: undefined }))
+      const doc = old._rev
+        ? { ...this.#schema.parse(document), _id: id, _rev: old._rev }
+        : { ...this.#schema.parse(document), _id: id }
+
+      const result = await db.put(doc)
+      // Unlike upsert, we don't transfer the existing attachments in the database to the new revision.
+      /* v8 ignore next 1 */ // Likely trigger by database corruption.
+      if (!result.ok) throw new Error(`Failed to insert document "${doc._id}"`)
+      if (attachments.length > 0) {
+        await this.addAttachments(result.id, result.rev, attachments)
+      } else if (document._attachments != null && document._attachments.length > 0) {
+        await this.addAttachments(result.id, result.rev, document._attachments)
+      }
+
+      return await this.get(id)
+    })
+  }
+
   /** Removes a document from the database. */
   async remove(id: DocumentId, rev?: RevisionId) {
     await this.run(async (db) => {
@@ -275,4 +335,18 @@ export class Database<RawSchema extends z.AnyZodObject> {
       await db.compact()
     })
   }
+
+  /** Deletes all data related to the database. */
+  async destroy() {
+    await this.run(async (db) => {
+      await db.destroy()
+    })
+  }
+
+  /** Closes the database. */
+  async close() {
+    await this.run(async (db) => {
+      await db.close()
+    })
+  }
 }
diff --git a/src/main/services/level.js b/src/main/services/level.js
index 1723aa1..6ca3ca7 100644
--- a/src/main/services/level.js
+++ b/src/main/services/level.js
@@ -1,5 +1,6 @@
 import { resolve as resolvePath } from 'node:path'
 import { app } from 'electron'
+import Logger from 'electron-log'
 import levelDown from 'leveldown'
 import levelUp from 'levelup'
 // @ts-expect-error -- No types
@@ -28,7 +29,7 @@ export const useLevelDb = memo(function useLevelDb() {
       app.on('will-quit', () => {
         db.close((err) => {
           /* v8 ignore next 1 */ // No way to spy or mock this deep in.
-          if (err != null) console.error(err)
+          if (err != null) Logger.error(err)
         })
       })
 
diff --git a/src/main/services/migration.ts b/src/main/services/migration.ts
new file mode 100644
index 0000000..e795a28
--- /dev/null
+++ b/src/main/services/migration.ts
@@ -0,0 +1,80 @@
+import { basename } from 'node:path'
+import Logger from 'electron-log'
+import { alphabetical, memo } from 'radash'
+import { z } from 'zod'
+import { useLevelDb } from './level'
+
+export type Migration = z.infer<typeof Migration>
+export const Migration = z
+  .object({
+    migrate: z.function(z.tuple([]), z.unknown())
+  })
+  .transform((m) => m.migrate)
+
+type State = z.infer<typeof State>
+const State = z.enum(['missed', 'failed', 'done'])
+const StateInDb = z
+  .union([z.instanceof(Buffer), State])
+  /* v8 ignore next 1 */ // Generally one or the other most of the time.
+  .transform((v) => (Buffer.isBuffer(v) ? State.parse(v.toString()) : v))
+
+const useMigrations = memo(function useMigrations() {
+  /** Gets the sorted list of migration modules. */
+  function loadMigrations() {
+    const migrations = Object.entries(import.meta.glob('../migrations/**/*', { eager: true })).map(
+      ([name, module]) => ({ name, migrate: Migration.parse(module) })
+    )
+
+    return alphabetical(migrations, (m) => m.name)
+  }
+
+  /** Opens a connection to the migration database. */
+  async function openMigrationDatabase() {
+    return await useLevelDb().levelup('_migrations')
+  }
+
+  // Memoized so the UI can determine the results.
+  const performMigration = memo(async function performMigration() {
+    Logger.debug('Loading migration information')
+    const migrations = loadMigrations()
+    const database = await openMigrationDatabase()
+
+    /* eslint-disable no-await-in-loop */
+    for (const migration of migrations) {
+      const name = basename(migration.name, '.ts')
+
+      const state = StateInDb.parse(await database.get(name).catch(() => 'missed'))
+      if (state === 'done') continue
+
+      /* v8 ignore next 2 */ // Difficult to test without injecting a broken migration.
+      if (state === 'failed') {
+        Logger.warn(`Attempting failed migration again: ${name}`)
+      } else {
+        Logger.debug(`Attempting migration: ${name}`)
+      }
+
+      try {
+        await migration.migrate()
+        /* v8 ignore next 4 */ // Difficult to test without injecting a broken migration.
+      } catch (cause) {
+        await database.put(name, 'failed')
+        throw new Error(`Failed to complete migration: ${name}`, { cause })
+      }
+
+      try {
+        await database.put(name, 'done')
+        /* v8 ignore next 4 */ // Difficult to test without injecting a broken migration.
+      } catch (cause) {
+        await database.put(name, 'failed')
+        throw new Error(`Failed to record migration completion: ${name}`, { cause })
+      }
+    }
+    /* eslint-enable no-await-in-loop */
+
+    await database.close()
+  })
+
+  return performMigration
+})
+
+export default useMigrations
diff --git a/src/main/services/rpc/trpc.ts b/src/main/services/rpc/trpc.ts
index f0395ad..1a471fc 100644
--- a/src/main/services/rpc/trpc.ts
+++ b/src/main/services/rpc/trpc.ts
@@ -1,6 +1,6 @@
 import { initTRPC } from '@trpc/server'
-import useSuperJson from '@/rpc/transformer'
+import { useIpcJson } from '@/rpc/transformer'
 
-const t = initTRPC.create({ transformer: useSuperJson() })
+const t = initTRPC.create({ transformer: useIpcJson() })
 
 export const { router, procedure } = t
diff --git a/src/preload/api.d.ts b/src/preload/api.d.ts
index b54c1ec..4ad82a5 100644
--- a/src/preload/api.d.ts
+++ b/src/preload/api.d.ts
@@ -13,9 +13,9 @@ export type { ApiLocales } from '../main/services/locale'
 export type { PortEntry } from '../main/services/ports'
 export type { UpdateInfo, ProgressInfo } from '../main/services/updater'
 
-export type { Source, NewSource, SourceUpdate } from '../main/dao/sources'
-export type { Switch, NewSwitch, SwitchUpdate } from '../main/dao/switches'
-export type { Tie, NewTie, TieUpdate } from '../main/dao/ties'
+export type { Source, NewSource, SourceUpdate, SourceUpsert } from '../main/dao/sources'
+export type { Device, NewDevice, DeviceUpdate, DeviceUpsert } from '../main/dao/devices'
+export type { Tie, NewTie, TieUpdate, TieUpsert } from '../main/dao/ties'
 export type { ApiLocales } from '../main/locale'
 
 export type {
diff --git a/src/renderer/components/Highlight.tsx b/src/renderer/components/Highlight.tsx
index 7d6ebc9..0d3b623 100644
--- a/src/renderer/components/Highlight.tsx
+++ b/src/renderer/components/Highlight.tsx
@@ -5,7 +5,7 @@ interface HighlightProps {
   search?: string
 }
 
-export function Highlight({ text, search }: HighlightProps) {
+export default function Highlight({ text, search }: HighlightProps) {
   if (!text) return h(Comment, 'Nothing')
   if (!search) return h(Text, text)
   const start = text.indexOf(search)
diff --git a/src/renderer/hooks/location.ts b/src/renderer/hooks/location.ts
index 054ba1a..c0ee473 100644
--- a/src/renderer/hooks/location.ts
+++ b/src/renderer/hooks/location.ts
@@ -3,7 +3,6 @@ import { toValue, computed, readonly } from 'vue'
 import { useI18n } from 'vue-i18n'
 import type { I18nSchema } from '../locales/locales'
 import type { PortEntry } from '../services/ports'
-import type { NewSwitch } from '../services/switches'
 import type { LocationType } from '@/location'
 import type { MessageProps } from '@vuelidate/validators'
 import type { MaybeRefOrGetter, Ref } from 'vue'
@@ -40,9 +39,12 @@ interface LocationTypeMetaData {
   value: LocationType
 }
 
-export function useLocation(location: Ref<string | undefined>, validSwitches: MaybeRefOrGetter<readonly PortEntry[]>) {
+export default function useLocation(
+  location: Ref<string | undefined>,
+  validPorts: MaybeRefOrGetter<readonly PortEntry[]>
+) {
   const { t } = useI18n<I18nSchema>()
-  const { locationPath } = useLocationUtils(validSwitches)
+  const { locationPath } = useLocationUtils(validPorts)
 
   const pathTypes = readonly([
     { title: t('label.remote'), value: 'ip' },
@@ -100,20 +102,3 @@ export function useLocation(location: Ref<string | undefined>, validSwitches: Ma
     path
   }
 }
-
-export const useSwitchLocation = (
-  switcher: MaybeRefOrGetter<NewSwitch>,
-  validSwitches: MaybeRefOrGetter<readonly PortEntry[]>
-) => {
-  const location = computed({
-    get: () => toValue(switcher).path,
-    set: (v) => {
-      toValue(switcher).path = v
-    }
-  })
-
-  return {
-    location,
-    ...useLocation(location, validSwitches)
-  }
-}
diff --git a/src/renderer/locales/en/messages.json b/src/renderer/locales/en/messages.json
index d5aa957..51c02cb 100644
--- a/src/renderer/locales/en/messages.json
+++ b/src/renderer/locales/en/messages.json
@@ -25,6 +25,8 @@
     "general": "General",
     "image": "Image",
     "loading": "Loading...",
+    "monitor": "Monitor",
+    "monitors": "Monitors",
     "name": "Name",
     "port": "Port",
     "remote": "Remote host",
diff --git a/src/renderer/modals/SwitchDialog.vue b/src/renderer/modals/DeviceDialog.vue
similarity index 92%
rename from src/renderer/modals/SwitchDialog.vue
rename to src/renderer/modals/DeviceDialog.vue
index b4203ba..4af9498 100644
--- a/src/renderer/modals/SwitchDialog.vue
+++ b/src/renderer/modals/DeviceDialog.vue
@@ -3,14 +3,14 @@ import { mdiClose, mdiFlask } from '@mdi/js'
 import { useVModel } from '@vueuse/core'
 import { computed, ref, reactive, onBeforeMount } from 'vue'
 import { useI18n } from 'vue-i18n'
-import { Highlight } from '../components/Highlight'
-import { useLocation } from '../hooks/location'
+import Highlight from '../components/Highlight'
+import useLocation from '../hooks/location'
 import { useRules, useValidation } from '../hooks/validation'
 import useDrivers from '../services/driver'
 import usePorts from '../services/ports'
-import { useDialogs, useSwitchDialog } from './dialogs'
+import { useDialogs, useDeviceDialog } from './dialogs'
 import type { I18nSchema } from '../locales/locales'
-import type { NewSwitch } from '../services/switches'
+import type { NewDevice } from '../services/data/devices'
 import type { DeepReadonly } from 'vue'
 
 const props = defineProps<{
@@ -19,12 +19,12 @@ const props = defineProps<{
   visible?: boolean
   // Form
   editing: boolean
-  switch: DeepReadonly<NewSwitch>
+  device: DeepReadonly<NewDevice>
 }>()
 
 const emit = defineEmits<{
   (on: 'update:visible', value: boolean): void
-  (on: 'confirm', value: NewSwitch): void
+  (on: 'confirm', value: NewDevice): void
 }>()
 
 const { t } = useI18n<I18nSchema>()
@@ -39,7 +39,7 @@ const ports = usePorts()
 onBeforeMount(ports.all)
 
 // eslint-disable-next-line vue/no-setup-props-reactivity-loss -- Prop reactivity not desired.
-const target = ref<NewSwitch>(structuredClone(props.switch))
+const target = ref<NewDevice>(structuredClone(props.device))
 const location = computed({
   get: () => v$.path.$model,
   set: (v) => {
@@ -90,7 +90,7 @@ const rules = reactive({
 
 const { dirty, getStatus, submit, v$ } = useValidation(rules, target, confirm)
 
-const { cardProps, isFullscreen, body, showDividers } = useSwitchDialog()
+const { cardProps, isFullscreen, body, showDividers } = useDeviceDialog()
 
 const isBusy = computed(() => drivers.isBusy || ports.isBusy)
 
@@ -142,7 +142,7 @@ const title = computed(() =>
           </template>
           <template #item="{ props: itemProps, item }">
             <VListItem v-bind="itemProps">
-              <template #title><Highlight :text="item.title" :search="driverSearch"></Highlight></template>
+              <template #title><Highlight :text="item.title" :search="driverSearch" /></template>
               <template v-if="item.raw.experimental" #append>
                 <VTooltip :text="t('label.experimental')">
                   <template #activator="{ props: tooltipProps }">
diff --git a/src/renderer/modals/SourceDialog.vue b/src/renderer/modals/SourceDialog.vue
index 39abf4a..0e14524 100644
--- a/src/renderer/modals/SourceDialog.vue
+++ b/src/renderer/modals/SourceDialog.vue
@@ -5,11 +5,11 @@ import { reactive, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import ReplaceableImage from '../components/ReplaceableImage.vue'
 import { useRules, useValidation } from '../hooks/validation'
-import { useSources } from '../services/sources'
+import { useSources } from '../services/data/sources'
 import { toAttachments } from '../support/files'
 import { useDialogs, useSourceDialog } from './dialogs'
 import type { I18nSchema } from '../locales/locales'
-import type { NewSource, Source } from '../services/sources'
+import type { NewSource, Source } from '../services/data/sources'
 import { toError } from '@/error-handling'
 
 const props = defineProps<{
diff --git a/src/renderer/modals/TieDialog.vue b/src/renderer/modals/TieDialog.vue
index d118a9d..4b76387 100644
--- a/src/renderer/modals/TieDialog.vue
+++ b/src/renderer/modals/TieDialog.vue
@@ -5,13 +5,13 @@ import { computed, ref, reactive, watch, onBeforeMount } from 'vue'
 import { useI18n } from 'vue-i18n'
 import NumberInput from '../components/NumberInput.vue'
 import { useRules, useValidation } from '../hooks/validation'
+import { useDevices } from '../services/data/devices'
+import { useSources } from '../services/data/sources'
 import useDrivers, { kDeviceCanDecoupleAudioOutput, kDeviceSupportsMultipleOutputs } from '../services/driver'
-import { useSources } from '../services/sources'
-import { useSwitches } from '../services/switches'
 import { useDialogs, useTieDialog } from './dialogs'
 import type { I18nSchema } from '../locales/locales'
-import type { Source } from '../services/sources'
-import type { NewTie } from '../services/ties'
+import type { Source } from '../services/data/sources'
+import type { NewTie } from '../services/data/ties'
 import type { DeepReadonly } from 'vue'
 
 const props = defineProps<{
@@ -31,7 +31,7 @@ const emit = defineEmits<{
 
 const { t } = useI18n<I18nSchema>()
 const dialogs = useDialogs()
-const isBusy = computed(() => switches.isBusy || sources.isBusy || drivers.isBusy)
+const isBusy = computed(() => devices.isBusy || sources.isBusy || drivers.isBusy)
 
 const isVisible = useVModel(props, 'visible', emit)
 
@@ -40,7 +40,7 @@ const title = computed(() => (props.editing ? t('label.addTie') : t('label.editT
 const drivers = useDrivers()
 onBeforeMount(drivers.all)
 
-const switches = useSwitches()
+const devices = useDevices()
 const sources = useSources()
 // eslint-disable-next-line vue/no-setup-props-reactivity-loss -- Prop reactivity not desired.
 const target = ref<NewTie>({
@@ -73,10 +73,10 @@ const videoOutputChannel = computed({
   }
 })
 
-const switcher = computed(() => switches.items.find((s) => s._id === target.value.switchId))
+const device = computed(() => devices.items.find((s) => s._id === target.value.deviceId))
 
 const driver = computed(() =>
-  switcher.value != null ? drivers.items.find((d) => d.guid === switcher.value?.driverId) : undefined
+  device.value != null ? drivers.items.find((d) => d.guid === device.value?.driverId) : undefined
 )
 
 const hasOutputChannel = computed(() => Boolean((driver.value?.capabilities ?? 0) & kDeviceSupportsMultipleOutputs))
@@ -127,7 +127,7 @@ function cancel() {
 const { integer, minValue, required, requiredIf, uuid } = useRules()
 const rules = reactive({
   sourceId: { required, uuid },
-  switchId: { required, uuid },
+  deviceId: { required, uuid },
   inputChannel: { required, integer, ...minValue(1) },
   outputChannels: {
     video: { ...requiredIf(hasOutputChannel), integer, ...minValue(1) },
@@ -157,14 +157,14 @@ const { cardProps, isFullscreen, body, showDividers } = useTieDialog()
     <VCardText ref="body">
       <VForm :disabled="isBusy">
         <VSelect
-          v-model="v$.switchId.$model"
+          v-model="v$.deviceId.$model"
           :label="t('label.switchOrMonitor')"
-          :items="switches.items"
+          :items="devices.items"
           item-title="title"
           item-value="_id"
           :placeholder="t('placeholder.required')"
-          v-bind="getStatus(v$.switchId)" />
-        <div v-if="target.switchId != null" class="colg d-flex flex-wrap justify-start">
+          v-bind="getStatus(v$.deviceId)" />
+        <div v-if="target.deviceId != null" class="colg d-flex flex-wrap justify-start">
           <NumberInput
             v-model="v$.inputChannel.$model"
             class="flex-grow-0 w-300px"
diff --git a/src/renderer/modals/dialogs.ts b/src/renderer/modals/dialogs.ts
index c992915..2b77dac 100644
--- a/src/renderer/modals/dialogs.ts
+++ b/src/renderer/modals/dialogs.ts
@@ -128,7 +128,7 @@ export function useSourceDialog() {
   return { breakpoint: xs, ...model }
 }
 
-export function useSwitchDialog() {
+export function useDeviceDialog() {
   const { width } = useDisplay()
   const breakpoint = computed(() => width.value <= 700)
 
diff --git a/src/renderer/pages/SwitchList.vue b/src/renderer/pages/DeviceList.vue
similarity index 69%
rename from src/renderer/pages/SwitchList.vue
rename to src/renderer/pages/DeviceList.vue
index 910aa54..aa27877 100644
--- a/src/renderer/pages/SwitchList.vue
+++ b/src/renderer/pages/DeviceList.vue
@@ -5,13 +5,13 @@ import { useI18n } from 'vue-i18n'
 import { useRouter } from 'vue-router'
 import Page from '../components/Page.vue'
 import { useGuardedAsyncOp } from '../hooks/utilities'
-import SwitchDialog from '../modals/SwitchDialog.vue'
-import { useDialogs, useSwitchDialog } from '../modals/dialogs'
+import DeviceDialog from '../modals/DeviceDialog.vue'
+import { useDialogs, useDeviceDialog } from '../modals/dialogs'
+import { useDevices } from '../services/data/devices'
 import useDrivers from '../services/driver'
-import { useSwitches } from '../services/switches'
 import type { I18nSchema } from '../locales/locales'
+import type { NewDevice, Device } from '../services/data/devices'
 import type { DriverInformation } from '../services/driver'
-import type { NewSwitch, Switch } from '../services/switches'
 import type { DeepReadonly } from 'vue'
 import { isNotNullish } from '@/basics'
 
@@ -22,53 +22,53 @@ const dialogs = useDialogs()
 const { t } = useI18n<I18nSchema>()
 
 interface Item {
-  switch: DeepReadonly<Switch>
+  device: DeepReadonly<Device>
   driver: DriverInformation
 }
 
-const switches = useSwitches()
+const devices = useDevices()
 const drivers = useDrivers()
 const items = computed(() =>
-  switches.items
-    .map((item) => {
-      const driver = drivers.items.find((d) => d.guid === item.driverId)
+  devices.items
+    .map((device) => {
+      const driver = drivers.items.find((d) => d.guid === device.driverId)
 
-      return driver != null ? ({ switch: item, driver } satisfies Item) : undefined
+      return driver != null ? ({ device, driver } satisfies Item) : undefined
     })
     .filter(isNotNullish)
 )
 
 const refresh = useGuardedAsyncOp(async () => {
   // TODO: await drivers.all(), with busy tracking
-  await switches.all()
+  await devices.all()
 })
 
 onMounted(refresh)
 
-async function addSwitch(target: NewSwitch) {
+async function addDevice(target: NewDevice) {
   try {
-    await switches.add(target)
+    await devices.add(target)
   } catch (e) {
     await dialogs.error(e)
     await refresh()
   }
 }
 
-async function updateSwitch(target: Switch, changes: NewSwitch) {
+async function updateDevice(target: Device, changes: NewDevice) {
   try {
-    await switches.update({ ...target, ...changes })
+    await devices.update({ ...target, ...changes })
   } catch (e) {
     await refresh()
     await dialogs.error(e)
   }
 }
 
-async function deleteSwitch(item: Item) {
+async function deleteDevice(item: Item) {
   const kind = item.driver.kind === 'monitor' ? t('label.monitor') : t('label.switch')
 
   const yes = await dialogs.confirm({
     title: t('message.confirmDeleteDevice', [kind]),
-    message: t('message.deleteSwitchWarning'),
+    message: t('message.deleteDeviceWarning'),
     confirmButton: t('action.delete'),
     cancelButton: t('action.keep'),
     color: 'error'
@@ -79,14 +79,14 @@ async function deleteSwitch(item: Item) {
   }
 
   try {
-    await switches.remove(item.switch._id)
+    await devices.remove(item.device._id)
   } catch (e) {
     await refresh()
     await dialogs.error(e)
   }
 }
 
-const { dialogProps: editorProps } = useSwitchDialog()
+const { dialogProps: editorProps } = useDeviceDialog()
 </script>
 
 <template>
@@ -94,27 +94,27 @@ const { dialogProps: editorProps } = useSwitchDialog()
     <VToolbar v-bind="toolbar" :title="t('label.switchesAndMonitors')">
       <template #prepend><VBtn :icon="mdiArrowLeft" @click="router.back" /></template>
     </VToolbar>
-    <VProgressLinear v-show="switches.isBusy" indeterminate />
-    <VList v-scroll.self="scrolled" :disabled="switches.isBusy" bg-color="transparent">
-      <template v-for="(item, index) of items" :key="item.switch._id">
+    <VProgressLinear v-show="devices.isBusy" indeterminate />
+    <VList v-scroll.self="scrolled" :disabled="devices.isBusy" bg-color="transparent">
+      <template v-for="(item, index) of items" :key="item.device._id">
         <VDivider v-if="index > 0" class="mx-4" />
         <VDialog v-bind="editorProps">
           <template #default="{ isActive }">
-            <SwitchDialog
+            <DeviceDialog
               v-model:visible="isActive.value"
-              :switch="item.switch"
+              :device="item.device"
               editing
-              @confirm="(v) => updateSwitch(item.switch, v)" />
+              @confirm="(v) => updateDevice(item.device, v)" />
           </template>
           <template #activator="{ props: dialog }">
-            <VListItem v-bind="dialog" :title="item.switch.title" :subtitle="item.driver.title">
+            <VListItem v-bind="dialog" :title="item.device.title" :subtitle="item.driver.title">
               <template #prepend>
                 <VAvatar :icon="item.driver.kind === 'monitor' ? mdiMonitor : mdiVideoSwitch" />
               </template>
               <template #append>
                 <VTooltip :text="t('action.delete')">
                   <template #activator="{ props: tooltip }">
-                    <VBtn v-bind="tooltip" :icon="mdiDelete" variant="text" @click.prevent.stop="deleteSwitch(item)" />
+                    <VBtn v-bind="tooltip" :icon="mdiDelete" variant="text" @click.prevent.stop="deleteDevice(item)" />
                   </template>
                 </VTooltip>
               </template>
@@ -128,11 +128,11 @@ const { dialogProps: editorProps } = useSwitchDialog()
         <template #activator="{ props }">
           <VDialog v-bind="editorProps">
             <template #default="{ isActive }">
-              <SwitchDialog
+              <DeviceDialog
                 v-model:visible="isActive.value"
-                :switch="switches.blank()"
+                :device="devices.blank()"
                 :editing="false"
-                @confirm="addSwitch" />
+                @confirm="addDevice" />
             </template>
             <template #activator="{ props: dialog }">
               <VBtn v-bind="{ ...props, ...dialog }" class="ml-6" :icon="mdiPlus" color="primary" />
@@ -150,7 +150,7 @@ en:
     addDevice: New switch or monitor
   message:
     confirmDeleteDevice: Do you want to remove this {0}?
-    deleteSwitchWarning: This will also remove any tie relationships on sources.
+    deleteDeviceWarning: This will also remove any tie relationships on sources.
   label:
     monitor: monitor
     switch: switch
diff --git a/src/renderer/pages/FirstRunLogic.vue b/src/renderer/pages/FirstRunLogic.vue
index d58ef45..5952683 100644
--- a/src/renderer/pages/FirstRunLogic.vue
+++ b/src/renderer/pages/FirstRunLogic.vue
@@ -3,6 +3,7 @@ import { useAsyncState, useLocalStorage, watchOnce } from '@vueuse/core'
 import { useI18n } from 'vue-i18n'
 import { trackBusy } from '../hooks/tracking'
 import { useDialogs } from '../modals/dialogs'
+import useMigration from '../services/migration'
 import { useClient } from '../services/rpc/trpc'
 import useStartup from '../services/startup'
 import type { I18nSchema } from '../locales/locales'
@@ -18,6 +19,7 @@ const { state: appInfo, isReady } = useAsyncState(async () => await useClient().
 })
 
 const startup = useStartup()
+const migrate = useMigration()
 
 const steps = [
   // v0: does nothing...
@@ -53,6 +55,10 @@ watchOnce(isReady, async function doFirstRun() {
     // Check if the entry needs to be updated.
     await startup.checkUp()
 
+    // Always "run" migrations, this just checks
+    // what the status was when run at startup.
+    await migrate()
+
     /* eslint-disable no-await-in-loop */
     for (const [index, step] of steps.entries()) {
       if (doneFirstRun.value >= index) {
diff --git a/src/renderer/pages/SettingsPage.vue b/src/renderer/pages/SettingsPage.vue
index afc22bc..2510ce6 100644
--- a/src/renderer/pages/SettingsPage.vue
+++ b/src/renderer/pages/SettingsPage.vue
@@ -14,9 +14,9 @@ import { useRouter } from 'vue-router'
 import Page from '../components/Page.vue'
 import { trackBusy } from '../hooks/tracking'
 import { useGuardedAsyncOp } from '../hooks/utilities'
+import { useDevices } from '../services/data/devices'
+import { useSources } from '../services/data/sources'
 import { useClient } from '../services/rpc/trpc'
-import { useSources } from '../services/sources'
-import { useSwitches } from '../services/switches'
 import type { I18nSchema } from '../locales/locales'
 
 //
@@ -36,34 +36,34 @@ const { state: appInfo } = useAsyncState(async () => await useClient().appInfo.q
 })
 
 //
-// Loading sources and switches so we have a count.
+// Loading sources and devices so we have a count.
 // TODO: Maybe find a better way.
 //
 
 const sources = useSources()
-const switches = useSwitches()
+const devices = useDevices()
 
 // Reduce flicker and shorten the path to the items length of the stores, update
 // them only on refresh. We will only track the refresh.
 const sourceCount = ref(0)
-const switchCount = ref(0)
+const deviceCount = ref(0)
 
 const { isBusy } = trackBusy(
   () => sources.isBusy,
-  () => switches.isBusy
+  () => devices.isBusy
 )
 
 onMounted(
   useGuardedAsyncOp(async () => {
-    await Promise.all([sources.all(), switches.all()])
+    await Promise.all([sources.all(), devices.all()])
     sourceCount.value = sources.items.length
-    switchCount.value = switches.items.length
+    deviceCount.value = devices.items.length
   })
 )
 
 onUnmounted(() => {
   sources.clear()
-  switches.clear()
+  devices.clear()
 })
 </script>
 
@@ -90,8 +90,8 @@ onUnmounted(() => {
         :title="t('label.switchesAndMonitors')"
         lines="two"
         :prepend-icon="mdiVideoSwitch"
-        :subtitle="t('count.switchesAndMonitors', { n: n(switchCount, 'integer') }, switchCount)"
-        :to="{ name: 'switches' }" />
+        :subtitle="t('count.devices', { n: n(deviceCount, 'integer') }, deviceCount)"
+        :to="{ name: 'devices' }" />
       <VListItem
         :title="t('label.backup')"
         :prepend-icon="mdiSwapVertical"
@@ -117,5 +117,5 @@ en:
     about: Version {0}
   count:
     sources: No sources | One source | {n} sources
-    switchesAndMonitors: No devices | One device | {n} devices
+    devices: No devices | One device | {n} devices
 </i18n>
diff --git a/src/renderer/pages/SourceList.vue b/src/renderer/pages/SourceList.vue
index 01f4e41..e04b1dc 100644
--- a/src/renderer/pages/SourceList.vue
+++ b/src/renderer/pages/SourceList.vue
@@ -8,10 +8,10 @@ import { useObjectUrls } from '../hooks/assets'
 import { useGuardedAsyncOp } from '../hooks/utilities'
 import SourceDialog from '../modals/SourceDialog.vue'
 import { useDialogs, useSourceDialog } from '../modals/dialogs'
-import { useSources } from '../services/sources'
+import { useSources } from '../services/data/sources'
 import { toFiles } from '../support/files'
 import type { I18nSchema } from '../locales/locales'
-import type { Source } from '../services/sources'
+import type { Source } from '../services/data/sources'
 import type { DocumentId } from '../services/store'
 
 //
diff --git a/src/renderer/pages/SourcePage.vue b/src/renderer/pages/SourcePage.vue
index 88b44c7..b48bcef 100644
--- a/src/renderer/pages/SourcePage.vue
+++ b/src/renderer/pages/SourcePage.vue
@@ -10,17 +10,17 @@ import { trackBusy } from '../hooks/tracking'
 import { useGuardedAsyncOp } from '../hooks/utilities'
 import TieDialog from '../modals/TieDialog.vue'
 import { useDialogs, useTieDialog } from '../modals/dialogs'
+import { useDevices } from '../services/data/devices'
+import { useSources } from '../services/data/sources'
+import { useTies } from '../services/data/ties'
 import useDrivers from '../services/driver'
-import { useSources } from '../services/sources'
-import { useSwitches } from '../services/switches'
-import { useTies } from '../services/ties'
 import { toAttachments, toFiles } from '../support/files'
 import type { I18nSchema } from '../locales/locales'
+import type { Device } from '../services/data/devices'
+import type { Source } from '../services/data/sources'
+import type { NewTie, Tie } from '../services/data/ties'
 import type { DriverInformation } from '../services/driver'
-import type { Source } from '../services/sources'
 import type { DocumentId } from '../services/store'
-import type { Switch } from '../services/switches'
-import type { NewTie, Tie } from '../services/ties'
 import type { DeepReadonly } from 'vue'
 import { isNotNullish } from '@/basics'
 
@@ -89,27 +89,27 @@ onBeforeMount(loadSource)
 //
 
 interface TieEntry {
-  switch: DeepReadonly<Switch>
+  device: DeepReadonly<Device>
   driver: DriverInformation
   tie: DeepReadonly<Tie>
 }
 
-const switches = useSwitches()
+const devices = useDevices()
 const drivers = useDrivers()
 const ties = useTies()
 const entries = computed(() =>
   ties.items
     .map(function makeEntry(tie) {
-      const switcher = switches.items.find((s) => s._id === tie.switchId)
-      const driver = switcher != null ? drivers.items.find((d) => d.guid === switcher.driverId) : undefined
+      const device = devices.items.find((d) => d._id === tie.deviceId)
+      const driver = device != null ? drivers.items.find((d) => d.guid === device.driverId) : undefined
 
-      return switcher != null && driver != null ? ({ switch: switcher, driver, tie } satisfies TieEntry) : undefined
+      return device != null && driver != null ? ({ device, driver, tie } satisfies TieEntry) : undefined
     })
     .filter(isNotNullish)
 )
 
 const loadTies = useGuardedAsyncOp(async function loadTies() {
-  await Promise.all([switches.all(), ties.forSource(props.id)])
+  await Promise.all([devices.all(), ties.forSource(props.id)])
 })
 
 onBeforeMount(loadTies)
@@ -160,7 +160,7 @@ const { dialogProps: editorProps } = useTieDialog()
 
 const { isBusy } = trackBusy(
   () => sources.isBusy,
-  () => switches.isBusy,
+  () => devices.isBusy,
   () => drivers.isBusy,
   () => ties.isBusy
 )
@@ -199,7 +199,7 @@ const { isBusy } = trackBusy(
                 @confirm="(v) => updateTie(entry.tie, v)" />
             </template>
             <template #activator="{ props: dialog }">
-              <VListItem v-bind="dialog" lines="three" :title="entry.switch.title" :subtitle="entry.driver.title">
+              <VListItem v-bind="dialog" lines="three" :title="entry.device.title" :subtitle="entry.driver.title">
                 <VChip
                   :prepend-icon="mdiImport"
                   class="mr-1"
diff --git a/src/renderer/plugins/router.ts b/src/renderer/plugins/router.ts
index 0122d8a..6c3d1ef 100644
--- a/src/renderer/plugins/router.ts
+++ b/src/renderer/plugins/router.ts
@@ -1,11 +1,11 @@
 import { createRouter, createWebHashHistory } from 'vue-router'
+import DeviceList from '../pages/DeviceList.vue'
 import GeneralPage from '../pages/GeneralPage.vue'
 import MainDashboard from '../pages/MainDashboard.vue'
 import SettingsBackupPage from '../pages/SettingsBackupPage.vue'
 import SettingsPage from '../pages/SettingsPage.vue'
 import SourceList from '../pages/SourceList.vue'
 import SourcePage from '../pages/SourcePage.vue'
-import SwitchList from '../pages/SwitchList.vue'
 import type { RouteRecordRaw } from 'vue-router'
 
 const routes = [
@@ -15,7 +15,7 @@ const routes = [
   { name: 'settings-backup', path: '/settings/backup', component: SettingsBackupPage },
   { name: 'sources', path: '/sources', component: SourceList },
   { name: 'sources-id', path: '/sources/:id', component: SourcePage, props: true },
-  { name: 'switches', path: '/switches', component: SwitchList }
+  { name: 'devices', path: '/devices', component: DeviceList }
 ] satisfies RouteRecordRaw[]
 
 const router = createRouter({
diff --git a/src/renderer/services/backup/export.ts b/src/renderer/services/backup/export.ts
index 3f4d486..381590e 100644
--- a/src/renderer/services/backup/export.ts
+++ b/src/renderer/services/backup/export.ts
@@ -1,20 +1,20 @@
 import { BlobReader, BlobWriter, TextReader, ZipWriter } from '@zip.js/zip.js'
 import { pick } from 'radash'
 import { toFiles } from '../../support/files'
+import { useDevices } from '../data/devices'
+import { useSources } from '../data/sources'
+import { useTies } from '../data/ties'
 import useSettings from '../settings'
-import { useSources } from '../sources'
-import { useSwitches } from '../switches'
-import { useTies } from '../ties'
 import { isNotNullish } from '@/basics'
 
 export async function exportSettings() {
   const settings = useSettings()
   const sources = useSources()
-  const switches = useSwitches()
+  const devices = useDevices()
   const ties = useTies()
 
   await sources.all()
-  await switches.all()
+  await devices.all()
   await ties.all()
 
   const zipFile = new BlobWriter()
@@ -27,12 +27,12 @@ export async function exportSettings() {
 
   const configText = new TextReader(
     JSON.stringify({
-      version: 2,
+      version: 3,
       settings: pick(settings, ['iconSize', 'colorScheme', 'powerOnSwitchesAtStart', 'powerOffWhen']),
       layouts: {
         sources: sources.items.map((item) => pick(item, ['_id', 'title', 'image'])),
-        switches: switches.items.map((item) => pick(item, ['_id', 'driverId', 'path', 'title'])),
-        ties: ties.items.map((item) => pick(item, ['_id', 'sourceId', 'switchId', 'inputChannel', 'outputChannels']))
+        devices: devices.items.map((item) => pick(item, ['_id', 'driverId', 'path', 'title'])),
+        ties: ties.items.map((item) => pick(item, ['_id', 'sourceId', 'deviceId', 'inputChannel', 'outputChannels']))
       }
     })
   )
diff --git a/src/renderer/services/backup/formats/version1.ts b/src/renderer/services/backup/formats/version1.ts
index 294f40b..3058f4a 100644
--- a/src/renderer/services/backup/formats/version1.ts
+++ b/src/renderer/services/backup/formats/version1.ts
@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { DocHeader } from './version0'
-import type { Export as V2 } from './version2'
+import type { Export as V3 } from './version3'
 
 /**
  * Layout v1, will be used in Export v1 but
@@ -30,21 +30,22 @@ export const Layouts = z.object({
         video: z.number().int().optional(),
         audio: z.number().int().optional()
       })
-    })
+    }).transform(({ switchId, ...tie }) => ({ ...tie, deviceId: switchId }))
   )
 })
 
 /**
  * Export format v1.
  */
+export type Export = z.output<typeof Export>
 export const Export = z
   .object({
     version: z.literal(1),
     ...Layouts.shape
   })
   .transform(
-    ({ sources, switches, ties }): V2 => ({
-      version: 2,
-      layouts: { sources, switches, ties }
+    ({ sources, switches, ties }): V3 => ({
+      version: 3,
+      layouts: { sources, devices: switches, ties }
     })
   )
diff --git a/src/renderer/services/backup/formats/version2.ts b/src/renderer/services/backup/formats/version2.ts
index ecbad2b..9e46373 100644
--- a/src/renderer/services/backup/formats/version2.ts
+++ b/src/renderer/services/backup/formats/version2.ts
@@ -2,16 +2,26 @@ import { z } from 'zod'
 import { ColorScheme, IconSize, PowerOffTaps } from '../../settings'
 import { Layouts } from './version1'
 
+/**
+ * Settings v2, will be used in Export v2 but
+ * may be reused by later versions.
+ */
+export type Settings = z.output<typeof Settings>
+export const Settings = z
+  .object({
+    iconSize: IconSize.optional(),
+    colorScheme: ColorScheme.optional(),
+    powerOnSwitchesAtStart: z.boolean().optional(),
+    powerOffWhen: PowerOffTaps.optional()
+  })
+  .optional()
+
+/**
+ * Export format v2.
+ */
 export type Export = z.output<typeof Export>
 export const Export = z.object({
-  version: z.literal(2),
-  settings: z
-    .object({
-      iconSize: IconSize.optional(),
-      colorScheme: ColorScheme.optional(),
-      powerOnSwitchesAtStart: z.boolean().optional(),
-      powerOffWhen: PowerOffTaps.optional()
-    })
-    .optional(),
-  layouts: Layouts
+  version: z.literal(2).transform(() => 3 as const),
+  settings: Settings,
+  layouts: Layouts.transform(({ sources, switches, ties }) => ({ sources, devices: switches, ties }))
 })
diff --git a/src/renderer/services/backup/formats/version3.ts b/src/renderer/services/backup/formats/version3.ts
new file mode 100644
index 0000000..98cea82
--- /dev/null
+++ b/src/renderer/services/backup/formats/version3.ts
@@ -0,0 +1,45 @@
+import { z } from 'zod'
+import { DocHeader } from './version0'
+import { Settings } from './version2'
+
+/**
+ * Layout v3, will be used in Export v3 but
+ * may be reused by later versions.
+ */
+export type Layouts = z.output<typeof Layouts>
+export const Layouts = z.object({
+  sources: z.array(
+    DocHeader.extend({
+      title: z.string().min(1),
+      image: z.string().min(1).nullable()
+    })
+  ),
+  devices: z.array(
+    DocHeader.extend({
+      driverId: z.string().uuid(),
+      title: z.string(),
+      path: z.string()
+    })
+  ),
+  ties: z.array(
+    DocHeader.extend({
+      sourceId: z.string().uuid(),
+      deviceId: z.string().uuid(),
+      inputChannel: z.number().int(),
+      outputChannels: z.object({
+        video: z.number().int().optional(),
+        audio: z.number().int().optional()
+      })
+    })
+  )
+})
+
+/**
+ * Export format v3.
+ */
+export type Export = z.output<typeof Export>
+export const Export = z.object({
+  version: z.literal(3),
+  settings: Settings,
+  layouts: Layouts
+})
diff --git a/src/renderer/services/backup/import.ts b/src/renderer/services/backup/import.ts
index 9346777..a5503ec 100644
--- a/src/renderer/services/backup/import.ts
+++ b/src/renderer/services/backup/import.ts
@@ -2,11 +2,11 @@ import { BlobReader, BlobWriter, TextWriter, ZipReader } from '@zip.js/zip.js'
 import mime from 'mime'
 import { z } from 'zod'
 import { toAttachment } from '../../support/files'
+import { useDevices } from '../data/devices'
+import { useSources } from '../data/sources'
+import { useTies } from '../data/ties'
 import useDrivers from '../driver'
 import useSettings from '../settings'
-import { useSources } from '../sources'
-import { useSwitches } from '../switches'
-import { useTies } from '../ties'
 
 export async function importSettings(file: File) {
   const settings = useSettings()
@@ -14,7 +14,8 @@ export async function importSettings(file: File) {
     // HACK: Don't use map to retain the tuple, and type for
     // each element, for z.union, which wants a tuple.
     import('./formats/version1').then((m) => m.Export),
-    import('./formats/version2').then((m) => m.Export)
+    import('./formats/version2').then((m) => m.Export),
+    import('./formats/version3').then((m) => m.Export)
   ])
 
   const backupSettings = z.union(formats)
@@ -44,21 +45,21 @@ export async function importSettings(file: File) {
   await drivers.all()
 
   const sources = useSources()
-  const switches = useSwitches()
+  const devices = useDevices()
   const ties = useTies()
 
   await Promise.all([
     Promise.all(
       data.layouts.sources.map(async (item) => {
         if (item.image == null) {
-          await sources.add(item)
+          await sources.upsert(item)
           return
         }
 
         const type = mime.getType(item.image) ?? 'application/octet-stream'
         let imageAttachment = imageCache.get(item.image)
         if (imageAttachment != null) {
-          await sources.add(item, await toAttachment(imageAttachment))
+          await sources.upsert(item, await toAttachment(imageAttachment))
           return
         }
 
@@ -66,7 +67,7 @@ export async function importSettings(file: File) {
         if (imageEntry?.getData == null) {
           // It's not fatal if the image is missing.
           console.warn(`Image for ${item._id}, "${item.image}", is missing`)
-          await sources.add({ ...item, image: null })
+          await sources.upsert({ ...item, image: null })
           return
         }
 
@@ -75,39 +76,39 @@ export async function importSettings(file: File) {
         const imageData = await imageFile.getData()
         imageAttachment = new File([imageData], item.image, { type })
         imageCache.set(item.image, imageAttachment)
-        await sources.add(item, await toAttachment(imageAttachment))
+        await sources.upsert(item, await toAttachment(imageAttachment))
       })
     ),
     Promise.all(
-      data.layouts.switches.map(async (item) => {
-        const driver = drivers.items.find((d) => d.guid === item.driverId)
-        // Non-fatally skip switches from drivers that don't exist.
+      data.layouts.devices.map(async (device) => {
+        const driver = drivers.items.find((d) => d.guid === device.driverId)
+        // Non-fatally skip devices from drivers that don't exist.
         if (driver == null) {
-          console.warn(`Driver for ${item.title} no longer support; ${item.driverId}`)
+          console.warn(`Driver for ${device.title} no longer support; ${device.driverId}`)
           return
         }
 
-        await switches.add(item)
+        await devices.upsert(device)
       })
     )
   ])
 
   await Promise.all(
     data.layouts.ties.map(async (item) => {
-      const sourceItem = sources.items.find((s) => s._id === item.sourceId)
-      const switchItem = switches.items.find((s) => s._id === item.switchId)
-      // Non-fatally skip ties that reference missing switches or sources.
-      if (sourceItem == null) {
-        console.warn(`Switch for tie no longer present; ${item.sourceId}`)
+      const source = sources.items.find((s) => s._id === item.sourceId)
+      const device = devices.items.find((d) => d._id === item.deviceId)
+      // Non-fatally skip ties that reference missing devices or sources.
+      if (source == null) {
+        console.warn(`Source for tie no longer present; ${item.sourceId}`)
         return
       }
 
-      if (switchItem == null) {
-        console.warn(`Switch for tie no longer present; ${item.switchId}`)
+      if (device == null) {
+        console.warn(`Device for tie no longer present; ${item.deviceId}`)
         return
       }
 
-      await ties.add(item)
+      await ties.upsert(item)
     })
   )
 }
diff --git a/src/renderer/services/dashboard.ts b/src/renderer/services/dashboard.ts
index 9b24b90..c6f072d 100644
--- a/src/renderer/services/dashboard.ts
+++ b/src/renderer/services/dashboard.ts
@@ -3,13 +3,13 @@ import { computed, readonly, ref } from 'vue'
 import { useImages } from '../hooks/assets'
 import { trackBusy } from '../hooks/tracking'
 import { toFiles } from '../support/files'
+import { useDevices } from './data/devices'
+import { useSources } from './data/sources'
+import { useTies } from './data/ties'
 import useDrivers from './driver'
 import useSettings from './settings'
-import { useSources } from './sources'
-import { useSwitches } from './switches'
-import { useTies } from './ties'
+import type { Source } from './data/sources'
 import type { Driver } from './driver'
-import type { Source } from './sources'
 import type { DocumentId } from './store'
 import type { ReadonlyDeep } from 'type-fest'
 import { isNotNullish } from '@/basics'
@@ -30,12 +30,12 @@ export const useDashboard = defineStore('dashboard', function defineDashboard()
   const drivers = useDrivers()
   const ties = useTies()
   const sources = useSources()
-  const switches = useSwitches()
+  const devices = useDevices()
   const tracker = trackBusy(
     () => !isReady.value,
     () => drivers.isBusy,
     () => sources.isBusy,
-    () => switches.isBusy,
+    () => devices.isBusy,
     () => ties.isBusy
   )
 
@@ -47,10 +47,10 @@ export const useDashboard = defineStore('dashboard', function defineDashboard()
   async function loadDrivers() {
     await drivers.all()
 
-    // Remove drivers for switches removed
+    // Remove drivers for devices removed
     const closing: Driver[] = []
     for (const guid of loadedDrivers.keys()) {
-      if (switches.items.find((switcher) => switcher._id === guid) == null) {
+      if (devices.items.find((device) => device._id === guid) == null) {
         const driver = loadedDrivers.get(guid)
         if (driver != null) {
           loadedDrivers.delete(guid)
@@ -61,10 +61,10 @@ export const useDashboard = defineStore('dashboard', function defineDashboard()
 
     // Load any drivers that are new or are being replaced.
     const loading = new Array<[string, Driver]>()
-    for (const switcher of switches.items) {
-      const driver = loadedDrivers.get(switcher._id)
-      if (driver == null || driver.uri !== switcher.path) {
-        loading.push([switcher._id, drivers.load(switcher.driverId, switcher.path)])
+    for (const device of devices.items) {
+      const driver = loadedDrivers.get(device._id)
+      if (driver == null || driver.uri !== device.path) {
+        loading.push([device._id, drivers.load(device.driverId, device.path)])
       }
     }
 
@@ -78,24 +78,24 @@ export const useDashboard = defineStore('dashboard', function defineDashboard()
     const commands = ties.items
       .filter((tie) => tie.sourceId === source._id)
       .map(function makeCommand(tie) {
-        const switcher = switches.items.find((item) => tie.switchId === item._id)
-        const driver = loadedDrivers.get(tie.switchId)
+        const device = devices.items.find((item) => tie.deviceId === item._id)
+        const driver = loadedDrivers.get(tie.deviceId)
 
-        if (switcher == null) {
-          console.error(`${tie.switchId}: No such switch for source "${source.title}"`)
+        if (device == null) {
+          console.error(`${tie.deviceId}: No such device for source "${source.title}"`)
 
           return undefined
         }
 
         if (driver == null) {
           console.error(
-            `${switcher.driverId}:  No such driver for switch "${switcher.title}" used by source "${source.title}"`
+            `${device.driverId}:  No such driver for device "${device.title}" used by source "${source.title}"`
           )
 
           return undefined
         }
 
-        return { tie, switch: switcher, driver }
+        return { tie, device, driver }
       })
       .filter(isNotNullish)
 
@@ -160,8 +160,8 @@ export const useDashboard = defineStore('dashboard', function defineDashboard()
 
   const refresh = tracker.track(async function refresh() {
     items.value = []
-    await Promise.all([ties.compact(), sources.compact(), switches.compact()])
-    await Promise.all([ties.all(), sources.all(), switches.all()])
+    await Promise.all([ties.compact(), sources.compact(), devices.compact()])
+    await Promise.all([ties.all(), sources.all(), devices.all()])
     await loadDrivers()
     await setupDashboard()
     await powerOnOnce()
diff --git a/src/renderer/services/data/devices.ts b/src/renderer/services/data/devices.ts
new file mode 100644
index 0000000..2290f37
--- /dev/null
+++ b/src/renderer/services/data/devices.ts
@@ -0,0 +1,57 @@
+import { defineStore } from 'pinia'
+import { forceUndefined } from '../../hooks/utilities'
+import { useClient } from '../rpc/trpc'
+import { useDataStore } from '../store'
+import type { NewDevice, Device, DeviceUpdate, DeviceUpsert } from '../../../preload/api'
+import type { DocumentId } from '../store'
+
+export type { NewDevice, Device, DeviceUpdate } from '../../../preload/api'
+
+export const useDevices = defineStore('devices', function defineDevices() {
+  const { devices } = useClient()
+  const store = useDataStore<Device>()
+
+  function blank(): NewDevice {
+    return {
+      driverId: forceUndefined(),
+      title: forceUndefined(),
+      path: 'port:'
+    }
+  }
+
+  const compact = store.defineOperation(async () => {
+    await devices.compact.mutate()
+  })
+
+  const all = store.defineFetchMany(async () => await devices.all.query())
+
+  const get = store.defineFetch(async (id: DocumentId) => await devices.get.query(id))
+
+  const add = store.defineInsertion(async (document: NewDevice) => await devices.add.mutate(document))
+
+  const update = store.defineMutation(async (document: DeviceUpdate) => await devices.update.mutate(document))
+
+  const upsert = store.defineMutation(async (document: DeviceUpsert) => await devices.upsert.mutate(document))
+
+  const remove = store.defineRemoval(async (id: DocumentId) => {
+    await devices.remove.mutate(id)
+    return id
+  })
+
+  return {
+    isBusy: store.isBusy,
+    error: store.error,
+    items: store.items,
+    current: store.current,
+    blank,
+    compact,
+    all,
+    get,
+    add,
+    update,
+    upsert,
+    remove,
+    dismiss: store.unsetCurrent,
+    clear: store.clearItems
+  }
+})
diff --git a/src/renderer/services/sources.ts b/src/renderer/services/data/sources.ts
similarity index 71%
rename from src/renderer/services/sources.ts
rename to src/renderer/services/data/sources.ts
index 754ec80..1882a5b 100644
--- a/src/renderer/services/sources.ts
+++ b/src/renderer/services/data/sources.ts
@@ -1,12 +1,12 @@
 import { defineStore } from 'pinia'
-import { forceUndefined } from '../hooks/utilities'
-import { useClient } from './rpc/trpc'
-import { useDataStore } from './store'
-import type { DocumentId } from './store'
-import type { NewSource, Source, SourceUpdate } from '../../preload/api'
+import { forceUndefined } from '../../hooks/utilities'
+import { useClient } from '../rpc/trpc'
+import { useDataStore } from '../store'
+import type { NewSource, Source, SourceUpdate, SourceUpsert } from '../../../preload/api'
+import type { DocumentId } from '../store'
 import type { Attachment } from '@/attachments'
 
-export type { NewSource, Source, SourceUpdate } from '../../preload/api'
+export type { NewSource, Source, SourceUpdate } from '../../../preload/api'
 
 export const useSources = defineStore('sources', function defineSources() {
   const { sources } = useClient()
@@ -36,6 +36,11 @@ export const useSources = defineStore('sources', function defineSources() {
       await sources.update.mutate([document, ...attachments])
   )
 
+  const upsert = store.defineMutation(
+    async (document: SourceUpsert, ...attachments: Attachment[]) =>
+      await sources.upsert.mutate([document, ...attachments])
+  )
+
   const remove = store.defineRemoval(async (id: DocumentId) => {
     await sources.remove.mutate(id)
     return id
@@ -52,6 +57,7 @@ export const useSources = defineStore('sources', function defineSources() {
     get,
     add,
     update,
+    upsert,
     remove,
     dismiss: store.unsetCurrent,
     clear: store.clearItems
diff --git a/src/renderer/services/storage.ts b/src/renderer/services/data/storage.ts
similarity index 98%
rename from src/renderer/services/storage.ts
rename to src/renderer/services/data/storage.ts
index 50eda03..b6eaffe 100644
--- a/src/renderer/services/storage.ts
+++ b/src/renderer/services/data/storage.ts
@@ -1,5 +1,5 @@
 import { createSharedComposable, useStorageAsync } from '@vueuse/core'
-import { useClient } from './rpc/trpc'
+import { useClient } from '../rpc/trpc'
 import type { RemovableRef, UseStorageAsyncOptions } from '@vueuse/core'
 import type { MaybeRefOrGetter } from 'vue'
 
diff --git a/src/renderer/services/ties.ts b/src/renderer/services/data/ties.ts
similarity index 69%
rename from src/renderer/services/ties.ts
rename to src/renderer/services/data/ties.ts
index d9b8a8f..7ac51f9 100644
--- a/src/renderer/services/ties.ts
+++ b/src/renderer/services/data/ties.ts
@@ -1,11 +1,11 @@
 import { defineStore } from 'pinia'
-import { forceUndefined } from '../hooks/utilities'
-import { useClient } from './rpc/trpc'
-import { useDataStore } from './store'
-import type { DocumentId } from './store'
-import type { NewTie, TieUpdate, Tie } from '../../preload/api'
+import { forceUndefined } from '../../hooks/utilities'
+import { useClient } from '../rpc/trpc'
+import { useDataStore } from '../store'
+import type { NewTie, TieUpdate, Tie, TieUpsert } from '../../../preload/api'
+import type { DocumentId } from '../store'
 
-export type { NewTie, TieUpdate, Tie } from '../../preload/api'
+export type { NewTie, TieUpdate, Tie } from '../../../preload/api'
 
 export const useTies = defineStore('ties', function defineTies() {
   const { ties } = useClient()
@@ -14,7 +14,7 @@ export const useTies = defineStore('ties', function defineTies() {
   function blank(): NewTie {
     return {
       sourceId: forceUndefined(),
-      switchId: forceUndefined(),
+      deviceId: forceUndefined(),
       inputChannel: forceUndefined(),
       outputChannels: {
         video: undefined,
@@ -35,12 +35,14 @@ export const useTies = defineStore('ties', function defineTies() {
 
   const update = store.defineMutation(async (document: TieUpdate) => await ties.update.mutate(document))
 
+  const upsert = store.defineMutation(async (document: TieUpsert) => await ties.upsert.mutate(document))
+
   const remove = store.defineRemoval(async (id: DocumentId) => {
     await ties.remove.mutate(id)
     return id
   })
 
-  const forSwitch = store.defineFetchMany(async (id: DocumentId) => await ties.forSwitch.query(id))
+  const forDevice = store.defineFetchMany(async (id: DocumentId) => await ties.forDevice.query(id))
 
   const forSource = store.defineFetchMany(async (id: DocumentId) => await ties.forSource.query(id))
 
@@ -55,8 +57,9 @@ export const useTies = defineStore('ties', function defineTies() {
     get,
     add,
     update,
+    upsert,
     remove,
-    forSwitch,
+    forDevice,
     forSource,
     dismiss: store.unsetCurrent,
     clear: store.clearItems
diff --git a/src/renderer/services/driver.ts b/src/renderer/services/driver.ts
index 4885dc7..75a7e0a 100644
--- a/src/renderer/services/driver.ts
+++ b/src/renderer/services/driver.ts
@@ -26,7 +26,7 @@ export interface DriverInformation extends DriverBasicInformation, LocalizedDriv
   // Just combines the localized information with the basic information.
 }
 
-/** Driver to interact with switching devices. */
+/** Driver to interact with monitors or switches. */
 export interface Driver extends DriverInformation {
   /**
    * Sets input and output ties.
diff --git a/src/renderer/services/migration.ts b/src/renderer/services/migration.ts
new file mode 100644
index 0000000..14a68e5
--- /dev/null
+++ b/src/renderer/services/migration.ts
@@ -0,0 +1,16 @@
+import { createSharedComposable } from '@vueuse/shared'
+import { trackBusy } from '../hooks/tracking'
+import { useClient } from './rpc/trpc'
+
+const useMigration = createSharedComposable(function useMigration() {
+  const tracker = trackBusy()
+  const client = useClient()
+
+  const migrate = tracker.track(async function migrate() {
+    await client.migration.migrate.mutate()
+  })
+
+  return migrate
+})
+
+export default useMigration
diff --git a/src/renderer/services/rpc/trpc.ts b/src/renderer/services/rpc/trpc.ts
index ed454fb..6a1cc85 100644
--- a/src/renderer/services/rpc/trpc.ts
+++ b/src/renderer/services/rpc/trpc.ts
@@ -2,8 +2,8 @@ import { createTRPCProxyClient } from '@trpc/client'
 import { createGlobalState } from '@vueuse/shared'
 import { useIpcLink } from './link'
 import type { AppRouter } from '../../../preload/api'
-import useSuperJson from '@/rpc/transformer'
+import { useIpcJson } from '@/rpc/transformer'
 
 export const useClient = createGlobalState(function useClient() {
-  return createTRPCProxyClient<AppRouter>({ transformer: useSuperJson(), links: [useIpcLink()] })
+  return createTRPCProxyClient<AppRouter>({ transformer: useIpcJson(), links: [useIpcLink()] })
 })
diff --git a/src/renderer/services/settings.ts b/src/renderer/services/settings.ts
index d89130e..e4cdcf3 100644
--- a/src/renderer/services/settings.ts
+++ b/src/renderer/services/settings.ts
@@ -2,8 +2,8 @@ import { usePreferredColorScheme } from '@vueuse/core'
 import { defineStore } from 'pinia'
 import { readonly, computed } from 'vue'
 import { z } from 'zod'
+import { useUserStorage } from './data/storage'
 import useStartup from './startup'
-import { useUserStorage } from './storage'
 import type { UseStorageOptions } from '@vueuse/core'
 
 // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style -- Will cause circular type reference.
diff --git a/src/renderer/services/switches.ts b/src/renderer/services/switches.ts
deleted file mode 100644
index 6b968a0..0000000
--- a/src/renderer/services/switches.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { defineStore } from 'pinia'
-import { forceUndefined } from '../hooks/utilities'
-import { useClient } from './rpc/trpc'
-import { useDataStore } from './store'
-import type { DocumentId } from './store'
-import type { NewSwitch, Switch, SwitchUpdate } from '../../preload/api'
-
-export type { NewSwitch, Switch, SwitchUpdate } from '../../preload/api'
-
-export const useSwitches = defineStore('switches', function defineSwitches() {
-  const { switches } = useClient()
-  const store = useDataStore<Switch>()
-
-  function blank(): NewSwitch {
-    return {
-      driverId: forceUndefined(),
-      title: forceUndefined(),
-      path: 'port:'
-    }
-  }
-
-  const compact = store.defineOperation(async () => {
-    await switches.compact.mutate()
-  })
-
-  const all = store.defineFetchMany(async () => await switches.all.query())
-
-  const get = store.defineFetch(async (id: DocumentId) => await switches.get.query(id))
-
-  const add = store.defineInsertion(async (document: NewSwitch) => await switches.add.mutate(document))
-
-  const update = store.defineMutation(async (document: SwitchUpdate) => await switches.update.mutate(document))
-
-  const remove = store.defineRemoval(async (id: DocumentId) => {
-    await switches.remove.mutate(id)
-    return id
-  })
-
-  return {
-    isBusy: store.isBusy,
-    error: store.error,
-    items: store.items,
-    current: store.current,
-    blank,
-    compact,
-    all,
-    get,
-    add,
-    update,
-    remove,
-    dismiss: store.unsetCurrent,
-    clear: store.clearItems
-  }
-})
diff --git a/src/tests/core/superjson.test.ts b/src/tests/core/superjson.test.ts
index 3f6dde5..fe5dfc7 100644
--- a/src/tests/core/superjson.test.ts
+++ b/src/tests/core/superjson.test.ts
@@ -1,12 +1,12 @@
 import { beforeAll, describe, expect, test } from 'vitest'
 import type { SuperJSONResult } from 'superjson'
 import { Attachment } from '@/attachments'
-import useSuperJson from '@/rpc/transformer'
+import { useWebJson, useIpcJson } from '@/rpc/transformer'
 
-describe('superjson', () => {
-  let superjson: ReturnType<typeof useSuperJson>
+describe('Web JSON', () => {
+  let superjson: ReturnType<typeof useWebJson>
   beforeAll(() => {
-    superjson = useSuperJson()
+    superjson = useWebJson()
   })
 
   describe('attachments', () => {
@@ -44,3 +44,47 @@ describe('superjson', () => {
     })
   })
 })
+
+describe('IPC JSON', () => {
+  let superjson: ReturnType<typeof useIpcJson>
+  beforeAll(() => {
+    superjson = useIpcJson()
+  })
+
+  describe('attachments', () => {
+    test('serialize', () => {
+      const buffer = new Uint8Array(Buffer.from('Hello World').buffer)
+      const payload = { file: new Attachment('test.txt', 'text/plain', buffer) }
+      expect(superjson.serialize(payload)).toStrictEqual({
+        json: { file: { name: 'test.txt', type: 'text/plain', data: buffer } },
+        meta: { values: { file: [['custom', 'Attachment']] } }
+      })
+    })
+
+    test('deserialize', () => {
+      const buffer = new Uint8Array(Buffer.from('Hello World').buffer)
+      const payload = {
+        json: { file: { name: 'test.txt', type: 'text/plain', data: buffer as never } },
+        meta: { values: { file: [['custom', 'Attachment']] } }
+      } satisfies SuperJSONResult
+      expect(superjson.deserialize(payload)).toStrictEqual({
+        file: new Attachment('test.txt', 'text/plain', buffer)
+      })
+    })
+  })
+
+  describe('functions', () => {
+    test('serialize', () => {
+      const payload = { hello: () => undefined }
+      expect(() => superjson.serialize(payload)).toThrow(new TypeError('Functions may not be serialized'))
+    })
+
+    test('deserialize', () => {
+      const payload = {
+        json: { file: null },
+        meta: { values: { file: [['custom', 'Function']] } }
+      } satisfies SuperJSONResult
+      expect(() => superjson.deserialize(payload)).toThrow(new TypeError('Functions may not be serialized'))
+    })
+  })
+})
diff --git a/src/tests/main/dao/switches.test.ts b/src/tests/main/dao/devices.test.ts
similarity index 62%
rename from src/tests/main/dao/switches.test.ts
rename to src/tests/main/dao/devices.test.ts
index de69034..bc629ca 100644
--- a/src/tests/main/dao/switches.test.ts
+++ b/src/tests/main/dao/devices.test.ts
@@ -1,8 +1,8 @@
 import { beforeAll, beforeEach, describe, expect, test, vi } from 'vitest'
-import useSwitchesDatabase from '../../../main/dao/switches'
+import useDevicesDatabase from '../../../main/dao/devices'
 import useTiesDatabase from '../../../main/dao/ties'
 import { seedDatabase } from '../../seeds/database.seed'
-import type { NewSwitch } from '../../../main/dao/switches'
+import type { NewDevice } from '../../../main/dao/devices'
 import { Attachment } from '@/attachments'
 
 const mock = await vi.hoisted(async () => await import('../../support/mock'))
@@ -13,28 +13,28 @@ beforeAll(() => {
 })
 
 let database: Awaited<ReturnType<typeof seedDatabase>>
-let switchesDao: ReturnType<typeof useSwitchesDatabase>
+let devicesDao: ReturnType<typeof useDevicesDatabase>
 let tiesDao: ReturnType<typeof useTiesDatabase>
 
 beforeEach(async () => {
   database = await seedDatabase()
-  switchesDao = useSwitchesDatabase()
+  devicesDao = useDevicesDatabase()
   tiesDao = useTiesDatabase()
 })
 
 test('compacting', async () => {
-  await expect(switchesDao.compact()).resolves.toBeUndefined()
+  await expect(devicesDao.compact()).resolves.toBeUndefined()
 })
 
 describe('query', () => {
   test('all', async () => {
-    await expect(switchesDao.all()).resolves.toStrictEqual(database.switches)
+    await expect(devicesDao.all()).resolves.toStrictEqual(database.devices)
   })
 
   test('single', async () => {
     await Promise.all(
-      database.switches.map(async (item) => {
-        await expect(switchesDao.get(item._id)).resolves.toStrictEqual(item)
+      database.devices.map(async (item) => {
+        await expect(devicesDao.get(item._id)).resolves.toStrictEqual(item)
       })
     )
   })
@@ -46,8 +46,8 @@ const kRevPattern = /^[0-9]-[0-9a-f]{32}$/u
 test('adding', async () => {
   const file = new File([Buffer.from('hello')], 'hello.txt', { type: 'text/plain' })
   const attachment = await Attachment.fromFile(file)
-  const raw = { title: 'Extron', driverId: database.extronSis.guid, path: 'ip:192.168.10.2' } satisfies NewSwitch
-  const doc = await switchesDao.add(raw, attachment)
+  const raw = { title: 'Extron', driverId: database.extronSis.guid, path: 'ip:192.168.10.2' } satisfies NewDevice
+  const doc = await devicesDao.add(raw, attachment)
 
   expect(doc._id).toMatch(kUuidPattern)
   expect(doc._rev).toMatch(kRevPattern)
@@ -60,9 +60,9 @@ test('adding', async () => {
 })
 
 test('updating', async () => {
-  const device = database.switches[0]
+  const device = database.devices[0]
   const changes = { title: 'Extron RGBHVA 128pro' }
-  const updated = await switchesDao.update({ _id: device._id, ...changes })
+  const updated = await devicesDao.update({ _id: device._id, ...changes })
   expect(updated._rev).toMatch(kRevPattern)
   expect(updated).toStrictEqual({
     ...device,
@@ -74,21 +74,21 @@ test('updating', async () => {
 })
 
 test('removing', async () => {
-  const device = database.switches[1]
-  await expect(switchesDao.remove(device._id)).resolves.toBeUndefined()
-  await expect(switchesDao.get(device._id)).rejects.toThrow('missing')
+  const device = database.devices[1]
+  await expect(devicesDao.remove(device._id)).resolves.toBeUndefined()
+  await expect(devicesDao.get(device._id)).rejects.toThrow('missing')
   await expect(tiesDao.forSource(device._id)).resolves.toHaveLength(0)
 })
 
 test('clearing', async () => {
-  await expect(switchesDao.all()).resolves.toHaveLength(database.switches.length)
+  await expect(devicesDao.all()).resolves.toHaveLength(database.devices.length)
   await expect(tiesDao.all()).resolves.toHaveLength(database.ties.length)
-  await expect(switchesDao.clear()).resolves.toBeUndefined()
+  await expect(devicesDao.clear()).resolves.toBeUndefined()
   await Promise.all(
-    database.switches.map(async (doc) => {
-      await expect(switchesDao.get(doc._id)).rejects.toThrow('missing')
+    database.devices.map(async (doc) => {
+      await expect(devicesDao.get(doc._id)).rejects.toThrow('missing')
     })
   )
-  await expect(switchesDao.all()).resolves.toHaveLength(0)
+  await expect(devicesDao.all()).resolves.toHaveLength(0)
   await expect(tiesDao.all()).resolves.toHaveLength(0)
 })
diff --git a/src/tests/main/dao/ties.test.ts b/src/tests/main/dao/ties.test.ts
index 2e901c2..cf4bf74 100644
--- a/src/tests/main/dao/ties.test.ts
+++ b/src/tests/main/dao/ties.test.ts
@@ -45,7 +45,7 @@ test('adding', async () => {
   const attachment = await Attachment.fromFile(file)
   const raw = {
     sourceId: database.sources[2]._id,
-    switchId: database.switches[1]._id,
+    deviceId: database.devices[1]._id,
     inputChannel: 3,
     outputChannels: { video: 6 }
   } satisfies NewTie
diff --git a/src/tests/main/services/database.test.ts b/src/tests/main/services/database.test.ts
index c9b33ac..cff90f2 100644
--- a/src/tests/main/services/database.test.ts
+++ b/src/tests/main/services/database.test.ts
@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto'
 import { map, memo, omit } from 'radash'
 import { beforeAll, beforeEach, describe, expect, test, vi } from 'vitest'
 import { z } from 'zod'
@@ -189,6 +190,204 @@ describe('updating document', () => {
   })
 })
 
+describe('upserting document', () => {
+  let raw: { x: number; y: number; z: number }
+  let attachment: Attachment
+  let doc: Awaited<ReturnType<typeof database.add>>
+  beforeEach(async () => {
+    raw = { x: 3, y: 4, z: 5 }
+    const file = new File([Buffer.from('hello')], 'hello.txt', { type: 'text/plain' })
+    attachment = await Attachment.fromFile(file)
+    doc = await database.add(raw)
+  })
+
+  test('new document', async () => {
+    const id = randomUUID()
+    const changes = { x: 13, y: 14, z: 15 }
+    const updated = await database.upsert({ _id: id, ...changes })
+    expect(updated._rev).toMatch(kRevPattern)
+    expect(updated).toStrictEqual({
+      ...raw,
+      ...changes,
+      _id: id.toUpperCase(),
+      _rev: updated._rev,
+      _attachments: []
+    })
+  })
+
+  describe('existing document', () => {
+    test('just document', async () => {
+      const changes = { x: 13, y: 14, z: 15 }
+      const updated = await database.upsert({ _id: doc._id, ...changes })
+      expect(updated._rev).toMatch(kRevPattern)
+      expect(updated).toStrictEqual({
+        ...raw,
+        ...changes,
+        _id: doc._id,
+        _rev: updated._rev,
+        _attachments: doc._attachments
+      })
+    })
+
+    describe('with attachments', () => {
+      test('as parameter', async () => {
+        const changes = { x: 13, y: 14, z: 15 }
+        const updated = await database.upsert({ _id: doc._id, ...changes }, attachment)
+        expect(updated._rev).toMatch(kRevPattern)
+        expect(updated).toStrictEqual({
+          ...raw,
+          ...changes,
+          _id: doc._id,
+          _rev: updated._rev,
+          _attachments: [attachment]
+        })
+      })
+
+      test('existing on update payload', async () => {
+        const attached = await database.update({ _id: doc._id, y: 11 }, attachment)
+
+        const changes = { _id: doc._id, x: 13, y: 14, z: 15, _attachments: attached._attachments }
+        const updated = await database.upsert({ ...changes })
+        expect(updated._rev).toMatch(kRevPattern)
+        expect(updated).toStrictEqual({
+          ...raw,
+          ...changes,
+          _id: doc._id,
+          _rev: updated._rev,
+          _attachments: [attachment]
+        })
+      })
+
+      test('existing in database', async () => {
+        await expect(database.update({ _id: doc._id, y: 11 }, attachment)).resolves.toBeTruthy()
+
+        const changes = { _id: doc._id, x: 13, y: 14, z: 15 }
+        const updated = await database.upsert({ ...changes })
+        expect(updated._rev).toMatch(kRevPattern)
+        expect(updated).toStrictEqual({
+          ...raw,
+          ...changes,
+          _id: doc._id,
+          _rev: updated._rev,
+          _attachments: [attachment]
+        })
+      })
+    })
+
+    test('strips unknown fields', async () => {
+      const changes = { x: 13, y: 14, z: 15, a: 5 }
+      const updated = await database.upsert({ _id: doc._id, ...changes })
+      expect(updated._rev).toMatch(kRevPattern)
+      expect(updated).toStrictEqual({
+        ...raw,
+        ...omit(changes, ['a']),
+        _id: doc._id,
+        _rev: updated._rev,
+        _attachments: doc._attachments
+      })
+    })
+  })
+})
+
+describe('replacing document', () => {
+  let raw: { x: number; y: number; z: number }
+  let attachment: Attachment
+  let doc: Awaited<ReturnType<typeof database.add>>
+  beforeEach(async () => {
+    raw = { x: 3, y: 4, z: 5 }
+    const file = new File([Buffer.from('hello')], 'hello.txt', { type: 'text/plain' })
+    attachment = await Attachment.fromFile(file)
+    doc = await database.add(raw)
+  })
+
+  test('new document', async () => {
+    const id = randomUUID()
+    const changes = { x: 13, y: 14, z: 15 }
+    const updated = await database.replace({ _id: id, ...changes })
+    expect(updated._rev).toMatch(kRevPattern)
+    expect(updated).toStrictEqual({
+      ...raw,
+      ...changes,
+      _id: id.toUpperCase(),
+      _rev: updated._rev,
+      _attachments: []
+    })
+  })
+
+  describe('existing document', () => {
+    test('just document', async () => {
+      const changes = { x: 13, y: 14, z: 15 }
+      const updated = await database.replace({ _id: doc._id, ...changes })
+      expect(updated._rev).toMatch(kRevPattern)
+      expect(updated).toStrictEqual({
+        ...raw,
+        ...changes,
+        _id: doc._id,
+        _rev: updated._rev,
+        _attachments: doc._attachments
+      })
+    })
+
+    describe('with attachments', () => {
+      test('as parameter', async () => {
+        const changes = { x: 13, y: 14, z: 15 }
+        const updated = await database.replace({ _id: doc._id, ...changes }, attachment)
+        expect(updated._rev).toMatch(kRevPattern)
+        expect(updated).toStrictEqual({
+          ...raw,
+          ...changes,
+          _id: doc._id,
+          _rev: updated._rev,
+          _attachments: [attachment]
+        })
+      })
+
+      test('existing on update payload', async () => {
+        const attached = await database.update({ _id: doc._id, y: 11 }, attachment)
+
+        const changes = { _id: doc._id, x: 13, y: 14, z: 15, _attachments: attached._attachments }
+        const updated = await database.replace({ ...changes })
+        expect(updated._rev).toMatch(kRevPattern)
+        expect(updated).toStrictEqual({
+          ...raw,
+          ...changes,
+          _id: doc._id,
+          _rev: updated._rev,
+          _attachments: [attachment]
+        })
+      })
+
+      test('existing in database, not transferred', async () => {
+        await expect(database.update({ _id: doc._id, y: 11 }, attachment)).resolves.toBeTruthy()
+
+        const changes = { _id: doc._id, x: 13, y: 14, z: 15 }
+        const updated = await database.replace({ ...changes })
+        expect(updated._rev).toMatch(kRevPattern)
+        expect(updated).toStrictEqual({
+          ...raw,
+          ...changes,
+          _id: doc._id,
+          _rev: updated._rev,
+          _attachments: []
+        })
+      })
+    })
+
+    test('strips unknown fields', async () => {
+      const changes = { x: 13, y: 14, z: 15, a: 5 }
+      const updated = await database.replace({ _id: doc._id, ...changes })
+      expect(updated._rev).toMatch(kRevPattern)
+      expect(updated).toStrictEqual({
+        ...raw,
+        ...omit(changes, ['a']),
+        _id: doc._id,
+        _rev: updated._rev,
+        _attachments: doc._attachments
+      })
+    })
+  })
+})
+
 test('removing document', async () => {
   const raw = { x: 3, y: 4, z: 5 }
   const doc = await database.add(raw)
diff --git a/src/tests/main/services/migration.test.ts b/src/tests/main/services/migration.test.ts
new file mode 100644
index 0000000..42924c7
--- /dev/null
+++ b/src/tests/main/services/migration.test.ts
@@ -0,0 +1,53 @@
+import { omit } from 'radash'
+import { beforeAll, expect, test, vi } from 'vitest'
+
+const mock = await vi.hoisted(async () => await import('../../support/mock'))
+
+beforeAll(() => {
+  vi.mock('electron', mock.electronModule('migration'))
+  vi.mock('electron-log', mock.electronLogModule)
+  // Disable memoize caching.
+  vi.mock('radash', async (original) => ({
+    ...(await original()),
+    memo: (x: unknown) => x
+  }))
+})
+
+test('migration', async () => {
+  const { seedForMigration } = await import('../../seeds/migration.seed')
+  const { switches, sources, ties } = await seedForMigration()
+
+  const { default: useMigrations } = await import('../../../main/services/migration')
+
+  const migrate = useMigrations()
+  await migrate()
+
+  const { default: useDevicesDatabase } = await import('../../../main/dao/devices')
+  const { default: useSourcesDatabase } = await import('../../../main/dao/sources')
+  const { default: useTiesDatabase } = await import('../../../main/dao/ties')
+
+  const deviceDao = useDevicesDatabase()
+  const sourceDao = useSourcesDatabase()
+  const tieDao = useTiesDatabase()
+
+  await expect(deviceDao.all()).resolves.toMatchObject(switches.map((device) => omit(device, ['_rev'])))
+
+  await expect(sourceDao.all()).resolves.toMatchObject(sources.map((source) => omit(source, ['_rev'])))
+
+  await expect(tieDao.all()).resolves.toMatchObject(
+    ties.map(({ switchId, ...tie }) => omit({ ...tie, deviceId: switchId }, ['_rev']))
+  )
+
+  await deviceDao.close()
+  await sourceDao.close()
+  await tieDao.close()
+})
+
+test('rerun migration', async () => {
+  vi.resetModules()
+
+  const { default: useMigrations } = await import('../../../main/services/migration')
+
+  const migrate = useMigrations()
+  await expect(migrate()).resolves.toBeUndefined()
+})
diff --git a/src/tests/main/services/startup.test.ts b/src/tests/main/services/startup.test.ts
index b3c5a0e..e57fc5a 100644
--- a/src/tests/main/services/startup.test.ts
+++ b/src/tests/main/services/startup.test.ts
@@ -17,6 +17,7 @@ beforeAll(() => {
   vi.mock('node:os', () => ({
     homedir: () => '/home/user'
   }))
+  // Disable memoize caching.
   vi.mock('radash', async (original) => ({
     ...(await original()),
     memo: (x: unknown) => x
diff --git a/src/tests/seeds/database.seed.ts b/src/tests/seeds/database.seed.ts
index bd4ee4e..49a0381 100644
--- a/src/tests/seeds/database.seed.ts
+++ b/src/tests/seeds/database.seed.ts
@@ -1,22 +1,22 @@
 import { alphabetical, map } from 'radash'
+import useDevicesDatabase from '../../main/dao/devices'
 import useSourcesDatabase from '../../main/dao/sources'
-import useSwitchesDatabase from '../../main/dao/switches'
 import useTiesDatabase from '../../main/dao/ties'
 import useDrivers from '../../main/services/drivers'
+import type { Device } from '../../main/dao/devices'
 import type { Source } from '../../main/dao/sources'
-import type { Switch } from '../../main/dao/switches'
 import type { Tie } from '../../main/dao/ties'
 import { Attachment } from '@/attachments'
 import { raiseError } from '@/error-handling'
 
 export async function seedDatabase() {
-  const switchDao = useSwitchesDatabase()
-  const sourceDao = useSourcesDatabase()
-  const tieDao = useTiesDatabase()
+  const devicesDao = useDevicesDatabase()
+  const sourcesDao = useSourcesDatabase()
+  const tiesDao = useTiesDatabase()
 
-  await switchDao.clear()
-  await sourceDao.clear()
-  await tieDao.clear()
+  await devicesDao.clear()
+  await sourcesDao.clear()
+  await tiesDao.clear()
 
   const drivers = await useDrivers().registered()
   const extronSis =
@@ -26,14 +26,14 @@ export async function seedDatabase() {
     drivers.find((driver) => driver.guid === '8626D6D3-C211-4D21-B5CC-F5E3B50D9FF0') ??
     raiseError(() => new ReferenceError('Sony RS485 driver not registered'))
 
-  const switches = (await map(
+  const devices = (await map(
     [
       { title: 'Extron RGBHVA 128plus', driverId: extronSis.guid, path: 'port:/dev/ttys0' },
       { title: 'Extron HDMI 84pro', driverId: extronSis.guid, path: 'ip:192.168.10.2' },
       { title: 'Sony BVM24D', driverId: sonyRemote.guid, path: 'port:/dev/ttys1' }
     ],
-    async (doc) => await switchDao.add(doc)
-  )) as [Switch, Switch, Switch]
+    async (doc) => await devicesDao.add(doc)
+  )) as [Device, Device, Device]
 
   const file = new File([Buffer.from('test')], 'test.txt', { type: 'text/plain' })
   const image = await Attachment.fromFile(file)
@@ -44,34 +44,34 @@ export async function seedDatabase() {
       { title: 'SNES', image: image.name },
       { title: 'N64', image: image.name }
     ],
-    async (doc) => await sourceDao.add(doc, image)
+    async (doc) => await sourcesDao.add(doc, image)
   )) as [Source, Source, Source]
 
   const ties = (await map(
     [
       // NES
-      { sourceId: sources[0]._id, switchId: switches[0]._id, inputChannel: 1, outputChannels: { video: 1 } },
-      { sourceId: sources[0]._id, switchId: switches[2]._id, inputChannel: 1, outputChannels: {} },
+      { sourceId: sources[0]._id, deviceId: devices[0]._id, inputChannel: 1, outputChannels: { video: 1 } },
+      { sourceId: sources[0]._id, deviceId: devices[2]._id, inputChannel: 1, outputChannels: {} },
       // SNES (HDMI FGPA clone)
-      { sourceId: sources[1]._id, switchId: switches[1]._id, inputChannel: 1, outputChannels: { video: 1 } },
-      { sourceId: sources[1]._id, switchId: switches[2]._id, inputChannel: 2, outputChannels: {} },
+      { sourceId: sources[1]._id, deviceId: devices[1]._id, inputChannel: 1, outputChannels: { video: 1 } },
+      { sourceId: sources[1]._id, deviceId: devices[2]._id, inputChannel: 2, outputChannels: {} },
       // N64
-      { sourceId: sources[2]._id, switchId: switches[0]._id, inputChannel: 2, outputChannels: { video: 1 } },
-      { sourceId: sources[2]._id, switchId: switches[2]._id, inputChannel: 1, outputChannels: {} }
+      { sourceId: sources[2]._id, deviceId: devices[0]._id, inputChannel: 2, outputChannels: { video: 1 } },
+      { sourceId: sources[2]._id, deviceId: devices[2]._id, inputChannel: 1, outputChannels: {} }
     ],
-    async (doc) => await tieDao.add(doc)
+    async (doc) => await tiesDao.add(doc)
   )) as [Tie, Tie, Tie, Tie, Tie, Tie]
 
   return {
     // DAOs
-    switchDao,
-    sourceDao,
-    tieDao,
+    devicesDao,
+    sourcesDao,
+    tiesDao,
     // Drivers
     extronSis,
     sonyRemote,
     // Added documents
-    switches: alphabetical(switches, (item) => item._id) as typeof switches,
+    devices: alphabetical(devices, (item) => item._id) as typeof devices,
     sources: alphabetical(sources, (item) => item._id) as typeof sources,
     ties: alphabetical(ties, (item) => item._id) as typeof ties
   }
diff --git a/src/tests/seeds/migration.seed.ts b/src/tests/seeds/migration.seed.ts
new file mode 100644
index 0000000..504993c
--- /dev/null
+++ b/src/tests/seeds/migration.seed.ts
@@ -0,0 +1,142 @@
+import { alphabetical, map } from 'radash'
+import { z } from 'zod'
+import { Database } from '../../main/services/database'
+import useDrivers from '../../main/services/drivers'
+import { useLevelDb } from '../../main/services/level'
+import type { inferDocumentOf } from '../../main/services/database'
+import { Attachment } from '@/attachments'
+import { raiseError } from '@/error-handling'
+
+export async function seedForMigration() {
+  //
+  // Migration database must be clean.
+  //
+
+  const migrationDb = await useLevelDb().levelup('_migrations')
+  await migrationDb.clear()
+  await migrationDb.close()
+
+  //
+  // Original, v1, models.
+  //
+
+  const DocumentId = z
+    .string()
+    .uuid()
+    .transform((value) => value.toUpperCase())
+
+  type Switch = inferDocumentOf<typeof SwitchModel>
+  const SwitchModel = z.object({
+    driverId: DocumentId,
+    title: z.string().min(1),
+    path: z.string().min(1)
+  })
+
+  type Source = inferDocumentOf<typeof SourceModel>
+  const SourceModel = z.object({
+    title: z.string().min(1),
+    image: z.string().min(1).nullable()
+  })
+
+  type Tie = inferDocumentOf<typeof TieModel>
+  const TieModel = z.object({
+    sourceId: DocumentId,
+    switchId: DocumentId,
+    inputChannel: z.number().int().nonnegative(),
+    outputChannels: z.object({
+      video: z.number().int().nonnegative().optional(),
+      audio: z.number().int().nonnegative().optional()
+    })
+  })
+
+  //
+  // Original, v1 databases.
+  //
+  // These should be closed once seeded.
+
+  const switchesDb = new Database('switches', SwitchModel)
+  const sourcesDb = new Database('sources', SourceModel)
+  const tiesDb = new Database('ties', TieModel)
+
+  await switchesDb.clear()
+  await sourcesDb.clear()
+  await tiesDb.clear()
+
+  //
+  // Intermediate databases.
+  //
+  // When other databases that could exist that become
+  // intermediaries to the current.
+  //
+  // These should be closed once cleared.
+
+  //
+  // Current databases
+  //
+  // These should be closed once cleaned.
+
+  const UnknownModel = z.object({})
+
+  const devicesDb = new Database('devices', UnknownModel)
+
+  await devicesDb.clear()
+  await devicesDb.close()
+
+  const drivers = await useDrivers().registered()
+  const extronSis =
+    drivers.find((driver) => driver.guid === '4C8F2838-C91D-431E-84DD-3666D14A6E2C') ??
+    raiseError(() => new ReferenceError('Extron SIS driver not registered'))
+  const sonyRemote =
+    drivers.find((driver) => driver.guid === '8626D6D3-C211-4D21-B5CC-F5E3B50D9FF0') ??
+    raiseError(() => new ReferenceError('Sony RS485 driver not registered'))
+
+  const switches = (await map(
+    [
+      { title: 'Extron RGBHVA 128plus', driverId: extronSis.guid, path: 'port:/dev/ttys0' },
+      { title: 'Extron HDMI 84pro', driverId: extronSis.guid, path: 'ip:192.168.10.2' },
+      { title: 'Sony BVM24D', driverId: sonyRemote.guid, path: 'port:/dev/ttys1' }
+    ],
+    async (doc) => await switchesDb.add(doc)
+  )) as [Switch, Switch, Switch]
+
+  const file = new File([Buffer.from('test')], 'test.txt', { type: 'text/plain' })
+  const image = await Attachment.fromFile(file)
+
+  const sources = (await map(
+    [
+      { title: 'NES', image: image.name },
+      { title: 'SNES', image: image.name },
+      { title: 'N64', image: image.name }
+    ],
+    async (doc) => await sourcesDb.add(doc, image)
+  )) as [Source, Source, Source]
+
+  const ties = (await map(
+    [
+      // NES
+      { sourceId: sources[0]._id, switchId: switches[0]._id, inputChannel: 1, outputChannels: { video: 1 } },
+      { sourceId: sources[0]._id, switchId: switches[2]._id, inputChannel: 1, outputChannels: {} },
+      // SNES (HDMI FGPA clone)
+      { sourceId: sources[1]._id, switchId: switches[1]._id, inputChannel: 1, outputChannels: { video: 1 } },
+      { sourceId: sources[1]._id, switchId: switches[2]._id, inputChannel: 2, outputChannels: {} },
+      // N64
+      { sourceId: sources[2]._id, switchId: switches[0]._id, inputChannel: 2, outputChannels: { video: 1 } },
+      { sourceId: sources[2]._id, switchId: switches[2]._id, inputChannel: 1, outputChannels: {} }
+    ],
+    async (doc) => await tiesDb.add(doc)
+  )) as [Tie, Tie, Tie, Tie, Tie, Tie]
+
+  await switchesDb.close()
+  await sourcesDb.close()
+  await tiesDb.close()
+
+  return {
+    // Drivers
+    extronSis,
+    sonyRemote,
+    // Added documents
+    switches: alphabetical(switches, (item) => item._id) as typeof switches,
+    sources: alphabetical(sources, (item) => item._id) as typeof sources,
+    ties: alphabetical(ties, (item) => item._id) as typeof ties
+  }
+}
diff --git a/yarn.lock b/yarn.lock
index 866b5e7..948c71b 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4153,11 +4153,6 @@ jake@^10.8.5:
     filelist "^1.0.4"
     minimatch "^3.1.2"
 
-js-base64@^3.7.7:
-  version "3.7.7"
-  resolved "https://registry.yarnpkg.com/js-base64/-/js-base64-3.7.7.tgz#e51b84bf78fbf5702b9541e2cb7bfcb893b43e79"
-  integrity sha512-7rCnleh0z2CkXhH67J8K1Ytz0b2Y+yxTPL+/KOJoa20hfnVQ/3/T6W/KflYI4bRHRagNeXeU2bkNGI3v1oS/lw==
-
 js-tokens@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"