@7365admin1/layer-common 4.40.1 → 4.42.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @iservice365/layer-common
 
+## 4.42.0
+
+### Minor Changes
+
+- 5472953: Roles and permissions (owner approval 2026-09-25): Robots offered in the Property Management and Cleaning role editors; the PM editor's camera-wall row reads "CCTV" (label only, `virtual-patrol:*` strings unchanged); PM's CCTV page follows the client's module list (`org-site-cctv` -> `virtual-patrol`, fails open); `NavigationDrawer` takes `sectionLabels` so an app can rename a sidebar heading.
+
+## 4.41.0
+
+### Minor Changes
+
+- 7052a86: Notification bell: every notification now opens its page. Rows route on `params.kind` (else their `module`) to the matching page — work order, feedback, incident, visitors, cameras, patrol logs, documents, emergency contacts, events, facility bookings, online forms, bulletin board, inventory, service providers, marketplace orders, and the Seven365 staff robot/client pages — in this app when it has the page, otherwise in the app that does (by its `APP_*` URL), with the organisation and site in the link. Rows with nowhere to go are no longer drawn as links. New `chooseNavigation`, `notificationKind`, `WEB_TARGET_KINDS`.
+
 ## 4.40.1
 
 ### Patch Changes
@@ -1465,11 +1477,11 @@
   `utils/console-tier.ts` + `composables/useConsoleTier.ts` mirror the server's
   own rule from two endpoints the console already calls, unprojected:
 
-                                                                                                                                                                                                    GET /api/members/user/:user/app/admin    the Seven365 staff membership
-                                                                                                                                                                                                    GET /api/roles/id/:role                  that membership's role document
+                                                                                                                                                                                                        GET /api/members/user/:user/app/admin    the Seven365 staff membership
+                                                                                                                                                                                                        GET /api/roles/id/:role                  that membership's role document
 
-                                                                                                                                                                                                    owner  = member.type === "admin" && role.type === "admin" && role.default === true
-                                                                                                                                                                                                    staff  = member.type === "admin" && role.type === "admin"
+                                                                                                                                                                                                        owner  = member.type === "admin" && role.type === "admin" && role.default === true
+                                                                                                                                                                                                        staff  = member.type === "admin" && role.type === "admin"
 
   `role.default` is the marker because it is the only property of a platform
   staff role no API caller can set - `role.controller.ts` validates create and

package/components/Layout/NavigationDrawer.vue

@@ -129,6 +129,9 @@ import { withoutDeniedRoutes } from "../../utils/module-routes";
 const props = defineProps({
   navigationItems: { type: Array, required: true },
   title: { type: String, default: "" },
+  // An app's own name for a section heading (`withSections`), e.g.
+  // `{ "SECURITY OPERATIONS": "ESTATE SECURITY" }` in Property Management.
+  sectionLabels: { type: Object, default: () => ({}) },
 });
 
 const emit = defineEmits(["navigate"]);
@@ -196,7 +199,7 @@ const navigationItems = computed(() => {
   return withoutDeniedRoutes(items, userAppModulesDenied.value);
 });
 
-const sectionedItems = computed(() => withSections(navigationItems.value));
+const sectionedItems = computed(() => withSections(navigationItems.value, props.sectionLabels as Record<string, string>));
 
 /**
  * The design's brand tile carries the product's own mark. One icon for eleven

package/components/NotificationBell.vue

@@ -70,7 +70,10 @@
               :key="item._id"
               type="button"
               class="notif-card"
-              :class="{ 'notif-card--unread': !item.hasRead }"
+              :class="{
+                'notif-card--unread': !item.hasRead,
+                'notif-card--plain': !targetFor(item),
+              }"
               @click="openNotification(item)"
             >
               <div class="notif-card__top">
@@ -134,7 +137,7 @@ import {
   timeAgo,
   type TInboxItem,
 } from "../utils/notification-inbox";
-import { externalTargetUrl, notificationTarget } from "../utils/notification-target";
+import { chooseNavigation, notificationTarget } from "../utils/notification-target";
 
 /**
  * The top-bar notification feed for the web, in every signed-in app.
@@ -304,26 +307,59 @@ function markRead(item: Record<string, any>) {
  * layer: the ten apps that have no order queue simply do not match it, and the
  * click there stays what it always was.
  */
