test(hono): keep the raw-mount pin's Hono handlers never-returning, add the changeset

A Hono handler may not return `void`, and only a body whose statement IS the
`throw` infers `never` — so each door throws a value a factory hands back
instead of calling a shared throwing helper.

Claude-Session: https://claude.ai/code/session_01TSf4DV7ziu4V5j73e46b7c
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

.changeset/raw-mount-declared-envelope.md

@@ -0,0 +1,9 @@
+---
+'@objectstack/plugin-hono-server': patch
+---
+
+**`getRawApp()` mounts now answer an escaped throw with the declared ADR-0112 envelope.** A route mounted on the Hono handle funnels through neither the adapter's `wrap()` nor any registrar wrapper, so an escaped throw was answered by Hono's own default handler — `500 text/plain "Internal Server Error"`, no `success` flag, no `code`, and the thrown value's own declared `status` / `code` discarded. A transport error seam on the raw handle now renders the same throw-to-envelope rule a direct-mount route already used, so both doors answer one shape: a throw declaring `503` / `SERVICE_UNAVAILABLE` answers `503 application/json` with `{"success":false,"error":{"code":"SERVICE_UNAVAILABLE",…}}`, and a throw declaring no envelope still answers `500` with no cause in the body.
+
+The escape hatch is unchanged: consumers still mount framework-natively, still stay outside `getMountedRoutes()`, and still need no adapter verb. A thrown value carrying its own `Response` (Hono's `HTTPException`) keeps the response it declared. A consumer that installs its own `getRawApp().onError(...)` replaces the seam.
+
+Also fixed alongside it: `afterResponse` observers — and therefore `http_requests_total{status}` — reported a hard-coded `500` for any request that ended in a throw, which stops being the status actually sent once a declared envelope is rendered.

packages/plugins/plugin-hono-server/src/raw-mount-declared-envelope.test.ts

@@ -77,17 +77,17 @@ function declared(status: number, code: string, message: string) {
  */
 function fourDoors(logger?: Logger): HonoHttpServer {
     const s = server(logger);
-    const envelopeThrow = () => {
-        throw declared(503, 'SERVICE_UNAVAILABLE', 'The authorization store could not be read.');
-    };
-    const plainThrow = () => {
-        throw new Error('connect ECONNREFUSED 127.0.0.1:5432');
-    };
-
-    s.getRawApp().get('/raw/envelope', () => { envelopeThrow(); });
-    s.getRawApp().get('/raw/plain', () => { plainThrow(); });
-    s.get('/wrapped/envelope', async () => { envelopeThrow(); });
-    s.get('/wrapped/plain', async () => { plainThrow(); });
+    // The two throws are built by a factory and thrown AT each door, rather
+    // than thrown inside a shared helper: a Hono handler must not return
+    // `void`, and only a body whose statement IS the `throw` infers `never`.
+    const envelopeError = () =>
+        declared(503, 'SERVICE_UNAVAILABLE', 'The authorization store could not be read.');
+    const plainError = () => new Error('connect ECONNREFUSED 127.0.0.1:5432');
+
+    s.getRawApp().get('/raw/envelope', () => { throw envelopeError(); });
+    s.getRawApp().get('/raw/plain', () => { throw plainError(); });
+    s.get('/wrapped/envelope', async () => { throw envelopeError(); });
+    s.get('/wrapped/plain', async () => { throw plainError(); });
     return s;
 }
 
@@ -181,14 +181,13 @@ describe('the raw door reads the ONE rule, not a second one', () => {
         const s = server();
         // `plugin-approvals`' lifecycle hooks and `metadata-protocol` throw
         // `statusCode`; both spellings are produced in this repo.
-        const thrower = () => {
-            throw Object.assign(new Error('locked by another process'), {
+        const conflict = () =>
+            Object.assign(new Error('locked by another process'), {
                 statusCode: 409,
                 code: 'LOCK_CONFLICT',
             });
-        };
-        s.getRawApp().get('/raw/conflict', () => { thrower(); });
-        s.get('/wrapped/conflict', async () => { thrower(); });
+        s.getRawApp().get('/raw/conflict', () => { throw conflict(); });
+        s.get('/wrapped/conflict', async () => { throw conflict(); });
 
         const raw = await call(s, '/raw/conflict');
         const wrapped = await call(s, '/wrapped/conflict');
@@ -204,11 +203,10 @@ describe('the raw door reads the ONE rule, not a second one', () => {
         // declaration (#16545 recorded this as its widest limb), so a bare
         // ValidationError answers 400/VALIDATION_FAILED at BOTH doors rather
         // than the raw door inventing its own rule.
-        const thrower = () => {
-            throw Object.assign(new Error('name is required'), { name: 'ValidationError' });
-        };
-        s.getRawApp().get('/raw/invalid', () => { thrower(); });
-        s.get('/wrapped/invalid', async () => { thrower(); });
+        const invalid = () =>
+            Object.assign(new Error('name is required'), { name: 'ValidationError' });
+        s.getRawApp().get('/raw/invalid', () => { throw invalid(); });
+        s.get('/wrapped/invalid', async () => { throw invalid(); });
 
         const raw = await call(s, '/raw/invalid');
         const wrapped = await call(s, '/wrapped/invalid');