@forgeax/engine-render 0.0.0-dev.8d955ade1c79

package/src/prepare/prepared-graphics-resolver.ts

@@ -0,0 +1,456 @@
+import type { BindGroup, Buffer, RenderPipeline, RhiDevice } from '@forgeax/engine-rhi';
+import { err, ok, type Result } from '@forgeax/engine-types';
+import {
+  type RenderError,
+  RenderFeaturePreparationFailedError,
+  RenderFeaturePreparedStateMismatchError,
+  RenderFeatureStageFailedError,
+} from '../errors/render';
+import type {
+  PreparedGraphicsResourceLease,
+  RenderFeatureResolvedGpuBuffer,
+} from '../features/prepared-gpu-work';
+import type {
+  RenderFeatureBindingsDescriptor,
+  RenderFeaturePreparedRef,
+} from '../features/prepared-graphics';
+import type {
+  PreparedGraphicsItem,
+  PreparedGraphicsKind,
+  PreparedGraphicsNormalizedDescriptor,
+} from '../features/prepared-graphics-store';
+
+type PreparedBufferKind = Exclude<PreparedGraphicsKind, 'pipeline' | 'bindings'>;
+
+type PreparedGraphicsMismatch =
+  | {
+      readonly reason: 'missing-prepared-state';
+      readonly missingResource: string;
+    }
+  | {
+      readonly reason: 'generation-mismatch';
+      readonly expectedGeneration: number;
+      readonly actualGeneration: number;
+    };
+
+export type PreparedGraphicsReference =
+  | RenderFeaturePreparedRef<'pipeline'>
+  | RenderFeaturePreparedRef<'bindings'>
+  | RenderFeaturePreparedRef<'vertex-data'>
+  | RenderFeaturePreparedRef<'index-data'>;
+
+export type PreparedGraphicsResolvedResource =
+  | {
+      readonly kind: 'pipeline';
+      readonly reference: RenderFeaturePreparedRef;
+      readonly handle: RenderPipeline;
+    }
+  | {
+      readonly kind: 'bindings';
+      readonly reference: RenderFeaturePreparedRef;
+      readonly handle: BindGroup | undefined;
+      readonly pipeline?: RenderPipeline;
+      readonly descriptor?: RenderFeatureBindingsDescriptor;
+      readonly dynamicOffsets?: readonly number[];
+    }
+  | {
+      readonly kind: PreparedBufferKind;
+      readonly reference: RenderFeaturePreparedRef;
+      readonly handle: Buffer;
+      readonly size: number;
+      readonly physicalUsage: number;
+    };
+
+export interface PreparedGraphicsResolverInput {
+  readonly device: RhiDevice;
+  /** Owning feature identity survives lookup failures for feature-local diagnostics. */
+  readonly featureIdentity?: string;
+  readonly generation: number;
+  readonly capabilityAvailable: boolean;
+  readonly lookup: (reference: RenderFeaturePreparedRef) => PreparedGraphicsItem | undefined;
+  readonly resolvePipeline: (
+    descriptor: PreparedGraphicsNormalizedDescriptor & { readonly kind: 'pipeline' },
+  ) => Result<RenderPipeline, unknown>;
+  readonly resolveBindings: (
+    descriptor: RenderFeatureBindingsDescriptor,
+    pipeline: RenderPipeline,
+  ) => Result<
+    | undefined
+    | BindGroup
+    | {
+        readonly handle: BindGroup;
+        readonly dynamicOffsets?: readonly number[];
+        readonly release: () => Result<void, unknown>;
+      },
+    unknown
+  >;
+  readonly resolveGpuBuffer?: (
+    reference: import('../features/prepared-gpu-work').RenderFeatureGpuBufferRef,
+  ) => RenderFeatureResolvedGpuBuffer | undefined;
+  readonly featureOrder?: number;
+}
+
+export interface PreparedGraphicsResolver {
+  resolve(
+    reference: PreparedGraphicsReference,
+  ): Result<PreparedGraphicsResolvedResource, RenderError>;
+  readonly leases: readonly PreparedGraphicsResourceLease[];
+  readonly resolveGpuBuffer?: PreparedGraphicsResolverInput['resolveGpuBuffer'];
+  release(): Result<void, RenderError>;
+}
+
+export type { PreparedGraphicsResourceLease } from '../features/prepared-gpu-work';
+
+export interface PreparedGraphicsResolvedSnapshot {
+  readonly generation: number;
+  readonly leases?: readonly PreparedGraphicsResourceLease[];
+  readonly resolve: (
+    reference: RenderFeaturePreparedRef,
+  ) => PreparedGraphicsResolvedResource | undefined;
+  readonly resolveGpuBuffer?: (
+    reference: import('../features/prepared-gpu-work').RenderFeatureGpuBufferRef,
+  ) => RenderFeatureResolvedGpuBuffer | undefined;
+}
+
+function preparationFailure(
+  item: PreparedGraphicsItem | undefined,
+  input: PreparedGraphicsResolverInput,
+  kind: RenderFeaturePreparedRef['kind'],
+  name: string,
+  reason: string,
+): RenderError {
+  return new RenderFeaturePreparationFailedError(
+    item?.featureIdentity ?? input.featureIdentity ?? 'unknown',
+    input.featureOrder ?? -1,
+    'resolve',
+    kind,
+    name,
+    reason,
+    'next-frame',
+  );
+}
+
+function pipelineResolutionReason(error: unknown): string {
+  return typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    error.code === 'rhi-not-available'
+    ? 'pipeline-pending'
+    : 'pipeline resolution failed';
+}
+
+function stateMismatch(
+  input: PreparedGraphicsResolverInput,
+  reference: RenderFeaturePreparedRef,
+  detail: PreparedGraphicsMismatch,
+): RenderError {
+  if (detail.reason === 'missing-prepared-state') {
+    return new RenderFeaturePreparedStateMismatchError({
+      featureIdentity: input.featureIdentity ?? 'unknown',
+      order: input.featureOrder ?? -1,
+      stage: 'contribute',
+      operation: 'resolve',
+      resourceKind: reference.kind,
+      reason: detail.reason,
+      missingResource: detail.missingResource,
+      recovery: 'next-frame',
+    });
+  }
+  return new RenderFeaturePreparedStateMismatchError({
+    featureIdentity: input.featureIdentity ?? 'unknown',
+    order: input.featureOrder ?? -1,
+    stage: 'contribute',
+    operation: 'resolve',
+    resourceKind: reference.kind,
+    reason: detail.reason,
+    expectedGeneration: detail.expectedGeneration,
+    actualGeneration: detail.actualGeneration,
+    recovery: 'next-frame',
+  });
+}
+
+function bufferUsage(kind: PreparedBufferKind): number {
+  const copyDst = 8;
+  return kind === 'vertex-data' ? 32 | copyDst : 16 | copyDst;
+}
+
+function uploadBuffer(
+  input: PreparedGraphicsResolverInput,
+  item: PreparedGraphicsItem,
+  kind: PreparedBufferKind,
+): Result<Buffer, RenderError> {
+  const bytes = item.uploadBytes;
+  if (bytes === undefined || bytes.length === 0) {
+    return err(preparationFailure(item, input, kind, item.name, 'upload bytes are missing'));
+  }
+  const size = Math.max(4, (bytes.length + 3) & ~3);
+  const created = input.device.createBuffer({
+    label: `${item.featureIdentity}::${item.name}`,
+    size,
+    usage: bufferUsage(kind),
+  });
+  if (!created.ok) {
+    return err(preparationFailure(item, input, kind, item.name, 'device buffer creation failed'));
+  }
+  const payload = new Uint8Array(size);
+  payload.set(bytes);
+  const uploaded = input.device.queue.writeBuffer(created.value, 0, payload);
+  if (!uploaded.ok) {
+    input.device.destroyBuffer(created.value);
+    return err(preparationFailure(item, input, kind, item.name, 'device buffer upload failed'));
+  }
+  return ok(created.value);
+}
+
+function descriptorFor(
+  item: PreparedGraphicsItem,
+  kind: 'pipeline',
+): Extract<PreparedGraphicsNormalizedDescriptor, { readonly kind: 'pipeline' }> | undefined;
+function descriptorFor(
+  item: PreparedGraphicsItem,
+  kind: 'bindings',
+): Extract<PreparedGraphicsNormalizedDescriptor, { readonly kind: 'bindings' }> | undefined;
+function descriptorFor(
+  item: PreparedGraphicsItem,
+  kind: PreparedBufferKind,
+): Extract<PreparedGraphicsNormalizedDescriptor, { readonly kind: PreparedBufferKind }> | undefined;
+function descriptorFor(
+  item: PreparedGraphicsItem,
+  kind: PreparedGraphicsNormalizedDescriptor['kind'],
+): PreparedGraphicsNormalizedDescriptor | undefined {
+  return item.descriptor?.kind === kind ? item.descriptor : undefined;
+}
+
+export function createPreparedGraphicsResolver(
+  input: PreparedGraphicsResolverInput,
+): PreparedGraphicsResolver {
+  const resolved = new WeakMap<object, PreparedGraphicsResolvedResource>();
+  const leases: PreparedGraphicsResourceLease[] = [];
+
+  const resolve = (
+    reference: PreparedGraphicsReference,
+  ): Result<PreparedGraphicsResolvedResource, RenderError> => {
+    if (!input.capabilityAvailable) {
+      return err(
+        preparationFailure(
+          undefined,
+          input,
+          reference.kind,
+          reference.kind,
+          'required capability is unavailable',
+        ),
+      );
+    }
+    const item = input.lookup(reference);
+    if (item === undefined || item.reference !== reference) {
+      return err(
+        stateMismatch(input, reference, {
+          reason: 'missing-prepared-state',
+          missingResource: reference.kind,
+        }),
+      );
+    }
+    if (item.generation !== input.generation || reference.generation !== input.generation) {
+      return err(
+        stateMismatch(input, reference, {
+          reason: 'generation-mismatch',
+          expectedGeneration: input.generation,
+          actualGeneration: reference.generation,
+        }),
+      );
+    }
+    const cached = resolved.get(reference);
+    if (cached !== undefined) return ok(cached);
+
+    switch (reference.kind) {
+      case 'pipeline':
+        return resolvePipeline(item, reference);
+      case 'bindings':
+        return resolveBindings(item, reference);
+      case 'vertex-data':
+      case 'index-data':
+        return resolveBuffer(item, reference);
+    }
+  };
+
+  const resolvePipeline = (
+    item: PreparedGraphicsItem,
+    reference: RenderFeaturePreparedRef<'pipeline'>,
+  ): Result<PreparedGraphicsResolvedResource, RenderError> => {
+    const descriptor = descriptorFor(item, 'pipeline');
+    if (descriptor === undefined) {
+      return err(
+        preparationFailure(
+          item,
+          input,
+          reference.kind,
+          item.name,
+          'pipeline descriptor is missing',
+        ),
+      );
+    }
+    const created = input.resolvePipeline(descriptor);
+    if (!created.ok || created.value === undefined) {
+      return err(
+        preparationFailure(
+          item,
+          input,
+          reference.kind,
+          item.name,
+          created.ok ? 'pipeline resolution failed' : pipelineResolutionReason(created.error),
+        ),
+      );
+    }
+    const resource: PreparedGraphicsResolvedResource = {
+      kind: 'pipeline',
+      reference,
+      handle: created.value,
+    };
+    resolved.set(reference, resource);
+    return ok(resource);
+  };
+
+  const resolveBindings = (
+    item: PreparedGraphicsItem,
+    reference: RenderFeaturePreparedRef<'bindings'>,
+  ): Result<PreparedGraphicsResolvedResource, RenderError> => {
+    const descriptor = descriptorFor(item, 'bindings');
+    if (descriptor === undefined) {
+      return err(
+        preparationFailure(
+          item,
+          input,
+          reference.kind,
+          item.name,
+          'bindings descriptor is missing',
+        ),
+      );
+    }
+    const pipeline = resolve(descriptor.pipeline);
+    if (!pipeline.ok || pipeline.value.kind !== 'pipeline') return pipeline;
+    const created = input.resolveBindings(descriptor, pipeline.value.handle);
+    if (!created.ok) {
+      return err(
+        preparationFailure(item, input, reference.kind, item.name, 'bindings resolution failed'),
+      );
+    }
+    const binding =
+      created.value !== undefined &&
+      typeof created.value === 'object' &&
+      created.value !== null &&
+      'handle' in created.value &&
+      'release' in created.value
+        ? created.value
+        : undefined;
+    const resource: PreparedGraphicsResolvedResource = {
+      kind: 'bindings',
+      reference,
+      handle: binding?.handle ?? (created.value as BindGroup | undefined),
+      pipeline: pipeline.value.handle,
+      descriptor,
+      ...(binding?.dynamicOffsets === undefined ? {} : { dynamicOffsets: binding.dynamicOffsets }),
+    };
+    if (binding !== undefined) {
+      let released = false;
+      leases.push({
+        release: () => {
+          if (released) return ok(undefined);
+          released = true;
+          const result = binding.release();
+          return result.ok
+            ? ok(undefined)
+            : err(
+                new RenderFeatureStageFailedError(
+                  item.featureIdentity,
+                  input.featureOrder ?? -1,
+                  'dispose',
+                  'renderer-recover',
+                ),
+              );
+        },
+      });
+    }
+    resolved.set(reference, resource);
+    return ok(resource);
+  };
+
+  const resolveBuffer = (
+    item: PreparedGraphicsItem,
+    reference: RenderFeaturePreparedRef<PreparedBufferKind>,
+  ): Result<PreparedGraphicsResolvedResource, RenderError> => {
+    const descriptor = descriptorFor(item, reference.kind);
+    if (descriptor === undefined) {
+      return err(
+        preparationFailure(
+          item,
+          input,
+          reference.kind,
+          item.name,
+          `${reference.kind} descriptor is missing`,
+        ),
+      );
+    }
+    if ('buffer' in descriptor && descriptor.buffer !== undefined) {
+      const handle = input.resolveGpuBuffer?.(descriptor.buffer);
+      if (handle === undefined) {
+        return err(
+          preparationFailure(item, input, reference.kind, item.name, 'GPU buffer is unavailable'),
+        );
+      }
+      const resource: PreparedGraphicsResolvedResource = {
+        kind: reference.kind,
+        reference,
+        handle: handle.buffer,
+        size: handle.size,
+        physicalUsage: handle.physicalUsage,
+      };
+      resolved.set(reference, resource);
+      return ok(resource);
+    }
+    const buffer = uploadBuffer(input, item, reference.kind);
+    if (!buffer.ok) return buffer;
+    const resource: PreparedGraphicsResolvedResource = {
+      kind: reference.kind,
+      reference,
+      handle: buffer.value,
+      size: Math.max(4, ((item.uploadBytes?.length ?? 0) + 3) & ~3),
+      physicalUsage: bufferUsage(reference.kind),
+    };
+    leases.push({
+      release: (() => {
+        let released = false;
+        return () => {
+          if (released) return ok(undefined);
+          released = true;
+          const destroyed = input.device.destroyBuffer(buffer.value);
+          return destroyed.ok
+            ? ok(undefined)
+            : err(
+                new RenderFeatureStageFailedError(
+                  item.featureIdentity,
+                  input.featureOrder ?? -1,
+                  'dispose',
+                  'renderer-recover',
+                ),
+              );
+        };
+      })(),
+    });
+    resolved.set(reference, resource);
+    return ok(resource);
+  };
+
+  return {
+    resolve,
+    leases,
+    ...(input.resolveGpuBuffer === undefined ? {} : { resolveGpuBuffer: input.resolveGpuBuffer }),
+    release: () => {
+      let firstError: RenderError | undefined;
+      for (const lease of leases) {
+        const released = lease.release();
+        if (!released.ok && firstError === undefined) firstError = released.error;
+      }
+      return firstError === undefined ? ok(undefined) : err(firstError);
+    },
+  };
+}

