aril 1.2.18 → 2.0.1-dev.0

package/fesm2022/aril-boot-config-apps.mjs

@@ -1,10 +1,16 @@
 import * as i0 from '@angular/core';
-import { inject, Injectable, Renderer2, ElementRef, Component, ViewEncapsulation, ViewChild, isDevMode } from '@angular/core';
-import { Router, BaseRouteReuseStrategy } from '@angular/router';
+import { inject, Injectable, ElementRef, Component, ViewChild, Input, Renderer2, ViewEncapsulation, isDevMode, signal, effect, DestroyRef, Directive, HostListener } from '@angular/core';
+import * as i1 from '@angular/router';
+import { Router, NavigationEnd, DefaultUrlSerializer } from '@angular/router';
 import { WebComponentWrapper, startsWith } from '@angular-architects/module-federation-tools';
 import { KeycloakAuthGuard, KeycloakService } from 'keycloak-angular';
 import { map, catchError, of } from 'rxjs';
 import { ForbiddenComponent, NotFoundComponent } from 'aril/boot/pages';
+import { loadRemoteModule } from '@angular-architects/module-federation-runtime';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { MessageService } from 'primeng/api';
+import { TranslocoService } from '@ngneat/transloco';
+import { filter, tap, map as map$1 } from 'rxjs/operators';
 
 const routePermissions = new Map();
 function setRoutePermissions(menuItems) {
@@ -52,6 +58,209 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
 
+// eslint-disable-next-line @angular-eslint/component-class-suffix
+class ArilWebComponentWrapper {
+    constructor(route) {
+        this.route = route;
+        this.isDestroyed = false;
+        // setupEvents tarafından bağlanan listener'ları izleriz — ngOnDestroy/yeniden bind sırasında
+        // doğru şekilde kaldırılmaları için.
+        this.registeredEvents = [];
+        // Route reuse stratejisi ile wrapper arasındaki sözleşme:
+        // - `needsRestore`: strategy retrieve sırasında set eder; ngAfterViewInit element'i view'a ekler.
+        // - `propsUpdated`: restore sonrası populateProps çağrısının ngOnChanges ile çakışmasını
+        //   engellemek için kullanılır (idempotency flag).
+        this.needsRestore = false;
+        this.propsUpdated = false;
+    }
+    ngOnInit() {
+        // Component tekrar eklendiğinde (reuse durumunda)
+        // Element restore işlemini dene (view hazır olmayabilir, o durumda ngAfterViewInit'te tekrar denenecek)
+        if (this.element) {
+            console.log('[ArilWC] ngOnInit: Element mevcut, restore deneniyor...');
+            // setTimeout ile bir sonraki tick'te dene (view henüz hazır olmayabilir)
+            setTimeout(() => {
+                this.restoreElement();
+            }, 0);
+        }
+    }
+    ngOnChanges() {
+        if (!this.element || this.isDestroyed)
+            return;
+        this.populateProps();
+    }
+    populateProps() {
+        if (!this.element || !this.props)
+            return;
+        // Custom element'e dinamik prop set ediyoruz; HTMLElement bunun için index signature
+        // taşımıyor, bu yüzden Record cast'i ile yazıyoruz.
+        const target = this.element;
+        for (const prop in this.props) {
+            target[prop] = this.props[prop];
+        }
+    }
+    setupEvents() {
+        if (!this.element)
+            return;
+        // İdempotent: önce eski listener'ları kaldır, sonra yenilerini bağla.
+        this.teardownEvents();
+        if (!this.events)
+            return;
+        for (const event in this.events) {
+            const handler = this.events[event];
+            this.element.addEventListener(event, handler);
+            this.registeredEvents.push({ name: event, handler });
+        }
+    }
+    teardownEvents() {
+        if (!this.element) {
+            this.registeredEvents = [];
+            return;
+        }
+        for (const { name, handler } of this.registeredEvents) {
+            this.element.removeEventListener(name, handler);
+        }
+        this.registeredEvents = [];
+    }
+    restoreElement() {
+        if (!this.element) {
+            console.warn('restoreElement: element yok');
+            return;
+        }
+        if (!this.vc?.nativeElement) {
+            console.warn('restoreElement: vc.nativeElement yok, tekrar denenecek');
+            // View henüz hazır değilse, bir sonraki lifecycle hook'ta tekrar dene
+            return;
+        }
+        // Hidden container'dan element'i al
+        const hiddenContainer = this.getHiddenContainer();
+        if (hiddenContainer.contains(this.element)) {
+            // Element hidden container'da, geri al
+            hiddenContainer.removeChild(this.element);
+            this.vc.nativeElement.appendChild(this.element);
+            this.populateProps();
+            console.log('Web component hidden container\'dan geri alındı ve DOM\'a eklendi');
+        }
+        else if (!this.vc.nativeElement.contains(this.element)) {
+            // Element başka bir yerdeyse veya hiçbir yerde değilse, direkt ekle
+            if (this.element.parentNode) {
+                this.element.parentNode.removeChild(this.element);
+            }
+            this.vc.nativeElement.appendChild(this.element);
+            this.populateProps();
+            console.log('Web component DOM\'a geri eklendi');
+        }
+        else {
+            // Element zaten DOM'da, sadece props'ları güncelle
+            this.populateProps();
+            console.log('Web component zaten DOM\'da, props güncellendi');
+        }
+    }
+    getHiddenContainer() {
+        const slot = globalThis;
+        let container = slot.__arilWebComponentHiddenContainer;
+        if (!container) {
+            container = document.createElement('div');
+            container.style.display = 'none';
+            container.style.position = 'absolute';
+            container.style.left = '-9999px';
+            container.style.top = '-9999px';
+            container.style.visibility = 'hidden';
+            document.body.appendChild(container);
+            slot.__arilWebComponentHiddenContainer = container;
+        }
+        return container;
+    }
+    async ngAfterContentInit() {
+        const options = this.options ?? this.route.snapshot.data;
+        if (!options) {
+            console.warn('Web component options bulunamadı');
+            return;
+        }
+        // Eğer element zaten varsa (reuse durumunda), restore işlemi ngAfterViewInit'te yapılacak
+        if (this.element) {
+            return;
+        }
+        try {
+            await loadRemoteModule(options);
+            this.element = document.createElement(options.elementName);
+            // Tab izolasyonu için tab kimliğini element'e attribute olarak yaz. MFE bootstrap.ts
+            // `connectedCallback`'te bu attribute'u okuyup kendine ait yeni bir Angular Application
+            // yaratır → her tab kendi Injector + Router'ına sahip olur. Subscribe ile sonraki
+            // `_tab` değişimlerini de yakala (firstCheckForRoute replaceUrl sonrası).
+            this.routeSub = this.route.queryParams.subscribe((params) => {
+                const tabId = params['_tab'] ?? '';
+                if (tabId && this.element && this.element.getAttribute('aril-tab-id') !== tabId) {
+                    this.element.setAttribute('aril-tab-id', tabId);
+                }
+            });
+            this.populateProps();
+            this.setupEvents();
+            if (this.vc?.nativeElement) {
+                this.vc.nativeElement.appendChild(this.element);
+            }
+        }
+        catch (error) {
+            console.error('Web component yüklenirken hata:', error);
+        }
+    }
+    ngAfterViewInit() {
+        // View hazır olduğunda, eğer element varsa (reuse durumunda) restore et
+        if (this.element) {
+            console.log('ngAfterViewInit: Element mevcut, restore deneniyor...');
+            // Strategy `needsRestore` flag'i set etmişse: element hidden container'dan çıkarılmış
+            // ama view henüz hazır olmadığı için view'a eklenememiş. Şimdi ekle.
+            if (this.needsRestore) {
+                this.needsRestore = false;
+                if (this.vc?.nativeElement && !this.vc.nativeElement.contains(this.element)) {
+                    this.vc.nativeElement.appendChild(this.element);
+                    this.populateProps();
+                    this.propsUpdated = true;
+                    console.log('Web component element component view\'a eklendi (ngAfterViewInit)');
+                }
+            }
+            else if (!this.propsUpdated) {
+                // Normal restore işlemi (eğer props güncellenmemişse)
+                this.restoreElement();
+                this.propsUpdated = true;
+            }
+            else {
+                // Element zaten view'da, sadece props'ları güncelle
+                this.populateProps();
+            }
+        }
+    }
+    ngOnDestroy() {
+        // Route reuse stratejisi kullanıldığında, component destroy edilmez
+        // Route reuse stratejisi store() metodunda element'i hidden container'a taşıyacak.
+        // Yine de gerçekten destroy edildiğimiz senaryolarda (farklı remote, tab cleanup vs.)
+        // event listener'ları + queryParams subscription sızdırmamak için kaldırırız.
+        this.teardownEvents();
+        this.routeSub?.unsubscribe();
+        this.routeSub = undefined;
+        this.isDestroyed = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ArilWebComponentWrapper, deps: [{ token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.2", type: ArilWebComponentWrapper, selector: "mft-wc-wrapper", inputs: { options: "options", props: "props", events: "events" }, viewQueries: [{ propertyName: "vc", first: true, predicate: ["vc"], descendants: true, read: ElementRef, static: true }], usesOnChanges: true, ngImport: i0, template: '<div #vc></div>', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: ArilWebComponentWrapper, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'mft-wc-wrapper',
+                    template: '<div #vc></div>',
+                }]
+        }], ctorParameters: () => [{ type: i1.ActivatedRoute }], propDecorators: { vc: [{
+                type: ViewChild,
+                args: ['vc', { read: ElementRef, static: true }]
+            }], options: [{
+                type: Input
+            }], props: [{
+                type: Input
+            }], events: [{
+                type: Input
+            }] } });
+
 class ShadowDOMWrapperComponent extends WebComponentWrapper {
     constructor() {
         super(...arguments);
@@ -117,11 +326,18 @@ class MicroAppService {
         }));
     }
     buildRoutes(options) {
-        const routes = options.map((options) => {
+        const routes = options.map((opt) => {
+            if (!opt.remoteName) {
+                // `remoteName` boşsa Strategy `getRouteKey` doğru tab key üretemiyor → tab izolasyonu
+                // silent kırılıyordu. Fail-fast: config hatasını boot-time'da yakala, runtime'da
+                // kullanıcı boş tab'lar görmesin.
+                throw new Error(`[MicroAppService.buildRoutes] PluginConfig.remoteName eksik. ` +
+                    `Route oluşturulamaz — config kontrol et: ${JSON.stringify(opt)}`);
+            }
             return {
-                matcher: startsWith(options.remoteName),
-                component: options.shadowDomPassive ? WebComponentWrapper : ShadowDOMWrapperComponent,
-                data: options,
+                matcher: startsWith(opt.remoteName),
+                component: opt.shadowDomPassive ? ArilWebComponentWrapper : ShadowDOMWrapperComponent,
+                data: opt,
                 canActivate: [AuthGuard]
             };
         });
@@ -178,17 +394,1469 @@ var Apps;
     Apps["DMS"] = "dms";
 })(Apps || (Apps = {}));
 
-class ArilReuseStrategy extends BaseRouteReuseStrategy {
+class RouteCloseService {
+    constructor() {
+        this.deleteRoute = signal({ key: null });
+    }
+    deleteStoredRoute(key) {
+        this.deleteRoute.update(() => ({ key }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: RouteCloseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: RouteCloseService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: RouteCloseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Tab-bazlı navigation için custom `RouteReuseStrategy`.
+ *
+ * ## Tab izolasyonu (`_tab` query param)
+ * `NavService` her tab'a unique `tabId` üretir ve URL'e `?_tab=<tabId>` query param
+ * ekler. Strategy bu param'ı route key'in parçası yapar:
+ *  - Matcher (web component) route'lar: `mfe:${remoteName}:${tabId}`
+ *  - Normal route'lar: `pathFromRoot` + tüm queryParams (zaten `_tab` dahil)
+ *
+ * Sonuç: aynı sayfanın iki tab'i `storedRoutes` üzerinde farklı slot'lara yazılır
+ * → bağımsız componentRef'ler, bağımsız state. `shouldReuseRoute` matcher karşılaştırması
+ * `tabId` farkını da dikkate alır — tab değişiminde fresh component oluşur.
+ *
+ * ## Mimari: iki bağımsız instance
+ * Bu strategy hem `aril/boot/host/src/bootstrap.ts`'te hem her MFE remote'unun
+ * `aril/boot/mfe/src/bootstrap.ts`'inde provider olarak veriliyor. Class
+ * `providedIn: 'root'` olduğu için **her root injector'da AYRI instance** yaşar.
+ * İki instance bağımsız `storedRoutes` map'i tutar ve birbirinden habersizdir:
+ *
+ * - **Host instance**: matcher route'ları yönetir; key `mfe:${remoteName}:${tabId}`.
+ *   Tab kapanıp `mfe:wdm:abc123` silindiğinde effect remote'a ait `#0/wdm/...`
+ *   prefix'li VE `_tab=abc123` içeren child key'leri de temizler.
+ * - **MFE instance** (her remote'un kendi içinde): normal route'lar için çalışır.
+ *   Query params zaten `getRouteKey` çıktısına dahil olduğu için tab izolasyonu
+ *   doğal olarak gelir — ek özel davranış gerekmez.
+ *
+ * ## Plugin custom element preservation
+ * `preserveCustomElementsInTree` detached view'daki `<md-search>` gibi custom
+ * element'leri hidden container'a taşır — element document'tan ayrılmaz, Angular
+ * Elements `disconnectedCallback` 10ms destroy timer'ı tetiklenmez, plugin
+ * componentRef'i ve dahili state'i (form input, search sonuçları) korunur.
+ *
+ * ## Bilinen sınırlamalar
+ * - `shouldDetach` matcher route'lar için tabId yokken false döner (tabsız orphan
+ *   handle oluşmasın), diğer durumlarda `true` — tüm detached route'lar cache'lenir.
+ *   Memory leak'i sınırlamak için `NavService` tab sayısını `MAX_TABS` ile kısıtlar
+ *   ve son tab kapatıldığında effect remote'un tüm child key'lerini temizler. Yine de
+ *   tab içinde açılan detail/edit gibi parametreli alt sayfaların handle'ları, parent
+ *   tab kapanana kadar storedRoutes'ta kalır.
+ */
+class CustomRouteReuseStrategy {
+    constructor() {
+        this.routeCloseService = inject(RouteCloseService);
+        this.storedRoutes = {};
+        /**
+         * `(detachedTree as any).__arilPreservedCustomEls = [...]` runtime property
+         * eklemek yerine handle'ı key olarak kullanan bir WeakMap tutuyoruz —
+         * type-safe ve handle GC'ye uğradığında bellek otomatik temizlenir.
+         */
+        this.preservedCustomEls = new WeakMap();
+        effect(() => {
+            const key = this.routeCloseService.deleteRoute().key;
+            if (!key)
+                return;
+            console.log(`[Strategy] cleanup tetiklendi key="${key}" storedKeys=[${Object.keys(this.storedRoutes).join(',')}]`);
+            this.processCleanupKey(key);
+            // Cross-injector yayın: `RouteCloseService` `providedIn: 'root'` olduğu için host ve
+            // her MFE remote'unda AYRI instance yaşar. Host'tan tetiklenen cleanup MFE strategy'sini
+            // otomatik uyandırmaz. Window event ile sinyal yayınlayıp MFE strategy'sinin kendi
+            // `storedRoutes`'unu temizlemesini sağlıyoruz (aksi takdirde MFE'de hidden container'a
+            // taşınmış plugin element'leri orphan kalır).
+            if (key.startsWith('mfe:')) {
+                const parsed = this.parseMatcherKey(key);
+                if (parsed) {
+                    window.dispatchEvent(new CustomEvent('aril:remote-cleanup', {
+                        detail: { remoteName: parsed.remoteName, tabId: parsed.tabId }
+                    }));
+                }
+            }
+        });
+        // Karşı yönde (cross-injector): host strategy'nin yayınladığı `aril:remote-cleanup`
+        // event'ini her MFE strategy instance'ı yakalar, kendi `storedRoutes`'undaki o remote'a
+        // (ve varsa o tabId'ye) ait key'leri temizler. Host strategy de bu listener'a sahip
+        // ama kendi `#0/${remoteName}/...` key'leri olmadığı için no-op çalışır (güvenli).
+        const cleanupHandler = (e) => {
+            const detail = e.detail;
+            const remoteName = detail?.remoteName;
+            if (!remoteName)
+                return;
+            const tabId = detail?.tabId ?? null;
+            const prefix = `#0/${remoteName}`;
+            const keys = Object.keys(this.storedRoutes).filter((k) => {
+                if (!k.startsWith(prefix))
+                    return false;
+                // tabId verildiyse SADECE o tab'a ait child handle'ları temizle. Aksi takdirde
+                // aynı remote'un başka tab'lerinin state'i de yanlışlıkla silinir.
+                if (tabId && !k.includes(`_tab=${tabId}`))
+                    return false;
+                return true;
+            });
+            if (!keys.length)
+                return;
+            console.log(`[Strategy] cross-injector cleanup remoteName="${remoteName}" tabId="${tabId ?? '*'}" keys=[${keys.join(',')}]`);
+            for (const k of keys) {
+                this.cleanupStoredHandle(this.storedRoutes[k]);
+                delete this.storedRoutes[k];
+            }
+        };
+        window.addEventListener('aril:remote-cleanup', cleanupHandler);
+        // Strategy `providedIn: 'root'` → root injector destroy edildiğinde listener'ı kaldır.
+        // Pratikte uzun ömürlü ama test ortamı ve gelecekteki iframe vb. multi-window
+        // senaryolarda orphan listener bırakmamak için defensive.
+        inject(DestroyRef).onDestroy(() => window.removeEventListener('aril:remote-cleanup', cleanupHandler));
+    }
+    /**
+     * Injector destroy edildiğinde — hibrit modda her tab'ın child `EnvironmentInjector`'ı tab
+     * kapanınca `destroy()` edilir; bu strategy `providedIn:'root'` olduğundan child injector'da
+     * (root-scope) materialize olmuş instance da yıkılır — `storedRoutes`'ta kalan TÜM detached
+     * handle'ları temizler. Aksi halde `preserveCustomElementsInTree` ile hidden container'a
+     * taşınmış plugin custom element'leri (örn. `<md-search>`) orphan kalır (memory leak): MFE
+     * internal route key'leri `_tab` taşımadığı için `aril:remote-cleanup` cross-injector temizliği
+     * onlara ulaşamaz. Injector-destroy bazlı bu süpürme garantili ve idempotenttir.
+     */
+    ngOnDestroy() {
+        const keys = Object.keys(this.storedRoutes);
+        if (keys.length)
+            console.log(`[Strategy] ngOnDestroy → ${keys.length} stored handle temizleniyor (tab kapandı)`);
+        for (const key of keys) {
+            this.cleanupStoredHandle(this.storedRoutes[key]);
+            delete this.storedRoutes[key];
+        }
+    }
+    /**
+     * Verilen key için direct + child cleanup uygular. Effect içinden ayrıştırılmış helper.
+     */
+    processCleanupKey(key) {
+        // Doğrudan eşleşen key varsa onu sil.
+        if (this.storedRoutes[key]) {
+            console.log(`[Strategy] cleanup → direct match "${key}"`);
+            this.cleanupStoredHandle(this.storedRoutes[key]);
+            delete this.storedRoutes[key];
+        }
+        // Matcher key silindiğinde (`mfe:wdm:abc` gibi) o remote'a ait — varsa o tab'a ait —
+        // internal route handle'larını da temizle. Convention: matcher key
+        // `mfe:${remoteName}` veya `mfe:${remoteName}:${tabId}`, normal key'ler
+        // `#0/${remoteName}/...?...&_tab=${tabId}` formatında.
+        if (key.startsWith('mfe:')) {
+            const parsed = this.parseMatcherKey(key);
+            if (!parsed)
+                return;
+            const { remoteName, tabId } = parsed;
+            const prefix = `#0/${remoteName}`;
+            for (const k of Object.keys(this.storedRoutes)) {
+                if (!k.startsWith(prefix))
+                    continue;
+                // tabId verildiyse sadece o tab'a ait child handle'ları temizle
+                if (tabId && !k.includes(`_tab=${tabId}`))
+                    continue;
+                console.log(`[Strategy] cleanup → child match "${k}"`);
+                this.cleanupStoredHandle(this.storedRoutes[k]);
+                delete this.storedRoutes[k];
+            }
+        }
+    }
+    /**
+     * `mfe:${remoteName}` veya `mfe:${remoteName}:${tabId}` formatındaki matcher key'i parse eder.
+     * tabId yoksa `null` döner (geriye dönük uyumluluk: legacy çağrılar tabId vermeyebilir).
+     */
+    parseMatcherKey(key) {
+        if (!key.startsWith('mfe:'))
+            return null;
+        const tail = key.substring(4);
+        const colonIdx = tail.indexOf(':');
+        return {
+            remoteName: colonIdx === -1 ? tail : tail.substring(0, colonIdx),
+            tabId: colonIdx === -1 ? null : tail.substring(colonIdx + 1)
+        };
+    }
+    /**
+     * Stored handle'ı tamamen temizle: hidden container'daki preserved element'leri (plugin
+     * custom element'leri + ArilWebComponentWrapper'ın `<app-xxx>` element'i) DOM'dan kaldır,
+     * sonra Angular `componentRef.destroy()` ile view tree'sini destroy et.
+     *
+     * `componentRef.destroy()` tek başına yeterli değil: Angular sadece view tree'sini bilir,
+     * bizim `preserveCustomElementsInTree` ve `preserveWebComponentElement` ile hidden
+     * container'a manuel taşınan element'lerden haberi yoktur → onlar orphan kalır.
+     */
+    cleanupStoredHandle(handle) {
+        if (!handle)
+            return; // Angular Router'ın `store(route, null)` ile bıraktığı orphan key'ler için defensive guard.
+        const hiddenContainer = this.getHiddenContainer();
+        // 1. preserveCustomElementsInTree ile taşınan plugin element'leri (örn. <md-search>)
+        const preserved = this.preservedCustomEls.get(handle);
+        if (preserved) {
+            for (const { el } of preserved) {
+                if (hiddenContainer.contains(el)) {
+                    hiddenContainer.removeChild(el);
+                }
+            }
+            this.preservedCustomEls.delete(handle);
+        }
+        // 2. preserveWebComponentElement ile taşınan wrapper element'i (örn. <app-wdm>)
+        const componentRef = handle.componentRef;
+        const instance = componentRef?.instance;
+        if (instance?.element) {
+            // Flag'i temizle ki removeChild sonrası tetiklenen disconnectedCallback Application'ı
+            // gerçekten destroy etsin — aksi halde MFEAppElement orphan kalır (memory leak).
+            delete instance.element.__arilPreserveDuringDetach;
+            if (hiddenContainer.contains(instance.element)) {
+                hiddenContainer.removeChild(instance.element);
+            }
+        }
+        // 3. Angular view tree'sini destroy et
+        componentRef?.destroy();
+    }
+    /**
+     * Matcher (MFE) route'lar için tabId zorunlu. `getTabIdFromRoute` URL queryParams +
+     * history.state'i okur. Hiçbir kaynak tabId vermezse (ilk navigation interim'i) detach
+     * edilmez; `firstCheckForRoute` `_tab` ekleyip yeniden navigate edecek.
+     */
+    shouldDetach(route) {
+        if (this.isMatcherRoute(route) && !this.getTabIdFromRoute(route)) {
+            console.log(`[Strategy] shouldDetach key="${this.getRouteKey(route)}" → false (matcher route, tabId yok)`);
+            return false;
+        }
+        const routeKey = this.getRouteKey(route);
+        console.log(`[Strategy] shouldDetach key="${routeKey}" → true`);
+        return true;
+    }
+    store(route, detachedTree) {
+        const routeKey = this.getRouteKey(route);
+        console.log(`[Strategy] store key="${routeKey}" handle=`, !!detachedTree);
+        if (!detachedTree) {
+            delete this.storedRoutes[routeKey];
+            return;
+        }
+        if (this.isMatcherRoute(route) && !this.getTabIdFromRoute(route)) {
+            console.log(`[Strategy] store SKIP key="${routeKey}" (matcher route, tabId yok)`);
+            return;
+        }
+        this.storedRoutes[routeKey] = detachedTree;
+        this.preserveWebComponentElement(detachedTree);
+        this.preserveCustomElementsInTree(detachedTree);
+    }
+    shouldAttach(route) {
+        if (this.isMatcherRoute(route) && !this.getTabIdFromRoute(route)) {
+            console.log(`[Strategy] shouldAttach key="${this.getRouteKey(route)}" → false (matcher route, tabId yok)`);
+            return false;
+        }
+        const routeKey = this.getRouteKey(route);
+        const shouldAttach = !!this.storedRoutes[routeKey];
+        console.log(`[Strategy] shouldAttach key="${routeKey}" → ${shouldAttach} (storedKeys=[${Object.keys(this.storedRoutes).join(',')}])`);
+        return shouldAttach;
+    }
+    retrieve(route) {
+        if (this.isMatcherRoute(route) && !this.getTabIdFromRoute(route)) {
+            return null;
+        }
+        const routeKey = this.getRouteKey(route);
+        const handle = this.storedRoutes[routeKey];
+        console.log(`[Strategy] retrieve key="${routeKey}" → ${handle ? 'HAS' : 'NULL'}`);
+        if (handle) {
+            this.restoreWebComponentElement(handle);
+            this.restoreCustomElementsInTree(handle);
+        }
+        return handle || null;
+    }
+    /**
+     * Web component element'ini hidden container'a taşır (state korunması için).
+     *
+     * Element'e `__arilPreserveDuringDetach` flag'i yazılır: `removeChild` + `appendChild`
+     * arasında MFE custom element'in `disconnectedCallback`'i tetikleniyor; flag oradaki
+     * destroy timer'ını **deterministic** şekilde bypass eder. Eskiden 50ms hardcoded timer
+     * yarış koşulu üretiyordu (yavaş cihazlarda Application istemsiz destroy oluyordu).
+     */
+    preserveWebComponentElement(detachedTree) {
+        try {
+            const componentRef = detachedTree.componentRef;
+            if (!componentRef)
+                return;
+            const componentInstance = componentRef.instance;
+            if (!componentInstance?.element)
+                return;
+            const element = componentInstance.element;
+            const hiddenContainer = this.getHiddenContainer();
+            // Flag — disconnectedCallback bunu okuyup destroy'ı atlayacak. removeChild'tan
+            // ÖNCE set ediliyor ki callback ilk tetiklendiğinde flag yerinde olsun.
+            element.__arilPreserveDuringDetach = true;
+            // Eğer element zaten bir parent'a sahipse, ondan ayır
+            if (element.parentNode && element.parentNode !== hiddenContainer) {
+                element.parentNode.removeChild(element);
+            }
+            // Hidden container'a ekle (eğer zaten orada değilse)
+            if (!hiddenContainer.contains(element)) {
+                hiddenContainer.appendChild(element);
+                console.log('Web component element hidden container\'a taşındı (state korunuyor)');
+            }
+        }
+        catch (error) {
+            console.warn('Web component element preserve edilirken hata:', error);
+        }
+    }
+    /**
+     * Web component element'ini hidden container'dan çıkar ve component view'a eklemeyi dene.
+     *
+     * `__arilPreserveDuringDetach` flag'i temizlenir — eğer bu retrieve sonrası element
+     * gerçek anlamda destroy edilirse `disconnectedCallback` flag yok kabul edip Application
+     * cleanup'ını yürütecek.
+     */
+    restoreWebComponentElement(detachedTree) {
+        try {
+            const componentRef = detachedTree.componentRef;
+            if (!componentRef)
+                return;
+            const componentInstance = componentRef.instance;
+            if (!componentInstance?.element)
+                return;
+            const element = componentInstance.element;
+            const hiddenContainer = this.getHiddenContainer();
+            // Eğer element hidden container'da ise, çıkar
+            if (hiddenContainer.contains(element)) {
+                hiddenContainer.removeChild(element);
+                delete element.__arilPreserveDuringDetach;
+                console.log('Web component element hidden container\'dan çıkarıldı');
+                // Component view'ın native element'ine eklemeyi dene
+                const tryRestore = () => {
+                    const vc = componentInstance.vc;
+                    if (vc?.nativeElement) {
+                        vc.nativeElement.appendChild(element);
+                        console.log('Web component element component view\'a eklendi (retrieve sırasında)');
+                        // Props'ları güncellemek için flag set et (component kendi populateProps'unu çağıracak)
+                        componentInstance.propsUpdated = false;
+                        return true;
+                    }
+                    return false;
+                };
+                // Hemen dene
+                if (!tryRestore()) {
+                    // View henüz hazır değilse, bir sonraki tick'te tekrar dene
+                    setTimeout(() => {
+                        if (!tryRestore()) {
+                            // Hala başarısızsa, flag set et (ngAfterViewInit'te tekrar denenecek)
+                            componentInstance.needsRestore = true;
+                            console.log('Web component element restore edilecek (view hazır değil, ngAfterViewInit\'te tekrar denenecek)');
+                        }
+                    }, 0);
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Web component element restore edilirken hata:', error);
+        }
+    }
+    /**
+     * Global hidden container'ı oluşturur veya döndürür
+     */
+    getHiddenContainer() {
+        const slot = globalThis;
+        let container = slot.__arilWebComponentHiddenContainer;
+        if (!container) {
+            container = document.createElement('div');
+            container.style.display = 'none';
+            container.style.position = 'absolute';
+            container.style.left = '-9999px';
+            container.style.top = '-9999px';
+            container.style.visibility = 'hidden';
+            document.body.appendChild(container);
+            slot.__arilWebComponentHiddenContainer = container;
+        }
+        return container;
+    }
+    /**
+     * Detached route view'ı içindeki plugin/MFE custom element'lerini (tag adında `-`
+     * bulunan ve `customElements`'a kayıtlı olanları) hidden container'a taşır ve
+     * yerlerine birer Comment placeholder bırakır. Element document'tan ayrılmaz,
+     * Angular Elements `disconnectedCallback` 10ms destroy timer'ı kanat çırpmaz —
+     * dolayısıyla plugin'in `ComponentRef` ve dahili state'i (form değerleri, search
+     * sonuçları vs.) sonraki retrieve'e kadar korunur.
+     */
+    preserveCustomElementsInTree(detachedTree) {
+        try {
+            const componentRef = detachedTree.componentRef;
+            const rootEl = componentRef?.location?.nativeElement;
+            if (!rootEl)
+                return;
+            const hiddenContainer = this.getHiddenContainer();
+            const all = rootEl.querySelectorAll('*');
+            const preservedList = [];
+            for (const el of Array.from(all)) {
+                const tag = el.tagName.toLowerCase();
+                if (!tag.includes('-'))
+                    continue;
+                if (!window.customElements?.get(tag))
+                    continue;
+                const node = el;
+                const placeholder = document.createComment(`aril-preserved:${tag}`);
+                node.parentNode?.insertBefore(placeholder, node);
+                hiddenContainer.appendChild(node);
+                preservedList.push({ el: node, placeholder });
+            }
+            if (preservedList.length) {
+                this.preservedCustomEls.set(detachedTree, preservedList);
+                console.log(`[Strategy] preserveCustomElementsInTree: ${preservedList.length} element taşındı`);
+            }
+        }
+        catch (error) {
+            console.warn('Custom element preserve edilirken hata:', error);
+        }
+    }
+    /**
+     * preserveCustomElementsInTree ile taşınan custom element'leri orijinal
+     * placeholder'larının yerine geri koyar.
+     */
+    restoreCustomElementsInTree(detachedTree) {
+        try {
+            const preservedList = this.preservedCustomEls.get(detachedTree);
+            if (!preservedList?.length)
+                return;
+            for (const { el, placeholder } of preservedList) {
+                if (placeholder.parentNode) {
+                    placeholder.parentNode.replaceChild(el, placeholder);
+                }
+                else {
+                    // Placeholder ağaçtan koparılmış — parent view tamamen destroy edilmiş olabilir
+                    // (örn. remote tab kapanmış). Element'i hidden container'da bırakmamak için cleanup.
+                    console.warn('[Strategy] restore: placeholder parent yok, custom element cleanup ediliyor', el.tagName);
+                    if (el.parentNode === this.getHiddenContainer()) {
+                        this.getHiddenContainer().removeChild(el);
+                    }
+                }
+            }
+            this.preservedCustomEls.delete(detachedTree);
+            console.log(`[Strategy] restoreCustomElementsInTree: ${preservedList.length} element geri yerleştirildi`);
+        }
+        catch (error) {
+            console.warn('Custom element restore edilirken hata:', error);
+        }
+    }
+    isMatcherRoute(route) {
+        return !!route?.routeConfig?.matcher;
+    }
+    getRemoteName(route) {
+        return route?.routeConfig?.data?.remoteName ?? null;
+    }
+    /**
+     * URL `?_tab=<tabId>` query param'ını oku — `NavService` her tab için unique değer üretir.
+     * `IsolatedLocationStrategy` sayesinde host Router'a tabsız navigation gelmez, sadece
+     * `tabState({_tab})`'lı tab tıklamaları gelir → `route.queryParams['_tab']` her zaman dolu.
+     */
+    getTabIdFromRoute(route) {
+        const v = route?.queryParams?.['_tab'];
+        return typeof v === 'string' && v.length > 0 ? v : null;
+    }
+    /**
+     * Route key'ini oluşturur. Matcher (web component) route'lar için remoteName + tabId
+     * bazlı key kullanılır — aynı remote'un her tab'i ayrı MFE custom element instance'ına
+     * sahiptir (bağımsız state).
+     *
+     * Normal route'lar için `pathFromRoot` üzerinden tam yol üretilir, ardından query params
+     * eklenir (zaten `_tab` dahil) — nested boş-path (`path: ''`) child route'larının aynı `""`
+     * key'iyle çakışmasını engeller ve aynı path'in iki tab'i farklı key alır.
+     */
+    getRouteKey(route) {
+        if (this.isMatcherRoute(route)) {
+            const remoteName = this.getRemoteName(route);
+            if (remoteName) {
+                const tabId = this.getTabIdFromRoute(route);
+                return tabId ? `mfe:${remoteName}:${tabId}` : `mfe:${remoteName}`;
+            }
+        }
+        // Tam path: kök → intermediate → self. Boş segmentleri index ile koruyarak hiyerarşi
+        // pozisyonunu key'e dahil ederiz (kardeş empty-path route'lar farklı key alır).
+        const fullPath = route.pathFromRoot
+            .map((r, i) => {
+            const seg = r.url.map((s) => s.path).join('/');
+            return seg.length > 0 ? seg : `#${i}`;
+        })
+            .join('/');
+        const queryParams = this.serializeQueryParams(route.queryParams);
+        const fragment = route.fragment ? '#' + route.fragment : '';
+        return fullPath + queryParams + fragment;
+    }
+    /**
+     * Query param'ları URL-safe şekilde serileştirir. `URLSearchParams` constructor'una
+     * doğrudan object verirsek array değerler `?ids=1,2,3` gibi tek key olarak yazılır;
+     * Angular Router'ın `?ids=1&ids=2&ids=3` davranışıyla uyumsuz olabilir. `append` ile
+     * her array elemanı ayrı entry olur ve null/undefined değerler atlanır.
+     */
+    serializeQueryParams(params) {
+        // `sort()` ile determinism — aynı sayfanın farklı insertion-order'lı queryParams'ı
+        // (deep link share, server-side render, JS-generated URL'ler) aynı route key üretir.
+        // Aksi takdirde `?b=1&a=2` ve `?a=2&b=1` iki ayrı handle olarak cache'lenir → tab
+        // izolasyonu aynı sayfanın iki ayrı instance'ını açar.
+        const keys = Object.keys(params).sort();
+        if (!keys.length)
+            return '';
+        const out = new URLSearchParams();
+        for (const k of keys) {
+            const v = params[k];
+            if (v == null)
+                continue;
+            if (Array.isArray(v)) {
+                v.forEach((vv) => vv != null && out.append(k, String(vv)));
+            }
+            else {
+                out.append(k, String(v));
+            }
+        }
+        const str = out.toString();
+        return str ? '?' + str : '';
+    }
     shouldReuseRoute(future, curr) {
-        if (curr.firstChild?.routeConfig?.data?.['remoteEntry'] === future.firstChild?.routeConfig?.data?.['remoteEntry'])
+        const futureMatcher = this.isMatcherRoute(future);
+        const currMatcher = this.isMatcherRoute(curr);
+        if (futureMatcher && currMatcher) {
+            const fr = this.getRemoteName(future);
+            const cr = this.getRemoteName(curr);
+            const ft = this.getTabIdFromRoute(future);
+            const ct = this.getTabIdFromRoute(curr);
+            // Aynı remote olsa bile farklı tab'lerse fresh component instantiate edilmeli —
+            // aksi takdirde iki tab tek componentRef'i paylaşır ve state izolasyonu kaybolur.
+            const shouldReuse = !!fr && fr === cr && ft === ct;
+            console.log(`[Strategy] shouldReuseRoute matcher → ${shouldReuse}. future=${fr}/${ft} curr=${cr}/${ct}`);
+            return shouldReuse;
+        }
+        if (futureMatcher !== currMatcher) {
+            console.log('[Strategy] shouldReuseRoute mixed → false');
+            return false;
+        }
+        const shouldReuse = future.routeConfig === curr.routeConfig;
+        const futureKey = this.getRouteKey(future);
+        const currKey = this.getRouteKey(curr);
+        const futureComp = future.routeConfig?.component?.name ?? future.component?.name ?? 'none';
+        const currComp = curr.routeConfig?.component?.name ?? curr.component?.name ?? 'none';
+        console.log(`[Strategy] shouldReuseRoute normal → ${shouldReuse}. future="${futureKey}"(${futureComp}) curr="${currKey}"(${currComp})`);
+        return shouldReuse;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: CustomRouteReuseStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: CustomRouteReuseStrategy, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: CustomRouteReuseStrategy, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * `Router.navigateByUrl` wrapper'ı — `AbortError`'ı caller için "navigation cancelled"
+ * sinyali olarak değerlendirip Promise'i `false` ile resolve eder.
+ *
+ * **Neden**: Angular Router pending bir navigation cycle aktifken yeni `navigateByUrl`
+ * çağrılırsa, eski cycle'ı **kasıtlı olarak iptal eder** ("son navigation kazanır" semantiği)
+ * ve eski Promise'ı `AbortError: Transition was skipped` ile reject eder. Bu hata değil,
+ * Router'ın akış kontrolüdür — eski navigation zaten anlamsız çünkü kullanıcı yeni bir
+ * hedefe yöneldi. Caller'ın bu rejection'ı silently handle etmesi BEKLENİR. Aksi halde
+ * "Uncaught (in promise) AbortError" console gürültüsü oluşur.
+ *
+ * Bu helper bütün NavService + MFE bootstrap relay + AppLayoutComponent çağrılarını
+ * tek noktadan tutarlı handle eder. Diğer hata türleri (`NavigationError`, runtime exception)
+ * normal şekilde reject edilir — gerçekten beklenmeyen sorunlar yutulmaz.
+ */
+function safeNavigate(router, url, extras) {
+    return router.navigateByUrl(url, extras).catch((err) => {
+        // Yalnızca "iptal" semantiği false ile resolve edilir — genuine hatalar (guard reject,
+        // runtime exception, network down) rethrow edilir ki global `ErrorHandler` veya caller
+        // `.catch` zinciri yakalasın. Silent yutmak production debug'ı imkansızlaştırıyordu.
+        if (isCancelledNavigation(err)) {
             return false;
-        return future?.routeConfig === curr?.routeConfig && JSON.stringify(future?.params) === JSON.stringify(curr?.params);
+        }
+        throw err;
+    });
+}
+/**
+ * Angular Router cycle iptali pek çok şekilde rejection üretebilir:
+ *  - `Error` instance'ı, `name='AbortError'` veya plain `name='Error'`
+ *  - `message` 'Transition was skipped' veya 'Navigation Cancel' içerir
+ *  - `code` numerik `NavigationCancellationCode` (Router 16+)
+ * Tüm bu varyasyonları "iptal edildi, normal" olarak yorumlayıp yutarız.
+ */
+function isCancelledNavigation(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    if (e.name === 'AbortError')
+        return true;
+    if (typeof e.message === 'string') {
+        const m = e.message;
+        if (m.includes('Transition was skipped') || m.includes('NavigationCancel'))
+            return true;
     }
+    // Angular Router NavigationCancellationCode enum: SupersededByNewNavigation = 2
+    if (typeof e.code === 'number' && e.code === 2)
+        return true;
+    return false;
+}
+
+/**
+ * Router'a verilecek URL'e `_tab` query param ekler. Tab navLink'leri CLEAN saklandığı
+ * için her navigation'da bu helper'la `_tab` eklenir. UrlSerializer serialize sırasında
+ * `_tab`'i strip eder → adres çubuğunda görünmez ama Router internal queryParams'ında
+ * kalır → strategy doğru çalışır.
+ *
+ * Path'in başında leading slash garanti edilir (Router URL formatına uygunluk için).
+ */
+function withTabId(rawNavLink, tabId) {
+    const { path, query, fragment } = splitUrl(rawNavLink ?? '');
+    const params = new URLSearchParams(query);
+    params.set('_tab', tabId);
+    return `${path}?${params.toString()}${fragment}`;
+}
+/**
+ * NavLink'i clean formatta normalize eder: leading slash garantisi, query string'ten
+ * `_tab` strip, fragment korunur. `activeRoute()` UrlSerializer override'ı sayesinde
+ * clean URL döner; tab storage da clean olmalı ki karşılaştırma çalışsın.
+ */
+function cleanNavLink(rawNavLink) {
+    const { path, query, fragment } = splitUrl(rawNavLink ?? '');
+    if (!query)
+        return path + fragment;
+    const params = new URLSearchParams(query);
+    params.delete('_tab');
+    const remaining = params.toString();
+    return remaining ? `${path}?${remaining}${fragment}` : path + fragment;
+}
+/**
+ * URL string'ini path/query/fragment olarak parçalar. Fragment (`#`) ilk önce ayrılır
+ * ki query (`?`) içindeki `#` ile karışmasın. Path'in başına leading slash garanti
+ * edilir (Router URL formatı için zorunlu).
+ *
+ * `URL` constructor'ı relative URL ile çalışmaz, manuel split `URLSearchParams`'a
+ * uygun temiz query string verir. Fragment olduğu gibi (öncesinde `#` ile) döner.
+ */
+function splitUrl(raw) {
+    const fragmentIdx = raw.indexOf('#');
+    const fragment = fragmentIdx >= 0 ? raw.slice(fragmentIdx) : '';
+    const beforeFragment = fragmentIdx >= 0 ? raw.slice(0, fragmentIdx) : raw;
+    const queryIdx = beforeFragment.indexOf('?');
+    let path = queryIdx >= 0 ? beforeFragment.slice(0, queryIdx) : beforeFragment;
+    const query = queryIdx >= 0 ? beforeFragment.slice(queryIdx + 1) : '';
+    if (!path.startsWith('/'))
+        path = '/' + path;
+    return { path, query, fragment };
+}
+/** Router'a verilen extras.state objesi — `_tab`'i history state'inde tutar. */
+function tabState(tabId) {
+    return { state: { _tab: tabId } };
+}
+/**
+ * NavLink'in remote (ilk path segment) adını döndürür. Query param'lardan ve leading
+ * slash'tan etkilenmez — `/mw/app-management?_tab=abc` → `mw`.
+ */
+function extractRemoteName(navLink) {
+    if (!navLink)
+        return null;
+    let path = navLink.split('?')[0];
+    if (path.startsWith('/'))
+        path = path.slice(1);
+    return path.split('/')[0] || null;
 }
+class NavService {
+    constructor() {
+        this.router = inject(Router);
+        this.routeCloseService = inject(RouteCloseService);
+        this.messageService = inject(MessageService);
+        this.translocoService = inject(TranslocoService);
+        // i18n çevirileri lazy (async HTTP) yüklenir; `firstCheckForRoute`/`openHomeTab` çeviri
+        // yüklenmeden `translate('tab.home')` ederse raw key ("tab.home") kalır. Çeviri yüklenince
+        // fallback-isimli tab'ları (özellikle anasayfa) menüyle revize et → "Anasayfa" yerine oturur.
+        this.i18nReloadSub = this.translocoService.events$
+            .pipe(
+        // Yalnız root/global i18n (scope YOK) yüklenince reconcile et — 'tab.home' orada.
+        // Feature lazy scope'ları (her MFE sayfası kendi scope'unu yükler) gereksiz menü-DFS
+        // tetiklemesin; reconcile yalnız home/menü adlarının bağlı olduğu global çeviri içindir.
+        filter((e) => e.type === 'translationLoadSuccess' && !e.payload?.scope), takeUntilDestroyed())
+            .subscribe(() => this.reconcileTabsWithMenu());
+        this.firstCheckForRoute = false;
+        /**
+         * Aynı anda açık olabilecek tab sayısı tavanı. Tab bar'ın UX'i ve `CustomRouteReuseStrategy`
+         * `storedRoutes` birikimi için üst sınır. Aşılırsa yeni navigasyon engellenir.
+         */
+        this.MAX_TABS = 20;
+        /**
+         * Menu items'i NavService'ten almak için provider. `aril/boot/bridge`'i doğrudan import
+         * etmek ng-packagr'da `aril/boot/bridge → aril/boot/config/apps` döngüsü tetikliyordu
+         * (bridge `PluginMenuItem` type'ını import ediyor). Bunun yerine host shell
+         * (`AppLayoutComponent`) `setMenuItemsProvider(() => bridge.hostMenuItems())` ile bağlar.
+         * Provider yoksa label/icon resolve'u atlanır, URL segment fallback'i devreye girer.
+         */
+        this.menuItemsProvider = null;
+        /**
+         * Host shell anasayfa NavItem'ını sağlar — `AppLayoutComponent.homeNavItem` (menüdeki
+         * `root: true` öğesinden türetilir: navLink/navName/icon). Tüm tab'lar kapatıldığında
+         * liste boş kalmasın diye `openHomeTab` bunu kullanır; provider yoksa `/` + i18n fallback.
+         */
+        this.homeNavItemProvider = null;
+        /**
+         * URL adres çubuğundan görülen aktif route — `TabAwareUrlSerializer` `_tab`'i strip
+         * ettiği için bu CLEAN URL'dir (ör. `/crm/address-management/search`). Tab navLink'leri
+         * de clean saklandığı için `r.navLink === activeRoute()` doğrudan karşılaştırılır.
+         */
+        this.activeRoute = toSignal(this.router.events.pipe(filter((e) => e instanceof NavigationEnd), tap((e) => {
+            // Her NavigationEnd'de history state'ten aktif tabId'yi okuyup signal'a yaz.
+            // `extras.state` ile yapılan navigation'larda Angular history.state'e `_tab`'i koyar;
+            // browser back/forward navigasyonlarında da history.state korunur.
+            const tabIdFromState = window.history.state?.['_tab'];
+            if (typeof tabIdFromState === 'string' && tabIdFromState.length > 0) {
+                this.activeTabId.set(tabIdFromState);
+            }
+            const currentUrl = e.urlAfterRedirects || e.url;
+            // NOT: Aktif tab'ın navLink'ini güncelleme `syncActiveTabNavLinkForTab` ile
+            // `bridge.activeMFEUrl` üzerinden yapılır (kaynağa-bağlı, cross-tab safe).
+            // Tab `activeRoutes`'ta YOKSA türet: (a) ilk açılış/refresh deep-link, VEYA
+            // (b) browser back/forward ile KAPATILMIŞ tab'ın history entry'sine dönüş
+            // (kapatma host history'yi silmez → geri tuşu o URL'e gider, tab yeniden açılmalı).
+            // Bilinen tab (normal tıklama / yeni tab / açık tab'a geri) → yalnız activeTabId
+            // güncellenir (yukarıda), mevcut tab'a focus; türetme yapılmaz.
+            const knownTab = typeof tabIdFromState === 'string' &&
+                tabIdFromState.length > 0 &&
+                this.activeRoutes().some((r) => r.tabId === tabIdFromState);
+            if (!knownTab) {
+                // Refresh sonrası deep link → URL'den nav item türet ve activeRoutes'a ekle.
+                // URL'de `_tab` yoksa (UrlSerializer strip ettiği için adres çubuğundan paylaşılan
+                // link `_tab` taşımaz) yeni tabId üret + history state'e yaz; navigateByUrl
+                // çağrısı ile state injekte ederiz, adres çubuğu temiz kalır.
+                if (currentUrl) {
+                    const stateTabId = window.history.state?.['_tab'];
+                    const navLink = cleanNavLink(currentUrl);
+                    // İlk navigation'da (F5/açılış) gelen URL zaten activeRoutes'taki bir tab ile
+                    // eşleşiyorsa (özellikle restore edilmiş pinned tab) YENİ tab TÜRETME — o tab'ı
+                    // kullan. F5 sonrası Angular initial navigation `history.state._tab`'ı koruMAZ →
+                    // `knownTab` yakalayamaz; navLink eşleşmesi restore-duplicate'ini önler. Yalnız ilk
+                    // check'te + state'te `_tab` yokken: sonraki navigationlarda kasıtlı duplicate tab ve
+                    // browser-back ile kapatılan tab'ın re-derive davranışı korunur.
+                    const existing = !this.firstCheckForRoute && !stateTabId
+                        ? this.activeRoutes().find((r) => r.navLink === navLink)
+                        : undefined;
+                    let tabId = typeof stateTabId === 'string' && stateTabId.length > 0 ? stateTabId : existing?.tabId ?? '';
+                    let needsStateInject = false;
+                    if (!tabId) {
+                        tabId = this.generateTabId();
+                        needsStateInject = true;
+                    }
+                    else if (existing) {
+                        // Eşleşen tab'ın `tabId`'sini URL/state'e yansıt — adres çubuğu `_tab` taşımadığı
+                        // için RouteReuse `mfe:<remote>:<tabId>` key tutarlılığı state inject ister.
+                        needsStateInject = true;
+                    }
+                    this.activeTabId.set(tabId);
+                    if (!existing) {
+                        const menuInfo = this.resolveNavInfoFromMenu(navLink);
+                        const fallbackName = () => {
+                            let path = navLink;
+                            if (path.startsWith('/'))
+                                path = path.slice(1);
+                            const parts = path.split('/').filter((s) => s.length > 0);
+                            const last = parts[parts.length - 1] || 'Page';
+                            return last.charAt(0).toUpperCase() + last.slice(1).replace(/-/g, ' ');
+                        };
+                        this.addToActiveRoutes({
+                            tabId,
+                            navLink,
+                            navName: menuInfo?.navName || fallbackName(),
+                            icon: menuInfo?.icon
+                        });
+                    }
+                    if (needsStateInject) {
+                        // Mevcut navigation cycle bitiminden SONRA yeni navigation tetikle —
+                        // `queueMicrotask` Router'ın navigation kuyruğu finalize olmadan çalışıp
+                        // `AbortError: Transition was skipped`'a yol açıyordu. `setTimeout(0)` macrotask
+                        // ile current cycle biter, Router idle olur. `this.navigate` zaten AbortError'ı
+                        // yutuyor — concurrent navigation race'leri sessizce iptal edilir.
+                        setTimeout(() => {
+                            safeNavigate(this.router, withTabId(navLink, tabId), {
+                                replaceUrl: true,
+                                state: { _tab: tabId }
+                            }).catch(() => { });
+                        }, 0);
+                    }
+                }
+                this.firstCheckForRoute = true;
+            }
+        }), map$1((w) => w.urlAfterRedirects || w.url)));
+        this.activeRoutes = signal([]);
+        /** History state'ten okunan aktif tab kimliği — `isActive(tab) = tab.tabId === activeTabId()`. */
+        this.activeTabId = signal('');
+    }
+    /** RFC4122 v4 UUID — collision-free, internal state taşımaz. */
+    generateTabId() {
+        return crypto.randomUUID();
+    }
+    setMenuItemsProvider(provider) {
+        this.menuItemsProvider = provider;
+        // Provider geç set edildiyse (örn. shell layout NavigationEnd'den sonra mount oldu),
+        // activeRoutes'ta default/fallback isimle eklenmiş ilk tab'ı menüyle revize et.
+        this.reconcileTabsWithMenu();
+    }
+    setHomeNavItemProvider(provider) {
+        this.homeNavItemProvider = provider;
+        // Refresh/ilk açılış path'inde fallback ("Page") isim/ikonla eklenmiş anasayfa tab'ı
+        // varsa, provider hazır olunca menüyle (home dahil) revize et.
+        this.reconcileTabsWithMenu();
+    }
+    /**
+     * Chrome bookmark click davranışı: aktif tab'ın navLink/navName'i güncellenir,
+     * o tab'a navigate edilir. Yeni tab açılmaz. Mevcut tab'ın `tabId`'si KORUNUR —
+     * Router'a `?_tab=tabId` ile navigate edilir, history state'e yazılır; navLink
+     * storage'da CLEAN saklanır.
+     */
+    navigateInCurrentTab(navItem) {
+        const idx = this.findActiveTabIndex();
+        if (idx === -1) {
+            // Aktif tab yok — fallback olarak yeni tab aç.
+            this.openInNewTabAndFocus(navItem);
+            return;
+        }
+        const existingTab = this.activeRoutes()[idx];
+        const tabId = existingTab.tabId;
+        const newNavLink = cleanNavLink(navItem.navLink);
+        // Aynı navLink'e tıklama → yine de navigate et (`onSameUrlNavigation: 'reload'`).
+        if (existingTab.navLink === newNavLink) {
+            safeNavigate(this.router, withTabId(newNavLink, tabId), tabState(tabId));
+            return;
+        }
+        this.activeRoutes.update((routes) => {
+            const next = [...routes];
+            // Mevcut tab'ın `tabId` VE `pinned` durumu korunur — menüden gelen navItem `pinned`
+            // taşımaz; `{ ...navItem }` ile ezilirse sabitlenmiş tab unpin olurdu (tab içeriğini
+            // değiştirmek sabitlemeyi bozmamalı).
+            next[idx] = { ...navItem, tabId, navLink: newNavLink, pinned: existingTab.pinned };
+            return next;
+        });
+        safeNavigate(this.router, withTabId(newNavLink, tabId), tabState(tabId));
+    }
+    /**
+     * Arka planda yeni tab aç — aktif tab değişmez, navigate edilmez. `tabId` her zaman
+     * yeni üretilir (ya da caller verdiyse o kullanılır), exists check YOKTUR; aynı path
+     * birden fazla tab'da bağımsız yaşayabilir.
+     */
+    openInBackgroundTab(navItem) {
+        if (this.activeRoutes().length >= this.MAX_TABS) {
+            this.notifyMaxTabsReached();
+            return;
+        }
+        const tabId = navItem.tabId || this.generateTabId();
+        const navLink = cleanNavLink(navItem.navLink);
+        this.activeRoutes.update((val) => [...val, { ...navItem, tabId, navLink }]);
+    }
+    /**
+     * Yeni tab aç ve o tab'a geç. Exists check YOK — aynı path'in iki ayrı tab'i kabul edilir;
+     * her tab kendi `tabId`'siyle ayrı componentRef instantiate eder.
+     */
+    openInNewTabAndFocus(navItem) {
+        if (this.activeRoutes().length >= this.MAX_TABS) {
+            this.notifyMaxTabsReached();
+            return;
+        }
+        const tabId = navItem.tabId || this.generateTabId();
+        const navLink = cleanNavLink(navItem.navLink);
+        this.activeRoutes.update((val) => [...val, { ...navItem, tabId, navLink }]);
+        safeNavigate(this.router, withTabId(navLink, tabId), tabState(tabId));
+    }
+    /** Programatik tab ekleme; activeRoute observable refresh path'i bunu kullanır. */
+    addToActiveRoutes(navItem) {
+        if (this.activeRoutes().length >= this.MAX_TABS) {
+            // Programmatic çağrı — toast göstermek yerine sessizce return.
+            return;
+        }
+        const tabId = navItem.tabId || this.generateTabId();
+        const navLink = cleanNavLink(navItem.navLink);
+        // Signal change detection reference identity ile çalışır — yeni array dön.
+        this.activeRoutes.update((val) => [...val, { ...navItem, tabId, navLink }]);
+    }
+    /**
+     * Aktif tab'ı `activeTabId` üzerinden bulur. Aynı `navLink`'in birden fazla tab'i
+     * olabileceği için navLink karşılaştırması ambiguous; tabId tek doğru kimlik.
+     */
+    findActiveTabIndex() {
+        const tabId = this.activeTabId();
+        if (!tabId)
+            return -1;
+        return this.activeRoutes().findIndex((r) => r.tabId === tabId);
+    }
+    /** Tab limiti aşıldığında kullanıcıyı toast ile bilgilendirir. */
+    notifyMaxTabsReached() {
+        this.messageService.add({
+            severity: 'warn',
+            summary: this.translocoService.translate('tab.maxReachedSummary', { max: this.MAX_TABS }),
+            detail: this.translocoService.translate('tab.maxReachedDetail'),
+            key: 'toast-root'
+        });
+    }
+    /** Anasayfa navLink'i — host menü root item'ından (yoksa '/'), clean format. */
+    homeNavLink() {
+        return cleanNavLink(this.homeNavItemProvider?.().navLink || '/');
+    }
+    /** Verilen tab anasayfaya mı ait. */
+    isHomeTab(item) {
+        return item.navLink === this.homeNavLink();
+    }
+    /**
+     * Anasayfa tab'ı açıp ona navigate eder — tab listesi HİÇ boş kalmamalı (en az 1 tab).
+     * NavItem host menü root item'ından gelir; yoksa `/` + i18n fallback ('tab.home', 'pi pi-home').
+     */
+    openHomeTab() {
+        const base = this.homeNavItemProvider?.();
+        const navLink = cleanNavLink(base?.navLink || '/');
+        const tabId = this.generateTabId();
+        const home = {
+            tabId,
+            navLink,
+            navName: base?.navName || this.translocoService.translate('tab.home'),
+            icon: base?.icon || 'pi pi-home'
+        };
+        this.activeRoutes.update((val) => [...val, home]);
+        return safeNavigate(this.router, withTabId(navLink, tabId), tabState(tabId));
+    }
+    closeNavigation(navItem) {
+        // `tabId` ile bul — aynı path'in birden fazla tab'i olabileceği için `navLink`
+        // karşılaştırması ambiguous olur, kimlik bazlı arama tek doğru yöntem.
+        const idx = this.activeRoutes().findIndex((r) => r.tabId === navItem.tabId);
+        console.log(`[NavService] closeNavigation tabId="${navItem.tabId}" navLink="${navItem.navLink}" index=${idx}`);
+        if (idx === -1)
+            return;
+        const closedItem = this.activeRoutes()[idx];
+        // Son kalan tab anasayfaysa kapatma — her zaman en az 1 (anasayfa) tab açık kalmalı.
+        if (this.activeRoutes().length === 1 && this.isHomeTab(closedItem))
+            return;
+        // Signal change detection reference identity ile çalışır — yeni array dön.
+        this.activeRoutes.update((val) => val.filter((_, i) => i !== idx));
+        const cleanup = () => this.cleanupTabHandle(closedItem);
+        const closingActiveTab = this.activeTabId() === closedItem.tabId;
+        if (closingActiveTab) {
+            // Aktif tab kapatılıyor — başka tab'a (veya home'a) navigate edip cleanup'ı SONRA tetikle.
+            // Aksi takdirde strategy henüz `store('mfe:${remoteName}:${tabId}', handle)`'i yapmadan
+            // `deleteStoredRoute` çağrılır ve cleanup boş hit eder; ardından detach tamamlanınca
+            // element hidden container'da orphan kalır (race condition).
+            const remaining = this.activeRoutes();
+            const willNavigateItem = remaining.length > 0 ? remaining[idx] || remaining[idx - 1] : null;
+            if (willNavigateItem) {
+                safeNavigate(this.router, withTabId(willNavigateItem.navLink, willNavigateItem.tabId), tabState(willNavigateItem.tabId)).finally(cleanup);
+            }
+            else {
+                // Hiç tab kalmadı — boş bırakma, anasayfa tab'ı aç (en az 1 tab kuralı).
+                this.openHomeTab().finally(cleanup);
+            }
+        }
+        else {
+            // Aktif değildi — navigation gerekmez. Ancak arka planda açılıp (`openInBackgroundTab`)
+            // hiç görüntülenmemiş tab henüz Router tarafından `store()` edilmemiş olabilir; cleanup'ı
+            // bir microtask geciktirip olası store cycle'ına fırsat veriyoruz (orphan handle önlemi).
+            void Promise.resolve().then(cleanup);
+        }
+    }
+    /**
+     * Bir tab hariç diğer tüm tab'ları kapatır. Aktif tab kapatılanlardan ise `keepItem`'a geçer.
+     * **Sabit tab'lar korunur** (Chrome davranışı) — pinned olanlar her zaman açık kalır.
+     */
+    closeOthers(keepItem) {
+        const all = this.activeRoutes();
+        const toClose = all.filter((r) => r.tabId !== keepItem.tabId && !r.pinned);
+        if (toClose.length === 0)
+            return;
+        const survivorIds = new Set([keepItem.tabId, ...all.filter((r) => r.pinned).map((r) => r.tabId)]);
+        this.activeRoutes.set(all.filter((r) => survivorIds.has(r.tabId)));
+        const cleanupAll = () => toClose.forEach((t) => this.cleanupTabHandle(t));
+        if (this.activeTabId() !== keepItem.tabId) {
+            safeNavigate(this.router, withTabId(keepItem.navLink, keepItem.tabId), tabState(keepItem.tabId)).finally(cleanupAll);
+        }
+        else {
+            cleanupAll();
+        }
+    }
+    /**
+     * Verilen tab'ın sağındaki tüm tab'ları kapatır. **Sabit tab'lar korunur** —
+     * pinned bir tab sağda olsa bile kapatılmaz (Chrome davranışı).
+     */
+    closeToRight(item) {
+        const all = this.activeRoutes();
+        const idx = all.findIndex((r) => r.tabId === item.tabId);
+        if (idx === -1)
+            return;
+        const toClose = all.slice(idx + 1).filter((r) => !r.pinned);
+        if (toClose.length === 0)
+            return;
+        const toCloseIds = new Set(toClose.map((r) => r.tabId));
+        this.activeRoutes.set(all.filter((r) => !toCloseIds.has(r.tabId)));
+        const activeWasClosed = toClose.some((r) => r.tabId === this.activeTabId());
+        const cleanupAll = () => toClose.forEach((t) => this.cleanupTabHandle(t));
+        if (activeWasClosed) {
+            safeNavigate(this.router, withTabId(item.navLink, item.tabId), tabState(item.tabId)).finally(cleanupAll);
+        }
+        else {
+            cleanupAll();
+        }
+    }
+    /**
+     * Sabit olmayan tüm tab'ları kapatır. **Sabit tab'lar korunur** — kullanıcı "Tümünü Kapat"
+     * isterse bile pinned tab'lar açık kalır (Chrome davranışı). Hiç pinned tab yoksa ana sayfaya
+     * navigate edilir.
+     */
+    closeAll() {
+        const all = this.activeRoutes();
+        if (all.length === 0)
+            return;
+        const toClose = all.filter((r) => !r.pinned);
+        if (toClose.length === 0)
+            return;
+        const survivors = all.filter((r) => r.pinned);
+        this.activeRoutes.set(survivors);
+        const cleanupAll = () => toClose.forEach((t) => this.cleanupTabHandle(t));
+        // Aktif tab kapatılanlardan ise: ya bir pinned tab'a geç (yaşıyorsa), yoksa ana sayfaya.
+        const activeWasClosed = toClose.some((r) => r.tabId === this.activeTabId());
+        if (activeWasClosed) {
+            if (survivors.length > 0) {
+                const target = survivors[0];
+                safeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId)).finally(cleanupAll);
+            }
+            else {
+                // Pinned survivor yok — boş bırakma, anasayfa tab'ı aç (en az 1 tab kuralı).
+                this.openHomeTab().finally(cleanupAll);
+            }
+        }
+        else {
+            cleanupAll();
+        }
+    }
+    /**
+     * Tab sabitleme toggle — Chrome-vari pinning. Pinned tab'lar tab bar'ın **soluna** taşınır
+     * (insertion sırasını koruyarak), kompakt görünür, `closeOthers`/`closeToRight`/`closeAll`
+     * çağrılarından korunur. Aynı pinned tıklanırsa sabitlemeyi kaldırır → normal alanın **sonuna**
+     * taşınır.
+     */
+    togglePin(item) {
+        const all = this.activeRoutes();
+        const idx = all.findIndex((r) => r.tabId === item.tabId);
+        if (idx === -1)
+            return;
+        const target = all[idx];
+        const newPinned = !target.pinned;
+        // Önce target'ı array'den çıkar, sonra pinned/normal bloğunun **sonuna** ekle.
+        // Bu Chrome davranışı: pinlenince pinned bloğun sonuna (en sağa), unpinlenince normal
+        // bloğun başına (pinned'in hemen sağına).
+        const without = all.filter((_, i) => i !== idx);
+        const pinnedSegment = without.filter((r) => r.pinned);
+        const normalSegment = without.filter((r) => !r.pinned);
+        const updated = { ...target, pinned: newPinned };
+        // Pin → pinned bloğun sonuna; unpin → normal bloğun başına. Her iki durumda da `updated`,
+        // pinned ve normal segmentlerin SINIRINA yerleşir (pozisyon aynı) → tek ifade yeterli.
+        const next = [...pinnedSegment, updated, ...normalSegment];
+        this.activeRoutes.set(next);
+    }
+    /** Sıradaki tab'a (circular) geçer. */
+    goToNextTab() {
+        const all = this.activeRoutes();
+        if (all.length === 0)
+            return;
+        const idx = this.findActiveTabIndex();
+        const nextIdx = idx === -1 ? 0 : (idx + 1) % all.length;
+        const target = all[nextIdx];
+        safeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId));
+    }
+    /** Önceki tab'a (circular) geçer. */
+    goToPrevTab() {
+        const all = this.activeRoutes();
+        if (all.length === 0)
+            return;
+        const idx = this.findActiveTabIndex();
+        const prevIdx = idx === -1 ? all.length - 1 : (idx - 1 + all.length) % all.length;
+        const target = all[prevIdx];
+        safeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId));
+    }
+    /** Index'teki tab'a geçer (Alt+1..9 için 0-tabanlı index). */
+    goToTabByIndex(index) {
+        const all = this.activeRoutes();
+        if (index < 0 || index >= all.length)
+            return;
+        const target = all[index];
+        safeNavigate(this.router, withTabId(target.navLink, target.tabId), tabState(target.tabId));
+    }
+    /**
+     * Verilen tab'a navigate — UI'dan (tab tıklama) çağrılır. Router'a `_tab` ile URL ve
+     * `extras.state` ile tabId verir; UrlSerializer adres çubuğunu temiz tutar.
+     */
+    navigateToTab(item) {
+        if (!item?.navLink || !item?.tabId)
+            return;
+        const url = withTabId(item.navLink, item.tabId);
+        console.log(`[NavService] navigateToTab tabId="${item.tabId}" navLink="${item.navLink}" → url="${url}"`);
+        safeNavigate(this.router, url, tabState(item.tabId));
+    }
+    /**
+     * Belirli bir tab'ın `navLink`'ini ve (varsa) `navName`'ini günceller. **Kaynağa-bağlı**
+     * (per-tab) sync — caller hangi tab'ın URL'i olduğunu söyler, NavService aktif tab
+     * varsayımında bulunmaz. Hidden container'daki async MFE NavigationEnd'leri aktif tab'ın
+     * state'ini KONTAMİNE EDEMEZ.
+     *
+     * `title` parametresi MFE Router deepest route'unun `Route.title` veya `data.tabName`
+     * değerinden gelir → kullanıcı detail/edit gibi sub-sayfalara navigate olduğunda tab
+     * adı dinamik güncellenir. `title` undefined ise tab.navName değişmez (statik kalır).
+     *
+     * AppLayoutComponent effect'ten `bridge.activeMFEUrl` (`{tabId, url, title}`) ile çağrılır.
+     */
+    syncActiveTabNavLinkForTab(tabId, rawUrl, title) {
+        if (!tabId || !rawUrl)
+            return;
+        const cleanUrl = cleanNavLink(rawUrl);
+        const target = this.activeRoutes().find((t) => t.tabId === tabId);
+        if (!target)
+            return;
+        const linkChanged = target.navLink !== cleanUrl;
+        const nameChanged = !!title && target.navName !== title;
+        if (!linkChanged && !nameChanged)
+            return;
+        const newNavLink = linkChanged ? cleanUrl : target.navLink;
+        const newName = nameChanged ? title : target.navName;
+        console.log(`[NavService] syncActiveTabNavLinkForTab tab="${tabId}" ` +
+            `navLink "${target.navLink}" → "${newNavLink}" name "${target.navName}" → "${newName}"`);
+        this.activeRoutes.update((routes) => routes.map((t) => (t.tabId === tabId ? { ...t, navLink: newNavLink, navName: newName } : t)));
+    }
+    /**
+     * Tab context-menu "Yinele" (Chrome "Duplicate"): mevcut tab'ın path'i kopyalanır, yeni bir
+     * `tabId` üretilir ve yeni tab oluşturulur. Strategy `_tab` query param'ını route key'in
+     * parçası yaptığı için yeni tab bağımsız `storedRoutes` slot'una yazılır → bağımsız
+     * componentRef + state. Mevcut tab korunur, kullanıcı her ikisinde de bağımsız çalışabilir.
+     */
+    duplicateTab(item) {
+        if (!item?.navLink)
+            return;
+        if (this.activeRoutes().length >= this.MAX_TABS) {
+            this.notifyMaxTabsReached();
+            return;
+        }
+        const newTabId = this.generateTabId();
+        const newNavLink = cleanNavLink(item.navLink);
+        this.activeRoutes.update((val) => [
+            ...val,
+            { ...item, tabId: newTabId, navLink: newNavLink }
+        ]);
+        safeNavigate(this.router, withTabId(newNavLink, newTabId), tabState(newTabId));
+    }
+    reorderActiveRoutes(newRoutes) {
+        // Pinned/normal sınırı koruması — sabit tab'lar tab bar'ın solunda (insertion sırasıyla),
+        // normal tab'lar sağında kalır. CDK drag drop bir tab'ı yanlış segmente düşürürse
+        // burada otomatik düzeltilir. Segment içi sıra korunur.
+        const pinned = newRoutes.filter((r) => r.pinned);
+        const normal = newRoutes.filter((r) => !r.pinned);
+        this.activeRoutes.set([...pinned, ...normal]);
+    }
+    /**
+     * Menu config'inden navLink'e karşılık gelen item'i longest-prefix match ile bulup
+     * aktif dilde label + icon döner. Adres çubuğuna URL yapıştırarak deep link açıldığında
+     * tab'ın menüden açılan tab'la aynı görünüme sahip olmasını sağlar.
+     *
+     * Lookup `menuItemsProvider` üzerinden — host shell `setMenuItemsProvider` ile
+     * `bridge.hostMenuItems()`'a bağlar. Provider yoksa veya eşleşme yoksa `null` döner ve
+     * caller URL segment fallback'ine düşer.
+     */
+    resolveNavInfoFromMenu(navLink) {
+        // Anasayfa (menüdeki `root` öğesi) çoğu zaman `routerLink` ile eşleşmez (routerLink'i `/`
+        // veya boş olabilir, longest-prefix match'e takılmaz) → `/` için fallback "Page" + jenerik
+        // ikon dönerdi. Home provider varsa ad/ikonu doğrudan oradan (root item'dan) çöz.
+        if (this.homeNavItemProvider) {
+            const home = this.homeNavItemProvider();
+            // Anasayfa navLink eşleşiyorsa dön — menü boş/geç yüklendiyse ya da menüde `root` öğesi
+            // yoksa navName/icon boş gelebilir; i18n ('tab.home') + ev ikonu fallback ile asla
+            // menü-segment fallback'ine ("Page") düşme.
+            if (navLink === cleanNavLink(home.navLink || '/')) {
+                return {
+                    navName: home.navName || this.translocoService.translate('tab.home'),
+                    icon: home.icon || 'pi pi-home'
+                };
+            }
+        }
+        const items = this.menuItemsProvider?.();
+        if (!items?.length)
+            return null;
+        const path = navLink.split('?')[0];
+        const matched = this.findMenuItemForRoute(items, path);
+        if (!matched)
+            return null;
+        const lang = this.translocoService.getActiveLang();
+        const label = matched.label;
+        const navName = label?.[lang] || label?.['tr'] || label?.['en'] || '';
+        if (!navName)
+            return null;
+        return { navName, icon: matched.icon };
+    }
+    /**
+     * Menü/i18n yüklenince tab'ları (özellikle anasayfa) menüyle revize eder — refresh/ilk açılış
+     * path'inde tab fallback isim/iconla eklenmiş olabilir (menü veya çeviri o anda hazır değildi).
+     * Tetikleyiciler: `setMenuItemsProvider`/`setHomeNavItemProvider`, `translationLoadSuccess`
+     * event'i ve host shell menü signal'i değişimi (`AppLayoutComponent` effect). Public — host
+     * layout menü async yüklenince çağırır ki anasayfa adı `tab.home` fallback'inde takılmasın.
+     */
+    reconcileTabsWithMenu() {
+        const tabs = this.activeRoutes();
+        if (!tabs.length)
+            return;
+        let changed = false;
+        const next = tabs.map((t) => {
+            const info = this.resolveNavInfoFromMenu(t.navLink);
+            if (!info)
+                return t;
+            if (t.navName === info.navName && t.icon === info.icon)
+                return t;
+            changed = true;
+            return { ...t, navName: info.navName, icon: info.icon };
+        });
+        if (changed)
+            this.activeRoutes.set(next);
+    }
+    /**
+     * Menu ağacında verilen path için en spesifik (longest routerLink prefix) eşleşmeyi bulur.
+     * `mw/app-management/view-app` için hem `mw` hem `mw/app-management/view-app` eşleşse,
+     * daha uzun olan kazanır → leaf menu item'ın label/icon'u kullanılır.
+     *
+     * Path leading slash içerebilir (Router URL formatı), menu config routerLink'leri
+     * genelde leading slash'sız (`mw/meters`); ikisini normalize edip karşılaştırırız.
+     */
+    findMenuItemForRoute(items, path) {
+        const normalize = (p) => (p.startsWith('/') ? p.slice(1) : p);
+        const normalizedPath = normalize(path);
+        let best;
+        const visit = (list) => {
+            for (const it of list) {
+                if (it.routerLink) {
+                    const r = normalize(it.routerLink);
+                    if (r && (normalizedPath === r || normalizedPath.startsWith(r + '/'))) {
+                        const length = r.length;
+                        if (!best || length > best.length)
+                            best = { length, item: it };
+                    }
+                }
+                if (it.items?.length)
+                    visit(it.items);
+            }
+        };
+        visit(items);
+        return best?.item;
+    }
+    /**
+     * Bir tab'ın stored route handle'ını strategy'den temizler. Key formatı
+     * `mfe:${remoteName}:${tabId}` — strategy `processCleanupKey` matcher key'inden hem
+     * MFE custom element handle'ını hem o tab'a ait child route handle'larını düşürür.
+     */
+    cleanupTabHandle(item) {
+        const remoteName = extractRemoteName(item.navLink);
+        if (!remoteName || !item.tabId)
+            return;
+        console.log(`[NavService] cleanupTabHandle remoteName="${remoteName}" tabId="${item.tabId}"`);
+        this.routeCloseService.deleteStoredRoute(`mfe:${remoteName}:${item.tabId}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Cross-injector singleton slot. `NavLinkContextMenuService` `providedIn: 'root'` olduğu
+ * için host ve her MFE remote'unda AYRI instance yaşar — `register(cm)` sadece host
+ * shell'de çağrılır, MFE'lerden gelen `open(...)` çağrıları kendi instance'ında `cm`
+ * bulamaz. Bu yüzden register sırasında host instance'ı global slot'a yazar; MFE
+ * instance'ları `cm` null ise bu slot üzerinden host'a delege eder.
+ *
+ * `bridge` modülündeki `__arilMfeBridge__` ile aynı pattern.
+ */
+const SLOT = '__arilNavLinkContextMenuOpen';
+const COMMAND_SLOT = '__arilNavCommand';
+/**
+ * Tab navigasyonu yapan tüm linkli yapılar için ortak sağ-tık context menu servisi.
+ * Tek bir global PrimeNG `ContextMenu` instance'ı host shell (`AppLayoutComponent`)
+ * template'inde yaşar; her sayfa kendi `ContextMenu` enstantiate etmek yerine bu
+ * service üzerinden `open(event, navItem)` çağırır.
+ *
+ * Servis hangi link tıklandıysa onun `NavItem`'iyle menü modelini yeniden inşa eder
+ * ve `cm.show(event)` ile açar — tüm tüketiciler için tek source-of-truth.
+ *
+ * **Kayıt sözleşmesi**: shell mount olunca `register(cm)` çağırır. MFE'lerden gelen
+ * çağrılar global slot üzerinden host'a delege edilir.
+ */
+class NavLinkContextMenuService {
+    constructor() {
+        this.navService = inject(NavService);
+        this.translocoService = inject(TranslocoService);
+        this.cm = null;
+    }
+    register(cm) {
+        this.cm = cm;
+        // MFE'lerden gelen open çağrıları için cross-injector slot kur — bu instance'ın
+        // `openLocal`'ını sarmalayan bir function global slot'a yazılır.
+        const slotHost = globalThis;
+        slotHost[SLOT] = (event, navItem) => this.openLocal(event, navItem);
+        // Programatik "yeni tab aç ve geç" — MFE'lerden (eski `window.open('#'+url,'_blank')`
+        // yerine) host NavService'e delege için cross-injector slot.
+        slotHost[COMMAND_SLOT] = (navItem) => this.navService.openInNewTabAndFocus(navItem);
+    }
+    open(event, navItem) {
+        // Kendi cm'imiz varsa (host instance) doğrudan aç
+        if (this.cm) {
+            this.openLocal(event, navItem);
+            return;
+        }
+        // MFE instance: global slot üzerinden host'a delege
+        const slotHost = globalThis;
+        const hostOpen = slotHost[SLOT];
+        if (hostOpen) {
+            hostOpen(event, navItem);
+        }
+    }
+    /**
+     * Programatik "yeni tab aç ve geç" — MFE component'lerinden çağrılır (eski
+     * `window.open('#'+url,'_blank')` yerine). Host instance'ta (`cm` set) doğrudan
+     * `NavService.openInNewTabAndFocus`'u çağırır; MFE instance'ında `__arilNavCommand`
+     * global slot'u üzerinden host'a delege eder. Host shell henüz mount olmadıysa
+     * (slot boş) sessizce no-op olur.
+     */
+    openInNewTabAndFocus(navItem) {
+        if (this.cm) {
+            this.navService.openInNewTabAndFocus(navItem);
+            return;
+        }
+        const slotHost = globalThis;
+        const hostCommand = slotHost[COMMAND_SLOT];
+        if (hostCommand) {
+            hostCommand(navItem);
+        }
+    }
+    openLocal(event, navItem) {
+        if (!this.cm)
+            return;
+        const t = (key) => this.translocoService.translate(key);
+        this.cm.model = [
+            {
+                label: t('navLink.openHere'),
+                icon: 'pi pi-arrow-right',
+                command: () => this.navService.navigateInCurrentTab(navItem)
+            },
+            {
+                label: t('navLink.openInNewTab'),
+                icon: 'pi pi-external-link',
+                command: () => this.navService.openInBackgroundTab(navItem)
+            },
+            {
+                label: t('navLink.openInNewTabAndFocus'),
+                icon: 'pi pi-clone',
+                command: () => this.navService.openInNewTabAndFocus(navItem)
+            }
+        ];
+        this.cm.show(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavLinkContextMenuService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavLinkContextMenuService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavLinkContextMenuService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Linkli her HTML elementine sağ-tık → tab context menüsü ekleyen directive.
+ *
+ * **Kullanım**: navLink/navName (ve opsiyonel icon) bilgisini object literal olarak verin:
+ * ```html
+ * <a [attr.href]="'#/' + path"
+ *    [arilNavLink]="{ tabId: '', navLink: path, navName: 'Sayfa Adı', icon: 'pi pi-cog' }"
+ *    (click)="...">
+ * ```
+ *
+ * Sağ tık → "Bu sekmede aç / Yeni sekmede aç / Yeni sekmede aç ve geç" menüsü açılır;
+ * komutlar `NavService` üzerinden ilgili tab eylemini tetikler. Ctrl+Click / Middle Click
+ * gibi mevcut shortcut'lar değişmez — bu menü onlara klavye/fare bilgisi olmayan
+ * kullanıcılar için keşfedilebilir bir alternatif.
+ */
+class NavLinkDirective {
+    constructor() {
+        this.contextMenuService = inject(NavLinkContextMenuService);
+    }
+    onContextMenu(event) {
+        if (!this.navItem?.navLink)
+            return;
+        event.preventDefault();
+        this.contextMenuService.open(event, this.navItem);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.2", type: NavLinkDirective, isStandalone: true, selector: "[arilNavLink]", inputs: { navItem: ["arilNavLink", "navItem"] }, host: { listeners: { "contextmenu": "onContextMenu($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: NavLinkDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[arilNavLink]'
+                }]
+        }], propDecorators: { navItem: [{
+                type: Input,
+                args: ['arilNavLink']
+            }], onContextMenu: [{
+                type: HostListener,
+                args: ['contextmenu', ['$event']]
+            }] } });
+
+/**
+ * `_tab` query param'ını adres çubuğunda gizleyen `UrlSerializer`. Param Router'ın
+ * internal `UrlTree.queryParams`'ında korunur (parse imzasız, default davranış);
+ * sadece `serialize` çıktısı üzerinden — yani `Router.url`, `NavigationEnd.urlAfterRedirects`
+ * ve browser address bar — `_tab` strip edilir.
+ *
+ * **Sonuç**: `CustomRouteReuseStrategy.getRouteKey` `route.queryParams['_tab']`'ı
+ * normal şekilde okumaya devam eder (parse path'inde değişiklik yok), ama kullanıcının
+ * gördüğü URL temizdir.
+ *
+ * **NavService etkisi**: `activeRoute()` artık `_tab` taşımaz. Aktif tab tespiti
+ * `activeTabId` signal'i üzerinden yapılmalı (NavService bunu `window.history.state`'ten
+ * okur — `navigateByUrl(url, { state: { _tab } })` ile her navigation'da set edilir).
+ */
+class TabAwareUrlSerializer extends DefaultUrlSerializer {
+    /** `parse` default davranışla bırakıldı — input URL'inde `_tab` varsa korunur (refresh deep link). */
+    serialize(tree) {
+        // Default serialize'ı tut, sonra `_tab`'ı string seviyesinde (split/filter) çıkar.
+        // `URLSearchParams` round-trip'inden KAÇINIYORUZ: diğer query param'ların Angular
+        // encoding'ini bozar (örn. `a%20b` → `a+b`) ve bu string `Router.url`/`NavigationEnd`
+        // olarak kullanıldığı için `cleanNavLink` karşılaştırmaları kaçabilirdi. Diğer param'lara
+        // HİÇ dokunmuyoruz — yalnız `_tab` segment'ini düşürüyoruz.
+        const url = super.serialize(tree);
+        if (!url.includes('_tab='))
+            return url;
+        const fragmentIdx = url.indexOf('#');
+        const fragment = fragmentIdx >= 0 ? url.slice(fragmentIdx) : '';
+        const beforeFragment = fragmentIdx >= 0 ? url.slice(0, fragmentIdx) : url;
+        const queryIdx = beforeFragment.indexOf('?');
+        if (queryIdx < 0)
+            return url;
+        const path = beforeFragment.slice(0, queryIdx);
+        const query = beforeFragment
+            .slice(queryIdx + 1)
+            .split('&')
+            .filter((p) => p !== '_tab' && !p.startsWith('_tab='))
+            .join('&');
+        return query ? `${path}?${query}${fragment}` : `${path}${fragment}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TabAwareUrlSerializer, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TabAwareUrlSerializer, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: TabAwareUrlSerializer, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { Apps, ArilReuseStrategy, MicroAppService };
+export { Apps, CustomRouteReuseStrategy, MicroAppService, NavLinkContextMenuService, NavLinkDirective, NavService, RouteCloseService, TabAwareUrlSerializer, safeNavigate };
 //# sourceMappingURL=aril-boot-config-apps.mjs.map