@schmock/core 2.4.1 → 2.6.0

package/dist/plugin-hooks.js

@@ -0,0 +1,276 @@
+import { errorMessage, SchmockError } from "./errors.js";
+import { snapshotNormalizedBody, snapshotRequestBody } from "./snapshot.js";
+const PLUGIN_HOOK_ERROR_CODES = {
+    install: {
+        expired: "PLUGIN_INSTALL_SCOPE_EXPIRED",
+        unsupported: "PLUGIN_INSTALL_OPERATION_UNSUPPORTED",
+    },
+    uninstall: {
+        expired: "PLUGIN_UNINSTALL_SCOPE_EXPIRED",
+        unsupported: "PLUGIN_UNINSTALL_OPERATION_UNSUPPORTED",
+    },
+};
+/**
+ * Optional hooks rejected when set to a truthy non-function. `install` threw a
+ * TypeError from pipe() and `beforeRequest` failed every matched request, so
+ * rejecting them breaks no working setup. `onExchange` is new: no working
+ * setup relies on another shape, and a non-function would otherwise silently
+ * observe nothing. Falsy values (`onError: null`, `install: false`,
+ * `onExchange: undefined`) still switch a hook off. `onError`/`uninstall`
+ * failures only ever surfaced on paths that already fail or log, so they are
+ * left alone.
+ */
+const EAGER_PLUGIN_HOOKS = ["install", "beforeRequest", "onExchange"];
+export function isThenable(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "then" in value &&
+        typeof value.then === "function");
+}
+function describeInvalidPlugin(plugin) {
+    if ((typeof plugin !== "object" && typeof plugin !== "function") ||
+        plugin === null) {
+        return "expected a plugin object";
+    }
+    if (typeof Reflect.get(plugin, "process") !== "function") {
+        return "process must be a function";
+    }
+    for (const hook of EAGER_PLUGIN_HOOKS) {
+        const value = Reflect.get(plugin, hook);
+        if (value && typeof value !== "function") {
+            return `${hook} must be a function when set`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Reject, when it is piped, a plugin that could never work: one without a
+ * `process` function (it answered every matched request with a 500), or one
+ * whose `install`, `beforeRequest` or `onExchange` is a truthy non-function.
+ * The `install` and `beforeRequest` shapes already failed before this check;
+ * `onExchange` is new, so no working setup breaks.
+ */
+export function assertValidPlugin(plugin) {
+    const reason = describeInvalidPlugin(plugin);
+    if (reason === undefined)
+        return;
+    const name = typeof plugin === "object" && plugin !== null
+        ? Reflect.get(plugin, "name")
+        : undefined;
+    const label = typeof name === "string" && name.length > 0 ? ` "${name}"` : "";
+    throw new SchmockError(`Invalid plugin${label}: ${reason}`, "PLUGIN_INVALID", {
+        plugin: typeof name === "string" ? name : undefined,
+        reason,
+    });
+}
+/** Whether any plugin observes exchanges (a function `onExchange`). */
+export function hasExchangeObserver(plugins) {
+    return plugins.some((plugin) => typeof plugin.onExchange === "function");
+}
+/** A fresh, frozen copy of an exchange, built for one observer. */
+function snapshotExchange(exchange) {
+    const { request } = exchange;
+    const requestCopy = Object.freeze({
+        method: request.method,
+        url: request.url,
+        headers: Object.freeze({ ...request.headers }),
+        ...(request.body !== undefined
+            ? { body: snapshotRequestBody(request.body) }
+            : {}),
+    });
+    const { startTime, endTime } = exchange;
+    if (exchange.outcome === "answered") {
+        const { response } = exchange;
+        return Object.freeze({
+            outcome: exchange.outcome,
+            request: requestCopy,
+            response: Object.freeze({
+                status: response.status,
+                headers: Object.freeze({ ...response.headers }),
+                ...(response.body !== undefined
+                    ? { body: snapshotNormalizedBody(response.body) }
+                    : {}),
+            }),
+            startTime,
+            endTime,
+        });
+    }
+    if (exchange.outcome === "failed") {
+        return Object.freeze({
+            outcome: exchange.outcome,
+            request: requestCopy,
+            error: exchange.error,
+            startTime,
+            endTime,
+        });
+    }
+    return Object.freeze({
+        outcome: exchange.outcome,
+        request: requestCopy,
+        startTime,
+        endTime,
+    });
+}
+/**
+ * Report one settled exchange to each plugin's `onExchange`, in pipe order.
+ * Every observer gets its own frozen snapshot, built right before its call, so
+ * none sees or alters another's copy. A throwing or rejecting observer is
+ * logged and never stops the others. Reporting stops as soon as `isLive`
+ * returns false.
+ */
+export function runExchangeHooks(input) {
+    const { plugins, exchange, logger, isLive } = input;
+    for (const plugin of plugins) {
+        if (isLive !== undefined && !isLive())
+            return;
+        try {
+            const observe = plugin.onExchange;
+            if (typeof observe !== "function")
+                continue;
+            const result = Reflect.apply(observe, plugin, [
+                snapshotExchange(exchange),
+            ]);
+            if (isThenable(result)) {
+                void Promise.resolve(result).catch((error) => {
+                    logger.log("plugin", `Plugin ${plugin.name} onExchange rejected: ${errorMessage(error)}`);
+                });
+            }
+        }
+        catch (error) {
+            logger.log("plugin", `Plugin ${plugin.name} onExchange failed: ${errorMessage(error)}`);
+        }
+    }
+}
+/**
+ * The instance a plugin hook receives. Reads are live; route registration is
+ * allowed only when the hook passes `registerRoute` (install does, uninstall
+ * does not); every other operation is rejected. `isActive` expires the
+ * facade when the hook returns, so a retained reference cannot act later.
+ */
+function createHookFacade(input) {
+    const { plugin, hook, isActive, reads, registerRoute } = input;
+    const codes = PLUGIN_HOOK_ERROR_CODES[hook];
+    const requireScope = () => {
+        if (isActive())
+            return;
+        throw new SchmockError(`Plugin "${plugin.name}" used its ${hook} instance outside ${hook}()`, codes.expired, { plugin: plugin.name });
+    };
+    const reject = (operation) => {
+        requireScope();
+        throw new SchmockError(`Plugin "${plugin.name}" cannot call ${operation} during ${hook}()`, codes.unsupported, { operation, plugin: plugin.name });
+    };
+    let facade;
+    const defineRoute = (route, generator, config = {}) => {
+        if (!registerRoute)
+            return reject("route registration");
+        requireScope();
+        registerRoute(route, generator, config);
+        return facade;
+    };
+    facade = Object.assign(defineRoute, {
+        pipe: () => reject("pipe()"),
+        handle: () => reject("handle()"),
+        history: (method, path) => {
+            requireScope();
+            return reads.history(method, path);
+        },
+        called: (method, path) => {
+            requireScope();
+            return reads.called(method, path);
+        },
+        callCount: (method, path) => {
+            requireScope();
+            return reads.callCount(method, path);
+        },
+        lastRequest: (method, path) => {
+            requireScope();
+            return reads.lastRequest(method, path);
+        },
+        reset: () => reject("reset()"),
+        resetHistory: () => reject("resetHistory()"),
+        resetState: () => reject("resetState()"),
+        on: () => reject("on()"),
+        off: () => reject("off()"),
+        getRoutes: () => {
+            requireScope();
+            return reads.getRoutes();
+        },
+        getState: () => {
+            requireScope();
+            return reads.getState();
+        },
+        listen: () => reject("listen()"),
+        close: () => reject("close()"),
+        intercept: () => reject("intercept()"),
+    });
+    return facade;
+}
+/**
+ * Run a plugin's `install()` against an expiring facade that may register
+ * routes. A Promise returned from `install()` is rejected: the routes it would
+ * register later could not be rolled back. The caller owns the rollback of
+ * whatever the hook registered before it threw.
+ */
+export function runInstallHook(input) {
+    const { plugin, logger } = input;
+    if (!plugin.install)
+        return;
+    let installActive = true;
+    const installFacade = createHookFacade({
+        plugin,
+        hook: "install",
+        isActive: () => installActive,
+        reads: input.reads,
+        registerRoute: input.registerRoute,
+    });
+    try {
+        const installResult = plugin.install(installFacade);
+        installActive = false;
+        if (isThenable(installResult)) {
+            void Promise.resolve(installResult).catch((error) => {
+                logger.log("plugin", `Rejected async install for ${plugin.name}: ${errorMessage(error)}`);
+            });
+            throw new SchmockError(`Plugin "${plugin.name}" returned a Promise from install()`, "PLUGIN_ASYNC_INSTALL_UNSUPPORTED", { plugin: plugin.name });
+        }
+    }
+    finally {
+        installActive = false;
+    }
+}
+/**
+ * Run `uninstall()` for each plugin, last piped first. A failing hook is
+ * logged and never stops the others.
+ */
+export function runUninstallHooks(input) {
+    const { plugins, logger } = input;
+    for (let index = plugins.length - 1; index >= 0; index -= 1) {
+        const plugin = plugins[index];
+        if (!plugin.uninstall)
+            continue;
+        // Cleanup gets a read-only, expiring instance: through the live one a
+        // plugin could pipe plugins or register routes into the mock that
+        // reset() just cleared.
+        let uninstallActive = true;
+        const uninstallFacade = createHookFacade({
+            plugin,
+            hook: "uninstall",
+            isActive: () => uninstallActive,
+            reads: input.reads,
+        });
+        try {
+            const uninstallResult = plugin.uninstall(uninstallFacade);
+            if (isThenable(uninstallResult)) {
+                void Promise.resolve(uninstallResult).catch((error) => {
+                    logger.log("plugin", `Async uninstall for ${plugin.name} failed: ${errorMessage(error)}`);
+                });
+                logger.log("plugin", `Plugin ${plugin.name} returned an unsupported Promise from uninstall()`);
+            }
+        }
+        catch (error) {
+            logger.log("plugin", `Plugin ${plugin.name} uninstall failed: ${errorMessage(error)}`);
+        }
+        finally {
+            uninstallActive = false;
+        }
+    }
+}

package/dist/plugin-pipeline.d.ts

@@ -19,4 +19,3 @@ export declare function recoverGeneratorError(plugins: readonly Schmock.Plugin[]
  */
 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

package/dist/plugin-pipeline.js

@@ -7,6 +7,27 @@ function isPluginResult(value) {
         typeof value.context === "object" &&
         value.context !== null);
 }
+/** The failure a plugin hook raises by returning something that is not a PluginResult. */
+function invalidPluginResultError(pluginName) {
+    return new PluginError(pluginName, new Error("didn't return valid result"));
+}
+function isAttributedTo(error, pluginName) {
+    const context = error.context;
+    return (typeof context === "object" &&
+        context !== null &&
+        "pluginName" in context &&
+        context.pluginName === pluginName);
+}
+/**
+ * Attribute an unrecovered failure to the plugin that raised it, once: an
+ * error that already is that plugin's PluginError (an invalid result) is not
+ * wrapped a second time.
+ */
+function toPluginError(pluginName, error) {
+    return error instanceof PluginError && isAttributedTo(error, pluginName)
+        ? error
+        : new PluginError(pluginName, error);
+}
 function preserveRequestSignal(context, signal) {
     return context.signal === signal ? context : { ...context, signal };
 }
@@ -55,7 +76,7 @@ export async function runPluginBeforeRequest(plugins, context, logger, signal =
             if (result === undefined)
                 continue;
             if (!isPluginResult(result)) {
-                throw new Error(`Plugin ${plugin.name} didn't return valid result`);
+                throw invalidPluginResultError(plugin.name);
             }
             currentContext = preserveRequestSignal(result.context, signal);
             if (result.response !== undefined) {
@@ -79,7 +100,7 @@ export async function runPluginBeforeRequest(plugins, context, logger, signal =
                     requestShortCircuited: true,
                 };
             }
-            throw new PluginError(plugin.name, recovery.error);
+            throw toPluginError(plugin.name, recovery.error);
         }
     }
     return { context: currentContext };
@@ -115,7 +136,7 @@ export async function runPluginPipeline(plugins, context, initialResponse, logge
             const result = await awaitWithAbort(plugin.process(currentContext, response), signal);
             throwIfAborted(signal);
             if (!isPluginResult(result)) {
-                throw new Error(`Plugin ${plugin.name} didn't return valid result`);
+                throw invalidPluginResultError(plugin.name);
             }
             currentContext = preserveRequestSignal(result.context, signal);
             // First plugin to set response becomes the generator
@@ -140,7 +161,7 @@ export async function runPluginPipeline(plugins, context, initialResponse, logge
                     recoveredFromError: true,
                 };
             }
-            throw new PluginError(plugin.name, recovery.error);
+            throw toPluginError(plugin.name, recovery.error);
         }
     }
     return { context: currentContext, response };

