Tighten layout codecs and extend cross-tab test coverage

- Move the graphViewLayout activeToggles Set rebuild from an object-level
  transform onto the activeToggles field, so the transform sits on the
  field it converts and the object schema infers the runtime shape.
- Correct the SessionValueCodec.deserialize contract doc: it returns null
  only for an absent value and throws on a corrupt one, which the seam
  catches. Do not swallow errors in the codec.
- Drop the unused session() accessor from the test tab harness.
- Add cross-tab coverage for both layout codecs through the real codecs
  (graph view proves the activeToggles Set survives the array round-trip
  across a write-then-cold-start sequence; schema view covers isolation
  and cold-start seeding), matching the active-connection assurances.

Author: kmcginnes

packages/graph-explorer/src/core/StateProvider/graphViewLayoutDefaults.ts

@@ -36,20 +36,15 @@ export type GraphViewLayout = {
  * rebuilds the runtime {@link GraphViewLayout}, so a hand-edited or stale
  * per-tab value with the wrong shape is rejected rather than seeding bad state.
  */
-const serializedGraphViewLayoutSchema = z
-  .object({
-    activeSidebarItem: graphViewSidebarItemSchema.nullable(),
-    sidebar: z.object({ width: z.number() }),
-    activeToggles: z.array(toggleableViewSchema),
-    tableView: z.object({ height: z.number() }).optional(),
-    detailsAutoOpenOnSelection: z.boolean().optional(),
-  })
-  .transform(
-    (value): GraphViewLayout => ({
-      ...value,
-      activeToggles: new Set(value.activeToggles),
-    }),
-  );
+const serializedGraphViewLayoutSchema = z.object({
+  activeSidebarItem: graphViewSidebarItemSchema.nullable(),
+  sidebar: z.object({ width: z.number() }),
+  activeToggles: z
+    .array(toggleableViewSchema)
+    .transform(toggles => new Set(toggles)),
+  tableView: z.object({ height: z.number() }).optional(),
+  detailsAutoOpenOnSelection: z.boolean().optional(),
+});
 
 /** Default height for the table view panel in pixels. */
 export const DEFAULT_TABLE_VIEW_HEIGHT = 300;

packages/graph-explorer/src/core/StateProvider/sessionScopedStorage.test.ts

@@ -12,6 +12,11 @@ import {
 } from "./graphViewLayoutDefaults";
 import { persistenceStatusStore } from "./persistence";
 import { createInMemorySessionStorage } from "./safeSessionStorage";
+import {
+  defaultSchemaViewLayout,
+  type SchemaViewLayout,
+  schemaViewLayoutCodec,
+} from "./schemaViewLayoutDefaults";
 import {
   createSessionScopedAtom,
   parseSessionJson,
@@ -34,38 +39,47 @@ const counterCodec: SessionValueCodec<Counter> = {
 const KEY = "test-counter";
 
 /**
- * Simulates one browser tab over the counter atom: its own Jotai store and
- * sessionStorage (per-tab), all tabs sharing the one fake-indexeddb. Mirrors
- * the active-connection test harness.
+ * Builds a tab-opener bound to one key/default/codec. Each opened tab has its
+ * own Jotai store and sessionStorage (per-tab), while all tabs share the one
+ * fake-indexeddb — exactly how same-origin tabs relate. Mirrors the
+ * active-connection test harness, parameterized so each real codec can be
+ * exercised through the same multi-tab sequences rather than only a toy codec.
  */
-async function openTab() {
-  const sessionStorage = createInMemorySessionStorage();
-  let store = createStore();
-  let atom = await createSessionScopedAtom<Counter>({
-    key: KEY,
-    defaultValue: { count: 0 },
-    codec: counterCodec,
-    sessionStorage,
-  });
-  return {
-    read: () => store.get(atom),
-    write: (value: Counter) => {
-      store.set(atom, value);
-      return persistenceStatusStore.waitForIdle();
-    },
-    session: () => sessionStorage.getItem(KEY),
-    reload: async () => {
-      store = createStore();
-      atom = await createSessionScopedAtom<Counter>({
-        key: KEY,
-        defaultValue: { count: 0 },
-        codec: counterCodec,
-        sessionStorage,
-      });
-    },
+function tabOpener<T>(
+  key: string,
+  defaultValue: T,
+  codec: SessionValueCodec<T>,
+) {
+  return async function openTab() {
+    const sessionStorage = createInMemorySessionStorage();
+    let store = createStore();
+    let atom = await createSessionScopedAtom<T>({
+      key,
+      defaultValue,
+      codec,
+      sessionStorage,
+    });
+    return {
+      read: () => store.get(atom),
+      write: (value: T) => {
+        store.set(atom, value);
+        return persistenceStatusStore.waitForIdle();
+      },
+      reload: async () => {
+        store = createStore();
+        atom = await createSessionScopedAtom<T>({
+          key,
+          defaultValue,
+          codec,
+          sessionStorage,
+        });
+      },
+    };
   };
 }
 
+const openTab = tabOpener<Counter>(KEY, { count: 0 }, counterCodec);
+
 describe("createSessionScopedAtom", () => {
   beforeEach(async () => {
     await localForage.clear();
@@ -278,3 +292,98 @@ describe("createSessionScopedAtom with the graph view layout codec", () => {
     ).toStrictEqual(breadcrumb);
   });
 });
+
+// The two layout atoms ride the same primitive as the active connection, so
+// they get the same multi-tab assurances active-connection has — proven
+// through their real codecs, not the toy counter codec. The graph view codec
+// is the interesting one: its activeToggles Set must survive the array
+// serialization across a write-in-one-tab / cold-start-in-another sequence.
+describe("graph view layout across tabs", () => {
+  const openGraphViewTab = tabOpener<GraphViewLayout>(
+    "graph-view-layout",
+    defaultGraphViewLayout,
+    graphViewLayoutCodec,
+  );
+
+  beforeEach(async () => {
+    await localForage.clear();
+  });
+
+  test("changing layout in one tab does not change an already-open tab", async () => {
+    const tabB = await openGraphViewTab();
+    const tabBLayout: GraphViewLayout = {
+      ...defaultGraphViewLayout,
+      activeSidebarItem: "filters",
+      activeToggles: new Set(["graph-viewer"]),
+    };
+    await tabB.write(tabBLayout);
+
+    const tabA = await openGraphViewTab();
+    await tabA.write({
+      ...defaultGraphViewLayout,
+      activeSidebarItem: "edges-styling",
+    });
+
+    expect(tabB.read()).toStrictEqual(tabBLayout);
+  });
+
+  test("a later tab cold-starts to the layout an earlier tab wrote, with toggles rebuilt as a Set", async () => {
+    const earlierTab = await openGraphViewTab();
+    const written: GraphViewLayout = {
+      ...defaultGraphViewLayout,
+      activeSidebarItem: "expand",
+      activeToggles: new Set(["table-view"]),
+      sidebar: { width: 512 },
+    };
+    await earlierTab.write(written);
+
+    const freshTab = await openGraphViewTab();
+
+    const seeded = freshTab.read();
+    expect(seeded).toStrictEqual(written);
+    expect(seeded.activeToggles).toBeInstanceOf(Set);
+  });
+});
+
+describe("schema view layout across tabs", () => {
+  const openSchemaViewTab = tabOpener<SchemaViewLayout>(
+    "schema-view-layout",
+    defaultSchemaViewLayout,
+    schemaViewLayoutCodec,
+  );
+
+  beforeEach(async () => {
+    await localForage.clear();
+  });
+
+  test("changing layout in one tab does not change an already-open tab", async () => {
+    const tabB = await openSchemaViewTab();
+    const tabBLayout: SchemaViewLayout = {
+      ...defaultSchemaViewLayout,
+      activeSidebarItem: "nodes-styling",
+    };
+    await tabB.write(tabBLayout);
+
+    const tabA = await openSchemaViewTab();
+    await tabA.write({
+      ...defaultSchemaViewLayout,
+      activeSidebarItem: "edges-styling",
+    });
+
+    expect(tabB.read()).toStrictEqual(tabBLayout);
+  });
+
+  test("a later tab cold-starts to the layout an earlier tab wrote", async () => {
+    const earlierTab = await openSchemaViewTab();
+    const written: SchemaViewLayout = {
+      ...defaultSchemaViewLayout,
+      activeSidebarItem: "edges-styling",
+      sidebar: { width: 480 },
+    };
+    await earlierTab.write(written);
+
+    const freshTab = await openSchemaViewTab();
+
+    expect(freshTab.read()).toStrictEqual(written);
+  });
+});

packages/graph-explorer/src/core/StateProvider/sessionScopedStorage.ts

@@ -15,8 +15,11 @@ import { createWriteThroughAtom } from "./writeThroughAtom";
  *
  * `serialize` returns `null` to mean "remove the per-tab key" — used when the
  * value is the kind of empty/cleared state that should not seed a later reload.
- * `deserialize` returns `null` when the stored string is missing or corrupt, so
- * seeding falls through to the breadcrumb rather than adopting a bad value.
+ * `deserialize` returns `null` for an absent value (a legitimate miss); a
+ * present-but-invalid value is corrupt and **throws** — the seam
+ * (`createSessionScopedAtom`) catches it and treats it as a miss, so detecting
+ * corruption stays separate from deciding what to do about it. Do not swallow
+ * errors here.
  */
 export type SessionValueCodec<T> = {
   serialize: (value: T) => string | null;