@flighthq/render-gl 0.3.0-next.1032.e2b99fc → 0.3.0-next.1220.6982c21

package/src/enableGlTextureResolverGuards.test.ts

@@ -0,0 +1,58 @@
+import { addLogSink, createMemoryLogSink, getMemoryLogSinkEntries, removeLogSink } from '@flighthq/log/contract';
+import { createTexture } from '@flighthq/texture/contract';
+import type { Image } from '@flighthq/types/contract';
+
+import { areGlTextureResolverGuardsEnabled, enableGlTextureResolverGuards } from './enableGlTextureResolverGuards';
+import { createGlState } from './glTestHelper';
+import { registerGlTextureResolver, resolveGlTexture } from './glTextureResolver';
+
+describe('areGlTextureResolverGuardsEnabled', () => {
+  it('reports whether diagnostics were installed for the state', () => {
+    const { state } = createGlState();
+    expect(areGlTextureResolverGuardsEnabled(state)).toBe(false);
+
+    enableGlTextureResolverGuards(state);
+    expect(areGlTextureResolverGuardsEnabled(state)).toBe(true);
+  });
+});
+
+describe('enableGlTextureResolverGuards', () => {
+  it('is idempotent', () => {
+    const { state } = createGlState();
+    enableGlTextureResolverGuards(state);
+    enableGlTextureResolverGuards(state);
+    expect(areGlTextureResolverGuardsEnabled(state)).toBe(true);
+  });
+
+  it('warns once for a missing resolver and stays silent for a registered resolver returning null', () => {
+    const { state } = createGlState();
+    const missing = textureWithKind('acme.missing.gl');
+    const registered = textureWithKind('acme.registered.gl');
+    const sink = createMemoryLogSink(4);
+    addLogSink(sink.sink);
+    enableGlTextureResolverGuards(state);
+    registerGlTextureResolver(state, 'acme.registered.gl', () => null);
+    try {
+      expect(resolveGlTexture(state, missing)).toBeNull();
+      expect(resolveGlTexture(state, missing)).toBeNull();
+      expect(resolveGlTexture(state, registered)).toBeNull();
+
+      const entries = getMemoryLogSinkEntries(sink);
+      expect(entries).toHaveLength(1);
+      expect(entries[0]?.data).toMatchObject({
+        kind: 'acme.missing.gl',
+        message:
+          'resolveGlTexture: texture source kind has no registered resolver — call registerGlTextureResolver(state, sourceKind, resolver), or copyGlRenderStateRegistrations(offscreenState, screenState) after a late screen registration',
+      });
+    } finally {
+      removeLogSink(sink.sink);
+    }
+  });
+});
+
+function textureWithKind(kind: string) {
+  return createTexture({
+    dimension: '2d',
+    source: { kind } as Image,
+  });
+}

package/src/explainGlTextureResolution.test.ts

@@ -0,0 +1,32 @@
+import { createEntity } from '@flighthq/entity/contract';
+import { createTexture } from '@flighthq/texture/contract';
+import type { TextureSource } from '@flighthq/types/contract';
+
+import { explainGlTextureResolution } from './explainGlTextureResolution';
+import { createGlState } from './glTestHelper';
+import { registerGlTextureResolver } from './glTextureResolver';
+
+describe('explainGlTextureResolution', () => {
+  it('distinguishes missing kinds, missing resolvers, and registered resolvers', () => {
+    const { state } = createGlState();
+    const texture = createTexture({
+      dimension: '2d',
+      source: createEntity({ height: 1, kind: 'acme.test', version: 0, width: 1 }) as TextureSource,
+    });
+
+    expect(explainGlTextureResolution(state, createTexture())).toEqual({
+      kind: null,
+      status: 'missing-kind',
+    });
+    expect(explainGlTextureResolution(state, texture)).toEqual({
+      kind: 'acme.test',
+      status: 'missing-resolver',
+    });
+
+    registerGlTextureResolver(state, 'acme.test', () => null);
+    expect(explainGlTextureResolution(state, texture)).toEqual({
+      kind: 'acme.test',
+      status: 'registered',
+    });
+  });
+});

package/src/glCompressedTexture.test.ts

@@ -1,5 +1,5 @@
 import type { CompressedImage, GlCompressedTextureSupport, TextureContainer } from '@flighthq/types/contract';
