@weavetab/mcp 2.5.0-beta.0 → 2.5.0-beta.2

package/dist/overlay/ghost.js

@@ -1,5 +1,5 @@
 import { logDebug } from "../audit/logger.js";
-import { getConfigHeadless, getConfigVisuals } from "../config/loader.js";
+import { getConfigHeadless } from "../config/loader.js";
 function sleep(ms) {
     return new Promise(r => setTimeout(r, ms));
 }
@@ -22,42 +22,87 @@ function wtCursor(session, x, y, state, opts) {
     const trail = opts?.trail && opts.trail !== "off" ? getCursorTrail(opts.trail === "full" ? 20 : 8) : undefined;
     sendToExtension(session, { type: 'Weavetab_STATE', cursor: { x, y, trail }, state }).catch(() => { });
 }
+let _wanderActive = false;
+export async function ensureInitialCursorPosition(session) {
+    if (currentX >= 0 && currentY >= 0) {
+        return { x: currentX, y: currentY };
+    }
+    try {
+        const layout = await session.Page.getLayoutMetrics().catch(() => null);
+        if (layout?.visualViewport?.clientWidth && layout?.visualViewport?.clientHeight) {
+            currentX = Math.round(layout.visualViewport.clientWidth / 2);
+            currentY = Math.round(layout.visualViewport.clientHeight / 2);
+        }
+        else {
+            const evalRes = await session.Runtime.evaluate({
+                expression: `({ x: Math.round(window.innerWidth / 2), y: Math.round(window.innerHeight / 2) })`,
+                returnByValue: true
+            }).catch(() => null);
+            if (evalRes?.result?.value?.x && evalRes?.result?.value?.y) {
+                currentX = evalRes.result.value.x;
+                currentY = evalRes.result.value.y;
+            }
+            else {
+                currentX = 640;
+                currentY = 400;
+            }
+        }
+    }
+    catch {
+        currentX = 640;
+        currentY = 400;
+    }
+    wtCursor(session, currentX, currentY, "idle");
+    return { x: currentX, y: currentY };
+}
 async function wtThought(session, text) {
     await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: text } }).catch(() => { });
