@flighthq/render 0.2.1-next.738.07b221d → 0.2.1-next.841.373388f

package/src/{explainDisplayObjectRender.test.ts → explainScene2DRender.test.ts}

@@ -1,22 +1,22 @@
-import { createDisplayObject } from '@flighthq/displayobject';
 import { addNodeChild } from '@flighthq/node';
+import { createDisplayObject } from '@flighthq/scene2d';
 
-import { explainDisplayObjectRender } from './explainDisplayObjectRender';
+import { explainScene2DRender } from './explainScene2DRender';
 import { registerRenderer } from './renderer';
-import { getRenderProxy2D, prepareDisplayObjectRender } from './renderProxy';
+import { getRenderProxy2D, prepareScene2DRender } from './renderProxy';
 import { createRenderState, getRenderStateRuntime } from './renderState';
 
 function makeRenderer() {
   return { createData: () => ({ tag: 'data' }), submit: vi.fn() } as any;
 }
 
-describe('explainDisplayObjectRender', () => {
+describe('explainScene2DRender', () => {
   it('reports no-renderer for a node whose kind has no registered renderer', () => {
     const state = createRenderState();
     const source = createDisplayObject();
-    prepareDisplayObjectRender(state, source);
+    prepareScene2DRender(state, source);
 
-    const explanation = explainDisplayObjectRender(state, source);
+    const explanation = explainScene2DRender(state, source);
 
     expect(explanation.hasRenderer).toBe(false);
     expect(explanation.reason).toBe('no-renderer');
@@ -28,7 +28,7 @@ describe('explainDisplayObjectRender', () => {
     const source = createDisplayObject();
     registerRenderer(state, source.kind, makeRenderer());
 
-    const explanation = explainDisplayObjectRender(state, source);
+    const explanation = explainScene2DRender(state, source);
 
     expect(explanation.hasRenderer).toBe(true);
     expect(explanation.prepared).toBe(false);
@@ -39,9 +39,9 @@ describe('explainDisplayObjectRender', () => {
     const state = createRenderState();
     const source = createDisplayObject();
     registerRenderer(state, source.kind, makeRenderer());
-    prepareDisplayObjectRender(state, source);
+    prepareScene2DRender(state, source);
 
-    const explanation = explainDisplayObjectRender(state, source);
+    const explanation = explainScene2DRender(state, source);
 
     expect(explanation.prepared).toBe(true);
     expect(explanation.visible).toBe(true);
@@ -54,9 +54,9 @@ describe('explainDisplayObjectRender', () => {
     const source = createDisplayObject();
     source.visible = false;
     registerRenderer(state, source.kind, makeRenderer());
-    prepareDisplayObjectRender(state, source);
+    prepareScene2DRender(state, source);
 
-    const explanation = explainDisplayObjectRender(state, source);
+    const explanation = explainScene2DRender(state, source);
 
     expect(explanation.visible).toBe(false);
     expect(explanation.reason).toBe('not-visible');
@@ -67,9 +67,9 @@ describe('explainDisplayObjectRender', () => {
     const source = createDisplayObject();
     source.alpha = 0;
     registerRenderer(state, source.kind, makeRenderer());
-    prepareDisplayObjectRender(state, source);
+    prepareScene2DRender(state, source);
 
-    const explanation = explainDisplayObjectRender(state, source);
+    const explanation = explainScene2DRender(state, source);
 
     expect(explanation.visible).toBe(true);
     expect(explanation.effectiveAlpha).toBe(0);
@@ -83,9 +83,9 @@ describe('explainDisplayObjectRender', () => {
     parent.visible = false;
     addNodeChild(parent, child);
     registerRenderer(state, child.kind, makeRenderer());
-    prepareDisplayObjectRender(state, parent);
+    prepareScene2DRender(state, parent);
 
-    const explanation = explainDisplayObjectRender(state, child);
+    const explanation = explainScene2DRender(state, child);
 
     expect(explanation.prepared).toBe(false);
     expect(explanation.reason).toBe('not-prepared');
@@ -99,9 +99,9 @@ describe('explainDisplayObjectRender', () => {
     child.alpha = 0.5;
     addNodeChild(parent, child);
     registerRenderer(state, child.kind, makeRenderer());
-    prepareDisplayObjectRender(state, parent);
+    prepareScene2DRender(state, parent);
 
-    const explanation = explainDisplayObjectRender(state, child);
+    const explanation = explainScene2DRender(state, child);
 
     expect(explanation.effectiveAlpha).toBeCloseTo(0.25);
     expect(explanation.reason).toBe('ok');
@@ -112,10 +112,10 @@ describe('explainDisplayObjectRender', () => {
     const source = createDisplayObject();
     registerRenderer(state, source.kind, makeRenderer());
 
-    expect(() => explainDisplayObjectRender(state, source)).not.toThrow();
+    expect(() => explainScene2DRender(state, source)).not.toThrow();
     // Two calls agree and neither materialized a proxy — the query is a pure read.
-    const first = explainDisplayObjectRender(state, source);
-    const second = explainDisplayObjectRender(state, source);
+    const first = explainScene2DRender(state, source);
+    const second = explainScene2DRender(state, source);
     expect(second).toEqual(first);
     expect(getRenderProxy2D(state, source)).toBeUndefined();
     expect(getRenderStateRuntime(state).renderProxyMap.get(source)).toBeUndefined();
@@ -125,6 +125,6 @@ describe('explainDisplayObjectRender', () => {
     const state = createRenderState();
     const bare = { kind: 'DisplayObject' } as any;
 
-    expect(() => explainDisplayObjectRender(state, bare)).not.toThrow();
+    expect(() => explainScene2DRender(state, bare)).not.toThrow();
   });
 });

package/src/renderAppearance.test.ts

@@ -1,5 +1,5 @@
-import { createDisplayObject } from '@flighthq/displayobject';
 import { invalidateNodeAppearance } from '@flighthq/node';
+import { createDisplayObject } from '@flighthq/scene2d';
 import { BlendMode } from '@flighthq/types';
 
 import { updateRenderProxyAppearance } from './renderAppearance';

package/src/renderCache.test.ts

@@ -1,4 +1,4 @@
-import { createDisplayObject } from '@flighthq/displayobject';
+import { createDisplayObject } from '@flighthq/scene2d';
 import { connectSignal } from '@flighthq/signals';
 
 import {

package/src/renderColorTransform.test.ts

@@ -1,10 +1,6 @@
 import { createColorTransformAdjustment } from '@flighthq/adjustments';
-import {
-  createDisplayObject,
-  getDisplayObjectRuntime,
-  setDisplayObjectColorAdjustments,
-} from '@flighthq/displayobject';
 import { createColorTransform } from '@flighthq/materials';
+import { createDisplayObject, getNode2DRuntime, setNode2DColorAdjustments } from '@flighthq/scene2d';
 import type { Renderable } from '@flighthq/types';
 
 import { updateRenderProxyColorTransform } from './renderColorTransform';
@@ -15,7 +11,7 @@ describe('updateRenderProxyColorTransform', () => {
   it('resolves a node color-adjustment stack onto the render node as an affine ColorTransform', () => {
     const state = createRenderState();
     const node = createDisplayObject();
-    setDisplayObjectColorAdjustments(node, [
+    setNode2DColorAdjustments(node, [
       createColorTransformAdjustment(createColorTransform({ redMultiplier: 0.5, greenMultiplier: 0 })),
     ]);
     const data = createRenderProxy(state, node as unknown as Renderable);
@@ -36,11 +32,9 @@ describe('updateRenderProxyColorTransform', () => {
   it('reads the cache the accessor fused once (the walk never re-fuses)', () => {
     const state = createRenderState();
     const node = createDisplayObject();
-    setDisplayObjectColorAdjustments(node, [
-      createColorTransformAdjustment(createColorTransform({ redMultiplier: 0.25 })),
-    ]);
+    setNode2DColorAdjustments(node, [createColorTransformAdjustment(createColorTransform({ redMultiplier: 0.25 }))]);
     // The set-accessor fused the stack once; the runtime already holds the cached resolved value.
-    const cached = getDisplayObjectRuntime(node).resolvedColorTransform;
+    const cached = getNode2DRuntime(node).resolvedColorTransform;
     expect(cached).not.toBeNull();
     const data = createRenderProxy(state, node as unknown as Renderable);
     updateRenderProxyColorTransform(state, data);

package/src/renderProxy.test.ts

@@ -1,4 +1,3 @@
-import { createDisplayObject, setDisplayObjectClip } from '@flighthq/displayobject';
 import { createMatrix, createRectangle } from '@flighthq/geometry';
 import {
   addNodeChild,
@@ -8,6 +7,7 @@ import {
   invalidateNodeAppearance,
   invalidateNodeLocalTransform,
 } from '@flighthq/node';
+import { createDisplayObject, setNode2DClip } from '@flighthq/scene2d';
 import { createSprite } from '@flighthq/sprite';
 import type { ClipRegion } from '@flighthq/types';
 
@@ -15,14 +15,14 @@ import { registerRenderer } from './renderer';
 import {
   createRenderProxy,
   createRenderProxy2D,
-  disposeDisplayObjectRender,
+  disposeScene2DRender,
   disposeRenderProxy,
   getOrCreateRenderProxy2D,
   getRenderProxy2D,
   installRenderAdaptHook,
   isRenderProxyDirty,
   isRenderProxyVisible,
-  prepareDisplayObjectRender,
+  prepareScene2DRender,
   updateNodeClip,
   updateRenderProxy2D,
   updateRenderProxyRenderer,
@@ -108,7 +108,28 @@ describe('createRenderProxy2D', () => {
   });
 });
 
-describe('disposeDisplayObjectRender', () => {
+describe('disposeRenderProxy', () => {
+  it('cascades to the renderer destroyData and removes the proxy', () => {
+    const state = createRenderState();
+    const source = createSprite();
+    const destroyData = vi.fn();
+    registerRenderer(state, source.kind, { createData: () => ({ tag: 'data' }), destroyData, submit: vi.fn() } as any);
+    const node = getOrCreateRenderProxy2D(state, source);
+    const data = node.rendererData;
+
+    disposeRenderProxy(state, source);
+
+    expect(destroyData).toHaveBeenCalledWith(state, data);
+    expect(getRenderProxy2D(state, source)).toBeUndefined();
+  });
+
+  it('is a no-op when no proxy exists', () => {
+    const state = createRenderState();
+    expect(() => disposeRenderProxy(state, createSprite())).not.toThrow();
+  });
+});
+
+describe('disposeScene2DRender', () => {
   it('disposes the root and all descendants', () => {
     const state = createRenderState();
     const root = createDisplayObject();
@@ -116,9 +137,9 @@ describe('disposeDisplayObjectRender', () => {
     const grandchild = createDisplayObject();
     addNodeChild(root, child);
     addNodeChild(child, grandchild);
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
 
-    disposeDisplayObjectRender(state, root);
+    disposeScene2DRender(state, root);
 
     expect(getRenderProxy2D(state, root)).toBeUndefined();
     expect(getRenderProxy2D(state, child)).toBeUndefined();
@@ -132,9 +153,9 @@ describe('disposeDisplayObjectRender', () => {
     const grandchild = createSprite();
     addNodeChild(root, child);
     addNodeChild(child, grandchild);
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
 
-    disposeDisplayObjectRender(state, root);
+    disposeScene2DRender(state, root);
 
     expect(getRenderProxy2D(state, root)).toBeUndefined();
     expect(getRenderProxy2D(state, child)).toBeUndefined();
@@ -151,7 +172,7 @@ describe('disposeDisplayObjectRender', () => {
     getOrCreateRenderProxy2D(state, root);
     getOrCreateRenderProxy2D(state, child);
 
-    disposeDisplayObjectRender(state, root);
+    disposeScene2DRender(state, root);
 
     expect(destroyData).toHaveBeenCalledTimes(2);
   });
@@ -162,37 +183,16 @@ describe('disposeDisplayObjectRender', () => {
     const child = createDisplayObject();
     addNodeChild(root, child);
     child.enabled = false;
-    prepareDisplayObjectRender(state, root);
-    // prepareDisplayObjectRender skips disabled nodes, but disposeDisplayObjectRender should not
+    prepareScene2DRender(state, root);
+    // prepareScene2DRender skips disabled nodes, but disposeScene2DRender should not
     getOrCreateRenderProxy2D(state, child);
 
-    disposeDisplayObjectRender(state, root);
+    disposeScene2DRender(state, root);
 
     expect(getRenderProxy2D(state, child)).toBeUndefined();
   });
 });
 
-describe('disposeRenderProxy', () => {
-  it('cascades to the renderer destroyData and removes the proxy', () => {
-    const state = createRenderState();
-    const source = createSprite();
-    const destroyData = vi.fn();
-    registerRenderer(state, source.kind, { createData: () => ({ tag: 'data' }), destroyData, submit: vi.fn() } as any);
-    const node = getOrCreateRenderProxy2D(state, source);
-    const data = node.rendererData;
-
-    disposeRenderProxy(state, source);
-
-    expect(destroyData).toHaveBeenCalledWith(state, data);
-    expect(getRenderProxy2D(state, source)).toBeUndefined();
-  });
-
-  it('is a no-op when no proxy exists', () => {
-    const state = createRenderState();
-    expect(() => disposeRenderProxy(state, createSprite())).not.toThrow();
-  });
-});
-
 describe('getOrCreateRenderProxy2D', () => {
   it('creates a node on first call', () => {
     const state = createRenderState();
@@ -336,14 +336,14 @@ describe('isRenderProxyVisible', () => {
   });
 });
 
-describe('prepareDisplayObjectRender', () => {
+describe('prepareScene2DRender', () => {
   it('creates render nodes for all enabled nodes in the tree', () => {
     const state = createRenderState();
     const root = createDisplayObject();
     const child = createDisplayObject();
     addNodeChild(root, child);
 
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
 
     expect(getRenderStateRuntime(state).renderProxyMap.get(root)).toBeDefined();
     expect(getRenderStateRuntime(state).renderProxyMap.get(child)).toBeDefined();
@@ -355,7 +355,7 @@ describe('prepareDisplayObjectRender', () => {
     const child = createSprite();
     addNodeChild(root, child);
 
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
 
     expect(getRenderStateRuntime(state).renderProxyMap.get(root)).toBeDefined();
     expect(getRenderStateRuntime(state).renderProxyMap.get(child)).toBeDefined();
@@ -368,7 +368,7 @@ describe('prepareDisplayObjectRender', () => {
     addNodeChild(root, child);
     child.enabled = false;
 
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
 
     expect(getRenderStateRuntime(state).renderProxyMap.get(root)).toBeDefined();
     expect(getRenderStateRuntime(state).renderProxyMap.get(child)).toBeUndefined();
@@ -378,15 +378,15 @@ describe('prepareDisplayObjectRender', () => {
     const state = createRenderState();
     const root = createDisplayObject();
 
-    expect(prepareDisplayObjectRender(state, root)).toBe(true);
+    expect(prepareScene2DRender(state, root)).toBe(true);
   });
 
   it('returns false when tree is clean', () => {
     const state = createRenderState({ sceneGraphSyncPolicy: 'requiresInvalidation' });
     const root = createDisplayObject();
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
 
-    expect(prepareDisplayObjectRender(state, root)).toBe(false);
+    expect(prepareScene2DRender(state, root)).toBe(false);
   });
 
   it('accumulates clip depth down a clipped subtree', () => {
@@ -396,10 +396,10 @@ describe('prepareDisplayObjectRender', () => {
     const grandchild = createDisplayObject();
     addNodeChild(root, child);
     addNodeChild(child, grandchild);
-    setDisplayObjectClip(root, makeClipRegion());
-    setDisplayObjectClip(child, makeClipRegion());
+    setNode2DClip(root, makeClipRegion());
+    setNode2DClip(child, makeClipRegion());
 
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
 
     expect(getOrCreateRenderProxy2D(state, root).clipDepth).toBe(1);
     expect(getOrCreateRenderProxy2D(state, child).clipDepth).toBe(2);
@@ -411,7 +411,7 @@ describe('updateNodeClip', () => {
   it('adds one to the parent depth when the node has a clip', () => {
     const state = createRenderState();
     const node = createDisplayObject();
-    setDisplayObjectClip(node, makeClipRegion());
+    setNode2DClip(node, makeClipRegion());
     const data = getOrCreateRenderProxy2D(state, node);
     updateNodeClip(state, node, data, undefined);
     expect(data.clipDepth).toBe(1);
@@ -456,7 +456,7 @@ describe('updateRenderProxy2D', () => {
   it('sets clip depth from the parent through the same visitor', () => {
     const state = createRenderState();
     const root = createDisplayObject();
-    setDisplayObjectClip(root, makeClipRegion());
+    setNode2DClip(root, makeClipRegion());
     const data = getOrCreateRenderProxy2D(state, root);
     updateRenderProxy2D(state, root, data, undefined);
     expect(data.clipDepth).toBe(1);

package/src/renderProxyAdapter.test.ts

@@ -1,4 +1,4 @@
-import { createDisplayObject } from '@flighthq/displayobject';
+import { createDisplayObject } from '@flighthq/scene2d';
 import type { RenderProxyAdapter } from '@flighthq/types';
 
 import { registerRenderer } from './renderer';

package/src/renderQueue.test.ts

@@ -1,10 +1,10 @@
-import { createDisplayObject } from '@flighthq/displayobject';
 import { addNodeChild } from '@flighthq/node';
+import { createDisplayObject } from '@flighthq/scene2d';
 import { createSprite } from '@flighthq/sprite';
 import type { Renderer, RenderProxy, RenderQueueEntry } from '@flighthq/types';
 
 import { registerRenderer } from './renderer';
-import { prepareDisplayObjectRender } from './renderProxy';
+import { prepareScene2DRender } from './renderProxy';
 import {
   buildRenderQueue,
   clearRenderQueue,
@@ -24,7 +24,7 @@ describe('buildRenderQueue', () => {
   it('produces zero entries for a scene with no renderers', () => {
     const state = createRenderState();
     const root = createDisplayObject();
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
     const queue = createRenderQueue();
     buildRenderQueue(state, root, queue);
     expect(queue.entryCount).toBe(0);
@@ -35,7 +35,7 @@ describe('buildRenderQueue', () => {
     const child = createDisplayObject();
     addNodeChild(root, child);
     registerRenderer(state, root.kind, makeRenderer());
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
     const queue = createRenderQueue();
     buildRenderQueue(state, root, queue);
     expect(queue.entryCount).toBe(2);
@@ -45,7 +45,7 @@ describe('buildRenderQueue', () => {
     const root = createDisplayObject();
     root.visible = false;
     registerRenderer(state, root.kind, makeRenderer());
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
     const queue = createRenderQueue();
     buildRenderQueue(state, root, queue);
     expect(queue.entryCount).toBe(0);
@@ -54,7 +54,7 @@ describe('buildRenderQueue', () => {
     const state = createRenderState();
     const root = createDisplayObject();
     registerRenderer(state, root.kind, makeRenderer());
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
     const queue = createRenderQueue();
     buildRenderQueue(state, root, queue);
     const firstCount = queue.entryCount;
@@ -71,7 +71,7 @@ describe('buildRenderQueue', () => {
     registerRenderer(state, root.kind, makeRenderer());
     registerRenderer(state, child1.kind, makeRenderer());
     registerRenderer(state, child2.kind, makeRenderer());
-    prepareDisplayObjectRender(state, root);
+    prepareScene2DRender(state, root);
     const queue = createRenderQueue();
     buildRenderQueue(state, root, queue);
     expect(queue.entries[0].sortKey).toBeLessThan(queue.entries[1].sortKey);

package/src/renderTarget.test.ts

@@ -1,42 +1,12 @@
-import { createDisplayObject } from '@flighthq/displayobject';
 import { createMatrix, createRectangle } from '@flighthq/geometry';
+import { createDisplayObject } from '@flighthq/scene2d';
 
 import {
-  computeDisplayObjectRenderTargetTransform,
+  computeScene2DRenderTargetTransform,
   computeRenderCacheTransform,
   computeRenderTargetSize,
 } from './renderTarget';
 
-describe('computeDisplayObjectRenderTargetTransform', () => {
-  it('writes an identity-based transform for an unrotated object at origin', () => {
-    const obj = createDisplayObject();
-    const bounds = createRectangle(0, 0, 100, 80);
-    const out = createMatrix();
-    computeDisplayObjectRenderTargetTransform(out, obj, bounds);
-    expect(typeof out.a).toBe('number');
-    expect(typeof out.tx).toBe('number');
-  });
-
-  it('offsets by contentX and contentY', () => {
-    const obj = createDisplayObject();
-    const bounds = createRectangle(10, 20, 100, 80);
-    const out1 = createMatrix();
-    const out2 = createMatrix();
-    computeDisplayObjectRenderTargetTransform(out1, obj, bounds, 0, 0);
-    computeDisplayObjectRenderTargetTransform(out2, obj, bounds, 5, 10);
-    expect(out2.tx).not.toBe(out1.tx);
-  });
-
-  it('does not throw for a non-identity local transform', () => {
-    const obj = createDisplayObject();
-    obj.x = 50;
-    obj.y = 30;
-    const bounds = createRectangle(50, 30, 100, 80);
-    const out = createMatrix();
-    expect(() => computeDisplayObjectRenderTargetTransform(out, obj, bounds)).not.toThrow();
-  });
-});
-
 describe('computeRenderCacheTransform', () => {
   it('produces a pure translation from bounds origin', () => {
     const out = createMatrix();
@@ -82,3 +52,33 @@ describe('computeRenderTargetSize', () => {
     expect(result.height).toBe(1);
   });
 });
+
+describe('computeScene2DRenderTargetTransform', () => {
+  it('writes an identity-based transform for an unrotated object at origin', () => {
+    const obj = createDisplayObject();
+    const bounds = createRectangle(0, 0, 100, 80);
+    const out = createMatrix();
+    computeScene2DRenderTargetTransform(out, obj, bounds);
+    expect(typeof out.a).toBe('number');
+    expect(typeof out.tx).toBe('number');
+  });
+
+  it('offsets by contentX and contentY', () => {
+    const obj = createDisplayObject();
+    const bounds = createRectangle(10, 20, 100, 80);
+    const out1 = createMatrix();
+    const out2 = createMatrix();
+    computeScene2DRenderTargetTransform(out1, obj, bounds, 0, 0);
+    computeScene2DRenderTargetTransform(out2, obj, bounds, 5, 10);
+    expect(out2.tx).not.toBe(out1.tx);
+  });
+
+  it('does not throw for a non-identity local transform', () => {
+    const obj = createDisplayObject();
+    obj.x = 50;
+    obj.y = 30;
+    const bounds = createRectangle(50, 30, 100, 80);
+    const out = createMatrix();
+    expect(() => computeScene2DRenderTargetTransform(out, obj, bounds)).not.toThrow();
+  });
+});

package/src/renderTransform2d.test.ts

@@ -1,4 +1,4 @@
-import { createDisplayObject } from '@flighthq/displayobject';
+import { createDisplayObject } from '@flighthq/scene2d';
 
 import { createRenderProxy2D } from './renderProxy';
 import { createRenderState, getRenderStateRuntime } from './renderState';

package/src/renderViewport.test.ts

@@ -1,9 +1,9 @@
-import { createBitmap, createDisplayObject } from '@flighthq/displayobject';
 import { createMatrix, createRectangle } from '@flighthq/geometry';
 import { addNodeChild, getNodeRuntime, invalidateNodeLocalBounds, invalidateNodeLocalTransform } from '@flighthq/node';
+import { createBitmap, createDisplayObject } from '@flighthq/scene2d';
 import type { HasBoundsRectangleRuntime, RenderProxy2D, RenderViewport2D } from '@flighthq/types';
 
-import { createRenderProxy2D, prepareDisplayObjectRender } from './renderProxy';
+import { createRenderProxy2D, prepareScene2DRender } from './renderProxy';
 import { createRenderState } from './renderState';
 import {
   computeRenderProxyWorldBounds,
@@ -44,7 +44,7 @@ describe('computeRenderProxyWorldBounds', () => {
     expect(result).toBe(false);
   });
 
-  it('returns true and writes world bounds for a DisplayObject', () => {
+  it('returns true and writes world bounds for a Node2D', () => {
     const obj = makeObjectWithBounds(10, 20, 50, 30);
     const out = createRectangle();
     const result = computeRenderProxyWorldBounds(out, obj);
@@ -176,10 +176,10 @@ describe('isRenderProxyInViewport', () => {
     expect(isRenderProxyInViewport(proxy, vp)).toBe(true);
   });
 
-  it('returns true for a proxy backed by a DisplayObject within the viewport', () => {
+  it('returns true for a proxy backed by a Node2D within the viewport', () => {
     const state = createRenderState();
     const obj = makeObjectWithBounds(10, 10, 50, 50);
-    prepareDisplayObjectRender(state, obj);
+    prepareScene2DRender(state, obj);
     const proxy = createRenderProxy2D(state, obj);
     const vp: RenderViewport2D = { x: 0, y: 0, width: 800, height: 600 };
     expect(isRenderProxyInViewport(proxy, vp)).toBe(true);

package/src/renderer.test.ts

@@ -1,4 +1,4 @@
-import type { DisplayObjectClipHooks, Renderer, RenderState } from '@flighthq/types';
+import type { Scene2DClipHooks, Renderer, RenderState } from '@flighthq/types';
 
 import {
   copyAllRenderersFromRenderState,
@@ -18,7 +18,7 @@ describe('copyAllRenderersFromRenderState', () => {
       finalize: vi.fn(),
       popClip: vi.fn(),
       pushClip: vi.fn(),
-    } as unknown as DisplayObjectClipHooks;
+    } as unknown as Scene2DClipHooks;
     registerRenderer(source, kind, renderer);
     source.displayObjectClipHooks = hooks;