@pb33f/cowboy-components 0.7.17 → 0.8.0

package/dist/controllers/state-controller.js

@@ -1,73 +1,108 @@
-import { AllRulesetBag, CustomRulesetBag, DefaultDocument, DefaultRulesetBag, DiagnosticBag, DocumentProblems, FunctionsBag, FunctionsSchemaBag, GraphBag, HowToFixBag, OWASPRulesetBag, PanelStateBag, ReferenceMapBag, RolodexResponseBag, RolodexStateBag, RuleConfigurationBag, SessionRulesetMapBag, SettingsBag } from "../components/the-doctor/the-doctor.js";
+import { AllRulesetBag, CustomRulesetBag, DefaultDocument, DefaultRulesetBag, DiagnosticBag, DocumentProblems, FunctionsBag, FunctionsSchemaBag, GraphBag, HowToFixBag, OWASPRulesetBag, PanelStateBag, ReferenceMapBag, RolodexResponseBag, RolodexStateBag, RuleConfigurationBag, SessionRulesetMapBag, SessionRulesetYamlBag, SettingsBag } from "../components/the-doctor/the-doctor.js";
 import { ModelService } from "../services/model-service.js";
+import { DefaultMaxNodes } from "../components/visualizer/equalizer.js";
 import { Problem } from "../model/problem.js";
