webgpu-profiler 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Redmond Riddell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# webgpu-profiler
+
+Live GPU memory profiler for WebGPU. One call patches the device, then every
+buffer and texture is tracked. Optional React HUD overlay.
+
+```bash
+npm install webgpu-profiler
+```
+
+## Use
+
+```ts
+import { autoInstrument } from "webgpu-profiler";
+
+// Once, at boot, before any renderer is created.
+if (process.env.NODE_ENV !== "production") autoInstrument();
+```
+
+```tsx
+import { MemoryHUD } from "webgpu-profiler/react";
+
+// Anywhere in your tree, dev-only:
+{process.env.NODE_ENV !== "production" && <MemoryHUD />}
+```
+
+That's it. The HUD finds the active instrumentation automatically.
+
+## What it does
+
+`autoInstrument()` patches `GPUAdapter.prototype.requestDevice` so any
+`GPUDevice` returned anywhere in the app gets its `createBuffer` and
+`createTexture` wrapped. Those are the only two WebGPU JS-side allocation
+entry points, so every buffer and texture is captured with its descriptor.
+The HUD polls a snapshot every second and shows a copyable breakdown.
+
+## API
+
+| Symbol | Purpose |
+|---|---|
+| `autoInstrument(options?)` | Patch the adapter prototype to auto-instrument every new device. Returns a disposer. |
+| `instrumentDevice(device)` | Manually instrument a single device. Idempotent. Returns a `DeviceInstrumentation` handle. |
+| `getActiveInstrumentation()` | Read the most recently registered handle (null if none). |
+| `subscribeActiveInstrumentation(cb)` | Subscribe to changes in the active handle. |
+| `profileMemory(inst)` | Build a `MemoryReport` snapshot from a handle. |
+| `reportToText(report)` | Plain-text rendering for clipboard / bug reports. |
+| `textureDescriptorBytes(desc)` | Byte calc for a single `GPUTextureDescriptor`. |
+| `resolveExtent(size)` | Normalize a `GPUExtent3D` to `{ width, height, depth }`. |
+| `MemoryHUD` *(from `/react`)* | Overlay component. All props optional. |
+
+`MemoryHUD` props: `instrumentation?`, `refreshMs?` (1000), `corner?`
+(`"top-right"` / `"top-left"` / `"bottom-right"` / `"bottom-left"`),
+`className?`, `style?`.
+
+### Building your own UI
+
+If you're not using React, `getActiveInstrumentation()` and
+`subscribeActiveInstrumentation()` let you react to instrumentation
+changes from any code:
+
+```ts
+import {
+  getActiveInstrumentation,
+  subscribeActiveInstrumentation,
+  profileMemory,
+} from "webgpu-profiler";
+
+const unsubscribe = subscribeActiveInstrumentation(() => {
+  const inst = getActiveInstrumentation();
+  if (inst) console.log(profileMemory(inst));
+});
+```
+
+## What is not counted
+
+- Canvas swapchain backbuffer (created by `context.configure()`, not
+  `createTexture`).
+- Driver-internal allocations: residency caches, MSAA backing, pipeline
+  objects, bind group layouts, staging buffers that bypass the JS API.
+  Always opaque to JS by design.
+
+Compare against your browser's per-tab GPU memory readout
+(Chrome `Shift+Esc`, "GPU Memory" column) to see the residual gap, which
+is typically 5 to 15 percent.
+
+## Caveats
+
+- WebGPU only. WebGL's allocation model differs significantly and is not
+  supported.
+- Depth-stencil formats (`depth24plus`, `depth32float-stencil8`, etc.) are
+  reported as their JS-API minimums. Real driver footprint is often
+  larger due to alignment and separate stencil planes.
+- ASTC bytes-per-pixel reflect the format's block size. Some
+  implementations may pad differently.
+
+## License
+
+MIT (c) Redmond Riddell

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { instrumentDevice, autoInstrument, getActiveInstrumentation, subscribeActiveInstrumentation, textureDescriptorBytes, resolveExtent, type DeviceInstrumentation, type TrackedBuffer, type TrackedTexture, type AutoInstrumentOptions, } from "./instrument.js";
+export { profileMemory, reportToText, type MemoryReport, type TextureEntry, type BufferEntry, } from "./profiler.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,wBAAwB,EACxB,8BAA8B,EAC9B,sBAAsB,EACtB,aAAa,EACb,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,qBAAqB,GAC3B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,aAAa,EACb,YAAY,EACZ,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,WAAW,GACjB,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { instrumentDevice, autoInstrument, getActiveInstrumentation, subscribeActiveInstrumentation, textureDescriptorBytes, resolveExtent, } from "./instrument.js";
+export { profileMemory, reportToText, } from "./profiler.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,wBAAwB,EACxB,8BAA8B,EAC9B,sBAAsB,EACtB,aAAa,GAKd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,aAAa,EACb,YAAY,GAIb,MAAM,eAAe,CAAC"}

