screenhand 0.2.0 → 0.3.1

package/dist/src/recovery/engine.js

@@ -0,0 +1,327 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+// This file is part of ScreenHand.
+//
+// ScreenHand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3.
+//
+// ScreenHand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with ScreenHand. If not, see <https://www.gnu.org/licenses/>.
+import fs from "node:fs";
+import path from "node:path";
+import { detectBlockers } from "./detectors.js";
+import { getBuiltinStrategies, parseReferenceStrategies, buildStrategyWithContext, } from "./strategies.js";
+const DEFAULT_CONFIG = {
+    referencesDir: path.join(process.cwd(), "references"),
+};
+const STRATEGY_COOLDOWN_MS = 30_000; // 30 seconds
+export class RecoveryEngine {
+    worldModel;
+    executeTool;
+    memory;
+    config;
+    referenceCache = new Map();
+    /** Map of "blockerType:strategyId" → cooldown entry */
+    strategyCooldowns = new Map();
+    learningEngine = null;
+    constructor(worldModel, executeTool, memory, config) {
+        this.worldModel = worldModel;
+        this.executeTool = executeTool;
+        this.memory = memory;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Inject the learning engine for recording recovery outcomes.
+     * Called after both engines are constructed (avoids circular dependency).
+     */
+    setLearningEngine(engine) {
+        this.learningEngine = engine;
+    }
+    /**
+     * Get the current status of the recovery engine.
+     */
+    getStatus() {
+        return {
+            cooldownCount: this.strategyCooldowns.size,
+            referenceCacheSize: this.referenceCache.size,
+            learningEngineConnected: this.learningEngine !== null,
+        };
+    }
+    /**
+     * Update the default recovery budget configuration.
+     */
+    configure(partial) {
+        Object.assign(this.config, partial);
+    }
+    /**
+     * Attempt to recover from a step failure.
+     * Called by PlanExecutor after a step fails, before replanning.
+     */
+    async attemptRecovery(failedStepError, expectedBundleId, budget) {
+        const budgetStart = Date.now();
+        // Detect blockers
+        const blockers = detectBlockers(this.worldModel, failedStepError, expectedBundleId);
+        // Try strategies for each blocker in priority order
+        for (const blocker of blockers) {
+            if (Date.now() - budgetStart >= budget.maxRecoveryTimeMs) {
+                return { recovered: false, reason: "budget_exhausted" };
+            }
+            const strategies = this.selectStrategies(blocker, budget);
+            for (const strategy of strategies) {
+                if (Date.now() - budgetStart >= budget.maxRecoveryTimeMs) {
+                    return { recovered: false, reason: "budget_exhausted" };
+                }
+                if (budget.usedStrategyIds.size >= budget.maxStrategies) {
+                    return { recovered: false, reason: "budget_exhausted" };
+                }
+                budget.usedStrategyIds.add(strategy.id);
+                const outcome = await this.executeStrategy(strategy, blocker, budgetStart, budget);
+                if (outcome.recovered)
+                    return outcome;
+            }
+        }
+        return { recovered: false, reason: "all_strategies_failed" };
+    }
+    /**
+     * Select strategies for a blocker: reference-based first, then built-in.
+     * Excludes already-used strategies.
+     */
+    selectStrategies(blocker, budget) {
+        const candidates = [];
+        // Reference strategies first (app-specific)
+        if (blocker.bundleId) {
+            const refErrors = this.loadReferenceErrors(blocker.bundleId);
+            candidates.push(...parseReferenceStrategies(refErrors, blocker.type));
+        }
+        // Then built-in
+        candidates.push(...getBuiltinStrategies(blocker.type));
+        const now = Date.now();
+        const available = candidates.filter((s) => {
+            if (budget.usedStrategyIds.has(s.id))
+                return false;
+            // Check cooldown — skip strategies that failed recently for this blocker type
+            const cooldownKey = `${blocker.type}:${s.id}`;
+            const entry = this.strategyCooldowns.get(cooldownKey);
+            if (entry && now - entry.failedAt < STRATEGY_COOLDOWN_MS)
+                return false;
+            return true;
+        });
+        // Re-order by learning engine ranking if available
+        if (this.learningEngine && blocker.bundleId) {
+            const ranked = this.learningEngine.rankRecoveryStrategies(blocker.type, blocker.bundleId);
+            if (ranked.length > 0) {
+                const rankMap = new Map(ranked.map((r, i) => [r.strategyId, i]));
+                available.sort((a, b) => {
+                    const ra = rankMap.get(a.id) ?? 999;
+                    const rb = rankMap.get(b.id) ?? 999;
+                    return ra - rb;
+                });
+            }
+        }
+        return available;
+    }
+    /**
+     * Execute a strategy's steps and verify recovery.
+     */
+    async executeStrategy(rawStrategy, blocker, budgetStart, budget) {
+        const start = Date.now();
+        const strategy = buildStrategyWithContext(rawStrategy, blocker.bundleId, blocker.pid);
+        // Escalation strategies (empty steps) — cannot auto-recover
+        if (strategy.steps.length === 0) {
+            this.recordEvent({
+                timestamp: new Date().toISOString(),
+                blocker,
+                strategyId: strategy.id,
+                strategyLabel: strategy.label,
+                success: false,
+                durationMs: 0,
+                error: "escalation_required",
+            });
+            return { recovered: false, reason: "all_strategies_failed" };
+        }
+        // Execute each step
+        for (const step of strategy.steps) {
+            if (Date.now() - budgetStart >= budget.maxRecoveryTimeMs) {
+                return { recovered: false, reason: "budget_exhausted" };
+            }
+            try {
+                const result = await this.executeTool(step.tool, step.params);
+                if (!result.ok) {
+                    this.recordEvent({
+                        timestamp: new Date().toISOString(),
+                        blocker,
+                        strategyId: strategy.id,
+                        strategyLabel: strategy.label,
+                        success: false,
+                        durationMs: Date.now() - start,
+                        error: result.error ?? "tool failed",
+                    });
+                    this.strategyCooldowns.set(`${blocker.type}:${strategy.id}`, { failedAt: Date.now() });
+                    return { recovered: false, reason: "all_strategies_failed" };
+                }
+            }
+            catch (err) {
+                this.recordEvent({
+                    timestamp: new Date().toISOString(),
+                    blocker,
+                    strategyId: strategy.id,
+                    strategyLabel: strategy.label,
+                    success: false,
+                    durationMs: Date.now() - start,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                this.strategyCooldowns.set(`${blocker.type}:${strategy.id}`, { failedAt: Date.now() });
+                return { recovered: false, reason: "all_strategies_failed" };
+            }
+        }
+        // Verify recovery
+        await sleep(300);
+        const verified = this.verifyRecovery(blocker);
+        const durationMs = Date.now() - start;
+        this.recordEvent({
+            timestamp: new Date().toISOString(),
+            blocker,
+            strategyId: strategy.id,
+            strategyLabel: strategy.label,
+            success: verified,
+            durationMs,
+            error: verified ? null : "verification failed",
+        });
+        // Feed learning engine with recovery outcome
+        if (this.learningEngine && blocker.bundleId) {
+            this.learningEngine.recordRecoveryOutcome({
+                bundleId: blocker.bundleId,
+                blockerType: blocker.type,
+                strategyId: strategy.id,
+                success: verified,
+                durationMs,
+            });
+        }
+        if (verified) {
+            // Clear cooldown on success
+            this.strategyCooldowns.delete(`${blocker.type}:${strategy.id}`);
+            return { recovered: true, strategyId: strategy.id, durationMs };
+        }
+        // Record cooldown for failed strategy
+        this.strategyCooldowns.set(`${blocker.type}:${strategy.id}`, { failedAt: Date.now() });
+        return { recovered: false, reason: "all_strategies_failed" };
+    }
+    /**
+     * Verify the blocker is resolved by re-checking world model state.
+     */
+    verifyRecovery(blocker) {
+        switch (blocker.type) {
+            case "unexpected_dialog":
+            case "permission_dialog":
+            case "login_required":
+            case "captcha": {
+                const dialogs = this.worldModel.getActiveDialogs();
+                if (blocker.dialogTitle) {
+                    return !dialogs.some((d) => d.title === blocker.dialogTitle);
+                }
+                return dialogs.length === 0;
+            }
+            case "focus_lost": {
+                if (!blocker.bundleId)
+                    return false;
+                return this.worldModel.getState().focusedApp?.bundleId === blocker.bundleId;
+            }
+            case "app_crashed": {
+                return this.worldModel.getState().windows.size > 0;
+            }
+            case "element_gone": {
+                // The element should be back — verify focused window has controls
+                const win = this.worldModel.getFocusedWindow();
+                if (!win)
+                    return false;
+                return win.controls.size > 0;
+            }
+            case "selector_drift": {
+                // After recovery, controls should be findable — verify the focused window
+                // has recently updated controls (not all stale)
+                const win = this.worldModel.getFocusedWindow();
+                if (!win)
+                    return false;
+                if (win.controls.size === 0)
+                    return false;
+                const stale = this.worldModel.getStaleControls(5_000);
+                return stale.length < win.controls.size;
+            }
+            case "unknown_state": {
+                // State should be less stale after recovery — check stale count is low
+                const state = this.worldModel.getState();
+                if (state.windows.size === 0)
+                    return false;
+                const stale = this.worldModel.getStaleControls(5_000);
+                let totalControls = 0;
+                for (const w of state.windows.values()) {
+                    totalControls += w.controls.size;
+                }
+                // Pass if fewer than half of controls are stale
+                return totalControls > 0 && stale.length < totalControls / 2;
+            }
+            case "loading_stuck": {
+                // UI should have changed — verify state was updated recently (within 2s)
+                const state = this.worldModel.getState();
+                const ageMs = Date.now() - new Date(state.updatedAt).getTime();
+                return ageMs < 2_000;
+            }
+            case "network_error":
+            case "rate_limited": {
+                // Transient errors — verify state was refreshed recently (within 3s)
+                const state = this.worldModel.getState();
+                const ageMs = Date.now() - new Date(state.updatedAt).getTime();
+                return ageMs < 3_000;
+            }
+        }
+    }
+    /**
+     * Load and cache reference errors for a bundleId.
+     */
+    loadReferenceErrors(bundleId) {
+        const cached = this.referenceCache.get(bundleId);
+        if (cached !== undefined)
+            return cached;
+        let errors = [];
+        try {
+            const files = fs.readdirSync(this.config.referencesDir);
+            for (const file of files) {
+                if (!file.endsWith(".json"))
+                    continue;
+                try {
+                    // Guard against oversized files (same 10MB limit as LearningEngine)
+                    const filePath = path.join(this.config.referencesDir, file);
+                    const stat = fs.statSync(filePath);
+                    if (stat.size > 10 * 1024 * 1024)
+                        continue;
+                    const raw = fs.readFileSync(filePath, "utf-8");
+                    const ref = JSON.parse(raw);
+                    if (ref.bundleId === bundleId && Array.isArray(ref.errors)) {
+                        errors = ref.errors.filter((e) => typeof e.error === "string" && typeof e.solution === "string");
+                        break;
+                    }
+                }
+                catch { /* skip malformed */ }
+            }
+        }
+        catch { /* dir doesn't exist */ }
+        this.referenceCache.set(bundleId, errors);
+        return errors;
+    }
+    recordEvent(event) {
+        try {
+            this.memory.recordError(`recovery:${event.strategyId}`, event.error ?? "", event.success ? event.strategyLabel : null, event.blocker.bundleId ?? undefined);
+        }
+        catch { /* best-effort */ }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/src/recovery/index.js

@@ -0,0 +1,20 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+// This file is part of ScreenHand.
+//
+// ScreenHand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3.
+//
+// ScreenHand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with ScreenHand. If not, see <https://www.gnu.org/licenses/>.
+export { RecoveryEngine } from "./engine.js";
+export { detectBlockers } from "./detectors.js";
+export { getBuiltinStrategies, parseReferenceStrategies } from "./strategies.js";
+export { DEFAULT_RECOVERY_BUDGET } from "./types.js";

package/dist/src/recovery/strategies.js

@@ -0,0 +1,274 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+// This file is part of ScreenHand.
+//
+// ScreenHand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3.
+//
+// ScreenHand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with ScreenHand. If not, see <https://www.gnu.org/licenses/>.
+/**
+ * Built-in recovery strategies keyed by BlockerType, in priority order.
+ * Strategies with empty steps are escalations — they signal that human
+ * intervention is needed.
+ */
+const BUILTIN_STRATEGIES = [
+    // ── unexpected_dialog ──
+    {
+        id: "dismiss_dialog_cancel",
+        blockerType: "unexpected_dialog",
+        label: "Dismiss dialog via Cancel",
+        steps: [{ tool: "click_text", params: { text: "Cancel" }, description: "Click Cancel" }],
+        postcondition: null,
+        source: "builtin",
+    },
+    {
+        id: "dismiss_dialog_ok",
+        blockerType: "unexpected_dialog",
+        label: "Dismiss dialog via OK",
+        steps: [{ tool: "click_text", params: { text: "OK" }, description: "Click OK" }],
+        postcondition: null,
+        source: "builtin",
+    },
+    {
+        id: "dismiss_dialog_escape",
+        blockerType: "unexpected_dialog",
+        label: "Dismiss dialog via Escape",
+        steps: [{ tool: "key", params: { combo: "Escape" }, description: "Press Escape" }],
+        postcondition: null,
+        source: "builtin",
+    },
+    // ── permission_dialog ──
+    {
+        id: "grant_permission_allow",
+        blockerType: "permission_dialog",
+        label: "Grant permission via Allow",
+        steps: [{ tool: "click_text", params: { text: "Allow" }, description: "Click Allow" }],
+        postcondition: null,
+        source: "builtin",
+    },
+    {
+        id: "grant_permission_ok",
+        blockerType: "permission_dialog",
+        label: "Grant permission via OK",
+        steps: [{ tool: "click_text", params: { text: "OK" }, description: "Click OK" }],
+        postcondition: null,
+        source: "builtin",
+    },
+    {
+        id: "safari_allow_popup",
+        blockerType: "permission_dialog",
+        label: "Allow Safari popup via notification bar",
+        steps: [
+            { tool: "key", params: { combo: "cmd+z" }, description: "Undo popup block (shows notification)" },
+            { tool: "screenshot", params: {}, description: "Check for popup notification bar" },
+        ],
+        postcondition: null,
+        source: "builtin",
+    },
+    {
+        id: "safari_enable_popups_applescript",
+        blockerType: "permission_dialog",
+        label: "Enable popups for site via AppleScript",
+        steps: [
+            { tool: "applescript", params: { script: 'tell application "Safari" to activate' }, description: "Activate Safari" },
+            { tool: "key", params: { combo: "cmd+," }, description: "Open Safari preferences" },
+            { tool: "screenshot", params: {}, description: "Navigate to popup settings" },
+        ],
+        postcondition: null,
+        source: "builtin",
+    },
+    // ── focus_lost ──
+    {
+        id: "refocus_app",
+        blockerType: "focus_lost",
+        label: "Refocus target application",
+        steps: [{ tool: "focus", params: {}, description: "Focus target app" }],
+        postcondition: null,
+        source: "builtin",
+    },
+    // ── app_crashed ──
+    {
+        id: "relaunch_app",
+        blockerType: "app_crashed",
+        label: "Relaunch crashed application",
+        steps: [
+            { tool: "launch", params: {}, description: "Launch application" },
+            { tool: "screenshot", params: {}, description: "Wait for app ready" },
+        ],
+        postcondition: null,
+        source: "builtin",
+    },
+    // ── element_gone ──
+    {
+        id: "rescan_ax_tree",
+        blockerType: "element_gone",
+        label: "Rescan AX tree to relocate element",
+        steps: [{ tool: "ui_tree", params: {}, description: "Refresh AX tree" }],
+        postcondition: null,
+        source: "builtin",
+    },
+    // ── selector_drift ──
+    {
+        id: "rescan_for_drift",
+        blockerType: "selector_drift",
+        label: "Rescan AX tree for selector drift",
+        steps: [{ tool: "ui_tree", params: {}, description: "Rescan for drift" }],
+        postcondition: null,
+        source: "builtin",
+    },
+    // ── loading_stuck ──
+    {
+        id: "wait_for_load",
+        blockerType: "loading_stuck",
+        label: "Wait and recheck",
+        steps: [{ tool: "screenshot", params: {}, description: "Wait via screenshot" }],
+        postcondition: null,
+        source: "builtin",
+    },
+    // ── network_error ──
+    {
+        id: "reload_page",
+        blockerType: "network_error",
+        label: "Reload page",
+        steps: [{ tool: "key", params: { combo: "cmd+r" }, description: "Reload page" }],
+        postcondition: null,
+        source: "builtin",
+    },
+    // ── unknown_state ──
+    {
+        id: "full_perception_refresh",
+        blockerType: "unknown_state",
+        label: "Full perception refresh",
+        steps: [
+            { tool: "screenshot", params: {}, description: "Take screenshot" },
+            { tool: "ui_tree", params: {}, description: "Refresh AX tree" },
+        ],
+        postcondition: null,
+        source: "builtin",
+    },
+    // ── Escalation-only (no automated recovery possible) ──
+    {
+        id: "escalate_login",
+        blockerType: "login_required",
+        label: "Escalate: login required",
+        steps: [],
+        postcondition: null,
+        source: "builtin",
+    },
+    {
+        id: "escalate_captcha",
+        blockerType: "captcha",
+        label: "Escalate: captcha",
+        steps: [],
+        postcondition: null,
+        source: "builtin",
+    },
+    {
+        id: "escalate_rate_limited",
+        blockerType: "rate_limited",
+        label: "Escalate: rate limited",
+        steps: [],
+        postcondition: null,
+        source: "builtin",
+    },
+];
+/** Return built-in strategies matching a blocker type, in priority order. */
+export function getBuiltinStrategies(blockerType) {
+    return BUILTIN_STRATEGIES.filter((s) => s.blockerType === blockerType);
+}
+/**
+ * Parse a solution text into concrete recovery steps.
+ * Pattern-matches common instruction phrases to map to tool calls.
+ * Falls back to screenshot with full solution as description.
+ */
+export function parseSolutionToSteps(solution) {
+    const steps = [];
+    // Split multi-sentence solutions into individual instructions
+    const sentences = solution.split(/[.;]\s+/).filter((s) => s.trim().length > 5);
+    if (sentences.length === 0)
+        sentences.push(solution);
+    for (const sentence of sentences) {
+        const lower = sentence.toLowerCase();
+        const step = matchSolutionSentence(lower, sentence);
+        steps.push(step);
+    }
+    return steps;
+}
+function matchSolutionSentence(lower, original) {
+    // Click/tap/select patterns
+    const clickMatch = lower.match(/(?:click|tap|select|choose|press)\s+(?:the\s+)?['"]?([^'",.]+)['"]?/i);
+    if (clickMatch && !/(?:cmd|ctrl|alt|shift|command)/i.test(clickMatch[1])) {
+        // Trim trailing filler words like "button and wait", "and then", "to confirm"
+        let clickText = clickMatch[1].trim()
+            .replace(/\s+(?:button|link|icon|tab|menu|option)(?:\s+.*)?$/i, "")
+            .replace(/\s+(?:and\s+.*|to\s+.*|in\s+.*|on\s+.*|from\s+.*|into\s+.*)$/i, "")
+            .trim();
+        if (!clickText)
+            clickText = clickMatch[1].trim();
+        return { tool: "click_text", params: { text: clickText }, description: original };
+    }
+    // Keyboard shortcut patterns
+    const keyMatch = lower.match(/(?:press|use|hit)\s+(?:the\s+)?(?:shortcut\s+)?((?:cmd|ctrl|alt|shift|command|control|option)[\s+]+\w+)/i);
+    if (keyMatch) {
+        const key = keyMatch[1].replace(/\s+/g, "+").replace(/command/i, "Cmd").replace(/control/i, "Ctrl");
+        return { tool: "key", params: { combo: key }, description: original };
+    }
+    // Navigate/go to/open URL patterns
+    const navMatch = lower.match(/(?:navigate\s+to|go\s+to|open|visit)\s+(?:the\s+)?(?:url\s+)?(https?:\/\/\S+)/i);
+    if (navMatch) {
+        const url = navMatch[1];
+        // Reject javascript: and data: URLs
+        if (/^javascript:/i.test(url) || /^data:/i.test(url)) {
+            return { tool: "screenshot", params: {}, description: `Blocked unsafe URL: ${original}` };
+        }
+        return { tool: "browser_navigate", params: { url }, description: original };
+    }
+    // Type/enter/input patterns
+    const typeMatch = lower.match(/(?:type|enter|input)\s+['"]?([^'",.]+)['"]?/i);
+    if (typeMatch) {
+        return { tool: "type_text", params: { text: typeMatch[1].trim() }, description: original };
+    }
+    // Fallback: screenshot with full solution as description
+    return { tool: "screenshot", params: {}, description: `Reference solution: ${original}` };
+}
+/**
+ * Parse app-specific recovery strategies from reference JSON errors.
+ */
+export function parseReferenceStrategies(errors, blockerType) {
+    return errors.map((e, idx) => ({
+        id: `ref_${blockerType}_${idx}`,
+        blockerType,
+        label: `Reference: ${e.error}`,
+        steps: parseSolutionToSteps(e.solution),
+        postcondition: null,
+        source: "reference",
+    }));
+}
+/**
+ * Inject bundleId into strategy steps that need it (focus, launch).
+ * Returns a shallow clone.
+ */
+export function buildStrategyWithContext(strategy, bundleId, pid) {
+    if (!bundleId && !pid)
+        return strategy;
+    return {
+        ...strategy,
+        steps: strategy.steps.map((step) => {
+            if (bundleId && (step.tool === "focus" || step.tool === "launch")) {
+                return { ...step, params: { ...step.params, bundleId } };
+            }
+            if (pid != null && step.tool === "ui_tree") {
+                return { ...step, params: { ...step.params, pid } };
+            }
+            return step;
+        }),
+    };
+}

package/dist/src/recovery/types.js

@@ -0,0 +1,20 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+// This file is part of ScreenHand.
+//
+// ScreenHand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3.
+//
+// ScreenHand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with ScreenHand. If not, see <https://www.gnu.org/licenses/>.
+export const DEFAULT_RECOVERY_BUDGET = {
+    maxRecoveryTimeMs: 30_000,
+    maxStrategies: 3,
+};