@flighthq/render-wgpu 0.1.0

package/dist/wgpuTestHelper.js

@@ -0,0 +1,137 @@
+import { createWgpuRenderState } from './wgpuRenderState';
+// Wgpu flag constants are only type-level in @webgpu/types; install runtime values for JSDOM.
+function installWgpuConstants() {
+    const g = globalThis;
+    if (!g['GPUBufferUsage']) {
+        g['GPUBufferUsage'] = {
+            MAP_READ: 1,
+            MAP_WRITE: 2,
+            COPY_SRC: 4,
+            COPY_DST: 8,
+            INDEX: 16,
+            VERTEX: 32,
+            UNIFORM: 64,
+            STORAGE: 128,
+            INDIRECT: 256,
+            QUERY_RESOLVE: 512,
+        };
+    }
+    if (!g['GPUTextureUsage']) {
+        g['GPUTextureUsage'] = { COPY_SRC: 1, COPY_DST: 2, TEXTURE_BINDING: 4, STORAGE_BINDING: 8, RENDER_ATTACHMENT: 16 };
+    }
+    if (!g['GPUShaderStage']) {
+        g['GPUShaderStage'] = { VERTEX: 1, FRAGMENT: 2, COMPUTE: 4 };
+    }
+    if (!g['GPUColorWrite']) {
+        g['GPUColorWrite'] = { RED: 1, GREEN: 2, BLUE: 4, ALPHA: 8, ALL: 15 };
+    }
+    if (!g['GPUMapMode']) {
+        g['GPUMapMode'] = { READ: 1, WRITE: 2 };
+    }
+}
+// Minimal Wgpu mock for JSDOM test environments.
+// Provides enough surface area for state creation and basic draw call recording.
+function makeBindGroup() {
+    return {};
+}
+function makeBindGroupLayout() {
+    return {};
+}
+function makeBuffer() {
+    return { destroy: () => { } };
+}
+function makeTexture() {
+    return {
+        createView: () => ({}),
+        destroy: () => { },
+    };
+}
+function makeRenderPassEncoder() {
+    return {
+        draw: () => { },
+        end: () => { },
+        setBindGroup: () => { },
+        setPipeline: () => { },
+        setScissorRect: () => { },
+        setStencilReference: () => { },
+        setViewport: () => { },
+    };
+}
+function makeCommandEncoder() {
+    return {
+        beginRenderPass: () => makeRenderPassEncoder(),
+        finish: () => ({}),
+    };
+}
+function makePipeline() {
+    return {};
+}
+function makeShaderModule() {
+    return {};
+}
+function makeSampler() {
+    return {};
+}
+function makePipelineLayout() {
+    return {};
+}
+function makeDevice() {
+    return {
+        limits: { minUniformBufferOffsetAlignment: 256 },
+        createBindGroup: () => makeBindGroup(),
+        createBindGroupLayout: () => makeBindGroupLayout(),
+        createBuffer: () => makeBuffer(),
+        createCommandEncoder: () => makeCommandEncoder(),
+        createPipelineLayout: () => makePipelineLayout(),
+        createRenderPipeline: () => makePipeline(),
+        createSampler: () => makeSampler(),
+        createShaderModule: () => makeShaderModule(),
+        createTexture: () => makeTexture(),
+        queue: {
+            copyExternalImageToTexture: () => { },
+            submit: () => { },
+            writeBuffer: () => { },
+            writeTexture: () => { },
+        },
+    };
+}
+function makeAdapter() {
+    return {
+        requestDevice: () => Promise.resolve(makeDevice()),
+    };
+}
+export async function createWgpuRenderStateForTest() {
+    const canvas = document.createElement('canvas');
+    canvas.width = 800;
+    canvas.height = 600;
+    return createWgpuRenderState(canvas);
+}
+export function installWgpuMock() {
+    installWgpuConstants();
+    const gpu = {
+        getPreferredCanvasFormat: () => 'bgra8unorm',
+        requestAdapter: () => Promise.resolve(makeAdapter()),
+    };
+    // A shared (isolate:false) worker may reach this helper with no navigator present; defineProperty
+    // on a missing navigator throws, so ensure one exists before attaching the mock GPU.
+    if (globalThis.navigator == null) {
+        Object.defineProperty(globalThis, 'navigator', { value: {}, configurable: true, writable: true });
+    }
+    Object.defineProperty(globalThis.navigator, 'gpu', {
+        value: gpu,
+        configurable: true,
+        writable: true,
+    });
+    const origGetContext = HTMLCanvasElement.prototype.getContext;
+    HTMLCanvasElement.prototype.getContext = function (contextId, options) {
+        if (contextId === 'webgpu') {
+            return {
+                configure: () => { },
+                getCurrentTexture: () => makeTexture(),
+            };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return origGetContext.call(this, contextId, options);
+    };
+}
+//# sourceMappingURL=wgpuTestHelper.js.map

package/dist/wgpuTestHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuTestHelper.js","sourceRoot":"","sources":["../src/wgpuTestHelper.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,8FAA8F;AAC9F,SAAS,oBAAoB;IAC3B,MAAM,CAAC,GAAG,UAAqC,CAAC;IAEhD,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACzB,CAAC,CAAC,gBAAgB,CAAC,GAAG;YACpB,QAAQ,EAAE,CAAC;YACX,SAAS,EAAE,CAAC;YACZ,QAAQ,EAAE,CAAC;YACX,QAAQ,EAAE,CAAC;YACX,KAAK,EAAE,EAAE;YACT,MAAM,EAAE,EAAE;YACV,OAAO,EAAE,EAAE;YACX,OAAO,EAAE,GAAG;YACZ,QAAQ,EAAE,GAAG;YACb,aAAa,EAAE,GAAG;SACnB,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,CAAC,CAAC,iBAAiB,CAAC,EAAE,CAAC;QAC1B,CAAC,CAAC,iBAAiB,CAAC,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,iBAAiB,EAAE,EAAE,EAAE,CAAC;IACrH,CAAC;IACD,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACzB,CAAC,CAAC,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAC/D,CAAC;IACD,IAAI,CAAC,CAAC,CAAC,eAAe,CAAC,EAAE,CAAC;QACxB,CAAC,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC;IACxE,CAAC;IACD,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,EAAE,CAAC;QACrB,CAAC,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IAC1C,CAAC;AACH,CAAC;AAED,iDAAiD;AACjD,iFAAiF;AAEjF,SAAS,aAAa;IACpB,OAAO,EAAkB,CAAC;AAC5B,CAAC;AAED,SAAS,mBAAmB;IAC1B,OAAO,EAAwB,CAAC;AAClC,CAAC;AAED,SAAS,UAAU;IACjB,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAE,CAAC,EAA0B,CAAC;AACvD,CAAC;AAED,SAAS,WAAW;IAClB,OAAO;QACL,UAAU,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAmB;QACxC,OAAO,EAAE,GAAG,EAAE,GAAE,CAAC;KACO,CAAC;AAC7B,CAAC;AAED,SAAS,qBAAqB;IAC5B,OAAO;QACL,IAAI,EAAE,GAAG,EAAE,GAAE,CAAC;QACd,GAAG,EAAE,GAAG,EAAE,GAAE,CAAC;QACb,YAAY,EAAE,GAAG,EAAE,GAAE,CAAC;QACtB,WAAW,EAAE,GAAG,EAAE,GAAE,CAAC;QACrB,cAAc,EAAE,GAAG,EAAE,GAAE,CAAC;QACxB,mBAAmB,EAAE,GAAG,EAAE,GAAE,CAAC;QAC7B,WAAW,EAAE,GAAG,EAAE,GAAE,CAAC;KACa,CAAC;AACvC,CAAC;AAED,SAAS,kBAAkB;IACzB,OAAO;QACL,eAAe,EAAE,GAAG,EAAE,CAAC,qBAAqB,EAAE;QAC9C,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAqB;KACP,CAAC;AACpC,CAAC;AAED,SAAS,YAAY;IACnB,OAAO,EAAuB,CAAC;AACjC,CAAC;AAED,SAAS,gBAAgB;IACvB,OAAO,EAAqB,CAAC;AAC/B,CAAC;AAED,SAAS,WAAW;IAClB,OAAO,EAAgB,CAAC;AAC1B,CAAC;AAED,SAAS,kBAAkB;IACzB,OAAO,EAAuB,CAAC;AACjC,CAAC;AAED,SAAS,UAAU;IACjB,OAAO;QACL,MAAM,EAAE,EAAE,+BAA+B,EAAE,GAAG,EAAE;QAChD,eAAe,EAAE,GAAG,EAAE,CAAC,aAAa,EAAE;QACtC,qBAAqB,EAAE,GAAG,EAAE,CAAC,mBAAmB,EAAE;QAClD,YAAY,EAAE,GAAG,EAAE,CAAC,UAAU,EAAE;QAChC,oBAAoB,EAAE,GAAG,EAAE,CAAC,kBAAkB,EAAE;QAChD,oBAAoB,EAAE,GAAG,EAAE,CAAC,kBAAkB,EAAE;QAChD,oBAAoB,EAAE,GAAG,EAAE,CAAC,YAAY,EAAE;QAC1C,aAAa,EAAE,GAAG,EAAE,CAAC,WAAW,EAAE;QAClC,kBAAkB,EAAE,GAAG,EAAE,CAAC,gBAAgB,EAAE;QAC5C,aAAa,EAAE,GAAG,EAAE,CAAC,WAAW,EAAE;QAClC,KAAK,EAAE;YACL,0BAA0B,EAAE,GAAG,EAAE,GAAE,CAAC;YACpC,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;YAChB,WAAW,EAAE,GAAG,EAAE,GAAE,CAAC;YACrB,YAAY,EAAE,GAAG,EAAE,GAAE,CAAC;SACvB;KACsB,CAAC;AAC5B,CAAC;AAED,SAAS,WAAW;IAClB,OAAO;QACL,aAAa,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;KAC1B,CAAC;AAC7B,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,4BAA4B;IAChD,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IAChD,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC;IACnB,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC;IACpB,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,oBAAoB,EAAE,CAAC;IACvB,MAAM,GAAG,GAAQ;QACf,wBAAwB,EAAE,GAAG,EAAE,CAAC,YAAgC;QAChE,cAAc,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;KACnC,CAAC;IAEpB,kGAAkG;IAClG,qFAAqF;IACrF,IAAI,UAAU,CAAC,SAAS,IAAI,IAAI,EAAE,CAAC;QACjC,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,WAAW,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IACpG,CAAC;IACD,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,SAAS,EAAE,KAAK,EAAE;QACjD,KAAK,EAAE,GAAG;QACV,YAAY,EAAE,IAAI;QAClB,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;IAEH,MAAM,cAAc,GAAG,iBAAiB,CAAC,SAAS,CAAC,UAAU,CAAC;IAC7D,iBAAiB,CAAC,SAAqC,CAAC,UAAU,GAAG,UAEpE,SAAiB,EACjB,OAAiB;QAEjB,IAAI,SAAS,KAAK,QAAQ,EAAE,CAAC;YAC3B,OAAO;gBACL,SAAS,EAAE,GAAG,EAAE,GAAE,CAAC;gBACnB,iBAAiB,EAAE,GAAG,EAAE,CAAC,WAAW,EAAE;aACR,CAAC;QACnC,CAAC;QACD,8DAA8D;QAC9D,OAAQ,cAAsB,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC,CAAC;AACJ,CAAC"}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@flighthq/render-wgpu",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/displayobject": "0.1.0",
+    "@flighthq/geometry": "0.1.0",
+    "@flighthq/render": "0.1.0",
+    "@flighthq/surface": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "@webgpu/types": "*",
+    "typescript": "^5.3.0"
+  },
+  "description": "WebGPU renderer core: render state, targets, shaders, draw, surface, and background",
+  "sideEffects": false
+}

