@schmock/core 2.4.1 → 2.6.0

package/dist/interceptor.js

@@ -1,15 +1,36 @@
 /// <reference path="../schmock.d.ts" />
 import { awaitWithAbort, throwIfAborted } from "./abort.js";
-import { isBinaryBody } from "./binary.js";
-import { canonicalizePath, getResponseException, isRouteNotFound, toHttpMethod, } from "./constants.js";
-import { normalizeResponse, serializeResponseBody, } from "./response-normalizer.js";
+import { canonicalizePath, getResponseException, isHttpMethod, isRouteNotFound, matchPathPrefix, parsePathPrefix, } from "./constants.js";
+import { buildFormattedErrorResponse, buildJsonErrorResponse, normalizeResponse, serializeResponseBody, withDefaultContentType, } from "./response-normalizer.js";
+import { snapshotRequestBody } from "./snapshot.js";
 const PASSTHROUGH = Symbol("schmock.fetch.passthrough");
-// A lease whose baseUrl filter rejected the request never reached its handler.
-// It is distinct from PASSTHROUGH so the dispatch loop can tell "this owner
-// already ran" from "this lease was not interested in the request at all".
+// A lease whose baseUrl filter rejected the request never reached its handler:
+// it was not interested in the request at all, and claimed nothing.
 const FILTERED = Symbol("schmock.fetch.filtered");
+// A newer lease of the same mock already asked it this exact request, so
+// asking again would only repeat the answer and its lifecycle events.
+const ALREADY_CONSULTED = Symbol("schmock.fetch.already-consulted");
 const RELATIVE_REQUEST_BASE = "http://schmock.invalid/";
+/**
+ * Marks an admission whose `handle()` already returns responses normalized
+ * for the request method (hop-by-hop headers dropped, a HEAD body stripped):
+ * only the admissions a `schmock()` instance of this copy creates. The
+ * interceptor re-normalizes the responses of any other admission, such as a
+ * hand-written one passed to `createFetchInterceptor`. Deliberately
+ * unregistered: an admission from a second copy of `@schmock/core` is simply
+ * normalized again.
+ */
+export const NORMALIZED_ADMISSION_KEY = Symbol("schmock.normalized-admission");
+function isNormalizedAdmission(admission) {
+    return (admission !== undefined &&
+        Reflect.get(admission, NORMALIZED_ADMISSION_KEY) === true);
+}
 let activeSession;