package/dist/instrument.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Patches `GPUDevice.createBuffer` and `GPUDevice.createTexture` to track
+ * every GPU resource the page allocates. Combined with a `.destroy()` patch
+ * on each returned object, this gives a live view of all WebGPU memory
+ * the JS API can see.
+ *
+ * Why monkey-patch the device:
+ *   - WebGPU has *exactly two* JS-visible allocation entry points
+ *     (`createBuffer`, `createTexture`). Patching both captures everything
+ *     a renderer, post-processing nodes, and compute services allocate.
+ *   - No need to instrument production modules. This is the same pattern
+ *     used by React DevTools, Vue DevTools, and Chrome's GPU inspector.
+ *
+ * What is NOT captured (driver-internal, not exposed to JS):
+ *   - Canvas swapchain backbuffer (created by `context.configure()`).
+ *   - Driver-side staging buffers, residency systems, MSAA backing,
+ *     pipeline layouts, bind group memory.
+ *
+ * ## Timing
+ *
+ * Call `instrumentDevice(device)` *after* the renderer has obtained a
+ * `GPUDevice`, but *before* any other code allocates resources. In
+ * practice: right after the renderer's `init()` promise resolves. A few
+ * allocations (the swapchain, a couple of renderer internals) happen
+ * during init itself and will not be captured. Typical overhead: <5 MB.
+ *
+ * ## Usage
+ *
+ *     import { instrumentDevice } from "webgpu-profiler";
+ *
+ *     const inst = instrumentDevice(device);
+ *     // ... time passes ...
+ *     console.log(`GPU bytes: ${inst.bytes()}`);
+ *     // When done:
+ *     inst.uninstrument();
+ *
+ * The returned maps are live views — iterate at query time, do not cache.
+ * Entries are removed automatically when `buffer.destroy()` or
+ * `texture.destroy()` is called.
+ */
+export interface TrackedBuffer {
+    buffer: GPUBuffer;
+    descriptor: GPUBufferDescriptor;
+}
+export interface TrackedTexture {
+    texture: GPUTexture;
+    descriptor: GPUTextureDescriptor;
+}
+export interface DeviceInstrumentation {
+    readonly device: GPUDevice;
+    readonly buffers: ReadonlyMap<GPUBuffer, TrackedBuffer>;
+    readonly textures: ReadonlyMap<GPUTexture, TrackedTexture>;
+    /** Sum of all tracked buffer sizes, in bytes. */
+    bufferBytes(): number;
+    /** Sum of all tracked texture sizes (across formats, mip chains, layers). */
+    textureBytes(): number;
+    /** Combined total in bytes. */
+    bytes(): number;
+    /** Remove patches and restore the original device methods. */
+    uninstrument(): void;
+}
+/**
+ * Resolve a GPUExtent3D to (w, h, d). Per WebGPU spec, `size` is either a
+ * `GPUExtent3DDict` (object with `.width`) or any iterable of numbers
+ * (Array, Uint32Array, etc). `Array.isArray` returns false for typed
+ * arrays, so we discriminate on the dict's `width` property instead.
+ */
+export declare function resolveExtent(size: GPUExtent3D): {
+    width: number;
+    height: number;
+    depth: number;
+};
+/**
+ * Bytes occupied on the GPU by a texture with the given descriptor.
+ * Accounts for mip chain, array layers / depth, MSAA samples, and the
+ * format-specific bits per pixel.
+ *
+ * For 3D textures, each mip level halves all three dimensions, so the
+ * per-level pixel count series is `8^-i`. For 2D and 2D-array textures
+ * only x/y halve, giving `4^-i`.
+ */
+export declare function textureDescriptorBytes(desc: GPUTextureDescriptor): number;
+/**
+ * Returns the most recently registered active instrumentation (or `null`
+ * if none). For React, prefer using `MemoryHUD` without a prop — it reads
+ * this via `useSyncExternalStore` and re-renders when it changes.
+ */
+export declare function getActiveInstrumentation(): DeviceInstrumentation | null;
+/**
+ * Subscribe to changes in the active instrumentation. Returns an
+ * unsubscribe function. Used internally by `MemoryHUD` via React's
+ * `useSyncExternalStore`. Exposed for non-React consumers who want to
+ * react to active-instrumentation changes.
+ */
+export declare function subscribeActiveInstrumentation(cb: () => void): () => void;
+export declare function instrumentDevice(device: GPUDevice): DeviceInstrumentation;
+export interface AutoInstrumentOptions {
+    /** Called for each device the patch instruments. Useful for logging. */
+    onInstrument?: (instrumentation: DeviceInstrumentation) => void;
+}
+/**
+ * Patches `GPUAdapter.prototype.requestDevice` to auto-instrument every
+ * `GPUDevice` it returns. Returns a disposer that restores the original
+ * method (existing instrumentations stay live until their own
+ * `uninstrument()` is called).
+ *
+ * Typical usage at the top of your app boot file:
+ *
+ *     import { autoInstrument } from "webgpu-profiler";
+ *     if (import.meta.env.DEV) autoInstrument();
+ *
+ * No further wiring needed — render `<MemoryHUD />` anywhere.
+ */
+export declare function autoInstrument(options?: AutoInstrumentOptions): () => void;
+//# sourceMappingURL=instrument.d.ts.map

