autokap 1.0.7 → 1.0.10

package/dist/legacy/video-variant-state.d.ts

@@ -0,0 +1,29 @@
+import { Browser } from '../browser.js';
+import type { VideoPageSignals } from '../types.js';
+export interface VariantStateDetection {
+    lang: {
+        requested: string | undefined;
+        detected: string | null;
+        active: boolean;
+        ambiguous: boolean;
+    };
+    theme: {
+        requested: 'light' | 'dark' | undefined;
+        detected: 'light' | 'dark' | null;
+        active: boolean;
+        ambiguous: boolean;
+    };
+    pageSignals: VideoPageSignals;
+}
+export declare function scoreLocaleSignals(signals: VideoPageSignals, requestedLang?: string): {
+    score: number;
+    reasons: string[];
+    ambiguous: boolean;
+};
+export declare function evaluateRequestedThemeState(signals: VideoPageSignals, requestedTheme?: 'light' | 'dark'): {
+    detected: 'light' | 'dark' | null;
+    active: boolean;
+    ambiguous: boolean;
+    reason: string;
+};
+export declare function detectVariantStateDeterministic(browser: Browser, requestedLang?: string, requestedTheme?: 'light' | 'dark'): Promise<VariantStateDetection>;

package/dist/legacy/video-variant-state.js

@@ -0,0 +1,80 @@
+import { evaluateRequestedLanguageState, evaluateRequestedThemeState as evaluateRequestedThemeStateRich, } from '../session-profile.js';
+function normalizeConfidenceScore(confidence) {
+    switch (confidence) {
+        case 'high':
+            return 1;
+        case 'medium':
+            return 0.78;
+        case 'low':
+        default:
+            return 0.58;
+    }
+}
+export function scoreLocaleSignals(signals, requestedLang) {
+    if (!requestedLang)
+        return { score: 1, reasons: [], ambiguous: false };
+    const languageState = evaluateRequestedLanguageState({
+        currentUrl: signals.url,
+        requestedLang,
+        signals,
+    });
+    if (languageState.active) {
+        return {
+            score: normalizeConfidenceScore(languageState.confidence),
+            reasons: languageState.reasons,
+            ambiguous: false,
+        };
+    }
+    if (languageState.ambiguous) {
+        return {
+            score: languageState.confidence === 'high' ? 0.45 : languageState.confidence === 'medium' ? 0.32 : 0.18,
+            reasons: languageState.reasons,
+            ambiguous: true,
+        };
+    }
+    return {
+        score: 0,
+        reasons: languageState.reasons,
+        ambiguous: false,
+    };
+}
+export function evaluateRequestedThemeState(signals, requestedTheme) {
+    const themeState = evaluateRequestedThemeStateRich({
+        requestedTheme,
+        signals,
+    });
+    return {
+        detected: themeState.detected,
+        active: themeState.active,
+        ambiguous: themeState.ambiguous,
+        reason: themeState.reasons.join('; ') || 'no_theme_signal',
+    };
+}
+export async function detectVariantStateDeterministic(browser, requestedLang, requestedTheme) {
+    const signals = await browser.capturePageSignals();
+    const languageState = evaluateRequestedLanguageState({
+        currentUrl: signals.url,
+        requestedLang,
+        signals,
+    });
+    const themeState = evaluateRequestedThemeStateRich({
+        requestedTheme,
+        signals,
+    });
+    return {
+        lang: {
+            requested: requestedLang,
+            detected: languageState.detected,
+            active: requestedLang ? languageState.active : true,
+            ambiguous: requestedLang ? languageState.ambiguous : false,
+        },
+        theme: {
+            requested: requestedTheme,
+            detected: themeState.detected,
+            active: requestedTheme ? themeState.active : true,
+            ambiguous: requestedTheme ? themeState.ambiguous : false,
+        },
+        pageSignals: signals,
+    };
+}
+//# sourceMappingURL=video-variant-state.js.map

package/dist/legacy/vision-model.d.ts