package/src/wgpuAdapterCapabilities.test.ts

@@ -0,0 +1,49 @@
+import { getWgpuAdapterCapabilities } from './wgpuAdapterCapabilities';
+
+function makeAdapter(features: ReadonlyArray<string> = [], limits: Record<string, number> = {}): GPUAdapter {
+  return {
+    features: new Set(features),
+    limits: { maxTextureDimension2D: 8192, ...limits },
+  } as unknown as GPUAdapter;
+}
+
+describe('getWgpuAdapterCapabilities', () => {
+  it('returns false for supportsFloat32Filterable when feature is absent', () => {
+    const caps = getWgpuAdapterCapabilities(makeAdapter([]));
+    expect(caps.supportsFloat32Filterable).toBe(false);
+  });
+
+  it('returns true for supportsFloat32Filterable when feature is present', () => {
+    const caps = getWgpuAdapterCapabilities(makeAdapter(['float32-filterable']));
+    expect(caps.supportsFloat32Filterable).toBe(true);
+  });
+
+  it('returns false for supportsTimestampQuery when feature is absent', () => {
+    const caps = getWgpuAdapterCapabilities(makeAdapter([]));
+    expect(caps.supportsTimestampQuery).toBe(false);
+  });
+
+  it('returns true for supportsTimestampQuery when feature is present', () => {
+    const caps = getWgpuAdapterCapabilities(makeAdapter(['timestamp-query']));
+    expect(caps.supportsTimestampQuery).toBe(true);
+  });
+
+  it('reads maxTextureDimension2D from adapter limits', () => {
+    const caps = getWgpuAdapterCapabilities(makeAdapter([], { maxTextureDimension2D: 16384 }));
+    expect(caps.maxTextureDimension2D).toBe(16384);
+  });
+
+  it('falls back to 8192 when maxTextureDimension2D is absent from limits', () => {
+    const adapter = {
+      features: new Set(),
+      limits: {},
+    } as unknown as GPUAdapter;
+    const caps = getWgpuAdapterCapabilities(adapter);
+    expect(caps.maxTextureDimension2D).toBe(8192);
+  });
+
+  it('reports maxSampleCount of 4', () => {
+    const caps = getWgpuAdapterCapabilities(makeAdapter([]));
+    expect(caps.maxSampleCount).toBe(4);
+  });
+});

