Launch a new Chrome/Edge instance controlled by this plugin. Every page it opens is automatically instrumented with the WebGPU Inspector — no extension and no page changes needed. Optionally navigate a first tab to a URL.

Attach to an already-running Chrome/Edge that was started with --remote-debugging-port. New tabs and navigations are instrumented automatically.

Open a new instrumented tab in the controlled browser and navigate it to a URL. Waits for the page to connect to the bridge and returns it ready to capture.

Report whether a controlled browser is connected, how it was connected, which targets are instrumented, and which pages have connected to the bridge.

List browser pages currently connected to the live bridge. A page connects after it is instrumented (via launch_browser/open_page) or after it calls webgpuInspector.initializeServer() itself.

Capture a PNG screenshot of an instrumented page and return it as an image. This reads the COMPOSITED page — the WebGPU canvas exactly as it was presented — so it is the reliable way to SEE what an engine rendered, independent of how it pools/aliases its render targets (reading a pooled target back after the frame is unreliable; the presented surface is not). Requires a page opened via launch_browser/open_page. Use this to visually verify a rendering change, not to inspect intermediate G-buffer contents (use read_texture / capture_frames for those).

Ask a connected page to capture one or more WebGPU frames, then return a summary of the resulting capture (command/draw/pass counts, object counts, validation errors, flagged issues). Use list_pages first if unsure. For a PERFORMANCE analysis, set profilePasses:true (and payloads:"none" for a light perf-only capture) to measure per-pass GPU time, then call analyze_performance — treat a performance request as implying profilePasses:true.

List captures currently available to analyze (both live captures and capture files that were explicitly loaded).

Load a WebGPU Inspector capture file from disk (a .wgpuc binary saved by saveCaptureData() or the DevTools 'Save Capture' action, or a legacy .json capture) so it can be analyzed.

Summarize a capture: object counts by type, command counts by method, derived render statistics, shader entry points, validation error count, and heuristic performance/correctness issues. When the capture was taken with profilePasses:true it also includes gpuTiming (per-frame GPU time, slowest pass); when taken from a live page it includes frameBudget with a CPU/GPU/vsync bound verdict. For a focused performance report, use analyze_performance instead.

Diagnose a capture's performance and return concrete improvement suggestions. Reports the frame budget and a CPU- / GPU- / vsync-bound verdict (needs a live capture for CPU/refresh context and profilePasses:true for GPU time), render passes ranked by GPU time (or fill workload when untimed) each annotated with render-target size/format/MSAA, blend usage, fragment-shader complexity, and a likely bottleneck (fillrate/ROP vs fragment-ALU), plus heuristic issues and ranked suggestions. Best paired with a capture taken via capture_frames({ profilePasses: true, payloads: "none" }).

Return a paginated, base64-stripped slice of a capture's command list. Each entry has its index, method, pass number, object, and arguments.

Return one GPU object record from a capture (descriptor, label, stacktrace), with base64 payloads omitted.

Return the WGSL source code of a ShaderModule object in a capture.

Return the WebGPU validation errors recorded during a capture.

Resolve the full GPU state for a draw/dispatch command: the bound pipeline (and its vertex layout), bind groups per slot (with resource ids), vertex buffers per slot (each with the command index that captured its bytes), the index buffer, and draw params. Use this to diagnose what a specific draw actually read.

Decode the first N vertices of a captured vertex buffer into per-attribute numbers, so you can read e.g. 'attribute @location(2) (uv) = (0,0)' directly. Pass the bufferDataCommandIndex from get_draw_state (a setVertexBuffer command); the vertex layout is taken from the draw's pipeline automatically (or pass layout/pipelineId).

Structurally diff the resolved state (pipeline, bind groups, vertex/index bindings, draw params) of two draw commands — useful when a working draw and a broken draw share a pipeline and the difference must be in bound resources.

Read the current contents of a live GPU buffer on a connected page, without taking a full capture. The inspector copies the buffer to a readback buffer, maps it, and returns the bytes decoded as the requested type. The source buffer must have been created with COPY_SRC usage (buffers created while a capture is armed are given COPY_SRC).

Read a region of a live GPU texture / render target (G-buffer attachment, depth, canvas) on a connected page, without taking a full capture. Copies the texture to a readback buffer, decodes per its format, and returns per-channel min/max/mean, the fraction of unrasterised 'hole' texels (RGB all ~0 = the clear value showing through), and a small ASCII luminance view of the spatial pattern — never raw pixels. Pass a Texture id OR a TextureView id (a render pass attachment is a TextureView — it is resolved to its source texture automatically, so no get_object round-trip is needed). The texture must have COPY_SRC, which the inspector adds to every texture while a capture is armed. Note: reading an engine's POOLED render target after the frame can be unreliable (the pool may have recycled it); to see the final image use screenshot_page instead.

Sample a live page's frame-health metrics over a short window (without taking a capture) and return aggregates: frame rate (fps), average and worst frame time, dropped frames, CPU submit time (main-thread cost per frame), the estimated display refresh interval, and a CPU-vs-GPU/vsync bound verdict. Use this to tell whether a page is dropping frames and whether it's CPU/main-thread bound; GPU time is not measured live, so a non-CPU verdict reads "GPU/vsync" — take a capture with profilePasses:true to measure GPU time and confirm. Requires the page's rendering loop to use requestAnimationFrame.