diff --git a/.gitignore b/.gitignore
index 5a3e46ad..9882c7e2 100755
--- a/.gitignore
+++ b/.gitignore
@@ -29,3 +29,9 @@ auth.json
 !.yarn/versions
 
 *.d.ts
+
+# Local development data profiles
+.dev-profiles/
+
+# End-to-end test output
+e2e/.output/
diff --git a/.node-version b/.node-version
new file mode 100644
index 00000000..df6ae337
--- /dev/null
+++ b/.node-version
@@ -0,0 +1 @@
+24.21.0
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
new file mode 100644
index 00000000..e9cdfe86
--- /dev/null
+++ b/DEVELOPMENT.md
@@ -0,0 +1,188 @@
+# Local Development
+
+This guide tells you how to build and start Knowledge on your computer.
+You do not need AWS, an Apple developer account, or an AI API key.
+
+## Toolchain
+
+| Tool | Version | Notes |
+| --- | --- | --- |
+| macOS | 26.6 (arm64) | Verified. Linux and Windows are not verified. |
+| Node.js | 24.21.0 | Verified. See the compatibility note below. |
+| Yarn | 3.2.4 | The repository contains this version (`.yarnrc.yml` `yarnPath`). Any global `yarn` starts it. |
+| Electron | 26.3.0 | Installed by Yarn. |
+
+No native compiler is necessary. The install does not build `canvas`.
+
+Compatibility note: Angular 14 officially supports Node.js 14.15+ and 16.10+ only.
+Node.js 24 builds and runs this branch, but it is outside the official range.
+Electron 26 is end-of-life. Upgrade these in a separate step.
+
+## Setup
+
+```sh
+yarn install --immutable
+yarn build-dev
+yarn start
+```
+
+`yarn start-dev` does the build and the start in one command.
+
+## Instances and local servers
+
+Each instance starts its own chat server on a random loopback port. Each
+server requires a random token. The renderer receives the address and the
+token through IPC (`A2E:Backend:Info`). One instance cannot use the server of
+another instance.
+
+Only one instance can use a profile at a time. A second start with the same
+profile prints a message and exits. Different profiles can run at the same time.
+
+## Data profiles
+
+A development run never uses your normal Knowledge data.
+
+| Start condition | Data location |
+| --- | --- |
+| Unpackaged, `KC_PROFILE_DIR` not set | `<repo>/.dev-profiles/dev` |
+| `KC_PROFILE_DIR=<path>` | `<path>` |
+| `KC_PROFILE_DIR=system` | Normal per-user locations (see below) |
+| Packaged build, `KC_PROFILE_DIR` not set | Normal per-user locations |
+
+A profile contains these directories:
+
+| Directory | Contents |
+| --- | --- |
+| `userData` | Chromium storage: local storage (projects, sources, chat history), cache, cookies |
+| `data` | Source text cache (`storage/sources`), OpenAI key file, temporary files |
+| `settings` | `knowledge.settings.json` |
+| `downloads` | Default save location. The autoscan folder is `downloads/Knowledge`. |
+
+To start with an empty profile:
+
+```sh
+KC_PROFILE_DIR=/tmp/kc-empty yarn start
+```
+
+To delete the default development profile, delete `.dev-profiles/`.
+Git ignores this directory.
+
+Caution: `KC_PROFILE_DIR=system` uses your real data. Autoscan can move files
+out of the autoscan folder. Make a backup first.
+
+### Normal per-user locations (macOS)
+
+| Data | Location |
+| --- | --- |
+| Chromium storage | `~/Library/Application Support/knowledge-canvas` |
+| Settings | `~/Library/Preferences/Knowledge/knowledge.settings.json` |
+| Source text cache, API key | `~/.Knowledge` |
+| Autoscan folder | `~/Downloads/Knowledge` |
+
+Do not confuse `~/Library/Application Support/Knowledge`. macOS owns that
+directory (`knowledgeC.db`). Knowledge does not use it.
+
+## Tests
+
+Unit tests (Node.js 22.18 or later):
+
+```sh
+yarn test
+```
+
+These check backup and restore, and profile path isolation.
+
+End-to-end tests (macOS):
+
+```sh
+yarn build-dev
+yarn e2e
+```
+
+The end-to-end tests start the real app with new, empty profiles in
+`e2e/.output/<run>/`. They never use your normal profile. They do these checks:
+
+- `e2e/workflow.e2e.mjs`: create a project, save a link (local fixture site),
+  import a PDF and a text file, annotate, search, restart, export a backup,
+  and restore it into a second profile.
+- `e2e/isolation.e2e.mjs`: two profiles at the same time get different server
+  addresses and tokens. Each instance rejects the other instance's requests.
+  A second start of the same profile exits.
+
+Test files are in `e2e/fixtures/`. To delete old test output, delete
+`e2e/.output/`.
+
+To explore the UI by hand, use the interactive driver:
+
+```sh
+node e2e/drive.mjs /tmp/kc-explore 7777
+curl -s -X POST http://127.0.0.1:7777 -d '{"op":"launch"}'
+curl -s -X POST http://127.0.0.1:7777 -d '{"op":"shot","name":"home"}'
+curl -s -X POST http://127.0.0.1:7777 -d '{"op":"close"}'
+```
+
+## Current limits
+
+- Annotations are topics and metadata entries (tag and value). The app has
+  no notes editor.
+- Search uses titles, topics, descriptions, and source type. It does not
+  search file content.
+- A backup does not include imported files.
+- File sources keep the absolute path of the original file. After a restore,
+  file sources work only if the original files are still at those paths.
+- Signed and notarized releases are not verified.
+- AI chat with a real API key is not verified.
+- Only macOS is verified.
+
+## Optional services
+
+| Service | Default | How to enable |
+| --- | --- | --- |
+| AI chat (OpenAI) | Off | Open the Chat tab of a source. Enter a key in the dialog. |
+| Update check | Off | Packaged build only. Set `KC_ENABLE_UPDATES=1`. The update feed (S3) does not exist now. |
+| Browser extension server | Off | Settings > Import. Uses port 9000. |
+| Autoscan | Off | Settings > Import. |
+
+Without an API key, all source management works. Chat, summaries, and
+AI topics do not work. The app shows an API key dialog.
+
+The key file (`openai.encrypted`) uses a fixed passphrase. Treat it as
+plain text.
+
+## Backup and restore
+
+Use Settings > Backup.
+
+A backup contains all renderer local storage:
+
+- Projects and their sources
+- Source topics and metadata annotations
+- Chat history
+- The inbox
+- Theme and table preferences
+
+A backup does not contain:
+
+- Settings (`knowledge.settings.json`)
+- Imported files. File sources keep the absolute path of the original file.
+- The source text cache. The app extracts the text again when necessary.
+- The API key
+
+Restore merges the project list and replaces items that have the same ID.
+The app reloads after a restore. Restore accepts only files that Settings >
+Backup made (`format: knowledge-backup`, version 1).
+
+## Packaging
+
+```sh
+CSC_IDENTITY_AUTO_DISCOVERY=false yarn run pack
+```
+
+Use `yarn run pack`. The command `yarn pack` is a Yarn built-in. It makes an
+npm archive and does not start electron-builder.
+
+The result is an unsigned app in `dist/mac-arm64`. Notarization starts only
+when `APPLEID`, `APPLEPWD`, and `TEAMID` are set. Signing needs a valid
+Developer ID certificate.
+
+Do not use `yarn publish`. Its target S3 bucket does not exist.
diff --git a/README.md b/README.md
index aa9b43b8..91192a09 100755
--- a/README.md
+++ b/README.md
@@ -36,6 +36,7 @@ Unleash the power of context with the built-in Chromium browser (just like Googl
   Knowledge application more efficiently.
 - [Feature Roadmap](https://github.com/KnowledgeCanvas/knowledge/wiki/Feature-Roadmap): A list of existing and planned
   features.
+- [Local Development](DEVELOPMENT.md): Build and start Knowledge from source, with an isolated data profile.
 - [Developer Guide](https://github.com/KnowledgeCanvas/knowledge/wiki/Development): Interested in contributing to
   Knowledge? Check here first!
 - [Debug Guide](https://github.com/KnowledgeCanvas/knowledge/wiki/Debugging): Something not working? Check here for
diff --git a/Resources/notarize.js b/Resources/notarize.js
index 8b5d68a4..3e911a92 100644
--- a/Resources/notarize.js
+++ b/Resources/notarize.js
@@ -28,6 +28,13 @@ exports.default = async function notarizing(context) {
   const password = process.env.APPLEPWD;
   const teamId = process.env.TEAMID;
 
+  if (!appleId || !password || !teamId) {
+    console.log(
+      "Skipping notarization: set APPLEID, APPLEPWD and TEAMID to notarize."
+    );
+    return;
+  }
+
   return await notarize({
     appBundleId: "com.knowledge.canvas.app",
     appPath: `${appOutDir}/${appName}.app`,
diff --git a/e2e/drive.mjs b/e2e/drive.mjs
new file mode 100644
index 00000000..21635b41
--- /dev/null
+++ b/e2e/drive.mjs
@@ -0,0 +1,97 @@
+/*
+ * Interactive driver for manual exploration.
+ *
+ *   node e2e/drive.mjs <profileDir> [port]
+ *   curl -s -X POST http://127.0.0.1:7777 -d '{"op":"launch"}'
+ *
+ * Operations: launch, close, eval {js}, main {js}, click {sel,nth},
+ * dblclick {sel,nth}, fill {sel,value}, press {sel,key}, files {sel,paths},
+ * text {sel}, shot {name}, wait {ms}.
+ * Screenshots and the app log go into the profile directory.
+ */
+
+import http from "node:http";
+import path from "node:path";
+import { close, launch, shot } from "./lib.mjs";
+
+const profile = process.argv[2] && path.resolve(process.argv[2]);
+const port = Number(process.argv[3] || 7777);
+if (!profile) {
+  console.error("Usage: node e2e/drive.mjs <profileDir> [port]");
+  process.exit(1);
+}
+
+let ctx = null;
+async function page() {
+  if (!ctx) {
+    ctx = await launch(profile, path.join(profile, "app.log"));
+  }
+  return ctx.page;
+}
+
+const ops = {
+  launch: async () => ({ url: (await page()).url() }),
+  close: async () => {
+    if (ctx) {
+      await close(ctx);
+      ctx = null;
+    }
+    return { closed: true };
+  },
+  eval: async ({ js }) => ({ value: await (await page()).evaluate(js) }),
+  main: async ({ js }) => {
+    await page();
+    const fn = new Function("electron", `return (async () => { ${js} })()`);
+    return { value: await ctx.app.evaluate(fn) };
+  },
+  click: async ({ sel, nth = 0 }) => {
+    await (await page()).locator(sel).nth(nth).click({ timeout: 10000 });
+    return { ok: true };
+  },
+  dblclick: async ({ sel, nth = 0 }) => {
+    await (await page()).locator(sel).nth(nth).dblclick({ timeout: 10000 });
+    return { ok: true };
+  },
+  fill: async ({ sel, value, nth = 0 }) => {
+    await (await page()).locator(sel).nth(nth).fill(value, { timeout: 10000 });
+    return { ok: true };
+  },
+  press: async ({ sel, key, nth = 0 }) => {
+    await (await page()).locator(sel).nth(nth).press(key);
+    return { ok: true };
+  },
+  files: async ({ sel, paths, nth = 0 }) => {
+    await (await page()).locator(sel).nth(nth).setInputFiles(paths);
+    return { ok: true };
+  },
+  text: async ({ sel = "body" }) => ({
+    value: (await (await page()).locator(sel).first().innerText()).slice(
+      0,
+      4000
+    ),
+  }),
+  shot: async ({ name }) => ({ file: await shot(await page(), profile, name) }),
+  wait: async ({ ms }) => {
+    await new Promise((r) => setTimeout(r, ms));
+    return { ok: true };
+  },
+};
+
+http
+  .createServer(async (req, res) => {
+    let body = "";
+    for await (const chunk of req) body += chunk;
+    try {
+      const cmd = JSON.parse(body || "{}");
+      if (!ops[cmd.op]) throw new Error(`Unknown op: ${cmd.op}`);
+      res.end(JSON.stringify(await ops[cmd.op](cmd)));
+    } catch (e) {
+      res.statusCode = 500;
+      res.end(
+        JSON.stringify({ error: String(e?.message ?? e).slice(0, 2000) })
+      );
+    }
+  })
+  .listen(port, "127.0.0.1", () => {
+    console.log(`Driver on http://127.0.0.1:${port} (profile ${profile})`);
+  });
diff --git a/e2e/fixtures/recovery-fixture.pdf b/e2e/fixtures/recovery-fixture.pdf
new file mode 100644
index 00000000..efaea4c5
Binary files /dev/null and b/e2e/fixtures/recovery-fixture.pdf differ
diff --git a/e2e/fixtures/recovery-note.txt b/e2e/fixtures/recovery-note.txt
new file mode 100644
index 00000000..1bed69ac
--- /dev/null
+++ b/e2e/fixtures/recovery-note.txt
@@ -0,0 +1,3 @@
+Knowledge recovery test note.
+The quick brown fox studies photosynthesis and chlorophyll.
+Unique marker: zebrafish-lattice-42
diff --git a/e2e/fixtures/site/index.html b/e2e/fixtures/site/index.html
new file mode 100644
index 00000000..a89b551c
--- /dev/null
+++ b/e2e/fixtures/site/index.html
@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Knowledge Fixture Site</title>
+    <meta name="description" content="Local page for Knowledge end-to-end tests." />
+    <meta name="keywords" content="fixture,testing" />
+  </head>
+  <body>
+    <article>
+      <h1>Knowledge Fixture Site</h1>
+      <p>Unique marker: heron-cascade-19</p>
+    </article>
+  </body>
+</html>
diff --git a/e2e/isolation.e2e.mjs b/e2e/isolation.e2e.mjs
new file mode 100644
index 00000000..22de334a
--- /dev/null
+++ b/e2e/isolation.e2e.mjs
@@ -0,0 +1,96 @@
+/*
+ * Instance isolation. Two profiles run at the same time. Each renderer
+ * must reach only its own local server. A second launch of the same
+ * profile must exit.
+ *
+ * Run: yarn build-dev && yarn e2e
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import CryptoJS from "crypto-js";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { ELECTRON, REPO, appEnv, close, launch, newRun } from "./lib.mjs";
+
+function backendInfo(page) {
+  return page.evaluate(() => window.api.invoke("A2E:Backend:Info"));
+}
+
+function callChat(page, url, token) {
+  return page.evaluate(
+    async ({ url, token }) => {
+      const headers = token ? { Authorization: `Bearer ${token}` } : {};
+      const res = await fetch(`${url}/api/key`, { headers });
+      return { status: res.status, body: await res.text() };
+    },
+    { url, token }
+  );
+}
+
+test(
+  "two profiles get separate servers and cannot use each other's",
+  { timeout: 180000 },
+  async () => {
+    const run = newRun("isolation");
+    const profileA = path.join(run, "profile-a");
+    const profileB = path.join(run, "profile-b");
+    const log = path.join(run, "app.log");
+
+    // Profile A has an API key file. Profile B has none.
+    fs.mkdirSync(path.join(profileA, "data"), { recursive: true });
+    fs.writeFileSync(
+      path.join(profileA, "data", "openai.encrypted"),
+      CryptoJS.AES.encrypt("sk-dummy-profile-a", "unsecured").toString()
+    );
+
+    const a = await launch(profileA, log);
+    const b = await launch(profileB, log);
+    try {
+      const infoA = await backendInfo(a.page);
+      const infoB = await backendInfo(b.page);
+
+      assert.match(infoA.chat.url, /^http:\/\/127\.0\.0\.1:\d+$/);
+      assert.match(infoB.chat.url, /^http:\/\/127\.0\.0\.1:\d+$/);
+      assert.notEqual(infoA.chat.url, infoB.chat.url);
+      assert.notEqual(infoA.chat.token, infoB.chat.token);
+
+      // Each renderer reaches its own server with its own token
+      const ownA = await callChat(a.page, infoA.chat.url, infoA.chat.token);
+      assert.equal(ownA.status, 200, ownA.body);
+      assert.equal(JSON.parse(ownA.body).apiKeySet, true);
+      const ownB = await callChat(b.page, infoB.chat.url, infoB.chat.token);
+      assert.equal(ownB.status, 200, ownB.body);
+      assert.equal(JSON.parse(ownB.body).apiKeySet, false);
+
+      // B cannot use A's server: no token, or B's token, gives 401
+      assert.equal((await callChat(b.page, infoA.chat.url)).status, 401);
+      assert.equal(
+        (await callChat(b.page, infoA.chat.url, infoB.chat.token)).status,
+        401
+      );
+
+      // A second launch of profile A exits and leaves the first instance running
+      const second = spawnSync(ELECTRON, [REPO], {
+        cwd: REPO,
+        env: { ...appEnv(), KC_PROFILE_DIR: profileA },
+        encoding: "utf8",
+        timeout: 30000,
+      });
+      assert.equal(
+        second.status,
+        0,
+        `second instance did not exit: ${second.signal}`
+      );
+      assert.match(
+        second.stdout + second.stderr,
+        /already open in another instance/
+      );
+      assert.equal(a.app.windows().length, 1);
+    } finally {
+      await close(b);
+      await close(a);
+    }
+  }
+);
diff --git a/e2e/lib.mjs b/e2e/lib.mjs
new file mode 100644
index 00000000..35aae002
--- /dev/null
+++ b/e2e/lib.mjs
@@ -0,0 +1,144 @@
+/*
+ * Launch helpers for driving Knowledge with isolated data profiles.
+ *
+ * Every launch sets KC_PROFILE_DIR. These helpers never use the normal
+ * per-user profile. Output (profiles, logs, screenshots) goes to
+ * e2e/.output/<run>, which Git ignores.
+ */
+
+import { _electron as electron } from "playwright-core";
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+
+export const REPO = path.resolve(import.meta.dirname, "..");
+export const FIXTURES = path.join(REPO, "e2e", "fixtures");
+
+export const ELECTRON = path.join(
+  REPO,
+  "node_modules/electron/dist/Electron.app/Contents/MacOS/Electron"
+);
+
+/**
+ * Environment for the app. The Node test runner sets NODE_TEST_CONTEXT in
+ * child processes. Electron's Node must not see it, or startup stalls.
+ */
+export function appEnv() {
+  const env = { ...process.env };
+  delete env.NODE_TEST_CONTEXT;
+  delete env.NODE_OPTIONS;
+  return env;
+}
+
+/** Create an empty output directory for one test run. */
+export function newRun(name) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const dir = path.join(REPO, "e2e", ".output", `${name}-${stamp}`);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** Launch the app with the given profile directory. */
+export async function launch(profileDir, logFile, env = {}) {
+  if (!profileDir) {
+    throw new Error("launch() needs an explicit profile directory");
+  }
+  const log = fs.createWriteStream(logFile, { flags: "a" });
+  const app = await electron.launch({
+    executablePath: ELECTRON,
+    args: [REPO],
+    cwd: REPO,
+    env: { ...appEnv(), ...env, KC_PROFILE_DIR: profileDir },
+    timeout: 60000,
+  });
+  app.process().stdout?.on("data", (d) => log.write(`[main] ${d}`));
+  app.process().stderr?.on("data", (d) => log.write(`[main:err] ${d}`));
+  const page = await app.firstWindow();
+  page.on("console", (m) => log.write(`[renderer:${m.type()}] ${m.text()}\n`));
+  page.on("pageerror", (e) => log.write(`[renderer:pageerror] ${e.message}\n`));
+  await page.waitForSelector("app-create button", { timeout: 30000 });
+  return { app, page, log };
+}
+
+export async function close(ctx) {
+  await ctx.app.close();
+  ctx.log.end();
+}
+
+export async function shot(page, dir, name) {
+  const file = path.join(dir, `${name}.png`);
+  await page.screenshot({ path: file });
+  return file;
+}
+
+/** Save every download from this window into dir. */
+export async function captureDownloads(app, dir) {
+  await app.evaluate(({ BrowserWindow }, target) => {
+    const session = BrowserWindow.getAllWindows()[0].webContents.session;
+    session.removeAllListeners("will-download");
+    session.on("will-download", (_event, item) => {
+      item.setSavePath(`${target}/${item.getFilename()}`);
+    });
+  }, dir);
+}
+
+/** Wait until a file exists and has stopped growing. */
+export async function waitForFile(file, timeout = 15000) {
+  const end = Date.now() + timeout;
+  let last = -1;
+  while (Date.now() < end) {
+    if (fs.existsSync(file)) {
+      const size = fs.statSync(file).size;
+      if (size > 0 && size === last) {
+        return file;
+      }
+      last = size;
+    }
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  throw new Error(`File did not appear: ${file}`);
+}
+
+/** Serve e2e/fixtures/site on an ephemeral loopback port. */
+export async function startFixtureSite() {
+  const root = path.join(FIXTURES, "site");
+  const server = http.createServer((req, res) => {
+    const name =
+      path.basename(new URL(req.url, "http://x").pathname) || "index.html";
+    const file = path.join(root, name);
+    if (!fs.existsSync(file)) {
+      res.statusCode = 404;
+      return res.end();
+    }
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    fs.createReadStream(file).pipe(res);
+  });
+  await new Promise((r) => server.listen(0, "127.0.0.1", r));
+  const { port } = server.address();
+  return {
+    url: `http://127.0.0.1:${port}/index.html`,
+    close: () => server.close(),
+  };
+}
+
+/** Read projects and their sources as the renderer sees them. */
+export async function readLibrary(page) {
+  return page.evaluate(() => {
+    const ids = JSON.parse(localStorage.getItem("kc-projects") ?? "[]");
+    return ids.map((id) => {
+      const p = JSON.parse(localStorage.getItem(id));
+      return {
+        id,
+        name: p.name,
+        sources: p.knowledgeSource.map((k) => ({
+          title: k.title,
+          type: k.ingestType,
+          topics: k.topics ?? [],
+          annotations: (k.meta ?? [])
+            .filter((m) => m.key === "annotation")
+            .map((m) => m.value),
+        })),
+      };
+    });
+  });
+}
diff --git a/e2e/steps.mjs b/e2e/steps.mjs
new file mode 100644
index 00000000..1d872248
--- /dev/null
+++ b/e2e/steps.mjs
@@ -0,0 +1,128 @@
+/*
+ * User-level steps for the Knowledge UI. Each step uses the visible
+ * controls a person would use.
+ */
+
+const TIMEOUT = 15000;
+
+export async function createProject(page, name, description = "") {
+  await page.locator("button.create-project").click();
+  const dialog = page
+    .locator(".p-dialog")
+    .filter({ hasText: "Create Project" });
+  await dialog.locator("input").first().fill(name);
+  if (description) {
+    await dialog.locator("textarea").fill(description);
+  }
+  await dialog.locator("button", { hasText: "Create" }).click();
+  await page
+    .locator("p-tree, .p-tree")
+    .getByText(name, { exact: true })
+    .first()
+    .waitFor({ timeout: TIMEOUT });
+}
+
+/** Add a website through the Web Import dialog into the current project. */
+export async function addLinkToProject(page, url, expectedTitle) {
+  await page.locator("app-create button").nth(2).click();
+  const input = page.locator("app-import-web input#linkInput");
+  await input.fill(url);
+  await input.press("Enter");
+  await page
+    .locator("app-import-web table input")
+    .first()
+    .waitFor({ timeout: TIMEOUT });
+  if (expectedTitle) {
+    await page.waitForFunction(
+      (title) =>
+        [...document.querySelectorAll("app-import-web table input")].some(
+          (i) => i.value === title
+        ),
+      expectedTitle,
+      { timeout: TIMEOUT }
+    );
+  }
+  await page
+    .locator("app-import-web p-selectbutton .p-button", { hasText: "Project" })
+    .click();
+  await page.locator("app-import-web button", { hasText: "Import" }).click();
+}
+
+/** Import files into the Inbox, then move all Inbox items to the current project. */
+export async function importFilesToProject(page, files) {
+  await page.locator("app-create input[type=file]").setInputFiles(files);
+  for (const file of files) {
+    const name = file.split("/").pop();
+    await page.getByText(name).first().waitFor({ timeout: TIMEOUT });
+  }
+  await page.getByText("Import All").click();
+  await page.locator("button", { hasText: "Import" }).first().click();
+}
+
+export async function openTable(page) {
+  await page.locator("i.pi-table").first().click();
+  await page
+    .locator("app-ks-table, p-table")
+    .first()
+    .waitFor({ timeout: TIMEOUT });
+}
+
+export async function tableTitles(page) {
+  return page.locator("p-table tbody tr td:nth-child(3)").allInnerTexts();
+}
+
+export async function openSource(page, title) {
+  await page.getByText(title, { exact: true }).first().dblclick();
+  await page
+    .locator(".p-dialog, app-source")
+    .getByText(title)
+    .first()
+    .waitFor({ timeout: TIMEOUT });
+}
+
+export async function closeDialog(page) {
+  await page.keyboard.press("Escape");
+  await page.waitForTimeout(500);
+}
+
+export async function addAnnotation(page, key, value) {
+  await page.locator('input[placeholder="Tag"]').fill(key);
+  const valueInput = page.locator('input[placeholder="Value"]');
+  await valueInput.fill(value);
+  await valueInput.press("Enter");
+}
+
+export async function addTopic(page, topic) {
+  const input = page.locator(
+    'input[placeholder="Start typing to add a topic..."]'
+  );
+  await input.fill(topic);
+  await input.press("Enter");
+}
+
+export async function openDocumentTab(page) {
+  await page.getByText("Document", { exact: true }).click();
+}
+
+/** Type into the global search box and return the suggestion texts. */
+export async function search(page, query) {
+  const input = page.locator("input.p-autocomplete-input");
+  await input.click();
+  await input.fill("");
+  await input.type(query, { delay: 30 });
+  await page
+    .locator(".p-autocomplete-panel li")
+    .first()
+    .waitFor({ timeout: TIMEOUT });
+  await page.waitForTimeout(500);
+  return page
+    .locator(".p-autocomplete-panel li")
+    .evaluateAll((items) =>
+      items.map((i) => i.innerText.replace(/\s+/g, " ").trim())
+    );
+}
+
+export async function openSettings(page, section) {
+  await page.locator("i.pi-cog").first().click();
+  await page.locator(".p-menuitem-link", { hasText: section }).click();
+}
diff --git a/e2e/workflow.e2e.mjs b/e2e/workflow.e2e.mjs
new file mode 100644
index 00000000..40e08786
--- /dev/null
+++ b/e2e/workflow.e2e.mjs
@@ -0,0 +1,130 @@
+/*
+ * Basic local workflow on fresh, isolated profiles:
+ * create a project, save a link, import a PDF and a text file, annotate,
+ * search, restart, export a backup, and restore it into a second profile.
+ *
+ * Run: yarn build-dev && yarn e2e
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import {
+  FIXTURES,
+  captureDownloads,
+  close,
+  launch,
+  newRun,
+  readLibrary,
+  shot,
+  startFixtureSite,
+  waitForFile,
+} from "./lib.mjs";
+import * as ui from "./steps.mjs";
+
+const PDF = path.join(FIXTURES, "recovery-fixture.pdf");
+const TXT = path.join(FIXTURES, "recovery-note.txt");
+const PROJECT = "Recovery Project";
+const SITE_TITLE = "Knowledge Fixture Site";
+
+const expected = [
+  { title: SITE_TITLE, type: "website" },
+  { title: "recovery-fixture.pdf", type: "file" },
+  { title: "recovery-note.txt", type: "file" },
+];
+
+test(
+  "basic workflow persists across restart and restores from backup",
+  { timeout: 300000 },
+  async () => {
+    const run = newRun("workflow");
+    const profileA = path.join(run, "profile-a");
+    const profileB = path.join(run, "profile-b");
+    const log = path.join(run, "app.log");
+    const site = await startFixtureSite();
+
+    try {
+      // 1-6: create, save, import, view, annotate, search
+      let ctx = await launch(profileA, log);
+      await ui.createProject(ctx.page, PROJECT, "Created by the e2e workflow.");
+      await ui.addLinkToProject(ctx.page, site.url, SITE_TITLE);
+      await ui.importFilesToProject(ctx.page, [PDF, TXT]);
+
+      await ui.openTable(ctx.page);
+      assert.deepEqual(
+        (await ui.tableTitles(ctx.page)).sort(),
+        expected.map((e) => e.title).sort()
+      );
+
+      await ui.openSource(ctx.page, "recovery-note.txt");
+      await ui.addAnnotation(ctx.page, "annotation", "mentions chlorophyll");
+      await ui.addTopic(ctx.page, "recoverytopic");
+      await ctx.page.waitForTimeout(1500);
+      await ui.closeDialog(ctx.page);
+
+      await ui.openSource(ctx.page, "recovery-fixture.pdf");
+      await ui.openDocumentTab(ctx.page);
+      await ctx.page.waitForTimeout(2000);
+      await shot(ctx.page, run, "a-pdf-document");
+      await ui.closeDialog(ctx.page);
+
+      const results = await ui.search(ctx.page, "Fixture Site");
+      assert.ok(
+        results.some((r) => r.includes(SITE_TITLE)),
+        `search results: ${results}`
+      );
+      await close(ctx);
+
+      // 7-9: restart and confirm the data remains
+      ctx = await launch(profileA, log);
+      const library = await readLibrary(ctx.page);
+      assert.equal(library.length, 1);
+      assert.equal(library[0].name, PROJECT);
+      assert.deepEqual(
+        library[0].sources
+          .map(({ title, type }) => ({ title, type }))
+          .sort((a, b) => a.title.localeCompare(b.title)),
+        [...expected].sort((a, b) => a.title.localeCompare(b.title))
+      );
+      const note = library[0].sources.find(
+        (s) => s.title === "recovery-note.txt"
+      );
+      assert.deepEqual(note.topics, ["recoverytopic"]);
+      assert.deepEqual(note.annotations, ["mentions chlorophyll"]);
+
+      // 10: export a backup
+      const downloads = path.join(run, "downloads");
+      await captureDownloads(ctx.app, downloads);
+      await ui.openSettings(ctx.page, "Backup");
+      await ctx.page.locator("button", { hasText: "Export" }).click();
+      const date = new Date().toISOString().slice(0, 10);
+      const backup = await waitForFile(
+        path.join(downloads, `knowledge-backup-${date}.json`)
+      );
+      await close(ctx);
+
+      // 11: restore into an empty second profile, then restart it
+      ctx = await launch(profileB, log);
+      assert.deepEqual(await readLibrary(ctx.page), []);
+      await ui.openSettings(ctx.page, "Backup");
+      await ctx.page
+        .locator("app-storage-settings input[type=file]")
+        .setInputFiles(backup);
+      await ctx.page.waitForFunction(
+        () =>
+          JSON.parse(localStorage.getItem("kc-projects") ?? "[]").length === 1,
+        null,
+        { timeout: 15000 }
+      );
+      await close(ctx);
+
+      ctx = await launch(profileB, log);
+      assert.deepEqual(await readLibrary(ctx.page), library);
+      await ui.openTable(ctx.page);
+      await shot(ctx.page, run, "b-restored-table");
+      await close(ctx);
+    } finally {
+      site.close();
+    }
+  }
+);
diff --git a/package.json b/package.json
index 65d90bfd..d801993e 100644
--- a/package.json
+++ b/package.json
@@ -33,20 +33,26 @@
     "publish-all": "electron-builder -mwl --x64 --arm64 --publish always",
     "release": "standard-version",
     "start": "electron .",
+    "start-dev": "yarn build-dev && electron .",
     "start-windows": "./node_modules/electron/dist/electron.exe . --platform win --arch x64",
     "start-debug": "electron . --inspect=5858",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "node --disable-warning=MODULE_TYPELESS_PACKAGE_JSON --test \"tests/*.test.mts\"",
+    "e2e": "node --test --test-concurrency=1 \"e2e/*.e2e.mjs\"",
     "watch-main": "cd src/kc_angular && yarn run watch-main",
     "watch-main-dev": "cd src/kc_angular && yarn run watch-main-dev",
     "watch-electron": "cd src/kc_electron && yarn run watch-electron",
     "watch-electron-dev": "cd src/kc_electron && yarn run watch-electron-dev"
   },
   "packageManager": "yarn@3.2.4",
+  "dependenciesMeta": {
+    "canvas": {
+      "built": false
+    }
+  },
   "dependencies": {
     "@adobe/css-tools": "^4.3.2",
     "async": "^3.2.5",
     "axios": "^1.6.5",
-    "canvas": "^2.11.2",
     "ejs": "^3.1.9",
     "express": "^4.18.2",
     "follow-redirects": "^1.15.5",
@@ -85,6 +91,7 @@
     "eslint-plugin-html": "^7.1.0",
     "loader-utils": "^3.2.1",
     "node-loader": "^2.0.0",
+    "playwright-core": "^1.63.0",
     "prettier": "^2.8.8",
     "standard-version": "^9.5.0",
     "worker-loader": "^3.0.8"
diff --git a/src/kc_angular/src/app/app.component.html b/src/kc_angular/src/app/app.component.html
index e812e471..87affd7b 100755
--- a/src/kc_angular/src/app/app.component.html
+++ b/src/kc_angular/src/app/app.component.html
@@ -81,7 +81,7 @@
     <img
       alt="Knowledge Logo"
       class="pulsate-fwd knowledge-logo"
-      src="https://knowledge-app.s3.us-west-1.amazonaws.com/kc-icon-transparent.png"
+      src="assets/img/kc-icon-transparent.png"
     />
   </div>
   <div style="width: 100%; max-width: 12rem">
@@ -113,7 +113,7 @@
           <img
             alt="Icon for the Knowledge application."
             height="30"
-            src="https://knowledge-app.s3.us-west-1.amazonaws.com/kc-icon-transparent.png"
+            src="assets/img/kc-icon-transparent.png"
           />
         </div>
         <div class="overflow-y-auto">
diff --git a/src/kc_angular/src/app/app.module.ts b/src/kc_angular/src/app/app.module.ts
index 31b4eb4e..9f0a5a33 100755
--- a/src/kc_angular/src/app/app.module.ts
+++ b/src/kc_angular/src/app/app.module.ts
@@ -13,6 +13,13 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
+import { APP_INITIALIZER } from '@angular/core';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import {
+  BackendAuthInterceptor,
+  BackendService,
+  loadBackend,
+} from '@services/ipc-services/backend.service';
 import { A11yModule } from '@angular/cdk/a11y';
 import { AccordionModule } from 'primeng/accordion';
 import { AppComponent } from '@app/app.component';
@@ -322,6 +329,17 @@ import { CarouselModule } from 'primeng/carousel';
     CarouselModule,
   ],
   providers: [
+    {
+      provide: APP_INITIALIZER,
+      useFactory: loadBackend,
+      deps: [BackendService],
+      multi: true,
+    },
+    {
+      provide: HTTP_INTERCEPTORS,
+      useClass: BackendAuthInterceptor,
+      multi: true,
+    },
     ConfirmationService,
     DialogService,
     IngestService,
diff --git a/src/kc_angular/src/app/components/chat-components/message-templates/quiz.message.ts b/src/kc_angular/src/app/components/chat-components/message-templates/quiz.message.ts
index 7011f363..a942fb07 100644
--- a/src/kc_angular/src/app/components/chat-components/message-templates/quiz.message.ts
+++ b/src/kc_angular/src/app/components/chat-components/message-templates/quiz.message.ts
@@ -37,7 +37,7 @@ interface QuizQuestion {
         <div>
           <div (dragstart)="$event.preventDefault()">
             <img
-              src="https://knowledge-app.s3.us-west-1.amazonaws.com/kc-icon-transparent.png"
+              src="assets/img/kc-icon-transparent.png"
               alt="Knowledge Logo"
               class="knowledge-logo pulsate-fwd"
             />
diff --git a/src/kc_angular/src/app/components/home.component.ts b/src/kc_angular/src/app/components/home.component.ts
index eb8d7b25..a895c25f 100755
--- a/src/kc_angular/src/app/components/home.component.ts
+++ b/src/kc_angular/src/app/components/home.component.ts
@@ -210,7 +210,7 @@ import { finalize, map, take, takeUntil, tap } from 'rxjs/operators';
               >
                 <div (dragstart)="$event.preventDefault()">
                   <img
-                    src="https://knowledge-app.s3.us-west-1.amazonaws.com/kc-icon-transparent.png"
+                    src="assets/img/kc-icon-transparent.png"
                     alt="Knowledge Logo"
                     class="knowledge-logo"
                     [class.pulsate-fwd]="animate"
diff --git a/src/kc_angular/src/app/components/settings/settings.component.ts b/src/kc_angular/src/app/components/settings/settings.component.ts
index 867ba219..a88f4942 100755
--- a/src/kc_angular/src/app/components/settings/settings.component.ts
+++ b/src/kc_angular/src/app/components/settings/settings.component.ts
@@ -79,10 +79,10 @@ export class SettingsComponent {
       icon: 'pi pi-fw pi-comments',
       routerLink: ['app', { outlets: { settings: ['chat'] } }],
     },
-    // { TODO: reinstate once storage settings component is implemented
-    //   label: 'Storage',
-    //   icon: 'pi pi-fw pi-database',
-    //   routerLink: ['app', {outlets: {settings: ['storage']}}]
-    // }
+    {
+      label: 'Backup',
+      icon: 'pi pi-fw pi-database',
+      routerLink: ['app', { outlets: { settings: ['storage'] } }],
+    },
   ];
 }
diff --git a/src/kc_angular/src/app/components/settings/storage-settings.component.ts b/src/kc_angular/src/app/components/settings/storage-settings.component.ts
index 86647a5f..f58417d0 100755
--- a/src/kc_angular/src/app/components/settings/storage-settings.component.ts
+++ b/src/kc_angular/src/app/components/settings/storage-settings.component.ts
@@ -18,6 +18,7 @@ import { Component } from '@angular/core';
 import { StorageService } from '@services/ipc-services/storage.service';
 import { FormBuilder, FormGroup } from '@angular/forms';
 import { NotificationsService } from '@services/user-services/notifications.service';
+import { SettingsService } from '@services/ipc-services/settings.service';
 
 @Component({
   selector: 'app-storage-settings',
@@ -28,12 +29,16 @@ import { NotificationsService } from '@services/user-services/notifications.serv
           <p-panel>
             <ng-template pTemplate="header">
               <div class="flex-row-center-between w-full">
-                <div class="text-2xl">Import/Export</div>
+                <div class="text-2xl">Backup</div>
               </div>
             </ng-template>
             <ng-template pTemplate="content">
               <div class="w-full h-full flex flex-column">
-                <app-setting-template class="w-full" label="Export All">
+                <div class="mb-3 text-500">
+                  A backup holds projects, sources, annotations, chat history
+                  and the inbox. It does not hold settings or imported files.
+                </div>
+                <app-setting-template class="w-full" label="Export Backup">
                   <div class="settings-input">
                     <button
                       pButton
@@ -44,17 +49,18 @@ import { NotificationsService } from '@services/user-services/notifications.serv
                   </div>
                 </app-setting-template>
 
-                <app-setting-template class="w-full" label="Import from File">
+                <app-setting-template class="w-full" label="Restore Backup">
                   <div class="settings-input">
                     <input
                       #importUpload
                       class="hidden"
                       (change)="onImport($event)"
                       type="file"
+                      accept=".json,application/json"
                     />
                     <button
                       pButton
-                      label="Import"
+                      label="Restore"
                       (click)="importUpload.click()"
                     ></button>
                   </div>
@@ -78,64 +84,53 @@ export class StorageSettingsComponent {
   constructor(
     private storage: StorageService,
     private formBuilder: FormBuilder,
-    private notifications: NotificationsService
+    private notifications: NotificationsService,
+    private settings: SettingsService
   ) {
     this.form = formBuilder.group({});
   }
 
-  async onExport() {
+  onExport() {
     this.exporting = true;
-    await this.storage.export();
-    this.exporting = false;
+    try {
+      const keys = this.storage.export(this.settings.get().system?.appVersion);
+      this.notifications.success(
+        'Backup',
+        'Backup Exported',
+        `Saved ${keys} storage entries.`
+      );
+    } catch (e) {
+      this.notifications.error('Backup', 'Export Failed', `${e}`);
+    } finally {
+      this.exporting = false;
+    }
   }
 
   onImport($event: any) {
-    const files: any[] = $event.target.files;
-    if (!files) {
+    const input: HTMLInputElement = $event.target;
+    const file = input.files?.[0];
+    if (!file) {
       return;
     }
 
-    const file: File = files[0];
     file
       .text()
-      .then((importFile) => {
-        const imported = JSON.parse(importFile);
-        if (imported?.projects) {
-          const projects = imported.projects;
-          const projectList: string[] = [];
-          for (const project of projects) {
-            projectList.push(project.id.value);
-            const id = project.id.value;
-            const pStr = JSON.stringify(project);
-            if (pStr) {
-              localStorage.setItem(id, pStr);
-            }
-          }
+      .then((text) => {
+        const result = this.storage.restore(text);
+        this.notifications.success(
+          'Backup',
+          'Backup Restored',
+          `${result.projectsAdded} projects added, ${result.projectsReplaced} replaced. Reloading...`
+        );
 
-          const projectsStr = localStorage.getItem('kc-projects');
-          if (projectsStr) {
-            const ids: string[] = JSON.parse(projectsStr);
-            if (ids) {
-              const nextIds = [];
-              for (const id of ids) {
-                nextIds.push(id);
-              }
-              for (const id of projectList) {
-                nextIds.push(id);
-              }
-              ids.concat(projectList);
-              const idStr = JSON.stringify(nextIds);
-              localStorage.setItem('kc-projects', idStr);
-            }
-          }
-        }
+        // Reload so every service reads the restored storage
+        setTimeout(() => window.location.reload(), 1500);
       })
-      .catch(() => {
-        this.notifications.error(
-          'Storage Settings',
-          'File Error',
-          'Unable to read file.'
-        );
+      .catch((e: Error) => {
+        this.notifications.error('Backup', 'Restore Failed', e.message);
+      })
+      .finally(() => {
+        input.value = '';
       });
   }
 }
diff --git a/src/kc_angular/src/app/components/shared/web.import.component.ts b/src/kc_angular/src/app/components/shared/web.import.component.ts
index 065fbef5..44ea0032 100644
--- a/src/kc_angular/src/app/components/shared/web.import.component.ts
+++ b/src/kc_angular/src/app/components/shared/web.import.component.ts
@@ -175,26 +175,28 @@ export class WebImportComponent {
   // HostListener for pasting text
   @HostListener('paste', ['$event'])
   onPaste(event: ClipboardEvent) {
-    const text = event.clipboardData?.getData('text');
+    this.addUrls(event.clipboardData?.getData('text') ?? '');
+  }
+
+  onSubmit(value: string) {
+    this.addUrls(value);
+  }
 
-    // Get all URLs in text
-    const regex = /https?:\/\/[^\s]+/g;
-    const matches = text?.match(regex);
+  /**
+   * Create Sources from every URL in the text, then clear the input.
+   */
+  private addUrls(text: string) {
+    const matches = text.match(/https?:\/\/[^\s]+/g);
 
-    // Add URLs to array
     if (matches) {
-      const urls: string[] = [];
-      matches.forEach((match) => {
-        // Remove commas from end of URLs
-        if (match.endsWith(',')) {
-          match = match.slice(0, -1);
-        }
-        urls.push(match);
-      });
+      // Remove trailing commas from pasted lists
+      const urls = matches.map((match) =>
+        match.endsWith(',') ? match.slice(0, -1) : match
+      );
       this.createSource(urls);
     }
 
-    // Clear form by resetting URL field, making sure the value is updated
+    // Reset after the input event so the field clears
     setTimeout(() => {
       this.linkForm.setValue({
         url: '',
@@ -203,8 +205,6 @@ export class WebImportComponent {
     });
   }
 
-  onSubmit(value: string) {}
-
   createSource(urls: string[]) {
     const requests: KnowledgeSourceFactoryRequest = {
       ingestType: 'website',
diff --git a/src/kc_angular/src/app/components/source-components/ks-preview.component.ts b/src/kc_angular/src/app/components/source-components/ks-preview.component.ts
index 9ebd8390..5aad7a96 100755
--- a/src/kc_angular/src/app/components/source-components/ks-preview.component.ts
+++ b/src/kc_angular/src/app/components/source-components/ks-preview.component.ts
@@ -62,7 +62,7 @@ export interface KsPreviewInput {
       <div class="ks-preview-footer w-full flex-row-center-center">
         <div *ngIf="!viewReady">
           <img
-            src="https://knowledge-app.s3.us-west-1.amazonaws.com/kc-icon-transparent.png"
+            src="assets/img/kc-icon-transparent.png"
             alt="Knowledge Logo"
             class="pulsate-fwd"
             style="filter: drop-shadow(0 0 1px var(--primary-color)); height: 8rem; position: absolute; left: calc(50vw - 4rem); top: calc(50vh - 4rem)"
diff --git a/src/kc_angular/src/app/services/chat-services/chat.service.ts b/src/kc_angular/src/app/services/chat-services/chat.service.ts
index 383416f5..64ea6d08 100755
--- a/src/kc_angular/src/app/services/chat-services/chat.service.ts
+++ b/src/kc_angular/src/app/services/chat-services/chat.service.ts
@@ -15,6 +15,7 @@
  */
 
 import { AgentType, ChatMessage, MessageRating } from '@app/models/chat.model';
+import { BackendService } from '@services/ipc-services/backend.service';
 import { HttpClient } from '@angular/common/http';
 import { Injectable } from '@angular/core';
 import { KcProject } from '@app/models/project.model';
@@ -51,7 +52,6 @@ export interface ChatTarget {
 })
 export class ChatService {
   // TODO: Make this a configurable setting when backend becomes available as standalone
-  private backendUrl = 'http://localhost:21003';
 
   private canConnect = new BehaviorSubject<boolean>(false);
 
@@ -84,7 +84,8 @@ export class ChatService {
     private factory: ChatFactoryService,
     private http: HttpClient,
     private notify: NotificationsService,
-    private settings: SettingsService
+    private settings: SettingsService,
+    private backend: BackendService
   ) {
     this.checkConnection();
 
@@ -180,8 +181,9 @@ export class ChatService {
       });
   }
 
-  get serverUrl() {
-    return this.backendUrl;
+  /** Chat server of this instance. Empty if the server is unavailable. */
+  private get backendUrl() {
+    return this.backend.chat.url ?? '';
   }
 
   canChat() {
diff --git a/src/kc_angular/src/app/services/factory-services/examples.ts b/src/kc_angular/src/app/services/factory-services/examples.ts
new file mode 100644
index 00000000..ecdc78c6
--- /dev/null
+++ b/src/kc_angular/src/app/services/factory-services/examples.ts
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2026 Rob Royce
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * Example Sources offered on the Inbox page. They ship with the app.
+ */
+export const EXAMPLE_SOURCES = [
+  {
+    title: 'Knowledge (Wikipedia)',
+    accessLink: 'https://en.wikipedia.org/wiki/Knowledge',
+    topics: ['knowledge', 'epistemology'],
+  },
+  {
+    title: 'Spaced repetition (Wikipedia)',
+    accessLink: 'https://en.wikipedia.org/wiki/Spaced_repetition',
+    topics: ['learning', 'memory'],
+  },
+  {
+    title: 'Zettelkasten (Wikipedia)',
+    accessLink: 'https://en.wikipedia.org/wiki/Zettelkasten',
+    topics: ['notes', 'knowledge management'],
+  },
+  {
+    title: 'Electron Documentation',
+    accessLink: 'https://www.electronjs.org/docs/latest/',
+    topics: ['electron', 'software'],
+  },
+  {
+    title: 'Angular Documentation',
+    accessLink: 'https://angular.dev/overview',
+    topics: ['angular', 'software'],
+  },
+  {
+    title: 'MDN Web Docs: HTML',
+    accessLink: 'https://developer.mozilla.org/en-US/docs/Web/HTML',
+    topics: ['html', 'web'],
+  },
+  {
+    title: 'The Feynman Lectures on Physics',
+    accessLink: 'https://www.feynmanlectures.caltech.edu/',
+    topics: ['physics', 'lectures'],
+  },
+  {
+    title: 'Project Gutenberg',
+    accessLink: 'https://www.gutenberg.org/',
+    topics: ['books', 'literature'],
+  },
+];
diff --git a/src/kc_angular/src/app/services/factory-services/ks-factory.service.ts b/src/kc_angular/src/app/services/factory-services/ks-factory.service.ts
index ab41037c..847dbc84 100755
--- a/src/kc_angular/src/app/services/factory-services/ks-factory.service.ts
+++ b/src/kc_angular/src/app/services/factory-services/ks-factory.service.ts
@@ -17,7 +17,7 @@ import { ElectronIpcService } from '@services/ipc-services/electron-ipc.service'
 import { ExtractorService } from '@services/ingest-services/extractor.service';
 import { FaviconService } from '@services/ingest-services/favicon.service';
 import { FileSourceModel } from '@shared/models/file.source.model';
-import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { HttpClient } from '@angular/common/http';
 import {
   IngestType,
   KnowledgeSource,
@@ -30,6 +30,7 @@ import { SettingsService } from '@services/ipc-services/settings.service';
 import { UUID } from '@shared/models/uuid.model';
 import { UuidService } from '@services/ipc-services/uuid.service';
 import { map } from 'rxjs/operators';
+import { EXAMPLE_SOURCES } from './examples';
 
 export interface KnowledgeSourceFactoryRequest {
   ingestType: IngestType;
@@ -66,17 +67,9 @@ export class KsFactoryService {
   }
 
   examples(): Observable<KnowledgeSource[]> {
-    return this.http
-      .get('https://knowledge-app.s3.us-west-1.amazonaws.com/examples.json', {
-        responseType: 'json',
-        headers: new HttpHeaders({
-          'Cache-Control': 'no-cache',
-          Pragma: 'no-cache',
-          Expires: 'Sat, 01 Jan 2000 00:00:00 GMT',
-        }),
-      })
+    return of(EXAMPLE_SOURCES.map((example) => ({ ...example })))
       .pipe(
-        map((example: any) => {
+        map((example: ExampleSource[]) => {
           let examples: ExampleSource[] = example;
           this.shuffleArray(examples);
           examples = examples.slice(0, 6);
@@ -254,25 +247,6 @@ export class KsFactoryService {
     return new KnowledgeSource(file.name.trim(), uuid, 'file', ref);
   }
 
-  private getFileMetadata(
-    ks: KnowledgeSource,
-    file: File
-  ): Promise<KnowledgeSource> {
-    return new Promise<KnowledgeSource>((resolve) => {
-      this.extractor
-        .textFromFile(file)
-        .then((results) => {
-          ks.rawText = results;
-        })
-        .catch((reason) => {
-          console.warn('Could not extract text from file: ', reason);
-        })
-        .finally(() => {
-          resolve(ks);
-        });
-    });
-  }
-
   private getFileIcon(ks: KnowledgeSource): Promise<KnowledgeSource> {
     return new Promise<KnowledgeSource>((resolve) => {
       this.favicon
diff --git a/src/kc_angular/src/app/services/ingest-services/extractor.service.ts b/src/kc_angular/src/app/services/ingest-services/extractor.service.ts
index 7790065d..ab70d1c6 100755
--- a/src/kc_angular/src/app/services/ingest-services/extractor.service.ts
+++ b/src/kc_angular/src/app/services/ingest-services/extractor.service.ts
@@ -262,31 +262,4 @@ export class ExtractorService {
       );
     });
   }
-
-  async textFromFile(file: File): Promise<any> {
-    return new Promise<string>((resolve, reject) => {
-      const headers = new Headers();
-      headers.append('Content-Type', file.type);
-      headers.append('Accept', 'text/html');
-      headers.append('X-Tika-OCRLanguage', 'eng');
-
-      const requestOptions: RequestInit = {
-        method: 'PUT',
-        headers: headers,
-        body: file,
-        redirect: 'follow',
-      };
-
-      fetch('http://localhost:9998/tika', requestOptions)
-        .then((response) => {
-          response.text().then((raw) => {
-            resolve(raw);
-          });
-        })
-        .catch((error) => {
-          this.notifications.error('ExtractorService', 'Tika Error', error);
-          reject(error);
-        });
-    });
-  }
 }
diff --git a/src/kc_angular/src/app/services/ingest-services/favicon.service.ts b/src/kc_angular/src/app/services/ingest-services/favicon.service.ts
index 6fb22529..383ad69a 100755
--- a/src/kc_angular/src/app/services/ingest-services/favicon.service.ts
+++ b/src/kc_angular/src/app/services/ingest-services/favicon.service.ts
@@ -28,10 +28,8 @@ export class FaviconService {
   private googleFaviconSize = '32';
   private googleFaviconServicePrefix = `https://s2.googleusercontent.com/s2/favicons?domain_url=`;
   private googleFaviconServiceSuffix = `&sz=${this.googleFaviconSize}`;
-  private defaultIcon =
-    'https://knowledge-app.s3.us-west-1.amazonaws.com/kc-icon-transparent.png';
-  private loadingIcon =
-    'https://knowledge-app.s3.us-west-1.amazonaws.com/kc-icon-transparent.png';
+  private defaultIcon = 'assets/img/kc-icon-transparent.png';
+  private loadingIcon = 'assets/img/kc-icon-transparent.png';
 
   constructor(
     private httpClient: HttpClient,
@@ -114,11 +112,12 @@ export class FaviconService {
           resolve(icons);
         },
         error: (error) => {
-          this.notifications.error(
+          this.notifications.warn(
             'Favicon Extractor',
-            'Failed to get Favicon',
-            error
+            'Favicon Unavailable',
+            `${error}`
           );
+          resolve(urls.map(() => this.defaultIcon));
         },
       });
     });
diff --git a/src/kc_angular/src/app/services/ipc-services/backend.service.ts b/src/kc_angular/src/app/services/ipc-services/backend.service.ts
new file mode 100644
index 00000000..6f7f3d64
--- /dev/null
+++ b/src/kc_angular/src/app/services/ipc-services/backend.service.ts
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2026 Rob Royce
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+import { Injectable } from '@angular/core';
+import {
+  HttpEvent,
+  HttpHandler,
+  HttpInterceptor,
+  HttpRequest,
+} from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+export interface BackendEndpoint {
+  url?: string;
+  token?: string;
+  error?: string;
+}
+
+export interface BackendInfo {
+  chat: BackendEndpoint;
+}
+
+/**
+ * Addresses and tokens of the local servers that belong to this instance.
+ * Electron provides them through IPC. Load before the app starts.
+ */
+@Injectable({
+  providedIn: 'root',
+})
+export class BackendService {
+  private info: BackendInfo = {
+    chat: { error: 'Backend information not loaded.' },
+  };
+
+  get chat(): BackendEndpoint {
+    return this.info.chat;
+  }
+
+  async load() {
+    try {
+      this.info = await window.api.invoke('A2E:Backend:Info');
+    } catch (e) {
+      this.info = { chat: { error: `Backend information unavailable: ${e}` } };
+    }
+    if (this.info.chat.error) {
+      console.error('[Backend]:', this.info.chat.error);
+    }
+  }
+
+  /** Bearer token for a URL that belongs to this instance, if any. */
+  tokenFor(url: string): string | undefined {
+    for (const endpoint of Object.values(this.info)) {
+      if (
+        endpoint.url &&
+        endpoint.token &&
+        url.startsWith(endpoint.url + '/')
+      ) {
+        return endpoint.token;
+      }
+    }
+    return undefined;
+  }
+}
+
+@Injectable()
+export class BackendAuthInterceptor implements HttpInterceptor {
+  constructor(private backend: BackendService) {}
+
+  intercept(
+    req: HttpRequest<unknown>,
+    next: HttpHandler
+  ): Observable<HttpEvent<unknown>> {
+    const token = this.backend.tokenFor(req.url);
+    if (!token) {
+      return next.handle(req);
+    }
+    return next.handle(
+      req.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
+    );
+  }
+}
+
+export function loadBackend(backend: BackendService) {
+  return () => backend.load();
+}
diff --git a/src/kc_angular/src/app/services/ipc-services/backup.ts b/src/kc_angular/src/app/services/ipc-services/backup.ts
new file mode 100644
index 00000000..b36c7f5e
--- /dev/null
+++ b/src/kc_angular/src/app/services/ipc-services/backup.ts
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2026 Rob Royce
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*
+ * Backup and restore for renderer storage.
+ *
+ * A backup is a full snapshot of localStorage. It holds projects, their
+ * sources and annotations, chat history, the inbox, topics and UI state.
+ * It does not hold settings, imported files or the extracted-text cache.
+ *
+ * This module has no Angular or Electron imports so that Node can test it.
+ */
+
+export const BACKUP_FORMAT = 'knowledge-backup';
+export const BACKUP_VERSION = 1;
+export const PROJECT_LIST_KEY = 'kc-projects';
+
+/** The subset of the Web Storage API that backup and restore use. */
+export interface KeyValueStore {
+  readonly length: number;
+  key(index: number): string | null;
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+export interface Backup {
+  format: typeof BACKUP_FORMAT;
+  version: number;
+  exportedAt: string;
+  appVersion?: string;
+  data: Record<string, string>;
+}
+
+export interface RestoreResult {
+  keysWritten: number;
+  projectsAdded: number;
+  projectsReplaced: number;
+}
+
+export function createBackup(
+  store: KeyValueStore,
+  appVersion?: string,
+  now = new Date()
+): Backup {
+  const data: Record<string, string> = {};
+  for (let i = 0; i < store.length; i++) {
+    const key = store.key(i);
+    if (key === null) {
+      continue;
+    }
+    const value = store.getItem(key);
+    if (value !== null) {
+      data[key] = value;
+    }
+  }
+
+  return {
+    format: BACKUP_FORMAT,
+    version: BACKUP_VERSION,
+    exportedAt: now.toISOString(),
+    appVersion,
+    data,
+  };
+}
+
+/**
+ * Restore a backup into the store.
+ *
+ * Keys from the backup replace keys with the same name. The project list is
+ * merged so that projects already in the store remain listed.
+ * Throws an Error with a user-facing message if the input is not a backup.
+ */
+export function restoreBackup(
+  store: KeyValueStore,
+  input: unknown
+): RestoreResult {
+  const data = toKeyValues(input);
+
+  const existingIds = readProjectIds(store.getItem(PROJECT_LIST_KEY));
+  const importedIds = readProjectIds(data[PROJECT_LIST_KEY] ?? null);
+
+  let keysWritten = 0;
+  for (const [key, value] of Object.entries(data)) {
+    if (key === PROJECT_LIST_KEY) {
+      continue;
+    }
+    store.setItem(key, value);
+    keysWritten++;
+  }
+
+  const merged = [...existingIds];
+  let projectsAdded = 0;
+  let projectsReplaced = 0;
+  for (const id of importedIds) {
+    if (merged.includes(id)) {
+      projectsReplaced++;
+    } else {
+      merged.push(id);
+      projectsAdded++;
+    }
+  }
+  store.setItem(PROJECT_LIST_KEY, JSON.stringify(merged));
+  keysWritten++;
+
+  return { keysWritten, projectsAdded, projectsReplaced };
+}
+
+/**
+ * Convert a parsed backup file into storage keys and values.
+ */
+function toKeyValues(input: unknown): Record<string, string> {
+  if (!input || typeof input !== 'object') {
+    throw new Error('The file is not a Knowledge backup.');
+  }
+  const obj = input as Record<string, unknown>;
+
+  if (obj['format'] === BACKUP_FORMAT) {
+    if (obj['version'] !== BACKUP_VERSION) {
+      throw new Error(
+        `Backup version ${obj['version']} is not supported. Expected ${BACKUP_VERSION}.`
+      );
+    }
+    const data = obj['data'];
+    if (!data || typeof data !== 'object') {
+      throw new Error('The backup has no data.');
+    }
+    for (const [key, value] of Object.entries(data)) {
+      if (typeof value !== 'string') {
+        throw new Error(`The backup value for "${key}" is not text.`);
+      }
+    }
+    return data as Record<string, string>;
+  }
+
+  throw new Error('The file is not a Knowledge backup.');
+}
+
+function readProjectIds(raw: string | null): string[] {
+  if (!raw) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed)
+      ? parsed.filter((id) => typeof id === 'string')
+      : [];
+  } catch {
+    return [];
+  }
+}
diff --git a/src/kc_angular/src/app/services/ipc-services/storage.service.ts b/src/kc_angular/src/app/services/ipc-services/storage.service.ts
index 8bd2ffac..7026e5f3 100755
--- a/src/kc_angular/src/app/services/ipc-services/storage.service.ts
+++ b/src/kc_angular/src/app/services/ipc-services/storage.service.ts
@@ -18,6 +18,7 @@ import { KcProject } from '@app/models/project.model';
 import { KnowledgeSource } from '@app/models/knowledge.source.model';
 import { AutoscanService } from '@services/ingest-services/autoscan.service';
 import { NotificationsService } from '@services/user-services/notifications.service';
+import { createBackup, restoreBackup, RestoreResult } from './backup';
 
 @Injectable({
   providedIn: 'root',
@@ -279,75 +280,44 @@ export class StorageService {
     this.db.setItem(this.KC_ALL_PROJECT_IDS, projectListStr);
   }
 
-  createFile(encoding: string) {
-    const type = 'text/json';
-    const charset = 'utf-8';
-
-    const blob = new Blob([encoding], {
-      type: `${type};charset=${charset};`,
+  /**
+   * Download a backup of all renderer storage as a JSON file.
+   */
+  export(appVersion?: string) {
+    const backup = createBackup(this.db, appVersion);
+    const date = backup.exportedAt.slice(0, 10);
+    const blob = new Blob([JSON.stringify(backup)], {
+      type: 'application/json;charset=utf-8;',
     });
 
     const link = document.createElement('a');
     link.style.display = 'none';
+    link.href = URL.createObjectURL(blob);
+    link.download = `knowledge-backup-${date}.json`;
     document.body.appendChild(link);
-    if (link.download !== undefined) {
-      link.setAttribute('href', URL.createObjectURL(blob));
-      link.setAttribute('download', `knowledge_export.json`);
-      link.click();
-    } else {
-      encoding = `data:${type};charset=${charset}` + encoding;
-      window.open(encodeURI(encoding));
-    }
+    link.click();
     document.body.removeChild(link);
-  }
 
-  async export() {
-    const sources: KnowledgeSource[] = [];
-    const icons: any[] = [];
-    const projects: KcProject[] = [];
+    // Chromium reads the blob after click() returns
+    setTimeout(() => URL.revokeObjectURL(link.href), 10000);
 
-    for (let i = 0; i < this.db.length; i++) {
-      const key = this.db.key(i);
-      if (key?.startsWith('ks-')) {
-        const ksStr = this.db.getItem(key);
-        if (ksStr) {
-          const ks: KnowledgeSource = JSON.parse(ksStr);
-          if (ks) {
-            sources.push(ks);
-          }
-        }
-      } else if (key?.startsWith('icon-')) {
-        const iconStr = this.db.getItem(key);
-        if (iconStr) {
-          icons.push({
-            ksId: key.replace('icon-', ''),
-            icon: iconStr,
-          });
-        }
-      } else if (key?.length === 36) {
-        const projectStr = this.db.getItem(key);
-        if (projectStr) {
-          const kcProject: KcProject = JSON.parse(projectStr);
-          if (kcProject) {
-            projects.push(kcProject);
-          }
-        }
-      } else {
-        this.notifications.error(
-          'Storage Service',
-          'Invalid Storage Key',
-          key ?? ''
-        );
-      }
-    }
-
-    const encoding = {
-      projects: projects,
-      sources: sources,
-      icons: icons,
-    };
+    return Object.keys(backup.data).length;
+  }
 
-    this.createFile(JSON.stringify(encoding));
+  /**
+   * Restore a backup file. The caller must reload the app afterwards.
+   * Throws an Error with a user-facing message if the file is invalid.
+   */
+  restore(fileText: string): RestoreResult {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(fileText);
+    } catch {
+      throw new Error('The file is not valid JSON.');
+    }
+    const result = restoreBackup(this.db, parsed);
+    this.projectList = null;
+    return result;
   }
 
   deleteKnowledgeSource(ks: KnowledgeSource) {
diff --git a/src/kc_electron/package.json b/src/kc_electron/package.json
index 727759fe..fc218f1d 100755
--- a/src/kc_electron/package.json
+++ b/src/kc_electron/package.json
@@ -24,6 +24,7 @@
     "electron": "^26.3.0",
     "electron-updater": "^6.1.4",
     "express-rate-limit": "^6.11.2",
+    "fs-extra": "^10.1.0",
     "lodash": "^4.17.21",
     "mime-types": "^2.1.35",
     "openai": "^4.25.0",
diff --git a/src/kc_electron/src/app/backend.ts b/src/kc_electron/src/app/backend.ts
new file mode 100644
index 00000000..1d638581
--- /dev/null
+++ b/src/kc_electron/src/app/backend.ts
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2026 Rob Royce
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*
+ * Local backend addresses for this instance.
+ *
+ * Each server listens on an ephemeral loopback port and requires a random
+ * bearer token. The renderer receives the address and token only through
+ * the A2E:Backend:Info IPC channel, so it cannot reach another instance.
+ */
+
+import { ipcMain } from "electron";
+import crypto from "crypto";
+
+export interface BackendEndpoint {
+  url?: string;
+  token?: string;
+  error?: string;
+}
+
+export interface BackendInfo {
+  chat: BackendEndpoint;
+}
+
+export function newToken() {
+  return crypto.randomBytes(32).toString("hex");
+}
+
+/**
+ * Register the IPC handler. Each value resolves when its server is ready
+ * or has failed.
+ */
+export function registerBackendInfo(endpoints: {
+  [K in keyof BackendInfo]: Promise<BackendEndpoint>;
+}) {
+  ipcMain.handle("A2E:Backend:Info", async (): Promise<BackendInfo> => {
+    return { chat: await endpoints.chat };
+  });
+}
diff --git a/src/kc_electron/src/app/ipc/ipc-auto-update.ts b/src/kc_electron/src/app/ipc/ipc-auto-update.ts
index 472daac9..d0b046f9 100755
--- a/src/kc_electron/src/app/ipc/ipc-auto-update.ts
+++ b/src/kc_electron/src/app/ipc/ipc-auto-update.ts
@@ -21,6 +21,12 @@ const autoUpdater = share.autoUpdater;
 import { IpcMessage } from "../../../../kc_shared/models/electron.ipc.model";
 
 const checkForUpdate = ipcMain.on("A2E:AutoUpdate:Check", (_: any) => {
+  if (!share.app.isPackaged || process.env.KC_ENABLE_UPDATES !== "1") {
+    console.log(
+      "[AutoUpdate]: update check disabled (set KC_ENABLE_UPDATES=1)"
+    );
+    return;
+  }
   autoUpdater
     .checkForUpdates()
     .then((result: any) => {
diff --git a/src/kc_electron/src/app/profile.paths.ts b/src/kc_electron/src/app/profile.paths.ts
new file mode 100644
index 00000000..06683769
--- /dev/null
+++ b/src/kc_electron/src/app/profile.paths.ts
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026 Rob Royce
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*
+ * Data profile path rules. This module has no Electron imports so that
+ * Node can test it.
+ *
+ *   KC_PROFILE_DIR=<path>   Use <path> for all application data.
+ *   KC_PROFILE_DIR=system   Use the normal per-user locations.
+ *   (unset, unpackaged)     Use <appPath>/.dev-profiles/dev.
+ *   (unset, packaged)       Use the normal per-user locations.
+ */
+
+import path from "path";
+
+export interface DataProfile {
+  root: string;
+  userData: string;
+  data: string;
+  settings: string;
+  downloads: string;
+}
+
+export function resolveProfile(
+  requested: string | undefined,
+  isPackaged: boolean,
+  appPath: string
+): DataProfile | null {
+  if (requested === "system") {
+    return null;
+  }
+
+  let root: string;
+  if (requested) {
+    root = path.resolve(requested);
+  } else if (!isPackaged) {
+    root = path.join(appPath, ".dev-profiles", "dev");
+  } else {
+    return null;
+  }
+
+  return {
+    root,
+    userData: path.join(root, "userData"),
+    data: path.join(root, "data"),
+    settings: path.join(root, "settings"),
+    downloads: path.join(root, "downloads"),
+  };
+}
diff --git a/src/kc_electron/src/app/profile.ts b/src/kc_electron/src/app/profile.ts
new file mode 100644
index 00000000..56a94665
--- /dev/null
+++ b/src/kc_electron/src/app/profile.ts
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2026 Rob Royce
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*
+ * Applies the data profile and resolves the Resources directory.
+ *
+ * Import this module before any other application module. It must call
+ * app.setPath("userData") before Electron creates the default session.
+ * See profile.paths.ts for the profile selection rules.
+ */
+
+import { app } from "electron";
+import fs from "fs";
+import path from "path";
+import { resolveProfile } from "./profile.paths";
+
+export const profile = resolveProfile(
+  process.env.KC_PROFILE_DIR,
+  app.isPackaged,
+  app.getAppPath()
+);
+
+if (profile) {
+  for (const dir of Object.values(profile)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  app.setPath("userData", profile.userData);
+  app.setPath("sessionData", profile.userData);
+  app.setPath("crashDumps", path.join(profile.userData, "Crashpad"));
+  console.log(`[Knowledge]: data profile: ${profile.root}`);
+} else {
+  console.log("[Knowledge]: data profile: system (per-user default)");
+}
+
+/**
+ * Directory that holds app.env, icon.png and tiktoken_bg.wasm.
+ * Packaged builds receive these files through electron-builder extraResources.
+ */
+export function resourcesDir(): string {
+  return app.isPackaged
+    ? process.resourcesPath
+    : path.join(app.getAppPath(), "Resources");
+}
diff --git a/src/kc_electron/src/app/services/settings.service.ts b/src/kc_electron/src/app/services/settings.service.ts
index 20615443..ca842cc1 100755
--- a/src/kc_electron/src/app/services/settings.service.ts
+++ b/src/kc_electron/src/app/services/settings.service.ts
@@ -40,6 +40,7 @@ import os from "os";
 import * as lodash from "lodash";
 import { KcTheme } from "../../../../kc_shared/models/style.model";
 import { app, BrowserWindow, ipcMain } from "electron";
+import { profile, resourcesDir } from "../profile";
 
 const RET_OK = 0;
 const RET_FAIL = -1;
@@ -70,8 +71,7 @@ class SettingsService {
 
   constructor() {
     // 1. Load optimal default settings on every startup
-    const resources = path.join(process.cwd(), "Resources");
-    const envPath = path.resolve(resources, "app.env");
+    const envPath = path.resolve(resourcesDir(), "app.env");
     const defaults = this.defaults(envPath);
 
     // 2. Instantiate the `all` settings Observable for Electron-side usage
@@ -151,7 +151,7 @@ class SettingsService {
       firstRun: true,
       homePath: os.homedir(),
       pathSep: path.sep,
-      resourcesPath: path.join(process.cwd(), "Resources"),
+      resourcesPath: resourcesDir(),
       settingsPath: "",
       settingsFilePath: "",
       appVersion: app.getVersion(),
@@ -192,6 +192,13 @@ class SettingsService {
         );
         process.exit(-1);
     }
+
+    if (profile) {
+      system.appPath = profile.data;
+      system.downloadPath = profile.downloads;
+      system.settingsPath = profile.settings;
+    }
+
     system.settingsFilePath = path.resolve(
       system.settingsPath,
       env.settingsFilename
@@ -284,6 +291,7 @@ class SettingsService {
 
       // settings.system.appVersion was added in >=0.5.5. If it does not exist, we do not want to include the file
       if (settings && settings.system.appVersion) {
+        const pinned = { ...this._all.value.system };
         const merged = lodash.merge(this._all.value, settings);
 
         // Make sure we always have the latest version numbers (otherwise the versions from the file will overwrite actual values)
@@ -292,6 +300,16 @@ class SettingsService {
         merged.system.nodeVersion = process.versions.node;
         merged.system.osPlatform = process.platform;
         merged.system.osVersion = process.getSystemVersion();
+
+        // A profile always owns its storage paths, even if the file says otherwise
+        if (profile) {
+          merged.system.appPath = pinned.appPath;
+          merged.system.downloadPath = pinned.downloadPath;
+          merged.system.settingsPath = pinned.settingsPath;
+          merged.system.settingsFilePath = pinned.settingsFilePath;
+          merged.system.resourcesPath = pinned.resourcesPath;
+        }
+
         this._all.next(merged);
       } else {
         this.warn(
@@ -302,9 +320,25 @@ class SettingsService {
           this._all.next(this._all.value);
         });
       }
-    } catch (e) {
-      console.error("SettingsService - Error - ", e);
-      this.warn("Settings File Does Not Exist", "Creating new settings file.");
+    } catch (e: any) {
+      if (e?.code === "ENOENT") {
+        this.warn(
+          "Settings File Does Not Exist",
+          "Creating new settings file."
+        );
+      } else {
+        // Keep the unreadable file so the user can recover it
+        const backupPath = `${filePath}.unreadable-${Date.now()}`;
+        try {
+          fs.renameSync(filePath, backupPath);
+        } catch (renameError) {
+          console.error("Could not move unreadable settings file", renameError);
+        }
+        this.error(
+          "Settings File Unreadable",
+          `Moved to ${backupPath}. Creating new settings file. ${e}`
+        );
+      }
       if (makeDirectory(this._all.value.system.settingsPath) !== RET_OK) {
         console.error("Exiting with code ", -1);
         process.exit(-1);
diff --git a/src/kc_electron/src/local/chat.api.ts b/src/kc_electron/src/local/chat.api.ts
index 99d89a00..b6f4e5ce 100755
--- a/src/kc_electron/src/local/chat.api.ts
+++ b/src/kc_electron/src/local/chat.api.ts
@@ -14,7 +14,10 @@
  *  limitations under the License.
  */
 
-import express, { Express } from "express";
+import express, { Express, NextFunction, Request, Response } from "express";
+import crypto from "crypto";
+import { AddressInfo } from "net";
+import { BackendEndpoint } from "../app/backend";
 import cors from "cors";
 import { ErrorHandler } from "./middleware/ErrorHandler";
 import ChatController from "./controllers/chat.controller";
@@ -49,7 +52,10 @@ export default class ChatServer {
   private sourceRouter;
   private projectRouter;
 
-  constructor() {
+  private token: string;
+
+  constructor(token: string) {
+    this.token = token;
     this.tokenizerUtils = new TokenizerUtils();
 
     settings.all
@@ -88,15 +94,49 @@ export default class ChatServer {
     this.setupRoutes();
   }
 
-  start(port: number) {
-    this.app.listen(port, () => {
-      console.log(`[Knowledge]: chat server listening on port ${port}`);
+  /**
+   * Listen on an ephemeral loopback port. Resolves to the endpoint for this
+   * instance, or to an error that the renderer can show.
+   */
+  start(): Promise<BackendEndpoint> {
+    return new Promise((resolve) => {
+      const server = this.app.listen(0, "127.0.0.1", () => {
+        const { port } = server.address() as AddressInfo;
+        const url = `http://127.0.0.1:${port}`;
+        console.log(`[Knowledge]: chat server listening on ${url}`);
+        resolve({ url, token: this.token });
+      });
+
+      server.on("error", (err: Error) => {
+        console.error(`[Knowledge]: chat server unavailable: ${err.message}`);
+        resolve({ error: `Chat server unavailable: ${err.message}` });
+      });
     });
   }
 
   private setupMiddleware() {
-    this.app.use(express.json({ limit: "50mb" })); // Parse JSON request bodies
-    this.app.use(cors()); // Enable CORS
+    this.app.use(cors());
+    this.app.use(this.requireToken.bind(this));
+    this.app.use(express.json({ limit: "50mb" }));
+  }
+
+  /**
+   * Only the renderer of this instance knows the token. Loopback binding
+   * and CORS alone do not restrict other local clients.
+   */
+  private requireToken(req: Request, res: Response, next: NextFunction) {
+    if (req.method === "OPTIONS") {
+      return next();
+    }
+    const expected = Buffer.from(`Bearer ${this.token}`);
+    const actual = Buffer.from(req.headers.authorization ?? "");
+    if (
+      actual.length !== expected.length ||
+      !crypto.timingSafeEqual(actual, expected)
+    ) {
+      return res.status(401).json({ error: "Missing or invalid token" });
+    }
+    next();
   }
 
   private setupRoutes() {
diff --git a/src/kc_electron/src/local/controllers/api.controller.ts b/src/kc_electron/src/local/controllers/api.controller.ts
index b6f7961f..7d719a68 100755
--- a/src/kc_electron/src/local/controllers/api.controller.ts
+++ b/src/kc_electron/src/local/controllers/api.controller.ts
@@ -37,7 +37,7 @@ export default class ApiKeyController {
     try {
       const apiKey = await this.loadApiKey();
       return res.json({
-        apiKeySet: apiKey && apiKey.length > 0,
+        apiKeySet: Boolean(apiKey && apiKey.length > 0),
       });
     } catch {
       return res.json({ apiKeySet: false });
diff --git a/src/kc_electron/src/local/utils/tokenizer.utils.ts b/src/kc_electron/src/local/utils/tokenizer.utils.ts
index 5acea207..258e6f62 100755
--- a/src/kc_electron/src/local/utils/tokenizer.utils.ts
+++ b/src/kc_electron/src/local/utils/tokenizer.utils.ts
@@ -23,21 +23,25 @@ import {
 import fs from "fs";
 import path from "path";
 import { app } from "electron";
+import { resourcesDir } from "../../app/profile";
 import {
   ChatModel,
   SupportedChatModels,
 } from "../../../../kc_shared/models/chat.model";
 import { ChatCompletionMessageParam } from "openai/resources/chat/completions";
 
-const settingsService = require("../../app/services/settings.service");
-
 export default class TokenizerUtils {
   private tiktoken!: Tiktoken;
 
   private model: TiktokenModel = "gpt-3.5-turbo";
 
   constructor() {
-    this.initialize();
+    this.initialize().catch((e) => {
+      console.error(
+        "[Knowledge]: tokenizer unavailable. AI chat will not work.",
+        e.message
+      );
+    });
   }
 
   async initialize() {
@@ -260,31 +264,30 @@ export default class TokenizerUtils {
   }
 
   /**
-   * Get the path to the tiktoken wasm file. This is used to initialize the tokenizer.
+   * Get the path to the tiktoken wasm file. Packaged builds copy it into
+   * Resources through extraResources. Development builds read it from
+   * node_modules.
    * @private
    */
   private getWasmPath() {
-    // TODO: Figure out how to do this in a cleaner way
     const possiblePaths = [
-      path.resolve(app.getAppPath(), "..", "tiktoken_bg.wasm"),
+      path.join(resourcesDir(), "tiktoken_bg.wasm"),
       path.join(
-        settingsService.getSettings().system.resourcesPath,
+        app.getAppPath(),
+        "node_modules",
+        "@dqbd",
+        "tiktoken",
         "tiktoken_bg.wasm"
       ),
-      path.join(process.cwd(), "Resources", "tiktoken_bg.wasm"),
-      path.join(process.cwd(), "resources", "tiktoken_bg.wasm"),
-      path.join(__dirname, "Resources", "tiktoken_bg.wasm"),
-      path.join(__dirname, "resources", "tiktoken_bg.wasm"),
-      path.join("tiktoken_bg.wasm"),
-      path.join(process.cwd(), "tiktoken_bg.wasm"),
     ];
-
     for (const possible of possiblePaths) {
       if (fs.existsSync(possible)) {
         return possible;
       }
     }
-    throw new Error("Could not find tiktoken wasm file.");
+    throw new Error(
+      `Could not find tiktoken_bg.wasm. Checked: ${possiblePaths.join(", ")}`
+    );
   }
 
   /**
diff --git a/src/kc_electron/src/main.ts b/src/kc_electron/src/main.ts
index bef69a43..6d0f2aef 100755
--- a/src/kc_electron/src/main.ts
+++ b/src/kc_electron/src/main.ts
@@ -14,6 +14,9 @@
  *  limitations under the License.
  */
 
+// Must load first. It sets the userData path before the session exists.
+import { profile, resourcesDir } from "./app/profile";
+
 import { autoUpdater, UpdateCheckResult } from "electron-updater";
 
 import {
@@ -37,6 +40,7 @@ import path from "path";
 import * as uuid from "uuid";
 import KnowledgeIpc from "./local/utils/ipc.utils";
 import ChatServer from "./local/chat.api";
+import { newToken, registerBackendInfo } from "./app/backend";
 
 const settingsService = require("./app/services/settings.service");
 
@@ -74,8 +78,16 @@ require("./app/services/auto.update.service");
 // Setup IPC
 require("./app/ipc");
 
-const chatServer = new ChatServer();
-chatServer.start(21003);
+// One instance per profile. Chromium keys this lock on the userData path.
+if (!app.requestSingleInstanceLock()) {
+  console.error(
+    "[Knowledge]: this profile is already open in another instance. Exiting."
+  );
+  app.exit(0);
+}
+
+const chatServer = new ChatServer(newToken());
+registerBackendInfo({ chat: chatServer.start() });
 
 // Setup knowledge source ingestion
 require("./app/services/index");
@@ -85,8 +97,6 @@ const browserIpc = require("./app/ipc").browserIpc;
 // Declare main window for later use
 let kcMainWindow: BrowserWindow;
 
-require("./local/chat.api");
-
 /**
  * Main Window Functions
  */
@@ -98,6 +108,11 @@ function createMainWindow() {
   console.log("Theme: ", appEnv.display.theme);
 
   console.log("Knowledge storage path: ", app.getPath("userData"));
+  console.log(
+    "Knowledge data path: ",
+    settingsService.getSettings().system.appPath,
+    profile ? "(profile)" : ""
+  );
 
   app.setName("Knowledge");
 
@@ -110,7 +125,7 @@ function createMainWindow() {
     minWidth: 1000,
     minHeight: 850,
     frame: false,
-    icon: path.resolve(app.getAppPath(), "..", "icon.png"),
+    icon: path.join(resourcesDir(), "icon.png"),
     show: false,
     webPreferences: {
       nodeIntegration: false, // is default value after Electron v5
@@ -179,6 +194,13 @@ function setMainWindowListeners() {
   const ipcChannels = new KnowledgeIpc();
 }
 
+app.on("second-instance", () => {
+  if (kcMainWindow) {
+    if (kcMainWindow.isMinimized()) kcMainWindow.restore();
+    kcMainWindow.focus();
+  }
+});
+
 app.on("window-all-closed", function () {
   // MacOS apps typically do not quit all the way when a window is closed...
   if (process.platform !== "darwin") app.quit();
@@ -190,22 +212,34 @@ app.on("activate", () => {
   }
 });
 
-app.on("ready", function () {
-  // Create window but wait to load and show until after update
-  createMainWindow();
+/**
+ * Update checks are opt-in. Set KC_ENABLE_UPDATES=1 in a packaged build to
+ * enable them. The check runs after the window loads and never blocks startup.
+ */
+function updatesEnabled() {
+  return app.isPackaged && process.env.KC_ENABLE_UPDATES === "1";
+}
+
+function checkForUpdates() {
+  if (!updatesEnabled()) {
+    console.log("[Knowledge]: update check disabled (set KC_ENABLE_UPDATES=1)");
+    return;
+  }
 
   autoUpdater
     .checkForUpdatesAndNotify()
     .then((update: UpdateCheckResult | null) => {
       if (update) {
-        // TODO: take action on new versions, such as an "Updating" window or compatibility checks
         console.log("Update Check Results: ", update);
       }
     })
     .catch((reason: any) => {
       console.error("Update Check Error: ", reason);
-    })
-    .finally(() => {
-      kcMainWindow.loadFile(MAIN_ENTRY);
     });
+}
+
+app.on("ready", function () {
+  createMainWindow();
+  kcMainWindow.loadFile(MAIN_ENTRY);
+  checkForUpdates();
 });
diff --git a/src/kc_electron/src/preload.js b/src/kc_electron/src/preload.js
index 63bb6bd8..515a0b7d 100755
--- a/src/kc_electron/src/preload.js
+++ b/src/kc_electron/src/preload.js
@@ -55,7 +55,7 @@ const ipcSendChannels = [
   "A2E:Window:ZoomIn",
 ];
 
-const ipcInvokeChannels = [];
+const ipcInvokeChannels = ["A2E:Backend:Info"];
 
 const ipcReceiveOnceChannels = [
   "E2A:BrowserView:Close",
@@ -98,11 +98,12 @@ contextBridge.exposeInMainWorld("api", {
         `[Debug]-[${datetime()}]-[Electron IPC]: Invoke - Invoked on ${channel} with data: `,
         data
       );
-      ipcRenderer.invoke(channel, data);
+      return ipcRenderer.invoke(channel, data);
     } else {
       console.error(
         `[Error]-[${datetime()}]-[Electron IPC]: Invalid Invoke Channel -- ${channel}`
       );
+      return Promise.reject(new Error(`Invalid invoke channel: ${channel}`));
     }
   },
   send: (channel, data) => {
diff --git a/src/kc_electron/tsconfig.json b/src/kc_electron/tsconfig.json
index 1c91d46a..2ab5ce2d 100755
--- a/src/kc_electron/tsconfig.json
+++ b/src/kc_electron/tsconfig.json
@@ -66,8 +66,10 @@
     /* Module Resolution Options */
     "moduleResolution": "node",
     /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
-    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
-    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    "paths": {
+      "@shared/*": ["../kc_shared/*"]
+    },                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
     // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */
diff --git a/src/kc_electron/webpack.common.js b/src/kc_electron/webpack.common.js
index a127480f..370328f5 100755
--- a/src/kc_electron/webpack.common.js
+++ b/src/kc_electron/webpack.common.js
@@ -43,6 +43,8 @@ let webpack_config = {
     // NOTE: https://github.com/yan-foto/electron-reload/issues/71
     fsevents: "require('fsevents')",
     express: "require('express')",
+    // pdfjs-dist loads canvas only to render pages. Text extraction does not need it.
+    canvas: "commonjs canvas",
   },
   resolve: {
     extensions: [".ts", ".js", ".json"],
diff --git a/tests/backup.test.mts b/tests/backup.test.mts
new file mode 100644
index 00000000..535d86c5
--- /dev/null
+++ b/tests/backup.test.mts
@@ -0,0 +1,128 @@
+/*
+ * Backup and restore checks. Run with `yarn test` (Node 22.18+ or 24).
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  createBackup,
+  restoreBackup,
+  PROJECT_LIST_KEY,
+} from "../src/kc_angular/src/app/services/ipc-services/backup.ts";
+import type { KeyValueStore } from "../src/kc_angular/src/app/services/ipc-services/backup.ts";
+
+class MemoryStore implements KeyValueStore {
+  private items = new Map<string, string>();
+
+  get length() {
+    return this.items.size;
+  }
+
+  key(index: number) {
+    return [...this.items.keys()][index] ?? null;
+  }
+
+  getItem(key: string) {
+    return this.items.get(key) ?? null;
+  }
+
+  setItem(key: string, value: string) {
+    this.items.set(key, String(value));
+  }
+
+  snapshot() {
+    return Object.fromEntries(this.items);
+  }
+}
+
+function project(id: string, sources: object[] = []) {
+  return { id: { value: id }, name: `Project ${id}`, knowledgeSource: sources };
+}
+
+function populated() {
+  const store = new MemoryStore();
+  const source = {
+    id: { value: "source-1" },
+    title: "notes.txt",
+    topics: ["biology"],
+    meta: [{ key: "annotation", value: "mentions chlorophyll" }],
+  };
+  store.setItem("project-a", JSON.stringify(project("project-a", [source])));
+  store.setItem(PROJECT_LIST_KEY, JSON.stringify(["project-a"]));
+  store.setItem("chat-source-1", JSON.stringify([{ text: "hello" }]));
+  store.setItem("ingest-queue", JSON.stringify([{ title: "pending" }]));
+  store.setItem("current-project", "project-a");
+  return store;
+}
+
+test("backup round trip restores every key into an empty profile", () => {
+  const original = populated();
+  const backup = JSON.parse(JSON.stringify(createBackup(original, "0.8.6")));
+
+  const fresh = new MemoryStore();
+  const result = restoreBackup(fresh, backup);
+
+  assert.deepEqual(fresh.snapshot(), original.snapshot());
+  assert.equal(result.projectsAdded, 1);
+  assert.equal(result.projectsReplaced, 0);
+});
+
+test("backup keeps chat history, inbox and source annotations", () => {
+  const backup = createBackup(populated());
+
+  assert.ok(backup.data["chat-source-1"]);
+  assert.ok(backup.data["ingest-queue"]);
+  const restored = JSON.parse(backup.data["project-a"]);
+  assert.deepEqual(restored.knowledgeSource[0].meta, [
+    { key: "annotation", value: "mentions chlorophyll" },
+  ]);
+});
+
+test("restore merges the project list and does not duplicate IDs", () => {
+  const backup = createBackup(populated());
+
+  const target = new MemoryStore();
+  target.setItem("project-b", JSON.stringify(project("project-b")));
+  target.setItem(PROJECT_LIST_KEY, JSON.stringify(["project-b", "project-a"]));
+
+  const result = restoreBackup(target, backup);
+
+  assert.deepEqual(JSON.parse(target.getItem(PROJECT_LIST_KEY)!), [
+    "project-b",
+    "project-a",
+  ]);
+  assert.ok(target.getItem("project-b"));
+  assert.equal(result.projectsAdded, 0);
+  assert.equal(result.projectsReplaced, 1);
+});
+
+test("restore rejects invalid files and leaves the store unchanged", () => {
+  const target = populated();
+  const before = target.snapshot();
+
+  assert.throws(() => restoreBackup(target, null), /not a Knowledge backup/);
+  assert.throws(
+    () => restoreBackup(target, { hello: 1 }),
+    /not a Knowledge backup/
+  );
+  assert.throws(
+    () =>
+      restoreBackup(target, {
+        format: "knowledge-backup",
+        version: 99,
+        data: {},
+      }),
+    /version 99 is not supported/
+  );
+  assert.throws(
+    () =>
+      restoreBackup(target, {
+        format: "knowledge-backup",
+        version: 1,
+        data: { key: 42 },
+      }),
+    /not text/
+  );
+
+  assert.deepEqual(target.snapshot(), before);
+});
diff --git a/tests/profile.test.mts b/tests/profile.test.mts
new file mode 100644
index 00000000..659ddcb7
--- /dev/null
+++ b/tests/profile.test.mts
@@ -0,0 +1,54 @@
+/*
+ * Data profile checks. Development runs must never resolve to per-user data.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { resolveProfile } from "../src/kc_electron/src/app/profile.paths.ts";
+
+const repo = "/work/knowledge";
+
+test("unpackaged runs default to the repository dev profile", () => {
+  const profile = resolveProfile(undefined, false, repo)!;
+
+  assert.equal(profile.root, path.join(repo, ".dev-profiles", "dev"));
+  for (const dir of Object.values(profile)) {
+    assert.ok(dir.startsWith(profile.root), `${dir} is outside the profile`);
+  }
+});
+
+test("KC_PROFILE_DIR places every location under that directory", () => {
+  const profile = resolveProfile("/tmp/kc-test", false, repo)!;
+
+  assert.deepEqual(profile, {
+    root: "/tmp/kc-test",
+    userData: "/tmp/kc-test/userData",
+    data: "/tmp/kc-test/data",
+    settings: "/tmp/kc-test/settings",
+    downloads: "/tmp/kc-test/downloads",
+  });
+});
+
+test("no profile location falls inside the home directory defaults", () => {
+  const home = os.homedir();
+  const real = [
+    path.join(home, ".Knowledge"),
+    path.join(home, "Library", "Preferences", "Knowledge"),
+    path.join(home, "Library", "Application Support"),
+    path.join(home, "Downloads"),
+  ];
+  const profile = resolveProfile(undefined, false, repo)!;
+
+  for (const dir of Object.values(profile)) {
+    for (const prefix of real) {
+      assert.ok(!dir.startsWith(prefix), `${dir} is inside ${prefix}`);
+    }
+  }
+});
+
+test("packaged builds and KC_PROFILE_DIR=system use per-user locations", () => {
+  assert.equal(resolveProfile(undefined, true, repo), null);
+  assert.equal(resolveProfile("system", false, repo), null);
+});
diff --git a/yarn.lock b/yarn.lock
index 15e81b9d..ed647eb5 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9205,6 +9205,7 @@ __metadata:
     electron-builder: ^24.6.4
     electron-updater: ^6.1.4
     express-rate-limit: ^6.11.2
+    fs-extra: ^10.1.0
     lodash: ^4.17.21
     mime-types: ^2.1.35
     openai: ^4.25.0
@@ -9270,7 +9271,6 @@ __metadata:
     "@types/uuid": ^9.0.7
     async: ^3.2.5
     axios: ^1.6.5
-    canvas: ^2.11.2
     ejs: ^3.1.9
     electron-builder: ^24.6.4
     electron-notarize: ^1.2.2
@@ -9288,6 +9288,7 @@ __metadata:
     node-forge: ^1.3.1
     node-loader: ^2.0.0
     pdfjs-dist: ^3.11.174
+    playwright-core: ^1.63.0
     plist: ^3.1.0
     postcss: ^8.4.33
     prettier: ^2.8.8
@@ -9295,6 +9296,9 @@ __metadata:
     terser: ^5.27.0
     url: ^0.11.3
     worker-loader: ^3.0.8
+  dependenciesMeta:
+    canvas:
+      built: false
   languageName: unknown
   linkType: soft
 
@@ -11065,6 +11069,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"playwright-core@npm:^1.63.0":
+  version: 1.63.0
+  resolution: "playwright-core@npm:1.63.0"
+  bin:
+    playwright-core: cli.js
+  checksum: b4c190c4099d0620a9ba22a0e826194ad511c3149153a79c44dc632ac2058da7da01cf66f011ee3ee0f360bbd83aa2f67f04519eb3c7c2bea257c4f598537937
+  languageName: node
+  linkType: hard
+
 "plist@npm:^3.0.4":
   version: 3.0.6
   resolution: "plist@npm:3.0.6"