package/src/wgpuBackground.test.ts

@@ -0,0 +1,52 @@
+import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
+import { getWgpuRenderStateRuntime } from './wgpuRenderState';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('renderWgpuBackground', () => {
+  it('opens a render pass on the state', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const runtime = getWgpuRenderStateRuntime(state);
+    expect(runtime.renderPass).toBeNull();
+    renderWgpuBackground(state);
+    expect(runtime.renderPass).not.toBeNull();
+  });
+
+  it('resets uniformOffset to zero', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const runtime = getWgpuRenderStateRuntime(state);
+    runtime.uniformOffset = 512;
+    renderWgpuBackground(state);
+    expect(runtime.uniformOffset).toBe(0);
+  });
+
+  it('creates a command encoder', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    expect(getWgpuRenderStateRuntime(state).commandEncoder).not.toBeNull();
+  });
+});
+
+describe('submitWgpuRenderPass', () => {
+  it('clears commandEncoder after submit', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    submitWgpuRenderPass(state);
+    expect(getWgpuRenderStateRuntime(state).commandEncoder).toBeNull();
+  });
+
+  it('clears renderPass after submit', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    submitWgpuRenderPass(state);
+    expect(getWgpuRenderStateRuntime(state).renderPass).toBeNull();
+  });
+
+  it('is safe to call without an open pass', async () => {
+    const state = await createWgpuRenderStateForTest();
+    expect(() => submitWgpuRenderPass(state)).not.toThrow();
+  });
+});

