From ff7a57948f0e0798aff2ceafa841002e4549fe8f Mon Sep 17 00:00:00 2001
From: Kris McGinnes <kmcginnes@me.com>
Date: Thu, 18 Jun 2026 18:23:44 -0500
Subject: [PATCH 1/8] Enable no-floating-promises and make fire-and-forget
 explicit

Turn on the oxlint typescript/no-floating-promises rule and resolve every
violation across the codebase. Persisted Jotai atom writes return a background
persistence promise that was previously dropped silently, hiding real failures
behind intentional fire-and-forget calls.

Add a fireAndForget helper that observes failures via logger.error, and apply
two idioms by meaning: fireAndForget for unawaited writes whose rejection should
be logged (persisted-atom setters), and bare void for genuinely inert promises
(navigation, self-catching helpers, test-state seeding). Record the convention
in an ADR and the TypeScript conventions skill.
---
 .kiro/skills/typescript/SKILL.md              |  9 +++
 .oxlintrc.json                                |  2 +-
 ...exeddb-not-localstorage-for-persistence.md |  2 +-
 ...key-diff-merge-cross-tab-reconciliation.md |  2 +-
 ...18-explicit-floating-promise-convention.md | 31 ++++++++
 .../src/components/Button/NavButton.tsx       |  2 +-
 .../src/components/Redirect.tsx               |  2 +-
 .../src/components/utils/canvas/drawImage.ts  | 34 ++++----
 .../src/connector/LoggerConnector.test.ts     | 12 +--
 .../connector/queries/edgeConnectionsQuery.ts | 54 +++++++------
 .../connector/queries/schemaSyncQuery.test.ts | 16 ++--
 .../src/connector/queries/schemaSyncQuery.ts  | 56 ++++++-------
 .../src/core/AppStatusLoader.tsx              | 20 ++---
 .../StateProvider/atomWithLocalForage.test.ts | 22 +++---
 .../core/StateProvider/displayEdge.test.ts    | 12 +--
 .../core/StateProvider/displayVertex.test.ts  | 12 +--
 .../StateProvider/graphSession/storage.ts     |  5 +-
 .../src/core/StateProvider/localDb.test.ts    | 30 +++----
 .../src/core/StateProvider/schema.test.ts     | 36 ++++-----
 .../src/core/StateProvider/schema.ts          | 36 +++++----
 .../core/StateProvider/storageAtoms.test.ts   |  4 +-
 .../src/core/StateProvider/userLayout.test.ts | 14 ++--
 .../src/core/StateProvider/userLayout.ts      | 38 +++++----
 .../src/hooks/useDeleteConfig.test.ts         | 10 +--
 .../src/hooks/useDeleteConfig.ts              | 58 ++++++++------
 .../src/hooks/useExpandNode.test.ts           | 10 +--
 .../src/hooks/useSchemaSync.test.ts           | 10 +--
 .../src/hooks/useTextTransform.test.ts        |  6 +-
 .../AvailableConnections.test.tsx             |  2 +-
 .../AvailableConnections/ConnectionRow.tsx    |  4 +-
 .../useImportConnectionFile.ts                | 35 +++++----
 .../CreateConnection/CreateConnection.tsx     | 78 ++++++++++---------
 .../EdgesStyling/SingleEdgeStyling.tsx        |  4 +-
 .../internalComponents/ContextMenu.tsx        | 10 ++-
 .../GraphViewer/useAutoOpenDetailsSidebar.ts  | 21 ++---
 .../src/modules/Namespaces/UserPrefixes.tsx   | 59 +++++++-------
 .../modules/NodesStyling/NodeStyleDialog.tsx  |  8 +-
 .../NodesStyling/SingleNodeStyling.tsx        |  3 +-
 .../SchemaGraph/SchemaGraphToolbar.tsx        |  2 +-
 .../SearchSidebar/QuerySearchTabContent.tsx   |  2 +-
 .../SearchSidebar/useKeywordSearch.test.ts    | 10 +--
 .../src/routes/DataExplorer/DataExplorer.tsx  | 13 +++-
 .../src/routes/Settings/SettingsGeneral.tsx   | 11 ++-
 .../src/utils/fireAndForget.test.ts           | 26 +++++++
 .../graph-explorer/src/utils/fireAndForget.ts | 17 ++++
 packages/graph-explorer/src/utils/index.ts    |  1 +
 .../src/utils/testing/DbState.ts              | 20 +++--
 .../src/utils/testing/createCancelledError.ts |  2 +-
 .../src/utils/testing/persistence.test.ts     |  8 +-
 49 files changed, 518 insertions(+), 363 deletions(-)
 create mode 100644 docs/adr/20260618-explicit-floating-promise-convention.md
 create mode 100644 packages/graph-explorer/src/utils/fireAndForget.test.ts
 create mode 100644 packages/graph-explorer/src/utils/fireAndForget.ts

diff --git a/.kiro/skills/typescript/SKILL.md b/.kiro/skills/typescript/SKILL.md
index 4d571a364..caf93e4d2 100644
--- a/.kiro/skills/typescript/SKILL.md
+++ b/.kiro/skills/typescript/SKILL.md
@@ -12,6 +12,15 @@ 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:
+
+- **`fireAndForget(promise)`** (from `@/utils`) — when a rejection is meaningful and should be observed even though you don't await it. It attaches `.catch(logger.error)`. This is the idiom for persisted-atom setters (`atomWithLocalForage`-backed writes), where a failed durable write should be logged rather than silently dropped.
+- **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..f7ee3165e
--- /dev/null
+++ b/docs/adr/20260618-explicit-floating-promise-convention.md
@@ -0,0 +1,31 @@
+# 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 two idioms by meaning:
+
+1. **`fireAndForget(promise)`** (`@/utils`) — attaches `.catch(logger.error)`. Use when a rejection is **meaningful and should be observed** even though the caller does not await it. This is the idiom for **persisted-atom setters**: a failed durable write gets logged rather than silently dropped, and the call sites stay greppable for follow-up auditing.
+
+2. **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).
+
+The reconciliation contract for user-facing persistence errors (reject + surface a toast) is a **separate, in-flight effort** on the persistence branch. This ADR deliberately does **not** change the runtime behavior of persisted setters — it only makes the existing fire-and-forget explicit. When the toast contract lands, the `fireAndForget`-wrapped userStyling call sites are the ones to revisit toward a handled-reject form.
+
+### Alternatives considered
+
+**Centralize the `.catch` inside `atomWithLocalForage` and return `void`.** The writer atom could attach its own `.catch(logger.error)` and return `void`, deleting most of the ~25 `fireAndForget(set(...))` wrappers 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 logged (`fireAndForget`) or a deliberate, reviewed `void` — no longer invisible.
+- Reviewers have a clear rule: meaningful-but-unawaited → `fireAndForget`; 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..d0979b245 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, fireAndForget } 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();
-    });
+    fireAndForget(
+      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();
+      }),
+    );
 
     return;
   }
diff --git a/packages/graph-explorer/src/connector/LoggerConnector.test.ts b/packages/graph-explorer/src/connector/LoggerConnector.test.ts
index b0fc46e6d..1bdc5ab6e 100644
--- a/packages/graph-explorer/src/connector/LoggerConnector.test.ts
+++ b/packages/graph-explorer/src/connector/LoggerConnector.test.ts
@@ -21,31 +21,31 @@ describe("ServerLoggerConnector", () => {
 
     const connector = new ServerLoggerConnector("https://example.com/");
 
-    connector.error("error msg");
+    void 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");
+    void 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");
+    void 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");
+    void 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");
+    void connector.trace("trace msg");
     expect(mockFetch).toHaveBeenCalledWith("https://example.com/logger", {
       method: "POST",
       headers: { level: "trace", message: JSON.stringify("trace msg") },
@@ -57,7 +57,7 @@ describe("ServerLoggerConnector", () => {
     vi.stubGlobal("fetch", mockFetch);
 
     const connector = new ServerLoggerConnector("https://example.com/");
-    connector.info("test");
+    void connector.info("test");
 
     expect(mockFetch).toHaveBeenCalledWith(
       "https://example.com/logger",
diff --git a/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.ts b/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.ts
index ba2ecea2f..8a00ee7e4 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 { fireAndForget, logger } from "@/utils";
 
 import { getExplorer, getStore } from "./helpers";
 import { schemaSyncQueryKey } from "./schemaSyncQuery";
@@ -90,19 +90,21 @@ const setEdgeConnectionsAtom = atom(
     if (!activeConfigId) {
       return;
     }
-    set(schemaAtom, prev => {
-      const activeSchema = prev.get(activeConfigId);
-      if (!activeSchema) {
-        return prev;
-      }
-      const updated = new Map(prev);
-      updated.set(activeConfigId, {
-        ...activeSchema,
-        edgeConnections,
-        lastEdgeConnectionSyncFail: false,
-      });
-      return updated;
-    });
+    fireAndForget(
+      set(schemaAtom, prev => {
+        const activeSchema = prev.get(activeConfigId);
+        if (!activeSchema) {
+          return prev;
+        }
+        const updated = new Map(prev);
+        updated.set(activeConfigId, {
+          ...activeSchema,
+          edgeConnections,
+          lastEdgeConnectionSyncFail: false,
+        });
+        return updated;
+      }),
+    );
   },
 );
 
@@ -114,15 +116,17 @@ const setEdgeConnectionSyncFailedAtom = atom(null, (get, set) => {
     return;
   }
 
-  set(schemaAtom, prev => {
-    const existing = prev.get(id);
-    const updated = new Map(prev);
-    updated.set(id, {
-      ...existing,
-      vertices: existing?.vertices ?? [],
-      edges: existing?.edges ?? [],
-      lastEdgeConnectionSyncFail: true,
-    });
-    return updated;
-  });
+  fireAndForget(
+    set(schemaAtom, prev => {
+      const existing = prev.get(id);
+      const updated = new Map(prev);
+      updated.set(id, {
+        ...existing,
+        vertices: existing?.vertices ?? [],
+        edges: existing?.edges ?? [],
+        lastEdgeConnectionSyncFail: true,
+      });
+      return updated;
+    }),
+  );
 });
diff --git a/packages/graph-explorer/src/connector/queries/schemaSyncQuery.test.ts b/packages/graph-explorer/src/connector/queries/schemaSyncQuery.test.ts
index 94dd2c7a9..4efc33648 100644
--- a/packages/graph-explorer/src/connector/queries/schemaSyncQuery.test.ts
+++ b/packages/graph-explorer/src/connector/queries/schemaSyncQuery.test.ts
@@ -36,9 +36,9 @@ describe("schemaSyncQuery", () => {
 
     // 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());
+    void store.set(configurationAtom, new Map([[config.id, config]]));
+    void store.set(activeConfigurationAtom, config.id);
+    void 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 => {
+    void 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 => {
+    void 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 => {
+    void 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 => {
+    void 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 => {
+    void 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..c8cb33a47 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 { fireAndForget, logger } from "@/utils";
 
 import type { SchemaResponse } from "../useGEFetchTypes";
 
@@ -84,22 +84,24 @@ const replaceSchemaAtom = atom(
       return;
     }
 
-    set(schemaAtom, prev => {
-      const updated = new Map(prev);
-      updated.set(id, {
-        ...schema,
-        prefixes,
+    fireAndForget(
+      set(schemaAtom, prev => {
+        const updated = new Map(prev);
+        updated.set(id, {
+          ...schema,
+          prefixes,
 
-        // Reset edge connection information during schema sync
-        edgeConnections: undefined,
-        lastEdgeConnectionSyncFail: false,
+          // Reset edge connection information during schema sync
+          edgeConnections: undefined,
+          lastEdgeConnectionSyncFail: false,
 
-        // Mark as completed successfully
-        lastUpdate: new Date(),
-        lastSyncFail: false,
-      });
-      return updated;
-    });
+          // Mark as completed successfully
+          lastUpdate: new Date(),
+          lastSyncFail: false,
+        });
+        return updated;
+      }),
+    );
   },
 );
 
@@ -111,15 +113,17 @@ const setSyncFailedAtom = atom(null, (get, set) => {
     return;
   }
 
-  set(schemaAtom, prev => {
-    const existing = prev.get(id);
-    const updated = new Map(prev);
-    updated.set(id, {
-      ...existing,
-      vertices: existing?.vertices ?? [],
-      edges: existing?.edges ?? [],
-      lastSyncFail: true,
-    });
-    return updated;
-  });
+  fireAndForget(
+    set(schemaAtom, prev => {
+      const existing = prev.get(id);
+      const updated = new Map(prev);
+      updated.set(id, {
+        ...existing,
+        vertices: existing?.vertices ?? [],
+        edges: existing?.edges ?? [],
+        lastSyncFail: true,
+      });
+      return updated;
+    }),
+  );
 });
diff --git a/packages/graph-explorer/src/core/AppStatusLoader.tsx b/packages/graph-explorer/src/core/AppStatusLoader.tsx
index 36535788f..74964db33 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 { fireAndForget, logger } from "@/utils";
 
 import { fetchDefaultConnection } from "./defaultConnection";
 import { activeConfigurationAtom, configurationAtom } from "./StateProvider";
@@ -48,14 +48,16 @@ function LoadDefaultConfig({ children }: PropsWithChildren) {
 
     startTransition(() => {
       logger.debug("Adding default connections", defaultConnectionConfigs);
-      setConfiguration(prev => {
-        const updatedConfig = new Map(prev);
-        defaultConnectionConfigs.forEach(config => {
-          updatedConfig.set(config.id, config);
-        });
-        return updatedConfig;
-      });
-      setActiveConfig(defaultConnectionConfigs[0].id);
+      fireAndForget(
+        setConfiguration(prev => {
+          const updatedConfig = new Map(prev);
+          defaultConnectionConfigs.forEach(config => {
+            updatedConfig.set(config.id, config);
+          });
+          return updatedConfig;
+        }),
+      );
+      fireAndForget(setActiveConfig(defaultConnectionConfigs[0].id));
     });
   }, [
     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..2b7ad4028 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");
+    void 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);
+    void 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);
+    void 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);
+    void store.set(atom, 1);
+    void store.set(atom, 2);
+    void 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");
+    void store.set(stringAtom, "world");
     expect(store.get(stringAtom)).toBe("world");
 
     // Number
     const numberAtom = await atomWithLocalForage("test-number", 42);
-    store.set(numberAtom, 100);
+    void store.set(numberAtom, 100);
     expect(store.get(numberAtom)).toBe(100);
 
     // Boolean
     const boolAtom = await atomWithLocalForage("test-bool", false);
-    store.set(boolAtom, true);
+    void 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]);
+    void 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 });
+    void 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..d2d4c14da 100644
--- a/packages/graph-explorer/src/core/StateProvider/displayEdge.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/displayEdge.test.ts
@@ -239,9 +239,9 @@ 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);
+      void store.set(configurationAtom, new Map([[config.id, config]]));
+      void store.set(schemaAtom, new Map([[config.id, schema]]));
+      void store.set(activeConfigurationAtom, config.id);
     };
   }
 
@@ -252,9 +252,9 @@ 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);
+      void store.set(configurationAtom, new Map([[config.id, config]]));
+      void store.set(schemaAtom, new Map([[config.id, schema]]));
+      void store.set(activeConfigurationAtom, config.id);
     };
   }
 });
diff --git a/packages/graph-explorer/src/core/StateProvider/displayVertex.test.ts b/packages/graph-explorer/src/core/StateProvider/displayVertex.test.ts
index 020b513fe..65019996b 100644
--- a/packages/graph-explorer/src/core/StateProvider/displayVertex.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/displayVertex.test.ts
@@ -219,9 +219,9 @@ 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);
+      void store.set(configurationAtom, new Map([[config.id, config]]));
+      void store.set(schemaAtom, new Map([[config.id, schema]]));
+      void store.set(activeConfigurationAtom, config.id);
     };
   }
 
@@ -232,9 +232,9 @@ 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);
+      void store.set(configurationAtom, new Map([[config.id, config]]));
+      void store.set(schemaAtom, new Map([[config.id, schema]]));
+      void store.set(activeConfigurationAtom, config.id);
     };
   }
 });
diff --git a/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts b/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts
index 272672281..f36c9bce6 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 { fireAndForget } from "@/utils";
 
 import type { EdgeId, VertexId } from "../../entities";
 
@@ -39,11 +40,11 @@ export const activeGraphSessionAtom = atom(
     // Delete the active graph if we receive a default value
     if (newValue === RESET || !newValue) {
       newGraphs.delete(connectionId);
-      set(allGraphSessionsAtom, newGraphs);
+      fireAndForget(set(allGraphSessionsAtom, newGraphs));
       return;
     }
 
     newGraphs.set(connectionId, newValue);
-    set(allGraphSessionsAtom, newGraphs);
+    fireAndForget(set(allGraphSessionsAtom, newGraphs));
   },
 );