-    // Add realistic wandering movement connected to thoughts
-    if (currentX > 0 && currentY > 0 && Math.random() > 0.2) {
-        const wanderDistance = 15 + Math.random() * 35;
+    if (currentX < 0 || currentY < 0) {
+        await ensureInitialCursorPosition(session);
+    }
+    // Add realistic wandering movement connected to thoughts (non-racing)
+    if (currentX > 0 && currentY > 0 && !_wanderActive && Math.random() > 0.3) {
+        _wanderActive = true;
+        const startX = currentX;
+        const startY = currentY;
+        const wanderDistance = 10 + Math.random() * 25;
         const angle = Math.random() * Math.PI * 2;
-        const tx = Math.max(0, currentX + Math.cos(angle) * wanderDistance);
-        const ty = Math.max(0, currentY + Math.sin(angle) * wanderDistance);
-        const steps = 15;
+        const tx = Math.max(20, startX + Math.cos(angle) * wanderDistance);
+        const ty = Math.max(20, startY + Math.sin(angle) * wanderDistance);
+        const steps = 12;
         const waypoints = [];
-        const cp1X = currentX + (tx - currentX) * 0.3 + (Math.random() - 0.5) * 15;
-        const cp1Y = currentY + (ty - currentY) * 0.3 + (Math.random() - 0.5) * 15;
-        const cp2X = currentX + (tx - currentX) * 0.7 + (Math.random() - 0.5) * 15;
-        const cp2Y = currentY + (ty - currentY) * 0.7 + (Math.random() - 0.5) * 15;
+        const cp1X = startX + (tx - startX) * 0.3;
+        const cp1Y = startY + (ty - startY) * 0.3;
+        const cp2X = startX + (tx - startX) * 0.7;
+        const cp2Y = startY + (ty - startY) * 0.7;
         for (let i = 1; i <= steps; i++) {
             let t = i / steps;
             t = 1 - Math.pow(1 - t, 3);
             waypoints.push({
-                x: cubicBezier(t, currentX, cp1X, cp2X, tx),
-                y: cubicBezier(t, currentY, cp1Y, cp2Y, ty)
+                x: Math.round(cubicBezier(t, startX, cp1X, cp2X, tx)),
+                y: Math.round(cubicBezier(t, startY, cp1Y, cp2Y, ty))
             });
         }
         sendToExtension(session, {
             type: 'Weavetab_STATE',
-            cursor: { waypoints, duration_ms: steps * 20, x: currentX, y: currentY },
+            cursor: { waypoints, duration_ms: steps * 25, x: startX, y: startY },
             state: "thinking"
         }).catch(() => { });
-        // Async physical dispatch to not block the main logic flow
         (async () => {
-            for (let i = 1; i <= steps; i++) {
-                const x = waypoints[i - 1].x;
-                const y = waypoints[i - 1].y;
-                await session.Input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" }).catch(() => { });
-                currentX = x;
-                currentY = y;
-                await new Promise(r => setTimeout(r, 20));
+            try {
+                for (let i = 1; i <= steps; i++) {
+                    if (!_wanderActive)
+                        break;
+                    const x = waypoints[i - 1].x;
+                    const y = waypoints[i - 1].y;
+                    await session.Input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" }).catch(() => { });
+                    currentX = x;
+                    currentY = y;
+                    await new Promise(r => setTimeout(r, 25));
+                }
+            }
+            finally {
+                _wanderActive = false;
             }
         })();
     }
@@ -139,6 +184,9 @@ targetSelector, profileName) {
     let wordsSinceBreak = 0;
     let wordCharCount = 0;
     let prevChar = '';
+    if (currentX < 0 || currentY < 0) {
+        await ensureInitialCursorPosition(session);
+    }
     wtCursor(session, currentX, currentY, "typing");
     let currentGroupSize = Math.floor(Math.random() * (p.groupSize[1] - p.groupSize[0] + 1)) + p.groupSize[0];
     let charsTypedInGroup = 0;
@@ -271,6 +319,10 @@ function cubicBezier(t, p0, p1, p2, p3) {
 }
 let _firstMoveDone = false;
 export async function ghostMove(session, targetX, targetY, config, label, profile, cursorOpts) {
+    _wanderActive = false; // Stop any ongoing thought wander immediately
+    if (currentX < 0 || currentY < 0) {
+        await ensureInitialCursorPosition(session);
+    }
     const resolvedProfile = profile || (getConfigHeadless(config) ? "instant" : "human");
     if (resolvedProfile === "instant") {
         await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: targetX, y: targetY, button: "none" });
@@ -290,9 +342,9 @@ export async function ghostMove(session, targetX, targetY, config, label, profil
         return;
     }
     if (resolvedProfile === "fast") {
-        const steps = 4;
-        const startX = currentX === -1 ? targetX : currentX;
-        const startY = currentY === -1 ? targetY : currentY;
+        const steps = 6;
+        const startX = currentX;
+        const startY = currentY;
         for (let i = 1; i <= steps; i++) {
             const t = i / steps;
             const x = Math.round(startX + (targetX - startX) * t);
@@ -301,7 +353,7 @@ export async function ghostMove(session, targetX, targetY, config, label, profil
             currentX = x;
             currentY = y;
             wtCursor(session, x, y, "moving", cursorOpts);
-            await sleep(5);
+            await sleep(6);
         }
         currentX = targetX;
         currentY = targetY;
@@ -311,93 +363,61 @@ export async function ghostMove(session, targetX, targetY, config, label, profil
         return;
     }
     if (!_firstMoveDone) {
-        logDebug(`[Weavetab Ghost] First mouse move → (${targetX}, ${targetY}) — CDP session active`);
+        logDebug(`[Weavetab Ghost] First mouse move from (${currentX}, ${currentY}) → (${targetX}, ${targetY}) — CDP session active`);
         _firstMoveDone = true;
     }
-    // Don't fake-init cursor position — injector.ts hides cursor until first real move
-    if (currentX === -1 && currentY === -1) {
-        currentX = targetX;
-        currentY = targetY;
-        wtCursor(session, targetX, targetY, "hover", cursorOpts);
-        recordCursorPosition(targetX, targetY);
-        await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: targetX, y: targetY, button: "none" });
-        await session.Runtime.evaluate({
-            expression: `(function(){
-        var el = document.elementFromPoint(${targetX}, ${targetY});
-        if (el) {
-          el.dispatchEvent(new MouseEvent('mouseover', {bubbles:true,cancelable:true,clientX:${targetX},clientY:${targetY}}));
-          el.dispatchEvent(new MouseEvent('mouseenter', {bubbles:false,cancelable:true,clientX:${targetX},clientY:${targetY}}));
-        }
-      })()`
-        }).catch(() => { });
-        return;
-    }
     const dx = targetX - currentX;
     const dy = targetY - currentY;
     const distance = Math.sqrt(dx * dx + dy * dy);
-    wtCursor(session, currentX, currentY, label && distance >= 150 ? "searching" : "idle", cursorOpts);
-    if (label && distance >= 150 && getConfigVisuals(config) !== false) {
-        wtThought(session, `moving to ${label.slice(0, 40)}...`);
-        await sleep(80 + Math.random() * 120);
-    }
-    if (distance < 150) {
+    if (distance < 4) {
         currentX = targetX;
         currentY = targetY;
         await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: targetX, y: targetY, button: "none" });
         wtCursor(session, targetX, targetY, "hover", cursorOpts);
         recordCursorPosition(targetX, targetY);
-        await session.Runtime.evaluate({
-            expression: `(function(){
-        var el = document.elementFromPoint(${targetX}, ${targetY});
-        if (el) {
-          el.dispatchEvent(new MouseEvent('mouseover', {bubbles:true,cancelable:true,clientX:${targetX},clientY:${targetY}}));
-          el.dispatchEvent(new MouseEvent('mouseenter', {bubbles:false,cancelable:true,clientX:${targetX},clientY:${targetY}}));
-        }
-      })()`
-        }).catch(() => { });
         return;
     }
-    const duration = Math.max(80, Math.min(300, distance * 0.6));
-    let steps = Math.floor(duration / 16);
-    if (steps > 10)
-        steps = 10;
-    if (steps < 3)
-        steps = 3;
-    const cp1X = currentX + dx * 0.2 + randomGaussian(0, distance * 0.2);
-    const cp1Y = currentY + dy * 0.2 + randomGaussian(0, distance * 0.2);
-    const cp2X = currentX + dx * 0.8 + randomGaussian(0, distance * 0.2);
-    const cp2Y = currentY + dy * 0.8 + randomGaussian(0, distance * 0.2);
-    const doOvershoot = distance >= 300 && Math.random() > 0.3;
-    const overshootAmount = doOvershoot ? randomGaussian(10, 5) : 0;
-    const angle = Math.atan2(dy, dx);
-    const overshootX = targetX + Math.cos(angle) * overshootAmount;
-    const overshootY = targetY + Math.sin(angle) * overshootAmount;
-    wtCursor(session, targetX, targetY, "idle", cursorOpts);
+    wtCursor(session, currentX, currentY, label && distance >= 150 ? "searching" : "idle", cursorOpts);
+    if (label && distance >= 150) {
+        wtThought(session, `moving to ${label.slice(0, 40)}...`);
+        await sleep(60 + Math.random() * 80);
+    }
+    // Smooth, natural human hand curve
+    const duration = Math.max(120, Math.min(380, 80 + Math.sqrt(distance) * 12));
+    const steps = Math.max(8, Math.min(24, Math.floor(duration / 16)));
+    const stepDelay = Math.max(10, Math.floor(duration / steps));
+    // Gentle perpendicular curvature (arcing motion)
+    const nx = -dy / distance;
+    const ny = dx / distance;
+    const maxArc = Math.min(45, distance * 0.15);
+    const arcSign = (Math.random() > 0.5 ? 1 : -1);
+    const arcAmount = maxArc * arcSign * (0.4 + Math.random() * 0.6);
+    const cp1X = currentX + dx * 0.3 + nx * arcAmount;
+    const cp1Y = currentY + dy * 0.3 + ny * arcAmount;
+    const cp2X = currentX + dx * 0.7 + nx * (arcAmount * 0.6);
+    const cp2Y = currentY + dy * 0.7 + ny * (arcAmount * 0.6);
     const waypoints = [];
     for (let i = 1; i <= steps; i++) {
-        let t = i / steps;
-        t = 1 - Math.pow(1 - t, 4);
-        const actualTargetX = doOvershoot && i < steps * 0.8 ? overshootX : targetX;
-        const actualTargetY = doOvershoot && i < steps * 0.8 ? overshootY : targetY;
+        const rawT = i / steps;
+        // Cubic ease-out for natural deceleration
+        const t = 1 - Math.pow(1 - rawT, 3);
         waypoints.push({
-            x: cubicBezier(t, currentX, cp1X, cp2X, actualTargetX),
-            y: cubicBezier(t, currentY, cp1Y, cp2Y, actualTargetY)
+            x: Math.round(cubicBezier(t, currentX, cp1X, cp2X, targetX)),
+            y: Math.round(cubicBezier(t, currentY, cp1Y, cp2Y, targetY))
         });
     }
-    // Pre-announce the move
+    // Pre-announce waypoints for smooth client-side interpolation
     sendToExtension(session, {
         type: 'Weavetab_STATE',
-        cursor: { waypoints, duration_ms: steps * 8, x: currentX, y: currentY },
+        cursor: { waypoints, duration_ms: steps * stepDelay, x: currentX, y: currentY },
         state: "moving"
     }).catch(() => { });
     for (let i = 1; i <= steps; i++) {
-        const x = waypoints[i - 1].x;
-        const y = waypoints[i - 1].y;
-        await session.Input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" });
-        currentX = x;
-        currentY = y;
-        wtCursor(session, x, y, "moving", cursorOpts);
-        await sleep(8);
+        const pt = waypoints[i - 1];
+        await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: pt.x, y: pt.y, button: "none" }).catch(() => { });
+        currentX = pt.x;
+        currentY = pt.y;
+        await sleep(stepDelay);
     }
     currentX = targetX;
     currentY = targetY;