package/dist/response-normalizer.d.ts

@@ -12,5 +12,40 @@ export declare function normalizeResponse(response: NormalizableResponse, method
  * Encode a response body using its normalized content type semantics.
  */
 export declare function serializeResponseBody(response: Schmock.Response): OwnedBytes | undefined;
+/**
+ * Give a response the content type its body implies when it declares none:
+ * `application/octet-stream` for a binary body, `application/json` for any
+ * other non-string body (`null` included, which serializes as JSON). A string
+ * body is sent as-is and gets no default.
+ *
+ * Total: it never throws and never mutates `response`. The result is not
+ * normalized; pass it to `normalizeResponse` when it still needs to be.
+ */
+export declare function withDefaultContentType(response: Schmock.Response): Schmock.Response;
+/**
+ * The JSON error envelope `{ "error": message, "code": code }` every transport
+ * answers a failure with, normalized for `method`. `headers` are added after
+ * the JSON content type (a 405's `allow`). The one constructor of that shape,
+ * so `handle()`, `listen()` and `intercept()` cannot drift apart.
+ */
+export declare function buildJsonErrorResponse(input: {
+    status: number;
+    error: string;
+    code: string;
+    method: string;
+    headers?: Readonly<Record<string, string>>;
+}): Schmock.Response;
+/**
+ * Run an `errorFormatter` and build the normalized 500 that carries its result.
+ *
+ * Total: it never throws, and the formatter runs exactly once. There are two
+ * fallbacks. When the inherited headers cannot be sent (a non-string value, a
+ * control character, a case-duplicate name), the formatted body is kept and
+ * sent with the fixed JSON header set instead, since losing the body would
+ * silently change the caller's error contract. When the formatter throws or
+ * its result cannot be serialized, the minimal
+ * `{ error: "Internal Server Error", code: "INTERNAL_ERROR" }` body is sent,
+ * inheriting nothing.
+ */
+export declare function buildFormattedErrorResponse(options: Schmock.FormattedErrorOptions): Schmock.Response;
 export {};
-//# sourceMappingURL=response-normalizer.d.ts.map

package/dist/response-normalizer.js

@@ -1,5 +1,6 @@
 import { isBinaryBody } from "./binary.js";
 import { errorMessage, InvalidResponseError } from "./errors.js";
+import { hasHeader } from "./headers.js";
 const BODY_FORBIDDEN_STATUSES = new Set([204, 205, 304]);
 const HEADER_NAME_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 const FRAMING_HEADERS = new Set([
@@ -314,3 +315,104 @@ export function serializeResponseBody(response) {
     const serialized = typeof body === "string" ? body : stringifyJsonBody(body);
     return new TextEncoder().encode(serialized);
 }
+/**
+ * Give a response the content type its body implies when it declares none:
+ * `application/octet-stream` for a binary body, `application/json` for any
+ * other non-string body (`null` included, which serializes as JSON). A string
+ * body is sent as-is and gets no default.
+ *
+ * Total: it never throws and never mutates `response`. The result is not
+ * normalized; pass it to `normalizeResponse` when it still needs to be.
+ */
+export function withDefaultContentType(response) {
+    const headers = { ...response.headers };
+    const body = response.body;
+    if (body !== undefined && !hasHeader(headers, "content-type")) {
+        if (isBinaryBody(body)) {
+            headers["content-type"] = "application/octet-stream";
+        }
+        else if (typeof body !== "string") {
+            headers["content-type"] = "application/json";
+        }
+    }
+    return { status: response.status, body, headers };
+}
+/**
+ * A formatted error body is always JSON, whatever the replaced response
+ * declared. Every case variant of content-type is dropped first: a leftover
+ * `Content-Type` beside the lowercase key makes the pair untransportable.
+ */
+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;
+}
+/**
+ * The JSON error envelope `{ "error": message, "code": code }` every transport
+ * answers a failure with, normalized for `method`. `headers` are added after
+ * the JSON content type (a 405's `allow`). The one constructor of that shape,
+ * so `handle()`, `listen()` and `intercept()` cannot drift apart.
+ */
+export function buildJsonErrorResponse(input) {
+    return normalizeResponse({
+        status: input.status,
+        body: { error: input.error, code: input.code },
+        headers: { "content-type": "application/json", ...input.headers },
+    }, input.method);
+}
+function internalErrorResponse(method) {
+    return buildJsonErrorResponse({
+        status: 500,
+        error: "Internal Server Error",
+        code: "INTERNAL_ERROR",
+        method,
+    });
+}
+/**
+ * Run an `errorFormatter` and build the normalized 500 that carries its result.
+ *
+ * Total: it never throws, and the formatter runs exactly once. There are two
+ * fallbacks. When the inherited headers cannot be sent (a non-string value, a
+ * control character, a case-duplicate name), the formatted body is kept and
+ * sent with the fixed JSON header set instead, since losing the body would
+ * silently change the caller's error contract. When the formatter throws or
+ * its result cannot be serialized, the minimal
+ * `{ error: "Internal Server Error", code: "INTERNAL_ERROR" }` body is sent,
+ * inheriting nothing.
+ */
+export function buildFormattedErrorResponse(options) {
+    const { formatter, error, inheritedHeaders, method } = options;
+    let formatted;
+    try {
+        formatted = formatter(error);
+    }
+    catch {
+        return internalErrorResponse(method);
+    }
+    try {
+        return normalizeResponse({
+            status: 500,
+            body: formatted,
+            headers: withJsonContentType(inheritedHeaders),
+        }, method);
+    }
+    catch {
+        // The inherited headers were not transportable. `formatted` is reused,
+        // so the formatter still fires exactly once.
+    }
+    try {
+        return normalizeResponse({
+            status: 500,
+            body: formatted,
+            headers: { "content-type": "application/json" },
+        }, method);
+    }
+    catch {
+        return internalErrorResponse(method);
+    }
+}

package/dist/response-parser.d.ts

@@ -1,6 +1,24 @@
+/**
+ * Split a route or plugin result into the status, body and headers core will
+ * answer with, using exactly the guards `handle()` applies: an object is an
+ * envelope only when it has a numeric `status`, a `body`, and `headers` that
+ * are absent or a string record; anything else is delivered whole as the body.
+ *
+ * `body` is the element as carried (`null` stays `null`, though core sends no
+ * body for it), `status` is what core answers with (a plain `null` or
+ * `undefined` result is 204), and `headers` is a fresh copy, `{}` when the
+ * carried headers are not a string record.
+ */
+export declare function getResponseParts(response: unknown): Schmock.ResponseParts;
+/**
+ * Put `body` in place of the body `response` carries, keeping its shape: a
+ * tuple stays a tuple of the same length, an envelope keeps its status and
+ * headers (other properties are dropped, as core ignores them), and a plain
+ * result is replaced by `body` itself. Never mutates `response`.
+ */
+export declare function replaceResponseBody(response: unknown, body: unknown): unknown;
 /**
  * Parse and normalize response result into Response object
  * Handles tuple format [status, body, headers], direct values, and response objects
  */
 export declare function parseResponse(result: unknown, routeConfig: Schmock.RouteConfig): Schmock.Response;
-//# sourceMappingURL=response-parser.d.ts.map

package/dist/response-parser.js

@@ -1,6 +1,7 @@
 import { isBinaryBody } from "./binary.js";
 import { isStatusTuple } from "./constants.js";
 import { InvalidResponseError } from "./errors.js";
+import { hasHeader } from "./headers.js";
 const BINARY_CONTENT_TYPE = "application/octet-stream";
 /**
  * Take ownership of caller-supplied response headers.
@@ -25,7 +26,7 @@ function toOwnHeaderRecord(value) {
     return record;
 }
 function hasContentType(headers) {
-    return Object.keys(headers).some((header) => header.toLowerCase() === "content-type");
+    return hasHeader(headers, "content-type");
 }
 /**
  * Detect the object response envelope `{ status, body, headers? }`.
@@ -35,8 +36,9 @@ function hasContentType(headers) {
  * payload. Callers who need to return such a shape as data should nest it or
  * use an explicit `[status, body]` tuple for the envelope. An object whose
  * `headers` is present but not a string record is deliberately NOT an envelope
- * and is delivered whole — plugins that inspect responses must use this same
- * rule (see `@schmock/validation`) or they will judge an undelivered payload.
+ * and is delivered whole — plugins that inspect responses read them through
+ * {@link getResponseParts}, which applies this same rule, or they will judge
+ * an undelivered payload.
  */
 function isResponseObject(value) {
     return (typeof value === "object" &&
@@ -56,27 +58,83 @@ function isStringRecord(value) {
         Object.values(value).every((entry) => typeof entry === "string"));
 }
 /**
- * Parse and normalize response result into Response object
- * Handles tuple format [status, body, headers], direct values, and response objects
+ * The single place a route result is split into status, body and headers.
+ * `parseResponse` and the exported `getResponseParts` both build on it, so
+ * what a plugin inspects is what core delivers.
  */
-export function parseResponse(result, routeConfig) {
-    let status = 200;
-    let body = result;
-    let headers = {};
-    let tupleFormat = false;
+function decomposeResponse(result) {
     // Handle already-formed response objects (from plugin error recovery)
     if (isResponseObject(result)) {
-        status = result.status;
-        body = result.body;
-        headers = toOwnHeaderRecord(result.headers);
-        tupleFormat = true;
+        return {
+            kind: "object",
+            status: result.status,
+            body: result.body,
+            rawHeaders: result.headers,
+        };
     }
-    else if (isStatusTuple(result)) {
-        // Handle tuple response format [status, body, headers?]
-        [status, body] = result;
-        headers = toOwnHeaderRecord(result[2]);
-        tupleFormat = true;
+    // Handle tuple response format [status, body, headers?]
+    if (isStatusTuple(result)) {
+        return {
+            kind: "tuple",
+            status: result[0],
+            body: result[1],
+            rawHeaders: result[2],
+        };
     }
+    return { kind: "plain", status: 200, body: result, rawHeaders: undefined };
+}
+function isNullish(value) {
+    return value === null || value === undefined;
+}
+/**
+ * Split a route or plugin result into the status, body and headers core will
+ * answer with, using exactly the guards `handle()` applies: an object is an
+ * envelope only when it has a numeric `status`, a `body`, and `headers` that
+ * are absent or a string record; anything else is delivered whole as the body.
+ *
+ * `body` is the element as carried (`null` stays `null`, though core sends no
+ * body for it), `status` is what core answers with (a plain `null` or
+ * `undefined` result is 204), and `headers` is a fresh copy, `{}` when the
+ * carried headers are not a string record.
+ */
+export function getResponseParts(response) {
+    const parts = decomposeResponse(response);
+    return {
+        kind: parts.kind,
+        status: parts.kind === "plain" && isNullish(parts.body) ? 204 : parts.status,
+        body: parts.body,
+        headers: isStringRecord(parts.rawHeaders) ? { ...parts.rawHeaders } : {},
+    };
+}
+/**
+ * Put `body` in place of the body `response` carries, keeping its shape: a
+ * tuple stays a tuple of the same length, an envelope keeps its status and
+ * headers (other properties are dropped, as core ignores them), and a plain
+ * result is replaced by `body` itself. Never mutates `response`.
+ */
+export function replaceResponseBody(response, body) {
+    if (isResponseObject(response)) {
+        return response.headers === undefined
+            ? { status: response.status, body }
+            : { status: response.status, body, headers: response.headers };
+    }
+    if (isStatusTuple(response)) {
+        return response.length === 3
+            ? [response[0], body, response[2]]
+            : [response[0], body];
+    }
+    return body;
+}
+/**
+ * Parse and normalize response result into Response object
+ * Handles tuple format [status, body, headers], direct values, and response objects
+ */
+export function parseResponse(result, routeConfig) {
+    const parts = decomposeResponse(result);
+    let status = parts.status;
+    let body = parts.body;
+    const headers = toOwnHeaderRecord(parts.rawHeaders);
+    const tupleFormat = parts.kind !== "plain";
     // Handle null/undefined responses with 204 No Content
     // But don't auto-convert if tuple format was used (status was explicitly provided)
     if (body === null || body === undefined) {

package/dist/route-matcher.d.ts

@@ -24,4 +24,3 @@ export declare function findRoute(method: Schmock.HttpMethod, path: string, stat
  * captures are decoded afterwards, so a generator receives readable values.
  */
 export declare function extractParams(route: CompiledCallableRoute, path: string): Record<string, string>;
-//# sourceMappingURL=route-matcher.d.ts.map