autokap 1.0.7 → 1.0.8

package/dist/capture-preset-credentials.js

@@ -37,21 +37,148 @@ export function decryptPresetCredentials(value) {
     }
     return normalizePresetCredentials(value);
 }
+export function normalizePresetAuthCookies(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const cleaned = [];
+    for (const entry of value) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const candidate = entry;
+        const name = typeof candidate.name === 'string' ? candidate.name.trim() : '';
+        const cookieValue = typeof candidate.value === 'string' ? candidate.value : '';
+        const domain = typeof candidate.domain === 'string' ? candidate.domain.trim().toLowerCase() : '';
+        if (!name || !cookieValue || !domain)
+            continue;
+        const path = typeof candidate.path === 'string' && candidate.path.trim()
+            ? candidate.path.trim()
+            : undefined;
+        cleaned.push({
+            name,
+            value: cookieValue,
+            domain,
+            ...(path ? { path } : {}),
+        });
+    }
+    return cleaned.length > 0 ? cleaned : undefined;
+}
+export function encryptPresetAuthCookies(cookies) {
+    return encrypt(JSON.stringify(cookies), getSecret());
+}
+export function decryptPresetAuthCookies(value) {
+    if (!value)
+        return undefined;
+    if (isEncryptedEnvelope(value)) {
+        const decrypted = decrypt(value, getSecret());
+        return normalizePresetAuthCookies(JSON.parse(decrypted));
+    }
+    return normalizePresetAuthCookies(value);
+}
+export function hasStoredAuthCookies(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    return raw.authCookies != null;
+}
+export function buildAuthCookiesMeta(cookies) {
+    const domainSet = new Set();
+    for (const cookie of cookies) {
+        if (cookie.domain)
+            domainSet.add(cookie.domain);
+    }
+    return {
+        count: cookies.length,
+        domains: Array.from(domainSet),
+    };
+}
+/**
+ * Normalize a Playwright storageState payload, dropping anything that doesn't
+ * match the expected shape. Returns undefined if the payload is empty (no
+ * cookies and no origin data).
+ */
+export function normalizeStorageState(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    const cookies = Array.isArray(candidate.cookies)
+        ? candidate.cookies
+            .filter((c) => !!c && typeof c === 'object' && typeof c.name === 'string' && typeof c.value === 'string' && typeof c.domain === 'string')
+            .map((c) => ({
+            name: c.name,
+            value: c.value,
+            domain: c.domain,
+            path: typeof c.path === 'string' ? c.path : '/',
+            expires: typeof c.expires === 'number' ? c.expires : -1,
+            httpOnly: !!c.httpOnly,
+            secure: !!c.secure,
+            sameSite: c.sameSite === 'Strict' || c.sameSite === 'Lax' || c.sameSite === 'None'
+                ? c.sameSite
+                : 'Lax',
+        }))
+        : [];
+    const origins = Array.isArray(candidate.origins)
+        ? candidate.origins
+            .filter((o) => !!o && typeof o === 'object' && typeof o.origin === 'string')
+            .map((o) => ({
+            origin: o.origin,
+            localStorage: Array.isArray(o.localStorage)
+                ? o.localStorage
+                    .filter((entry) => entry && typeof entry === 'object' && typeof entry.name === 'string')
+                    .map((entry) => ({ name: entry.name, value: typeof entry.value === 'string' ? entry.value : '' }))
+                : [],
+        }))
+        : [];
+    if (cookies.length === 0 && origins.length === 0)
+        return undefined;
+    return { cookies, origins };
+}
+export function encryptStorageState(state) {
+    return encrypt(JSON.stringify(state), getSecret());
+}
+export function decryptStorageState(value) {
+    if (!value)
+        return undefined;
+    if (isEncryptedEnvelope(value)) {
+        const decrypted = decrypt(value, getSecret());
+        return normalizeStorageState(JSON.parse(decrypted));
+    }
+    return normalizeStorageState(value);
+}
+export function summarizeStorageState(state) {
+    const domainSet = new Set();
+    for (const cookie of state.cookies) {
+        if (cookie.domain)
+            domainSet.add(cookie.domain);
+    }
+    return {
+        cookieCount: state.cookies.length,
+        originCount: state.origins.length,
+        domains: Array.from(domainSet),
+    };
+}
 export function preparePresetConfigForStorage(config) {
     const credentials = normalizePresetCredentials(config.credentials);
+    const authCookies = normalizePresetAuthCookies(config.authCookies);
     return {
         ...config,
         ...(credentials
             ? { credentials: encryptPresetCredentials(credentials) }
             : { credentials: undefined }),
+        ...(authCookies
+            ? {
+                authCookies: encryptPresetAuthCookies(authCookies),
+                authCookiesMeta: buildAuthCookiesMeta(authCookies),
+            }
+            : { authCookies: undefined, authCookiesMeta: undefined }),
     };
 }
 export function hydratePresetConfigFromStorage(raw) {
     const config = (raw && typeof raw === 'object' ? raw : {});
     const credentials = decryptPresetCredentials(config.credentials);
+    const authCookies = decryptPresetAuthCookies(config.authCookies);
     return {
         ...config,
         ...(credentials ? { credentials } : { credentials: undefined }),
+        ...(authCookies ? { authCookies } : { authCookies: undefined }),
     };
 }
 //# sourceMappingURL=capture-preset-credentials.js.map

