@superblocksteam/vite-plugin-file-sync 2.0.76 → 2.0.77-next.0

package/dist/ai-service/mcp/embedded-playwright-mcp-server.js

@@ -174,8 +174,12 @@ const PLAYWRIGHT_ACTIONS = [
     "scroll",
     "scrollIntoView",
     "checkRuntimeErrors",
+    "getEmbedEvents",
+    "triggerEmbedEvent",
+    "setEmbedProperties",
 ];
 let capturedConsoleLogs = [];
+let lastDrainedEmbedEvents = null;
 export async function startEmbeddedPlaywrightMcpServer(options) {
     const logger = options.logger;
     // Create action logger for capturing Playwright actions
@@ -239,154 +243,174 @@ export async function startEmbeddedPlaywrightMcpServer(options) {
     if (!context) {
         throw new Error("Failed to create or reuse a Playwright context");
     }
-    // Inject sb-init and sb-bootstrap-response data for direct iframe access
-    // This simulates the parent window sending these messages to the iframe
-    if (options?.initData || options?.bootstrapData) {
-        const initData = options.initData;
-        const bootstrapData = options.bootstrapData;
+    // Mock parent window for Playwright browser automation.
+    //
+    // NOTE: We always install this init script, even when init/bootstrap data is not available.
+    // This ensures third-party embed hooks (embed-emit-event) can be exercised and asserted in tests.
+    // When init/bootstrap data is provided, this script also simulates Superblocks editor messaging
+    // (sb-init, sb-bootstrap-response, etc.) needed for first-party embedding flows.
+    const initData = options.initData;
+    const bootstrapData = options.bootstrapData;
+    /**
+     * CRITICAL: Mock Parent Window Setup for Playwright Browser Automation
+     *
+     * WHY THIS IS NECESSARY:
+     * The Superblocks library code (in @superblocksteam/library) expects to run inside an iframe
+     * embedded by the Superblocks editor. It uses `window.parent.postMessage()` to communicate
+     * with the editor and relies on `window.parent !== window` to detect the embedded state.
+     *
+     * When running in Playwright for E2E testing, there is no parent iframe - the page runs
+     * standalone. Without this mock, the library would:
+     * 1. Fail the `isEmbeddedBySuperblocksFirstParty()` check
+     * 2. Never receive the `sb-init` message needed to establish socket connections
+     * 3. Never receive the `sb-bootstrap-response` with auth tokens and app data
+     *
+     * HOW IT WORKS:
+     * 1. We override `window.parent` with a mock object BEFORE library code loads (via addInitScript)
+     * 2. The mock intercepts `postMessage` calls from the library
+     * 3. When the library sends "sb-ready", we respond with "sb-init" containing peerId/auth data
+     * 4. When the library sends "sb-editor-request-bootstrap", we respond with bootstrap data
+     * 5. We also send initial messages proactively in case the library sets up listeners late
+     *
+     * TESTING NOTE:
+     * Integration tests for this setup should verify:
+     * 1. The app successfully initializes and shows content
+     * 2. API calls are authenticated (tokens were passed correctly)
+     * 3. Real-time features work (socket connection established via peerId)
+     */
+    await context.addInitScript((payload) => {
+        const { initData: init, bootstrapData: bootstrap } = payload;
         /**
-         * CRITICAL: Mock Parent Window Setup for Playwright Browser Automation
-         *
-         * WHY THIS IS NECESSARY:
-         * The Superblocks library code (in @superblocksteam/library) expects to run inside an iframe
-         * embedded by the Superblocks editor. It uses `window.parent.postMessage()` to communicate
-         * with the editor and relies on `window.parent !== window` to detect the embedded state.
-         *
-         * When running in Playwright for E2E testing, there is no parent iframe - the page runs
-         * standalone. Without this mock, the library would:
-         * 1. Fail the `isEmbeddedBySuperblocksFirstParty()` check
-         * 2. Never receive the `sb-init` message needed to establish socket connections
-         * 3. Never receive the `sb-bootstrap-response` with auth tokens and app data
-         *
-         * HOW IT WORKS:
-         * 1. We override `window.parent` with a mock object BEFORE library code loads (via addInitScript)
-         * 2. The mock intercepts `postMessage` calls from the library
-         * 3. When the library sends "sb-ready", we respond with "sb-init" containing peerId/auth data
-         * 4. When the library sends "sb-editor-request-bootstrap", we respond with bootstrap data
-         * 5. We also send initial messages proactively in case the library sets up listeners late
+         * Capture embed events emitted by apps via @superblocksteam/library:
+         * useEmitEmbedEvent() -> embedStore.emitEvent() -> window.parent.postMessage({ type: "embed-emit-event" })
          *
-         * WHAT COULD BREAK THIS:
-         * - If the library changes how it detects parent window embedding (e.g., different checks)
-         * - If the message types or payload shapes change in the library
-         * - If the library adds additional security checks (e.g., origin verification on parent)
-         * - If timing changes require different setTimeout delays
-         *
-         * TESTING NOTE:
-         * Integration tests for this setup should verify:
-         * 1. The app successfully initializes and shows content
-         * 2. API calls are authenticated (tokens were passed correctly)
-         * 3. Real-time features work (socket connection established via peerId)
+         * We store them on the window so the MCP server can drain them and attach to test steps.
          */
-        await context.addInitScript((payload) => {
-            const { initData: init, bootstrapData: bootstrap } = payload;
-            /**
-             * Mock parent window object that intercepts postMessage calls from the library.
-             * When the app sends messages expecting a parent response, we handle them here.
-             */
-            const mockParent = {
-                postMessage: (message, _targetOrigin) => {
-                    // When the app sends sb-ready, we respond with sb-init
-                    // This triggers the library to establish its socket connection
-                    if (message?.type === "sb-ready" && init) {
-                        setTimeout(() => {
-                            window.postMessage({
-                                type: "sb-init",
-                                payload: {
-                                    peerId: init.peerId,
-                                    userId: init.userId,
-                                    devServerAuthorization: init.devServerAuthorization,
-                                    appId: init.appId,
-                                    windowOriginUrl: init.windowOriginUrl,
-                                },
-                                startTime: Date.now(),
-                            }, "*");
-                        }, 10);
-                    }
-                    // When the app sends sb-editor-request-bootstrap, we respond with bootstrap data
-                    // This provides auth tokens and configuration needed by the API manager
-                    if (message?.type === "sb-editor-request-bootstrap" && bootstrap) {
+        const EMBED_EVENTS_KEY = "__sb_embed_events__";
+        window[EMBED_EVENTS_KEY] =
+            window[EMBED_EVENTS_KEY] ?? [];
+        window.__sbGetAndClearEmbedEvents = () => {
+            const events = Array.isArray(window[EMBED_EVENTS_KEY])
+                ? window[EMBED_EVENTS_KEY]
+                : [];
+            window[EMBED_EVENTS_KEY] = [];
+            return events;
+        };
+        /**
+         * Mock parent window object that intercepts postMessage calls from the library.
+         * When the app sends messages expecting a parent response, we handle them here.
+         */
+        const mockParent = {
+            postMessage: (message, _targetOrigin) => {
+                // Record third-party embed events emitted by the app.
+                if (message?.type === "embed-emit-event") {
+                    window[EMBED_EVENTS_KEY].push({
+                        timestamp: Date.now(),
+                        eventName: message?.payload?.eventName,
+                        payload: message?.payload?.payload,
+                    });
+                }
+                // When the app sends sb-ready, we respond with sb-init
+                // This triggers the library to establish its socket connection
+                if (message?.type === "sb-ready" && init) {
+                    setTimeout(() => {
+                        window.postMessage({
+                            type: "sb-init",
+                            payload: {
+                                peerId: init.peerId,
+                                userId: init.userId,
+                                devServerAuthorization: init.devServerAuthorization,
+                                appId: init.appId,
+                                windowOriginUrl: init.windowOriginUrl,
+                            },
+                            startTime: Date.now(),
+                        }, "*");
+                    }, 10);
+                }
+                // When the app sends sb-editor-request-bootstrap, we respond with bootstrap data
+                // This provides auth tokens and configuration needed by the API manager
+                if (message?.type === "sb-editor-request-bootstrap" && bootstrap) {
+                    setTimeout(() => {
+                        window.postMessage({
+                            type: "sb-bootstrap-response",
+                            payload: bootstrap,
+                            startTime: Date.now(),
+                        }, "*");
+                    }, 10);
+                }
+                // When the app sends authenticate-api-request, we respond with resolve-promise
+                // This allows API calls to proceed in test mode without actual auth
+                if (message?.type === "authenticate-api-request") {
+                    const { callbackId } = message.payload || {};
+                    if (callbackId) {
                         setTimeout(() => {
                             window.postMessage({
-                                type: "sb-bootstrap-response",
-                                payload: bootstrap,
-                                startTime: Date.now(),
+                                type: "resolve-promise",
+                                callbackId,
+                                payload: {}, // Empty success result - no auth errors
                             }, "*");
                         }, 10);
                     }
-                    // When the app sends authenticate-api-request, we respond with resolve-promise
-                    // This allows API calls to proceed in test mode without actual auth
-                    if (message?.type === "authenticate-api-request") {
-                        const { callbackId } = message.payload || {};
-                        if (callbackId) {
-                            setTimeout(() => {
-                                window.postMessage({
-                                    type: "resolve-promise",
-                                    callbackId,
-                                    payload: {}, // Empty success result - no auth errors
-                                }, "*");
-                            }, 10);
-                        }
-                    }
-                },
-                // These properties make the mock look like a real window object
-                // which helps pass any instanceof or property existence checks
-                window: window,
-                document: document,
-                location: window.location,
-            };
-            // Override window.parent to point to our mock
-            // This must happen before the library code runs (hence addInitScript)
-            Object.defineProperty(window, "parent", {
-                value: mockParent,
-                writable: false,
-                configurable: true,
-            });
-            // Send initial messages proactively after a delay
-            // This handles the case where the library sets up listeners after checking window.parent
-            if (init) {
+                }
+            },
+            // These properties make the mock look like a real window object
+            // which helps pass any instanceof or property existence checks
+            window: window,
+            document: document,
+            location: window.location,
+        };
+        // Override window.parent to point to our mock
+        // This must happen before the library code runs (hence addInitScript)
+        Object.defineProperty(window, "parent", {
+            value: mockParent,
+            writable: false,
+            configurable: true,
+        });
+        // Send initial messages proactively after a delay
+        // This handles the case where the library sets up listeners after checking window.parent
+        if (init) {
+            setTimeout(() => {
+                window.postMessage({
+                    type: "sb-init",
+                    payload: {
+                        peerId: init.peerId,
+                        userId: init.userId,
+                        devServerAuthorization: init.devServerAuthorization,
+                        appId: init.appId,
+                        windowOriginUrl: init.windowOriginUrl,
+                    },
+                    startTime: Date.now(),
+                }, "*");
+            }, 100);
+        }
+        if (bootstrap) {
+            setTimeout(() => {
+                window.postMessage({
+                    type: "sb-bootstrap-response",
+                    payload: bootstrap,
+                    startTime: Date.now(),
+                }, "*");
+            }, 200);
+            // Send sb-global-sync with profiles data for API execution
+            // This sets superblocksContext.profiles which is needed for profileId
+            if (bootstrap.profiles) {
                 setTimeout(() => {
                     window.postMessage({
-                        type: "sb-init",
+                        type: "sb-global-sync",
                         payload: {
-                            peerId: init.peerId,
-                            userId: init.userId,
-                            devServerAuthorization: init.devServerAuthorization,
-                            appId: init.appId,
-                            windowOriginUrl: init.windowOriginUrl,
+                            global: {
+                                profiles: bootstrap.profiles,
+                            },
                         },
                         startTime: Date.now(),
                     }, "*");
-                }, 100);
-            }
-            if (bootstrap) {
-                setTimeout(() => {
-                    window.postMessage({
-                        type: "sb-bootstrap-response",
-                        payload: bootstrap,
-                        startTime: Date.now(),
-                    }, "*");
-                }, 200);
-                // Send sb-global-sync with profiles data for API execution
-                // This sets superblocksContext.profiles which is needed for profileId
-                if (bootstrap.profiles) {
-                    setTimeout(() => {
-                        window.postMessage({
-                            type: "sb-global-sync",
-                            payload: {
-                                global: {
-                                    profiles: bootstrap.profiles,
-                                },
-                            },
-                            startTime: Date.now(),
-                        }, "*");
-                    }, 300);
-                }
+                }, 300);
             }
-        }, {
-            initData,
-            bootstrapData,
-        });
-    }
+        }
+    }, {
+        initData,
+        bootstrapData,
+    });
     // Seed a cookie/localStorage with JWT for app domain if provided
     if (options?.jwt && options?.appUrl) {
         try {
@@ -739,6 +763,9 @@ ACTIONS:
 - reload: Reload the page. No params.
 - navigate: Go to URL. Params: { url: string }
 - getConsoleLogs: Get browser console logs. Params: { clear?: boolean }
+- getEmbedEvents: Get the most recent embed events emitted by the app. Params: { }
+- triggerEmbedEvent: Trigger an incoming embed event as if sent by the embedder. Params: { eventName: string, payload?: object }
+- setEmbedProperties: Set embed properties as if sent by the embedder. Params: { properties: object }
 - scroll: Scroll the page. Params: { x?: number, y?: number, deltaX?: number, deltaY?: number }
 - scrollIntoView: Scroll element into view. Params: { selector: string }
 - checkRuntimeErrors: Explicitly check for component crashes. No params.
@@ -811,6 +838,20 @@ TIPS:
                                         type: "boolean",
                                         description: "Clear logs after retrieving (for 'getConsoleLogs' action)",
                                     },
+                                    eventName: {
+                                        type: "string",
+                                        description: "Embed event name to trigger (for 'triggerEmbedEvent' action)",
+                                    },
+                                    payload: {
+                                        type: "object",
+                                        description: "Optional payload to send with the embed event (for 'triggerEmbedEvent' action)",
+                                        additionalProperties: true,
+                                    },
+                                    properties: {
+                                        type: "object",
+                                        description: "Embed properties to set (for 'setEmbedProperties' action)",
+                                        additionalProperties: true,
+                                    },
                                     x: {
                                         type: "number",
                                         description: "Absolute horizontal scroll position in pixels (for 'scroll' action)",
@@ -959,6 +1000,21 @@ async function captureScreenshot(page) {
         format: "png",
     };
 }
+async function drainEmbedEvents(page) {
+    try {
+        const events = await page.evaluate(() => {
+            return window.__sbGetAndClearEmbedEvents?.() ?? null;
+        });
+        if (Array.isArray(events) && events.length > 0) {
+            lastDrainedEmbedEvents = events;
+            return events;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 async function executePlaywrightAction(action, page, params) {
     switch (action) {
         case "navigate": {
@@ -973,6 +1029,7 @@ async function executePlaywrightAction(action, page, params) {
                 });
                 // Auto-capture screenshot after navigation
                 const screenshot = await captureScreenshot(page);
+                const embedEvents = await drainEmbedEvents(page);
                 // Check for runtime errors (component crashes)
                 const runtimeErrors = await checkForRuntimeErrors(page);
                 return {
@@ -983,6 +1040,7 @@ async function executePlaywrightAction(action, page, params) {
                     format: screenshot.format,
                     context: {
                         url,
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                     ...(runtimeErrors.hasErrors && {
                         runtimeErrors: runtimeErrors.errors,
@@ -1000,6 +1058,7 @@ async function executePlaywrightAction(action, page, params) {
                 catch {
                     // Ignore screenshot errors
                 }
+                const embedEvents = await drainEmbedEvents(page);
                 return {
                     success: false,
                     action: "navigate",
@@ -1008,6 +1067,7 @@ async function executePlaywrightAction(action, page, params) {
                     format: errorScreenshot?.format ?? "png",
                     context: {
                         url,
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                     error: `Navigation to ${url} failed: ${String(error)}`,
                 };
@@ -1024,6 +1084,7 @@ async function executePlaywrightAction(action, page, params) {
                     .click({ timeout: params.timeout ?? 10000 });
                 // Auto-capture screenshot after action
                 const screenshot = await captureScreenshot(page);
+                const embedEvents = await drainEmbedEvents(page);
                 // Check for runtime errors (component crashes)
                 const runtimeErrors = await checkForRuntimeErrors(page);
                 return {
@@ -1034,6 +1095,7 @@ async function executePlaywrightAction(action, page, params) {
                     format: screenshot.format,
                     context: {
                         selector,
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                     ...(runtimeErrors.hasErrors && {
                         runtimeErrors: runtimeErrors.errors,
@@ -1050,6 +1112,7 @@ async function executePlaywrightAction(action, page, params) {
                 catch {
                     // Ignore screenshot errors
                 }
+                const embedEvents = await drainEmbedEvents(page);
                 return {
                     success: false,
                     action: "click",
@@ -1058,6 +1121,7 @@ async function executePlaywrightAction(action, page, params) {
                     format: errorScreenshot?.format ?? "png",
                     context: {
                         selector,
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                     error: `Click failed on "${selector}": ${String(error)}`,
                 };
@@ -1075,6 +1139,7 @@ async function executePlaywrightAction(action, page, params) {
                     .fill(value, { timeout: params.timeout ?? 10000 });
                 // Auto-capture screenshot after fill
                 const screenshot = await captureScreenshot(page);
+                const embedEvents = await drainEmbedEvents(page);
                 // Check for runtime errors (component crashes)
                 const runtimeErrors = await checkForRuntimeErrors(page);
                 return {
@@ -1086,6 +1151,7 @@ async function executePlaywrightAction(action, page, params) {
                     context: {
                         selector,
                         value,
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                     ...(runtimeErrors.hasErrors && {
                         runtimeErrors: runtimeErrors.errors,
@@ -1102,6 +1168,7 @@ async function executePlaywrightAction(action, page, params) {
                 catch {
                     // Ignore screenshot errors
                 }
+                const embedEvents = await drainEmbedEvents(page);
                 return {
                     success: false,
                     action: "fill",
@@ -1111,6 +1178,7 @@ async function executePlaywrightAction(action, page, params) {
                     context: {
                         selector,
                         value,
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                     error: `Fill failed on "${selector}": ${String(error)}`,
                 };
@@ -1120,6 +1188,7 @@ async function executePlaywrightAction(action, page, params) {
             const description = params.description || "Capture current state";
             // Capture screenshot in WebP format for optimal compression
             const screenshot = await captureScreenshot(page);
+            const embedEvents = await drainEmbedEvents(page);
             return {
                 success: true,
                 action: "screenshot",
@@ -1128,6 +1197,7 @@ async function executePlaywrightAction(action, page, params) {
                 format: screenshot.format,
                 context: {
                     fullPage: Boolean(params.fullPage),
+                    ...(embedEvents ? { embedEvents } : {}),
                 },
             };
         }
@@ -1199,6 +1269,7 @@ async function executePlaywrightAction(action, page, params) {
                 }
                 // Auto-capture screenshot after evaluation
                 const screenshot = await captureScreenshot(page);
+                const embedEvents = await drainEmbedEvents(page);
                 // Check for runtime errors (component crashes)
                 const runtimeErrors = await checkForRuntimeErrors(page);
                 return {
@@ -1210,6 +1281,7 @@ async function executePlaywrightAction(action, page, params) {
                     format: screenshot.format,
                     context: {
                         script: script.substring(0, 100) + (script.length > 100 ? "..." : ""),
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                     ...(runtimeErrors.hasErrors && {
                         runtimeErrors: runtimeErrors.errors,
@@ -1226,6 +1298,7 @@ async function executePlaywrightAction(action, page, params) {
                 catch {
                     // Ignore screenshot errors
                 }
+                const embedEvents = await drainEmbedEvents(page);
                 // If the error looks like a syntax error, provide helpful guidance
                 const errorMsg = String(error);
                 if (errorMsg.includes("SyntaxError") ||
@@ -1239,6 +1312,7 @@ async function executePlaywrightAction(action, page, params) {
                         format: errorScreenshot?.format ?? "png",
                         context: {
                             script: script.substring(0, 100) + (script.length > 100 ? "..." : ""),
+                            ...(embedEvents ? { embedEvents } : {}),
                         },
                         error: "JavaScript evaluation failed. Make sure your code is browser-compatible " +
                             "(no import/export statements). Error: " +
@@ -1253,6 +1327,7 @@ async function executePlaywrightAction(action, page, params) {
                     format: errorScreenshot?.format ?? "png",
                     context: {
                         script: script.substring(0, 100) + (script.length > 100 ? "..." : ""),
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                     error: String(error),
                 };
@@ -1280,6 +1355,150 @@ async function executePlaywrightAction(action, page, params) {
                 count: logs.length,
             };
         }
+        case "getEmbedEvents": {
+            const description = params.description || "Get embed events";
+            const events = lastDrainedEmbedEvents ?? (await drainEmbedEvents(page)) ?? [];
+            lastDrainedEmbedEvents = null;
+            const screenshot = await captureScreenshot(page);
+            // Check for runtime errors (component crashes)
+            const runtimeErrors = await checkForRuntimeErrors(page);
+            return {
+                success: !runtimeErrors.hasErrors,
+                action: "getEmbedEvents",
+                description,
+                screenshot: screenshot.data,
+                format: screenshot.format,
+                events,
+                count: events.length,
+                ...(runtimeErrors.hasErrors && {
+                    runtimeErrors: runtimeErrors.errors,
+                    error: `Component crashed with ${runtimeErrors.errors.length} runtime error(s): ${runtimeErrors.errors.map((e) => e.header).join(", ")}`,
+                }),
+            };
+        }
+        case "triggerEmbedEvent": {
+            const description = params.description || "Trigger embed event";
+            const eventName = params.eventName;
+            const payload = params.payload ?? {};
+            if (typeof eventName !== "string" || !eventName.trim()) {
+                throw new Error("Missing eventName for triggerEmbedEvent action");
+            }
+            try {
+                // Simulate the embedder sending a message into the iframe.
+                // The library converts this to a CustomEvent `superblocks:${eventName}`,
+                // which is what `useEmbedEvent()` listens to.
+                await page.evaluate(({ eventName, payload }) => {
+                    window.postMessage({
+                        type: "embed-trigger-event",
+                        payload: { eventName, payload },
+                        startTime: Date.now(),
+                    }, "*");
+                }, { eventName, payload });
+                await page.waitForTimeout(50);
+                const screenshot = await captureScreenshot(page);
+                const embedEvents = await drainEmbedEvents(page);
+                // Check for runtime errors (component crashes)
+                const runtimeErrors = await checkForRuntimeErrors(page);
+                return {
+                    success: !runtimeErrors.hasErrors,
+                    action: "triggerEmbedEvent",
+                    description,
+                    screenshot: screenshot.data,
+                    format: screenshot.format,
+                    context: {
+                        eventName,
+                        ...(embedEvents ? { embedEvents } : {}),
+                    },
+                    ...(runtimeErrors.hasErrors && {
+                        runtimeErrors: runtimeErrors.errors,
+                        error: `Component crashed with ${runtimeErrors.errors.length} runtime error(s): ${runtimeErrors.errors.map((e) => e.header).join(", ")}`,
+                    }),
+                };
+            }
+            catch (error) {
+                let errorScreenshot = null;
+                try {
+                    errorScreenshot = await captureScreenshot(page);
+                }
+                catch {
+                    // Ignore screenshot errors
+                }
+                const embedEvents = await drainEmbedEvents(page);
+                return {
+                    success: false,
+                    action: "triggerEmbedEvent",
+                    description,
+                    screenshot: errorScreenshot?.data,
+                    format: errorScreenshot?.format ?? "png",
+                    context: {
+                        eventName,
+                        ...(embedEvents ? { embedEvents } : {}),
+                    },
+                    error: `triggerEmbedEvent failed for "${eventName}": ${String(error)}`,
+                };
+            }
+        }
+        case "setEmbedProperties": {
+            const description = params.description || "Set embed properties";
+            const properties = params.properties;
+            if (!properties || typeof properties !== "object") {
+                throw new Error("Missing properties for setEmbedProperties action");
+            }
+            try {
+                // Simulate the embedder sending embed properties into the iframe.
+                // The library listens for "embed-property-change" and updates embedStore.properties,
+                // which is what `useEmbedProperties()` reads.
+                await page.evaluate(({ properties }) => {
+                    window.postMessage({
+                        type: "embed-property-change",
+                        payload: { properties },
+                        startTime: Date.now(),
+                    }, "*");
+                }, { properties });
+                await page.waitForTimeout(50);
+                const screenshot = await captureScreenshot(page);
+                const embedEvents = await drainEmbedEvents(page);
+                // Check for runtime errors (component crashes)
+                const runtimeErrors = await checkForRuntimeErrors(page);
+                return {
+                    success: !runtimeErrors.hasErrors,
+                    action: "setEmbedProperties",
+                    description,
+                    screenshot: screenshot.data,
+                    format: screenshot.format,
+                    context: {
+                        properties,
+                        ...(embedEvents ? { embedEvents } : {}),
+                    },
+                    ...(runtimeErrors.hasErrors && {
+                        runtimeErrors: runtimeErrors.errors,
+                        error: `Component crashed with ${runtimeErrors.errors.length} runtime error(s): ${runtimeErrors.errors.map((e) => e.header).join(", ")}`,
+                    }),
+                };
+            }
+            catch (error) {
+                let errorScreenshot = null;
+                try {
+                    errorScreenshot = await captureScreenshot(page);
+                }
+                catch {
+                    // Ignore screenshot errors
+                }
+                const embedEvents = await drainEmbedEvents(page);
+                return {
+                    success: false,
+                    action: "setEmbedProperties",
+                    description,
+                    screenshot: errorScreenshot?.data,
+                    format: errorScreenshot?.format ?? "png",
+                    context: {
+                        properties,
+                        ...(embedEvents ? { embedEvents } : {}),
+                    },
+                    error: `setEmbedProperties failed: ${String(error)}`,
+                };
+            }
+        }
         case "scroll": {
             const { x, y, deltaX, deltaY } = params;
             const description = params.description || "Scroll page";
@@ -1293,6 +1512,7 @@ async function executePlaywrightAction(action, page, params) {
                     }
                 }, { x, y, deltaX, deltaY });
                 const screenshot = await captureScreenshot(page);
+                const embedEvents = await drainEmbedEvents(page);
                 return {
                     success: true,
                     action: "scroll",
@@ -1304,6 +1524,7 @@ async function executePlaywrightAction(action, page, params) {
                         y,
                         deltaX,
                         deltaY,
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                 };
             }
@@ -1315,6 +1536,7 @@ async function executePlaywrightAction(action, page, params) {
                 catch {
                     // Ignore screenshot errors
                 }
+                const embedEvents = await drainEmbedEvents(page);
                 return {
                     success: false,
                     action: "scroll",
@@ -1326,6 +1548,7 @@ async function executePlaywrightAction(action, page, params) {
                         y,
                         deltaX,
                         deltaY,
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                     error: `Scroll failed: ${String(error)}`,
                 };
@@ -1342,6 +1565,7 @@ async function executePlaywrightAction(action, page, params) {
                     timeout: params.timeout ?? 10000,
                 });
                 const screenshot = await captureScreenshot(page);
+                const embedEvents = await drainEmbedEvents(page);
                 return {
                     success: true,
                     action: "scrollIntoView",
@@ -1350,6 +1574,7 @@ async function executePlaywrightAction(action, page, params) {
                     format: screenshot.format,
                     context: {
                         selector,
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                 };
             }
@@ -1361,6 +1586,7 @@ async function executePlaywrightAction(action, page, params) {
                 catch {
                     // Ignore screenshot errors
                 }
+                const embedEvents = await drainEmbedEvents(page);
                 return {
                     success: false,
                     action: "scrollIntoView",
@@ -1369,6 +1595,7 @@ async function executePlaywrightAction(action, page, params) {
                     format: errorScreenshot?.format ?? "png",
                     context: {
                         selector,
+                        ...(embedEvents ? { embedEvents } : {}),
                     },
                     error: `scrollIntoView failed on "${selector}": ${String(error)}`,
                 };