diff --git a/packages/graph-explorer/src/core/StateProvider/localDb.test.ts b/packages/graph-explorer/src/core/StateProvider/localDb.test.ts
index a8634e4e7..3a7407864 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);
+    void localDb.setItem("schema", schemaMap);
+    void localDb.setItem("configuration", configMap);
+    void 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);
+    void localDb.setItem("schema", schemaMap);
+    void localDb.setItem("configuration", configMap);
+    void 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);
+    void localDb.setItem("schema", schemaMap);
+    void localDb.setItem("configuration", configMap);
+    void localDb.setItem("active-configuration", config.id);
+    void localDb.setItem(addRestoredPrefix("schema"), schemaMap);
+    void localDb.setItem(addRestoredPrefix("configuration"), configMap);
+    void 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);
+    void localDb.setItem("schema", schemaMap);
+    void localDb.setItem("configuration", configMap);
+    void 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/schema.test.ts b/packages/graph-explorer/src/core/StateProvider/schema.test.ts
index 97a9d4e8f..21a430f4a 100644
--- a/packages/graph-explorer/src/core/StateProvider/schema.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/schema.test.ts
@@ -1320,9 +1320,9 @@ describe("maybeActiveSchemaAtom", () => {
     const { result } = renderHookWithJotai(
       () => useAtomValue(maybeActiveSchemaAtom),
       store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map());
+        void store.set(configurationAtom, new Map([[config.id, config]]));
+        void store.set(activeConfigurationAtom, config.id);
+        void store.set(schemaAtom, new Map());
       },
     );
 
@@ -1336,9 +1336,9 @@ describe("maybeActiveSchemaAtom", () => {
     const { result } = 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]]));
+        void store.set(configurationAtom, new Map([[config.id, config]]));
+        void store.set(activeConfigurationAtom, config.id);
+        void store.set(schemaAtom, new Map([[config.id, schema]]));
       },
     );
 
@@ -1359,9 +1359,9 @@ describe("useMaybeActiveSchema", () => {
     const { result } = renderHookWithJotai(
       () => useMaybeActiveSchema(),
       store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map());
+        void store.set(configurationAtom, new Map([[config.id, config]]));
+        void store.set(activeConfigurationAtom, config.id);
+        void store.set(schemaAtom, new Map());
       },
     );
 
@@ -1375,9 +1375,9 @@ describe("useMaybeActiveSchema", () => {
     const { result } = renderHookWithJotai(
       () => useMaybeActiveSchema(),
       store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map([[config.id, schema]]));
+        void store.set(configurationAtom, new Map([[config.id, config]]));
+        void store.set(activeConfigurationAtom, config.id);
+        void store.set(schemaAtom, new Map([[config.id, schema]]));
       },
     );
 
@@ -1402,9 +1402,9 @@ describe("useActiveSchema", () => {
     const { result } = renderHookWithJotai(
       () => useActiveSchema(),
       store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map());
+        void store.set(configurationAtom, new Map([[config.id, config]]));
+        void store.set(activeConfigurationAtom, config.id);
+        void store.set(schemaAtom, new Map());
       },
     );
 
