diff --git a/.kiro/skills/typescript/SKILL.md b/.kiro/skills/typescript/SKILL.md
index 4d571a364..14dbbe833 100644
--- a/.kiro/skills/typescript/SKILL.md
+++ b/.kiro/skills/typescript/SKILL.md
@@ -12,6 +12,16 @@ description: TypeScript conventions and rules for Graph Explorer, including bran
 - Every commit should have no type errors
 - Use explicit type aliases instead of `ReturnType<typeof ...>` when available (e.g., use `AppStore` instead of `ReturnType<typeof getAppStore>`)
 
+## Floating Promises
+
+`typescript/no-floating-promises` is enabled as an error, so every unhandled promise must be marked explicitly. Pick the idiom by meaning:
+
+- **`.catch(logAndNotify(message, options?))`** (`logAndNotify` from `@/utils`) — when the user should know about the failure. Logs via `logger.warn` and shows a warning toast with `message`. This is the idiom for persisted-atom writes from a user action (saving a connection, editing a style, toggling a setting). Build the `message` with `useTranslations` when it references node/edge vocabulary so it reads correctly per query engine; pass `options` for sonner extras like `description`.
+- **`.catch(logAndIgnore)`** (`logAndIgnore` from `@/utils`) — when a rejection is worth logging but not worth interrupting the user (e.g. a background canvas icon fetch). Logs via `logger.warn` only (warn, not error, since an ignored rejection is non-blocking).
+- **bare `void expr;`** — when the rejection is genuinely inert or already handled elsewhere: aborted `navigate()`, a refetch whose errors surface through query state, a self-catching async helper, and test-state seeding.
+
+See ADR `docs/adr/20260618-explicit-floating-promise-convention.md` for the full rationale.
+
 ## Branded Types
 
 The project uses branded types from `@/utils` for type safety. These prevent accidental mixing of similar types at compile time.
diff --git a/.oxlintrc.json b/.oxlintrc.json
index 316c65f83..d2d860fc0 100644
--- a/.oxlintrc.json
+++ b/.oxlintrc.json
@@ -28,7 +28,7 @@
     "jest/require-to-throw-message": "off",
     "jest/valid-expect": "off",
     "typescript/unbound-method": "off",
