@vc-shell/framework 1.2.4-beta.4 → 1.2.4-beta.6

package/core/composables/index.ts

@@ -22,5 +22,8 @@ export * from "@core/composables/useToolbar";
 export * from "@core/composables/useDynamicProperties";
 export * from "@core/composables/useBlade";
 export * from "@core/composables/useSidebarState";
+export * from "@core/composables/useWebVitals";
+// Note: useConnectionStatus is NOT re-exported here to avoid circular
+// dependency. Import directly from "@core/composables/useConnectionStatus".
 // useBladeSelection and useAiAgent are now part of the ai-agent plugin
 // export * from "./core/plugins/ai-agent";

package/core/composables/useAssets/index.ts

@@ -1,6 +1,6 @@
 import { computed, ref, ComputedRef } from "vue";
 import * as _ from "lodash-es";
-import { ICommonAsset } from "@core/types";
+import type { ICommonAsset } from "@core/types";
 import { createLogger } from "@core/utilities";
 
 const logger = createLogger("use-assets");

package/core/composables/useAsync/index.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { useAsync } from "./index";
+import { DisplayableError, parseError } from "@core/utilities/error";
+import { cancelPendingErrorNotification } from "@core/utilities/pendingErrorNotifications";
+
+vi.mock("@shared/components/notifications/core/notification", () => ({
+  notification: { error: vi.fn(), remove: vi.fn() },
+}));
+
+import { notification } from "@shared/components/notifications/core/notification";
+
+describe("useAsync", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("should return error ref alongside loading and action", () => {
+    const { loading, action, error } = useAsync(async () => {});
+    expect(loading.value).toBe(false);
+    expect(error.value).toBeNull();
+    expect(typeof action).toBe("function");
+  });
+
+  it("should set error ref on failure", async () => {
+    const { action, error } = useAsync(async () => {
+      throw new Error("test");
+    });
+    await expect(action()).rejects.toThrow("test");
+    expect(error.value).toBeInstanceOf(DisplayableError);
+    expect(error.value!.message).toBe("test");
+  });
+
+  it("should clear error on next successful invocation", async () => {
+    let shouldFail = true;
+    const { action, error } = useAsync(async () => {
+      if (shouldFail) throw new Error("fail");
+    });
+
+    await expect(action()).rejects.toThrow();
+    expect(error.value).not.toBeNull();
+
+    shouldFail = false;
+    await action();
+    expect(error.value).toBeNull();
+  });
+
+  it("should schedule deferred notification by default", async () => {
+    const { action } = useAsync(async () => {
+      throw new Error("notify me");
+    });
+    await expect(action()).rejects.toThrow();
+
+    // Before timer fires, notification not yet shown
+    expect(notification.error).not.toHaveBeenCalled();
+
+    // After timer fires (+ microtask flush for dynamic import), notification appears
+    await vi.runAllTimersAsync();
+    expect(notification.error).toHaveBeenCalledWith(
+      "notify me",
+      expect.objectContaining({ notificationId: expect.any(String) }),
+    );
+  });
+
+  it("should allow ErrorInterceptor to cancel deferred notification", async () => {
+    const { action } = useAsync(async () => {
+      throw new Error("cancellable");
+    });
+
+    let caughtError: unknown;
+    try {
+      await action();
+    } catch (e) {
+      caughtError = e;
+    }
+
+    // Simulate what ErrorInterceptor does — cancel before timer fires
+    const cancelled = cancelPendingErrorNotification(caughtError);
+    expect(cancelled).toBe(true);
+
+    await vi.runAllTimersAsync();
+    expect(notification.error).not.toHaveBeenCalled();
+  });
+
+  it("should cancel via DisplayableError.originalError (real ErrorInterceptor flow)", async () => {
+    const { action } = useAsync(async () => {
+      throw new Error("wrapped-cancel");
+    });
+
+    let caughtError: unknown;
+    try {
+      await action();
+    } catch (e) {
+      caughtError = e;
+    }
+
+    // useErrorHandler wraps the error via parseError() → DisplayableError.
+    // The watch in ErrorInterceptor receives this wrapped object, not the original.
+    const wrappedError = parseError(caughtError);
+
+    const cancelled = cancelPendingErrorNotification(wrappedError);
+    expect(cancelled).toBe(true);
+
+    await vi.runAllTimersAsync();
+    expect(notification.error).not.toHaveBeenCalled();
+  });
+
+  it("should suppress notification when notify: false", async () => {
+    const { action } = useAsync(
+      async () => {
+        throw new Error("silent");
+      },
+      { notify: false },
+    );
+    await expect(action()).rejects.toThrow();
+    await vi.runAllTimersAsync();
+    expect(notification.error).not.toHaveBeenCalled();
+  });
+
+  it("should still re-throw (backward compat)", async () => {
+    const { action } = useAsync(async () => {
+      throw new Error("rethrow");
+    });
+    await expect(action()).rejects.toThrow("rethrow");
+  });
+
+  it("backward compat: destructuring without error works", async () => {
+    const { loading, action } = useAsync(async () => "result");
+    const result = await action();
+    expect(result).toBe("result");
+    expect(loading.value).toBe(false);
+  });
+});