package/src/record/__tests__/material-bg-cache.unit.test.ts

@@ -0,0 +1,41 @@
+import type { BindGroup, BindGroupLayout, Buffer } from '@forgeax/engine-rhi';
+import { describe, expect, it } from 'vitest';
+import type { MaterialSnapshot } from '../../render-system-extract';
+import type { MaterialBgAssemblyCacheEntry } from '../frame-snapshot';
+import { isMaterialBgAssemblyCacheHit } from '../main-pass-material';
+
+describe('material bind-group assembly cache', () => {
+  it('invalidates when material buffer capacity growth replaces the buffer', () => {
+    const material = {} as MaterialSnapshot;
+    const materialBgl = {} as BindGroupLayout;
+    const oldBuffer = {} as Buffer;
+    const newBuffer = {} as Buffer;
+    const skylightResources = {
+      irradianceView: {},
+      irradianceSampler: {},
+      prefilterView: {},
+      prefilterSampler: {},
+      brdfLutView: {},
+      brdfLutSampler: {},
+      intensityBuffer: {},
+    } as MaterialBgAssemblyCacheEntry['skylightResources'];
+    const cached: MaterialBgAssemblyCacheEntry = {
+      material,
+      materialResourceEpoch: 7,
+      materialBgl,
+      materialBuffer: oldBuffer,
+      skylightResources,
+      bindGroup: {} as BindGroup,
+    };
+
+    expect(
+      isMaterialBgAssemblyCacheHit(cached, material, materialBgl, oldBuffer, skylightResources, 7),
+    ).toBe(true);
+    expect(
+      isMaterialBgAssemblyCacheHit(cached, material, materialBgl, newBuffer, skylightResources, 7),
+    ).toBe(false);
+    expect(
+      isMaterialBgAssemblyCacheHit(cached, material, materialBgl, oldBuffer, skylightResources, 8),
+    ).toBe(false);
+  });
+});