@@ -1422,9 +1422,9 @@ describe("useActiveSchema", () => {
     const { result } = renderHookWithJotai(
       () => useActiveSchema(),
       store => {
-        store.set(configurationAtom, new Map([[config.id, config]]));
-        store.set(activeConfigurationAtom, config.id);
-        store.set(schemaAtom, new Map([[config.id, schema]]));
+        void store.set(configurationAtom, new Map([[config.id, config]]));
+        void store.set(activeConfigurationAtom, config.id);
+        void 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..9cba4942a 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 { fireAndForget, logger } from "@/utils";
 import { generatePrefixes, PrefixLookup } from "@/utils/rdf";
 
 import { nodesAtom, toNodeMap } from "./nodes";
@@ -254,28 +254,30 @@ export const activeSchemaSelector = atom(
     if (!schemaId) {
       return;
     }
-    set(schemaAtom, prevSchemaMap => {
-      const prev = prevSchemaMap.get(schemaId);
-      const newValue = typeof update === "function" ? update(prev) : update;
+    fireAndForget(
+      set(schemaAtom, prevSchemaMap => {
+        const prev = prevSchemaMap.get(schemaId);
+        const newValue = typeof update === "function" ? update(prev) : update;
 
-      if (newValue === prev) {
-        return prevSchemaMap;
-      }
+        if (newValue === prev) {
+          return prevSchemaMap;
+        }
 
-      const updatedSchemaMap = new Map(prevSchemaMap);
+        const updatedSchemaMap = new Map(prevSchemaMap);
 
-      if (newValue === RESET || !newValue) {
-        if (!prev) {
-          return prevSchemaMap;
+        if (newValue === RESET || !newValue) {
+          if (!prev) {
+            return prevSchemaMap;
+          }
+          updatedSchemaMap.delete(schemaId);
+          return updatedSchemaMap;
         }
-        updatedSchemaMap.delete(schemaId);
-        return updatedSchemaMap;
-      }
 
-      updatedSchemaMap.set(schemaId, newValue);
+        updatedSchemaMap.set(schemaId, newValue);
 
-      return updatedSchemaMap;
-    });
+        return updatedSchemaMap;
+      }),
+    );
   },
 );
 
diff --git a/packages/graph-explorer/src/core/StateProvider/storageAtoms.test.ts b/packages/graph-explorer/src/core/StateProvider/storageAtoms.test.ts
index 886546b93..7667764d8 100644
--- a/packages/graph-explorer/src/core/StateProvider/storageAtoms.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/storageAtoms.test.ts
@@ -55,10 +55,10 @@ describe("storageAtoms", () => {
   it("should persist a written value on subsequent reads", () => {
     const store = createStore();
 
-    store.set(showDebugActionsAtom, true);
+    void store.set(showDebugActionsAtom, true);
     expect(store.get(showDebugActionsAtom)).toBe(true);
 
-    store.set(showDebugActionsAtom, false);
+    void store.set(showDebugActionsAtom, false);
     expect(store.get(showDebugActionsAtom)).toBe(false);
   });
 });
diff --git a/packages/graph-explorer/src/core/StateProvider/userLayout.test.ts b/packages/graph-explorer/src/core/StateProvider/userLayout.test.ts
index c0337066b..b72bf958f 100644
--- a/packages/graph-explorer/src/core/StateProvider/userLayout.test.ts
+++ b/packages/graph-explorer/src/core/StateProvider/userLayout.test.ts
@@ -61,19 +61,19 @@ describe("useSidebar", () => {
     expect(result.current.isSidebarOpen).toBe(true);
   });
 
-  it("should change to the given sidebar item", async () => {
+  it("should change to the given sidebar item", () => {
     const { result } = 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 () => {
+  it("should close the sidebar if toggling to the same item", () => {
     const { result } = renderHookWithJotai(
       () => useSidebar(),
       store =>
@@ -83,7 +83,7 @@ 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();
@@ -105,7 +105,7 @@ describe("useSidebar", () => {
       () => useSidebar(),
       store => {
         dbState.applyTo(store);
-        store.set(userLayoutAtom, {
+        void store.set(userLayoutAtom, {
           activeSidebarItem: "namespaces",
           activeToggles: new Set(),
         } satisfies UserLayout);
@@ -125,7 +125,7 @@ describe("useSidebar", () => {
       () => useSidebar(),
       store => {
         dbState.applyTo(store);
-        store.set(userLayoutAtom, {
+        void store.set(userLayoutAtom, {
           activeSidebarItem: "namespaces",
           activeToggles: new Set(),
         } satisfies UserLayout);
diff --git a/packages/graph-explorer/src/core/StateProvider/userLayout.ts b/packages/graph-explorer/src/core/StateProvider/userLayout.ts
index e9a0d0f8c..2c8243c88 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 { fireAndForget } from "@/utils";
+
 import { useQueryEngine } from "../connector";
 import { userLayoutAtom } from "./storageAtoms";
 import {
@@ -93,12 +95,14 @@ export function useSidebar() {
    * item is the same as the current active item.
    */
   const toggleSidebar = (item: SidebarItems) =>
-    setUserLayout(prev => {
-      return {
-        ...prev,
-        activeSidebarItem: prev.activeSidebarItem === item ? null : item,
-      };
-    });
+    fireAndForget(
+      setUserLayout(prev => {
+        return {
+          ...prev,
+          activeSidebarItem: prev.activeSidebarItem === item ? null : item,
+        };
+      }),
+    );
 
   return {
     activeSidebarItem,
@@ -116,16 +120,18 @@ export function useSidebarSize() {
 
   /** Sets the sidebar width to the current width + the given delta */
   const setSidebarWidth = (deltaWidth: number) => {
-    setUserLayout(prev => {
-      const prevWidth = prev.sidebar?.width ?? DEFAULT_SIDEBAR_WIDTH;
-      return {
-        ...prev,
-        sidebar: {
-          ...prev.sidebar,
-          width: prevWidth + deltaWidth,
-        },
-      };
-    });
+    fireAndForget(
+      setUserLayout(prev => {
+        const prevWidth = prev.sidebar?.width ?? DEFAULT_SIDEBAR_WIDTH;
+        return {
+          ...prev,
+          sidebar: {
+            ...prev.sidebar,
+            width: prevWidth + deltaWidth,
+          },
+        };
+      }),
+    );
   };
 
   return [sidebarWidth, setSidebarWidth] as const;
diff --git a/packages/graph-explorer/src/hooks/useDeleteConfig.test.ts b/packages/graph-explorer/src/hooks/useDeleteConfig.test.ts
index e08dcd58f..d2979bc50 100644
--- a/packages/graph-explorer/src/hooks/useDeleteConfig.test.ts
+++ b/packages/graph-explorer/src/hooks/useDeleteConfig.test.ts
@@ -31,8 +31,8 @@ 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]]));
+      void store.set(activeConfigurationAtom, config1.id);
+      void store.set(configurationAtom, new Map([[config1.id, config1]]));
     },
   );
 
@@ -56,9 +56,9 @@ test("should delete the active schema", async () => {
       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]]));
+      void store.set(activeConfigurationAtom, config1.id);
+      void store.set(configurationAtom, new Map([[config1.id, config1]]));
+      void store.set(schemaAtom, new Map([[config1.id, schema1]]));
     },
   );
 
diff --git a/packages/graph-explorer/src/hooks/useDeleteConfig.ts b/packages/graph-explorer/src/hooks/useDeleteConfig.ts
index a843c856b..827ba5f87 100644
--- a/packages/graph-explorer/src/hooks/useDeleteConfig.ts
+++ b/packages/graph-explorer/src/hooks/useDeleteConfig.ts
@@ -9,36 +9,44 @@ import {
   type ConfigurationId,
   schemaAtom,
 } from "@/core";
-import { logger } from "@/utils";
+import { fireAndForget, logger } from "@/utils";
 
 export function useDeleteConfig() {
   return useAtomCallback(
     useCallback((_get, set, id: ConfigurationId) => {
       logger.log("Deleting connection:", id);
-      set(activeConfigurationAtom, prev => {
-        if (prev === id) {
-          return null;
-        }
-        return prev;
-      });
-
-      set(configurationAtom, prevConfigs => {
-        const updatedConfigs = new Map(prevConfigs);
-        updatedConfigs.delete(id);
-        return updatedConfigs;
-      });
-
-      set(schemaAtom, prevSchemas => {
-        const updatedSchemas = new Map(prevSchemas);
-        updatedSchemas.delete(id);
-        return updatedSchemas;
-      });
-
-      set(allGraphSessionsAtom, prev => {
-        const updatedGraphs = new Map(prev);
-        updatedGraphs.delete(id);
-        return updatedGraphs;
-      });
+      fireAndForget(
+        set(activeConfigurationAtom, prev => {
+          if (prev === id) {
+            return null;
+          }
+          return prev;
+        }),
+      );
+
+      fireAndForget(
+        set(configurationAtom, prevConfigs => {
+          const updatedConfigs = new Map(prevConfigs);
+          updatedConfigs.delete(id);
+          return updatedConfigs;
+        }),
+      );
+
+      fireAndForget(
+        set(schemaAtom, prevSchemas => {
+          const updatedSchemas = new Map(prevSchemas);
+          updatedSchemas.delete(id);
+          return updatedSchemas;
+        }),
+      );
+
+      fireAndForget(
+        set(allGraphSessionsAtom, prev => {
+          const updatedGraphs = new Map(prev);
+          updatedGraphs.delete(id);
+          return updatedGraphs;
+        }),
+      );
     }, []),
   );
 }
diff --git a/packages/graph-explorer/src/hooks/useExpandNode.test.ts b/packages/graph-explorer/src/hooks/useExpandNode.test.ts
index c15134deb..4f30a2a7a 100644
--- a/packages/graph-explorer/src/hooks/useExpandNode.test.ts
+++ b/packages/graph-explorer/src/hooks/useExpandNode.test.ts
@@ -29,8 +29,8 @@ describe("useDefaultNeighborExpansionLimit", () => {
       () => useDefaultNeighborExpansionLimit(),
       store => {
         dbState.applyTo(store);
-        store.set(defaultNeighborExpansionLimitAtom, 10);
-        store.set(defaultNeighborExpansionLimitEnabledAtom, true);
+        void store.set(defaultNeighborExpansionLimitAtom, 10);
+        void store.set(defaultNeighborExpansionLimitEnabledAtom, true);
       },
     );
 
@@ -61,8 +61,8 @@ describe("useDefaultNeighborExpansionLimit", () => {
       () => useDefaultNeighborExpansionLimit(),
       store => {
         dbState.applyTo(store);
-        store.set(defaultNeighborExpansionLimitEnabledAtom, true);
-        store.set(defaultNeighborExpansionLimitAtom, 10);
+        void store.set(defaultNeighborExpansionLimitEnabledAtom, true);
+        void store.set(defaultNeighborExpansionLimitAtom, 10);
       },
     );
 
@@ -78,7 +78,7 @@ describe("useDefaultNeighborExpansionLimit", () => {
       () => useDefaultNeighborExpansionLimit(),
       store => {
         dbState.applyTo(store);
-        store.set(defaultNeighborExpansionLimitEnabledAtom, false);
+        void store.set(defaultNeighborExpansionLimitEnabledAtom, false);
       },
     );
 
diff --git a/packages/graph-explorer/src/hooks/useSchemaSync.test.ts b/packages/graph-explorer/src/hooks/useSchemaSync.test.ts
index 51b2b7651..66980109b 100644
--- a/packages/graph-explorer/src/hooks/useSchemaSync.test.ts
+++ b/packages/graph-explorer/src/hooks/useSchemaSync.test.ts
@@ -59,9 +59,9 @@ describe("useSchemaSync", () => {
       return renderHookWithJotai(
         () => useSchemaSync(),
         store => {
-          store.set(activeConfigurationAtom, null);
-          store.set(configurationAtom, new Map());
-          store.set(schemaAtom, new Map());
+          void store.set(activeConfigurationAtom, null);
+          void store.set(configurationAtom, new Map());
+          void store.set(schemaAtom, new Map());
           store.set(explorerForTestingAtom, explorer);
         },
       );
@@ -456,12 +456,12 @@ describe("useSchemaSync", () => {
       // Switch to a new connection with no schema
       const store = getAppStore();
       const newConfig = createRandomRawConfiguration();
-      store.set(configurationAtom, prev => {
+      void store.set(configurationAtom, prev => {
         const updated = new Map(prev);
         updated.set(newConfig.id, newConfig);
         return updated;
       });
-      store.set(activeConfigurationAtom, newConfig.id);
+      void store.set(activeConfigurationAtom, newConfig.id);
 
       rerender();
 
diff --git a/packages/graph-explorer/src/hooks/useTextTransform.test.ts b/packages/graph-explorer/src/hooks/useTextTransform.test.ts
index b5215b68b..41090256a 100644
--- a/packages/graph-explorer/src/hooks/useTextTransform.test.ts
+++ b/packages/graph-explorer/src/hooks/useTextTransform.test.ts
@@ -28,11 +28,11 @@ 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]]));
+  void store.set(configurationAtom, new Map([[config.id, config]]));
+  void store.set(schemaAtom, new Map([[config.id, schema]]));
 
   // Make config active
-  store.set(activeConfigurationAtom, config.id);
+  void store.set(activeConfigurationAtom, config.id);
 }
 
 describe("useTextTransform", () => {
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..ace52f23a 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 { fireAndForget, logger } from "@/utils";
 
 function ConnectionRow({
   connection,
@@ -67,7 +67,7 @@ function useSetActiveConfigCallback(configId: ConfigurationId) {
     useCallback(
       (_get, set) => {
         logger.debug("Setting active connection to", configId);
-        set(activeConfigurationAtom, configId);
+        fireAndForget(set(activeConfigurationAtom, configId));
         resetState();
       },
       [configId, resetState],
diff --git a/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts b/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts
index 8c007ed66..30f9151f6 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 { fireAndForget } from "@/utils";
 import { fromFileToJson } from "@/utils/fileData";
 import { parseConnectionFile } from "@/utils/parseConnectionFile";
 
@@ -29,21 +30,25 @@ export function useImportConnectionFile() {
 
         // Create new id to avoid collisions
         const newId = createNewConfigurationId();
-        set(configurationAtom, prevConfig => {
-          const updatedConfig = new Map(prevConfig);
-          updatedConfig.set(newId, {
-            id: newId,
-            displayLabel: parsedFile.displayLabel,
-            connection: parsedFile.connection,
-          });
-          return updatedConfig;
-        });
-        set(schemaAtom, prevSchema => {
-          const updatedSchema = new Map(prevSchema);
-          updatedSchema.set(newId, parsedFile.schema);
-          return updatedSchema;
-        });
-        set(activeConfigurationAtom, newId);
+        fireAndForget(
+          set(configurationAtom, prevConfig => {
+            const updatedConfig = new Map(prevConfig);
+            updatedConfig.set(newId, {
+              id: newId,
+              displayLabel: parsedFile.displayLabel,
+              connection: parsedFile.connection,
+            });
+            return updatedConfig;
+          }),
+        );
+        fireAndForget(
+          set(schemaAtom, prevSchema => {
+            const updatedSchema = new Map(prevSchema);
+            updatedSchema.set(newId, parsedFile.schema);
+            return updatedSchema;
+          }),
+        );
+        fireAndForget(set(activeConfigurationAtom, newId));
 
         resetState();
       },
diff --git a/packages/graph-explorer/src/modules/CreateConnection/CreateConnection.tsx b/packages/graph-explorer/src/modules/CreateConnection/CreateConnection.tsx
index 637a0dc26..f26d0b25d 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 { fireAndForget, formatDate, logger } from "@/utils";
 import {
   DEFAULT_FETCH_TIMEOUT,
   DEFAULT_NODE_EXPAND_LIMIT,
@@ -117,32 +117,36 @@ const CreateConnection = ({
             connection: mapToConnection(data),
           };
           logger.log("Saving new connection", { newConfigId, newConfig });
-          set(configurationAtom, prevConfigMap => {
-            const updatedConfig = new Map(prevConfigMap);
-            updatedConfig.set(newConfigId, newConfig);
-            return updatedConfig;
-          });
-          set(activeConfigurationAtom, newConfigId);
+          fireAndForget(
+            set(configurationAtom, prevConfigMap => {
+              const updatedConfig = new Map(prevConfigMap);
+              updatedConfig.set(newConfigId, newConfig);
+              return updatedConfig;
+            }),
+          );
+          fireAndForget(set(activeConfigurationAtom, newConfigId));
           return;
         }
 
-        set(configurationAtom, prev => {
-          const updated = new Map(prev);
-          const currentConfig = updated.get(configId);
-          const updatedConfig: RawConfiguration = {
-            ...currentConfig,
-            id: configId,
-            displayLabel: data.name,
-            connection: mapToConnection(data),
-          };
-          logger.log("Updating existing connection", {
-            configId,
-            currentConfig,
-            updatedConfig,
-          });
-          updated.set(configId, updatedConfig);
-          return updated;
-        });
+        fireAndForget(
+          set(configurationAtom, prev => {
+            const updated = new Map(prev);
+            const currentConfig = updated.get(configId);
+            const updatedConfig: RawConfiguration = {
+              ...currentConfig,
+              id: configId,
+              displayLabel: data.name,
+              connection: mapToConnection(data),
+            };
+            logger.log("Updating existing connection", {
+              configId,
+              currentConfig,
+              updatedConfig,
+            });
+            updated.set(configId, updatedConfig);
+            return updated;
+          }),
+        );
 
         const urlChange = initialData?.url !== data.url;
         const dbUrlChange = initialData?.graphDbUrl !== data.graphDbUrl;
@@ -155,19 +159,23 @@ const CreateConnection = ({
           );
 
           // Force a sync of the schema by deleting the existing schema cache, which is now invalid
-          set(schemaAtom, prevSchemaMap => {
-            const updatedSchema = new Map(prevSchemaMap);
-            updatedSchema.delete(configId);
-            return updatedSchema;
-          });
+          fireAndForget(
+            set(schemaAtom, prevSchemaMap => {
+              const updatedSchema = new Map(prevSchemaMap);
+              updatedSchema.delete(configId);
+              return updatedSchema;
+            }),
+          );
 
           // Delete previous session data
-          set(allGraphSessionsAtom, prev => {
-            const updatedGraphs = new Map(prev);
-            logger.log("Deleting previous graph session");
-            updatedGraphs.delete(configId);
-            return updatedGraphs;
-          });
+          fireAndForget(
+            set(allGraphSessionsAtom, prev => {
+              const updatedGraphs = new Map(prev);
+              logger.log("Deleting previous graph session");
+              updatedGraphs.delete(configId);
+              return updatedGraphs;
+            }),
+          );
 
           // 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..efec82856 100644
--- a/packages/graph-explorer/src/modules/EdgesStyling/SingleEdgeStyling.tsx
+++ b/packages/graph-explorer/src/modules/EdgesStyling/SingleEdgeStyling.tsx
@@ -4,7 +4,7 @@ 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 { fireAndForget, LABELS } from "@/utils";
 
 import { useOpenEdgeStyleDialog } from "./EdgeStyleDialog";
 
@@ -30,7 +30,7 @@ export default function SingleEdgeStyling({
     if (prevDisplayAs === null || prevDisplayAs === debouncedDisplayAs) {
       return;
     }
-    setEdgeStyle({ displayLabel: debouncedDisplayAs });
+    fireAndForget(setEdgeStyle({ displayLabel: debouncedDisplayAs }));
   }, [debouncedDisplayAs, prevDisplayAs, setEdgeStyle]);
 
   return (
diff --git a/packages/graph-explorer/src/modules/GraphViewer/internalComponents/ContextMenu.tsx b/packages/graph-explorer/src/modules/GraphViewer/internalComponents/ContextMenu.tsx
index c37d28246..344b56ddf 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, fireAndForget } from "@/utils";
 
 import { useGraphSelection } from "../useGraphSelection";
 
@@ -111,7 +111,9 @@ function SingleVertexMenu({ vertexId }: { vertexId: VertexId }) {
     });
 
   const openSidebarPanel = (panelName: SidebarItems) => () => {
-    setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName }));
+    fireAndForget(
+      setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName })),
+    );
     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 }));
+    fireAndForget(
+      setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName })),
+    );
     replaceGraphSelection({ edges: [edgeId], disableSideEffects: true });
   };
 
diff --git a/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts b/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
index fdd2f5337..292d0e84f 100644
--- a/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
+++ b/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
@@ -1,19 +1,22 @@
 import { useSetAtom } from "jotai";
 
 import { userLayoutAtom } from "@/core";
+import { fireAndForget } from "@/utils";
 
 export function useAutoOpenDetailsSidebar() {
   const setUserLayout = useSetAtom(userLayoutAtom);
   return () => {
-    setUserLayout(prev => {
-      if (prev.detailsAutoOpenOnSelection !== true) {
-        return prev;
-      }
+    fireAndForget(
+      setUserLayout(prev => {
+        if (prev.detailsAutoOpenOnSelection !== true) {
+          return prev;
+        }
 
-      return {
-        ...prev,
-        activeSidebarItem: "details",
-      };
-    });
+        return {
+          ...prev,
+          activeSidebarItem: "details",
+        };
+      }),
+    );
   };
 }
diff --git a/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx b/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx
index 0a4495902..15e026d93 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 { fireAndForget } from "@/utils";
 
 type PrefixForm = {
   prefix: string;
@@ -171,21 +172,23 @@ function useDeletePrefixCallback(prefix: string) {
           return;
         }
 
-        set(schemaAtom, prevSchemas => {
-          const updatedSchemas = new Map(prevSchemas);
-          const activeSchema = updatedSchemas.get(activeConfigId);
+        fireAndForget(
+          set(schemaAtom, prevSchemas => {
+            const updatedSchemas = new Map(prevSchemas);
+            const activeSchema = updatedSchemas.get(activeConfigId);
 
-          updatedSchemas.set(activeConfigId, {
-            ...activeSchema,
-            vertices: activeSchema?.vertices || [],
-            edges: activeSchema?.edges || [],
-            prefixes: (activeSchema?.prefixes || []).filter(
-              prefixConfig => prefixConfig.prefix !== prefix,
-            ),
-          });
+            updatedSchemas.set(activeConfigId, {
+              ...activeSchema,
+              vertices: activeSchema?.vertices || [],
+              edges: activeSchema?.edges || [],
+              prefixes: (activeSchema?.prefixes || []).filter(
+                prefixConfig => prefixConfig.prefix !== prefix,
+              ),
+            });
 
-          return updatedSchemas;
-        });
+            return updatedSchemas;
+          }),
+        );
       },
       [prefix],
     ),
@@ -222,22 +225,24 @@ function EditPrefixModal({
           return;
         }
 
-        set(schemaAtom, prevSchemas => {
-          const updatedSchemas = new Map(prevSchemas);
-          const activeSchema = updatedSchemas.get(configId);
+        fireAndForget(
+          set(schemaAtom, prevSchemas => {
+            const updatedSchemas = new Map(prevSchemas);
+            const activeSchema = updatedSchemas.get(configId);
 
-          updatedSchemas.set(configId, {
-            ...activeSchema,
-            vertices: activeSchema?.vertices || [],
-            edges: activeSchema?.edges || [],
-            prefixes: [
-              ...(activeSchema?.prefixes || []),
-              { prefix: prefix as RdfPrefix, uri: uri as IriNamespace },
-            ],
-          });
+            updatedSchemas.set(configId, {
+              ...activeSchema,
+              vertices: activeSchema?.vertices || [],
+              edges: activeSchema?.edges || [],
+              prefixes: [
+                ...(activeSchema?.prefixes || []),
+                { prefix: prefix as RdfPrefix, uri: uri as IriNamespace },
+              ],
+            });
 
-          return updatedSchemas;
-        });
+            return updatedSchemas;
+          }),
+        );
       },
       [configId],
     ),
diff --git a/packages/graph-explorer/src/modules/NodesStyling/NodeStyleDialog.tsx b/packages/graph-explorer/src/modules/NodesStyling/NodeStyleDialog.tsx
index 78073c414..47f69584f 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 { fireAndForget, parseNumberSafely } from "@/utils";
 import {
   RESERVED_ID_PROPERTY,
   RESERVED_TYPES_PROPERTY,
@@ -119,7 +119,9 @@ function Content({ vertexType }: { vertexType: VertexType }) {
     }
     try {
       const result = await file2Base64(file);
-      setVertexStyle({ iconUrl: result, iconImageType: file.type });
+      fireAndForget(
+        setVertexStyle({ iconUrl: result, iconImageType: file.type }),
+      );
     } catch (error) {
       console.error("Unable to convert uploaded image to base64: ", error);
       toast.error("Invalid file", {
@@ -219,7 +221,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..1de824102 100644
--- a/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
+++ b/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
@@ -4,6 +4,7 @@ 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 { fireAndForget } from "@/utils";
 import { LABELS } from "@/utils/constants";
 
 import { useOpenNodeStyleDialog } from "./NodeStyleDialog";
@@ -31,7 +32,7 @@ export default function SingleNodeStyling({
     if (prevDisplayAs === null || prevDisplayAs === debouncedDisplayAs) {
       return;
     }
-    setVertexStyle({ displayLabel: debouncedDisplayAs });
+    fireAndForget(setVertexStyle({ displayLabel: debouncedDisplayAs }));
   }, [debouncedDisplayAs, prevDisplayAs, setVertexStyle]);
 
   return (
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/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/useKeywordSearch.test.ts b/packages/graph-explorer/src/modules/SearchSidebar/useKeywordSearch.test.ts
index a09964963..374747330 100644
--- a/packages/graph-explorer/src/modules/SearchSidebar/useKeywordSearch.test.ts
+++ b/packages/graph-explorer/src/modules/SearchSidebar/useKeywordSearch.test.ts
@@ -31,10 +31,10 @@ function initializeConfigWithQueryEngine(queryEngine: QueryEngine) {
     const config = createRandomRawConfiguration();
     config.connection!.queryEngine = queryEngine;
 
-    store.set(configurationAtom, new Map([[config.id, config]]));
+    void store.set(configurationAtom, new Map([[config.id, config]]));
 
     // Make config active
-    store.set(activeConfigurationAtom, config.id);
+    void store.set(activeConfigurationAtom, config.id);
   };
 }
 
@@ -136,11 +136,11 @@ describe("useKeywordSearch", () => {
         dataType: "String",
       });
 
-      store.set(configurationAtom, new Map([[config.id, config]]));
-      store.set(schemaAtom, new Map([[config.id, schema]]));
+      void store.set(configurationAtom, new Map([[config.id, config]]));
+      void store.set(schemaAtom, new Map([[config.id, schema]]));
 
       // Make config active
-      store.set(activeConfigurationAtom, config.id);
+      void store.set(activeConfigurationAtom, config.id);
     }
 
     it("Should default to precision match exact", () => {
diff --git a/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx b/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx
index 43ed056f9..7d0bfcec6 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 { fireAndForget } 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,15 @@ function DisplayNameAndDescriptionOptions({
   const onDisplayNameChange =
     (field: "name" | "longName") => (value: string | string[]) => {
       if (field === "name") {
-        setPreferences({ displayNameAttribute: value as string });
+        fireAndForget(
+          setPreferences({ displayNameAttribute: value as string }),
+        );
       }
 
       if (field === "longName") {
-        setPreferences({ longDisplayNameAttribute: value as string });
+        fireAndForget(
+          setPreferences({ longDisplayNameAttribute: value as string }),
+        );
       }
     };
 
diff --git a/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx b/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx
index 451011b7a..7ea6b1921 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 { fireAndForget } from "@/utils";
 
 import LoadConfigButton from "./LoadConfigButton";
 
@@ -59,7 +60,9 @@ export default function SettingsGeneral() {
           value="defaultNeighborExpansionLimitEnabled"
           checked={defaultNeighborExpansionLimitEnabled}
           onCheckedChange={isSelected => {
-            setDefaultNeighborExpansionLimitEnabled(Boolean(isSelected));
+            fireAndForget(
+              setDefaultNeighborExpansionLimitEnabled(Boolean(isSelected)),
+            );
           }}
         />
         <AnimatePresence initial={false}>
@@ -116,7 +119,7 @@ export default function SettingsGeneral() {
           value="isDiagnosticLoggingEnabled"
           checked={diagnosticLogging}
           onCheckedChange={isSelected => {
-            setDiagnosticLogging(Boolean(isSelected));
+            fireAndForget(setDiagnosticLogging(Boolean(isSelected)));
           }}
           label="Diagnostic logging"
           description="Enables verbose logging to the browser console for troubleshooting."
@@ -127,7 +130,7 @@ export default function SettingsGeneral() {
           value="isLoggingDbQueryEnabled"
           checked={allowLoggingDbQuery}
           onCheckedChange={isSelected => {
-            setAllowLoggingDbQuery(Boolean(isSelected));
+            fireAndForget(setAllowLoggingDbQuery(Boolean(isSelected)));
           }}
           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 +148,7 @@ export default function SettingsGeneral() {
             value="isDebugOptionsEnabled"
             checked={isDebugOptionsEnabled}
             onCheckedChange={isSelected => {
-              setIsDebugOptionsEnabled(Boolean(isSelected));
+              fireAndForget(setIsDebugOptionsEnabled(Boolean(isSelected)));
             }}
             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/fireAndForget.test.ts b/packages/graph-explorer/src/utils/fireAndForget.test.ts
new file mode 100644
index 000000000..a015e32b4
--- /dev/null
+++ b/packages/graph-explorer/src/utils/fireAndForget.test.ts
@@ -0,0 +1,26 @@
+import { fireAndForget } from "./fireAndForget";
+import logger from "./logger";
+
+vi.mock("./logger", () => ({
+  default: {
+    error: vi.fn(),
+  },
+}));
+
+describe("fireAndForget", () => {
+  it("logs the error when the promise rejects", async () => {
+    const error = new Error("persist failed");
+
+    fireAndForget(Promise.reject(error));
+    await vi.waitFor(() => {
+      expect(logger.error).toHaveBeenCalledWith(error);
+    });
+  });
+
+  it("does not log anything when the promise resolves", async () => {
+    fireAndForget(Promise.resolve());
+    await Promise.resolve();
+
+    expect(logger.error).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/graph-explorer/src/utils/fireAndForget.ts b/packages/graph-explorer/src/utils/fireAndForget.ts
new file mode 100644
index 000000000..8cada8c45
--- /dev/null
+++ b/packages/graph-explorer/src/utils/fireAndForget.ts
@@ -0,0 +1,17 @@
+import logger from "./logger";
+
+/**
+ * Explicitly ignores a promise whose result the caller does not await, while
+ * still observing failures by logging them.
+ *
+ * Use this for intentional fire-and-forget work where a rejection should not be
+ * silently swallowed — most notably background persistence writes (see
+ * `atomWithLocalForage`), which resolve synchronously in memory but may reject
+ * when the durable write fails. For promises whose rejection is genuinely inert
+ * (e.g. an aborted navigation), prefer the bare `void` operator instead.
+ */
+export function fireAndForget(promise: Promise<unknown>) {
+  promise.catch(error => {
+    logger.error(error);
+  });
+}
diff --git a/packages/graph-explorer/src/utils/index.ts b/packages/graph-explorer/src/utils/index.ts
index 44fef6c49..df0ac3fed 100644
--- a/packages/graph-explorer/src/utils/index.ts
+++ b/packages/graph-explorer/src/utils/index.ts
@@ -6,6 +6,7 @@ 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 { fireAndForget } from "./fireAndForget";
 export { default as logger } from "./logger";
 export * from "./branded";
 export * from "./sanitizeQuery";
diff --git a/packages/graph-explorer/src/utils/testing/DbState.ts b/packages/graph-explorer/src/utils/testing/DbState.ts
index 52feadc3b..ba59948a0 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. */
+  /**
+   * Applies the state to the given Jotai store.
+   *
+   * The localForage-backed atom writes return background persistence promises
+   * that are intentionally ignored here — seeding test state does not care
+   * whether the value lands in durable storage.
+   */
   applyTo(store: AppStore) {
     // Config
-    store.set(
+    void store.set(
       configurationAtom,
       new Map([[this.activeConfig.id, this.activeConfig]]),
     );
     if (this._activeSchema) {
-      store.set(
+      void store.set(
         schemaAtom,
         new Map([[this.activeConfig.id, this._activeSchema]]),
       );
     } else {
-      store.set(schemaAtom, new Map());
+      void store.set(schemaAtom, new Map());
     }
-    store.set(activeConfigurationAtom, this.activeConfig.id);
+    void store.set(activeConfigurationAtom, this.activeConfig.id);
 
     // Styling
-    store.set(userStylingAtom, this.activeStyling);
+    void 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(
+    void 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");

From f9290f107cd5eacb92bb3d6119534c4b249f1098 Mon Sep 17 00:00:00 2001
From: Kris McGinnes <kmcginnes@me.com>
Date: Thu, 18 Jun 2026 19:03:57 -0500
Subject: [PATCH 2/8] Log ignored promise rejections at warn level with context

An explicitly-ignored rejection is non-blocking by construction, so warn
better reflects its severity than error. Prefix the log so a reader knows
the rejection came from a deliberately-unawaited promise.
---
 .kiro/skills/typescript/SKILL.md                      |  2 +-
 .../20260618-explicit-floating-promise-convention.md  |  2 +-
 .../graph-explorer/src/utils/fireAndForget.test.ts    | 11 +++++++----
 packages/graph-explorer/src/utils/fireAndForget.ts    |  2 +-
 4 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/.kiro/skills/typescript/SKILL.md b/.kiro/skills/typescript/SKILL.md
index caf93e4d2..c708f1a2a 100644
--- a/.kiro/skills/typescript/SKILL.md
+++ b/.kiro/skills/typescript/SKILL.md
@@ -16,7 +16,7 @@ description: TypeScript conventions and rules for Graph Explorer, including bran
 
 `typescript/no-floating-promises` is enabled as an error, so every unhandled promise must be marked explicitly. Pick the idiom by meaning:
 
-- **`fireAndForget(promise)`** (from `@/utils`) — when a rejection is meaningful and should be observed even though you don't await it. It attaches `.catch(logger.error)`. This is the idiom for persisted-atom setters (`atomWithLocalForage`-backed writes), where a failed durable write should be logged rather than silently dropped.
+- **`fireAndForget(promise)`** (from `@/utils`) — when a rejection is meaningful and should be observed even though you don't await it. It logs the rejection via `logger.warn` (warn, not error, since an ignored rejection is non-blocking). This is the idiom for persisted-atom setters (`atomWithLocalForage`-backed writes), where a failed durable write should be logged rather than silently dropped.
 - **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.
diff --git a/docs/adr/20260618-explicit-floating-promise-convention.md b/docs/adr/20260618-explicit-floating-promise-convention.md
index f7ee3165e..8cf29f17e 100644
--- a/docs/adr/20260618-explicit-floating-promise-convention.md
+++ b/docs/adr/20260618-explicit-floating-promise-convention.md
@@ -14,7 +14,7 @@ Until now `typescript/no-floating-promises` was off, so these reads as ordinary
 
 Turn on `typescript/no-floating-promises` (`error`) so every unhandled promise must be **explicitly** marked. Use one of two idioms by meaning:
 
-1. **`fireAndForget(promise)`** (`@/utils`) — attaches `.catch(logger.error)`. Use when a rejection is **meaningful and should be observed** even though the caller does not await it. This is the idiom for **persisted-atom setters**: a failed durable write gets logged rather than silently dropped, and the call sites stay greppable for follow-up auditing.
+1. **`fireAndForget(promise)`** (`@/utils`) — attaches a `.catch` that logs the rejection via `logger.warn` (warn, not error: an explicitly-ignored rejection is non-blocking by construction — the in-memory state already updated and nothing downstream awaits it). Use when a rejection is **meaningful and should be observed** even though the caller does not await it. This is the idiom for **persisted-atom setters**: a failed durable write gets logged rather than silently dropped, and the call sites stay greppable for follow-up auditing.
 
 2. **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).
 
diff --git a/packages/graph-explorer/src/utils/fireAndForget.test.ts b/packages/graph-explorer/src/utils/fireAndForget.test.ts
index a015e32b4..78199689e 100644
--- a/packages/graph-explorer/src/utils/fireAndForget.test.ts
+++ b/packages/graph-explorer/src/utils/fireAndForget.test.ts
@@ -3,17 +3,20 @@ import logger from "./logger";
 
 vi.mock("./logger", () => ({
   default: {
-    error: vi.fn(),
+    warn: vi.fn(),
   },
 }));
 
 describe("fireAndForget", () => {
-  it("logs the error when the promise rejects", async () => {
+  it("warns with the error when the promise rejects", async () => {
     const error = new Error("persist failed");
 
     fireAndForget(Promise.reject(error));
     await vi.waitFor(() => {
-      expect(logger.error).toHaveBeenCalledWith(error);
+      expect(logger.warn).toHaveBeenCalledWith(
+        "Ignored promise rejection:",
+        error,
+      );
     });
   });
 
@@ -21,6 +24,6 @@ describe("fireAndForget", () => {
     fireAndForget(Promise.resolve());
     await Promise.resolve();
 
-    expect(logger.error).not.toHaveBeenCalled();
+    expect(logger.warn).not.toHaveBeenCalled();
   });
 });
diff --git a/packages/graph-explorer/src/utils/fireAndForget.ts b/packages/graph-explorer/src/utils/fireAndForget.ts
index 8cada8c45..e647db5c4 100644
--- a/packages/graph-explorer/src/utils/fireAndForget.ts
+++ b/packages/graph-explorer/src/utils/fireAndForget.ts
@@ -12,6 +12,6 @@ import logger from "./logger";
  */
 export function fireAndForget(promise: Promise<unknown>) {
   promise.catch(error => {
-    logger.error(error);
+    logger.warn("Ignored promise rejection:", error);
   });
 }

From 964428537e0c89632b9da109252be90b2af7fdbb Mon Sep 17 00:00:00 2001
From: Kris McGinnes <kmcginnes@me.com>
Date: Thu, 18 Jun 2026 19:15:29 -0500
Subject: [PATCH 3/8] Replace fireAndForget wrapper with a logAndIgnore catch
 handler

Use `promise.catch(logAndIgnore)` instead of `fireAndForget(promise)`. The
catch-handler form reads left-to-right and avoids wrapping each call in an
extra paren and indent level, which is clearest for the multi-line setter
blocks. Behavior is unchanged: rejections are still logged at warn level.
---
 .kiro/skills/typescript/SKILL.md              |  2 +-
 ...18-explicit-floating-promise-convention.md | 10 +--
 .../src/components/utils/canvas/drawImage.ts  | 10 +--
 .../connector/queries/edgeConnectionsQuery.ts | 54 ++++++-------
 .../src/connector/queries/schemaSyncQuery.ts  | 56 +++++++------
 .../src/core/AppStatusLoader.tsx              | 20 +++--
 .../StateProvider/graphSession/storage.ts     |  6 +-
 .../src/core/StateProvider/schema.ts          | 36 ++++-----
 .../src/core/StateProvider/userLayout.ts      | 41 +++++-----
 .../src/hooks/useDeleteConfig.ts              | 58 ++++++--------
 .../AvailableConnections/ConnectionRow.tsx    |  4 +-
 .../useImportConnectionFile.ts                | 36 ++++-----
 .../CreateConnection/CreateConnection.tsx     | 78 +++++++++----------
 .../EdgesStyling/SingleEdgeStyling.tsx        |  4 +-
 .../internalComponents/ContextMenu.tsx        | 10 +--
 .../GraphViewer/useAutoOpenDetailsSidebar.ts  | 22 +++---
 .../src/modules/Namespaces/UserPrefixes.tsx   | 60 +++++++-------
 .../modules/NodesStyling/NodeStyleDialog.tsx  |  6 +-
 .../NodesStyling/SingleNodeStyling.tsx        |  4 +-
 .../src/routes/DataExplorer/DataExplorer.tsx  | 10 +--
 .../src/routes/Settings/SettingsGeneral.tsx   | 12 +--
 .../graph-explorer/src/utils/fireAndForget.ts | 17 ----
 packages/graph-explorer/src/utils/index.ts    |  2 +-
 ...AndForget.test.ts => logAndIgnore.test.ts} | 11 ++-
 .../graph-explorer/src/utils/logAndIgnore.ts  | 19 +++++
 25 files changed, 274 insertions(+), 314 deletions(-)
 delete mode 100644 packages/graph-explorer/src/utils/fireAndForget.ts
 rename packages/graph-explorer/src/utils/{fireAndForget.test.ts => logAndIgnore.test.ts} (62%)
 create mode 100644 packages/graph-explorer/src/utils/logAndIgnore.ts

diff --git a/.kiro/skills/typescript/SKILL.md b/.kiro/skills/typescript/SKILL.md
index c708f1a2a..43cb66a44 100644
--- a/.kiro/skills/typescript/SKILL.md
+++ b/.kiro/skills/typescript/SKILL.md
@@ -16,7 +16,7 @@ description: TypeScript conventions and rules for Graph Explorer, including bran
 
 `typescript/no-floating-promises` is enabled as an error, so every unhandled promise must be marked explicitly. Pick the idiom by meaning:
 
-- **`fireAndForget(promise)`** (from `@/utils`) — when a rejection is meaningful and should be observed even though you don't await it. It logs the rejection via `logger.warn` (warn, not error, since an ignored rejection is non-blocking). This is the idiom for persisted-atom setters (`atomWithLocalForage`-backed writes), where a failed durable write should be logged rather than silently dropped.
+- **`.catch(logAndIgnore)`** (`logAndIgnore` from `@/utils`) — when a rejection is meaningful and should be observed even though you don't await it. It logs the rejection via `logger.warn` (warn, not error, since an ignored rejection is non-blocking). This is the idiom for persisted-atom setters (`atomWithLocalForage`-backed writes), where a failed durable write should be logged rather than silently dropped.
 - **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.
diff --git a/docs/adr/20260618-explicit-floating-promise-convention.md b/docs/adr/20260618-explicit-floating-promise-convention.md
index 8cf29f17e..6e454562e 100644
--- a/docs/adr/20260618-explicit-floating-promise-convention.md
+++ b/docs/adr/20260618-explicit-floating-promise-convention.md
@@ -14,18 +14,18 @@ Until now `typescript/no-floating-promises` was off, so these reads as ordinary
 
 Turn on `typescript/no-floating-promises` (`error`) so every unhandled promise must be **explicitly** marked. Use one of two idioms by meaning:
 
-1. **`fireAndForget(promise)`** (`@/utils`) — attaches a `.catch` that logs the rejection via `logger.warn` (warn, not error: an explicitly-ignored rejection is non-blocking by construction — the in-memory state already updated and nothing downstream awaits it). Use when a rejection is **meaningful and should be observed** even though the caller does not await it. This is the idiom for **persisted-atom setters**: a failed durable write gets logged rather than silently dropped, and the call sites stay greppable for follow-up auditing.
+1. **`.catch(logAndIgnore)`** (`logAndIgnore` from `@/utils`) — a `.catch` handler that logs the rejection via `logger.warn` (warn, not error: an explicitly-ignored rejection is non-blocking by construction — the in-memory state already updated and nothing downstream awaits it). Use when a rejection is **meaningful and should be observed** even though the caller does not await it. This is the idiom for **persisted-atom setters**: a failed durable write gets logged rather than silently dropped, and the call sites stay greppable for follow-up auditing.
 
 2. **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).
 
-The reconciliation contract for user-facing persistence errors (reject + surface a toast) is a **separate, in-flight effort** on the persistence branch. This ADR deliberately does **not** change the runtime behavior of persisted setters — it only makes the existing fire-and-forget explicit. When the toast contract lands, the `fireAndForget`-wrapped userStyling call sites are the ones to revisit toward a handled-reject form.
+The reconciliation contract for user-facing persistence errors (reject + surface a toast) is a **separate, in-flight effort** on the persistence branch. This ADR deliberately does **not** change the runtime behavior of persisted setters — it only makes the existing fire-and-forget explicit. When the toast contract lands, the `logAndIgnore`-handled userStyling call sites are the ones to revisit toward a handled-reject form.
 
 ### Alternatives considered
 
-**Centralize the `.catch` inside `atomWithLocalForage` and return `void`.** The writer atom could attach its own `.catch(logger.error)` and return `void`, deleting most of the ~25 `fireAndForget(set(...))` wrappers 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.
+**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 logged (`fireAndForget`) or a deliberate, reviewed `void` — no longer invisible.
-- Reviewers have a clear rule: meaningful-but-unawaited → `fireAndForget`; inert → `void`.
+- A swallowed persistence error is now either logged (`.catch(logAndIgnore)`) or a deliberate, reviewed `void` — no longer invisible.
+- Reviewers have a clear rule: meaningful-but-unawaited → `.catch(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/utils/canvas/drawImage.ts b/packages/graph-explorer/src/components/utils/canvas/drawImage.ts
index d0979b245..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, fireAndForget } from "@/utils";
+import { env, logAndIgnore } from "@/utils";
 
 import type { BoundingBox } from "./types";
 
@@ -104,8 +104,8 @@ const drawImage = (
 
   if (src.match(/\.svg$/i)) {
     IMAGES_PENDING.add(`${src}::${color || "default"}`);
-    fireAndForget(
-      fetchIcon(src).then(icon => {
+    fetchIcon(src)
+      .then(icon => {
         IMAGES_PENDING.delete(`${src}::${color || "default"}`);
 
         let iconSrc = icon;
@@ -119,8 +119,8 @@ const drawImage = (
 
         createImage(iconSrc);
         context.restore();
-      }),
-    );
+      })
+      .catch(logAndIgnore);
 
     return;
   }
diff --git a/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.ts b/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.ts
index 8a00ee7e4..bb5b5ad86 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 { fireAndForget, logger } from "@/utils";
+import { logAndIgnore, logger } from "@/utils";
 
 import { getExplorer, getStore } from "./helpers";
 import { schemaSyncQueryKey } from "./schemaSyncQuery";
@@ -90,21 +90,19 @@ const setEdgeConnectionsAtom = atom(
     if (!activeConfigId) {
       return;
     }
-    fireAndForget(
-      set(schemaAtom, prev => {
-        const activeSchema = prev.get(activeConfigId);
-        if (!activeSchema) {
-          return prev;
-        }
-        const updated = new Map(prev);
-        updated.set(activeConfigId, {
-          ...activeSchema,
-          edgeConnections,
-          lastEdgeConnectionSyncFail: false,
-        });
-        return updated;
-      }),
-    );
+    set(schemaAtom, prev => {
+      const activeSchema = prev.get(activeConfigId);
+      if (!activeSchema) {
+        return prev;
+      }
+      const updated = new Map(prev);
+      updated.set(activeConfigId, {
+        ...activeSchema,
+        edgeConnections,
+        lastEdgeConnectionSyncFail: false,
+      });
+      return updated;
+    }).catch(logAndIgnore);
   },
 );
 
@@ -116,17 +114,15 @@ const setEdgeConnectionSyncFailedAtom = atom(null, (get, set) => {
     return;
   }
 
-  fireAndForget(
-    set(schemaAtom, prev => {
-      const existing = prev.get(id);
-      const updated = new Map(prev);
-      updated.set(id, {
-        ...existing,
-        vertices: existing?.vertices ?? [],
-        edges: existing?.edges ?? [],
-        lastEdgeConnectionSyncFail: true,
-      });
-      return updated;
-    }),
-  );
+  set(schemaAtom, prev => {
+    const existing = prev.get(id);
+    const updated = new Map(prev);
+    updated.set(id, {
+      ...existing,
+      vertices: existing?.vertices ?? [],
+      edges: existing?.edges ?? [],
+      lastEdgeConnectionSyncFail: true,
+    });
+    return updated;
+  }).catch(logAndIgnore);
 });
diff --git a/packages/graph-explorer/src/connector/queries/schemaSyncQuery.ts b/packages/graph-explorer/src/connector/queries/schemaSyncQuery.ts
index c8cb33a47..308153acd 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 { fireAndForget, logger } from "@/utils";
+import { logAndIgnore, logger } from "@/utils";
 
 import type { SchemaResponse } from "../useGEFetchTypes";
 
@@ -84,24 +84,22 @@ const replaceSchemaAtom = atom(
       return;
     }
 
-    fireAndForget(
-      set(schemaAtom, prev => {
-        const updated = new Map(prev);
-        updated.set(id, {
-          ...schema,
-          prefixes,
+    set(schemaAtom, prev => {
+      const updated = new Map(prev);
+      updated.set(id, {
+        ...schema,
+        prefixes,
 
-          // Reset edge connection information during schema sync
-          edgeConnections: undefined,
-          lastEdgeConnectionSyncFail: false,
+        // Reset edge connection information during schema sync
+        edgeConnections: undefined,
+        lastEdgeConnectionSyncFail: false,
 
-          // Mark as completed successfully
-          lastUpdate: new Date(),
-          lastSyncFail: false,
-        });
-        return updated;
-      }),
-    );
+        // Mark as completed successfully
+        lastUpdate: new Date(),
+        lastSyncFail: false,
+      });
+      return updated;
+    }).catch(logAndIgnore);
   },
 );
 
@@ -113,17 +111,15 @@ const setSyncFailedAtom = atom(null, (get, set) => {
     return;
   }
 
-  fireAndForget(
-    set(schemaAtom, prev => {
-      const existing = prev.get(id);
-      const updated = new Map(prev);
-      updated.set(id, {
-        ...existing,
-        vertices: existing?.vertices ?? [],
-        edges: existing?.edges ?? [],
-        lastSyncFail: true,
-      });
-      return updated;
-    }),
-  );
+  set(schemaAtom, prev => {
+    const existing = prev.get(id);
+    const updated = new Map(prev);
+    updated.set(id, {
+      ...existing,
+      vertices: existing?.vertices ?? [],
+      edges: existing?.edges ?? [],
+      lastSyncFail: true,
+    });
+    return updated;
+  }).catch(logAndIgnore);
 });
diff --git a/packages/graph-explorer/src/core/AppStatusLoader.tsx b/packages/graph-explorer/src/core/AppStatusLoader.tsx
index 74964db33..f97136102 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 { fireAndForget, logger } from "@/utils";
+import { logAndIgnore, logger } from "@/utils";
 
 import { fetchDefaultConnection } from "./defaultConnection";
 import { activeConfigurationAtom, configurationAtom } from "./StateProvider";
@@ -48,16 +48,14 @@ function LoadDefaultConfig({ children }: PropsWithChildren) {
 
     startTransition(() => {
       logger.debug("Adding default connections", defaultConnectionConfigs);
-      fireAndForget(
-        setConfiguration(prev => {
-          const updatedConfig = new Map(prev);
-          defaultConnectionConfigs.forEach(config => {
-            updatedConfig.set(config.id, config);
-          });
-          return updatedConfig;
-        }),
-      );
-      fireAndForget(setActiveConfig(defaultConnectionConfigs[0].id));
+      setConfiguration(prev => {
+        const updatedConfig = new Map(prev);
+        defaultConnectionConfigs.forEach(config => {
+          updatedConfig.set(config.id, config);
+        });
+        return updatedConfig;
+      }).catch(logAndIgnore);
+      setActiveConfig(defaultConnectionConfigs[0].id).catch(logAndIgnore);
     });
   }, [
     activeConfig,
diff --git a/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts b/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts
index f36c9bce6..0e515921b 100644
--- a/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts
+++ b/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts
@@ -2,7 +2,7 @@ import { atom } from "jotai";
 import { atomWithReset, RESET } from "jotai/utils";
 
 import { activeConfigurationAtom, allGraphSessionsAtom } from "@/core";
-import { fireAndForget } from "@/utils";
+import { logAndIgnore } from "@/utils";
 
 import type { EdgeId, VertexId } from "../../entities";
 
@@ -40,11 +40,11 @@ export const activeGraphSessionAtom = atom(
     // Delete the active graph if we receive a default value
     if (newValue === RESET || !newValue) {
       newGraphs.delete(connectionId);
-      fireAndForget(set(allGraphSessionsAtom, newGraphs));
+      set(allGraphSessionsAtom, newGraphs).catch(logAndIgnore);
       return;
     }
 
     newGraphs.set(connectionId, newValue);
-    fireAndForget(set(allGraphSessionsAtom, newGraphs));
+    set(allGraphSessionsAtom, newGraphs).catch(logAndIgnore);
   },
 );
diff --git a/packages/graph-explorer/src/core/StateProvider/schema.ts b/packages/graph-explorer/src/core/StateProvider/schema.ts
index 9cba4942a..c9599379f 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 { fireAndForget, logger } from "@/utils";
+import { logAndIgnore, logger } from "@/utils";
 import { generatePrefixes, PrefixLookup } from "@/utils/rdf";
 
 import { nodesAtom, toNodeMap } from "./nodes";
@@ -254,30 +254,28 @@ export const activeSchemaSelector = atom(
     if (!schemaId) {
       return;
     }
-    fireAndForget(
-      set(schemaAtom, prevSchemaMap => {
-        const prev = prevSchemaMap.get(schemaId);
-        const newValue = typeof update === "function" ? update(prev) : update;
+    set(schemaAtom, prevSchemaMap => {
+      const prev = prevSchemaMap.get(schemaId);
+      const newValue = typeof update === "function" ? update(prev) : update;
 
-        if (newValue === prev) {
-          return prevSchemaMap;
-        }
+      if (newValue === prev) {
+        return prevSchemaMap;
+      }
 
-        const updatedSchemaMap = new Map(prevSchemaMap);
+      const updatedSchemaMap = new Map(prevSchemaMap);
 
-        if (newValue === RESET || !newValue) {
-          if (!prev) {
-            return prevSchemaMap;
-          }
-          updatedSchemaMap.delete(schemaId);
-          return updatedSchemaMap;
+      if (newValue === RESET || !newValue) {
+        if (!prev) {
+          return prevSchemaMap;
         }
+        updatedSchemaMap.delete(schemaId);
+        return updatedSchemaMap;
+      }
 
-        updatedSchemaMap.set(schemaId, newValue);
+      updatedSchemaMap.set(schemaId, newValue);
 
-        return updatedSchemaMap;
-      }),
-    );
+      return updatedSchemaMap;
+    }).catch(logAndIgnore);
   },
 );
 
diff --git a/packages/graph-explorer/src/core/StateProvider/userLayout.ts b/packages/graph-explorer/src/core/StateProvider/userLayout.ts
index 2c8243c88..9ffdff319 100644
--- a/packages/graph-explorer/src/core/StateProvider/userLayout.ts
+++ b/packages/graph-explorer/src/core/StateProvider/userLayout.ts
@@ -1,6 +1,6 @@
 import { useAtom } from "jotai";
 
-import { fireAndForget } from "@/utils";
+import { logAndIgnore } from "@/utils";
 
 import { useQueryEngine } from "../connector";
 import { userLayoutAtom } from "./storageAtoms";
@@ -94,15 +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) =>
-    fireAndForget(
-      setUserLayout(prev => {
-        return {
-          ...prev,
-          activeSidebarItem: prev.activeSidebarItem === item ? null : item,
-        };
-      }),
-    );
+  const toggleSidebar = (item: SidebarItems) => {
+    setUserLayout(prev => {
+      return {
+        ...prev,
+        activeSidebarItem: prev.activeSidebarItem === item ? null : item,
+      };
+    }).catch(logAndIgnore);
+  };
 
   return {
     activeSidebarItem,
@@ -120,18 +119,16 @@ export function useSidebarSize() {
 
   /** Sets the sidebar width to the current width + the given delta */
   const setSidebarWidth = (deltaWidth: number) => {
-    fireAndForget(
-      setUserLayout(prev => {
-        const prevWidth = prev.sidebar?.width ?? DEFAULT_SIDEBAR_WIDTH;
-        return {
-          ...prev,
-          sidebar: {
-            ...prev.sidebar,
-            width: prevWidth + deltaWidth,
-          },
-        };
-      }),
-    );
+    setUserLayout(prev => {
+      const prevWidth = prev.sidebar?.width ?? DEFAULT_SIDEBAR_WIDTH;
+      return {
+        ...prev,
+        sidebar: {
+          ...prev.sidebar,
+          width: prevWidth + deltaWidth,
+        },
+      };
+    }).catch(logAndIgnore);
   };
 
   return [sidebarWidth, setSidebarWidth] as const;
diff --git a/packages/graph-explorer/src/hooks/useDeleteConfig.ts b/packages/graph-explorer/src/hooks/useDeleteConfig.ts
index 827ba5f87..cfc8143b3 100644
--- a/packages/graph-explorer/src/hooks/useDeleteConfig.ts
+++ b/packages/graph-explorer/src/hooks/useDeleteConfig.ts
@@ -9,44 +9,36 @@ import {
   type ConfigurationId,
   schemaAtom,
 } from "@/core";
-import { fireAndForget, logger } from "@/utils";
+import { logAndIgnore, logger } from "@/utils";
 
 export function useDeleteConfig() {
   return useAtomCallback(
     useCallback((_get, set, id: ConfigurationId) => {
       logger.log("Deleting connection:", id);
-      fireAndForget(
-        set(activeConfigurationAtom, prev => {
-          if (prev === id) {
-            return null;
-          }
-          return prev;
-        }),
-      );
-
-      fireAndForget(
-        set(configurationAtom, prevConfigs => {
-          const updatedConfigs = new Map(prevConfigs);
-          updatedConfigs.delete(id);
-          return updatedConfigs;
-        }),
-      );
-
-      fireAndForget(
-        set(schemaAtom, prevSchemas => {
-          const updatedSchemas = new Map(prevSchemas);
-          updatedSchemas.delete(id);
-          return updatedSchemas;
-        }),
-      );
-
-      fireAndForget(
-        set(allGraphSessionsAtom, prev => {
-          const updatedGraphs = new Map(prev);
-          updatedGraphs.delete(id);
-          return updatedGraphs;
-        }),
-      );
+      set(activeConfigurationAtom, prev => {
+        if (prev === id) {
+          return null;
+        }
+        return prev;
+      }).catch(logAndIgnore);
+
+      set(configurationAtom, prevConfigs => {
+        const updatedConfigs = new Map(prevConfigs);
+        updatedConfigs.delete(id);
+        return updatedConfigs;
+      }).catch(logAndIgnore);
+
+      set(schemaAtom, prevSchemas => {
+        const updatedSchemas = new Map(prevSchemas);
+        updatedSchemas.delete(id);
+        return updatedSchemas;
+      }).catch(logAndIgnore);
+
+      set(allGraphSessionsAtom, prev => {
+        const updatedGraphs = new Map(prev);
+        updatedGraphs.delete(id);
+        return updatedGraphs;
+      }).catch(logAndIgnore);
     }, []),
   );
 }
diff --git a/packages/graph-explorer/src/modules/AvailableConnections/ConnectionRow.tsx b/packages/graph-explorer/src/modules/AvailableConnections/ConnectionRow.tsx
index ace52f23a..0a2a997de 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 { fireAndForget, logger } from "@/utils";
+import { logAndIgnore, logger } from "@/utils";
 
 function ConnectionRow({
   connection,
@@ -67,7 +67,7 @@ function useSetActiveConfigCallback(configId: ConfigurationId) {
     useCallback(
       (_get, set) => {
         logger.debug("Setting active connection to", configId);
-        fireAndForget(set(activeConfigurationAtom, configId));
+        set(activeConfigurationAtom, configId).catch(logAndIgnore);
         resetState();
       },
       [configId, resetState],
diff --git a/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts b/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts
index 30f9151f6..e75da1777 100644
--- a/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts
+++ b/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts
@@ -9,7 +9,7 @@ import {
   schemaAtom,
 } from "@/core";
 import useResetState from "@/core/StateProvider/useResetState";
-import { fireAndForget } from "@/utils";
+import { logAndIgnore } from "@/utils";
 import { fromFileToJson } from "@/utils/fileData";
 import { parseConnectionFile } from "@/utils/parseConnectionFile";
 
@@ -30,25 +30,21 @@ export function useImportConnectionFile() {
 
         // Create new id to avoid collisions
         const newId = createNewConfigurationId();
-        fireAndForget(
-          set(configurationAtom, prevConfig => {
-            const updatedConfig = new Map(prevConfig);
-            updatedConfig.set(newId, {
-              id: newId,
-              displayLabel: parsedFile.displayLabel,
-              connection: parsedFile.connection,
-            });
-            return updatedConfig;
-          }),
-        );
-        fireAndForget(
-          set(schemaAtom, prevSchema => {
-            const updatedSchema = new Map(prevSchema);
-            updatedSchema.set(newId, parsedFile.schema);
-            return updatedSchema;
-          }),
-        );
-        fireAndForget(set(activeConfigurationAtom, newId));
+        set(configurationAtom, prevConfig => {
+          const updatedConfig = new Map(prevConfig);
+          updatedConfig.set(newId, {
+            id: newId,
+            displayLabel: parsedFile.displayLabel,
+            connection: parsedFile.connection,
+          });
+          return updatedConfig;
+        }).catch(logAndIgnore);
+        set(schemaAtom, prevSchema => {
+          const updatedSchema = new Map(prevSchema);
+          updatedSchema.set(newId, parsedFile.schema);
+          return updatedSchema;
+        }).catch(logAndIgnore);
+        set(activeConfigurationAtom, newId).catch(logAndIgnore);
 
         resetState();
       },
diff --git a/packages/graph-explorer/src/modules/CreateConnection/CreateConnection.tsx b/packages/graph-explorer/src/modules/CreateConnection/CreateConnection.tsx
index f26d0b25d..2eca4c7a9 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 { fireAndForget, formatDate, logger } from "@/utils";
+import { logAndIgnore, formatDate, logger } from "@/utils";
 import {
   DEFAULT_FETCH_TIMEOUT,
   DEFAULT_NODE_EXPAND_LIMIT,
@@ -117,36 +117,32 @@ const CreateConnection = ({
             connection: mapToConnection(data),
           };
           logger.log("Saving new connection", { newConfigId, newConfig });
-          fireAndForget(
-            set(configurationAtom, prevConfigMap => {
-              const updatedConfig = new Map(prevConfigMap);
-              updatedConfig.set(newConfigId, newConfig);
-              return updatedConfig;
-            }),
-          );
-          fireAndForget(set(activeConfigurationAtom, newConfigId));
+          set(configurationAtom, prevConfigMap => {
+            const updatedConfig = new Map(prevConfigMap);
+            updatedConfig.set(newConfigId, newConfig);
+            return updatedConfig;
+          }).catch(logAndIgnore);
+          set(activeConfigurationAtom, newConfigId).catch(logAndIgnore);
           return;
         }
 
-        fireAndForget(
-          set(configurationAtom, prev => {
-            const updated = new Map(prev);
-            const currentConfig = updated.get(configId);
-            const updatedConfig: RawConfiguration = {
-              ...currentConfig,
-              id: configId,
-              displayLabel: data.name,
-              connection: mapToConnection(data),
-            };
-            logger.log("Updating existing connection", {
-              configId,
-              currentConfig,
-              updatedConfig,
-            });
-            updated.set(configId, updatedConfig);
-            return updated;
-          }),
-        );
+        set(configurationAtom, prev => {
+          const updated = new Map(prev);
+          const currentConfig = updated.get(configId);
+          const updatedConfig: RawConfiguration = {
+            ...currentConfig,
+            id: configId,
+            displayLabel: data.name,
+            connection: mapToConnection(data),
+          };
+          logger.log("Updating existing connection", {
+            configId,
+            currentConfig,
+            updatedConfig,
+          });
+          updated.set(configId, updatedConfig);
+          return updated;
+        }).catch(logAndIgnore);
 
         const urlChange = initialData?.url !== data.url;
         const dbUrlChange = initialData?.graphDbUrl !== data.graphDbUrl;
@@ -159,23 +155,19 @@ const CreateConnection = ({
           );
 
           // Force a sync of the schema by deleting the existing schema cache, which is now invalid
-          fireAndForget(
-            set(schemaAtom, prevSchemaMap => {
-              const updatedSchema = new Map(prevSchemaMap);
-              updatedSchema.delete(configId);
-              return updatedSchema;
-            }),
-          );
+          set(schemaAtom, prevSchemaMap => {
+            const updatedSchema = new Map(prevSchemaMap);
+            updatedSchema.delete(configId);
+            return updatedSchema;
+          }).catch(logAndIgnore);
 
           // Delete previous session data
-          fireAndForget(
-            set(allGraphSessionsAtom, prev => {
-              const updatedGraphs = new Map(prev);
-              logger.log("Deleting previous graph session");
-              updatedGraphs.delete(configId);
-              return updatedGraphs;
-            }),
-          );
+          set(allGraphSessionsAtom, prev => {
+            const updatedGraphs = new Map(prev);
+            logger.log("Deleting previous graph session");
+            updatedGraphs.delete(configId);
+            return updatedGraphs;
+          }).catch(logAndIgnore);
 
           // 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 efec82856..42530594e 100644
--- a/packages/graph-explorer/src/modules/EdgesStyling/SingleEdgeStyling.tsx
+++ b/packages/graph-explorer/src/modules/EdgesStyling/SingleEdgeStyling.tsx
@@ -4,7 +4,7 @@ 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 { fireAndForget, LABELS } from "@/utils";
+import { logAndIgnore, LABELS } from "@/utils";
 
 import { useOpenEdgeStyleDialog } from "./EdgeStyleDialog";
 
@@ -30,7 +30,7 @@ export default function SingleEdgeStyling({
     if (prevDisplayAs === null || prevDisplayAs === debouncedDisplayAs) {
       return;
     }
-    fireAndForget(setEdgeStyle({ displayLabel: debouncedDisplayAs }));
+    setEdgeStyle({ displayLabel: debouncedDisplayAs }).catch(logAndIgnore);
   }, [debouncedDisplayAs, prevDisplayAs, setEdgeStyle]);
 
   return (
diff --git a/packages/graph-explorer/src/modules/GraphViewer/internalComponents/ContextMenu.tsx b/packages/graph-explorer/src/modules/GraphViewer/internalComponents/ContextMenu.tsx
index 344b56ddf..8ff9223b6 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, fireAndForget } from "@/utils";
+import { cn, logAndIgnore } from "@/utils";
 
 import { useGraphSelection } from "../useGraphSelection";
 
@@ -111,8 +111,8 @@ function SingleVertexMenu({ vertexId }: { vertexId: VertexId }) {
     });
 
   const openSidebarPanel = (panelName: SidebarItems) => () => {
-    fireAndForget(
-      setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName })),
+    setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName })).catch(
+      logAndIgnore,
     );
     replaceGraphSelection({ vertices: [vertexId], disableSideEffects: true });
   };
@@ -185,8 +185,8 @@ function SingleEdgeMenu({ edgeId }: { edgeId: EdgeId }) {
   const handleFit = () => onFitEdgeToCanvas(edgeId);
 
   const openSidebarPanel = (panelName: SidebarItems) => () => {
-    fireAndForget(
-      setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName })),
+    setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName })).catch(
+      logAndIgnore,
     );
     replaceGraphSelection({ edges: [edgeId], disableSideEffects: true });
   };
diff --git a/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts b/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
index 292d0e84f..a0a9f7057 100644
--- a/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
+++ b/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
@@ -1,22 +1,20 @@
 import { useSetAtom } from "jotai";
 
 import { userLayoutAtom } from "@/core";
-import { fireAndForget } from "@/utils";
+import { logAndIgnore } from "@/utils";
 
 export function useAutoOpenDetailsSidebar() {
   const setUserLayout = useSetAtom(userLayoutAtom);
   return () => {
-    fireAndForget(
-      setUserLayout(prev => {
-        if (prev.detailsAutoOpenOnSelection !== true) {
-          return prev;
-        }
+    setUserLayout(prev => {
+      if (prev.detailsAutoOpenOnSelection !== true) {
+        return prev;
+      }
 
-        return {
-          ...prev,
-          activeSidebarItem: "details",
-        };
-      }),
-    );
+      return {
+        ...prev,
+        activeSidebarItem: "details",
+      };
+    }).catch(logAndIgnore);
   };
 }
diff --git a/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx b/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx
index 15e026d93..2fcaeddbe 100644
--- a/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx
+++ b/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx
@@ -36,7 +36,7 @@ import {
   useConfiguration,
 } from "@/core";
 import { usePrefixes } from "@/core/StateProvider/schema";
-import { fireAndForget } from "@/utils";
+import { logAndIgnore } from "@/utils";
 
 type PrefixForm = {
   prefix: string;
@@ -172,23 +172,21 @@ function useDeletePrefixCallback(prefix: string) {
           return;
         }
 
-        fireAndForget(
-          set(schemaAtom, prevSchemas => {
-            const updatedSchemas = new Map(prevSchemas);
-            const activeSchema = updatedSchemas.get(activeConfigId);
+        set(schemaAtom, prevSchemas => {
+          const updatedSchemas = new Map(prevSchemas);
+          const activeSchema = updatedSchemas.get(activeConfigId);
 
-            updatedSchemas.set(activeConfigId, {
-              ...activeSchema,
-              vertices: activeSchema?.vertices || [],
-              edges: activeSchema?.edges || [],
-              prefixes: (activeSchema?.prefixes || []).filter(
-                prefixConfig => prefixConfig.prefix !== prefix,
-              ),
-            });
+          updatedSchemas.set(activeConfigId, {
+            ...activeSchema,
+            vertices: activeSchema?.vertices || [],
+            edges: activeSchema?.edges || [],
+            prefixes: (activeSchema?.prefixes || []).filter(
+              prefixConfig => prefixConfig.prefix !== prefix,
+            ),
+          });
 
-            return updatedSchemas;
-          }),
-        );
+          return updatedSchemas;
+        }).catch(logAndIgnore);
       },
       [prefix],
     ),
@@ -225,24 +223,22 @@ function EditPrefixModal({
           return;
         }
 
-        fireAndForget(
-          set(schemaAtom, prevSchemas => {
-            const updatedSchemas = new Map(prevSchemas);
-            const activeSchema = updatedSchemas.get(configId);
+        set(schemaAtom, prevSchemas => {
+          const updatedSchemas = new Map(prevSchemas);
+          const activeSchema = updatedSchemas.get(configId);
 
-            updatedSchemas.set(configId, {
-              ...activeSchema,
-              vertices: activeSchema?.vertices || [],
-              edges: activeSchema?.edges || [],
-              prefixes: [
-                ...(activeSchema?.prefixes || []),
-                { prefix: prefix as RdfPrefix, uri: uri as IriNamespace },
-              ],
-            });
+          updatedSchemas.set(configId, {
+            ...activeSchema,
+            vertices: activeSchema?.vertices || [],
+            edges: activeSchema?.edges || [],
+            prefixes: [
+              ...(activeSchema?.prefixes || []),
+              { prefix: prefix as RdfPrefix, uri: uri as IriNamespace },
+            ],
+          });
 
-            return updatedSchemas;
-          }),
-        );
+          return updatedSchemas;
+        }).catch(logAndIgnore);
       },
       [configId],
     ),
diff --git a/packages/graph-explorer/src/modules/NodesStyling/NodeStyleDialog.tsx b/packages/graph-explorer/src/modules/NodesStyling/NodeStyleDialog.tsx
index 47f69584f..fc0e83b45 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 { fireAndForget, parseNumberSafely } from "@/utils";
+import { logAndIgnore, parseNumberSafely } from "@/utils";
 import {
   RESERVED_ID_PROPERTY,
   RESERVED_TYPES_PROPERTY,
@@ -119,8 +119,8 @@ function Content({ vertexType }: { vertexType: VertexType }) {
     }
     try {
       const result = await file2Base64(file);
-      fireAndForget(
-        setVertexStyle({ iconUrl: result, iconImageType: file.type }),
+      setVertexStyle({ iconUrl: result, iconImageType: file.type }).catch(
+        logAndIgnore,
       );
     } catch (error) {
       console.error("Unable to convert uploaded image to base64: ", error);
diff --git a/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx b/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
index 1de824102..2541c3a90 100644
--- a/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
+++ b/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
@@ -4,7 +4,7 @@ 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 { fireAndForget } from "@/utils";
+import { logAndIgnore } from "@/utils";
 import { LABELS } from "@/utils/constants";
 
 import { useOpenNodeStyleDialog } from "./NodeStyleDialog";
@@ -32,7 +32,7 @@ export default function SingleNodeStyling({
     if (prevDisplayAs === null || prevDisplayAs === debouncedDisplayAs) {
       return;
     }
-    fireAndForget(setVertexStyle({ displayLabel: debouncedDisplayAs }));
+    setVertexStyle({ displayLabel: debouncedDisplayAs }).catch(logAndIgnore);
   }, [debouncedDisplayAs, prevDisplayAs, setVertexStyle]);
 
   return (
diff --git a/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx b/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx
index 7d0bfcec6..005721213 100644
--- a/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx
+++ b/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx
@@ -56,7 +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 { fireAndForget } from "@/utils";
+import { logAndIgnore } from "@/utils";
 import {
   LABELS,
   RESERVED_ID_PROPERTY,
@@ -257,14 +257,14 @@ function DisplayNameAndDescriptionOptions({
   const onDisplayNameChange =
     (field: "name" | "longName") => (value: string | string[]) => {
       if (field === "name") {
-        fireAndForget(
-          setPreferences({ displayNameAttribute: value as string }),
+        setPreferences({ displayNameAttribute: value as string }).catch(
+          logAndIgnore,
         );
       }
 
       if (field === "longName") {
-        fireAndForget(
-          setPreferences({ longDisplayNameAttribute: value as string }),
+        setPreferences({ longDisplayNameAttribute: value as string }).catch(
+          logAndIgnore,
         );
       }
     };
diff --git a/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx b/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx
index 7ea6b1921..61bd2bf66 100644
--- a/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx
+++ b/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx
@@ -25,7 +25,7 @@ import {
   showDebugActionsAtom,
 } from "@/core";
 import { saveLocalForageToFile } from "@/core/StateProvider/localDb";
-import { fireAndForget } from "@/utils";
+import { logAndIgnore } from "@/utils";
 
 import LoadConfigButton from "./LoadConfigButton";
 
@@ -60,8 +60,8 @@ export default function SettingsGeneral() {
           value="defaultNeighborExpansionLimitEnabled"
           checked={defaultNeighborExpansionLimitEnabled}
           onCheckedChange={isSelected => {
-            fireAndForget(
-              setDefaultNeighborExpansionLimitEnabled(Boolean(isSelected)),
+            setDefaultNeighborExpansionLimitEnabled(Boolean(isSelected)).catch(
+              logAndIgnore,
             );
           }}
         />
@@ -119,7 +119,7 @@ export default function SettingsGeneral() {
           value="isDiagnosticLoggingEnabled"
           checked={diagnosticLogging}
           onCheckedChange={isSelected => {
-            fireAndForget(setDiagnosticLogging(Boolean(isSelected)));
+            setDiagnosticLogging(Boolean(isSelected)).catch(logAndIgnore);
           }}
           label="Diagnostic logging"
           description="Enables verbose logging to the browser console for troubleshooting."
@@ -130,7 +130,7 @@ export default function SettingsGeneral() {
           value="isLoggingDbQueryEnabled"
           checked={allowLoggingDbQuery}
           onCheckedChange={isSelected => {
-            fireAndForget(setAllowLoggingDbQuery(Boolean(isSelected)));
+            setAllowLoggingDbQuery(Boolean(isSelected)).catch(logAndIgnore);
           }}
           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."
@@ -148,7 +148,7 @@ export default function SettingsGeneral() {
             value="isDebugOptionsEnabled"
             checked={isDebugOptionsEnabled}
             onCheckedChange={isSelected => {
-              fireAndForget(setIsDebugOptionsEnabled(Boolean(isSelected)));
+              setIsDebugOptionsEnabled(Boolean(isSelected)).catch(logAndIgnore);
             }}
             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/fireAndForget.ts b/packages/graph-explorer/src/utils/fireAndForget.ts
deleted file mode 100644
index e647db5c4..000000000
--- a/packages/graph-explorer/src/utils/fireAndForget.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import logger from "./logger";
-
-/**
- * Explicitly ignores a promise whose result the caller does not await, while
- * still observing failures by logging them.
- *
- * Use this for intentional fire-and-forget work where a rejection should not be
- * silently swallowed — most notably background persistence writes (see
- * `atomWithLocalForage`), which resolve synchronously in memory but may reject
- * when the durable write fails. For promises whose rejection is genuinely inert
- * (e.g. an aborted navigation), prefer the bare `void` operator instead.
- */
-export function fireAndForget(promise: Promise<unknown>) {
-  promise.catch(error => {
-    logger.warn("Ignored promise rejection:", error);
-  });
-}
diff --git a/packages/graph-explorer/src/utils/index.ts b/packages/graph-explorer/src/utils/index.ts
index df0ac3fed..16fe4f684 100644
--- a/packages/graph-explorer/src/utils/index.ts
+++ b/packages/graph-explorer/src/utils/index.ts
@@ -6,7 +6,7 @@ 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 { fireAndForget } from "./fireAndForget";
+export { logAndIgnore } from "./logAndIgnore";
 export { default as logger } from "./logger";
 export * from "./branded";
 export * from "./sanitizeQuery";
diff --git a/packages/graph-explorer/src/utils/fireAndForget.test.ts b/packages/graph-explorer/src/utils/logAndIgnore.test.ts
similarity index 62%
rename from packages/graph-explorer/src/utils/fireAndForget.test.ts
rename to packages/graph-explorer/src/utils/logAndIgnore.test.ts
index 78199689e..f6192a51f 100644
--- a/packages/graph-explorer/src/utils/fireAndForget.test.ts
+++ b/packages/graph-explorer/src/utils/logAndIgnore.test.ts
@@ -1,4 +1,4 @@
-import { fireAndForget } from "./fireAndForget";
+import { logAndIgnore } from "./logAndIgnore";
 import logger from "./logger";
 
 vi.mock("./logger", () => ({
@@ -7,11 +7,11 @@ vi.mock("./logger", () => ({
   },
 }));
 
-describe("fireAndForget", () => {
-  it("warns with the error when the promise rejects", async () => {
+describe("logAndIgnore", () => {
+  it("warns with the error when used as a catch handler for a rejection", async () => {
     const error = new Error("persist failed");
 
-    fireAndForget(Promise.reject(error));
+    Promise.reject(error).catch(logAndIgnore);
     await vi.waitFor(() => {
       expect(logger.warn).toHaveBeenCalledWith(
         "Ignored promise rejection:",
@@ -21,8 +21,7 @@ describe("fireAndForget", () => {
   });
 
   it("does not log anything when the promise resolves", async () => {
-    fireAndForget(Promise.resolve());
-    await Promise.resolve();
+    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);
+}

From 5fa10edca00bc8fe980fa0c395255e8d98e07472 Mon Sep 17 00:00:00 2001
From: Kris McGinnes <kmcginnes@me.com>
Date: Thu, 18 Jun 2026 19:20:55 -0500
Subject: [PATCH 4/8] Await persisted-atom seeding in async test contexts

Where a test seeds a localForage-backed atom inside an async body or
beforeEach, await the write instead of marking it void. This fails the test
on a seeding error and removes the unhandled-rejection race at teardown.
Seeds inside the synchronous renderHookWithJotai initializeState callback stay
void, since its return is ignored and awaiting there is a no-op.
---
 .../connector/queries/schemaSyncQuery.test.ts | 18 +++++++--------
 .../StateProvider/atomWithLocalForage.test.ts | 22 +++++++++----------
 .../core/StateProvider/storageAtoms.test.ts   |  6 ++---
 .../src/hooks/useSchemaSync.test.ts           |  4 ++--
 4 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/packages/graph-explorer/src/connector/queries/schemaSyncQuery.test.ts b/packages/graph-explorer/src/connector/queries/schemaSyncQuery.test.ts
index 4efc33648..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();
-    void store.set(configurationAtom, new Map([[config.id, config]]));
-    void store.set(activeConfigurationAtom, config.id);
-    void 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");
-    void 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()];
-    void 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)!;
-    void 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"));
-    void 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()];
-    void 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/core/StateProvider/atomWithLocalForage.test.ts b/packages/graph-explorer/src/core/StateProvider/atomWithLocalForage.test.ts
index 2b7ad4028..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");
 
-    void 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);
 
-    void 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, {});
 
-    void 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
-    void store.set(atom, 1);
-    void store.set(atom, 2);
-    void 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");
-    void store.set(stringAtom, "world");
+    await store.set(stringAtom, "world");
     expect(store.get(stringAtom)).toBe("world");
 
     // Number
     const numberAtom = await atomWithLocalForage("test-number", 42);
-    void store.set(numberAtom, 100);
+    await store.set(numberAtom, 100);
     expect(store.get(numberAtom)).toBe(100);
 
     // Boolean
     const boolAtom = await atomWithLocalForage("test-bool", false);
-    void store.set(boolAtom, true);
+    await store.set(boolAtom, true);
     expect(store.get(boolAtom)).toBe(true);
 
     // Array
     const arrayAtom = await atomWithLocalForage("test-array", [1, 2]);
-    void 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,
       },
     );
-    void 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/storageAtoms.test.ts b/packages/graph-explorer/src/core/StateProvider/storageAtoms.test.ts
index 7667764d8..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();
 
-    void store.set(showDebugActionsAtom, true);
+    await store.set(showDebugActionsAtom, true);
     expect(store.get(showDebugActionsAtom)).toBe(true);
 
-    void store.set(showDebugActionsAtom, false);
+    await store.set(showDebugActionsAtom, false);
     expect(store.get(showDebugActionsAtom)).toBe(false);
   });
 });
diff --git a/packages/graph-explorer/src/hooks/useSchemaSync.test.ts b/packages/graph-explorer/src/hooks/useSchemaSync.test.ts
index 66980109b..493193fcb 100644
--- a/packages/graph-explorer/src/hooks/useSchemaSync.test.ts
+++ b/packages/graph-explorer/src/hooks/useSchemaSync.test.ts
@@ -456,12 +456,12 @@ describe("useSchemaSync", () => {
       // Switch to a new connection with no schema
       const store = getAppStore();
       const newConfig = createRandomRawConfiguration();
-      void store.set(configurationAtom, prev => {
+      await store.set(configurationAtom, prev => {
         const updated = new Map(prev);
         updated.set(newConfig.id, newConfig);
         return updated;
       });
-      void store.set(activeConfigurationAtom, newConfig.id);
+      await store.set(activeConfigurationAtom, newConfig.id);
 
       rerender();
 

From ebf3dfeade96d45e57fa7c3d20812a7bfe3d9216 Mon Sep 17 00:00:00 2001
From: Kris McGinnes <kmcginnes@me.com>
Date: Thu, 18 Jun 2026 19:39:27 -0500
Subject: [PATCH 5/8] Await fire-and-forget writes in remaining async test
 bodies

LoggerConnector.test.ts and localDb.test.ts call promise-returning writes
inside async test bodies where the result can be awaited. Await them instead
of marking void, so a failed write fails the test rather than surfacing as an
unhandled rejection at teardown.
---
 .../src/connector/LoggerConnector.test.ts     | 16 +++++-----
 .../src/core/StateProvider/localDb.test.ts    | 30 +++++++++----------
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/packages/graph-explorer/src/connector/LoggerConnector.test.ts b/packages/graph-explorer/src/connector/LoggerConnector.test.ts
index 1bdc5ab6e..c3f77105a 100644
--- a/packages/graph-explorer/src/connector/LoggerConnector.test.ts
+++ b/packages/graph-explorer/src/connector/LoggerConnector.test.ts
@@ -15,49 +15,49 @@ 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/");
 
-    void 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") },
     });
 
-    void 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") },
     });
 
-    void 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") },
     });
 
-    void 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") },
     });
 
-    void 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/");
-    void connector.info("test");
+    await connector.info("test");
 
     expect(mockFetch).toHaveBeenCalledWith(
       "https://example.com/logger",
diff --git a/packages/graph-explorer/src/core/StateProvider/localDb.test.ts b/packages/graph-explorer/src/core/StateProvider/localDb.test.ts
index 3a7407864..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
-    void localDb.setItem("schema", schemaMap);
-    void localDb.setItem("configuration", configMap);
-    void 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
-    void localDb.setItem("schema", schemaMap);
-    void localDb.setItem("configuration", configMap);
-    void 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
-    void localDb.setItem("schema", schemaMap);
-    void localDb.setItem("configuration", configMap);
-    void localDb.setItem("active-configuration", config.id);
-    void localDb.setItem(addRestoredPrefix("schema"), schemaMap);
-    void localDb.setItem(addRestoredPrefix("configuration"), configMap);
-    void 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]]);
 
-    void localDb.setItem("schema", schemaMap);
-    void localDb.setItem("configuration", configMap);
-    void 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);

From 1d0a2025c754ff227b410c528af1b534e973d749 Mon Sep 17 00:00:00 2001
From: Kris McGinnes <kmcginnes@me.com>
Date: Fri, 19 Jun 2026 09:04:11 -0500
Subject: [PATCH 6/8] Make test seeding helpers async so persisted writes are
 awaited

renderHookWithState, renderHookWithJotai, and DbState.applyTo now await the
localForage-backed atom writes they seed, instead of leaving them as floating
void promises. This means a seeding failure surfaces as a test failure and the
unhandled-rejection race at teardown is gone.

Both render helpers became async and renderHookWithJotai's initializeState now
accepts an async callback, so all call sites await the helper (and their
enclosing test functions are async). Sweeps the ~35 affected test files.
---
 .../queries/edgeConnectionsQuery.test.ts      |  24 +--
 .../queries/nodeCountByNodeTypeQuery.test.ts  |   4 +-
 .../core/StateProvider/displayEdge.test.ts    |  97 ++++++-----
 .../StateProvider/displayTypeConfigs.test.ts  |  52 +++---
 .../core/StateProvider/displayVertex.test.ts  |  81 +++++----
 .../core/StateProvider/featureFlags.test.ts   |   4 +-
 .../src/core/StateProvider/neighbors.test.ts  |  42 ++---
 .../StateProvider/renderedEntities.test.ts    |  12 +-
 .../src/core/StateProvider/schema.test.ts     | 142 +++++++--------
 .../core/StateProvider/useResetState.test.ts  |  20 +--
 .../src/core/StateProvider/userLayout.test.ts |  58 +++----
 .../StateProvider/userPreferences.test.ts     |  68 ++++----
 .../src/hooks/useAddToGraph.test.ts           |  30 ++--
 .../src/hooks/useContextMenuTarget.test.ts    |  56 +++---
 .../src/hooks/useDeleteConfig.test.ts         |  24 +--
 .../src/hooks/useEntitiesCounts.test.ts       |  28 +--
 .../src/hooks/useEntityCountFormatter.test.ts |  32 ++--
 .../src/hooks/useExpandNode.test.ts           |  64 +++----
 .../useHasVertexBeenAddedToGraph.test.ts      |  16 +-
 .../src/hooks/useNeighborsOptions.test.ts     |  12 +-
 .../src/hooks/useRefreshEntities.test.ts      |  12 +-
 .../src/hooks/useRemoveFromGraph.test.ts      |  18 +-
 .../src/hooks/useSchemaSync.test.ts           | 164 ++++++++++++------
 .../src/hooks/useTextTransform.test.ts        |  40 ++---
 .../useImportConnectionFile.test.tsx          |  20 +--
 .../EntitiesFilter/useFiltersConfig.test.ts   |  28 +--
 .../useAutoOpenDetailsSidebar.test.ts         |  12 +-
 .../GraphViewer/useBackgroundImageMap.test.ts |  29 ++--
 .../GraphViewer/useGraphSelection.test.ts     |  68 ++++----
 .../GraphViewer/useGraphStyles.test.tsx       | 100 +++++++----
 .../Sidebar/SchemaExplorerSidebar.test.tsx    |  16 +-
 .../useEdgeAttributesAsScalars.test.ts        |  28 +--
 .../SearchSidebar/useKeywordSearch.test.ts    |  78 ++++-----
 .../useVertexAttributesAsScalars.test.ts      |  20 +--
 .../routes/DataExplorer/DataExplorer.test.tsx |  20 +--
 .../src/utils/testing/DbState.ts              |  20 +--
 .../src/utils/testing/renderHookWithJotai.tsx |  10 +-
 37 files changed, 836 insertions(+), 713 deletions(-)

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/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/core/StateProvider/displayEdge.test.ts b/packages/graph-explorer/src/core/StateProvider/displayEdge.test.ts
index d2d4c14da..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) => {
-      void store.set(configurationAtom, new Map([[config.id, config]]));
-      void store.set(schemaAtom, new Map([[config.id, schema]]));
-      void 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) => {
-      void store.set(configurationAtom, new Map([[config.id, config]]));
-      void store.set(schemaAtom, new Map([[config.id, schema]]));
-      void 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 65019996b..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) => {
-      void store.set(configurationAtom, new Map([[config.id, config]]));
-      void store.set(schemaAtom, new Map([[config.id, schema]]));
-      void 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) => {
-      void store.set(configurationAtom, new Map([[config.id, config]]));
-      void store.set(schemaAtom, new Map([[config.id, schema]]));
-      void 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/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 21a430f4a..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 => {
-        void store.set(configurationAtom, new Map([[config.id, config]]));
-        void store.set(activeConfigurationAtom, config.id);
-        void 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 => {
-        void store.set(configurationAtom, new Map([[config.id, config]]));
-        void store.set(activeConfigurationAtom, config.id);
-        void 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 => {
-        void store.set(configurationAtom, new Map([[config.id, config]]));
-        void store.set(activeConfigurationAtom, config.id);
-        void 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 => {
-        void store.set(configurationAtom, new Map([[config.id, config]]));
-        void store.set(activeConfigurationAtom, config.id);
-        void 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 => {
-        void store.set(configurationAtom, new Map([[config.id, config]]));
-        void store.set(activeConfigurationAtom, config.id);
-        void 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 => {
-        void store.set(configurationAtom, new Map([[config.id, config]]));
-        void store.set(activeConfigurationAtom, config.id);
-        void 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/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 b72bf958f..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,14 +55,14 @@ 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", () => {
-    const { result } = renderHookWithJotai(() => useSidebar());
+  it("should change to the given sidebar item", async () => {
+    const { result } = await renderHookWithJotai(() => useSidebar());
 
     act(() => result.current.toggleSidebar("details"));
     expect(result.current.isSidebarOpen).toBe(true);
@@ -73,8 +73,8 @@ describe("useSidebar", () => {
     expect(result.current.activeSidebarItem).toBe("search");
   });
 
-  it("should close the sidebar if toggling to the same item", () => {
-    const { result } = renderHookWithJotai(
+  it("should close the sidebar if toggling to the same item", async () => {
+    const { result } = await renderHookWithJotai(
       () => useSidebar(),
       store =>
         store.set(userLayoutAtom, {
@@ -90,22 +90,22 @@ describe("useSidebar", () => {
   });
 
   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);
-        void 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);
-        void 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/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 d2979bc50..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 => {
-      void store.set(activeConfigurationAtom, config1.id);
-      void 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 => {
-      void store.set(activeConfigurationAtom, config1.id);
-      void store.set(configurationAtom, new Map([[config1.id, config1]]));
-      void 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/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 4f30a2a7a..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);
-        void store.set(defaultNeighborExpansionLimitAtom, 10);
-        void 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);
-        void store.set(defaultNeighborExpansionLimitEnabledAtom, true);
-        void 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);
-        void 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/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 493193fcb..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 => {
-          void store.set(activeConfigurationAtom, null);
-          void store.set(configurationAtom, new Map());
-          void 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,
       );
@@ -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 41090256a..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,
     },
   ];
-  void store.set(configurationAtom, new Map([[config.id, config]]));
-  void 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
-  void 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/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/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/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/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/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/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 374747330..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;
 
-    void store.set(configurationAtom, new Map([[config.id, config]]));
+    await store.set(configurationAtom, new Map([[config.id, config]]));
 
     // Make config active
-    void 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",
       });
 
-      void store.set(configurationAtom, new Map([[config.id, config]]));
-      void 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
-      void 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/utils/testing/DbState.ts b/packages/graph-explorer/src/utils/testing/DbState.ts
index ba59948a0..6aa7d90f2 100644
--- a/packages/graph-explorer/src/utils/testing/DbState.ts
+++ b/packages/graph-explorer/src/utils/testing/DbState.ts
@@ -188,28 +188,28 @@ export class DbState {
   /**
    * Applies the state to the given Jotai store.
    *
-   * The localForage-backed atom writes return background persistence promises
-   * that are intentionally ignored here — seeding test state does not care
-   * whether the value lands in durable storage.
+   * 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.
    */
-  applyTo(store: AppStore) {
+  async applyTo(store: AppStore) {
     // Config
-    void store.set(
+    await store.set(
       configurationAtom,
       new Map([[this.activeConfig.id, this.activeConfig]]),
     );
     if (this._activeSchema) {
-      void store.set(
+      await store.set(
         schemaAtom,
         new Map([[this.activeConfig.id, this._activeSchema]]),
       );
     } else {
-      void store.set(schemaAtom, new Map());
+      await store.set(schemaAtom, new Map());
     }
-    void store.set(activeConfigurationAtom, this.activeConfig.id);
+    await store.set(activeConfigurationAtom, this.activeConfig.id);
 
     // Styling
-    void store.set(userStylingAtom, this.activeStyling);
+    await store.set(userStylingAtom, this.activeStyling);
 
     // Vertices
     store.set(nodesAtom, toNodeMap(this.vertices));
@@ -222,7 +222,7 @@ export class DbState {
     store.set(edgesTypesFilteredAtom, this.filteredEdgeTypes);
 
     // Graph Storage
-    void store.set(
+    await store.set(
       allGraphSessionsAtom,
       new Map([
         [
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

From 83e93c4ad9e6a016426c020577e7bb625e2c4d31 Mon Sep 17 00:00:00 2001
From: Kris McGinnes <kmcginnes@me.com>
Date: Fri, 19 Jun 2026 10:45:02 -0500
Subject: [PATCH 7/8] Expose the log-send promise and surface failures to the
 user

LoggerConnector methods now return Promise<void> instead of hiding the
server-send promise behind a void contract. When sending a log to the server
fails, ServerLoggerConnector logs a console warning and shows a warning toast,
so the failure is no longer silent.

Consumers that fire logging fire-and-forget (the explorers and schema fetchers)
mark the now-visible promise with void; its rejection is handled inside the
connector, so floating it is inert.
---
 .../src/connector/LoggerConnector.test.ts     | 21 +++++++
 .../src/connector/LoggerConnector.ts          | 58 +++++++++++--------
 .../connector/gremlin/fetchSchema/index.ts    | 28 +++++----
 .../src/connector/gremlin/gremlinExplorer.ts  | 20 ++++---
 .../connector/openCypher/fetchSchema/index.ts | 26 +++++----
 .../openCypher/openCypherExplorer.ts          | 26 ++++++---
 .../src/connector/sparql/fetchSchema/index.ts | 12 ++--
 .../src/connector/sparql/sparqlExplorer.ts    | 18 +++---
 .../src/hooks/useExpandNode.tsx               |  4 +-
 9 files changed, 133 insertions(+), 80 deletions(-)

diff --git a/packages/graph-explorer/src/connector/LoggerConnector.test.ts b/packages/graph-explorer/src/connector/LoggerConnector.test.ts
index c3f77105a..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,
@@ -64,4 +68,21 @@ describe("ServerLoggerConnector", () => {
       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/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/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);

From e5a5b1b722bdd6e952eaa368c5f8e2231556869b Mon Sep 17 00:00:00 2001
From: Kris McGinnes <kmcginnes@me.com>
Date: Fri, 19 Jun 2026 11:39:26 -0500
Subject: [PATCH 8/8] Notify the user when a persisted write fails

Add logAndNotify(message, options?), a .catch handler that logs at warn level
and shows a warning toast, as the user-facing counterpart to logAndIgnore.

Migrate every user-facing fire-and-forget persistence write to logAndNotify so
a failed save is no longer silently swallowed: connections, schema cache, graph
session, styles, namespace prefixes, settings, and layout preferences. Styling
sites build the message with useTranslations so node/edge vocabulary reads
correctly per query engine. The background canvas icon fetch keeps logAndIgnore
since its failure is not worth interrupting the user.
---
 .kiro/skills/typescript/SKILL.md              |  3 +-
 ...18-explicit-floating-promise-convention.md | 14 ++---
 .../connector/queries/edgeConnectionsQuery.ts |  6 +--
 .../src/connector/queries/schemaSyncQuery.ts  |  6 +--
 .../src/core/AppStatusLoader.tsx              |  8 +--
 .../StateProvider/graphSession/storage.ts     | 10 ++--
 .../src/core/StateProvider/schema.ts          |  4 +-
 .../src/core/StateProvider/userLayout.ts      |  6 +--
 .../src/hooks/useDeleteConfig.ts              | 10 ++--
 .../AvailableConnections/ConnectionRow.tsx    |  6 ++-
 .../useImportConnectionFile.ts                | 10 ++--
 .../CreateConnection/CreateConnection.tsx     | 24 ++++++---
 .../EdgesStyling/SingleEdgeStyling.tsx        | 12 +++--
 .../internalComponents/ContextMenu.tsx        |  6 +--
 .../GraphViewer/useAutoOpenDetailsSidebar.ts  |  4 +-
 .../src/modules/Namespaces/UserPrefixes.tsx   |  6 +--
 .../modules/NodesStyling/NodeStyleDialog.tsx  |  6 ++-
 .../NodesStyling/SingleNodeStyling.tsx        | 12 +++--
 .../src/routes/DataExplorer/DataExplorer.tsx  | 10 ++--
 .../src/routes/Settings/SettingsGeneral.tsx   | 16 ++++--
 packages/graph-explorer/src/utils/index.ts    |  1 +
 .../src/utils/logAndNotify.test.ts            | 54 +++++++++++++++++++
 .../graph-explorer/src/utils/logAndNotify.ts  | 23 ++++++++
 23 files changed, 192 insertions(+), 65 deletions(-)
 create mode 100644 packages/graph-explorer/src/utils/logAndNotify.test.ts
 create mode 100644 packages/graph-explorer/src/utils/logAndNotify.ts

diff --git a/.kiro/skills/typescript/SKILL.md b/.kiro/skills/typescript/SKILL.md
index 43cb66a44..14dbbe833 100644
--- a/.kiro/skills/typescript/SKILL.md
+++ b/.kiro/skills/typescript/SKILL.md
@@ -16,7 +16,8 @@ description: TypeScript conventions and rules for Graph Explorer, including bran
 
 `typescript/no-floating-promises` is enabled as an error, so every unhandled promise must be marked explicitly. Pick the idiom by meaning:
 
-- **`.catch(logAndIgnore)`** (`logAndIgnore` from `@/utils`) — when a rejection is meaningful and should be observed even though you don't await it. It logs the rejection via `logger.warn` (warn, not error, since an ignored rejection is non-blocking). This is the idiom for persisted-atom setters (`atomWithLocalForage`-backed writes), where a failed durable write should be logged rather than silently dropped.
+- **`.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.
diff --git a/docs/adr/20260618-explicit-floating-promise-convention.md b/docs/adr/20260618-explicit-floating-promise-convention.md
index 6e454562e..7b363ecd4 100644
--- a/docs/adr/20260618-explicit-floating-promise-convention.md
+++ b/docs/adr/20260618-explicit-floating-promise-convention.md
@@ -12,13 +12,15 @@ Until now `typescript/no-floating-promises` was off, so these reads as ordinary
 
 ## Decision
 
-Turn on `typescript/no-floating-promises` (`error`) so every unhandled promise must be **explicitly** marked. Use one of two idioms by meaning:
+Turn on `typescript/no-floating-promises` (`error`) so every unhandled promise must be **explicitly** marked. Use one of three idioms by meaning:
 
-1. **`.catch(logAndIgnore)`** (`logAndIgnore` from `@/utils`) — a `.catch` handler that logs the rejection via `logger.warn` (warn, not error: an explicitly-ignored rejection is non-blocking by construction — the in-memory state already updated and nothing downstream awaits it). Use when a rejection is **meaningful and should be observed** even though the caller does not await it. This is the idiom for **persisted-atom setters**: a failed durable write gets logged rather than silently dropped, and the call sites stay greppable for follow-up auditing.
+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. **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).
+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.)
 
-The reconciliation contract for user-facing persistence errors (reject + surface a toast) is a **separate, in-flight effort** on the persistence branch. This ADR deliberately does **not** change the runtime behavior of persisted setters — it only makes the existing fire-and-forget explicit. When the toast contract lands, the `logAndIgnore`-handled userStyling call sites are the ones to revisit toward a handled-reject form.
+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
 
@@ -26,6 +28,6 @@ The reconciliation contract for user-facing persistence errors (reject + surface
 
 ## Consequences
 
-- A swallowed persistence error is now either logged (`.catch(logAndIgnore)`) or a deliberate, reviewed `void` — no longer invisible.
-- Reviewers have a clear rule: meaningful-but-unawaited → `.catch(logAndIgnore)`; inert → `void`.
+- 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/connector/queries/edgeConnectionsQuery.ts b/packages/graph-explorer/src/connector/queries/edgeConnectionsQuery.ts
index bb5b5ad86..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 { logAndIgnore, 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(logAndIgnore);
+    }).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(logAndIgnore);
+  }).catch(logAndNotify("Failed to save the schema to the local cache."));
 });
diff --git a/packages/graph-explorer/src/connector/queries/schemaSyncQuery.ts b/packages/graph-explorer/src/connector/queries/schemaSyncQuery.ts
index 308153acd..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 { logAndIgnore, 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(logAndIgnore);
+    }).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(logAndIgnore);
+  }).catch(logAndNotify("Failed to save the schema to the local cache."));
 });
diff --git a/packages/graph-explorer/src/core/AppStatusLoader.tsx b/packages/graph-explorer/src/core/AppStatusLoader.tsx
index f97136102..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 { logAndIgnore, 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;
-      }).catch(logAndIgnore);
-      setActiveConfig(defaultConnectionConfigs[0].id).catch(logAndIgnore);
+      }).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/graphSession/storage.ts b/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts
index 0e515921b..066b4dd71 100644
--- a/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts
+++ b/packages/graph-explorer/src/core/StateProvider/graphSession/storage.ts
@@ -2,7 +2,7 @@ import { atom } from "jotai";
 import { atomWithReset, RESET } from "jotai/utils";
 
 import { activeConfigurationAtom, allGraphSessionsAtom } from "@/core";
-import { logAndIgnore } from "@/utils";
+import { logAndNotify } from "@/utils";
 
 import type { EdgeId, VertexId } from "../../entities";
 
@@ -40,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).catch(logAndIgnore);
+      set(allGraphSessionsAtom, newGraphs).catch(
+        logAndNotify("Failed to save the current graph session."),
+      );
       return;
     }
 
     newGraphs.set(connectionId, newValue);
-    set(allGraphSessionsAtom, newGraphs).catch(logAndIgnore);
+    set(allGraphSessionsAtom, newGraphs).catch(
+      logAndNotify("Failed to save the current graph session."),
+    );
   },
 );
diff --git a/packages/graph-explorer/src/core/StateProvider/schema.ts b/packages/graph-explorer/src/core/StateProvider/schema.ts
index c9599379f..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 { logAndIgnore, 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(logAndIgnore);
+    }).catch(logAndNotify("Failed to save the schema to the local cache."));
   },
 );
 
diff --git a/packages/graph-explorer/src/core/StateProvider/userLayout.ts b/packages/graph-explorer/src/core/StateProvider/userLayout.ts
index 9ffdff319..2142b490a 100644
--- a/packages/graph-explorer/src/core/StateProvider/userLayout.ts
+++ b/packages/graph-explorer/src/core/StateProvider/userLayout.ts
@@ -1,6 +1,6 @@
 import { useAtom } from "jotai";
 
-import { logAndIgnore } from "@/utils";
+import { logAndNotify } from "@/utils";
 
 import { useQueryEngine } from "../connector";
 import { userLayoutAtom } from "./storageAtoms";
@@ -100,7 +100,7 @@ export function useSidebar() {
         ...prev,
         activeSidebarItem: prev.activeSidebarItem === item ? null : item,
       };
-    }).catch(logAndIgnore);
+    }).catch(logAndNotify("Failed to save your layout preferences."));
   };
 
   return {
@@ -128,7 +128,7 @@ export function useSidebarSize() {
           width: prevWidth + deltaWidth,
         },
       };
-    }).catch(logAndIgnore);
+    }).catch(logAndNotify("Failed to save your layout preferences."));
   };
 
   return [sidebarWidth, setSidebarWidth] as const;