package/dist/capture-request-plan.d.ts

@@ -1,5 +1,4 @@
 import { type ScreenshotPageRunInput, type ScreenshotVariantExecution } from "./capture-run-optimizer.js";
-import { findVariantPageDefinitionIssues } from "./capture-page-identity.js";
 export type CaptureTheme = "light" | "dark";
 export interface CaptureViewport {
     width: number;
@@ -40,9 +39,10 @@ export interface CaptureRequestPlan<TTarget extends CaptureTargetLike = CaptureT
     elements: TElement[];
     pageRuns: ScreenshotPageRunInput[];
     variantPlan: ScreenshotVariantExecution[];
-    pageDefinitionIssues: ReturnType<typeof findVariantPageDefinitionIssues>;
     requestedCaptureCount: number;
     totalCaptures: number;
+    /** Warnings about non-fatal issues (e.g. unknown device frames). */
+    warnings: string[];
 }
 export declare function hasNonEmptyCapturePrompt(prompt: string | null | undefined): boolean;
 export declare function getCapturePromptValidationError(input: Pick<CaptureRequestPlanInput, "url" | "prompt" | "pages">): string | null;

package/dist/capture-request-plan.js

@@ -1,11 +1,34 @@
 import { resolveDeviceFrameDescriptor, } from "./mockup.js";
 import { buildScreenshotVariantPlan, } from "./capture-run-optimizer.js";
-import { findVariantPageDefinitionIssues } from "./capture-page-identity.js";
 function normalizeViewportDimension(value) {
     if (!Number.isFinite(value))
         return 1;
     return Math.max(1, Math.round(value));
 }
+function viewportAspectRatio(viewport) {
+    return viewport.width / Math.max(1, viewport.height);
+}
+function shouldPreserveStoredDeviceViewport(storedViewport, resolvedViewport) {
+    const sameOrientation = (storedViewport.width >= storedViewport.height)
+        === (resolvedViewport.width >= resolvedViewport.height);
+    if (!sameOrientation) {
+        return false;
+    }
+    if (storedViewport.width > resolvedViewport.width
+        || storedViewport.height > resolvedViewport.height) {
+        return false;
+    }
+    const widthDelta = Math.abs(storedViewport.width - resolvedViewport.width);
+    const heightDelta = Math.abs(storedViewport.height - resolvedViewport.height);
+    const differsMeaningfully = widthDelta > 24 || heightDelta > 24;
+    if (!differsMeaningfully) {
+        return false;
+    }
+    const resolvedAspect = viewportAspectRatio(resolvedViewport);
+    const storedAspect = viewportAspectRatio(storedViewport);
+    const aspectDelta = Math.abs(storedAspect - resolvedAspect) / resolvedAspect;
+    return aspectDelta <= 0.015;
+}
 function getRequestedOrientation(target) {
     const orientation = target.mockupOptions?.orientation;
     return orientation === "portrait" || orientation === "landscape"
@@ -18,17 +41,18 @@ async function resolveDeviceViewport(deviceId, orientation) {
     });
     if (!descriptor)
         return null;