package/src/wgpuDraw.test.ts

@@ -0,0 +1,174 @@
+import { createBitmap } from '@flighthq/displayobject';
+import { getOrCreateRenderProxy2D, prepareDisplayObjectRender } from '@flighthq/render';
+import { BlendMode, ColorTransformMaterialKind, UniformColorTransformMaterialKind } from '@flighthq/types';
+
+import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
+import {
+  applyWgpuBlendMode,
+  bindWgpuTexture,
+  buildWgpuRenderTargetBindGroup,
+  createWgpuTextureEntry,
+  drawWgpuQuad,
+  drawWgpuQuadWithTransform,
+  enableWgpuBlendModeSupport,
+  getWgpuRenderProxyColorTransform,
+  submitWgpuQuadDraw,
+  updateWgpuTextureEntry,
+  warmWgpuPipelines,
+} from './wgpuDraw';
+import { getWgpuRenderStateRuntime } from './wgpuRenderState';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+describe('applyWgpuBlendMode', () => {
+  it('updates currentBlendMode on the state', async () => {
+    const state = await createWgpuRenderStateForTest();
+    applyWgpuBlendMode(state, BlendMode.Add);
+    expect(getWgpuRenderStateRuntime(state).currentBlendMode).toBe(BlendMode.Add);
+  });
+
+  it('accepts null', async () => {
+    const state = await createWgpuRenderStateForTest();
+    applyWgpuBlendMode(state, null);
+    expect(getWgpuRenderStateRuntime(state).currentBlendMode).toBeNull();
+  });
+});
+
+describe('bindWgpuTexture', () => {
+  it('creates and caches a texture entry', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const canvas = document.createElement('canvas');
+    canvas.width = 8;
+    canvas.height = 8;
+    const entry = bindWgpuTexture(state, canvas);
+    expect(entry).toBeDefined();
+    expect(entry.texture).toBeDefined();
+    expect(bindWgpuTexture(state, canvas)).toBe(entry);
+  });
+});
+
+describe('buildWgpuRenderTargetBindGroup', () => {
+  it('returns a bind group for a view', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const fakeView = {} as GPUTextureView;
+    const bindGroup = buildWgpuRenderTargetBindGroup(state, fakeView);
+    expect(bindGroup).toBeDefined();
+  });
+});
+
+describe('createWgpuTextureEntry', () => {
+  it('creates a texture entry from a canvas', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const entry = createWgpuTextureEntry(state, 4, 4, canvas);
+    expect(entry.texture).toBeDefined();
+    expect(entry.bindGroup).toBeDefined();
+  });
+});
+
+describe('drawWgpuQuad', () => {
+  it('does not throw when render pass is open', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    const bitmap = createBitmap();
+    prepareDisplayObjectRender(state, bitmap);
+    const renderProxy = getOrCreateRenderProxy2D(state, bitmap);
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const entry = bindWgpuTexture(state, canvas);
+    expect(() => drawWgpuQuad(state, renderProxy, entry, 0, 0, 4, 4, 0, 0, 1, 1)).not.toThrow();
+    submitWgpuRenderPass(state);
+  });
+});
+
+describe('drawWgpuQuadWithTransform', () => {
+  it('does not throw when render pass is open', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    const bitmap = createBitmap();
+    prepareDisplayObjectRender(state, bitmap);
+    const renderProxy = getOrCreateRenderProxy2D(state, bitmap);
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const entry = bindWgpuTexture(state, canvas);
+    const t = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+    expect(() => drawWgpuQuadWithTransform(state, renderProxy, t, entry, 0, 0, 4, 4, 0, 0, 1, 1)).not.toThrow();
+    submitWgpuRenderPass(state);
+  });
+});
+
+describe('enableWgpuBlendModeSupport', () => {
+  it('sets applyBlendMode', async () => {
+    const state = await createWgpuRenderStateForTest();
+    enableWgpuBlendModeSupport(state);
+    expect(state.applyBlendMode).not.toBeNull();
+  });
+});
+
+describe('getWgpuRenderProxyColorTransform', () => {
+  it('returns null when the node has no material', () => {
+    expect(getWgpuRenderProxyColorTransform({ material: null } as never)).toBeNull();
+  });
+
+  it('returns the value carried on a uniform color transform material', () => {
+    const colorTransform = { redMultiplier: 0.5 };
+    const node = { material: { kind: UniformColorTransformMaterialKind, colorTransform } } as never;
+    expect(getWgpuRenderProxyColorTransform(node)).toBe(colorTransform);
+  });
+
+  it('returns the per-node material data for a color transform material', () => {
+    const colorTransform = { redMultiplier: 0.5 };
+    const node = { material: { kind: ColorTransformMaterialKind }, materialData: colorTransform } as never;
+    expect(getWgpuRenderProxyColorTransform(node)).toBe(colorTransform);
+  });
+});
+
+describe('submitWgpuQuadDraw', () => {
+  it('does not throw when render pass is open', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const entry = bindWgpuTexture(state, canvas);
+    expect(() => submitWgpuQuadDraw(state, 0, entry.bindGroup)).not.toThrow();
+    submitWgpuRenderPass(state);
+  });
+
+  it('is a no-op when render pass is null', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const entry = bindWgpuTexture(state, canvas);
+    expect(() => submitWgpuQuadDraw(state, 0, entry.bindGroup)).not.toThrow();
+  });
+});
+
+describe('updateWgpuTextureEntry', () => {
+  it('does not throw when called with a canvas', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const canvas = document.createElement('canvas');
+    canvas.width = 4;
+    canvas.height = 4;
+    const entry = createWgpuTextureEntry(state, 4, 4, canvas);
+    expect(() => updateWgpuTextureEntry(state, entry, canvas)).not.toThrow();
+  });
+});
+
+describe('warmWgpuPipelines', () => {
+  it('pre-populates the pipeline cache', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const runtime = getWgpuRenderStateRuntime(state);
+    const before = runtime.pipelineCache.size;
+    warmWgpuPipelines(state);
+    expect(runtime.pipelineCache.size).toBeGreaterThanOrEqual(before);
+  });
+});

