feat: Fire after-response hooks inside the request scope

DispatchHandler stashes the rendered Response as an exchange attribute
so fireAfterHooks can pass the real response to global and per-request
hooks. resolveResponse falls back to synthesising a Response from
exchange headers/status on the error path. A try/finally around
runInnerChain ensures hooks fire even when exceptionHandler.handle
itself throws.

Author: thced

src/main/java/com/retailsvc/http/Request.java

@@ -336,8 +336,8 @@ public void afterResponse(Runnable runnable) {
     afterHooks.add(runnable);
   }
 
-  /** Package-private accessor for the after-hook queue; used by RequestPreparationFilter. */
-  List<Runnable> afterHooks() {
+  /** Internal accessor for the after-hook queue; used by RequestPreparationFilter. */
+  public List<Runnable> afterHooks() {
     return afterHooks;
   }
 

src/main/java/com/retailsvc/http/internal/DispatchHandler.java

@@ -15,6 +15,7 @@
 public final class DispatchHandler implements HttpHandler {
 
   public static final ScopedValue<Request> CURRENT = ScopedValue.newInstance();
+  public static final String RESPONSE_ATTR = "com.retailsvc.http.response";
 
   private final Map<String, RequestHandler> handlers;
   private final List<RequestInterceptor> interceptors;
@@ -43,6 +44,7 @@ public void handle(HttpExchange exchange) throws IOException {
     for (ResponseDecorator decorator : decorators) {
       response = decorator.decorate(request, response);
     }
+    exchange.setAttribute(RESPONSE_ATTR, response);
     renderer.render(exchange, response);
   }
 

src/main/java/com/retailsvc/http/internal/RequestPreparationFilter.java

@@ -17,9 +17,11 @@
 import com.retailsvc.http.validate.ValidationError;
 import com.retailsvc.http.validate.Validator;
 import com.sun.net.httpserver.Filter;
+import com.sun.net.httpserver.Headers;
 import com.sun.net.httpserver.HttpExchange;
 import java.io.IOException;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -78,8 +80,11 @@ public void doFilter(HttpExchange exchange, Chain chain) throws IOException {
       ScopedValue.where(DispatchHandler.CURRENT, request)
           .call(
               () -> {
-                runInnerChain(exchange, chain);
-                fireAfterHooks(exchange, request);
+                try {
+                  runInnerChain(exchange, chain);
+                } finally {
+                  fireAfterHooks(exchange, request);
+                }
                 return null;
               });
     } catch (IOException | RuntimeException e) {
@@ -132,7 +137,42 @@ private void runInnerChain(HttpExchange exchange, Chain chain) throws IOExceptio
   }
 
   private void fireAfterHooks(HttpExchange exchange, Request request) {
-    // implemented in Task 5
+    Response response = resolveResponse(exchange);
+    List<Runnable> snapshot = List.copyOf(request.afterHooks());
+
+    for (AfterResponseHook hook : afterHooks) {
+      try {
+        hook.after(request, response);
+      } catch (Throwable t) {
+        LOG.debug("after-response hook threw", t);
+      }
+    }
+    for (Runnable runnable : snapshot) {
+      try {
+        runnable.run();
+      } catch (Throwable t) {
+        LOG.debug("after-response runnable threw", t);
+      }
+    }
+  }
+
+  private static Response resolveResponse(HttpExchange exchange) {
+    Object stashed = exchange.getAttribute(DispatchHandler.RESPONSE_ATTR);
+    if (stashed instanceof Response r) {
+      return r;
+    }
+    Headers headers = exchange.getResponseHeaders();
+    String contentType = headers != null ? headers.getFirst("Content-Type") : null;
+    Map<String, String> flat = new LinkedHashMap<>();
+    if (headers != null) {
+      for (Map.Entry<String, List<String>> e : headers.entrySet()) {
+        List<String> values = e.getValue();
+        if (values != null && !values.isEmpty()) {
+          flat.put(e.getKey(), values.get(0));
+        }
+      }
+    }
+    return new Response(exchange.getResponseCode(), null, contentType, flat);
   }
 
   private String stripBasePath(String path) {