@junejs/server 0.1.2 → 0.2.0

package/src/negotiate.ts

@@ -6,6 +6,7 @@
 // header — a link is unambiguous; Accept is a hint. The clean pathname (with
 // the projection extension stripped) is what the router matches.
 
+import { FRAGMENT_ACCEPT } from "@junejs/core/nav-protocol";
 import type { RenderTarget } from "@junejs/core/route";
 
 // The fragment media type + title header are the client-router wire protocol —
@@ -18,12 +19,43 @@ const EXT_TARGET: Record<string, RenderTarget> = {
   ".md": "md",
 };
 
-const ACCEPT_TARGET: Array<[test: RegExp, target: RenderTarget]> = [
-  // fragment first: its media type is exact + can't collide with browser Accepts.
-  [/text\/vnd\.june\.fragment\+html/, "fragment"],
-  [/text\/markdown/, "md"],
-  [/application\/json/, "json"],
-];
+// RFC 9110 §12.4.2 qvalue: 0–1 with at most three decimals ("0", "0.5", "1.000").
+const QVALUE = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/;
+
+// Parse an Accept header into media-range → q (RFC 9110 §12.5.1). A q outside the
+// qvalue grammar ("2", "-0.5", "0.1234") is malformed and reads as the default 1:
+// the client still listed the type, so it stays acceptable at the default weight
+// rather than being dropped or excluded. Parameters other than q are ignored.
+function acceptRanges(accept: string): Map<string, number> {
+  const ranges = new Map<string, number>();
+  for (const part of accept.split(",")) {
+    const [type, ...params] = part.split(";").map((s) => s.trim().toLowerCase());
+    if (!type) continue;
+    const raw = params.find((p) => p.startsWith("q="))?.slice(2).trim();
+    ranges.set(type, raw !== undefined && QVALUE.test(raw) ? Number(raw) : 1);
+  }
+  return ranges;
+}
+
+// The projection an Accept header asks for — null when it asks for none of the
+// agent projections (→ the HTML view). ONE decision shared by the pipeline and
+// the deployed worker's asset layer (withAssets), so the two can't disagree.
+//   - The client router's fragment media type (exact range, q > 0) wins outright.
+//   - Markdown / JSON are chosen when listed with q > 0 and at least as preferred
+//     as HTML; HTML's quality is text/html's, else the text/* or */* wildcard's.
+//     So `text/markdown, text/html;q=0.9` → md, `text/html, text/markdown;q=0.5`
+//     → HTML, and a plain browser Accept (no markdown/json) → HTML.
+//   - Ties go to the agent projection (md before json), as they always have.
+export function acceptTarget(accept: string): RenderTarget | null {
+  const ranges = acceptRanges(accept);
+  if ((ranges.get(FRAGMENT_ACCEPT) ?? 0) > 0) return "fragment";
+  const html = ranges.get("text/html") ?? ranges.get("text/*") ?? ranges.get("*/*") ?? 0;
+  const md = ranges.get("text/markdown") ?? 0;
+  const json = ranges.get("application/json") ?? 0;
+  const best = Math.max(md, json);
+  if (best <= 0 || best < html) return null;
+  return md >= json ? "md" : "json";
+}
 
 export type Negotiated = {
   target: RenderTarget;
@@ -61,15 +93,7 @@ export function negotiate(url: URL, request: Request, basePath?: string): Negoti
     pathname = original;
   }
 
-  if (!target) {
-    const accept = request.headers.get("accept") ?? "";
-    for (const [re, t] of ACCEPT_TARGET) {
-      if (re.test(accept)) {
-        target = t;
-        break;
-      }
-    }
-  }
+  if (!target) target = acceptTarget(request.headers.get("accept") ?? "");
 
   // A speculative request (Sec-Purpose: prefetch / prerender) may never be seen
   // — load()s read it to skip side effects (analytics, rate limits, counters).