autokap 1.0.6 → 1.0.8

package/dist/capture-alt-text.d.ts

@@ -0,0 +1,12 @@
+interface GenerateAltTextParams {
+    url: string;
+    prompt: string;
+    lang: string;
+    theme: 'light' | 'dark';
+    targetLabel?: string;
+    elementName?: string;
+    model: string;
+    apiKey: string;
+}
+export declare function generateAltText(params: GenerateAltTextParams): Promise<string | null>;
+export {};

package/dist/capture-alt-text.js

@@ -0,0 +1,52 @@
+import { zdrParam } from './provider-config.js';
+export async function generateAltText(params) {
+    const { url, prompt, lang, theme, targetLabel, elementName, model, apiKey } = params;
+    const contextParts = [
+        `URL: ${url}`,
+        `Capture intent: "${prompt}"`,
+        `Theme: ${theme}`,
+    ];
+    if (targetLabel)
+        contextParts.push(`Device: ${targetLabel}`);
+    if (elementName)
+        contextParts.push(`Isolated element: ${elementName}`);
+    const systemPrompt = `You generate concise alt text for web page screenshots, for accessibility purposes.
+Write in ${lang}. Output ONLY the alt text, nothing else. Keep it under 150 characters.
+Describe what the screenshot represents based on the context provided.`;
+    try {
+        const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+                'HTTP-Referer': 'https://autokap.app',
+                'X-Title': 'Screenshot Agent',
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: 100,
+                stream: false,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: contextParts.join('\n') },
+                ],
+                provider: { ...zdrParam() },
+            }),
+            signal: AbortSignal.timeout(5_000),
+        });
+        if (!res.ok) {
+            console.warn(`[generate-alt-text] LLM call failed: HTTP ${res.status}`);
+            return null;
+        }
+        const json = (await res.json());
+        const content = json.choices?.[0]?.message?.content?.trim();
+        if (!content)
+            return null;
+        return content.replace(/^["']|["']$/g, '');
+    }
+    catch {
+        console.warn('[generate-alt-text] ALT text generation failed');
+        return null;
+    }
+}
+//# sourceMappingURL=capture-alt-text.js.map

package/dist/capture-encryption.d.ts

@@ -0,0 +1,10 @@
+export interface EncryptedEnvelope {
+    __encrypted: true;
+    version: 1;
+    iv: string;
+    tag: string;
+    ciphertext: string;
+}
+export declare function encrypt(plaintext: string, secret: string): EncryptedEnvelope;
+export declare function decrypt(envelope: EncryptedEnvelope, secret: string): string;
+export declare function isEncryptedEnvelope(value: unknown): value is EncryptedEnvelope;

package/dist/capture-encryption.js

@@ -0,0 +1,41 @@
+import crypto from 'node:crypto';
+function deriveKey(secret) {
+    return crypto.createHash('sha256').update(secret).digest();
+}
+export function encrypt(plaintext, secret) {
+    const key = deriveKey(secret);
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    const ciphertext = Buffer.concat([
+        cipher.update(plaintext, 'utf8'),
+        cipher.final(),
+    ]);
+    const tag = cipher.getAuthTag();
+    return {
+        __encrypted: true,
+        version: 1,
+        iv: iv.toString('base64'),
+        tag: tag.toString('base64'),
+        ciphertext: ciphertext.toString('base64'),
+    };
+}
+export function decrypt(envelope, secret) {
+    const key = deriveKey(secret);
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, Buffer.from(envelope.iv, 'base64'));
+    decipher.setAuthTag(Buffer.from(envelope.tag, 'base64'));
+    return Buffer.concat([
+        decipher.update(Buffer.from(envelope.ciphertext, 'base64')),
+        decipher.final(),
+    ]).toString('utf8');
+}
+export function isEncryptedEnvelope(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (candidate.__encrypted === true
+        && candidate.version === 1
+        && typeof candidate.iv === 'string'
+        && typeof candidate.tag === 'string'
+        && typeof candidate.ciphertext === 'string');
+}
+//# sourceMappingURL=capture-encryption.js.map

