fix(nextcompile): serve root-level public/ files (install.sh, robots.txt) from R2

The dispatcher only consulted R2 for /_next/static/* and /public/*
prefixed paths, but Next.js serves files in public/ at the bare root
and the packager uploads them keyed by basename. As a result every
root-level public asset 404'd on Cloudflare Workers deploys —
including /install.sh, which made the curl|bash one-liner advertised
in the README dead on arrival.

Add serveRootPublicFromR2 in serve.mjs (gated on paths whose final
segment contains a '.' so we don't spend an R2 GET on every typo'd
route) and call it from dispatcher.mjs after route dispatch fails but
before notFound. /install.sh, /install.bat, /daemon.sh, /robots.txt,
/favicon.ico, etc. now resolve via the public Cloudflare deploy.

Verified end-to-end: redeployed nextdeploy.org and confirmed
`curl -fsSL https://nextdeploy.org/install.sh | bash` now succeeds.

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

Author: aynaash

shared/nextcompile/runtime_src/dispatcher.mjs

@@ -12,7 +12,8 @@
 //   5. SSG routes — pre-rendered HTML from R2
 //   6. ISR routes — HTML from R2 (revalidation arrives with cache.mjs)
 //   7. Dynamic table — regex-matched routes, ordered by specificity
-//   8. 404
+//   8. Root-served public files (/install.sh, /robots.txt, …) from R2
+//   9. 404
 //
 // Every handler invocation is wrapped in an AsyncLocalStorage context so
 // Next's async cookies() / headers() / draftMode() resolve to per-request
@@ -23,7 +24,7 @@
 // without RSC fall through to the legacy default-export path (Pages
 // Router + simple App Router pages).
 
-import { serveStaticFromR2, serveSSGFromR2 } from "./serve.mjs";
+import { serveStaticFromR2, serveSSGFromR2, serveRootPublicFromR2 } from "./serve.mjs";
 import { matchDynamic, buildRouteContext } from "./route_match.mjs";
 import { notFound, serverError } from "./errors.mjs";
 import { runWithContext, createRequestContext } from "./context.mjs";
@@ -69,6 +70,9 @@ export async function dispatch(request, env, ctx, tables) {
     const routed = await tryRouteDispatch(request, env, ctx, url, pathname, tables);
     if (routed) return routed;
 
+    const publicRoot = await serveRootPublicFromR2(env, pathname);
+    if (publicRoot) return publicRoot;
+
     return notFound();
   } catch (err) {
     return serverError(err);

shared/nextcompile/runtime_src/serve.mjs

@@ -38,6 +38,32 @@ export async function serveStaticFromR2(env, pathname) {
   return new Response(obj.body, { headers });
 }
 
+/**
+ * Serve a public/* file requested at the bare root path (e.g.
+ * /install.sh, /robots.txt, /favicon.ico). Next serves public/ at the
+ * root, and the packager uploads those files to R2 keyed by their
+ * basename — so the request path minus the leading slash is the R2
+ * key. Restricted to paths whose final segment contains a "." to keep
+ * real 404s from spending an R2 GET each.
+ */
+export async function serveRootPublicFromR2(env, pathname) {
+  if (!env.ASSETS) return null;
+  if (pathname.length < 2 || pathname.endsWith("/")) return null;
+  const last = pathname.slice(pathname.lastIndexOf("/") + 1);
+  if (!last.includes(".")) return null;
+
+  const obj = await env.ASSETS.get(pathname.slice(1));
+  if (!obj) return null;
+
+  const headers = new Headers();
+  obj.writeHttpMetadata?.(headers);
+  if (obj.httpEtag) headers.set("etag", obj.httpEtag);
+  if (!headers.has("cache-control")) {
+    headers.set("cache-control", "public, max-age=300");
+  }
+  return new Response(obj.body, { headers });
+}
+
 /**
  * Serve a pre-rendered HTML file (SSG or ISR) from R2. The dispatcher
  * resolves the R2 key from manifest.routes.ssg/isr and passes it here.