autokap 1.0.6 → 1.0.7

package/dist/capture-run-optimizer.js

@@ -0,0 +1,848 @@
+const GENERIC_NAV_TOKENS = new Set([
+    "page",
+    "pages",
+    "open",
+    "view",
+    "link",
+    "button",
+    "click",
+    "menu",
+    "nav",
+    "navigation",
+    "section",
+    "screen",
+    "capture",
+    "prepare",
+    "show",
+    "the",
+    "and",
+    "for",
+    "with",
+]);
+const ELEMENT_ASSIGNMENT_STOP_WORDS = new Set([
+    ...GENERIC_NAV_TOKENS,
+    "card",
+    "cards",
+    "grid",
+    "rectangular",
+    "title",
+    "containing",
+    "component",
+    "element",
+    "entire",
+    "full",
+    "inside",
+    "within",
+    "target",
+    "titre",
+    "contenant",
+    "carte",
+    "cartes",
+    "grille",
+    "rectangulaire",
+    "composant",
+    "element",
+    "élément",
+    "capturez",
+    "capturer",
+    "dans",
+    "sur",
+]);
+const ELEMENT_DOMAIN_HINTS = [
+    {
+        element: /\b(gallery|screenshot|screenshots|capture|captures|thumbnail|download all|filter by preset|filtrer par preset)\b/i,
+        page: /\b(gallery|screenshot|screenshots|capture|captures)\b/i,
+        score: 5,
+    },
+    {
+        element: /\b(preset|presets|template|templates|mockup|iphone|instructions|editor|configuration|settings)\b/i,
+        page: /\b(preset|presets|template|templates|mockup|editor|configuration|settings)\b/i,
+        score: 5,
+    },
+    {
+        element: /\b(assistant|chat|conversation|prompt ia|ai assistant)\b/i,
+        page: /\b(assistant|chat|conversation)\b/i,
+        score: 5,
+    },
+    {
+        element: /\b(home|homepage|dashboard|accueil)\b/i,
+        page: /\b(home|homepage|dashboard|accueil)\b/i,
+        score: 4,
+    },
+];
+const MODAL_CAPTURE_RE = /\b(modal|dialog|popup|drawer|template|picker|gallery|selection|select|choose)\b/i;
+const CONFIG_CAPTURE_RE = /\b(edit|editor|config|configuration|configure|settings|instruction|instructions|textarea|form|detail|details|modify|modifier|edition)\b/i;
+const MODAL_OPENER_RE = /\b(new|nouveau|create|creer|cr[eé]er|add|ajouter|open|ouvrir|plus)\b/i;
+function uniqueInOrder(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
+function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, max - 1)}...` : value;
+}
+function normalizeNavigationTokens(values) {
+    const tokens = [];
+    for (const value of values) {
+        if (!value)
+            continue;
+        const parts = value
+            .toLowerCase()
+            .split(/[^a-z0-9]+/i)
+            .map((part) => part.trim())
+            .filter((part) => part.length >= 3 && part.length <= 32 && !GENERIC_NAV_TOKENS.has(part));
+        tokens.push(...parts);
+    }
+    return uniqueInOrder(tokens).slice(0, 8);
+}
+function normalizeElementAssignmentTokens(values) {
+    const tokens = [];
+    for (const value of values) {
+        if (!value)
+            continue;
+        const parts = value
+            .toLowerCase()
+            .normalize("NFD")
+            .replace(/[\u0300-\u036f]/g, "")
+            .split(/[^a-z0-9]+/i)
+            .map((part) => part.trim())
+            .filter((part) => part.length >= 3 && part.length <= 32 && !ELEMENT_ASSIGNMENT_STOP_WORDS.has(part));
+        tokens.push(...parts);
+    }
+    return uniqueInOrder(tokens).slice(0, 16);
+}
+function extractPathTokens(rawUrl) {
+    if (!rawUrl)
+        return [];
+    try {
+        const url = new URL(rawUrl);
+        return normalizeNavigationTokens(url.pathname.split("/"));
+    }
+    catch {
+        return normalizeNavigationTokens(rawUrl.split("/"));
+    }
+}
+function countOverlap(left, right) {
+    if (left.length === 0 || right.length === 0)
+        return 0;
+    const rightSet = new Set(right);
+    return left.filter((token) => rightSet.has(token)).length;
+}
+function inferCaptureIntent(values) {
+    const joined = values.filter(Boolean).join(" ");
+    return {
+        tokens: normalizeNavigationTokens(values),
+        modalSelection: MODAL_CAPTURE_RE.test(joined),
+        configuration: CONFIG_CAPTURE_RE.test(joined),
+        domain: inferCaptureDomain(joined),
+    };
+}
+function inferCaptureDomain(value) {
+    if (/\b(assistant|chat|conversation|copilot|prompt ia|ai assistant)\b/i.test(value)) {
+        return "assistant";
+    }
+    if (/\b(gallery|screenshots?|captures?|thumbnail|download all|filter by preset)\b/i.test(value)) {
+        return "gallery";
+    }
+    if (/\b(preset|template|editor|mockup|instructions?|configuration|configure)\b/i.test(value)) {
+        return "preset";
+    }
+    if (/\b(settings|preferences|appearance|language|theme|param[eè]tres)\b/i.test(value)) {
+        return "settings";
+    }
+    if (/\b(home|homepage|dashboard|accueil)\b/i.test(value)) {
+        return "home";
+    }
+    return "unknown";
+}
+export function getUrlOrigin(value) {
+    if (!value)
+        return null;
+    try {
+        return new URL(value).origin;
+    }
+    catch {
+        return null;
+    }
+}
+export function urlMatchesCaptureTarget(currentUrl, targetUrl) {
+    if (!currentUrl)
+        return false;
+    try {
+        const current = new URL(currentUrl);
+        const target = new URL(targetUrl);
+        if (current.origin !== target.origin)
+            return false;
+        const currentSegments = current.pathname
+            .split("/")
+            .map((segment) => decodeURIComponent(segment).trim().toLowerCase())
+            .filter(Boolean);
+        const targetSegments = target.pathname
+            .split("/")
+            .map((segment) => decodeURIComponent(segment).trim().toLowerCase())
+            .filter(Boolean);
+        if (targetSegments.length === 0) {
+            return currentSegments.length === 0;
+        }
+        if (currentSegments.length < targetSegments.length)
+            return false;
+        return targetSegments.every((segment, index) => currentSegments[index] === segment);
+    }
+    catch {
+        const normalize = (value) => value
+            .trim()
+            .replace(/[?#].*$/, "")
+            .replace(/\/+$/, "")
+            .toLowerCase();
+        const current = normalize(currentUrl);
+        const target = normalize(targetUrl);
+        return current === target || current.startsWith(`${target}/`);
+    }
+}
+export function urlsShareOrigin(left, right) {
+    const leftOrigin = getUrlOrigin(left);
+    const rightOrigin = getUrlOrigin(right);
+    return !!leftOrigin && !!rightOrigin && leftOrigin === rightOrigin;
+}
+export function resolveCaptureResumeUrl(params) {
+    const normalizedPageId = params.pageId ?? "main";
+    const checkpoint = [...params.checkpoints]
+        .reverse()
+        .find((entry) => entry.pageId === normalizedPageId);
+    const candidates = [
+        params.cursorResumeUrl,
+        checkpoint?.resumeUrl,
+        checkpoint?.url,
+        checkpoint?.canonicalUrl,
+        params.currentUrl,
+        params.sessionProfile?.lastKnownUrl,
+        params.sessionProfile?.validatedStartUrl,
+        params.pageUrl,
+    ];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        if (urlMatchesCaptureTarget(candidate, params.pageUrl))
+            return candidate;
+    }
+    if (params.pageIndex > 0) {
+        for (const candidate of candidates) {
+            if (!candidate)
+                continue;
+            if (urlsShareOrigin(candidate, params.pageUrl))
+                return candidate;
+        }
+    }
+    return params.pageUrl;
+}
+export function shouldNormalizeDialogsBeforeTargetReuse(params) {
+    // Always close leftover dialogs/overlays when transitioning between pages.
+    // Even if the next page expects a dialog, we should start clean — the agent
+    // will open the correct dialog as part of its navigation plan.
+    return (params.currentDialogCount ?? 0) > 0;
+}
+export function buildScreenshotVariantPlan(params) {
+    const langs = uniqueInOrder(params.langs);
+    const themes = uniqueInOrder(params.themes);
+    return langs.flatMap((lang) => themes.map((theme) => ({
+        key: `${lang}:${theme}`,
+        lang,
+        theme,
+        pages: params.pages,
+    })));
+}
+function scoreIsolatedElementForPage(params) {
+    const elementText = `${params.element.name} ${params.element.description}`;
+    const pageText = `${params.pageRun.pageId ?? "main"} ${params.pageRun.prompt} ${params.pageRun.url}`;
+    const elementTokens = normalizeElementAssignmentTokens([elementText]);
+    const pageTokens = normalizeElementAssignmentTokens([
+        params.pageRun.pageId,
+        params.pageRun.prompt,
+        ...extractPathTokens(params.pageRun.url),
+    ]);
+    let score = countOverlap(elementTokens, pageTokens) * 3;
+    const normalizedPageId = (params.pageRun.pageId ?? "main").toLowerCase();
+    if (params.element.sourcePageId
+        && normalizedPageId === params.element.sourcePageId.trim().toLowerCase()) {
+        return 100;
+    }
+    if (normalizeElementAssignmentTokens([params.pageRun.pageId]).some((token) => elementTokens.includes(token))) {
+        score += 3;
+    }
+    for (const hint of ELEMENT_DOMAIN_HINTS) {
+        if (hint.element.test(elementText) && hint.page.test(pageText)) {
+            score += hint.score;
+        }
+    }
+    if (/\b(current|currently|already|active|visible|open)\b/i.test(elementText)) {
+        score += 1;
+    }
+    return score;
+}
+export function resolveIsolatedElementAssignments(params) {
+    const finalPageId = params.pageRuns[params.pageRuns.length - 1]?.pageId ?? "main";
+    return params.elements.map((element) => {
+        const explicitPageId = element.sourcePageId?.trim();
+        if (explicitPageId) {
+            const matchingPage = params.pageRuns.find((pageRun) => (pageRun.pageId ?? "main").toLowerCase() === explicitPageId.toLowerCase());
+            if (matchingPage) {
+                return {
+                    element,
+                    pageId: matchingPage.pageId ?? "main",
+                    explicit: true,
+                    score: 100,
+                };
+            }
+        }
+        let best = null;
+        let runnerUp = Number.NEGATIVE_INFINITY;
+        for (const pageRun of params.pageRuns) {
+            const pageId = pageRun.pageId ?? "main";
+            const score = scoreIsolatedElementForPage({ element, pageRun });
+            if (!best || score > best.score) {
+                runnerUp = best?.score ?? Number.NEGATIVE_INFINITY;
+                best = { pageId, score };
+                continue;
+            }
+            if (score > runnerUp) {
+                runnerUp = score;
+            }
+        }
+        const bestScore = best?.score ?? Number.NEGATIVE_INFINITY;
+        const uniqueBest = best && bestScore >= 5 && bestScore >= runnerUp + 2;
+        const resolvedPageId = uniqueBest && best ? best.pageId : finalPageId;
+        return {
+            element,
+            pageId: resolvedPageId,
+            explicit: false,
+            score: uniqueBest ? bestScore : 0,
+        };
+    });
+}
+export function describeScreenshotVariantPlan(plan) {
+    if (plan.length === 0)
+        return "none";
+    return plan
+        .map((variant) => `${variant.lang}/${variant.theme} (${variant.pages.length} page${variant.pages.length > 1 ? "s" : ""})`)
+        .join(" -> ");
+}
+export function shouldReuseLivePageState(params) {
+    if (params.pageIndex === 0)
+        return false;
+    if (!params.isAuthenticated)
+        return false;
+    if (!params.currentUrl)
+        return false;
+    const currentOrigin = getUrlOrigin(params.currentUrl);
+    const pageOrigin = getUrlOrigin(params.pageUrl);
+    if (!currentOrigin || !pageOrigin || currentOrigin !== pageOrigin) {
+        return false;
+    }
+    // Only skip the reset when the page uses the preset root URL.
+    // Explicit per-page URLs still navigate directly for determinism.
+    return params.pageUrl === params.presetRootUrl;
+}
+export function shouldUseSequentialPageHandoff(params) {
+    if (params.pageIndex === 0)
+        return false;
+    if (!params.currentUrl)
+        return false;
+    const currentOrigin = getUrlOrigin(params.currentUrl);
+    const pageOrigin = getUrlOrigin(params.pageUrl);
+    if (!currentOrigin || !pageOrigin)
+        return false;
+    if (currentOrigin !== pageOrigin)
+        return false;
+    if (params.previousPageId && params.pageId && params.previousPageId === params.pageId) {
+        return true;
+    }
+    const currentPathTokens = extractPathTokens(params.currentUrl);
+    const targetPathTokens = extractPathTokens(params.pageUrl);
+    const pathOverlap = countOverlap(currentPathTokens, targetPathTokens);
+    const previousIntent = inferCaptureIntent([params.previousPageId, params.previousPrompt]);
+    const targetIntent = inferCaptureIntent([params.pageId, params.pagePrompt]);
+    const promptOverlap = countOverlap(previousIntent.tokens, targetIntent.tokens);
+    if (pathOverlap > 0 && promptOverlap > 0) {
+        return true;
+    }
+    if (promptOverlap >= 2) {
+        return true;
+    }
+    if (targetIntent.modalSelection && !previousIntent.configuration) {
+        return true;
+    }
+    if (previousIntent.modalSelection && targetIntent.configuration && !targetIntent.modalSelection) {
+        return false;
+    }
+    return false;
+}
+export function buildSequentialHandoffArtifacts(actions) {
+    const selectorHints = [];
+    const selectorMemory = {};
+    const seenSelectors = new Set();
+    for (let index = actions.length - 1; index >= 0; index -= 1) {
+        const action = actions[index];
+        if (!action.success)
+            continue;
+        if (action.stateChanged === false)
+            continue;
+        if (action.action !== "click"
+            && action.action !== "safe_expand"
+            && action.action !== "select_option"
+            && action.action !== "scroll"
+            && action.action !== "press_key"
+            && action.action !== "dismiss_overlays") {
+            continue;
+        }
+        const selector = String(action.params.selector ?? "").trim();
+        if (!selector || selector.startsWith("[index:") || seenSelectors.has(selector))
+            continue;
+        seenSelectors.add(selector);
+        const label = String(action.params.elementLabel ?? "").trim();
+        const href = String(action.params.href ?? "").trim();
+        const detail = [label, href].filter(Boolean).join(" -> ");
+        selectorMemory[`handoff:recent_${selectorHints.length + 1}`] = [selector];
+        selectorHints.push(detail ? `${selector} (${truncate(detail, 120)})` : selector);
+        if (selectorHints.length >= 6)
+            break;
+    }
+    return { selectorHints, selectorMemory };
+}
+export function buildTargetNavigationArtifacts(params) {
+    if (!params.selectorMemory || Object.keys(params.selectorMemory).length === 0) {
+        return { navigationHints: [], selectorMemory: {} };
+    }
+    const targetTokens = uniqueInOrder([
+        ...extractPathTokens(params.pageUrl),
+        ...normalizeNavigationTokens([params.pageId ?? null, params.prompt]),
+    ]).slice(0, 8);
+    if (targetTokens.length === 0) {
+        return { navigationHints: [], selectorMemory: {} };
+    }
+    const hints = [];
+    const selectorMemory = {};
+    const seenSelectors = new Set();
+    for (const token of targetTokens) {
+        const candidateSelectors = [
+            ...(params.selectorMemory[`nav:path:${token}`] ?? []),
+            ...(params.selectorMemory[`nav:label:${token}`] ?? []),
+        ];
+        for (const selector of candidateSelectors) {
+            const normalizedSelector = selector.trim();
+            if (!normalizedSelector || seenSelectors.has(normalizedSelector))
+                continue;
+            seenSelectors.add(normalizedSelector);
+            selectorMemory[`nav:target:${token}`] = [normalizedSelector];
+            hints.push(`${token} -> ${truncate(normalizedSelector, 120)}`);
+            if (hints.length >= 6) {
+                return { navigationHints: hints, selectorMemory };
+            }
+            break;
+        }
+    }
+    return { navigationHints: hints, selectorMemory };
+}
+export function buildDeterministicNavigationPlan(params) {
+    if (!params.selectorMemory || Object.keys(params.selectorMemory).length === 0) {
+        return [];
+    }
+    const targetArtifacts = buildTargetNavigationArtifacts(params);
+    const targetSelectors = uniqueInOrder(Object.values(targetArtifacts.selectorMemory).flat()).slice(0, 2);
+    const openerSelectors = uniqueInOrder([
+        ...(params.selectorMemory["menu:primary"] ?? []),
+        ...(params.selectorMemory["account:menu"] ?? []),
+    ]).slice(0, 2);
+    const candidates = [];
+    for (const targetSelector of targetSelectors) {
+        candidates.push({
+            description: `direct:${truncate(targetSelector, 80)}`,
+            selectors: [targetSelector],
+        });
+    }
+    if (openerSelectors.length > 0 && targetSelectors.length > 0) {
+        for (const openerSelector of openerSelectors.slice(0, 2)) {
+            candidates.push({
+                description: `open_then_target:${truncate(openerSelector, 60)} -> ${truncate(targetSelectors[0], 60)}`,
+                selectors: [openerSelector, targetSelectors[0]],
+            });
+        }
+    }
+    const deduped = new Map();
+    for (const candidate of candidates) {
+        const key = candidate.selectors.join(" -> ");
+        if (!deduped.has(key)) {
+            deduped.set(key, candidate);
+        }
+    }
+    return Array.from(deduped.values()).slice(0, 4);
+}
+export function buildVisibleControlNavigationPlan(params) {
+    if (!params.interactiveElements || params.interactiveElements.length === 0) {
+        return [];
+    }
+    const targetIntent = inferCaptureIntent([params.pageId, params.prompt]);
+    const targetTokens = targetIntent.tokens;
+    const candidates = new Map();
+    for (const element of params.interactiveElements) {
+        if (!element.selector)
+            continue;
+        if (!element.visible && element.visibilityState === "offscreen")
+            continue;
+        const label = [element.text, element.ariaLabel, element.title]
+            .filter((value) => typeof value === "string" && value.trim().length > 0)
+            .join(" ")
+            .trim();
+        if (!label)
+            continue;
+        const labelTokens = normalizeNavigationTokens([label]);
+        const overlap = countOverlap(labelTokens, targetTokens);
+        const normalizedLabel = label.toLowerCase();
+        let score = overlap * 4;
+        if (targetIntent.modalSelection && MODAL_OPENER_RE.test(normalizedLabel)) {
+            score += 5;
+        }
+        if (/\bpreset|template\b/i.test(`${params.pageId ?? ""} ${params.prompt}`) && /\bpreset|template\b/i.test(normalizedLabel)) {
+            score += 4;
+        }
+        if (/\bgallery|capture|captures|screenshot|screenshots\b/i.test(`${params.pageId ?? ""} ${params.prompt}`) && /\bgallery|capture|captures|screenshot|screenshots\b/i.test(normalizedLabel)) {
+            score += 4;
+        }
+        if (element.visibilityState === "full")
+            score += 1;
+        if (element.role === "button" || element.role === "link")
+            score += 1;
+        if (score <= 0)
+            continue;
+        const current = candidates.get(element.selector);
+        const description = `visible:${truncate(label.replace(/\s+/g, " "), 80)}`;
+        if (!current || score > current.score) {
+            candidates.set(element.selector, {
+                score,
+                candidate: {
+                    description,
+                    selectors: [element.selector],
+                },
+            });
+        }
+    }
+    const ranked = Array.from(candidates.values())
+        .sort((left, right) => right.score - left.score);
+    const bestScore = ranked[0]?.score ?? 0;
+    const scoreFloor = Math.max(4, bestScore - 2);
+    return ranked
+        .filter((entry) => entry.score >= scoreFloor)
+        .map((entry) => entry.candidate)
+        .slice(0, 4);
+}
+export function shouldAttemptSequentialReadyCheck(params) {
+    if (!params.currentUrl)
+        return false;
+    const currentOrigin = getUrlOrigin(params.currentUrl);
+    const pageOrigin = getUrlOrigin(params.pageUrl);
+    if (!currentOrigin || !pageOrigin || currentOrigin !== pageOrigin)
+        return false;
+    const previousIntent = inferCaptureIntent([params.previousPageId, params.previousPrompt]);
+    const targetIntent = inferCaptureIntent([params.pageId, params.pagePrompt]);
+    const samePageId = !!params.previousPageId && !!params.pageId && params.previousPageId === params.pageId;
+    const currentPathTokens = extractPathTokens(params.currentUrl);
+    const targetPathTokens = extractPathTokens(params.pageUrl);
+    if (samePageId) {
+        return true;
+    }
+    if (targetIntent.modalSelection)
+        return false;
+    if (previousIntent.modalSelection && targetIntent.configuration && !targetIntent.modalSelection) {
+        return false;
+    }
+    const intentOverlap = countOverlap(previousIntent.tokens, targetIntent.tokens);
+    if (countOverlap(currentPathTokens, targetPathTokens) > 0) {
+        // Many AutoKap captures share the same base route (for example /home) while
+        // representing materially different UI states. Do not use the fast ready
+        // check on same-path transitions unless the target is clearly a close
+        // continuation of the previous page.
+        if (previousIntent.domain !== "unknown"
+            && targetIntent.domain !== "unknown"
+            && previousIntent.domain !== targetIntent.domain) {
+            return false;
+        }
+        return intentOverlap >= 2;
+    }
+    return intentOverlap >= 2;
+}
+export function shouldUseLiveStateFastPath(params) {
+    if (params.bootstrapMode !== "sequential_handoff"
+        && params.bootstrapMode !== "reused_live_state") {
+        return false;
+    }
+    return shouldAttemptSequentialReadyCheck({
+        currentUrl: params.currentUrl,
+        pageUrl: params.pageUrl,
+        previousPageId: params.previousPageId,
+        pageId: params.pageId,
+        previousPrompt: params.previousPrompt,
+        pagePrompt: params.pagePrompt,
+    });
+}
+export function deriveRunSharedAuthProfile(profile) {
+    if (!profile?.storageState || profile.authState !== "authenticated") {
+        return undefined;
+    }
+    const url = profile.lastKnownUrl ?? profile.validatedStartUrl ?? null;
+    const parts = [
+        "scope=run_auth",
+        "auth=authenticated",
+        profile.accountLabel ? `account=${profile.accountLabel}` : null,
+        profile.detectedLang ? `lang=${profile.detectedLang}` : null,
+        profile.detectedTheme ? `theme=${profile.detectedTheme}` : null,
+        url ? `url=${url}` : null,
+    ].filter(Boolean);
+    return {
+        storageState: profile.storageState,
+        sessionStorage: profile.sessionStorage,
+        authState: "authenticated",
+        accountLabel: profile.accountLabel ?? null,
+        detectedLang: profile.detectedLang ?? null,
+        detectedTheme: profile.detectedTheme ?? null,
+        validatedStartUrl: profile.validatedStartUrl ?? url,
+        lastKnownUrl: url,
+        summary: truncate(parts.join("; "), 180),
+        validationStatus: profile.validationStatus ?? "unknown",
+        lastUsedAt: profile.lastUsedAt ?? new Date().toISOString(),
+        profileVersion: profile.profileVersion ?? 1,
+    };
+}
+export function buildSessionBootstrapProfile(params) {
+    const { runAuthProfile, persistedVariantProfile } = params;
+    const requestedLang = params.requestedLang.trim().toLowerCase();
+    const runLangMatches = runAuthProfile?.detectedLang?.trim().toLowerCase() === requestedLang;
+    const persistedLangMatches = persistedVariantProfile?.detectedLang?.trim().toLowerCase() === requestedLang;
+    const runThemeMatches = runAuthProfile?.detectedTheme === params.requestedTheme;
+    const persistedThemeMatches = persistedVariantProfile?.detectedTheme === params.requestedTheme;
+    const runVariantMatches = runLangMatches && runThemeMatches;
+    const persistedVariantMatches = persistedLangMatches && persistedThemeMatches;
+    if (runAuthProfile) {
+        const preferredLiveUrl = runAuthProfile.lastKnownUrl ?? persistedVariantProfile?.lastKnownUrl ?? null;
+        const sameOriginLiveUrl = preferredLiveUrl && params.startUrl
+            ? getUrlOrigin(preferredLiveUrl) === getUrlOrigin(params.startUrl)
+            : !!preferredLiveUrl;
+        const url = (sameOriginLiveUrl ? preferredLiveUrl : null)
+            ?? params.startUrl
+            ?? persistedVariantProfile?.validatedStartUrl
+            ?? runAuthProfile.validatedStartUrl
+            ?? preferredLiveUrl
+            ?? null;
+        const parts = [
+            "scope=bootstrap",
+            "source=run_shared_auth",
+            `auth=${runAuthProfile.authState}`,
+            runAuthProfile.accountLabel ? `account=${runAuthProfile.accountLabel}` : null,
+            `target=${params.requestedLang}/${params.requestedTheme}`,
+            url ? `url=${url}` : null,
+        ].filter(Boolean);
+        return {
+            source: "run_shared_auth",
+            profile: {
+                storageState: runAuthProfile.storageState ?? persistedVariantProfile?.storageState,
+                sessionStorage: runAuthProfile.sessionStorage ?? persistedVariantProfile?.sessionStorage,
+                authState: runAuthProfile.authState,
+                accountLabel: runAuthProfile.accountLabel ?? persistedVariantProfile?.accountLabel ?? null,
+                detectedLang: (runLangMatches ? runAuthProfile.detectedLang : null)
+                    ?? (persistedLangMatches ? persistedVariantProfile?.detectedLang ?? null : null),
+                detectedTheme: (runThemeMatches ? runAuthProfile.detectedTheme : null)
+                    ?? (persistedThemeMatches ? persistedVariantProfile?.detectedTheme ?? null : null),
+                validatedStartUrl: url,
+                lastKnownUrl: preferredLiveUrl ?? url,
+                summary: truncate(parts.join("; "), 200),
+                validationStatus: runVariantMatches && runAuthProfile.validationStatus !== "invalid"
+                    ? runAuthProfile.validationStatus
+                    : persistedVariantMatches && persistedVariantProfile?.validationStatus !== "invalid"
+                        ? persistedVariantProfile.validationStatus
+                        : "unknown",
+                lastUsedAt: runAuthProfile.lastUsedAt ?? persistedVariantProfile?.lastUsedAt ?? null,
+                profileVersion: Math.max(runAuthProfile.profileVersion ?? 1, persistedVariantProfile?.profileVersion ?? 1),
+            },
+        };
+    }
+    if (persistedVariantProfile) {
+        return {
+            source: "persisted_variant",
+            profile: persistedVariantProfile,
+        };
+    }
+    return { source: "none" };
+}
+const SELECTOR_MEMORY_SCOPE_DELIMITER = "::";
+function sanitizeSelectorMemoryScopePart(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+function buildScopedSelectorMemorySignature(scopeKey, stepSignature) {
+    return `${scopeKey}${SELECTOR_MEMORY_SCOPE_DELIMITER}${stepSignature}`;
+}
+function parseScopedSelectorMemorySignature(signature) {
+    const delimiterIndex = signature.indexOf(SELECTOR_MEMORY_SCOPE_DELIMITER);
+    if (delimiterIndex <= 0)
+        return null;
+    return {
+        scopeKey: signature.slice(0, delimiterIndex),
+        stepSignature: signature.slice(delimiterIndex + SELECTOR_MEMORY_SCOPE_DELIMITER.length),
+    };
+}
+function shouldKeepSelectorMemoryGlobal(signature) {
+    return signature === "menu:primary"
+        || signature === "account:menu"
+        || signature === "search:field"
+        || signature.startsWith("login:")
+        || signature.startsWith("lang:")
+        || signature.startsWith("theme:");
+}
+function shouldSuppressGenericSelectorMemory(signature, hasScopedContext) {
+    return hasScopedContext && signature.startsWith("nav:");
+}
+export function buildSelectorMemoryScopeKeys(context) {
+    if (!context)
+        return [];
+    const scopeKeys = [];
+    const origin = getUrlOrigin(context.pageUrl);
+    if (origin) {
+        const normalizedOrigin = sanitizeSelectorMemoryScopePart(origin.replace(/^https?:\/\//i, ""));
+        if (normalizedOrigin) {
+            scopeKeys.push(`origin:${normalizedOrigin}`);
+        }
+    }
+    const normalizedPageId = sanitizeSelectorMemoryScopePart(context.pageId ?? "main");
+    if (normalizedPageId) {
+        scopeKeys.push(`page:${normalizedPageId}`);
+    }
+    const identityKind = context.pageIdentity?.kind && context.pageIdentity.kind !== "unknown"
+        ? sanitizeSelectorMemoryScopePart(context.pageIdentity.kind)
+        : "";
+    if (identityKind) {
+        const subjectTokenKey = uniqueInOrder((context.pageIdentity?.subjectTokens ?? [])
+            .map((token) => sanitizeSelectorMemoryScopePart(token))
+            .filter(Boolean))
+            .slice(0, 3)
+            .join("-");
+        if (subjectTokenKey) {
+            scopeKeys.push(`identity:${identityKind}:${subjectTokenKey}`);
+        }
+        scopeKeys.push(`identity:${identityKind}`);
+    }
+    return uniqueInOrder(scopeKeys);
+}
+export function scopeSelectorMemoryUpdates(updates, context) {
+    const scopeKeys = buildSelectorMemoryScopeKeys(context);
+    if (scopeKeys.length === 0) {
+        return updates.map((update) => ({ ...update }));
+    }
+    const scopedUpdates = new Map();
+    for (const update of updates) {
+        const signature = update.stepSignature.trim();
+        const selector = update.selector.trim();
+        if (!signature || !selector)
+            continue;
+        const keepGlobal = shouldKeepSelectorMemoryGlobal(signature);
+        if (keepGlobal) {
+            scopedUpdates.set(`${signature}|${selector}|global`, {
+                ...update,
+                stepSignature: signature,
+                selector,
+            });
+        }
+        for (const scopeKey of scopeKeys) {
+            const scopedSignature = buildScopedSelectorMemorySignature(scopeKey, signature);
+            scopedUpdates.set(`${scopedSignature}|${selector}|${scopeKey}`, {
+                ...update,
+                stepSignature: scopedSignature,
+                selector,
+            });
+        }
+    }
+    return Array.from(scopedUpdates.values());
+}
+export function resolveScopedSelectorMemory(memory, context) {
+    if (!memory || Object.keys(memory).length === 0) {
+        return {};
+    }
+    const scopeKeys = buildSelectorMemoryScopeKeys(context);
+    const merged = {};
+    const appendSelectors = (signature, selectors) => {
+        for (const selector of selectors) {
+            const normalizedSelector = selector.trim();
+            if (!normalizedSelector)
+                continue;
+            if (!merged[signature]) {
+                merged[signature] = [];
+            }
+            if (!merged[signature].includes(normalizedSelector)) {
+                merged[signature].push(normalizedSelector);
+            }
+        }
+    };
+    for (const scopeKey of scopeKeys) {
+        for (const [signature, selectors] of Object.entries(memory)) {
+            const parsed = parseScopedSelectorMemorySignature(signature);
+            if (!parsed || parsed.scopeKey !== scopeKey)
+                continue;
+            appendSelectors(parsed.stepSignature, selectors);
+        }
+    }
+    for (const [signature, selectors] of Object.entries(memory)) {
+        if (parseScopedSelectorMemorySignature(signature))
+            continue;
+        if (shouldSuppressGenericSelectorMemory(signature, scopeKeys.length > 0))
+            continue;
+        appendSelectors(signature, selectors);
+    }
+    return merged;
+}
+export function mergeSelectorMemory(...sources) {
+    const merged = {};
+    for (const source of sources) {
+        if (!source)
+            continue;
+        for (const [signature, selectors] of Object.entries(source)) {
+            for (const selector of selectors) {
+                const normalizedSelector = selector.trim();
+                if (!normalizedSelector)
+                    continue;
+                if (!merged[signature]) {
+                    merged[signature] = [];
+                }
+                if (!merged[signature].includes(normalizedSelector)) {
+                    merged[signature].push(normalizedSelector);
+                }
+            }
+        }
+    }
+    return merged;
+}
+export function applySelectorMemoryUpdates(current, updates) {
+    const fresh = {};
+    for (const update of updates) {
+        if (!update.success)
+            continue;
+        const signature = update.stepSignature.trim();
+        const selector = update.selector.trim();
+        if (!signature || !selector)
+            continue;
+        if (!fresh[signature]) {
+            fresh[signature] = [];
+        }
+        if (!fresh[signature].includes(selector)) {
+            fresh[signature].push(selector);
+        }
+    }
+    return mergeSelectorMemory(fresh, current);
+}
+//# sourceMappingURL=capture-run-optimizer.js.map