package/dist/capture-language-preflight.d.ts

@@ -0,0 +1,41 @@
+import type { Browser } from "./browser.js";
+import { type RequestedLanguageState, type RequestedThemeState } from "./session-profile.js";
+import type { AgentResult, LoginCredentials, StepUsage, ValidatedSessionProfile, VideoPageSignals } from "./types.js";
+import { type ScreenshotSelectorMemoryUpdate } from "./capture-selector-memory.js";
+interface LanguageObservation {
+    currentUrl: string;
+    signals: VideoPageSignals | null;
+    languageState: RequestedLanguageState | null;
+    themeState: RequestedThemeState | null;
+}
+export interface ScreenshotLanguagePreflightResult {
+    ok: boolean;
+    resolvedBy: "already_active" | "deterministic_repair" | "language_preflight_agent" | "blocked";
+    observation: LanguageObservation;
+    usage: StepUsage[];
+    selectorUpdates: ScreenshotSelectorMemoryUpdate[];
+    rebasedToStartUrl: boolean;
+    reason?: string;
+}
+export declare function ensureScreenshotVariantLanguage(params: {
+    browser: Browser;
+    requestedLang: string;
+    requestedTheme: "light" | "dark";
+    startUrl?: string;
+    profile?: ValidatedSessionProfile;
+    credentials?: LoginCredentials;
+    selectorMemory?: Record<string, string[]>;
+    langInstructions?: string;
+    themeInstructions?: string;
+    onLog?: (message: string) => void;
+    performRepair?: () => Promise<{
+        repaired: boolean;
+        updates: ScreenshotSelectorMemoryUpdate[];
+    } | null>;
+    rebaseToStartUrl?: (currentUrl: string, startUrl: string) => Promise<void>;
+    runLanguageSwitchAgent?: (state: {
+        languageState: RequestedLanguageState | null;
+        themeState: RequestedThemeState | null;
+    }) => Promise<AgentResult | null>;
+}): Promise<ScreenshotLanguagePreflightResult>;
+export {};

package/dist/capture-language-preflight.js