+/**
+ * Holds taken through acquireFetchRelay(). Module-wide rather than per
+ * session, so a dispatcher that a third-party wrapper captured obeys them too.
+ */
+const fetchRelayHolds = new Set();
 function getRelativeRequestBase() {
     const candidates = [
         typeof document === "undefined" ? undefined : document.baseURI,
@@ -96,45 +117,101 @@ function normalizeFetchRequest(input, init) {
         origin,
     };
 }
+/**
+ * Whether `error` is the signal's own abort. An abort that lands after the
+ * lease already rejected with another error leaves that error the outcome.
+ */
+function isAbortOf(signal, error) {
+    if (!signal.aborted)
+        return false;
+    if ("reason" in signal && signal.reason !== undefined) {
+        return error === signal.reason;
+    }
+    return error instanceof Error && error.name === "AbortError";
+}
+async function routeThroughLeases(leases, normalizedRequest, startTime) {
+    const { signal } = normalizedRequest.request;
+    throwIfAborted(signal);
+    // A mock is asked each distinct effective request at most once, however
+    // many leases it holds: without this, nested providers on one mock would
+    // run handle() — and emit request:start/notfound/end — once per lease.
+    // The key is the request each lease would issue after its own baseUrl
+    // filter and beforeRequest, so an older lease whose hook rewrites the
+    // request (an outer provider stripping "/api") still gets its turn.
+    const consultedRequests = new Map();
+    const claimFor = (owner) => (requestKey) => {
+        if (owner === undefined)
+            return true;
+        let keys = consultedRequests.get(owner);
+        if (keys === undefined) {
+            keys = new Set();
+            consultedRequests.set(owner, keys);
+        }
+        if (keys.has(requestKey))
+            return false;
+        keys.add(requestKey);
+        return true;
+    };
+    for (let index = leases.length - 1; index >= 0; index -= 1) {
+        const registered = leases[index];
+        // Synchronously before the call: the handler admits before its first await,
+        // so the generation the opener captures is the one the request runs in.
+        const observe = registered.observe?.();
+        const draft = { observed: observe !== undefined };
+        let result;
+        try {
+            result = await awaitWithAbort(registered.intercept({
+                request: normalizedRequest,
+                claim: claimFor(registered.owner),
+                draft,
+            }), signal);
+            throwIfAborted(signal);
+        }
+        catch (error) {
+            if (observe !== undefined) {
+                if (!isAbortOf(signal, error)) {
+                    notify(observe, () => failedExchange(normalizedRequest, draft, error, startTime));
+                }
+                else if (draft.response !== undefined || draft.answers?.() === true) {
+                    notify(observe, () => abortedExchange(normalizedRequest, draft, startTime));
+                }
+            }
+            throw error;
+        }
+        // FILTERED: this lease was not interested, so a sibling lease may be.
+        // ALREADY_CONSULTED: the mock already answered this exact request.
+        // PASSTHROUGH: the mock has no route for it. All three move on.
+        if (result === FILTERED ||
+            result === ALREADY_CONSULTED ||
+            result === PASSTHROUGH) {
+            continue;
+        }
+        const response = result;
+        if (observe !== undefined) {
+            notify(observe, () => answeredExchange(normalizedRequest, draft, response, startTime));
+        }
+        return response;
+    }
+    return PASSTHROUGH;
+}
 function createInterceptorSession() {
     const baselineFetch = globalThis.fetch;
     const interceptors = [];
     const dispatchFetch = async (input, init) => {
         const snapshot = interceptors.slice();
-        if (snapshot.length === 0) {
+        if (snapshot.length === 0 || fetchRelayHolds.size > 0) {
             return baselineFetch(input, init);
         }
+        const startTime = performance.now();
         const normalizedRequest = normalizeFetchRequest(input, init);
-        throwIfAborted(normalizedRequest.request.signal);
-        // A mock is consulted at most once per request, however many leases it
-        // holds: without this, nested providers on one mock would run handle()
-        // — and emit request:start/notfound/end — once per lease.
-        const consultedOwners = new Set();
-        for (let index = snapshot.length - 1; index >= 0; index -= 1) {
-            const registered = snapshot[index];
-            const { owner } = registered;
-            if (owner !== undefined && consultedOwners.has(owner)) {
-                continue;
-            }
-            const result = await awaitWithAbort(registered.intercept(normalizedRequest), normalizedRequest.request.signal);
-            throwIfAborted(normalizedRequest.request.signal);
-            // The lease filtered the request out before admission, so its owner
-            // keeps its turn — a sibling lease may carry a matching baseUrl.
-            if (result === FILTERED) {
-                continue;
-            }
-            if (result !== PASSTHROUGH) {
-                return result;
-            }
-            if (owner !== undefined) {
-                consultedOwners.add(owner);
-            }
-        }
+        const answer = await routeThroughLeases(snapshot, normalizedRequest, startTime);
+        if (answer !== PASSTHROUGH)
+            return answer;
         return awaitWithAbort(baselineFetch(normalizedRequest.request), normalizedRequest.request.signal);
     };
     return { baselineFetch, dispatchFetch, interceptors };
 }
-function registerInterceptor(intercept, applyOptions, owner) {
+function registerInterceptor(intercept, applyOptions, owner, observe) {
     let session = activeSession;
     if (!session || globalThis.fetch !== session.dispatchFetch) {
         session = createInterceptorSession();
@@ -142,7 +219,7 @@ function registerInterceptor(intercept, applyOptions, owner) {
         globalThis.fetch = session.dispatchFetch;
     }
     const token = Symbol("schmock.fetch.interceptor");
-    session.interceptors.push({ token, owner, intercept });
+    session.interceptors.push({ token, owner, intercept, observe });
     let active = true;
     return {
         restore() {
@@ -177,57 +254,124 @@ function registerInterceptor(intercept, applyOptions, owner) {
     };
 }
 /**
- * Parse the user-supplied baseUrl option into its origin and path parts.
- * - "/api"                  → { origin: null, path: "/api" }
- * - "https://x.com/api/v1"  → { origin: "https://x.com", path: "/api/v1" }
- * - "https://x.com"         → { origin: "https://x.com", path: "" }
- *
- * Trailing slash is stripped from the path so the segment-boundary check
- * works the same way for "/api" and "/api/".
+ * Makes every intercepted fetch skip routing and go straight to the baseline
+ * until released. Holds stack: fetches resume once every hold is released.
+ * It never touches `globalThis.fetch`.
  */
-function parseBaseUrl(baseUrl) {
-    if (baseUrl.includes("://")) {
-        try {
-            const parsed = new URL(baseUrl);
-            const canonicalPath = canonicalizePath(parsed.pathname);
-            const path = canonicalPath === "/" ? "" : canonicalPath.replace(/\/$/, "");
-            return { origin: parsed.origin, path };
-        }
-        catch {
-            // Fall through to path-only handling
-        }
-    }
-    const canonicalPath = canonicalizePath(baseUrl);
-    const path = canonicalPath === "/" ? "" : canonicalPath.replace(/\/$/, "");
-    return { origin: null, path };
+export function acquireFetchRelay() {
+    const token = Symbol("schmock.fetch.relay");
+    fetchRelayHolds.add(token);
+    return {
+        release() {
+            fetchRelayHolds.delete(token);
+        },
+        get active() {
+            return fetchRelayHolds.has(token);
+        },
+    };
+}
+/**
+ * Routes a request that a service worker relayed to the page through the
+ * newest session's leases. Resolves `undefined` when nothing answers it (no
+ * lease, or a route miss with passthrough) and never calls the baseline fetch,
+ * so the caller decides how the request reaches the network. Rejects with the
+ * request's abort reason when it is aborted mid-route.
+ */
+export async function routeRelayedRequest(request) {
+    const startTime = performance.now();
+    const leases = activeSession?.interceptors.slice() ?? [];
+    if (leases.length === 0)
+        return undefined;
+    const normalizedRequest = normalizeFetchRequest(request);
+    const answer = await routeThroughLeases(leases, normalizedRequest, startTime);
+    return answer === PASSTHROUGH ? undefined : answer;
 }
 function extractQuery(url) {
     return Object.fromEntries(url.searchParams);
 }
-function extractHeaders(request) {
-    const headers = {};
-    request.headers.forEach((value, key) => {
-        headers[key.toLowerCase()] = value;
+function headerRecordOf(headers) {
+    const record = {};
+    headers.forEach((value, key) => {
+        record[key.toLowerCase()] = value;
     });
-    return headers;
+    return record;
+}
+function extractHeaders(request) {
+    return headerRecordOf(request.headers);
+}
+/** Hand an exchange to its observer. */
+function notify(observe, build) {
+    try {
+        observe(build());
+    }
+    catch {
+        // observation never changes the fetch outcome
+    }
+}
+function exchangeRequestOf({ request, url }, draft) {
+    return {
+        method: request.method,
+        url: responseUrlOf(url),
+        headers: extractHeaders(request),
+        ...(draft.requestBody !== undefined ? { body: draft.requestBody } : {}),
+    };
+}
+function answeredExchange(normalizedRequest, draft, response, startTime) {
+    return {
+        outcome: "answered",
+        request: exchangeRequestOf(normalizedRequest, draft),
+        response: {
+            status: response.status,
+            headers: headerRecordOf(response.headers),
+            ...(draft.response?.body !== undefined
+                ? { body: draft.response.body }
+                : {}),
+        },
+        startTime,
+        endTime: performance.now(),
+    };
+}
+function failedExchange(normalizedRequest, draft, error, startTime) {
+    return {
+        outcome: "failed",
+        request: exchangeRequestOf(normalizedRequest, draft),
+        error,
+        startTime,
+        endTime: performance.now(),
+    };
+}
+function abortedExchange(normalizedRequest, draft, startTime) {
+    return {
+        outcome: "aborted",
+        request: exchangeRequestOf(normalizedRequest, draft),
+        startTime,
+        endTime: performance.now(),
+    };
 }
 function normalizeMediaType(contentType) {
     return contentType?.split(";", 1)[0].trim().toLowerCase() ?? "";
 }
 async function extractBody(request) {
     if (request.body === null)
-        return undefined;
-    const body = request.clone();
+        return { value: undefined, malformedJson: false };
     const mediaType = normalizeMediaType(request.headers.get("content-type"));
-    if (mediaType === "application/json" || mediaType.endsWith("+json")) {
-        const text = await body.text();
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return text;
-        }
+    if (mediaType !== "application/json" && !mediaType.endsWith("+json")) {
+        return { value: await extractNonJsonBody(request), malformedJson: false };
     }
+    const text = await request.clone().text();
+    // An empty JSON body is no body at all, as the Node ingress reads it.
+    if (text === "")
+        return { value: undefined, malformedJson: false };
+    try {
+        return { value: JSON.parse(text), malformedJson: false };
+    }
+    catch {
+        return { value: text, malformedJson: true };
+    }
+}
+async function extractNonJsonBody(request) {
+    const body = request.clone();
+    const mediaType = normalizeMediaType(request.headers.get("content-type"));
     if (mediaType === "application/x-www-form-urlencoded") {
         return Object.fromEntries(new URLSearchParams(await body.text()));
     }
@@ -239,106 +383,118 @@ async function extractBody(request) {
     }
     return body.arrayBuffer();
 }
+/** An admission's route probe (`hasRoute`), when it carries one. */
+function routeProbeOf(admission) {
+    if (admission === undefined)
+        return undefined;
+    let probe;
+    try {
+        probe = Reflect.get(admission, "hasRoute");
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof probe !== "function")
+        return undefined;
+    // Anything but a definite `false` counts as a route, so an unexpected
+    // answer, or a throw, only costs the body read the probe would have saved.
+    return (method, path) => {
+        try {
+            return Reflect.apply(probe, admission, [method, path]) !== false;
+        }
+        catch {
+            return true;
+        }
+    };
+}
 function isAbortError(error) {
     return (typeof error === "object" &&
         error !== null &&
         "name" in error &&
         error.name === "AbortError");
 }
-function toFetchResponse(response, method) {
-    const headers = { ...response.headers };
-    const hasContentType = Object.keys(headers).some((name) => name.toLowerCase() === "content-type");
-    if (!hasContentType &&
-        response.body !== null &&
-        response.body !== undefined) {
-        if (isBinaryBody(response.body)) {
-            headers["content-type"] = "application/octet-stream";
-        }
-        else if (typeof response.body !== "string") {
-            headers["content-type"] = "application/json";
-        }
-    }
-    const normalized = normalizeResponse({ ...response, headers }, method);
-    return new Response(serializeResponseBody(normalized) ?? null, {
+/**
+ * Build the fetch Response from an already-normalized Schmock response.
+ */
+function createFetchResponse(normalized, context) {
+    const response = new Response(serializeResponseBody(normalized) ?? null, {
         status: normalized.status,
         headers: normalized.headers,
     });
+    // A constructed Response has an empty url. Real fetch reports the request
+    // URL, and code resolving links with `new URL(next, res.url)` needs it.
+    Object.defineProperty(response, "url", { value: context.url });
+    context.draft.response = normalized;
+    return response;
+}
+function toFetchResponse(response, context) {
+    return createFetchResponse(normalizeResponse(withDefaultContentType(response), context.method), context);
+}
+function jsonErrorResponse(input) {
+    return createFetchResponse(buildJsonErrorResponse({
+        status: input.status,
+        error: input.error,
+        code: input.code,
+        method: input.context.method,
+    }), input.context);
 }
 /**
- * Formatted error bodies are always JSON, so the replaced response's own
- * content type must be dropped rather than inherited. Every case variant goes
- * first: leaving a `Content-Type` beside the forced lowercase key makes the
- * pair transport-invalid and the normalizer rejects it.
+ * A request this lease owns but cannot route: pass it on, or answer the same
+ * 404 a route miss gets when passthrough is off.
  */
-function withJsonContentType(headers) {
-    const result = {};
-    for (const [name, value] of Object.entries(headers ?? {})) {
-        if (name.toLowerCase() === "content-type")
-            continue;
-        result[name] = value;
-    }
-    result["content-type"] = "application/json";
-    return result;
+function unroutedResult(passthrough, context) {
+    if (passthrough)
+        return PASSTHROUGH;
+    return jsonErrorResponse({
+        status: 404,
+        error: "No matching mock route found",
+        code: "ROUTE_NOT_FOUND",
+        context,
+    });
 }
 /**
- * Invoke the errorFormatter for a core-marked exception and build its
- * response, falling back to a minimal safe body when the formatter throws or
- * its result is not serializable.
- *
- * This helper is TOTAL — it never throws. It runs inside the interceptor's
- * `try`, so an escaping error would land in the catch below and invoke the
- * formatter a second time; the re-entrancy is exactly the defect the Express
- * adapter's `sendFormattedError` was shaped to avoid.
- *
- * `responseHeaders` carries the (post-hook) headers of the response being
- * replaced so metadata such as `retry-after` survives. There are two distinct
- * fallbacks. When the inherited headers are untransportable, the send is
- * retried once with the fixed JSON header set and the SAME formatted body —
- * nothing is on the wire yet, and losing the body would silently change the
- * user's error contract. Only a failure of the formatter itself, or of its
- * body, reaches the minimal fallback, which deliberately inherits nothing.
+ * The fetch Response for an errorFormatter result, built by the shared
+ * {@link buildFormattedErrorResponse}. TOTAL: it never throws, and the
+ * formatter runs exactly once. It runs inside the interceptor's `try`, so an
+ * escaping error would land in the catch below and invoke the formatter a
+ * second time.
  */
-function formatInterceptedError(errorFormatter, error, responseHeaders, method) {
-    try {
-        const formatted = errorFormatter(error);
-        try {
-            return toFetchResponse({
-                status: 500,
-                body: formatted,
-                headers: withJsonContentType(responseHeaders),
-            }, method);
-        }
-        catch {
-            // `formatted` is reused, so the formatter still fires exactly once.
-            return toFetchResponse({
-                status: 500,
-                body: formatted,
-                headers: { "content-type": "application/json" },
-            }, method);
-        }
-    }
-    catch {
-        return toFetchResponse({
-            status: 500,
-            body: { error: "Internal Server Error", code: "INTERNAL_ERROR" },
-            headers: { "content-type": "application/json" },
-        }, method);
-    }
+function formattedErrorResponse(input) {
+    return createFetchResponse(buildFormattedErrorResponse({
+        formatter: input.formatter,
+        error: input.error,
+        inheritedHeaders: input.responseHeaders,
+        method: input.context.method,
+    }), input.context);
+}
+/** Fetch reports the request URL without its fragment. */
+function responseUrlOf(url) {
+    const responseUrl = new URL(url.href);
+    responseUrl.hash = "";
+    return responseUrl.href;
+}
+function effectiveRequestKey(method, path) {
+    return `${method} ${canonicalizePath(path)}`;
 }
 /**
  * Create a fetch interceptor that routes requests through mock.handle().
  *
- * `owner` identifies the mock behind the lease. Leases sharing an owner are
- * consulted at most once per request, so a mock held by several leases runs
- * its handler — and emits its lifecycle events — once per network request.
+ * `owner` identifies the mock behind the lease. Leases sharing an owner ask it
+ * each distinct effective request (method and path after the lease's own
+ * beforeRequest) at most once, so a mock held by several leases runs its
+ * handler — and emits its lifecycle events — once per request it is asked.
  */
 export function createFetchInterceptor(handle, options = {}, admitRequest, owner) {
+    return createFetchLease({ handle, options, admitRequest, owner });
+}
+export function createFetchLease(spec) {
+    const { handle, admitRequest, owner, observe } = spec;
     // The options live in a mutable cell that each request reads once at its
     // start. Reconfiguring a lease in place is what lets an adapter apply new
     // hooks without re-registering — re-registration would move the lease to the
     // front of the dispatch order and steal precedence from other mocks.
-    let currentOptions = options;
-    return registerInterceptor(async ({ request, url, origin }) => {
+    let currentOptions = spec.options ?? {};
+    return registerInterceptor(async ({ request: { request, url, origin }, claim, draft, }) => {
         const { baseUrl, passthrough = true, beforeRequest, beforeResponse, errorFormatter, } = currentOptions;
         const path = canonicalizePath(url.pathname);
         // BaseUrl filter — non-matching requests go straight to real fetch.
@@ -348,32 +504,83 @@ export function createFetchInterceptor(handle, options = {}, admitRequest, owner
         //   - path form ("/api"): match pathname prefix only.
         // Both enforce a segment boundary so "/api" doesn't match "/apiv2".
         if (baseUrl) {
-            const { origin: baseOrigin, path: basePath } = parseBaseUrl(baseUrl);
-            if (baseOrigin && origin !== baseOrigin) {
+            const base = parsePathPrefix(baseUrl);
+            if (base.origin && origin !== base.origin) {
                 return FILTERED;
             }
-            if (basePath) {
-                const isMatch = path === basePath || path.startsWith(`${basePath}/`);
-                if (!isMatch) {
-                    return FILTERED;
-                }
+            if (!matchPathPrefix(base, path)) {
+                return FILTERED;
             }
         }
         throwIfAborted(request.signal);
-        const initialMethod = toHttpMethod(request.method);
+        const context = {
+            method: request.method,
+            url: responseUrlOf(url),
+            draft,
+        };
+        const initialMethod = request.method.toUpperCase();
+        // Without a beforeRequest hook (which may change the method or path)
+        // the effective request is already known, so it is claimed before this
+        // lease can answer anything: once a newer lease of the same mock has
+        // passed it through, an older passthrough:false lease must not answer
+        // it with a 404 or a malformed-JSON 400. A lease with a hook claims only
+        // after the hook, so its own 400 for a malformed JSON body (which comes
+        // before the hook) still answers.
+        if (beforeRequest === undefined &&
+            !claim(effectiveRequestKey(initialMethod, path))) {
+            return ALREADY_CONSULTED;
+        }
+        // No route can ever match a method outside the supported set (WebDAV's
+        // PROPFIND, a CDN PURGE), so it is a miss like any other rather than a
+        // rejected fetch. Checked before admission, which it never needs.
+        if (!isHttpMethod(initialMethod)) {
+            return unroutedResult(passthrough, context);
+        }
+        context.method = initialMethod;
         const admission = admitRequest?.();
         const admittedHandle = admission?.handle ?? handle;
-        let effectiveMethod = initialMethod;
+        // Without a beforeRequest hook (which receives the body and may change
+        // the method or path), the request handle() will see is already known,
+        // so a passthrough lease asks the admission whether any route answers
+        // it. On a definite miss the body is never read: the request reaches
+        // the network untouched, and handle() still runs, without a body, so
+        // request:start/notfound/end are emitted exactly as before.
+        const routeExists = routeProbeOf(admission);
+        const answersFor = (method, routedPath) => () => !passthrough ||
+            routeExists === undefined ||
+            routeExists(method, routedPath);
+        if (beforeRequest === undefined)
+            draft.answers = answersFor(initialMethod, path);
+        const routeProbe = passthrough && !beforeRequest ? routeExists : undefined;
+        // The request handed to errorFormatter: the latest one this lease built,
+        // so it reflects beforeRequest once that hook has returned.
+        let formatterRequest;
         try {
-            const body = await awaitWithAbort(extractBody(request), request.signal);
+            const body = routeProbe !== undefined && !routeProbe(initialMethod, path)
+                ? { value: undefined, malformedJson: false }
+                : await awaitWithAbort(extractBody(request), request.signal);
+            if (draft.observed)
+                draft.requestBody = snapshotRequestBody(body.value);
             throwIfAborted(request.signal);
+            // With passthrough off the lease owns every request that reaches it,
+            // as the Node server does, so a JSON body that does not parse gets
+            // the server's 400 before any route runs or history records it.
+            if (body.malformedJson && !passthrough) {
+                return jsonErrorResponse({
+                    status: 400,
+                    error: "Malformed JSON request body",
+                    code: "MALFORMED_JSON",
+                    context,
+                });
+            }
             let adapterRequest = {
                 method: request.method,
                 path,
                 headers: extractHeaders(request),
-                body,
+                body: body.value,
                 query: extractQuery(url),
             };
+            formatterRequest = adapterRequest;
             // Apply beforeRequest hook
             if (beforeRequest) {
                 throwIfAborted(request.signal);
@@ -381,16 +588,30 @@ export function createFetchInterceptor(handle, options = {}, admitRequest, owner
                 throwIfAborted(request.signal);
                 if (modified) {
                     adapterRequest = modified;
+                    formatterRequest = modified;
                 }
             }
             throwIfAborted(request.signal);
+            // A hook may produce a method no route can match; that is a miss
+            // too, as the Angular adapter treats it.
+            const effectiveMethod = adapterRequest.method.toUpperCase();
+            if (!isHttpMethod(effectiveMethod)) {
+                return unroutedResult(passthrough, context);
+            }
+            context.method = effectiveMethod;
+            if (beforeRequest !== undefined &&
+                !claim(effectiveRequestKey(effectiveMethod, adapterRequest.path))) {
+                return ALREADY_CONSULTED;
+            }
+            if (beforeRequest !== undefined) {
+                draft.answers = answersFor(effectiveMethod, adapterRequest.path);
+            }
             const requestOptions = {
                 headers: adapterRequest.headers,
                 body: adapterRequest.body,
                 query: adapterRequest.query,
                 signal: request.signal,
             };
-            effectiveMethod = toHttpMethod(adapterRequest.method);
             const schmockResponse = await awaitWithAbort(admittedHandle(effectiveMethod, adapterRequest.path, requestOptions), request.signal);
             throwIfAborted(request.signal);
             // Exception provenance is carried on the response as a non-enumerable
@@ -401,17 +622,7 @@ export function createFetchInterceptor(handle, options = {}, admitRequest, owner
             const internalError = getResponseException(schmockResponse);
             // Route not found — passthrough or 404
             if (isRouteNotFound(schmockResponse)) {
-                if (passthrough) {
-                    return PASSTHROUGH;
-                }
-                return toFetchResponse({
-                    status: 404,
-                    body: {
-                        error: "No matching mock route found",
-                        code: "ROUTE_NOT_FOUND",
-                    },
-                    headers: { "content-type": "application/json" },
-                }, effectiveMethod);
+                return unroutedResult(passthrough, context);
             }
             // Apply beforeResponse hook
             let response = schmockResponse;
@@ -429,9 +640,22 @@ export function createFetchInterceptor(handle, options = {}, admitRequest, owner
             // Angular): a beforeResponse that rewrites an exception into a 503 or
             // a 200 is honoured instead of being forced back to a formatted 500.
             if (errorFormatter && internalError && response.status === 500) {
-                return formatInterceptedError(errorFormatter, internalError, response.headers, effectiveMethod);
+                const seenRequest = adapterRequest;
+                return formattedErrorResponse({
+                    formatter: (error) => errorFormatter(error, seenRequest),
+                    error: internalError,
+                    responseHeaders: response.headers,
+                    context,
+                });
+            }
+            // A schmock() admission's handle() already normalized its own output
+            // for this method; with no hook to replace or mutate it, a second
+            // pass would only re-validate the same tree. Anything else, including
+            // a hand-written admission's response, is re-normalized.
+            if (isNormalizedAdmission(admission) && beforeResponse === undefined) {
+                return createFetchResponse(withDefaultContentType(schmockResponse), context);
             }
-            return toFetchResponse(response, effectiveMethod);
+            return toFetchResponse(response, context);
         }
         catch (error) {
             throwIfAborted(request.signal);
@@ -439,13 +663,23 @@ export function createFetchInterceptor(handle, options = {}, admitRequest, owner
                 throw error;
             }
             if (errorFormatter) {
-                const formatted = errorFormatter(error instanceof Error ? error : new Error(String(error)));
+                // A formatter that throws here propagates and rejects the fetch; a
+                // body it returns that cannot be serialized falls back to the same
+                // INTERNAL_ERROR body the core-marked path uses.
+                const failure = error instanceof Error ? error : new Error(String(error));
+                // No request was built when the body itself could not be read.
+                const formatted = errorFormatter(failure, formatterRequest ?? {
+                    method: request.method,
+                    path,
+                    headers: extractHeaders(request),
+                    query: extractQuery(url),
+                });
                 throwIfAborted(request.signal);
-                return toFetchResponse({
-                    status: 500,
-                    body: formatted,
-                    headers: { "content-type": "application/json" },
-                }, effectiveMethod);
+                return formattedErrorResponse({
+                    formatter: () => formatted,
+                    error: failure,
+                    context,
+                });
             }
             throw error;
         }
@@ -454,5 +688,5 @@ export function createFetchInterceptor(handle, options = {}, admitRequest, owner
         }
     }, (nextOptions) => {
         currentOptions = nextOptions ?? {};
-    }, owner);
+    }, owner, observe);
 }