-import { CompressedImageTextureBackingKind } from '@flighthq/types/contract';
+import { CompressedImageTextureSourceKind } from '@flighthq/types/contract';
 
 import {
   detectGlCompressedTextureSupport,
@@ -51,7 +51,7 @@ function uploadableCompressedImage(containerOverrides?: Partial<TextureContainer
   return {
     compressed: { container: { ...makeContainer(), ...containerOverrides }, payload: new Uint8Array(16) },
     height: 4,
-    kind: CompressedImageTextureBackingKind,
+    kind: CompressedImageTextureSourceKind,
     version: 1,
     width: 4,
   } as unknown as CompressedImage;

package/src/glDraw.test.ts

@@ -1,10 +1,11 @@
-import type { Bitmap, CompressedImage, ImageResource, SamplerLike, Texture } from '@flighthq/types/contract';
+import { getTextureSource } from '@flighthq/texture/contract';
+import type { Bitmap, CompressedImage, Image, SamplerLike, Texture } from '@flighthq/types/contract';
 import {
   AdvancedBlendMode,
-  BitmapTextureBackingKind,
+  BitmapTextureSourceKind,
   BlendMode,
-  CompressedImageTextureBackingKind,
-  ImageTextureBackingKind,
+  CompressedImageTextureSourceKind,
+  ImageTextureSourceKind,
 } from '@flighthq/types/contract';
 
 import { registerGlCompressedTextureDecoder, registerGlCompressedTextureUpload } from './glCompressedTexture';
@@ -50,7 +51,7 @@ function compressedBc3Image(): CompressedImage {
     width: 4,
     height: 4,
     version: 1,
-    kind: CompressedImageTextureBackingKind,
+    kind: CompressedImageTextureSourceKind,
   } as unknown as CompressedImage;
 }
 
@@ -61,7 +62,7 @@ function bitmap(size: number, version: number): Bitmap {
     data: new Uint8ClampedArray(size * size * 4),
     format: 'rgba8unorm',
     height: size,
-    kind: BitmapTextureBackingKind,
+    kind: BitmapTextureSourceKind,
     version,
     width: size,
   } as unknown as Bitmap;
@@ -291,9 +292,9 @@ describe('bindGlImageResourceTexture', () => {
       source: document.createElement('img'),
       width: 1,
       height: 1,
-      kind: ImageTextureBackingKind,
+      kind: ImageTextureSourceKind,
       version: 1,
-    } as unknown as ImageResource;
+    } as unknown as Image;
     bindGlImageResourceTexture(state, image);
     expect(gl.texImage2D).toHaveBeenCalled();
   });
