@memberjunction/ng-explorer-core 6.2.0-edge.4 → 6.2.0-edge.6

package/dist/lib/shell/shell.component.js

@@ -1,11 +1,11 @@
 import { Component, ViewChild, HostListener, inject } from '@angular/core';
 import { AngularAdapterService } from '@memberjunction/ng-react';
-import { NavigationEnd } from '@angular/router';
+import { NavigationEnd, NavigationError, NavigationCancel } from '@angular/router';
 import { combineLatest, Subject } from 'rxjs';
 import { filter, takeUntil } from 'rxjs/operators';
 import { LogStatus, LogError, StartupManager, CompositeKey, EncodeNewRecordValuesForURL, IsNewEntityRecordUrlId, NEW_ENTITY_RECORD_URL_ID, NEW_RECORD_VALUES_QUERY_PARAM, RecordUrlMatchesTab, ResourceUrlsEquivalent } from '@memberjunction/core';
 import { MJEventType, MJGlobal, uuidv4, UUIDsEqual } from '@memberjunction/global';
-import { EventCodes, SharedService, SYSTEM_APP_ID, SetRecordOpenStyle, IsRecordsRegionTab, IsRecordsTabConfiguration } from '@memberjunction/ng-shared';
+import { EventCodes, SharedService, SYSTEM_APP_ID, SetRecordOpenStyle, IsRecordsRegionTab, IsRecordsTabConfiguration, NormalizeRecordIdForMatch, FormatEntityRecordDisplayTitle, ResolveRecordTabDisplayTitle, FORM_MODE_QUERY_PARAM, ReadStandardFormQuery } from '@memberjunction/ng-shared';
 import { MJNotificationService } from '@memberjunction/ng-notifications';
 import { IsOmnibarAvailable, IsOmnibarEnabledForUser, OMNIBAR_PROMO_DISMISSED_KEY, OMNIBAR_USER_SETTING_KEY } from '../omnibar/omnibar-user-setting';
 import { GetOmnibarShortcutLabel } from '../omnibar/omnibar-shortcut';
@@ -18,6 +18,7 @@ import { BaseAngularComponent } from '@memberjunction/ng-base-types';
 import { ApplyShellChromePolicy, BaseShellChromePolicy } from './shell-chrome-policy';
 import { SetReadinessBeacon } from './readiness-beacon';
 import { FindDashboardTabForUrl, OpenDashboardForUrl, ParseAppDashboardUrl } from './dashboard-tab-for-url';
+import { ApplyDeepLinkToRestoredWorkspace } from './deep-link-workspace';
 import * as i0 from "@angular/core";
 import * as i1 from "@memberjunction/ng-base-application";
 import * as i2 from "@memberjunction/ng-shared";
@@ -927,6 +928,9 @@ export class ShellComponent extends BaseAngularComponent {
             // to 'auto' (compact under a handful of apps, launcher otherwise)
             appSwitcherStyle: rawStyle === 'launcher' || rawStyle === 'compact' ? rawStyle : 'auto',
             appNav: engine.GetBoolean('Shell.AppNav.Enabled', true),
+            // The same key explorer-app read directly before the overlay went through the policy;
+            // explorer-app now reads the resolved bit from ChromeFlags.
+            chatOverlay: engine.GetBoolean('Shell.ChatOverlay.Enabled', true),
             // Resolved (and pushed to collaborators) in resolveRecordOpenStyle()
             // during initializeShell — NEVER as a getter side effect; getters
             // run at change detection's whim and startup correctness must not
@@ -939,6 +943,16 @@ export class ShellComponent extends BaseAngularComponent {
         }
         return flags;
     }