package/dist/instrument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrument.d.ts","sourceRoot":"","sources":["../src/instrument.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,SAAS,CAAC;IAClB,UAAU,EAAE,mBAAmB,CAAC;CACjC;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,UAAU,CAAC;IACpB,UAAU,EAAE,oBAAoB,CAAC;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;IACxD,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;IAC3D,iDAAiD;IACjD,WAAW,IAAI,MAAM,CAAC;IACtB,6EAA6E;IAC7E,YAAY,IAAI,MAAM,CAAC;IACvB,+BAA+B;IAC/B,KAAK,IAAI,MAAM,CAAC;IAChB,8DAA8D;IAC9D,YAAY,IAAI,IAAI,CAAC;CACtB;AA2ED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,WAAW,GAChB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAWlD;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,MAAM,CAazE;AAmBD;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,qBAAqB,GAAG,IAAI,CAEvE;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKzE;AAID,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,qBAAqB,CAsFzE;AAeD,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,YAAY,CAAC,EAAE,CAAC,eAAe,EAAE,qBAAqB,KAAK,IAAI,CAAC;CACjE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,MAAM,IAAI,CAiC9E"}

package/dist/instrument.js

@@ -0,0 +1,315 @@
+/**
+ * Patches `GPUDevice.createBuffer` and `GPUDevice.createTexture` to track
+ * every GPU resource the page allocates. Combined with a `.destroy()` patch
+ * on each returned object, this gives a live view of all WebGPU memory
+ * the JS API can see.
+ *
+ * Why monkey-patch the device:
+ *   - WebGPU has *exactly two* JS-visible allocation entry points
+ *     (`createBuffer`, `createTexture`). Patching both captures everything
+ *     a renderer, post-processing nodes, and compute services allocate.
+ *   - No need to instrument production modules. This is the same pattern
+ *     used by React DevTools, Vue DevTools, and Chrome's GPU inspector.
+ *
+ * What is NOT captured (driver-internal, not exposed to JS):
+ *   - Canvas swapchain backbuffer (created by `context.configure()`).
+ *   - Driver-side staging buffers, residency systems, MSAA backing,
+ *     pipeline layouts, bind group memory.
+ *
+ * ## Timing
+ *
+ * Call `instrumentDevice(device)` *after* the renderer has obtained a
+ * `GPUDevice`, but *before* any other code allocates resources. In
+ * practice: right after the renderer's `init()` promise resolves. A few
+ * allocations (the swapchain, a couple of renderer internals) happen
+ * during init itself and will not be captured. Typical overhead: <5 MB.
+ *
+ * ## Usage
+ *
+ *     import { instrumentDevice } from "webgpu-profiler";
+ *
+ *     const inst = instrumentDevice(device);
+ *     // ... time passes ...
+ *     console.log(`GPU bytes: ${inst.bytes()}`);
+ *     // When done:
+ *     inst.uninstrument();
+ *
+ * The returned maps are live views — iterate at query time, do not cache.
+ * Entries are removed automatically when `buffer.destroy()` or
+ * `texture.destroy()` is called.
+ */
+// ── GPUTextureFormat → bytes per texel ──────────────────────────────────────
+//
+// Comprehensive table per WebGPU spec. For compressed block formats, bpp is
+// the effective rate (BC1 = 0.5, BC7 = 1.0, etc.). A few approximate cases
+// (depth24plus, ASTC variants) are flagged inline.
+const FORMAT_BPP = {
+    // 8-bit single channel
+    r8unorm: 1, r8snorm: 1, r8uint: 1, r8sint: 1,
+    // 8-bit two channel
+    rg8unorm: 2, rg8snorm: 2, rg8uint: 2, rg8sint: 2,
+    // 8-bit four channel
+    rgba8unorm: 4, "rgba8unorm-srgb": 4,
+    rgba8snorm: 4, rgba8uint: 4, rgba8sint: 4,
+    bgra8unorm: 4, "bgra8unorm-srgb": 4,
+    // 16-bit single channel
+    r16float: 2, r16uint: 2, r16sint: 2, r16unorm: 2, r16snorm: 2,
+    // 16-bit two channel
+    rg16float: 4, rg16uint: 4, rg16sint: 4, rg16unorm: 4, rg16snorm: 4,
+    // 16-bit four channel
+    rgba16float: 8, rgba16uint: 8, rgba16sint: 8,
+    rgba16unorm: 8, rgba16snorm: 8,
+    // 32-bit single channel
+    r32float: 4, r32uint: 4, r32sint: 4,
+    // 32-bit two channel
+    rg32float: 8, rg32uint: 8, rg32sint: 8,
+    // 32-bit four channel
+    rgba32float: 16, rgba32uint: 16, rgba32sint: 16,
+    // Packed
+    rgb9e5ufloat: 4,
+    rgb10a2unorm: 4, rgb10a2uint: 4,
+    rg11b10ufloat: 4,
+    // Depth / stencil
+    stencil8: 1,
+    depth16unorm: 2,
+    depth24plus: 4, // implementation-defined, conservative
+    "depth24plus-stencil8": 4,
+    depth32float: 4,
+    "depth32float-stencil8": 5,
+    // Block-compressed (effective bytes per pixel)
+    "bc1-rgba-unorm": 0.5, "bc1-rgba-unorm-srgb": 0.5,
+    "bc2-rgba-unorm": 1, "bc2-rgba-unorm-srgb": 1,
+    "bc3-rgba-unorm": 1, "bc3-rgba-unorm-srgb": 1,
+    "bc4-r-unorm": 0.5, "bc4-r-snorm": 0.5,
+    "bc5-rg-unorm": 1, "bc5-rg-snorm": 1,
+    "bc6h-rgb-ufloat": 1, "bc6h-rgb-float": 1,
+    "bc7-rgba-unorm": 1, "bc7-rgba-unorm-srgb": 1,
+    "etc2-rgb8unorm": 0.5, "etc2-rgb8unorm-srgb": 0.5,
+    "etc2-rgb8a1unorm": 0.5, "etc2-rgb8a1unorm-srgb": 0.5,
+    "etc2-rgba8unorm": 1, "etc2-rgba8unorm-srgb": 1,
+    "eac-r11unorm": 0.5, "eac-r11snorm": 0.5,
+    "eac-rg11unorm": 1, "eac-rg11snorm": 1,
+    // ASTC variants are derived dynamically from the format string — see
+    // bytesPerTexel(). All ASTC blocks are 16 bytes; bpp is 16 / (W * H).
+};
+// ASTC block-compressed formats name their block dimensions inline, e.g.
+// `astc-4x4-unorm` or `astc-12x12-unorm-srgb`. Every block is 16 bytes,
+// covering W * H texels, so bpp = 16 / (W * H). Covers all 28 variants.
+const ASTC_RE = /^astc-(\d+)x(\d+)-/;
+function bytesPerTexel(format) {
+    const known = FORMAT_BPP[format];
+    if (known !== undefined)
+        return known;
+    const astc = ASTC_RE.exec(format);
+    if (astc) {
+        const blockW = Number(astc[1]);
+        const blockH = Number(astc[2]);
+        return 16 / (blockW * blockH);
+    }
+    return 4;
+}
+/**
+ * Resolve a GPUExtent3D to (w, h, d). Per WebGPU spec, `size` is either a
+ * `GPUExtent3DDict` (object with `.width`) or any iterable of numbers
+ * (Array, Uint32Array, etc). `Array.isArray` returns false for typed
+ * arrays, so we discriminate on the dict's `width` property instead.
+ */
+export function resolveExtent(size) {
+    if (size != null && typeof size.width === "number") {
+        const dict = size;
+        return {
+            width: dict.width,
+            height: dict.height ?? 1,
+            depth: dict.depthOrArrayLayers ?? 1,
+        };
+    }
+    const [width = 0, height = 1, depth = 1] = Array.from(size);
+    return { width, height, depth };
+}
+/**
+ * Bytes occupied on the GPU by a texture with the given descriptor.
+ * Accounts for mip chain, array layers / depth, MSAA samples, and the
+ * format-specific bits per pixel.
+ *
+ * For 3D textures, each mip level halves all three dimensions, so the
+ * per-level pixel count series is `8^-i`. For 2D and 2D-array textures
+ * only x/y halve, giving `4^-i`.
+ */
+export function textureDescriptorBytes(desc) {
+    const bpp = bytesPerTexel(desc.format);
+    const { width, height, depth } = resolveExtent(desc.size);
+    const is3D = desc.dimension === "3d";
+    const mipLevels = desc.mipLevelCount ?? 1;
+    const mipBase = is3D ? 8 : 4;
+    let mipFactor = 0;
+    for (let i = 0; i < mipLevels; i++)
+        mipFactor += Math.pow(mipBase, -i);
+    const sampleCount = desc.sampleCount ?? 1;
+    return Math.ceil(width * height * depth * bpp * mipFactor * sampleCount);
+}
+// ── Module-level active instrumentation ─────────────────────────────────────
+//
+// For ease of use, `instrumentDevice` sets the returned handle as the
+// "active" instrumentation. The React `MemoryHUD` reads from this state by
+// default, so callers don't need to thread the handle through props or
+// React context. Power users who want to manage multiple instrumentations
+// can still ignore the global and pass handles explicitly.
+let active = null;
+const subscribers = new Set();
+const INSTRUMENTED = Symbol.for("webgpu-profiler.instrumented");
+function notify() {
+    for (const cb of subscribers)
+        cb();
+}
+/**
+ * Returns the most recently registered active instrumentation (or `null`
+ * if none). For React, prefer using `MemoryHUD` without a prop — it reads
+ * this via `useSyncExternalStore` and re-renders when it changes.
+ */
+export function getActiveInstrumentation() {
+    return active;
+}
+/**
+ * Subscribe to changes in the active instrumentation. Returns an
+ * unsubscribe function. Used internally by `MemoryHUD` via React's
+ * `useSyncExternalStore`. Exposed for non-React consumers who want to
+ * react to active-instrumentation changes.
+ */
+export function subscribeActiveInstrumentation(cb) {
+    subscribers.add(cb);
+    return () => {
+        subscribers.delete(cb);
+    };
+}
+// ── Patcher ─────────────────────────────────────────────────────────────────
+export function instrumentDevice(device) {
+    // Idempotent: calling twice on the same device returns the existing
+    // handle rather than double-patching (and double-counting).
+    const existing = device[INSTRUMENTED];
+    if (existing) {
+        active = existing;
+        notify();
+        return existing;
+    }
+    const buffers = new Map();
+    const textures = new Map();
+    // Set to false by `uninstrument()`. Guards against a tracking write
+    // landing after teardown (rare, but possible if a `createBuffer` call
+    // is in-flight while uninstrument runs).
+    let alive = true;
+    const origCreateBuffer = device.createBuffer.bind(device);
+    const origCreateTexture = device.createTexture.bind(device);
+    device.createBuffer = (descriptor) => {
+        const buffer = origCreateBuffer(descriptor);
+        if (alive)
+            buffers.set(buffer, { buffer, descriptor });
+        const origDestroy = buffer.destroy.bind(buffer);
+        // GPUBuffer.destroy may be called multiple times; the patch handles
+        // that idempotently via the no-op Map.delete.
+        buffer.destroy = () => {
+            buffers.delete(buffer);
+            origDestroy();
+        };
+        return buffer;
+    };
+    device.createTexture = (descriptor) => {
+        const texture = origCreateTexture(descriptor);
+        if (alive)
+            textures.set(texture, { texture, descriptor });
+        const origDestroy = texture.destroy.bind(texture);
+        texture.destroy = () => {
+            textures.delete(texture);
+            origDestroy();
+        };
+        return texture;
+    };
+    const inst = {
+        device,
+        buffers,
+        textures,
+        bufferBytes() {
+            let total = 0;
+            for (const { descriptor } of buffers.values())
+                total += descriptor.size;
+            return total;
+        },
+        textureBytes() {
+            let total = 0;
+            for (const { descriptor } of textures.values()) {
+                total += textureDescriptorBytes(descriptor);
+            }
+            return total;
+        },
+        bytes() {
+            return this.bufferBytes() + this.textureBytes();
+        },
+        uninstrument() {
+            alive = false;
+            device.createBuffer = origCreateBuffer;
+            device.createTexture = origCreateTexture;
+            buffers.clear();
+            textures.clear();
+            delete device[INSTRUMENTED];
+            if (active === inst) {
+                active = null;
+                notify();
+            }
+        },
+    };
+    device[INSTRUMENTED] =
+        inst;
+    active = inst;
+    notify();
+    return inst;
+}
+// ── Auto-instrument ─────────────────────────────────────────────────────────
+//
+// Patches `GPUAdapter.prototype.requestDevice` so every device any code
+// requests is automatically instrumented as soon as it's created. Call
+// this once at boot — before any renderer or framework's `init()` runs —
+// and you're done. The React `MemoryHUD` picks up the active
+// instrumentation through `useSyncExternalStore`.
+//
+// Idempotent and safe to call multiple times. No-op if WebGPU is not
+// available in the current environment (e.g. SSR, older browsers).
+const ADAPTER_PATCHED = Symbol.for("webgpu-profiler.adapter-patched");
+/**
+ * Patches `GPUAdapter.prototype.requestDevice` to auto-instrument every
+ * `GPUDevice` it returns. Returns a disposer that restores the original
+ * method (existing instrumentations stay live until their own
+ * `uninstrument()` is called).
+ *
+ * Typical usage at the top of your app boot file:
+ *
+ *     import { autoInstrument } from "webgpu-profiler";
+ *     if (import.meta.env.DEV) autoInstrument();
+ *
+ * No further wiring needed — render `<MemoryHUD />` anywhere.
+ */
+export function autoInstrument(options = {}) {
+    if (typeof GPUAdapter === "undefined") {
+        // WebGPU not available in this environment; nothing to patch.
+        return () => undefined;
+    }
+    const proto = GPUAdapter.prototype;
+    if (proto[ADAPTER_PATCHED]) {
+        return () => undefined;
+    }
+    const orig = proto.requestDevice;
+    proto.requestDevice = async function (descriptor) {
+        const device = await orig.call(this, descriptor);
+        if (device) {
+            const inst = instrumentDevice(device);
+            options.onInstrument?.(inst);
+        }
+        return device;
+    };
+    proto[ADAPTER_PATCHED] = true;
+    return () => {
+        if (proto[ADAPTER_PATCHED]) {
+            proto.requestDevice = orig;
+            delete proto[ADAPTER_PATCHED];
+        }
+    };
+}
+//# sourceMappingURL=instrument.js.map