@@ -516,18 +517,16 @@ describe('bindGlVideoTexture', () => {
   function videoTexture(version: number, readyState = 4, videoWidth = 320, videoHeight = 240): Texture {
     return {
       sampler: makeSampler(),
-      storage: {
-        dimension: '2d',
-        image: {
-          source: { readyState, videoWidth, videoHeight } as unknown as HTMLVideoElement,
-          version,
-        },
+      dimension: '2d',
+      source: {
+        source: { readyState, videoWidth, videoHeight } as unknown as HTMLVideoElement,
+        version,
       },
       version,
     } as unknown as Texture;
   }
 
-  it('creates a texture, uploads the current frame, and caches by backing identity', () => {
+  it('creates a texture, uploads the current frame, and caches by source identity', () => {
     const { state, gl } = createGlState();
     const vt = videoTexture(3);
     const t1 = bindGlVideoTexture(state, vt);
@@ -538,20 +537,20 @@ describe('bindGlVideoTexture', () => {
       gl.RGBA,
       gl.RGBA,
       gl.UNSIGNED_BYTE,
-      (vt.storage.image as ImageResource).source,
+      (getTextureSource(vt) as Image).source,
     );
     const t2 = bindGlVideoTexture(state, vt);
     expect(t2).toBe(t1);
   });
 
-  it('re-uploads only when the backing version advances (the dirty-gate)', () => {
+  it('re-uploads only when the source version advances (the dirty-gate)', () => {
     const { state, gl } = createGlState();
     const vt = videoTexture(1);
     bindGlVideoTexture(state, vt);
     const uploads = (gl.texImage2D as ReturnType<typeof vi.fn>).mock.calls.length;
     bindGlVideoTexture(state, vt);
     expect((gl.texImage2D as ReturnType<typeof vi.fn>).mock.calls.length).toBe(uploads);
-    vt.storage.image!.version = 2;
+    getTextureSource(vt)!.version = 2;
     bindGlVideoTexture(state, vt);
     expect((gl.texImage2D as ReturnType<typeof vi.fn>).mock.calls.length).toBe(uploads + 1);
   });

package/src/glExternalTexture.test.ts

@@ -1,5 +1,5 @@
-import { getTextureBackingKind } from '@flighthq/texture/contract';
-import { ExternalTextureBackingKind } from '@flighthq/types/contract';
+import { getTextureSourceKind } from '@flighthq/texture/contract';
+import { ExternalTextureSourceKind } from '@flighthq/types/contract';
 
 import { createExternalGlTexture, disposeExternalGlTexture } from './glExternalTexture';
 import { createGlState } from './glTestHelper';
@@ -12,7 +12,7 @@ describe('createExternalGlTexture', () => {
     const deleteTexture = vi.spyOn(state.gl, 'deleteTexture');
     const texture = createExternalGlTexture(state, handle, { height: 16, width: 32 });
 
-    expect(getTextureBackingKind(texture)).toBe(ExternalTextureBackingKind);
+    expect(getTextureSourceKind(texture)).toBe(ExternalTextureSourceKind);
     expect(resolveGlTexture(state, texture)).toBe(handle);
     expect(disposeExternalGlTexture(state, texture)).toBe(true);
     expect(resolveGlTexture(state, texture)).toBeNull();

package/src/glFullscreenPass.test.ts

@@ -16,9 +16,22 @@ void main() {
 
 function makeTarget(framebuffer: WebGLFramebuffer, width = 32, height = 16): GlRenderTarget {
   return {
+    requestedAxes: {
+      width,
+      height,
+      format: 'rgba8',
+      colorAttachments: 1,
+      colorFormats: ['rgba8'],
+      sampleCount: 1,
+      depth: 'none',
+      colorSpace: 'srgb',
+    },
     width,
     height,
     format: 'rgba8',
+    colorAttachments: 1,
+    colorFormats: ['rgba8'],
+    depth: 'none',
     colorSpace: 'srgb',
     clearColors: [],
     clearDepth: 1,

package/src/glLinearToSrgbPass.test.ts

@@ -5,9 +5,22 @@ import { createGlState } from './glTestHelper';
 
 function makeTarget(framebuffer: WebGLFramebuffer, texture: WebGLTexture, width = 32, height = 16): GlRenderTarget {
   return {
+    requestedAxes: {
+      width,
+      height,
+      format: 'rgba16f',
+      colorAttachments: 1,
+      colorFormats: ['rgba16f'],
+      sampleCount: 1,
+      depth: 'none',
+      colorSpace: 'linear',
+    },
     width,
     height,
     format: 'rgba16f',
+    colorAttachments: 1,
+    colorFormats: ['rgba16f'],
+    depth: 'none',
     colorSpace: 'linear',
     clearColors: [],
     clearDepth: 1,

package/src/glPresentRenderTarget.test.ts

@@ -4,10 +4,24 @@ import { presentGlRenderTarget } from './glPresentRenderTarget';
 import { createGlState } from './glTestHelper';
 
 function makeTarget(colorSpace: 'linear' | 'srgb', texture: WebGLTexture): GlRenderTarget {
+  const format = colorSpace === 'linear' ? 'rgba16f' : 'rgba8';
   return {
+    requestedAxes: {
+      width: 32,
+      height: 16,
+      format,
+      colorAttachments: 1,
+      colorFormats: [format],
+      sampleCount: 1,
+      depth: 'none',
+      colorSpace,
+    },
     width: 32,
     height: 16,
-    format: colorSpace === 'linear' ? 'rgba16f' : 'rgba8',
+    format,
+    colorAttachments: 1,
+    colorFormats: [format],
+    depth: 'none',
     colorSpace,
     clearColors: [],
     clearDepth: 1,

package/src/glReadback.test.ts

@@ -5,9 +5,22 @@ import { createGlState } from './glTestHelper';
 
 function makeTarget(overrides?: Partial<GlRenderTarget>): GlRenderTarget {
   return {
+    requestedAxes: {
+      width: 4,
+      height: 4,
+      format: 'rgba8',
+      colorAttachments: 1,
+      colorFormats: ['rgba8'],
+      sampleCount: 1,
+      depth: 'none',
+      colorSpace: 'srgb',
+    },
     width: 4,
     height: 4,
     format: 'rgba8',
+    colorAttachments: 1,
+    colorFormats: ['rgba8'],
+    depth: 'none',
     colorSpace: 'srgb',
     sampleCount: 1,
     framebuffer: {} as WebGLFramebuffer,

package/src/glRenderPass.test.ts

@@ -1,4 +1,6 @@
 import { createMatrix } from '@flighthq/geometry/contract';
+import { getOrCreateRenderProxy2D } from '@flighthq/render/contract';
+import { createDisplayObject } from '@flighthq/scene2d/contract';
 import type { GlRenderTarget, Viewport } from '@flighthq/types/contract';
 
 import { beginGlRenderPass, endGlRenderPass, setGlRenderTransform2D } from './glRenderPass';
@@ -8,9 +10,22 @@ import { createGlState } from './glTestHelper';
 function makeTarget(overrides?: Partial<GlRenderTarget>): GlRenderTarget {
   const texture = { id: 'c0' } as unknown as WebGLTexture;
   return {
+    requestedAxes: {
+      width: 32,
+      height: 16,
+      format: 'rgba8',
+      colorAttachments: 1,
+      colorFormats: ['rgba8'],
+      sampleCount: 1,
+      depth: 'depth-stencil',
+      colorSpace: 'srgb',
+    },
     width: 32,
     height: 16,
     format: 'rgba8',
+    colorAttachments: 1,
+    colorFormats: ['rgba8'],
+    depth: 'depth-stencil',
     colorSpace: 'srgb',
     clearColors: [],
     clearDepth: 1,
@@ -161,6 +176,44 @@ describe('beginGlRenderPass', () => {
     expect(runtime.currentRenderTarget).toBe(outer);
     expect(runtime.renderTargetViewport).toEqual({ height: 48, width: 64, x: 0, y: 0 });
   });
+
+  it('shares pass ownership between render states using the same context', () => {
+    const outerFixture = createGlState();
+    const innerFixture = createGlState();
+    const { gl, state: outerState } = outerFixture;
+    const innerState = innerFixture.state;
+    (innerState as { gl: WebGL2RenderingContext }).gl = gl;
+    const outer = makeTarget({ width: 64, height: 48 });
+    const inner = makeTarget({ width: 32, height: 24 });
+
+    beginGlRenderPass(outerState, outer);
+    beginGlRenderPass(innerState, inner);
+    endGlRenderPass(innerState);
+
+    expect(vi.mocked(gl.bindFramebuffer).mock.calls.at(-1)?.[1]).toBe(outer.framebuffer);
+    expect(getGlRenderStateRuntime(outerState).currentRenderTarget).toBe(outer);
+    expect(getGlRenderStateRuntime(innerState).currentRenderTarget).toBeNull();
+    endGlRenderPass(outerState);
+  });
+
+  it('rejects a same-target contour pass across render states sharing one context', () => {
+    const outerFixture = createGlState();
+    const innerFixture = createGlState();
+    const { gl, state: outerState } = outerFixture;
+    const innerState = innerFixture.state;
+    (innerState as { gl: WebGL2RenderingContext }).gl = gl;
+    const target = makeTarget({ width: 64, height: 48 });
+
+    beginGlRenderPass(outerState, target);
+    getGlRenderStateRuntime(outerState).currentMaskDepth = 1;
+
+    expect(() => beginGlRenderPass(innerState, target)).toThrow(
+      'cannot nest the active framebuffer while a contour clip is live',
+    );
+    expect(getGlRenderStateRuntime(outerState).currentRenderTarget).toBe(target);
+    expect(getGlRenderStateRuntime(innerState).currentRenderTarget).toBeNull();
+    endGlRenderPass(outerState);
+  });
 });
 
 describe('endGlRenderPass', () => {
@@ -306,4 +359,14 @@ describe('setGlRenderTransform2D', () => {
 
     expect(state.renderTransform2D).toBe(original);
   });
+
+  it('dirties existing state-local proxy transforms for repeated offscreen captures', () => {
+    const { state } = createGlState();
+    const proxy = getOrCreateRenderProxy2D(state, createDisplayObject());
+    proxy.lastLocalTransformId = 7;
+
+    setGlRenderTransform2D(state, createMatrix());
+
+    expect(proxy.lastLocalTransformId).toBe(-1);
+  });
 });

package/src/glRenderState.test.ts

@@ -1,6 +1,18 @@
+import { addLogSink, createMemoryLogSink, getMemoryLogSinkEntries, removeLogSink } from '@flighthq/log/contract';
+import {
+  copyAllRenderersFromRenderState,
+  getRenderStateRuntime,
+  prepareScene2DRender,
+  registerRenderer,
+} from '@flighthq/render/contract';
+import { createDisplayObject } from '@flighthq/scene2d/contract';
 import { BlendMode } from '@flighthq/types/contract';
 
+import { enableGlRenderStateGuards } from './enableGlRenderStateGuards';
+import { registerGlMaterialRenderer } from './glMaterialRegistry';
 import {
+  copyGlRenderStateRegistrations,
+  createGlOffscreenRenderState,
   createGlRenderState,
   createGlRenderStateRuntime,
   destroyGlRenderState,
@@ -8,6 +20,7 @@ import {
   invalidateGlRenderStateCache,
 } from './glRenderState';
 import { makeGL } from './glTestHelper';
+import { registerGlTextureResolver } from './glTextureResolver';
 
 function makeCanvas() {
   const canvas = document.createElement('canvas');
@@ -18,6 +31,108 @@ function makeCanvas() {
   return { canvas, gl };
 }
 
+describe('copyGlRenderStateRegistrations', () => {
+  it('copies late GL registrations only when explicitly requested', () => {
+    const { canvas } = makeCanvas();
+    const screen = createGlRenderState(canvas);
+    const offscreen = createGlOffscreenRenderState(screen);
+    const resolver = vi.fn(() => null);
+    registerGlTextureResolver(screen, 'acme.LateTexture', resolver);
+
+    expect(getGlRenderStateRuntime(offscreen).glTextureResolverRegistry?.has('acme.LateTexture')).not.toBe(true);
+    copyGlRenderStateRegistrations(offscreen, screen);
+    expect(getGlRenderStateRuntime(offscreen).glTextureResolverRegistry?.get('acme.LateTexture')).toBe(resolver);
+  });
+});
+
+describe('createGlOffscreenRenderState', () => {
+  it('shares context resources while snapshotting registration policy into independent maps', () => {
+    const { canvas } = makeCanvas();
+    const screen = createGlRenderState(canvas);
+    const renderer = { createData: () => null, submit: vi.fn() };
+    const materialRenderer = { getBatchData: vi.fn(), getBatchFloats: vi.fn() } as never;
+    const paddingResolver = vi.fn(() => ({ bottom: 1, left: 1, right: 1, top: 1 }));
+    const textureResolver = vi.fn(() => null);
+    registerRenderer(screen, 'acme.Node', renderer);
+    registerGlMaterialRenderer(screen, 'acme.Material', materialRenderer);
+    registerGlTextureResolver(screen, 'acme.Texture', textureResolver);
+    getRenderStateRuntime(screen).renderEffectPaddingResolverRegistry = new Map([['acme.Effect', paddingResolver]]);
+    getGlRenderStateRuntime(screen).glRenderTextureCache = new WeakMap();
+
+    const offscreen = createGlOffscreenRenderState(screen);
+    const screenRuntime = getGlRenderStateRuntime(screen);
+    const offscreenRuntime = getGlRenderStateRuntime(offscreen);
+
+    expect(offscreen.gl).toBe(screen.gl);
+    expect(offscreen.canvas).toBe(screen.canvas);
+    expect(offscreenRuntime.textureCache).toBe(screenRuntime.textureCache);
+    expect(offscreenRuntime.textureSourcePremultipliedTextureCache).toBe(
+      screenRuntime.textureSourcePremultipliedTextureCache,
+    );
+    expect(offscreenRuntime.glRenderTextureCache).toBe(screenRuntime.glRenderTextureCache);
+    expect(offscreenRuntime.quadIndexBuffer).toBe(screenRuntime.quadIndexBuffer);
+    expect(offscreenRuntime.rendererMap).not.toBe(screenRuntime.rendererMap);
+    expect(offscreenRuntime.materialRendererMap).not.toBe(screenRuntime.materialRendererMap);
+    expect(offscreenRuntime.glTextureResolverRegistry).not.toBe(screenRuntime.glTextureResolverRegistry);
+    expect(offscreenRuntime.renderEffectPaddingResolverRegistry).not.toBe(
+      screenRuntime.renderEffectPaddingResolverRegistry,
+    );
+    expect(offscreenRuntime.rendererMap.get('acme.Node')).toBe(renderer);
+    expect(offscreenRuntime.materialRendererMap?.get('acme.Material')).toBe(materialRenderer);
+    expect(offscreenRuntime.glTextureResolverRegistry?.get('acme.Texture')).toBe(textureResolver);
+    expect(offscreenRuntime.renderEffectPaddingResolverRegistry?.get('acme.Effect')).toBe(paddingResolver);
+
+    screenRuntime.currentProgram = {} as WebGLProgram;
+    expect(offscreenRuntime.currentProgram).toBe(screenRuntime.currentProgram);
+  });
+
+  it('requires explicit re-copy for registrations added after derivation', () => {
+    const { canvas } = makeCanvas();
+    const screen = createGlRenderState(canvas);
+    const offscreen = createGlOffscreenRenderState(screen);
+    const renderer = { createData: () => null, submit: vi.fn() };
+    const paddingResolver = vi.fn(() => ({ bottom: 2, left: 2, right: 2, top: 2 }));
+    const resolver = vi.fn(() => null);
+    registerRenderer(screen, 'acme.LateNode', renderer);
+    registerGlTextureResolver(screen, 'acme.LateTexture', resolver);
+    getRenderStateRuntime(screen).renderEffectPaddingResolverRegistry = new Map([['acme.LateEffect', paddingResolver]]);
+
+    expect(getRenderStateRuntime(offscreen).rendererMap.has('acme.LateNode')).toBe(false);
+    expect(getGlRenderStateRuntime(offscreen).glTextureResolverRegistry?.has('acme.LateTexture')).not.toBe(true);
+    expect(getRenderStateRuntime(offscreen).renderEffectPaddingResolverRegistry?.has('acme.LateEffect')).not.toBe(true);
+
+    copyAllRenderersFromRenderState(offscreen, screen);
+    copyGlRenderStateRegistrations(offscreen, screen);
+    expect(getRenderStateRuntime(offscreen).rendererMap.get('acme.LateNode')).toBe(renderer);
+    expect(getGlRenderStateRuntime(offscreen).glTextureResolverRegistry?.get('acme.LateTexture')).toBe(resolver);
+    expect(getRenderStateRuntime(offscreen).renderEffectPaddingResolverRegistry?.get('acme.LateEffect')).toBe(
+      paddingResolver,
+    );
+  });
+
+  it('keeps proxy trees independent and destroys derived renderer data without freeing shared context resources', () => {
+    const { canvas, gl } = makeCanvas();
+    const screen = createGlRenderState(canvas);
+    const destroyData = vi.fn();
+    const root = createDisplayObject();
+    registerRenderer(screen, root.kind, {
+      createData: () => createEntity({}),
+      destroyData,
+      submit: vi.fn(),
+    });
+    const offscreen = createGlOffscreenRenderState(screen);
+    prepareScene2DRender(offscreen, root);
+
+    expect(getRenderStateRuntime(offscreen).renderProxyMap).not.toBe(getRenderStateRuntime(screen).renderProxyMap);
+    destroyGlRenderState(offscreen);
+    expect(destroyData).toHaveBeenCalledOnce();
+    expect(gl.deleteProgram).not.toHaveBeenCalled();
+
+    destroyGlRenderState(screen);
+    expect(gl.deleteProgram).toHaveBeenCalled();
+  });
+});
+
 describe('createGlRenderState', () => {
   it('throws when Gl2 context is unavailable', () => {
     const canvas = document.createElement('canvas');
@@ -141,6 +256,25 @@ describe('destroyGlRenderState', () => {
   });
 });
 
+describe('enableGlRenderStateGuards', () => {
+  it('warns when one GL pipeline prepares two different roots', () => {
+    const { canvas } = makeCanvas();
+    const state = createGlRenderState(canvas);
+    const sink = createMemoryLogSink(4);
+    addLogSink(sink.sink);
+    enableGlRenderStateGuards(state);
+    try {
+      prepareScene2DRender(state, createDisplayObject());
+      prepareScene2DRender(state, createDisplayObject());
+      const entries = getMemoryLogSinkEntries(sink);
+      expect(entries).toHaveLength(1);
+      expect((entries[0].data as { message: string }).message).toContain('createGlOffscreenRenderState');
+    } finally {
+      removeLogSink(sink.sink);
+    }
+  });
+});
+
 describe('getGlRenderStateRuntime', () => {
   it('returns the runtime attached by createGlRenderState', () => {
     const { canvas } = makeCanvas();
@@ -184,3 +318,4 @@ describe('invalidateGlRenderStateCache', () => {
     expect(runtime.renderTargetViewport).toBeNull();
   });
 });
+import { createEntity } from '@flighthq/entity/contract';