package/src/record/__tests__/material-slot-plan.unit.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildMaterialSlotPlan,
+  findRenderablePrefixForSlotCapacity,
+  materialSlotCountForPrefix,
+} from '../frame';
+
+describe('material slot plan', () => {
+  it('interns repeated snapshot identities across renderables', () => {
+    const a = {};
+    const b = {};
+    const c = {};
+    expect(
+      buildMaterialSlotPlan([
+        [a, b],
+        [a, c],
+        [b, a],
+      ]),
+    ).toEqual({
+      slotIndices: [
+        [0, 1],
+        [0, 2],
+        [1, 0],
+      ],
+      slots: [a, b, c],
+      slotOwners: [0, 0, 1],
+    });
+  });
+
+  it('does not merge equal-looking snapshots with distinct identities', () => {
+    expect(buildMaterialSlotPlan([[{}], [{}]])).toMatchObject({
+      slotIndices: [[0], [1]],
+      slots: [{}, {}],
+      slotOwners: [0, 1],
+    });
+  });
+
+  it('truncates only at complete mesh and material prefixes', () => {
+    const indices = [[0], [1, 2, 3], [0, 4], [5, 6, 7, 8]];
+    expect(findRenderablePrefixForSlotCapacity(indices, 3)).toBe(1);
+    expect(findRenderablePrefixForSlotCapacity(indices, 5)).toBe(3);
+    expect(materialSlotCountForPrefix(indices, 3)).toBe(5);
+  });
+});