package/core/composables/useAsync/index.ts

@@ -1,27 +1,80 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { readonly, ref } from "vue";
+import { readonly, ref, type Ref, type DeepReadonly } from "vue";
 import { HasLoading } from "@core/composables/useLoading";
+import { parseError, DisplayableError } from "@core/utilities/error";
+import { setPendingErrorNotification } from "@core/utilities/pendingErrorNotifications";
 import { createLogger } from "@core/utilities";
 
+// Lazy-resolved reference to the notification singleton.
+// We avoid a top-level import of `@shared/components/notifications/core/notification`
+// because that module transitively pulls in UI components (@ui/components) which
+// import from @core/composables — creating a circular dependency at module load time.
+let _notification: typeof import("@shared/components/notifications/core/notification").notification | undefined;
+
 const logger = createLogger("use-async");
 
 export type AsyncAction<Payload = void, Result = void> = (payload?: Payload, ...rest: any[]) => Promise<Result>;
 
+export interface UseAsyncOptions {
+  /**
+   * Show error notification on failure. Default: true.
+   *
+   * Notifications are deferred via setTimeout(0) so that ErrorInterceptor
+   * can cancel them when it catches the same error for blade banner display.
+   * This prevents duplicate toast+banner for load errors while still
+   * showing toasts for save/delete errors caught by module try/catch.
+   */
+  notify?: boolean;
+  /** Notification timeout in ms. Default: 8000 */
+  notifyTimeout?: number;
+}
+
 export interface UseAsync<Payload = void, Result = void> extends HasLoading {
   action: AsyncAction<Payload, Result>;
+  /** Reactive error state — set on failure, cleared on next invocation */
+  error: DeepReadonly<Ref<DisplayableError | null>>;
 }
 
 export function useAsync<Payload = void, Result = void>(
   innerAction: AsyncAction<Payload, Result>,
+  options?: UseAsyncOptions,
 ): UseAsync<Payload, Result> {
   const loading = ref(false);
+  const error = ref<DisplayableError | null>(null);
+
+  const shouldNotify = options?.notify !== false;
+  const notifyTimeout = options?.notifyTimeout ?? 8000;
 
   async function action(payload?: Payload, ...rest: any[]): Promise<Result> {
     loading.value = true;
+    error.value = null;
+
     try {
       return await innerAction(payload, ...rest);
     } catch (e) {
+      const parsed = parseError(e);
+      error.value = parsed;
       logger.error("Async action failed:", e);
+
+      if (shouldNotify && e && typeof e === "object") {
+        const notifId = `async-error-${parsed.message.slice(0, 80)}`;
+
+        // Defer notification so ErrorInterceptor can cancel it
+        // when onErrorCaptured fires (synchronously, before setTimeout(0) callback)
+        const timerId = setTimeout(async () => {
+          if (!_notification) {
+            const mod = await import("@shared/components/notifications/core/notification");
+            _notification = mod.notification;
+          }
+          _notification.error(parsed.message, {
+            timeout: notifyTimeout,
+            notificationId: notifId,
+          });
+        }, 0);
+
+        setPendingErrorNotification(e, timerId, notifId);
+      }
+
       throw e;
     } finally {
       loading.value = false;
@@ -30,6 +83,7 @@ export function useAsync<Payload = void, Result = void>(
 
   return {
     loading: readonly(loading),
+    error: readonly(error),
     action,
   };
 }

package/core/composables/useBladeRegistry/index.ts

@@ -1,5 +1,5 @@
 import { App, inject, shallowRef, computed, ComputedRef, readonly as vueReadonly } from "vue";
-import { BladeInstanceConstructor } from "@shared/components/blade-navigation/types";
+import type { BladeInstanceConstructor } from "@shared/components/blade-navigation/types";
 import { createLogger } from "@core/utilities";
 
 const logger = createLogger("blade-registry");

package/core/composables/useBreadcrumbs/index.ts

@@ -1,4 +1,4 @@
-import { Breadcrumbs } from "@ui/types";
+import type { Breadcrumbs } from "@ui/types";
 import { ComputedRef, computed, shallowRef } from "vue";
 import { createLogger } from "@core/utilities";
 

package/core/composables/useConnectionStatus/index.ts

@@ -0,0 +1,48 @@
+import { watch, readonly, ref } from "vue";
+import { useNetwork } from "@vueuse/core";
+import { notification } from "@shared/components/notifications/core/notification";
+import { createLogger } from "@core/utilities";
+
+const logger = createLogger("connection-status");
+
+const OFFLINE_NOTIFICATION_ID = "vc-framework-offline-status";
+
+// Module-level singleton state
+const _isSetup = ref(false);
+const _isOnline = ref(true);
+
+export interface UseConnectionStatus {
+  isOnline: Readonly<typeof _isOnline>;
+}
+
+export function useConnectionStatus(): UseConnectionStatus {
+  if (!_isSetup.value && typeof window !== "undefined") {
+    _isSetup.value = true;
+
+    const { isOnline } = useNetwork();
+
+    watch(isOnline, (online) => {
+      _isOnline.value = online;
+
+      if (!online) {
+        logger.warn("Network connection lost");
+        notification.warning(
+          "You are currently offline. Some features may be unavailable.",
+          {
+            notificationId: OFFLINE_NOTIFICATION_ID,
+            timeout: false,
+          },
+        );
+        document.documentElement.classList.add("vc-offline");
+      } else {
+        logger.info("Network connection restored");
+        notification.remove(OFFLINE_NOTIFICATION_ID);
+        document.documentElement.classList.remove("vc-offline");
+      }
+    }, { immediate: true });
+  }
+
+  return {
+    isOnline: readonly(_isOnline),
+  };
+}

package/core/composables/useDynamicProperties/index.ts

@@ -272,11 +272,12 @@ export const useDynamicProperties = <
     property: TProperty,
     value: string | TPropertyValue[] | (TPropertyDictionaryItem & { value: string })[],
     dictionary: TPropertyDictionaryItem[],
+    locale?: string,
   ): void {
     const dict = dictionary.map((x) => new PropertyDictionaryItemConstructor(x));
 
     if (isMultilanguageProperty(property)) {
-      handleMultilanguageDictionary(property, value, dict);
+      handleMultilanguageDictionary(property, value, dict, locale);
     } else {
       handleSingleLanguageDictionary(property, value, dict);
     }
@@ -286,11 +287,12 @@ export const useDynamicProperties = <
     property: TProperty,
     value: string | TPropertyValue[] | (TPropertyDictionaryItem & { value: string })[],
     dict: TPropertyDictionaryItem[],
+    locale?: string,
   ): void {
     if (Array.isArray(value)) {
       handleMultilanguageMultivalueDictionary(property, value as (TPropertyDictionaryItem & { value: string })[], dict);
     } else {
-      handleMultilanguageSingleValueDictionary(property, value as string, dict);
+      handleMultilanguageSingleValueDictionary(property, value as string, dict, locale);
     }
   }
 
@@ -323,10 +325,16 @@ export const useDynamicProperties = <
     property: TProperty,
     value: string,
     dict: TPropertyDictionaryItem[],
+    locale?: string,
   ): void {
     const dictionaryItem = dict.find((x) => x.id === value);
 
-    if (dictionaryItem?.localizedValues) {
+    if (!dictionaryItem) {
+      property.values = [];
+      return;
+    }
+
+    if (dictionaryItem.localizedValues?.length) {
       property.values = dictionaryItem.localizedValues.map((locValue) =>
         createPropertyValue({
           propertyId: dictionaryItem.propertyId,
@@ -338,7 +346,23 @@ export const useDynamicProperties = <
         } as Partial<TPropertyValue>),
       );
     } else {
-      property.values = [];
+      // Fallback: localizedValues is missing or empty (e.g. improperly created on platform side).
+      // Use existing language codes from property.values, or fall back to current locale.
+      const existingLanguageCodes = [
+        ...new Set((property.values ?? []).map((v) => v.languageCode).filter(Boolean)),
+      ];
+      const languageCodes = existingLanguageCodes.length > 0 ? existingLanguageCodes : locale ? [locale] : [];
+
+      property.values = languageCodes.map((langCode) =>
+        createPropertyValue({
+          propertyId: dictionaryItem.propertyId,
+          alias: dictionaryItem.alias,
+          languageCode: langCode,
+          value: dictionaryItem.alias,
+          valueId: dictionaryItem.id,
+          colorCode: dictionaryItem.colorCode,
+        } as Partial<TPropertyValue>),
+      );
     }
   }
 
@@ -528,7 +552,7 @@ export const useDynamicProperties = <
     }
 
     if (dictionary?.length) {
-      setDictionaryPropertyValue(property, value, dictionary);
+      setDictionaryPropertyValue(property, value, dictionary, locale);
       return;
     }
 

package/core/composables/useKeyboardNavigation/index.ts

@@ -174,6 +174,11 @@ export function useKeyboardNavigation(options: UseKeyboardNavigationOptions = {}
    * Initialization and event processing
    */
   const initKeyboardNavigation = (el: HTMLElement) => {
+    // Clean up previous listener to avoid double-registration
+    // (onMounted may have auto-attached to a global containerSelector match)
+    if (container.value) {
+      container.value.removeEventListener("keydown", handleKeyDown);
+    }
     container.value = el;
     el.addEventListener("keydown", handleKeyDown);
   };

package/core/composables/useMenuService/index.ts

@@ -3,6 +3,7 @@ import {
   MenuService,
   createMenuService,
   addMenuItem,
+  removeRegisteredMenuItem,
   setMenuBadge,
   getMenuBadge,
   removeMenuBadge,
@@ -39,4 +40,4 @@ export function useMenuService(): MenuService {
   return service;
 }
 
-export { addMenuItem, setMenuBadge, getMenuBadge, removeMenuBadge, getMenuBadges };
+export { addMenuItem, removeRegisteredMenuItem, setMenuBadge, getMenuBadge, removeMenuBadge, getMenuBadges };

package/core/composables/useSidebarState/index.ts

@@ -1,6 +1,6 @@
 import { ref, computed, provide, inject } from "vue";
 import type { Ref, ComputedRef, InjectionKey } from "vue";
-import { useMenuExpanded } from "@shared/composables";
+import { useMenuExpanded } from "@shared/composables/useMenuExpanded";
 
 export interface SidebarState {
   /** Sidebar is pinned open by user (persisted to localStorage) */

package/core/composables/useUser/index.ts

@@ -12,7 +12,7 @@ import {
   LoginRequest,
   SignInResult,
 } from "@core/api/platform";
-import { RequestPasswordResult } from "@core/types";
+import type { RequestPasswordResult } from "@core/types";
 import { createSharedComposable } from "@vueuse/core";
 import { useExternalProvider } from "@shared/components/sign-in/useExternalProvider";
 import { createLogger } from "@core/utilities";
@@ -181,6 +181,10 @@ export function _createInternalUserLogic(): IUserInternalAPI {
       const result = await securityClient.login(new LoginRequest({ userName: username, password }));
       logger.debug("signIn - Cookie login completed:", result);
 
+      if (!result.succeeded) {
+        return result;
+      }
+
       // Then get OAuth token for API calls (direct fetch, bypasses API client)
       // Request offline_access scope to get refresh_token for automatic token renewal
       logger.debug("signIn - Requesting token...");
@@ -207,7 +211,19 @@ export function _createInternalUserLogic(): IUserInternalAPI {
       throw { succeeded: false };
     } catch (e: any) {
       logger.error("signIn failed:", e);
-      return { succeeded: false, error: e.message, status: e.status };
+
+      // Extract human-readable error from ApiException.response (raw JSON from server)
+      let error = e.message;
+      if (e.response) {
+        try {
+          const body = JSON.parse(e.response);
+          error = body.errorDescription || body.errors?.[0]?.description || body.error || error;
+        } catch {
+          // response is not JSON, keep e.message
+        }
+      }
+
+      return { succeeded: false, error, status: e.status };
     } finally {
       loading.value = false;
     }
@@ -234,8 +250,18 @@ export function _createInternalUserLogic(): IUserInternalAPI {
 
     try {
       loading.value = true;
-      user.value = await securityClient.getCurrentUser();
-      await getAccessToken();
+      performance.mark("vc:auth-start");
+
+      // getCurrentUser() and getAccessToken() have no data dependency.
+      // getAccessToken() reads from localStorage (sync ~0ms) or refreshes via /connect/token.
+      // Running in parallel saves one sequential round-trip on token refresh paths.
+      const [userDetail] = await Promise.all([
+        securityClient.getCurrentUser(),
+        getAccessToken(),
+      ]);
+
+      user.value = userDetail;
+      performance.mark("vc:auth-done");
       logger.debug("User details loaded:", user.value);
     } catch (e: any) {
       logger.error("loadUser failed:", e);

package/core/composables/useUser/useUser.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// --- Stable mock function references ---
+// These live at module scope so the SecurityClient mock factory can close over them.
+// Each test configures getCurrentUser behavior via mockImplementationOnce / mockResolvedValueOnce.
+const mockGetCurrentUser = vi.fn();
+const mockPerformanceMark = vi.fn();
+
+vi.mock("@core/utilities", () => ({
+  createLogger: () => ({
+    debug: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  }),
+}));
+
+vi.mock("@shared/components/sign-in/useExternalProvider", () => ({
+  useExternalProvider: () => ({
+    storage: { value: null },
+    signOut: vi.fn(),
+  }),
+}));
+
+vi.mock("@core/api/platform", () => ({
+  SecurityClient: vi.fn().mockImplementation(() => ({
+    getCurrentUser: mockGetCurrentUser,
+    login: vi.fn(),
+    logout: vi.fn(),
+    validatePasswordResetToken: vi.fn(),
+    validatePassword: vi.fn(),
+    resetPasswordByToken: vi.fn(),
+    requestPasswordReset: vi.fn(),
+    changeCurrentUserPassword: vi.fn(),
+    getLoginTypes: vi.fn(),
+  })),
+  LoginRequest: vi.fn().mockImplementation((args: unknown) => args),
+}));
+
+// Import after mocks are registered
+import { _createInternalUserLogic } from "./index";
+
+// Use a single store reference accessible across tests for localStorage mock
+let localStorageStore: Record<string, string> = {};
+
+beforeEach(() => {
+  // Reset only the mock functions' call history and implementation queues.
+  // Do NOT call vi.restoreAllMocks() — it also restores vi.mock()-created mocks
+  // (including SecurityClient), breaking them for subsequent tests.
+  mockGetCurrentUser.mockReset();
+  mockPerformanceMark.mockReset();
+
+  // Fresh localStorage per test
+  localStorageStore = {};
+  vi.spyOn(Storage.prototype, "getItem").mockImplementation((key) => localStorageStore[key] ?? null);
+  vi.spyOn(Storage.prototype, "setItem").mockImplementation((key, value) => {
+    localStorageStore[key] = value;
+  });
+  vi.spyOn(Storage.prototype, "removeItem").mockImplementation((key) => {
+    delete localStorageStore[key];
+  });
+
+  // Stub performance.mark globally (jsdom exposes performance.mark natively,
+  // but we want to spy on it to verify it's called with the right marks)
+  vi.stubGlobal("performance", { mark: mockPerformanceMark });
+});
+
+// NOTE: No afterEach with vi.restoreAllMocks() — this would restore SecurityClient
+// mock and break subsequent tests. Each beforeEach resets what it needs.
+
+describe("loadUser() - parallelization", () => {
+  it("Test 1: getCurrentUser() starts immediately when loadUser() is called", async () => {
+    let getCurrentUserStarted = false;
+    let resolveCurrentUser!: (value: any) => void;
+
+    mockGetCurrentUser.mockImplementationOnce(
+      () =>
+        new Promise<any>((resolve) => {
+          getCurrentUserStarted = true;
+          resolveCurrentUser = resolve;
+        }),
+    );
+
+    const logic = _createInternalUserLogic();
+    const loadUserPromise = logic.loadUser();
+
+    // After one microtask, getCurrentUser should already have been called
+    await Promise.resolve();
+    expect(getCurrentUserStarted).toBe(true);
+    expect(mockGetCurrentUser).toHaveBeenCalledTimes(1);
+
+    // Resolve to let loadUser complete
+    resolveCurrentUser({ userName: "concurrent@vc.com", isAdministrator: false });
+    await loadUserPromise;
+  });
+
+  it("Test 2: loadUser() returns the UserDetail from getCurrentUser()", async () => {
+    const expectedUser = { userName: "admin@vc.com", isAdministrator: true };
+    mockGetCurrentUser.mockResolvedValueOnce(expectedUser);
+
+    const logic = _createInternalUserLogic();
+    const result = await logic.loadUser();
+
+    expect(result.userName).toBe("admin@vc.com");
+    expect(result.isAdministrator).toBe(true);
+  });
+
+  it("Test 3: loadUser() sets user.value to the getCurrentUser() result", async () => {
+    const expectedUser = { userName: "user@vc.com", isAdministrator: false };
+    mockGetCurrentUser.mockResolvedValueOnce(expectedUser);
+
+    const logic = _createInternalUserLogic();
+    await logic.loadUser();
+
+    // user is module-level ref; loadUser sets it to the getCurrentUser() result
+    expect(logic.user.value?.userName).toBe("user@vc.com");
+    expect(logic.user.value?.isAdministrator).toBe(false);
+  });
+
+  it("Test 4: loadUser() catches errors from getCurrentUser() and does not throw", async () => {
+    mockGetCurrentUser.mockRejectedValueOnce(new Error("Network error"));
+
+    const logic = _createInternalUserLogic();
+
+    // Should not throw — error is caught internally and logged
+    await expect(logic.loadUser()).resolves.not.toThrow();
+  });
+
+  it("Test 5: loadUser() resets loading to false in finally block — even after error", async () => {
+    mockGetCurrentUser.mockRejectedValueOnce(new Error("Server error"));
+
+    const logic = _createInternalUserLogic();
+    await logic.loadUser();
+
+    expect(logic.loading.value).toBe(false);
+  });
+
+  it("emits vc:auth-start and vc:auth-done performance marks in correct order", async () => {
+    const expectedUser = { userName: "perf@vc.com", isAdministrator: false };
+    mockGetCurrentUser.mockResolvedValueOnce(expectedUser);
+
+    const logic = _createInternalUserLogic();
+    await logic.loadUser();
+
+    expect(mockPerformanceMark).toHaveBeenCalledWith("vc:auth-start");
+    expect(mockPerformanceMark).toHaveBeenCalledWith("vc:auth-done");
+
+    // auth-start must come before auth-done
+    const calls = mockPerformanceMark.mock.calls.map((c: string[]) => c[0]);
+    const startIdx = calls.indexOf("vc:auth-start");
+    const doneIdx = calls.indexOf("vc:auth-done");
+    expect(startIdx).toBeGreaterThanOrEqual(0);
+    expect(doneIdx).toBeGreaterThanOrEqual(0);
+    expect(startIdx).toBeLessThan(doneIdx);
+  });
+});

package/core/composables/useUserManagement/index.ts

@@ -2,7 +2,7 @@ import { computed, ComputedRef } from "vue";
 import { createSharedComposable } from "@vueuse/core";
 import { _createInternalUserLogic, IUserInternalAPI } from "@core/composables/useUser"; // Import the internal logic
 import { SecurityResult, IdentityResult, LoginType, UserDetail, SignInResult } from "@core/api/platform";
-import { RequestPasswordResult } from "@core/types";
+import type { RequestPasswordResult } from "@core/types";
 
 // Interface for the API exposed by useUserManagement (for framework/admin use)
 export interface IUserManagementAPI {