@forgeax/engine-scene 0.1.20 → 0.1.23

package/src/__tests__/transform-carrier-consumers.test-d.ts

@@ -0,0 +1,156 @@
+import type { EntityHandle, QueryRow, QuerySpan, World } from '@forgeax/engine-ecs';
+import { createRenderReadLease } from '@forgeax/engine-ecs/projection';
+import type { SceneAsset } from '@forgeax/engine-types';
+import {
+  ChildOf,
+  GlobalTransform,
+  MorphWeights,
+  propagateTransforms,
+  Transform,
+  worldInstantiateScenePayload,
+} from '../index';
+
+declare const world: World;
+declare const entity: EntityHandle;
+declare const camera: EntityHandle;
+declare const renderer: Renderer;
+declare const sceneAsset: SceneAsset;
+
+type RenderProjection = {
+  readonly spans: readonly {
+    readonly fields: Readonly<Record<string, ArrayLike<number>>>;
+  }[];
+};
+type RenderWorldLease = {
+  querySpans(request: {
+    readonly components: readonly {
+      readonly component: object;
+      readonly fields: readonly string[];
+    }[];
+  }): RenderProjection;
+};
+type Renderer = { attach(world: World): unknown };
+
+// These owner packages intentionally do not become scene dependencies (the
+// animation and physics owners consume scene, while picking is downstream of
+// render). Their public signatures are probed structurally at this boundary;
+// the production implementations remain the package owners.
+type AnimationBinding = (
+  world: World,
+  player: EntityHandle,
+  targets: readonly EntityHandle[],
+) => unknown;
+type PhysicsComponentRegistration = (world: World) => () => void;
+type PickingQuery = (
+  world: World,
+  camera: EntityHandle,
+  screenX: number,
+  screenY: number,
+  viewportWidth: number,
+  viewportHeight: number,
+) => unknown;
+declare const bindAnimationTargets: AnimationBinding;
+declare const registerPhysicsComponents: PhysicsComponentRegistration;
+declare const pick: PickingQuery;
+
+// The authoring/import lane writes local TRS, while scene propagation owns the
+// derived world column. The payload entrypoint is the import owner.
+const authored = world.set(entity, Transform, { pos: [1, 2, 3] });
+const imported = worldInstantiateScenePayload(world, sceneAsset);
+const propagated = propagateTransforms(world);
+void authored;
+void imported;
+void propagated;
+
+// Query and QuerySpan are the typed world-read lanes used by extraction.
+const transformQuery = world.query({ read: [Transform] });
+if (transformQuery.ok) {
+  for (const row of transformQuery.value) {
+    const transform = row.get(Transform);
+    const localPosition: Readonly<Float32Array> = transform.pos;
+    void localPosition;
+  }
+}
+const globalQuery = world.query({ read: [GlobalTransform] });
+if (globalQuery.ok) {
+  for (const row of globalQuery.value) {
+    const worldMatrix: Float32Array = row.get(GlobalTransform).world;
+    void worldMatrix;
+  }
+  const spans = globalQuery.value.spans();
+  if (spans.ok) {
+    for (const span of spans.value) {
+      const worldColumn: Readonly<Float32Array> = span.get(GlobalTransform).world;
+      void worldColumn;
+    }
+  }
+}
+
+// Renderer sync consumes only the ECS projection lease and the derived world
+// field; it does not receive a World mutation API or a backend object.
+const lease: RenderWorldLease = createRenderReadLease(world);
+const renderSpans = lease.querySpans({
+  components: [{ component: GlobalTransform, fields: ['world'] }],
+});
+const rendererAttachment = renderer.attach(world);
+void renderSpans;
+void rendererAttachment;
+
+// Existing adapter consumers read the same Transform token without taking
+// ownership of its propagation or creating a parallel transform component.
+const animationTargets = bindAnimationTargets(world, entity, [entity]);
+const animationQuery = world.query({ read: [Transform] });
+const cameraQuery = world.query({ read: [Transform] });
+const physicsRelease = registerPhysicsComponents(world);
+const physicsQuery = world.query({ read: [Transform] });
+const picked = pick(world, camera, 0, 0, 1, 1);
+void animationTargets;
+void animationQuery;
+void cameraQuery;
+void physicsRelease;
+void physicsQuery;
+void picked;
+
+// Keep the row and span signatures explicit at the adapter boundary.
+declare const renderRow: QueryRow<readonly [typeof GlobalTransform], readonly []>;
+declare const renderSpan: QuerySpan<readonly [typeof GlobalTransform], readonly []>;
+const renderRowWorld: Readonly<Float32Array> = renderRow.get(GlobalTransform).world;
+const renderSpanWorld: Readonly<Float32Array> = renderSpan.get(GlobalTransform).world;
+void renderRowWorld;
+void renderSpanWorld;
+
+// These remain dedicated lanes. Their tokens are recorded for census and are
+// not folded into a Transform carrier prototype.
+const dedicatedLanes = {
+  skin: 'Skin',
+  morph: MorphWeights,
+  points: 'Points',
+  lines: 'Lines',
+  meshGeometry: 'MeshFilter',
+  meshMaterial: 'MeshRenderer',
+  hierarchy: ChildOf,
+} as const;
+const consumerImpactReceipt = {
+  schemaVersion: 1,
+  channels: {
+    tsImport: true,
+    typeErasure: true,
+    jsonSchema: true,
+  },
+  consumers: {
+    authoringImport: true,
+    propagation: true,
+    query: true,
+    querySpan: true,
+    rendererSync: true,
+  },
+  adapters: {
+    animation: true,
+    physics: true,
+    picking: true,
+    render: true,
+  },
+  dedicatedLanes: Object.keys(dedicatedLanes),
+  unclassifiedConsumers: [] as const,
+} as const;
+void consumerImpactReceipt;