@@ -0,0 +1,17 @@
+export declare class VisionModelUnsupportedError extends Error {
+    requestedModel: string;
+    fallbackModel?: string;
+    constructor(requestedModel: string, fallbackModel?: string);
+}
+export declare function isImageInputUnsupportedError(err: unknown): boolean;
+export declare function buildVisionModelUnavailableMessage(requestedModel: string, fallbackModel?: string): string;
+export declare function callVisionCapableModel<T>(params: {
+    primaryModel: string;
+    fallbackModel?: string;
+    callModel: (model: string) => Promise<T>;
+    onFallbackActivated?: (model: string, reason: string) => void;
+}): Promise<{
+    result: T;
+    model: string;
+    fellBack: boolean;
+}>;

package/dist/legacy/vision-model.js

@@ -0,0 +1,74 @@
+export class VisionModelUnsupportedError extends Error {
+    requestedModel;
+    fallbackModel;
+    constructor(requestedModel, fallbackModel) {
+        super(buildVisionModelUnavailableMessage(requestedModel, fallbackModel));
+        this.name = 'VisionModelUnsupportedError';
+        this.requestedModel = requestedModel;
+        this.fallbackModel = fallbackModel;
+    }
+}
+function extractNestedErrorMessage(err) {
+    if (!err || typeof err !== 'object')
+        return '';
+    const errorRecord = err;
+    const directMessage = typeof errorRecord.message === 'string' ? errorRecord.message : '';
+    const nestedError = errorRecord.error;
+    const nestedMessage = nestedError && typeof nestedError === 'object' && typeof nestedError.message === 'string'
+        ? nestedError.message
+        : '';
+    if (nestedMessage && nestedMessage === directMessage)
+        return directMessage;
+    return [directMessage, nestedMessage].filter(Boolean).join(' ');
+}
+export function isImageInputUnsupportedError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const errorRecord = err;
+    const status = typeof errorRecord.status === 'number' ? errorRecord.status : undefined;
+    const message = extractNestedErrorMessage(err).toLowerCase();
+    if (!message)
+        return false;
+    const mentionsImageEndpoint = message.includes('no endpoints found that support image input')
+        || message.includes('no providers that support image input')
+        || (message.includes('image input') && message.includes('no') && message.includes('support'))
+        || (message.includes('image input') && message.includes('endpoint') && message.includes('no'));
+    if (!mentionsImageEndpoint)
+        return false;
+    return status === undefined || status === 400 || status === 404 || status === 422;
+}
+export function buildVisionModelUnavailableMessage(requestedModel, fallbackModel) {
+    const fallbackHint = fallbackModel && fallbackModel !== requestedModel
+        ? ` Automatic fallback to "${fallbackModel}" also failed or was unavailable.`
+        : '';
+    return `The model "${requestedModel}" has no available endpoint that supports image input.${fallbackHint} Configure a vision-capable default/fallback model or retry later if the provider is degraded.`;
+}
+export async function callVisionCapableModel(params) {
+    const { primaryModel, fallbackModel, callModel, onFallbackActivated } = params;
+    let fallbackReason = '';
+    try {
+        const result = await callModel(primaryModel);
+        return { result, model: primaryModel, fellBack: false };
+    }
+    catch (err) {
+        if (!isImageInputUnsupportedError(err)) {
+            throw err;
+        }
+        fallbackReason = extractNestedErrorMessage(err) || 'image input unsupported';
+        if (!fallbackModel || fallbackModel === primaryModel) {
+            throw new VisionModelUnsupportedError(primaryModel, fallbackModel);
+        }
+    }
+    try {
+        const result = await callModel(fallbackModel);
+        onFallbackActivated?.(fallbackModel, fallbackReason);
+        return { result, model: fallbackModel, fellBack: true };
+    }
+    catch (fallbackErr) {
+        if (isImageInputUnsupportedError(fallbackErr)) {
+            throw new VisionModelUnsupportedError(primaryModel, fallbackModel);
+        }
+        throw fallbackErr;
+    }
+}
+//# sourceMappingURL=vision-model.js.map