diff --git a/packages/graph-explorer/src/hooks/useDeleteConfig.ts b/packages/graph-explorer/src/hooks/useDeleteConfig.ts
index cfc8143b3..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 { logAndIgnore, 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(logAndIgnore);
+      }).catch(logAndNotify("Failed to finish deleting the connection."));
 
       set(configurationAtom, prevConfigs => {
         const updatedConfigs = new Map(prevConfigs);
         updatedConfigs.delete(id);
         return updatedConfigs;
-      }).catch(logAndIgnore);
+      }).catch(logAndNotify("Failed to finish deleting the connection."));
 
       set(schemaAtom, prevSchemas => {
         const updatedSchemas = new Map(prevSchemas);
         updatedSchemas.delete(id);
         return updatedSchemas;
-      }).catch(logAndIgnore);
+      }).catch(logAndNotify("Failed to finish deleting the connection."));
 
       set(allGraphSessionsAtom, prev => {
         const updatedGraphs = new Map(prev);
         updatedGraphs.delete(id);
         return updatedGraphs;
-      }).catch(logAndIgnore);
+      }).catch(logAndNotify("Failed to finish deleting the connection."));
     }, []),
   );
 }
diff --git a/packages/graph-explorer/src/modules/AvailableConnections/ConnectionRow.tsx b/packages/graph-explorer/src/modules/AvailableConnections/ConnectionRow.tsx
index 0a2a997de..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 { logAndIgnore, 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).catch(logAndIgnore);
+        set(activeConfigurationAtom, configId).catch(
+          logAndNotify("Failed to switch the active connection."),
+        );
         resetState();
       },
       [configId, resetState],