package/dist/instrument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrument.js","sourceRoot":"","sources":["../src/instrument.ts"],"names":[],"mappings":"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"}

package/dist/profiler.d.ts

@@ -0,0 +1,48 @@
+import { type DeviceInstrumentation } from "./instrument.js";
+/**
+ * Builds a snapshot of GPU memory currently allocated by the page, sourced
+ * from a {@link DeviceInstrumentation} handle (see `instrument.ts`).
+ *
+ * The numbers below are exact for every resource that flows through
+ * `GPUDevice.createBuffer` / `createTexture` — those are the only two
+ * WebGPU JS-side allocation entry points, so this is exhaustive by
+ * construction.
+ *
+ * Not counted (driver-internal, opaque to JS):
+ *   - Canvas swapchain backbuffer (created by `context.configure()`).
+ *   - Residency caches, MSAA backing, pipeline objects, bind group
+ *     layouts, staging buffers that bypass `createBuffer`.
+ */
+export interface TextureEntry {
+    name: string;
+    width: number;
+    height: number;
+    depth: number;
+    format: string;
+    mipLevels: number;
+    sampleCount: number;
+    /** True if this texture is a render attachment (post-fx, MRT, depth, etc.). */
+    isRenderTarget: boolean;
+    bytes: number;
+}
+export interface BufferEntry {
+    name: string;
+    bytes: number;
+    /** Pipe-separated decoded usage flags (e.g. "STORAGE|COPY_DST"). */
+    usage: string;
+}
+export interface MemoryReport {
+    sampledTextures: TextureEntry[];
+    renderTargets: TextureEntry[];
+    buffers: BufferEntry[];
+    totals: {
+        sampledTextures: number;
+        renderTargets: number;
+        buffers: number;
+        all: number;
+    };
+}
+export declare function profileMemory(instrumentation: DeviceInstrumentation): MemoryReport;
+/** Build a multi-line plain-text report. Feed to a copy button or bug report. */
+export declare function reportToText(report: MemoryReport): string;
+//# sourceMappingURL=profiler.d.ts.map

package/dist/profiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiler.d.ts","sourceRoot":"","sources":["../src/profiler.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,+EAA+E;IAC/E,cAAc,EAAE,OAAO,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,eAAe,EAAE,YAAY,EAAE,CAAC;IAChC,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,MAAM,EAAE;QACN,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;CACH;AAsCD,wBAAgB,aAAa,CAC3B,eAAe,EAAE,qBAAqB,GACrC,YAAY,CAkDd;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CA0BzD"}