Fix track preview start marker alignment

The track preview placed the green start marker at the center of StartTileCoords and ignored StartTileConnection. On A01, this shifted the marker half a tile left of the saved start.

Use the saved connection for the marker and share the native connection offsets with the orange route endpoints. Validate that the start matches its atlas tile and clarify that the route is approximate.

This PR includes the matching RELEASE_MANIFEST.json entry so the renderer and integrity manifest reach main together.

Validation: six focused renderer regressions pass, covering A01, every side/index, adjacent endpoints, invalid start data, and input preservation. Independent review also accepted all 828 connections in the current atlas.

track-map.js

@@ -14,6 +14,25 @@
       throw Error('Track coordinates exceed preview bounds');
     return [x,y];
   }
+  function connection(value,message='Track has an invalid piece connection'){
+    if(!value||typeof value!=='object'||Array.isArray(value)||
+       !Number.isInteger(value.side)||value.side<0||value.side>3||
+       !Number.isInteger(value.index)||value.index<0||value.index>2||
+       !Number.isInteger(value.type)||value.type<0)throw Error(message);
+    return {side:value.side,index:value.index,type:value.type};
+  }
+  function connectionPoint(value,x,y,size){
+    const {side,index}=connection(value);
+    // Native Connection.position uses offsets 128,384,640 in a 768-unit tile.
+    // Shared boundaries keep adjacent path endpoints and the saved start aligned.
+    const offset=[128,384,640][index]/768*size;
+    switch(side){
+      case 0:return [x+offset,y];
+      case 1:return [x+offset,y+size];
+      case 2:return [x,y+offset];
+      case 3:return [x+size,y+offset];
+    }
+  }
   async function decode(file){
     if(!file||file.size<1||file.size>1048576)throw Error('Choose a .track file under 1 MB');
     if(typeof DecompressionStream!=='function')throw Error('This browser cannot preview gzip tracks');
@@ -39,14 +58,20 @@
       const id=item?.Block?.TileSetId;
       const block=atlas?.blocks?.[`${id?.AtlasId}:${id?.AlternativeId}`];
       if(!block||![0,1,2].includes(block.surface))throw Error('Track uses a piece not in the simulator atlas');
-      return {x,y,surface:block.surface,connections:block.connections};
+      if(!Array.isArray(block.connections)||block.connections.length!==2)throw Error('Track piece connections are unavailable');
+      return {x,y,surface:block.surface,connections:block.connections.map(value=>connection(value))};
     });
     if(new Set(tiles.map(t=>`${t.x},${t.y}`)).size!==tiles.length)throw Error('Duplicate track tile');
     const start=vector(saved.StartTileCoords);
+    const startTile=tiles.find(tile=>tile.x===start[0]&&tile.y===start[1]);
+    if(!startTile)throw Error('Start tile is not present in this track');
+    const startConnection=connection({side:saved.StartTileConnection?.Side,index:saved.StartTileConnection?.Index,type:saved.StartTileConnection?.Type},'Track has an invalid or missing start connection');
+    if(!startTile.connections.some(item=>item.side===startConnection.side&&item.index===startConnection.index&&item.type===startConnection.type))
+      throw Error('Saved start connection does not match the start tile');
     const minX=Math.min(...tiles.map(t=>t.x)),maxX=Math.max(...tiles.map(t=>t.x));
     const minY=Math.min(...tiles.map(t=>t.y)),maxY=Math.max(...tiles.map(t=>t.y));
     if(maxX-minX>30||maxY-minY>30)throw Error('Track preview is too large');
-    return {tiles,start,bounds:{minX,maxX,minY,maxY}};
+    return {tiles,start,startConnection,bounds:{minX,maxX,minY,maxY}};
   }
   function render(canvas,track){
     const context=canvas.getContext('2d');
@@ -63,25 +88,16 @@
       context.beginPath();context.roundRect(x+2,y+2,size-4,size-4,Math.max(4,size*.13));context.fill();
       context.strokeStyle='#d7e8f2';context.lineWidth=Math.max(1,size*.018);
       context.stroke();
-      const edge=connection=>{
-        const offset=(connection.index-1)*size*.16;
-        switch(connection.side){
-          case 0:return [x+size/2+offset,y+2];
-          case 1:return [x+size/2+offset,y+size-2];
-          case 2:return [x+2,y+size/2+offset];
-          case 3:return [x+size-2,y+size/2+offset];
-          default:return [x+size/2,y+size/2];
-        }
-      };
       if(Array.isArray(tile.connections)&&tile.connections.length>=2){
-        const a=edge(tile.connections[0]),z=edge(tile.connections[1]);
+        const a=connectionPoint(tile.connections[0],x,y,size),z=connectionPoint(tile.connections[1],x,y,size);
         context.beginPath();context.moveTo(...a);
         context.quadraticCurveTo(x+size/2,y+size/2,...z);
         context.strokeStyle='#f3a967';context.lineWidth=Math.max(3,size*.055);
         context.lineCap='round';context.stroke();
       }
     }
-    const sx=left+(track.start[0]-b.minX+.5)*size,sy=top+(track.start[1]-b.minY+.5)*size;
+    const startX=left+(track.start[0]-b.minX)*size,startY=top+(track.start[1]-b.minY)*size;
+    const [sx,sy]=connectionPoint(track.startConnection,startX,startY,size);
     context.beginPath();context.arc(sx,sy,Math.max(6,size*.105),0,Math.PI*2);
     context.fillStyle='#66e5aa';context.fill();context.strokeStyle='#0c1926';context.lineWidth=3;context.stroke();
   }
@@ -106,10 +122,10 @@
         if(current!==version)return;
         render(canvas,track);
         const counts=[0,0,0];track.tiles.forEach(tile=>counts[tile.surface]++);
-        status.textContent=source+' · '+track.tiles.length+' pieces · green dot marks the start';
+        status.textContent=source+' · '+track.tiles.length+' pieces · green dot marks the saved starting point';
         legend.textContent=NAMES.filter((_,i)=>counts[i]).map((name,index)=>{
           const i=NAMES.indexOf(name);return name+' '+counts[i];
-        }).join(' · ')+' · Piece and terrain preview; collision shapes are not shown.';
+        }).join(' · ')+' · Orange line shows the approximate route; collision shapes and car positions are not shown.';
       }catch(error){
         if(current!==version)return;
         renderEmpty();status.textContent='Map unavailable: '+error.message;legend.textContent='Training selection is unaffected.';