@@ -405,7 +425,7 @@ export async function ghostMove(session, targetX, targetY, config, label, profil
     recordCursorPosition(targetX, targetY);
     if (label)
         wtClearThought(session);
-    await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: targetX, y: targetY, button: "none" });
+    await session.Input.dispatchMouseEvent({ type: "mouseMoved", x: targetX, y: targetY, button: "none" }).catch(() => { });
     await session.Runtime.evaluate({
         expression: `(function(){
       var el = document.elementFromPoint(${targetX}, ${targetY});
@@ -501,8 +521,12 @@ export async function ghostClick(session, x, y, options) {
     }).catch(() => { });
 }
 export function ghostWait(session) {
-    wtCursor(session, currentX, currentY, "waiting");
+    const x = currentX >= 0 ? currentX : 640;
+    const y = currentY >= 0 ? currentY : 400;
+    wtCursor(session, x, y, "waiting");
 }
 export function ghostIdle(session) {
-    wtCursor(session, currentX, currentY, "idle");
+    const x = currentX >= 0 ? currentX : 640;
+    const y = currentY >= 0 ? currentY : 400;
+    wtCursor(session, x, y, "idle");
 }

package/dist/overlay/injector.d.ts

@@ -2,7 +2,7 @@
  * src/overlay/injector.ts
  * Weavetab — Browser Presence Layer v3 (stripped)
  *
- * Kept:     __wt_plan (mission dashboard), SPA nav detection,
+ * Kept:     SPA nav detection,
  *           __wt_setConfig, __wt_status, favicon state.
  * Removed:  cursor (moved to content.js), chat panel, thought bubble,
  *           ask modal, screen glow, CSS keyframes, emoji system.

package/dist/overlay/injector.js

@@ -1,5 +1,5 @@
 import { logDebug } from "../audit/logger.js";
-import { getConfigVisuals, getConfigDevMode } from "../config/loader.js";
+import { getConfigDevMode } from "../config/loader.js";
 // ─── Minimal Overlay Script ───────────────────────────────────────────────────
 export function getMinimalOverlayScript() {
     return `(function(){
@@ -52,23 +52,11 @@ export function getMinimalOverlayScript() {
       document.addEventListener('NavigationEnd', function() { em('angular', location.href); });
     }
 
-    // ── Mission plan dashboard ──────────────────────────────────────────────
-    window.__wt_plan_comments = window.__wt_plan_comments || [];
-    window.__wt_plan = function(action, goal, tasks) {
-      window.postMessage({ type: '__WT_PLAN', action: action, goal: goal, tasks: tasks }, '*');
-    };
-
     // The message listeners below are guarded so they are registered exactly once
     // per page, even when __wt_install_minimal() is called repeatedly (e.g. SPAs
     // with frequent navigations).
     if (!window.__wt_msg_installed) {
       window.__wt_msg_installed = true;
-      window.addEventListener("message", function(e) {
-        if (e.data && e.data.type === "__WT_PLAN_COMMENT") {
-          window.__wt_plan_comments.push({ taskId: Number(e.data.taskId), comment: e.data.comment, time: Date.now() });
-        }
-      });
-
       window.__wt_chat_queue = window.__wt_chat_queue || [];
       window.addEventListener("message", function(e) {
         if (e.data && e.data.type === "__WT_FEEDBACK") {
@@ -79,7 +67,6 @@ export function getMinimalOverlayScript() {
 
     window.__wt_setConfig = function(c) {
       if (c && c.devMode) window.__wt_devMode = true;
-      if (c && c.visuals !== undefined) window.__wt_showVisuals = !!c.visuals;
     };
 
     window.__wt_status = function() { return JSON.stringify({ rootInjected: true }); };
@@ -133,7 +120,6 @@ function buildConfigExpr(config) {
     return `
 if(window.__wt_setConfig)window.__wt_setConfig(${JSON.stringify({
         ...config,
-        visuals: getConfigVisuals(config) !== false,
     })});
 window.postMessage({type:'Weavetab-msg-in',data:${JSON.stringify(msg)}},'*');
 `;

package/dist/plugin/extension_bridge.d.ts

@@ -0,0 +1,40 @@
+import type CDP from "chrome-remote-interface";
+import type { WeavetabPermissions } from "./interface.js";
+export interface IPluginExtensionBridge {
+    send(session: CDP.Client, message: object): Promise<boolean>;
+    setHudState(session: CDP.Client, state: {
+        action?: string;
+        badge?: string;
+        badgeColor?: string;
+        groupState?: string;
+    }): Promise<void>;
+    showThought(session: CDP.Client, text: string, options?: {
+        durationMs?: number;
+    }): Promise<void>;
+    clearThought(session: CDP.Client): Promise<void>;
+    injectStyles(session: CDP.Client, css: string): Promise<void>;
+    injectScript<T = any>(session: CDP.Client, js: string): Promise<T>;
+    hideOverlay(session: CDP.Client): Promise<void>;
+    restoreOverlay(session: CDP.Client): Promise<void>;
+}
+export declare class PluginExtensionBridge implements IPluginExtensionBridge {
+    readonly pluginName: string;
+    private readonly permissions?;
+    constructor(pluginName: string, permissions?: WeavetabPermissions | undefined);
+    private checkPermission;
+    send(session: CDP.Client, message: object): Promise<boolean>;
+    setHudState(session: CDP.Client, state: {
+        action?: string;
+        badge?: string;
+        badgeColor?: string;
+        groupState?: string;
+    }): Promise<void>;
+    showThought(session: CDP.Client, text: string, options?: {
+        durationMs?: number;
+    }): Promise<void>;
+    clearThought(session: CDP.Client): Promise<void>;
+    injectStyles(session: CDP.Client, css: string): Promise<void>;
+    injectScript<T = any>(session: CDP.Client, js: string): Promise<T>;
+    hideOverlay(session: CDP.Client): Promise<void>;
+    restoreOverlay(session: CDP.Client): Promise<void>;
+}

package/dist/plugin/extension_bridge.js

@@ -0,0 +1,158 @@
+import { sendToExtension, hideWeaveTabOverlay, restoreWeaveTabOverlay } from "../cdp/helpers.js";
+import { logDebug } from "../audit/logger.js";
+export class PluginExtensionBridge {
+    pluginName;
+    permissions;
+    constructor(pluginName, permissions) {
+        this.pluginName = pluginName;
+        this.permissions = permissions;
+    }
+    checkPermission(category) {
+        if (!this.permissions || !this.permissions.extension)
+            return true; // Default permissive if not restricted
+        return this.permissions.extension[category] !== false;
+    }
+    async send(session, message) {
+        if (!session)
+            return false;
+        return await sendToExtension(session, {
+            ...message,
+            plugin: this.pluginName,
+        });
+    }
+    async setHudState(session, state) {
+        if (!this.checkPermission("hud")) {
+            logDebug(`[Weavetab PluginExtension] Plugin "${this.pluginName}" lacks permissions.extension.hud`);
+            return;
+        }
+        await this.send(session, {
+            type: "wt-hud-update",
+            action: state.action,
+            badge: state.badge,
+            badgeColor: state.badgeColor,
+            groupState: state.groupState,
+            timestamp: Date.now(),
+        });
+    }
+    async showThought(session, text, options) {
+        if (!this.checkPermission("hud"))
+            return;
+        if (!session || !session.Runtime)
+            return;
+        const duration = options?.durationMs || 4000;
+        const safeText = JSON.stringify(text);
+        try {
+            await session.Runtime.evaluate({
+                expression: `(function() {
+          var existing = document.getElementById('__wt_plugin_thought_${this.pluginName}');
+          if (existing) existing.remove();
+
+          var bubble = document.createElement('div');
+          bubble.id = '__wt_plugin_thought_${this.pluginName}';
+          bubble.className = 'wt-bubble';
+          bubble.setAttribute('data-wt-internal', 'true');
+          bubble.style.cssText = [
+            'position: fixed',
+            'bottom: 24px',
+            'right: 24px',
+            'background: linear-gradient(135deg, rgba(17, 24, 39, 0.95), rgba(30, 41, 59, 0.95))',
+            'color: #f8fafc',
+            'padding: 12px 18px',
+            'border-radius: 12px',
+            'font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+            'font-size: 13px',
+            'font-weight: 500',
+            'box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(255, 255, 255, 0.1)',
+            'z-index: 2147483647',
+            'backdrop-filter: blur(8px)',
+            'pointer-events: none',
+            'animation: wtThoughtFade 0.25s cubic-bezier(0.16, 1, 0.3, 1)',
+            'display: flex',
+            'align-items: center',
+            'gap: 8px'
+          ].join(';');
+
+          var icon = document.createElement('span');
+          icon.textContent = '✨';
+          var textSpan = document.createElement('span');
+          textSpan.textContent = ${safeText};
+
+          bubble.appendChild(icon);
+          bubble.appendChild(textSpan);
+          document.body.appendChild(bubble);
+
+          setTimeout(function() {
+            if (bubble && bubble.parentNode) {
+              bubble.style.opacity = '0';
+              bubble.style.transition = 'opacity 0.3s ease';
+              setTimeout(function() { bubble.remove(); }, 300);
+            }
+          }, ${duration});
+        })()`,
+                returnByValue: false,
+            });
+        }
+        catch (e) {
+            logDebug(`[Weavetab PluginExtension] Failed to show thought:`, e);
+        }
+    }
+    async clearThought(session) {
+        if (!session || !session.Runtime)
+            return;
+        try {
+            await session.Runtime.evaluate({
+                expression: `(function() {
+          var existing = document.getElementById('__wt_plugin_thought_${this.pluginName}');
+          if (existing) existing.remove();
+        })()`,
+                returnByValue: false,
+            });
+        }
+        catch { /* ignore */ }
+    }
+    async injectStyles(session, css) {
+        if (!this.checkPermission("styles")) {
+            throw new Error(`Permission Denied: Plugin "${this.pluginName}" does not have permissions.extension.styles`);
+        }
+        if (!session || !session.Runtime)
+            return;
+        const safeCss = JSON.stringify(css);
+        await session.Runtime.evaluate({
+            expression: `(function() {
+        var styleId = '__wt_plugin_styles_${this.pluginName}';
+        var style = document.getElementById(styleId) || document.createElement('style');
+        style.id = styleId;
+        style.textContent = ${safeCss};
+        if (!style.parentNode) document.head.appendChild(style);
+      })()`,
+            returnByValue: false,
+        });
+    }
+    async injectScript(session, js) {
+        if (!this.checkPermission("scripts")) {
+            throw new Error(`Permission Denied: Plugin "${this.pluginName}" does not have permissions.extension.scripts`);
+        }
+        if (!session || !session.Runtime)
+            throw new Error("No active CDP session available");
+        const res = await session.Runtime.evaluate({
+            expression: js,
+            returnByValue: true,
+            awaitPromise: true,
+        });
+        return res.result?.value ?? res;
+    }
+    async hideOverlay(session) {
+        if (!this.checkPermission("overlay"))
+            return;
+        if (!session)
+            return;
+        await hideWeaveTabOverlay(session);
+    }
+    async restoreOverlay(session) {
+        if (!this.checkPermission("overlay"))
+            return;
+        if (!session)
+            return;
+        await restoreWeaveTabOverlay(session);
+    }
+}