autokap 1.0.7 → 1.0.8

package/dist/provider-config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared OpenRouter provider configuration.
+ *
+ * Zero Data Retention (ZDR) tells OpenRouter to only route requests to
+ * providers that guarantee they won't store or train on request data.
+ * Controlled by the ENABLE_ZDR environment variable (default: off).
+ */
+export declare function isZdrEnabled(): boolean;
+/** Build the `provider.zdr` fragment for OpenRouter requests. */
+export declare function zdrParam(): {
+    zdr?: true;
+};

package/dist/provider-config.js

@@ -0,0 +1,15 @@
+/**
+ * Shared OpenRouter provider configuration.
+ *
+ * Zero Data Retention (ZDR) tells OpenRouter to only route requests to
+ * providers that guarantee they won't store or train on request data.
+ * Controlled by the ENABLE_ZDR environment variable (default: off).
+ */
+export function isZdrEnabled() {
+    return process.env.ENABLE_ZDR === '1' || process.env.ENABLE_ZDR === 'true';
+}
+/** Build the `provider.zdr` fragment for OpenRouter requests. */
+export function zdrParam() {
+    return isZdrEnabled() ? { zdr: true } : {};
+}
+//# sourceMappingURL=provider-config.js.map

package/dist/recovery-chain.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Capture Agent — Recovery Chain
+ *
+ * Ordered recovery strategies when a deterministic opcode fails:
+ * 1. Deterministic retry (same opcode, fresh observation)
+ * 2. Selector memory lookup (known-good selectors from Supabase)
+ * 3. Alternative interaction (keyboard, JS dispatch, coordinates)
+ * 4. Targeted reload (reload page and retry)
+ * 5. LLM Healer (last resort)
+ */
+import type { ExecutionOpcode, RuntimeAdapter } from './execution-types.js';
+import type { RecoveryChain as IRecoveryChain, RecoveryAttemptResult, RecoveryAttemptOptions } from './opcode-runner.js';
+import { type HealerLLMProvider } from './llm-healer.js';
+export interface RecoveryChainOptions {
+    /** Selector memory: stepSignature -> known-good selectors */
+    selectorMemory?: Record<string, string[]>;
+    /** LLM provider for the healer (optional, disables healer if not provided) */
+    llmProvider?: HealerLLMProvider;
+    /** Max healer invocations per run. Default: 3 */
+    maxHealerInvocations?: number;
+    /** Full program steps for healer context */
+    programSteps?: ExecutionOpcode[];
+    /** Credentials for {{email}}/{{password}}/{{loginUrl}} substitution during recovery */
+    credentials?: {
+        email?: string;
+        password?: string;
+        loginUrl?: string;
+    };
+}
+export declare class RecoveryChainImpl implements IRecoveryChain {
+    private healer;
+    private selectorMemory;
+    private programSteps;
+    private credentials?;
+    constructor(options?: RecoveryChainOptions);
+    attempt(failedOpcode: ExecutionOpcode, opcodeIndex: number, adapter: RuntimeAdapter, options?: RecoveryAttemptOptions): Promise<RecoveryAttemptResult>;
+}

package/dist/recovery-chain.js