diff --git a/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts b/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts
index e75da1777..695af9b48 100644
--- a/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts
+++ b/packages/graph-explorer/src/modules/AvailableConnections/useImportConnectionFile.ts
@@ -9,7 +9,7 @@ import {
   schemaAtom,
 } from "@/core";
 import useResetState from "@/core/StateProvider/useResetState";
-import { logAndIgnore } from "@/utils";
+import { logAndNotify } from "@/utils";
 import { fromFileToJson } from "@/utils/fileData";
 import { parseConnectionFile } from "@/utils/parseConnectionFile";
 
@@ -38,13 +38,15 @@ export function useImportConnectionFile() {
             connection: parsedFile.connection,
           });
           return updatedConfig;
-        }).catch(logAndIgnore);
+        }).catch(logAndNotify("Failed to import the connection."));
         set(schemaAtom, prevSchema => {
           const updatedSchema = new Map(prevSchema);
           updatedSchema.set(newId, parsedFile.schema);
           return updatedSchema;
-        }).catch(logAndIgnore);
-        set(activeConfigurationAtom, newId).catch(logAndIgnore);
+        }).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 2eca4c7a9..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 { logAndIgnore, 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;
-          }).catch(logAndIgnore);
-          set(activeConfigurationAtom, newConfigId).catch(logAndIgnore);
+          }).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(logAndIgnore);
+        }).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(logAndIgnore);
+          }).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(logAndIgnore);
+          }).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 42530594e..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 { logAndIgnore, 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 }).catch(logAndIgnore);
-  }, [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/GraphViewer/internalComponents/ContextMenu.tsx b/packages/graph-explorer/src/modules/GraphViewer/internalComponents/ContextMenu.tsx
index 8ff9223b6..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, logAndIgnore } from "@/utils";
+import { cn, logAndNotify } from "@/utils";
 
 import { useGraphSelection } from "../useGraphSelection";
 
