autokap 1.3.13 → 1.3.15

package/dist/browser.js

@@ -822,28 +822,29 @@ export class Browser {
         const baseArgs = (process.platform === 'linux' && !isLinuxWithGpu)
             ? CHROMIUM_ARGS
             : CHROMIUM_ARGS.filter(arg => arg !== '--disable-gpu' && arg !== '--disable-gpu-sandbox');
-        // Pin ANGLE to the platform's native graphics API. Chrome's default
-        // backend is OpenGL on macOS, which is far slower than Metal for the
-        // compositor (measured 4 FPS vs 32 FPS at 2880×1800 on a heavy React UI).
-        // Same story on Windows where D3D11 is the native fast path. Cloud Run
-        // L4 routes through ANGLE→OpenGL using NVIDIA's libGL/libEGL (mounted at
-        // /usr/local/nvidia/lib64). We tried `--use-angle=vulkan` first but
-        // Cloud Run does not bind-mount the NVIDIA Vulkan ICD, so vulkaninfo
-        // resolves to llvmpipe (software fallback). The OpenGL path goes through
-        // the EGL/GLX libs that ARE mounted, hitting the L4 directly.
+        // Pin GPU backend to each platform's native graphics API:
+        //   - macOS: Metal (compositor 4→32 fps boost at 2880×1800 vs OpenGL).
+        //   - Windows: D3D11.
+        //   - Cloud Run Linux: ANGLE/Vulkan binding NVIDIA L4. The Dockerfile
+        //     ships /usr/share/vulkan/icd.d/nvidia_icd.json (Cloud Run does NOT
+        //     bind-mount it) so Vulkan loader resolves to libGLX_nvidia.so.0
+        //     instead of llvmpipe. Verified flag set comes from Musixmatch's
+        //     production K8s recipe and davesnider's Playwright benchmark.
         const angleArg = process.platform === 'darwin' ? '--use-angle=metal'
             : process.platform === 'win32' ? '--use-angle=d3d11'
-                : isLinuxWithGpu ? '--use-angle=gl'
+                : isLinuxWithGpu ? '--use-angle=vulkan'
                     : null;
-        // Cloud Run NVIDIA L4: GPU rasterization + zero-copy upload via the GL
-        // backend. `--ignore-gpu-blocklist` bypasses Chromium's hardcoded driver
-        // blocklist (it doesn't know about Cloud Run's mounted NVIDIA driver).
-        // These flags target the throughput wins for backdrop-filter, blur, and
-        // full-viewport repaints — the modal-open scenario that defeats software
-        // rasterization at ~1 fps.
+        // Cloud Run NVIDIA L4: ANGLE/Vulkan + GPU rasterization + zero-copy upload.
+        // `--ignore-gpu-blocklist` bypasses Chromium's hardcoded blocklist (it has
+        // no entry for Cloud Run's mounted NVIDIA driver). `--enable-features=Vulkan`
+        // is required so Chromium uses the Vulkan compositor instead of falling
+        // back through HARDWARE_GL → SWIFTSHADER. These flags target the throughput
+        // wins for backdrop-filter, blur, and full-viewport repaints — the modal
+        // scenario that pinned software rasterization at ~1 fps.
         const cloudGpuArgs = isLinuxWithGpu
             ? [
                 '--use-gl=angle',
+                '--enable-features=Vulkan',
                 '--ignore-gpu-blocklist',
                 '--enable-gpu-rasterization',
                 '--enable-zero-copy',
@@ -895,6 +896,36 @@ export class Browser {
             }
         }, { styleId: CAPTURE_HIDE_STYLE_ID, css: getCaptureHideCSS() });
         instance.page = await instance.context.newPage();
+        // Cloud Run only: query the WebGL UNMASKED_RENDERER_WEBGL string once
+        // per browser launch and log it. This is the source of truth for which
+        // GPU backend Chromium picked — flag combinations alone are not enough,
+        // because Chromium silently steps down the fallback chain
+        // (HARDWARE_VULKAN → HARDWARE_GL → SWIFTSHADER → DISPLAY_COMPOSITOR)
+        // when a backend fails to initialize. A renderer string containing
+        // "NVIDIA" confirms hardware; "SwiftShader" or "llvmpipe" means
+        // software fallback. Cheap (~50ms) and only runs in cloud mode.
+        if (isCloudRunner) {
+            try {
+                const gpuInfo = await instance.page.evaluate(() => {
+                    const canvas = document.createElement('canvas');
+                    const gl = (canvas.getContext('webgl2') || canvas.getContext('webgl'));
+                    if (!gl)
+                        return { error: 'no webgl context' };
+                    const ext = gl.getExtension('WEBGL_debug_renderer_info');
+                    if (!ext)
+                        return { error: 'no debug_renderer_info extension' };
+                    return {
+                        vendor: gl.getParameter(ext.UNMASKED_VENDOR_WEBGL),
+                        renderer: gl.getParameter(ext.UNMASKED_RENDERER_WEBGL),
+                        version: gl.getParameter(gl.VERSION),
+                    };
+                });
+                console.info('[gpu-check] WebGL renderer:', JSON.stringify(gpuInfo));
+            }
+            catch (err) {
+                console.warn('[gpu-check] WebGL query failed:', err.message);
+            }
+        }
         return instance;
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autokap",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "AI-powered CLI tool for capturing clean screenshots of websites",
   "type": "module",
   "main": "./dist/index.js",