We need answer with code? User asks create single-page web app in index.html current dir. Need implement. Must create file. Need inspect? We can write index.html. Need no external resources. Animated synthwave sunset: glowing gradient sun, scanlines, infinite neon grid scrolling toward viewer, starfield, reflected horizon. Single self-contained file with CSS/JS inline. Need likely HTML canvas animation. Need create index.html. Need perhaps include controls? Not necessary. Need produce final concise.

Need ensure all in one file, no external. Need likely use canvas full screen, CSS. Need animate grid perspective, stars, sun gradient, scanlines. Need reflected horizon maybe neon grid reflection below horizon? "reflected horizon" maybe mirrored reflection of sun and grid on water/horizon. Need implement robust.

Let's craft index.html. Need maybe use requestAnimationFrame. Canvas. Use devicePixelRatio. Background gradient. Sun gradient radial gradient, glow. Stars generated. Grid: perspective lines horizontal and vertical. Infinite grid scrolling toward viewer: use perspective projection from horizon. We can draw lines with vanishing point center. Use vertical perspective lines from horizon to bottom, spaced increasingly. Horizontal lines y positions computed with exponential perspective. For infinite, compute distances t increasing and map y = horizonY + perspectiveFactor*t. Actually grid moving toward viewer: horizon lines denser near horizon and spread toward bottom. We can animate offset phase so lines shift down? Let's design.

Coordinate: canvas W,H; horizon = H*0.55 maybe. Vanishing point center. Draw sky gradient from deep purple top to pink/orange horizon. Sun at center x, y = horizon - 60 maybe, radius 90. Glow gradient radial. Draw scanlines overlay: CSS pseudo-element or canvas. Could draw in CSS with repeating-linear-gradient black transparent 2px. Also "scanlines" animated? CSS animation. Need starfield: array stars with x,y,size,alpha,twinkle. Draw with alpha.

Grid: draw upper neon grid from horizon to bottom, with perspective. Need "infinite neon grid that scrolls toward viewer". Use lines. For each receding distance d from horizon: d = (i + phase) * spacing. But phase? If lines move toward viewer, lines come from horizon to bottom? In perspective, distance increases from horizon to bottom. If phase increments, lines appear at horizon and move down (toward viewer), then reset. Need y = horizon + (d^1.7 / (d^1.7 + k)) * (H - horizon) maybe saturates. For d near 0, y near horizon; as d large, y near bottom. For a moving line with phase, when d passes large, y near bottom then resets to horizon; good. But if phase increasing, y increases. Need d = (i + phase) * step. The lower lines maybe after saturation near bottom, not infinite. To create infinite, we can wrap around and draw many. Use formula y = horizon + (1 - exp(-d / scale)) * (H - horizon - 20). As d increases, y approaches bottom asymptotically. It will never reset? It wraps at phase. For each i from 0 to max, y; if y<bottom. phase should be in [0,1). d=(i+phase)*spacing. y maybe near bottom for i large. At wrap, lines jump from bottom to horizon. Good.

Vertical perspective lines: from vanishing point to bottom x positions. For infinite grid, horizontal spacing at bottom increases? Need draw lines from vanishing point to bottom at x positions across screen. We can compute x at horizon? Actually perspective vertical lines radiate from vanishing point to bottom positions. For each segment maybe x = vpX + (bottomX - vpX)*t? Use t from 0 to1, bottom positions from negative to W+... We can draw full line from vp to bottomX, with stroke gradient. But to make grid scroll, horizontal lines move down, vertical lines fixed. That's typical. Need maybe "infinite neon grid scrolling toward viewer" achieved by horizontal lines.

Reflection horizon: below horizon? Actually grid is over ground, horizon maybe water reflection. Could draw reflection of sun below horizon as mirrored radial gradient, and a horizontal glowing horizon line. Maybe "reflected horizon" means a reflection of sun/horizon on grid/water. We can add water band below horizon, draw mirrored sun glow and horizon reflection. But user said "setting over an infinite neon grid that scrolls toward viewer, with a starfield and a reflected horizon." Could be a horizon reflection below sun? Let's implement a water/reflection strip just below horizon: draw mirrored sun gradient below horizon with alpha and blur-like radial gradient; draw horizontal reflection streaks. The neon grid extends from horizon to bottom and can have reflection overlay.

