@schmock/core 2.3.0 → 2.3.1

package/dist/interceptor.js

@@ -1,31 +1,140 @@
 /// <reference path="../schmock.d.ts" />
+import { awaitWithAbort, throwIfAborted } from "./abort.js";
 import { isBinaryBody } from "./binary.js";
-import { isRouteNotFound, toHttpMethod } from "./constants.js";
+import { canonicalizePath, getResponseException, isRouteNotFound, toHttpMethod, } from "./constants.js";
+import { normalizeResponse, serializeResponseBody, } from "./response-normalizer.js";
 const PASSTHROUGH = Symbol("schmock.fetch.passthrough");
-function toFetchBinaryBody(body) {
-    if (body instanceof ArrayBuffer)
-        return body;
-    const bytes = new Uint8Array(body.byteLength);
-    bytes.set(new Uint8Array(body.buffer, body.byteOffset, body.byteLength));
-    return bytes;
-}
+// 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".
+const FILTERED = Symbol("schmock.fetch.filtered");
+const RELATIVE_REQUEST_BASE = "http://schmock.invalid/";
 let activeSession;
+function getRelativeRequestBase() {
+    const candidates = [
+        typeof document === "undefined" ? undefined : document.baseURI,
+        typeof location === "undefined" ? undefined : location.href,
+    ];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        try {
+            return new URL(candidate).href;
+        }
+        catch {
+            // Ignore invalid environment globals and use the next fallback.
+        }
+    }
+    return RELATIVE_REQUEST_BASE;
+}
+// The Fetch standard stamps a content type when the body is extracted from a
+// string or URLSearchParams. Node's Request constructor conforms; Bun's omits
+// the header, so identical consumer code would otherwise deliver a string
+// body on Node and an opaque ArrayBuffer on Bun.
+function stampBodyContentType(request, body) {
+    if (body == null || request.headers.has("content-type"))
+        return;
+    if (typeof body === "string") {
+        request.headers.set("content-type", "text/plain;charset=UTF-8");
+    }
+    else if (body instanceof URLSearchParams) {
+        request.headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+    }
+}
+function normalizeFetchRequest(input, init) {
+    if (input instanceof Request) {
+        // Constructing a Request from another Request transfers its body. Use a
+        // clone when the body is inherited so the original remains passthrough-safe.
+        const source = init?.body == null ? input.clone() : input;
+        const request = new Request(source, init);
+        if (init?.body != null) {
+            stampBodyContentType(request, init.body);
+        }
+        else if (request.body != null && !request.headers.has("content-type")) {
+            // The body was inherited from the input Request, but init.headers
+            // replaces the whole header list, dropping the content type stamped
+            // when that body was extracted. Restore it so the handler still sees
+            // the body as its original kind. (Bun never stamps at construction,
+            // so a string body on a type-less input Request stays opaque there.)
+            const inheritedType = input.headers.get("content-type");
+            if (inheritedType !== null) {
+                request.headers.set("content-type", inheritedType);
+            }
+        }
+        const url = new URL(request.url);
+        return {
+            request,
+            url,
+            origin: url.origin,
+        };
+    }
+    if (input instanceof URL) {
+        const request = new Request(input, init);
+        stampBodyContentType(request, init?.body);
+        const url = new URL(request.url);
+        return {
+            request,
+            url,
+            origin: url.origin,
+        };
+    }
+    let inputUrl;
+    let origin;
+    try {
+        inputUrl = new URL(input);
+        origin = inputUrl.origin;
+    }
+    catch {
+        inputUrl = new URL(input, getRelativeRequestBase());
+        origin = null;
+    }
+    const request = new Request(inputUrl, init);
+    stampBodyContentType(request, init?.body);
+    return {
+        request,
+        url: new URL(request.url),
+        origin,
+    };
+}
 function createInterceptorSession() {
     const baselineFetch = globalThis.fetch;
     const interceptors = [];
     const dispatchFetch = async (input, init) => {
         const snapshot = interceptors.slice();
+        if (snapshot.length === 0) {
+            return baselineFetch(input, init);
+        }
+        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 result = await snapshot[index].intercept(input, init);
+            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);
+            }
         }
