aril 1.2.18 → 2.0.1-dev.1

package/boot/bridge/src/mfe-bridge.d.ts

@@ -1,3 +1,4 @@
+import type { Location } from '@angular/common';
 import { NgZone, Signal } from '@angular/core';
 import type { Router } from '@angular/router';
 import type { Apps, PluginMenuItem } from 'aril/boot/config/apps';
@@ -6,10 +7,13 @@ export interface RouteConfig {
     content: string;
     version: number;
 }
+export interface Breadcrumb {
+    label: string;
+    url?: string;
+}
 export interface LegacyWindowSlots {
     activeHost?: Apps;
     activeMF?: Apps;
-    isHostMode?: boolean;
     hostMenuItems?: Signal<PluginMenuItem[]>;
     pluginJson?: Record<string, unknown>;
     routeConfigs?: RouteConfig[];
@@ -20,13 +24,49 @@ export interface LegacyWindowSlots {
 export declare class MfeBridge {
     readonly activeHost: import("@angular/core").WritableSignal<Apps | null>;
     readonly activeMF: import("@angular/core").WritableSignal<Apps | null>;
-    readonly isHostMode: import("@angular/core").WritableSignal<boolean>;
     readonly hostMenuItems: import("@angular/core").WritableSignal<PluginMenuItem[]>;
     readonly pluginJson: import("@angular/core").WritableSignal<Record<string, unknown>>;
     readonly routeConfigs: import("@angular/core").WritableSignal<RouteConfig[] | null>;
     readonly pageTitle: import("@angular/core").WritableSignal<string>;
+    readonly breadcrumbs: import("@angular/core").WritableSignal<Breadcrumb[]>;
+    /**
+     * Bir MFE Router'ında olan son `NavigationEnd`'in URL'i ve **hangi tab'a ait olduğu**.
+     * MFE içi sayfa içi navigation'lar host Router'a yansımayabiliyor → `NavService` tab
+     * navLink'ini güncellemek için bu signal'ı izler.
+     *
+     * **Neden tabId taşıyor**: Birden fazla tab'ın MFE Router'ı async event tetikleyebilir
+     * (örn. hidden container'daki tab2 `?activeTab=1` replaceState yaparken). `activeTabId`'ye
+     * bakarak update yaparsak yanlış tab'ı kontamine ederiz. Mesajda kaynak tabId'yi taşıyıp
+     * `NavService.syncActiveTabNavLinkForTab(tabId, url)` ile spesifik tab'ı update ederiz.
+     *
+     * **Custom `equal`**: AppComponent her MFE NavigationEnd'de `set({tabId, url})` çağırır;
+     * yeni object reference olduğu için default reference-equality re-emit eder. Bu durumda
+     * aynı tab+url ile sürekli effect tetiklenir → tab navLink'i kullanıcının anasayfaya
+     * geçtiği gibi (host route'lar MFE NavigationEnd tetiklemez ama signal eski değerinde
+     * kalır) state değişikliklerini geri alır. Value-equality ile yalnızca gerçek URL
+     * değişikliklerinde tetiklensin.
+     */
+    readonly activeMFEUrl: import("@angular/core").WritableSignal<{
+        tabId: string;
+        url: string;
+        title?: string | undefined;
+    } | null>;
+    /**
+     * Aktif tab'ın `tabId`'si — `NavService` tab değişimlerinde günceller.
+     * Plugin Router proxy'leri (`provideHostRouter`) bu signal'ı okuyup `navigate`/`navigateByUrl`
+     * çağrılarına `extras.state._tab` enjekte eder → plugin'lerin yaptığı tüm host
+     * navigation'ları otomatik tab-aware olur, Strategy doğru tab handle'ını korur.
+     */
+    readonly activeTabId: import("@angular/core").WritableSignal<string>;
     hostNgZone: NgZone | null;
     hostRouter: Router | null;
+    /**
+     * Host (shell) `Location` servisi. Host modda MFE/plugin child injector'larından
+     * erişilemez (child Location izole `IsolatedLocationStrategy`'ye bağlı); browser
+     * adres çubuğuna `replaceState` ile yazmak isteyen directive'ler (örn. `?activeTab`
+     * senkronizasyonu) bunu kullanır. `hostRouter` ile aynı pattern.
+     */
+    hostLocation: Location | null;
     private mirrored;
     mirrorToWindow(): void;
 }

package/boot/config/apps/index.d.ts

@@ -1,3 +1,9 @@
 export * from './src/apps.service';
 export * from './src/interfaces';
-export * from './src/reuse-strategy';
+export * from './src/custom-route-reuse-strategy.class';
+export * from './src/route-close.service';
+export * from './src/nav.service';
+export * from './src/nav-link-context-menu.service';
+export * from './src/nav-link.directive';
+export * from './src/tab-aware-url-serializer';
+export * from './src/safe-navigate';

package/boot/config/apps/src/custom-reuse-outlet.component.d.ts

@@ -0,0 +1,37 @@
+import { AfterContentInit, AfterViewInit, ElementRef, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { LoadRemoteModuleOptions } from '@angular-architects/module-federation-runtime';
+import * as i0 from "@angular/core";
+export type WebComponentWrapperOptions = LoadRemoteModuleOptions & {
+    elementName: string;
+};
+export declare class ArilWebComponentWrapper implements OnInit, AfterContentInit, AfterViewInit, OnChanges, OnDestroy {
+    private route;
+    vc?: ElementRef;
+    options?: WebComponentWrapperOptions;
+    props?: {
+        [prop: string]: unknown;
+    };
+    events?: {
+        [event: string]: (event: Event) => void;
+    };
+    element?: HTMLElement;
+    private isDestroyed;
+    private registeredEvents;
+    private routeSub?;
+    needsRestore: boolean;
+    propsUpdated: boolean;
+    constructor(route: ActivatedRoute);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private populateProps;
+    private setupEvents;
+    private teardownEvents;
+    private restoreElement;
+    private getHiddenContainer;
+    ngAfterContentInit(): Promise<void>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArilWebComponentWrapper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArilWebComponentWrapper, "mft-wc-wrapper", never, { "options": { "alias": "options"; "required": false; }; "props": { "alias": "props"; "required": false; }; "events": { "alias": "events"; "required": false; }; }, {}, never, never, false, never>;
+}

package/boot/config/apps/src/custom-route-reuse-strategy.class.d.ts

@@ -0,0 +1,156 @@
+import { OnDestroy } from '@angular/core';
+import { ActivatedRouteSnapshot, DetachedRouteHandle, RouteReuseStrategy } from '@angular/router';
+import { RouteCloseService } from './route-close.service';
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
+export declare class CustomRouteReuseStrategy implements RouteReuseStrategy, OnDestroy {
+    routeCloseService: RouteCloseService;
+    storedRoutes: Record<string, DetachedRouteHandle>;
+    /**
+     * `(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.
+     */
+    private preservedCustomEls;
+    constructor();
+    /**
+     * 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(): void;
+    /**
+     * Verilen key için direct + child cleanup uygular. Effect içinden ayrıştırılmış helper.
+     */
+    private processCleanupKey;
+    /**
+     * `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).
+     */
+    private parseMatcherKey;
+    /**
+     * 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.
+     */
+    private cleanupStoredHandle;
+    /**
+     * 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: ActivatedRouteSnapshot): boolean;
+    store(route: ActivatedRouteSnapshot, detachedTree: DetachedRouteHandle): void;
+    shouldAttach(route: ActivatedRouteSnapshot): boolean;
+    retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle | 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).
+     */
+    private preserveWebComponentElement;
+    /**
+     * 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.
+     */
+    private restoreWebComponentElement;
+    /**
+     * Global hidden container'ı oluşturur veya döndürür
+     */
+    private getHiddenContainer;
+    /**
+     * 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.
+     */
+    private preserveCustomElementsInTree;
+    /**
+     * preserveCustomElementsInTree ile taşınan custom element'leri orijinal
+     * placeholder'larının yerine geri koyar.
+     */
+    private restoreCustomElementsInTree;
+    private isMatcherRoute;
+    private getRemoteName;
+    /**
+     * 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.
+     */
+    private getTabIdFromRoute;
+    /**
+     * 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.
+     */
+    private getRouteKey;
+    /**
+     * 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.
+     */
+    private serializeQueryParams;
+    shouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomRouteReuseStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomRouteReuseStrategy>;
+}

package/boot/config/apps/src/nav-link-context-menu.service.d.ts

@@ -0,0 +1,33 @@
+import { ContextMenu } from 'primeng/contextmenu';
+import { NavItem } from './nav.service';
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
+export declare class NavLinkContextMenuService {
+    private readonly navService;
+    private readonly translocoService;
+    private cm;
+    register(cm: ContextMenu): void;
+    open(event: MouseEvent, navItem: NavItem): void;
+    /**
+     * 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: NavItem): void;
+    private openLocal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavLinkContextMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavLinkContextMenuService>;
+}

package/boot/config/apps/src/nav-link.directive.d.ts

@@ -0,0 +1,29 @@
+import { NavItem } from './nav.service';
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
+export declare class NavLinkDirective {
+    /**
+     * Optional çünkü site-map gibi conditional yapılarda template binding'i `node.routerLink ? {...} : null`
+     * şeklinde çalışıyor — required işaretlemek `null/undefined` durumunda TS hatası verir. Boş veya
+     * `navLink`'i olmayan navItem için `onContextMenu` no-op çalışır.
+     */
+    navItem?: NavItem | null;
+    private readonly contextMenuService;
+    onContextMenu(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavLinkDirective, "[arilNavLink]", never, { "navItem": { "alias": "arilNavLink"; "required": false; }; }, {}, never, never, true, never>;
+}

package/boot/config/apps/src/nav.service.d.ts

@@ -0,0 +1,198 @@
+import { Router } from '@angular/router';
+import { PluginMenuItem } from './interfaces';
+import { RouteCloseService } from './route-close.service';
+import * as i0 from "@angular/core";
+/**
+ * `tabId` her tab'ı tekil kılan kimliktir; aynı `navLink` (path) altında birden fazla
+ * bağımsız tab açılabilmesini sağlar. NavService Router'a navigation yaparken URL'e
+ * `_tab=<tabId>` query param ekler ve `extras.state._tab` ile history state'e yazar.
+ * `TabAwareUrlSerializer` adres çubuğundan `_tab`'i strip eder; Router internal
+ * `queryParams` korunur → `CustomRouteReuseStrategy.getRouteKey` doğru tab key türetir.
+ *
+ * **Önemli**: `NavItem.navLink` HER ZAMAN CLEAN URL (no `_tab`). Hem display hem
+ * `activeRoute()` ile karşılaştırma için kullanılır. Tab kimliği `tabId` üzerinden
+ * yönetilir (`activeTabId` signal).
+ */
+export interface NavItem {
+    tabId: string;
+    navLink: string;
+    navName: string;
+    /**
+     * Menu item'dan gelen icon class'ı (örn. 'pi pi-bolt'). Verilmezse layout `getTabIcon`
+     * menu config'inden longest-prefix match ile lookup yapar; o da bulamazsa generic ikona düşer.
+     */
+    icon?: string;
+    /**
+     * Tab sabitleme — Chrome-vari pinning. Sabit tab'lar tab bar'ın **soluna** sıralanır,
+     * kompakt gösterilir (yalnız icon, başlık + close button gizli), `closeOthers`/`closeToRight`/
+     * `closeAll` çağrılarından korunur. Drag & drop'ta pinned ↔ normal sınırı geçilemez.
+     */
+    pinned?: boolean;
+}
+export declare class NavService {
+    router: Router;
+    routeCloseService: RouteCloseService;
+    private readonly messageService;
+    private readonly translocoService;
+    private readonly i18nReloadSub;
+    firstCheckForRoute: boolean;
+    /**
+     * 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.
+     */
+    private readonly MAX_TABS;
+    /** RFC4122 v4 UUID — collision-free, internal state taşımaz. */
+    private generateTabId;
+    /**
+     * 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.
+     */
+    private menuItemsProvider;
+    setMenuItemsProvider(provider: () => PluginMenuItem[]): void;
+    /**
+     * 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.
+     */
+    private homeNavItemProvider;
+    setHomeNavItemProvider(provider: () => NavItem): void;
+    /**
+     * 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.
+     */
+    activeRoute: import("@angular/core").Signal<string | undefined>;
+    activeRoutes: import("@angular/core").WritableSignal<NavItem[]>;
+    /** History state'ten okunan aktif tab kimliği — `isActive(tab) = tab.tabId === activeTabId()`. */
+    activeTabId: import("@angular/core").WritableSignal<string>;
+    /**
+     * 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: NavItem): void;
+    /**
+     * 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: NavItem): void;
+    /**
+     * 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: NavItem): void;
+    /** Programatik tab ekleme; activeRoute observable refresh path'i bunu kullanır. */
+    addToActiveRoutes(navItem: NavItem): void;
+    /**
+     * 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.
+     */
+    private findActiveTabIndex;
+    /** Tab limiti aşıldığında kullanıcıyı toast ile bilgilendirir. */
+    private notifyMaxTabsReached;
+    /** Anasayfa navLink'i — host menü root item'ından (yoksa '/'), clean format. */
+    private homeNavLink;
+    /** Verilen tab anasayfaya mı ait. */
+    private isHomeTab;
+    /**
+     * 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').
+     */
+    private openHomeTab;
+    closeNavigation(navItem: NavItem): void;
+    /**
+     * 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: NavItem): void;
+    /**
+     * 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: NavItem): void;
+    /**
+     * 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(): void;
+    /**
+     * 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: NavItem): void;
+    /** Sıradaki tab'a (circular) geçer. */
+    goToNextTab(): void;
+    /** Önceki tab'a (circular) geçer. */
+    goToPrevTab(): void;
+    /** Index'teki tab'a geçer (Alt+1..9 için 0-tabanlı index). */
+    goToTabByIndex(index: number): void;
+    /**
+     * 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: NavItem): void;
+    /**
+     * 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: string, rawUrl: string, title?: string): void;
+    /**
+     * 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: NavItem): void;
+    reorderActiveRoutes(newRoutes: NavItem[]): void;
+    /**
+     * 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.
+     */
+    private resolveNavInfoFromMenu;
+    /**
+     * 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(): void;
+    /**
+     * 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.
+     */
+    private findMenuItemForRoute;
+    /**
+     * 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.
+     */
+    private cleanupTabHandle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavService>;
+}

package/boot/config/apps/src/route-close.service.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class RouteCloseService {
+    deleteRoute: import("@angular/core").WritableSignal<{
+        key: string | null;
+    }>;
+    deleteStoredRoute(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouteCloseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RouteCloseService>;
+}

package/boot/config/apps/src/safe-navigate.d.ts

@@ -0,0 +1,17 @@
+import { NavigationBehaviorOptions, Router } from '@angular/router';
+/**
+ * `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.
+ */
+export declare function safeNavigate(router: Router, url: string, extras?: NavigationBehaviorOptions): Promise<boolean>;

package/boot/config/apps/src/tab-aware-url-serializer.d.ts

@@ -0,0 +1,22 @@
+import { DefaultUrlSerializer, UrlTree } from '@angular/router';
+import * as i0 from "@angular/core";
+/**
+ * `_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).
+ */
+export declare class TabAwareUrlSerializer extends DefaultUrlSerializer {
+    /** `parse` default davranışla bırakıldı — input URL'inde `_tab` varsa korunur (refresh deep link). */
+    serialize(tree: UrlTree): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabAwareUrlSerializer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TabAwareUrlSerializer>;
+}

package/boot/config/plugins/src/getNgZone.d.ts

@@ -1,5 +1,13 @@
 import { NgZone } from '@angular/core';
-export declare const getNgZone: () => never[] | {
+/**
+ * Host shell'in NgZone'unu MFE/plugin Application'a inject eder (paylaşımlı zone).
+ *
+ * `hostNgZone` host bootstrap'inde (`AppComponent` constructor'ında `inject(NgZone)`)
+ * set ediliyor. `getNgZone()` MFE/plugin bootstrap zamanında çağrılıyor → o anda
+ * `hostNgZone` set edilmiş olmalı. Set edilmemişse explicit error: silent `undefined`
+ * provider DI hatası "no provider for NgZone" gibi yanıltıcı bir mesajla patlardı.
+ */
+export declare const getNgZone: () => {
     provide: typeof NgZone;
     useValue: NgZone;
 };

package/boot/mfe/src/app.component.d.ts

@@ -3,16 +3,27 @@ import { PrimeNGConfig } from 'primeng/api';
 import { TranslocoService } from '@ngneat/transloco';
 import { MfeBridge } from 'aril/boot/bridge';
 import { LanguageCode } from 'aril/boot/config/translate';
-import { AppMenuService } from 'aril/theme/layout';
 import * as i0 from "@angular/core";
+/**
+ * Tab izolasyonlu MFE app root.
+ *
+ * Her `<app-${appName}>` custom element instance'ı kendi `createApplication`'ını yarattığı için
+ * (bkz. `bootstrap.ts` `MFEAppElement`), `AppComponent` constructor'ı her tab için **bağımsız**
+ * çalışır — paylaşılan Injector/Router yok. Bu yüzden host Router subscription'ı her tab için
+ * ayrı kurulur ama "tab-id filter" ile **sadece o tab'a ait** `NavigationEnd`'leri MFE Router'a
+ * iletir; diğer tab'lerin navigation'ları ignore edilir.
+ *
+ * Tab kimliği `<app-${appName}>` element'inde `aril-tab-id` attribute olarak yazılır
+ * (`ArilWebComponentWrapper` route.queryParams._tab'ten okuyup set eder). Filter karşılaştırması:
+ * `window.history.state._tab === tabId` — `navigateToTab` `extras.state._tab` ile yazıyor.
+ */
 export declare class AppComponent {
     private readonly router;
     private readonly translocoService;
-    private readonly appMenuService;
     private readonly primeNgConfig;
     private readonly bridgeSvc;
-    constructor(router: Router, translocoService: TranslocoService, appMenuService: AppMenuService, primeNgConfig: PrimeNGConfig, bridgeSvc: MfeBridge);
-    get isHostMode(): import("@angular/core").WritableSignal<boolean>;
+    private readonly elementRef;
+    constructor(router: Router, translocoService: TranslocoService, primeNgConfig: PrimeNGConfig, bridgeSvc: MfeBridge);
     setLocale(lang: LanguageCode): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AppComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AppComponent, "ng-component", never, {}, {}, never, never, true, never>;