fix(hosting): serve Nuxt bare prerendered routes from S3 (frozen, no SSR)

The nitro adapter emitted only the subtree route (/about/*) for each
prerendered page, leaving the bare canonical URL (/about) to fall through
to the SSR Lambda — which re-rendered a prerender:true page on every
request, breaking the 'frozen, served from S3, no Lambda' contract.

The router's directory-index rewrite now appends /index.html to any
extensionless path, so a bare path resolves to builds/<id>/<route>/index.html
(exactly how Nuxt prerenders /about -> about/index.html). Emit BOTH the bare
route and its subtree as static for both the filesystem walk and the
routeRules prerender loop. Add a kvs_router regression test asserting
/myapp/about routes to S3 and rewrites to the frozen index.html.

Author: osama-rizk

packages/hosting/src/adapters/nitro.ts

@@ -1434,36 +1434,44 @@ const buildRoutes = (
       addRoute({ pattern, target: 'static' });
     }
 
-    // Walk for prerendered HTML pages and emit a *subtree* route for each.
+    // Walk for prerendered HTML pages and emit BOTH the bare route and its
+    // subtree as static → S3:
+    //   - `/<route>`   → so the canonical bare URL serves the FROZEN prerendered
+    //     HTML from S3 (the build-id rewrite's directory-index branch appends
+    //     `/index.html` to any extensionless path → `builds/{id}/<route>/index.html`,
+    //     which is exactly how Nuxt prerenders `/about` → `about/index.html`).
+    //   - `/<route>/*` → so sibling assets the framework prefetches
+    //     (`_payload.json`, etc.) also resolve from S3.
     //
-    // We deliberately do NOT emit a bare `/<route>` static route — the
-    // CloudFront build-ID rewrite Function only appends `index.html` when
-    // the URI ends with `/`, so `/about` would resolve to the S3 key
-    // `builds/{id}/about` (no such object → 403). Instead we route
-    // `/<route>/*` to S3 (so `_payload.json` and other sibling assets the
-    // framework prefetches resolve), and let the bare `/<route>` flow
-    // through the catch-all to the SSR Lambda, which re-renders the page
-    // from the bundled component on demand.
+    // (Historically only `/<route>/*` was emitted and bare `/<route>` fell
+    // through to the SSR Lambda — which re-rendered a `prerender: true` page on
+    // every request, breaking the "frozen, served from S3, no Lambda" contract.
+    // The router's directory-index rewrite now handles bare extensionless paths,
+    // so the bare route resolves correctly from S3.)
     for (const htmlFile of walkHtmlFiles(publicDir)) {
       const rel = path.relative(publicDir, htmlFile).replace(/\\/g, '/');
       const urlPath = htmlFileToUrlPath(rel);
       if (urlPath === '/') continue;
+      addRoute({ pattern: urlPath, target: 'static' });
       addRoute({ pattern: `${urlPath}/*`, target: 'static' });
     }
   }
 
   // Honour route rules with `prerender: true` even if the build hasn't
-  // emitted a file at that path yet. We emit the subtree pattern only
-  // (e.g. `/about/*` not bare `/about`) for the same reason the
-  // filesystem walk above does — the build-ID rewriter can't resolve a
-  // bare prerendered path to its index.html.
+  // emitted a file at that path yet. Emit BOTH the bare route and its subtree
+  // as static (the router's directory-index rewrite resolves the bare
+  // extensionless path to its `index.html` on S3 — see the filesystem walk
+  // above), so a `prerender: true` page is served frozen from S3 rather than
+  // re-rendered by the SSR Lambda.
   for (const [routePattern, rule] of Object.entries(routeRules)) {
     if (rule.prerender) {
       const normalized = normalizeRulePattern(routePattern);
-      const subtree = normalized.endsWith('/*')
-        ? normalized
-        : `${normalized}/*`;
-      addRoute({ pattern: subtree, target: 'static' });
+      if (normalized.endsWith('/*')) {
+        addRoute({ pattern: normalized, target: 'static' });
+      } else {
+        addRoute({ pattern: normalized, target: 'static' });
+        addRoute({ pattern: `${normalized}/*`, target: 'static' });
+      }
     }
   }
 

packages/hosting/src/constructs/kvs_router.test.ts

@@ -585,6 +585,38 @@ void describe('request fn — G8 directory-index (spa=0)', () => {
   });
 });
 
+void describe('request fn — bare prerendered route under basePath → S3 (Issue 1)', () => {
+  // Regression: a Nuxt `prerender: true` page (e.g. /about) under basePath
+  // /myapp must serve the FROZEN prerendered HTML from S3, not be re-rendered
+  // by the SSR Lambda. The adapter now emits a bare `/about` static route (+
+  // `/about/*`); the router strips basePath, classifies it static, and the
+  // directory-index branch resolves the extensionless bare path to
+  // /builds/<id>/about/index.html (how Nuxt prerenders it).
+  const entries = buildKvsEntries({
+    manifest: baseManifest({
+      basePath: '/myapp',
+      staticAssets: { directory: '/tmp', spaFallback: false },
+      routes: [
+        { pattern: '/about', target: 'static' },
+        { pattern: '/about/*', target: 'static' },
+        { pattern: '/*', target: 'compute' },
+      ],
+    }),
+    buildId: 'b1',
+    hasServer: true,
+    hasImage: false,
+  });
+  void it('routes bare /myapp/about to S3 + rewrites to the frozen index.html', async () => {
+    const { output, selectedOrigin } = await runRequestFn(
+      reqCode,
+      entries,
+      req('/myapp/about'),
+    );
+    assert.equal(selectedOrigin, ORIGIN_ID.s3);
+    assert.equal(output.uri, '/builds/b1/about/index.html');
+  });
+});
+
 void describe('request fn — G10 fail-open when meta is missing', () => {
   void it('returns the request unchanged (no origin selected) if KVS has no meta', async () => {
     const { output, selectedOrigin } = await runRequestFn(reqCode, {}, req('/x'));