package/dist/llm-healer.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Capture Agent — LLM Healer
+ *
+ * Last-resort recovery: when all deterministic strategies fail,
+ * the healer asks an LLM to analyze the current page state and
+ * produce a bounded selector patch.
+ */
+import type { ExecutionOpcode, HealerPatch } from './execution-types.js';
+import type { LLMCallResult } from './llm-provider.js';
+export interface HealerContext {
+    /** The failed opcode */
+    failedOpcode: ExecutionOpcode;
+    /** Index in the program */
+    opcodeIndex: number;
+    /** Serialized AKTree of the current page */
+    akTreeSerialized: string;
+    /** Current page URL */
+    currentUrl: string;
+    /** Screenshot buffer (for multimodal models) */
+    screenshot?: Buffer;
+    /** The 3 opcodes before and after the failed one (for context) */
+    surroundingOpcodes: ExecutionOpcode[];
+    /** Error message from the failed attempt */
+    errorMessage: string;
+}
+export interface HealerResult {
+    healed: boolean;
+    patch?: HealerPatch;
+    reason: string;
+    /** Raw LLM usage for this healing attempt */
+    llmResult?: LLMCallResult;
+}
+export interface HealerLLMProvider {
+    /**
+     * Call the LLM with a healing prompt. Returns raw JSON string.
+     * The provider handles model selection, API keys, etc.
+     */
+    call(prompt: string, screenshot?: Buffer): Promise<{
+        response: string;
+        llmResult: LLMCallResult;
+    }>;
+}
+/**
+ * The LLM Healer — a constrained agent that repairs failed selectors.
+ */
+export declare class LLMHealer {
+    private llmProvider;
+    private invocationCount;
+    private maxInvocations;
+    constructor(llmProvider: HealerLLMProvider, options?: {
+        maxInvocations?: number;
+    });
+    get remainingInvocations(): number;
+    heal(context: HealerContext): Promise<HealerResult>;
+}

package/dist/llm-healer.js