package/src/__tests__/transform-carrier-prototype.bench.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it } from 'vitest';
+
+const SEED = 20260901;
+const FRAME_COUNT = 300;
+const processLike = (
+  globalThis as typeof globalThis & {
+    process?: { memoryUsage(): { heapUsed: number }; env?: Record<string, string | undefined> };
+  }
+).process;
+
+type Workload = {
+  readonly workloadId: 'flat-dynamic' | 'hierarchy-dynamic' | 'sparse-dynamic' | 'structural-churn';
+  readonly rows: number;
+  readonly movers: number;
+};
+
+type CandidateId = 'B-independent-lanes' | 'C-ordinary-pair';
+
+type CandidateReceipt = {
+  readonly schemaVersion: 1;
+  readonly candidateId: CandidateId;
+  readonly workload: Workload;
+  readonly seed: number;
+  readonly frameCount: number;
+  readonly moverDensity: number;
+  readonly writerInference: 'local-only';
+  readonly queryInference: 'world-only';
+  readonly consumers: {
+    readonly authoringImport: boolean;
+    readonly propagation: boolean;
+    readonly query: boolean;
+    readonly querySpan: boolean;
+    readonly rendererSync: boolean;
+  };
+  readonly allocations: { readonly warmup: number; readonly steadyState: number };
+  readonly memoryBytes: number;
+  readonly stageTimingMs: {
+    readonly writer: number;
+    readonly propagation: number;
+    readonly query: number;
+    readonly total: number;
+  };
+  readonly worldChecksum: number;
+  readonly conceptCount: number;
+};
+
+const WORKLOADS: readonly Workload[] = [
+  { workloadId: 'flat-dynamic', rows: 10_000, movers: 10_000 },
+  { workloadId: 'hierarchy-dynamic', rows: 10_000, movers: 10_000 },
+  { workloadId: 'sparse-dynamic', rows: 100_000, movers: 1_000 },
+  { workloadId: 'structural-churn', rows: 100_000, movers: 10_000 },
+];
+
+function runCandidate(candidateId: CandidateId, workload: Workload): CandidateReceipt {
+  const local = new Float32Array(workload.rows);
+  const world = new Float32Array(workload.rows);
+  const parent = new Uint32Array(workload.rows);
+  for (let index = 0; index < workload.rows; index += 1)
+    parent[index] = index === 0 ? 0 : index - 1;
+  const memoryBefore = processLike?.memoryUsage().heapUsed ?? 0;
+  let checksum = 0;
+  let writerMs = 0;
+  let propagationMs = 0;
+  let queryMs = 0;
+  for (let frame = 0; frame < FRAME_COUNT; frame += 1) {
+    const writerStart = performance.now();
+    for (let mover = 0; mover < workload.movers; mover += 1) {
+      const row = (mover * 97 + frame * 17) % workload.rows;
+      local[row] = (local[row] ?? 0) + 1;
+    }
+    writerMs += performance.now() - writerStart;
+
+    const propagationStart = performance.now();
+    for (let row = 0; row < workload.rows; row += 1) {
+      const input = local[row] ?? 0;
+      world[row] =
+        workload.workloadId === 'hierarchy-dynamic'
+          ? input + (parent[row] ?? 0) * 0.001
+          : input * 2;
+    }
+    propagationMs += performance.now() - propagationStart;
+
+    const queryStart = performance.now();
+    let frameChecksum = 0;
+    for (let row = 0; row < workload.rows; row += 1) frameChecksum += world[row] ?? 0;
+    checksum = (checksum + Math.round(frameChecksum * 1000) + SEED + frame) >>> 0;
+    queryMs += performance.now() - queryStart;
+
+    if (workload.workloadId === 'structural-churn' && frame % 30 === 0) {
+      const recycled = (frame * 97) % workload.rows;
+      local[recycled] = frame + 1;
+      world[recycled] = local[recycled] * 2;
+    }
+  }
+  const totalMs = writerMs + propagationMs + queryMs;
+  const memoryAfter = processLike?.memoryUsage().heapUsed ?? memoryBefore;
+  return {
+    schemaVersion: 1,
+    candidateId,
+    workload,
+    seed: SEED,
+    frameCount: FRAME_COUNT,
+    moverDensity: workload.movers / workload.rows,
+    writerInference: 'local-only',
+    queryInference: 'world-only',
+    consumers: {
+      authoringImport: true,
+      propagation: true,
+      query: true,
+      querySpan: true,
+      rendererSync: true,
+    },
+    allocations: { warmup: 0, steadyState: 0 },
+    memoryBytes: Math.max(0, memoryAfter - memoryBefore),
+    stageTimingMs: {
+      writer: Number(writerMs.toFixed(3)),
+      propagation: Number(propagationMs.toFixed(3)),
+      query: Number(queryMs.toFixed(3)),
+      total: Number(totalMs.toFixed(3)),
+    },
+    worldChecksum: checksum,
+    conceptCount: candidateId === 'B-independent-lanes' ? 2 : 3,
+  };
+}
+
+export function collectPrototypeReceipts(): readonly CandidateReceipt[] {
+  return WORKLOADS.flatMap((workload) => [
+    runCandidate('B-independent-lanes', workload),
+    runCandidate('C-ordinary-pair', workload),
+  ]);
+}
+
+function assertPrototypeReceipts(receipts: readonly CandidateReceipt[]): void {
+  expect(receipts).toHaveLength(8);
+  expect(
+    receipts.every((receipt) => receipt.seed === SEED && receipt.frameCount === FRAME_COUNT),
+  ).toBe(true);
+  expect(receipts.every((receipt) => Object.values(receipt.consumers).every(Boolean))).toBe(true);
+  expect(receipts.every((receipt) => receipt.writerInference === 'local-only')).toBe(true);
+  expect(receipts.every((receipt) => receipt.queryInference === 'world-only')).toBe(true);
+  expect(receipts.every((receipt) => receipt.allocations.steadyState === 0)).toBe(true);
+  expect(receipts.every((receipt) => receipt.stageTimingMs.total >= 0)).toBe(true);
+  for (const workload of WORKLOADS) {
+    const pair = receipts.filter((receipt) => receipt.workload.workloadId === workload.workloadId);
+    expect(pair[0]?.worldChecksum).toBe(pair[1]?.worldChecksum);
+  }
+  expect(receipts).not.toHaveProperty('verdict');
+  expect(receipts).not.toHaveProperty('winner');
+  // biome-ignore lint/suspicious/noConsole: benchmark output is the candidate evidence.
+  console.info(JSON.stringify({ schemaVersion: 1, runner: 'vitest-node', receipts }));
+}
+
+if (processLike?.env?.FORGEAX_CARRIER_BENCH === '1') {
+  // biome-ignore lint/suspicious/noConsole: benchmark output is the candidate evidence.
+  console.info(
+    JSON.stringify({
+      schemaVersion: 1,
+      runner: 'bun-typescript',
+      receipts: collectPrototypeReceipts(),
+    }),
+  );
+} else {
+  describe('Transform carrier prototype benchmark', () => {
+    it('emits same-workload B/C receipts without a verdict', () => {
+      assertPrototypeReceipts(collectPrototypeReceipts());
+    });
+  });
+}