@@ -0,0 +1,350 @@
+/**
+ * Capture Agent — Recovery Chain
+ *
+ * Ordered recovery strategies when a deterministic opcode fails:
+ * 1. Deterministic retry (same opcode, fresh observation)
+ * 2. Selector memory lookup (known-good selectors from Supabase)
+ * 3. Alternative interaction (keyboard, JS dispatch, coordinates)
+ * 4. Targeted reload (reload page and retry)
+ * 5. LLM Healer (last resort)
+ */
+import { resolveSelector } from './selector-resolver.js';
+import { evaluatePostcondition } from './postcondition.js';
+import { LLMHealer } from './llm-healer.js';
+import { serializeAKTree } from './ak-tree.js';
+import { executeOpcodeCoreAction, substituteCredentialPlaceholders } from './opcode-actions.js';
+import { dismissAllOverlays } from './overlay-engine.js';
+import { logger } from './logger.js';
+export class RecoveryChainImpl {
+    healer;
+    selectorMemory;
+    programSteps;
+    credentials;
+    constructor(options = {}) {
+        this.selectorMemory = options.selectorMemory ?? {};
+        this.programSteps = options.programSteps ?? [];
+        this.credentials = options.credentials;
+        this.healer = options.llmProvider
+            ? new LLMHealer(options.llmProvider, { maxInvocations: options.maxHealerInvocations ?? 3 })
+            : null;
+    }
+    async attempt(failedOpcode, opcodeIndex, adapter, options = {}) {
+        const recovery = failedOpcode.recovery;
+        logger.debug(`[recovery ${opcodeIndex}] starting — remainingMs=${options.remainingTimeMs ?? '∞'}, flags=[retries=${recovery.retries},selMem=${recovery.useSelectorMemory},alt=${recovery.useAltInteraction},reload=${recovery.allowReload},healer=${recovery.allowHealer}]`);
+        // Strategy 1: Deterministic retry
+        const retryBudget = Math.max(0, Math.min(recovery.retries, options.maxDeterministicRetries ?? recovery.retries));
+        if (retryBudget > 0) {
+            logger.debug(`[recovery ${opcodeIndex}] strategy 1 (retry x${retryBudget})`);
+            const result = await retryOpcode(failedOpcode, adapter, retryBudget, options.remainingTimeMs, options.currentVariant, this.credentials);
+            logger.debug(`[recovery ${opcodeIndex}] strategy 1 → recovered=${result.recovered}, reason=${result.reason}`);
+            if (result.recovered)
+                return result;
+        }
+        // Strategy 2: Selector memory + alternate selectors
+        if (recovery.useSelectorMemory && hasSelector(failedOpcode)) {
+            logger.debug(`[recovery ${opcodeIndex}] strategy 2 (selector memory)`);
+            const result = await trySelectorAlternatives(failedOpcode, opcodeIndex, adapter, this.selectorMemory, this.credentials);
+            logger.debug(`[recovery ${opcodeIndex}] strategy 2 → recovered=${result.recovered}, reason=${result.reason}`);
+            if (result.recovered)
+                return result;
+        }
+        // Strategy 3: Alternative interaction methods
+        if (recovery.useAltInteraction && hasSelector(failedOpcode)) {
+            logger.debug(`[recovery ${opcodeIndex}] strategy 3 (alt interaction: keyboard, js_dispatch, coords)`);
+            const result = await tryAltInteraction(failedOpcode, adapter, this.credentials);
+            logger.debug(`[recovery ${opcodeIndex}] strategy 3 → recovered=${result.recovered}, reason=${result.reason}`);
+            if (result.recovered)
+                return result;
+        }
+        // Strategy 4: Targeted reload
+        if (recovery.allowReload) {
+            logger.debug(`[recovery ${opcodeIndex}] strategy 4 (reload)`);
+            const result = await tryReload(failedOpcode, adapter, options.currentVariant, this.credentials);
+            logger.debug(`[recovery ${opcodeIndex}] strategy 4 → recovered=${result.recovered}, reason=${result.reason}`);
+            if (result.recovered)
+                return result;
+        }
+        // Strategy 5: LLM Healer
+        if (recovery.allowHealer && this.healer && this.healer.remainingInvocations > 0) {
+            logger.debug(`[recovery ${opcodeIndex}] strategy 5 (LLM healer)`);
+            const result = await tryHealer(failedOpcode, opcodeIndex, adapter, this.healer, this.programSteps, options.currentVariant, this.credentials);
+            logger.debug(`[recovery ${opcodeIndex}] strategy 5 → recovered=${result.recovered}, reason=${result.reason}`);
+            return result;
+        }
+        logger.debug(`[recovery ${opcodeIndex}] all strategies exhausted`);
+        return { recovered: false, reason: 'all recovery strategies exhausted' };
+    }
+}
+// ── Strategy 1: Deterministic retry ─────────────────────────────────
+async function retryOpcode(opcode, adapter, maxRetries, remainingTimeMs, currentVariant, credentials) {
+    const deadlineMs = typeof remainingTimeMs === 'number'
+        ? Date.now() + remainingTimeMs
+        : Number.POSITIVE_INFINITY;
+    for (let i = 0; i < maxRetries; i++) {
+        if (Date.now() >= deadlineMs) {
+            return { recovered: false, reason: 'retry budget exhausted by timeout' };
+        }
+        await sleep(500 * (i + 1)); // backoff
+        try {
+            await executeRawAction(opcode, adapter, currentVariant, credentials);
+            const postcondition = await evaluatePostcondition(adapter, clampPostconditionWait(opcode.postcondition, deadlineMs));
+            if (postcondition.passed) {
+                return { recovered: true, strategy: 'retry', reason: `retry ${i + 1}/${maxRetries} succeeded` };
+            }
+        }
+        catch {
+            // continue to next retry
+        }
+    }
+    return { recovered: false, reason: `${maxRetries} retries exhausted` };
+}
+// ── Strategy 2: Selector memory ─────────────────────────────────────
+async function trySelectorAlternatives(opcode, opcodeIndex, adapter, selectorMemory, credentials) {
+    if (!hasSelector(opcode)) {
+        return { recovered: false, reason: 'opcode has no selector' };
+    }
+    const selectorOpcode = opcode;
+    const primarySelector = selectorOpcode.selector ?? '';
+    const stepSignature = `${opcode.kind}:${primarySelector}`;
+    const resolved = await resolveSelector(adapter, {
+        primary: primarySelector,
+        fingerprint: selectorOpcode.fingerprint,
+        alternates: selectorOpcode.selectorAlternates,
+        selectorMemory,
+        stepSignature,
+        description: opcode.description,
+    });
+    if (!resolved || resolved.strategy === 'primary') {
+        return { recovered: false, reason: 'no alternative selectors found' };
+    }
+    // Try the resolved selector
+    try {
+        await executeWithSelector(opcode, adapter, resolved.selector, credentials);
+        const postcondition = await evaluatePostcondition(adapter, opcode.postcondition);
+        if (postcondition.passed) {
+            return {
+                recovered: true,
+                strategy: 'selector_memory',
+                reason: `resolved via ${resolved.strategy}: "${resolved.selector}"`,
+            };
+        }
+    }
+    catch {
+        // fall through
+    }
+    return { recovered: false, reason: `resolved selector "${resolved.selector}" also failed` };
+}
+// ── Strategy 3: Alternative interaction ─────────────────────────────
+async function tryAltInteraction(opcode, adapter, _credentials) {
+    if (opcode.kind !== 'CLICK' || !opcode.selector) {
+        return { recovered: false, reason: 'alt interaction only for CLICK opcodes with selectors' };
+    }
+    const clickOpcode = opcode;
+    const sel = clickOpcode.selector;
+    const methods = [
+        { name: 'keyboard', options: { useKeyboard: true } },
+        { name: 'js_dispatch', options: { useJsDispatch: true } },
+    ];
+    for (const method of methods) {
+        try {
+            await adapter.click(sel, method.options);
+            await sleep(500);
+            const postcondition = await evaluatePostcondition(adapter, opcode.postcondition);
+            if (postcondition.passed) {
+                return {
+                    recovered: true,
+                    strategy: 'alt_interaction',
+                    reason: `${method.name} interaction succeeded`,
+                };
+            }
+        }
+        catch {
+            // continue to next method
+        }
+    }
+    // Try coordinate-based click from AKTree
+    try {
+        const tree = await adapter.getAKTree();
+        const node = findInteractiveNodeBySelector(tree, sel);
+        if (node) {
+            const x = node.bounds.x + node.bounds.w / 2;
+            const y = node.bounds.y + node.bounds.h / 2;
+            await adapter.click(sel, { coordinates: { x, y } });
+            await sleep(500);
+            const postcondition = await evaluatePostcondition(adapter, opcode.postcondition);
+            if (postcondition.passed) {
+                return {
+                    recovered: true,
+                    strategy: 'alt_interaction',
+                    reason: `coordinate click at (${x}, ${y}) succeeded`,
+                };
+            }
+        }
+    }
+    catch {
+        // fall through
+    }
+    return { recovered: false, reason: 'all alternative interactions failed' };
+}
+// ── Strategy 4: Targeted reload ─────────────────────────────────────
+async function tryReload(opcode, adapter, currentVariant, credentials) {
+    try {
+        if (adapter.reloadPage) {
+            await adapter.reloadPage();
+        }
+        else {
+            const url = await adapter.getCurrentUrl();
+            await adapter.navigate(url);
+        }
+        await sleep(1000);
+        await dismissAllOverlays(adapter);
+        await executeRawAction(opcode, adapter, currentVariant, credentials);
+        const postcondition = await evaluatePostcondition(adapter, opcode.postcondition);
+        if (postcondition.passed) {
+            return { recovered: true, strategy: 'reload', reason: 'reload + retry succeeded' };
+        }
+    }
+    catch {
+        // fall through
+    }
+    return { recovered: false, reason: 'reload + retry failed' };
+}
+// ── Strategy 5: LLM Healer ─────────────────────────────────────────
+async function tryHealer(failedOpcode, opcodeIndex, adapter, healer, programSteps, currentVariant, credentials) {
+    try {
+        const tree = await adapter.getAKTree();
+        const akTreeSerialized = serializeAKTree(tree);
+        const currentUrl = await adapter.getCurrentUrl();
+        let screenshot;
+        try {
+            screenshot = await adapter.takeScreenshot();
+        }
+        catch { /* optional */ }
+        // Get surrounding opcodes for context
+        const start = Math.max(0, opcodeIndex - 3);
+        const end = Math.min(programSteps.length, opcodeIndex + 4);
+        const surroundingOpcodes = programSteps.slice(start, end).filter((_, i) => start + i !== opcodeIndex);
+        const context = {
+            failedOpcode,
+            opcodeIndex,
+            akTreeSerialized,
+            currentUrl,
+            screenshot,
+            surroundingOpcodes,
+            errorMessage: `opcode ${failedOpcode.kind} failed after all deterministic recovery strategies`,
+        };
+        const result = await healer.heal(context);
+        if (result.healed && result.patch) {
+            // Execute the replacement opcode(s) to verify they work
+            for (const replacementOp of result.patch.replacementOpcodes) {
+                try {
+                    await executeRawAction(replacementOp, adapter, currentVariant, credentials);
+                }
+                catch (err) {
+                    return {
+                        recovered: false,
+                        llmResult: result.llmResult,
+                        reason: `healer patch failed during execution: ${err instanceof Error ? err.message : String(err)}`,
+                    };
+                }
+            }
+            // Verify the last replacement's postcondition
+            const lastOp = result.patch.replacementOpcodes[result.patch.replacementOpcodes.length - 1];
+            const postcondition = await evaluatePostcondition(adapter, lastOp.postcondition);
+            if (postcondition.passed) {
+                return {
+                    recovered: true,
+                    strategy: 'healer',
+                    patch: result.patch,
+                    llmResult: result.llmResult,
+                    reason: result.reason,
+                };
+            }
+            return {
+                recovered: false,
+                llmResult: result.llmResult,
+                reason: `healer patch executed but postcondition failed: ${postcondition.reason}`,
+            };
+        }
+        return { recovered: false, llmResult: result.llmResult, reason: result.reason };
+    }
+    catch (err) {
+        return {
+            recovered: false,
+            reason: `healer error: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+// ── Shared helpers ──────────────────────────────────────────────────
+function hasSelector(opcode) {
+    return 'selector' in opcode && typeof opcode.selector === 'string' && !!opcode.selector;
+}
+async function executeRawAction(opcode, adapter, currentVariant, credentials) {
+    const result = await executeOpcodeCoreAction(opcode, adapter, { currentVariant, credentials });
+    if (!result.success) {
+        throw new Error(result.error ?? `opcode ${opcode.kind} could not be replayed`);
+    }
+}
+async function executeWithSelector(opcode, adapter, newSelector, credentials) {
+    switch (opcode.kind) {
+        case 'CLICK':
+            await adapter.click(newSelector, opcode.button ? { button: opcode.button } : undefined);
+            break;
+        case 'TYPE': {
+            const text = substituteCredentialPlaceholders(opcode.text, credentials);
+            await adapter.type(newSelector, text, opcode.clearFirst);
+            break;
+        }
+        case 'HOVER':
+            if (!adapter.hover)
+                throw new Error('adapter does not support HOVER');
+            await adapter.hover(newSelector);
+            break;
+        case 'SELECT_OPTION':
+            if (!adapter.selectOption)
+                throw new Error('adapter does not support SELECT_OPTION');
+            await adapter.selectOption(newSelector, {
+                label: opcode.optionLabel,
+                value: opcode.optionValue,
+                index: opcode.optionIndex,
+            });
+            break;
+        case 'CHECK':
+            if (!adapter.check)
+                throw new Error('adapter does not support CHECK');
+            await adapter.check(newSelector, opcode.checked);
+            break;
+        case 'DOUBLE_CLICK':
+            if (!adapter.doubleClick)
+                throw new Error('adapter does not support DOUBLE_CLICK');
+            await adapter.doubleClick(newSelector);
+            break;
+        default:
+            throw new Error(`cannot swap selector for opcode kind: ${opcode.kind}`);
+    }
+}
+function findInteractiveNodeBySelector(tree, selector) {
+    function walk(node) {
+        if (node.visible && node.interactive && node.sourceRef.includes(selector.replace(/[[\]"#.]/g, ''))) {
+            return node;
+        }
+        for (const child of node.children) {
+            const found = walk(child);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    return walk(tree.root);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function clampPostconditionWait(spec, deadlineMs) {
+    const remainingTimeMs = Math.max(1, deadlineMs - Date.now());
+    return {
+        ...spec,
+        waitMs: Math.max(1, Math.min(spec.waitMs ?? remainingTimeMs, remainingTimeMs)),
+    };
+}
+//# sourceMappingURL=recovery-chain.js.map

package/dist/remote-browser.d.ts

@@ -5,7 +5,7 @@
  * Used by the WS server to control a Playwright browser running on the user's machine.
  */
 import type { WebSocket } from 'ws';
-import type { PageState, PageStateLite, InteractiveElement, BrowserStorageState, BrowserSessionStorageState, VideoPageSignals, OutscaleConfig, SelectorValidationResult } from './types.js';
+import type { PageState, PageStateLite, InteractiveElement, BrowserStorageState, BrowserSessionStorageState, VideoPageSignals, OutscaleConfig, SelectorValidationResult, AKTree, AKNode, AKNodeRuntimeIndexEntry, FocusQuery } from './types.js';
 import type { BrowserObservation, BrowserReaction, BrowserSelectorProbe, BrowserStorageHintWriteParams, BrowserVerificationBundle, BrowserVideoVerificationBundle } from './browser.js';
 export interface WsCommand {
     id: string;
@@ -18,14 +18,15 @@ export interface WsResult {
     error?: string;
 }
 export interface WsEvent {
-    type: 'done' | 'error' | 'progress';
+    type: 'done' | 'error' | 'progress' | 'live_url';
     message?: string;
+    url?: string;
     summary?: {
         successes: number;
         total: number;
     };
 }
-export declare const REMOTE_BROWSER_PROTOCOL_VERSION = 2;
+export declare const REMOTE_BROWSER_PROTOCOL_VERSION = 3;
 export interface RemoteBrowserClientInfo {
     version?: string;
     protocolVersion?: number;
@@ -33,8 +34,9 @@ export interface RemoteBrowserClientInfo {
 export interface WsClientHello {
     type: 'client_hello';
     client: RemoteBrowserClientInfo;
+    apiKey?: string;
 }
-export declare function buildRemoteBrowserClientHello(version: string): WsClientHello;
+export declare function buildRemoteBrowserClientHello(version: string, apiKey?: string): WsClientHello;
 export declare function getRemoteBrowserCompatibilityError(client: RemoteBrowserClientInfo | null | undefined): string | null;
 /**
  * Lightweight proxy for `browser.currentPage` — only exposes the methods
@@ -153,6 +155,26 @@ export declare class RemoteBrowser {
     }): Promise<void>;
     pressKey(key: string): Promise<void>;
     searchText(query: string): Promise<Array<Record<string, unknown>>>;
+    getAKTree(): Promise<AKTree>;
+    resolveAKNode(nodeId: string, options?: {
+        reparse?: boolean;
+    }): Promise<AKNodeRuntimeIndexEntry | null>;
+    tapNode(nodeId: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    typeIntoNode(nodeId: string, text: string, options?: {
+        clearFirst?: boolean;
+    }): Promise<void>;
+    captureNode(nodeId?: string): Promise<Buffer>;
+    focusTree(query: FocusQuery): Promise<{
+        tree: AKTree;
+        serialized: string;
+        matches: AKNode[];
+    }>;
+    centerNodeInView(centerNodeId: string, options?: {
+        containerNodeId?: string;
+        offset?: number;
+    }): Promise<void>;
     waitForPageReaction(before?: BrowserObservation, options?: {
         timeoutMs?: number;
         settleMs?: number;
@@ -183,6 +205,8 @@ export declare class RemoteBrowser {
     observeNetworkRequests(url: string, waitMs?: number): Promise<Array<Record<string, unknown>>>;
     setupRouteInterception(mocks: Array<Record<string, unknown>>): Promise<void>;
     clearRouteInterception(): Promise<void>;
+    /** Explicit allowlist of callable RPC methods — defense-in-depth. */
+    private static readonly ALLOWED_METHODS;
     private call;
     private callAndSyncPageInfo;
     sendEvent(event: WsEvent): void;

package/dist/remote-browser.js

@@ -4,14 +4,16 @@
  *
  * Used by the WS server to control a Playwright browser running on the user's machine.
  */
-export const REMOTE_BROWSER_PROTOCOL_VERSION = 2;
-export function buildRemoteBrowserClientHello(version) {
+import { logger } from './logger.js';
+export const REMOTE_BROWSER_PROTOCOL_VERSION = 3;
+export function buildRemoteBrowserClientHello(version, apiKey) {
     return {
         type: 'client_hello',
         client: {
             version,
             protocolVersion: REMOTE_BROWSER_PROTOCOL_VERSION,
         },
+        ...(apiKey ? { apiKey } : {}),
     };
 }
 export function getRemoteBrowserCompatibilityError(client) {
@@ -80,7 +82,10 @@ export class RemoteBrowser {
                     call.resolve(msg.result);
                 }
             }
-            catch { /* ignore malformed messages */ }
+            catch {
+                const raw = typeof data === 'string' ? data : data.toString('utf-8');
+                logger.warn(`[WS] Malformed message received (${raw.length} bytes)`);
+            }
         });
     }
     // ── Lifecycle ────────────────────────────────────────────────────
@@ -217,6 +222,29 @@ export class RemoteBrowser {
     async searchText(query) {
         return await this.call('searchText', { query });
     }
+    // ── AKTree ──────────────────────────────────────────────────────
+    async getAKTree() {
+        return await this.call('getAKTree', {});
+    }
+    async resolveAKNode(nodeId, options = {}) {
+        return await this.call('resolveAKNode', { nodeId, ...options });
+    }
+    async tapNode(nodeId, options) {
+        await this.callAndSyncPageInfo('tapNode', { nodeId, ...options });
+    }
+    async typeIntoNode(nodeId, text, options) {
+        await this.callAndSyncPageInfo('typeIntoNode', { nodeId, text, ...options });
+    }
+    async captureNode(nodeId) {
+        const r = await this.call('captureNode', { nodeId });
+        return Buffer.from(r.screenshot, 'base64');
+    }
+    async focusTree(query) {
+        return await this.call('focusTree', query);
+    }
+    async centerNodeInView(centerNodeId, options) {
+        await this.callAndSyncPageInfo('centerNodeInView', { centerOn: centerNodeId, ...options });
+    }
     // ── Reactions ────────────────────────────────────────────────────
     async waitForPageReaction(before, options) {
         const reaction = await this.call('waitForPageReaction', { before, ...options });
@@ -239,8 +267,7 @@ export class RemoteBrowser {
         await this.callAndSyncPageInfo('setLanguage', { lang });
     }
     async resizeViewport(width, height) {
-        await this.call('resizeViewport', { width, height });
-        this._pageProxy._cachedViewport = { width, height };
+        await this.callAndSyncPageInfo('resizeViewport', { width, height });
     }
     async forceLoadLazyImages(options) {
         await this.call('forceLoadLazyImages', options ?? {});
@@ -275,7 +302,35 @@ export class RemoteBrowser {
         await this.call('clearRouteInterception', {});
     }
     // ── RPC core ─────────────────────────────────────────────────────
+    /** Explicit allowlist of callable RPC methods — defense-in-depth. */
+    static ALLOWED_METHODS = new Set([
+        'launch', 'close', 'closeContext', 'recreateContext',
+        'setDeviceScaleFactor', 'navigateTo', 'addCookies',
+        'getPageInfo', 'getPageTitle',
+        'takeScreenshot', 'takeScreenshotForAI',
+        'screenshotElement', 'screenshotRegion', 'screenshotBySelector', 'screenshotByRegion',
+        'getPageState', 'getPageStateLite', 'getAccessibilityTree',
+        'getInteractiveElements', 'getSimplifiedDOM',
+        'captureObservation', 'capturePageSignals',
+        'captureVerificationBundle', 'captureVideoVerificationBundle',
+        'clickByIndex', 'clickBySelector', 'clickByCoordinates',
+        'hoverByIndex', 'hoverBySelector', 'hoverByCoordinates',
+        'typeText', 'selectOption', 'scroll', 'scrollElementIntoView',
+        'safeExpand', 'pressKey', 'searchText',
+        'getAKTree', 'resolveAKNode', 'tapNode', 'typeIntoNode',
+        'captureNode', 'focusTree', 'centerNodeInView',
+        'waitForPageReaction', 'wait', 'dismissOverlays',
+        'setColorScheme', 'setLanguage', 'resizeViewport',
+        'forceLoadLazyImages',
+        'exportStorageState', 'exportSessionStorage',
+        'reloadCurrentPage', 'writeStorageHintCandidate',
+        'probeSelector', 'prepareSessionStorage',
+        'observeNetworkRequests', 'setupRouteInterception', 'clearRouteInterception',
+    ]);
     call(method, params, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        if (!RemoteBrowser.ALLOWED_METHODS.has(method)) {
+            return Promise.reject(new Error(`RemoteBrowser: method "${method}" is not allowed`));
+        }
         return new Promise((resolve, reject) => {
             const id = `cmd_${++this.idCounter}`;
             const timer = setTimeout(() => {

package/dist/safari-browser-bar.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Safari macOS browser bar — uses the Figma-exported asset directly.
+ *
+ * Reference SVG: assets/frames/Safari tool bar.svg (1299×88, single-row toolbar).
+ * The asset is embedded as a string constant via `safari-toolbar-asset.ts`
+ * (auto-generated). All icons are baked as paths — only the URL inside
+ * the address pill is dynamic.
+ *
+ * Two outputs:
+ *  - HTML (Playwright preview / React) — inline SVG inside a scaled wrapper
+ *  - SVG (sharp / resvg server compositing)
+ */
+import type { BrowserBarRenderOptions } from './browser-bar.js';
+export declare function generateSafariBrowserBarHtml(options: BrowserBarRenderOptions): string;
+export declare function generateSafariBrowserBarSvg(options: BrowserBarRenderOptions): string;