-async function goToSubject(item: Record<string, any>) {
-  const target = notificationTarget(item as any, {
+function targetFor(item: Record<string, any>) {
+  return notificationTarget(item as any, {
     // The org app nests under `organization`; the service apps under `org`.
-    organization: String(route.params?.organization ?? route.params?.org ?? ""),
+    // Staff pages and the org app have neither, so the person's own default
+    // organisation builds a service-app link from there.
+    organization: String(
+      route.params?.organization ?? route.params?.org ?? currentUser.value?.defaultOrg ?? "",
+    ),
+    site: String(route.params?.site ?? ""),
   });
-  if (!target) return;
-
-  if (typeof router.hasRoute !== "function" || !router.hasRoute(target.name)) {
-    // The page lives in another web app (the invitation is answered in the
-    // organisation app): go there by URL, or stay put if it is not configured.
-    const href = externalTargetUrl(target, { org: String(appConfig?.public?.APP_ORG ?? "") });
-    if (!href) return;
-    open.value = false;
-    window.location.assign(href);
-    return;
+}
+
+/** A path this app really has a page for (every app has a 404 fallback, so check the match). */
+function hasLocalPage(path: string) {
+  try {
+    const resolved = router.resolve(path);
+    return resolved.matched.length > 0 && !resolved.matched.some((m) => m.path.includes("pathMatch"));
+  } catch {
+    return false;
   }
+}
+
+/** Every web app's URL, keyed like `TAppKey`, from the layer's runtime config. */
+function appUrls() {
+  const p = appConfig?.public ?? {};
+  return {
+    org: String(p.APP_ORG ?? ""),
+    security: String(p.APP_SECURITY ?? ""),
+    "property-management": String(p.APP_PROPERTY_MANAGEMENT ?? ""),
+    hygiene: String(p.APP_HYGIENE ?? ""),
+    "mechanical-electrical": String(p.APP_MECHANICAL_ELECTRICAL ?? ""),
+    "pest-control": String(p.APP_PEST_CONTROL ?? ""),
+    landscaping: String(p.APP_LANDSCAPING ?? ""),
+    "pool-maintenance": String(p.APP_POOL_MAINTENANCE ?? ""),
+  };
+}
+
+/** The decision is `chooseNavigation` (unit-tested); this only carries it out. */
+async function goToSubject(item: Record<string, any>) {
+  const nav = chooseNavigation(targetFor(item), {
+    hasRoute: (name) => typeof router.hasRoute === "function" && router.hasRoute(name),
+    hasPage: hasLocalPage,
+    appUrls: appUrls(),
+  });
+  if (!nav) return;
 
   open.value = false;
+  if (nav.type === "href") {
+    window.location.assign(nav.href);
+    return;
+  }
   try {
-    await router.push({ name: target.name, params: target.params, query: target.query });
+    await router.push(nav.to as any);
   } catch {
     // A cancelled or duplicate navigation is not worth an error in the top bar.
   }
@@ -462,6 +498,11 @@ onBeforeUnmount(() => {
   background: var(--hover);
 }
 
+/* Nothing to open: still marks read on click, but does not look like a link. */
+.notif-card--plain {
+  cursor: default;
+}
+
 .notif-card__top {
   display: flex;
   align-items: baseline;

package/components/RolePermissionFormCreate.vue

@@ -139,7 +139,7 @@
                   </template>
                   <v-list-item-title>
                     <span class="text-capitalize role-create__row-title">
-                      {{ formatResourceLabel(String(resourceKey)) }}
+                      {{ formatResourceLabel(String(resourceKey), props.type) }}
                     </span>
                   </v-list-item-title>
                   <template #append>
@@ -279,6 +279,7 @@ const props = defineProps({
   },
 });
 
+
 const emit = defineEmits(["cancel", "success", "success:create-more"]);
 
 const validForm = ref(false);
@@ -537,14 +538,14 @@ const moduleSearch = ref<string | null>("");
 /** `safePermissions`, narrowed to what the search box matches. */
 const visiblePermissions = computed(() => {
   const query = (moduleSearch.value ?? "").trim().toLowerCase();
-  const all = sortResourcesByLabel(safePermissions.value);
+  const all = sortResourcesByLabel(safePermissions.value, props.type);
   if (!query) return all;
 
   const matches: Record<string, any> = {};
   for (const [resource, actions] of Object.entries(all)) {
     const haystack = [
       resource,
-      formatResourceLabel(resource),
+      formatResourceLabel(resource, props.type),
       ...Object.keys(actions ?? {}).flatMap((action) => [
         action,
         formatActionLabel(action),

package/components/RolePermissionFormPreviewUpdate.vue

@@ -102,7 +102,7 @@
                     />
                   </template>
                   <v-list-item-title class="text-capitalize role-perm__row-title">
-                    {{ formatResourceLabel(String(resourceKey)) }}
+                    {{ formatResourceLabel(String(resourceKey), props.type) }}
                   </v-list-item-title>
                   <template #append>
                     <div class="role-perm__cat-actions">
@@ -191,7 +191,7 @@
                   <v-divider v-if="resourceIndex > 0" />
                   <v-list-item density="compact" :ripple="false">
                     <v-list-item-title class="text-capitalize role-perm__row-title">
-                      {{ formatResourceLabel(String(resourceKey)) }}
+                      {{ formatResourceLabel(String(resourceKey), props.type) }}
                     </v-list-item-title>
                     <v-list-item-subtitle class="role-perm__row-sub">
                       {{
@@ -311,8 +311,15 @@ const props = defineProps({
     type: Number,
     default: 0,
   },
+  // The role type the editor was opened for; only changes a module's NAME
+  // where one app calls a key something else (`RESOURCE_LABELS_BY_TYPE`).
+  type: {
+    type: String,
+    default: "",
+  },
 });
 
+
 /** A role holding the wildcard has ONE stored entry and reaches everything. */
 const holdsWildcard = computed(() => (definedModel.value ?? []).includes("*"));
 
@@ -486,14 +493,14 @@ const moduleSearch = ref<string | null>("");
 
 const visiblePermissions = computed(() => {
   const query = (moduleSearch.value ?? "").trim().toLowerCase();
-  const all = sortResourcesByLabel(safePermissions.value);
+  const all = sortResourcesByLabel(safePermissions.value, props.type);
   if (!query) return all;
 
   const matches: Record<string, any> = {};
   for (const [resource, actions] of Object.entries(all)) {
     const haystack = [
       resource,
-      formatResourceLabel(resource),
+      formatResourceLabel(resource, props.type),
       ...Object.keys((actions as Record<string, unknown>) ?? {}).flatMap(
         (action) => [action, formatActionLabel(action)]
       ),
@@ -509,7 +516,7 @@ const visiblePermissions = computed(() => {
 // Same A-Z as the tree above it; a second list in a second order reads as a
 // different kind of thing.
 const sortedNotOffered = computed(() =>
-  sortResourcesByLabel(props.notOfferedPermissions as Record<string, any>)
+  sortResourcesByLabel(props.notOfferedPermissions as Record<string, any>, props.type)
 );
 
 /*

package/components/RolePermissionMain.vue

@@ -120,6 +120,7 @@
         :can-update-role="props.canUpdateRole"
         :catalogue-size="permissionCatalogueSize"
         :module-count="permissionModuleCount"
+        :type="props.type"
       />
     </v-dialog>
 

package/composables/useCleaningPermission.ts

@@ -13,6 +13,7 @@ export default function useCleaningPermission() {
     bulletinBoardPermissions,
  
     inventoryPermissions,
+    robotPermissions,
   } = useCommonPermissions();
   const permissions: TPermissions = {
     inventory: inventoryPermissions,
@@ -291,6 +292,7 @@ export default function useCleaningPermission() {
           "Allows the user to view detailed information for item checkouts.",
       },
     },
+    "robot-mgmt": robotPermissions,
   };
 
   return {

package/composables/useCommonPermission.ts

@@ -331,7 +331,39 @@ export function useCommonPermissions() {
     },
   };
 
+  /*
+   * ROBOTS - owner approval 2026-09-25, item 1: the Property Management and
+   * Cleaning role editors offer Robots, so a narrower role can be given robot
+   * access. Same five strings, spelling and wording as `useSecurityPermission`
+   * and exactly what core `robot-permission.util.ts ROBOT_PERMISSIONS` enforces.
+   * Catalogue-only: offering an entry grants nobody anything until it is ticked.
+   */
+  const robotPermissions = {
+    "add-robot": {
+      check: true,
+      description: "Allows the user to add a new robot to the system.",
+    },
+    "see-all-robots": {
+      check: true,
+      description: "Allows the user to view the list of all robots.",
+    },
+    "see-robot-details": {
+      check: true,
+      description: "Allows the user to view the details of a specific robot.",
+    },
+    "update-robot": {
+      check: true,
+      description: "Allows the user to update robot details.",
+    },
+    "delete-robot": {
+      check: true,
+      description:
+        "Allows the user to remove a robot from the system permanently.",
+    },
+  };
+
   return {
+    robotPermissions,
     inventoryPermissions,
     invitationPermissions,
     memberPermissions,

package/composables/usePropertyPermission.ts

@@ -42,6 +42,7 @@ export default function usePropertyPermission() {
     siteSettingsPermissions,
   
     inventoryPermissions,
+    robotPermissions,
   } = useCommonPermissions();
 
 
@@ -618,6 +619,7 @@ export default function usePropertyPermission() {
           "Allows the user to view the list of all resident transactions on mobile. Checked by the iMA365 mobile app.",
       },
     },
+    "robot-mgmt": robotPermissions,
     "site-settings": siteSettingsPermissions
   };
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.40.1",
+  "version": "4.42.0",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "//files": "What a consumer extending this layer actually loads. Without this npm ships the whole working tree - the changesets, the CI workflows, the render harness in tools/ and any scratch directory that happened to exist at publish time. Nuxt resolves a layer by directory, so every runtime directory below has to stay listed; adding a new top-level runtime directory means adding it here too.",

package/utils/module-routes.ts

@@ -12,7 +12,7 @@
  * (checked against every app's own `useLocalPermission` nav gate, 2026-09-11).
  * Shared or ambiguous pages stay out: calendar, keys (gated on `site-settings`),
  * access-mgmt (`site-settings:manage-entry-pass` also opens it), equipment and
- * inventory, the property CCTV wall, service-providers and support tickets.
+ * inventory, service-providers and support tickets.
  *
  * NEVER MAPPED: the dashboard, settings, members, invitations and roles. A client
  * must always be able to run its own people and roles; the server never denies
@@ -40,6 +40,13 @@ export const MODULE_ROUTES: Readonly<Record<string, string>> = Object.freeze({
   // Includes its CCTV page: security's drawer shows it to whoever can see
   // Virtual Patrol, so it follows the same module.
   "org-site-virtual-patrol": "virtual-patrol",
+  // Property Management's camera wall (owner approval 2026-09-25, item 3). Its
+  // menu, page and the server's wall endpoint all read the four legacy
+  // `virtual-patrol:` strings (`useCameraViewPermission`, core
+  // `CAMERA_VIEW_PERMISSIONS`), and the PM role editor now calls that row
+  // "CCTV". So it follows the same module as Security's own CCTV page above.
+  // Fails open like every entry: a client with no module list keeps it.
+  "org-site-cctv": "virtual-patrol",
   "org-site-robot-management": "robot-mgmt",
   "org-site-attendance": "attendance-mgmt",
   "org-site-my-attendance": "my-attendance",

package/utils/nav-sections.ts

@@ -125,7 +125,13 @@ export const SECTION_ORDER: string[] = [
  * objects; only the order changes.
  */
 export function withSections<T extends { title?: string }>(
-  items: T[]
+  items: T[],
+  /**
+   * An application's own name for a heading, e.g. Property Management prints
+   * SECURITY OPERATIONS as ESTATE SECURITY (owner approval 2026-09-25, item 6).
+   * Changes the printed label only; grouping and order are unchanged.
+   */
+  labels: Readonly<Record<string, string>> = {}
 ): Array<TSectionedNavItem<T>> {
   // An unmapped title inherits the section of the item above it.
   let current = "";
@@ -144,7 +150,7 @@ export function withSections<T extends { title?: string }>(
 
   let printed = "";
   return grouped.map(({ item, section }) => {
-    const label = section === printed ? "" : section;
+    const label = section === printed ? "" : labels[section] ?? section;
     printed = section;
     return { item, section: label };
   });

package/utils/notification-target.ts

@@ -24,33 +24,68 @@
  * Eleven web apps render this bell and only `iservice365-web-app-org` has an
  * order queue. Rather than make eleven apps configure a map, the name is
  * written down once here and the bell asks its own router whether the route
- * exists before pushing — so in the ten apps without the page the click stays
- * exactly what it was: mark as read, go nowhere.
+ * exists before pushing.
+ *
+ * EVERY KIND SINCE 2026-09-24 (owner: "the notification never routes me")
+ * Each row names what it is about (`params.kind`, else its `module`), and the
+ * tables below say which web apps have that page. The bell opens this app's
+ * own page when it has one and otherwise jumps to the app that does, by its
+ * `APP_*` URL, with the organisation and site in the path.
  */
 
 /** Only the fields a destination is decided from. */
 export type TTargetRow = {
   module?: string;
   screen?: string;
-  params?: { id?: string; org?: string } | null;
+  title?: string;
+  appSlug?: string;
+  siteId?: string | null;
+  /**
+   * `kind` is the click-through target every sender sets since 2026-09-24
+   * (core `withNotificationKind`); `site` stands in for `siteId` on rows kept
+   * unscoped on purpose. Older rows have neither and are read from `module`.
+   */
+  params?: { id?: string; org?: string; kind?: string; site?: string } | null;
 };
 
 /** What the surrounding app knows that the stored row does not. */
 export type TTargetContext = {
   /** The organization in the current URL. Org routes are all nested under it. */
   organization?: string;
+  /** The site in the current URL, used when the row names none. */
+  site?: string;
 };
 
+/** The web apps a click can land in, keyed like their `APP_*` runtime URLs. */
+export type TAppKey =
+  | "org"
+  | "security"
+  | "property-management"
+  | "hygiene"
+  | "mechanical-electrical"
+  | "pest-control"
+  | "landscaping"
+  | "pool-maintenance";
+
+/** One place the record can be opened: a path inside one web app. */
+export type TCandidate = { app: TAppKey; path: string };
+
 export type TNotificationTarget = {
-  name: string;
-  params: Record<string, string>;
+  /** A route name in the current app, tried first (the two original targets). */
+  name?: string;
+  params?: Record<string, string>;
   query?: Record<string, string>;
   /**
    * Set when the page lives in another web app. The bell opens
    * `<that app's URL><path>` when its own router has no route by `name`.
    */
-  app?: "org";
+  app?: TAppKey;
   path?: string;
+  /**
+   * Every page that shows the record, best first. The bell opens the first one
+   * its own router has; otherwise it jumps to the first whose app URL is set.
+   */
+  candidates?: TCandidate[];
 };
 
 /** Nuxt's generated names for `pages/org/[organization]/marketplace/orders/`. */
@@ -73,13 +108,138 @@ export const VENDOR_ORDER_MODULE = "marketplace-vendor-order";
 export const SP_INVITATION_SCREEN = "/service-provider-invitation";
 export const INVITATIONS_ROUTE = "org-organization-client-invitations";
 
+/**
+ * What a row is about. `params.kind` when the sender set it; for older rows the
+ * `module`, except where the module is shared: `platform` (a new client, an
+ * accepted invitation, a robot) and `other` (both halves of a service-provider
+ * invitation) are told apart by the fixed titles their senders use.
+ */
+export function notificationKind(item: TTargetRow | null | undefined): string {
+  const kind = String(item?.params?.kind ?? "").trim();
+  if (kind) return kind;
+  const module = String(item?.module ?? "");
+  const title = String(item?.title ?? "");
+  if (String(item?.screen ?? "") === SP_INVITATION_SCREEN) return "serviceProviderInvite";
+  if (module === "platform") {
+    if (/^robot /i.test(title)) return "robot";
+    if (/^new client/i.test(title)) return "client";
+    if (/^invitation accepted/i.test(title)) return "clientInvitation";
+    return "";
+  }
+  if (module === "other") {
+    return /(accepted|declined) your invitation$/i.test(title) ? "serviceProviderInviteAnswer" : "";
+  }
+  return module;
+}
+
+/**
+ * The web app a mobile-tagged row's work lives in. A work order sent to the
+ * iClean365 app is managed in the Hygiene web app, and so on; anything from the
+ * resident or iMA365 apps is the property manager's.
+ */
+const APP_FOR_SLUG: Record<string, TAppKey> = {
+  "iservice365-hygiene-mobile-app": "hygiene",
+  "iservice365-m-and-e-mobile-app": "mechanical-electrical",
+  "iservice365-pest-control-mobile-app": "pest-control",
+  "iservice365-pool-maintenance-mobile-app": "pool-maintenance",
+  "iservice365-landscaping-mobile-app": "landscaping",
+  "iservice365-landscape-mobile-app": "landscaping",
+};
+
+const SERVICE_APPS: TAppKey[] = [
+  "property-management",
+  "security",
+  "hygiene",
+  "mechanical-electrical",
+  "pest-control",
+  "landscaping",
+  "pool-maintenance",
+];
+
+/**
+ * Site pages, `/<org>/<site>/<page>` in the service web apps, and which apps
+ * have them. "any" = every service app has the page; the row's own app leads.
+ */
+type TSitePage = { apps: TAppKey[] | "any"; page: (id: string) => string };
+const withId = (list: string) => (id: string) => (id ? `${list}/${id}` : list);
+const SITE_PAGES: Record<string, TSitePage[]> = {
+  workOrder: [{ apps: "any", page: withId("work-orders") }],
+  feedback: [{ apps: "any", page: withId("feedbacks") }],
+  bulletinBoard: [{ apps: "any", page: () => "bulletin-board" }],
+  inventory: [{ apps: "any", page: () => "inventory" }],
+  event: [{ apps: ["property-management"], page: () => "event-mgmt" }],
+  facilityBooking: [{ apps: ["property-management"], page: () => "facility-booking" }],
+  onlineForm: [{ apps: ["property-management"], page: () => "online-forms" }],
+  documentExpiry: [{ apps: ["property-management"], page: () => "document-mgmt" }],
+  emergencyContact: [{ apps: ["property-management"], page: () => "emergency-contacts" }],
+  incidentReport: [{ apps: ["security", "property-management"], page: withId("incident-reports") }],
+  visitors: [
+    { apps: ["security"], page: () => "visitor-management" },
+    { apps: ["property-management"], page: () => "visitor-mgmt" },
+  ],
+  virtualPatrol: [{ apps: ["security"], page: () => "virtual-patrol/logs" }],
+  cameraFault: [
+    { apps: ["security"], page: () => "virtual-patrol/cctv" },
+    { apps: ["property-management"], page: () => "cctv" },
+  ],
+  serviceProviderInviteAnswer: [
+    { apps: SERVICE_APPS.filter((a) => a !== "hygiene"), page: () => "service-providers" },
+  ],
+};
+SITE_PAGES.myVisitors = SITE_PAGES.visitors;
+
+/** Every kind the web can open, for tests and for anyone asking "is this clickable?". */
+export const WEB_TARGET_KINDS = [
+  ...Object.keys(SITE_PAGES),
+  "serviceProviderInvite",
+  VENDOR_ORDER_MODULE,
+  "robot",
+  "client",
+  "clientInvitation",
+];
+
+function sitePageTarget(
+  kind: string,
+  item: TTargetRow,
+  organization: string,
+  site: string,
+): TNotificationTarget | null {
+  const pages = SITE_PAGES[kind];
+  if (!pages || !organization || !site) return null;
+  const id = encodeURIComponent(String(item.params?.id ?? "").trim());
+  const home = APP_FOR_SLUG[String(item.appSlug ?? "")] ?? "property-management";
+  const base = `/${encodeURIComponent(organization)}/${encodeURIComponent(site)}/`;
+  const candidates: TCandidate[] = [];
+  for (const { apps, page } of pages) {
+    const list = apps === "any" ? [home, ...SERVICE_APPS.filter((a) => a !== home)] : apps;
+    for (const app of list) candidates.push({ app, path: base + page(id) });
+  }
+  return { candidates };
+}
+
+/** Seven365 staff pages, in the organisation app. */
+function staffTarget(kind: string, item: TTargetRow): TNotificationTarget | null {
+  const id = String(item.params?.id ?? "").trim();
+  if (kind === "robot") return { candidates: [{ app: "org", path: "/super-admin/robots" }] };
+  if (kind === "clientInvitation") {
+    return { candidates: [{ app: "org", path: "/super-admin/client-list" }] };
+  }
+  if (kind === "client") {
+    return id
+      ? { candidates: [{ app: "org", path: "/super-admin/client-details" }], query: { org: id } }
+      : { candidates: [{ app: "org", path: "/super-admin/client-list" }] };
+  }
+  return null;
+}
+
 export function notificationTarget(
   item: TTargetRow | null | undefined,
   context: TTargetContext = {},
 ): TNotificationTarget | null {
   const organization = String(context.organization ?? "").trim();
+  const kind = notificationKind(item);
 
-  if (String(item?.screen ?? "") === SP_INVITATION_SCREEN) {
+  if (kind === "serviceProviderInvite") {
     // The invited company's organisation when the row names it (the invitation
     // belongs there), otherwise the one on screen. The list on that page is
     // keyed on the signed-in account, so either shows the invitation.
@@ -96,7 +256,14 @@ export function notificationTarget(
     };
   }
 
-  if (String(item?.module ?? "") !== VENDOR_ORDER_MODULE) return null;
+  if (!item) return null;
+  const staff = staffTarget(kind, item);
+  if (staff) return staff;
+
+  if (kind !== VENDOR_ORDER_MODULE) {
+    const site = String(item.siteId ?? item.params?.site ?? context.site ?? "").trim();
+    return sitePageTarget(kind, item, organization, site);
+  }
 
   // Every order route is nested under the organization. Without one there is no
   // URL to build, and guessing an organization for somebody who belongs to
@@ -104,12 +271,23 @@ export function notificationTarget(
   if (!organization) return null;
 
   const id = String(item?.params?.id ?? "").trim();
+  const orders = `/org/${encodeURIComponent(organization)}/marketplace/orders`;
 
   // No id — an older row, or one whose params were dropped — still has an
   // honest destination: the queue the order is sitting in.
-  if (!id) return { name: ORDER_QUEUE_ROUTE, params: { organization } };
+  if (!id) {
+    return {
+      name: ORDER_QUEUE_ROUTE,
+      params: { organization },
+      candidates: [{ app: "org", path: orders }],
+    };
+  }
 
-  return { name: ORDER_DETAIL_ROUTE, params: { organization, id } };
+  return {
+    name: ORDER_DETAIL_ROUTE,
+    params: { organization, id },
+    candidates: [{ app: "org", path: `${orders}/${encodeURIComponent(id)}` }],
+  };
 }
 
 /**
@@ -118,11 +296,49 @@ export function notificationTarget(
  */
 export function externalTargetUrl(
   target: TNotificationTarget | null | undefined,
-  appUrls: { org?: string } = {},
+  appUrls: Partial<Record<TAppKey, string>> = {},
 ): string {
-  if (!target?.app || !target.path) return "";
-  const base = String(appUrls[target.app] ?? "").trim().replace(/\/+$/, "");
-  if (!base) return "";
-  const qs = new URLSearchParams(target.query ?? {}).toString();
-  return `${base}${target.path}${qs ? `?${qs}` : ""}`;
+  const options: TCandidate[] = [
+    ...(target?.app && target.path ? [{ app: target.app, path: target.path }] : []),
+    ...(target?.candidates ?? []),
+  ];
+  const qs = new URLSearchParams(target?.query ?? {}).toString();
+  for (const { app, path } of options) {
+    const base = String(appUrls[app] ?? "").trim().replace(/\/+$/, "");
+    if (base) return `${base}${path}${qs ? `?${qs}` : ""}`;
+  }
+  return "";
+}
+
+/** What the bell does with a click: move inside this app, open another app, or nothing. */
+export type TNavigation =
+  | {
+      type: "route";
+      to: { name?: string; params?: Record<string, string>; path?: string; query?: Record<string, string> };
+    }
+  | { type: "href"; href: string }
+  | null;
+
+/**
+ * This app's own page first — by route name, then by path (the site is in the
+ * path, so opening it switches the site) — else the first app that has the
+ * page and whose URL is configured. The page itself still checks the person may
+ * see it: a link grants nothing.
+ */
+export function chooseNavigation(
+  target: TNotificationTarget | null | undefined,
+  app: {
+    hasRoute: (name: string) => boolean;
+    hasPage: (path: string) => boolean;
+    appUrls?: Partial<Record<TAppKey, string>>;
+  },
+): TNavigation {
+  if (!target) return null;
+  if (target.name && app.hasRoute(target.name)) {
+    return { type: "route", to: { name: target.name, params: target.params, query: target.query } };
+  }
+  const local = target.candidates?.find((c) => app.hasPage(c.path));
+  if (local) return { type: "route", to: { path: local.path, query: target.query } };
+  const href = externalTargetUrl(target, app.appUrls);
+  return href ? { type: "href", href } : null;
 }

package/utils/permission-labels.ts

@@ -55,14 +55,31 @@ export const RESOURCE_LABELS: Record<string, string> = {
   roles: "Roles and permissions",
 };
 
+/**
+ * Names that differ BY APPLICATION, keyed by the role `type` the editor is
+ * opened with. Only where one key means a different screen in one app.
+ *
+ * Owner approval 2026-09-25, item 2: in the Property Management editor the
+ * `virtual-patrol` row is the CCTV camera wall (the four legacy strings
+ * `useCameraViewPermission` and core `CAMERA_VIEW_PERMISSIONS` read), not the
+ * Security app's Virtual Patrol. Label only: the key and every stored string
+ * stay `virtual-patrol:*`, so every role that holds them keeps working.
+ */
+export const RESOURCE_LABELS_BY_TYPE: Record<string, Record<string, string>> = {
+  property_management_agency: { "virtual-patrol": "CCTV" },
+  real_estate_developer: { "virtual-patrol": "CCTV" },
+};
+
 /**
  * `work_orders` -> `Work orders`.
  *
  * Sentence case, not Title Case: a list of 47 Title Cased phrases is harder to
  * scan, not easier.
  */
-export function formatResourceLabel(key: string): string {
+export function formatResourceLabel(key: string, type?: string): string {
   if (!key) return "";
+  const byType = type ? RESOURCE_LABELS_BY_TYPE[type]?.[key] : undefined;
+  if (byType) return byType;
   if (RESOURCE_LABELS[key]) return RESOURCE_LABELS[key];
 
   const words = key
@@ -115,11 +132,12 @@ export function formatActionLabel(action: string): string {
  */
 export function sortResourcesByLabel<T>(
   tree: Record<string, T> | null | undefined,
+  type?: string,
 ): Record<string, T> {
   if (!tree || typeof tree !== "object") return {};
   const sorted: Record<string, T> = {};
   for (const key of Object.keys(tree).sort((a, b) =>
-    formatResourceLabel(a).localeCompare(formatResourceLabel(b), undefined, {
+    formatResourceLabel(a, type).localeCompare(formatResourceLabel(b, type), undefined, {
       sensitivity: "base",
       numeric: true,
     }),