Need include CSS in style, JS in script. No external. Need maybe support reduced motion? Could include. Need no separate files. Need maybe responsive.

Need perhaps use CSS scanline overlay with mix-blend-mode: screen? Let's craft.

Important: "animated synthwave sunset" maybe need aesthetic. We could use canvas plus CSS overlay. Need index.html present. We can write file.

Let's draft robust code.

Potential implementation details:
- HTML structure: canvas id="scene", overlay div.scanlines, div.vignette maybe.
- CSS:
html,body { margin:0; width:100%; height:100%; overflow:hidden; background:#050014; }
canvas { display:block; width:100vw; height:100vh; }
.scanlines { position:fixed; inset:0; pointer-events:none; background: repeating-linear-gradient(to bottom, rgba(255,255,255,0.05) 0px, rgba(255,255,255,0.05) 1px, rgba(0,0,0,0.18) 2px, rgba(0,0,0,0.18) 4px); mix-blend-mode:overlay; opacity:.35; animation: scanMove 8s linear infinite; }
@keyframes scanMove { from { transform: translateY(0); } to { transform: translateY(4px); } }
.vignette { ... radial-gradient transparent center, rgba(0,0,0,.65) edge; }
Need maybe "retro CRT".

JS:
(() => {
const canvas = document.getElementById('scene'); const ctx = canvas.getContext('2d', { alpha: false });
let w,h,dpr; const stars=[];
function resize() { dpr=Math.min(window.devicePixelRatio||1, 2); w=innerWidth; h=innerHeight; canvas.width=Math.floor(w*dpr); canvas.height=Math.floor(h*dpr); canvas.style.width=w+'px'; canvas.style.height=h+'px'; ctx.setTransform(dpr,0,0,dpr,0,0); makeStars(); }
function makeStars() { const count=Math.floor((w*h)/7000); for ... random; }
const t0 = performance.now();
function lerp, ease.
function drawBackground(now) { gradient sky; fillRect; maybe clouds? }
function drawSun(now) { center x=w/2, horizon=h*0.54, y=horizon - 50 maybe; sunR = min(w,h)*0.13; time = (now/1000); draw glow: radial gradient center, r=0 to sunR*3.6 with colors rgba(255,117,199,0.75), rgba(255,222,92,0.35), transparent. Also draw large semi-transparent circles. Draw sun gradient: radial from top-left orange to pink to dark; fill circle. Draw clipped horizontal bands? Synthwave sun often has stripes. Draw bands with gradient. Draw top half? We'll draw several semi-transparent bands across sun with colors.
Maybe horizon covers lower part; draw sun partly behind horizon by clipping to sky? But we draw background first then sun, then horizon/water; horizon will cover lower part. Good.

drawStars: loop stars; alpha = star.a*(0.65+0.35*sin(time*star.twinkle+star.phase)); fillStyle rgba(255,255,255,alpha); fillRect/star. Draw some magenta/blue.

drawHorizon: glowing horizontal line at horizon. Fill water/reflection band: linear gradient from horizon to bottom: rgba(20,0,35,0.8) to rgba(3,0,12,1). But grid already ground. Could draw reflection below horizon:
- clip to y>horizon
- draw mirrored sun glow: radial gradient center x, y=horizon + (horizon - sunY), radius; alpha .35.
- draw horizontal reflection streaks: for i=0..18, y = horizon + 20 + i*i*8 + sin...; alpha decreasing; draw line from x±len; gradient. Use ctx.shadowBlur.
- draw water shimmer.

drawGrid(now):
const horizon=h*0.54; const bottom=h; const vpX=w/2; const vpY=horizon; const bottomY=h+20; const scale = Math.max(120, Math.min(w,h)*0.42); const phase = ((now*0.025)%1); // speed
Draw vertical lines:
for (let i=0; i<14; i++) { const t=(i+1)/14; const x = lerp(-w*0.25, w*1.25, t); drawLine(vpX,horizon, x, bottomY, color). But vertical lines radiate from center to bottom. Need maybe use shadowBlur. Use linear gradient from horizon to bottom with alpha.
for i=-... perhaps 17 lines.
Draw horizontal lines:
for (let i=0; i<90; i++) { const d=(i+phase)*28; const y=horizon + (1 - Math.exp(-d/scale))*(bottom-horizon-10); if y>bottom+5 continue; const depth = (y-horizon)/(bottom-horizon); const alpha = Math.min(0.95, 0.08 + depth*0.85); const hue = lerp(280, 190, depth); const width = lerp(0.6,1.8,depth); ctx.strokeStyle=`hsla(${hue},100%,60%,${alpha})`; line from 0,y to w,y; shadowBlur=12; }
Draw "vanishing glow" maybe.
Need make grid "infinite" maybe add a second layer with lower alpha.

Maybe vertical lines should be drawn after horizontal? Usually vertical lines and horizontal lines both. Draw horizontal first then vertical? Neon grid. Use ctx.save(); shadowColor; shadowBlur. Then draw.

Potential issue using ctx.shadowBlur heavy but okay.

Need draw "reflected horizon" maybe draw "horizon reflection" below horizon. Could draw before grid? If grid on top, reflection hidden. Better draw background, stars, sun, horizon reflection, grid, scanlines overlay. The reflection should be visible on water between horizon and maybe bottom; grid can overlay. Maybe draw reflection before grid; grid lines over it. Fine.

Need maybe draw "sun reflection" in water and "horizon" line.

Need maybe "glowing gradient sun" with scanlines. CSS overlay scanlines. Need maybe "setting" = sun descending slowly. Use sunY = horizon - 70 + sin? Actually setting means static setting at horizon. Could animate slight descent: sunY = horizon - 75 + Math.sin(time*0.2)*2; But if lower, maybe. We can set sunY = horizon - 80.

Need maybe "starfield" visible at sunset? Synthwave often stars. Stars with twinkle.

Need maybe "reflected horizon" perhaps draw a "mirror horizon" as a horizontal band reflecting sun:
function drawReflection(horizon, sunY, now) {
ctx.save(); ctx.beginPath(); ctx.rect(0,horizon,w,h-horizon); ctx.clip();
const mirrorY = horizon + (horizon - sunY);
let g=ctx.createRadialGradient(sunX,mirrorY,0,sunX,mirrorY,sunR*2.4);
g.addColorStop(0, 'rgba(255,136,210,.30)'); ...
ctx.fillStyle=g; ctx.fillRect(0,horizon,w,h-horizon);
for (let i=0; i<30; i++) { const y = horizon + 18 + i*i*5 + (Math.sin(now*0.001+i)*4); const len = sunR*(0.7+i*0.035); const alpha = (1-i/30)*0.35; const grad=ctx.createLinearGradient(sunX-len,y,sunX+len,y); ... draw line with shadowBlur.}
ctx.restore();
}
Need "reflected horizon" maybe a "horizon reflection" from sun and grid.

Need maybe add "clouds" or mountains? User didn't ask. Could include neon mountains? But maybe not.

Need final answer include "Created index.html" and code maybe. Since asked "Create ...". We can just write file and final mention. Need maybe not include full code? Usually for code task, provide final summary and path. But user might expect code. We can include code in final. But desired overwordy medium. We can say "Created /tmp/ws/index.html" with maybe code snippet? However final answer should maybe include complete code? Since artifact is file. Need "End with index.html present" maybe file. We can include concise.

Need use write tool. Let's create.

Need maybe verify file exists. Use bash ls? Need maybe read? We can run ls -l and maybe maybe no need but to ensure present.