-        return baselineFetch(input, init);
+        return awaitWithAbort(baselineFetch(normalizedRequest.request), normalizedRequest.request.signal);
     };
     return { baselineFetch, dispatchFetch, interceptors };
 }
-function registerInterceptor(intercept) {
+function registerInterceptor(intercept, applyOptions, owner) {
     let session = activeSession;
     if (!session || globalThis.fetch !== session.dispatchFetch) {
         session = createInterceptorSession();
@@ -33,7 +142,7 @@ function registerInterceptor(intercept) {
         globalThis.fetch = session.dispatchFetch;
     }
     const token = Symbol("schmock.fetch.interceptor");
-    session.interceptors.push({ token, intercept });
+    session.interceptors.push({ token, owner, intercept });
     let active = true;
     return {
         restore() {
@@ -55,44 +164,18 @@ function registerInterceptor(intercept) {
                 globalThis.fetch = session.baselineFetch;
             }
         },
+        update(options) {
+            // Reconfiguring never touches session.interceptors, so the lease keeps
+            // the dispatch position it was registered with.
+            if (!active)
+                return;
+            applyOptions(options);
+        },
         get active() {
             return active;
         },
     };
 }
-/**
- * Extract pathname from a URL string, handling both absolute and relative URLs.
- */
-function extractPathname(url) {
-    const queryStart = url.indexOf("?");
-    const urlWithoutQuery = queryStart === -1 ? url : url.slice(0, queryStart);
-    if (urlWithoutQuery.includes("://")) {
-        try {
-            return new URL(urlWithoutQuery).pathname;
-        }
-        catch {
-            // Fall through to simple extraction
-        }
-    }
-    if (!urlWithoutQuery.startsWith("/")) {
-        return `/${urlWithoutQuery}`;
-    }
-    return urlWithoutQuery;
-}
-/**
- * Extract origin (scheme + host + port) from a URL string, or null for
- * relative URLs that don't carry one.
- */
-function extractOrigin(url) {
-    if (!url.includes("://"))
-        return null;
-    try {
-        return new URL(url).origin;
-    }
-    catch {
-        return null;
-    }
-}
 /**
  * Parse the user-supplied baseUrl option into its origin and path parts.
  * - "/api"                  → { origin: null, path: "/api" }
@@ -106,109 +189,158 @@ function parseBaseUrl(baseUrl) {
     if (baseUrl.includes("://")) {
         try {
             const parsed = new URL(baseUrl);
-            const rawPath = parsed.pathname;
-            const path = rawPath === "/" ? "" : rawPath.replace(/\/$/, "");
+            const canonicalPath = canonicalizePath(parsed.pathname);
+            const path = canonicalPath === "/" ? "" : canonicalPath.replace(/\/$/, "");
             return { origin: parsed.origin, path };
         }
         catch {
             // Fall through to path-only handling
         }
     }
-    return { origin: null, path: baseUrl.replace(/\/$/, "") };
+    const canonicalPath = canonicalizePath(baseUrl);
+    const path = canonicalPath === "/" ? "" : canonicalPath.replace(/\/$/, "");
+    return { origin: null, path };
 }
-/**
- * Extract query parameters from a URL string.
- */
 function extractQuery(url) {
-    const queryStart = url.indexOf("?");
-    if (queryStart === -1)
-        return {};
-    const params = new URLSearchParams(url.slice(queryStart + 1));
-    const result = {};
-    params.forEach((value, key) => {
-        result[key] = value;
-    });
-    return result;
+    return Object.fromEntries(url.searchParams);
 }
-/**
- * Extract headers from fetch init or Request object.
- */
-function extractHeaders(input, init) {
+function extractHeaders(request) {
     const headers = {};
-    const raw = init?.headers ?? (input instanceof Request ? input.headers : undefined);
-    if (!raw)
-        return headers;
-    if (raw instanceof Headers) {
-        raw.forEach((value, key) => {
-            headers[key.toLowerCase()] = value;
-        });
-    }
-    else if (Array.isArray(raw)) {
-        for (const [key, value] of raw) {
-            headers[key.toLowerCase()] = value;
-        }
-    }
-    else {
-        for (const key of Object.keys(raw)) {
-            headers[key.toLowerCase()] = raw[key];
-        }
-    }
+    request.headers.forEach((value, key) => {
+        headers[key.toLowerCase()] = value;
+    });
     return headers;
 }
-/**
- * Extract body from fetch init, parsing JSON when possible.
- */
-async function extractBody(input, init) {
-    // Per Fetch spec, init.body overrides Request.body when both are present
-    const bodyInit = init?.body ?? (input instanceof Request ? input.body : null);
-    if (bodyInit === null || bodyInit === undefined)
+function normalizeMediaType(contentType) {
+    return contentType?.split(";", 1)[0].trim().toLowerCase() ?? "";
+}
+async function extractBody(request) {
+    if (request.body === null)
         return undefined;
-    // String body — try to parse as JSON
-    if (typeof bodyInit === "string") {
+    const body = request.clone();
+    const mediaType = normalizeMediaType(request.headers.get("content-type"));
+    if (mediaType === "application/json" || mediaType.endsWith("+json")) {
+        const text = await body.text();
         try {
-            return JSON.parse(bodyInit);
+            return JSON.parse(text);
         }
         catch {
-            return bodyInit;
+            return text;
         }
     }
-    // URLSearchParams — convert to key/value object
-    if (bodyInit instanceof URLSearchParams) {
-        const result = {};
-        bodyInit.forEach((value, key) => {
-            result[key] = value;
-        });
-        return result;
+    if (mediaType === "application/x-www-form-urlencoded") {
+        return Object.fromEntries(new URLSearchParams(await body.text()));
+    }
+    if (mediaType.startsWith("text/")) {
+        return body.text();
+    }
+    if (mediaType.startsWith("multipart/")) {
+        return body.formData();
+    }
+    return body.arrayBuffer();
+}
+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";
+        }
     }
-    // Request with body — clone and read
-    if (input instanceof Request && !init?.body && input.body) {
+    const normalized = normalizeResponse({ ...response, headers }, method);
+    return new Response(serializeResponseBody(normalized) ?? null, {
+        status: normalized.status,
+        headers: normalized.headers,
+    });
+}
+/**
+ * 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.
+ */
+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;
+}
+/**
+ * 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.
+ */
+function formatInterceptedError(errorFormatter, error, responseHeaders, method) {
+    try {
+        const formatted = errorFormatter(error);
         try {
-            return await input.clone().json();
+            return toFetchResponse({
+                status: 500,
+                body: formatted,
+                headers: withJsonContentType(responseHeaders),
+            }, method);
         }
         catch {
-            try {
-                return await input.clone().text();
-            }
-            catch {
-                return undefined;
-            }
+            // `formatted` is reused, so the formatter still fires exactly once.
+            return toFetchResponse({
+                status: 500,
+                body: formatted,
+                headers: { "content-type": "application/json" },
+            }, method);
         }
     }
-    return undefined;
+    catch {
+        return toFetchResponse({
+            status: 500,
+            body: { error: "Internal Server Error", code: "INTERNAL_ERROR" },
+            headers: { "content-type": "application/json" },
+        }, method);
+    }
 }
 /**
  * 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.
  */
-export function createFetchInterceptor(handle, options = {}) {
-    const { baseUrl, passthrough = true, beforeRequest, beforeResponse, errorFormatter, } = options;
-    return registerInterceptor(async (input, init) => {
-        // Resolve the URL string
-        const urlString = input instanceof Request
-            ? input.url
-            : input instanceof URL
-                ? input.href
-                : input;
-        const path = extractPathname(urlString);
+export function createFetchInterceptor(handle, options = {}, admitRequest, owner) {
+    // 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 }) => {
+        const { baseUrl, passthrough = true, beforeRequest, beforeResponse, errorFormatter, } = currentOptions;
+        const path = canonicalizePath(url.pathname);
         // BaseUrl filter — non-matching requests go straight to real fetch.
         // Two modes:
         //   - origin form ("https://api.example.com/v1"): require matching
@@ -217,95 +349,110 @@ export function createFetchInterceptor(handle, options = {}) {
         // Both enforce a segment boundary so "/api" doesn't match "/apiv2".
         if (baseUrl) {
             const { origin: baseOrigin, path: basePath } = parseBaseUrl(baseUrl);
-            if (baseOrigin) {
-                const reqOrigin = extractOrigin(urlString);
-                if (reqOrigin !== baseOrigin) {
-                    return PASSTHROUGH;
-                }
+            if (baseOrigin && origin !== baseOrigin) {
+                return FILTERED;
             }
             if (basePath) {
                 const isMatch = path === basePath || path.startsWith(`${basePath}/`);
                 if (!isMatch) {
-                    return PASSTHROUGH;
+                    return FILTERED;
                 }
             }
         }
-        // Build adapter request
-        const method = input instanceof Request ? input.method : (init?.method ?? "GET");
-        const headers = extractHeaders(input, init);
-        const query = extractQuery(urlString);
-        const body = await extractBody(input, init);
-        let adapterRequest = {
-            method,
-            path,
-            headers,
-            body,
-            query,
-        };
+        throwIfAborted(request.signal);
+        const initialMethod = toHttpMethod(request.method);
+        const admission = admitRequest?.();
+        const admittedHandle = admission?.handle ?? handle;
+        let effectiveMethod = initialMethod;
         try {
+            const body = await awaitWithAbort(extractBody(request), request.signal);
+            throwIfAborted(request.signal);
+            let adapterRequest = {
+                method: request.method,
+                path,
+                headers: extractHeaders(request),
+                body,
+                query: extractQuery(url),
+            };
             // Apply beforeRequest hook
             if (beforeRequest) {
-                const modified = await beforeRequest(adapterRequest);
+                throwIfAborted(request.signal);
+                const modified = await awaitWithAbort(beforeRequest(adapterRequest), request.signal);
+                throwIfAborted(request.signal);
                 if (modified) {
                     adapterRequest = modified;
                 }
             }
-            const schmockResponse = await handle(toHttpMethod(adapterRequest.method), adapterRequest.path, {
+            throwIfAborted(request.signal);
+            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
+            // symbol, so it must be read BEFORE beforeResponse runs: the
+            // documented `{...response}` hook pattern copies only own enumerable
+            // properties and would otherwise strip the mark, silently bypassing
+            // errorFormatter.
+            const internalError = getResponseException(schmockResponse);
             // Route not found — passthrough or 404
             if (isRouteNotFound(schmockResponse)) {
                 if (passthrough) {
                     return PASSTHROUGH;
                 }
-                return new Response(JSON.stringify({
-                    error: "No matching mock route found",
-                    code: "ROUTE_NOT_FOUND",
-                }), {
+                return toFetchResponse({
                     status: 404,
+                    body: {
+                        error: "No matching mock route found",
+                        code: "ROUTE_NOT_FOUND",
+                    },
                     headers: { "content-type": "application/json" },
-                });
+                }, effectiveMethod);
             }
             // Apply beforeResponse hook
             let response = schmockResponse;
             if (beforeResponse) {
-                const modified = await beforeResponse(response, adapterRequest);
+                throwIfAborted(request.signal);
+                const modified = await awaitWithAbort(beforeResponse(response, adapterRequest), request.signal);
+                throwIfAborted(request.signal);
                 if (modified) {
                     response = modified;
                 }
             }
-            // Build fetch Response
-            const responseHeaders = new Headers(response.headers);
-            if (!responseHeaders.has("content-type") &&
-                response.body !== null &&
-                response.body !== undefined) {
-                responseHeaders.set("content-type", isBinaryBody(response.body)
-                    ? "application/octet-stream"
-                    : "application/json");
+            // Only core-marked exceptions reach errorFormatter; a user-defined 500
+            // with an error-shaped body stays an ordinary domain response. The
+            // POST-hook status gates the replacement (matching Express and
+            // 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 responseBody = response.body === null || response.body === undefined
-                ? null
-                : typeof response.body === "string"
-                    ? response.body
-                    : isBinaryBody(response.body)
-                        ? toFetchBinaryBody(response.body)
-                        : JSON.stringify(response.body);
-            return new Response(responseBody, {
-                status: response.status,
-                headers: responseHeaders,
-            });
+            return toFetchResponse(response, effectiveMethod);
         }
         catch (error) {
+            throwIfAborted(request.signal);
+            if (isAbortError(error)) {
+                throw error;
+            }
             if (errorFormatter) {
                 const formatted = errorFormatter(error instanceof Error ? error : new Error(String(error)));
-                return new Response(JSON.stringify(formatted), {
+                throwIfAborted(request.signal);
+                return toFetchResponse({
                     status: 500,
+                    body: formatted,
                     headers: { "content-type": "application/json" },
-                });
+                }, effectiveMethod);
             }
             throw error;
         }
-    });
+        finally {
+            admission?.release();
+        }
+    }, (nextOptions) => {
+        currentOptions = nextOptions ?? {};
+    }, owner);
 }

package/dist/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAyC3D"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAmD3D"}

package/dist/parser.js

@@ -1,4 +1,4 @@
-import { toHttpMethod } from "./constants.js";
+import { canonicalizePath, normalizePath, toHttpMethod } from "./constants.js";
 import { RouteParseError } from "./errors.js";
 /**
  * Parse 'METHOD /path' route key format
@@ -12,11 +12,20 @@ import { RouteParseError } from "./errors.js";
  * // => { method: 'GET', path: '/users/:id', pattern: /^\/users\/([^/]+)$/, params: ['id'] }
  */
 export function parseRouteKey(routeKey) {
-    const match = routeKey.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS) (.+)$/);
+    // The path group must start with "/": every transport (server, interceptor,
+    // adapters) delivers a leading-slash pathname, so a slash-less key such as
+    // "GET users" compiles a route no request can ever reach. `.*` is kept
+    // deliberately — hostile-but-reachable segments (spaces, tabs, unicode) must
+    // still parse.
+    const match = routeKey.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS) (\/.*)$/);
     if (!match) {
         throw new RouteParseError(routeKey, 'Expected format: "METHOD /path" (e.g., "GET /users")');
     }
-    const [, method, path] = match;
+    const [, method, rawPath] = match;
+    // Canonicalize once, here, so `path`, `pattern`, the duplicate check, the
+    // static-route Map key and getRoutes() all agree on one spelling: the
+    // percent-encoded transport form with a single trailing slash stripped.
+    const path = normalizePath(canonicalizePath(rawPath));
     // Parameter names are restricted to [A-Za-z0-9_-] so that surrounding
     // literals (".json", brackets, parens, etc.) terminate the name and can
     // be escaped without bleeding into the parameter regex. Build the

package/dist/plugin-pipeline.d.ts

@@ -9,14 +9,14 @@ interface PipelineResult {
     requestShortCircuited?: boolean;
 }
 /** Run request guards before route code is allowed to execute. */
-export declare function runPluginBeforeRequest(plugins: Schmock.Plugin[], context: Schmock.PluginContext, logger: PipelineLogger): Promise<PipelineResult>;
+export declare function runPluginBeforeRequest(plugins: readonly Schmock.Plugin[], context: Schmock.PluginContext, logger: PipelineLogger, signal?: AbortSignal | undefined): Promise<PipelineResult>;
 /** Give pipeline error handlers a chance to recover a route-generator error. */
-export declare function recoverGeneratorError(plugins: Schmock.Plugin[], context: Schmock.PluginContext, error: unknown, logger: PipelineLogger): Promise<PipelineResult>;
+export declare function recoverGeneratorError(plugins: readonly Schmock.Plugin[], context: Schmock.PluginContext, error: unknown, logger: PipelineLogger, signal?: AbortSignal | undefined): Promise<PipelineResult>;
 /**
  * Run all registered plugins in sequence
  * First plugin to set response becomes generator, subsequent plugins transform
  * Handles plugin errors via onError hooks
  */
-export declare function runPluginPipeline(plugins: Schmock.Plugin[], context: Schmock.PluginContext, initialResponse: unknown, logger: PipelineLogger): Promise<PipelineResult>;
+export declare function runPluginPipeline(plugins: readonly Schmock.Plugin[], context: Schmock.PluginContext, initialResponse: unknown, logger: PipelineLogger, signal?: AbortSignal | undefined): Promise<PipelineResult>;
 export {};
 //# sourceMappingURL=plugin-pipeline.d.ts.map