package/src/wgpuElement.test.ts

@@ -0,0 +1,21 @@
+import { createWgpuCanvasElement } from './wgpuElement';
+
+describe('createWgpuCanvasElement', () => {
+  it('sets CSS dimensions from width and height', () => {
+    const canvas = createWgpuCanvasElement(400, 300);
+    expect(canvas.style.width).toBe('400px');
+    expect(canvas.style.height).toBe('300px');
+  });
+
+  it('scales pixel dimensions by pixelRatio', () => {
+    const canvas = createWgpuCanvasElement(200, 100, 2);
+    expect(canvas.width).toBe(400);
+    expect(canvas.height).toBe(200);
+  });
+
+  it('defaults pixelRatio to 1', () => {
+    const canvas = createWgpuCanvasElement(300, 200);
+    expect(canvas.width).toBe(300);
+    expect(canvas.height).toBe(200);
+  });
+});

package/src/wgpuFullscreenPass.test.ts

@@ -0,0 +1,64 @@
+import { renderWgpuBackground, submitWgpuRenderPass } from './wgpuBackground';
+import {
+  createWgpuFullscreenPipeline,
+  destroyWgpuFullscreenPipeline,
+  drawWgpuFullscreenPass,
+} from './wgpuFullscreenPass';
+import { createWgpuRenderTarget } from './wgpuRenderTarget';
+import { createWgpuRenderStateForTest, installWgpuMock } from './wgpuTestHelper';
+
+beforeAll(() => {
+  installWgpuMock();
+});
+
+const SIMPLE_FRAGMENT_WGSL = /* wgsl */ `
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var smp : sampler;
+@fragment
+fn fs_main(@builtin(position) pos : vec4f) -> @location(0) vec4f {
+  return textureSample(tex, smp, pos.xy);
+}
+`;
+
+describe('createWgpuFullscreenPipeline', () => {
+  it('returns a pipeline with a layout and bind group layouts', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const result = createWgpuFullscreenPipeline(state, SIMPLE_FRAGMENT_WGSL, 1);
+    expect(result.pipeline).toBeDefined();
+    expect(result.pipelineLayout).toBeDefined();
+    expect(result.uniformBindGroupLayout).toBeDefined();
+    expect(result.textureBindGroupLayouts.length).toBe(1);
+  });
+
+  it('builds multiple texture bind group layouts when textureInputCount > 1', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const result = createWgpuFullscreenPipeline(state, SIMPLE_FRAGMENT_WGSL, 3);
+    expect(result.textureBindGroupLayouts.length).toBe(3);
+  });
+});
+
+describe('destroyWgpuFullscreenPipeline', () => {
+  it('does not throw', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const pipeline = createWgpuFullscreenPipeline(state, SIMPLE_FRAGMENT_WGSL, 1);
+    expect(() => destroyWgpuFullscreenPipeline(state, pipeline)).not.toThrow();
+  });
+});
+
+describe('drawWgpuFullscreenPass', () => {
+  it('does not throw when render pass is open and no uniforms', async () => {
+    const state = await createWgpuRenderStateForTest();
+    renderWgpuBackground(state);
+    const pipeline = createWgpuFullscreenPipeline(state, SIMPLE_FRAGMENT_WGSL, 1);
+    const target = createWgpuRenderTarget(state, 64, 64);
+    expect(() => drawWgpuFullscreenPass(state, pipeline, [target], null, null)).not.toThrow();
+    submitWgpuRenderPass(state);
+  });
+
+  it('is a no-op when render pass is not open', async () => {
+    const state = await createWgpuRenderStateForTest();
+    const pipeline = createWgpuFullscreenPipeline(state, SIMPLE_FRAGMENT_WGSL, 1);
+    const target = createWgpuRenderTarget(state, 64, 64);
+    expect(() => drawWgpuFullscreenPass(state, pipeline, [target], null, null)).not.toThrow();
+  });
+});