package/src/record/__tests__/typed-frame-graph-plan.unit.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import type { RenderFeaturePlannedFrame } from '../../features/plan';
+import {
+  type RenderFeatureGraphCandidate,
+  renderFeatureGraphPlanSignature,
+} from '../typed-frame-graph';
+
+function planned(generation: number, signature: string): RenderFeaturePlannedFrame {
+  return {
+    featureIdentity: 'synthetic.feature',
+    generation,
+    signature,
+    plan: { resources: [], passes: [] },
+  };
+}
+
+describe('typed frame graph feature plan authority', () => {
+  it('keys topology and last-known-good candidates by stable plan signature and generation', () => {
+    const first = renderFeatureGraphPlanSignature([planned(1, 'plan-a')]);
+    expect(renderFeatureGraphPlanSignature([planned(1, 'plan-a')])).toBe(first);
+    expect(renderFeatureGraphPlanSignature([planned(1, 'plan-b')])).not.toBe(first);
+    expect(renderFeatureGraphPlanSignature([planned(2, 'plan-a')])).not.toBe(first);
+  });
+
+  it('keys candidates only by producer plans', () => {
+    const candidate: RenderFeatureGraphCandidate = {
+      plans: [planned(1, 'plan-a')],
+      fullscreenEffects: new Map(),
+    };
+    expect(candidate.plans).toHaveLength(1);
+  });
+
+  it('keeps execution projection out of the public planned-frame vocabulary', () => {
+    const invalid: RenderFeaturePlannedFrame = {
+      ...planned(1, 'plan-a'),
+      // @ts-expect-error execution belongs to the graph candidate adapter, not the producer plan.
+      execution: {},
+    };
+    void invalid;
+  });
+});