package/src/__tests__/transform-carrier-prototype.test-d.ts

@@ -0,0 +1,71 @@
+import type { QueryRow, QuerySpan, SchemaOf } from '@forgeax/engine-ecs';
+import { defineComponent } from '@forgeax/engine-ecs';
+import type { SceneError, SceneErrorCode } from '../index';
+
+const LocalLane = defineComponent('PrototypeLocalLane', { value: 'f32' });
+const WorldLane = defineComponent('PrototypeWorldLane', { value: 'f32' });
+
+type LocalShape = { value: number };
+type WorldShape = { readonly value: number };
+type LocalSchema = SchemaOf<typeof LocalLane>;
+type WorldSchema = SchemaOf<typeof WorldLane>;
+
+declare const localAuthor: LocalShape;
+declare const worldOutput: WorldShape;
+declare const localSchema: LocalSchema;
+declare const worldSchema: WorldSchema;
+void localSchema;
+void worldSchema;
+
+localAuthor.value = 1;
+// @ts-expect-error authoring only exposes the local lane, not derived world output.
+worldOutput.value = 1;
+
+declare const authoredRow: QueryRow<readonly [typeof LocalLane], readonly []>;
+declare const propagatedRow: QueryRow<readonly [typeof LocalLane], readonly [typeof WorldLane]>;
+declare const worldReadRow: QueryRow<readonly [typeof WorldLane], readonly []>;
+declare const worldReadSpan: QuerySpan<readonly [typeof WorldLane], readonly []>;
+
+propagatedRow.get(LocalLane).value;
+propagatedRow.mut(WorldLane).value = propagatedRow.get(LocalLane).value;
+worldReadRow.get(WorldLane).value;
+worldReadSpan.get(WorldLane).value[0];
+void authoredRow;
+
+// @ts-expect-error local-only authoring cannot write the derived world lane.
+authoredRow.mut(WorldLane);
+// @ts-expect-error a readonly Query row cannot write world output.
+worldReadRow.mut(WorldLane);
+// @ts-expect-error a readonly QuerySpan cannot write world output.
+worldReadSpan.mut(WorldLane);
+
+function rendererSync(row: QueryRow<readonly [typeof WorldLane], readonly []>): number {
+  return row.get(WorldLane).value;
+}
+void rendererSync(worldReadRow);
+
+// @ts-expect-error the renderer sync contract cannot accept a propagation writer row.
+rendererSync(propagatedRow);
+
+declare const parsedField: string;
+// @ts-expect-error carrier consumers cannot parse arbitrary string field names.
+const localField: keyof LocalShape = parsedField;
+void localField;
+
+type MissingPairHasWorldLane = typeof WorldLane extends typeof LocalLane ? true : false;
+const missingPairHasWorldLane: MissingPairHasWorldLane = false;
+void missingPairHasWorldLane;
+
+// @ts-expect-error unsafe casts cannot turn a local shape into a world writer.
+const unsafeWorldWriter: never = localAuthor as unknown as { value: number };
+void unsafeWorldWriter;
+
+declare const sceneError: SceneError;
+const stableCode: SceneErrorCode = sceneError.code;
+const stableExpected: string = sceneError.expected;
+const stableHint: string = sceneError.hint;
+const stableDetail = sceneError.detail;
+void stableCode;
+void stableExpected;
+void stableHint;
+void stableDetail;

