@@ -2,7 +2,6 @@ import { afterEach, expect, it, vi } from "vitest";
22import { initSandboxRuntimeModular } from "./init" ;
33import { hideTimedClipsUntilFirstPass } from "./timedClipHide" ;
44import { resetSeekDispatchState } from "./adapters/seek-dispatch" ;
5- import { notePlaybackIntent } from "./media" ;
65import { createMockTimeline , resetRuntimeFixtureDom } from "./runtimeSeekFixture.test-helpers" ;
76import { PREVIEW_SEEK_HOLD_ATTR , STUDIO_PREVIEW_MARK_META } from "../studioPreviewMark" ;
87import type {
@@ -414,29 +413,88 @@ it("settles a stalled paused fallback while retaining the last complete picture"
414413 expect ( document . documentElement . hasAttribute ( PREVIEW_SEEK_HOLD_ATTR ) ) . toBe ( false ) ;
415414} ) ;
416415
417- it ( "plays the rest after native loading stops at metadata, retaining the stalled picture until recovery" , async ( ) => {
416+ it . each ( [
417+ [ "already metadata-only, idle" , false , 1 ] ,
418+ [ "ready, then metadata-only idle" , true , 1 ] ,
419+ [ "ready, then loading forever" , true , 2 ] ,
420+ [ "metadata-only, loading forever" , false , 2 ] ,
421+ ] as const ) (
422+ "bounds Play for %s and releases its picture only at the current transport time" ,
423+ async ( _ , initiallyReady , networkState ) => {
424+ vi . useFakeTimers ( { toFake : [ "setTimeout" , "clearTimeout" , "performance" ] } ) ;
425+ const { main, old, next } = film ( ) ;
426+ const { pending } = frameProvider ( [ ...old , ...next ] ) ;
427+ const initial = window . __player ! . seek ( 3 ) ;
428+ pending . shift ( ) ! ( ) ;
429+ await initial ;
430+ const stalled = old [ 0 ] ! ;
431+ if ( initiallyReady ) stalled . land ( ) ;
432+ else stalled . metadataAt ( 3 ) ;
433+ Object . defineProperty ( stalled . video , "networkState" , {
434+ value : networkState ,
435+ configurable : true ,
436+ } ) ;
437+ window . __player ! . play ( ) ;
438+ old [ 1 ] ! . land ( ) ;
439+ await vi . advanceTimersByTimeAsync ( 5100 ) ;
440+ if ( initiallyReady || networkState === 2 ) expect ( window . __player ! . isPlaying ( ) ) . toBe ( false ) ;
441+ expect ( document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ) . toHaveLength (
442+ window . __player ! . isPlaying ( ) ? 1 : 2 ,
443+ ) ;
444+ stalled . video . dispatchEvent ( new Event ( "progress" ) ) ;
445+ await vi . advanceTimersByTimeAsync ( 4900 ) ;
446+ expect ( window . __player ! . isPlaying ( ) ) . toBe ( true ) ;
447+ expect ( main . time ?.( ) ) . toBeGreaterThanOrEqual ( 3 ) ;
448+ expect ( document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ) . toHaveLength ( 1 ) ;
449+ const held = document . querySelector ( "[data-hf-preview-video-canvas]" ) ! ;
450+ expect ( [ held . getAttribute ( "width" ) , held . getAttribute ( "height" ) ] ) . toEqual ( [ "64" , "36" ] ) ;
451+ } ,
452+ ) ;
453+
454+ it ( "keeps every unready video picture at the hard deadline" , async ( ) => {
418455 vi . useFakeTimers ( { toFake : [ "setTimeout" , "clearTimeout" , "performance" ] } ) ;
419- const { main , old, next } = film ( ) ;
456+ const { old, next } = film ( ) ;
420457 const { pending } = frameProvider ( [ ...old , ...next ] ) ;
421- const initial = window . __player ! . seek ( 1 ) ;
458+ const initial = window . __player ! . seek ( 3 ) ;
459+ pending . shift ( ) ! ( ) ;
460+ await initial ;
461+ const pictures = [ ...document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ] ;
462+ window . __player ! . play ( ) ;
463+ await vi . advanceTimersByTimeAsync ( 10000 ) ;
464+ expect ( window . __player ! . isPlaying ( ) ) . toBe ( true ) ;
465+ expect ( [ ...document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ] ) . toEqual ( pictures ) ;
466+ window . __player ! . pause ( ) ;
467+ pending . shift ( ) ! ( ) ;
468+ await Promise . resolve ( ) ;
469+ await Promise . resolve ( ) ;
470+ window . __player ! . play ( ) ;
471+ await Promise . resolve ( ) ;
472+ await Promise . resolve ( ) ;
473+ expect ( window . __player ! . isPlaying ( ) ) . toBe ( true ) ;
474+ expect ( document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ) . toHaveLength ( 2 ) ;
475+ } ) ;
476+
477+ it ( "seeks late native recovery to the moving transport before removing its picture" , async ( ) => {
478+ vi . useFakeTimers ( { toFake : [ "setTimeout" , "clearTimeout" , "performance" ] } ) ;
479+ const { old, next } = film ( ) ;
480+ const { pending } = frameProvider ( [ ...old , ...next ] ) ;
481+ const initial = window . __player ! . seek ( 3 ) ;
422482 pending . shift ( ) ! ( ) ;
423483 await initial ;
424484 const stalled = old [ 0 ] ! ;
425- stalled . land ( ) ;
426- notePlaybackIntent ( stalled . video ) ;
427- stalled . metadataAt ( 1 ) ;
428- Object . defineProperty ( stalled . video , "networkState" , { value : 1 , configurable : true } ) ;
485+ stalled . metadataAt ( 3 ) ;
486+ let error : { code : number } | null = { code : 4 } ;
487+ Object . defineProperty ( stalled . video , "error" , { configurable : true , get : ( ) => error } ) ;
429488 window . __player ! . play ( ) ;
430489 old [ 1 ] ! . land ( ) ;
431- await vi . advanceTimersByTimeAsync ( 5100 ) ;
490+ await vi . advanceTimersByTimeAsync ( 500 ) ;
432491 expect ( window . __player ! . isPlaying ( ) ) . toBe ( true ) ;
433- expect ( main . time ?. ( ) ) . toBeGreaterThanOrEqual ( 1 ) ;
434- expect ( document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ) . toHaveLength ( 1 ) ;
435- expect ( stalled . video . previousElementSibling ?. hasAttribute ( "data-hf-preview-video-canvas" ) ) . toBe (
436- true ,
437- ) ;
492+ const picture = stalled . video . previousElementSibling ;
493+ error = null ;
494+ stalled . land ( ) ;
495+ expect ( stalled . video . previousElementSibling ) . toBe ( picture ) ;
496+ expect ( stalled . video . currentTime ) . toBeCloseTo ( 3.5 , 2 ) ;
438497 stalled . land ( ) ;
439- await Promise . resolve ( ) ;
440498 expect ( document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ) . toHaveLength ( 0 ) ;
441499} ) ;
442500
@@ -454,6 +512,12 @@ it("publishes a late native recovery after a paused fallback wait has settled",
454512 await stalled ;
455513 expect ( main . time ?.( ) ) . toBe ( 1 ) ;
456514 expect ( document . documentElement . hasAttribute ( PREVIEW_SEEK_HOLD_ATTR ) ) . toBe ( true ) ;
515+ expect ( window . __player ! . getTime ( ) ) . toBe ( 1 ) ;
516+ const priorSeeks = old [ 0 ] ! . seeks . length ;
517+ const destinationSeeks = next . map ( ( video ) => video . seeks . length ) ;
518+ old [ 0 ] ! . reload ( ) ;
519+ expect ( old [ 0 ] ! . seeks . length ) . toBeGreaterThan ( priorSeeks ) ;
520+ expect ( next . map ( ( video ) => video . seeks . length ) ) . toEqual ( destinationSeeks ) ;
457521 for ( const video of next ) video . land ( ) ;
458522 await Promise . resolve ( ) ;
459523 expect ( main . time ?.( ) ) . toBe ( 6 ) ;
@@ -470,11 +534,11 @@ it("keeps a hold-only snapshot visible while Play awaits decoder suspension", as
470534 suspended = resolve ;
471535 } ) ;
472536 const seek = window . __player ! . seek ( 6 ) ;
473- expect ( document . querySelectorAll ( "[data-hf-seek-video]" ) ) . toHaveLength ( 2 ) ;
537+ const pictures = [ ...document . querySelectorAll ( "canvas" ) ] ;
538+ expect ( pictures ) . toHaveLength ( 2 ) ;
474539 window . __player ! . play ( ) ;
475540 await seek ;
476- expect ( document . querySelectorAll ( "[data-hf-seek-video]" ) ) . toHaveLength ( 2 ) ;
477- expect ( document . querySelectorAll ( "canvas" ) ) . toHaveLength ( 2 ) ;
541+ expect ( [ ...document . querySelectorAll ( "canvas" ) ] ) . toEqual ( pictures ) ;
478542 suspended ( ) ;
479543 await Promise . resolve ( ) ;
480544 for ( const video of next ) video . land ( ) ;
@@ -499,6 +563,75 @@ it("resumes a pending Play after its frame provider is replaced", async () => {
499563 expect ( document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ) . toHaveLength ( 0 ) ;
500564} ) ;
501565
566+ it ( "cancels the hard Play deadline when Pause restores provider ownership" , async ( ) => {
567+ vi . useFakeTimers ( { toFake : [ "setTimeout" , "clearTimeout" , "performance" ] } ) ;
568+ const { old, next } = film ( ) ;
569+ const { pending } = frameProvider ( [ ...old , ...next ] ) ;
570+ const initial = window . __player ! . seek ( 3 ) ;
571+ pending . shift ( ) ! ( ) ;
572+ await initial ;
573+ window . __player ! . play ( ) ;
574+ await vi . advanceTimersByTimeAsync ( 9000 ) ;
575+ window . __player ! . pause ( ) ;
576+ pending . shift ( ) ! ( ) ;
577+ await vi . advanceTimersByTimeAsync ( 20000 ) ;
578+ expect ( window . __player ! . isPlaying ( ) ) . toBe ( false ) ;
579+ expect ( document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ) . toHaveLength ( 2 ) ;
580+ } ) ;
581+
582+ it ( "bounds a deferred decoder release and ignores its late completion" , async ( ) => {
583+ vi . useFakeTimers ( { toFake : [ "setTimeout" , "clearTimeout" , "performance" ] } ) ;
584+ const { old, next } = film ( ) ;
585+ const { provider, pending } = frameProvider ( [ ...old , ...next ] ) ;
586+ let released = ( ) => { } ;
587+ provider . suspend = ( ) =>
588+ new Promise < void > ( ( resolve ) => {
589+ released = resolve ;
590+ } ) ;
591+ const initial = window . __player ! . seek ( 3 ) ;
592+ pending . shift ( ) ! ( ) ;
593+ await initial ;
594+ window . __player ! . play ( ) ;
595+ await vi . advanceTimersByTimeAsync ( 10000 ) ;
596+ expect ( window . __player ! . isPlaying ( ) ) . toBe ( true ) ;
597+ const pictures = [ ...document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ] ;
598+ expect ( pictures ) . toHaveLength ( 2 ) ;
599+ released ( ) ;
600+ await Promise . resolve ( ) ;
601+ await Promise . resolve ( ) ;
602+ expect ( window . __player ! . isPlaying ( ) ) . toBe ( true ) ;
603+ expect ( [ ...document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ] ) . toEqual ( pictures ) ;
604+ } ) ;
605+
606+ it ( "ignores decoder release after Pause cancels a pending Play" , async ( ) => {
607+ vi . useFakeTimers ( { toFake : [ "setTimeout" , "clearTimeout" , "performance" ] } ) ;
608+ const { old, next } = film ( ) ;
609+ const { provider, pending } = frameProvider ( [ ...old , ...next ] ) ;
610+ let released = ( ) => { } ;
611+ provider . suspend = ( ) =>
612+ new Promise < void > ( ( resolve ) => {
613+ released = resolve ;
614+ } ) ;
615+ const initial = window . __player ! . seek ( 3 ) ;
616+ pending . shift ( ) ! ( ) ;
617+ await initial ;
618+ window . __player ! . play ( ) ;
619+ await vi . advanceTimersByTimeAsync ( 9000 ) ;
620+ window . __player ! . pause ( ) ;
621+ pending . shift ( ) ! ( ) ;
622+ await Promise . resolve ( ) ;
623+ await Promise . resolve ( ) ;
624+ const pictures = [ ...document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ] ;
625+ const seeks = old . map ( ( video ) => video . seeks . length ) ;
626+ released ( ) ;
627+ await Promise . resolve ( ) ;
628+ await Promise . resolve ( ) ;
629+ expect ( old . map ( ( video ) => video . seeks . length ) ) . toEqual ( seeks ) ;
630+ await vi . advanceTimersByTimeAsync ( 1000 ) ;
631+ expect ( window . __player ! . isPlaying ( ) ) . toBe ( false ) ;
632+ expect ( [ ...document . querySelectorAll ( "[data-hf-preview-video-canvas]" ) ] ) . toEqual ( pictures ) ;
633+ } ) ;
634+
502635it ( "does not wait for a video frame from an audio-only video element" , async ( ) => {
503636 const { main, next } = film ( ) ;
504637 for ( const { video } of next )
0 commit comments