@shadowcoderr/context-graph 0.3.0

package/dist/core/runtime.d.ts

@@ -0,0 +1,38 @@
+import { Browser, Page } from '@playwright/test';
+import { Config } from '../types/config';
+export declare enum RuntimeMode {
+    BROWSER = "browser",
+    RECORDER = "recorder"
+}
+export type StartRecorderOptions = {
+    captureArtifacts?: boolean;
+};
+export declare class RuntimeController {
+    private config;
+    private mode;
+    private browserAdapter;
+    private captureEngine;
+    private storageEngine;
+    private componentsRegistry;
+    private sessionId;
+    private capturedPages;
+    private pendingCaptures;
+    constructor(config: Config, mode: RuntimeMode);
+    initialize(): Promise<void>;
+    startRecorder(url: string, options?: StartRecorderOptions): Promise<void>;
+    private captureFromRecordedScript;
+    private executeRecordedSpecSteps;
+    private extractTestBody;
+    launchBrowser(): Promise<Browser>;
+    createContext(browser: Browser): Promise<any>;
+    private setupRecorderMode;
+    setupPage(page: Page): Promise<void>;
+    private normalizeUrl;
+    private captureCurrentPage;
+    private isValidUrl;
+    shutdown(): Promise<void>;
+    onBrowserDisconnect(callback: () => void): void;
+    getSessionId(): string;
+    capturePageIfNeeded(page: Page): Promise<void>;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/dist/core/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/core/runtime.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,IAAI,EAAU,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAWzC,oBAAY,WAAW;IACrB,OAAO,YAAY;IACnB,QAAQ,aAAa;CACtB;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,IAAI,CAAc;IAC1B,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,kBAAkB,CAA0C;IAEpE,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,eAAe,CAAiC;gBAE5C,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW;IAavC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB3B,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;YAiFrE,yBAAyB;YAYzB,wBAAwB;IAiBtC,OAAO,CAAC,eAAe;IAmCjB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC;IAIjC,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;YAiBrC,iBAAiB;IAmJzB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IA8H1C,OAAO,CAAC,YAAY;YAgBN,kBAAkB;IAgGhC,OAAO,CAAC,UAAU;IASZ,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IA0C/B,mBAAmB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAI/C,YAAY,IAAI,MAAM;IAIhB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAsBrD"}

package/dist/core/runtime.js

@@ -0,0 +1,648 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeController = exports.RuntimeMode = void 0;
+// Developer: Shadow Coderr, Architect
+const test_1 = require("@playwright/test");
+const browser_adapter_1 = require("./browser-adapter");
+const capture_engine_1 = require("./capture-engine");
+const engine_1 = require("../storage/engine");
+const components_registry_1 = require("../registry/components-registry");
+const hash_1 = require("../utils/hash");
+const logger_1 = require("../utils/logger");
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+var RuntimeMode;
+(function (RuntimeMode) {
+    RuntimeMode["BROWSER"] = "browser";
+    RuntimeMode["RECORDER"] = "recorder";
+})(RuntimeMode || (exports.RuntimeMode = RuntimeMode = {}));
+class RuntimeController {
+    config;
+    mode;
+    browserAdapter;
+    captureEngine;
+    storageEngine;
+    componentsRegistry = null;
+    sessionId;
+    capturedPages = new Set();
+    pendingCaptures = new Set();
+    constructor(config, mode) {
+        this.config = config;
+        this.mode = mode;
+        this.browserAdapter = new browser_adapter_1.BrowserAdapter();
+        this.captureEngine = new capture_engine_1.CaptureEngine(config);
+        this.storageEngine = new engine_1.StorageEngine(config.storage.outputDir, config.storage.prettyJson, config.capture.forceCapture);
+        this.sessionId = (0, hash_1.generateSessionId)(new Date());
+    }
+    async initialize() {
+        await this.storageEngine.initialize();
+        // Initialize components registry manager if enabled
+        if (this.config.capture.components?.enabled) {
+            this.componentsRegistry = new components_registry_1.ComponentsRegistryManager(this.config.storage.outputDir, 'unknown', {
+                minOccurrences: this.config.capture.components.minOccurrences,
+                maxComponents: this.config.capture.components.maxComponents,
+            });
+            await this.componentsRegistry.initialize();
+        }
+        logger_1.logger.info(`Initialized runtime in ${this.mode} mode`);
+    }
+    async startRecorder(url, options = {}) {
+        const scriptPath = await this.storageEngine.getUniqueScriptPath(url);
+        logger_1.logger.info(`Starting Playwright Codegen for: ${url}`);
+        logger_1.logger.info(`Script will be saved to: ${scriptPath}`);
+        return new Promise((resolve, reject) => {
+            let cliPath;
+            try {
+                cliPath = require.resolve('playwright-core/cli');
+            }
+            catch (e) {
+                try {
+                    cliPath = require.resolve('playwright/cli');
+                }
+                catch (e2) {
+                    cliPath = path.join(process.cwd(), 'node_modules', 'playwright-core', 'cli.js');
+                }
+            }
+            logger_1.logger.debug(`Using Playwright CLI at: ${cliPath}`);
+            logger_1.logger.debug(`Using Playwright channel: msedge`);
+            const env = { ...process.env };
+            delete env.NODE_OPTIONS;
+            const spawnArgs = [
+                cliPath,
+                'codegen',
+                '-b', 'chromium',
+                '--channel', 'msedge',
+                '--output', scriptPath,
+                url,
+            ];
+            logger_1.logger.debug(`Spawning recorder: ${process.execPath} ${spawnArgs.join(' ')}`);
+            const recorderProcess = (0, child_process_1.spawn)(process.execPath, spawnArgs, {
+                stdio: 'inherit',
+                shell: false,
+                windowsHide: true,
+                cwd: process.cwd(),
+                env,
+            });
+            recorderProcess.on('error', (err) => {
+                logger_1.logger.error(`Failed to start recorder: ${err.message}`);
+                reject(err);
+            });
+            recorderProcess.on('close', (code) => {
+                if (code === 0) {
+                    logger_1.logger.info(`Script saved to: ${scriptPath}`);
+                }
+                else {
+                    // It's normal for codegen to return non-zero if closed via window X button sometimes
+                    logger_1.logger.info(`Playwright Codegen session ended (code ${code})`);
+                }
+                this.storageEngine.mergeRecordedScript(url, scriptPath)
+                    .then(async (mergedPath) => {
+                    logger_1.logger.info(`Merged script saved to: ${mergedPath}`);
+                    if (options.captureArtifacts) {
+                        try {
+                            await this.captureFromRecordedScript(mergedPath);
+                        }
+                        catch (err) {
+                            logger_1.logger.warn(`Failed to capture artifacts from recorded script: ${err.message}`);
+                        }
+                    }
+                    resolve();
+                })
+                    .catch((err) => {
+                    logger_1.logger.warn(`Failed to merge recorded script: ${err.message}`);
+                    resolve();
+                });
+            });
+        });
+    }
+    async captureFromRecordedScript(specPath) {
+        const browser = await this.launchBrowser();
+        const context = await this.createContext(browser);
+        const page = await context.newPage();
+        await this.setupPage(page);
+        await this.executeRecordedSpecSteps(specPath, page);
+        await this.shutdown();
+    }
+    async executeRecordedSpecSteps(specPath, page) {
+        const source = fs.readFileSync(specPath, 'utf8');
+        const body = this.extractTestBody(source);
+        if (!body.trim()) {
+            throw new Error(`No executable steps found in script: ${specPath}`);
+        }
+        const fn = new Function('page', 'expect', `"use strict"; return (async () => {\n${body}\n})();`);
+        await fn(page, test_1.expect);
+    }
+    extractTestBody(specSource) {
+        const lines = specSource.split(/\r?\n/);
+        const bodyLines = [];
+        let inTest = false;
+        let startedBody = false;
+        for (const line of lines) {
+            if (!inTest) {
+                if (/^\s*test\(/.test(line)) {
+                    inTest = true;
+                    if (line.includes('{')) {
+                        startedBody = true;
+                    }
+                }
+                continue;
+            }
+            if (!startedBody) {
+                if (line.includes('{')) {
+                    startedBody = true;
+                }
+                continue;
+            }
+            if (/^\s*\}\);\s*$/.test(line)) {
+                break;
+            }
+            bodyLines.push(line);
+        }
+        return bodyLines.join('\n').trim();
+    }
+    async launchBrowser() {
+        return await this.browserAdapter.launchBrowser(this.config);
+    }
+    async createContext(browser) {
+        const context = await this.browserAdapter.createContext(browser, this.config);
+        // Attach page handler for newly-created pages (popups)
+        context.on('page', async (page) => {
+            await this.setupPage(page);
+        });
+        // Attach setup to any existing pages
+        const pages = context.pages();
+        for (const p of pages) {
+            await this.setupPage(p);
+        }
+        return context;
+    }
+    async setupRecorderMode(page) {
+        logger_1.logger.info('Setting up recorder mode');
+        // Inject script to capture user interactions
+        await page.addInitScript(() => {
+            // Store recorded interactions
+            window.__contextGraph = {
+                interactions: [],
+                startTime: Date.now()
+            };
+            // Helper to record interactions
+            const recordInteraction = (type, element, data) => {
+                const interaction = {
+                    type,
+                    timestamp: Date.now(),
+                    element: {
+                        tagName: element.tagName.toLowerCase(),
+                        id: element.id,
+                        className: element.className,
+                        text: element.textContent?.slice(0, 50) || '',
+                        xpath: getXPath(element),
+                        cssSelector: getCssSelector(element)
+                    },
+                    data: data || {}
+                };
+                window.__contextGraph.interactions.push(interaction);
+                console.log('ContextGraph: Recorded', type, interaction);
+            };
+            // Helper functions
+            const getXPath = (element) => {
+                if (element.id)
+                    return `//*[@id="${element.id}"]`;
+                if (element === document.body)
+                    return '/html/body';
+                let ix = 0;
+                const siblings = element.parentNode.childNodes;
+                for (let i = 0; i < siblings.length; i++) {
+                    const sibling = siblings[i];
+                    if (sibling === element) {
+                        return getXPath(element.parentNode) + '/' + element.tagName.toLowerCase() + '[' + (ix + 1) + ']';
+                    }
+                    if (sibling.nodeType === 1 && sibling.tagName === element.tagName) {
+                        ix++;
+                    }
+                }
+                return '';
+            };
+            const getCssSelector = (element) => {
+                if (element.id)
+                    return `#${element.id}`;
+                if (element.className) {
+                    const classes = element.className.split(' ').filter((c) => c);
+                    return `${element.tagName.toLowerCase()}.${classes.join('.')}`;
+                }
+                return element.tagName.toLowerCase();
+            };
+            // Record clicks
+            document.addEventListener('click', (e) => {
+                recordInteraction('click', e.target, {
+                    button: e.button,
+                    ctrlKey: e.ctrlKey,
+                    shiftKey: e.shiftKey,
+                    altKey: e.altKey
+                });
+            }, true);
+            // Record form inputs
+            document.addEventListener('input', (e) => {
+                const target = e.target;
+                recordInteraction('input', target, {
+                    value: target.value.slice(0, 100), // Limit value length
+                    inputType: target.type,
+                    name: target.name
+                });
+            }, true);
+            // Record focus changes
+            document.addEventListener('focus', (e) => {
+                recordInteraction('focus', e.target);
+            }, true);
+            // Record scroll events
+            let scrollTimeout;
+            window.addEventListener('scroll', () => {
+                clearTimeout(scrollTimeout);
+                scrollTimeout = setTimeout(() => {
+                    recordInteraction('scroll', document.body, {
+                        scrollX: window.scrollX,
+                        scrollY: window.scrollY
+                    });
+                }, 100);
+            });
+            // Record navigation
+            const originalPushState = history.pushState;
+            history.pushState = function (data, unused, url) {
+                recordInteraction('navigation', document.body, {
+                    url: url?.toString(),
+                    method: 'pushState'
+                });
+                return originalPushState.apply(this, [data, unused, url]);
+            };
+            const originalReplaceState = history.replaceState;
+            history.replaceState = function (data, unused, url) {
+                recordInteraction('navigation', document.body, {
+                    url: url?.toString(),
+                    method: 'replaceState'
+                });
+                return originalReplaceState.apply(this, [data, unused, url]);
+            };
+            window.addEventListener('popstate', () => {
+                recordInteraction('navigation', document.body, {
+                    url: location.href,
+                    method: 'popstate'
+                });
+            });
+        });
+        // Set up periodic capture of interactions
+        const captureInteractions = async () => {
+            try {
+                const interactions = await page.evaluate(() => window.__contextGraph?.interactions || []);
+                if (interactions.length > 0) {
+                    logger_1.logger.info(`Captured ${interactions.length} user interactions`);
+                    // Save interactions to a separate file
+                    await this.storageEngine.saveUserInteractions(page.url(), interactions);
+                }
+            }
+            catch (error) {
+                logger_1.logger.debug(`Error capturing interactions: ${error.message}`);
+            }
+        };
+        // Capture interactions every 5 seconds
+        const interval = setInterval(captureInteractions, 5000);
+        // Clean up on page close
+        page.on('close', () => {
+            clearInterval(interval);
+            captureInteractions(); // Final capture
+        });
+    }
+    async setupPage(page) {
+        try {
+            // Ensure the page is ready before proceeding
+            await page.waitForLoadState('domcontentloaded');
+            await page.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => {
+                logger_1.logger.debug('Network idle state not reached, continuing...');
+            });
+            // Attach listeners
+            await this.browserAdapter.attachPageListeners(page);
+            await this.captureEngine.attachNetworkListeners(page);
+            // Set up recorder mode if enabled
+            if (this.mode === RuntimeMode.RECORDER) {
+                await this.setupRecorderMode(page);
+            }
+            // Prevent accidental closure using addInitScript instead of evaluateOnNewDocument
+            await page.addInitScript(() => {
+                window.addEventListener('beforeunload', (e) => {
+                    e.preventDefault();
+                    // @ts-ignore - TypeScript doesn't recognize returnValue on BeforeUnloadEvent
+                    e.returnValue = '';
+                    return '';
+                });
+            });
+        }
+        catch (error) {
+            logger_1.logger.error(`Error in setupPage: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+        // Set up page change detection
+        // Capture traditional load events
+        page.on('load', async () => {
+            const url = page.url();
+            logger_1.logger.info(`Page load detected: ${url}`);
+            const key = this.normalizeUrl(url);
+            if (!this.capturedPages.has(key) && this.isValidUrl(url)) {
+                logger_1.logger.info(`New page detected (load event): ${url}`);
+                this.capturedPages.add(key);
+                await this.captureCurrentPage(page);
+            }
+            else {
+                logger_1.logger.debug(`Page already captured (load event): ${url}`);
+            }
+        });
+        // Also capture DOMContentLoaded for faster detection
+        page.on('domcontentloaded', async () => {
+            const url = page.url();
+            const key = this.normalizeUrl(url);
+            if (!this.capturedPages.has(key) && this.isValidUrl(url)) {
+                logger_1.logger.info(`New page detected (DOMContentLoaded): ${url}`);
+                this.capturedPages.add(key);
+                await this.captureCurrentPage(page);
+            }
+        });
+        // Capture frame navigations (including main frame)
+        page.on('framenavigated', async (frame) => {
+            // Only capture main frame navigations to avoid duplicates
+            if (frame === page.mainFrame()) {
+                const url = frame.url();
+                logger_1.logger.info(`Frame navigated (main frame): ${url}`);
+                const key = this.normalizeUrl(url);
+                if (!this.capturedPages.has(key) && this.isValidUrl(url)) {
+                    logger_1.logger.info(`New page detected (framenavigated): ${url}`);
+                    this.capturedPages.add(key);
+                    await this.captureCurrentPage(page);
+                }
+                else {
+                    logger_1.logger.debug(`Page already captured (framenavigated): ${url}`);
+                }
+            }
+        });
+        // Capture SPA navigation via history API
+        try {
+            await page.exposeBinding('cc_onHistoryChange', async (_source, url) => {
+                logger_1.logger.info(`History change detected: ${url}`);
+                const key = this.normalizeUrl(url);
+                if (!this.capturedPages.has(key) && this.isValidUrl(url)) {
+                    logger_1.logger.info(`New page detected (history API): ${url}`);
+                    this.capturedPages.add(key);
+                    // Add a small delay to ensure page is ready
+                    await new Promise(r => setTimeout(r, 300));
+                    await this.captureCurrentPage(page);
+                }
+                else {
+                    logger_1.logger.debug(`Page already captured (history API): ${url}`);
+                }
+            });
+            await page.addInitScript(() => {
+                (function () {
+                    const origPush = history.pushState;
+                    history.pushState = function () {
+                        const ret = origPush.apply(this, arguments);
+                        try {
+                            setTimeout(() => {
+                                window['cc_onHistoryChange'] && window['cc_onHistoryChange'](location.href);
+                            }, 100);
+                        }
+                        catch (e) { }
+                        return ret;
+                    };
+                    const origReplace = history.replaceState;
+                    history.replaceState = function () {
+                        const ret = origReplace.apply(this, arguments);
+                        try {
+                            setTimeout(() => {
+                                window['cc_onHistoryChange'] && window['cc_onHistoryChange'](location.href);
+                            }, 100);
+                        }
+                        catch (e) { }
+                        return ret;
+                    };
+                    window.addEventListener('popstate', function () {
+                        try {
+                            setTimeout(() => {
+                                window['cc_onHistoryChange'] && window['cc_onHistoryChange'](location.href);
+                            }, 100);
+                        }
+                        catch (e) { }
+                    });
+                })();
+            });
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to set up history API interception: ${error.message}`);
+        }
+    }
+    normalizeUrl(url) {
+        try {
+            const u = new URL(url);
+            // Sort query params for consistent comparison
+            const sortedParams = Array.from(u.searchParams.entries())
+                .sort((a, b) => a[0].localeCompare(b[0]));
+            const queryString = sortedParams.length > 0
+                ? '?' + sortedParams.map(([k, v]) => `${k}=${v}`).join('&')
+                : '';
+            // Fix: Include hash so SPAs (e.g., /#/dashboard) are treated as unique pages
+            return `${u.origin}${u.pathname}${queryString}${u.hash}`;
+        }
+        catch {
+            return url;
+        }
+    }
+    async captureCurrentPage(page) {
+        const captureWork = (async () => {
+            const maxAttempts = 3;
+            let attempt = 0;
+            const startingUrl = page.url();
+            while (attempt < maxAttempts) {
+                attempt++;
+                try {
+                    if (page.isClosed()) {
+                        logger_1.logger.warn('Skipping capture: page is already closed');
+                        break;
+                    }
+                    // If the page has navigated since this capture was scheduled, abort to avoid racing navigation.
+                    const liveUrl = page.url();
+                    if (this.normalizeUrl(liveUrl) !== this.normalizeUrl(startingUrl)) {
+                        logger_1.logger.info(`Skipping capture: page navigated during capture scheduling (${startingUrl} -> ${liveUrl})`);
+                        break;
+                    }
+                    // Wait for page to be stable
+                    try {
+                        await page.waitForLoadState('networkidle', { timeout: 3000 }).catch(() => {
+                            logger_1.logger.debug('Network idle timeout, proceeding with capture');
+                        });
+                    }
+                    catch {
+                        await new Promise(r => setTimeout(r, 1000));
+                    }
+                    if (page.isClosed()) {
+                        logger_1.logger.warn('Skipping capture: page closed while waiting for stability');
+                        break;
+                    }
+                    const currentUrl = page.url();
+                    logger_1.logger.info(`Capturing page (attempt ${attempt}/${maxAttempts}): ${currentUrl}`);
+                    const consoleMessages = this.browserAdapter.getConsoleMessages();
+                    const snapshot = await this.captureEngine.capturePageSnapshot(page, this.config, consoleMessages);
+                    await this.storageEngine.savePageSnapshot(snapshot);
+                    // Update components registry
+                    if (this.componentsRegistry && this.config.capture.components?.enabled) {
+                        // Update registry domain if unknown
+                        if (this.componentsRegistry.registry?.domain === 'unknown') {
+                            this.componentsRegistry.registry.domain = snapshot.metadata.domain;
+                        }
+                        await this.componentsRegistry.processPage(snapshot);
+                    }
+                    this.browserAdapter.clearConsoleMessages();
+                    await this.storageEngine.updateGlobalManifest({
+                        captureId: snapshot.metadata.captureId,
+                        url: snapshot.metadata.url,
+                        title: snapshot.metadata.title,
+                        timestamp: snapshot.metadata.timestamp,
+                        sessionId: this.sessionId,
+                        domain: snapshot.metadata.domain,
+                        mode: this.mode,
+                    });
+                    logger_1.logger.info(`✓ Successfully captured page: ${snapshot.metadata.url} (saved as: ${snapshot.metadata.pageName})`);
+                    break;
+                }
+                catch (error) {
+                    const msg = error.message || '';
+                    logger_1.logger.warn(`Capture attempt ${attempt} failed: ${msg}`);
+                    // Check for fatal browser closure errors - don't retry these
+                    if (/Target page, context or browser has been closed|Execution context was destroyed|Navigation cancelled/i.test(msg)) {
+                        logger_1.logger.warn(`Capture aborted due to navigation/page close: ${msg}`);
+                        break; // don't retry these
+                    }
+                    // For other errors, retry if we haven't exhausted attempts
+                    if (attempt < maxAttempts) {
+                        await new Promise((r) => setTimeout(r, 300));
+                        continue;
+                    }
+                    logger_1.logger.error(`Failed to capture page: ${error}`);
+                    break;
+                }
+            }
+        })();
+        this.pendingCaptures.add(captureWork);
+        try {
+            await captureWork;
+        }
+        finally {
+            this.pendingCaptures.delete(captureWork);
+        }
+    }
+    isValidUrl(url) {
+        try {
+            const parsed = new URL(url);
+            return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+        }
+        catch {
+            return false;
+        }
+    }
+    async shutdown() {
+        try {
+            const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error('Shutdown timeout')), 20000));
+            await Promise.race([
+                Promise.all(Array.from(this.pendingCaptures)),
+                timeout
+            ]);
+            logger_1.logger.info('All pending captures completed');
+        }
+        catch (err) {
+            const error = err;
+            if (error.message === 'Shutdown timeout') {
+                logger_1.logger.warn('Shutdown timeout - some captures may still be in progress');
+            }
+            else {
+                logger_1.logger.warn('Error waiting for pending captures: ' + error.message);
+            }
+        }
+        // Persist components registry and update manifest reference
+        try {
+            if (this.componentsRegistry && this.config.capture.components?.enabled) {
+                const domain = this.componentsRegistry.getRegistry().domain;
+                const domainName = (() => {
+                    const parts = domain.split('.');
+                    const filtered = parts.filter(p => p.toLowerCase() !== 'www');
+                    if (filtered.length >= 2)
+                        return filtered[filtered.length - 2];
+                    return filtered[0] || parts[0];
+                })();
+                const registry = this.componentsRegistry.getRegistry();
+                await this.storageEngine.saveComponentsRegistry(registry, domainName);
+                await this.storageEngine.updateManifestWithComponents(domainName, registry.components.length);
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to persist components registry: ${error.message}`);
+        }
+        await this.browserAdapter.close();
+        logger_1.logger.info('Runtime shutdown complete');
+    }
+    onBrowserDisconnect(callback) {
+        this.browserAdapter.onBrowserDisconnect(callback);
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    async capturePageIfNeeded(page) {
+        try {
+            const url = page.url();
+            const key = this.normalizeUrl(url);
+            if (!this.capturedPages.has(key) && this.isValidUrl(url)) {
+                logger_1.logger.info(`New page detected: ${url}`);
+                // Ensure page is stable before capturing
+                await page.waitForLoadState('domcontentloaded');
+                await page.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => {
+                    logger_1.logger.debug('Network idle state not reached, continuing with capture...');
+                });
+                await this.captureCurrentPage(page);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger_1.logger.error(`Error in capturePageIfNeeded: ${errorMessage}`);
+            throw error;
+        }
+    }
+}
+exports.RuntimeController = RuntimeController;
+//# sourceMappingURL=runtime.js.map