@@ -112,7 +112,7 @@ function SingleVertexMenu({ vertexId }: { vertexId: VertexId }) {
 
   const openSidebarPanel = (panelName: SidebarItems) => () => {
     setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName })).catch(
-      logAndIgnore,
+      logAndNotify("Failed to save your layout preferences."),
     );
     replaceGraphSelection({ vertices: [vertexId], disableSideEffects: true });
   };
@@ -186,7 +186,7 @@ function SingleEdgeMenu({ edgeId }: { edgeId: EdgeId }) {
 
   const openSidebarPanel = (panelName: SidebarItems) => () => {
     setUserLayout(prev => ({ ...prev, activeSidebarItem: panelName })).catch(
-      logAndIgnore,
+      logAndNotify("Failed to save your layout preferences."),
     );
     replaceGraphSelection({ edges: [edgeId], disableSideEffects: true });
   };
diff --git a/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts b/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
index a0a9f7057..e162f46c6 100644
--- a/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
+++ b/packages/graph-explorer/src/modules/GraphViewer/useAutoOpenDetailsSidebar.ts
@@ -1,7 +1,7 @@
 import { useSetAtom } from "jotai";
 
 import { userLayoutAtom } from "@/core";
-import { logAndIgnore } from "@/utils";
+import { logAndNotify } from "@/utils";
 
 export function useAutoOpenDetailsSidebar() {
   const setUserLayout = useSetAtom(userLayoutAtom);
@@ -15,6 +15,6 @@ export function useAutoOpenDetailsSidebar() {
         ...prev,
         activeSidebarItem: "details",
       };
-    }).catch(logAndIgnore);
+    }).catch(logAndNotify("Failed to save your layout preferences."));
   };
 }
