@memberjunction/ng-dashboards 3.4.0 → 4.1.0

package/dist/Home/home-application.d.ts

@@ -3,20 +3,38 @@ import { SharedService } from '@memberjunction/ng-shared';
 /**
  * Home Application - Provides dynamic navigation items for orphan resources.
  *
- * When a user opens a resource (record, view, dashboard, etc.) from within the Home app,
- * this application dynamically creates a nav item to represent that resource.
- * The nav item shows the resource name and appropriate icon from ResourceTypes metadata.
+ * Maintains a recency-ordered stack of up to 3 recently visited orphan resources.
+ * When the user opens a record/view/dashboard from within the Home app, the resource
+ * appears as a dynamic nav item. When they navigate away (e.g., click Home), the
+ * nav item persists so they can quickly jump back. Older items drop off as new ones
+ * are added.
+ *
+ * The stack is persisted to localStorage (via Metadata.Provider.LocalStorageProvider)
+ * so it survives page reloads. Resolved record labels are stored alongside each
+ * snapshot to avoid async lookups when restoring from storage.
  *
  * @example
- * User opens "John Smith" contact record from Home app:
- * - Dynamic nav item appears: [person icon] "John Smith"
- * - Clicking it re-selects that tab
+ * User opens "John Smith" contact, then "Acme Corp" company:
+ * - Nav shows: [Home] [Favorites] | [person] "Acme Corp" [building] "John Smith"
+ * - Clicking "John Smith" re-opens that record
  */
 export declare class HomeApplication extends BaseApplication {
+    private static readonly MAX_RECENT_ITEMS;
     private workspaceManager;
     private sharedService;
+    private recentOrphanStack;
+    private _storageLoadPromise;
+    /**
+     * Fingerprint of the last-processed active tab state (tabId::resourceRecordId).
+     * Guards against redundant stack mutations while still detecting content changes.
+     * In single-resource mode the tab ID stays constant when navigating between records
+     * (OpenTab replaces the temp tab's content but keeps its ID), so we must also
+     * include the resourceRecordId to detect when the tab shows a different record.
+     */
+    private _lastSeenTabFingerprint;
     /**
-     * Inject WorkspaceStateManager for accessing current tab state
+     * Inject WorkspaceStateManager for accessing current tab state.
+     * Also triggers loading the persisted stack from storage on first call.
      */
     SetWorkspaceManager(manager: WorkspaceStateManager): void;
     /**
@@ -24,30 +42,94 @@ export declare class HomeApplication extends BaseApplication {
      */
     SetSharedService(service: SharedService): void;
     /**
-     * Returns navigation items including any dynamic item for the active orphan resource.
-     * Static items (Apps, Favorites) come from DefaultNavItems in metadata.
-     * Dynamic items are generated based on the currently active tab.
+     * Returns navigation items including dynamic items for recently visited orphan resources.
+     * Static items come from DefaultNavItems in metadata.
+     * Dynamic items are generated from the recent orphan stack (up to 3).
+     */
+    GetNavItems(): Promise<NavItem[]>;
+    /**
+     * Removes a dynamic nav item from the recent stack by RecordID.
+     * Called by AppNavComponent when the user clicks the dismiss X button.
+     * If the dismissed item is currently active, navigates back to the app's default tab.
+     */
+    RemoveDynamicNavItem(item: NavItem): void;
+    /**
+     * Checks whether the dismissed nav item matches the currently active tab.
+     */
+    private isDismissedItemActive;
+    /**
+     * Navigates back to the app's default tab (first static nav item / Home dashboard).
+     */
+    private navigateToDefault;
+    /**
+     * Resolves the best icon for a dynamic nav item.
+     * Priority: entity-specific icon from metadata → resource type icon → generic fallback.
+     */
+    private resolveIcon;
+    /**
+     * Updates the recent orphan stack based on the currently active tab.
+     * If the active tab is a new orphan resource (not already in the stack and not
+     * matching any static nav item), it gets added to the front. Items already in the
+     * stack keep their position to avoid visually jarring reordering when users click
+     * between existing dynamic nav items.
+     */
+    private updateRecentStack;
+    /**
+     * Creates an OrphanResourceSnapshot from a tab if it qualifies as an orphan resource.
+     * Returns null if the tab is a static nav item, has no resource type, or is an
+     * app-level custom dashboard (no record ID).
      */
-    GetNavItems(): NavItem[];
+    private createSnapshotIfOrphan;
     /**
-     * Gets the icon for a resource type from the ResourceTypes entity.
-     * Uses SharedService which caches ResourceTypes on app load.
+     * Checks whether a tab matches any static nav item (by label, route, or driver class).
      */
-    private getResourceTypeIcon;
+    private matchesStaticNavItem;
     /**
-     * Creates a dynamic nav item for the currently active orphan resource tab.
-     * Returns null if:
-     * - No workspace manager is set
-     * - No active tab exists
-     * - Active tab doesn't belong to this app
-     * - Active tab matches a static nav item
-     * - Active tab has no resource type (e.g., app default dashboard)
+     * Creates DynamicNavItem entries for each item in the recent orphan stack.
+     * Uses the pre-resolved label from the snapshot (no async needed).
      */
-    private getDynamicResourceNavItem;
+    private buildDynamicNavItems;
+    /**
+     * Creates a single DynamicNavItem from an OrphanResourceSnapshot.
+     * Uses the snapshot's resolvedLabel directly — no async lookup needed.
+     */
+    private createDynamicNavItem;
+    /**
+     * Resolves the best available display label for an entity record nav item.
+     * Priority order:
+     *   1. Cached record name (from EntityRecordNameCache, populated by entity Load/Save)
+     *   2. Tab title (whatever the workspace assigned when the tab was opened)
+     *   3. Generated default (entity name + truncated primary key values)
+     *
+     * @param entityName - Entity name from tab configuration, may be undefined for non-entity resources
+     * @param tabRecordId - URL-encoded composite key segment (e.g. "ID|abc-123" or "Field1|val1||Field2|val2")
+     * @param tabTitle - Fallback title assigned by the workspace when the tab was opened
+     */
+    private resolveRecordLabel;
+    /**
+     * Generates a fallback label when no cached record name or tab title is available.
+     * Format: "EntityName: <truncated key value(s)>"
+     *
+     * @example
+     * // Single key:  "Contacts: abc1234..."
+     * // Multi key:   "Order Details: abc1..., 42"
+     * // No key:      "Contacts record"
+     */
+    private createDefaultLabel;
+    /**
+     * Truncates a primary key value for display, appending "..." if it exceeds maxLength.
+     * Returns the value as-is if it's short enough or empty.
+     */
+    private trimValue;
+    /**
+     * Persists the current recentOrphanStack to localStorage via Provider.
+     * Fire-and-forget — errors are logged but don't affect the UX.
+     */
+    private saveStackToStorage;
+    /**
+     * Loads the recent orphan stack from localStorage via Provider.
+     * Filters out stale entries (older than MAX_SNAPSHOT_AGE_MS).
+     */
+    private loadStackFromStorage;
 }