@@ -0,0 +1,300 @@
+import { evaluateRequestedLanguageState, evaluateRequestedThemeState, performDeterministicSessionRepair, } from "./session-profile.js";
+import { extractSelectorUpdates, } from "./capture-selector-memory.js";
+import { isCaptureStepTimeoutError, withCaptureStepTimeout, } from "./capture-step-timeout.js";
+import { urlMatchesCaptureTarget } from "./capture-run-optimizer.js";
+const LANGUAGE_OBSERVATION_TIMEOUT_MS = 12000;
+const LANGUAGE_REPAIR_TIMEOUT_MS = 15000;
+const LANGUAGE_STABILITY_DELAY_MS = 900;
+function urlsRoughlyMatch(expectedUrl, currentUrl) {
+    if (!expectedUrl || !currentUrl)
+        return false;
+    return urlMatchesCaptureTarget(currentUrl, expectedUrl) || urlMatchesCaptureTarget(expectedUrl, currentUrl);
+}
+async function waitForVariantStability(browser, delayMs) {
+    if (typeof browser.wait === "function") {
+        await browser.wait(delayMs);
+        return;
+    }
+    const pageWait = browser.currentPage.waitForTimeout;
+    if (typeof pageWait === "function") {
+        await pageWait.call(browser.currentPage, delayMs);
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function summarizeRequestedLanguageState(state) {
+    if (!state)
+        return "language_state=unavailable";
+    return [
+        state.requested ? `requested=${state.requested}` : null,
+        state.detected ? `detected=${state.detected}` : "detected=unknown",
+        `ambiguous=${state.ambiguous}`,
+        ...state.reasons.slice(0, 3),
+    ]
+        .filter(Boolean)
+        .join("; ");
+}
+function summarizeRequestedThemeState(state) {
+    if (!state)
+        return "theme_state=unavailable";
+    return [
+        state.requested ? `requested=${state.requested}` : null,
+        state.detected ? `detected=${state.detected}` : "detected=unknown",
+        `ambiguous=${state.ambiguous}`,
+        ...state.reasons.slice(0, 3),
+    ]
+        .filter(Boolean)
+        .join("; ");
+}
+function summarizeVariantObservation(observation) {
+    return [
+        summarizeRequestedLanguageState(observation.languageState),
+        summarizeRequestedThemeState(observation.themeState),
+    ].join(" | ");
+}
+function isObservationReady(observation) {
+    const languageReady = !!(observation.languageState?.active
+        && !observation.languageState.ambiguous);
+    const themeReady = !!(observation.themeState?.active
+        && !observation.themeState.ambiguous);
+    return languageReady && themeReady;
+}
+function buildFailureReason(requestedLang, requestedTheme, observation) {
+    const failures = [];
+    if (!observation.languageState) {
+        failures.push(`unable to inspect the current UI language for "${requestedLang}"`);
+    }
+    else if (!observation.languageState.active || observation.languageState.ambiguous) {
+        failures.push(`requested "${requestedLang}", detected "${observation.languageState.detected ?? "unknown"}" (${observation.languageState.reasons.join("; ")})`);
+    }
+    if (!observation.themeState) {
+        failures.push(`unable to inspect the current UI theme for "${requestedTheme}"`);
+    }
+    else if (!observation.themeState.active || observation.themeState.ambiguous) {
+        failures.push(`theme requested "${requestedTheme}", detected "${observation.themeState.detected ?? "unknown"}" (${observation.themeState.reasons.join("; ")})`);
+    }
+    if (failures.length === 0) {
+        return "";
+    }
+    return `Language preflight failed: ${failures.join(" | ")}.`;
+}
+async function observeLanguageState(browser, requestedLang, params) {
+    const currentUrl = browser.currentPage.url();
+    const phase = params?.phase ?? "inspection";
+    params?.onLog?.(`Language guard: inspecting fixed UI chrome during ${phase}.`);
+    const signals = await withCaptureStepTimeout(() => browser.capturePageSignals(), {
+        stepLabel: `inspecting fixed UI chrome during ${phase}`,
+        timeoutMs: LANGUAGE_OBSERVATION_TIMEOUT_MS,
+    }).catch((error) => {
+        if (isCaptureStepTimeoutError(error)) {
+            params?.onLog?.(`Language guard: fixed UI inspection timed out after ${error.timeoutMs}ms during ${phase}.`);
+            return null;
+        }
+        params?.onLog?.(`Language guard: fixed UI inspection failed during ${phase} (${error instanceof Error ? error.message : String(error)}).`);
+        return null;
+    });
+    return {
+        currentUrl,
+        signals,
+        languageState: signals
+            ? evaluateRequestedLanguageState({
+                currentUrl,
+                requestedLang,
+                signals,
+            })
+            : null,
+        themeState: signals
+            ? evaluateRequestedThemeState({
+                requestedTheme: params?.requestedTheme,
+                signals,
+            })
+            : null,
+    };
+}
+async function confirmStableLanguageState(params) {
+    if (!isObservationReady(params.observation)) {
+        return params.observation;
+    }
+    params.onLog?.(`Language guard: waiting ${LANGUAGE_STABILITY_DELAY_MS}ms to confirm the variant remains stable during ${params.phase}.`);
+    await waitForVariantStability(params.browser, LANGUAGE_STABILITY_DELAY_MS);
+    return observeLanguageState(params.browser, params.requestedLang, {
+        onLog: params.onLog,
+        phase: `${params.phase} stability verification`,
+        requestedTheme: params.requestedTheme,
+    });
+}
+export async function ensureScreenshotVariantLanguage(params) {
+    const usage = [];
+    const selectorUpdates = [];
+    const requestedLang = params.requestedLang.trim().toLowerCase();
+    let rebasedToStartUrl = false;
+    const rebaseIfNeeded = async (observation) => {
+        if (!params.startUrl
+            || !params.rebaseToStartUrl
+            || urlsRoughlyMatch(params.startUrl, observation.currentUrl)) {
+            return observation;
+        }
+        params.onLog?.(`Language guard: rebasing back to ${params.startUrl} after language switch from ${observation.currentUrl}.`);
+        await params.rebaseToStartUrl(observation.currentUrl, params.startUrl);
+        rebasedToStartUrl = true;
+        return observeLanguageState(params.browser, requestedLang, {
+            onLog: params.onLog,
+            phase: "post-rebase verification",
+            requestedTheme: params.requestedTheme,
+        });
+    };
+    let observation = await observeLanguageState(params.browser, requestedLang, {
+        onLog: params.onLog,
+        phase: "initial preflight",
+        requestedTheme: params.requestedTheme,
+    });
+    if (isObservationReady(observation)) {
+        return {
+            ok: true,
+            resolvedBy: "already_active",
+            observation,
+            usage,
+            selectorUpdates,
+            rebasedToStartUrl,
+        };
+    }
+    params.onLog?.(`Language guard: requested variant "${requestedLang}/${params.requestedTheme}" is not active yet; ${summarizeVariantObservation(observation)}.`);
+    params.onLog?.("Language guard: running deterministic variant repair before the main workflow.");
+    const repair = await withCaptureStepTimeout(async () => (params.performRepair
+        ?? (async () => {
+            const result = await performDeterministicSessionRepair(params.browser, {
+                startUrl: params.startUrl,
+                requestedLang,
+                requestedTheme: params.requestedTheme,
+                credentials: params.credentials,
+                profile: params.profile,
+                selectorMemory: params.selectorMemory,
+            }).catch(() => null);
+            return result
+                ? {
+                    repaired: result.repaired,
+                    updates: result.updates.map((update) => ({
+                        ...update,
+                        source: "deterministic",
+                    })),
+                }
+                : null;
+        }))(), {
+        stepLabel: "running deterministic variant repair",
+        timeoutMs: LANGUAGE_REPAIR_TIMEOUT_MS,
+    }).catch((error) => {
+        if (isCaptureStepTimeoutError(error)) {
+            params.onLog?.(`Language guard: deterministic repair timed out after ${error.timeoutMs}ms.`);
+            return null;
+        }
+        params.onLog?.(`Language guard: deterministic repair failed (${error instanceof Error ? error.message : String(error)}).`);
+        return null;
+    });
+    if (repair?.updates.length) {
+        selectorUpdates.push(...repair.updates);
+    }
+    observation = await observeLanguageState(params.browser, requestedLang, {
+        onLog: params.onLog,
+        phase: "post-repair verification",
+        requestedTheme: params.requestedTheme,
+    });
+    if (isObservationReady(observation)) {
+        observation = await rebaseIfNeeded(observation);
+        observation = await confirmStableLanguageState({
+            browser: params.browser,
+            requestedLang,
+            requestedTheme: params.requestedTheme,
+            observation,
+            onLog: params.onLog,
+            phase: "post-deterministic-repair",
+        });
+    }
+    if (isObservationReady(observation)) {
+        params.onLog?.(`Language guard: fixed UI variant switched successfully after deterministic repair; ${summarizeVariantObservation(observation)}.`);
+        return {
+            ok: true,
+            resolvedBy: "deterministic_repair",
+            observation,
+            usage,
+            selectorUpdates,
+            rebasedToStartUrl,
+        };
+    }
+    if (!params.runLanguageSwitchAgent) {
+        const reason = buildFailureReason(requestedLang, params.requestedTheme, observation);
+        params.onLog?.(`Language guard: blocking variant before main workflow. ${reason}`);
+        return {
+            ok: false,
+            resolvedBy: "blocked",
+            observation,
+            usage,
+            selectorUpdates,
+            rebasedToStartUrl,
+            reason,
+        };
+    }
+    params.onLog?.(`Language guard: deterministic repair was insufficient; launching dedicated variant preflight. ${summarizeVariantObservation(observation)}.`);
+    const preflightAgentResult = await params.runLanguageSwitchAgent({
+        languageState: observation.languageState,
+        themeState: observation.themeState,
+    }).catch(() => null);
+    if (preflightAgentResult?.usage?.length) {
+        usage.push(...preflightAgentResult.usage);
+    }
+    if (preflightAgentResult?.actions?.length) {
+        selectorUpdates.push(...extractSelectorUpdates(preflightAgentResult.actions));
+    }
+    observation = await observeLanguageState(params.browser, requestedLang, {
+        onLog: params.onLog,
+        phase: "post-variant-switch verification",
+        requestedTheme: params.requestedTheme,
+    });
+    if (isObservationReady(observation)) {
+        observation = await rebaseIfNeeded(observation);
+        observation = await confirmStableLanguageState({
+            browser: params.browser,
+            requestedLang,
+            requestedTheme: params.requestedTheme,
+            observation,
+            onLog: params.onLog,
+            phase: "post-variant-switch",
+        });
+    }
+    if (isObservationReady(observation)) {
+        params.onLog?.(`Language guard: fixed UI variant switched successfully after dedicated variant preflight. ${summarizeVariantObservation(observation)}.`);
+        return {
+            ok: true,
+            resolvedBy: "language_preflight_agent",
+            observation,
+            usage,
+            selectorUpdates,
+            rebasedToStartUrl,
+        };
+    }
+    // Trust the agent when it succeeded (verification passed) but metadata signals
+    // still disagree. This handles SPAs and sites that don't update <html lang> or
+    // locale controls after client-side navigation (e.g., /en/ with lang="fr-FR").
+    if (preflightAgentResult?.success) {
+        params.onLog?.(`Language guard: metadata signals still disagree but variant preflight agent succeeded — trusting agent assessment. ${summarizeVariantObservation(observation)}.`);
+        return {
+            ok: true,
+            resolvedBy: "language_preflight_agent",
+            observation,
+            usage,
+            selectorUpdates,
+            rebasedToStartUrl,
+        };
+    }
+    const reason = buildFailureReason(requestedLang, params.requestedTheme, observation);
+    params.onLog?.(`Language guard: blocking variant before main workflow. ${reason}`);
+    return {
+        ok: false,
+        resolvedBy: "blocked",
+        observation,
+        usage,
+        selectorUpdates,
+        rebasedToStartUrl,
+        reason,
+    };
+}
+//# sourceMappingURL=capture-language-preflight.js.map

package/dist/capture-llm-page-identity.d.ts

@@ -0,0 +1,15 @@
+import type { CapturePageIdentity, StepUsage } from "./types.js";
+import type { ScreenshotPageRunInput } from "./capture-run-optimizer.js";
+export interface PageIdentityInferenceResult {
+    identities: Record<string, CapturePageIdentity>;
+    usage: StepUsage | null;
+}
+/**
+ * Use a cheap LLM call to classify all pages in a capture run.
+ * Falls back to regex heuristics if the LLM call fails.
+ */
+export declare function inferPageIdentitiesWithLLM(pageRuns: ScreenshotPageRunInput[], model: string, apiKey: string, providerPrefs?: Record<string, {
+    order?: string[];
+    require?: string[];
+    disallow?: string[];
+}>): Promise<PageIdentityInferenceResult>;

package/dist/capture-llm-page-identity.js

@@ -0,0 +1,128 @@
+import { buildCapturePageIdentitySummary, inferCapturePageIdentity, normalizeCaptureIdentityTokens, } from "./capture-page-identity.js";
+import { zdrParam } from "./provider-config.js";
+/**
+ * Use a cheap LLM call to classify all pages in a capture run.
+ * Falls back to regex heuristics if the LLM call fails.
+ */
+export async function inferPageIdentitiesWithLLM(pageRuns, model, apiKey, providerPrefs) {
+    // Regex fallback for all pages
+    const regexFallback = Object.fromEntries(pageRuns.map((pr) => [pr.pageId ?? "main", inferCapturePageIdentity(pr)]));
+    if (pageRuns.length === 0) {
+        return { identities: regexFallback, usage: null };
+    }
+    const pagesDescription = pageRuns.map((pr, i) => {
+        const pageId = pr.pageId ?? "main";
+        return `${i + 1}. pageId="${pageId}" | url="${pr.url}" | prompt="${pr.prompt}"`;
+    }).join("\n");
+    const systemPrompt = `You classify web page capture targets for a screenshot automation tool.
+
+IMPORTANT: The "pageId" is a user-defined identifier — it is NOT a technical description. Do NOT infer the page type from the pageId name alone. A page named "preset_creation_modal" might actually be a sidebar panel, not a DOM dialog. Base your classification on the PROMPT text and URL, not the pageId.
+
+For each page, determine:
+- "kind": one of "gallery", "modal_selection", "modal_configuration", "editor_route", "detail_route", "unknown"
+  - "gallery": a non-modal overview/list/grid/collection page
+  - "modal_selection": the prompt explicitly describes opening a dialog/modal/popup to pick or select something
+  - "modal_configuration": the prompt explicitly describes opening a dialog/modal/popup to configure or edit something
+  - "editor_route": a dedicated full-page destination with its own route
+  - "detail_route": a non-modal detail/content state that is not just a generic overview
+  - "unknown": none of the above
+- "dialogTarget": true ONLY if the prompt explicitly says to open an actual DOM dialog, modal, or popup overlay. Set to FALSE for: sidebar panels, drawers, slide-over panels, full pages, dropdown menus, popovers, or any UI that is part of the main page layout. When in doubt, set to false.
+- "dedicatedRoute": true if the capture target has its own URL route (not just a modal on top of another page)
+- "subjectTokens": 2-6 short semantic tokens that describe the FINAL visible capture target. Exclude navigation verbs and chrome words such as: click, open, wait, sidebar, header, page, route, menu, button, first, current.
+
+Respond with a JSON array of objects: [{ "pageId": "...", "kind": "...", "dialogTarget": true/false, "dedicatedRoute": true/false, "subjectTokens": ["...", "..."] }]
+Output ONLY valid JSON, nothing else.`;
+    try {
+        const providerBody = { provider: { ...providerPrefs?.[model], ...zdrParam() } };
+        const res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+                "HTTP-Referer": "https://github.com/screenshot-agent",
+                "X-Title": "Screenshot Agent",
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: 512,
+                stream: false,
+                response_format: { type: "json_object" },
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: `Classify these ${pageRuns.length} page capture targets:\n\n${pagesDescription}` },
+                ],
+                ...providerBody,
+            }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok) {
+            console.warn(`[llm-page-identity] LLM call failed: HTTP ${res.status}`);
+            return { identities: regexFallback, usage: null };
+        }
+        const json = await res.json();
+        const content = json.choices?.[0]?.message?.content?.trim();
+        const usage = {
+            stepNumber: 0,
+            stepType: "page_identity_classification",
+            generationId: json.id ?? null,
+            modelRequested: model,
+            modelUsed: json.model ?? null,
+            promptTokens: json.usage?.prompt_tokens ?? null,
+            completionTokens: json.usage?.completion_tokens ?? null,
+            totalTokens: json.usage?.total_tokens ?? null,
+            imagesInPrompt: 0,
+        };
+        if (!content)
+            return { identities: regexFallback, usage };
+        // Parse — handle both array and { pages: [...] } wrapper
+        let classifications;
+        const parsed = JSON.parse(content);
+        if (Array.isArray(parsed)) {
+            classifications = parsed;
+        }
+        else if (Array.isArray(parsed.pages)) {
+            classifications = parsed.pages;
+        }
+        else if (Array.isArray(parsed.classifications)) {
+            classifications = parsed.classifications;
+        }
+        else {
+            console.warn("[llm-page-identity] Unexpected LLM response shape:", content.slice(0, 200));
+            return { identities: regexFallback, usage };
+        }
+        // Merge LLM results with regex fallback (LLM wins, regex fills gaps)
+        const result = { ...regexFallback };
+        for (const cls of classifications) {
+            const pageId = cls.pageId;
+            if (!pageId || !result[pageId])
+                continue;
+            const validKinds = [
+                "gallery", "modal_selection", "modal_configuration", "editor_route", "detail_route", "unknown",
+            ];
+            const kind = validKinds.includes(cls.kind) ? cls.kind : result[pageId].kind;
+            const subjectTokens = normalizeCaptureIdentityTokens(cls.subjectTokens ?? []);
+            result[pageId] = {
+                ...result[pageId],
+                kind,
+                subjectTokens: subjectTokens.length > 0 ? subjectTokens : result[pageId].subjectTokens,
+                dialogTarget: typeof cls.dialogTarget === "boolean" ? cls.dialogTarget : result[pageId].dialogTarget,
+                dedicatedRoute: typeof cls.dedicatedRoute === "boolean" ? cls.dedicatedRoute : result[pageId].dedicatedRoute,
+                summary: buildCapturePageIdentitySummary(kind, subjectTokens.length > 0 ? subjectTokens : result[pageId].subjectTokens, (() => {
+                    try {
+                        const pageRun = pageRuns.find((pr) => (pr.pageId ?? "main") === pageId);
+                        return new URL(pageRun?.url ?? "").pathname.toLowerCase();
+                    }
+                    catch {
+                        return "/";
+                    }
+                })()),
+            };
+        }
+        return { identities: result, usage };
+    }
+    catch (err) {
+        console.warn(`[llm-page-identity] LLM classification failed, using regex fallback:`, err instanceof Error ? err.message : err);
+        return { identities: regexFallback, usage: null };
+    }
+}
+//# sourceMappingURL=capture-llm-page-identity.js.map