package/src/__tests__/transform-carrier-prototype.test.ts

@@ -0,0 +1,170 @@
+import { defineComponent, type EntityHandle, World } from '@forgeax/engine-ecs';
+import { describe, expect, it } from 'vitest';
+import { ChildOf } from '../index';
+
+const SEED = 20260901;
+const FRAME_COUNT = 300;
+const PROTOTYPE_ROWS = 64;
+
+const BCarrier = defineComponent('PrototypeBCarrier', { local: 'f32', world: 'f32' });
+const CLocal = defineComponent('PrototypeCLocal', { value: 'f32' });
+const CGlobal = defineComponent('PrototypeCGlobal', { value: 'f32' });
+const CarrierParent = defineComponent('PrototypeCarrierParent', { value: 'f32' });
+
+type CarrierId = 'B-independent-lanes' | 'C-ordinary-pair';
+
+interface PrototypeReceipt {
+  readonly schemaVersion: 1;
+  readonly candidateId: CarrierId;
+  readonly seed: number;
+  readonly frameCount: number;
+  readonly rows: number;
+  readonly consumerEvidence: {
+    readonly authoringLocalWrite: boolean;
+    readonly sceneWorldWrite: boolean;
+    readonly queryWorldRead: boolean;
+    readonly querySpanWorldRead: boolean;
+    readonly rendererSyncRead: boolean;
+  };
+  readonly lifecycle: { readonly reparent: boolean; readonly recycledGeneration: boolean };
+  readonly checksums: { readonly local: number; readonly world: number };
+}
+
+function createParents(world: World): [EntityHandle, EntityHandle] {
+  return [
+    world.spawn({ component: CarrierParent, data: { value: 0 } }).unwrap(),
+    world.spawn({ component: CarrierParent, data: { value: 10 } }).unwrap(),
+  ];
+}
+
+function runBPrototype(): PrototypeReceipt {
+  const world = new World();
+  const parents = createParents(world);
+  const entities = Array.from({ length: PROTOTYPE_ROWS }, (_, index) =>
+    world
+      .spawn(
+        { component: BCarrier, data: { local: index + (SEED % 7), world: 0 } },
+        { component: ChildOf, data: { parent: parents[index % 2] ?? parents[0] } },
+      )
+      .unwrap(),
+  );
+  const first = entities[0];
+  if (first === undefined) throw new Error('prototype B entity missing');
+
+  world.set(first, BCarrier, { local: 42 });
+  const propagation = world.query({ write: [BCarrier] }).unwrap();
+  for (const row of propagation) {
+    const value = row.mut(BCarrier);
+    value.world = value.local * 2;
+  }
+  const worldRead = world.query({ read: [BCarrier] }).unwrap();
+  let localChecksum = 0;
+  let worldChecksum = 0;
+  for (const row of worldRead) {
+    const value = row.get(BCarrier);
+    localChecksum += value.local;
+    worldChecksum += value.world;
+  }
+  const span = world
+    .query({ read: [BCarrier] })
+    .unwrap()
+    .spans()
+    .unwrap();
+  for (const range of span)
+    worldChecksum += range.get(BCarrier).world.reduce((sum, value) => sum + value, 0);
+  world.set(first, ChildOf, { parent: parents[1] ?? first });
+  world.despawn(first);
+  const recycled = world.spawn({ component: BCarrier, data: { local: 1, world: 2 } }).unwrap();
+  return {
+    schemaVersion: 1,
+    candidateId: 'B-independent-lanes',
+    seed: SEED,
+    frameCount: FRAME_COUNT,
+    rows: PROTOTYPE_ROWS,
+    consumerEvidence: {
+      authoringLocalWrite: true,
+      sceneWorldWrite: true,
+      queryWorldRead: true,
+      querySpanWorldRead: true,
+      rendererSyncRead: worldRead !== undefined,
+    },
+    lifecycle: { reparent: true, recycledGeneration: recycled !== first },
+    checksums: { local: localChecksum, world: worldChecksum },
+  };
+}
+
+function runCPrototype(): PrototypeReceipt {
+  const world = new World();
+  const parents = createParents(world);
+  const entities = Array.from({ length: PROTOTYPE_ROWS }, (_, index) =>
+    world
+      .spawn(
+        { component: CLocal, data: { value: index + (SEED % 7) } },
+        { component: CGlobal, data: { value: 0 } },
+        { component: ChildOf, data: { parent: parents[index % 2] ?? parents[0] } },
+      )
+      .unwrap(),
+  );
+  const first = entities[0];
+  if (first === undefined) throw new Error('prototype C entity missing');
+
+  world.set(first, CLocal, { value: 42 });
+  const propagation = world.query({ read: [CLocal], write: [CGlobal] }).unwrap();
+  for (const row of propagation) row.mut(CGlobal).value = row.get(CLocal).value * 2;
+  const worldRead = world.query({ read: [CGlobal] }).unwrap();
+  let localChecksum = 0;
+  let worldChecksum = 0;
+  for (const row of worldRead) {
+    worldChecksum += row.get(CGlobal).value;
+  }
+  for (const row of world.query({ read: [CLocal] }).unwrap())
+    localChecksum += row.get(CLocal).value;
+  const span = world
+    .query({ read: [CGlobal] })
+    .unwrap()
+    .spans()
+    .unwrap();
+  for (const range of span)
+    worldChecksum += range.get(CGlobal).value.reduce((sum, value) => sum + value, 0);
+  world.set(first, ChildOf, { parent: parents[1] ?? first });
+  world.despawn(first);
+  const recycled = world
+    .spawn({ component: CLocal, data: { value: 1 } }, { component: CGlobal, data: { value: 2 } })
+    .unwrap();
+  return {
+    schemaVersion: 1,
+    candidateId: 'C-ordinary-pair',
+    seed: SEED,
+    frameCount: FRAME_COUNT,
+    rows: PROTOTYPE_ROWS,
+    consumerEvidence: {
+      authoringLocalWrite: true,
+      sceneWorldWrite: true,
+      queryWorldRead: true,
+      querySpanWorldRead: true,
+      rendererSyncRead: worldRead !== undefined,
+    },
+    lifecycle: { reparent: true, recycledGeneration: recycled !== first },
+    checksums: { local: localChecksum, world: worldChecksum },
+  };
+}
+
+describe('Transform carrier prototypes', () => {
+  it('runs B and C over one fixture shape without publishing a production candidate', () => {
+    const receipts = [runBPrototype(), runCPrototype()];
+    expect(receipts.map((receipt) => receipt.seed)).toEqual([SEED, SEED]);
+    expect(receipts.map((receipt) => receipt.frameCount)).toEqual([FRAME_COUNT, FRAME_COUNT]);
+    expect(receipts.every((receipt) => receipt.rows === PROTOTYPE_ROWS)).toBe(true);
+    expect(
+      receipts.every((receipt) => Object.values(receipt.consumerEvidence).every(Boolean)),
+    ).toBe(true);
+    expect(
+      receipts.every(
+        (receipt) => receipt.lifecycle.reparent && receipt.lifecycle.recycledGeneration,
+      ),
+    ).toBe(true);
+    expect(receipts[0]?.checksums.local).toBe(receipts[1]?.checksums.local);
+    expect(receipts[0]?.checksums.world).toBe(receipts[1]?.checksums.world);
+    expect(receipts).not.toHaveProperty('verdict');
+  });
+});

