autokap 1.0.7 → 1.0.8

package/dist/mouse-animation.d.ts

@@ -6,8 +6,8 @@ export interface BezierMoveOptions {
     steps?: number;
 }
 /**
- * Move the mouse from `from` to `to` along a cubic Bezier curve with natural
- * human-like motion: ease-in-out timing, randomized control points, micro-jitter.
+ * Move the mouse from `from` to `to` along a cubic Bezier curve with
+ * smooth controlled motion: ease-in-out timing, gentle proportional curves.
  */
 export declare function moveMouse(page: Page, from: {
     x: number;

package/dist/mouse-animation.js

@@ -14,8 +14,8 @@ function randomOffset(scale) {
     return (Math.random() - 0.5) * 2 * scale;
 }
 /**
- * Move the mouse from `from` to `to` along a cubic Bezier curve with natural
- * human-like motion: ease-in-out timing, randomized control points, micro-jitter.
+ * Move the mouse from `from` to `to` along a cubic Bezier curve with
+ * smooth controlled motion: ease-in-out timing, gentle proportional curves.
  */
 export async function moveMouse(page, from, to, options = {}) {
     const dx = to.x - from.x;
@@ -23,35 +23,49 @@ export async function moveMouse(page, from, to, options = {}) {
     const distance = Math.sqrt(dx * dx + dy * dy);
     if (distance < 2)
         return; // Already there
-    const steps = options.steps ?? 30;
-    const durationMs = options.durationMs ?? Math.min(900, Math.max(350, distance * 1.2));
+    const durationMs = options.durationMs ?? Math.min(700, Math.max(80, Math.sqrt(distance) * 28));
+    const steps = options.steps ?? Math.max(4, Math.ceil(durationMs / 16));
     const msPerStep = durationMs / steps;
-    // Randomize control points to create a natural curve.
-    // Enforce a minimum arc so short-distance moves still curve visibly.
-    const perpScale = Math.max(30, Math.min(distance * 0.3, 80));
-    const p1 = {
-        x: from.x + dx * 0.25 + randomOffset(perpScale),
-        y: from.y + dy * 0.25 + randomOffset(perpScale),
-    };
-    const p2 = {
-        x: from.x + dx * 0.75 + randomOffset(perpScale),
-        y: from.y + dy * 0.75 + randomOffset(perpScale),
-    };
+    // Control points: straight line for short moves, gentle proportional arc for longer ones.
+    let p1;
+    let p2;
+    if (distance < 30) {
+        p1 = { x: from.x + dx * 0.33, y: from.y + dy * 0.33 };
+        p2 = { x: from.x + dx * 0.67, y: from.y + dy * 0.67 };
+    }
+    else {
+        const perpScale = Math.min(distance * 0.12, 60);
+        p1 = {
+            x: from.x + dx * 0.25 + randomOffset(perpScale),
+            y: from.y + dy * 0.25 + randomOffset(perpScale),
+        };
+        p2 = {
+            x: from.x + dx * 0.75 + randomOffset(perpScale),
+            y: from.y + dy * 0.75 + randomOffset(perpScale),
+        };
+    }
     for (let i = 1; i <= steps; i++) {
         const linearT = i / steps;
         const t = easeInOut(linearT);
         const point = cubicBezier(from, p1, p2, to, t);
-        // Add micro-jitter to simulate hand imprecision
-        const jitter = Math.max(0, 1 - linearT) * 1.5; // jitter decreases near destination
-        const jx = randomOffset(jitter);
-        const jy = randomOffset(jitter);
-        await page.mouse.move(point.x + jx, point.y + jy);
+        const mx = Math.round(point.x);
+        const my = Math.round(point.y);
+        await page.mouse.move(mx, my);
+        // CDP mouse.move doesn't fire DOM mousemove — update overlay directly
+        await page.evaluate(({ x, y }) => {
+            if (typeof window.__akMoveCursor === 'function')
+                window.__akMoveCursor(x, y);
+        }, { x: mx, y: my }).catch(() => { });
         if (msPerStep > 1) {
             await page.waitForTimeout(msPerStep);
         }
     }
     // Final move to exact destination (no jitter)
     await page.mouse.move(to.x, to.y);
+    await page.evaluate(({ x, y }) => {
+        if (typeof window.__akMoveCursor === 'function')
+            window.__akMoveCursor(x, y);
+    }, { x: Math.round(to.x), y: Math.round(to.y) }).catch(() => { });
 }
 /**
  * Move the mouse to `target` with Bezier curve animation and click.

package/dist/opcode-actions.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Capture Agent — Shared Opcode Actions
+ *
+ * Deterministic action dispatch shared by the main opcode runner and the
+ * recovery chain so both paths execute the same behavior.
+ */
+import type { ExecutionOpcode, MockDataGroup, RuntimeAdapter, VariantSpec } from './execution-types.js';
+export interface OpcodeActionContext {
+    currentVariant?: VariantSpec;
+    /** Mock data groups available to INJECT_MOCK_DATA. Plumbed from ExecutionProgram. */
+    mockDataGroups?: MockDataGroup[];
+    /**
+     * Live credentials used to substitute {{email}}/{{password}}/{{loginUrl}}
+     * placeholders in TYPE / NAVIGATE opcodes. Plumbed from
+     * `program.preconditions.credentials`.
+     */
+    credentials?: {
+        email?: string;
+        password?: string;
+        loginUrl?: string;
+    };
+}
+/**
+ * Substitute credential placeholders inside opcode text fields.
+ * Only the {{email}}, {{password}} and {{loginUrl}} tokens are replaced.
+ * No-op if no credentials are present or the text contains no placeholder.
+ */
+export declare function substituteCredentialPlaceholders(text: string, credentials?: OpcodeActionContext['credentials']): string;
+/**
+ * Returns the list of credential placeholders (`{{email}}`, `{{password}}`,
+ * `{{loginUrl}}`) that the input string references but the provided
+ * `credentials` object does NOT have a non-empty value for. Used by the
+ * opcode dispatcher to fail loudly with a clear message when a NAVIGATE /
+ * TYPE / etc. would otherwise resolve to an empty string and crash
+ * Playwright with a confusing "Cannot navigate to invalid URL" error.
+ */
+export declare function findUnresolvedCredentialPlaceholders(text: string, credentials?: OpcodeActionContext['credentials']): string[];
+export interface OpcodeActionResult {
+    success: boolean;
+    error?: string;
+}
+export declare function executeOpcodeCoreAction(opcode: ExecutionOpcode, adapter: RuntimeAdapter, context?: OpcodeActionContext): Promise<OpcodeActionResult>;

package/dist/opcode-actions.js

@@ -0,0 +1,511 @@
+/**
+ * Capture Agent — Shared Opcode Actions
+ *
+ * Deterministic action dispatch shared by the main opcode runner and the
+ * recovery chain so both paths execute the same behavior.
+ */
+import { VARIANT_PLACEHOLDER } from './execution-types.js';
+import { dismissAllOverlays } from './overlay-engine.js';
+/**
+ * Substitute credential placeholders inside opcode text fields.
+ * Only the {{email}}, {{password}} and {{loginUrl}} tokens are replaced.
+ * No-op if no credentials are present or the text contains no placeholder.
+ */
+export function substituteCredentialPlaceholders(text, credentials) {
+    if (typeof text !== 'string' || !text.includes('{{')) {
+        return text;
+    }
+    return text
+        .replaceAll('{{email}}', credentials?.email ?? '')
+        .replaceAll('{{password}}', credentials?.password ?? '')
+        .replaceAll('{{loginUrl}}', credentials?.loginUrl ?? '');
+}
+/**
+ * Returns the list of credential placeholders (`{{email}}`, `{{password}}`,
+ * `{{loginUrl}}`) that the input string references but the provided
+ * `credentials` object does NOT have a non-empty value for. Used by the
+ * opcode dispatcher to fail loudly with a clear message when a NAVIGATE /
+ * TYPE / etc. would otherwise resolve to an empty string and crash
+ * Playwright with a confusing "Cannot navigate to invalid URL" error.
+ */
+export function findUnresolvedCredentialPlaceholders(text, credentials) {
+    if (typeof text !== 'string' || !text.includes('{{'))
+        return [];
+    const missing = [];
+    if (text.includes('{{email}}') && !credentials?.email?.trim()) {
+        missing.push('{{email}}');
+    }
+    if (text.includes('{{password}}') && !credentials?.password) {
+        missing.push('{{password}}');
+    }
+    if (text.includes('{{loginUrl}}') && !credentials?.loginUrl?.trim()) {
+        missing.push('{{loginUrl}}');
+    }
+    return missing;
+}
+export async function executeOpcodeCoreAction(opcode, adapter, context = {}) {
+    try {
+        switch (opcode.kind) {
+            case 'NAVIGATE': {
+                const missing = findUnresolvedCredentialPlaceholders(opcode.url, context.credentials);
+                if (missing.length > 0) {
+                    throw new Error(`NAVIGATE url contains placeholder(s) ${missing.join(', ')} but the preset's credentials are missing the matching value(s). ` +
+                        `Open the preset editor and fill in the credentials (${missing.map((p) => p.replace(/[{}]/g, '')).join(', ')}), or remove the placeholder from the program.`);
+                }
+                const url = substituteCredentialPlaceholders(opcode.url, context.credentials);
+                if (!url.trim()) {
+                    throw new Error(`NAVIGATE url resolved to an empty string (original: "${opcode.url}")`);
+                }
+                await adapter.navigate(url);
+                break;
+            }
+            case 'DISMISS_OVERLAYS':
+                await dismissAllOverlays(adapter);
+                break;
+            case 'CLICK':
+                try {
+                    await adapter.click(opcode.selector, opcode.button ? { button: opcode.button } : undefined);
+                }
+                catch (error) {
+                    if (!opcode.target || !adapter.clickByTarget)
+                        throw error;
+                    await adapter.clickByTarget({
+                        selector: opcode.selector,
+                        target: opcode.target,
+                        selectorAlternates: opcode.selectorAlternates,
+                    });
+                }
+                break;
+            case 'TYPE': {
+                const rawText = (opcode.textByLocale && context.currentVariant?.locale
+                    ? opcode.textByLocale[context.currentVariant.locale] ?? opcode.text
+                    : opcode.text);
+                const text = substituteCredentialPlaceholders(rawText, context.credentials);
+                try {
+                    await adapter.type(opcode.selector, text, opcode.clearFirst);
+                }
+                catch (error) {
+                    if (!opcode.target || !adapter.typeByTarget)
+                        throw error;
+                    await adapter.typeByTarget({
+                        selector: opcode.selector,
+                        target: opcode.target,
+                        selectorAlternates: opcode.selectorAlternates,
+                    }, text, opcode.clearFirst);
+                }
+                break;
+            }
+            case 'PRESS_KEY':
+                await adapter.pressKey(opcode.key);
+                break;
+            case 'WAIT_FOR': {
+                const waitSelector = opcode.selector;
+                if (waitSelector) {
+                    const found = await adapter.waitFor({
+                        selector: waitSelector,
+                        state: opcode.state,
+                        timeoutMs: opcode.timeoutMs,
+                    });
+                    if (!found) {
+                        return { success: false, error: `element "${waitSelector}" not found within timeout` };
+                    }
+                }
+                else if (opcode.target && adapter.waitForTarget) {
+                    const found = await adapter.waitForTarget({ target: opcode.target }, opcode.timeoutMs);
+                    if (!found) {
+                        return { success: false, error: `target "${opcode.target.text ?? opcode.target.role ?? 'unknown'}" not found within timeout` };
+                    }
+                }
+                else {
+                    return { success: false, error: 'WAIT_FOR needs a selector or target' };
+                }
+                break;
+            }
+            case 'SET_LOCALE':
+                return applyLocaleOpcode(opcode, adapter, context.currentVariant);
+            case 'SET_THEME':
+                return applyThemeOpcode(opcode, adapter, context.currentVariant);
+            case 'SCROLL':
+                if (opcode.targetSelector) {
+                    await adapter.scrollIntoView(opcode.targetSelector);
+                }
+                else if (opcode.target && adapter.scrollIntoViewByTarget) {
+                    await adapter.scrollIntoViewByTarget({ target: opcode.target });
+                }
+                else {
+                    await adapter.scroll(opcode.direction, opcode.amount);
+                }
+                break;
+            case 'HOVER':
+                if (!adapter.hover)
+                    return { success: false, error: 'adapter does not support HOVER' };
+                try {
+                    await adapter.hover(opcode.selector);
+                }
+                catch (error) {
+                    if (!opcode.target || !adapter.hoverByTarget)
+                        throw error;
+                    await adapter.hoverByTarget({
+                        selector: opcode.selector,
+                        target: opcode.target,
+                        selectorAlternates: opcode.selectorAlternates,
+                    });
+                }
+                break;
+            case 'SELECT_OPTION':
+                if (!adapter.selectOption)
+                    return { success: false, error: 'adapter does not support SELECT_OPTION' };
+                await adapter.selectOption(opcode.selector, {
+                    label: opcode.optionLabel,
+                    value: opcode.optionValue,
+                    index: opcode.optionIndex,
+                });
+                break;
+            case 'CHECK':
+                if (!adapter.check)
+                    return { success: false, error: 'adapter does not support CHECK' };
+                await adapter.check(opcode.selector, opcode.checked);
+                break;
+            case 'DOUBLE_CLICK':
+                if (!adapter.doubleClick)
+                    return { success: false, error: 'adapter does not support DOUBLE_CLICK' };
+                await adapter.doubleClick(opcode.selector);
+                break;
+            case 'CLONE_ELEMENT':
+                if (!adapter.cloneElement) {
+                    return { success: false, error: 'adapter does not support CLONE_ELEMENT' };
+                }
+                await adapter.cloneElement({
+                    sourceSelector: opcode.sourceSelector,
+                    containerSelector: opcode.containerSelector,
+                    count: opcode.count,
+                    removeSource: opcode.removeSource,
+                });
+                break;
+            case 'REMOVE_ELEMENT':
+                if (!adapter.removeElement) {
+                    return { success: false, error: 'adapter does not support REMOVE_ELEMENT' };
+                }
+                await adapter.removeElement({ selector: opcode.selector });
+                break;
+            case 'SET_ATTRIBUTE':
+                if (!adapter.setAttribute) {
+                    return { success: false, error: 'adapter does not support SET_ATTRIBUTE' };
+                }
+                await adapter.setAttribute({
+                    selector: opcode.selector,
+                    attribute: opcode.attribute,
+                    value: opcode.value,
+                });
+                break;
+            case 'INJECT_MOCK_DATA':
+                return applyInjectMockDataOpcode(opcode, adapter, context);
+            case 'CAPTURE_SCREENSHOT':
+            case 'CAPTURE_DOM':
+            case 'CAPTURE_FRAGMENT':
+            case 'BEGIN_CLIP':
+            case 'END_CLIP':
+            case 'ASSERT_ROUTE':
+            case 'ASSERT_SURFACE':
+                break;
+            default: {
+                const _exhaustive = opcode;
+                return { success: false, error: `unknown opcode kind: ${opcode.kind}` };
+            }
+        }
+        return { success: true };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function resolveVariantPlaceholder(value, replacement, fieldName) {
+    if (value !== VARIANT_PLACEHOLDER)
+        return { resolved: value };
+    if (!replacement) {
+        return { error: `${fieldName} uses ${VARIANT_PLACEHOLDER} but no variant value is available` };
+    }
+    return { resolved: replacement };
+}
+function resolveStorageHintValues(hints, replacement, fieldName) {
+    const resolvedHints = [];
+    for (const hint of hints) {
+        const result = resolveVariantPlaceholder(hint.value, replacement, fieldName);
+        if ('error' in result) {
+            return { error: result.error };
+        }
+        resolvedHints.push({ ...hint, value: result.resolved });
+    }
+    return { resolvedHints };
+}
+async function applyLocaleOpcode(opcode, adapter, currentVariant) {
+    const localeResult = resolveVariantPlaceholder(opcode.locale, currentVariant?.locale, 'SET_LOCALE.locale');
+    if ('error' in localeResult)
+        return { success: false, error: localeResult.error };
+    const resolvedLocale = localeResult.resolved;
+    if (opcode.method === 'browser_context') {
+        await adapter.setLocale(resolvedLocale);
+        if (adapter.reloadPage) {
+            await adapter.reloadPage();
+        }
+        return { success: true };
+    }
+    if (opcode.method === 'ui_interaction') {
+        if (!opcode.selector) {
+            return { success: false, error: 'SET_LOCALE ui_interaction requires selector' };
+        }
+        await adapter.click(opcode.selector);
+        return { success: true };
+    }
+    if (!opcode.storageHints || opcode.storageHints.length === 0 || !adapter.writeStorageHint) {
+        return { success: false, error: 'SET_LOCALE storage mode requires storageHints and adapter storage support' };
+    }
+    const resolvedHints = resolveStorageHintValues(opcode.storageHints, currentVariant?.locale, 'SET_LOCALE.storageHints.value');
+    if ('error' in resolvedHints) {
+        return { success: false, error: resolvedHints.error };
+    }
+    const writes = await Promise.all(resolvedHints.resolvedHints.map((hint) => adapter.writeStorageHint({
+        storage: hint.storage,
+        key: hint.key,
+        value: hint.value,
+        kind: 'locale',
+    })));
+    if (!writes.some(Boolean)) {
+        return { success: false, error: 'SET_LOCALE storage hints did not match any writable locale keys' };
+    }
+    if (adapter.reloadPage) {
+        await adapter.reloadPage();
+    }
+    return { success: true };
+}
+/**
+ * Orchestrates mock data injection for one group. Applies BOTH delivery
+ * mechanisms additively when their fields are provided:
+ *
+ *   1. **Clone**: clones a template DOM element N times and writes each slot
+ *      value into the cloned descendants. Provides instant visual feedback
+ *      even before the app re-renders.
+ *
+ *   2. **Trigger**: writes the JSON-encoded `defaultValues` into a hidden
+ *      input the user's app exposed, then clicks a hidden trigger button. The
+ *      user's `onClick` handler reads the input and re-renders the widget.
+ *      Survives React re-renders that would otherwise clobber clones.
+ *
+ * The two mechanisms are independent and complementary. An opcode typically
+ * carries fields for both. Each runs in isolation: a failure of one does not
+ * prevent the other from running. As long as AT LEAST ONE produces a
+ * successful application, the group is recorded as 'applied'. If both fail
+ * (or neither was wired), the opcode returns failure and the runner's
+ * soft-skip branch converts it to `status: 'skipped'`.
+ */
+async function applyInjectMockDataOpcode(opcode, adapter, context) {
+    const group = context.mockDataGroups?.find((g) => g.name === opcode.groupName);
+    if (!group) {
+        return {
+            success: false,
+            error: `INJECT_MOCK_DATA: group "${opcode.groupName}" not found in program.mockDataGroups`,
+        };
+    }
+    if (group.defaultValues.length === 0) {
+        return {
+            success: false,
+            error: `INJECT_MOCK_DATA: group "${opcode.groupName}" has no defaultValues`,
+        };
+    }
+    const hasCloneFields = Boolean(opcode.containerSelector && opcode.slotMappings && opcode.slotMappings.length > 0);
+    const hasTriggerFields = Boolean(opcode.inputSelector && opcode.triggerSelector);
+    if (!hasCloneFields && !hasTriggerFields) {
+        return {
+            success: false,
+            error: `INJECT_MOCK_DATA "${opcode.groupName}": no clone fields and no trigger fields provided`,
+        };
+    }
+    const errors = [];
+    let anySucceeded = false;
+    // Apply clone first so the user sees an instant paint of the mocked DOM,
+    // even before the app's state-driven re-render fires.
+    if (hasCloneFields) {
+        try {
+            const cloneResult = await applyInjectMockDataCloneStrategy(opcode, adapter, group);
+            if (cloneResult.success) {
+                anySucceeded = true;
+            }
+            else if (cloneResult.error) {
+                errors.push(`clone: ${cloneResult.error}`);
+            }
+        }
+        catch (err) {
+            errors.push(`clone: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // Apply trigger second so the app's state takes over and survives any
+    // future re-renders that would clobber the cloned DOM.
+    if (hasTriggerFields) {
+        try {
+            const triggerResult = await applyInjectMockDataTriggerStrategy(opcode, adapter, group);
+            if (triggerResult.success) {
+                anySucceeded = true;
+            }
+            else if (triggerResult.error) {
+                errors.push(`trigger: ${triggerResult.error}`);
+            }
+        }
+        catch (err) {
+            errors.push(`trigger: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (anySucceeded) {
+        return { success: true };
+    }
+    return {
+        success: false,
+        error: `INJECT_MOCK_DATA "${opcode.groupName}" failed: ${errors.join('; ')}`,
+    };
+}
+async function applyInjectMockDataCloneStrategy(opcode, adapter, group) {
+    if (!adapter.cloneElement || !adapter.setAttribute || !adapter.setTextContent) {
+        return {
+            success: false,
+            error: 'adapter does not support cloneElement / setAttribute / setTextContent',
+        };
+    }
+    if (!opcode.containerSelector) {
+        return {
+            success: false,
+            error: 'containerSelector is required',
+        };
+    }
+    if (!opcode.slotMappings || opcode.slotMappings.length === 0) {
+        return {
+            success: false,
+            error: 'slotMappings are required',
+        };
+    }
+    const rowCount = opcode.count ?? group.defaultValues.length;
+    const templateSelector = opcode.templateSelector ?? `${opcode.containerSelector} > *:first-child`;
+    // Clone N copies of the template element. The runner short-circuits to
+    // 'skipped' if cloneElement throws (selector miss).
+    await adapter.cloneElement({
+        sourceSelector: templateSelector,
+        containerSelector: opcode.containerSelector,
+        count: rowCount,
+        removeSource: opcode.removeTemplate,
+    });
+    // If the group is configured to replace existing data, remove every child
+    // of the container that is NOT a clone (placeholders, real items, empty
+    // states). This must run AFTER cloning so we know which children to keep.
+    if (group.replaceExisting && adapter.removeElement) {
+        try {
+            await adapter.removeElement({
+                selector: `${opcode.containerSelector} > *:not([data-ak-mock-clone])`,
+            });
+        }
+        catch {
+            // non-blocking — if nothing to remove, skip
+        }
+    }
+    // Each clone is tagged by cloneElement with `data-ak-mock-clone="<i>"`,
+    // so we address them by that attribute instead of nth-child math. This
+    // is robust against the container holding non-template siblings (e.g.
+    // empty-state placeholders) that would otherwise shift indices.
+    for (let i = 0; i < rowCount; i++) {
+        const row = group.defaultValues[i % group.defaultValues.length];
+        const rowSelector = `${opcode.containerSelector} > [data-ak-mock-clone="${i}"]`;
+        for (const mapping of opcode.slotMappings) {
+            const value = row[mapping.slot];
+            if (value === undefined)
+                continue;
+            const targetSelector = `${rowSelector} ${mapping.selector}`;
+            if (mapping.attribute) {
+                await adapter.setAttribute({
+                    selector: targetSelector,
+                    attribute: mapping.attribute,
+                    value,
+                });
+            }
+            else {
+                await adapter.setTextContent({
+                    selector: targetSelector,
+                    text: value,
+                });
+            }
+        }
+    }
+    return { success: true };
+}
+async function applyInjectMockDataTriggerStrategy(opcode, adapter, group) {
+    if (!adapter.setInputValue || !adapter.clickHidden) {
+        return {
+            success: false,
+            error: 'adapter does not support setInputValue / clickHidden',
+        };
+    }
+    if (!opcode.inputSelector) {
+        return {
+            success: false,
+            error: 'inputSelector is required',
+        };
+    }
+    if (!opcode.triggerSelector) {
+        return {
+            success: false,
+            error: 'triggerSelector is required',
+        };
+    }
+    // Serialize the seed values. The user's onClick handler will JSON.parse this
+    // and feed it into its render function (e.g. setChartData(parsed)).
+    const valueJson = JSON.stringify(group.defaultValues);
+    // Write into the hidden input via the React-aware native setter so the
+    // app's controlled-component bookkeeping picks up the change.
+    await adapter.setInputValue({
+        selector: opcode.inputSelector,
+        value: valueJson,
+    });
+    // Click the hidden trigger via the native .click() method so React's
+    // onClick handler fires even if the button is display:none.
+    await adapter.clickHidden({
+        selector: opcode.triggerSelector,
+    });
+    return { success: true };
+}
+async function applyThemeOpcode(opcode, adapter, currentVariant) {
+    const themeResult = resolveVariantPlaceholder(opcode.theme, currentVariant?.theme, 'SET_THEME.theme');
+    if ('error' in themeResult)
+        return { success: false, error: themeResult.error };
+    const resolvedTheme = themeResult.resolved;
+    if (opcode.method === 'color_scheme') {
+        await adapter.setColorScheme(resolvedTheme);
+        return { success: true };
+    }
+    if (opcode.method === 'ui_interaction') {
+        if (!opcode.selector) {
+            return { success: false, error: 'SET_THEME ui_interaction requires selector' };
+        }
+        await adapter.click(opcode.selector);
+        return { success: true };
+    }
+    if (!opcode.storageHints || opcode.storageHints.length === 0 || !adapter.writeStorageHint) {
+        return { success: false, error: 'SET_THEME storage mode requires storageHints and adapter storage support' };
+    }
+    const resolvedHints = resolveStorageHintValues(opcode.storageHints, currentVariant?.theme, 'SET_THEME.storageHints.value');
+    if ('error' in resolvedHints) {
+        return { success: false, error: resolvedHints.error };
+    }
+    const writes = await Promise.all(resolvedHints.resolvedHints.map((hint) => adapter.writeStorageHint({
+        storage: hint.storage,
+        key: hint.key,
+        value: hint.value,
+        kind: 'theme',
+    })));
+    if (!writes.some(Boolean)) {
+        return { success: false, error: 'SET_THEME storage hints did not match any writable theme keys' };
+    }
+    if (adapter.reloadPage) {
+        await adapter.reloadPage();
+    }
+    return { success: true };
+}
+//# sourceMappingURL=opcode-actions.js.map