fix(platform): install analog-owned SSR renderer to bypass Nitro auto-template

Nitro's resolveRendererOptions (nitro/dist/_chunks/nitro.mjs:296-311)
auto-detects index.html and installs renderer-template[.dev] as
renderer.handler. nitro/vite's configResolved branch that would
swap in its SSR-dispatch renderer only runs when both renderer.handler
and renderer.template are empty (nitro/dist/vite.mjs:574), which never
holds for a typical app with an index.html at root. Result: every
HTML request returns the raw template instead of routing through the
SSR service.

analogNitroPlugin now registers an explicit #analog/ssr-renderer
virtual in nitro.options.virtual and sets renderer.handler to it.
The handler short-circuits to the raw template when
x-analog-no-ssr is on the response (set by injectAnalogRouteRuleHeaders
from routeRules with ssr: false) and otherwise dispatches through
fetchViteEnv to the SSR service env.

The SSR-wrapper service entry keeps its own response shape; the
no-ssr request-header check stays in place as a defense-in-depth path.

Refs #2035

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: brandonroberts

packages/platform/src/lib/nitro/analog-nitro-plugin.ts

@@ -212,6 +212,21 @@ export function analogNitroPlugin(options: Options = {}): Plugin {
           }
         });
 
+        // Override Nitro's auto-detected template-serving renderer with one
+        // that routes HTML requests to our SSR service. Nitro's
+        // `resolveRendererOptions` finds `index.html` at the project root
+        // and installs `internal/routes/renderer-template[.dev]`, which
+        // just serves the raw template. nitro/vite's own SSR-routing
+        // renderer only auto-installs when both `renderer.handler` and
+        // `renderer.template` are empty (vite.mjs:574), which never holds
+        // for a typical app — so we install our own renderer virtual
+        // explicitly here.
+        nitro.options.virtual['#analog/ssr-renderer'] =
+          generateSsrRendererVirtual(readIndexHtml());
+        nitro.options.renderer ??= {};
+        nitro.options.renderer.handler = '#analog/ssr-renderer';
+        delete nitro.options.renderer.template;
+
         injectAnalogRouteRuleHeaders(nitro);
 
         await wirePrerender(nitro, options, context, apiPrefix);
@@ -231,10 +246,39 @@ export function analogNitroPlugin(options: Options = {}): Plugin {
   return plugin;
 }
 
+/**
+ * Builds the h3 handler installed as Nitro's `renderer.handler`. Short-circuits
+ * `ssr: false` routes to the raw client template; otherwise dispatches the
+ * request to the SSR service env (`fetchViteEnv("ssr", req)` works in dev via
+ * the env-runner and in prod via the `__nitro_vite_envs__` global set up by
+ * nitro/vite's `prodSetup`).
+ */
+function generateSsrRendererVirtual(template: string): string {
+  return `
+import { defineHandler } from 'nitro/h3';
+import { fetchViteEnv } from 'nitro/vite/runtime';
+
+const TEMPLATE = ${JSON.stringify(template)};
+
+export default defineHandler(async (event) => {
+  event.res.headers.set('content-type', 'text/html; charset=utf-8');
+  // 'x-analog-no-ssr' is stamped on response headers by
+  // injectAnalogRouteRuleHeaders for routeRules with \`ssr: false\`. Nitro
+  // applies routeRule headers to the response before the renderer fires,
+  // so we can short-circuit by reading them here.
+  if (event.res.headers.get('x-analog-no-ssr') === 'true') {
+    return TEMPLATE;
+  }
+  return fetchViteEnv('ssr', event.req);
+});
+`;
+}
+
 /**
  * Walks Nitro's resolved routeRules and stamps `x-analog-no-ssr: true` onto
- * any rule with `ssr: false`. Analog's SSR service wrapper reads this header
- * to short-circuit the renderer and return the raw template.
+ * any rule with `ssr: false`. Kept as a response-header hint for downstream
+ * consumers (CDN, edge logic); the actual SSR short-circuit happens inside
+ * the SSR renderer virtual above.
  */
 function injectAnalogRouteRuleHeaders(nitro: Nitro): void {
   const routeRules = nitro.options.routeRules as