-/**
- * Tree-shaking prevention function.
- * Call this to ensure the HomeApplication class is not removed during build.
- */
-export declare function LoadHomeApplication(): void;
 //# sourceMappingURL=home-application.d.ts.map

package/dist/Home/home-application.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"home-application.d.ts","sourceRoot":"","sources":["../../src/Home/home-application.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAkB,OAAO,EAAE,qBAAqB,EAAgB,MAAM,qCAAqC,CAAC;AACpI,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,qBACa,eAAgB,SAAQ,eAAe;IAClD,OAAO,CAAC,gBAAgB,CAAsC;IAC9D,OAAO,CAAC,aAAa,CAA8B;IAEnD;;OAEG;IACI,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI;IAIhE;;OAEG;IACI,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAIrD;;;;OAIG;IACM,WAAW,IAAI,OAAO,EAAE;IAYjC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;;;;;;;OAQG;IACH,OAAO,CAAC,yBAAyB;CAwElC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAI1C"}
+{"version":3,"file":"home-application.d.ts","sourceRoot":"","sources":["../../src/Home/home-application.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAkB,OAAO,EAAE,qBAAqB,EAAgB,MAAM,qCAAqC,CAAC;AACpI,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAiC1D;;;;;;;;;;;;;;;;;GAiBG;AACH,qBACa,eAAgB,SAAQ,eAAe;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAK;IAE7C,OAAO,CAAC,gBAAgB,CAAsC;IAC9D,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,iBAAiB,CAAgC;IACzD,OAAO,CAAC,mBAAmB,CAA8B;IAEzD;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB,CAAuB;IAEtD;;;OAGG;IACI,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI;IAOhE;;OAEG;IACI,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAIrD;;;;OAIG;IACY,WAAW,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAwBhD;;;;OAIG;IACI,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAiBhD;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAe7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAezB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAuBnB;;;;;;OAMG;YACW,iBAAiB;IAkD/B;;;;OAIG;YACW,sBAAsB;IAgCpC;;OAEG;YACW,oBAAoB;IAoBlC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAsB5B;;;;;;;;;;OAUG;YACW,kBAAkB;IAwBhC;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB;IAc1B;;;OAGG;IACH,OAAO,CAAC,SAAS;IAiBjB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IA2B1B;;;OAGG;YACW,oBAAoB;CA0BnC"}

package/dist/Home/home-application.js

@@ -4,28 +4,57 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var HomeApplication_1;
 import { RegisterClass } from '@memberjunction/global';
 import { BaseApplication } from '@memberjunction/ng-base-application';
+import { Metadata, CompositeKey, FieldValueCollection } from '@memberjunction/core';
+/** Storage key and category for persisting the recent orphan stack */
+const STORAGE_KEY = 'HomeApp_RecentOrphanStack';
+const STORAGE_CATEGORY = 'HomeApplication';
+/** Max age for persisted snapshots — 7 days */
+const MAX_SNAPSHOT_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 /**
  * Home Application - Provides dynamic navigation items for orphan resources.
  *
- * When a user opens a resource (record, view, dashboard, etc.) from within the Home app,
- * this application dynamically creates a nav item to represent that resource.
- * The nav item shows the resource name and appropriate icon from ResourceTypes metadata.
+ * Maintains a recency-ordered stack of up to 3 recently visited orphan resources.
+ * When the user opens a record/view/dashboard from within the Home app, the resource
+ * appears as a dynamic nav item. When they navigate away (e.g., click Home), the
+ * nav item persists so they can quickly jump back. Older items drop off as new ones
+ * are added.
+ *
+ * The stack is persisted to localStorage (via Metadata.Provider.LocalStorageProvider)
+ * so it survives page reloads. Resolved record labels are stored alongside each
+ * snapshot to avoid async lookups when restoring from storage.
  *
  * @example
- * User opens "John Smith" contact record from Home app:
- * - Dynamic nav item appears: [person icon] "John Smith"
- * - Clicking it re-selects that tab
+ * User opens "John Smith" contact, then "Acme Corp" company:
+ * - Nav shows: [Home] [Favorites] | [person] "Acme Corp" [building] "John Smith"
+ * - Clicking "John Smith" re-opens that record
  */
 let HomeApplication = class HomeApplication extends BaseApplication {
+    static { HomeApplication_1 = this; }
+    static MAX_RECENT_ITEMS = 3;
     workspaceManager = null;
     sharedService = null;
+    recentOrphanStack = [];
+    _storageLoadPromise = null;
+    /**
+     * Fingerprint of the last-processed active tab state (tabId::resourceRecordId).
+     * Guards against redundant stack mutations while still detecting content changes.
+     * In single-resource mode the tab ID stays constant when navigating between records
+     * (OpenTab replaces the temp tab's content but keeps its ID), so we must also
+     * include the resourceRecordId to detect when the tab shows a different record.
+     */
+    _lastSeenTabFingerprint = null;
     /**
-     * Inject WorkspaceStateManager for accessing current tab state
+     * Inject WorkspaceStateManager for accessing current tab state.
+     * Also triggers loading the persisted stack from storage on first call.
      */
     SetWorkspaceManager(manager) {
         this.workspaceManager = manager;
+        if (!this._storageLoadPromise) {
+            this._storageLoadPromise = this.loadStackFromStorage();
+        }
     }
     /**
      * Inject SharedService for accessing ResourceTypes metadata
@@ -34,115 +63,362 @@ let HomeApplication = class HomeApplication extends BaseApplication {
         this.sharedService = service;
     }
     /**
-     * Returns navigation items including any dynamic item for the active orphan resource.
-     * Static items (Apps, Favorites) come from DefaultNavItems in metadata.
-     * Dynamic items are generated based on the currently active tab.
+     * Returns navigation items including dynamic items for recently visited orphan resources.
+     * Static items come from DefaultNavItems in metadata.
+     * Dynamic items are generated from the recent orphan stack (up to 3).
      */
-    GetNavItems() {
-        const staticItems = super.GetNavItems();
-        // Get dynamic nav item for currently active orphan resource tab
-        const dynamicItem = this.getDynamicResourceNavItem();
-        if (dynamicItem) {
-            return [...staticItems, dynamicItem];
+    async GetNavItems() {
+        // Ensure persisted stack is loaded before building nav items.
+        // On first call after page load, this awaits the IndexedDB read;
+        // on subsequent calls the promise is already resolved (no-op await).
+        if (this._storageLoadPromise) {
+            await this._storageLoadPromise;
+        }
+        const staticItems = await super.GetNavItems();
+        // Update the recent stack based on current active tab
+        // Must await — updateRecentStack is async (calls matchesStaticNavItem → super.GetNavItems())
+        // and buildDynamicNavItems reads recentOrphanStack, so the stack must be fully updated first.
+        await this.updateRecentStack();
+        // Build dynamic nav items from the stack
+        const dynamicItems = this.buildDynamicNavItems();
+        if (dynamicItems.length > 0) {
+            return [...staticItems, ...dynamicItems];
         }
         return staticItems;
     }
     /**
-     * Gets the icon for a resource type from the ResourceTypes entity.
-     * Uses SharedService which caches ResourceTypes on app load.
+     * Removes a dynamic nav item from the recent stack by RecordID.
+     * Called by AppNavComponent when the user clicks the dismiss X button.
+     * If the dismissed item is currently active, navigates back to the app's default tab.
      */
-    getResourceTypeIcon(resourceTypeName) {
-        if (!this.sharedService) {
-            return 'fa-solid fa-file';
+    RemoveDynamicNavItem(item) {
+        const index = this.recentOrphanStack.findIndex(s => s.resourceRecordId === item.RecordID);
+        if (index < 0) {
+            return;
+        }
+        const wasActive = this.isDismissedItemActive(item);
+        this.recentOrphanStack.splice(index, 1);
+        this.saveStackToStorage();
+        if (wasActive) {
+            this.navigateToDefault();
         }
-        const resourceType = this.sharedService.ResourceTypeByName(resourceTypeName);
-        return resourceType?.Icon || 'fa-solid fa-file';
     }
     /**
-     * Creates a dynamic nav item for the currently active orphan resource tab.
-     * Returns null if:
-     * - No workspace manager is set
-     * - No active tab exists
-     * - Active tab doesn't belong to this app
-     * - Active tab matches a static nav item
-     * - Active tab has no resource type (e.g., app default dashboard)
+     * Checks whether the dismissed nav item matches the currently active tab.
      */
-    getDynamicResourceNavItem() {
+    isDismissedItemActive(item) {
         if (!this.workspaceManager) {
-            return null;
+            return false;
         }
         const config = this.workspaceManager.GetConfiguration();
         if (!config?.activeTabId) {
-            return null;
+            return false;
+        }
+        const activeTab = config.tabs.find(t => t.id === config.activeTabId);
+        if (!activeTab) {
+            return false;
+        }
+        return activeTab.resourceRecordId === item.RecordID;
+    }
+    /**
+     * Navigates back to the app's default tab (first static nav item / Home dashboard).
+     */
+    navigateToDefault() {
+        if (!this.workspaceManager) {
+            return;
+        }
+        this.CreateDefaultTab().then(tabRequest => {
+            if (tabRequest && this.workspaceManager) {
+                this.workspaceManager.OpenTab(tabRequest, this.GetColor());
+            }
+        });
+    }
+    // ========================================
+    // Icon Resolution
+    // ========================================
+    /**
+     * Resolves the best icon for a dynamic nav item.
+     * Priority: entity-specific icon from metadata → resource type icon → generic fallback.
+     */
+    resolveIcon(entityName, resourceTypeName) {
+        if (entityName) {
+            const md = new Metadata();
+            const entityIcon = md.EntityByName(entityName)?.Icon;
+            if (entityIcon) {
+                return entityIcon;
+            }
+        }
+        if (this.sharedService) {
+            const resourceType = this.sharedService.ResourceTypeByName(resourceTypeName);
+            if (resourceType?.Icon) {
+                return resourceType.Icon;
+            }
+        }
+        return 'fa-solid fa-file';
+    }
+    // ========================================
+    // Recent Stack Management
+    // ========================================
+    /**
+     * Updates the recent orphan stack based on the currently active tab.
+     * If the active tab is a new orphan resource (not already in the stack and not
+     * matching any static nav item), it gets added to the front. Items already in the
+     * stack keep their position to avoid visually jarring reordering when users click
+     * between existing dynamic nav items.
+     */
+    async updateRecentStack() {
+        if (!this.workspaceManager) {
+            return;
+        }
+        const config = this.workspaceManager.GetConfiguration();
+        if (!config?.activeTabId) {
+            return;
         }
         const activeTab = config.tabs.find(t => t.id === config.activeTabId);
         if (!activeTab || activeTab.applicationId !== this.ID) {
-            return null;
+            return;
+        }
+        // Build a fingerprint from tab ID + record content. In single-resource mode,
+        // OpenTab replaces the temp tab's content but keeps the same tab ID, so we
+        // need the resourceRecordId to detect when a different record is shown.
+        const fingerprint = `${activeTab.id}::${activeTab.resourceRecordId ?? ''}`;
+        if (fingerprint === this._lastSeenTabFingerprint) {
+            return;
+        }
+        this._lastSeenTabFingerprint = fingerprint;
+        // Check if active tab qualifies as an orphan resource
+        const snapshot = await this.createSnapshotIfOrphan(activeTab);
+        if (!snapshot) {
+            // Active tab is a static resource (Home dashboard, etc.) — leave stack as-is
+            return;
         }
-        // Get resource type from tab configuration
-        const resourceType = activeTab.configuration?.['resourceType'];
+        // If this item is already in the stack, leave the order unchanged.
+        // Reordering on every click is visually jarring — items shift around
+        // while the user is clicking between existing nav items.
+        const alreadyTracked = this.recentOrphanStack.some(s => s.resourceRecordId === snapshot.resourceRecordId);
+        if (alreadyTracked) {
+            return;
+        }
+        // New orphan — push to front (most recent first) and trim oldest if needed
+        this.recentOrphanStack.unshift(snapshot);
+        if (this.recentOrphanStack.length > HomeApplication_1.MAX_RECENT_ITEMS) {
+            this.recentOrphanStack.length = HomeApplication_1.MAX_RECENT_ITEMS;
+        }
+        this.saveStackToStorage();
+    }
+    /**
+     * Creates an OrphanResourceSnapshot from a tab if it qualifies as an orphan resource.
+     * Returns null if the tab is a static nav item, has no resource type, or is an
+     * app-level custom dashboard (no record ID).
+     */
+    async createSnapshotIfOrphan(tab) {
+        const resourceType = tab.configuration?.['resourceType'];
         if (!resourceType) {
             return null;
         }
-        // Don't create dynamic nav item for 'custom' resource type without a specific record
-        // (these are typically app-level dashboards, not orphan resources)
-        if (resourceType.toLowerCase() === 'custom' && !activeTab.resourceRecordId) {
+        // Skip 'custom' resource type without a specific record (app-level dashboards)
+        if (resourceType.toLowerCase() === 'custom' && !tab.resourceRecordId) {
             return null;
         }
-        // Don't create dynamic nav item if it matches a static nav item
-        const staticItems = super.GetNavItems();
-        const matchesStatic = staticItems.some(item => {
-            // Match by label
-            if (item.Label === activeTab.title) {
+        // Skip if it matches a static nav item
+        if (await this.matchesStaticNavItem(tab)) {
+            return null;
+        }
+        // Resolve the label now so it's stored with the snapshot
+        const entityName = tab.configuration?.['Entity'];
+        const resolvedLabel = await this.resolveRecordLabel(entityName, tab.resourceRecordId, tab.title);
+        return {
+            resourceRecordId: tab.resourceRecordId,
+            resourceType,
+            entityName,
+            title: tab.title,
+            resolvedLabel,
+            configuration: tab.configuration,
+            tabId: tab.id,
+            timestamp: Date.now()
+        };
+    }
+    /**
+     * Checks whether a tab matches any static nav item (by label, route, or driver class).
+     */
+    async matchesStaticNavItem(tab) {
+        const staticItems = await super.GetNavItems();
+        return staticItems.some(item => {
+            if (item.Label === tab.title) {
                 return true;
             }
-            // Match by route
-            if (item.Route && activeTab.configuration?.['route'] === item.Route) {
+            if (item.Route && tab.configuration?.['route'] === item.Route) {
                 return true;
             }
-            // Match by driver class (for Custom resources)
-            if (item.DriverClass && activeTab.configuration?.['driverClass'] === item.DriverClass) {
+            if (item.DriverClass && tab.configuration?.['driverClass'] === item.DriverClass) {
                 return true;
             }
             return false;
         });
-        if (matchesStatic) {
-            return null;
-        }
-        // Create the dynamic nav item representing this orphan resource
-        // Icon comes from ResourceTypes entity (metadata-driven, not hardcoded)
-        const tabId = activeTab.id;
-        const tabRecordId = activeTab.resourceRecordId;
+    }
+    // ========================================
+    // Dynamic NavItem Building
+    // ========================================
+    /**
+     * Creates DynamicNavItem entries for each item in the recent orphan stack.
+     * Uses the pre-resolved label from the snapshot (no async needed).
+     */
+    buildDynamicNavItems() {
+        return this.recentOrphanStack.map(snapshot => this.createDynamicNavItem(snapshot));
+    }
+    /**
+     * Creates a single DynamicNavItem from an OrphanResourceSnapshot.
+     * Uses the snapshot's resolvedLabel directly — no async lookup needed.
+     */
+    createDynamicNavItem(snapshot) {
         return {
-            Label: activeTab.title,
-            Icon: this.getResourceTypeIcon(resourceType),
-            ResourceType: resourceType,
-            RecordID: tabRecordId,
-            Configuration: activeTab.configuration,
+            Label: snapshot.resolvedLabel,
+            Icon: this.resolveIcon(snapshot.entityName, snapshot.resourceType),
+            ResourceType: snapshot.resourceType,
+            RecordID: snapshot.resourceRecordId,
+            Configuration: snapshot.configuration,
             isDynamic: true,
-            // Custom matching function - matches if tab has same resource record ID
             isActiveMatch: (tab) => {
                 const wsTab = tab;
-                if (tabRecordId) {
-                    return wsTab.resourceRecordId === tabRecordId;
+                if (snapshot.resourceRecordId) {
+                    return wsTab.resourceRecordId === snapshot.resourceRecordId;
                 }
-                // Fall back to tab ID matching if no record ID
-                return wsTab.id === tabId;
+                return wsTab.id === snapshot.tabId;
             }
         };
     }
+    // ========================================
+    // Label Resolution
+    // ========================================
+    /**
+     * Resolves the best available display label for an entity record nav item.
+     * Priority order:
+     *   1. Cached record name (from EntityRecordNameCache, populated by entity Load/Save)
+     *   2. Tab title (whatever the workspace assigned when the tab was opened)
+     *   3. Generated default (entity name + truncated primary key values)
+     *
+     * @param entityName - Entity name from tab configuration, may be undefined for non-entity resources
+     * @param tabRecordId - URL-encoded composite key segment (e.g. "ID|abc-123" or "Field1|val1||Field2|val2")
+     * @param tabTitle - Fallback title assigned by the workspace when the tab was opened
+     */
+    async resolveRecordLabel(entityName, tabRecordId, tabTitle) {
+        if (!entityName || !tabRecordId) {
+            return tabTitle || '';
+        }
+        // Parse the URL segment into a CompositeKey
+        const fvCollection = new FieldValueCollection();
+        fvCollection.SimpleLoadFromURLSegment(tabRecordId);
+        const compositeKey = new CompositeKey(fvCollection.KeyValuePairs);
+        // Check the cache first
+        try {
+            const cachedName = await Metadata.Provider.GetCachedRecordName(entityName, compositeKey, true);
+            if (cachedName) {
+                return cachedName;
+            }
+        }
+        catch (error) {
+            console.warn('Failed to look up cached record name:', error);
+        }
+        // Fall back generated default from the key values, then tabTitle if we have no default label(unlikely)
+        return this.createDefaultLabel(entityName, compositeKey) || tabTitle;
+    }
+    /**
+     * Generates a fallback label when no cached record name or tab title is available.
+     * Format: "EntityName: <truncated key value(s)>"
+     *
+     * @example
+     * // Single key:  "Contacts: abc1234..."
+     * // Multi key:   "Order Details: abc1..., 42"
+     * // No key:      "Contacts record"
+     */
+    createDefaultLabel(entityName, key) {
+        if (!key || key.KeyValuePairs.length === 0) {
+            return `${entityName} record`;
+        }
+        if (key.KeyValuePairs.length === 1) {
+            return `${entityName}: ${this.trimValue(key.KeyValuePairs[0].Value)}`;
+        }
+        // Multiple keys - show each value trimmed, comma-separated
+        const values = key.KeyValuePairs.map(kv => this.trimValue(kv.Value)).join(', ');
+        return `${entityName}: ${values}`;
+    }
+    /**
+     * Truncates a primary key value for display, appending "..." if it exceeds maxLength.
+     * Returns the value as-is if it's short enough or empty.
+     */
+    trimValue(value, maxLength = 8) {
+        if (!value || value.trim().length === 0) {
+            return value;
+        }
+        const trimmed = value.trim();
+        if (trimmed.length <= maxLength) {
+            return trimmed;
+        }
+        return trimmed.substring(0, maxLength) + '...';
+    }
+    // ========================================
+    // Storage Persistence
+    // ========================================
+    /**
+     * Persists the current recentOrphanStack to localStorage via Provider.
+     * Fire-and-forget — errors are logged but don't affect the UX.
+     */
+    saveStackToStorage() {
+        try {
+            const provider = Metadata.Provider.LocalStorageProvider;
+            if (!provider) {
+                return;
+            }
+            // Strip non-serializable fields (isActiveMatch closures are rebuilt on load)
+            const serializable = this.recentOrphanStack.map(s => ({
+                resourceRecordId: s.resourceRecordId,
+                resourceType: s.resourceType,
+                entityName: s.entityName,
+                title: s.title,
+                resolvedLabel: s.resolvedLabel,
+                configuration: s.configuration,
+                tabId: s.tabId,
+                timestamp: s.timestamp
+            }));
+            provider.SetItem(STORAGE_KEY, JSON.stringify(serializable), STORAGE_CATEGORY).catch(err => {
+                console.warn('Failed to persist recent nav stack:', err);
+            });
+        }
+        catch (err) {
+            console.warn('Failed to persist recent nav stack:', err);
+        }
+    }
+    /**
+     * Loads the recent orphan stack from localStorage via Provider.
+     * Filters out stale entries (older than MAX_SNAPSHOT_AGE_MS).
+     */
+    async loadStackFromStorage() {
+        try {
+            const provider = Metadata.Provider.LocalStorageProvider;
+            if (!provider) {
+                return;
+            }
+            const raw = await provider.GetItem(STORAGE_KEY, STORAGE_CATEGORY);
+            if (!raw) {
+                return;
+            }
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed)) {
+                return;
+            }
+            // Filter out stale snapshots
+            const now = Date.now();
+            this.recentOrphanStack = parsed
+                .filter(s => s.resourceRecordId && s.timestamp && (now - s.timestamp) < MAX_SNAPSHOT_AGE_MS)
+                .slice(0, HomeApplication_1.MAX_RECENT_ITEMS);
+        }
+        catch (err) {
+            console.warn('Failed to load recent nav stack from storage:', err);
+        }
+    }
 };
-HomeApplication = __decorate([
+HomeApplication = HomeApplication_1 = __decorate([
     RegisterClass(BaseApplication, 'HomeApplication')
 ], HomeApplication);
 export { HomeApplication };
-/**
- * Tree-shaking prevention function.
- * Call this to ensure the HomeApplication class is not removed during build.
- */
-export function LoadHomeApplication() {
-    // This function exists solely to prevent tree-shaking
-    // The @RegisterClass decorator handles actual registration
-    const x = 1;
-}
 //# sourceMappingURL=home-application.js.map