package/dist/capture-model-resolution.d.ts

@@ -0,0 +1,9 @@
+export declare function resolveRunModels(params: {
+    requestModel?: string | null;
+    defaultModel?: string | null;
+    fallbackModel?: string | null;
+    presetId?: string | null;
+}): {
+    model: string;
+    fallbackModel?: string;
+};

package/dist/capture-model-resolution.js

@@ -0,0 +1,21 @@
+function normalizeModelId(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export function resolveRunModels(params) {
+    const requestModel = normalizeModelId(params.requestModel);
+    const defaultModel = normalizeModelId(params.defaultModel);
+    const fallbackModel = normalizeModelId(params.fallbackModel);
+    const preferAdminModel = Boolean(params.presetId && (defaultModel || fallbackModel));
+    const model = (preferAdminModel
+        ? defaultModel ?? fallbackModel ?? requestModel
+        : requestModel ?? defaultModel ?? fallbackModel)
+        ?? '';
+    return {
+        model,
+        fallbackModel: fallbackModel && fallbackModel !== model ? fallbackModel : undefined,
+    };
+}
+//# sourceMappingURL=capture-model-resolution.js.map

package/dist/capture-page-identity.d.ts

@@ -0,0 +1,7 @@
+import type { CapturePageIdentity, CapturePageIdentityKind } from "./types.js";
+import type { ScreenshotPageRunInput } from "./capture-run-optimizer.js";
+export declare function normalizeCaptureIdentityTokens(values: Array<string | null | undefined>, options?: {
+    stopWords?: ReadonlySet<string>;
+}): string[];
+export declare function buildCapturePageIdentitySummary(kind: CapturePageIdentityKind, tokens: string[], urlPath: string): string;
+export declare function inferCapturePageIdentity(pageRun: ScreenshotPageRunInput): CapturePageIdentity;