-    return {
-        label: descriptor.name,
-        viewport: {
-            width: normalizeViewportDimension(descriptor.screen.logicalWidth
-                - (descriptor.safeArea.left ?? 0)
-                - (descriptor.safeArea.right ?? 0)),
-            height: normalizeViewportDimension(descriptor.screen.logicalHeight
-                - descriptor.safeArea.top
-                - descriptor.safeArea.bottom),
-        },
+    // Compute viewport from screen dimensions minus safe areas.
+    // The device config's `viewport` field is NOT reliable (Supabase configs may
+    // store stale/wrong values like 400x740). Always compute from logicalWidth/Height.
+    const viewport = {
+        width: normalizeViewportDimension(descriptor.screen.logicalWidth
+            - (descriptor.safeArea.left ?? 0)
+            - (descriptor.safeArea.right ?? 0)),
+        height: normalizeViewportDimension(descriptor.screen.logicalHeight
+            - descriptor.safeArea.top
+            - descriptor.safeArea.bottom),
     };
+    return { label: descriptor.name, viewport };
 }
 export function hasNonEmptyCapturePrompt(prompt) {
     return typeof prompt === "string" && prompt.trim().length > 0;
@@ -122,9 +146,19 @@ export async function normalizeCaptureTargets(input) {
     }
     const deviceViewportCache = new Map();
     const resolvedTargets = await Promise.all(targets.map(async (target) => {
-        if (!target.deviceFrame)
+        if (!target.deviceFrame) {
+            console.log(`[capture-plan] target ${target.id}: no deviceFrame, keeping stored viewport ${target.viewport.width}x${target.viewport.height}`);
             return target;
-        const orientation = getRequestedOrientation(target);
+        }
+        let orientation = getRequestedOrientation(target);
+        // Fallback: infer orientation from stored viewport aspect ratio when
+        // mockupOptions.orientation is missing (e.g. legacy presets).
+        if (!orientation && target.viewport) {
+            orientation = target.viewport.height > target.viewport.width
+                ? "portrait"
+                : "landscape";
+            console.log(`[capture-plan] target ${target.id}: mockupOptions.orientation missing (mockupOptions=${JSON.stringify(target.mockupOptions)}), inferred "${orientation}" from stored viewport ${target.viewport.width}x${target.viewport.height}`);
+        }
         const cacheKey = `${target.deviceFrame}:${orientation ?? "default"}`;
         let pending = deviceViewportCache.get(cacheKey);
         if (!pending) {
@@ -132,8 +166,15 @@ export async function normalizeCaptureTargets(input) {
             deviceViewportCache.set(cacheKey, pending);
         }
         const resolved = await pending;
-        if (!resolved)
+        if (!resolved) {
+            console.log(`[capture-plan] target ${target.id} (${target.deviceFrame}): device NOT FOUND, keeping stored viewport ${target.viewport.width}x${target.viewport.height}`);
+            return { ...target, _deviceNotFound: true };
+        }
+        if (shouldPreserveStoredDeviceViewport(target.viewport, resolved.viewport)) {
+            console.log(`[capture-plan] target ${target.id} (${target.deviceFrame}): keeping custom viewport ${target.viewport.width}x${target.viewport.height} instead of native ${resolved.viewport.width}x${resolved.viewport.height}`);
             return target;
+        }
+        console.log(`[capture-plan] target ${target.id} (${target.deviceFrame}): resolved viewport ${resolved.viewport.width}x${resolved.viewport.height} (was ${target.viewport.width}x${target.viewport.height})`);
         return {
             ...target,
             viewport: resolved.viewport,
@@ -197,9 +238,16 @@ export async function resolveCaptureRequestPlan(input) {
         themes,
         pages: pageRuns,
     });
-    const pageDefinitionIssues = findVariantPageDefinitionIssues(pageRuns);
     const requestedCaptureCount = pageRuns.length * targets.length * langs.length * themes.length
         + elements.length * langs.length * themes.length;
+    // Collect warnings for device frames that could not be resolved
+    const warnings = [];
+    for (const target of targets) {
+        if (target._deviceNotFound) {
+            warnings.push(`Device frame "${target.deviceFrame}" not found — using stored viewport ${target.viewport.width}x${target.viewport.height} as fallback.`);
+            delete target._deviceNotFound;
+        }
+    }
     return {
         targets,
         outputScale,
@@ -208,9 +256,9 @@ export async function resolveCaptureRequestPlan(input) {
         elements,
         pageRuns,
         variantPlan,
-        pageDefinitionIssues,
         requestedCaptureCount,
         totalCaptures: requestedCaptureCount,
+        warnings,
     };
 }
 //# sourceMappingURL=capture-request-plan.js.map

package/dist/capture-run-optimizer.js

@@ -50,27 +50,27 @@ const ELEMENT_ASSIGNMENT_STOP_WORDS = new Set([
 ]);
 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,
+        element: /\b(gallery|grid|list|overview|results?|catalog|library|feed|table|items?|cards?|thumbnail|thumbnails)\b/i,
+        page: /\b(gallery|grid|list|overview|results?|catalog|library|feed|table|items?|cards?)\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,
+        element: /\b(edit|editor|editing|configuration|configure|settings?|preferences|details?|detail|instructions?|form|compose|customi[sz]e)\b/i,
+        page: /\b(edit|editor|editing|configuration|configure|settings?|preferences|details?|detail|instructions?|form|compose|customi[sz]e)\b/i,
         score: 5,
     },
     {
-        element: /\b(assistant|chat|conversation|prompt ia|ai assistant)\b/i,
-        page: /\b(assistant|chat|conversation)\b/i,
+        element: /\b(assistant|chat|conversation|message|messages|inbox|thread)\b/i,
+        page: /\b(assistant|chat|conversation|message|messages|inbox|thread)\b/i,
         score: 5,
     },
     {
-        element: /\b(home|homepage|dashboard|accueil)\b/i,
-        page: /\b(home|homepage|dashboard|accueil)\b/i,
+        element: /\b(home|homepage|landing|dashboard|welcome|overview|accueil)\b/i,
+        page: /\b(home|homepage|landing|dashboard|welcome|overview|accueil)\b/i,
         score: 4,
     },
 ];
-const MODAL_CAPTURE_RE = /\b(modal|dialog|popup|drawer|template|picker|gallery|selection|select|choose)\b/i;
+const MODAL_CAPTURE_RE = /\b(modal|dialog|popup|drawer|overlay|selection|select|choose|pick|picker)\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) {
@@ -140,24 +140,24 @@ function inferCaptureIntent(values) {
         tokens: normalizeNavigationTokens(values),
         modalSelection: MODAL_CAPTURE_RE.test(joined),
         configuration: CONFIG_CAPTURE_RE.test(joined),
-        domain: inferCaptureDomain(joined),
+        structure: inferCaptureStructure(joined),
     };
 }
-function inferCaptureDomain(value) {
+function inferCaptureStructure(value) {
     if (/\b(assistant|chat|conversation|copilot|prompt ia|ai assistant)\b/i.test(value)) {
-        return "assistant";
+        return "conversation";
     }
-    if (/\b(gallery|screenshots?|captures?|thumbnail|download all|filter by preset)\b/i.test(value)) {
-        return "gallery";
+    if (/\b(gallery|grid|list|overview|results?|catalog|library|feed|table|items?|cards?|screenshots?|captures?|thumbnail)\b/i.test(value)) {
+        return "overview";
     }
-    if (/\b(preset|template|editor|mockup|instructions?|configuration|configure)\b/i.test(value)) {
-        return "preset";
+    if (/\b(edit|editor|detail|details|instructions?|configuration|configure|form|compose|customi[sz]e)\b/i.test(value)) {
+        return "detail";
     }
     if (/\b(settings|preferences|appearance|language|theme|param[eè]tres)\b/i.test(value)) {
-        return "settings";
+        return "preferences";
     }
-    if (/\b(home|homepage|dashboard|accueil)\b/i.test(value)) {
-        return "home";
+    if (/\b(home|homepage|landing|dashboard|welcome|accueil)\b/i.test(value)) {
+        return "landing";
     }
     return "unknown";
 }
@@ -212,9 +212,14 @@ export function urlsShareOrigin(left, right) {
 }
 export function resolveCaptureResumeUrl(params) {
     const normalizedPageId = params.pageId ?? "main";
-    const checkpoint = [...params.checkpoints]
-        .reverse()
-        .find((entry) => entry.pageId === normalizedPageId);
+    const checkpoints = [...params.checkpoints].reverse();
+    const checkpoint = checkpoints.find((entry) => entry.pageId === normalizedPageId);
+    const sameOriginCheckpoint = checkpoints.find((entry) => entry.pageId !== normalizedPageId
+        && [
+            entry.resumeUrl,
+            entry.url,
+            entry.canonicalUrl,
+        ].some((candidate) => urlsShareOrigin(candidate, params.pageUrl)));
     const candidates = [
         params.cursorResumeUrl,
         checkpoint?.resumeUrl,
@@ -223,7 +228,11 @@ export function resolveCaptureResumeUrl(params) {
         params.currentUrl,
         params.sessionProfile?.lastKnownUrl,
         params.sessionProfile?.validatedStartUrl,
-        params.pageUrl,
+    ];
+    const sameOriginCheckpointCandidates = [
+        sameOriginCheckpoint?.resumeUrl,
+        sameOriginCheckpoint?.url,
+        sameOriginCheckpoint?.canonicalUrl,
     ];
     for (const candidate of candidates) {
         if (!candidate)
@@ -232,6 +241,12 @@ export function resolveCaptureResumeUrl(params) {
             return candidate;
     }
     if (params.pageIndex > 0) {
+        for (const candidate of sameOriginCheckpointCandidates) {
+            if (!candidate)
+                continue;
+            if (urlsShareOrigin(candidate, params.pageUrl))
+                return candidate;
+        }
         for (const candidate of candidates) {
             if (!candidate)
                 continue;
@@ -344,7 +359,7 @@ export function shouldReuseLivePageState(params) {
     if (!currentOrigin || !pageOrigin || currentOrigin !== pageOrigin) {
         return false;
     }
-    // Only skip the reset when the page uses the preset root URL.
+    // Only skip the reset when the page uses the shared root URL for the flow.
     // Explicit per-page URLs still navigate directly for determinism.
     return params.pageUrl === params.presetRootUrl;
 }
@@ -507,10 +522,10 @@ export function buildVisibleControlNavigationPlan(params) {
         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)) {
+        if (/\b(edit|editor|detail|details|configuration|configure|settings?|preferences|form)\b/i.test(`${params.pageId ?? ""} ${params.prompt}`) && /\b(edit|editor|detail|details|configuration|configure|settings?|preferences|form)\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)) {
+        if (/\b(gallery|grid|list|overview|results?|catalog|library|feed|table|items?|cards?|capture|captures|screenshot|screenshots)\b/i.test(`${params.pageId ?? ""} ${params.prompt}`) && /\b(gallery|grid|list|overview|results?|catalog|library|feed|table|items?|cards?|capture|captures|screenshot|screenshots)\b/i.test(normalizedLabel)) {
             score += 4;
         }
         if (element.visibilityState === "full")
@@ -562,13 +577,13 @@ export function shouldAttemptSequentialReadyCheck(params) {
     }
     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) {
+        // Many apps reuse the same base route 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.structure !== "unknown"
+            && targetIntent.structure !== "unknown"
+            && previousIntent.structure !== targetIntent.structure) {
             return false;
         }
         return intentOverlap >= 2;

package/dist/capture-selector-memory.d.ts

@@ -5,12 +5,16 @@ export interface ScreenshotSelectorMemoryUpdate {
     source: 'agent' | 'deterministic' | 'manual';
     success: boolean;
 }
+/** Map a viewport width to a device category for selector memory scoping. */
+export declare function getViewportCategory(width: number): 'mobile' | 'tablet' | 'desktop';
 export declare function loadScreenshotSelectorMemory(supabase: SupabaseClient, params: {
     projectId: string | null;
     presetId?: string | null;
     domain: string;
     lang: string;
     theme: 'light' | 'dark';
+    /** Optional viewport width — when provided, filters selectors by viewport category. */
+    viewportWidth?: number | null;
 }): Promise<Record<string, string[]>>;
 export declare function persistScreenshotSelectorMemoryUpdates(supabase: SupabaseClient, params: {
     projectId: string | null;
@@ -18,6 +22,7 @@ export declare function persistScreenshotSelectorMemoryUpdates(supabase: Supabas
     domain: string;
     lang: string;
     theme: 'light' | 'dark';
+    viewportWidth?: number | null;
 }, updates: ScreenshotSelectorMemoryUpdate[]): Promise<void>;
 export declare function extractSelectorUpdates(actions: Array<{
     action: string;

package/dist/capture-selector-memory.js

@@ -59,6 +59,14 @@ function extractPathTokens(rawUrl) {
         return normalizeNavigationTokens(rawUrl.split('/'));
     }
 }
+/** Map a viewport width to a device category for selector memory scoping. */
+export function getViewportCategory(width) {
+    if (width < 768)
+        return 'mobile';
+    if (width < 1024)
+        return 'tablet';
+    return 'desktop';
+}
 export async function loadScreenshotSelectorMemory(supabase, params) {
     const selectFields = 'step_signature, selector, confidence, last_success_at';
     const grouped = {};
@@ -75,6 +83,9 @@ export async function loadScreenshotSelectorMemory(supabase, params) {
             }
         }
     };
+    const viewportCategory = params.viewportWidth
+        ? getViewportCategory(params.viewportWidth)
+        : null;
     if (params.presetId) {
         let query = supabase
             .from('screenshot_step_memory')
@@ -89,6 +100,9 @@ export async function loadScreenshotSelectorMemory(supabase, params) {
         if (params.projectId) {
             query = query.eq('project_id', params.projectId);
         }
+        if (viewportCategory) {
+            query = query.or(`viewport_category.eq.${viewportCategory},viewport_category.is.null`);
+        }
         const { data } = await query;
         if (data && data.length > 0) {
             appendRows(data);
@@ -105,6 +119,9 @@ export async function loadScreenshotSelectorMemory(supabase, params) {
     if (params.projectId) {
         fallbackQuery = fallbackQuery.eq('project_id', params.projectId);
     }
+    if (viewportCategory) {
+        fallbackQuery = fallbackQuery.or(`viewport_category.eq.${viewportCategory},viewport_category.is.null`);
+    }
     const { data: fallbackData } = await fallbackQuery;
     if (fallbackData) {
         appendRows(fallbackData);
@@ -145,6 +162,7 @@ export async function persistScreenshotSelectorMemoryUpdates(supabase, params, u
                 domain: params.domain,
                 lang: params.lang,
                 theme: params.theme,
+                viewport_category: params.viewportWidth ? getViewportCategory(params.viewportWidth) : null,
                 step_signature: update.stepSignature,
                 selector: update.selector,
                 source: update.source,

package/dist/capture-strategy.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Capture Agent — Capture Strategy
+ *
+ * Abstraction over the supported media modes: screenshot and clip.
+ * The opcode runner is identical for all three — only the capture
+ * opcodes dispatch to different strategies.
+ */
+import type { ArtifactSpec, ArtifactResult, RuntimeAdapter, MediaMode } from './execution-types.js';
+export interface CaptureStrategy {
+    readonly mediaMode: MediaMode;
+    /** Prepare the adapter for capture (e.g. lock viewport, inject cursor overlay) */
+    prepare(adapter: RuntimeAdapter, spec: ArtifactSpec): Promise<void>;
+    /** Perform the capture and return the raw artifact */
+    capture(adapter: RuntimeAdapter, spec: ArtifactSpec): Promise<ArtifactResult>;
+    /** Post-process the artifact (mockup frame, status bar, format conversion) */
+    postProcess(artifact: ArtifactResult, spec: ArtifactSpec): Promise<ArtifactResult>;
+}
+export declare class ScreenshotStrategy implements CaptureStrategy {
+    readonly mediaMode: "screenshot";
+    prepare(_adapter: RuntimeAdapter, _spec: ArtifactSpec): Promise<void>;
+    capture(adapter: RuntimeAdapter, _spec: ArtifactSpec): Promise<ArtifactResult>;
+    postProcess(artifact: ArtifactResult, spec: ArtifactSpec): Promise<ArtifactResult>;
+}
+export declare class ClipStrategy implements CaptureStrategy {
+    readonly mediaMode: "clip";
+    prepare(adapter: RuntimeAdapter, _spec: ArtifactSpec): Promise<void>;
+    capture(adapter: RuntimeAdapter, _spec: ArtifactSpec): Promise<ArtifactResult>;
+    postProcess(artifact: ArtifactResult, spec: ArtifactSpec): Promise<ArtifactResult>;
+}
+export declare class DomStrategy implements CaptureStrategy {
+    readonly mediaMode: "dom";
+    prepare(_adapter: RuntimeAdapter, _spec: ArtifactSpec): Promise<void>;
+    capture(adapter: RuntimeAdapter, _spec: ArtifactSpec): Promise<ArtifactResult>;
+    postProcess(artifact: ArtifactResult, _spec: ArtifactSpec): Promise<ArtifactResult>;
+}
+export declare function createCaptureStrategy(mediaMode: MediaMode): CaptureStrategy;

package/dist/capture-strategy.js

@@ -0,0 +1,95 @@
+/**
+ * Capture Agent — Capture Strategy
+ *
+ * Abstraction over the supported media modes: screenshot and clip.
+ * The opcode runner is identical for all three — only the capture
+ * opcodes dispatch to different strategies.
+ */
+// ── Screenshot strategy ─────────────────────────────────────────────
+export class ScreenshotStrategy {
+    mediaMode = 'screenshot';
+    async prepare(_adapter, _spec) {
+        // Viewport locking is handled externally by the CLI runner
+        // when creating the browser context per variant.
+    }
+    async capture(adapter, _spec) {
+        const buffer = await adapter.takeScreenshot();
+        return {
+            mediaMode: 'screenshot',
+            buffer,
+            mimeType: 'image/png',
+        };
+    }
+    async postProcess(artifact, spec) {
+        // Post-processing (mockup frame, status bar) will be applied
+        // by the CLI runner using existing utilities:
+        // - applyDeviceFrame() from src/mockup.ts
+        // - generateStatusBarHtml() from src/status-bar.ts
+        // For now, return as-is. Phase 4 CLI runner handles the orchestration.
+        return artifact;
+    }
+}
+// ── Clip strategy ───────────────────────────────────────────────────
+export class ClipStrategy {
+    mediaMode = 'clip';
+    async prepare(adapter, _spec) {
+        // Clip recording preparation:
+        // - The browser context is created with video recording enabled
+        // - Cursor overlay is injected by Browser.forVideoRecording()
+    }
+    async capture(adapter, _spec) {
+        // Clip capture is bounded by BEGIN_CLIP / END_CLIP opcodes.
+        // The opcode runner calls adapter.beginRecording() and adapter.endRecording().
+        // This method is called for the final artifact assembly.
+        const recording = await adapter.endRecording();
+        return {
+            mediaMode: 'clip',
+            buffer: recording.buffer,
+            mimeType: recording.mimeType,
+        };
+    }
+    async postProcess(artifact, spec) {
+        // Post-processing for clips:
+        // - Convert WebM to GIF/MP4 via src/clip-postprocess.ts (if it exists)
+        // - Trim start/end
+        // - Apply cursor theme
+        // Handled by CLI runner using existing video processing utilities.
+        return artifact;
+    }
+}
+// ── DOM strategy (Interactive Demos — AUT-121) ──────────────────────
+export class DomStrategy {
+    mediaMode = 'dom';
+    async prepare(_adapter, _spec) {
+        // Nothing to prepare — DOM serialization happens inline in the
+        // CAPTURE_DOM opcode handler in opcode-runner.ts.
+    }
+    async capture(adapter, _spec) {
+        if (!adapter.serializeDom) {
+            throw new Error('DOM capture requires an adapter that implements serializeDom()');
+        }
+        const result = await adapter.serializeDom();
+        return {
+            mediaMode: 'dom',
+            buffer: Buffer.from(result.html, 'utf8'),
+            mimeType: 'text/html; charset=utf-8',
+            domHtml: result.html,
+            domAssetUrls: result.assetUrls,
+            domHtmlBytes: result.html.length,
+            dimensions: result.viewport,
+        };
+    }
+    async postProcess(artifact, _spec) {
+        // Phase 3 will add asset extraction (CAS), PurgeCSS and Brotli here.
+        return artifact;
+    }
+}
+// ── Factory ─────────────────────────────────────────────────────────
+export function createCaptureStrategy(mediaMode) {
+    switch (mediaMode) {
+        case 'screenshot': return new ScreenshotStrategy();
+        case 'clip': return new ClipStrategy();
+        case 'dom': return new DomStrategy();
+    }
+}
+//# sourceMappingURL=capture-strategy.js.map