Nemotron 3 Nano Omni (free)

We need to produce a website for Korean taco food truck "Kimchi Loco". Must be a self-contained HTML file with CSS and JS inline. Must be a game? Not necessarily. The user wants a website that makes people want to come. So we need a landing page with appealing design, maybe a simple interactive demo like a mini game where an AI (maybe a moving taco) appears, with "Click or press a key to start". The page must show something on first paint, adapt to viewport, no external resources except allowed CDN. Must be zero errors in console.

We need to ensure that the page automatically shows a demo mode where a simple AI plays (maybe a moving taco that the user can control). But the requirement: "Games must start in a self-playing demo mode (a simple AI plays) behind a 'Click or press a key to start' message". So we need a game-like interactive element. Perhaps a simple "catch the taco" or "drag the taco" or "move the taco to the target". But we need a self-playing demo mode: maybe an AI automatically moves a taco across the screen, and the user can click to start. Or maybe a simple animation where a taco moves automatically, and the user can click to start controlling.

Simplify: We'll create a full-screen canvas with a taco sprite (maybe using CSS to draw a simple shape). The page shows a heading "Kimchi Loco" with tagline. Then a message "Click or press a key to start". When user clicks or presses a key, the game starts: a taco moves automatically (AI) across the screen following a simple path, and the user can click to "eat" the taco (maybe increase score). The AI can be a simple random movement that eventually reaches the bottom where a "serving" area is. The user wants to come, so we want to make it appealing.

But maybe simpler: just a static page with beautiful design and a "Start Demo" button that triggers an animation of tacos flying around, showing the food. That would be enough to make people want to come. The requirement about "self-playing demo mode" suggests a game-like interactive element. Let's create a simple canvas game: a taco that moves automatically (AI) across the screen, and the user can click to "catch" it, scoring points. The AI moves in a pattern, maybe bouncing off walls. The game runs automatically (self-playing) after start, showing the taco moving, and the user can see the food.

We need to ensure the page looks good on 1280x800 and down to 375px. Use responsive CSS with flexbox, maybe a max-width container.

No external resources except CDN if needed. We can use Google Fonts? That would be external. Better avoid. Use system fonts.

We'll embed CSS in <style> and JS in <script>. Use canvas for the game.

Make sure there's a "Click or press a key to start" overlay initially. After click, hide overlay and start animation. The animation should be visible on first paint (maybe the overlay is part of first paint). But we need something meaningful visible on first paint: maybe the header and a static image of tacos, plus the overlay message. That's fine.

The page must adapt gracefully down to 375px. Use viewport meta tag.

No console errors. Ensure we use requestAnimationFrame for animation.

Let's design:

HTML:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Kimchi Loco - Korean Taco Food Truck</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
  /* CSS */
  body, html { margin:0; padding:0; height:100%; font-family: Arial, Helvetica, sans-serif; background:#f5f5f5; color:#333; overflow:hidden; }
  .container { position:relative; width:100%; height:100%; display:flex; flex-direction:column; align-items:center; justify-content:center; }
  h1 { font-size:2.5rem; margin:0; color:#e63946; }
  .tagline { font-size:1.2rem; margin-top:0.5rem; color:#555; }
  .overlay {
    position:absolute; top:0; left:0; width:100%; height:100%;
    display:flex; align-items:center; justify-content:center;
    background:rgba(0,0,0,0.6); color:#fff; font-size:1.5rem;
    pointer-events:none;
  }
  .overlay.active { pointer-events:auto; }
  canvas { position:absolute; top:0; left:0; width:100%; height:100%; }
  .score { position:absolute; top:10px; right:10px; font-size:1.2rem; color:#fff; text-shadow:0 0 5px #000; }
</style>
</head>
<body>
<div class="container">
  <h1>Kimchi Loco</h1>
  <div class="tagline">Spicy Kimchi Tacos & Fusion Flavors</div>
  <div class="overlay" id="startOverlay">Click or press a key to start</div>
  <canvas id="gameCanvas"></canvas>
  <div class="score" id="score">Score: 0</div>
</div>
<script>
/* JS */
const canvas = document.getElementById('gameCanvas');
const ctx = canvas.getContext('2d');
const overlay = document.getElementById('startOverlay');
const scoreEl = document.getElementById('score');

// Set canvas size responsive
function resize() {
  canvas.width = window.innerWidth;
  canvas.height = window.innerHeight;
}
window.addEventListener('resize', resize);
resize();

let taco = {
  x: 0,
  y: 0,
  radius: 30,
  speed: 2,
  dx: 2,
  dy: 2,
  // simple AI: bounce off edges
};
let score = 0;

function drawTaco() {
  ctx.fillStyle = '#ff6b6b'; // red for taco
  ctx.beginPath();
  ctx.arc(taco.x, taco.y, taco.radius, 0, Math.PI*2);
  ctx.fill();
  // add some kimchi topping
  ctx.fillStyle = '#4ecca3';
  ctx.fillRect(taco.x - taco.radius/2, taco.y - taco.radius + 5, taco.radius, 10);
}
function update() {
  // AI movement
  taco.x += taco.dx;
  taco.y += taco.dy;
  // bounce
  if (taco.x - taco.radius < 0 || taco.x + taco.radius > canvas.width) taco.dx *= -1;
  if (taco.y - taco.radius < 0 || taco.y + taco.radius > canvas.height) taco.dy *= -1;
  // check catch: if taco reaches bottom center (serving zone)
  const servingZoneY = canvas.height - 80;
  const servingZoneX = canvas.width/2 - 50;
  const servingZoneWidth = 100;
  if (taco.y + taco.radius > servingZoneY) {
    if (taco.x > servingZoneX && taco.x < servingZoneX + servingZoneWidth) {
      // catch!
      score++;
      scoreEl.textContent = `Score: ${score}`;
      // reset taco
      taco.x = canvas.width/2;
      taco.y = canvas.height/2;
      taco.dx = 2 * (Math.random() > 0.5 ? 1 : -1);
      taco.dy = 2 * (Math.random() > 0.5 ? 1 : -1);
    }
  }
}
function render() {
  ctx.clearRect(0,0,canvas.width,canvas.height);
  drawTaco();
}
function loop() {
  update();
  render();
  requestAnimationFrame(loop);
}
overlay.addEventListener('click', startGame);
window.addEventListener('keydown', startGame);
function startGame() {
  overlay.classList.remove('active');
  // reset game
  taco.x = canvas.width/2;
  taco.y = canvas.height/2;
  taco.dx = 2 * (Math.random() > 0.5 ? 1 : -1);
  taco.dy = 2 * (Math.random() > 0.5 ? 1 : -1);
  score = 0;
  scoreEl.textContent = `Score: ${score}`;
  loop();
}
</script>
</body>
</html>

Check constraints:

- Single fenced code block with html. Yes.

- All inline CSS and JS. Yes.

- No external resources. No CDN.

- Responsive: canvas resizes to window size; overlay text scales? Not needed.

- Something visible on first paint: header, tagline, overlay message, canvas (blank). That's fine.

- Must adapt down to 375px: canvas will fill width; layout is centered.

- No horizontal scrollbar: we use full viewport; no fixed height causing scroll.

- Game starts in self-playing demo mode: after click, taco moves automatically (AI) bouncing around; the user can see movement.

- The overlay message appears initially, then disappears on click/keypress, revealing game.

- Zero console errors: ensure we don't have undefined variables. All good.

Potential issues: The overlay is positioned over canvas; clicking on overlay may not register if click passes through canvas? We set pointer-events:auto on overlay, but canvas also receives click events. The overlay is a div covering whole screen; clicking anywhere triggers startGame. That's fine.

But we need to ensure that after start, the overlay is removed (classList.remove('active')). That hides it.

Potential bug: The overlay has pointer-events:none initially, then active sets pointer-events:auto. So clicking will work.

Edge Cases: On mobile, click may not fire? But we also listen for keydown, which works.

Make sure the canvas is not hidden behind overlay after start: we remove active class, so overlay disappears.

All good.

Now produce final answer with exactly one fenced code block.