@@ -0,0 +1,213 @@
+/**
+ * Capture Agent — LLM Healer
+ *
+ * Last-resort recovery: when all deterministic strategies fail,
+ * the healer asks an LLM to analyze the current page state and
+ * produce a bounded selector patch.
+ */
+/**
+ * The LLM Healer — a constrained agent that repairs failed selectors.
+ */
+export class LLMHealer {
+    llmProvider;
+    invocationCount = 0;
+    maxInvocations;
+    constructor(llmProvider, options) {
+        this.llmProvider = llmProvider;
+        this.maxInvocations = options?.maxInvocations ?? 3;
+    }
+    get remainingInvocations() {
+        return Math.max(0, this.maxInvocations - this.invocationCount);
+    }
+    async heal(context) {
+        if (this.invocationCount >= this.maxInvocations) {
+            return { healed: false, reason: `healer budget exhausted (${this.maxInvocations}/${this.maxInvocations} used)` };
+        }
+        this.invocationCount++;
+        try {
+            const prompt = buildHealerPrompt(context);
+            const { response, llmResult } = await this.llmProvider.call(prompt, context.screenshot);
+            const parsed = parseHealerResponse(response);
+            if (!parsed) {
+                return { healed: false, reason: 'healer produced invalid response', llmResult };
+            }
+            if (parsed.cannotHeal) {
+                return { healed: false, reason: parsed.reason ?? 'healer cannot resolve this failure', llmResult };
+            }
+            const replacementOpcode = buildReplacementOpcode(context.failedOpcode, parsed);
+            if (!replacementOpcode) {
+                return { healed: false, reason: 'healer could not produce a bounded selector patch', llmResult };
+            }
+            const patch = {
+                opcodeIndex: context.opcodeIndex,
+                originalOpcode: context.failedOpcode,
+                replacementOpcodes: [replacementOpcode],
+                patchType: 'selector_patch',
+                interactionMode: parsed.interactionMode,
+                reason: parsed.reason ?? 'healer selector repair',
+                patchedAt: new Date().toISOString(),
+            };
+            return { healed: true, patch, reason: patch.reason, llmResult };
+        }
+        catch (err) {
+            return {
+                healed: false,
+                reason: `healer error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+}
+function buildHealerPrompt(context) {
+    const { failedOpcode, errorMessage, akTreeSerialized, currentUrl, surroundingOpcodes } = context;
+    const selector = hasPatchableSelector(failedOpcode) ? failedOpcode.selector : null;
+    const surroundingDesc = surroundingOpcodes
+        .map((op, i) => `  ${i + 1}. ${op.kind}: ${sanitizePromptText(op.description)}`)
+        .join('\n');
+    return `You are a web automation repair agent. An opcode in a deterministic browser automation program has failed. Your job is to repair the selector only.
+
+## Failed Opcode
+Kind: ${failedOpcode.kind}
+Description: ${sanitizePromptText(failedOpcode.description)}
+Selector: ${selector ?? '<unsupported>'}
+
+## Error
+<<<ERROR>>>
+${sanitizePromptText(errorMessage)}
+<<<END_ERROR>>>
+
+## Current Page
+URL: ${sanitizeUrlForPrompt(currentUrl)}
+
+## AKTree (current page structure)
+<<<AKTREE>>>
+${sanitizePromptText(akTreeSerialized).slice(0, 8000)}
+<<<END_AKTREE>>>
+
+## Surrounding Opcodes (context)
+${surroundingDesc}
+
+## Rules
+1. You MUST NOT emit opcodes or navigation targets.
+2. You may only return a selector patch for the existing opcode.
+3. You may optionally return a bounded interaction mode: default, keyboard, js_dispatch, or coordinates.
+4. Use selectors you can actually see in the AKTree above.
+5. If the opcode kind is unsupported or there is no reliable selector, return cannotHeal=true.
+
+## Response Format
+Respond with a JSON object:
+{
+  "cannotHeal": false,
+  "reason": "explanation of what you changed",
+  "selector": "[data-ak='submit']",
+  "selectorAlternates": ["button[type='submit']"],
+  "interactionMode": "default"
+}
+
+Or if you cannot fix it:
+{
+  "cannotHeal": true,
+  "reason": "explanation of why this cannot be fixed"
+}
+
+Respond ONLY with the JSON object, no markdown, no explanation outside JSON.`;
+}
+function parseHealerResponse(response) {
+    try {
+        const jsonStr = response
+            .replace(/```json\s*/g, '')
+            .replace(/```\s*/g, '')
+            .trim();
+        const parsed = JSON.parse(jsonStr);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        if (parsed.cannotHeal) {
+            return {
+                cannotHeal: true,
+                reason: typeof parsed.reason === 'string' ? parsed.reason : null,
+                selector: null,
+                selectorAlternates: [],
+                interactionMode: 'default',
+            };
+        }
+        const selector = typeof parsed.selector === 'string' && parsed.selector.trim()
+            ? parsed.selector.trim()
+            : null;
+        if (!selector)
+            return null;
+        return {
+            cannotHeal: false,
+            reason: typeof parsed.reason === 'string' ? parsed.reason : null,
+            selector,
+            selectorAlternates: Array.isArray(parsed.selectorAlternates)
+                ? parsed.selectorAlternates
+                    .filter((entry) => typeof entry === 'string' && entry.trim().length > 0)
+                    .map((entry) => entry.trim())
+                    .slice(0, 5)
+                : [],
+            interactionMode: parsed.interactionMode === 'keyboard'
+                || parsed.interactionMode === 'js_dispatch'
+                || parsed.interactionMode === 'coordinates'
+                ? parsed.interactionMode
+                : 'default',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function hasPatchableSelector(opcode) {
+    return ((opcode.kind === 'CLICK'
+        || opcode.kind === 'TYPE'
+        || opcode.kind === 'WAIT_FOR'
+        || opcode.kind === 'HOVER'
+        || opcode.kind === 'SELECT_OPTION'
+        || opcode.kind === 'CHECK'
+        || opcode.kind === 'DOUBLE_CLICK')
+        && typeof opcode.selector === 'string'
+        && opcode.selector.trim().length > 0);
+}
+function buildReplacementOpcode(failedOpcode, parsed) {
+    if (!hasPatchableSelector(failedOpcode) || !parsed.selector) {
+        return null;
+    }
+    switch (failedOpcode.kind) {
+        case 'CLICK':
+        case 'TYPE':
+        case 'WAIT_FOR':
+        case 'HOVER':
+        case 'SELECT_OPTION':
+        case 'CHECK':
+        case 'DOUBLE_CLICK':
+            return {
+                ...failedOpcode,
+                selector: parsed.selector,
+                ...('selectorAlternates' in failedOpcode
+                    ? { selectorAlternates: parsed.selectorAlternates }
+                    : {}),
+            };
+        default:
+            return null;
+    }
+}
+function sanitizePromptText(value) {
+    return value
+        .replace(/\{\{(email|password|loginUrl)\}\}/g, '<credential-placeholder>')
+        .replace(/data:[^"' )]+/gi, '<data-url>')
+        .replace(/https?:\/\/[^\s"'<>]+/gi, (match) => sanitizeUrlForPrompt(match))
+        .replace(/[^\x09\x0a\x0d\x20-\x7e]/g, ' ')
+        .slice(0, 12_000);
+}
+function sanitizeUrlForPrompt(value) {
+    try {
+        const parsed = new URL(value);
+        parsed.username = '';
+        parsed.password = '';
+        parsed.search = parsed.search ? '?<redacted>' : '';
+        parsed.hash = parsed.hash ? '#<redacted>' : '';
+        return parsed.toString();
+    }
+    catch {
+        return value.slice(0, 512);
+    }
+}
+//# sourceMappingURL=llm-healer.js.map

package/dist/llm-provider.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Capture Agent — LLM Provider
+ *
+ * Thin wrapper around OpenAI SDK for OpenRouter calls.
+ * Used by: capture verification, alt text generation, healer.
+ */
+export interface LLMCallResult {
+    text: string;
+    model: string;
+    promptTokens: number;
+    completionTokens: number;
+    costEur: number;
+    /** OpenRouter generation ID for async cost resolution */
+    generationId: string | null;
+}
+export interface LLMProviderConfig {
+    apiKey: string;
+    /** Model to use. Default: google/gemini-2.5-flash */
+    model?: string;
+    /** Max tokens for response. Default: 200 */
+    maxTokens?: number;
+    /** Timeout in ms. Default: 15000 */
+    timeoutMs?: number;
+}
+/**
+ * Makes a single LLM call with optional image input.
+ * Returns the text response and usage metadata.
+ */
+export declare function callLLM(config: LLMProviderConfig, systemPrompt: string, userContent: string, image?: Buffer): Promise<LLMCallResult>;

package/dist/llm-provider.js

@@ -0,0 +1,83 @@
+/**
+ * Capture Agent — LLM Provider
+ *
+ * Thin wrapper around OpenAI SDK for OpenRouter calls.
+ * Used by: capture verification, alt text generation, healer.
+ */
+import OpenAI from 'openai';
+import { createOpenRouterCompletion } from './openrouter-client.js';
+import { assertZdrCompatibleModel, zdrParam } from './provider-config.js';
+const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
+const DEFAULT_MODEL = 'google/gemini-2.5-flash';
+/**
+ * Makes a single LLM call with optional image input.
+ * Returns the text response and usage metadata.
+ */
+export async function callLLM(config, systemPrompt, userContent, image) {
+    const client = new OpenAI({
+        baseURL: OPENROUTER_BASE_URL,
+        apiKey: config.apiKey,
+    });
+    const model = config.model ?? DEFAULT_MODEL;
+    const maxTokens = config.maxTokens ?? 200;
+    assertZdrCompatibleModel(model);
+    const messages = [
+        { role: 'system', content: systemPrompt },
+    ];
+    if (image) {
+        const base64 = image.toString('base64');
+        messages.push({
+            role: 'user',
+            content: [
+                { type: 'text', text: userContent },
+                {
+                    type: 'image_url',
+                    image_url: { url: `data:image/png;base64,${base64}`, detail: 'low' },
+                },
+            ],
+        });
+    }
+    else {
+        messages.push({ role: 'user', content: userContent });
+    }
+    const params = {
+        model,
+        messages,
+        max_tokens: maxTokens,
+        temperature: 0.1,
+        provider: Object.keys(zdrParam()).length > 0 ? zdrParam() : undefined,
+    };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), config.timeoutMs ?? 15000);
+    try {
+        const response = await createOpenRouterCompletion(client, params, { signal: controller.signal });
+        clearTimeout(timer);
+        const text = response.choices?.[0]?.message?.content?.trim() ?? '';
+        const usage = response.usage;
+        return {
+            text,
+            model: response.model ?? model,
+            promptTokens: usage?.prompt_tokens ?? 0,
+            completionTokens: usage?.completion_tokens ?? 0,
+            costEur: estimateCost(model, usage?.prompt_tokens ?? 0, usage?.completion_tokens ?? 0),
+            generationId: response.id ?? null,
+        };
+    }
+    catch (err) {
+        clearTimeout(timer);
+        throw err;
+    }
+}
+/**
+ * Rough cost estimation based on known model pricing.
+ * Actual cost is resolved asynchronously via OpenRouter generation API.
+ */
+function estimateCost(model, promptTokens, completionTokens) {
+    // Gemini 2.5 Flash pricing (approximate)
+    if (model.includes('gemini')) {
+        return (promptTokens * 0.15 + completionTokens * 0.6) / 1_000_000;
+    }
+    // Fallback: conservative estimate
+    return (promptTokens * 0.5 + completionTokens * 1.5) / 1_000_000;
+}
+//# sourceMappingURL=llm-provider.js.map

package/dist/logger.d.ts

@@ -1,4 +1,4 @@
-export type LogLevel = 'info' | 'action' | 'success' | 'error' | 'ai';
+export type LogLevel = 'info' | 'warn' | 'action' | 'success' | 'error' | 'ai';
 export type LogKind = 'reasoning' | 'action' | 'system' | 'guidance';
 export interface LogEntry {
     level: LogLevel;
@@ -25,6 +25,8 @@ interface LoggerContext {
     onScreenshot?: OnScreenshotCallback | null;
     onReasoningDelta?: OnReasoningDeltaCallback | null;
 }
+export declare function setDebugEnabled(enabled: boolean): void;
+export declare function isDebugEnabled(): boolean;
 export declare function runWithLoggerCallbacks<T>(callbacks: LoggerContext, fn: () => Promise<T>): Promise<T>;
 export declare function setOnLog(cb: OnLogCallback | null): void;
 export declare function setOnScreenshot(cb: OnScreenshotCallback | null): void;
@@ -33,8 +35,10 @@ export declare function emitReasoningDelta(delta: string, messageId: string): vo
 export declare const logger: {
     /** User-visible informational log — shown in both console and UI. */
     info(msg: string): void;
-    /** Internal debug log — console only, NOT emitted to the UI callback. */
+    /** Internal debug log — only printed when --debug is enabled. Console only, NOT emitted to the UI callback. */
     debug(msg: string): void;
+    /** Security / rate-limit warnings — emitted to both console and UI. */
+    warn(msg: string): void;
     action(iteration: number, maxIter: number, action: string, params: Record<string, unknown>, context?: {
         lang?: string;
         theme?: string;

package/dist/logger.js

@@ -2,7 +2,14 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import chalk from 'chalk';
 let _onLog = null;
 let _onScreenshot = null;
+let _debugEnabled = false;
 const _loggerContext = new AsyncLocalStorage();
+export function setDebugEnabled(enabled) {
+    _debugEnabled = enabled;
+}
+export function isDebugEnabled() {
+    return _debugEnabled;
+}
 export async function runWithLoggerCallbacks(callbacks, fn) {
     return _loggerContext.run(callbacks, fn);
 }
@@ -42,10 +49,17 @@ export const logger = {
         console.log(chalk.cyan('[INFO]'), msg);
         emit({ level: 'info', message: msg, timestamp: Date.now(), kind: 'system' });
     },
-    /** Internal debug log — console only, NOT emitted to the UI callback. */
+    /** Internal debug log — only printed when --debug is enabled. Console only, NOT emitted to the UI callback. */
     debug(msg) {
+        if (!_debugEnabled)
+            return;
         console.log(chalk.gray('[DEBUG]'), msg);
     },
+    /** Security / rate-limit warnings — emitted to both console and UI. */
+    warn(msg) {
+        console.log(chalk.yellow('[WARN]'), msg);
+        emit({ level: 'warn', message: msg, timestamp: Date.now(), kind: 'system' });
+    },
     action(iteration, maxIter, action, params, context) {
         const paramsStr = Object.entries(params)
             .map(([k, v]) => `${k}=${JSON.stringify(v)}`)