@multiplatform.one/backoffice 7.34.3 → 7.34.4

package/src/chrome/notifications-data.tsx

@@ -24,7 +24,8 @@ import {
   type FrappeApp,
 } from "@multiplatform.one/frappe";
 import { useFrappeConfig } from "@multiplatform.one/frappe-ui";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useMemo, useState } from "react";
+import { useSessionIdentity } from "../shared/sessionUser";
 import { useFrappeApp } from "../shared/useFrappeApp";
 import { parseFrappeTimestamp, stripHtmlToText } from "./notifications-utils";
 
@@ -72,54 +73,6 @@ const MARK_ALL_AS_READ_METHOD =
 // Session user (module cache — one fetch per FrappeApp per session)
 // ---------------------------------------------------------------------------
 
-const sessionUserCache = new WeakMap<FrappeApp, Promise<string | undefined>>();
-
-interface SessionUserState {
-  user?: string;
-  /** True once the probe settled (Guest / unreachable resolve to no user). */
-  resolved: boolean;
-}
-
-function useNotificationsSessionUser(fixtureMode: boolean): SessionUserState {
-  const app = useFrappeApp();
-  const [state, setState] = useState<SessionUserState>({ resolved: false });
-
-  useEffect(() => {
-    // Fixture mode has no session endpoint; report resolved-with-no-user.
-    // No app (no provider config) settles the same way so the panel never
-    // skeletons forever.
-    if (fixtureMode || !app) {
-      setState({ resolved: true });
-      return;
-    }
-    let cancelled = false;
-    let promise = sessionUserCache.get(app);
-    if (!promise) {
-      promise = app
-        .call()
-        .get<{ message?: string }>("frappe.auth.get_logged_user")
-        .then((res) => {
-          const user = res.payload?.message;
-          return user && user !== "Guest" ? user : undefined;
-        })
-        .catch(() => {
-          // Evict failed probes so a later mount can retry.
-          sessionUserCache.delete(app);
-          return undefined;
-        });
-      sessionUserCache.set(app, promise);
-    }
-    promise.then((user) => {
-      if (!cancelled) setState({ user, resolved: true });
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [app, fixtureMode]);
-
-  return state;
-}
-
 // ---------------------------------------------------------------------------
 // Mark-as-read RPCs
 // ---------------------------------------------------------------------------
@@ -174,7 +127,7 @@ export function useNotifications(): UseNotificationsResult {
   const config = useFrappeConfig();
   const app = useFrappeApp();
   const fixtureMode = Boolean(config?.fixtures);
-  const { user: sessionUser, resolved: sessionResolved } = useNotificationsSessionUser(fixtureMode);
+  const { user: sessionUser, resolved: sessionResolved } = useSessionIdentity();
 
   // Stable connection config (fresh identities would churn the collection).
   const connectionConfig = useMemo(

package/src/chrome/user-session.tsx

@@ -7,8 +7,9 @@ import React from "react";
  * frappe.client.get_value(User, <name>, ["full_name","user_image","email"]).
  */
 import type { FrappeApp } from "@multiplatform.one/frappe";
-import { useFrappeConfig } from "@multiplatform.one/frappe-ui";
+import { useFrappeConfig, type FrappeConfig } from "@multiplatform.one/frappe-ui";
 import { useEffect, useMemo, useState } from "react";
+import { clearSessionIdentityCache, loadSessionUser, sessionUserKey } from "../shared/sessionUser";
 import { useFrappeApp } from "../shared/useFrappeApp";
 
 export interface SessionUserInfo {
@@ -26,14 +27,12 @@ interface UserDocBits {
   email?: string;
 }
 
-// Keyed by FrappeApp instance: a different bench/auth config gets its own
-// entry (useFrappeApp memoizes apps per config). Failed fetches self-evict
-// so the next mount retries.
-let sessionCache = new WeakMap<FrappeApp, Promise<SessionUserInfo>>();
+const sessionCache = new Map<string, Promise<SessionUserInfo>>();
 
 /** Logout hygiene: drops every cached session-user fetch in this module. */
 export function clearSessionUserCache(): void {
-  sessionCache = new WeakMap();
+  sessionCache.clear();
+  clearSessionIdentityCache();
 }
 
 /** Resolve a User.user_image value (usually "/files/…") to an absolute URL. */
@@ -47,8 +46,13 @@ export function resolveUserImageUrl(
   return `${baseURL.replace(/\/+$/, "")}${userImage.startsWith("/") ? "" : "/"}${userImage}`;
 }
 
-async function fetchSessionUserInfo(app: FrappeApp, baseURL: string): Promise<SessionUserInfo> {
-  const user = await app.auth().getLoggedInUser();
+async function fetchSessionUserInfo(
+  app: FrappeApp,
+  config: FrappeConfig,
+): Promise<SessionUserInfo> {
+  const user = await loadSessionUser(config);
+  const baseURL = config.baseURL ?? "";
+  if (user === "Guest") return { user, fullName: user };
   if (!user) throw new Error("No session user");
   // Param format probed against the bench: filters takes the plain docname,
   // fieldname a JSON array (the http client JSON-encodes non-string params).
@@ -74,26 +78,27 @@ export function useSessionUserInfo(): {
 } {
   const app = useFrappeApp();
   const config = useFrappeConfig();
-  const baseURL = config?.baseURL ?? "";
+  const key = config ? sessionUserKey(config) : "";
   const [info, setInfo] = useState<SessionUserInfo | undefined>(undefined);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<Error | undefined>(undefined);
 
   useEffect(() => {
-    if (!app) {
+    if (!app || !config || config.fixtures) {
       setInfo(undefined);
       setLoading(false);
       return;
     }
     let cancelled = false;
-    let promise = sessionCache.get(app);
+    let promise = sessionCache.get(key);
     if (!promise) {
-      promise = fetchSessionUserInfo(app, baseURL);
-      sessionCache.set(app, promise);
+      promise = fetchSessionUserInfo(app, config);
+      sessionCache.set(key, promise);
       promise.catch(() => {
-        if (sessionCache.get(app) === promise) sessionCache.delete(app);
+        if (sessionCache.get(key) === promise) sessionCache.delete(key);
       });
     }
+    setInfo(undefined);
     setLoading(true);
     setError(undefined);
     promise
@@ -110,7 +115,7 @@ export function useSessionUserInfo(): {
     return () => {
       cancelled = true;
     };
-  }, [app, baseURL]);
+  }, [app, key, config]);
 
   return useMemo(() => ({ info, loading, error }), [info, loading, error]);
 }

package/src/form/DocFormScreen.guest.screen.spec.tsx

@@ -149,13 +149,13 @@ describe("DocFormScreen with DocType meta refused (LC-96)", () => {
     expect(screen.queryByRole("button", { name: /retry/i })).toBeNull();
   });
 
-  it("says the reader can't create, with each server message on its own line", async () => {
+  it("explains a create refusal without exposing server internals", async () => {
     renderForm("new");
     const state = await screen.findByTestId("frappe-form-not-permitted", {}, settle);
     expect(state.textContent).toContain(`You can't create ${doctype}`);
     const lines = Array.from(state.querySelectorAll("p")).map((node) => node.textContent);
-    expect(lines).toContain("You are not permitted to access this resource. Login to access");
-    expect(lines).toContain("Function frappe.desk.form.load.getdoctype is not whitelisted.");
+    expect(lines).toContain("You don't have permission to create this document.");
+    expect(state.textContent).not.toMatch(/frappe\.|whitelisted|Function/);
     expect(lines.some((line) => line?.includes("accessFunction"))).toBe(false);
     expect(button("Save")).toBeUndefined();
   });

package/src/list/DoctypeListScreen.guest.screen.spec.tsx

@@ -1,3 +1,4 @@
+import { StrictMode } from "react";
 // LC-96 on the desk list (MPO-477), the list twin of MPO-473. Signed out,
 // pokemon's bench refuses getdoctype, get_count and every desk RPC to Guest
 // while Guest can still read the rows through /api/resource, and the desk list
@@ -11,6 +12,12 @@ import { BackofficeProvider } from "../config/BackofficeProvider";
 import { createMemoryNavigator } from "../navigation/navigator";
 import { DoctypeListScreen } from "./DoctypeListScreen";
 
+const layout = vi.hoisted(() => ({ size: "wide" }));
+vi.mock("@multiplatform.one/theme", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@multiplatform.one/theme")>()),
+  useLayoutSizeClass: () => layout.size,
+}));
+
 const doctype = "Pokemon";
 
 const rows = [
@@ -29,6 +36,13 @@ const rows = [
     pokemon_name: "Bulbasaur",
     species: "Seed Pokémon",
     base_experience: 64,
+    image: "/files/bulbasaur.png",
+    height: 7,
+    weight: 69,
+    habitat: "grassland",
+    color: "green",
+    ability: "overgrow",
+    title: "Seed monster",
   },
   {
     name: "ivysaur",
@@ -61,6 +75,8 @@ let run = 0;
 let metaAnswer: "refused" | "broken" = "refused";
 let rowsReadable = true;
 let metaReads = 0;
+let countReads = 0;
+let countGate: Promise<void> | undefined;
 
 function json(body: unknown, status = 200) {
   return new Response(JSON.stringify(body), {
@@ -83,9 +99,12 @@ function refused(method: string) {
 
 beforeEach(() => {
   run += 1;
+  layout.size = "wide";
   metaAnswer = "refused";
   rowsReadable = true;
   metaReads = 0;
+  countReads = 0;
+  countGate = undefined;
   vi.stubGlobal("fetch", async (input: string | URL | Request) => {
     const url = new URL(String(input instanceof Request ? input.url : input));
     const method = url.pathname.replace(/^\/api\/method\//, "");
@@ -95,6 +114,11 @@ beforeEach(() => {
         ? refused(method)
         : json({ exc_type: "ValidationError", exception: "Pokemon is being migrated" }, 417);
     }
+    if (method === "frappe.client.get_count") {
+      countReads += 1;
+      await countGate;
+      return refused(method);
+    }
     if (url.pathname.startsWith("/api/method/")) return refused(method);
     if (url.pathname === `/api/resource/${doctype}`) {
       if (!rowsReadable) {
@@ -112,15 +136,16 @@ afterEach(() => {
   vi.unstubAllGlobals();
 });
 
-function renderList() {
-  return renderWithProviders(
+function renderList(strict = false) {
+  const tree = (
     <BackofficeProvider
       frappe={{ baseURL: `https://desk-list-guest-${run}.spec.test` }}
       navigation={createMemoryNavigator("/backoffice")}
     >
       <DoctypeListScreen doctype={doctype} />
-    </BackofficeProvider>,
+    </BackofficeProvider>
   );
+  return renderWithProviders(strict ? <StrictMode>{tree}</StrictMode> : tree);
 }
 
 function button(name: string): HTMLElement | undefined {
@@ -130,6 +155,40 @@ function button(name: string): HTMLElement | undefined {
 }
 
 describe("DoctypeListScreen with DocType meta refused (LC-96)", () => {
+  it.each(["wide", "compact"])(
+    "owns a bounded vertical scroll region in %s layout",
+    async (size) => {
+      layout.size = size;
+      renderList();
+      await waitFor(() => expect(screen.getByText("Bulbasaur")).toBeTruthy(), settle);
+      const region = screen.getByTestId("backoffice-list-scroll");
+      expect(["auto", "scroll"]).toContain(getComputedStyle(region).overflowY);
+      expect(getComputedStyle(region).minHeight).toBe("0px");
+      const content = region.firstElementChild?.firstElementChild as HTMLElement;
+      expect(getComputedStyle(content).flexBasis).toBe("auto");
+      expect(getComputedStyle(content).flexShrink).toBe("0");
+      expect(region.contains(screen.getByRole("heading", { name: doctype }))).toBe(false);
+    },
+  );
+
+  it("renders headers on wide screens and bounds sampled columns", async () => {
+    renderList();
+    await waitFor(() => expect(screen.getByText("Bulbasaur")).toBeTruthy(), settle);
+    expect(screen.getAllByRole("columnheader").length).toBeGreaterThan(0);
+    expect(screen.queryByText("/files/bulbasaur.png")).toBeNull();
+    expect(screen.queryByText("overgrow")).toBeNull();
+    expect(screen.getByText("Seed monster")).toBeTruthy();
+  });
+
+  it("keeps compact rows in a bounded document list", async () => {
+    layout.size = "compact";
+    renderList();
+    await waitFor(() => expect(screen.getByText("Bulbasaur")).toBeTruthy(), settle);
+    expect(screen.queryAllByRole("columnheader")).toEqual([]);
+    expect(screen.queryByText("/files/bulbasaur.png")).toBeNull();
+    expect(screen.queryByText("overgrow")).toBeNull();
+  });
+
   it("lists the rows Guest can read, laid out from a record's own fields", async () => {
     renderList();
     await waitFor(() => expect(screen.getByText("Bulbasaur")).toBeTruthy(), settle);
@@ -179,3 +238,23 @@ describe("DoctypeListScreen with DocType meta refused (LC-96)", () => {
     await waitFor(() => expect(metaReads).toBe(2), settle);
   });
 });
+
+it("requests one count for the list filter state, including strict effect replay", async () => {
+  renderList(true);
+  await waitFor(() => expect(screen.getByText("Bulbasaur")).toBeTruthy(), settle);
+  expect(countReads).toBe(1);
+});
+
+it("renders rows before a slow count settles", async () => {
+  let release!: () => void;
+  countGate = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  try {
+    renderList();
+    await waitFor(() => expect(screen.getByText("Bulbasaur")).toBeTruthy(), settle);
+    expect(countReads).toBe(1);
+  } finally {
+    release();
+  }
+});

package/src/list/DoctypeListScreen.tsx

@@ -17,7 +17,6 @@ import {
   Spinner,
   XStack,
   YStack,
-  isWeb,
   notify,
 } from "@multiplatform.one/components";
 import { useLayoutSizeClass, useResolvedKnobs } from "@multiplatform.one/theme";
@@ -235,7 +234,16 @@ export function DoctypeListScreen({
       (recordShape.fields
         ? {
             name: doctype,
-            fields: recordShape.fields.map((field) => ({ ...field, in_list_view: 1 as const })),
+            fields: [...recordShape.fields]
+              .sort(
+                (a, b) =>
+                  Number(b.fieldname === "title" || b.fieldname === "name") -
+                  Number(a.fieldname === "title" || a.fieldname === "name"),
+              )
+              .map((field, index) => ({
+                ...field,
+                in_list_view: index < 6 ? (1 as const) : (0 as const),
+              })),
           }
         : undefined),
     [meta, recordShape.fields, doctype],
@@ -981,7 +989,7 @@ export function DoctypeListScreen({
   );
 
   return (
-    <YStack flex={1} {...knobProps.gap} {...knobProps.panelPadding}>
+    <YStack flex={1} minHeight={0} {...knobProps.gap} {...knobProps.panelPadding}>
       <PageHeader
         gap="$2"
         heading={
@@ -1012,7 +1020,7 @@ export function DoctypeListScreen({
 
       {(() => {
         const listBody = (
-          <XStack flex={1} gap="$2" alignItems="stretch">
+          <XStack flexGrow={1} flexShrink={0} flexBasis="auto" gap="$2" alignItems="stretch">
             {/* Facet sidebar needs bench RPCs (fixture mode hides it) and is
                 hidden on narrow viewports (< $sm) like desk. MOD-04 keeps it:
                 facet clicks toggle tuples through the same baseFilters
@@ -1077,6 +1085,7 @@ export function DoctypeListScreen({
                   refreshToken={refreshGen}
                   enablePagination={!fixtureMode}
                   paginationMode="infinite"
+                  fetchTotalCount={false}
                   compact
                   // ONE FILTER SYSTEM (MOD-04 / LC-16): the list chrome is
                   // the single filtering authority; tuples reach the table
@@ -1094,20 +1103,17 @@ export function DoctypeListScreen({
                   onRowClick={handleRowClick}
                   onStateChange={handleStateChange}
                   rights={rights}
-                  layout="list"
+                  layout={compactChrome ? "list" : "table"}
                 />
               )}
             </YStack>
           </XStack>
         );
-        // Native has no page-level scroll and the table body ships none —
-        // wrap in a vertical ScrollView (DocFormScreen precedent) so rows
-        // below the fold stay reachable. Compact web is in the same boat:
-        // the card list renders in flow inside the shell's overflow-hidden
-        // frame, so it needs the same scroll wrapper (the compact header
-        // stays pinned above it). Wide web keeps the flex layout as-is —
-        // the grid body scrolls internally.
-        return isWeb && !compactChrome ? listBody : <ScrollView flex={1}>{listBody}</ScrollView>;
+        return (
+          <ScrollView flex={1} minHeight={0} testID="backoffice-list-scroll">
+            {listBody}
+          </ScrollView>
+        );
       })()}
 
       {showNew && (

package/src/report/DoctypeReportView.screen.spec.tsx

@@ -152,3 +152,15 @@ describe("<DoctypeReportView />", () => {
     ).toBeTruthy();
   });
 });
+
+it("keeps the report toolbar outside a bounded vertical body scrollport", async () => {
+  renderReport();
+  await waitFor(() => expect(screen.getByText("ACME Corp")).toBeTruthy());
+  const region = screen.getByTestId("frappe-report-scroll");
+  expect(["auto", "scroll"]).toContain(getComputedStyle(region).overflowY);
+  expect(getComputedStyle(region).minHeight).toBe("0px");
+  const content = region.firstElementChild?.firstElementChild as HTMLElement;
+  expect(getComputedStyle(content).flexBasis).toBe("auto");
+  expect(getComputedStyle(content).flexShrink).toBe("0");
+  expect(region.querySelector('[aria-label="Columns"]')).toBeNull();
+});

package/src/shared/sessionUser.spec.tsx

@@ -0,0 +1,106 @@
+import React from "react";
+import { FrappeProvider } from "@multiplatform.one/frappe-ui";
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { cleanup, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useWorkspaces } from "../shell/useWorkspaces";
+import { useSessionUserInfo } from "../chrome/user-session";
+import { useNotifications } from "../chrome/notifications-data";
+import { clearSessionUserCache } from "../chrome/user-session";
+import { loadSessionUser } from "./sessionUser";
+import { useSessionUserId } from "./useSessionUserId";
+
+let run = 0;
+let reads = 0;
+let status = 200;
+function Consumers() {
+  const workspaces = useWorkspaces();
+  const { info, loading } = useSessionUserInfo();
+  useNotifications();
+  const id = useSessionUserId();
+  return (
+    <div data-testid="session">
+      {JSON.stringify({ workspace: workspaces.sessionUser, user: info?.user, loading, id })}
+    </div>
+  );
+}
+function Tree({ token = "first" }: { token?: string }) {
+  return (
+    <FrappeProvider
+      baseURL={`https://shared-session-${run}.spec.test`}
+      auth={{ useToken: true, token, type: "Bearer" }}
+      realtime={false}
+    >
+      <Consumers />
+    </FrappeProvider>
+  );
+}
+beforeEach(() => {
+  run += 1;
+  reads = 0;
+  status = 200;
+  vi.stubGlobal("fetch", async (input: string | URL | Request) => {
+    const url = new URL(String(input instanceof Request ? input.url : input));
+    let body: unknown = { data: [], message: {} };
+    if (url.pathname.endsWith("frappe.auth.get_logged_user")) {
+      reads += 1;
+      body = status === 200 ? { message: "reader@example.test" } : { exc_type: "PermissionError" };
+      return new Response(JSON.stringify(body), {
+        status,
+        headers: { "content-type": "application/json" },
+      });
+    }
+    return new Response(JSON.stringify(body), { headers: { "content-type": "application/json" } });
+  });
+});
+afterEach(() => {
+  cleanup();
+  vi.unstubAllGlobals();
+});
+it.each([200, 401, 403])(
+  "shares identity across consumers and remounts after %s",
+  async (answer) => {
+    status = answer;
+    const view = renderWithProviders(<Tree />);
+    await waitFor(() =>
+      expect(screen.getByTestId("session").textContent).toContain('"loading":false'),
+    );
+    expect(reads).toBe(1);
+    view.unmount();
+    renderWithProviders(<Tree />);
+    await waitFor(() =>
+      expect(screen.getByTestId("session").textContent).toContain('"loading":false'),
+    );
+    expect(reads).toBe(1);
+  },
+);
+it("refetches identity when credentials change", async () => {
+  const view = renderWithProviders(<Tree />);
+  await waitFor(() =>
+    expect(screen.getByTestId("session").textContent).toContain('"loading":false'),
+  );
+  expect(reads).toBe(1);
+  view.rerender(<Tree token="second" />);
+  await waitFor(() => expect(reads).toBe(2));
+});
+
+it("does not retain a failed network request", async () => {
+  const request = vi.fn().mockRejectedValue(new TypeError("Network unavailable"));
+  vi.stubGlobal("fetch", request);
+  const config = { baseURL: `https://network-session-${run}.spec.test` };
+  await expect(loadSessionUser(config)).rejects.toThrow("Network unavailable");
+  request.mockResolvedValue(
+    new Response(JSON.stringify({ message: "reader" }), {
+      headers: { "content-type": "application/json" },
+    }),
+  );
+  await expect(loadSessionUser(config)).resolves.toBe("reader");
+});
+
+it("clears the shared identity when the user menu clears session caches", async () => {
+  const config = { baseURL: `https://logout-session-${run}.spec.test` };
+  await loadSessionUser(config);
+  clearSessionUserCache();
+  await loadSessionUser(config);
+  expect(reads).toBe(2);
+});

package/src/shared/sessionUser.ts

@@ -0,0 +1,59 @@
+import { HttpClient, type AuthConfig } from "@multiplatform.one/frappe";
+import { useFrappeConfig, type FrappeConfig } from "@multiplatform.one/frappe-ui";
+import { useEffect, useState } from "react";
+
+const cache = new Map<string, Promise<string>>();
+
+export function sessionUserKey(config: Pick<FrappeConfig, "baseURL" | "auth">): string {
+  const auth = config.auth;
+  return `${config.baseURL}:${auth?.useToken ? "t" : ""}:${auth?.token ?? ""}:${auth?.type ?? ""}`;
+}
+
+export function clearSessionIdentityCache(): void {
+  cache.clear();
+}
+
+export function loadSessionUser(config: Pick<FrappeConfig, "baseURL" | "auth">): Promise<string> {
+  if (!config.baseURL) return Promise.reject(new Error("No session endpoint"));
+  const key = sessionUserKey(config);
+  let promise = cache.get(key);
+  if (!promise) {
+    const client = new HttpClient(config.baseURL, config.auth as AuthConfig | undefined);
+    promise = client
+      .get<{ message?: string }>("/api/method/frappe.auth.get_logged_user")
+      .then((response) => response.payload?.message || "Guest")
+      .catch((error: unknown) => {
+        const status = (error as { status?: number })?.status;
+        if (status === 401 || status === 403) return "Guest";
+        if (cache.get(key) === promise) cache.delete(key);
+        throw error;
+      });
+    cache.set(key, promise);
+  }
+  return promise;
+}
+
+export function useSessionIdentity(): { user?: string; resolved: boolean } {
+  const config = useFrappeConfig();
+  const key = config?.baseURL && !config.fixtures ? sessionUserKey(config) : undefined;
+  const [state, setState] = useState<{ key?: string; user?: string; resolved: boolean }>({
+    resolved: false,
+  });
+  useEffect(() => {
+    if (!key || !config) return;
+    let cancelled = false;
+    loadSessionUser(config)
+      .then((user) => {
+        if (!cancelled)
+          setState({ key, user: user === "Guest" ? undefined : user, resolved: true });
+      })
+      .catch(() => {
+        if (!cancelled) setState({ key, resolved: true });
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [key, config]);
+  if (!key) return { resolved: true };
+  return state.key === key ? state : { resolved: false };
+}

package/src/shared/useSessionUserId.ts

@@ -1,43 +1,5 @@
-// Session user id (for liked-hearts + "assigned to me"), cached per app.
-// (The shell's useSessionUser in shell/useWorkspaces.ts is the HttpClient
-// variant used by the sidebar; this one rides the FrappeApp auth module.)
-import { useFrappeConfig } from "@multiplatform.one/frappe-ui";
-import { useEffect, useState } from "react";
-import { useFrappeApp } from "./useFrappeApp";
+import { useSessionIdentity } from "./sessionUser";
 
-const userCache = new Map<string, Promise<string>>();
-
-/**
- * The logged-in user's id (`frappe.auth.get_logged_user`), or undefined
- * while loading / in fixture mode (no session exists against fixtures).
- */
 export function useSessionUserId(): string | undefined {
-  const config = useFrappeConfig();
-  const app = useFrappeApp();
-  const fixtureMode = Boolean(config?.fixtures);
-  const [user, setUser] = useState<string | undefined>(undefined);
-
-  useEffect(() => {
-    const baseURL = config?.baseURL;
-    if (!app || fixtureMode || !baseURL) return;
-    let cancelled = false;
-    let promise = userCache.get(baseURL);
-    if (!promise) {
-      promise = app.auth().getLoggedInUser();
-      userCache.set(baseURL, promise);
-      promise.catch(() => userCache.delete(baseURL));
-    }
-    promise
-      .then((value) => {
-        if (!cancelled && value) setUser(value);
-      })
-      .catch(() => {
-        // No session — hearts render unfilled, "me" facets hidden.
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [app, fixtureMode, config?.baseURL]);
-
-  return user;
+  return useSessionIdentity().user;
 }