@jskit-ai/users-web 0.1.37 → 0.1.38

package/src/client/composables/{useEndpointResource.js → runtime/useEndpointResource.js}

@@ -1,10 +1,10 @@
 import { computed } from "vue";
 import { useMutation, useQuery } from "@tanstack/vue-query";
-import { usersWebHttpClient } from "../lib/httpClient.js";
-import { asPlainObject } from "./scopeHelpers.js";
-import { resolveEnabledRef, resolveTextRef } from "./refValueHelpers.js";
-import { toQueryErrorMessage } from "./errorMessageHelpers.js";
-import { hasResolvedQueryData } from "./resourceLoadStateHelpers.js";
+import { usersWebHttpClient } from "../../lib/httpClient.js";
+import { asPlainObject } from "../support/scopeHelpers.js";
+import { resolveEnabledRef, resolveTextRef } from "../support/refValueHelpers.js";
+import { toQueryErrorMessage } from "../support/errorMessageHelpers.js";
+import { hasResolvedQueryData } from "../support/resourceLoadStateHelpers.js";
 
 function useEndpointResource({
   queryKey,

package/src/client/composables/{useListCore.js → runtime/useListCore.js}

@@ -1,9 +1,9 @@
 import { computed } from "vue";
 import { appendQueryString } from "@jskit-ai/kernel/shared/support";
-import { usersWebHttpClient } from "../lib/httpClient.js";
-import { asPlainObject } from "./scopeHelpers.js";
-import { resolveEnabledRef, resolveTextRef } from "./refValueHelpers.js";
-import { usePagedCollection } from "./usePagedCollection.js";
+import { usersWebHttpClient } from "../../lib/httpClient.js";
+import { asPlainObject } from "../support/scopeHelpers.js";
+import { resolveEnabledRef, resolveTextRef } from "../support/refValueHelpers.js";
+import { usePagedCollection } from "../usePagedCollection.js";
 
 function appendPageParam(path, pageParam) {
   const normalizedPath = String(path || "").trim();

package/src/client/composables/{useUiFeedback.js → runtime/useUiFeedback.js}

@@ -1,6 +1,6 @@
 import { ref } from "vue";
 import { useShellWebErrorRuntime } from "@jskit-ai/shell-web/client/error";
-import { toUiErrorMessage } from "./errorMessageHelpers.js";
+import { toUiErrorMessage } from "../support/errorMessageHelpers.js";
 
 function useUiFeedback({
   initialType = "success",

package/src/client/composables/{viewUiRuntime.js → runtime/viewUiRuntime.js}

@@ -1,12 +1,12 @@
 import { computed, unref } from "vue";
-import { asPlainObject } from "./scopeHelpers.js";
+import { asPlainObject } from "../support/scopeHelpers.js";
 import {
   normalizeRouteParamName,
   resolveRouteParamsSource,
   resolveScopedRoutePathname,
   resolveRouteTemplateLocation,
   toRouteParamValue
-} from "./routeTemplateHelpers.js";
+} from "../support/routeTemplateHelpers.js";
 
 function resolveRecordId({ routeParams, recordIdParam, routeRecordId }) {
   const explicitRecordId = toRouteParamValue(

package/src/client/composables/useAccess.js

@@ -1,10 +1,10 @@
 import { computed } from "vue";
 import { hasPermission, normalizePermissionList } from "../lib/permissions.js";
-import { resolveEnabledRef, resolveTextRef } from "./refValueHelpers.js";
+import { resolveEnabledRef, resolveTextRef } from "./support/refValueHelpers.js";
 import {
   normalizeAccessMode,
   resolveAccessModeEnabled
-} from "./scopeHelpers.js";
+} from "./support/scopeHelpers.js";
 import { useWebPlacementContext } from "@jskit-ai/shell-web/client/placement";
 
 function asPermissionList(value) {

package/src/client/composables/useAccountSettingsRuntime.js

@@ -19,9 +19,9 @@ import {
 import {
   useWorkspaceSurfaceId
 } from "./useWorkspaceSurfaceId.js";
-import { useAddEdit } from "./useAddEdit.js";
+import { useAddEdit } from "./records/useAddEdit.js";
 import { useCommand } from "./useCommand.js";
-import { useView } from "./useView.js";
+import { useView } from "./records/useView.js";
 import { usePaths } from "./usePaths.js";
 import { resolveAccountSettingsPathFromPlacementContext } from "../lib/workspaceSurfacePaths.js";
 import {
@@ -34,16 +34,16 @@ import {
   NUMBER_FORMAT_OPTIONS,
   THEME_OPTIONS,
   TIME_ZONE_OPTIONS
-} from "./accountSettingsRuntimeConstants.js";
+} from "./account-settings/accountSettingsRuntimeConstants.js";
 import {
   normalizeAvatarSize,
   normalizePendingInvite,
   normalizeReturnToPath,
   normalizeSettingsPayload,
   resolveAllowedReturnToOrigins
-} from "./accountSettingsRuntimeHelpers.js";
-import { createAccountSettingsAvatarUploadRuntime } from "./accountSettingsAvatarUploadRuntime.js";
-import { createAccountSettingsInvitesRuntime } from "./accountSettingsInvitesRuntime.js";
+} from "./account-settings/accountSettingsRuntimeHelpers.js";
+import { createAccountSettingsAvatarUploadRuntime } from "./account-settings/accountSettingsAvatarUploadRuntime.js";
+import { createAccountSettingsInvitesRuntime } from "./account-settings/accountSettingsInvitesRuntime.js";
 
 function useAccountSettingsRuntime() {
   const route = useRoute();

package/src/client/composables/useBootstrapQuery.js

@@ -5,7 +5,7 @@ import { useQuery } from "@tanstack/vue-query";
 import { normalizeQueryToken } from "@jskit-ai/kernel/shared/support/normalize";
 import { usersWebHttpClient } from "../lib/httpClient.js";
 import { buildBootstrapApiPath } from "../lib/bootstrap.js";
-import { resolveEnabledRef, resolveTextRef } from "./refValueHelpers.js";
+import { resolveEnabledRef, resolveTextRef } from "./support/refValueHelpers.js";
 
 const DEFAULT_BOOTSTRAP_STALE_TIME_MS = 60_000;
 

package/src/client/composables/useCommand.js

@@ -1,14 +1,14 @@
 import { proxyRefs } from "vue";
 import { USERS_ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/users-core/shared/support/usersVisibility";
-import { useCommandCore } from "./useCommandCore.js";
-import { useEndpointResource } from "./useEndpointResource.js";
+import { useCommandCore } from "./runtime/useCommandCore.js";
+import { useEndpointResource } from "./runtime/useEndpointResource.js";
 import { useOperationScope } from "./internal/useOperationScope.js";
-import { useUiFeedback } from "./useUiFeedback.js";
-import { useFieldErrorBag } from "./useFieldErrorBag.js";
+import { useUiFeedback } from "./runtime/useUiFeedback.js";
+import { useFieldErrorBag } from "./runtime/useFieldErrorBag.js";
 import {
   setupRouteChangeCleanup,
   setupOperationErrorReporting
-} from "./operationUiHelpers.js";
+} from "./runtime/operationUiHelpers.js";
 
 function useCommand({
   ownershipFilter = USERS_ROUTE_VISIBILITY_WORKSPACE,

package/src/client/composables/useCrudListParentTitle.js

@@ -0,0 +1,131 @@
+import { computed, proxyRefs } from "vue";
+import { useRoute } from "vue-router";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import {
+  resolveRouteParamsSource,
+  toRouteParamValue
+} from "./support/routeTemplateHelpers.js";
+import { useView } from "./records/useView.js";
+import {
+  resolveCrudListParentDescriptor,
+  resolveCrudListParentRecordTitle,
+  resolveCrudListParentTitleFromItems
+} from "./internal/crudListParentTitleSupport.js";
+
+function normalizeQueryKeyPrefix(value = []) {
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => normalizeText(entry))
+      .filter(Boolean);
+  }
+
+  const normalizedValue = normalizeText(value);
+  return normalizedValue ? [normalizedValue] : [];
+}
+
+function useCrudListParentTitle({
+  listRuntime = null,
+  resource = {},
+  adapter = null,
+  recordIdParam = "recordId",
+  queryKeyPrefix = ["users-web", "crud-list-parent-title"],
+  placementSource = "users-web.crud-list-parent-title",
+  fallbackLoadError = "Unable to load parent record.",
+  notFoundMessage = "Parent record not found.",
+  route = null,
+  viewRuntimeFactory = useView
+} = {}) {
+  const sourceRoute = route && typeof route === "object" ? route : useRoute();
+  const parentDescriptor = computed(() => {
+    const descriptor = resolveCrudListParentDescriptor({
+      resource,
+      route: sourceRoute,
+      recordIdParam
+    });
+    if (!descriptor) {
+      return null;
+    }
+
+    const routeParams = resolveRouteParamsSource(sourceRoute?.params || {});
+    const routeParamValue = toRouteParamValue(routeParams[descriptor.routeParamKey]);
+    if (!routeParamValue) {
+      return null;
+    }
+
+    return Object.freeze({
+      ...descriptor,
+      routeParamValue
+    });
+  });
+
+  const initialParentDescriptor = parentDescriptor.value || {};
+  const normalizedQueryKeyPrefix = normalizeQueryKeyPrefix(queryKeyPrefix);
+  const shouldLoadParentRecord = computed(() => {
+    const descriptor = parentDescriptor.value;
+    if (!descriptor?.apiUrlTemplate) {
+      return false;
+    }
+    if (Boolean(listRuntime?.isInitialLoading) || normalizeText(listRuntime?.loadError)) {
+      return false;
+    }
+
+    const items = Array.isArray(listRuntime?.items) ? listRuntime.items : [];
+    return items.length < 1;
+  });
+
+  const parentView = viewRuntimeFactory({
+    adapter,
+    apiUrlTemplate: normalizeText(initialParentDescriptor.apiUrlTemplate),
+    readEnabled: shouldLoadParentRecord,
+    recordIdParam: normalizeText(initialParentDescriptor.routeParamKey) || "recordId",
+    includeRecordIdInQueryKey: true,
+    queryKeyFactory: (surfaceId = "", workspaceSlug = "") => [
+      ...normalizedQueryKeyPrefix,
+      normalizeText(initialParentDescriptor.relationNamespace),
+      normalizeText(initialParentDescriptor.routeParamKey),
+      String(surfaceId || ""),
+      String(workspaceSlug || "")
+    ],
+    placementSource,
+    fallbackLoadError,
+    notFoundMessage
+  });
+
+  const title = computed(() => {
+    const descriptor = parentDescriptor.value;
+    if (!descriptor) {
+      return "";
+    }
+
+    const parentRecordTitle = resolveCrudListParentRecordTitle(parentView?.record || {}, descriptor);
+    if (parentRecordTitle && shouldLoadParentRecord.value) {
+      return parentRecordTitle;
+    }
+
+    const listTitle = resolveCrudListParentTitleFromItems(listRuntime?.items, descriptor);
+    if (listTitle) {
+      return listTitle;
+    }
+
+    if (parentRecordTitle) {
+      return parentRecordTitle;
+    }
+
+    if (descriptor.routeParamValue) {
+      return `${descriptor.entityLabel} #${descriptor.routeParamValue}`;
+    }
+
+    return descriptor.entityLabel;
+  });
+
+  return proxyRefs({
+    title,
+    descriptor: parentDescriptor,
+    shouldLoadParentRecord,
+    record: computed(() => parentView?.record || null),
+    isLoading: computed(() => Boolean(parentView?.isLoading)),
+    loadError: computed(() => normalizeText(parentView?.loadError))
+  });
+}
+
+export { useCrudListParentTitle };

package/src/client/composables/usePagedCollection.js

@@ -1,8 +1,8 @@
 import { computed, unref } from "vue";
 import { useInfiniteQuery, useQueryClient } from "@tanstack/vue-query";
-import { asPlainObject } from "./scopeHelpers.js";
-import { resolveEnabledRef } from "./refValueHelpers.js";
-import { toQueryErrorMessage } from "./errorMessageHelpers.js";
+import { asPlainObject } from "./support/scopeHelpers.js";
+import { resolveEnabledRef } from "./support/refValueHelpers.js";
+import { toQueryErrorMessage } from "./support/errorMessageHelpers.js";
 
 function defaultSelectItems(page) {
   return Array.isArray(page?.items) ? page.items : [];

package/src/client/composables/useScopeRuntime.js

@@ -11,7 +11,7 @@ import {
   resolveAccessModeEnabled,
   normalizeOwnershipFilter,
   resolveApiSuffix
-} from "./scopeHelpers.js";
+} from "./support/scopeHelpers.js";
 
 function useScopeRuntime({
   ownershipFilter = USERS_ROUTE_VISIBILITY_WORKSPACE,

package/src/client/support/menuLinkTarget.js

@@ -0,0 +1,93 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { surfaceRequiresWorkspaceFromPlacementContext } from "../lib/workspaceSurfaceContext.js";
+
+function normalizeMenuLinkPathname(pathname = "") {
+  const source = String(pathname || "").trim();
+  if (!source) {
+    return "";
+  }
+
+  const queryIndex = source.indexOf("?");
+  const hashIndex = source.indexOf("#");
+  const cutoff =
+    queryIndex < 0
+      ? hashIndex
+      : hashIndex < 0
+        ? queryIndex
+        : Math.min(queryIndex, hashIndex);
+
+  return cutoff < 0 ? source : source.slice(0, cutoff);
+}
+
+function resolveMenuLinkSurfaceId(surface = "", fallbackSurfaceId = "") {
+  const explicitSurface = normalizeText(surface).toLowerCase();
+  if (explicitSurface && explicitSurface !== "*") {
+    return explicitSurface;
+  }
+
+  return normalizeText(fallbackSurfaceId).toLowerCase();
+}
+
+function interpolateBracketParams(pathTemplate = "", params = {}) {
+  const source = String(pathTemplate || "").trim();
+  if (!source) {
+    return "";
+  }
+
+  return source.replace(/\[([^\]]+)\]/g, (_match, rawKey) => {
+    const key = String(rawKey || "").trim();
+    if (!key) {
+      return "";
+    }
+
+    const value = params?.[key];
+    return value == null ? `[${key}]` : encodeURIComponent(String(value));
+  });
+}
+
+function isRelativeMenuLinkTarget(target = "") {
+  const normalizedTarget = normalizeText(target);
+  return normalizedTarget.startsWith("./") || normalizedTarget.startsWith("../");
+}
+
+function resolveMenuLinkTarget({
+  to = "",
+  surface = "",
+  currentSurfaceId = "",
+  placementContext = null,
+  workspaceSuffix = "/",
+  nonWorkspaceSuffix = "/",
+  routeParams = {},
+  resolvePagePath = null
+} = {}) {
+  const explicitTarget = normalizeText(to);
+  const targetSurfaceId = resolveMenuLinkSurfaceId(surface, currentSurfaceId);
+  const workspaceRequired = surfaceRequiresWorkspaceFromPlacementContext(placementContext, targetSurfaceId);
+  const suffixTemplate = normalizeText(workspaceRequired ? workspaceSuffix : nonWorkspaceSuffix) || "/";
+  const interpolatedSuffix = interpolateBracketParams(suffixTemplate, routeParams);
+  const resolvedSuffixTarget =
+    typeof resolvePagePath === "function" &&
+    targetSurfaceId &&
+    interpolatedSuffix &&
+    !interpolatedSuffix.includes("[")
+      ? normalizeText(resolvePagePath(interpolatedSuffix, {
+          surface: targetSurfaceId,
+          mode: "auto"
+        }))
+      : "";
+
+  if (!explicitTarget) {
+    return resolvedSuffixTarget;
+  }
+
+  if (isRelativeMenuLinkTarget(explicitTarget)) {
+    return resolvedSuffixTarget;
+  }
+
+  return explicitTarget;
+}
+
+export {
+  normalizeMenuLinkPathname,
+  resolveMenuLinkTarget
+};

package/test/addEditUiRuntime.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { ref } from "vue";
-import { createAddEditUiRuntime } from "../src/client/composables/addEditUiRuntime.js";
+import { createAddEditUiRuntime } from "../src/client/composables/runtime/addEditUiRuntime.js";
 
 test("createAddEditUiRuntime resolves api/list/cancel paths from route params", () => {
   const runtime = createAddEditUiRuntime({

package/test/crudBindingSupport.test.js

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ref } from "vue";
+import {
+  CRUD_BINDING_MODE_ROUTE,
+  CRUD_BINDING_MODE_MERGE,
+  CRUD_BINDING_MODE_EXPLICIT,
+  CRUD_BINDING_MODE_NONE,
+  normalizeCrudBindingMode,
+  resolveCrudBoundValues
+} from "../src/client/composables/crud/crudBindingSupport.js";
+
+test("normalizeCrudBindingMode defaults invalid values to route", () => {
+  assert.equal(normalizeCrudBindingMode(""), CRUD_BINDING_MODE_ROUTE);
+  assert.equal(normalizeCrudBindingMode("unknown"), CRUD_BINDING_MODE_ROUTE);
+  assert.equal(normalizeCrudBindingMode("merge"), CRUD_BINDING_MODE_MERGE);
+  assert.equal(normalizeCrudBindingMode("explicit"), CRUD_BINDING_MODE_EXPLICIT);
+  assert.equal(normalizeCrudBindingMode("none"), CRUD_BINDING_MODE_NONE);
+});
+
+test("resolveCrudBoundValues returns route values in route mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "route",
+      values: {
+        contactId: "22"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    contactId: "11"
+  });
+});
+
+test("resolveCrudBoundValues merges explicit values over route values in merge mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "merge",
+      values: {
+        contactId: "22",
+        serviceId: "4"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    contactId: "22",
+    serviceId: "4"
+  });
+});
+
+test("resolveCrudBoundValues uses only explicit values in explicit mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "explicit",
+      values: {
+        serviceId: "4"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    serviceId: "4"
+  });
+});
+
+test("resolveCrudBoundValues disables automatic binding in none mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "none",
+      values: {
+        serviceId: "4"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {});
+});
+
+test("resolveCrudBoundValues unwraps reactive binding config and values", () => {
+  const values = resolveCrudBoundValues({
+    binding: ref({
+      mode: "merge",
+      values: ref({
+        serviceId: "4"
+      })
+    }),
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    contactId: "11",
+    serviceId: "4"
+  });
+});

package/test/crudLookupFieldRuntime.test.js

@@ -4,7 +4,7 @@ import {
   resolveLookupItemLabel,
   resolveLookupFieldDisplayValue,
   resolveRecordTitle
-} from "../src/client/composables/crudLookupFieldLabelSupport.js";
+} from "../src/client/composables/crud/crudLookupFieldLabelSupport.js";
 
 test("resolveLookupItemLabel composes name + surname", () => {
   assert.equal(

package/test/errorMessageHelpers.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { toQueryErrorMessage, toUiErrorMessage } from "../src/client/composables/errorMessageHelpers.js";
+import { toQueryErrorMessage, toUiErrorMessage } from "../src/client/composables/support/errorMessageHelpers.js";
 
 test("toQueryErrorMessage returns empty when query has no error", () => {
   assert.equal(toQueryErrorMessage(null, "Unable to load list."), "");

package/test/exportsContract.test.js

@@ -13,7 +13,16 @@ test("users-web exports are explicit and aligned with production/template usage"
     repoRoot: REPO_ROOT,
     packageDir: PACKAGE_DIR,
     packageId: "@jskit-ai/users-web",
-    requiredExports: ["./client"]
+    requiredExports: [
+      "./client",
+      "./client/composables/useAddEdit",
+      "./client/composables/useList",
+      "./client/composables/useView",
+      "./client/composables/useCrudAddEdit",
+      "./client/composables/useCrudList",
+      "./client/composables/useCrudView",
+      "./client/support/menuLinkTarget"
+    ]
   });
 
   assert.deepEqual(

package/test/listQueryParamSupport.test.js

@@ -12,7 +12,7 @@ import {
   buildRouteQueryCompareToken,
   mergeManagedQueryParamKeyHistory,
   resolveRouteSyncManagedKeys
-} from "../src/client/composables/listQueryParamSupport.js";
+} from "../src/client/composables/support/listQueryParamSupport.js";
 
 test("normalizeListSyncToRouteConfig defaults", () => {
   assert.deepEqual(

package/test/listUiRuntime.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { ref } from "vue";
-import { createListUiRuntime } from "../src/client/composables/listUiRuntime.js";
+import { createListUiRuntime } from "../src/client/composables/runtime/listUiRuntime.js";
 
 test("createListUiRuntime resolves row keys and relative route templates from string record ids", () => {
   const items = ref([{ uuid: "abc 123" }]);

package/test/menuLinkTarget.test.js

@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  normalizeMenuLinkPathname,
+  resolveMenuLinkTarget
+} from "../src/client/support/menuLinkTarget.js";
+
+const WORKSPACE_PLACEMENT_CONTEXT = Object.freeze({
+  surfaceConfig: {
+    enabledSurfaceIds: ["admin"],
+    surfacesById: {
+      admin: {
+        id: "admin",
+        requiresWorkspace: true
+      }
+    }
+  }
+});
+
+const MIXED_PLACEMENT_CONTEXT = Object.freeze({
+  surfaceConfig: {
+    enabledSurfaceIds: ["app", "admin"],
+    surfacesById: {
+      app: {
+        id: "app",
+        requiresWorkspace: false
+      },
+      admin: {
+        id: "admin",
+        requiresWorkspace: true
+      }
+    }
+  }
+});
+
+function createPageResolver() {
+  return function resolvePagePath(relativePath = "", options = {}) {
+    return `page:${String(options.surface || "")}:${String(relativePath || "")}`;
+  };
+}
+
+test("resolveMenuLinkTarget resolves suffix targets when no explicit to is provided", () => {
+  assert.equal(
+    resolveMenuLinkTarget({
+      surface: "admin",
+      placementContext: WORKSPACE_PLACEMENT_CONTEXT,
+      workspaceSuffix: "/practice/vets",
+      nonWorkspaceSuffix: "/practice/vets",
+      resolvePagePath: createPageResolver()
+    }),
+    "page:admin:/practice/vets"
+  );
+});
+
+test("resolveMenuLinkTarget resolves relative targets through suffix templates", () => {
+  assert.equal(
+    resolveMenuLinkTarget({
+      to: "./notes",
+      surface: "admin",
+      placementContext: WORKSPACE_PLACEMENT_CONTEXT,
+      workspaceSuffix: "/contacts/[contactId]/notes",
+      nonWorkspaceSuffix: "/contacts/[contactId]/notes",
+      routeParams: {
+        contactId: 42
+      },
+      resolvePagePath: createPageResolver()
+    }),
+    "page:admin:/contacts/42/notes"
+  );
+});
+
+test("resolveMenuLinkTarget returns empty string for unresolved relative targets", () => {
+  assert.equal(
+    resolveMenuLinkTarget({
+      to: "./notes",
+      surface: "admin",
+      placementContext: WORKSPACE_PLACEMENT_CONTEXT,
+      workspaceSuffix: "/contacts/[contactId]/notes",
+      nonWorkspaceSuffix: "/contacts/[contactId]/notes",
+      resolvePagePath: createPageResolver()
+    }),
+    ""
+  );
+});
+
+test("resolveMenuLinkTarget keeps absolute targets unchanged", () => {
+  assert.equal(
+    resolveMenuLinkTarget({
+      to: "/practice/vets",
+      surface: "admin",
+      placementContext: WORKSPACE_PLACEMENT_CONTEXT,
+      workspaceSuffix: "/ignored",
+      nonWorkspaceSuffix: "/ignored",
+      resolvePagePath: createPageResolver()
+    }),
+    "/practice/vets"
+  );
+});
+
+test("resolveMenuLinkTarget uses non-workspace suffix for non-workspace surfaces", () => {
+  assert.equal(
+    resolveMenuLinkTarget({
+      surface: "app",
+      currentSurfaceId: "admin",
+      placementContext: MIXED_PLACEMENT_CONTEXT,
+      workspaceSuffix: "/workspace-only",
+      nonWorkspaceSuffix: "/public-page",
+      resolvePagePath: createPageResolver()
+    }),
+    "page:app:/public-page"
+  );
+});
+
+test("normalizeMenuLinkPathname removes query strings and hashes", () => {
+  assert.equal(normalizeMenuLinkPathname("/practice/vets?tab=all#section"), "/practice/vets");
+});