-import { RulesetService } from "../services/ruleset-service";
+import { normalizeRolodexPath } from "../utils/path-utils.js";
+import { RulesetService } from "../services/ruleset-service.js";
+import { buildNodeMap, buildHashToNodeMap, collectAncestors, resolveNodeIdFromHash } from "../utils/node-helpers.js";
 export class StateController extends EventTarget {
-    constructor(doc) {
+    constructor(deps) {
         super();
-        this.doc = doc;
+        this.deps = deps;
     }
     loadState() {
         // register a handler for settings bag changes.
-        this.doc.settingsBag?.onAllChanges(this.doc.settingsChanged.bind(this));
-        this.doc.settingsComponent.settingsBag = this.doc.settingsBag;
-        if (this.doc.settingsBag) {
-            this.doc.settingsChanged('', this.doc.settingsBag.get(SettingsBag));
+        this.deps.settingsBag?.onAllChanges(this.deps.settingsChanged);
+        if (this.deps.settingsComponent) {
+            this.deps.settingsComponent.settingsBag = this.deps.settingsBag;
+        }
+        if (this.deps.settingsBag) {
+            this.deps.settingsChanged('', this.deps.settingsBag.get(SettingsBag));
+        }
+        this.deps.settingsComponent?.bootstrap?.();
+        this.deps.rolodexNeedsReset = true;
+        // Load panel state FIRST (before rolodex setup) to ensure divider positions
+        // are set before the split panels are created during render
+        if (this.deps.panelStateBag) {
+            const panelState = this.deps.panelStateBag.get(PanelStateBag);
+            if (panelState && panelState.explorerPanel && this.deps.splitPanelExplorer) {
+                this.deps.splitPanelExplorer.position = panelState.explorerPanel;
+            }
+            if (panelState && panelState.rolodexPanel) {
+                this.deps.rolodexDividerPosition = panelState.rolodexPanel;
+            }
+            if (panelState && panelState.inspectorPanel && this.deps.splitPanelInspector) {
+                this.deps.splitPanelInspector.position = panelState.inspectorPanel;
+            }
         }
-        this.doc.settingsComponent.bootstrap();
-        this.doc.rolodexNeedsReset = true;
         // load the rolodex
-        if (this.doc.rolodexResponseBag) {
-            const response = this.doc.rolodexResponseBag.get(RolodexResponseBag);
-            if (response) {
-                this.doc.rolodexRoot = response.rolodexRoot;
-                this.doc.rolodexTree.isRolodex = true;
-                this.doc.rolodexTree.node = response.rolodexRoot;
+        if (this.deps.rolodexResponseBag) {
+            const response = this.deps.rolodexResponseBag.get(RolodexResponseBag);
+            if (response && this.deps.rolodexTree) {
+                this.deps.rolodexRoot = response.rolodexRoot;
+                this.deps.rolodexTree.isRolodex = true;
+                this.deps.rolodexTree.nodeMap = buildNodeMap(response.nodes);
+                this.deps.rolodexTree.node = response.rolodexRoot;
                 response.rolodexRoot.treeExpanded = true;
-                this.doc.requestUpdate();
+                this.deps.rolodexTree.childrenRendered.add(response.rolodexRoot.id);
+                this.deps.rolodexTree.expandedNodes.set(response.rolodexRoot.id, response.rolodexRoot);
+                this.deps.requestUpdate();
             }
         }
         let skipDocBag = false;
         const checkRefMap = (key) => {
-            let refMap = this.doc.referenceMapBag?.get(ReferenceMapBag);
+            let refMap = this.deps.referenceMapBag?.get(ReferenceMapBag);
             if (refMap) {
-                // TODO: replace with scehduled task to refresh the reference map
+                // TODO: replace with scheduled task to refresh the reference map
                 setTimeout(() => {
                     let refs = refMap?.references[key];
                     if (!refs) {
                         refs = refMap?.references[""]; // single file
                     }
-                    if (refs) {
-                        this.doc.references = refs;
-                        this.doc.editor.links = refs;
-                        this.doc.editor.applyLinkDecorations();
+                    if (refs && this.deps.editor) {
+                        this.deps.references = refs;
+                        this.deps.editor.links = refs;
+                        this.deps.editor.applyLinkDecorations();
                     }
                 }, 5); // editor has not loaded yet, give it a second to breathe.
             }
             else {
                 ModelService.fetchReferenceMap().then((result) => {
-                    this.doc.references = result;
-                    this.doc.editor.links = result;
-                    this.doc.editor.applyLinkDecorations();
+                    this.deps.references = result;
+                    if (this.deps.editor) {
+                        this.deps.editor.links = result;
+                        this.deps.editor.applyLinkDecorations();
+                    }
                 }).catch(() => {
-                    this.doc.editor.clearDecorations();
-                    this.doc.editor.clearAllMarkers();
+                    if (this.deps.editor) {
+                        this.deps.editor.clearDecorations();
+                        this.deps.editor.clearAllMarkers();
+                    }
                 });
             }
         };
-        if (this.doc.rolodexStateBag) {
-            const state = this.doc.rolodexStateBag.get(RolodexStateBag);
+        if (this.deps.rolodexStateBag) {
+            const state = this.deps.rolodexStateBag.get(RolodexStateBag);
             if (state) {
-                this.doc.rolodexActivePath = state.activePath;
-                this.doc.rolodexActiveHash = state.activeHash;
-                // load the root.
-                if (state.rootHash) {
-                    this.doc.rolodexTree.pendingNavigationHash = state.rootHash;
+                // Always reset to root on reload - ignore persisted activePath/activeNode
+                this.deps.rolodexActivePath = state.rootPath ?? "root";
+                this.deps.rolodexActiveHash = state.rootHash;
+                // load the root - prefer id, fall back to hash resolution
+                if (this.deps.rolodexTree) {
+                    if (state.rootId) {
+                        this.deps.rolodexTree.pendingNavigationId = state.rootId;
+                    }
+                    else if (state.rootHash && this.deps.rolodexTree.nodeMap) {
+                        const resolvedId = resolveNodeIdFromHash(state.rootHash, this.deps.rolodexTree.nodeMap);
+                        if (resolvedId) {
+                            this.deps.rolodexTree.pendingNavigationId = resolvedId;
+                        }
+                    }
                 }
                 if (state.rootPath) {
-                    this.doc.rolodexRootPath = state.rootPath;
-                    if (state.activePath) {
-                        checkRefMap(state.activePath);
+                    this.deps.rolodexRootPath = state.rootPath;
+                    if (state.rootPath) {
+                        checkRefMap(state.rootPath);
                     }
                     // ensure the session has a root selected
                     ModelService.selectRootPath(state.rootPath).then(() => {
@@ -77,181 +112,184 @@ export class StateController extends EventTarget {
                     });
                 }
                 if (state.rootHash)
-                    this.doc.rolodexRootHash = state.rootHash;
-                if (state.activePath) {
-                    this.doc.rolodexTree.pendingNavigationPath = state.activePath;
-                    this.doc.rolodexTree.requestUpdate();
-                }
-                if (state.activeNode) {
-                    // load the content of the active node into the editor
-                    if (state.activeLanguage) {
-                        this.doc.editor.switchLanguage(state.activeLanguage);
-                    }
-                    this.doc.editor.setValue(state.activeNode.instance, true);
-                    skipDocBag = true;
-                }
+                    this.deps.rolodexRootHash = state.rootHash;
             }
             else {
-                this.doc.rolodexActivePath = "root";
+                this.deps.rolodexActivePath = "root";
                 // refresh the refmap.
-                checkRefMap(this.doc.rolodexActivePath);
+                checkRefMap(this.deps.rolodexActivePath);
             }
         }
-        if (this.doc.docBag && !skipDocBag) {
-            const doc = this.doc.docBag.get(DefaultDocument);
-            if (doc) {
-                this.doc.editor.setValue(doc, true);
+        if (this.deps.docBag && !skipDocBag) {
+            const doc = this.deps.docBag.get(DefaultDocument);
+            if (doc && this.deps.editor) {
+                this.deps.editor.setValue(doc, true);
             }
         }
-        this.doc.problemBag = this.doc.bagManager.getBag(DocumentProblems);
-        if (this.doc.problemBag) {
-            const markers = this.doc.problemBag.get(DocumentProblems);
+        this.deps.problemBag = this.deps.bagManager.getBag(DocumentProblems);
+        if (this.deps.problemBag) {
+            const markers = this.deps.problemBag.get(DocumentProblems);
             if (markers) {
-                this.doc.problems = markers;
+                this.deps.problems = markers;
                 for (let i = 0; i < markers.length; i++) {
                     markers[i] = Problem.reconstruct(markers[i]);
                 }
-                this.doc.rolodexController.buildRolodexResultMap(markers);
-                if (this.doc.rolodexProblemMap.size > 0 && this.doc.rolodexProblemMap.has(this.doc.rolodexActivePath)) {
-                    const probs = this.doc.rolodexProblemMap.get(this.doc.rolodexActivePath);
-                    if (probs) {
-                        this.doc.editor.setMarkers(probs);
+                this.deps.specController.updateProblems(markers);
+                this.deps.rolodexController.buildRolodexResultMap(markers);
+                const lookupPath = normalizeRolodexPath(this.deps.rolodexActivePath);
+                if (this.deps.rolodexProblemMap.size > 0 && this.deps.rolodexProblemMap.has(lookupPath)) {
+                    const probs = this.deps.rolodexProblemMap.get(lookupPath);
+                    if (probs && this.deps.editor) {
+                        this.deps.editor.setMarkers(probs);
                     }
                 }
-                this.doc.problemList.problems = markers;
-                this.doc.problemsOverview.problems = this.doc.problemList.problemItems;
+                if (this.deps.problemList) {
+                    this.deps.problemList.problems = markers;
+                }
+                if (this.deps.problemsOverview && this.deps.problemList) {
+                    this.deps.problemsOverview.problems = this.deps.problemList.problemItems;
+                }
             }
         }
-        this.doc.howToFixBag = this.doc.bagManager.getBag(HowToFixBag);
-        this.doc.diagnosticBag = this.doc.bagManager.getBag(DiagnosticBag);
-        if (this.doc.diagnosticBag) {
-            const stats = this.doc.diagnosticBag.get(DiagnosticBag);
-            if (stats) {
-                this.doc.problemsOverview.statistics = stats;
+        this.deps.howToFixBag = this.deps.bagManager.getBag(HowToFixBag);
+        this.deps.diagnosticBag = this.deps.bagManager.getBag(DiagnosticBag);
+        if (this.deps.diagnosticBag) {
+            const stats = this.deps.diagnosticBag.get(DiagnosticBag);
+            if (stats && this.deps.problemsOverview) {
+                this.deps.problemsOverview.statistics = stats;
             }
         }
-        // extract graph
-        if (this.doc.graphBag) {
-            const graph = this.doc.graphBag.get(GraphBag);
-            if (graph) {
-                this.doc.modelController.extractGraph(graph);
-            }
+        // stale-while-revalidate: show cached graph for fast startup, then update with fresh API data
+        const cachedGraph = this.deps.graphBag?.get(GraphBag);
+        if (cachedGraph) {
+            this.deps.modelController.extractGraph(cachedGraph);
         }
-        // extract panel state
-        if (this.doc.panelStateBag) {
-            const panelState = this.doc.panelStateBag.get(PanelStateBag);
-            if (panelState && panelState.explorerPanel) {
-                this.doc.splitPanelExplorer.position = panelState.explorerPanel;
+        const maxNodes = this.deps.explorer?.equalizer?.maxNodes ?? DefaultMaxNodes;
+        ModelService.fetchLatestGraph(maxNodes).then((freshGraph) => {
+            this.deps.modelController.extractGraph(freshGraph);
+        }).catch((e) => {
+            if (!cachedGraph) {
+                console.error('failed to fetch graph and no cached data available', e);
             }
-            if (panelState && panelState.rolodexPanel) {
-                if (this.doc.splitPanelRolodex) {
-                    this.doc.splitPanelRolodex.position = panelState.rolodexPanel;
-                }
-                this.doc.rolodexDividerPosition = panelState.rolodexPanel;
-            }
-            if (panelState && panelState.inspectorPanel) {
-                this.doc.splitPanelInspector.position = panelState.inspectorPanel;
+            else {
+                console.warn('using cached graph data - API fetch failed', e);
             }
-        }
-        if (!this.doc.rolodexRoot) {
-            // this.importDisabled = false;
-        }
-        else {
-            // this.importDisabled = true;
-        }
+        });
         // extract rulesets from bags
         const promises = [];
-        this.doc.defaultRulesetBag = this.doc.bagManager.getBag(DefaultRulesetBag);
-        if (this.doc.defaultRulesetBag) {
-            const ruleset = this.doc.defaultRulesetBag.get(DefaultRulesetBag);
+        this.deps.defaultRulesetBag = this.deps.bagManager.getBag(DefaultRulesetBag);
+        if (this.deps.defaultRulesetBag) {
+            const ruleset = this.deps.defaultRulesetBag.get(DefaultRulesetBag);
             if (ruleset) {
-                this.doc.defaultRuleset = ruleset;
+                this.deps.defaultRuleset = ruleset;
             }
             else {
-                promises.push(this.doc.ruleController.fetchDefaultRuleset());
+                promises.push(this.deps.ruleController.fetchDefaultRuleset());
             }
         }
         // OWASP ruleset
-        this.doc.OWASPRulesetBag = this.doc.bagManager.getBag(OWASPRulesetBag);
-        if (this.doc.OWASPRulesetBag) {
-            const ruleset = this.doc.OWASPRulesetBag.get(OWASPRulesetBag);
+        this.deps.OWASPRulesetBag = this.deps.bagManager.getBag(OWASPRulesetBag);
+        if (this.deps.OWASPRulesetBag) {
+            const ruleset = this.deps.OWASPRulesetBag.get(OWASPRulesetBag);
             if (ruleset) {
-                this.doc.OWASPRuleset = ruleset;
+                this.deps.OWASPRuleset = ruleset;
             }
             else {
-                promises.push(this.doc.ruleController.fetchOWASPRuleset());
+                promises.push(this.deps.ruleController.fetchOWASPRuleset());
             }
         }
         // All ruleset
-        this.doc.allRulesetBag = this.doc.bagManager.getBag(AllRulesetBag);
-        if (this.doc.allRulesetBag) {
-            const ruleset = this.doc.allRulesetBag.get(AllRulesetBag);
+        this.deps.allRulesetBag = this.deps.bagManager.getBag(AllRulesetBag);
+        if (this.deps.allRulesetBag) {
+            const ruleset = this.deps.allRulesetBag.get(AllRulesetBag);
             if (ruleset) {
-                this.doc.allRuleset = ruleset;
+                this.deps.allRuleset = ruleset;
             }
             else {
-                promises.push(this.doc.ruleController.fetchAllRuleset());
+                promises.push(this.deps.ruleController.fetchAllRuleset());
             }
         }
         // functions
-        this.doc.functionsBag = this.doc.bagManager.getBag(FunctionsBag);
-        this.doc.functionSchemaBag = this.doc.bagManager.getBag(FunctionsSchemaBag);
-        if (this.doc.functionsBag) {
-            const functions = this.doc.functionsBag.get(FunctionsBag);
+        this.deps.functionsBag = this.deps.bagManager.getBag(FunctionsBag);
+        this.deps.functionSchemaBag = this.deps.bagManager.getBag(FunctionsSchemaBag);
+        if (this.deps.functionsBag) {
+            const functions = this.deps.functionsBag.get(FunctionsBag);
             if (functions) {
-                this.doc.functions = functions;
+                this.deps.functions = functions;
             }
             else {
                 promises.push(this.fetchFunctions());
             }
         }
         // custom ruleset
-        this.doc.customRulesetBag = this.doc.bagManager.getBag(CustomRulesetBag);
-        if (this.doc.customRulesetBag) {
-            const ruleset = this.doc.customRulesetBag.get(CustomRulesetBag);
+        this.deps.customRulesetBag = this.deps.bagManager.getBag(CustomRulesetBag);
+        if (this.deps.customRulesetBag) {
+            const ruleset = this.deps.customRulesetBag.get(CustomRulesetBag);
             if (ruleset) {
-                this.doc.customRuleset = ruleset;
+                this.deps.customRuleset = ruleset;
             }
         }
         // create rule configuration bag
-        this.doc.ruleConfigBag = this.doc.bagManager.getBag(RuleConfigurationBag);
-        // create rule configuration bag
-        this.doc.sessionRulesetMapBag = this.doc.bagManager.getBag(SessionRulesetMapBag);
+        this.deps.ruleConfigBag = this.deps.bagManager.getBag(RuleConfigurationBag);
+        // create session ruleset map bag
+        this.deps.sessionRulesetMapBag = this.deps.bagManager.getBag(SessionRulesetMapBag);
+        // create session ruleset YAML bag for caching
+        this.deps.sessionRulesetYamlBag = this.deps.bagManager.getBag(SessionRulesetYamlBag);
         // fire off all network requests, then configure the ruleset management.
         Promise.all(promises).then(() => {
             // configure rule management
-            this.doc.manageRuleset.defaultRuleset = this.doc.defaultRuleset;
-            this.doc.manageRuleset.owaspRuleset = this.doc.OWASPRuleset;
-            this.doc.manageRuleset.allRuleset = this.doc.allRuleset;
-            this.doc.manageRuleset.functions = this.doc.functions;
-            const config = this.doc.ruleConfigBag?.get(RuleConfigurationBag);
-            if (config) {
-                this.doc.manageRuleset.rulesetConfig = config;
-            }
-            else {
-                this.doc.manageRuleset.rulesetConfig = { ruleMapping: new Map(), allRulesSwitch: true };
-            }
-            setTimeout(() => {
-                this.doc.manageRuleset.buildRulesets();
-                if (this.doc.customRuleset && this.doc.customRuleset.rules.size > 0) {
-                    this.doc.manageRuleset.customRuleset = this.doc.customRuleset;
+            if (this.deps.manageRuleset) {
+                this.deps.manageRuleset.defaultRuleset = this.deps.defaultRuleset;
+                this.deps.manageRuleset.owaspRuleset = this.deps.OWASPRuleset;
+                this.deps.manageRuleset.allRuleset = this.deps.allRuleset;
+                this.deps.manageRuleset.functions = this.deps.functions;
+                const config = this.deps.ruleConfigBag?.get(RuleConfigurationBag);
+                if (config) {
+                    this.deps.manageRuleset.rulesetConfig = config;
                 }
-                this.doc.ruleController.fetchSessionRulesetAsYaml().then((result) => {
-                    this.doc.rulesetEditor?.setValue(result, true);
-                    this.doc.ruleController.fetchRulesetMap();
-                }).catch((e) => {
-                    this.doc.platformUnavailable(e);
-                });
-            }, 50);
+                else {
+                    this.deps.manageRuleset.rulesetConfig = { ruleMapping: new Map(), allRulesSwitch: true };
+                }
+                setTimeout(() => {
+                    if (this.deps.manageRuleset) {
+                        this.deps.manageRuleset.buildRulesets();
+                        // Handle customRuleset - check works for both Map and plain object (after IndexedDB deserialization)
+                        if (this.deps.customRuleset && this.deps.customRuleset.rules) {
+                            const rulesCount = this.deps.customRuleset.rules instanceof Map
+                                ? this.deps.customRuleset.rules.size
+                                : Object.keys(this.deps.customRuleset.rules).length;
+                            if (rulesCount > 0) {
+                                this.deps.manageRuleset.customRuleset = this.deps.customRuleset;
+                            }
+                        }
+                        // Try to fetch fresh YAML from API, fall back to cached if API fails
+                        const cachedYaml = this.deps.sessionRulesetYamlBag?.get(SessionRulesetYamlBag);
+                        this.deps.ruleController.fetchSessionRulesetAsYaml().then((result) => {
+                            this.deps.rulesetEditor?.setValue(result, true);
+                            this.deps.ruleController.fetchRulesetMap();
+                            // Cache the fresh YAML
+                            this.deps.sessionRulesetYamlBag?.set(SessionRulesetYamlBag, result);
+                        }).catch((e) => {
+                            // If API fails, try using cached YAML
+                            if (cachedYaml) {
+                                this.deps.rulesetEditor?.setValue(cachedYaml, true);
+                            }
+                            else {
+                                this.deps.platformUnavailable(e);
+                            }
+                        });
+                    }
+                }, 50);
+            }
         });
         // refresh state for how to fix.
-        this.doc.docsController.fetchDocs();
+        this.deps.docsController.fetchDocs();
     }
     async fetchFunctions() {
         return new Promise(async (resolve) => {
             RulesetService.getFunctions().then((result) => {
-                this.doc.functions = result;
-                this.doc.functionsBag?.set(FunctionsBag, result);
+                this.deps.functions = result;
+                this.deps.functionsBag?.set(FunctionsBag, result);
                 // extract schemas for each function
                 const promises = [];
                 result.forEach((functionId) => {
@@ -266,14 +304,23 @@ export class StateController extends EventTarget {
     async fetchFunctionSchema(functionId) {
         return new Promise(async (resolve) => {
             RulesetService.getFunctionSchema(functionId).then((result) => {
-                let m = this.doc.functionSchemaBag?.get(FunctionsSchemaBag);
+                let m = this.deps.functionSchemaBag?.get(FunctionsSchemaBag);
                 if (!m) {
                     m = new Map();
                 }
                 m.set(functionId, result);
-                this.doc.functionSchemaBag?.set(FunctionsSchemaBag, m);
+                this.deps.functionSchemaBag?.set(FunctionsSchemaBag, m);
                 resolve(result);
             });
         });
     }
+    expandAncestorsForNode(node, nodeMap) {
+        const hashToNode = buildHashToNodeMap(nodeMap);
+        const ancestors = collectAncestors(node, nodeMap, hashToNode);
+        for (const ancestor of ancestors) {
+            ancestor.treeExpanded = true;
+            this.deps.rolodexTree?.childrenRendered.add(ancestor.id);
+            this.deps.rolodexTree?.expandedNodes.set(ancestor.id, ancestor);
+        }
+    }
 }

package/dist/controllers/tab-cache-controller.d.ts

@@ -0,0 +1,29 @@
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+export interface TabCacheConfig {
+    maxCachedTabs?: number;
+    alwaysLoadedControlTabs?: string[];
+    alwaysLoadedEditorTabs?: string[];
+    heavyControlTabs?: string[];
+    heavyEditorTabs?: string[];
+}
+export declare class TabCacheController implements ReactiveController {
+    host: ReactiveControllerHost;
+    private loadedControlTabs;
+    private loadedEditorTabs;
+    private _maxCachedTabs;
+    private _controlTabAccessOrder;
+    private _editorTabAccessOrder;
+    private alwaysLoadedControlTabs;
+    private alwaysLoadedEditorTabs;
+    private heavyControlTabs;
+    private heavyEditorTabs;
+    constructor(host: ReactiveControllerHost, config?: TabCacheConfig);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    markControlTabLoaded(tabName: string): void;
+    markEditorTabLoaded(tabName: string): void;
+    private _evictLRUControlTab;
+    private _evictLRUEditorTab;
+    shouldRenderControlTab(tabName: string): boolean;
+    shouldRenderEditorTab(tabName: string): boolean;
+}

package/dist/controllers/tab-cache-controller.js

@@ -0,0 +1,68 @@
+export class TabCacheController {
+    constructor(host, config = {}) {
+        this.loadedControlTabs = new Set();
+        this.loadedEditorTabs = new Set();
+        this._controlTabAccessOrder = [];
+        this._editorTabAccessOrder = [];
+        this.host = host;
+        this._maxCachedTabs = config.maxCachedTabs ?? 3;
+        this.alwaysLoadedControlTabs = config.alwaysLoadedControlTabs ?? ['overview'];
+        this.alwaysLoadedEditorTabs = config.alwaysLoadedEditorTabs ?? ['spec'];
+        this.heavyControlTabs = config.heavyControlTabs ?? ['ruleset'];
+        this.heavyEditorTabs = config.heavyEditorTabs ?? ['explorer'];
+        host.addController(this);
+    }
+    hostConnected() { }
+    hostDisconnected() {
+        this.loadedControlTabs.clear();
+        this.loadedEditorTabs.clear();
+        this._controlTabAccessOrder = [];
+        this._editorTabAccessOrder = [];
+    }
+    markControlTabLoaded(tabName) {
+        if (this.loadedControlTabs.has(tabName)) {
+            this._controlTabAccessOrder = this._controlTabAccessOrder.filter(t => t !== tabName);
+            this._controlTabAccessOrder.push(tabName);
+            return;
+        }
+        this.loadedControlTabs.add(tabName);
+        this._controlTabAccessOrder.push(tabName);
+        this._evictLRUControlTab();
+        this.host.requestUpdate();
+    }
+    markEditorTabLoaded(tabName) {
+        if (this.loadedEditorTabs.has(tabName)) {
+            this._editorTabAccessOrder = this._editorTabAccessOrder.filter(t => t !== tabName);
+            this._editorTabAccessOrder.push(tabName);
+            return;
+        }
+        this.loadedEditorTabs.add(tabName);
+        this._editorTabAccessOrder.push(tabName);
+        this._evictLRUEditorTab();
+        this.host.requestUpdate();
+    }
+    _evictLRUControlTab() {
+        const heavyLoaded = this._controlTabAccessOrder.filter(t => this.heavyControlTabs.includes(t));
+        if (heavyLoaded.length > this._maxCachedTabs) {
+            const lruTab = heavyLoaded[0];
+            this.loadedControlTabs.delete(lruTab);
+            this._controlTabAccessOrder = this._controlTabAccessOrder.filter(t => t !== lruTab);
+        }
+    }
+    _evictLRUEditorTab() {
+        const heavyLoaded = this._editorTabAccessOrder.filter(t => this.heavyEditorTabs.includes(t));
+        if (heavyLoaded.length > this._maxCachedTabs) {
+            const lruTab = heavyLoaded[0];
+            this.loadedEditorTabs.delete(lruTab);
+            this._editorTabAccessOrder = this._editorTabAccessOrder.filter(t => t !== lruTab);
+        }
+    }
+    shouldRenderControlTab(tabName) {
+        return this.alwaysLoadedControlTabs.includes(tabName) ||
+            this.loadedControlTabs.has(tabName);
+    }
+    shouldRenderEditorTab(tabName) {
+        return this.alwaysLoadedEditorTabs.includes(tabName) ||
+            this.loadedEditorTabs.has(tabName);
+    }
+}

package/dist/controllers/timeline-controller.d.ts

@@ -0,0 +1,18 @@
+import type { TimelineControllerDeps } from "../interfaces/doctor-interfaces.js";
+export interface ToolsCompareResult {
+    success: boolean;
+    totalChanges?: number;
+    error?: string;
+}
+export declare class TimelineController extends EventTarget {
+    private readonly deps;
+    private unsubscribePrChange?;
+    constructor(deps: TimelineControllerDeps);
+    init(): void;
+    private handlePrChangeCompleted;
+    destroy(): void;
+    loadRevisionViolations(changeId: string): Promise<void>;
+    restoreLiveViolations(): void;
+    private restoreLiveGraph;
+    toolsCompare(specContent: string): Promise<ToolsCompareResult>;
+}