package/src/wgpuMaterialRegistry.test.ts

@@ -0,0 +1,56 @@
+import type { Material, WgpuMaterialRenderer, WgpuRenderState } from '@flighthq/types';
+import { DefaultMaterialKind, EntityRuntimeKey } from '@flighthq/types';
+
+import {
+  getWgpuMaterialRenderer,
+  registerWgpuMaterialRenderer,
+  resolveWgpuMaterialRenderer,
+} from './wgpuMaterialRegistry';
+import { createWgpuRenderStateRuntime } from './wgpuRenderState';
+
+const TestKind = 'TestMaterial';
+const testRenderer: WgpuMaterialRenderer = { instanceFloatCount: 0, getShaderModule: () => ({}) as GPUShaderModule };
+
+function makeState(): WgpuRenderState {
+  const state = {} as WgpuRenderState;
+  state[EntityRuntimeKey] = createWgpuRenderStateRuntime();
+  return state;
+}
+
+function makeMaterial(kind: string): Material {
+  return { kind } as Material;
+}
+
+describe('getWgpuMaterialRenderer', () => {
+  it('returns null when nothing is registered for the kind', () => {
+    expect(getWgpuMaterialRenderer(makeState(), TestKind)).toBeNull();
+  });
+});
+
+describe('registerWgpuMaterialRenderer', () => {
+  it('registers a renderer retrievable by kind', () => {
+    const state = makeState();
+    registerWgpuMaterialRenderer(state, TestKind, testRenderer);
+    expect(getWgpuMaterialRenderer(state, TestKind)).toBe(testRenderer);
+  });
+});
+
+describe('resolveWgpuMaterialRenderer', () => {
+  it('returns null when nothing is registered — no built-in fallback', () => {
+    expect(resolveWgpuMaterialRenderer(makeState(), null)).toBeNull();
+    expect(resolveWgpuMaterialRenderer(makeState(), makeMaterial(TestKind))).toBeNull();
+  });
+
+  it('returns the registered renderer for a material kind', () => {
+    const state = makeState();
+    registerWgpuMaterialRenderer(state, TestKind, testRenderer);
+    expect(resolveWgpuMaterialRenderer(state, makeMaterial(TestKind))).toBe(testRenderer);
+  });
+
+  it('falls back to the renderer registered for DefaultMaterialKind', () => {
+    const state = makeState();
+    registerWgpuMaterialRenderer(state, DefaultMaterialKind, testRenderer);
+    expect(resolveWgpuMaterialRenderer(state, makeMaterial('Other'))).toBe(testRenderer);
+    expect(resolveWgpuMaterialRenderer(state, null)).toBe(testRenderer);
+  });
+});