diff --git a/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx b/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx
index 2fcaeddbe..9b218e420 100644
--- a/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx
+++ b/packages/graph-explorer/src/modules/Namespaces/UserPrefixes.tsx
@@ -36,7 +36,7 @@ import {
   useConfiguration,
 } from "@/core";
 import { usePrefixes } from "@/core/StateProvider/schema";
-import { logAndIgnore } from "@/utils";
+import { logAndNotify } from "@/utils";
 
 type PrefixForm = {
   prefix: string;
@@ -186,7 +186,7 @@ function useDeletePrefixCallback(prefix: string) {
           });
 
           return updatedSchemas;
-        }).catch(logAndIgnore);
+        }).catch(logAndNotify("Failed to delete the namespace prefix."));
       },
       [prefix],
     ),
@@ -238,7 +238,7 @@ function EditPrefixModal({
           });
 
           return updatedSchemas;
-        }).catch(logAndIgnore);
+        }).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 fc0e83b45..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 { logAndIgnore, parseNumberSafely } from "@/utils";
+import { logAndNotify, parseNumberSafely } from "@/utils";
 import {
   RESERVED_ID_PROPERTY,
   RESERVED_TYPES_PROPERTY,
@@ -120,7 +120,9 @@ function Content({ vertexType }: { vertexType: VertexType }) {
     try {
       const result = await file2Base64(file);
       setVertexStyle({ iconUrl: result, iconImageType: file.type }).catch(
-        logAndIgnore,
+        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);
diff --git a/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx b/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
index 2541c3a90..6e04ccd50 100644
--- a/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
+++ b/packages/graph-explorer/src/modules/NodesStyling/SingleNodeStyling.tsx
@@ -4,7 +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 { logAndIgnore } from "@/utils";
+import useTranslations from "@/hooks/useTranslations";
+import { logAndNotify } from "@/utils";
 import { LABELS } from "@/utils/constants";
 
 import { useOpenNodeStyleDialog } from "./NodeStyleDialog";
@@ -17,6 +18,7 @@ export default function SingleNodeStyling({
   vertexType,
   ...rest
 }: SingleNodeStylingProps) {
+  const t = useTranslations();
   const { setVertexStyle } = useVertexStyling(vertexType);
   const displayConfig = useDisplayVertexTypeConfig(vertexType);
 
@@ -32,8 +34,12 @@ export default function SingleNodeStyling({
     if (prevDisplayAs === null || prevDisplayAs === debouncedDisplayAs) {
       return;
     }
-    setVertexStyle({ displayLabel: debouncedDisplayAs }).catch(logAndIgnore);
-  }, [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/routes/DataExplorer/DataExplorer.tsx b/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx
index 005721213..dacc1582f 100644
--- a/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx
+++ b/packages/graph-explorer/src/routes/DataExplorer/DataExplorer.tsx
@@ -56,7 +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 { logAndIgnore } from "@/utils";
+import { logAndNotify } from "@/utils";
 import {
   LABELS,
   RESERVED_ID_PROPERTY,
@@ -258,13 +258,17 @@ function DisplayNameAndDescriptionOptions({
     (field: "name" | "longName") => (value: string | string[]) => {
       if (field === "name") {
         setPreferences({ displayNameAttribute: value as string }).catch(
-          logAndIgnore,
+          logAndNotify(
+            `Failed to save the ${t("node").toLowerCase()} display settings.`,
+          ),
         );
       }
 
       if (field === "longName") {
         setPreferences({ longDisplayNameAttribute: value as string }).catch(
-          logAndIgnore,
+          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 61bd2bf66..925dd98fb 100644
--- a/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx
+++ b/packages/graph-explorer/src/routes/Settings/SettingsGeneral.tsx
@@ -25,7 +25,7 @@ import {
   showDebugActionsAtom,
 } from "@/core";
 import { saveLocalForageToFile } from "@/core/StateProvider/localDb";
-import { logAndIgnore } from "@/utils";
+import { logAndNotify } from "@/utils";
 
 import LoadConfigButton from "./LoadConfigButton";
 
@@ -61,7 +61,7 @@ export default function SettingsGeneral() {
           checked={defaultNeighborExpansionLimitEnabled}
           onCheckedChange={isSelected => {
             setDefaultNeighborExpansionLimitEnabled(Boolean(isSelected)).catch(
-              logAndIgnore,
+              logAndNotify("Failed to save the setting."),
             );
           }}
         />
@@ -119,7 +119,9 @@ export default function SettingsGeneral() {
           value="isDiagnosticLoggingEnabled"
           checked={diagnosticLogging}
           onCheckedChange={isSelected => {
-            setDiagnosticLogging(Boolean(isSelected)).catch(logAndIgnore);
+            setDiagnosticLogging(Boolean(isSelected)).catch(
+              logAndNotify("Failed to save the setting."),
+            );
           }}
           label="Diagnostic logging"
           description="Enables verbose logging to the browser console for troubleshooting."
@@ -130,7 +132,9 @@ export default function SettingsGeneral() {
           value="isLoggingDbQueryEnabled"
           checked={allowLoggingDbQuery}
           onCheckedChange={isSelected => {
-            setAllowLoggingDbQuery(Boolean(isSelected)).catch(logAndIgnore);
+            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."
@@ -148,7 +152,9 @@ export default function SettingsGeneral() {
             value="isDebugOptionsEnabled"
             checked={isDebugOptionsEnabled}
             onCheckedChange={isSelected => {
-              setIsDebugOptionsEnabled(Boolean(isSelected)).catch(logAndIgnore);
+              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 16fe4f684..7fd157d99 100644
--- a/packages/graph-explorer/src/utils/index.ts
+++ b/packages/graph-explorer/src/utils/index.ts
@@ -7,6 +7,7 @@ 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/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);
+  };
+}