fix: report the swallowed fallback throw, and fix the vacuous slice

Delta review of the previous commit found four things.

The shim port's catch was empty, which hid dev-overlay bugs on that one
path. A throw out of an EventSource listener (the old shape) and out of the
SharedWorker path's onmessage ten lines below both reach the console, so
discarding it here was a new behaviour rather than the restored one the
comment claimed. It is reported now.

The slice meant to anchor that guard's assertion to the fallback function
ended at the bootstrap that follows it, so it still trailed a closing brace
plus `try {`, leaving the bootstrap's try inside the slice. The first
assertion therefore matched with the guard removed, and the comment
asserted a counterfactual that did not hold. The slice now ends at the
function's own closing brace, with an assertion that the bootstrap is
outside it, and each assertion was re-checked to fail with the guard gone.

The architecture page's Request Lifecycle said root middleware runs first
and put internal endpoints and static files after it. That was already
wrong for /__webjs/* before this PR, and the dev /public/* hoist widens it,
so two pages on the same site contradicted each other on the fact this PR
exists to correct.

The blog example's middleware comment wrote the brand as a lowercase code
token in prose, which invariant 11 does not allow.

Author: vivek7405

examples/blog/middleware.ts

@@ -1,5 +1,5 @@
 /**
- * Global middleware. Runs on every app request before webjs routes it.
+ * Global middleware. Runs on every app request before WebJs routes it.
  * Return a Response to short-circuit; call next() to continue.
  *
  * To add framework sessions:

packages/server/src/dev.js

@@ -3096,7 +3096,14 @@ function __webjsDirectEvents() {
     try {
       if (m.type === 'reload') __webjsReloadWhenReady();
       else if (m.type === 'webjs-error') __webjsApplyError(m.data);
-    } catch (_) { /* a bad frame must not cost this tab its live reload */ }
+    } catch (_) {
+      // Reported, never swallowed. Detachment is the only thing being
+      // prevented: a throw out of an EventSource listener (the old shape) and
+      // out of the SharedWorker path's onmessage below both surface to the
+      // console, so discarding it here would hide dev-overlay bugs on this one
+      // path, which would be a new behaviour rather than a restored one.
+      console.error('[webjs] dev reload handler threw', _);
+    }
   } }] });
 }
 try {

packages/server/test/dev/reload-shared-connection.test.js

@@ -58,16 +58,27 @@ test('dev serves the reload SharedWorker, and the client uses it with a direct E
   // Sliced to the fallback function's own body first. A regex over the whole
   // client matches the SharedWorker bootstrap's `try { ... } catch` further
   // down and passes with the guard removed, which is a test that observes
-  // nothing (found by running exactly that counterfactual).
+  // nothing.
+  //
+  // The slice must end at the function's OWN closing brace, not at the
+  // bootstrap that follows it: ending at `indexOf('if (typeof SharedWorker')`
+  // still trails `}\ntry {`, which leaves the bootstrap's `try` inside the
+  // slice and the first assertion below vacuous again. Verified by running the
+  // counterfactual against a reconstructed client: each of the three
+  // assertions below fails with the guard removed.
   const fallbackStart = clientSrc.indexOf('function __webjsDirectEvents()');
   assert.notEqual(fallbackStart, -1, 'the fallback function is in the client');
-  const fallbackBody = clientSrc.slice(fallbackStart, clientSrc.indexOf('if (typeof SharedWorker', fallbackStart));
+  const fallbackEnd = clientSrc.indexOf('\n}\n', fallbackStart);
+  assert.notEqual(fallbackEnd, -1, 'the fallback function closes');
+  const fallbackBody = clientSrc.slice(fallbackStart, fallbackEnd + 2);
+  assert.ok(!/if \(typeof SharedWorker/.test(fallbackBody), 'the slice stops before the bootstrap');
   assert.match(
     fallbackBody,
     /postMessage\(m\)\s*\{[^]*?try\s*\{/,
     'the shim port opens a try before running any application code',
   );
-  assert.match(fallbackBody, /\}\s*catch\s*\(_\)/, 'and swallows the throw so the relay cannot drop the tab');
+  assert.match(fallbackBody, /\}\s*catch\s*\(_\)/, 'and catches the throw so the relay cannot drop the tab');
+  assert.match(fallbackBody, /console\.error\(/, 'and reports it rather than discarding it');
   assert.ok(
     fallbackBody.indexOf('try {') < fallbackBody.indexOf('__webjsReloadWhenReady()'),
     'the guard opens BEFORE the reload call, not around something else',

website/app/docs/architecture/page.ts

@@ -103,9 +103,10 @@ import { listPosts } from '#modules/posts/queries/list-posts.server.ts';</code-b
     <h2>Request Lifecycle</h2>
     <ol>
       <li><strong>HTTP request arrives</strong> at the Node HTTP server (or HTTP/2 if TLS configured).</li>
-      <li><strong>Root middleware</strong> (<code>middleware.ts</code>) runs first if present.</li>
+      <li><strong>Framework-internal assets and probes</strong> (<code>/__webjs/*</code>: the core runtime, the dev reload client, downloaded vendor bundles, <code>/__webjs/health</code> and <code>/__webjs/ready</code>) are served here, ahead of everything below. They depend on neither the app analysis nor the vendor importmap, so a cold instance must not gate them. In <strong>development only</strong>, <code>/public/*</code> plus the <code>/sw.js</code> and <code>/offline.html</code> root remaps and <code>/favicon.ico</code> are served here too, so a stylesheet is never queued behind the startup analysis.</li>
+      <li><strong>Root middleware</strong> (<code>middleware.ts</code>) runs next if present, for every request that was not already answered above.</li>
       <li><strong>103 Early Hints</strong> sent (prod only) with modulepreload URLs for the matched page.</li>
-      <li><strong>Route matching</strong>: the router tries (in order) internal endpoints, static files, user source modules, API routes (<code>route.ts</code>), then page routes.</li>
+      <li><strong>Route matching</strong>: the router tries (in order) static files, user source modules, API routes (<code>route.ts</code>), then page routes. In production this is where <code>/public/*</code> is served, so a middleware that guards an asset still guards it.</li>
       <li><strong>Segment middleware</strong> chain runs (outermost → innermost) for the matched route.</li>
       <li>For <strong>pages</strong>: SSR pipeline runs (load page + layouts, render to HTML, inject DSD, collect metadata, stream response with Suspense).</li>
       <li>For <strong>API routes</strong>: the matched handler function runs, returns a Response.</li>