-    "typescript/no-floating-promises": "off",
+    "typescript/no-floating-promises": "error",
     "no-unused-vars": [
       "error",
       {
diff --git a/docs/adr/20260616-indexeddb-not-localstorage-for-persistence.md b/docs/adr/20260616-indexeddb-not-localstorage-for-persistence.md
index e4d6eae42..2af1174e6 100644
--- a/docs/adr/20260616-indexeddb-not-localstorage-for-persistence.md
+++ b/docs/adr/20260616-indexeddb-not-localstorage-for-persistence.md
@@ -2,7 +2,7 @@
 
 - **Status:** Accepted
 - **Date:** 2026-06-16
-- **Related:** ADR `per-key-diff-merge-cross-tab-reconciliation` builds the cross-tab fix on top of this constraint. Issue #1820.
+- **Related:** ADR `per-key-diff-merge-cross-tab-reconciliation` builds the cross-tab fix on top of this constraint. ADR `explicit-floating-promise-convention` makes this write path's fire-and-forget setters explicit. Issue #1820.
 
 ## Context
 
diff --git a/docs/adr/20260616-per-key-diff-merge-cross-tab-reconciliation.md b/docs/adr/20260616-per-key-diff-merge-cross-tab-reconciliation.md
index 104a8eff4..1dbbdf398 100644
--- a/docs/adr/20260616-per-key-diff-merge-cross-tab-reconciliation.md
+++ b/docs/adr/20260616-per-key-diff-merge-cross-tab-reconciliation.md
@@ -2,7 +2,7 @@
 
 - **Status:** Accepted
 - **Date:** 2026-06-16
-- **Related:** ADR `indexeddb-not-localstorage-for-persistence` (IndexedDB constraint) is the storage substrate this reconciliation runs on. Issue #1820 (the clobber bug); inverse of #1788 / per-tab active connection, which wants per-tab _divergence_ rather than reconciliation.
+- **Related:** ADR `indexeddb-not-localstorage-for-persistence` (IndexedDB constraint) is the storage substrate this reconciliation runs on. ADR `explicit-floating-promise-convention` makes the fire-and-forget setters on this write path explicit. Issue #1820 (the clobber bug); inverse of #1788 / per-tab active connection, which wants per-tab _divergence_ rather than reconciliation.
 
 ## Context
 
diff --git a/docs/adr/20260618-explicit-floating-promise-convention.md b/docs/adr/20260618-explicit-floating-promise-convention.md
new file mode 100644
index 000000000..7b363ecd4
--- /dev/null
+++ b/docs/adr/20260618-explicit-floating-promise-convention.md
@@ -0,0 +1,33 @@
+# ADR — Explicit handling of intentional floating promises
+
+- **Status:** Accepted
+- **Date:** 2026-06-18
+- **Related:** ADR `per-key-diff-merge-cross-tab-reconciliation` and `indexeddb-not-localstorage-for-persistence` describe the persistence write path whose fire-and-forget nature motivates this convention. Enables the `typescript/no-floating-promises` lint rule.
+
+## Context
+
+Many call sites start a promise and never await it. The most common is a write to a localForage-backed Jotai atom (`atomWithLocalForage`): the in-memory value updates synchronously, while the durable write happens in the background and is "never awaited in production" (see the write-path comment in `core/StateProvider/atomWithLocalForage.ts`). Other cases include react-router `navigate()`, fire-and-forget query refetches, and test-state seeding.
+
+Until now `typescript/no-floating-promises` was off, so these reads as ordinary statements. The hazard: a genuinely-swallowed persistence failure looks identical to an intentional fire-and-forget. The user's hypothesis was that some of those silent `store.set(...)` calls were latent bugs hiding behind that ambiguity.
+
+## Decision
+
+Turn on `typescript/no-floating-promises` (`error`) so every unhandled promise must be **explicitly** marked. Use one of three idioms by meaning:
+
+1. **`.catch(logAndNotify(message, options?))`** (`logAndNotify` from `@/utils`) — builds a `.catch` handler that logs the rejection via `logger.warn` **and** shows the user a warning toast. Use when an unawaited failure is something the **user should know about** — most persisted-atom writes from a user action (saving a connection, editing a style, toggling a setting). Each site passes its own message; query-language vocabulary (node/edge) is resolved with `useTranslations` at the call site so the toast reads correctly per engine (e.g. "resource" for SPARQL). `options` forwards sonner options such as `description`.
+
+2. **`.catch(logAndIgnore)`** (`logAndIgnore` from `@/utils`) — a `.catch` handler that only logs the rejection via `logger.warn`, no toast. Use when a rejection is **meaningful enough to log but not worth interrupting the user** — e.g. a background canvas icon fetch. (Warn, not error: an explicitly-ignored rejection is non-blocking by construction.)
+
+3. **bare `void expr;`** — use when a rejection is **genuinely inert** or already handled elsewhere: aborted `navigate()`, a refetch whose errors surface through query state, a self-catching async helper, and **test-state seeding** (a test seeding store state does not care whether the value lands in durable storage).
+
+Both `logAndNotify` and `logAndIgnore` log at `warn`; they differ only in whether the user is notified. The broader reconciliation contract for persistence errors (reject + per-key merge, per `per-key-diff-merge-cross-tab-reconciliation`) is still a separate effort; `logAndNotify` surfaces the failure but does not yet reconcile or retry the write.
+
+### Alternatives considered
+
+**Centralize the `.catch` inside `atomWithLocalForage` and return `void`.** The writer atom could attach its own `.catch(logAndIgnore)` and return `void`, deleting most of the ~25 `set(...).catch(logAndIgnore)` handlers at call sites. We rejected this for now because the in-flight persistence work (reject + toast, per `per-key-diff-merge-cross-tab-reconciliation`) needs _per-call-site_ control over how a failure is surfaced — a single swallow point in the writer would have to be unwound again to differentiate "log only" from "toast the user." Keeping the decision at each call site also keeps the persisted-write sites **greppable** for the #1854 audit. Once the surfacing contract is settled, collapsing the common case back into the writer is a reasonable follow-up.
+
+## Consequences
+
+- A swallowed persistence error is now either surfaced to the user (`.catch(logAndNotify(...))`), logged (`.catch(logAndIgnore)`), or a deliberate, reviewed `void` — no longer invisible.
+- Reviewers have a clear rule: user should know → `logAndNotify`; log-only → `logAndIgnore`; inert → `void`.
+- The lint rule prevents silent fire-and-forget from being reintroduced anywhere in the codebase.
diff --git a/packages/graph-explorer/src/components/Button/NavButton.tsx b/packages/graph-explorer/src/components/Button/NavButton.tsx
index 85db9844e..97821a7ea 100644
--- a/packages/graph-explorer/src/components/Button/NavButton.tsx
+++ b/packages/graph-explorer/src/components/Button/NavButton.tsx
@@ -24,7 +24,7 @@ function NavButton({ to, navOptions, ...props }: NavButtonProps) {
   const navigate = useNavigate();
 
   function handleClick() {
-    navigate(to, navOptions);
+    void navigate(to, navOptions);
   }
 
   return <Button {...props} onClick={handleClick} />;
diff --git a/packages/graph-explorer/src/components/Redirect.tsx b/packages/graph-explorer/src/components/Redirect.tsx
index fb325cada..7aa67d4d6 100644
--- a/packages/graph-explorer/src/components/Redirect.tsx
+++ b/packages/graph-explorer/src/components/Redirect.tsx
@@ -4,7 +4,7 @@ import { useNavigate } from "react-router";
 const Redirect = ({ to }: { to: string }) => {
   const navigate = useNavigate();
   useEffect(() => {
-    navigate(to, {
+    void navigate(to, {
       replace: true,
     });
   }, [navigate, to]);
diff --git a/packages/graph-explorer/src/components/utils/canvas/drawImage.ts b/packages/graph-explorer/src/components/utils/canvas/drawImage.ts
index c3fdc2dd5..ce5a5325b 100644
--- a/packages/graph-explorer/src/components/utils/canvas/drawImage.ts
+++ b/packages/graph-explorer/src/components/utils/canvas/drawImage.ts
@@ -1,4 +1,4 @@
-import { env } from "@/utils";
+import { env, logAndIgnore } from "@/utils";
 
 import type { BoundingBox } from "./types";
 
@@ -104,21 +104,23 @@ const drawImage = (
 
   if (src.match(/\.svg$/i)) {
     IMAGES_PENDING.add(`${src}::${color || "default"}`);
-    fetchIcon(src).then(icon => {
-      IMAGES_PENDING.delete(`${src}::${color || "default"}`);
-
-      let iconSrc = icon;
-      if (icon && color) {
-        iconSrc = colorizeSvg(icon, color);
-      }
-
-      if (!iconSrc) {
-        return;
-      }
-
-      createImage(iconSrc);
-      context.restore();
-    });
+    fetchIcon(src)
+      .then(icon => {
+        IMAGES_PENDING.delete(`${src}::${color || "default"}`);
+
+        let iconSrc = icon;
+        if (icon && color) {
+          iconSrc = colorizeSvg(icon, color);
+        }
+
+        if (!iconSrc) {
+          return;
+        }
+
+        createImage(iconSrc);
+        context.restore();
+      })
+      .catch(logAndIgnore);
 
     return;
   }
diff --git a/packages/graph-explorer/src/connector/LoggerConnector.test.ts b/packages/graph-explorer/src/connector/LoggerConnector.test.ts
index b0fc46e6d..7541b7d2e 100644
--- a/packages/graph-explorer/src/connector/LoggerConnector.test.ts
+++ b/packages/graph-explorer/src/connector/LoggerConnector.test.ts
@@ -1,3 +1,7 @@
+import { toast } from "sonner";
+
+import { logger } from "@/utils";
+
 import {
   ClientLoggerConnector,
   ServerLoggerConnector,
@@ -15,53 +19,70 @@ describe("ClientLoggerConnector", () => {
 });
 
 describe("ServerLoggerConnector", () => {
-  test("should send logs to the server", () => {
+  test("should send logs to the server", async () => {
     const mockFetch = vi.fn().mockResolvedValue({});
     vi.stubGlobal("fetch", mockFetch);
 
     const connector = new ServerLoggerConnector("https://example.com/");
 
-    connector.error("error msg");
+    await connector.error("error msg");
     expect(mockFetch).toHaveBeenCalledWith("https://example.com/logger", {
       method: "POST",
       headers: { level: "error", message: JSON.stringify("error msg") },
     });
 
-    connector.warn("warn msg");
+    await connector.warn("warn msg");
     expect(mockFetch).toHaveBeenCalledWith("https://example.com/logger", {
       method: "POST",
       headers: { level: "warn", message: JSON.stringify("warn msg") },
     });
 
-    connector.info("info msg");
+    await connector.info("info msg");
     expect(mockFetch).toHaveBeenCalledWith("https://example.com/logger", {
       method: "POST",
       headers: { level: "info", message: JSON.stringify("info msg") },
     });
 
-    connector.debug("debug msg");
+    await connector.debug("debug msg");
     expect(mockFetch).toHaveBeenCalledWith("https://example.com/logger", {
       method: "POST",
       headers: { level: "debug", message: JSON.stringify("debug msg") },
     });
 
-    connector.trace("trace msg");
+    await connector.trace("trace msg");
     expect(mockFetch).toHaveBeenCalledWith("https://example.com/logger", {
       method: "POST",
       headers: { level: "trace", message: JSON.stringify("trace msg") },
     });
   });
 
-  test("should strip trailing slash from connection URL", () => {
+  test("should strip trailing slash from connection URL", async () => {
     const mockFetch = vi.fn().mockResolvedValue({});
     vi.stubGlobal("fetch", mockFetch);
 
     const connector = new ServerLoggerConnector("https://example.com/");
-    connector.info("test");
+    await connector.info("test");
 
     expect(mockFetch).toHaveBeenCalledWith(
       "https://example.com/logger",
       expect.any(Object),
     );
   });
+
+  test("should warn the user and console when sending a log to the server fails", async () => {
+    const failure = new Error("network down");
+    vi.stubGlobal("fetch", vi.fn().mockRejectedValue(failure));
+
+    const connector = new ServerLoggerConnector("https://example.com/");
+
+    await expect(connector.error("error msg")).resolves.toBeUndefined();
+
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith(
+      "Failed to send log to server",
+      failure,
+    );
+    expect(vi.mocked(toast.warning)).toHaveBeenCalledWith(
+      "Failed to send log to the server.",
+    );
+  });
 });
diff --git a/packages/graph-explorer/src/connector/LoggerConnector.ts b/packages/graph-explorer/src/connector/LoggerConnector.ts
index 9edc2a4bb..08c67355f 100644
--- a/packages/graph-explorer/src/connector/LoggerConnector.ts
+++ b/packages/graph-explorer/src/connector/LoggerConnector.ts
@@ -1,13 +1,15 @@
+import { toast } from "sonner";
+
 import { logger } from "@/utils";
 
 export type LogLevel = "error" | "warn" | "info" | "debug" | "trace";
 
 export interface LoggerConnector {
-  error(message: unknown): void;
-  warn(message: unknown): void;
-  info(message: unknown): void;
-  debug(message: unknown): void;
-  trace(message: unknown): void;
+  error(message: unknown): Promise<void>;
+  warn(message: unknown): Promise<void>;
+  info(message: unknown): Promise<void>;
+  debug(message: unknown): Promise<void>;
+  trace(message: unknown): Promise<void>;
 }
 
 /** Sends log messages to the server in the connection configuration. */
@@ -22,56 +24,66 @@ export class ServerLoggerConnector implements LoggerConnector {
   }
 
   public error(message: unknown) {
-    this._clientLogger.error(message);
+    void this._clientLogger.error(message);
     return this._sendLog("error", message);
   }
 
   public warn(message: unknown) {
-    this._clientLogger.warn(message);
+    void this._clientLogger.warn(message);
     return this._sendLog("warn", message);
   }
 
   public info(message: unknown) {
-    this._clientLogger.info(message);
+    void this._clientLogger.info(message);
     return this._sendLog("info", message);
   }
 
   public debug(message: unknown) {
-    this._clientLogger.info(message);
+    void this._clientLogger.info(message);
     return this._sendLog("debug", message);
   }
 
   public trace(message: unknown) {
-    this._clientLogger.trace(message);
+    void this._clientLogger.trace(message);
     return this._sendLog("trace", message);
   }
 
-  private _sendLog(level: LogLevel, message: unknown) {
-    return fetch(this._baseUrl, {
-      method: "POST",
-      headers: {
-        level,
-        message: JSON.stringify(message),
-      },
-    }).catch(err => logger.error("Failed to send log to server", err));
+  private async _sendLog(level: LogLevel, message: unknown) {
+    try {
+      await fetch(this._baseUrl, {
+        method: "POST",
+        headers: {
+          level,
+          message: JSON.stringify(message),
+        },
+      });
+    } catch (error) {
+      logger.warn("Failed to send log to server", error);
+      toast.warning("Failed to send log to the server.");
+    }
   }
 }
 
 /** Sends logs to the browser's console. */
 export class ClientLoggerConnector implements LoggerConnector {
-  error(message: unknown): void {
+  error(message: unknown): Promise<void> {
     logger.error(message);
+    return Promise.resolve();
   }
-  warn(message: unknown): void {
+  warn(message: unknown): Promise<void> {
     logger.warn(message);
+    return Promise.resolve();
   }
-  info(message: unknown): void {
+  info(message: unknown): Promise<void> {
     logger.log(message);
+    return Promise.resolve();
   }
-  debug(message: unknown): void {
+  debug(message: unknown): Promise<void> {
     logger.debug(message);
+    return Promise.resolve();
   }
-  trace(message: unknown): void {
+  trace(message: unknown): Promise<void> {
     logger.log(message);
+    return Promise.resolve();
   }
 }
diff --git a/packages/graph-explorer/src/connector/gremlin/fetchSchema/index.ts b/packages/graph-explorer/src/connector/gremlin/fetchSchema/index.ts
index 53b55edb6..7452bd8af 100644
--- a/packages/graph-explorer/src/connector/gremlin/fetchSchema/index.ts
+++ b/packages/graph-explorer/src/connector/gremlin/fetchSchema/index.ts
@@ -102,7 +102,9 @@ const fetchVertexLabels = async (
   remoteLogger: LoggerConnector,
 ): Promise<Record<string, number>> => {
   const labelsTemplate = vertexLabelsTemplate();
-  remoteLogger.info("[Gremlin Explorer] Fetching vertex labels with counts...");
+  void remoteLogger.info(
+    "[Gremlin Explorer] Fetching vertex labels with counts...",
+  );
   const data = await gremlinFetch<RawVertexLabelsResponse>(labelsTemplate);
 
   const values = data.result.data["@value"][0]["@value"];
@@ -111,7 +113,7 @@ const fetchVertexLabels = async (
     labelsWithCounts[values[i] as string] = (values[i + 1] as GInt64)["@value"];
   }
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[Gremlin Explorer] Found ${Object.keys(labelsWithCounts).length} vertex labels.`,
   );
 
@@ -133,7 +135,7 @@ const fetchVerticesAttributes = async (
   // Batch in to sets of 100
   const batches = chunk(labels, DEFAULT_BATCH_REQUEST_SIZE);
 
-  remoteLogger.info("[Gremlin Explorer] Fetching vertices attributes...");
+  void remoteLogger.info("[Gremlin Explorer] Fetching vertices attributes...");
   for (const batch of batches) {
     const verticesTemplate = verticesSchemaTemplate({
       types: batch,
@@ -155,7 +157,7 @@ const fetchVerticesAttributes = async (
     }
   }
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[Gremlin Explorer] Found ${vertices.flatMap(v => v.attributes).length} vertex attributes across ${vertices.length} vertex types.`,
   );
 
@@ -182,7 +184,9 @@ const fetchEdgeLabels = async (
   remoteLogger: LoggerConnector,
 ): Promise<Record<string, number>> => {
   const labelsTemplate = edgeLabelsTemplate();
-  remoteLogger.info("[Gremlin Explorer] Fetching edge labels with counts...");
+  void remoteLogger.info(
+    "[Gremlin Explorer] Fetching edge labels with counts...",
+  );
   const data = await gremlinFetch<RawEdgeLabelsResponse>(labelsTemplate);
 
   const values = data.result.data["@value"][0]["@value"];
@@ -191,7 +195,7 @@ const fetchEdgeLabels = async (
     labelsWithCounts[values[i] as string] = (values[i + 1] as GInt64)["@value"];
   }
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[Gremlin Explorer] Found ${Object.keys(labelsWithCounts).length} edge labels.`,
   );
 
@@ -212,7 +216,7 @@ const fetchEdgesAttributes = async (
   // Batch in to sets of 100
   const batches = chunk(labels, DEFAULT_BATCH_REQUEST_SIZE);
 
-  remoteLogger.info("[Gremlin Explorer] Fetching edges attributes...");
+  void remoteLogger.info("[Gremlin Explorer] Fetching edges attributes...");
   for (const batch of batches) {
     const edgesTemplate = edgesSchemaTemplate({
       types: batch,
@@ -231,7 +235,7 @@ const fetchEdgesAttributes = async (
     }
   }
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[Gremlin Explorer] Found ${edges.flatMap(e => e.attributes).length} edge attributes across ${edges.length} edge types.`,
   );
 
@@ -270,7 +274,7 @@ const fetchSchema = async (
   summary?: GraphSummary,
 ): Promise<SchemaResponse> => {
   if (!summary) {
-    remoteLogger.info("[Gremlin Explorer] No summary statistics");
+    void remoteLogger.info("[Gremlin Explorer] No summary statistics");
 
     const vertices = await fetchVerticesSchema(gremlinFetch, remoteLogger);
     const totalVertices = vertices.reduce((total, vertex) => {
@@ -282,7 +286,7 @@ const fetchSchema = async (
       return total + (edge.total ?? 0);
     }, 0);
 
-    remoteLogger.info(
+    void remoteLogger.info(
       `[Gremlin Explorer] Schema sync successful (${totalVertices} vertices; ${totalEdges} edges; ${vertices.length} vertex types; ${edges.length} edge types)`,
     );
 
@@ -294,7 +298,7 @@ const fetchSchema = async (
     };
   }
 
-  remoteLogger.info("[Gremlin Explorer] Using summary statistics");
+  void remoteLogger.info("[Gremlin Explorer] Using summary statistics");
 
   const vertices = await fetchVerticesAttributes(
     gremlinFetch,
@@ -309,7 +313,7 @@ const fetchSchema = async (
     {},
   );
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[Gremlin Explorer] Schema sync successful (${summary.numNodes} vertices; ${summary.numEdges} edges; ${vertices.length} vertex types; ${edges.length} edge types)`,
   );
 
diff --git a/packages/graph-explorer/src/connector/gremlin/gremlinExplorer.ts b/packages/graph-explorer/src/connector/gremlin/gremlinExplorer.ts
index 874ac404d..254800699 100644
--- a/packages/graph-explorer/src/connector/gremlin/gremlinExplorer.ts
+++ b/packages/graph-explorer/src/connector/gremlin/gremlinExplorer.ts
@@ -81,7 +81,7 @@ export function createGremlinExplorer(
   return {
     connection: connection,
     async fetchSchema(options) {
-      remoteLogger.info("[Gremlin Explorer] Fetching schema...");
+      void remoteLogger.info("[Gremlin Explorer] Fetching schema...");
       const summary = await fetchSummary(connection, featureFlags, options);
       return fetchSchema(
         _gremlinFetch(connection, featureFlags, options),
@@ -90,21 +90,23 @@ export function createGremlinExplorer(
       );
     },
     async fetchVertexCountsByType(req, options) {
-      remoteLogger.info("[Gremlin Explorer] Fetching vertex counts by type...");
+      void remoteLogger.info(
+        "[Gremlin Explorer] Fetching vertex counts by type...",
+      );
       return fetchVertexTypeCounts(
         _gremlinFetch(connection, featureFlags, options),
         req,
       );
     },
     async fetchNeighbors(req, options) {
-      remoteLogger.info("[Gremlin Explorer] Fetching neighbors...");
+      void remoteLogger.info("[Gremlin Explorer] Fetching neighbors...");
       return fetchNeighbors(
         _gremlinFetch(connection, featureFlags, options),
         req,
       );
     },
     async neighborCounts(req, options) {
-      remoteLogger.info("[Gremlin Explorer] Fetching neighbors count...");
+      void remoteLogger.info("[Gremlin Explorer] Fetching neighbors count...");
       return neighborCounts(
         _gremlinFetch(connection, featureFlags, options),
         req,
@@ -114,7 +116,7 @@ export function createGremlinExplorer(
       options ??= {};
       options.queryId = v4();
 
-      remoteLogger.info("[Gremlin Explorer] Fetching keyword search...");
+      void remoteLogger.info("[Gremlin Explorer] Fetching keyword search...");
       return keywordSearch(
         _gremlinFetch(connection, featureFlags, options),
         req,
@@ -124,7 +126,7 @@ export function createGremlinExplorer(
       options ??= {};
       options.queryId = v4();
 
-      remoteLogger.info("[Gremlin Explorer] Fetching vertex details...");
+      void remoteLogger.info("[Gremlin Explorer] Fetching vertex details...");
       const result = await vertexDetails(
         _gremlinFetch(connection, featureFlags, options),
         req,
@@ -135,7 +137,7 @@ export function createGremlinExplorer(
       options ??= {};
       options.queryId = v4();
 
-      remoteLogger.info("[Gremlin Explorer] Fetching edge details...");
+      void remoteLogger.info("[Gremlin Explorer] Fetching edge details...");
       const result = await edgeDetails(
         _gremlinFetch(connection, featureFlags, options),
         req,
@@ -145,7 +147,7 @@ export function createGremlinExplorer(
     async rawQuery(req, options) {
       options ??= {};
       options.queryId = v4();
-      remoteLogger.info("[Gremlin Explorer] Fetching raw query...");
+      void remoteLogger.info("[Gremlin Explorer] Fetching raw query...");
       const result = await rawQuery(
         _gremlinFetch(connection, featureFlags, options),
         req,
@@ -153,7 +155,7 @@ export function createGremlinExplorer(
       return result;
     },
     async fetchEdgeConnections(req, options) {
-      remoteLogger.info("[Gremlin Explorer] Fetching edge connections...");
+      void remoteLogger.info("[Gremlin Explorer] Fetching edge connections...");
       return fetchEdgeConnections(
         _gremlinFetch(connection, featureFlags, options),
         req,
diff --git a/packages/graph-explorer/src/connector/openCypher/fetchSchema/index.ts b/packages/graph-explorer/src/connector/openCypher/fetchSchema/index.ts
index 369b98b5d..6e87aa7b0 100644
--- a/packages/graph-explorer/src/connector/openCypher/fetchSchema/index.ts
+++ b/packages/graph-explorer/src/connector/openCypher/fetchSchema/index.ts
@@ -67,7 +67,7 @@ const fetchVertexLabels = async (
   remoteLogger: LoggerConnector,
 ): Promise<Record<string, number>> => {
   const labelsTemplate = vertexLabelsTemplate();
-  remoteLogger.info(
+  void remoteLogger.info(
     "[openCypher Explorer] Fetching vertex labels with counts...",
   );
   const data = await openCypherFetch<RawVertexLabelsResponse>(labelsTemplate);
@@ -89,7 +89,7 @@ const fetchVertexLabels = async (
     labelsWithCounts[label] = vertex.count;
   }
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[openCypher Explorer] Found ${Object.keys(labelsWithCounts).length} vertex labels.`,
   );
 
@@ -107,7 +107,9 @@ const fetchVerticesAttributes = async (
     return [];
   }
 
-  remoteLogger.info("[openCypher Explorer] Fetching vertices attributes...");
+  void remoteLogger.info(
+    "[openCypher Explorer] Fetching vertices attributes...",
+  );
   const responses = await batchPromisesSerially(
     labels,
     DEFAULT_CONCURRENT_REQUESTS_LIMIT,
@@ -139,7 +141,7 @@ const fetchVerticesAttributes = async (
     })
     .filter(vertexSchema => vertexSchema != null);
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[openCypher Explorer] Found ${vertices.flatMap(v => v.attributes).length} vertex attributes across ${vertices.length} vertex types.`,
   );
 
@@ -168,7 +170,7 @@ const fetchEdgeLabels = async (
   remoteLogger: LoggerConnector,
 ): Promise<Record<string, number>> => {
   const labelsTemplate = edgeLabelsTemplate();
-  remoteLogger.info(
+  void remoteLogger.info(
     "[openCypher Explorer] Fetching edge labels with counts...",
   );
   const data = await openCypherFetch<RawEdgeLabelsResponse>(labelsTemplate);
@@ -195,7 +197,7 @@ const fetchEdgeLabels = async (
     labelsWithCounts[label] = edge.count;
   }
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[openCypher Explorer] Found ${Object.keys(labelsWithCounts).length} edge labels.`,
   );
 
@@ -213,7 +215,7 @@ const fetchEdgesAttributes = async (
     return [];
   }
 
-  remoteLogger.info("[openCypher Explorer] Fetching edges attributes...");
+  void remoteLogger.info("[openCypher Explorer] Fetching edges attributes...");
   const responses = await batchPromisesSerially(
     labels,
     DEFAULT_CONCURRENT_REQUESTS_LIMIT,
@@ -246,7 +248,7 @@ const fetchEdgesAttributes = async (
     })
     .filter(edgeSchema => edgeSchema != null);
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[openCypher Explorer] Found ${edges.flatMap(e => e.attributes).length} edge attributes across ${edges.length} edge types.`,
   );
 
@@ -290,7 +292,7 @@ const fetchSchema = async (
   summary?: GraphSummary,
 ): Promise<SchemaResponse> => {
   if (!summary) {
-    remoteLogger.info("[openCypher Explorer] No summary statistics");
+    void remoteLogger.info("[openCypher Explorer] No summary statistics");
 
     const vertices =
       (await fetchVerticesSchema(openCypherFetch, remoteLogger)) || [];
@@ -303,7 +305,7 @@ const fetchSchema = async (
       return total + (edge.total ?? 0);
     }, 0);
 
-    remoteLogger.info(
+    void remoteLogger.info(
       `[openCypher Explorer] Schema sync successful (${totalVertices} vertices; ${totalEdges} edges; ${vertices.length} vertex types; ${edges.length} edge types)`,
     );
 
@@ -315,7 +317,7 @@ const fetchSchema = async (
     };
   }
 
-  remoteLogger.info("[openCypher Explorer] Using summary statistics");
+  void remoteLogger.info("[openCypher Explorer] Using summary statistics");
 
   const vertices =
     (await fetchVerticesAttributes(
@@ -332,7 +334,7 @@ const fetchSchema = async (
       {},
     )) || [];
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[openCypher Explorer] Schema sync successful (${summary.numNodes} vertices; ${summary.numEdges} edges; ${vertices.length} vertex types; ${edges.length} edge types)`,
   );
 
diff --git a/packages/graph-explorer/src/connector/openCypher/openCypherExplorer.ts b/packages/graph-explorer/src/connector/openCypher/openCypherExplorer.ts
index ef66e182f..65dc560d9 100644
--- a/packages/graph-explorer/src/connector/openCypher/openCypherExplorer.ts
+++ b/packages/graph-explorer/src/connector/openCypher/openCypherExplorer.ts
@@ -50,7 +50,7 @@ export function createOpenCypherExplorer(
   return {
     connection,
     async fetchSchema(options) {
-      remoteLogger.info("[openCypher Explorer] Fetching schema...");
+      void remoteLogger.info("[openCypher Explorer] Fetching schema...");
       const summary = await fetchSummary(
         serviceType,
         connection,
@@ -64,7 +64,7 @@ export function createOpenCypherExplorer(
       );
     },
     async fetchVertexCountsByType(req, options) {
-      remoteLogger.info(
+      void remoteLogger.info(
         "[openCypher Explorer] Fetching vertex counts by type...",
       );
       return fetchVertexTypeCounts(
@@ -73,46 +73,54 @@ export function createOpenCypherExplorer(
       );
     },
     async fetchNeighbors(req, options) {
-      remoteLogger.info("[openCypher Explorer] Fetching neighbors...");
+      void remoteLogger.info("[openCypher Explorer] Fetching neighbors...");
       return fetchNeighbors(
         _openCypherFetch(connection, featureFlags, options),
         req,
       );
     },
     async neighborCounts(req, options) {
-      remoteLogger.info("[openCypher Explorer] Fetching neighbors count...");
+      void remoteLogger.info(
+        "[openCypher Explorer] Fetching neighbors count...",
+      );
       return neighborCounts(
         _openCypherFetch(connection, featureFlags, options),
         req,
       );
     },
     async keywordSearch(req, options) {
-      remoteLogger.info("[openCypher Explorer] Fetching keyword search...");
+      void remoteLogger.info(
+        "[openCypher Explorer] Fetching keyword search...",
+      );
       return keywordSearch(
         _openCypherFetch(connection, featureFlags, options),
         req,
       );
     },
     async vertexDetails(req, options) {
-      remoteLogger.info("[openCypher Explorer] Fetching vertex details...");
+      void remoteLogger.info(
+        "[openCypher Explorer] Fetching vertex details...",
+      );
       return vertexDetails(
         _openCypherFetch(connection, featureFlags, options),
         req,
       );
     },
     async edgeDetails(req, options) {
-      remoteLogger.info("[openCypher Explorer] Fetching edge details...");
+      void remoteLogger.info("[openCypher Explorer] Fetching edge details...");
       return edgeDetails(
         _openCypherFetch(connection, featureFlags, options),
         req,
       );
     },
     async rawQuery(req, options) {
-      remoteLogger.info("[openCypher Explorer] Fetching raw query...");
+      void remoteLogger.info("[openCypher Explorer] Fetching raw query...");
       return rawQuery(_openCypherFetch(connection, featureFlags, options), req);
     },
     async fetchEdgeConnections(req, options) {
-      remoteLogger.info("[openCypher Explorer] Fetching edge connections...");
+      void remoteLogger.info(
+        "[openCypher Explorer] Fetching edge connections...",
+      );
       return fetchEdgeConnections(
         _openCypherFetch(connection, featureFlags, options),
         req,
diff --git a/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.test.ts b/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.test.ts
index ecd46e3e9..1fef4edf9 100644
--- a/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.test.ts
+++ b/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.test.ts
@@ -36,7 +36,7 @@ describe("edgeConnectionsQuery", () => {
     const state = new DbState(explorer);
     const store = getAppStore();
     state.activeSchema.edgeConnections = undefined;
-    state.applyTo(store);
+    await state.applyTo(store);
 
     const fetchEdgeConnectionsSpy = vi.spyOn(explorer, "fetchEdgeConnections");
     const queryClient = createQueryClient();
@@ -62,7 +62,7 @@ describe("edgeConnectionsQuery", () => {
     const explorer = new FakeExplorer();
     const state = new DbState(explorer);
     const store = getAppStore();
-    state.applyTo(store);
+    await state.applyTo(store);
 
     const fetchEdgeConnectionsSpy = vi.spyOn(explorer, "fetchEdgeConnections");
 
@@ -93,7 +93,7 @@ describe("edgeConnectionsQuery", () => {
     const explorer = new FakeExplorer();
     const dbState = new DbState(explorer);
     const store = getAppStore();
-    dbState.applyTo(store);
+    await dbState.applyTo(store);
 
     const edge = createTestableEdge();
     explorer.addTestableEdge(edge);
@@ -113,7 +113,7 @@ describe("edgeConnectionsQuery", () => {
     const explorer = new FakeExplorer();
     const dbState = new DbState(explorer);
     const store = getAppStore();
-    dbState.applyTo(store);
+    await dbState.applyTo(store);
 
     vi.spyOn(explorer, "fetchEdgeConnections").mockRejectedValue(
       new Error("Network error"),
@@ -132,7 +132,7 @@ describe("edgeConnectionsQuery", () => {
     const explorer = new FakeExplorer();
     const state = new DbState(explorer);
     const store = getAppStore();
-    state.applyTo(store);
+    await state.applyTo(store);
 
     const source1 = createTestableVertex().with({
       types: [createVertexType("Person")],
@@ -166,7 +166,7 @@ describe("edgeConnectionsQuery", () => {
     const explorer = new FakeExplorer();
     const state = new DbState(explorer);
     const store = getAppStore();
-    state.applyTo(store);
+    await state.applyTo(store);
 
     const sourceType = createVertexType("Person");
     const targetType = createVertexType("Company");
@@ -197,7 +197,7 @@ describe("edgeConnectionsQuery", () => {
     const explorer = new FakeExplorer();
     const state = new DbState(explorer);
     const store = getAppStore();
-    state.applyTo(store);
+    await state.applyTo(store);
 
     // Set up initial edge connection
     const initialSourceType = createVertexType("Airport");
@@ -262,7 +262,7 @@ describe("edgeConnectionsQuery", () => {
     const explorer = new FakeExplorer();
     const state = new DbState(explorer);
     const store = getAppStore();
-    state.applyTo(store);
+    await state.applyTo(store);
 
     // Set up initial edge connection
     const sourceType = createVertexType("Person");
@@ -303,7 +303,7 @@ describe("edgeConnectionsQuery", () => {
 
     const edge = createRandomEdgeTypeConfig();
     state.activeSchema.edges = [edge];
-    state.applyTo(store);
+    await state.applyTo(store);
 
     vi.spyOn(explorer, "fetchEdgeConnections").mockImplementation(
       (_req: EdgeConnectionsRequest, options?: ExplorerRequestOptions) => {
@@ -337,7 +337,7 @@ describe("edgeConnectionsQuery", () => {
     const edge = createRandomEdgeTypeConfig();
     state.activeSchema.edges = [edge];
     state.activeSchema.edgeConnections = undefined;
-    state.applyTo(store);
+    await state.applyTo(store);
 
     vi.spyOn(explorer, "fetchEdgeConnections").mockRejectedValue(
       new Error("Connection failed"),
@@ -365,7 +365,7 @@ describe("edgeConnectionsQuery", () => {
 
     state.activeSchema.lastEdgeConnectionSyncFail = true;
     state.activeSchema.edgeConnections = undefined;
-    state.applyTo(store);
+    await state.applyTo(store);
 
     const sourceType = createVertexType("Person");
     const targetType = createVertexType("Company");
@@ -394,7 +394,7 @@ describe("edgeConnectionsQuery", () => {
     const edge = createRandomEdgeTypeConfig();
     state.activeSchema.edges = [edge];
     state.activeSchema.edgeConnections = existingEdgeConnections;
-    state.applyTo(store);
+    await state.applyTo(store);
 
     vi.spyOn(explorer, "fetchEdgeConnections").mockRejectedValue(
       new Error("Network error"),
diff --git a/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.ts b/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.ts
index ba2ecea2f..5aaddc659 100644
--- a/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.ts
+++ b/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.ts
@@ -8,7 +8,7 @@ import {
   schemaAtom,
   type SchemaStorageModel,
 } from "@/core";
-import { logger } from "@/utils";
+import { logAndNotify, logger } from "@/utils";
 
 import { getExplorer, getStore } from "./helpers";
 import { schemaSyncQueryKey } from "./schemaSyncQuery";
@@ -102,7 +102,7 @@ const setEdgeConnectionsAtom = atom(
         lastEdgeConnectionSyncFail: false,
       });
       return updated;
-    });
+    }).catch(logAndNotify("Failed to save the schema to the local cache."));
   },
 );
 
@@ -124,5 +124,5 @@ const setEdgeConnectionSyncFailedAtom = atom(null, (get, set) => {
       lastEdgeConnectionSyncFail: true,
     });
     return updated;
-  });
+  }).catch(logAndNotify("Failed to save the schema to the local cache."));
 });
diff --git a/packages/graph-explorer/src/connector/queries/nodeCountByNodeTypeQuery.test.ts b/packages/graph-explorer/src/connector/queries/nodeCountByNodeTypeQuery.test.ts
index 905eb2804..10f197880 100644
--- a/packages/graph-explorer/src/connector/queries/nodeCountByNodeTypeQuery.test.ts
+++ b/packages/graph-explorer/src/connector/queries/nodeCountByNodeTypeQuery.test.ts
@@ -45,7 +45,7 @@ describe("nodeCountByNodeTypeQuery", () => {
     state.activeSchema.vertices = [{ type: vertexType, attributes: [] }];
 
     const store = getAppStore();
-    state.applyTo(store);
+    await state.applyTo(store);
 
     const queryClient = createQueryClient();
 
@@ -122,7 +122,7 @@ describe("nodeCountByNodeTypeQuery", () => {
     state.activeSchema.vertices = [
       { type: differentVertexType, attributes: [] },
     ];
-    state.applyTo(getAppStore());
+    await state.applyTo(getAppStore());
 
     const queryClient = createQueryClient();
 
diff --git a/packages/graph-explorer/src/connector/queries/schemaSyncQuery.test.ts b/packages/graph-explorer/src/connector/queries/schemaSyncQuery.test.ts
index 94dd2c7a9..766182694 100644
--- a/packages/graph-explorer/src/connector/queries/schemaSyncQuery.test.ts
+++ b/packages/graph-explorer/src/connector/queries/schemaSyncQuery.test.ts
@@ -29,16 +29,16 @@ describe("schemaSyncQuery", () => {
   let explorer: FakeExplorer;
   let store: AppStore;
 
-  beforeEach(() => {
+  beforeEach(async () => {
     vi.restoreAllMocks();
     explorer = new FakeExplorer();
     store = getAppStore();
 
     // Set up a configuration so the schema can be stored
     const config = createRandomRawConfiguration();
-    store.set(configurationAtom, new Map([[config.id, config]]));
-    store.set(activeConfigurationAtom, config.id);
-    store.set(schemaAtom, new Map());
+    await store.set(configurationAtom, new Map([[config.id, config]]));
+    await store.set(activeConfigurationAtom, config.id);
+    await store.set(schemaAtom, new Map());
     store.set(explorerForTestingAtom, explorer);
   });
 
@@ -93,7 +93,7 @@ describe("schemaSyncQuery", () => {
     // Set up initial schema with different data
     const activeConfigId = store.get(activeConfigurationAtom)!;
     const oldVertexType = createVertexType("OldType");
-    store.set(schemaAtom, prev => {
+    await store.set(schemaAtom, prev => {
       const updated = new Map(prev);
       updated.set(activeConfigId, {
         vertices: [{ type: oldVertexType, attributes: [] }],
@@ -162,7 +162,7 @@ describe("schemaSyncQuery", () => {
   it("should clear edgeConnections on success", async () => {
     const activeConfigId = store.get(activeConfigurationAtom)!;
     const existingEdgeConnections = [createRandomEdgeConnection()];
-    store.set(schemaAtom, prev => {
+    await store.set(schemaAtom, prev => {
       const updated = new Map(prev);
       updated.set(activeConfigId, {
         vertices: [],
@@ -182,7 +182,7 @@ describe("schemaSyncQuery", () => {
   it("should clear lastSyncFail on success", async () => {
     // Set up a schema with lastSyncFail
     const activeConfigId = store.get(activeConfigurationAtom)!;
-    store.set(schemaAtom, prev => {
+    await store.set(schemaAtom, prev => {
       const updated = new Map(prev);
       updated.set(activeConfigId, {
         vertices: [],
@@ -203,7 +203,7 @@ describe("schemaSyncQuery", () => {
     // Set up initial schema
     const activeConfigId = store.get(activeConfigurationAtom)!;
     const initialVertexType = createVertexType(createRandomName("VertexType"));
-    store.set(schemaAtom, prev => {
+    await store.set(schemaAtom, prev => {
       const updated = new Map(prev);
       updated.set(activeConfigId, {
         vertices: [{ type: initialVertexType, attributes: [] }],
@@ -331,7 +331,7 @@ describe("schemaSyncQuery", () => {
   it("should preserve existing edgeConnections on failure", async () => {
     const activeConfigId = store.get(activeConfigurationAtom)!;
     const existingEdgeConnections = [createRandomEdgeConnection()];
-    store.set(schemaAtom, prev => {
+    await store.set(schemaAtom, prev => {
       const updated = new Map(prev);
       updated.set(activeConfigId, {
         vertices: [],
diff --git a/packages/graph-explorer/src/connector/queries/schemaSyncQuery.ts b/packages/graph-explorer/src/connector/queries/schemaSyncQuery.ts
index f5f10928e..3c8422323 100644
--- a/packages/graph-explorer/src/connector/queries/schemaSyncQuery.ts
+++ b/packages/graph-explorer/src/connector/queries/schemaSyncQuery.ts
@@ -13,7 +13,7 @@ import {
   getSchemaUris,
   type SchemaStorageModel,
 } from "@/core/StateProvider/schema";
-import { logger } from "@/utils";
+import { logAndNotify, logger } from "@/utils";
 
 import type { SchemaResponse } from "../useGEFetchTypes";
 
@@ -99,7 +99,7 @@ const replaceSchemaAtom = atom(
         lastSyncFail: false,
       });
       return updated;
-    });
+    }).catch(logAndNotify("Failed to save the schema to the local cache."));
   },
 );
 
@@ -121,5 +121,5 @@ const setSyncFailedAtom = atom(null, (get, set) => {
       lastSyncFail: true,
     });
     return updated;
-  });
+  }).catch(logAndNotify("Failed to save the schema to the local cache."));
 });
diff --git a/packages/graph-explorer/src/connector/sparql/fetchSchema/index.ts b/packages/graph-explorer/src/connector/sparql/fetchSchema/index.ts
index bcd7a80a4..3f807067b 100644
--- a/packages/graph-explorer/src/connector/sparql/fetchSchema/index.ts
+++ b/packages/graph-explorer/src/connector/sparql/fetchSchema/index.ts
@@ -91,7 +91,7 @@ const fetchPredicatesByClass = async (
       const classPredicatesTemplate = predicatesByClassTemplate({
         class: resourceClass,
       });
-      remoteLogger.info(
+      void remoteLogger.info(
         `[SPARQL Explorer] Fetching predicates by class ${resourceClass}...`,
       );
       const predicatesResponse =
@@ -142,7 +142,7 @@ const fetchClassesSchema = async (
   remoteLogger: LoggerConnector,
 ) => {
   const classesTemplate = classesWithCountsTemplates();
-  remoteLogger.info("[SPARQL Explorer] Fetching classes schema...");
+  void remoteLogger.info("[SPARQL Explorer] Fetching classes schema...");
   const classesCounts =
     await sparqlFetch<RawClassesWCountsResponse>(classesTemplate);
 
@@ -172,7 +172,9 @@ const fetchPredicatesWithCounts = async (
   remoteLogger: LoggerConnector,
 ): Promise<Record<string, number>> => {
   const template = predicatesWithCountsTemplate();
-  remoteLogger.info("[SPARQL Explorer] Fetching predicates with counts...");
+  void remoteLogger.info(
+    "[SPARQL Explorer] Fetching predicates with counts...",
+  );
   const data = await sparqlFetch<RawPredicatesWCountsResponse>(template);
 
   const values = data.results.bindings;
@@ -225,7 +227,7 @@ const fetchSchema = async (
       return total + (edge.total ?? 0);
     }, 0);
 
-    remoteLogger.info(
+    void remoteLogger.info(
       `[SPARQL Explorer] Schema sync successful (${totalVertices} vertices; ${totalEdges} edges; ${vertices.length} vertex types; ${edges.length} edge types)`,
     );
 
@@ -258,7 +260,7 @@ const fetchSchema = async (
     });
   });
 
-  remoteLogger.info(
+  void remoteLogger.info(
     `[SPARQL Explorer] Schema sync successful (${summary.numDistinctSubjects} vertices; ${summary.numQuads} edges; ${vertices.length} vertex types; ${edges.length} edge types)`,
   );
 
diff --git a/packages/graph-explorer/src/connector/sparql/sparqlExplorer.ts b/packages/graph-explorer/src/connector/sparql/sparqlExplorer.ts
index 94b9a64dc..dc9557acb 100644
--- a/packages/graph-explorer/src/connector/sparql/sparqlExplorer.ts
+++ b/packages/graph-explorer/src/connector/sparql/sparqlExplorer.ts
@@ -98,7 +98,7 @@ export function createSparqlExplorer(
   return {
     connection: connection,
     async fetchSchema(options) {
-      remoteLogger.info("[SPARQL Explorer] Fetching schema...");
+      void remoteLogger.info("[SPARQL Explorer] Fetching schema...");
       const summary = await fetchSummary(connection, featureFlags, options);
       return fetchSchema(
         _sparqlFetch(connection, featureFlags, options),
@@ -107,14 +107,16 @@ export function createSparqlExplorer(
       );
     },
     async fetchVertexCountsByType(req, options) {
-      remoteLogger.info("[SPARQL Explorer] Fetching vertex counts by type...");
+      void remoteLogger.info(
+        "[SPARQL Explorer] Fetching vertex counts by type...",
+      );
       return fetchClassCounts(
         _sparqlFetch(connection, featureFlags, options),
         req,
       );
     },
     async fetchNeighbors(req, options) {
-      remoteLogger.info("[SPARQL Explorer] Fetching neighbors...");
+      void remoteLogger.info("[SPARQL Explorer] Fetching neighbors...");
       const request: SPARQLNeighborsRequest = {
         resourceURI: req.vertexId,
         subjectClasses: req.filterByVertexTypes,
@@ -143,7 +145,7 @@ export function createSparqlExplorer(
       return { vertices, edges: response.edges };
     },
     async neighborCounts(req, options) {
-      remoteLogger.info("[SPARQL Explorer] Fetching neighbor counts...");
+      void remoteLogger.info("[SPARQL Explorer] Fetching neighbor counts...");
       return neighborCounts(
         _sparqlFetch(connection, featureFlags, options),
         req,
@@ -154,7 +156,7 @@ export function createSparqlExplorer(
       options ??= {};
       options.queryId = v4();
 
-      remoteLogger.info("[SPARQL Explorer] Fetching keyword search...");
+      void remoteLogger.info("[SPARQL Explorer] Fetching keyword search...");
 
       const reqParams: SPARQLKeywordSearchRequest = {
         searchTerm: req.searchTerm,
@@ -178,7 +180,7 @@ export function createSparqlExplorer(
       return { vertices };
     },
     async vertexDetails(req, options) {
-      remoteLogger.info("[SPARQL Explorer] Fetching vertex details...");
+      void remoteLogger.info("[SPARQL Explorer] Fetching vertex details...");
       return await vertexDetails(
         _sparqlFetch(connection, featureFlags, options),
         req,
@@ -188,14 +190,14 @@ export function createSparqlExplorer(
       return Promise.resolve(edgeDetails(req));
     },
     async rawQuery(req, options) {
-      remoteLogger.info("[SPARQL Explorer] Fetching raw query...");
+      void remoteLogger.info("[SPARQL Explorer] Fetching raw query...");
       return await rawQuery(
         _sparqlFetch(connection, featureFlags, options),
         req,
       );
     },
     async fetchEdgeConnections(req, options) {
-      remoteLogger.info("[SPARQL Explorer] Fetching edge connections...");
+      void remoteLogger.info("[SPARQL Explorer] Fetching edge connections...");
       return fetchEdgeConnections(
         _sparqlFetch(connection, featureFlags, options),
         req,
diff --git a/packages/graph-explorer/src/core/AppStatusLoader.tsx b/packages/graph-explorer/src/core/AppStatusLoader.tsx
index 36535788f..77d94a8a0 100644
--- a/packages/graph-explorer/src/core/AppStatusLoader.tsx
+++ b/packages/graph-explorer/src/core/AppStatusLoader.tsx
@@ -8,7 +8,7 @@ import {
 } from "react";
 
 import { PanelEmptyState, Spinner } from "@/components";
-import { logger } from "@/utils";
+import { logAndNotify, logger } from "@/utils";
 
 import { fetchDefaultConnection } from "./defaultConnection";
 import { activeConfigurationAtom, configurationAtom } from "./StateProvider";
@@ -54,8 +54,10 @@ function LoadDefaultConfig({ children }: PropsWithChildren) {
           updatedConfig.set(config.id, config);
         });
         return updatedConfig;
-      });
-      setActiveConfig(defaultConnectionConfigs[0].id);
+      }).catch(logAndNotify("Failed to save the default connection."));
+      setActiveConfig(defaultConnectionConfigs[0].id).catch(
+        logAndNotify("Failed to save the default connection."),
+      );
     });
   }, [
     activeConfig,
diff --git a/packages/graph-explorer/src/core/StateProvider/atomWithLocalForage.test.ts b/packages/graph-explorer/src/core/StateProvider/atomWithLocalForage.test.ts
index 9765cdb5c..6b0c23424 100644
--- a/packages/graph-explorer/src/core/StateProvider/atomWithLocalForage.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/atomWithLocalForage.test.ts
@@ -23,7 +23,7 @@ describe("atomWithLocalForage", () => {
     const key = "test-write";
     const atom = await atomWithLocalForage(key, "initial");
 
-    store.set(atom, "new-value");
+    await store.set(atom, "new-value");
 
     // Wait a bit for async persistence
     await new Promise(resolve => setTimeout(resolve, 10));
@@ -59,7 +59,7 @@ describe("atomWithLocalForage", () => {
   test("should handle function updates", async () => {
     const atom = await atomWithLocalForage("test-fn", 10);
 
-    store.set(atom, prev => prev + 5);
+    await store.set(atom, prev => prev + 5);
 
     expect(store.get(atom)).toBe(15);
   });
@@ -107,7 +107,7 @@ describe("atomWithLocalForage", () => {
 
     const atom = await atomWithLocalForage(key, {});
 
-    store.set(atom, complexObject);
+    await store.set(atom, complexObject);
 
     expect(store.get(atom)).toBe(complexObject);
 
@@ -139,9 +139,9 @@ describe("atomWithLocalForage", () => {
     const atom = await atomWithLocalForage(key, 0);
 
     // Rapid writes
-    store.set(atom, 1);
-    store.set(atom, 2);
-    store.set(atom, 3);
+    await store.set(atom, 1);
+    await store.set(atom, 2);
+    await store.set(atom, 3);
 
     expect(store.get(atom)).toBe(3);
 
@@ -155,22 +155,22 @@ describe("atomWithLocalForage", () => {
   test("should work with different data types", async () => {
     // String
     const stringAtom = await atomWithLocalForage("test-string", "hello");
-    store.set(stringAtom, "world");
+    await store.set(stringAtom, "world");
     expect(store.get(stringAtom)).toBe("world");
 
     // Number
     const numberAtom = await atomWithLocalForage("test-number", 42);
-    store.set(numberAtom, 100);
+    await store.set(numberAtom, 100);
     expect(store.get(numberAtom)).toBe(100);
 
     // Boolean
     const boolAtom = await atomWithLocalForage("test-bool", false);
-    store.set(boolAtom, true);
+    await store.set(boolAtom, true);
     expect(store.get(boolAtom)).toBe(true);
 
     // Array
     const arrayAtom = await atomWithLocalForage("test-array", [1, 2]);
-    store.set(arrayAtom, [3, 4, 5]);
+    await store.set(arrayAtom, [3, 4, 5]);
     expect(store.get(arrayAtom)).toEqual([3, 4, 5]);
 
     // Object
@@ -180,7 +180,7 @@ describe("atomWithLocalForage", () => {
         a: 1,
       },
     );
-    store.set(objAtom, { b: 2 });
+    await store.set(objAtom, { b: 2 });
     expect(store.get(objAtom)).toEqual({ b: 2 });
   });
 });
diff --git a/packages/graph-explorer/src/core/StateProvider/displayEdge.test.ts b/packages/graph-explorer/src/core/StateProvider/displayEdge.test.ts
index 4276d9bfb..755c6c0b4 100644
--- a/packages/graph-explorer/src/core/StateProvider/displayEdge.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/displayEdge.test.ts
@@ -39,38 +39,41 @@ describe("useDisplayEdgeFromEdge", () => {
     dbState = new DbState();
   });
 
-  function renderHookDisplayEdgeFromEdge(edge: Edge) {
-    return renderHookWithState(() => useDisplayEdgeFromEdge(edge), dbState);
+  async function renderHookDisplayEdgeFromEdge(edge: Edge) {
+    return await renderHookWithState(
+      () => useDisplayEdgeFromEdge(edge),
+      dbState,
+    );
   }
 
-  it("should keep the same ID", () => {
+  it("should keep the same ID", async () => {
     const edge = createRandomEdge();
-    expect(act(edge).id).toStrictEqual(edge.id);
+    expect((await act(edge)).id).toStrictEqual(edge.id);
   });
 
-  it("should be an edge", () => {
+  it("should be an edge", async () => {
     const edge = createRandomEdge();
-    expect(act(edge).entityType).toStrictEqual("edge");
+    expect((await act(edge)).entityType).toStrictEqual("edge");
   });
 
-  it("should have a display ID equal to the edge ID", () => {
+  it("should have a display ID equal to the edge ID", async () => {
     const edge = createRandomEdge();
-    expect(act(edge).displayId).toStrictEqual(getRawId(edge.id));
+    expect((await act(edge)).displayId).toStrictEqual(getRawId(edge.id));
   });
 
-  it("should have the display name be the types", () => {
+  it("should have the display name be the types", async () => {
     const edge = createRandomEdge();
-    expect(act(edge).displayName).toStrictEqual(edge.type);
+    expect((await act(edge)).displayName).toStrictEqual(edge.type);
   });
 
-  it("should contain the ID of the source and target vertices", () => {
+  it("should contain the ID of the source and target vertices", async () => {
     const edge = createRandomEdge();
 
-    expect(act(edge).sourceId).toStrictEqual(String(edge.sourceId));
-    expect(act(edge).targetId).toStrictEqual(String(edge.targetId));
+    expect((await act(edge)).sourceId).toStrictEqual(String(edge.sourceId));
+    expect((await act(edge)).targetId).toStrictEqual(String(edge.targetId));
   });
 
-  it("should have display name that matches the attribute value", () => {
+  it("should have display name that matches the attribute value", async () => {
     const edge = createRandomEdge();
     // Get the first attribute
     const attribute = Object.entries(edge.attributes).map(([name, value]) => ({
@@ -82,14 +85,14 @@ describe("useDisplayEdgeFromEdge", () => {
       displayNameAttribute: attribute.name,
     });
 
-    const { result } = renderHookDisplayEdgeFromEdge(edge);
+    const { result } = await renderHookDisplayEdgeFromEdge(edge);
 
     expect(result.current.displayName).toStrictEqual(
       getDisplayValueForScalar(attribute.value),
     );
   });
 
-  it("should have display name that matches the types when displayNameAttribute is 'type'", () => {
+  it("should have display name that matches the types when displayNameAttribute is 'type'", async () => {
     const edge = createRandomEdge();
     const schema = createRandomSchema();
 
@@ -99,11 +102,11 @@ describe("useDisplayEdgeFromEdge", () => {
     schema.edges.push(etConfig);
 
     expect(
-      act(edge, withSchemaAndConnection(schema, "gremlin")).displayName,
+      (await act(edge, withSchemaAndConnection(schema, "gremlin"))).displayName,
     ).toStrictEqual(edge.type);
   });
 
-  it("should ignore display label from schema", () => {
+  it("should ignore display label from schema", async () => {
     const dbState = new DbState();
     const edge = createRandomEdge();
 
@@ -112,7 +115,7 @@ describe("useDisplayEdgeFromEdge", () => {
     etConfig.displayLabel = createRandomName("schema");
     dbState.activeSchema.edges.push(etConfig);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useDisplayEdgeFromEdge(edge),
       dbState,
     );
@@ -120,7 +123,7 @@ describe("useDisplayEdgeFromEdge", () => {
     expect(result.current.displayTypes).toStrictEqual(edge.type);
   });
 
-  it("should use display label from user preferences", () => {
+  it("should use display label from user preferences", async () => {
     const dbState = new DbState();
     const edge = createRandomEdge();
 
@@ -134,7 +137,7 @@ describe("useDisplayEdgeFromEdge", () => {
     edgePrefs.displayLabel = createRandomName("prefs");
     dbState.activeStyling.edges?.push(edgePrefs);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useDisplayEdgeFromEdge(edge),
       dbState,
     );
@@ -142,7 +145,7 @@ describe("useDisplayEdgeFromEdge", () => {
     expect(result.current.displayTypes).toStrictEqual(edgePrefs.displayLabel);
   });
 
-  it("should have display types that list all types in gremlin", () => {
+  it("should have display types that list all types in gremlin", async () => {
     const edge = createRandomEdge();
     const schema = createRandomSchema();
 
@@ -153,11 +156,12 @@ describe("useDisplayEdgeFromEdge", () => {
     edge.type = etConfig.type;
 
     expect(
-      act(edge, withSchemaAndConnection(schema, "gremlin")).displayTypes,
+      (await act(edge, withSchemaAndConnection(schema, "gremlin")))
+        .displayTypes,
     ).toStrictEqual(etConfig.type);
   });
 
-  it("should have display types that list all types in sparql", () => {
+  it("should have display types that list all types in sparql", async () => {
     const edge = createRandomEdge();
     edge.type = createEdgeType("http://www.example.com/class#bar");
     const schema = createRandomSchema();
@@ -175,11 +179,11 @@ describe("useDisplayEdgeFromEdge", () => {
     edge.type = etConfig.type;
 
     expect(
-      act(edge, withSchemaAndConnection(schema, "sparql")).displayTypes,
+      (await act(edge, withSchemaAndConnection(schema, "sparql"))).displayTypes,
     ).toStrictEqual(`example-class:bar`);
   });
 
-  it("should have sorted attributes", () => {
+  it("should have sorted attributes", async () => {
     const edge = createRandomEdge();
     const attributes: DisplayAttribute[] = Object.entries(edge.attributes)
       .map(([key, value]) => ({
@@ -189,10 +193,10 @@ describe("useDisplayEdgeFromEdge", () => {
       }))
       .toSorted((a, b) => a.displayLabel.localeCompare(b.displayLabel));
 
-    expect(act(edge).attributes).toStrictEqual(attributes);
+    expect((await act(edge)).attributes).toStrictEqual(attributes);
   });
 
-  it("should format date values in attribute", () => {
+  it("should format date values in attribute", async () => {
     const edge = createRandomEdge();
     const schema = createRandomSchema();
 
@@ -201,15 +205,15 @@ describe("useDisplayEdgeFromEdge", () => {
       created: createRandomDate(),
     };
 
-    const actualAttribute = act(edge, withSchema(schema)).attributes.find(
-      attr => attr.name === "created",
-    );
+    const actualAttribute = (
+      await act(edge, withSchema(schema))
+    ).attributes.find(attr => attr.name === "created");
     expect(actualAttribute?.displayValue).toStrictEqual(
       formatDate(new Date(edge.attributes.created as any)),
     );
   });
 
-  it("should format date values in attribute", () => {
+  it("should format date values in attribute", async () => {
     const edge = createRandomEdge();
     const schema = createRandomSchema();
 
@@ -218,9 +222,9 @@ describe("useDisplayEdgeFromEdge", () => {
       created: createRandomDate(),
     };
 
-    const actualAttribute = act(edge, withSchema(schema)).attributes.find(
-      attr => attr.name === "created",
-    );
+    const actualAttribute = (
+      await act(edge, withSchema(schema))
+    ).attributes.find(attr => attr.name === "created");
     expect(actualAttribute?.displayValue).toStrictEqual(
       formatDate(new Date(edge.attributes.created as any)),
     );
@@ -228,8 +232,11 @@ describe("useDisplayEdgeFromEdge", () => {
 
   // Helpers
 
-  function act(edge: Edge, initializeState?: (store: AppStore) => void) {
-    const { result } = renderHookWithJotai(
+  async function act(
+    edge: Edge,
+    initializeState?: (store: AppStore) => void | Promise<void>,
+  ) {
+    const { result } = await renderHookWithJotai(
       () => useDisplayEdgeFromEdge(edge),
       initializeState,
     );
@@ -238,10 +245,10 @@ describe("useDisplayEdgeFromEdge", () => {
 
   function withSchema(schema: SchemaStorageModel) {
     const config = createRandomRawConfiguration();
-    return (store: AppStore) => {
-      store.set(configurationAtom, new Map([[config.id, config]]));
-      store.set(schemaAtom, new Map([[config.id, schema]]));
-      store.set(activeConfigurationAtom, config.id);
+    return async (store: AppStore) => {
+      await store.set(configurationAtom, new Map([[config.id, config]]));
+      await store.set(schemaAtom, new Map([[config.id, schema]]));
+      await store.set(activeConfigurationAtom, config.id);
     };
   }
 
@@ -251,10 +258,10 @@ describe("useDisplayEdgeFromEdge", () => {
   ) {
     const config = createRandomRawConfiguration();
     config.connection!.queryEngine = queryEngine;
-    return (store: AppStore) => {
-      store.set(configurationAtom, new Map([[config.id, config]]));
-      store.set(schemaAtom, new Map([[config.id, schema]]));
-      store.set(activeConfigurationAtom, config.id);
+    return async (store: AppStore) => {
+      await store.set(configurationAtom, new Map([[config.id, config]]));
+      await store.set(schemaAtom, new Map([[config.id, schema]]));
+      await store.set(activeConfigurationAtom, config.id);
     };
   }
 });
diff --git a/packages/graph-explorer/src/core/StateProvider/displayTypeConfigs.test.ts b/packages/graph-explorer/src/core/StateProvider/displayTypeConfigs.test.ts
index 7c21963ee..d09ffae5f 100644
--- a/packages/graph-explorer/src/core/StateProvider/displayTypeConfigs.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/displayTypeConfigs.test.ts
@@ -27,10 +27,10 @@ import { RDFS_LABEL_URI } from "./sortAttributeByName";
 const identityTextTransform: TextTransformer = (text: string) => text;
 
 describe("useDisplayVertexTypeConfig", () => {
-  it("should use default values when the vertex type is not in the schema", () => {
+  it("should use default values when the vertex type is not in the schema", async () => {
     const vtConfig = createRandomVertexTypeConfig();
 
-    const { result } = renderHookWithState(() =>
+    const { result } = await renderHookWithState(() =>
       useDisplayVertexTypeConfig(vtConfig.type),
     );
 
@@ -38,21 +38,21 @@ describe("useDisplayVertexTypeConfig", () => {
     expect(result.current.displayLabel).toBe(vtConfig.type);
   });
 
-  it("should use missing value string when type is empty", () => {
-    const { result } = renderHookWithState(() =>
+  it("should use missing value string when type is empty", async () => {
+    const { result } = await renderHookWithState(() =>
       useDisplayVertexTypeConfig(createVertexType("")),
     );
 
     expect(result.current.displayLabel).toBe(LABELS.MISSING_TYPE);
   });
 
-  it("should ignore display label from schema", () => {
+  it("should ignore display label from schema", async () => {
     const dbState = new DbState();
     const vtConfig = createRandomVertexTypeConfig();
     vtConfig.displayLabel = createRandomName("displayLabel");
     dbState.activeSchema.vertices.push(vtConfig);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useDisplayVertexTypeConfig(vtConfig.type),
       dbState,
     );
@@ -60,14 +60,14 @@ describe("useDisplayVertexTypeConfig", () => {
     expect(result.current.displayLabel).toBe(vtConfig.type);
   });
 
-  it("should use display label from user preferences", () => {
+  it("should use display label from user preferences", async () => {
     const dbState = new DbState();
     const vtConfig = createRandomVertexTypeConfig();
     vtConfig.displayLabel = createRandomName("displayLabel");
     dbState.activeSchema.vertices.push(vtConfig);
     dbState.activeStyling.vertices?.push(vtConfig);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useDisplayVertexTypeConfig(vtConfig.type),
       dbState,
     );
@@ -340,21 +340,21 @@ describe("mapToDisplayEdgeTypeConfig", () => {
 });
 
 describe("useDisplayEdgeTypeConfig", () => {
-  it("should use empty label constant when the type is empty", () => {
-    const { result } = renderHookWithState(() =>
+  it("should use empty label constant when the type is empty", async () => {
+    const { result } = await renderHookWithState(() =>
       useDisplayEdgeTypeConfig(createEdgeType("")),
     );
 
     expect(result.current.displayLabel).toBe(LABELS.MISSING_TYPE);
   });
 
-  it("should ignore display label from the config", () => {
+  it("should ignore display label from the config", async () => {
     const dbState = new DbState();
     const etConfig = createRandomEdgeTypeConfig();
     etConfig.displayLabel = createRandomName("displayLabel");
     dbState.activeSchema.edges.push(etConfig);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useDisplayEdgeTypeConfig(etConfig.type),
       dbState,
     );
@@ -362,14 +362,14 @@ describe("useDisplayEdgeTypeConfig", () => {
     expect(result.current.displayLabel).toBe(etConfig.type);
   });
 
-  it("should use display label from the user preferences", () => {
+  it("should use display label from the user preferences", async () => {
     const dbState = new DbState();
     const etConfig = createRandomEdgeTypeConfig();
     etConfig.displayLabel = createRandomName("displayLabel");
     dbState.activeSchema.edges.push(etConfig);
     dbState.activeStyling.edges?.push(etConfig);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useDisplayEdgeTypeConfig(etConfig.type),
       dbState,
     );
@@ -379,11 +379,11 @@ describe("useDisplayEdgeTypeConfig", () => {
 });
 
 describe("useSearchableAttributes", () => {
-  it("should return empty array when no vertex types exist", () => {
+  it("should return empty array when no vertex types exist", async () => {
     const dbState = new DbState();
     dbState.activeSchema.vertices = [];
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useSearchableAttributes(SEARCH_TOKENS.ALL_VERTEX_TYPES),
       dbState,
     );
@@ -391,7 +391,7 @@ describe("useSearchableAttributes", () => {
     expect(result.current).toStrictEqual([]);
   });
 
-  it("should return only searchable attributes for a specific vertex type", () => {
+  it("should return only searchable attributes for a specific vertex type", async () => {
     const dbState = new DbState();
     dbState.activeSchema.vertices = [];
     const vtConfig = createRandomVertexTypeConfig();
@@ -403,7 +403,7 @@ describe("useSearchableAttributes", () => {
     ];
     dbState.activeSchema.vertices.push(vtConfig);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useSearchableAttributes(vtConfig.type),
       dbState,
     );
@@ -418,13 +418,13 @@ describe("useSearchableAttributes", () => {
     ]);
   });
 
-  it("should return empty array when type does not exist", () => {
+  it("should return empty array when type does not exist", async () => {
     const dbState = new DbState();
     dbState.activeSchema.vertices = [];
     const vtConfig = createRandomVertexTypeConfig();
     dbState.activeSchema.vertices.push(vtConfig);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useSearchableAttributes("nonexistent-type"),
       dbState,
     );
@@ -432,7 +432,7 @@ describe("useSearchableAttributes", () => {
     expect(result.current).toStrictEqual([]);
   });
 
-  it("should return searchable attributes from all vertex types when using ALL_VERTEX_TYPES", () => {
+  it("should return searchable attributes from all vertex types when using ALL_VERTEX_TYPES", async () => {
     const dbState = new DbState();
     dbState.activeSchema.vertices = [];
 
@@ -450,7 +450,7 @@ describe("useSearchableAttributes", () => {
     ];
     dbState.activeSchema.vertices.push(vtConfig2);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useSearchableAttributes(SEARCH_TOKENS.ALL_VERTEX_TYPES),
       dbState,
     );
@@ -471,7 +471,7 @@ describe("useSearchableAttributes", () => {
     ]);
   });
 
-  it("should deduplicate searchable attributes with the same name across vertex types", () => {
+  it("should deduplicate searchable attributes with the same name across vertex types", async () => {
     const dbState = new DbState();
     dbState.activeSchema.vertices = [];
 
@@ -489,7 +489,7 @@ describe("useSearchableAttributes", () => {
     ];
     dbState.activeSchema.vertices.push(vtConfig2);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useSearchableAttributes(SEARCH_TOKENS.ALL_VERTEX_TYPES),
       dbState,
     );
@@ -516,7 +516,7 @@ describe("useSearchableAttributes", () => {
     ]);
   });
 
-  it("should sort attributes by display label", () => {
+  it("should sort attributes by display label", async () => {
     const dbState = new DbState();
     dbState.activeSchema.vertices = [];
     const vtConfig = createRandomVertexTypeConfig();
@@ -527,7 +527,7 @@ describe("useSearchableAttributes", () => {
     ];
     dbState.activeSchema.vertices.push(vtConfig);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useSearchableAttributes(vtConfig.type),
       dbState,
     );
diff --git a/packages/graph-explorer/src/core/StateProvider/displayVertex.test.ts b/packages/graph-explorer/src/core/StateProvider/displayVertex.test.ts
index 020b513fe..1614dff5d 100644
--- a/packages/graph-explorer/src/core/StateProvider/displayVertex.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/displayVertex.test.ts
@@ -34,40 +34,40 @@ import {
 } from "@/utils/testing";
 
 describe("useDisplayVertexFromVertex", () => {
-  it("should keep the same ID", () => {
+  it("should keep the same ID", async () => {
     const vertex = createRandomVertex();
-    expect(act(vertex).id).toStrictEqual(vertex.id);
+    expect((await act(vertex)).id).toStrictEqual(vertex.id);
   });
 
-  it("should be a vertex", () => {
+  it("should be a vertex", async () => {
     const vertex = createRandomVertex();
-    expect(act(vertex).entityType).toStrictEqual("vertex");
+    expect((await act(vertex)).entityType).toStrictEqual("vertex");
   });
 
-  it("should have a display ID equal to the vertex ID", () => {
+  it("should have a display ID equal to the vertex ID", async () => {
     const vertex = createRandomVertex();
-    expect(act(vertex).displayId).toStrictEqual(getRawId(vertex.id));
+    expect((await act(vertex)).displayId).toStrictEqual(getRawId(vertex.id));
   });
 
-  it("should have the display name be the sanitized vertex ID", () => {
+  it("should have the display name be the sanitized vertex ID", async () => {
     const vertex = createRandomVertex();
-    expect(act(vertex).displayName).toStrictEqual(getRawId(vertex.id));
+    expect((await act(vertex)).displayName).toStrictEqual(getRawId(vertex.id));
   });
 
-  it("should have the display description be the vertex type", () => {
+  it("should have the display description be the vertex type", async () => {
     const vertex = createRandomVertex();
-    expect(act(vertex).displayDescription).toStrictEqual(vertex.type);
+    expect((await act(vertex)).displayDescription).toStrictEqual(vertex.type);
   });
 
-  it("should have the display types be missing type label when no types", () => {
+  it("should have the display types be missing type label when no types", async () => {
     const vertex = createVertex({
       id: createRandomVertexId(),
       types: [],
     });
-    expect(act(vertex).displayTypes).toStrictEqual(LABELS.MISSING_TYPE);
+    expect((await act(vertex)).displayTypes).toStrictEqual(LABELS.MISSING_TYPE);
   });
 
-  it("should use the display label from user preferences", () => {
+  it("should use the display label from user preferences", async () => {
     const dbState = new DbState();
     const vertex = createRandomVertex();
 
@@ -83,7 +83,7 @@ describe("useDisplayVertexFromVertex", () => {
     userPrefs.displayLabel = createRandomName("userPrefs");
     dbState.activeStyling.vertices?.push(userPrefs);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useDisplayVertexFromVertex(vertex),
       dbState,
     );
@@ -91,7 +91,7 @@ describe("useDisplayVertexFromVertex", () => {
     expect(result.current.displayTypes).toStrictEqual(userPrefs.displayLabel);
   });
 
-  it("should have display types that list all types in gremlin", () => {
+  it("should have display types that list all types in gremlin", async () => {
     const vertex = createRandomVertex();
     const schema = createRandomSchema();
 
@@ -105,11 +105,12 @@ describe("useDisplayVertexFromVertex", () => {
     vertex.types = [vtConfig1.type, vtConfig2.type];
 
     expect(
-      act(vertex, withSchemaAndConnection(schema, "gremlin")).displayTypes,
+      (await act(vertex, withSchemaAndConnection(schema, "gremlin")))
+        .displayTypes,
     ).toStrictEqual(`${vtConfig1.type}, ${vtConfig2.type}`);
   });
 
-  it("should have display types that list all types in sparql", () => {
+  it("should have display types that list all types in sparql", async () => {
     const vertex = createRandomVertex();
     vertex.type = createVertexType("http://www.example.com/class#bar");
     const schema = createRandomSchema();
@@ -133,11 +134,12 @@ describe("useDisplayVertexFromVertex", () => {
     vertex.types = [vtConfig1.type, vtConfig2.type];
 
     expect(
-      act(vertex, withSchemaAndConnection(schema, "sparql")).displayTypes,
+      (await act(vertex, withSchemaAndConnection(schema, "sparql")))
+        .displayTypes,
     ).toStrictEqual(`example-class:bar, example-class:baz`);
   });
 
-  it("should have sorted attributes", () => {
+  it("should have sorted attributes", async () => {
     const vertex = createRandomVertex();
     const attributes: DisplayAttribute[] = Object.entries(vertex.attributes)
       .map(([key, value]) => ({
@@ -147,10 +149,10 @@ describe("useDisplayVertexFromVertex", () => {
       }))
       .toSorted((a, b) => a.displayLabel.localeCompare(b.displayLabel));
 
-    expect(act(vertex).attributes).toStrictEqual(attributes);
+    expect((await act(vertex)).attributes).toStrictEqual(attributes);
   });
 
-  it("should format date values in attribute", () => {
+  it("should format date values in attribute", async () => {
     const vertex = createRandomVertex();
     const schema = createRandomSchema();
 
@@ -159,29 +161,29 @@ describe("useDisplayVertexFromVertex", () => {
       created: createRandomDate(),
     };
 
-    const actualAttribute = act(vertex, withSchema(schema)).attributes.find(
-      attr => attr.name === "created",
-    );
+    const actualAttribute = (
+      await act(vertex, withSchema(schema))
+    ).attributes.find(attr => attr.name === "created");
     expect(actualAttribute?.displayValue).toStrictEqual(
       formatDate(new Date(vertex.attributes.created as any)),
     );
   });
 
-  it("should not add missing attributes from schema config", () => {
+  it("should not add missing attributes from schema config", async () => {
     const vertex = createRandomVertex();
     const schema = createRandomSchema();
     const vtConfig = createRandomVertexTypeConfig();
     vtConfig.type = vertex.type;
     schema.vertices.push(vtConfig);
 
-    const result = act(vertex, withSchema(schema));
+    const result = await act(vertex, withSchema(schema));
 
     expect(Object.keys(result.attributes)).not.toBe(
       expect.arrayContaining(vtConfig.attributes.map(a => a.name)),
     );
   });
 
-  it("should replace uri with prefixes when available", () => {
+  it("should replace uri with prefixes when available", async () => {
     const vertex = createRandomVertex();
     vertex.id = createVertexId("http://www.example.com/resources#foo");
     vertex.type = createVertexType("http://www.example.com/class#bar");
@@ -198,7 +200,7 @@ describe("useDisplayVertexFromVertex", () => {
       },
     ];
 
-    const displayVertex = act(
+    const displayVertex = await act(
       vertex,
       withSchemaAndConnection(schema, "sparql"),
     );
@@ -208,8 +210,11 @@ describe("useDisplayVertexFromVertex", () => {
 
   // Helpers
 
-  function act(vertex: Vertex, initializeState?: (store: AppStore) => void) {
-    const { result } = renderHookWithJotai(
+  async function act(
+    vertex: Vertex,
+    initializeState?: (store: AppStore) => void | Promise<void>,
+  ) {
+    const { result } = await renderHookWithJotai(
       () => useDisplayVertexFromVertex(vertex),
       initializeState,
     );
@@ -218,10 +223,10 @@ describe("useDisplayVertexFromVertex", () => {
 
   function withSchema(schema: SchemaStorageModel) {
     const config = createRandomRawConfiguration();
-    return (store: AppStore) => {
-      store.set(configurationAtom, new Map([[config.id, config]]));
-      store.set(schemaAtom, new Map([[config.id, schema]]));
-      store.set(activeConfigurationAtom, config.id);
+    return async (store: AppStore) => {
+      await store.set(configurationAtom, new Map([[config.id, config]]));
+      await store.set(schemaAtom, new Map([[config.id, schema]]));
+      await store.set(activeConfigurationAtom, config.id);
     };
   }
 
@@ -231,10 +236,10 @@ describe("useDisplayVertexFromVertex", () => {
   ) {
     const config = createRandomRawConfiguration();
     config.connection!.queryEngine = queryEngine;
-    return (store: AppStore) => {
-      store.set(configurationAtom, new Map([[config.id, config]]));
-      store.set(schemaAtom, new Map([[config.id, schema]]));
-      store.set(activeConfigurationAtom, config.id);
+    return async (store: AppStore) => {
+      await store.set(configurationAtom, new Map([[config.id, config]]));
+      await store.set(schemaAtom, new Map([[config.id, schema]]));
+      await store.set(activeConfigurationAtom, config.id);
     };
   }
 });
diff --git a/packages/graph-explorer/src/core/StateProvider/featureFlags.test.ts b/packages/graph-explorer/src/core/StateProvider/featureFlags.test.ts
index 05cdbb959..22ac2d12c 100644
--- a/packages/graph-explorer/src/core/StateProvider/featureFlags.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/featureFlags.test.ts
@@ -4,8 +4,8 @@ import { renderHookWithState } from "@/utils/testing";
 import { useFeatureFlags } from "./featureFlags";
 
 describe("useFeatureFlags", () => {
-  test("should return default feature flags", () => {
-    const { result } = renderHookWithState(() => useFeatureFlags());
+  test("should return default feature flags", async () => {
+    const { result } = await renderHookWithState(() => useFeatureFlags());
     expect(result.current).toStrictEqual({
       showDebugActions: false,
       allowLoggingDbQuery: false,
diff --git a/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts b/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts
index 272672281..066b4dd71 100644
--- a/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts
+++ b/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts
@@ -2,6 +2,7 @@ import { atom } from "jotai";
 import { atomWithReset, RESET } from "jotai/utils";
 
 import { activeConfigurationAtom, allGraphSessionsAtom } from "@/core";
+import { logAndNotify } from "@/utils";
 
 import type { EdgeId, VertexId } from "../../entities";
 
@@ -39,11 +40,15 @@ export const activeGraphSessionAtom = atom(
     // Delete the active graph if we receive a default value
     if (newValue === RESET || !newValue) {
       newGraphs.delete(connectionId);
-      set(allGraphSessionsAtom, newGraphs);
+      set(allGraphSessionsAtom, newGraphs).catch(
+        logAndNotify("Failed to save the current graph session."),
+      );
       return;
     }
 
     newGraphs.set(connectionId, newValue);
-    set(allGraphSessionsAtom, newGraphs);
+    set(allGraphSessionsAtom, newGraphs).catch(
+      logAndNotify("Failed to save the current graph session."),
+    );
   },
 );
diff --git a/packages/graph-explorer/src/core/StateProvider/localDb.test.ts b/packages/graph-explorer/src/core/StateProvider/localDb.test.ts
index a8634e4e7..9d91d8fc1 100644
--- a/packages/graph-explorer/src/core/StateProvider/localDb.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/localDb.test.ts
@@ -69,9 +69,9 @@ describe("exportFromLocalForage", () => {
     const schemaMap = new Map([[config.id, schema]]);
 
     // add to storage
-    localDb.setItem("schema", schemaMap);
-    localDb.setItem("configuration", configMap);
-    localDb.setItem("active-configuration", config.id);
+    await localDb.setItem("schema", schemaMap);
+    await localDb.setItem("configuration", configMap);
+    await localDb.setItem("active-configuration", config.id);
 
     // perform backup
     const result = await createBackupData(localDb);
@@ -99,9 +99,9 @@ describe("exportFromLocalForage", () => {
     const schemaMap = new Map([[config.id, schema]]);
 
     // add to storage
-    localDb.setItem("schema", schemaMap);
-    localDb.setItem("configuration", configMap);
-    localDb.setItem("active-configuration", config.id);
+    await localDb.setItem("schema", schemaMap);
+    await localDb.setItem("configuration", configMap);
+    await localDb.setItem("active-configuration", config.id);
 
     // perform backup
     const backupBefore = await createBackupData(localDb);
@@ -127,12 +127,12 @@ describe("exportFromLocalForage", () => {
     const schemaMap = new Map([[config.id, schema]]);
 
     // add to storage
-    localDb.setItem("schema", schemaMap);
-    localDb.setItem("configuration", configMap);
-    localDb.setItem("active-configuration", config.id);
-    localDb.setItem(addRestoredPrefix("schema"), schemaMap);
-    localDb.setItem(addRestoredPrefix("configuration"), configMap);
-    localDb.setItem(addRestoredPrefix("active-configuration"), config.id);
+    await localDb.setItem("schema", schemaMap);
+    await localDb.setItem("configuration", configMap);
+    await localDb.setItem("active-configuration", config.id);
+    await localDb.setItem(addRestoredPrefix("schema"), schemaMap);
+    await localDb.setItem(addRestoredPrefix("configuration"), configMap);
+    await localDb.setItem(addRestoredPrefix("active-configuration"), config.id);
 
     // perform backup
     const originalBackupData = await createBackupData(localDb);
@@ -218,9 +218,9 @@ describe("backward compatibility: legacy schema field on stored configuration",
     const configMap = new Map([[config.id, legacyConfig]]);
     const schemaMap = new Map([[config.id, schema]]);
 
-    localDb.setItem("schema", schemaMap);
-    localDb.setItem("configuration", configMap);
-    localDb.setItem("active-configuration", config.id);
+    await localDb.setItem("schema", schemaMap);
+    await localDb.setItem("configuration", configMap);
+    await localDb.setItem("active-configuration", config.id);
 
     // Backup -> serialize -> file -> parse -> restore
     const backupBefore = await createBackupData(localDb);
diff --git a/packages/graph-explorer/src/core/StateProvider/neighbors.test.ts b/packages/graph-explorer/src/core/StateProvider/neighbors.test.ts
index f2b620745..901fa5d79 100644
--- a/packages/graph-explorer/src/core/StateProvider/neighbors.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/neighbors.test.ts
@@ -289,11 +289,11 @@ describe("calculateNeighbors", () => {
 });
 
 describe("useNeighbors", () => {
-  it("should return default neighbors if no neighbors are found", () => {
+  it("should return default neighbors if no neighbors are found", async () => {
     const dbState = new DbState();
     const vertex = createRandomVertex();
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useNeighbors(vertex.id),
       dbState,
     );
@@ -319,7 +319,7 @@ describe("useNeighbors", () => {
     explorer.addTestableEdge(edge1);
     explorer.addTestableEdge(edge2);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useNeighbors(vertex.id),
       dbState,
     );
@@ -351,7 +351,7 @@ describe("useNeighbors", () => {
     explorer.addTestableEdge(edge1);
     explorer.addTestableEdge(edge2);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useNeighbors(vertex1.id),
       dbState,
     );
@@ -384,7 +384,7 @@ describe("useNeighbors", () => {
       counts: [response],
     });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useNeighbors(vertex.id),
       dbState,
     );
@@ -404,12 +404,12 @@ describe("useNeighbors", () => {
 });
 
 describe("useFetchedNeighborsCallback", () => {
-  it("should return empty set when no edges exist", () => {
+  it("should return empty set when no edges exist", async () => {
     const dbState = new DbState();
     const vertex = createTestableVertex();
     dbState.addTestableVertexToGraph(vertex);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useFetchedNeighborsCallback(),
       dbState,
     );
@@ -418,7 +418,7 @@ describe("useFetchedNeighborsCallback", () => {
     expect(neighbors).toEqual(new Set());
   });
 
-  it("should return neighbor IDs for outgoing edges", () => {
+  it("should return neighbor IDs for outgoing edges", async () => {
     const dbState = new DbState();
     const source = createTestableVertex();
     const target = createTestableVertex();
@@ -426,7 +426,7 @@ describe("useFetchedNeighborsCallback", () => {
 
     dbState.addTestableEdgeToGraph(edge);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useFetchedNeighborsCallback(),
       dbState,
     );
@@ -435,7 +435,7 @@ describe("useFetchedNeighborsCallback", () => {
     expect(neighbors).toEqual(new Set([target.id]));
   });
 
-  it("should return neighbor IDs for incoming edges", () => {
+  it("should return neighbor IDs for incoming edges", async () => {
     const dbState = new DbState();
     const source = createTestableVertex();
     const target = createTestableVertex();
@@ -443,7 +443,7 @@ describe("useFetchedNeighborsCallback", () => {
 
     dbState.addTestableEdgeToGraph(edge);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useFetchedNeighborsCallback(),
       dbState,
     );
@@ -452,7 +452,7 @@ describe("useFetchedNeighborsCallback", () => {
     expect(neighbors).toEqual(new Set([source.id]));
   });
 
-  it("should return unique neighbor IDs when multiple edges connect same vertices", () => {
+  it("should return unique neighbor IDs when multiple edges connect same vertices", async () => {
     const dbState = new DbState();
     const vertex1 = createTestableVertex();
     const vertex2 = createTestableVertex();
@@ -462,7 +462,7 @@ describe("useFetchedNeighborsCallback", () => {
     dbState.addTestableEdgeToGraph(edge1);
     dbState.addTestableEdgeToGraph(edge2);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useFetchedNeighborsCallback(),
       dbState,
     );
@@ -471,7 +471,7 @@ describe("useFetchedNeighborsCallback", () => {
     expect(neighbors).toEqual(new Set([vertex2.id]));
   });
 
-  it("should return multiple neighbor IDs", () => {
+  it("should return multiple neighbor IDs", async () => {
     const dbState = new DbState();
     const center = createTestableVertex();
     const neighbor1 = createTestableVertex();
@@ -486,7 +486,7 @@ describe("useFetchedNeighborsCallback", () => {
     dbState.addTestableEdgeToGraph(edge2);
     dbState.addTestableEdgeToGraph(edge3);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useFetchedNeighborsCallback(),
       dbState,
     );
@@ -497,7 +497,7 @@ describe("useFetchedNeighborsCallback", () => {
     );
   });
 
-  it("should exclude edges where neighbor vertex is not in the graph", () => {
+  it("should exclude edges where neighbor vertex is not in the graph", async () => {
     const dbState = new DbState();
     const source = createTestableVertex();
     const target = createTestableVertex();
@@ -507,7 +507,7 @@ describe("useFetchedNeighborsCallback", () => {
     dbState.addTestableVertexToGraph(source);
     dbState.addEdgeToGraph(edge.asEdge());
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useFetchedNeighborsCallback(),
       dbState,
     );
@@ -516,7 +516,7 @@ describe("useFetchedNeighborsCallback", () => {
     expect(neighbors).toEqual(new Set());
   });
 
-  it("should exclude edges where source vertex is not in the graph", () => {
+  it("should exclude edges where source vertex is not in the graph", async () => {
     const dbState = new DbState();
     const source = createTestableVertex();
     const target = createTestableVertex();
@@ -526,7 +526,7 @@ describe("useFetchedNeighborsCallback", () => {
     dbState.addTestableVertexToGraph(target);
     dbState.addEdgeToGraph(edge.asEdge());
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useFetchedNeighborsCallback(),
       dbState,
     );
@@ -535,7 +535,7 @@ describe("useFetchedNeighborsCallback", () => {
     expect(neighbors).toEqual(new Set());
   });
 
-  it("should return empty set for vertex not in graph", () => {
+  it("should return empty set for vertex not in graph", async () => {
     const dbState = new DbState();
     const vertex1 = createTestableVertex();
     const vertex2 = createTestableVertex();
@@ -544,7 +544,7 @@ describe("useFetchedNeighborsCallback", () => {
 
     dbState.addTestableEdgeToGraph(edge);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useFetchedNeighborsCallback(),
       dbState,
     );
diff --git a/packages/graph-explorer/src/core/StateProvider/renderedEntities.test.ts b/packages/graph-explorer/src/core/StateProvider/renderedEntities.test.ts
index 6e9c90e6b..3fe0d6ebc 100644
--- a/packages/graph-explorer/src/core/StateProvider/renderedEntities.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/renderedEntities.test.ts
@@ -103,7 +103,7 @@ describe("useRenderedVertices", () => {
       createRenderedVertexId(dbState.vertices[2].id),
     ];
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useRenderedEntities(),
       store => dbState.applyTo(store),
     );
@@ -127,7 +127,7 @@ describe("useRenderedVertices", () => {
 
     dbState.filterVertexType(createVertexType(vertex1.types[0]));
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useRenderedEntities(),
       store => dbState.applyTo(store),
     );
@@ -168,7 +168,7 @@ describe("useRenderedEdges", () => {
       createRenderedEdgeId(dbState.edges[3].id),
     ];
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useRenderedEntities(),
       store => dbState.applyTo(store),
     );
@@ -208,7 +208,7 @@ describe("useRenderedEdges", () => {
       createRenderedEdgeId(dbState.edges[3].id),
     ];
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useRenderedEntities(),
       store => dbState.applyTo(store),
     );
@@ -246,7 +246,7 @@ describe("useRenderedEdges", () => {
       createRenderedEdgeId(dbState.edges[3].id),
     ];
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useRenderedEntities(),
       store => dbState.applyTo(store),
     );
@@ -282,7 +282,7 @@ describe("useRenderedEdges", () => {
       createRenderedEdgeId(dbState.edges[1].id),
     ];
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useRenderedEntities(),
       store => dbState.applyTo(store),
     );
diff --git a/packages/graph-explorer/src/core/StateProvider/schema.test.ts b/packages/graph-explorer/src/core/StateProvider/schema.test.ts
index 97a9d4e8f..da5c3cc16 100644
--- a/packages/graph-explorer/src/core/StateProvider/schema.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/schema.test.ts
@@ -1040,17 +1040,17 @@ describe("referential integrity", () => {
 });
 
 describe("useGraphSchema edgeConnections", () => {
-  test("should return empty edgeConnections when schema has none", () => {
+  test("should return empty edgeConnections when schema has none", async () => {
     const state = new DbState();
     state.activeSchema.edgeConnections = undefined;
 
-    const { result } = renderHookWithState(() => useGraphSchema(), state);
+    const { result } = await renderHookWithState(() => useGraphSchema(), state);
 
     expect(result.current.edgeConnections.byVertexType.size).toBe(0);
     expect(result.current.edgeConnections.byEdgeConnectionId.size).toBe(0);
   });
 
-  test("should group connections by vertex type", () => {
+  test("should group connections by vertex type", async () => {
     const sharedVertexType = createRandomVertexType();
     const conn1 = createRandomEdgeConnection();
     const conn2 = createRandomEdgeConnection();
@@ -1060,14 +1060,14 @@ describe("useGraphSchema edgeConnections", () => {
     const state = new DbState();
     state.activeSchema.edgeConnections = [conn1, conn2];
 
-    const { result } = renderHookWithState(() => useGraphSchema(), state);
+    const { result } = await renderHookWithState(() => useGraphSchema(), state);
 
     const connectionsForShared =
       result.current.edgeConnections.byVertexType.get(sharedVertexType);
     expect(connectionsForShared).toStrictEqual([conn1, conn2]);
   });
 
-  test("forVertexType should return connections for a vertex type", () => {
+  test("forVertexType should return connections for a vertex type", async () => {
     const vertexType = createRandomVertexType();
     const conn = createRandomEdgeConnection();
     conn.sourceVertexType = vertexType;
@@ -1075,25 +1075,25 @@ describe("useGraphSchema edgeConnections", () => {
     const state = new DbState();
     state.activeSchema.edgeConnections = [conn];
 
-    const { result } = renderHookWithState(() => useGraphSchema(), state);
+    const { result } = await renderHookWithState(() => useGraphSchema(), state);
 
     expect(
       result.current.edgeConnections.forVertexType(vertexType),
     ).toStrictEqual([conn]);
   });
 
-  test("forVertexType should return empty array for unknown vertex type", () => {
+  test("forVertexType should return empty array for unknown vertex type", async () => {
     const state = new DbState();
     state.activeSchema.edgeConnections = [createRandomEdgeConnection()];
 
-    const { result } = renderHookWithState(() => useGraphSchema(), state);
+    const { result } = await renderHookWithState(() => useGraphSchema(), state);
 
     expect(
       result.current.edgeConnections.forVertexType(createRandomVertexType()),
     ).toStrictEqual([]);
   });
 
-  test("should not duplicate connection when source equals target", () => {
+  test("should not duplicate connection when source equals target", async () => {
     const vertexType = createRandomVertexType();
     const conn = createRandomEdgeConnection();
     conn.sourceVertexType = vertexType;
@@ -1102,31 +1102,31 @@ describe("useGraphSchema edgeConnections", () => {
     const state = new DbState();
     state.activeSchema.edgeConnections = [conn];
 
-    const { result } = renderHookWithState(() => useGraphSchema(), state);
+    const { result } = await renderHookWithState(() => useGraphSchema(), state);
 
     expect(
       result.current.edgeConnections.forVertexType(vertexType),
     ).toStrictEqual([conn]);
   });
 
-  test("byEdgeConnectionId should map connections by their ID", () => {
+  test("byEdgeConnectionId should map connections by their ID", async () => {
     const conn1 = createRandomEdgeConnection();
     const conn2 = createRandomEdgeConnection();
     const state = new DbState();
     state.activeSchema.edgeConnections = [conn1, conn2];
 
-    const { result } = renderHookWithState(() => useGraphSchema(), state);
+    const { result } = await renderHookWithState(() => useGraphSchema(), state);
 
     expect(result.current.edgeConnections.byEdgeConnectionId.size).toBe(2);
   });
 
-  test("byEdgeConnectionId should allow lookup by ID", () => {
+  test("byEdgeConnectionId should allow lookup by ID", async () => {
     const conn = createRandomEdgeConnection();
     const id = createEdgeConnectionId(conn);
     const state = new DbState();
     state.activeSchema.edgeConnections = [conn];
 
-    const { result } = renderHookWithState(() => useGraphSchema(), state);
+    const { result } = await renderHookWithState(() => useGraphSchema(), state);
 
     expect(
       result.current.edgeConnections.byEdgeConnectionId.get(id),
@@ -1135,10 +1135,10 @@ describe("useGraphSchema edgeConnections", () => {
 });
 
 describe("useUpdateSchemaFromEntities", () => {
-  it("should not churn schemaAtom when active config has no schema entry", () => {
+  it("should not churn schemaAtom when active config has no schema entry", async () => {
     const state = new DbState().withNoActiveSchema();
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => ({
         updateSchema: useUpdateSchemaFromEntities(),
         schemaMap: useAtomValue(schemaAtom),
@@ -1157,7 +1157,7 @@ describe("useUpdateSchemaFromEntities", () => {
     expect(result.current.schemaMap).toBe(schemaMapBefore);
   });
 
-  it("should not churn schemaAtom when entities already match schema", () => {
+  it("should not churn schemaAtom when entities already match schema", async () => {
     const state = new DbState();
     const existingVertex = createRandomVertex();
     existingVertex.type = state.activeSchema.vertices[0].type;
@@ -1168,7 +1168,7 @@ describe("useUpdateSchemaFromEntities", () => {
         return acc;
       }, {} as EntityProperties);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => ({
         updateSchema: useUpdateSchemaFromEntities(),
         schemaMap: useAtomValue(schemaAtom),
@@ -1187,7 +1187,7 @@ describe("useUpdateSchemaFromEntities", () => {
     expect(result.current.schemaMap).toBe(schemaMapBefore);
   });
 
-  it("should infer edge connections from entities and canvas vertices", () => {
+  it("should infer edge connections from entities and canvas vertices", async () => {
     const state = new DbState();
     state.activeSchema.edgeConnections = [];
 
@@ -1213,7 +1213,7 @@ describe("useUpdateSchemaFromEntities", () => {
       attributes: {},
     });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => ({
         updateSchema: useUpdateSchemaFromEntities(),
         schema: useAtomValue(activeSchemaSelector),
@@ -1233,7 +1233,7 @@ describe("useUpdateSchemaFromEntities", () => {
     ]);
   });
 
-  it("should prefer entity vertices over canvas vertices for edge connections", () => {
+  it("should prefer entity vertices over canvas vertices for edge connections", async () => {
     const state = new DbState();
     state.activeSchema.edgeConnections = [];
 
@@ -1264,7 +1264,7 @@ describe("useUpdateSchemaFromEntities", () => {
       attributes: {},
     });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => ({
         updateSchema: useUpdateSchemaFromEntities(),
         schema: useAtomValue(activeSchemaSelector),
@@ -1286,59 +1286,65 @@ describe("useUpdateSchemaFromEntities", () => {
 });
 
 describe("useHasActiveSchema", () => {
-  test("should return false when schema has no lastUpdate", () => {
+  test("should return false when schema has no lastUpdate", async () => {
     const state = new DbState();
     state.activeSchema.lastUpdate = undefined;
 
-    const { result } = renderHookWithState(() => useHasActiveSchema(), state);
+    const { result } = await renderHookWithState(
+      () => useHasActiveSchema(),
+      state,
+    );
 
     expect(result.current).toBe(false);
   });
 
-  test("should return true when schema has lastUpdate", () => {
+  test("should return true when schema has lastUpdate", async () => {
     const state = new DbState();
     state.activeSchema.lastUpdate = new Date();
 
-    const { result } = renderHookWithState(() => useHasActiveSchema(), state);
+    const { result } = await renderHookWithState(
+      () => useHasActiveSchema(),
+      state,
+    );
 
     expect(result.current).toBe(true);
   });
 });
 
 describe("maybeActiveSchemaAtom", () => {
-  it("returns undefined when no active configuration exists", () => {
-    const { result } = renderHookWithJotai(() =>
+  it("returns undefined when no active configuration exists", async () => {
+    const { result } = await renderHookWithJotai(() =>
       useAtomValue(maybeActiveSchemaAtom),
     );
 
     expect(result.current).toBeUndefined();
   });
 
-  it("returns undefined when active config has no schema", () => {
+  it("returns undefined when active config has no schema", async () => {
     const config = createRandomRawConfiguration();
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useAtomValue(maybeActiveSchemaAtom),
-      store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map());
+      async store => {
+        await store.set(configurationAtom, new Map([[config.id, config]]));
+        await store.set(activeConfigurationAtom, config.id);
+        await store.set(schemaAtom, new Map());
       },
     );
 
     expect(result.current).toBeUndefined();
   });
 
-  it("returns the schema when one exists", () => {
+  it("returns the schema when one exists", async () => {
     const config = createRandomRawConfiguration();
     const schema = createRandomSchema();
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useAtomValue(maybeActiveSchemaAtom),
-      store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map([[config.id, schema]]));
+      async store => {
+        await store.set(configurationAtom, new Map([[config.id, config]]));
+        await store.set(activeConfigurationAtom, config.id);
+        await store.set(schemaAtom, new Map([[config.id, schema]]));
       },
     );
 
@@ -1347,37 +1353,37 @@ describe("maybeActiveSchemaAtom", () => {
 });
 
 describe("useMaybeActiveSchema", () => {
-  it("returns undefined when no active configuration exists", () => {
-    const { result } = renderHookWithJotai(() => useMaybeActiveSchema());
+  it("returns undefined when no active configuration exists", async () => {
+    const { result } = await renderHookWithJotai(() => useMaybeActiveSchema());
 
     expect(result.current).toBeUndefined();
   });
 
-  it("returns undefined when active config has no schema", () => {
+  it("returns undefined when active config has no schema", async () => {
     const config = createRandomRawConfiguration();
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useMaybeActiveSchema(),
-      store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map());
+      async store => {
+        await store.set(configurationAtom, new Map([[config.id, config]]));
+        await store.set(activeConfigurationAtom, config.id);
+        await store.set(schemaAtom, new Map());
       },
     );
 
     expect(result.current).toBeUndefined();
   });
 
-  it("returns the schema when one exists", () => {
+  it("returns the schema when one exists", async () => {
     const config = createRandomRawConfiguration();
     const schema = createRandomSchema();
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useMaybeActiveSchema(),
-      store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map([[config.id, schema]]));
+      async store => {
+        await store.set(configurationAtom, new Map([[config.id, config]]));
+        await store.set(activeConfigurationAtom, config.id);
+        await store.set(schemaAtom, new Map([[config.id, schema]]));
       },
     );
 
@@ -1386,8 +1392,8 @@ describe("useMaybeActiveSchema", () => {
 });
 
 describe("useActiveSchema", () => {
-  it("returns empty schema when no active configuration exists", () => {
-    const { result } = renderHookWithJotai(() => useActiveSchema());
+  it("returns empty schema when no active configuration exists", async () => {
+    const { result } = await renderHookWithJotai(() => useActiveSchema());
 
     expect(result.current).toStrictEqual({
       vertices: [],
@@ -1396,15 +1402,15 @@ describe("useActiveSchema", () => {
     });
   });
 
-  it("returns empty schema when active config has no schema", () => {
+  it("returns empty schema when active config has no schema", async () => {
     const config = createRandomRawConfiguration();
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useActiveSchema(),
-      store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map());
+      async store => {
+        await store.set(configurationAtom, new Map([[config.id, config]]));
+        await store.set(activeConfigurationAtom, config.id);
+        await store.set(schemaAtom, new Map());
       },
     );
 
@@ -1415,16 +1421,16 @@ describe("useActiveSchema", () => {
     });
   });
 
-  it("returns the schema when one exists", () => {
+  it("returns the schema when one exists", async () => {
     const config = createRandomRawConfiguration();
     const schema = createRandomSchema();
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useActiveSchema(),
-      store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map([[config.id, schema]]));
+      async store => {
+        await store.set(configurationAtom, new Map([[config.id, config]]));
+        await store.set(activeConfigurationAtom, config.id);
+        await store.set(schemaAtom, new Map([[config.id, schema]]));
       },
     );
 
diff --git a/packages/graph-explorer/src/core/StateProvider/schema.ts b/packages/graph-explorer/src/core/StateProvider/schema.ts
index 6511bc9a0..d50040c60 100644
--- a/packages/graph-explorer/src/core/StateProvider/schema.ts
+++ b/packages/graph-explorer/src/core/StateProvider/schema.ts
@@ -29,7 +29,7 @@ import {
   type VertexId,
   type VertexType,
 } from "@/core";
-import { logger } from "@/utils";
+import { logAndNotify, logger } from "@/utils";
 import { generatePrefixes, PrefixLookup } from "@/utils/rdf";
 
 import { nodesAtom, toNodeMap } from "./nodes";
@@ -275,7 +275,7 @@ export const activeSchemaSelector = atom(
       updatedSchemaMap.set(schemaId, newValue);
 
       return updatedSchemaMap;
-    });
+    }).catch(logAndNotify("Failed to save the schema to the local cache."));
   },
 );
 
diff --git a/packages/graph-explorer/src/core/StateProvider/storageAtoms.test.ts b/packages/graph-explorer/src/core/StateProvider/storageAtoms.test.ts
index 886546b93..0a9518250 100644
--- a/packages/graph-explorer/src/core/StateProvider/storageAtoms.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/storageAtoms.test.ts
@@ -52,13 +52,13 @@ describe("storageAtoms", () => {
     expect(store.get(diagnosticLoggingAtom)).toBe(false);
   });
 
-  it("should persist a written value on subsequent reads", () => {
+  it("should persist a written value on subsequent reads", async () => {
     const store = createStore();
 
-    store.set(showDebugActionsAtom, true);
+    await store.set(showDebugActionsAtom, true);
     expect(store.get(showDebugActionsAtom)).toBe(true);
 
-    store.set(showDebugActionsAtom, false);
+    await store.set(showDebugActionsAtom, false);
     expect(store.get(showDebugActionsAtom)).toBe(false);
   });
 });
diff --git a/packages/graph-explorer/src/core/StateProvider/useResetState.test.ts b/packages/graph-explorer/src/core/StateProvider/useResetState.test.ts
index a047e60d9..849d85fde 100644
--- a/packages/graph-explorer/src/core/StateProvider/useResetState.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/useResetState.test.ts
@@ -41,14 +41,14 @@ import {
 import useResetState from "./useResetState";
 
 describe("useResetState", () => {
-  test("should reset all node atoms", () => {
+  test("should reset all node atoms", async () => {
     const state = new DbState();
     const vertex = createTestableVertex();
     state.addTestableVertexToGraph(vertex);
     state.filterVertex(vertex.asVertex().id);
     state.filterVertexType(vertex.asVertex().types[0]);
 
-    const { result } = renderHookWithState(() => useResetState(), state);
+    const { result } = await renderHookWithState(() => useResetState(), state);
     const store = getAppStore();
 
     expect(store.get(nodesAtom).size).toBeGreaterThan(0);
@@ -64,14 +64,14 @@ describe("useResetState", () => {
     expect(store.get(nodesTableSortsAtom)).toStrictEqual([]);
   });
 
-  test("should reset all edge atoms", () => {
+  test("should reset all edge atoms", async () => {
     const state = new DbState();
     const edge = createTestableEdge();
     state.addTestableEdgeToGraph(edge);
     state.filterEdge(edge.asEdge().id);
     state.filterEdgeType(edge.asEdge().type);
 
-    const { result } = renderHookWithState(() => useResetState(), state);
+    const { result } = await renderHookWithState(() => useResetState(), state);
     const store = getAppStore();
 
     expect(store.get(edgesAtom).size).toBeGreaterThan(0);
@@ -87,8 +87,8 @@ describe("useResetState", () => {
     expect(store.get(edgesTableSortsAtom)).toStrictEqual([]);
   });
 
-  test("should reset search and query editor atoms", () => {
-    const { result } = renderHookWithState(() => useResetState());
+  test("should reset search and query editor atoms", async () => {
+    const { result } = await renderHookWithState(() => useResetState());
     const store = getAppStore();
 
     store.set(searchTermAtom, "test search");
@@ -108,8 +108,8 @@ describe("useResetState", () => {
     expect(store.get(queryTextAtom)).toBe("");
   });
 
-  test("should reset previous session availability", () => {
-    const { result } = renderHookWithState(() => useResetState());
+  test("should reset previous session availability", async () => {
+    const { result } = await renderHookWithState(() => useResetState());
     const store = getAppStore();
 
     store.set(isRestorePreviousSessionAvailableAtom, false);
@@ -119,8 +119,8 @@ describe("useResetState", () => {
     expect(store.get(isRestorePreviousSessionAvailableAtom)).toBe(true);
   });
 
-  test("should remove all queries from the query client", () => {
-    const { result } = renderHookWithState(() => {
+  test("should remove all queries from the query client", async () => {
+    const { result } = await renderHookWithState(() => {
       const queryClient = useQueryClient();
       const resetState = useResetState();
       return { queryClient, resetState };
diff --git a/packages/graph-explorer/src/core/StateProvider/userLayout.test.ts b/packages/graph-explorer/src/core/StateProvider/userLayout.test.ts
index c0337066b..5281e4669 100644
--- a/packages/graph-explorer/src/core/StateProvider/userLayout.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/userLayout.test.ts
@@ -18,15 +18,15 @@ import {
 } from "./userLayout";
 
 describe("useViewToggles", () => {
-  it("should default to both views open", () => {
-    const { result } = renderHookWithState(() => useViewToggles());
+  it("should default to both views open", async () => {
+    const { result } = await renderHookWithState(() => useViewToggles());
 
     expect(result.current.isGraphVisible).toBe(true);
     expect(result.current.isTableVisible).toBe(true);
   });
 
   it("should toggle graph view", async () => {
-    const { result } = renderHookWithState(() => useViewToggles());
+    const { result } = await renderHookWithState(() => useViewToggles());
 
     await act(async () => result.current.toggleGraphVisibility());
 
@@ -40,7 +40,7 @@ describe("useViewToggles", () => {
   });
 
   it("should toggle table view", async () => {
-    const { result } = renderHookWithState(() => useViewToggles());
+    const { result } = await renderHookWithState(() => useViewToggles());
 
     await act(async () => result.current.toggleTableVisibility());
 
@@ -55,26 +55,26 @@ describe("useViewToggles", () => {
 });
 
 describe("useSidebar", () => {
-  it("should default to sidebar open", () => {
-    const { result } = renderHookWithJotai(() => useSidebar());
+  it("should default to sidebar open", async () => {
+    const { result } = await renderHookWithJotai(() => useSidebar());
 
     expect(result.current.isSidebarOpen).toBe(true);
   });
 
   it("should change to the given sidebar item", async () => {
-    const { result } = renderHookWithJotai(() => useSidebar());
+    const { result } = await renderHookWithJotai(() => useSidebar());
 
-    await act(async () => result.current.toggleSidebar("details"));
+    act(() => result.current.toggleSidebar("details"));
     expect(result.current.isSidebarOpen).toBe(true);
     expect(result.current.activeSidebarItem).toBe("details");
 
-    await act(async () => result.current.toggleSidebar("search"));
+    act(() => result.current.toggleSidebar("search"));
     expect(result.current.isSidebarOpen).toBe(true);
     expect(result.current.activeSidebarItem).toBe("search");
   });
 
   it("should close the sidebar if toggling to the same item", async () => {
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useSidebar(),
       store =>
         store.set(userLayoutAtom, {
@@ -83,29 +83,29 @@ describe("useSidebar", () => {
         } satisfies UserLayout),
     );
 
-    await act(async () => result.current.toggleSidebar("details"));
+    act(() => result.current.toggleSidebar("details"));
 
     expect(result.current.isSidebarOpen).toBe(false);
     expect(result.current.activeSidebarItem).toBeNull();
   });
 
   it("should close the sidebar", async () => {
-    const { result } = renderHookWithJotai(() => useSidebar());
+    const { result } = await renderHookWithJotai(() => useSidebar());
 
     await act(async () => result.current.closeSidebar());
 
     expect(result.current.isSidebarOpen).toBe(false);
   });
 
-  it("should show namespaces when the connection is a SPARQL connection", () => {
+  it("should show namespaces when the connection is a SPARQL connection", async () => {
     const dbState = new DbState();
     dbState.activeConfig.connection!.queryEngine = "sparql";
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useSidebar(),
-      store => {
-        dbState.applyTo(store);
-        store.set(userLayoutAtom, {
+      async store => {
+        await dbState.applyTo(store);
+        await store.set(userLayoutAtom, {
           activeSidebarItem: "namespaces",
           activeToggles: new Set(),
         } satisfies UserLayout);
@@ -117,15 +117,15 @@ describe("useSidebar", () => {
     expect(result.current.shouldShowNamespaces).toBe(true);
   });
 
-  it("should be closed when active item is namespaces but connection is not RDF", () => {
+  it("should be closed when active item is namespaces but connection is not RDF", async () => {
     const dbState = new DbState();
     dbState.activeConfig.connection!.queryEngine = "gremlin";
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useSidebar(),
-      store => {
-        dbState.applyTo(store);
-        store.set(userLayoutAtom, {
+      async store => {
+        await dbState.applyTo(store);
+        await store.set(userLayoutAtom, {
           activeSidebarItem: "namespaces",
           activeToggles: new Set(),
         } satisfies UserLayout);
@@ -139,14 +139,14 @@ describe("useSidebar", () => {
 });
 
 describe("useTableViewSize", () => {
-  it("should default to DEFAULT_TABLE_VIEW_HEIGHT", () => {
-    const { result } = renderHookWithState(() => useTableViewSize());
+  it("should default to DEFAULT_TABLE_VIEW_HEIGHT", async () => {
+    const { result } = await renderHookWithState(() => useTableViewSize());
 
     expect(result.current[0]).toBe(300);
   });
 
   it("should return 100% when graph viewer is hidden", async () => {
-    const { result } = renderHookWithState(() => ({
+    const { result } = await renderHookWithState(() => ({
       tableView: useTableViewSize(),
       toggles: useViewToggles(),
     }));
@@ -157,7 +157,7 @@ describe("useTableViewSize", () => {
   });
 
   it("should adjust height by delta", async () => {
-    const { result } = renderHookWithState(() => useTableViewSize());
+    const { result } = await renderHookWithState(() => useTableViewSize());
 
     await act(async () => result.current[1](50));
 
@@ -170,14 +170,14 @@ describe("useTableViewSize", () => {
 });
 
 describe("useSidebarSize", () => {
-  it("should default to 400", () => {
-    const { result } = renderHookWithState(() => useSidebarSize());
+  it("should default to 400", async () => {
+    const { result } = await renderHookWithState(() => useSidebarSize());
 
     expect(result.current[0]).toBe(400);
   });
 
-  it("should adjust width by delta", () => {
-    const { result } = renderHookWithState(() => useSidebarSize());
+  it("should adjust width by delta", async () => {
+    const { result } = await renderHookWithState(() => useSidebarSize());
 
     act(() => result.current[1](100));
 
diff --git a/packages/graph-explorer/src/core/StateProvider/userLayout.ts b/packages/graph-explorer/src/core/StateProvider/userLayout.ts
index e9a0d0f8c..2142b490a 100644
--- a/packages/graph-explorer/src/core/StateProvider/userLayout.ts
+++ b/packages/graph-explorer/src/core/StateProvider/userLayout.ts
@@ -1,5 +1,7 @@
 import { useAtom } from "jotai";
 
+import { logAndNotify } from "@/utils";
+
 import { useQueryEngine } from "../connector";
 import { userLayoutAtom } from "./storageAtoms";
 import {
@@ -92,13 +94,14 @@ export function useSidebar() {
    * Sets the active sidebar item to the given item, or closes the sidebar if the
    * item is the same as the current active item.
    */
-  const toggleSidebar = (item: SidebarItems) =>
+  const toggleSidebar = (item: SidebarItems) => {
     setUserLayout(prev => {
       return {
         ...prev,
         activeSidebarItem: prev.activeSidebarItem === item ? null : item,
       };
-    });
+    }).catch(logAndNotify("Failed to save your layout preferences."));
+  };
 
   return {
     activeSidebarItem,
@@ -125,7 +128,7 @@ export function useSidebarSize() {
           width: prevWidth + deltaWidth,
         },
       };
-    });
+    }).catch(logAndNotify("Failed to save your layout preferences."));
   };
 
   return [sidebarWidth, setSidebarWidth] as const;
diff --git a/packages/graph-explorer/src/core/StateProvider/userPreferences.test.ts b/packages/graph-explorer/src/core/StateProvider/userPreferences.test.ts
index 0a1ad999a..a2d51ae50 100644
--- a/packages/graph-explorer/src/core/StateProvider/userPreferences.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/userPreferences.test.ts
@@ -31,9 +31,9 @@ function createExpectedEdge(existing: EdgePreferencesStorageModel) {
 }
 
 describe("useVertexStyling", () => {
-  it("should return defaults when the style does not exist", () => {
+  it("should return defaults when the style does not exist", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexStyling(createVertexType("test")),
       dbState,
     );
@@ -42,14 +42,14 @@ describe("useVertexStyling", () => {
     expect(result.current.vertexStyle).toStrictEqual(expected);
   });
 
-  it("should return the vertex style when it exists", () => {
+  it("should return the vertex style when it exists", async () => {
     const dbState = new DbState();
     const style = dbState.addVertexStyle(createVertexType("test"), {
       color: "red",
     });
     const expected = createExpectedVertex(style);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexStyling(createVertexType("test")),
       dbState,
     );
@@ -59,7 +59,7 @@ describe("useVertexStyling", () => {
 
   it("should insert the vertex style when none exist", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexStyling(createVertexType("test")),
       dbState,
     );
@@ -73,7 +73,7 @@ describe("useVertexStyling", () => {
 
   it("should update the existing style, merging new styles", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexStyling(createVertexType("test")),
       dbState,
     );
@@ -98,7 +98,7 @@ describe("useVertexStyling", () => {
     const dbState = new DbState();
     dbState.addVertexStyle(createVertexType("test"), { borderColor: "blue" });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexStyling(createVertexType("test")),
       dbState,
     );
@@ -115,7 +115,7 @@ describe("useVertexStyling", () => {
     dbState.addVertexStyle(createVertexType("type1"), { color: "red" });
     dbState.addVertexStyle(createVertexType("type2"), { color: "blue" });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexStyling(createVertexType("type1")),
       dbState,
     );
@@ -134,7 +134,7 @@ describe("useVertexStyling", () => {
     );
 
     // Check that type2 was not affected by getting its hook
-    const { result: result2 } = renderHookWithState(
+    const { result: result2 } = await renderHookWithState(
       () => useVertexStyling(createVertexType("type2")),
       dbState,
     );
@@ -151,7 +151,7 @@ describe("useVertexStyling", () => {
     dbState.addVertexStyle(createVertexType("type1"), { color: "red" });
     dbState.addVertexStyle(createVertexType("type2"), { color: "blue" });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexStyling(createVertexType("type1")),
       dbState,
     );
@@ -163,7 +163,7 @@ describe("useVertexStyling", () => {
     );
 
     // Check that type2 still exists
-    const { result: result2 } = renderHookWithState(
+    const { result: result2 } = await renderHookWithState(
       () => useVertexStyling(createVertexType("type2")),
       dbState,
     );
@@ -177,7 +177,7 @@ describe("useVertexStyling", () => {
 
   it("should handle empty style updates", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexStyling(createVertexType("test")),
       dbState,
     );
@@ -191,9 +191,9 @@ describe("useVertexStyling", () => {
 });
 
 describe("useEdgeStyling", () => {
-  it("should return defaults when the style does not exist", () => {
+  it("should return defaults when the style does not exist", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useEdgeStyling(createEdgeType("test")),
       dbState,
     );
@@ -203,12 +203,12 @@ describe("useEdgeStyling", () => {
     );
   });
 
-  it("should return the edge style when it exists", () => {
+  it("should return the edge style when it exists", async () => {
     const dbState = new DbState();
     const style = dbState.addEdgeStyle(createEdgeType("test"), {
       lineColor: "red",
     });
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useEdgeStyling(createEdgeType("test")),
       dbState,
     );
@@ -218,7 +218,7 @@ describe("useEdgeStyling", () => {
 
   it("should insert the edge style when none exist", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useEdgeStyling(createEdgeType("test")),
       dbState,
     );
@@ -235,7 +235,7 @@ describe("useEdgeStyling", () => {
 
   it("should update the existing style, merging new styles", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useEdgeStyling(createEdgeType("test")),
       dbState,
     );
@@ -256,7 +256,7 @@ describe("useEdgeStyling", () => {
 
   it("should reset the edge style", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useEdgeStyling(createEdgeType("test")),
       dbState,
     );
@@ -274,7 +274,7 @@ describe("useEdgeStyling", () => {
     dbState.addEdgeStyle(createEdgeType("type1"), { lineColor: "red" });
     dbState.addEdgeStyle(createEdgeType("type2"), { lineColor: "blue" });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useEdgeStyling(createEdgeType("type1")),
       dbState,
     );
@@ -291,7 +291,7 @@ describe("useEdgeStyling", () => {
     );
 
     // Check that type2 was not affected
-    const { result: result2 } = renderHookWithState(
+    const { result: result2 } = await renderHookWithState(
       () => useEdgeStyling(createEdgeType("type2")),
       dbState,
     );
@@ -308,7 +308,7 @@ describe("useEdgeStyling", () => {
     dbState.addEdgeStyle(createEdgeType("type1"), { lineColor: "red" });
     dbState.addEdgeStyle(createEdgeType("type2"), { lineColor: "blue" });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useEdgeStyling(createEdgeType("type1")),
       dbState,
     );
@@ -320,7 +320,7 @@ describe("useEdgeStyling", () => {
     );
 
     // Check that type2 still exists
-    const { result: result2 } = renderHookWithState(
+    const { result: result2 } = await renderHookWithState(
       () => useEdgeStyling(createEdgeType("type2")),
       dbState,
     );
@@ -334,7 +334,7 @@ describe("useEdgeStyling", () => {
 
   it("should handle empty style updates", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useEdgeStyling(createEdgeType("test")),
       dbState,
     );
@@ -350,7 +350,7 @@ describe("useEdgeStyling", () => {
 describe("useDeferredAtom integration", () => {
   it("should handle multiple rapid updates correctly", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexStyling(createVertexType("test")),
       dbState,
     );
@@ -374,7 +374,7 @@ describe("useDeferredAtom integration", () => {
 
   it("should handle deferred atom updates correctly", async () => {
     const dbState = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexStyling(createVertexType("test")),
       dbState,
     );
@@ -406,12 +406,12 @@ describe("useDeferredAtom integration", () => {
 });
 
 describe("vertexPreferencesAtom", () => {
-  it("should return stored preferences for a known type", () => {
+  it("should return stored preferences for a known type", async () => {
     const dbState = new DbState();
     const vertexType = createVertexType("Person");
     dbState.addVertexStyle(vertexType, { color: "#ff0000" });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useAtomValue(vertexPreferencesAtom),
       dbState,
     );
@@ -421,11 +421,11 @@ describe("vertexPreferencesAtom", () => {
     );
   });
 
-  it("should return defaults for an unknown type", () => {
+  it("should return defaults for an unknown type", async () => {
     const dbState = new DbState();
     const vertexType = createVertexType("Unknown");
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useAtomValue(vertexPreferencesAtom),
       dbState,
     );
@@ -437,12 +437,12 @@ describe("vertexPreferencesAtom", () => {
 });
 
 describe("edgePreferencesAtom", () => {
-  it("should return stored preferences for a known type", () => {
+  it("should return stored preferences for a known type", async () => {
     const dbState = new DbState();
     const edgeType = createEdgeType("KNOWS");
     dbState.addEdgeStyle(edgeType, { lineColor: "#00ff00" });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useAtomValue(edgePreferencesAtom),
       dbState,
     );
@@ -452,11 +452,11 @@ describe("edgePreferencesAtom", () => {
     );
   });
 
-  it("should return defaults for an unknown type", () => {
+  it("should return defaults for an unknown type", async () => {
     const dbState = new DbState();
     const edgeType = createEdgeType("Unknown");
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useAtomValue(edgePreferencesAtom),
       dbState,
     );
diff --git a/packages/graph-explorer/src/hooks/useAddToGraph.test.ts b/packages/graph-explorer/src/hooks/useAddToGraph.test.ts
index 413277a44..530e05b1f 100644
--- a/packages/graph-explorer/src/hooks/useAddToGraph.test.ts
+++ b/packages/graph-explorer/src/hooks/useAddToGraph.test.ts
@@ -34,7 +34,7 @@ test("should add one node", async () => {
 
   const vertex = createRandomVertex();
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const vertices = useAtomValue(nodesAtom);
     const edges = useAtomValue(edgesAtom);
@@ -61,7 +61,7 @@ test("should add one edge", async () => {
   dbState.addVertexToGraph(node1);
   dbState.addVertexToGraph(node2);
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const vertices = useAtomValue(nodesAtom);
     const edges = useAtomValue(edgesAtom);
@@ -82,7 +82,7 @@ test("should add multiple nodes and edges", async () => {
 
   const randomEntities = createRandomEntities();
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const vertices = useAtomValue(nodesAtom);
     const edges = useAtomValue(edgesAtom);
@@ -106,7 +106,7 @@ test("should add multiple nodes and edges ignoring duplicates", async () => {
 
   const randomEntities = createRandomEntities();
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const vertices = useAtomValue(nodesAtom);
     const edges = useAtomValue(edgesAtom);
@@ -136,7 +136,7 @@ test("should update schema when adding a node", async () => {
   const vertex = createRandomVertex();
   const expectedVertexTypes = mapVertexToTypeConfigs(vertex);
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const vertices = useAtomValue(nodesAtom);
     const edges = useAtomValue(edgesAtom);
@@ -163,7 +163,7 @@ test("should update schema when adding a node with no label", async () => {
   vertex.types = [];
   const expectedVertexTypes = mapVertexToTypeConfigs(vertex);
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const vertices = useAtomValue(nodesAtom);
     const edges = useAtomValue(edgesAtom);
@@ -193,7 +193,7 @@ test("should update schema when adding an edge", async () => {
   dbState.addVertexToGraph(node1);
   dbState.addVertexToGraph(node2);
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const vertices = useAtomValue(nodesAtom);
     const edges = useAtomValue(edgesAtom);
@@ -223,7 +223,7 @@ test("should add missing attributes to the schema when adding a node", async ()
     dbState.activeSchema.vertices.push(initialVtConfig);
   }
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const vertices = useAtomValue(nodesAtom);
     const edges = useAtomValue(edgesAtom);
@@ -260,7 +260,7 @@ test("should add missing attributes to the schema when adding an edge", async ()
   };
   dbState.activeSchema.edges.push(initialEtConfig);
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const vertices = useAtomValue(nodesAtom);
     const edges = useAtomValue(edgesAtom);
@@ -280,7 +280,7 @@ test("should update graph storage when adding a node", async () => {
 
   const vertex = createRandomVertex();
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const graph = useAtomValue(activeGraphSessionAtom);
     return { callback, graph };
@@ -306,7 +306,7 @@ test("should update graph storage when adding an edge", async () => {
   dbState.addVertexToGraph(node1);
   dbState.addVertexToGraph(node2);
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const graph = useAtomValue(activeGraphSessionAtom);
     return { callback, graph };
@@ -333,7 +333,7 @@ test("should infer edge connections when adding edges with vertices", async () =
     .withSource(source)
     .withTarget(target);
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const schema = useAtomValue(activeSchemaSelector);
     return { callback, schema };
@@ -367,7 +367,7 @@ test("should use batch vertex types over canvas vertex types for edge connection
     .withSource(batchSource)
     .withTarget(target);
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const schema = useAtomValue(activeSchemaSelector);
     return { callback, schema };
@@ -400,7 +400,7 @@ test("should resolve edge endpoints from canvas when not in batch", async () =>
     .withSource(source)
     .withTarget(target);
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const schema = useAtomValue(activeSchemaSelector);
     return { callback, schema };
@@ -426,7 +426,7 @@ test("should ignore blank nodes when updating graph storage", async () => {
   blankNode.isBlankNode = true;
   const edge = createRandomEdge(vertex, blankNode);
 
-  const { result } = renderHookWithState(() => {
+  const { result } = await renderHookWithState(() => {
     const callback = useAddToGraph();
     const graph = useAtomValue(activeGraphSessionAtom);
     return { callback, graph };
diff --git a/packages/graph-explorer/src/hooks/useContextMenuTarget.test.ts b/packages/graph-explorer/src/hooks/useContextMenuTarget.test.ts
index 0d8733793..73a8e615c 100644
--- a/packages/graph-explorer/src/hooks/useContextMenuTarget.test.ts
+++ b/packages/graph-explorer/src/hooks/useContextMenuTarget.test.ts
@@ -20,7 +20,7 @@ describe("useContextMenuTarget", () => {
     state = new DbState();
   });
 
-  function renderHookContextMenuTarget(params: {
+  async function renderHookContextMenuTarget(params: {
     affectedVertexIds: VertexId[];
     affectedEdgeIds: EdgeId[];
     selectedVertexIds: VertexId[];
@@ -30,7 +30,7 @@ describe("useContextMenuTarget", () => {
       new Set(params.selectedVertexIds),
       new Set(params.selectedEdgeIds),
     );
-    return renderHookWithState(
+    return await renderHookWithState(
       () =>
         useContextMenuTarget({
           affectedVertexIds: params.affectedVertexIds,
@@ -41,11 +41,11 @@ describe("useContextMenuTarget", () => {
     );
   }
 
-  it("should return single-vertex when one vertex is affected and not in selection", () => {
+  it("should return single-vertex when one vertex is affected and not in selection", async () => {
     const vertex = createTestableVertex();
     state.addTestableVertexToGraph(vertex);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [vertex.id],
       affectedEdgeIds: [],
       selectedVertexIds: [],
@@ -58,11 +58,11 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return single-vertex when one vertex is affected and selection contains only that vertex", () => {
+  it("should return single-vertex when one vertex is affected and selection contains only that vertex", async () => {
     const vertex = createTestableVertex();
     state.addTestableVertexToGraph(vertex);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [vertex.id],
       affectedEdgeIds: [],
       selectedVertexIds: [vertex.id],
@@ -75,11 +75,11 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return single-edge when one edge is affected and not in selection", () => {
+  it("should return single-edge when one edge is affected and not in selection", async () => {
     const edge = createTestableEdge();
     state.addTestableEdgeToGraph(edge);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [],
       affectedEdgeIds: [edge.id],
       selectedVertexIds: [],
@@ -92,11 +92,11 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return single-edge when one edge is affected and selection contains only that edge", () => {
+  it("should return single-edge when one edge is affected and selection contains only that edge", async () => {
     const edge = createTestableEdge();
     state.addTestableEdgeToGraph(edge);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [],
       affectedEdgeIds: [edge.id],
       selectedVertexIds: [],
@@ -109,13 +109,13 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return multiple-vertices when multiple vertices selected and affected vertex within selection", () => {
+  it("should return multiple-vertices when multiple vertices selected and affected vertex within selection", async () => {
     const vertex1 = createTestableVertex();
     const vertex2 = createTestableVertex();
     state.addTestableVertexToGraph(vertex1);
     state.addTestableVertexToGraph(vertex2);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [vertex1.id],
       affectedEdgeIds: [],
       selectedVertexIds: [vertex1.id, vertex2.id],
@@ -128,13 +128,13 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return multiple-edges when multiple edges selected and affected edge within selection", () => {
+  it("should return multiple-edges when multiple edges selected and affected edge within selection", async () => {
     const edge1 = createTestableEdge();
     const edge2 = createTestableEdge();
     state.addTestableEdgeToGraph(edge1);
     state.addTestableEdgeToGraph(edge2);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [],
       affectedEdgeIds: [edge1.id],
       selectedVertexIds: [],
@@ -147,13 +147,13 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return multiple-vertices-and-edges when both selected and affected vertex within selection", () => {
+  it("should return multiple-vertices-and-edges when both selected and affected vertex within selection", async () => {
     const vertex = createTestableVertex();
     const edge = createTestableEdge();
     state.addTestableVertexToGraph(vertex);
     state.addTestableEdgeToGraph(edge);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [vertex.id],
       affectedEdgeIds: [],
       selectedVertexIds: [vertex.id],
@@ -167,13 +167,13 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return multiple-vertices-and-edges when both selected and affected edge within selection", () => {
+  it("should return multiple-vertices-and-edges when both selected and affected edge within selection", async () => {
     const vertex = createTestableVertex();
     const edge = createTestableEdge();
     state.addTestableVertexToGraph(vertex);
     state.addTestableEdgeToGraph(edge);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [],
       affectedEdgeIds: [edge.id],
       selectedVertexIds: [vertex.id],
@@ -187,7 +187,7 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return none when no selection and no affected", () => {
+  it("should return none when no selection and no affected", async () => {
     const vertex1 = createTestableVertex();
     const vertex2 = createTestableVertex();
     const edge = createTestableEdge();
@@ -195,7 +195,7 @@ describe("useContextMenuTarget", () => {
     state.addTestableVertexToGraph(vertex2);
     state.addTestableEdgeToGraph(edge);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [],
       affectedEdgeIds: [],
       selectedVertexIds: [],
@@ -205,13 +205,13 @@ describe("useContextMenuTarget", () => {
     expect(result.current).toStrictEqual({ type: "none" });
   });
 
-  it("should return single-vertex when single affected vertex not in selection", () => {
+  it("should return single-vertex when single affected vertex not in selection", async () => {
     const vertex1 = createTestableVertex();
     const vertex2 = createTestableVertex();
     state.addTestableVertexToGraph(vertex1);
     state.addTestableVertexToGraph(vertex2);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [vertex1.id],
       affectedEdgeIds: [],
       selectedVertexIds: [vertex2.id],
@@ -224,7 +224,7 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return multiple-vertices when multiple affected vertices not in selection", () => {
+  it("should return multiple-vertices when multiple affected vertices not in selection", async () => {
     const vertex1 = createTestableVertex();
     const vertex2 = createTestableVertex();
     const vertex3 = createTestableVertex();
@@ -232,7 +232,7 @@ describe("useContextMenuTarget", () => {
     state.addTestableVertexToGraph(vertex2);
     state.addTestableVertexToGraph(vertex3);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [vertex1.id, vertex2.id],
       affectedEdgeIds: [],
       selectedVertexIds: [vertex3.id],
@@ -245,13 +245,13 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return single-edge when single affected edge not in selection", () => {
+  it("should return single-edge when single affected edge not in selection", async () => {
     const edge1 = createTestableEdge();
     const edge2 = createTestableEdge();
     state.addTestableEdgeToGraph(edge1);
     state.addTestableEdgeToGraph(edge2);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [],
       affectedEdgeIds: [edge1.id],
       selectedVertexIds: [],
@@ -264,7 +264,7 @@ describe("useContextMenuTarget", () => {
     });
   });
 
-  it("should return multiple-edges when multiple affected edges not in selection", () => {
+  it("should return multiple-edges when multiple affected edges not in selection", async () => {
     const edge1 = createTestableEdge();
     const edge2 = createTestableEdge();
     const edge3 = createTestableEdge();
@@ -272,7 +272,7 @@ describe("useContextMenuTarget", () => {
     state.addTestableEdgeToGraph(edge2);
     state.addTestableEdgeToGraph(edge3);
 
-    const { result } = renderHookContextMenuTarget({
+    const { result } = await renderHookContextMenuTarget({
       affectedVertexIds: [],
       affectedEdgeIds: [edge1.id, edge2.id],
       selectedVertexIds: [],
diff --git a/packages/graph-explorer/src/hooks/useDeleteConfig.test.ts b/packages/graph-explorer/src/hooks/useDeleteConfig.test.ts
index e08dcd58f..40ef223ea 100644
--- a/packages/graph-explorer/src/hooks/useDeleteConfig.test.ts
+++ b/packages/graph-explorer/src/hooks/useDeleteConfig.test.ts
@@ -22,7 +22,7 @@ import { useDeleteActiveConfiguration } from "./useDeleteConfig";
 test("should delete the active configuration", async () => {
   const config1 = createRandomRawConfiguration();
 
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => {
       const callback = useDeleteActiveConfiguration();
       const allConfigs = useAtomValue(configurationAtom);
@@ -30,9 +30,9 @@ test("should delete the active configuration", async () => {
 
       return { callback, allConfigs, activeConfig };
     },
-    store => {
-      store.set(activeConfigurationAtom, config1.id);
-      store.set(configurationAtom, new Map([[config1.id, config1]]));
+    async store => {
+      await store.set(activeConfigurationAtom, config1.id);
+      await store.set(configurationAtom, new Map([[config1.id, config1]]));
     },
   );
 
@@ -48,17 +48,17 @@ test("should delete the active schema", async () => {
   const config1 = createRandomRawConfiguration();
   const schema1 = createRandomSchema();
 
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => {
       const callback = useDeleteActiveConfiguration();
       const allSchemas = useAtomValue(schemaAtom);
 
       return { callback, allSchemas };
     },
-    store => {
-      store.set(activeConfigurationAtom, config1.id);
-      store.set(configurationAtom, new Map([[config1.id, config1]]));
-      store.set(schemaAtom, new Map([[config1.id, schema1]]));
+    async store => {
+      await store.set(activeConfigurationAtom, config1.id);
+      await store.set(configurationAtom, new Map([[config1.id, config1]]));
+      await store.set(schemaAtom, new Map([[config1.id, schema1]]));
     },
   );
 
@@ -73,15 +73,15 @@ test("should delete the graph session for the active connection", async () => {
   const dbState = new DbState();
   dbState.addVertexToGraph(createRandomVertex());
 
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => {
       const callback = useDeleteActiveConfiguration();
       const allGraphs = useAtomValue(allGraphSessionsAtom);
 
       return { callback, allGraphs };
     },
-    store => {
-      dbState.applyTo(store);
+    async store => {
+      await dbState.applyTo(store);
     },
   );
 
diff --git a/packages/graph-explorer/src/hooks/useDeleteConfig.ts b/packages/graph-explorer/src/hooks/useDeleteConfig.ts
index a843c856b..1676213c9 100644
--- a/packages/graph-explorer/src/hooks/useDeleteConfig.ts
+++ b/packages/graph-explorer/src/hooks/useDeleteConfig.ts
@@ -9,7 +9,7 @@ import {
   type ConfigurationId,
   schemaAtom,
 } from "@/core";
-import { logger } from "@/utils";
+import { logAndNotify, logger } from "@/utils";
 
 export function useDeleteConfig() {
   return useAtomCallback(
@@ -20,25 +20,25 @@ export function useDeleteConfig() {
           return null;
         }
         return prev;
-      });
+      }).catch(logAndNotify("Failed to finish deleting the connection."));
 
       set(configurationAtom, prevConfigs => {
         const updatedConfigs = new Map(prevConfigs);
         updatedConfigs.delete(id);
         return updatedConfigs;
-      });
+      }).catch(logAndNotify("Failed to finish deleting the connection."));
 
       set(schemaAtom, prevSchemas => {
         const updatedSchemas = new Map(prevSchemas);
         updatedSchemas.delete(id);
         return updatedSchemas;
-      });
+      }).catch(logAndNotify("Failed to finish deleting the connection."));
 
       set(allGraphSessionsAtom, prev => {
         const updatedGraphs = new Map(prev);
         updatedGraphs.delete(id);
         return updatedGraphs;
-      });
+      }).catch(logAndNotify("Failed to finish deleting the connection."));
     }, []),
   );
 }
diff --git a/packages/graph-explorer/src/hooks/useEntitiesCounts.test.ts b/packages/graph-explorer/src/hooks/useEntitiesCounts.test.ts
index daa7a6c8b..98ef95097 100644
--- a/packages/graph-explorer/src/hooks/useEntitiesCounts.test.ts
+++ b/packages/graph-explorer/src/hooks/useEntitiesCounts.test.ts
@@ -15,14 +15,14 @@ import {
 
 import useEntitiesCounts from "./useEntitiesCounts";
 
-function renderUseEntitiesHook(
+async function renderUseEntitiesHook(
   config: RawConfiguration,
   schema: SchemaStorageModel,
 ) {
   const dbState = new DbState();
   dbState.activeSchema = schema;
   dbState.activeConfig = config;
-  return renderHookWithState(() => useEntitiesCounts(), dbState);
+  return await renderHookWithState(() => useEntitiesCounts(), dbState);
 }
 
 describe("useEntitiesCounts", () => {
@@ -35,50 +35,50 @@ describe("useEntitiesCounts", () => {
     vi.resetAllMocks();
   });
 
-  it("should return null when schema has not been synced", () => {
+  it("should return null when schema has not been synced", async () => {
     schema.lastUpdate = undefined;
     schema.lastSyncFail = false;
 
-    const { result } = renderUseEntitiesHook(config, schema);
+    const { result } = await renderUseEntitiesHook(config, schema);
 
     expect(result.current.totalNodes).toBeNull();
     expect(result.current.totalEdges).toBeNull();
   });
 
-  it("should return null when schema has tried to sync", () => {
+  it("should return null when schema has tried to sync", async () => {
     schema.lastUpdate = undefined;
     schema.lastSyncFail = true;
 
-    const { result } = renderUseEntitiesHook(config, schema);
+    const { result } = await renderUseEntitiesHook(config, schema);
 
     expect(result.current.totalNodes).toBeNull();
     expect(result.current.totalEdges).toBeNull();
   });
 
-  it("should return total vertices when totalVertices is defined", () => {
+  it("should return total vertices when totalVertices is defined", async () => {
     const preCalculatedTotal = createRandomInteger();
     schema.totalVertices = preCalculatedTotal;
     schema.totalEdges = preCalculatedTotal;
 
-    const { result } = renderUseEntitiesHook(config, schema);
+    const { result } = await renderUseEntitiesHook(config, schema);
 
     expect(result.current.totalNodes).toEqual(preCalculatedTotal);
     expect(result.current.totalEdges).toEqual(preCalculatedTotal);
   });
 
-  it("should return 0 when schema has no entity type configs", () => {
+  it("should return 0 when schema has no entity type configs", async () => {
     schema.totalVertices = 0;
     schema.vertices = [];
     schema.totalEdges = 0;
     schema.edges = [];
 
-    const { result } = renderUseEntitiesHook(config, schema);
+    const { result } = await renderUseEntitiesHook(config, schema);
 
     expect(result.current.totalNodes).toBe(0);
     expect(result.current.totalEdges).toBe(0);
   });
 
-  it("should calculate total when all entity type configs have a total", () => {
+  it("should calculate total when all entity type configs have a total", async () => {
     schema.totalVertices = 0;
     schema.vertices = [
       createRandomVertexTypeConfig(),
@@ -90,13 +90,13 @@ describe("useEntitiesCounts", () => {
       createRandomEdgeTypeConfig(),
     ].map(etConfig => ({ ...etConfig, total: 5 }));
 
-    const { result } = renderUseEntitiesHook(config, schema);
+    const { result } = await renderUseEntitiesHook(config, schema);
 
     expect(result.current.totalNodes).toEqual(10);
     expect(result.current.totalEdges).toEqual(10);
   });
 
-  it("should return null when some entity type configs are missing a total", () => {
+  it("should return null when some entity type configs are missing a total", async () => {
     schema.totalVertices = 0;
     schema.vertices = [
       createRandomVertexTypeConfig(),
@@ -111,7 +111,7 @@ describe("useEntitiesCounts", () => {
     ].map(etConfig => ({ ...etConfig, total: undefined }));
     schema.edges[0].total = 10;
 
-    const { result } = renderUseEntitiesHook(config, schema);
+    const { result } = await renderUseEntitiesHook(config, schema);
 
     expect(result.current.totalNodes).toBeNull();
     expect(result.current.totalEdges).toBeNull();
diff --git a/packages/graph-explorer/src/hooks/useEntityCountFormatter.test.ts b/packages/graph-explorer/src/hooks/useEntityCountFormatter.test.ts
index dc5e07646..a59f7a198 100644
--- a/packages/graph-explorer/src/hooks/useEntityCountFormatter.test.ts
+++ b/packages/graph-explorer/src/hooks/useEntityCountFormatter.test.ts
@@ -22,43 +22,43 @@ vi.mock("./useTranslations", () => ({
 }));
 
 describe("useFormattedEntityCounts", () => {
-  it("should format single node and single edge", () => {
-    const { result } = renderHookWithJotai(() =>
+  it("should format single node and single edge", async () => {
+    const { result } = await renderHookWithJotai(() =>
       useFormattedEntityCounts(1, 1),
     );
     expect(result.current).toBe("1 node and 1 edge");
   });
 
-  it("should format multiple nodes and multiple edges", () => {
-    const { result } = renderHookWithJotai(() =>
+  it("should format multiple nodes and multiple edges", async () => {
+    const { result } = await renderHookWithJotai(() =>
       useFormattedEntityCounts(5, 3),
     );
     expect(result.current).toBe("5 nodes and 3 edges");
   });
 
-  it("should format only nodes when edge count is zero", () => {
-    const { result } = renderHookWithJotai(() =>
+  it("should format only nodes when edge count is zero", async () => {
+    const { result } = await renderHookWithJotai(() =>
       useFormattedEntityCounts(2, 0),
     );
     expect(result.current).toBe("2 nodes");
   });
 
-  it("should format only edges when node count is zero", () => {
-    const { result } = renderHookWithJotai(() =>
+  it("should format only edges when node count is zero", async () => {
+    const { result } = await renderHookWithJotai(() =>
       useFormattedEntityCounts(0, 4),
     );
     expect(result.current).toBe("4 edges");
   });
 
-  it("should return empty string when both counts are zero", () => {
-    const { result } = renderHookWithJotai(() =>
+  it("should return empty string when both counts are zero", async () => {
+    const { result } = await renderHookWithJotai(() =>
       useFormattedEntityCounts(0, 0),
     );
     expect(result.current).toBe("");
   });
 
-  it("should format large numbers with locale formatting", () => {
-    const { result } = renderHookWithJotai(() =>
+  it("should format large numbers with locale formatting", async () => {
+    const { result } = await renderHookWithJotai(() =>
       useFormattedEntityCounts(1000, 2500),
     );
     expect(result.current).toBe("1,000 nodes and 2,500 edges");
@@ -66,8 +66,8 @@ describe("useFormattedEntityCounts", () => {
 });
 
 describe("useEntityCountFormatterCallback", () => {
-  it("should return a function that formats counts", () => {
-    const { result } = renderHookWithJotai(() =>
+  it("should return a function that formats counts", async () => {
+    const { result } = await renderHookWithJotai(() =>
       useEntityCountFormatterCallback(),
     );
 
@@ -75,8 +75,8 @@ describe("useEntityCountFormatterCallback", () => {
     expect(result.current(1, 1)).toBe("1 node and 1 edge");
   });
 
-  it("should handle different count combinations", () => {
-    const { result } = renderHookWithJotai(() =>
+  it("should handle different count combinations", async () => {
+    const { result } = await renderHookWithJotai(() =>
       useEntityCountFormatterCallback(),
     );
 
diff --git a/packages/graph-explorer/src/hooks/useExpandNode.test.ts b/packages/graph-explorer/src/hooks/useExpandNode.test.ts
index c15134deb..845973168 100644
--- a/packages/graph-explorer/src/hooks/useExpandNode.test.ts
+++ b/packages/graph-explorer/src/hooks/useExpandNode.test.ts
@@ -20,65 +20,65 @@ import useExpandNode, {
 } from "./useExpandNode";
 
 describe("useDefaultNeighborExpansionLimit", () => {
-  it("should return the app limit when defined", () => {
+  it("should return the app limit when defined", async () => {
     const dbState = new DbState();
     if (dbState.activeConfig.connection) {
       delete dbState.activeConfig.connection.nodeExpansionLimit;
     }
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useDefaultNeighborExpansionLimit(),
-      store => {
-        dbState.applyTo(store);
-        store.set(defaultNeighborExpansionLimitAtom, 10);
-        store.set(defaultNeighborExpansionLimitEnabledAtom, true);
+      async store => {
+        await dbState.applyTo(store);
+        await store.set(defaultNeighborExpansionLimitAtom, 10);
+        await store.set(defaultNeighborExpansionLimitEnabledAtom, true);
       },
     );
 
     expect(result.current).toBe(10);
   });
 
-  it("should return the connection limit when defined", () => {
+  it("should return the connection limit when defined", async () => {
     const dbState = new DbState();
     if (dbState.activeConfig.connection) {
       dbState.activeConfig.connection.nodeExpansionLimit = 20;
     }
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useDefaultNeighborExpansionLimit(),
-      store => {
-        dbState.applyTo(store);
+      async store => {
+        await dbState.applyTo(store);
       },
     );
 
     expect(result.current).toBe(20);
   });
 
-  it("should return the connection limit when both app and connection limits are defined", () => {
+  it("should return the connection limit when both app and connection limits are defined", async () => {
     const dbState = new DbState();
     if (dbState.activeConfig.connection) {
       dbState.activeConfig.connection.nodeExpansionLimit = 20;
     }
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useDefaultNeighborExpansionLimit(),
-      store => {
-        dbState.applyTo(store);
-        store.set(defaultNeighborExpansionLimitEnabledAtom, true);
-        store.set(defaultNeighborExpansionLimitAtom, 10);
+      async store => {
+        await dbState.applyTo(store);
+        await store.set(defaultNeighborExpansionLimitEnabledAtom, true);
+        await store.set(defaultNeighborExpansionLimitAtom, 10);
       },
     );
 
     expect(result.current).toBe(20);
   });
 
-  it("should return null when neither app nor connection limits are defined", () => {
+  it("should return null when neither app nor connection limits are defined", async () => {
     const dbState = new DbState();
     if (dbState.activeConfig.connection) {
       delete dbState.activeConfig.connection.nodeExpansionLimit;
     }
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useDefaultNeighborExpansionLimit(),
-      store => {
-        dbState.applyTo(store);
-        store.set(defaultNeighborExpansionLimitEnabledAtom, false);
+      async store => {
+        await dbState.applyTo(store);
+        await store.set(defaultNeighborExpansionLimitEnabledAtom, false);
       },
     );
 
@@ -95,17 +95,17 @@ describe("useExpandNode", () => {
     dbState = new DbState(explorer);
   });
 
-  function renderHookExpandNode() {
-    return renderHookWithState(() => useExpandNode(), dbState);
+  async function renderHookExpandNode() {
+    return await renderHookWithState(() => useExpandNode(), dbState);
   }
 
-  it("should return isPending as false initially", () => {
-    const { result } = renderHookExpandNode();
+  it("should return isPending as false initially", async () => {
+    const { result } = await renderHookExpandNode();
 
     expect(result.current.isPending).toBe(false);
   });
 
-  it("should not expand when vertex has no unfetched neighbors", () => {
+  it("should not expand when vertex has no unfetched neighbors", async () => {
     const vertex = createTestableVertex();
     const neighbor = createTestableVertex();
     const edge = createTestableEdge().withSource(vertex).withTarget(neighbor);
@@ -114,7 +114,7 @@ describe("useExpandNode", () => {
     dbState.addTestableEdgeToGraph(edge);
     explorer.addTestableEdge(edge);
 
-    const { result } = renderHookExpandNode();
+    const { result } = await renderHookExpandNode();
 
     act(() => {
       result.current.expandNode({ vertexId: vertex.id });
@@ -137,7 +137,7 @@ describe("useExpandNode", () => {
 
     vi.spyOn(explorer, "fetchNeighbors");
 
-    const { result } = renderHookExpandNode();
+    const { result } = await renderHookExpandNode();
 
     act(() => {
       result.current.expandNode({ vertexId: vertex.id });
@@ -175,7 +175,7 @@ describe("useExpandNode", () => {
 
     vi.spyOn(explorer, "fetchNeighbors");
 
-    const { result } = renderHookExpandNode();
+    const { result } = await renderHookExpandNode();
 
     act(() => {
       result.current.expandNode({ vertexId: vertex.id });
@@ -217,7 +217,7 @@ describe("useExpandNode", () => {
 
       vi.spyOn(explorer, "fetchNeighbors");
 
-      const { result } = renderHookExpandNode();
+      const { result } = await renderHookExpandNode();
 
       act(() => {
         result.current.expandNodes({ vertexIds: [vertex1.id, vertex2.id] });
@@ -252,7 +252,7 @@ describe("useExpandNode", () => {
 
       vi.spyOn(explorer, "fetchNeighbors");
 
-      const { result } = renderHookExpandNode();
+      const { result } = await renderHookExpandNode();
 
       act(() => {
         result.current.expandNodes({ vertexIds: [vertex1.id, vertex2.id] });
@@ -287,7 +287,7 @@ describe("useExpandNode", () => {
 
       vi.spyOn(explorer, "fetchNeighbors");
 
-      const { result } = renderHookExpandNode();
+      const { result } = await renderHookExpandNode();
 
       const request: ExpandNodesRequest = {
         vertexIds: [vertex1.id, vertex2.id],
diff --git a/packages/graph-explorer/src/hooks/useExpandNode.tsx b/packages/graph-explorer/src/hooks/useExpandNode.tsx
index 955720533..9e0888e39 100644
--- a/packages/graph-explorer/src/hooks/useExpandNode.tsx
+++ b/packages/graph-explorer/src/hooks/useExpandNode.tsx
@@ -82,7 +82,7 @@ export default function useExpandNode() {
       toast.promise(expandPromise, {
         loading: "Expanding neighbors",
         error: err => {
-          remoteLogger.error(
+          void remoteLogger.error(
             `Failed to expand node: ${(err as Error)?.message ?? "Unknown error"}`,
           );
           const displayError = createDisplayError(err);
@@ -155,7 +155,7 @@ export default function useExpandNode() {
       toast.promise(expandPromise, {
         loading: `Expanding neighbors`,
         error: err => {
-          remoteLogger.error(
+          void remoteLogger.error(
             `Failed to expand nodes: ${(err as Error)?.message ?? "Unknown error"}`,
           );
           const displayError = createDisplayError(err);
diff --git a/packages/graph-explorer/src/hooks/useHasVertexBeenAddedToGraph.test.ts b/packages/graph-explorer/src/hooks/useHasVertexBeenAddedToGraph.test.ts
index a645f4338..7ee59bfab 100644
--- a/packages/graph-explorer/src/hooks/useHasVertexBeenAddedToGraph.test.ts
+++ b/packages/graph-explorer/src/hooks/useHasVertexBeenAddedToGraph.test.ts
@@ -9,18 +9,18 @@ import { createRandomVertex, renderHookWithJotai } from "@/utils/testing";
 
 import { useHasVertexBeenAddedToGraph } from "./useHasVertexBeenAddedToGraph";
 
-test("returns false if vertex has not been added to graph", () => {
+test("returns false if vertex has not been added to graph", async () => {
   const vertex = createRandomVertex();
-  const { result } = renderHookWithJotai(() =>
+  const { result } = await renderHookWithJotai(() =>
     useHasVertexBeenAddedToGraph(vertex.id),
   );
 
   expect(result.current).toBe(false);
 });
 
-test("returns true if vertex has been added to graph", () => {
+test("returns true if vertex has been added to graph", async () => {
   const vertex = createRandomVertex();
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => useHasVertexBeenAddedToGraph(vertex.id),
     store => {
       store.set(nodesAtom, toNodeMap([vertex]));
@@ -30,9 +30,9 @@ test("returns true if vertex has been added to graph", () => {
   expect(result.current).toBe(true);
 });
 
-test("returns true if vertex has been added to graph and is filtered out by id", () => {
+test("returns true if vertex has been added to graph and is filtered out by id", async () => {
   const vertex = createRandomVertex();
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => useHasVertexBeenAddedToGraph(vertex.id),
     store => {
       store.set(nodesAtom, toNodeMap([vertex]));
@@ -43,9 +43,9 @@ test("returns true if vertex has been added to graph and is filtered out by id",
   expect(result.current).toBe(true);
 });
 
-test("returns true if vertex has been added to graph and is filtered out by type", () => {
+test("returns true if vertex has been added to graph and is filtered out by type", async () => {
   const vertex = createRandomVertex();
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => useHasVertexBeenAddedToGraph(vertex.id),
     store => {
       store.set(nodesAtom, toNodeMap([vertex]));
diff --git a/packages/graph-explorer/src/hooks/useNeighborsOptions.test.ts b/packages/graph-explorer/src/hooks/useNeighborsOptions.test.ts
index b071cc4cb..fe45ad574 100644
--- a/packages/graph-explorer/src/hooks/useNeighborsOptions.test.ts
+++ b/packages/graph-explorer/src/hooks/useNeighborsOptions.test.ts
@@ -18,11 +18,11 @@ describe("useNeighborsOptions", () => {
     vi.clearAllMocks();
   });
 
-  it("should return an empty list when no response", () => {
+  it("should return an empty list when no response", async () => {
     const dbState = new DbState();
     const vertex = createRandomVertex();
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useNeighborsOptions(vertex.id),
       dbState,
     );
@@ -30,7 +30,7 @@ describe("useNeighborsOptions", () => {
     expect(result.current).toHaveLength(0);
   });
 
-  it("should return an empty list when response is empty", () => {
+  it("should return an empty list when response is empty", async () => {
     const dbState = new DbState();
     const vertex = createRandomVertex();
 
@@ -43,7 +43,7 @@ describe("useNeighborsOptions", () => {
       counts: [response],
     });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useNeighborsOptions(vertex.id),
       dbState,
     );
@@ -68,7 +68,7 @@ describe("useNeighborsOptions", () => {
       counts: [response],
     });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useNeighborsOptions(vertex.id),
       dbState,
     );
@@ -113,7 +113,7 @@ describe("useNeighborsOptions", () => {
       counts: [response],
     });
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useNeighborsOptions(vertex.id),
       dbState,
     );
diff --git a/packages/graph-explorer/src/hooks/useRefreshEntities.test.ts b/packages/graph-explorer/src/hooks/useRefreshEntities.test.ts
index 26d3d5214..c925c0025 100644
--- a/packages/graph-explorer/src/hooks/useRefreshEntities.test.ts
+++ b/packages/graph-explorer/src/hooks/useRefreshEntities.test.ts
@@ -42,7 +42,7 @@ describe("useRefreshEntities", () => {
     explorer.addVertex(updatedVertex);
     explorer.addEdge(updatedEdge);
 
-    const { result } = renderHookWithState(() => {
+    const { result } = await renderHookWithState(() => {
       const queryClient = useQueryClient();
       const refreshHook = useRefreshEntities();
 
@@ -95,7 +95,10 @@ describe("useRefreshEntities", () => {
     const vertexDetailsSpy = vi.spyOn(explorer, "vertexDetails");
     const edgeDetailsSpy = vi.spyOn(explorer, "edgeDetails");
 
-    const { result } = renderHookWithState(() => useRefreshEntities(), state);
+    const { result } = await renderHookWithState(
+      () => useRefreshEntities(),
+      state,
+    );
 
     act(() => {
       result.current.refresh({
@@ -124,7 +127,10 @@ describe("useRefreshEntities", () => {
     const vertexDetailsSpy = vi.spyOn(explorer, "vertexDetails");
     const edgeDetailsSpy = vi.spyOn(explorer, "edgeDetails");
 
-    const { result } = renderHookWithState(() => useRefreshEntities(), state);
+    const { result } = await renderHookWithState(
+      () => useRefreshEntities(),
+      state,
+    );
 
     act(() => {
       result.current.refresh({
diff --git a/packages/graph-explorer/src/hooks/useRemoveFromGraph.test.ts b/packages/graph-explorer/src/hooks/useRemoveFromGraph.test.ts
index 07bc51429..39fad09b6 100644
--- a/packages/graph-explorer/src/hooks/useRemoveFromGraph.test.ts
+++ b/packages/graph-explorer/src/hooks/useRemoveFromGraph.test.ts
@@ -36,7 +36,7 @@ test("should remove one node", async () => {
   const vertex = createRandomVertex();
   const noise = createArray(10, createRandomVertex);
   const idsOfNoise = noise.map(n => n.id);
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => {
       const callback = useRemoveNodeFromGraph(vertex.id);
       const nodes = useAtomValue(nodesAtom);
@@ -75,7 +75,7 @@ test("should remove one edge", async () => {
   const edge1 = createRandomEdge(node1, node2);
   const edge2 = createRandomEdge(node2, node1);
 
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => {
       const callback = useRemoveEdgeFromGraph(edge1.id);
       const edges = useAtomValue(edgesAtom);
@@ -117,7 +117,7 @@ test("should remove associated edges when a node is removed", async () => {
   const edge1 = createRandomEdge(node1, node2);
   const edge2 = createRandomEdge(node2, node1);
 
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => {
       const callback = useRemoveNodeFromGraph(node2.id);
 
@@ -162,7 +162,7 @@ test("should remove all nodes and edges", async () => {
   dbState.createEdgeInGraph(dbState.vertices[0], dbState.vertices[1]);
   dbState.createEdgeInGraph(dbState.vertices[1], dbState.vertices[0]);
 
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => {
       const callback = useClearGraph();
 
@@ -193,8 +193,8 @@ test("should remove all nodes and edges", async () => {
         graph,
       };
     },
-    store => {
-      dbState.applyTo(store);
+    async store => {
+      await dbState.applyTo(store);
     },
   );
 
@@ -228,7 +228,7 @@ test("should update graph session", async () => {
   dbState.addEdgeToGraph(edge1);
   dbState.addEdgeToGraph(edge2);
 
-  const { result } = renderHookWithJotai(
+  const { result } = await renderHookWithJotai(
     () => {
       const callback = useRemoveFromGraph();
       const graph = useAtomValue(activeGraphSessionAtom);
@@ -238,8 +238,8 @@ test("should update graph session", async () => {
         graph,
       };
     },
-    store => {
-      dbState.applyTo(store);
+    async store => {
+      await dbState.applyTo(store);
     },
   );
 
diff --git a/packages/graph-explorer/src/hooks/useSchemaSync.test.ts b/packages/graph-explorer/src/hooks/useSchemaSync.test.ts
index 51b2b7651..020cf6087 100644
--- a/packages/graph-explorer/src/hooks/useSchemaSync.test.ts
+++ b/packages/graph-explorer/src/hooks/useSchemaSync.test.ts
@@ -55,55 +55,58 @@ describe("useSchemaSync", () => {
   }
 
   describe("no active connection", () => {
-    function renderWithNoConnection() {
-      return renderHookWithJotai(
+    async function renderWithNoConnection() {
+      return await renderHookWithJotai(
         () => useSchemaSync(),
-        store => {
-          store.set(activeConfigurationAtom, null);
-          store.set(configurationAtom, new Map());
-          store.set(schemaAtom, new Map());
+        async store => {
+          await store.set(activeConfigurationAtom, null);
+          await store.set(configurationAtom, new Map());
+          await store.set(schemaAtom, new Map());
           store.set(explorerForTestingAtom, explorer);
         },
       );
     }
 
-    it("should not fetch schema when no connection exists", () => {
+    it("should not fetch schema when no connection exists", async () => {
       const fetchSchemaSpy = vi.spyOn(explorer, "fetchSchema");
 
-      const { result } = renderWithNoConnection();
+      const { result } = await renderWithNoConnection();
 
       expect(fetchSchemaSpy).not.toHaveBeenCalled();
       expect(result.current.schemaDiscoveryQuery.fetchStatus).toBe("idle");
     });
 
-    it("should not fetch edge connections when no connection exists", () => {
+    it("should not fetch edge connections when no connection exists", async () => {
       const fetchEdgeConnectionsSpy = vi.spyOn(
         explorer,
         "fetchEdgeConnections",
       );
 
-      const { result } = renderWithNoConnection();
+      const { result } = await renderWithNoConnection();
 
       expect(fetchEdgeConnectionsSpy).not.toHaveBeenCalled();
       expect(result.current.edgeDiscoveryQuery.fetchStatus).toBe("idle");
     });
 
-    it("should report isFetching as false when no connection exists", () => {
-      const { result } = renderWithNoConnection();
+    it("should report isFetching as false when no connection exists", async () => {
+      const { result } = await renderWithNoConnection();
 
       expect(result.current.isFetching).toBe(false);
     });
   });
 
   describe("schemaDiscoveryQuery", () => {
-    it("should use initialData from active schema without fetching", () => {
+    it("should use initialData from active schema without fetching", async () => {
       const vertexType = createVertexType("Person");
       const edgeType = createEdgeType("knows");
       const state = createStateWithSchema([vertexType], [edgeType]);
 
       const fetchSchemaSpy = vi.spyOn(explorer, "fetchSchema");
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(result.current.schemaDiscoveryQuery.data?.vertices).toHaveLength(
         1,
@@ -112,12 +115,15 @@ describe("useSchemaSync", () => {
       expect(fetchSchemaSpy).not.toHaveBeenCalled();
     });
 
-    it("should fetch schema when no active schema exists", () => {
+    it("should fetch schema when no active schema exists", async () => {
       const state = new DbState(explorer).withNoActiveSchema();
 
       const fetchSchemaSpy = vi.spyOn(explorer, "fetchSchema");
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(result.current.schemaDiscoveryQuery.data).toBeUndefined();
       expect(fetchSchemaSpy).toHaveBeenCalled();
@@ -125,7 +131,7 @@ describe("useSchemaSync", () => {
   });
 
   describe("edgeDiscoveryQuery", () => {
-    it("should fetch edge connections when schema has edges", () => {
+    it("should fetch edge connections when schema has edges", async () => {
       const edgeType = createEdgeType("knows");
       const state = createStateWithSchema([], [edgeType]);
 
@@ -134,7 +140,7 @@ describe("useSchemaSync", () => {
         "fetchEdgeConnections",
       );
 
-      renderHookWithState(() => useSchemaSync(), state);
+      await renderHookWithState(() => useSchemaSync(), state);
 
       expect(fetchEdgeConnectionsSpy).toHaveBeenCalledWith(
         expect.objectContaining({ edgeTypes: [edgeType] }),
@@ -150,7 +156,7 @@ describe("useSchemaSync", () => {
         "fetchEdgeConnections",
       );
 
-      renderHookWithState(() => useSchemaSync(), state);
+      await renderHookWithState(() => useSchemaSync(), state);
 
       const store = getAppStore();
 
@@ -162,7 +168,7 @@ describe("useSchemaSync", () => {
       expect(fetchEdgeConnectionsSpy).not.toHaveBeenCalled();
     });
 
-    it("should not fetch edge connections when no active schema exists", () => {
+    it("should not fetch edge connections when no active schema exists", async () => {
       const state = new DbState(explorer).withNoActiveSchema();
 
       const fetchEdgeConnectionsSpy = vi.spyOn(
@@ -170,13 +176,16 @@ describe("useSchemaSync", () => {
         "fetchEdgeConnections",
       );
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(result.current.edgeDiscoveryQuery.fetchStatus).toBe("idle");
       expect(fetchEdgeConnectionsSpy).not.toHaveBeenCalled();
     });
 
-    it("should use existing edge connections as initialData", () => {
+    it("should use existing edge connections as initialData", async () => {
       const edgeType = createEdgeType("knows");
       const sourceType = createVertexType("Person");
       const targetType = createVertexType("Company");
@@ -198,7 +207,10 @@ describe("useSchemaSync", () => {
         "fetchEdgeConnections",
       );
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(result.current.edgeDiscoveryQuery.data).toStrictEqual(
         existingConnections,
@@ -206,7 +218,7 @@ describe("useSchemaSync", () => {
       expect(fetchEdgeConnectionsSpy).not.toHaveBeenCalled();
     });
 
-    it("should use empty edge connections array as initialData", () => {
+    it("should use empty edge connections array as initialData", async () => {
       const state = new DbState(explorer);
       state.activeSchema.edges = [
         { type: createEdgeType("knows"), attributes: [] },
@@ -218,13 +230,16 @@ describe("useSchemaSync", () => {
         "fetchEdgeConnections",
       );
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(result.current.edgeDiscoveryQuery.data).toStrictEqual([]);
       expect(fetchEdgeConnectionsSpy).not.toHaveBeenCalled();
     });
 
-    it("should use all edge connections as initialData without filtering", () => {
+    it("should use all edge connections as initialData without filtering", async () => {
       const edgeType1 = createEdgeType("knows");
       const edgeType2 = createEdgeType("worksAt");
       const sourceType = createVertexType("Person");
@@ -248,7 +263,10 @@ describe("useSchemaSync", () => {
       state.activeSchema.edges = [{ type: edgeType1, attributes: [] }];
       state.activeSchema.edgeConnections = existingConnections;
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(result.current.edgeDiscoveryQuery.data).toStrictEqual(
         existingConnections,
@@ -262,14 +280,17 @@ describe("useSchemaSync", () => {
       // Set edge connections so edge discovery doesn't run
       state.activeSchema.edgeConnections = [];
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       await waitFor(() => {
         expect(result.current.isFetching).toBe(false);
       });
     });
 
-    it("should be true when schema discovery is fetching", () => {
+    it("should be true when schema discovery is fetching", async () => {
       const state = new DbState(explorer).withNoActiveSchema();
 
       // Make fetchSchema hang to keep isFetching true
@@ -277,12 +298,15 @@ describe("useSchemaSync", () => {
         () => new Promise(() => {}),
       );
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(result.current.isFetching).toBe(true);
     });
 
-    it("should be true when edge discovery is fetching", () => {
+    it("should be true when edge discovery is fetching", async () => {
       const edgeType = createEdgeType("knows");
       const state = createStateWithSchema([], [edgeType]);
 
@@ -291,7 +315,10 @@ describe("useSchemaSync", () => {
         () => new Promise(() => {}),
       );
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(result.current.isFetching).toBe(true);
     });
@@ -302,7 +329,10 @@ describe("useSchemaSync", () => {
       const state = createStateWithSchema([], []);
       const fetchSchemaSpy = vi.spyOn(explorer, "fetchSchema");
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       // Initial render doesn't fetch because initialData is provided
       expect(fetchSchemaSpy).not.toHaveBeenCalled();
@@ -322,7 +352,10 @@ describe("useSchemaSync", () => {
         "fetchEdgeConnections",
       );
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       await waitFor(() => {
         expect(fetchEdgeConnectionsSpy).toHaveBeenCalledTimes(1);
@@ -337,24 +370,27 @@ describe("useSchemaSync", () => {
   });
 
   describe("staleTime behavior", () => {
-    it("should not fetch schema when initialData exists", () => {
+    it("should not fetch schema when initialData exists", async () => {
       const state = new DbState(explorer);
 
       const fetchSchemaSpy = vi.spyOn(explorer, "fetchSchema");
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       // Should use initialData but not fetch
       expect(result.current.schemaDiscoveryQuery.data).toBeDefined();
       expect(fetchSchemaSpy).not.toHaveBeenCalled();
     });
 
-    it("should fetch schema when no active schema exists", () => {
+    it("should fetch schema when no active schema exists", async () => {
       const state = new DbState(explorer).withNoActiveSchema();
 
       const fetchSchemaSpy = vi.spyOn(explorer, "fetchSchema");
 
-      renderHookWithState(() => useSchemaSync(), state);
+      await renderHookWithState(() => useSchemaSync(), state);
 
       expect(fetchSchemaSpy).toHaveBeenCalled();
     });
@@ -366,7 +402,10 @@ describe("useSchemaSync", () => {
 
       const fetchSchemaSpy = vi.spyOn(explorer, "fetchSchema");
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       // Auto-fetch should not happen because initialData is fresh
       expect(fetchSchemaSpy).not.toHaveBeenCalled();
@@ -379,13 +418,16 @@ describe("useSchemaSync", () => {
       expect(fetchSchemaSpy).toHaveBeenCalledTimes(1);
     });
 
-    it("should not auto-fetch when lastSyncFail is true", () => {
+    it("should not auto-fetch when lastSyncFail is true", async () => {
       const state = new DbState(explorer);
       state.activeSchema.lastSyncFail = true;
 
       const fetchSchemaSpy = vi.spyOn(explorer, "fetchSchema");
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(result.current.schemaDiscoveryQuery.data).toBeDefined();
       expect(fetchSchemaSpy).not.toHaveBeenCalled();
@@ -399,7 +441,10 @@ describe("useSchemaSync", () => {
 
       const fetchSchemaSpy = vi.spyOn(explorer, "fetchSchema");
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(fetchSchemaSpy).not.toHaveBeenCalled();
 
@@ -412,7 +457,7 @@ describe("useSchemaSync", () => {
   });
 
   describe("remount behavior", () => {
-    it("should not auto-fetch when lastSyncFail is true after remount", () => {
+    it("should not auto-fetch when lastSyncFail is true after remount", async () => {
       // Simulate: sync failed, user navigated away, then came back.
       // Start with lastSyncFail already set (as if a previous sync failed).
       const state = new DbState(explorer);
@@ -423,14 +468,17 @@ describe("useSchemaSync", () => {
         .mockRejectedValue(new Error("Network error"));
 
       // First mount — sync should not fire due to lastSyncFail
-      const { unmount } = renderHookWithState(() => useSchemaSync(), state);
+      const { unmount } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
       expect(fetchSchemaSpy).not.toHaveBeenCalled();
 
       // User navigates away
       unmount();
 
       // User navigates back — re-render with same state
-      renderHookWithState(() => useSchemaSync(), state);
+      await renderHookWithState(() => useSchemaSync(), state);
 
       // Should still not auto-fetch because lastSyncFail is true
       expect(fetchSchemaSpy).not.toHaveBeenCalled();
@@ -444,7 +492,7 @@ describe("useSchemaSync", () => {
 
       const fetchSchemaSpy = vi.spyOn(explorer, "fetchSchema");
 
-      const { result, rerender } = renderHookWithState(
+      const { result, rerender } = await renderHookWithState(
         () => useSchemaSync(),
         state,
       );
@@ -456,12 +504,12 @@ describe("useSchemaSync", () => {
       // Switch to a new connection with no schema
       const store = getAppStore();
       const newConfig = createRandomRawConfiguration();
-      store.set(configurationAtom, prev => {
+      await store.set(configurationAtom, prev => {
         const updated = new Map(prev);
         updated.set(newConfig.id, newConfig);
         return updated;
       });
-      store.set(activeConfigurationAtom, newConfig.id);
+      await store.set(activeConfigurationAtom, newConfig.id);
 
       rerender();
 
@@ -472,7 +520,7 @@ describe("useSchemaSync", () => {
   });
 
   describe("lastEdgeConnectionSyncFail", () => {
-    it("should not auto-fetch edge connections when lastEdgeConnectionSyncFail is true", () => {
+    it("should not auto-fetch edge connections when lastEdgeConnectionSyncFail is true", async () => {
       const edgeType = createEdgeType("knows");
       const state = createStateWithSchema([], [edgeType]);
       state.activeSchema.lastEdgeConnectionSyncFail = true;
@@ -483,7 +531,10 @@ describe("useSchemaSync", () => {
         "fetchEdgeConnections",
       );
 
-      const { result } = renderHookWithState(() => useSchemaSync(), state);
+      const { result } = await renderHookWithState(
+        () => useSchemaSync(),
+        state,
+      );
 
       expect(result.current.edgeDiscoveryQuery.fetchStatus).toBe("idle");
       expect(fetchEdgeConnectionsSpy).not.toHaveBeenCalled();
@@ -498,15 +549,15 @@ describe("useIsSyncing", () => {
     explorer = new FakeExplorer();
   });
 
-  it("should return false when no schema queries are running", () => {
+  it("should return false when no schema queries are running", async () => {
     const state = new DbState(explorer);
 
-    const { result } = renderHookWithState(() => useIsSyncing(), state);
+    const { result } = await renderHookWithState(() => useIsSyncing(), state);
 
     expect(result.current).toBe(false);
   });
 
-  it("should return true when a schema query is fetching", () => {
+  it("should return true when a schema query is fetching", async () => {
     const state = new DbState(explorer).withNoActiveSchema();
 
     vi.spyOn(explorer, "fetchSchema").mockImplementation(
@@ -514,7 +565,7 @@ describe("useIsSyncing", () => {
     );
 
     // Both hooks must share the same query client to observe fetching state
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => ({ syncing: useIsSyncing(), schema: useSchemaSync() }),
       state,
     );
@@ -530,10 +581,13 @@ describe("useCancelSchemaSync", () => {
     explorer = new FakeExplorer();
   });
 
-  it("should return a function", () => {
+  it("should return a function", async () => {
     const state = new DbState(explorer);
 
-    const { result } = renderHookWithState(() => useCancelSchemaSync(), state);
+    const { result } = await renderHookWithState(
+      () => useCancelSchemaSync(),
+      state,
+    );
 
     expect(typeof result.current).toBe("function");
   });
@@ -545,7 +599,7 @@ describe("useCancelSchemaSync", () => {
       .spyOn(explorer, "fetchSchema")
       .mockImplementation(() => new Promise(() => {}));
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => ({
         cancel: useCancelSchemaSync(),
         schema: useSchemaSync(),
diff --git a/packages/graph-explorer/src/hooks/useTextTransform.test.ts b/packages/graph-explorer/src/hooks/useTextTransform.test.ts
index b5215b68b..ea3586b6d 100644
--- a/packages/graph-explorer/src/hooks/useTextTransform.test.ts
+++ b/packages/graph-explorer/src/hooks/useTextTransform.test.ts
@@ -17,7 +17,7 @@ import {
 
 import useTextTransform from "./useTextTransform";
 
-function initializeConfigWithPrefix(store: AppStore) {
+async function initializeConfigWithPrefix(store: AppStore) {
   // Create config and setup schema
   const config = createRandomRawConfiguration();
   const schema = createRandomSchema();
@@ -28,65 +28,65 @@ function initializeConfigWithPrefix(store: AppStore) {
       uri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#" as IriNamespace,
     },
   ];
-  store.set(configurationAtom, new Map([[config.id, config]]));
-  store.set(schemaAtom, new Map([[config.id, schema]]));
+  await store.set(configurationAtom, new Map([[config.id, config]]));
+  await store.set(schemaAtom, new Map([[config.id, schema]]));
 
   // Make config active
-  store.set(activeConfigurationAtom, config.id);
+  await store.set(activeConfigurationAtom, config.id);
 }
 
 describe("useTextTransform", () => {
   beforeEach(() => {
     vi.resetAllMocks();
   });
-  it("should replace prefixes in URIs", () => {
+  it("should replace prefixes in URIs", async () => {
     const text = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
     const expected = "rdf:type";
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useTextTransform(),
       initializeConfigWithPrefix,
     );
     expect(result.current(text)).toEqual(expected);
   });
 
-  it("should not modify text", () => {
+  it("should not modify text", async () => {
     const text = "this is a test";
-    const { result } = renderHookWithJotai(() => useTextTransform());
+    const { result } = await renderHookWithJotai(() => useTextTransform());
     expect(result.current(text)).toBe(text);
   });
 
-  it("should return the original text if no transformation is needed", () => {
+  it("should return the original text if no transformation is needed", async () => {
     const text = "This Is A Test";
-    const { result } = renderHookWithJotai(() => useTextTransform());
+    const { result } = await renderHookWithJotai(() => useTextTransform());
     expect(result.current(text)).toBe(text);
   });
 
-  it("should handle empty string", () => {
+  it("should handle empty string", async () => {
     const input = "";
-    const { result } = renderHookWithJotai(() => useTextTransform());
+    const { result } = await renderHookWithJotai(() => useTextTransform());
     expect(result.current(input)).toBe(input);
   });
 
-  it("should handle strings with invalid characters", () => {
+  it("should handle strings with invalid characters", async () => {
     const input = "str\u{1F600}";
-    const { result } = renderHookWithJotai(() => useTextTransform());
+    const { result } = await renderHookWithJotai(() => useTextTransform());
     expect(result.current(input)).toBe(input);
   });
 
   // Boundary cases
-  it("should return original input if it's a URI not in schema.prefixes", () => {
+  it("should return original input if it's a URI not in schema.prefixes", async () => {
     const input = "http://www.some-uri.com/";
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useTextTransform(),
       initializeConfigWithPrefix,
     );
     expect(result.current(input)).toBe(input);
   });
 
-  it("should return original input if the connection.queryEngine is 'sparql' and input doesn't contain a URI", () => {
+  it("should return original input if the connection.queryEngine is 'sparql' and input doesn't contain a URI", async () => {
     const input = "Some Text Without URI";
 
-    const { result } = renderHookWithJotai(
+    const { result } = await renderHookWithJotai(
       () => useTextTransform(),
       initializeConfigWithPrefix,
     );
@@ -95,9 +95,9 @@ describe("useTextTransform", () => {
   });
 
   // Random data
-  it("should handle random data", () => {
+  it("should handle random data", async () => {
     const input = "str\u{1F600}abcdef";
-    const { result } = renderHookWithJotai(() => useTextTransform());
+    const { result } = await renderHookWithJotai(() => useTextTransform());
     expect(result.current(input)).toBe(input);
   });
 });
diff --git a/packages/graph-explorer/src/modules/AvailableConnections/AvailableConnections.test.tsx b/packages/graph-explorer/src/modules/AvailableConnections/AvailableConnections.test.tsx
index 2139f19f6..d01cbe938 100644
--- a/packages/graph-explorer/src/modules/AvailableConnections/AvailableConnections.test.tsx
+++ b/packages/graph-explorer/src/modules/AvailableConnections/AvailableConnections.test.tsx
@@ -16,7 +16,7 @@ vi.mock("@/modules/CreateConnection", () => ({
 describe("AvailableConnections", () => {
   test("renders empty state when there are no connections", () => {
     const store = getAppStore();
-    store.set(configurationAtom, new Map());
+    void store.set(configurationAtom, new Map());
     const queryClient = createQueryClient();
 
     render(
diff --git a/packages/graph-explorer/src/modules/AvailableConnections/ConnectionRow.tsx b/packages/graph-explorer/src/modules/AvailableConnections/ConnectionRow.tsx
index 2b9fa1909..25b285af7 100644
--- a/packages/graph-explorer/src/modules/AvailableConnections/ConnectionRow.tsx
+++ b/packages/graph-explorer/src/modules/AvailableConnections/ConnectionRow.tsx
@@ -10,7 +10,7 @@ import {
 } from "@/core";
 import useResetState from "@/core/StateProvider/useResetState";
 import { useTranslations } from "@/hooks";
-import { logger } from "@/utils";
+import { logAndNotify, logger } from "@/utils";
 
 function ConnectionRow({
   connection,
@@ -67,7 +67,9 @@ function useSetActiveConfigCallback(configId: ConfigurationId) {
     useCallback(
       (_get, set) => {
         logger.debug("Setting active connection to", configId);
-        set(activeConfigurationAtom, configId);
+        set(activeConfigurationAtom, configId).catch(
+          logAndNotify("Failed to switch the active connection."),
+        );
         resetState();
       },
       [configId, resetState],
diff --git a/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.test.tsx b/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.test.tsx
index 29acfc5c7..e61bbca93 100644
--- a/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.test.tsx
+++ b/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.test.tsx
@@ -43,7 +43,7 @@ function getImportedConnection() {
 describe("useImportConnectionFile", () => {
   test("should import valid configuration file", async () => {
     const state = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useImportConnectionFile(),
       state,
     );
@@ -93,7 +93,7 @@ describe("useImportConnectionFile", () => {
 
   test("should reject invalid configuration file", async () => {
     const state = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useImportConnectionFile(),
       state,
     );
@@ -121,7 +121,7 @@ describe("useImportConnectionFile", () => {
 
   test("should create new ID to avoid collisions", async () => {
     const state = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useImportConnectionFile(),
       state,
     );
@@ -157,7 +157,7 @@ describe("useImportConnectionFile", () => {
 
   test("should handle schema with prefixes", async () => {
     const state = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useImportConnectionFile(),
       state,
     );
@@ -203,7 +203,7 @@ describe("useImportConnectionFile", () => {
 
   test("should handle schema with lastUpdate date", async () => {
     const state = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useImportConnectionFile(),
       state,
     );
@@ -241,7 +241,7 @@ describe("useImportConnectionFile", () => {
 
   test("should handle empty schema arrays", async () => {
     const state = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useImportConnectionFile(),
       state,
     );
@@ -277,7 +277,7 @@ describe("useImportConnectionFile", () => {
 
   test("should handle file with complex schema", async () => {
     const state = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useImportConnectionFile(),
       state,
     );
@@ -344,7 +344,7 @@ describe("useImportConnectionFile", () => {
 
   test("should import edgeConnections from file", async () => {
     const state = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useImportConnectionFile(),
       state,
     );
@@ -419,7 +419,7 @@ describe("useImportConnectionFile", () => {
 describe("backward compatibility: legacy __matches in exported files", () => {
   test("should import file with legacy __matches array on prefixes", async () => {
     const state = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useImportConnectionFile(),
       state,
     );
@@ -506,7 +506,7 @@ describe("backward compatibility: legacy __matches in exported files", () => {
 describe("backward compatibility: legacy exported connection file with embedded schema", () => {
   test("splits the bundled schema into schemaAtom and keeps it out of the config entry", async () => {
     const state = new DbState();
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useImportConnectionFile(),
       state,
     );
diff --git a/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts b/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts
index 8c007ed66..695af9b48 100644
--- a/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts
+++ b/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts
@@ -9,6 +9,7 @@ import {
   schemaAtom,
 } from "@/core";
 import useResetState from "@/core/StateProvider/useResetState";
+import { logAndNotify } from "@/utils";
 import { fromFileToJson } from "@/utils/fileData";
 import { parseConnectionFile } from "@/utils/parseConnectionFile";
 
@@ -37,13 +38,15 @@ export function useImportConnectionFile() {
             connection: parsedFile.connection,
           });
           return updatedConfig;
-        });
+        }).catch(logAndNotify("Failed to import the connection."));
         set(schemaAtom, prevSchema => {
           const updatedSchema = new Map(prevSchema);
           updatedSchema.set(newId, parsedFile.schema);
           return updatedSchema;
-        });
-        set(activeConfigurationAtom, newId);
+        }).catch(logAndNotify("Failed to import the connection."));
+        set(activeConfigurationAtom, newId).catch(
+          logAndNotify("Failed to import the connection."),
+        );
 
         resetState();
       },
diff --git a/packages/graph-explorer/src/modules/CreateConnection/CreateConnection.tsx b/packages/graph-explorer/src/modules/CreateConnection/CreateConnection.tsx
index 637a0dc26..c512f450e 100644
--- a/packages/graph-explorer/src/modules/CreateConnection/CreateConnection.tsx
+++ b/packages/graph-explorer/src/modules/CreateConnection/CreateConnection.tsx
@@ -28,7 +28,7 @@ import {
   schemaAtom,
 } from "@/core";
 import useResetState from "@/core/StateProvider/useResetState";
-import { formatDate, logger } from "@/utils";
+import { formatDate, logAndNotify, logger } from "@/utils";
 import {
   DEFAULT_FETCH_TIMEOUT,
   DEFAULT_NODE_EXPAND_LIMIT,
@@ -121,8 +121,16 @@ const CreateConnection = ({
             const updatedConfig = new Map(prevConfigMap);
             updatedConfig.set(newConfigId, newConfig);
             return updatedConfig;
-          });
-          set(activeConfigurationAtom, newConfigId);
+          }).catch(
+            logAndNotify("Failed to save the connection.", {
+              description: "Your changes may be lost when you reload.",
+            }),
+          );
+          set(activeConfigurationAtom, newConfigId).catch(
+            logAndNotify("Failed to save the connection.", {
+              description: "Your changes may be lost when you reload.",
+            }),
+          );
           return;
         }
 
@@ -142,7 +150,11 @@ const CreateConnection = ({
           });
           updated.set(configId, updatedConfig);
           return updated;
-        });
+        }).catch(
+          logAndNotify("Failed to save the connection.", {
+            description: "Your changes may be lost when you reload.",
+          }),
+        );
 
         const urlChange = initialData?.url !== data.url;
         const dbUrlChange = initialData?.graphDbUrl !== data.graphDbUrl;
@@ -159,7 +171,7 @@ const CreateConnection = ({
             const updatedSchema = new Map(prevSchemaMap);
             updatedSchema.delete(configId);
             return updatedSchema;
-          });
+          }).catch(logAndNotify("Failed to clear the cached schema."));
 
           // Delete previous session data
           set(allGraphSessionsAtom, prev => {
@@ -167,7 +179,7 @@ const CreateConnection = ({
             logger.log("Deleting previous graph session");
             updatedGraphs.delete(configId);
             return updatedGraphs;
-          });
+          }).catch(logAndNotify("Failed to clear the previous graph session."));
 
           // Reseting all query state. Using `removeQueries()` to ensure initial data is recalculated.
           // This ensures dependent queries execute in the right order
diff --git a/packages/graph-explorer/src/modules/EdgesStyling/SingleEdgeStyling.tsx b/packages/graph-explorer/src/modules/EdgesStyling/SingleEdgeStyling.tsx
index 486b5f3b2..515acf8d8 100644
--- a/packages/graph-explorer/src/modules/EdgesStyling/SingleEdgeStyling.tsx
+++ b/packages/graph-explorer/src/modules/EdgesStyling/SingleEdgeStyling.tsx
@@ -4,7 +4,8 @@ import { Button, FormItem, InputField, Label, StylingIcon } from "@/components";
 import { type EdgeType, useDisplayEdgeTypeConfig } from "@/core";
 import { useEdgeStyling } from "@/core/StateProvider/userPreferences";
 import { useDebounceValue, usePrevious } from "@/hooks";
-import { LABELS } from "@/utils";
+import useTranslations from "@/hooks/useTranslations";
+import { LABELS, logAndNotify } from "@/utils";
 
 import { useOpenEdgeStyleDialog } from "./EdgeStyleDialog";
 
@@ -16,6 +17,7 @@ export default function SingleEdgeStyling({
   edgeType,
   ...rest
 }: SingleEdgeStylingProps) {
+  const t = useTranslations();
   const { setEdgeStyle } = useEdgeStyling(edgeType);
   const openEdgeStyleDialog = useOpenEdgeStyleDialog();
   const displayConfig = useDisplayEdgeTypeConfig(edgeType);
@@ -30,8 +32,12 @@ export default function SingleEdgeStyling({
     if (prevDisplayAs === null || prevDisplayAs === debouncedDisplayAs) {
       return;
     }
-    setEdgeStyle({ displayLabel: debouncedDisplayAs });
-  }, [debouncedDisplayAs, prevDisplayAs, setEdgeStyle]);
+    setEdgeStyle({ displayLabel: debouncedDisplayAs }).catch(
+      logAndNotify(`Failed to save the ${t("edge").toLowerCase()} style.`, {
+        description: "Your style change may be lost when you reload.",
+      }),
+    );
+  }, [debouncedDisplayAs, prevDisplayAs, setEdgeStyle, t]);
 
   return (
     <FormItem {...rest}>
diff --git a/packages/graph-explorer/src/modules/EntitiesFilter/useFiltersConfig.test.ts b/packages/graph-explorer/src/modules/EntitiesFilter/useFiltersConfig.test.ts
index 7b4da2276..740077331 100644
--- a/packages/graph-explorer/src/modules/EntitiesFilter/useFiltersConfig.test.ts
+++ b/packages/graph-explorer/src/modules/EntitiesFilter/useFiltersConfig.test.ts
@@ -17,11 +17,11 @@ describe("useFiltersConfig", () => {
   });
 
   /** Creates a config with the schema and makes it active, then renders the `useFiltersConfig` hook. */
-  function renderFilterConfigHook() {
-    return renderHookWithState(() => useFiltersConfig(), dbState);
+  async function renderFilterConfigHook() {
+    return await renderHookWithState(() => useFiltersConfig(), dbState);
   }
 
-  it("should have all entities selected", () => {
+  it("should have all entities selected", async () => {
     dbState.activeSchema.vertices = [
       { type: createVertexType("Person"), attributes: [] },
       { type: createVertexType("Movie"), attributes: [] },
@@ -29,7 +29,7 @@ describe("useFiltersConfig", () => {
     dbState.activeSchema.edges = [
       { type: createEdgeType("ACTED_IN"), attributes: [] },
     ];
-    const { result } = renderFilterConfigHook();
+    const { result } = await renderFilterConfigHook();
 
     expect(result.current.selectedVertexTypes).toEqual(
       new Set([createVertexType("Person"), createVertexType("Movie")]),
@@ -39,17 +39,17 @@ describe("useFiltersConfig", () => {
     );
   });
 
-  it("should have all vertices in checkboxes", () => {
+  it("should have all vertices in checkboxes", async () => {
     const expectedCheckboxIds = dbState.activeSchema.vertices.map(v => v.type);
 
-    const { result } = renderFilterConfigHook();
+    const { result } = await renderFilterConfigHook();
 
     expect(result.current.vertexTypes.map(vt => vt.id)).toEqual(
       expect.arrayContaining(expectedCheckboxIds),
     );
   });
 
-  it("should sort checkboxes alphabetically", () => {
+  it("should sort checkboxes alphabetically", async () => {
     dbState.activeSchema.vertices = [
       { type: createVertexType("Person"), attributes: [] },
       { type: createVertexType("Movie"), attributes: [] },
@@ -58,7 +58,7 @@ describe("useFiltersConfig", () => {
       { type: createEdgeType("DIRECTED"), attributes: [] },
       { type: createEdgeType("ACTED_IN"), attributes: [] },
     ];
-    const { result } = renderFilterConfigHook();
+    const { result } = await renderFilterConfigHook();
 
     expect(result.current.vertexTypes.map(vt => vt.text)).toEqual([
       "Movie",
@@ -70,20 +70,20 @@ describe("useFiltersConfig", () => {
     ]);
   });
 
-  it("should have all edges in checkboxes", () => {
+  it("should have all edges in checkboxes", async () => {
     const expectedCheckboxIds = dbState.activeSchema.edges.map(v => v.type);
 
-    const { result } = renderFilterConfigHook();
+    const { result } = await renderFilterConfigHook();
 
     expect(result.current.connectionTypes.map(vt => vt.id)).toEqual(
       expect.arrayContaining(expectedCheckboxIds),
     );
   });
 
-  it("should unselect vertex when toggled", () => {
+  it("should unselect vertex when toggled", async () => {
     const changingVertex = sample(dbState.activeSchema.vertices)!;
 
-    const { result } = renderFilterConfigHook();
+    const { result } = await renderFilterConfigHook();
 
     // Ensure vertex is selected initially
     expect(result.current.selectedVertexTypes.has(changingVertex.type)).toEqual(
@@ -99,10 +99,10 @@ describe("useFiltersConfig", () => {
     );
   });
 
-  it("should unselect edge when toggled", () => {
+  it("should unselect edge when toggled", async () => {
     const changingEdge = sample(dbState.activeSchema.edges)!;
 
-    const { result } = renderFilterConfigHook();
+    const { result } = await renderFilterConfigHook();
 
     // Ensure edge is selected initially
     expect(
diff --git a/packages/graph-explorer/src/modules/GraphViewer/internalComponents/ContextMenu.tsx b/packages/graph-explorer/src/modules/GraphViewer/internalComponents/ContextMenu.tsx
index c37d28246..59c1050c2 100644
--- a/packages/graph-explorer/src/modules/GraphViewer/internalComponents/ContextMenu.tsx
+++ b/packages/graph-explorer/src/modules/GraphViewer/internalComponents/ContextMenu.tsx
@@ -42,7 +42,7 @@ import {
 import { useDefaultNeighborExpansionLimit } from "@/hooks/useExpandNode";
 import { useOpenEdgeStyleDialog } from "@/modules/EdgesStyling";
 import { useOpenNodeStyleDialog } from "@/modules/NodesStyling";
-import { cn } from "@/utils";
+import { cn, logAndNotify } from "@/utils";
 
 import { useGraphSelection } from "../useGraphSelection";
 
@@ -111,7 +111,9 @@ function SingleVertexMenu({ vertexId }: { vertexId: VertexId }) {
     });
 
   const openSidebarPanel = (panelName: SidebarItems) => () => {
-    setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName }));
+    setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName })).catch(
+      logAndNotify("Failed to save your layout preferences."),
+    );
     replaceGraphSelection({ vertices: [vertexId], disableSideEffects: true });
   };
 
@@ -183,7 +185,9 @@ function SingleEdgeMenu({ edgeId }: { edgeId: EdgeId }) {
   const handleFit = () => onFitEdgeToCanvas(edgeId);
 
   const openSidebarPanel = (panelName: SidebarItems) => () => {
-    setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName }));
+    setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName })).catch(
+      logAndNotify("Failed to save your layout preferences."),
+    );
     replaceGraphSelection({ edges: [edgeId], disableSideEffects: true });
   };
 
diff --git a/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.test.ts b/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.test.ts
index 3d337e57f..fcf80c4e5 100644
--- a/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.test.ts
+++ b/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.test.ts
@@ -7,8 +7,8 @@ import { renderHookWithJotai } from "@/utils/testing";
 import { useAutoOpenDetailsSidebar } from "./useAutoOpenDetailsSidebar";
 
 describe("useAutoOpenDetailsSidebar", () => {
-  it("should auto-open details when detailsAutoOpenOnSelection is true", () => {
-    const { result } = renderHookWithJotai(
+  it("should auto-open details when detailsAutoOpenOnSelection is true", async () => {
+    const { result } = await renderHookWithJotai(
       () => {
         const autoOpen = useAutoOpenDetailsSidebar();
         const sidebar = useSidebar();
@@ -27,8 +27,8 @@ describe("useAutoOpenDetailsSidebar", () => {
     expect(result.current.sidebar.activeSidebarItem).toBe("details");
   });
 
-  it("should do nothing when detailsAutoOpenOnSelection is true and sidebar is already details", () => {
-    const { result } = renderHookWithJotai(
+  it("should do nothing when detailsAutoOpenOnSelection is true and sidebar is already details", async () => {
+    const { result } = await renderHookWithJotai(
       () => {
         const autoOpen = useAutoOpenDetailsSidebar();
         const sidebar = useSidebar();
@@ -48,8 +48,8 @@ describe("useAutoOpenDetailsSidebar", () => {
     expect(result.current.sidebar.isSidebarOpen).toBe(true);
   });
 
-  it("should not auto-open details when detailsAutoOpenOnSelection is false", () => {
-    const { result } = renderHookWithJotai(
+  it("should not auto-open details when detailsAutoOpenOnSelection is false", async () => {
+    const { result } = await renderHookWithJotai(
       () => {
         const autoOpen = useAutoOpenDetailsSidebar();
         const sidebar = useSidebar();
diff --git a/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts b/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
index fdd2f5337..e162f46c6 100644
--- a/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
+++ b/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
@@ -1,6 +1,7 @@
 import { useSetAtom } from "jotai";
 
 import { userLayoutAtom } from "@/core";
+import { logAndNotify } from "@/utils";
 
 export function useAutoOpenDetailsSidebar() {
   const setUserLayout = useSetAtom(userLayoutAtom);
@@ -14,6 +15,6 @@ export function useAutoOpenDetailsSidebar() {
         ...prev,
         activeSidebarItem: "details",
       };
-    });
+    }).catch(logAndNotify("Failed to save your layout preferences."));
   };
 }
diff --git a/packages/graph-explorer/src/modules/GraphViewer/useBackgroundImageMap.test.ts b/packages/graph-explorer/src/modules/GraphViewer/useBackgroundImageMap.test.ts
index c5f7c10dd..565b12c59 100644
--- a/packages/graph-explorer/src/modules/GraphViewer/useBackgroundImageMap.test.ts
+++ b/packages/graph-explorer/src/modules/GraphViewer/useBackgroundImageMap.test.ts
@@ -25,8 +25,8 @@ describe("useBackgroundImageMap", () => {
     mockRenderNode.mockResolvedValue("data:image/svg+xml;utf8,<svg></svg>");
   });
 
-  it("should return empty map when no vertex configs provided", () => {
-    const { result } = renderHookWithState(
+  it("should return empty map when no vertex configs provided", async () => {
+    const { result } = await renderHookWithState(
       () => useBackgroundImageMap([]),
       dbState,
     );
@@ -39,7 +39,7 @@ describe("useBackgroundImageMap", () => {
     const expectedImage = "data:image/svg+xml;utf8,<svg>person</svg>";
     mockRenderNode.mockResolvedValue(expectedImage);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useBackgroundImageMap([vertexConfig]),
       dbState,
     );
@@ -63,7 +63,7 @@ describe("useBackgroundImageMap", () => {
 
     mockRenderNode.mockResolvedValueOnce(image1).mockResolvedValueOnce(image2);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useBackgroundImageMap([config1, config2]),
       dbState,
     );
@@ -88,7 +88,7 @@ describe("useBackgroundImageMap", () => {
       .mockResolvedValueOnce(successImage)
       .mockResolvedValueOnce(null); // Failed render
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useBackgroundImageMap([config1, config2]),
       dbState,
     );
@@ -104,7 +104,7 @@ describe("useBackgroundImageMap", () => {
     const vertexConfig = createRandomVertexPreferences();
     mockRenderNode.mockResolvedValue(undefined);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useBackgroundImageMap([vertexConfig]),
       dbState,
     );
@@ -119,7 +119,7 @@ describe("useBackgroundImageMap", () => {
     const vertexConfig = createRandomVertexPreferences();
     mockRenderNode.mockRejectedValue(new Error("Render failed"));
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useBackgroundImageMap([vertexConfig]),
       dbState,
     );
@@ -140,7 +140,7 @@ describe("useBackgroundImageMap", () => {
     // Test initial render
     mockRenderNode.mockResolvedValueOnce(initialImage);
 
-    const { result: initialResult } = renderHookWithState(
+    const { result: initialResult } = await renderHookWithState(
       () => useBackgroundImageMap([initialConfig]),
       dbState,
     );
@@ -152,7 +152,7 @@ describe("useBackgroundImageMap", () => {
     // Test updated render with different config
     mockRenderNode.mockResolvedValueOnce(updatedImage);
 
-    const { result: updatedResult } = renderHookWithState(
+    const { result: updatedResult } = await renderHookWithState(
       () => useBackgroundImageMap([updatedConfig]),
       dbState,
     );
@@ -178,7 +178,7 @@ describe("useBackgroundImageMap", () => {
       .mockResolvedValueOnce(null) // Second fails
       .mockResolvedValueOnce(image3);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useBackgroundImageMap(configs),
       dbState,
     );
@@ -195,7 +195,10 @@ describe("useBackgroundImageMap", () => {
     const vertexConfig = createRandomVertexPreferences();
     mockRenderNode.mockResolvedValue("data:image/svg+xml;utf8,<svg></svg>");
 
-    renderHookWithState(() => useBackgroundImageMap([vertexConfig]), dbState);
+    await renderHookWithState(
+      () => useBackgroundImageMap([vertexConfig]),
+      dbState,
+    );
 
     await waitFor(() => {
       expect(mockRenderNode).toHaveBeenCalledWith(
@@ -220,7 +223,7 @@ describe("useBackgroundImageMap", () => {
       .mockResolvedValueOnce(svgImage)
       .mockResolvedValueOnce(pngImage);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useBackgroundImageMap([svgConfig, pngConfig]),
       dbState,
     );
@@ -244,7 +247,7 @@ describe("useBackgroundImageMap", () => {
       .mockResolvedValueOnce(successImage)
       .mockResolvedValueOnce(null); // No icon URL returns null
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useBackgroundImageMap([configWithIcon, configWithoutIcon]),
       dbState,
     );
diff --git a/packages/graph-explorer/src/modules/GraphViewer/useGraphSelection.test.ts b/packages/graph-explorer/src/modules/GraphViewer/useGraphSelection.test.ts
index fdd17bcf4..667ef4586 100644
--- a/packages/graph-explorer/src/modules/GraphViewer/useGraphSelection.test.ts
+++ b/packages/graph-explorer/src/modules/GraphViewer/useGraphSelection.test.ts
@@ -13,15 +13,15 @@ vi.mock("./useAutoOpenDetailsSidebar", () => ({
 }));
 
 describe("useGraphSelection", () => {
-  test("should return empty selection initially", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should return empty selection initially", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     expect(result.current.graphSelection.vertices).toStrictEqual([]);
     expect(result.current.graphSelection.edges).toStrictEqual([]);
   });
 
-  test("should update vertex selection", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should update vertex selection", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const vertexId1 = createRandomVertexId();
     const vertexId2 = createRandomVertexId();
@@ -40,8 +40,8 @@ describe("useGraphSelection", () => {
     expect(result.current.graphSelection.edges).toStrictEqual([]);
   });
 
-  test("should update edge selection", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should update edge selection", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const edgeId1 = createRandomEdgeId();
     const edgeId2 = createRandomEdgeId();
@@ -60,8 +60,8 @@ describe("useGraphSelection", () => {
     ]);
   });
 
-  test("should update both vertices and edges selection", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should update both vertices and edges selection", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const vertexId = createRandomVertexId();
     const edgeId = createRandomEdgeId();
@@ -78,8 +78,8 @@ describe("useGraphSelection", () => {
     expect(result.current.graphSelection.edges).toStrictEqual([edgeId]);
   });
 
-  test("should replace previous selection when updating", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should replace previous selection when updating", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const vertexId1 = createRandomVertexId();
     const vertexId2 = createRandomVertexId();
@@ -101,8 +101,8 @@ describe("useGraphSelection", () => {
     expect(result.current.graphSelection.vertices).toStrictEqual([vertexId2]);
   });
 
-  test("should clear selection when called with empty arrays", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should clear selection when called with empty arrays", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const vertexId = createRandomVertexId();
     const edgeId = createRandomEdgeId();
@@ -127,8 +127,8 @@ describe("useGraphSelection", () => {
     expect(result.current.graphSelection.edges).toStrictEqual([]);
   });
 
-  test("should handle Set as input for vertices", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should handle Set as input for vertices", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const vertexId1 = createRandomVertexId();
     const vertexId2 = createRandomVertexId();
@@ -147,8 +147,8 @@ describe("useGraphSelection", () => {
     ]);
   });
 
-  test("should handle Set as input for edges", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should handle Set as input for edges", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const edgeId1 = createRandomEdgeId();
     const edgeId2 = createRandomEdgeId();
@@ -167,8 +167,8 @@ describe("useGraphSelection", () => {
     ]);
   });
 
-  test("should call autoOpenDetails when selecting single vertex", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should call autoOpenDetails when selecting single vertex", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const vertexId = createRandomVertexId();
 
@@ -181,8 +181,8 @@ describe("useGraphSelection", () => {
     expect(mockAutoOpenDetails).toHaveBeenCalledTimes(1);
   });
 
-  test("should call autoOpenDetails when selecting single edge", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should call autoOpenDetails when selecting single edge", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const edgeId = createRandomEdgeId();
 
@@ -195,8 +195,8 @@ describe("useGraphSelection", () => {
     expect(mockAutoOpenDetails).toHaveBeenCalledTimes(1);
   });
 
-  test("should not call autoOpenDetails when selecting multiple entities", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should not call autoOpenDetails when selecting multiple entities", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const vertexId1 = createRandomVertexId();
     const vertexId2 = createRandomVertexId();
@@ -210,8 +210,8 @@ describe("useGraphSelection", () => {
     expect(mockAutoOpenDetails).not.toHaveBeenCalled();
   });
 
-  test("should not call autoOpenDetails when disableSideEffects is true", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should not call autoOpenDetails when disableSideEffects is true", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const vertexId = createRandomVertexId();
 
@@ -225,8 +225,8 @@ describe("useGraphSelection", () => {
     expect(mockAutoOpenDetails).not.toHaveBeenCalled();
   });
 
-  test("should not call autoOpenDetails when clearing selection", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("should not call autoOpenDetails when clearing selection", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     act(() =>
       result.current.replaceGraphSelection({
@@ -238,8 +238,8 @@ describe("useGraphSelection", () => {
     expect(mockAutoOpenDetails).not.toHaveBeenCalled();
   });
 
-  test("isVertexSelected should return true for selected vertex", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("isVertexSelected should return true for selected vertex", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const vertexId = createRandomVertexId();
 
@@ -253,8 +253,8 @@ describe("useGraphSelection", () => {
     expect(result.current.graphSelection.isVertexSelected(vertexId)).toBe(true);
   });
 
-  test("isVertexSelected should return false for unselected vertex", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("isVertexSelected should return false for unselected vertex", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const selectedVertexId = createRandomVertexId();
     const unselectedVertexId = createRandomVertexId();
@@ -271,8 +271,8 @@ describe("useGraphSelection", () => {
     ).toBe(false);
   });
 
-  test("isEdgeSelected should return true for selected edge", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("isEdgeSelected should return true for selected edge", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const edgeId = createRandomEdgeId();
 
@@ -286,8 +286,8 @@ describe("useGraphSelection", () => {
     expect(result.current.graphSelection.isEdgeSelected(edgeId)).toBe(true);
   });
 
-  test("isEdgeSelected should return false for unselected edge", () => {
-    const { result } = renderHookWithState(() => useGraphSelection());
+  test("isEdgeSelected should return false for unselected edge", async () => {
+    const { result } = await renderHookWithState(() => useGraphSelection());
 
     const selectedEdgeId = createRandomEdgeId();
     const unselectedEdgeId = createRandomEdgeId();
diff --git a/packages/graph-explorer/src/modules/GraphViewer/useGraphStyles.test.tsx b/packages/graph-explorer/src/modules/GraphViewer/useGraphStyles.test.tsx
index 15e72bc0b..013755c23 100644
--- a/packages/graph-explorer/src/modules/GraphViewer/useGraphStyles.test.tsx
+++ b/packages/graph-explorer/src/modules/GraphViewer/useGraphStyles.test.tsx
@@ -53,7 +53,10 @@ describe("useGraphStyles", () => {
     dbState.activeSchema.vertices = [vertexConfig];
     dbState.addVertexStyle(vertexConfig.type, vertexConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     await waitFor(() => {
       const vertexStyle = getStyles(result)[`node[type="Person"]`] as any;
@@ -72,7 +75,7 @@ describe("useGraphStyles", () => {
     });
   });
 
-  it("should generate edge styles correctly", () => {
+  it("should generate edge styles correctly", async () => {
     const edgeConfig = {
       ...createRandomEdgeTypeConfig(),
       type: createEdgeType("KNOWS"),
@@ -90,7 +93,10 @@ describe("useGraphStyles", () => {
     dbState.activeSchema.edges = [edgeConfig];
     dbState.addEdgeStyle(edgeConfig.type, edgeConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     const edgeStyle = getStyles(result)[`edge[type="KNOWS"]`] as any;
     expect(edgeStyle).toMatchObject({
@@ -113,7 +119,7 @@ describe("useGraphStyles", () => {
     });
   });
 
-  it("should set border-opacity to 1 when border width is non-zero", () => {
+  it("should set border-opacity to 1 when border width is non-zero", async () => {
     const vertexConfig = {
       ...createRandomVertexTypeConfig(),
       type: createVertexType("Person"),
@@ -122,13 +128,16 @@ describe("useGraphStyles", () => {
     dbState.activeSchema.vertices = [vertexConfig];
     dbState.addVertexStyle(vertexConfig.type, vertexConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     const vertexStyle = getStyles(result)[`node[type="Person"]`] as any;
     expect(vertexStyle["border-opacity"]).toBe(1);
   });
 
-  it("should set border-opacity to 0 when border width is zero", () => {
+  it("should set border-opacity to 0 when border width is zero", async () => {
     const vertexConfig = {
       ...createRandomVertexTypeConfig(),
       type: createVertexType("Person"),
@@ -137,14 +146,17 @@ describe("useGraphStyles", () => {
     dbState.activeSchema.vertices = [vertexConfig];
     dbState.addVertexStyle(vertexConfig.type, vertexConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     const vertexStyle = getStyles(result)[`node[type="Person"]`] as any;
     expect(vertexStyle["border-width"]).toBe(0);
     expect(vertexStyle["border-opacity"]).toBe(0);
   });
 
-  it("should handle edge config with dotted line style", () => {
+  it("should handle edge config with dotted line style", async () => {
     const edgeConfig = {
       ...createRandomEdgeTypeConfig(),
       type: createEdgeType("KNOWS"),
@@ -153,14 +165,17 @@ describe("useGraphStyles", () => {
     dbState.activeSchema.edges = [edgeConfig];
     dbState.addEdgeStyle(edgeConfig.type, edgeConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     const edgeStyle = getStyles(result)[`edge[type="KNOWS"]`] as any;
     expect(edgeStyle["line-style"]).toBe("dashed");
     expect(edgeStyle["line-dash-pattern"]).toEqual([1, 2]);
   });
 
-  it("should handle edge config with dashed line style", () => {
+  it("should handle edge config with dashed line style", async () => {
     const edgeConfig = {
       ...createRandomEdgeTypeConfig(),
       type: createEdgeType("KNOWS"),
@@ -169,14 +184,17 @@ describe("useGraphStyles", () => {
     dbState.activeSchema.edges = [edgeConfig];
     dbState.addEdgeStyle(edgeConfig.type, edgeConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     const edgeStyle = getStyles(result)[`edge[type="KNOWS"]`] as any;
     expect(edgeStyle["line-style"]).toBe("dashed");
     expect(edgeStyle["line-dash-pattern"]).toEqual([5, 6]);
   });
 
-  it("should use light text color for light label background", () => {
+  it("should use light text color for light label background", async () => {
     const edgeConfig = {
       ...createRandomEdgeTypeConfig(),
       type: createEdgeType("KNOWS"),
@@ -185,25 +203,31 @@ describe("useGraphStyles", () => {
     dbState.activeSchema.edges = [edgeConfig];
     dbState.addEdgeStyle(edgeConfig.type, edgeConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     const edgeStyle = getStyles(result)[`edge[type="KNOWS"]`] as any;
     expect(edgeStyle.color).toBe("#000000"); // Black text for light background
   });
 
-  it("should handle text transformation for edge labels", () => {
+  it("should handle text transformation for edge labels", async () => {
     const edgeConfig = createRandomEdgeTypeConfig();
     dbState.activeSchema.edges = [edgeConfig];
     dbState.addEdgeStyle(edgeConfig.type, edgeConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     // The hook should work with the text transform functionality
     // This test verifies the integration works properly
     expect(getStyles(result)[`edge[type="${edgeConfig.type}"]`]).toBeDefined();
   });
 
-  it("should truncate long edge labels", () => {
+  it("should truncate long edge labels", async () => {
     const longEdgeType = createEdgeType(
       "VERY_LONG_EDGE_TYPE_NAME_THAT_EXCEEDS_LIMIT",
     );
@@ -214,7 +238,10 @@ describe("useGraphStyles", () => {
     dbState.activeSchema.edges = [edgeConfig];
     dbState.addEdgeStyle(edgeConfig.type, edgeConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     // The label function should be defined, but we can't easily test the truncation
     // without mocking the text transform function more specifically
@@ -222,7 +249,7 @@ describe("useGraphStyles", () => {
     expect(edgeStyle.label).toBeDefined();
   });
 
-  it("should have label use the display name in the data", () => {
+  it("should have label use the display name in the data", async () => {
     const edgeConfig = {
       ...createRandomEdgeTypeConfig(),
       type: createEdgeType("KNOWS"),
@@ -230,13 +257,16 @@ describe("useGraphStyles", () => {
     dbState.activeSchema.edges = [edgeConfig];
     dbState.addEdgeStyle(edgeConfig.type, edgeConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     const edgeStyle = getStyles(result)[`edge[type="KNOWS"]`] as any;
     expect(edgeStyle.label).toEqual("data(displayName)");
   });
 
-  it("should handle renderNode failure gracefully", () => {
+  it("should handle renderNode failure gracefully", async () => {
     const vertexConfig = {
       ...createRandomVertexTypeConfig(),
       type: createVertexType("Person"),
@@ -246,13 +276,16 @@ describe("useGraphStyles", () => {
 
     mockRenderNode.mockResolvedValue(undefined);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     const vertexStyle = getStyles(result)[`node[type="Person"]`] as any;
     expect(vertexStyle["background-image"]).toBeUndefined();
   });
 
-  it("should handle multiple vertex and edge types", () => {
+  it("should handle multiple vertex and edge types", async () => {
     const personConfig = {
       ...createRandomVertexTypeConfig(),
       type: createVertexType("Person"),
@@ -277,7 +310,10 @@ describe("useGraphStyles", () => {
     dbState.addEdgeStyle(knowsConfig.type, knowsConfig);
     dbState.addEdgeStyle(worksAtConfig.type, worksAtConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     expect(
       (getStyles(result)[`node[type="Company"]`] as any)["background-color"],
@@ -287,7 +323,7 @@ describe("useGraphStyles", () => {
     ).toBe("#00ff00");
   });
 
-  it("should update styles when configs change", () => {
+  it("should update styles when configs change", async () => {
     const vertexConfig = {
       ...createRandomVertexTypeConfig(),
       type: createVertexType("Person"),
@@ -301,7 +337,7 @@ describe("useGraphStyles", () => {
     updatedDbState.addVertexStyle(vertexConfig.type, vertexConfig);
     dbState.addEdgeStyle(edgeConfig.type, edgeConfig);
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useGraphStyles(),
       updatedDbState,
     );
@@ -311,7 +347,7 @@ describe("useGraphStyles", () => {
     ).toBe("#ff0000");
   });
 
-  it("should handle edge config with undefined optional properties", () => {
+  it("should handle edge config with undefined optional properties", async () => {
     const minimalEdgeConfig = {
       ...createRandomEdgeTypeConfig(),
       type: createEdgeType("MINIMAL"),
@@ -324,7 +360,10 @@ describe("useGraphStyles", () => {
     dbState.activeSchema.edges = [minimalEdgeConfig];
     dbState.addEdgeStyle(minimalEdgeConfig.type, minimalEdgeConfig);
 
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     const edgeStyle = getStyles(result)[`edge[type="MINIMAL"]`] as any;
     expect(edgeStyle["text-background-opacity"]).toBeUndefined();
@@ -332,7 +371,7 @@ describe("useGraphStyles", () => {
     expect(edgeStyle["text-border-width"]).toBeUndefined();
   });
 
-  it("should use deferred values for performance", () => {
+  it("should use deferred values for performance", async () => {
     const vertexConfig = createRandomVertexTypeConfig();
     const edgeConfig = createRandomEdgeTypeConfig();
 
@@ -344,7 +383,10 @@ describe("useGraphStyles", () => {
     // This test ensures that the hook uses useDeferredValue for configs
     // The actual deferring behavior is handled by React, so we just verify
     // that the hook works with the provided configs
-    const { result } = renderHookWithState(() => useGraphStyles(), dbState);
+    const { result } = await renderHookWithState(
+      () => useGraphStyles(),
+      dbState,
+    );
 
     // Verify that the hook successfully processes the configurations
     expect(
diff --git a/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx b/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx
index 0a4495902..9b218e420 100644
--- a/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx
+++ b/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx
@@ -36,6 +36,7 @@ import {
   useConfiguration,
 } from "@/core";
 import { usePrefixes } from "@/core/StateProvider/schema";
+import { logAndNotify } from "@/utils";
 
 type PrefixForm = {
   prefix: string;
@@ -185,7 +186,7 @@ function useDeletePrefixCallback(prefix: string) {
           });
 
           return updatedSchemas;
-        });
+        }).catch(logAndNotify("Failed to delete the namespace prefix."));
       },
       [prefix],
     ),
@@ -237,7 +238,7 @@ function EditPrefixModal({
           });
 
           return updatedSchemas;
-        });
+        }).catch(logAndNotify("Failed to save the namespace prefix."));
       },
       [configId],
     ),
diff --git a/packages/graph-explorer/src/modules/NodesStyling/NodeStyleDialog.tsx b/packages/graph-explorer/src/modules/NodesStyling/NodeStyleDialog.tsx
index 78073c414..555f8510a 100644
--- a/packages/graph-explorer/src/modules/NodesStyling/NodeStyleDialog.tsx
+++ b/packages/graph-explorer/src/modules/NodesStyling/NodeStyleDialog.tsx
@@ -36,7 +36,7 @@ import {
   useVertexStyling,
 } from "@/core/StateProvider/userPreferences";
 import useTranslations from "@/hooks/useTranslations";
-import { parseNumberSafely } from "@/utils";
+import { logAndNotify, parseNumberSafely } from "@/utils";
 import {
   RESERVED_ID_PROPERTY,
   RESERVED_TYPES_PROPERTY,
@@ -119,7 +119,11 @@ function Content({ vertexType }: { vertexType: VertexType }) {
     }
     try {
       const result = await file2Base64(file);
-      setVertexStyle({ iconUrl: result, iconImageType: file.type });
+      setVertexStyle({ iconUrl: result, iconImageType: file.type }).catch(
+        logAndNotify(`Failed to save the ${t("node").toLowerCase()} style.`, {
+          description: "Your style change may be lost when you reload.",
+        }),
+      );
     } catch (error) {
       console.error("Unable to convert uploaded image to base64: ", error);
       toast.error("Invalid file", {
@@ -219,7 +223,7 @@ function Content({ vertexType }: { vertexType: VertexType }) {
                       accept="image/*"
                       onChange={file => {
                         if (file) {
-                          convertImageToBase64AndSetNewIcon(file);
+                          void convertImageToBase64AndSetNewIcon(file);
                         }
                       }}
                       variant="outline"
diff --git a/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx b/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
index a84c9eb44..6e04ccd50 100644
--- a/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
+++ b/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
@@ -4,6 +4,8 @@ import { Button, FormItem, InputField, Label, StylingIcon } from "@/components";
 import { useDisplayVertexTypeConfig, type VertexType } from "@/core";
 import { useVertexStyling } from "@/core/StateProvider/userPreferences";
 import { useDebounceValue, usePrevious } from "@/hooks";
+import useTranslations from "@/hooks/useTranslations";
+import { logAndNotify } from "@/utils";
 import { LABELS } from "@/utils/constants";
 
 import { useOpenNodeStyleDialog } from "./NodeStyleDialog";
@@ -16,6 +18,7 @@ export default function SingleNodeStyling({
   vertexType,
   ...rest
 }: SingleNodeStylingProps) {
+  const t = useTranslations();
   const { setVertexStyle } = useVertexStyling(vertexType);
   const displayConfig = useDisplayVertexTypeConfig(vertexType);
 
@@ -31,8 +34,12 @@ export default function SingleNodeStyling({
     if (prevDisplayAs === null || prevDisplayAs === debouncedDisplayAs) {
       return;
     }
-    setVertexStyle({ displayLabel: debouncedDisplayAs });
-  }, [debouncedDisplayAs, prevDisplayAs, setVertexStyle]);
+    setVertexStyle({ displayLabel: debouncedDisplayAs }).catch(
+      logAndNotify(`Failed to save the ${t("node").toLowerCase()} style.`, {
+        description: "Your style change may be lost when you reload.",
+      }),
+    );
+  }, [debouncedDisplayAs, prevDisplayAs, setVertexStyle, t]);
 
   return (
     <FormItem {...rest}>
diff --git a/packages/graph-explorer/src/modules/SchemaGraph/SchemaGraphToolbar.tsx b/packages/graph-explorer/src/modules/SchemaGraph/SchemaGraphToolbar.tsx
index 1725dd32a..21249261a 100644
--- a/packages/graph-explorer/src/modules/SchemaGraph/SchemaGraphToolbar.tsx
+++ b/packages/graph-explorer/src/modules/SchemaGraph/SchemaGraphToolbar.tsx
@@ -56,7 +56,7 @@ function SchemaRefreshButton() {
 
   const handleRefresh = () => {
     logger.log("Schema graph: refresh schema requested");
-    refreshSchema();
+    void refreshSchema();
   };
 
   return (
diff --git a/packages/graph-explorer/src/modules/SchemaGraph/Sidebar/SchemaExplorerSidebar.test.tsx b/packages/graph-explorer/src/modules/SchemaGraph/Sidebar/SchemaExplorerSidebar.test.tsx
index 2dac05b7e..948232a3a 100644
--- a/packages/graph-explorer/src/modules/SchemaGraph/Sidebar/SchemaExplorerSidebar.test.tsx
+++ b/packages/graph-explorer/src/modules/SchemaGraph/Sidebar/SchemaExplorerSidebar.test.tsx
@@ -25,9 +25,9 @@ vi.mock("react-virtuoso", () => ({
   }) => data?.map((item, index) => itemContent(index, item)),
 }));
 
-function renderSidebar(state: DbState) {
+async function renderSidebar(state: DbState) {
   const store = getAppStore();
-  state.applyTo(store);
+  await state.applyTo(store);
 
   const queryClient = new QueryClient({
     defaultOptions: { queries: { retry: false } },
@@ -45,16 +45,16 @@ function renderSidebar(state: DbState) {
 }
 
 describe("SchemaExplorerSidebar", () => {
-  test("renders details tab by default with empty selection message", () => {
+  test("renders details tab by default with empty selection message", async () => {
     const state = new DbState();
-    renderSidebar(state);
+    await renderSidebar(state);
 
     expect(screen.getByText("Empty Selection")).toBeInTheDocument();
   });
 
-  test("shows three sidebar tabs", () => {
+  test("shows three sidebar tabs", async () => {
     const state = new DbState();
-    renderSidebar(state);
+    await renderSidebar(state);
 
     const tabs = screen.getAllByRole("tab");
     expect(tabs).toHaveLength(3);
@@ -66,7 +66,7 @@ describe("SchemaExplorerSidebar", () => {
     const vertex = createTestableVertex().with({ types: ["Airport"] });
     state.addTestableVertexToGraph(vertex);
 
-    renderSidebar(state);
+    await renderSidebar(state);
 
     const tabs = screen.getAllByRole("tab");
     await user.click(tabs[1]);
@@ -85,7 +85,7 @@ describe("SchemaExplorerSidebar", () => {
       .withTarget(target);
     state.addTestableEdgeToGraph(edge);
 
-    renderSidebar(state);
+    await renderSidebar(state);
 
     const tabs = screen.getAllByRole("tab");
     await user.click(tabs[2]);
diff --git a/packages/graph-explorer/src/modules/SearchSidebar/QuerySearchTabContent.tsx b/packages/graph-explorer/src/modules/SearchSidebar/QuerySearchTabContent.tsx
index cf8666e03..b6564d23b 100644
--- a/packages/graph-explorer/src/modules/SearchSidebar/QuerySearchTabContent.tsx
+++ b/packages/graph-explorer/src/modules/SearchSidebar/QuerySearchTabContent.tsx
@@ -81,7 +81,7 @@ export function QuerySearchTabContent() {
     if (form.formState.isSubmitting) {
       return;
     }
-    form.handleSubmit(onSubmit)();
+    void form.handleSubmit(onSubmit)();
   };
 
   return (
diff --git a/packages/graph-explorer/src/modules/SearchSidebar/useEdgeAttributesAsScalars.test.ts b/packages/graph-explorer/src/modules/SearchSidebar/useEdgeAttributesAsScalars.test.ts
index acddc5233..0ceb53a6b 100644
--- a/packages/graph-explorer/src/modules/SearchSidebar/useEdgeAttributesAsScalars.test.ts
+++ b/packages/graph-explorer/src/modules/SearchSidebar/useEdgeAttributesAsScalars.test.ts
@@ -50,8 +50,8 @@ describe("useEdgeAttributesAsScalars", () => {
       dbState.activeConfig.connection!.queryEngine = "gremlin";
     });
 
-    it("should return ID, Edge Label, and attributes for edge with unique ID", () => {
-      const { result } = renderHookWithState(
+    it("should return ID, Edge Label, and attributes for edge with unique ID", async () => {
+      const { result } = await renderHookWithState(
         () => useEdgeAttributesAsScalars(edge),
         dbState,
       );
@@ -88,13 +88,13 @@ describe("useEdgeAttributesAsScalars", () => {
       );
     });
 
-    it("should not include ID for edge without unique ID", () => {
+    it("should not include ID for edge without unique ID", async () => {
       const edgeWithoutId = {
         ...edge,
         hasUniqueId: false,
       };
 
-      const { result } = renderHookWithState(
+      const { result } = await renderHookWithState(
         () => useEdgeAttributesAsScalars(edgeWithoutId),
         dbState,
       );
@@ -116,8 +116,8 @@ describe("useEdgeAttributesAsScalars", () => {
       dbState.activeConfig.connection!.queryEngine = "openCypher";
     });
 
-    it("should return ID, Relationship Type, and attributes for edge with unique ID", () => {
-      const { result } = renderHookWithState(
+    it("should return ID, Relationship Type, and attributes for edge with unique ID", async () => {
+      const { result } = await renderHookWithState(
         () => useEdgeAttributesAsScalars(edge),
         dbState,
       );
@@ -154,13 +154,13 @@ describe("useEdgeAttributesAsScalars", () => {
       );
     });
 
-    it("should not include ID for edge without unique ID", () => {
+    it("should not include ID for edge without unique ID", async () => {
       const edgeWithoutId = {
         ...edge,
         hasUniqueId: false,
       };
 
-      const { result } = renderHookWithState(
+      const { result } = await renderHookWithState(
         () => useEdgeAttributesAsScalars(edgeWithoutId),
         dbState,
       );
@@ -181,8 +181,8 @@ describe("useEdgeAttributesAsScalars", () => {
     beforeEach(() => {
       dbState.activeConfig.connection!.queryEngine = "sparql";
     });
-    it("should return ID, Predicate and attributes for edge with unique ID", () => {
-      const { result } = renderHookWithState(
+    it("should return ID, Predicate and attributes for edge with unique ID", async () => {
+      const { result } = await renderHookWithState(
         () => useEdgeAttributesAsScalars(edge),
         dbState,
       );
@@ -219,13 +219,13 @@ describe("useEdgeAttributesAsScalars", () => {
       );
     });
 
-    it("should not include ID when hasUniqueId is false", () => {
+    it("should not include ID when hasUniqueId is false", async () => {
       const edgeWithoutId = {
         ...edge,
         hasUniqueId: false,
       };
 
-      const { result } = renderHookWithState(
+      const { result } = await renderHookWithState(
         () => useEdgeAttributesAsScalars(edgeWithoutId),
         dbState,
       );
@@ -236,13 +236,13 @@ describe("useEdgeAttributesAsScalars", () => {
     });
   });
 
-  it("should handle edge with no attributes", () => {
+  it("should handle edge with no attributes", async () => {
     const edgeWithNoAttributes = {
       ...edge,
       attributes: [],
     };
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useEdgeAttributesAsScalars(edgeWithNoAttributes),
       dbState,
     );
diff --git a/packages/graph-explorer/src/modules/SearchSidebar/useKeywordSearch.test.ts b/packages/graph-explorer/src/modules/SearchSidebar/useKeywordSearch.test.ts
index a09964963..d477d4db4 100644
--- a/packages/graph-explorer/src/modules/SearchSidebar/useKeywordSearch.test.ts
+++ b/packages/graph-explorer/src/modules/SearchSidebar/useKeywordSearch.test.ts
@@ -26,22 +26,22 @@ vi.mock("./useKeywordSearchQuery", () => ({
 }));
 
 function initializeConfigWithQueryEngine(queryEngine: QueryEngine) {
-  return (store: AppStore) => {
+  return async (store: AppStore) => {
     // Create config and setup schema
     const config = createRandomRawConfiguration();
     config.connection!.queryEngine = queryEngine;
 
-    store.set(configurationAtom, new Map([[config.id, config]]));
+    await store.set(configurationAtom, new Map([[config.id, config]]));
 
     // Make config active
-    store.set(activeConfigurationAtom, config.id);
+    await store.set(activeConfigurationAtom, config.id);
   };
 }
 
 describe("useKeywordSearch", () => {
   describe("Gremlin", () => {
-    it("Should default to precision match exact", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to precision match exact", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("gremlin"),
       );
@@ -49,8 +49,8 @@ describe("useKeywordSearch", () => {
       expect(result.current.partialMatch).toBe(false);
     });
 
-    it("Should default to attribute ID", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to attribute ID", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("gremlin"),
       );
@@ -58,8 +58,8 @@ describe("useKeywordSearch", () => {
       expect(result.current.selectedAttribute).toBe(SEARCH_TOKENS.NODE_ID);
     });
 
-    it("Should default to node type All", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to node type All", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("gremlin"),
       );
@@ -69,8 +69,8 @@ describe("useKeywordSearch", () => {
       );
     });
 
-    it("Should have all searchable attributes", () => {
-      const { result } = renderHookWithJotai(
+    it("Should have all searchable attributes", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("gremlin"),
       );
@@ -83,8 +83,8 @@ describe("useKeywordSearch", () => {
   });
 
   describe("OpenCypher", () => {
-    it("Should default to precision match exact", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to precision match exact", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("openCypher"),
       );
@@ -92,8 +92,8 @@ describe("useKeywordSearch", () => {
       expect(result.current.partialMatch).toBe(false);
     });
 
-    it("Should default to attribute ID", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to attribute ID", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("openCypher"),
       );
@@ -101,8 +101,8 @@ describe("useKeywordSearch", () => {
       expect(result.current.selectedAttribute).toBe(SEARCH_TOKENS.NODE_ID);
     });
 
-    it("Should default to node type All", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to node type All", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("openCypher"),
       );
@@ -112,8 +112,8 @@ describe("useKeywordSearch", () => {
       );
     });
 
-    it("Should have all searchable attributes", () => {
-      const { result } = renderHookWithJotai(
+    it("Should have all searchable attributes", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("openCypher"),
       );
@@ -126,7 +126,7 @@ describe("useKeywordSearch", () => {
   });
 
   describe("SPARQL", () => {
-    function initializeConfigWithRdfLabel(store: AppStore) {
+    async function initializeConfigWithRdfLabel(store: AppStore) {
       // Create config and setup schema
       const config = createRandomRawConfiguration();
       const schema = createRandomSchema();
@@ -136,15 +136,15 @@ describe("useKeywordSearch", () => {
         dataType: "String",
       });
 
-      store.set(configurationAtom, new Map([[config.id, config]]));
-      store.set(schemaAtom, new Map([[config.id, schema]]));
+      await store.set(configurationAtom, new Map([[config.id, config]]));
+      await store.set(schemaAtom, new Map([[config.id, schema]]));
 
       // Make config active
-      store.set(activeConfigurationAtom, config.id);
+      await store.set(activeConfigurationAtom, config.id);
     }
 
-    it("Should default to precision match exact", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to precision match exact", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithRdfLabel,
       );
@@ -152,8 +152,8 @@ describe("useKeywordSearch", () => {
       expect(result.current.partialMatch).toBe(false);
     });
 
-    it("Should default to attribute rdfs:label", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to attribute rdfs:label", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithRdfLabel,
       );
@@ -161,8 +161,8 @@ describe("useKeywordSearch", () => {
       expect(result.current.selectedAttribute).toBe("rdfs:label");
     });
 
-    it("Should default to node type All", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to node type All", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithRdfLabel,
       );
@@ -172,8 +172,8 @@ describe("useKeywordSearch", () => {
       );
     });
 
-    it("Should have all searchable attributes", () => {
-      const { result } = renderHookWithJotai(
+    it("Should have all searchable attributes", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithRdfLabel,
       );
@@ -189,8 +189,8 @@ describe("useKeywordSearch", () => {
   });
 
   describe("SPARQL without rdfs:label", () => {
-    it("Should default to precision match exact", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to precision match exact", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("sparql"),
       );
@@ -198,8 +198,8 @@ describe("useKeywordSearch", () => {
       expect(result.current.partialMatch).toBe(false);
     });
 
-    it("Should default to attribute All", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to attribute All", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("sparql"),
       );
@@ -209,8 +209,8 @@ describe("useKeywordSearch", () => {
       );
     });
 
-    it("Should default to node type All", () => {
-      const { result } = renderHookWithJotai(
+    it("Should default to node type All", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("sparql"),
       );
@@ -220,8 +220,8 @@ describe("useKeywordSearch", () => {
       );
     });
 
-    it("Should have all searchable attributes", () => {
-      const { result } = renderHookWithJotai(
+    it("Should have all searchable attributes", async () => {
+      const { result } = await renderHookWithJotai(
         () => useKeywordSearch(),
         initializeConfigWithQueryEngine("sparql"),
       );
diff --git a/packages/graph-explorer/src/modules/SearchSidebar/useVertexAttributesAsScalars.test.ts b/packages/graph-explorer/src/modules/SearchSidebar/useVertexAttributesAsScalars.test.ts
index bfc180923..592fc01d0 100644
--- a/packages/graph-explorer/src/modules/SearchSidebar/useVertexAttributesAsScalars.test.ts
+++ b/packages/graph-explorer/src/modules/SearchSidebar/useVertexAttributesAsScalars.test.ts
@@ -55,8 +55,8 @@ describe("useVertexAttributesAsScalars", () => {
         createRandomQueryEngine("pg");
     });
 
-    it("should return ID, Label, and attributes for vertex", () => {
-      const { result } = renderHookWithState(
+    it("should return ID, Label, and attributes for vertex", async () => {
+      const { result } = await renderHookWithState(
         () => useVertexAttributesAsScalars(vertex),
         dbState,
       );
@@ -99,8 +99,8 @@ describe("useVertexAttributesAsScalars", () => {
       dbState.activeConfig.connection!.queryEngine = "sparql";
     });
 
-    it("should return URI, Class, and attributes for vertex", () => {
-      const { result } = renderHookWithState(
+    it("should return URI, Class, and attributes for vertex", async () => {
+      const { result } = await renderHookWithState(
         () => useVertexAttributesAsScalars(vertex),
         dbState,
       );
@@ -123,7 +123,7 @@ describe("useVertexAttributesAsScalars", () => {
       );
     });
 
-    it("should use 'Blank node ID' for blank nodes", () => {
+    it("should use 'Blank node ID' for blank nodes", async () => {
       const blankNodeVertex = {
         ...vertex,
         isBlankNode: true,
@@ -132,7 +132,7 @@ describe("useVertexAttributesAsScalars", () => {
         } as any,
       };
 
-      const { result } = renderHookWithState(
+      const { result } = await renderHookWithState(
         () => useVertexAttributesAsScalars(blankNodeVertex),
         dbState,
       );
@@ -147,7 +147,7 @@ describe("useVertexAttributesAsScalars", () => {
     });
   });
 
-  it("should handle vertex with no attributes", () => {
+  it("should handle vertex with no attributes", async () => {
     const vertexWithNoAttributes = {
       ...vertex,
       attributes: [],
@@ -156,7 +156,7 @@ describe("useVertexAttributesAsScalars", () => {
       } as any,
     };
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexAttributesAsScalars(vertexWithNoAttributes),
       dbState,
     );
@@ -165,7 +165,7 @@ describe("useVertexAttributesAsScalars", () => {
     expect(scalars).toHaveLength(2); // Only ID and Label
   });
 
-  it("should handle empty displayTypes", () => {
+  it("should handle empty displayTypes", async () => {
     dbState.activeConfig.connection!.queryEngine = "openCypher";
 
     const vertexWithEmptyTypes: DisplayVertex = {
@@ -182,7 +182,7 @@ describe("useVertexAttributesAsScalars", () => {
       original: { types: [] } as any,
     };
 
-    const { result } = renderHookWithState(
+    const { result } = await renderHookWithState(
       () => useVertexAttributesAsScalars(vertexWithEmptyTypes),
       dbState,
     );
diff --git a/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.test.tsx b/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.test.tsx
index 206aa91b6..c6289aa0b 100644
--- a/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.test.tsx
+++ b/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.test.tsx
@@ -22,9 +22,9 @@ function LocationDisplay() {
   return <div data-testid="location">{location.pathname}</div>;
 }
 
-function renderDataExplorer(initialPath: string, state: DbState) {
+async function renderDataExplorer(initialPath: string, state: DbState) {
   const store = getAppStore();
-  state.applyTo(store);
+  await state.applyTo(store);
 
   const queryClient = new QueryClient({
     defaultOptions: { queries: { retry: false } },
@@ -56,7 +56,7 @@ describe("DataExplorer", () => {
     const vertex = createTestableVertex().with({ types: ["Person"] });
     state.addTestableVertexToGraph(vertex);
 
-    renderDataExplorer("/data-explorer", state);
+    await renderDataExplorer("/data-explorer", state);
 
     await waitFor(() => {
       expect(screen.getByTestId("location")).toHaveTextContent(
@@ -65,10 +65,10 @@ describe("DataExplorer", () => {
     });
   });
 
-  test("renders empty state when no vertexType param and no vertex types", () => {
+  test("renders empty state when no vertexType param and no vertex types", async () => {
     const state = new DbState().withNoActiveSchema();
 
-    renderDataExplorer("/data-explorer", state);
+    await renderDataExplorer("/data-explorer", state);
 
     // Should not redirect — stays at /data-explorer
     expect(screen.getByTestId("location")).toHaveTextContent("/data-explorer");
@@ -76,20 +76,20 @@ describe("DataExplorer", () => {
     expect(screen.getByText(/no .* available/i)).toBeInTheDocument();
   });
 
-  test("shows empty state when vertexType param exists but no vertex types in schema", () => {
+  test("shows empty state when vertexType param exists but no vertex types in schema", async () => {
     const state = new DbState().withNoActiveSchema();
 
-    renderDataExplorer("/data-explorer/Person", state);
+    await renderDataExplorer("/data-explorer/Person", state);
 
     expect(screen.getByText(/no .* available/i)).toBeInTheDocument();
   });
 
-  test("renders content when vertexType param and vertex types exist", () => {
+  test("renders content when vertexType param and vertex types exist", async () => {
     const state = new DbState();
     const vertex = createTestableVertex().with({ types: ["Airport"] });
     state.addTestableVertexToGraph(vertex);
 
-    renderDataExplorer("/data-explorer/Airport", state);
+    await renderDataExplorer("/data-explorer/Airport", state);
 
     // Should stay on the same route
     expect(screen.getByTestId("location")).toHaveTextContent(
@@ -106,7 +106,7 @@ describe("DataExplorer", () => {
     });
     state.addTestableVertexToGraph(vertex);
 
-    renderDataExplorer("/data-explorer", state);
+    await renderDataExplorer("/data-explorer", state);
 
     await waitFor(() => {
       expect(screen.getByTestId("location")).toHaveTextContent(
diff --git a/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx b/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx
index 43ed056f9..dacc1582f 100644
--- a/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx
+++ b/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx
@@ -56,6 +56,7 @@ import { useVertexTypeConfig } from "@/core/ConfigurationProvider/useConfigurati
 import { useVertexStyling } from "@/core/StateProvider/userPreferences";
 import { useAddVertexToGraph, useHasVertexBeenAddedToGraph } from "@/hooks";
 import useTranslations from "@/hooks/useTranslations";
+import { logAndNotify } from "@/utils";
 import {
   LABELS,
   RESERVED_ID_PROPERTY,
@@ -73,7 +74,7 @@ export default function DataExplorer() {
   const vtConfigs = useDisplayVertexTypeConfigs().values().toArray();
 
   if (!vertexType && vtConfigs.length > 0) {
-    navigate(`/data-explorer/${encodeURIComponent(vtConfigs[0].type)}`, {
+    void navigate(`/data-explorer/${encodeURIComponent(vtConfigs[0].type)}`, {
       replace: true,
     });
   }
@@ -132,7 +133,7 @@ function DataExplorerContent({ vertexType }: { vertexType: VertexType }) {
 
   const onVertexTypeChange = (value: string | string[]) => {
     const newType = Array.isArray(value) ? value[0] : value;
-    navigate(`/data-explorer/${encodeURIComponent(newType)}`, {
+    void navigate(`/data-explorer/${encodeURIComponent(newType)}`, {
       replace: true,
     });
   };
@@ -256,11 +257,19 @@ function DisplayNameAndDescriptionOptions({
   const onDisplayNameChange =
     (field: "name" | "longName") => (value: string | string[]) => {
       if (field === "name") {
-        setPreferences({ displayNameAttribute: value as string });
+        setPreferences({ displayNameAttribute: value as string }).catch(
+          logAndNotify(
+            `Failed to save the ${t("node").toLowerCase()} display settings.`,
+          ),
+        );
       }
 
       if (field === "longName") {
-        setPreferences({ longDisplayNameAttribute: value as string });
+        setPreferences({ longDisplayNameAttribute: value as string }).catch(
+          logAndNotify(
+            `Failed to save the ${t("node").toLowerCase()} display settings.`,
+          ),
+        );
       }
     };
 
diff --git a/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx b/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx
index 451011b7a..925dd98fb 100644
--- a/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx
+++ b/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx
@@ -25,6 +25,7 @@ import {
   showDebugActionsAtom,
 } from "@/core";
 import { saveLocalForageToFile } from "@/core/StateProvider/localDb";
+import { logAndNotify } from "@/utils";
 
 import LoadConfigButton from "./LoadConfigButton";
 
@@ -59,7 +60,9 @@ export default function SettingsGeneral() {
           value="defaultNeighborExpansionLimitEnabled"
           checked={defaultNeighborExpansionLimitEnabled}
           onCheckedChange={isSelected => {
-            setDefaultNeighborExpansionLimitEnabled(Boolean(isSelected));
+            setDefaultNeighborExpansionLimitEnabled(Boolean(isSelected)).catch(
+              logAndNotify("Failed to save the setting."),
+            );
           }}
         />
         <AnimatePresence initial={false}>
@@ -116,7 +119,9 @@ export default function SettingsGeneral() {
           value="isDiagnosticLoggingEnabled"
           checked={diagnosticLogging}
           onCheckedChange={isSelected => {
-            setDiagnosticLogging(Boolean(isSelected));
+            setDiagnosticLogging(Boolean(isSelected)).catch(
+              logAndNotify("Failed to save the setting."),
+            );
           }}
           label="Diagnostic logging"
           description="Enables verbose logging to the browser console for troubleshooting."
@@ -127,7 +132,9 @@ export default function SettingsGeneral() {
           value="isLoggingDbQueryEnabled"
           checked={allowLoggingDbQuery}
           onCheckedChange={isSelected => {
-            setAllowLoggingDbQuery(Boolean(isSelected));
+            setAllowLoggingDbQuery(Boolean(isSelected)).catch(
+              logAndNotify("Failed to save the setting."),
+            );
           }}
           label="Enable database query logging on proxy server"
           description="Logs the generated database queries to the servers logger. If you have encountered an issue this might be helpful with diagnosing the root cause."
@@ -145,7 +152,9 @@ export default function SettingsGeneral() {
             value="isDebugOptionsEnabled"
             checked={isDebugOptionsEnabled}
             onCheckedChange={isSelected => {
-              setIsDebugOptionsEnabled(Boolean(isSelected));
+              setIsDebugOptionsEnabled(Boolean(isSelected)).catch(
+                logAndNotify("Failed to save the setting."),
+              );
             }}
             label="Show debug actions"
             description="Shows debug actions in various places around the app such as buttons to delete the schema or reset the last sync time."
diff --git a/packages/graph-explorer/src/utils/index.ts b/packages/graph-explorer/src/utils/index.ts
index 44fef6c49..7fd157d99 100644
--- a/packages/graph-explorer/src/utils/index.ts
+++ b/packages/graph-explorer/src/utils/index.ts
@@ -6,6 +6,8 @@ export { default as useClickOutside } from "./useClickOutside";
 export { DEFAULT_SERVICE_TYPE } from "./constants";
 export { default as escapeString } from "./escapeString";
 export { default as batchPromisesSerially } from "./batchPromisesSerially";
+export { logAndIgnore } from "./logAndIgnore";
+export { logAndNotify } from "./logAndNotify";
 export { default as logger } from "./logger";
 export * from "./branded";
 export * from "./sanitizeQuery";
diff --git a/packages/graph-explorer/src/utils/logAndIgnore.test.ts b/packages/graph-explorer/src/utils/logAndIgnore.test.ts
new file mode 100644
index 000000000..f6192a51f
--- /dev/null
+++ b/packages/graph-explorer/src/utils/logAndIgnore.test.ts
@@ -0,0 +1,28 @@
+import { logAndIgnore } from "./logAndIgnore";
+import logger from "./logger";
+
+vi.mock("./logger", () => ({
+  default: {
+    warn: vi.fn(),
+  },
+}));
+
+describe("logAndIgnore", () => {
+  it("warns with the error when used as a catch handler for a rejection", async () => {
+    const error = new Error("persist failed");
+
+    Promise.reject(error).catch(logAndIgnore);
+    await vi.waitFor(() => {
+      expect(logger.warn).toHaveBeenCalledWith(
+        "Ignored promise rejection:",
+        error,
+      );
+    });
+  });
+
+  it("does not log anything when the promise resolves", async () => {
+    await Promise.resolve().catch(logAndIgnore);
+
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/graph-explorer/src/utils/logAndIgnore.ts b/packages/graph-explorer/src/utils/logAndIgnore.ts
new file mode 100644
index 000000000..c1a24df82
--- /dev/null
+++ b/packages/graph-explorer/src/utils/logAndIgnore.ts
@@ -0,0 +1,19 @@
+import logger from "./logger";
+
+/**
+ * Logs a rejected promise's error and otherwise ignores it. Intended as a
+ * `.catch` handler for promises the caller intentionally does not await:
+ * `somePromise.catch(logAndIgnore)`.
+ *
+ * Use this when a rejection is meaningful enough to surface in the logs but
+ * does not need to be awaited or propagated — most notably background
+ * persistence writes (see `atomWithLocalForage`), which resolve synchronously
+ * in memory but may reject when the durable write fails. It logs at `warn`
+ * rather than `error` because an explicitly-ignored rejection is non-blocking
+ * by construction: the in-memory state already updated and nothing downstream
+ * is waiting on it. For promises whose rejection is genuinely inert (e.g. an
+ * aborted navigation), prefer the bare `void` operator instead.
+ */
+export function logAndIgnore(error: unknown) {
+  logger.warn("Ignored promise rejection:", error);
+}
diff --git a/packages/graph-explorer/src/utils/logAndNotify.test.ts b/packages/graph-explorer/src/utils/logAndNotify.test.ts
new file mode 100644
index 000000000..5eeeb492e
--- /dev/null
+++ b/packages/graph-explorer/src/utils/logAndNotify.test.ts
@@ -0,0 +1,54 @@
+import { toast } from "sonner";
+
+import { logAndNotify } from "./logAndNotify";
+import logger from "./logger";
+
+vi.mock("./logger", () => ({
+  default: {
+    warn: vi.fn(),
+  },
+}));
+
+vi.mock("sonner", () => ({
+  toast: {
+    warning: vi.fn(),
+  },
+}));
+
+describe("logAndNotify", () => {
+  it("logs the error and shows a warning toast when the promise rejects", async () => {
+    const error = new Error("persist failed");
+    const handler = logAndNotify("Couldn't save your changes.");
+
+    await Promise.reject(error).catch(handler);
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      "Couldn't save your changes.",
+      error,
+    );
+    expect(toast.warning).toHaveBeenCalledWith(
+      "Couldn't save your changes.",
+      undefined,
+    );
+  });
+
+  it("passes toast options through to the warning toast", async () => {
+    const error = new Error("persist failed");
+    const handler = logAndNotify("Couldn't save your changes.", {
+      description: "Your edit may be lost when you reload.",
+    });
+
+    await Promise.reject(error).catch(handler);
+
+    expect(toast.warning).toHaveBeenCalledWith("Couldn't save your changes.", {
+      description: "Your edit may be lost when you reload.",
+    });
+  });
+
+  it("does not log or notify when the promise resolves", async () => {
+    await Promise.resolve().catch(logAndNotify("unused"));
+
+    expect(logger.warn).not.toHaveBeenCalled();
+    expect(toast.warning).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/graph-explorer/src/utils/logAndNotify.ts b/packages/graph-explorer/src/utils/logAndNotify.ts
new file mode 100644
index 000000000..d816433e9
--- /dev/null
+++ b/packages/graph-explorer/src/utils/logAndNotify.ts
@@ -0,0 +1,23 @@
+import { toast } from "sonner";
+
+import logger from "./logger";
+
+type ToastOptions = Parameters<typeof toast.warning>[1];
+
+/**
+ * Builds a `.catch` handler that logs a rejected promise's error and shows the
+ * user a warning toast: `somePromise.catch(logAndNotify("Couldn't save."))`.
+ *
+ * Use this for promises the caller does not await but whose failure the user
+ * should know about — most notably persistence writes that may silently fail.
+ * It is the user-facing counterpart to `logAndIgnore`: both log at `warn`
+ * level, but this one also surfaces the failure through a toast. The same
+ * `message` is logged (alongside the error) and shown in the toast; pass
+ * `options` to add a toast description or other sonner options.
+ */
+export function logAndNotify(message: string, options?: ToastOptions) {
+  return (error: unknown) => {
+    logger.warn(message, error);
+    toast.warning(message, options);
+  };
+}
diff --git a/packages/graph-explorer/src/utils/testing/DbState.ts b/packages/graph-explorer/src/utils/testing/DbState.ts
index 52feadc3b..6aa7d90f2 100644
--- a/packages/graph-explorer/src/utils/testing/DbState.ts
+++ b/packages/graph-explorer/src/utils/testing/DbState.ts
@@ -185,25 +185,31 @@ export class DbState {
     return composedStyle;
   }
 
-  /** Applies the state to the given Jotai store. */
-  applyTo(store: AppStore) {
+  /**
+   * Applies the state to the given Jotai store.
+   *
+   * Awaits the localForage-backed atom writes so the seeded state is fully
+   * persisted before the test proceeds, and so a seeding failure surfaces as a
+   * test failure rather than an unhandled rejection at teardown.
+   */
+  async applyTo(store: AppStore) {
     // Config
-    store.set(
+    await store.set(
       configurationAtom,
       new Map([[this.activeConfig.id, this.activeConfig]]),
     );
     if (this._activeSchema) {
-      store.set(
+      await store.set(
         schemaAtom,
         new Map([[this.activeConfig.id, this._activeSchema]]),
       );
     } else {
-      store.set(schemaAtom, new Map());
+      await store.set(schemaAtom, new Map());
     }
-    store.set(activeConfigurationAtom, this.activeConfig.id);
+    await store.set(activeConfigurationAtom, this.activeConfig.id);
 
     // Styling
-    store.set(userStylingAtom, this.activeStyling);
+    await store.set(userStylingAtom, this.activeStyling);
 
     // Vertices
     store.set(nodesAtom, toNodeMap(this.vertices));
@@ -216,7 +222,7 @@ export class DbState {
     store.set(edgesTypesFilteredAtom, this.filteredEdgeTypes);
 
     // Graph Storage
-    store.set(
+    await store.set(
       allGraphSessionsAtom,
       new Map([
         [
diff --git a/packages/graph-explorer/src/utils/testing/createCancelledError.ts b/packages/graph-explorer/src/utils/testing/createCancelledError.ts
index 69b0623f3..78b6fc426 100644
--- a/packages/graph-explorer/src/utils/testing/createCancelledError.ts
+++ b/packages/graph-explorer/src/utils/testing/createCancelledError.ts
@@ -13,7 +13,7 @@ export async function createCancelledError() {
       queryFn: () => new Promise(() => {}),
     });
     // Cancel, then await the query to get the error
-    queryClient.cancelQueries();
+    void queryClient.cancelQueries();
     await promise;
   } catch (error) {
     return error;
diff --git a/packages/graph-explorer/src/utils/testing/persistence.test.ts b/packages/graph-explorer/src/utils/testing/persistence.test.ts
index 6c21d7073..5f62b6341 100644
--- a/packages/graph-explorer/src/utils/testing/persistence.test.ts
+++ b/packages/graph-explorer/src/utils/testing/persistence.test.ts
@@ -23,7 +23,7 @@ describe("persistence test helpers", () => {
     const key = createRandomName("key");
     const tab = await openPersistenceTab(key, "initial");
 
-    tab.write("updated");
+    void tab.write("updated");
     await tab.flush();
 
     expect(await readPersistedValue(key)).toBe("updated");
@@ -36,9 +36,9 @@ describe("persistence test helpers", () => {
     // Fire several writes without awaiting each, then flush once. flush() must
     // wait for all of them; tracking only the latest would let earlier writes
     // be unobserved.
-    tab.write("first");
-    tab.write("second");
-    tab.write("third");
+    void tab.write("first");
+    void tab.write("second");
+    void tab.write("third");
     await tab.flush();
 
     expect(await readPersistedValue(key)).toBe("third");
diff --git a/packages/graph-explorer/src/utils/testing/renderHookWithJotai.tsx b/packages/graph-explorer/src/utils/testing/renderHookWithJotai.tsx
index b711f5f28..212722460 100644
--- a/packages/graph-explorer/src/utils/testing/renderHookWithJotai.tsx
+++ b/packages/graph-explorer/src/utils/testing/renderHookWithJotai.tsx
@@ -21,7 +21,7 @@ export function TestProvider({
   );
 }
 
-export function renderHookWithState<TResult>(
+export async function renderHookWithState<TResult>(
   callback: () => TResult,
   state?: DbState,
 ) {
@@ -30,7 +30,7 @@ export function renderHookWithState<TResult>(
 
   // Set values on the Jotai store
   const store = getAppStore();
-  state.applyTo(store);
+  await state.applyTo(store);
 
   // Create the query client using the mock explorer
   const queryClient = createQueryClient();
@@ -48,14 +48,14 @@ export function renderHookWithState<TResult>(
   });
 }
 
-export function renderHookWithJotai<TResult>(
+export async function renderHookWithJotai<TResult>(
   callback: () => TResult,
-  initializeState?: (store: AppStore) => void,
+  initializeState?: (store: AppStore) => void | Promise<void>,
 ) {
   // Provide a way to set atom initial values
   const store = getAppStore();
   if (initializeState) {
-    initializeState(store);
+    await initializeState(store);
   }
 
   // Call the standard testing hook with TanStack Query and Jotai setup