+    /**
+     * The resolved chrome, for collaborators outside the shell. explorer-app reads `chatOverlay`
+     * from here (through its view query on this component) so the overlay follows the host's
+     * chrome policy with ONE policy instance and ONE `Changed`; the memoization above makes a
+     * read from a parent's change detection a field access. Read-only on purpose: this IS the
+     * memo, and a consumer writing to it would poison the shell's own chrome.
+     */
+    get ChromeFlags() {
+        return this.chromeFlags;
+    }
     /** The policy's answer may have changed: forget the cached flags and repaint. */
     onChromePolicyChanged() {
         this._chromeFlags = null;
@@ -1258,18 +1272,33 @@ export class ShellComponent extends BaseAngularComponent {
     }
     async ngOnInit() {
         try {
+            let loggedIn = false;
+            let shellInitialized = false;
+            const initShellOnce = async () => {
+                if (shellInitialized) {
+                    return;
+                }
+                shellInitialized = true;
+                this.initialNavigationComplete = true;
+                await this.InitializeShell();
+            };
+            // Subscribe to router settlement events (NavigationEnd, NavigationError on unmatched routes,
+            // or NavigationCancel) before LoggedIn fires so we never miss a navigation that settled early
+            // or hang forever when a bad URL triggers NavigationError and resets to '/'.
+            this.subscriptions.push(this.router.events.pipe(filter((event) => event instanceof NavigationEnd ||
+                event instanceof NavigationError ||
+                event instanceof NavigationCancel), filter(() => !this.initialNavigationComplete)).subscribe(async () => {
+                this.initialNavigationComplete = true;
+                if (loggedIn) {
+                    await initShellOnce();
+                }
+            }));
             MJGlobal.Instance.GetEventListener(true).subscribe(async (loginEvent) => {
                 if (loginEvent.event === MJEventType.LoggedIn) {
-                    if (this.authBase.initialPath === "/") {
-                        // Base route - no need to wait for NavigationEnd
-                        await this.InitializeShell();
-                    }
-                    else {
-                        // Deep link route - wait for NavigationEnd to ensure router URL is correct
-                        this.router.events.pipe(filter((event) => event instanceof NavigationEnd), filter(() => !this.initialNavigationComplete)).subscribe(async () => {
-                            this.initialNavigationComplete = true;
-                            await this.InitializeShell();
-                        });
+                    loggedIn = true;
+                    if (this.authBase.initialPath === "/" || this.initialNavigationComplete) {
+                        // Base route or initial router navigation already settled
+                        await initShellOnce();
                     }
                 }
             });
@@ -1309,8 +1338,14 @@ export class ShellComponent extends BaseAngularComponent {
         // Check the current URL to determine if we're loading from a URL-based navigation
         const currentUrl = this.router.url;
         this.urlBasedNavigation = currentUrl.includes('/app/') || currentUrl.includes('/resource/');
-        // Wait for workspace initialization to complete before allowing any tab operations
-        await this.workspaceManager.Initialize(user.ID);
+        // Wait for workspace initialization to complete before allowing any tab operations.
+        // On a deep link the URL's query params are written into the matching restored tab
+        // BEFORE the configuration is published, so the URL — not the saved workspace — is what
+        // that tab's component first sees (see ApplyDeepLinkToRestoredWorkspace).
+        const startupUrl = currentUrl;
+        const startupPath = startupUrl.split('?')[0];
+        const startupIsDeepLink = startupPath.length > 1 && startupPath !== '/';
+        await this.workspaceManager.Initialize(user.ID, startupIsDeepLink ? { PrepareConfiguration: config => this.applyStartupDeepLink(config, startupUrl) } : undefined);
         // A saved tab of a nav item that moved to another app becomes a tab of that app's nav item: once now, before the
         // shell syncs the URL or the active app from the saved tabs, and again each time the user's app list changes.
         this.subscriptions.push(await this.navigationService.WatchMovedNavItemTabs());
@@ -1368,6 +1403,13 @@ export class ShellComponent extends BaseAngularComponent {
             // Nav-app list is now populated/changed — refresh the precomputed arrays
             // bound in the header template.
             this.recomputeNavBarApps();
+            // An app-locked session (magic link) whose user cannot read, or has no, User Application rows
+            // still gets its scoped app: adopt it before deciding there are no apps. Adopting re-emits
+            // Applications, which re-enters this handler with the app present.
+            const sessionLockedId = this.authBase.GetSessionScope()?.restrictedToApplicationId;
+            if (sessionLockedId && this.appManager.AdoptSessionApplication(sessionLockedId)) {
+                return;
+            }
             // Handle the case where user has no apps at all (only after loading is complete)
             if (apps.length === 0) {
                 await this.handleNoAppsAvailable();
@@ -1392,23 +1434,31 @@ export class ShellComponent extends BaseAngularComponent {
                     // already on the scoped app — fall through to normal handling below
                 }
             }
-            // Check if URL specifies an app by parsing the browser URL
+            // Check if URL specifies an app by parsing the browser URL (strip query string and fragment first)
             const currentUrl = this.router.url;
-            const appMatch = currentUrl.match(/\/app\/([^\/]+)/);
+            const currentUrlPath = (currentUrl || '').split('#')[0].split('?')[0];
+            const appMatch = currentUrlPath.match(/\/app\/([^\/?#]+)/);
             if (appMatch) {
                 const routeAppPath = decodeURIComponent(appMatch[1]);
                 // Find the app from the URL by Path (or Name for backwards compatibility)
-                const urlApp = this.appManager.GetAppByPath(routeAppPath);
+                const urlApp = this.appManager.GetAppByPath(routeAppPath) || this.appManager.GetAppByName(routeAppPath);
                 if (urlApp) {
                     // Set the app from URL - takes precedence over workspace restoration
                     await this.appManager.SetActiveApp(urlApp.ID);
                     // If the URL is just /app/:appName (no nav item), create default tab
-                    const hasNavItem = currentUrl.match(/\/app\/[^\/]+\/[^\/]+/);
+                    const hasNavItem = currentUrlPath.match(/\/app\/[^\/]+\/[^\/]+/);
                     if (!hasNavItem) {
                         const existingTabs = this.workspaceManager.GetAppTabs(urlApp.ID);
                         if (existingTabs.length === 0) {
                             const tabRequest = await urlApp.CreateDefaultTab();
                             if (tabRequest) {
+                                const urlParams = this.extractQueryParamsFromUrl(currentUrl);
+                                if (Object.keys(urlParams).length > 0) {
+                                    tabRequest.Configuration = {
+                                        ...(tabRequest.Configuration || {}),
+                                        queryParams: urlParams
+                                    };
+                                }
                                 this.tabService.OpenTab(tabRequest);
                             }
                         }
@@ -1531,17 +1581,15 @@ export class ShellComponent extends BaseAngularComponent {
         // Only restore workspace state when the URL is bare root (/) or empty.
         const initialUrl = this.router.url.split('?')[0]; // ignore query params for this check
         const isDeepLink = initialUrl.length > 1 && initialUrl !== '/';
-        const initConfig = this.workspaceManager.GetConfiguration();
+        let deepLinkResolved = false;
         if (isDeepLink) {
             // User navigated to a specific URL — sync workspace to match the URL,
             // not the other way around. The ResourceResolver will have created a tab
             // for this URL; we just need to activate it.
-            await this.syncWorkspaceWithUrl(this.router.url);
+            deepLinkResolved = await this.syncWorkspaceWithUrl(this.router.url);
         }
-        else if (initConfig && initConfig.activeTabId) {
-            // Bare root URL — restore last workspace state
-            await this.syncActiveAppWithTab(initConfig);
-            this.syncUrlWithWorkspace(initConfig);
+        if (!deepLinkResolved && !this.pendingAppPath) {
+            await this.restoreOrOpenFallbackTab();
         }
         // Force change detection to sync Angular's expected values after all async
         // state changes (apps loaded, searchableEntities populated, etc.) to prevent
@@ -1552,6 +1600,24 @@ export class ShellComponent extends BaseAngularComponent {
         // does this on construction (#4802). Non-blocking; Preload() logs and retries on demand.
         this.reactAdapter.Preload();
     }
+    /**
+     * PrepareConfiguration hook for the startup deep link: when the URL carries query params and
+     * resolves to a tab already in the restored workspace, that tab takes the URL's params and
+     * becomes active. Runs before any tab component mounts.
+     */
+    async applyStartupDeepLink(config, url) {
+        const urlParams = this.extractQueryParamsFromUrl(url);
+        if (Object.keys(urlParams).length === 0 || !config.tabs?.length) {
+            return config;
+        }
+        // findTabForUrl resolves /app/... URLs through the user's app list, which ApplicationManager
+        // is still loading when workspace initialization calls this hook; resolving now would match no
+        // app and drop the deep link. Waiting is cheap (the app list loads in parallel with the
+        // workspace) and resolves even when loading fails.
+        await this.appManager.WhenReady();
+        const tab = await this.findTabForUrl(url, config.tabs);
+        return tab ? ApplyDeepLinkToRestoredWorkspace(config, tab.id, urlParams, new Date().toISOString()) : config;
+    }
     /** @deprecated Use {@link InitializeShell}. */
     async initializeShell() {
         return this.InitializeShell();
@@ -1624,10 +1690,11 @@ export class ShellComponent extends BaseAngularComponent {
             this.titleService.reset();
             return;
         }
+        const resolvedTabTitle = ResolveRecordTabDisplayTitle(activeTab, this.ProviderToUse);
         // Get the tab's application ID
         const tabAppId = activeTab.applicationId;
         if (!tabAppId) {
-            this.titleService.setResourceName(activeTab.title || null);
+            this.titleService.setResourceName(resolvedTabTitle);
             return;
         }
         // Check if this is a system tab (not associated with a registered app)
@@ -1636,7 +1703,7 @@ export class ShellComponent extends BaseAngularComponent {
             this.cdr.detectChanges();
             // Don't try to set active app - SYSTEM_APP_ID has no registered app
             // Update browser title with just the tab title (no app context)
-            this.titleService.setContext(null, activeTab.title || 'Explorer');
+            this.titleService.setContext(null, resolvedTabTitle || 'Explorer');
             return;
         }
         // Not a system tab - clear the flag
@@ -1650,7 +1717,7 @@ export class ShellComponent extends BaseAngularComponent {
         // stays wherever the user is. Records DOCKED to the workspace fall
         // through: they are ordinary main-layout tabs and DO flip app context.
         if (this.RecordTabsStyle && IsRecordsRegionTab(activeTab.configuration)) {
-            this.titleService.setContext(this.ActiveApp?.Name || null, activeTab.title || null);
+            this.titleService.setContext(this.ActiveApp?.Name || null, resolvedTabTitle);
             return;
         }
         // Check if active app needs to be updated
@@ -1664,7 +1731,7 @@ export class ShellComponent extends BaseAngularComponent {
         // (which can be stale when switching between apps in single-resource mode).
         const app = this.appManager.GetAppById(tabAppId);
         const appName = app?.Name || null;
-        const tabTitle = activeTab.configuration?.['navItemName'] || activeTab.title || null;
+        const tabTitle = activeTab.configuration?.['navItemName'] || resolvedTabTitle || null;
         this.titleService.setContext(appName, tabTitle);
     }
     /**
@@ -1697,10 +1764,35 @@ export class ShellComponent extends BaseAngularComponent {
                 // Suppress ResourceResolver for this navigation - we're just syncing the URL
                 // to reflect the current active tab, not requesting a new tab to be opened
                 this.tabService.SuppressNextResolve();
-                this.router.navigateByUrl(resourceUrl);
+                // Leaving a record that was deleted: replace its history entry so
+                // browser Back can't reopen it as a blank form.
+                const leavingRecord = this.parseRecordUrl(currentUrl);
+                const replaceUrl = !!leavingRecord &&
+                    this.tabService.ConsumeRecordUrlReplacement(leavingRecord.EntityName, leavingRecord.RecordId);
+                this.router.navigateByUrl(resourceUrl, { replaceUrl });
             }
         }
     }
+    /**
+     * The record a URL shows, from either record URL shape
+     * (`/app/:app/record/:entity/:id` or legacy `/resource/record/:entity/:id`),
+     * or null when it is not a record URL. Query string and fragment ignored.
+     */
+    parseRecordUrl(url) {
+        const urlPath = url.split(/[?#]/)[0];
+        const appRecordMatch = urlPath.match(/^\/app\/[^\/]+\/record\/([^\/]+)\/(.+)$/);
+        const legacyRecordMatch = appRecordMatch ? null : urlPath.match(/^\/resource\/record\/([^\/]+)\/(.+)$/);
+        const match = appRecordMatch ?? legacyRecordMatch;
+        if (!match) {
+            return null;
+        }
+        try {
+            return { EntityName: decodeURIComponent(match[1]), RecordId: NormalizeRecordIdForMatch(decodeURIComponent(match[2])) };
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Sync workspace state with the current URL: find the tab that matches it and activate that tab.
      *
@@ -1716,11 +1808,12 @@ export class ShellComponent extends BaseAngularComponent {
      */
     async syncWorkspaceWithUrl(url, navigatedAt = this.lastNavigationAt) {
         const config = this.workspaceManager.GetConfiguration();
-        if (!config?.tabs?.length) {
-            return;
+        if (!config?.tabs) {
+            return false;
         }
-        // Find the tab that matches this URL
-        const matchingTab = await this.findTabForUrl(url, config.tabs);
+        // Find the tab that matches this URL (null when workspace has no tabs yet,
+        // which falls through to handleMissingTabForUrl below so deep links still open).
+        const matchingTab = config.tabs.length > 0 ? await this.findTabForUrl(url, config.tabs) : null;
         if (matchingTab && matchingTab.id !== config.activeTabId) {
             /**
              * ORDERING. A url sync must not override an activation that happened AFTER this url was
@@ -1763,16 +1856,37 @@ export class ShellComponent extends BaseAngularComponent {
             // stays because it says what the comparison relies on, but removing it changes no behaviour and
             // breaks no test — do not read it as the thing that handles NaN.
             if (Number.isFinite(activatedAt) && activatedAt > navigatedAt && activatedAt <= Date.now()) {
-                return;
+                return true;
+            }
+            // If the URL carries query params that differ from the matching tab's config, sync them
+            // before activating so syncUrlWithWorkspace doesn't overwrite the URL with stale params.
+            // When the URL is a bare app-level URL (/app/:appName) with no query params, preserve the
+            // default tab's saved queryParams state (matching ApplyDeepLinkToRestoredWorkspace).
+            const urlParams = this.extractQueryParamsFromUrl(url);
+            const isBareAppOnlyUrl = /^\/app\/[^\/]+$/.test(url.split('?')[0]) && Object.keys(urlParams).length === 0;
+            const tabParams = (matchingTab.configuration?.['queryParams'] || {});
+            if (!isBareAppOnlyUrl && !this.queryParamsEqual(urlParams, tabParams) && typeof this.workspaceManager.UpdateTabConfiguration === 'function') {
+                this.urlBasedNavigation = true;
+                try {
+                    this.workspaceManager.UpdateTabConfiguration(matchingTab.id, {
+                        queryParams: Object.keys(urlParams).length > 0 ? urlParams : undefined
+                    });
+                    this.navigationService?.NotifyQueryParamsChanged?.(matchingTab.id, urlParams);
+                }
+                finally {
+                    this.urlBasedNavigation = false;
+                }
             }
             // Activate the matching tab
             this.workspaceManager.SetActiveTab(matchingTab.id);
+            return true;
         }
         else if (matchingTab && matchingTab.id === config.activeTabId) {
             // Same tab is already active, but query params may have changed (back/forward within nav item)
             const urlParams = this.extractQueryParamsFromUrl(url);
+            const isBareAppOnlyUrl = /^\/app\/[^\/]+$/.test(url.split('?')[0]) && Object.keys(urlParams).length === 0;
             const tabParams = (matchingTab.configuration?.['queryParams'] || {});
-            if (!this.queryParamsEqual(urlParams, tabParams)) {
+            if (!isBareAppOnlyUrl && !this.queryParamsEqual(urlParams, tabParams)) {
                 // URL is source of truth during back/forward — update tab config to match.
                 this.urlBasedNavigation = true;
                 try {
@@ -1785,9 +1899,60 @@ export class ShellComponent extends BaseAngularComponent {
                     this.urlBasedNavigation = false;
                 }
             }
+            return true;
         }
         else if (!matchingTab) {
-            await this.handleMissingTabForUrl(url);
+            const handled = await this.handleMissingTabForUrl(url);
+            return handled !== false;
+        }
+        return false;
+    }
+    /**
+     * Restores the active workspace tab (syncing the active app and URL) or, when no active tab
+     * exists (such as a fresh workspace after an invalid deep link suppressed default tab creation),
+     * opens a default tab on the active or landing application so the loading screen always clears.
+     */
+    async restoreOrOpenFallbackTab() {
+        const config = this.workspaceManager.GetConfiguration();
+        const activeTab = config?.activeTabId
+            ? config.tabs?.find(tab => tab.id === config.activeTabId)
+            : undefined;
+        if (config && activeTab) {
+            await this.syncActiveAppWithTab(config);
+            await this.syncUrlWithWorkspace(config);
+            return;
+        }
+        if (config?.tabs && config.tabs.length > 0) {
+            const fallbackTab = config.tabs[0];
+            this.workspaceManager.SetActiveTab(fallbackTab.id);
+            const updatedConfig = this.workspaceManager.GetConfiguration() ?? { ...config, activeTabId: fallbackTab.id };
+            await this.syncActiveAppWithTab(updatedConfig);
+            await this.syncUrlWithWorkspace(updatedConfig);
+            return;
+        }
+        let activeApp = this.appManager.GetActiveApp();
+        if (!activeApp) {
+            const allApps = this.appManager.GetAllApps?.() ?? [];
+            if (allApps.length > 0) {
+                await this.openLandingApp(allApps);
+                activeApp = this.appManager.GetActiveApp();
+            }
+        }
+        if (activeApp) {
+            const existingAppTabs = this.workspaceManager.GetAppTabs?.(activeApp.ID) ?? [];
+            if (existingAppTabs.length === 0) {
+                const defaultTabRequest = await activeApp.CreateDefaultTab();
+                if (defaultTabRequest) {
+                    this.tabService.OpenTab(defaultTabRequest);
+                }
+            }
+            const latestConfig = this.workspaceManager.GetConfiguration();
+            if (latestConfig?.activeTabId) {
+                await this.syncUrlWithWorkspace(latestConfig);
+            }
+            else {
+                this.router.navigateByUrl(this.appManager.GetAppUrl(activeApp), { replaceUrl: true });
+            }
         }
     }
     /**
@@ -1800,9 +1965,16 @@ export class ShellComponent extends BaseAngularComponent {
         if (queryIndex === -1)
             return {};
         const params = new URLSearchParams(cleanUrl.substring(queryIndex + 1));
-        const result = {};
-        params.forEach((value, key) => { result[key] = value; });
-        return result;
+        return this.urlSearchParamsToRecord(params);
+    }
+    urlSearchParamsToRecord(params) {
+        const safeEntries = [];
+        params.forEach((value, key) => {
+            if (key !== '__proto__' && key !== 'constructor' && key !== 'prototype') {
+                safeEntries.push([key, value]);
+            }
+        });
+        return Object.fromEntries(safeEntries);
     }
     /**
      * Compare two query param records for equality, normalizing encoding differences
@@ -1819,6 +1991,7 @@ export class ShellComponent extends BaseAngularComponent {
     /**
      * Handle the case where no tab matches the URL during back/forward navigation.
      * Creates new tabs for resources when the original tab was replaced.
+     * Returns true when a valid resource/tab was opened, or false when the URL did not resolve.
      */
     async handleMissingTabForUrl(url) {
         const urlPath = url.split('?')[0];
@@ -1832,23 +2005,26 @@ export class ShellComponent extends BaseAngularComponent {
             if (appRecordMatch) {
                 const entityName = decodeURIComponent(appRecordMatch[2]);
                 const recordId = decodeURIComponent(appRecordMatch[3]);
-                this.openRecordFromUrl(entityName, recordId, queryParams);
-                return;
+                return this.openRecordFromUrl(entityName, recordId, queryParams);
             }
             // Check for app-scoped view URL: /app/:appName/view/:viewId
             const appViewMatch = urlPath.match(/^\/app\/([^\/]+)\/view\/([^\/]+)$/);
             if (appViewMatch && appViewMatch[2] !== 'dynamic') {
                 const viewId = appViewMatch[2];
                 this.navigationService.OpenView(viewId, 'View');
-                return;
+                return true;
             }
             // Check for app-scoped dynamic view URL: /app/:appName/view/dynamic/:entityName
             const appDynamicViewMatch = urlPath.match(/^\/app\/([^\/]+)\/view\/dynamic\/(.+)$/);
             if (appDynamicViewMatch) {
                 const entityName = decodeURIComponent(appDynamicViewMatch[2]);
-                const extraFilter = queryParams.get('ExtraFilter') || undefined;
-                this.navigationService.OpenDynamicView(entityName, extraFilter);
-                return;
+                if (!this.isKnownEntity(entityName)) {
+                    return false;
+                }
+                const extraFilter = queryParams.get('ExtraFilter') || queryParams.get('extraFilter') || undefined;
+                const alternateBaseView = queryParams.get('AlternateBaseView') || queryParams.get('alternateBaseView') || queryParams.get('abv') || undefined;
+                this.navigationService.OpenDynamicView(entityName, extraFilter, alternateBaseView ? { alternateBaseView } : undefined);
+                return true;
             }
             // Check for app-scoped dashboard URL: /app/:appName/dashboard/:dashboardId. The tab goes to
             // the URL's application, where the ResourceResolver also opens it.
@@ -1857,28 +2033,28 @@ export class ShellComponent extends BaseAngularComponent {
                 OpenDashboard: (dashboardId, dashboardName, options) => this.navigationService.OpenDashboard(dashboardId, dashboardName, options),
             });
             if (openedDashboard) {
-                return;
+                return true;
             }
             // Check for app-scoped artifact URL: /app/:appName/artifact/:artifactId
             const appArtifactMatch = urlPath.match(/^\/app\/([^\/]+)\/artifact\/(.+)$/);
             if (appArtifactMatch) {
                 const artifactId = appArtifactMatch[2];
                 this.navigationService.OpenArtifact(artifactId, 'Artifact');
-                return;
+                return true;
             }
             // Check for app-scoped query URL: /app/:appName/query/:queryId
             const appQueryMatch = urlPath.match(/^\/app\/([^\/]+)\/query\/(.+)$/);
             if (appQueryMatch) {
                 const queryId = appQueryMatch[2];
                 this.navigationService.OpenQuery(queryId, 'Query');
-                return;
+                return true;
             }
             // Check for app-scoped search URL: /app/:appName/search/:searchInput
             const appSearchMatch = urlPath.match(/^\/app\/([^\/]+)\/search\/(.+)$/);
             if (appSearchMatch) {
                 const searchInput = decodeURIComponent(appSearchMatch[2]);
                 this.navigationService.OpenSearch(searchInput);
-                return;
+                return true;
             }
             // Check for app nav item URL: /app/:appName/:navItemName
             const appNavItemMatch = urlPath.match(/^\/app\/([^\/]+)\/([^\/]+)$/);
@@ -1890,18 +2066,18 @@ export class ShellComponent extends BaseAngularComponent {
                     // Activate the app and open the nav item
                     await this.appManager.SetActiveApp(app.ID);
                     const navItems = await app.GetNavItems();
-                    const navItem = navItems.find(item => item.Label === navItemName);
+                    const navItem = navItems.find(item => item.Label?.trim().toLowerCase() === navItemName.trim().toLowerCase());
                     if (navItem) {
                         // Parse query params to pass as configuration
-                        const qpObj = {};
-                        queryParams.forEach((value, key) => { qpObj[key] = value; });
+                        const qpObj = this.urlSearchParamsToRecord(queryParams);
                         this.navigationService.OpenNavItem(app.ID, navItem, app.GetColor(), Object.keys(qpObj).length > 0 ? { queryParams: qpObj } : undefined);
+                        return true;
                     }
                     else {
                         console.warn('handleMissingTabForUrl: nav item not found:', navItemName, 'in app:', appPath);
                     }
                 }
-                return;
+                return false;
             }
             // Check for app-only URL: /app/:appName
             const appOnlyMatch = urlPath.match(/^\/app\/([^\/]+)$/);
@@ -1909,6 +2085,7 @@ export class ShellComponent extends BaseAngularComponent {
                 const appPath = decodeURIComponent(appOnlyMatch[1]);
                 const app = this.appManager.GetAppByPath(appPath) || this.appManager.GetAppByName(appPath);
                 if (app) {
+                    const qpObj = this.urlSearchParamsToRecord(queryParams);
                     const navItems = await app.GetNavItems();
                     // Only auto-create tabs for apps with zero nav items
                     // Apps with nav items should have had their tabs preserved
@@ -1917,7 +2094,14 @@ export class ShellComponent extends BaseAngularComponent {
                         await this.appManager.SetActiveApp(app.ID);
                         const defaultTab = await app.CreateDefaultTab();
                         if (defaultTab) {
+                            if (Object.keys(qpObj).length > 0) {
+                                defaultTab.Configuration = {
+                                    ...(defaultTab.Configuration || {}),
+                                    queryParams: qpObj
+                                };
+                            }
                             this.workspaceManager.OpenTab(defaultTab, app.GetColor());
+                            return true;
                         }
                     }
                     else {
@@ -1925,11 +2109,12 @@ export class ShellComponent extends BaseAngularComponent {
                         await this.appManager.SetActiveApp(app.ID);
                         const defaultNavItem = navItems.find(item => item.isDefault) || navItems[0];
                         if (defaultNavItem) {
-                            this.navigationService.OpenNavItem(app.ID, defaultNavItem, app.GetColor());
+                            this.navigationService.OpenNavItem(app.ID, defaultNavItem, app.GetColor(), Object.keys(qpObj).length > 0 ? { queryParams: qpObj } : undefined);
+                            return true;
                         }
                     }
                 }
-                return;
+                return false;
             }
             // Legacy resource URLs (backward compatibility)
             // Check for legacy record URL: /resource/record/:entityName/:recordId
@@ -1937,45 +2122,105 @@ export class ShellComponent extends BaseAngularComponent {
             if (legacyRecordMatch) {
                 const entityName = decodeURIComponent(legacyRecordMatch[1]);
                 const recordId = decodeURIComponent(legacyRecordMatch[2]);
-                this.openRecordFromUrl(entityName, recordId, queryParams);
-                return;
+                return this.openRecordFromUrl(entityName, recordId, queryParams);
+            }
+            // Check for legacy dynamic view URL: /resource/view/dynamic/:entityName
+            const legacyDynamicViewMatch = urlPath.match(/^\/resource\/view\/dynamic\/(.+)$/);
+            if (legacyDynamicViewMatch) {
+                const entityName = decodeURIComponent(legacyDynamicViewMatch[1]);
+                if (!this.isKnownEntity(entityName)) {
+                    return false;
+                }
+                const extraFilter = queryParams.get('ExtraFilter') || queryParams.get('extraFilter') || undefined;
+                const alternateBaseView = queryParams.get('AlternateBaseView') || queryParams.get('alternateBaseView') || queryParams.get('abv') || undefined;
+                this.navigationService.OpenDynamicView(entityName, extraFilter, alternateBaseView ? { alternateBaseView } : undefined);
+                return true;
             }
             // Check for legacy view URL: /resource/view/:viewId
             const legacyViewMatch = urlPath.match(/^\/resource\/view\/([^\/]+)$/);
             if (legacyViewMatch && legacyViewMatch[1] !== 'dynamic') {
                 const viewId = legacyViewMatch[1];
                 this.navigationService.OpenView(viewId, 'View');
-                return;
+                return true;
             }
             // Check for legacy dashboard URL: /resource/dashboard/:dashboardId
             const legacyDashboardMatch = urlPath.match(/^\/resource\/dashboard\/(.+)$/);
             if (legacyDashboardMatch) {
                 const dashboardId = legacyDashboardMatch[1];
                 this.navigationService.OpenDashboard(dashboardId, 'Dashboard');
-                return;
+                return true;
+            }
+            // Check for legacy artifact URL: /resource/artifact/:artifactId
+            const legacyArtifactMatch = urlPath.match(/^\/resource\/artifact\/(.+)$/);
+            if (legacyArtifactMatch) {
+                this.navigationService.OpenArtifact(legacyArtifactMatch[1], 'Artifact');
+                return true;
+            }
+            // Check for legacy query URL: /resource/query/:queryId
+            const legacyQueryMatch = urlPath.match(/^\/resource\/query\/(.+)$/);
+            if (legacyQueryMatch) {
+                this.navigationService.OpenQuery(legacyQueryMatch[1], 'Query');
+                return true;
             }
+            // Check for legacy search URL: /resource/search/:searchInput
+            const legacySearchMatch = urlPath.match(/^\/resource\/search\/(.+)$/);
+            if (legacySearchMatch) {
+                this.navigationService.OpenSearch(decodeURIComponent(legacySearchMatch[1]));
+                return true;
+            }
+            return false;
         }
         finally {
             this.urlBasedNavigation = false;
         }
     }
+    /**
+     * Checks whether an entity exists in metadata when metadata is loaded.
+     * When metadata is empty (e.g. lightweight unit test harnesses), returns true.
+     */
+    isKnownEntity(entityName) {
+        let md = null;
+        try {
+            md = this.getProviderSafe();
+        }
+        catch {
+            return true;
+        }
+        const entities = md?.Entities;
+        if (!entities || entities.length === 0) {
+            return true;
+        }
+        return !!md?.EntityByName(entityName);
+    }
+    getProviderSafe() {
+        return this.ProviderToUse ?? null;
+    }
     /**
      * Recreate a record tab from a URL. `/new` is OpenNewEntityRecord — feeding
      * the sentinel through OpenEntityRecord produced an empty CompositeKey and
      * another forced tab, which is the loop that killed the browser.
      */
     openRecordFromUrl(entityName, recordId, queryParams) {
+        if (!this.isKnownEntity(entityName)) {
+            LogError(`Entity ${entityName} not found in metadata`);
+            return false;
+        }
+        // Recreating from browser history must keep `?form=standard` (MJ#4755),
+        // or back/forward would reopen the record in the custom form.
+        const formMode = ReadStandardFormQuery({ [FORM_MODE_QUERY_PARAM]: queryParams.get(FORM_MODE_QUERY_PARAM) });
         if (IsNewEntityRecordUrlId(recordId)) {
             const nrv = queryParams.get(NEW_RECORD_VALUES_QUERY_PARAM) ?? undefined;
             this.navigationService.OpenNewEntityRecord(entityName, {
                 newRecordValues: nrv,
                 recordSource: 'none',
+                formMode,
             });
-            return;
+            return true;
         }
         const compositeKey = new CompositeKey();
         compositeKey.SimpleLoadFromURLSegment(recordId);
-        this.navigationService.OpenEntityRecord(entityName, compositeKey, { recordSource: 'none' });
+        this.navigationService.OpenEntityRecord(entityName, compositeKey, { recordSource: 'none', formMode });
+        return true;
     }
     recordTabMatchesUrl(tab, entityName, recordId) {
         const tabConfig = tab.configuration || {};
@@ -2030,6 +2275,18 @@ export class ShellComponent extends BaseAngularComponent {
                 if (navItems.length === 0) {
                     return tabs.find(tab => UUIDsEqual(tab.applicationId, app.ID)) || null;
                 }
+                // For apps with nav items, an app-level URL (/app/:appName) resolves to the default nav item's tab
+                const defaultNavItem = navItems.find(item => item.isDefault) || navItems[0];
+                if (defaultNavItem) {
+                    return tabs.find(tab => {
+                        const tabConfig = tab.configuration || {};
+                        const tabAppName = tabConfig['appName'];
+                        const tabNavItemName = tabConfig['navItemName'];
+                        const appMatches = (tabAppName && tabAppName.toLowerCase() === app.Name.toLowerCase()) ||
+                            UUIDsEqual(tab.applicationId, app.ID);
+                        return appMatches && tabNavItemName?.toLowerCase() === defaultNavItem.Label?.toLowerCase();
+                    }) || null;
+                }
                 return null;
             }
         }
@@ -2057,7 +2314,9 @@ export class ShellComponent extends BaseAngularComponent {
                 const resourceType = tabConfig['resourceType']?.toLowerCase();
                 const tabEntity = (tabConfig['Entity'] || tabConfig['entity']);
                 const isDynamic = tabConfig['isDynamic'];
-                return resourceType === 'user views' && isDynamic && tabEntity?.toLowerCase() === entityName.toLowerCase();
+                return (resourceType === 'user views' || resourceType === 'mj: user views') &&
+                    isDynamic &&
+                    tabEntity?.toLowerCase() === entityName.toLowerCase();
             }) || null;
         }
         // Saved view: /app/:appName/view/:viewId
@@ -2068,7 +2327,7 @@ export class ShellComponent extends BaseAngularComponent {
                 const tabConfig = tab.configuration || {};
                 const resourceType = tabConfig['resourceType']?.toLowerCase();
                 const tabViewId = (tabConfig['viewId'] || tabConfig['recordId'] || tab.resourceRecordId);
-                return resourceType === 'user views' && tabViewId === viewId;
+                return (resourceType === 'user views' || resourceType === 'mj: user views') && tabViewId === viewId;
             }) || null;
         }
         // Query: /app/:appName/query/:queryId
@@ -2179,6 +2438,14 @@ export class ShellComponent extends BaseAngularComponent {
             const params = new URLSearchParams(all);
             return `${url}${separator}${params.toString()}`;
         };
+        // Extra query params a record tab's URL carries beyond the tab's own
+        // queryParams (which appendQP already merges — that is where the
+        // standard-form `form` param lives, MJ#4755): initial values for an
+        // unsaved record.
+        const recordQueryParams = (isNewRecord) => {
+            const nrv = isNewRecord ? EncodeNewRecordValuesForURL(config['NewRecordValues']) : undefined;
+            return nrv ? { [NEW_RECORD_VALUES_QUERY_PARAM]: nrv } : {};
+        };
         // Helper function to get app path for URL
         const getAppPath = (appIdOrName) => {
             // First try by ID
@@ -2208,7 +2475,7 @@ export class ShellComponent extends BaseAngularComponent {
         // If this is an app's default dashboard (no nav items), use app-level URL
         if (isAppDefault && appName) {
             const appPath = getAppPath(appName) || appName;
-            return `/app/${encodeURIComponent(appPath)}`;
+            return appendQP(`/app/${encodeURIComponent(appPath)}`);
         }
         // Fallback: If tab belongs to a non-system app but doesn't have appName/navItemName,
         // try to reconstruct the URL from the ApplicationId and tab title
@@ -2250,7 +2517,7 @@ export class ShellComponent extends BaseAngularComponent {
                 if (staticNavItems.length === 0 && (!resourceType || resourceType === 'custom')) {
                     // App has zero static nav items AND this is not an orphan resource (no resourceType or custom)
                     // Use app-level URL - this handles apps that only have a default dashboard
-                    return `/app/${encodeURIComponent(appPath)}`;
+                    return appendQP(`/app/${encodeURIComponent(appPath)}`);
                 }
                 // Fall through to orphan resource URL building below
             }
@@ -2289,21 +2556,26 @@ export class ShellComponent extends BaseAngularComponent {
                             // here, `syncUrlWithWorkspace`'s `currentUrl !== newUrl` check is permanently true and can
                             // drive a re-navigation loop (with onSameUrlNavigation:'reload'). The read side already
                             // decodeURIComponent()s this segment, so encoding here keeps both sides consistent.
-                            const nrv = isNewRecord ? EncodeNewRecordValuesForURL(config['NewRecordValues']) : undefined;
-                            return appendQP(`/app/${encodeURIComponent(appPath)}/record/${encodeURIComponent(entityName)}/${encodeURIComponent(idSeg)}`, nrv ? { [NEW_RECORD_VALUES_QUERY_PARAM]: nrv } : undefined);
+                            return appendQP(`/app/${encodeURIComponent(appPath)}/record/${encodeURIComponent(entityName)}/${encodeURIComponent(idSeg)}`, recordQueryParams(isNewRecord));
                         }
                     }
                     break;
                 case 'user views':
+                case 'mj: user views':
                     // Check if it's a dynamic view
                     if (isDynamic || recordId === 'dynamic') {
-                        // /app/:appName/view/dynamic/:entityName?ExtraFilter=...
+                        // /app/:appName/view/dynamic/:entityName?ExtraFilter=...&abv=...
                         if (entityName) {
-                            let url = `/app/${encodeURIComponent(appPath)}/view/dynamic/${encodeURIComponent(entityName)}`;
+                            const url = `/app/${encodeURIComponent(appPath)}/view/dynamic/${encodeURIComponent(entityName)}`;
+                            const extraParams = {};
                             if (extraFilter) {
-                                url += `?ExtraFilter=${encodeURIComponent(extraFilter)}`;
+                                extraParams['ExtraFilter'] = extraFilter;
+                            }
+                            const abv = (config['AlternateBaseView'] || config['alternateBaseView']);
+                            if (abv) {
+                                extraParams['abv'] = abv;
                             }
-                            return appendQP(url);
+                            return appendQP(url, extraParams);
                         }
                     }
                     else if (recordId) {
@@ -2362,8 +2634,7 @@ export class ShellComponent extends BaseAngularComponent {
                     if (idSeg) {
                         // Encode the CompositeKey segment ('|' → %7C) to match Angular's serialized router.url and
                         // the decodeURIComponent() on the read side — see the app-scoped 'records' case above.
-                        const nrv = isNewRecord ? EncodeNewRecordValuesForURL(config['NewRecordValues']) : undefined;
-                        return appendQP(`/resource/record/${encodeURIComponent(entityName)}/${encodeURIComponent(idSeg)}`, nrv ? { [NEW_RECORD_VALUES_QUERY_PARAM]: nrv } : undefined);
+                        return appendQP(`/resource/record/${encodeURIComponent(entityName)}/${encodeURIComponent(idSeg)}`, recordQueryParams(isNewRecord));
                     }
                 }
                 break;
@@ -3292,9 +3563,8 @@ export class ShellComponent extends BaseAngularComponent {
             if (compositeKey.KeyValuePairs.length === 0)
                 return null;
             const results = await md.GetEntityRecordNames([{ EntityName: entityName, CompositeKey: compositeKey }]);
-            if (results.length > 0 && results[0].Success && results[0].RecordName) {
-                return results[0].RecordName;
-            }
+            const rawName = results.length > 0 && results[0].Success ? results[0].RecordName : null;
+            return FormatEntityRecordDisplayTitle(entityInfo, entityName, compositeKey, rawName);
         }
         catch {
             // Fall through to null
@@ -3491,7 +3761,7 @@ export class ShellComponent extends BaseAngularComponent {
         // Get resource name from active tab
         let resourceName = null;
         if (activeTab) {
-            resourceName = activeTab.title || null;
+            resourceName = ResolveRecordTabDisplayTitle(activeTab, this.ProviderToUse);
         }
         // Update title via TitleService
         this.titleService.setContext(appName, resourceName);
@@ -4289,5 +4559,5 @@ export class ShellComponent extends BaseAngularComponent {
             type: HostListener,
             args: ['document:click']
         }] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ShellComponent, { className: "ShellComponent", filePath: "src/lib/shell/shell.component.ts", lineNumber: 61 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ShellComponent, { className: "ShellComponent", filePath: "src/lib/shell/shell.component.ts", lineNumber: 62 }); })();
 //# sourceMappingURL=shell.component.js.map