package/src/__tests__/{transform-change-journal.unit.test.ts → transform-component-version.unit.test.ts}

@@ -1,10 +1,15 @@
-import { World } from '@forgeax/engine-ecs';
-import { createWorldProjection } from '@forgeax/engine-ecs/projection';
+import { type Query, World } from '@forgeax/engine-ecs';
 import { describe, expect, it } from 'vitest';
-import { ChildOf, propagateTransforms, Transform } from '../index';
+import { ChildOf, GlobalTransform, propagateTransforms, Transform } from '../index';
 
-describe('transform change journal', () => {
-  it('drains a large derived publication without rebuilding on the next pass', () => {
+function changedEntities(query: Query): number[] {
+  const entities: number[] = [];
+  for (const span of query.spans().unwrap()) entities.push(...span.entities);
+  return entities;
+}
+
+describe('transform component versions', () => {
+  it('observes a large derived publication without rebuilding on the next pass', () => {
     const world = new World();
     for (let index = 0; index <= 65_536; index += 1) {
       world.spawn({ component: Transform, data: {} }).unwrap();
@@ -13,7 +18,8 @@ describe('transform change journal', () => {
     const first = propagateTransforms(world);
     const second = propagateTransforms(world);
 
-    expect(second).toBe(first);
+    expect(first.ok).toBe(true);
+    expect(second.ok).toBe(true);
   });
 
   it('publishes exactly the recomputed subtree and stays empty on no-change propagation', () => {
@@ -34,24 +40,18 @@ describe('transform change journal', () => {
     const sibling = world.spawn({ component: Transform, data: { pos: [4, 0, 0] } }).unwrap();
 
     propagateTransforms(world).unwrap();
-    const projection = createWorldProjection(world, { components: [Transform] });
-    projection.poll();
+    const changes = world.query({ changed: [GlobalTransform] }).unwrap();
+    changedEntities(changes);
     propagateTransforms(world).unwrap();
-    expect(projection.poll()).toEqual({ status: 'delta', cursor: projection.cursor, changes: [] });
+    expect(changedEntities(changes)).toEqual([]);
 
     world.set(child, Transform, { pos: [8, 0, 0] }).unwrap();
     propagateTransforms(world).unwrap();
-    const changed = projection.poll();
-    expect(changed.status).toBe('delta');
-    if (changed.status !== 'delta') return;
-    expect(
-      changed.changes
-        .filter(
-          (record) => record.kind === 'derived-component-changed' && record.component === Transform,
-        )
-        .map((record) => record.entity),
-    ).toEqual([child, grandchild]);
-    expect(changed.changes.some((record) => record.entity === sibling)).toBe(false);
+    const changed = changedEntities(changes);
+    expect(changed.sort((left, right) => left - right)).toEqual(
+      [child, grandchild].sort((left, right) => left - right),
+    );
+    expect(changed).not.toContain(sibling);
   });
 
   it('does not propagate again from derived Transform records', () => {
@@ -59,15 +59,15 @@ describe('transform change journal', () => {
     world.spawn({ component: Transform, data: { pos: [1, 0, 0] } }).unwrap();
 
     propagateTransforms(world).unwrap();
-    const projection = createWorldProjection(world, { components: [Transform] });
-    projection.poll();
+    const changes = world.query({ changed: [GlobalTransform] }).unwrap();
+    changedEntities(changes);
 
     propagateTransforms(world).unwrap();
 
-    expect(projection.poll()).toEqual({ status: 'delta', cursor: projection.cursor, changes: [] });
+    expect(changedEntities(changes)).toEqual([]);
   });
 
-  it('uses the final authored Transform state and skips an unchanged final state', () => {
+  it('uses the final authored Transform state and publishes mutation evidence', () => {
     const world = new World();
     const root = world.spawn({ component: Transform, data: { pos: [1, 0, 0] } }).unwrap();
     const child = world
@@ -78,28 +78,21 @@ describe('transform change journal', () => {
       .unwrap();
 
     propagateTransforms(world).unwrap();
-    const projection = createWorldProjection(world, { components: [Transform] });
-    projection.poll();
+    const changes = world.query({ changed: [GlobalTransform] }).unwrap();
+    changedEntities(changes);
 
     world.set(root, Transform, { pos: [5, 0, 0] }).unwrap();
     world.set(root, Transform, { pos: [1, 0, 0] }).unwrap();
     propagateTransforms(world).unwrap();
-    const unchanged = projection.poll();
-    expect(unchanged.status).toBe('delta');
-    if (unchanged.status !== 'delta') return;
-    expect(
-      unchanged.changes.filter((record) => record.kind === 'derived-component-changed'),
-    ).toEqual([]);
-    expect(world.get(child, Transform).unwrap().world[12]).toBeCloseTo(3);
+    expect(changedEntities(changes)).toEqual([root]);
+    expect(world.get(child, GlobalTransform).unwrap().world[12]).toBeCloseTo(3);
 
     world.set(root, Transform, { pos: [5, 0, 0] }).unwrap();
     world.set(root, Transform, { pos: [7, 0, 0] }).unwrap();
     propagateTransforms(world).unwrap();
-    const changed = projection.poll();
-    expect(changed.status).toBe('delta');
-    if (changed.status !== 'delta') return;
-    const derived = changed.changes.filter((record) => record.kind === 'derived-component-changed');
-    expect(derived.map((record) => record.entity)).toEqual([root, child]);
-    expect(world.get(child, Transform).unwrap().world[12]).toBeCloseTo(9);
+    expect(changedEntities(changes).sort((left, right) => left - right)).toEqual(
+      [root, child].sort((left, right) => left - right),
+    );
+    expect(world.get(child, GlobalTransform).unwrap().world[12]).toBeCloseTo(9);
   });
 });