package/src/record/__tests__/video-texture-view.unit.test.ts

@@ -0,0 +1,90 @@
+import { type DynamicTextureDevice, DynamicTextureStore } from '@forgeax/engine-assets-runtime';
+import { World } from '@forgeax/engine-ecs';
+import {
+  VIDEO_ELEMENT_PROVIDER_KEY,
+  type VideoElementProvider,
+} from '@forgeax/engine-graphics-extras';
+import type { Result, RhiError, Texture, TextureView } from '@forgeax/engine-rhi';
+import { ok } from '@forgeax/engine-rhi';
+import type { Handle } from '@forgeax/engine-types';
+import { toShared } from '@forgeax/engine-types';
+import { describe, expect, it, vi } from 'vitest';
+import type { RenderSystemRuntime } from '../../render-system';
+import { videoTextureView } from '../main-pass-material';
+
+interface Probe {
+  copies: number;
+}
+
+function makeStore(probe: Probe): DynamicTextureStore {
+  let textureId = 0;
+  const device: DynamicTextureDevice = {
+    createTexture: () => ok({ id: `video-texture-${textureId++}` } as unknown as Texture),
+    createTextureView: (texture) => ok({ texture } as unknown as TextureView),
+    destroyTexture: () => ok(undefined) as Result<void, RhiError>,
+    queue: {
+      copyExternalImageToTexture: () => {
+        probe.copies += 1;
+        return ok(undefined) as Result<void, RhiError>;
+      },
+    },
+  };
+  const store = new DynamicTextureStore();
+  store.configureGpuDevice(device);
+  return store;
+}
+
+function runtimeWithErrors(fire: (error: { readonly code: string }) => void): RenderSystemRuntime {
+  return { errorRegistry: { fire } } as unknown as RenderSystemRuntime;
+}
+
+const CLIP = toShared<'VideoAsset'>(7001) as Handle<'VideoAsset', 'shared'>;
+const ENTITY = 17;
+const VIDEO = {
+  videoWidth: 8,
+  videoHeight: 8,
+  readyState: 2,
+} as unknown as HTMLVideoElement;
+
+describe('videoTextureView provider-loss recovery', () => {
+  it('keeps the LKG view, bounds each loss episode, and clears it after upload recovery', () => {
+    const world = new World();
+    const probe: Probe = { copies: 0 };
+    const store = makeStore(probe);
+    const errors: { readonly code: string }[] = [];
+    const runtime = runtimeWithErrors((error) => errors.push(error));
+    const provider: VideoElementProvider = {
+      getElement: vi.fn(() => VIDEO),
+    };
+    world.insertResource(VIDEO_ELEMENT_PROVIDER_KEY, provider);
+
+    const lkg = videoTextureView(world, store, runtime, ENTITY, CLIP, false);
+    expect(lkg).toBeDefined();
+    expect(probe.copies).toBe(1);
+
+    world.removeResource(VIDEO_ELEMENT_PROVIDER_KEY);
+    expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
+    expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
+    expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]?.code).toBe('video-upload-unsupported');
+    expect(probe.copies).toBe(1);
+
+    world.insertResource(VIDEO_ELEMENT_PROVIDER_KEY, provider);
+    expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
+    expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
+    expect(errors).toHaveLength(1);
+    expect(probe.copies).toBe(3);
+
+    world.removeResource(VIDEO_ELEMENT_PROVIDER_KEY);
+    expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
+    expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
+    expect(errors).toHaveLength(2);
+    expect(probe.copies).toBe(3);
+
+    world.insertResource(VIDEO_ELEMENT_PROVIDER_KEY, provider);
+    expect(videoTextureView(world, store, runtime, ENTITY, CLIP, false)).toBe(lkg);
+    expect(errors).toHaveLength(2);
+    expect(probe.copies).toBe(4);
+  });
+});