@schmock/core 1.9.0 → 1.9.1

package/dist/builder.d.ts

@@ -39,45 +39,5 @@ export declare class CallableMockInstance {
      * @private
      */
     private applyDelay;
-    /**
-     * Parse and normalize response result into Response object
-     * Handles tuple format [status, body, headers], direct values, and response objects
-     * @param result - Raw result from generator or plugin
-     * @param routeConfig - Route configuration for content-type defaults
-     * @returns Normalized Response object with status, body, and headers
-     * @private
-     */
-    private parseResponse;
-    /**
-     * Run all registered plugins in sequence
-     * First plugin to set response becomes generator, subsequent plugins transform
-     * Handles plugin errors via onError hooks
-     * @param context - Plugin context with request details
-     * @param initialResponse - Initial response from route generator
-     * @param _routeConfig - Route config (unused but kept for signature)
-     * @param _requestId - Request ID (unused but kept for signature)
-     * @returns Updated context and final response after all plugins
-     * @private
-     */
-    private runPluginPipeline;
-    /**
-     * Find a route that matches the given method and path
-     * Uses two-pass matching: static routes first, then parameterized routes
-     * Matches routes in registration order (first registered wins)
-     * @param method - HTTP method to match
-     * @param path - Request path to match
-     * @returns Matched compiled route or undefined if no match
-     * @private
-     */
-    private findRoute;
-    /**
-     * Extract parameter values from path based on route pattern
-     * Maps capture groups from regex match to parameter names
-     * @param route - Compiled route with pattern and param names
-     * @param path - Request path to extract values from
-     * @returns Object mapping parameter names to extracted values
-     * @private
-     */
-    private extractParams;
 }
 //# sourceMappingURL=builder.d.ts.map

package/dist/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAkFA;;;;GAIG;AACH,qBAAa,oBAAoB;IAYnB,OAAO,CAAC,YAAY;IAXhC,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,WAAW,CAA2C;IAC9D,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,UAAU,CAAiC;IAEnD,OAAO,CAAC,SAAS,CAAoC;gBAEjC,YAAY,GAAE,OAAO,CAAC,YAAiB;IAa3D,WAAW,CACT,KAAK,EAAE,OAAO,CAAC,QAAQ,EACvB,SAAS,EAAE,OAAO,CAAC,SAAS,EAC5B,MAAM,EAAE,OAAO,CAAC,WAAW,GAC1B,IAAI;IAqFP,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,oBAAoB,GAAG,IAAI;IAIvD,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI;IAoBlC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE;IAS5E,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAS3D,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;IAS7D,WAAW,CACT,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAC3B,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,GAAG,SAAS;IAYpC,SAAS,IAAI,OAAO,CAAC,SAAS,EAAE;IAQhC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAMnC,EAAE,CAAC,CAAC,SAAS,OAAO,CAAC,YAAY,EAC/B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GACnD,IAAI;IAUP,GAAG,CAAC,CAAC,SAAS,OAAO,CAAC,YAAY,EAChC,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GACnD,IAAI;IAKP,OAAO,CAAC,IAAI;IAWZ,KAAK,IAAI,IAAI;IAeb,YAAY,IAAI,IAAI;IAKpB,UAAU,IAAI,IAAI;IAWlB,MAAM,CAAC,IAAI,SAAI,EAAE,QAAQ,SAAc,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;IAuCrE,KAAK,IAAI,IAAI;IAUP,MAAM,CACV,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,GAC/B,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;IAgN5B;;;;OAIG;YACW,UAAU;IAgBxB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAwDrB;;;;;;;;;;OAUG;YACW,iBAAiB;IAqG/B;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS;IA0BjB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;CActB"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAuDA;;;;GAIG;AACH,qBAAa,oBAAoB;IAYnB,OAAO,CAAC,YAAY;IAXhC,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,WAAW,CAA2C;IAC9D,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,UAAU,CAAiC;IAEnD,OAAO,CAAC,SAAS,CAAoC;gBAEjC,YAAY,GAAE,OAAO,CAAC,YAAiB;IAa3D,WAAW,CACT,KAAK,EAAE,OAAO,CAAC,QAAQ,EACvB,SAAS,EAAE,OAAO,CAAC,SAAS,EAC5B,MAAM,EAAE,OAAO,CAAC,WAAW,GAC1B,IAAI;IAqFP,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,oBAAoB,GAAG,IAAI;IAIvD,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI;IAoBlC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE;IAS5E,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAS3D,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;IAS7D,WAAW,CACT,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,EAC3B,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,GAAG,SAAS;IAYpC,SAAS,IAAI,OAAO,CAAC,SAAS,EAAE;IAQhC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAMnC,EAAE,CAAC,CAAC,SAAS,OAAO,CAAC,YAAY,EAC/B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GACnD,IAAI;IAUP,GAAG,CAAC,CAAC,SAAS,OAAO,CAAC,YAAY,EAChC,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GACnD,IAAI;IAKP,OAAO,CAAC,IAAI;IAWZ,KAAK,IAAI,IAAI;IAeb,YAAY,IAAI,IAAI;IAKpB,UAAU,IAAI,IAAI;IAWlB,MAAM,CAAC,IAAI,SAAI,EAAE,QAAQ,SAAc,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;IAuCrE,KAAK,IAAI,IAAI;IAUP,MAAM,CACV,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,GAC/B,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;IAqN5B;;;;OAIG;YACW,UAAU;CAezB"}

package/dist/builder.js

@@ -1,11 +1,11 @@
 import { createServer } from "node:http";
-import { isStatusTuple, toHttpMethod } from "./constants.js";
-import { PluginError, RouteDefinitionError, RouteNotFoundError, SchmockError, } from "./errors.js";
+import { toHttpMethod } from "./constants.js";
+import { errorMessage, RouteDefinitionError, RouteNotFoundError, SchmockError, } from "./errors.js";
 import { collectBody, parseNodeHeaders, parseNodeQuery, writeSchmockResponse, } from "./http-helpers.js";
 import { parseRouteKey } from "./parser.js";
-function errorMessage(error) {
-    return error instanceof Error ? error.message : "Unknown error";
-}
+import { runPluginPipeline } from "./plugin-pipeline.js";
+import { parseResponse } from "./response-parser.js";
+import { extractParams, findRoute, isGeneratorFunction, } from "./route-matcher.js";
 /**
  * Debug logger that respects debug mode configuration
  */
@@ -37,15 +37,6 @@ class DebugLogger {
         console.timeEnd(`[SCHMOCK] ${label}`);
     }
 }
-function isGeneratorFunction(gen) {
-    return typeof gen === "function";
-}
-function isResponseObject(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "status" in value &&
-        "body" in value);
-}
 /**
  * Callable mock instance that implements the new API.
  *
@@ -324,7 +315,7 @@ export class CallableMockInstance {
                 requestPath = stripped.startsWith("/") ? stripped : `/${stripped}`;
             }
             // Find matching route
-            const matchedRoute = this.findRoute(method, requestPath);
+            const matchedRoute = findRoute(method, requestPath, this.staticRoutes, this.routes);
             if (!matchedRoute) {
                 this.logger.log("route", `[${requestId}] No route found for ${method} ${requestPath}`);
                 this.emit("request:notfound", { method, path: requestPath });
@@ -345,7 +336,7 @@ export class CallableMockInstance {
             }
             this.logger.log("route", `[${requestId}] Matched route: ${method} ${matchedRoute.path}`);
             // Extract parameters from the matched route
-            const params = this.extractParams(matchedRoute, requestPath);
+            const params = extractParams(matchedRoute, requestPath);
             this.emit("request:match", {
                 method,
                 path: requestPath,
@@ -383,7 +374,7 @@ export class CallableMockInstance {
             };
             // Run plugin pipeline to transform the response
             try {
-                const pipelineResult = await this.runPluginPipeline(pluginContext, result, matchedRoute.config, requestId);
+                const pipelineResult = await runPluginPipeline(this.plugins, pluginContext, result, this.logger);
                 pluginContext = pipelineResult.context;
                 result = pipelineResult.response;
             }
@@ -392,7 +383,7 @@ export class CallableMockInstance {
                 throw error;
             }
             // Parse and prepare response
-            const response = this.parseResponse(result, matchedRoute.config);
+            const response = parseResponse(result, matchedRoute.config);
             // Apply delay (route-level overrides global)
             await this.applyDelay(matchedRoute.config.delay);
             // Record request in history
@@ -455,173 +446,4 @@ export class CallableMockInstance {
             : effectiveDelay;
         await new Promise((resolve) => setTimeout(resolve, ms));
     }
-    /**
-     * Parse and normalize response result into Response object
-     * Handles tuple format [status, body, headers], direct values, and response objects
-     * @param result - Raw result from generator or plugin
-     * @param routeConfig - Route configuration for content-type defaults
-     * @returns Normalized Response object with status, body, and headers
-     * @private
-     */
-    parseResponse(result, routeConfig) {
-        let status = 200;
-        let body = result;
-        let headers = {};
-        let tupleFormat = false;
-        // Handle already-formed response objects (from plugin error recovery)
-        if (isResponseObject(result)) {
-            return {
-                status: result.status,
-                body: result.body,
-                headers: result.headers || {},
-            };
-        }
-        // Handle tuple response format [status, body, headers?]
-        if (isStatusTuple(result)) {
-            [status, body, headers = {}] = result;
-            tupleFormat = true;
-        }
-        // 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) {
-            if (!tupleFormat) {
-                status = status === 200 ? 204 : status; // Only change to 204 if status wasn't explicitly set via tuple
-            }
-            body = undefined; // Ensure body is undefined for null responses
-        }
-        // Add content-type header from route config if it exists and headers don't already have it
-        // But only if this isn't a tuple response (where headers are explicitly controlled)
-        if (!headers["content-type"] && routeConfig.contentType && !tupleFormat) {
-            headers["content-type"] = routeConfig.contentType;
-            // Handle special conversion cases when contentType is explicitly set
-            if (routeConfig.contentType === "text/plain" && body !== undefined) {
-                if (typeof body === "object" && !Buffer.isBuffer(body)) {
-                    body = JSON.stringify(body);
-                }
-                else if (typeof body !== "string") {
-                    body = String(body);
-                }
-            }
-        }
-        return {
-            status,
-            body,
-            headers,
-        };
-    }
-    /**
-     * Run all registered plugins in sequence
-     * First plugin to set response becomes generator, subsequent plugins transform
-     * Handles plugin errors via onError hooks
-     * @param context - Plugin context with request details
-     * @param initialResponse - Initial response from route generator
-     * @param _routeConfig - Route config (unused but kept for signature)
-     * @param _requestId - Request ID (unused but kept for signature)
-     * @returns Updated context and final response after all plugins
-     * @private
-     */
-    async runPluginPipeline(context, initialResponse, _routeConfig, _requestId) {
-        let currentContext = context;
-        let response = initialResponse;
-        this.logger.log("pipeline", `Running plugin pipeline for ${this.plugins.length} plugins`);
-        for (const plugin of this.plugins) {
-            this.logger.log("pipeline", `Processing plugin: ${plugin.name}`);
-            try {
-                const result = await plugin.process(currentContext, response);
-                if (!result || !result.context) {
-                    throw new Error(`Plugin ${plugin.name} didn't return valid result`);
-                }
-                currentContext = result.context;
-                // First plugin to set response becomes the generator
-                if (result.response !== undefined &&
-                    (response === undefined || response === null)) {
-                    this.logger.log("pipeline", `Plugin ${plugin.name} generated response`);
-                    response = result.response;
-                }
-                else if (result.response !== undefined && response !== undefined) {
-                    this.logger.log("pipeline", `Plugin ${plugin.name} transformed response`);
-                    response = result.response;
-                }
-            }
-            catch (error) {
-                this.logger.log("pipeline", `Plugin ${plugin.name} failed: ${errorMessage(error)}`);
-                // Try error handling if plugin has onError hook
-                if (plugin.onError) {
-                    try {
-                        const pluginError = error instanceof Error ? error : new Error(errorMessage(error));
-                        const errorResult = await plugin.onError(pluginError, currentContext);
-                        if (errorResult) {
-                            this.logger.log("pipeline", `Plugin ${plugin.name} handled error`);
-                            // Error return → transform the thrown error
-                            if (errorResult instanceof Error) {
-                                throw new PluginError(plugin.name, errorResult);
-                            }
-                            // ResponseResult return → recover, stop pipeline
-                            if (typeof errorResult === "object" &&
-                                errorResult !== null &&
-                                "status" in errorResult) {
-                                response = errorResult;
-                                break;
-                            }
-                        }
-                        // void/falsy return → propagate original error below
-                    }
-                    catch (hookError) {
-                        // If the hook itself threw (including our PluginError above), re-throw it
-                        if (hookError instanceof PluginError) {
-                            throw hookError;
-                        }
-                        this.logger.log("pipeline", `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`);
-                    }
-                }
-                const cause = error instanceof Error ? error : new Error(errorMessage(error));
-                throw new PluginError(plugin.name, cause);
-            }
-        }
-        return { context: currentContext, response };
-    }
-    /**
-     * Find a route that matches the given method and path
-     * Uses two-pass matching: static routes first, then parameterized routes
-     * Matches routes in registration order (first registered wins)
-     * @param method - HTTP method to match
-     * @param path - Request path to match
-     * @returns Matched compiled route or undefined if no match
-     * @private
-     */
-    findRoute(method, path) {
-        // O(1) lookup for static routes
-        const normalizedPath = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
-        const staticMatch = this.staticRoutes.get(`${method} ${normalizedPath}`);
-        if (staticMatch) {
-            return staticMatch;
-        }
-        // Fall through to parameterized route scan
-        for (const route of this.routes) {
-            if (route.method === method &&
-                route.params.length > 0 &&
-                route.pattern.test(path)) {
-                return route;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Extract parameter values from path based on route pattern
-     * Maps capture groups from regex match to parameter names
-     * @param route - Compiled route with pattern and param names
-     * @param path - Request path to extract values from
-     * @returns Object mapping parameter names to extracted values
-     * @private
-     */
-    extractParams(route, path) {
-        const match = path.match(route.pattern);
-        if (!match)
-            return {};
-        const params = {};
-        route.params.forEach((param, index) => {
-            params[param] = match[index + 1];
-        });
-        return params;
-    }
 }

package/dist/errors.d.ts

@@ -1,3 +1,4 @@
+export declare function errorMessage(error: unknown): string;
 /**
  * Base error class for all Schmock errors
  */

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;aAGnB,IAAI,EAAE,MAAM;aACZ,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,YAAA;CAQpC;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAOzC;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,YAAY;gBACnC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQ7C;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,YAAY;gBAC3C,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAQxC;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,YAAY;gBAC/B,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAO7C;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;gBACxC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQ7C;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;gBACzC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAQnE;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;gBACzC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO;CAQ1D;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;CAQ7D"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEnD;AAED;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;aAGnB,IAAI,EAAE,MAAM;aACZ,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,YAAA;CAQpC;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAOzC;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,YAAY;gBACnC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQ7C;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,YAAY;gBAC3C,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAQxC;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,YAAY;gBAC/B,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAO7C;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;gBACxC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQ7C;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;gBACzC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAQnE;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;gBACzC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO;CAQ1D;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;CAQ7D"}

package/dist/errors.js

@@ -1,3 +1,6 @@
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : "Unknown error";
+}
 /**
  * Base error class for all Schmock errors
  */

package/dist/plugin-pipeline.d.ts

@@ -0,0 +1,15 @@
+/** Structural typing — DebugLogger satisfies this without an import */
+interface PipelineLogger {
+    log(category: string, message: string, data?: unknown): void;
+}
+/**
+ * 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<{
+    context: Schmock.PluginContext;
+    response?: unknown;
+}>;
+export {};
+//# sourceMappingURL=plugin-pipeline.d.ts.map

package/dist/plugin-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-pipeline.d.ts","sourceRoot":"","sources":["../src/plugin-pipeline.ts"],"names":[],"mappings":"AAEA,uEAAuE;AACvE,UAAU,cAAc;IACtB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9D;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,EACzB,OAAO,EAAE,OAAO,CAAC,aAAa,EAC9B,eAAe,EAAE,OAAO,EACxB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAkFjE"}

package/dist/plugin-pipeline.js

@@ -0,0 +1,66 @@
+import { errorMessage, PluginError } from "./errors.js";
+/**
+ * Run all registered plugins in sequence
+ * First plugin to set response becomes generator, subsequent plugins transform
+ * Handles plugin errors via onError hooks
+ */
+export async function runPluginPipeline(plugins, context, initialResponse, logger) {
+    let currentContext = context;
+    let response = initialResponse;
+    logger.log("pipeline", `Running plugin pipeline for ${plugins.length} plugins`);
+    for (const plugin of plugins) {
+        logger.log("pipeline", `Processing plugin: ${plugin.name}`);
+        try {
+            const result = await plugin.process(currentContext, response);
+            if (!result || !result.context) {
+                throw new Error(`Plugin ${plugin.name} didn't return valid result`);
+            }
+            currentContext = result.context;
+            // First plugin to set response becomes the generator
+            if (result.response !== undefined &&
+                (response === undefined || response === null)) {
+                logger.log("pipeline", `Plugin ${plugin.name} generated response`);
+                response = result.response;
+            }
+            else if (result.response !== undefined && response !== undefined) {
+                logger.log("pipeline", `Plugin ${plugin.name} transformed response`);
+                response = result.response;
+            }
+        }
+        catch (error) {
+            logger.log("pipeline", `Plugin ${plugin.name} failed: ${errorMessage(error)}`);
+            // Try error handling if plugin has onError hook
+            if (plugin.onError) {
+                try {
+                    const pluginError = error instanceof Error ? error : new Error(errorMessage(error));
+                    const errorResult = await plugin.onError(pluginError, currentContext);
+                    if (errorResult) {
+                        logger.log("pipeline", `Plugin ${plugin.name} handled error`);
+                        // Error return → transform the thrown error
+                        if (errorResult instanceof Error) {
+                            throw new PluginError(plugin.name, errorResult);
+                        }
+                        // ResponseResult return → recover, stop pipeline
+                        if (typeof errorResult === "object" &&
+                            errorResult !== null &&
+                            "status" in errorResult) {
+                            response = errorResult;
+                            break;
+                        }
+                    }
+                    // void/falsy return → propagate original error below
+                }
+                catch (hookError) {
+                    // If the hook itself threw (including our PluginError above), re-throw it
+                    if (hookError instanceof PluginError) {
+                        throw hookError;
+                    }
+                    logger.log("pipeline", `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`);
+                }
+            }
+            const cause = error instanceof Error ? error : new Error(errorMessage(error));
+            throw new PluginError(plugin.name, cause);
+        }
+    }
+    return { context: currentContext, response };
+}

package/dist/response-parser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-parser.d.ts","sourceRoot":"","sources":["../src/response-parser.ts"],"names":[],"mappings":"AAeA;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,OAAO,EACf,WAAW,EAAE,OAAO,CAAC,WAAW,GAC/B,OAAO,CAAC,QAAQ,CAmDlB"}

package/dist/response-parser.js

@@ -0,0 +1,57 @@
+import { isStatusTuple } from "./constants.js";
+function isResponseObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "status" in value &&
+        "body" in value);
+}
+/**
+ * Parse and normalize response result into Response object
+ * Handles tuple format [status, body, headers], direct values, and response objects
+ */
+export function parseResponse(result, routeConfig) {
+    let status = 200;
+    let body = result;
+    let headers = {};
+    let tupleFormat = false;
+    // Handle already-formed response objects (from plugin error recovery)
+    if (isResponseObject(result)) {
+        return {
+            status: result.status,
+            body: result.body,
+            headers: result.headers || {},
+        };
+    }
+    // Handle tuple response format [status, body, headers?]
+    if (isStatusTuple(result)) {
+        [status, body, headers = {}] = result;
+        tupleFormat = true;
+    }
+    // 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) {
+        if (!tupleFormat) {
+            status = status === 200 ? 204 : status; // Only change to 204 if status wasn't explicitly set via tuple
+        }
+        body = undefined; // Ensure body is undefined for null responses
+    }
+    // Add content-type header from route config if it exists and headers don't already have it
+    // But only if this isn't a tuple response (where headers are explicitly controlled)
+    if (!headers["content-type"] && routeConfig.contentType && !tupleFormat) {
+        headers["content-type"] = routeConfig.contentType;
+        // Handle special conversion cases when contentType is explicitly set
+        if (routeConfig.contentType === "text/plain" && body !== undefined) {
+            if (typeof body === "object" && !Buffer.isBuffer(body)) {
+                body = JSON.stringify(body);
+            }
+            else if (typeof body !== "string") {
+                body = String(body);
+            }
+        }
+    }
+    return {
+        status,
+        body,
+        headers,
+    };
+}

package/dist/route-matcher.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Compiled callable route with pattern matching
+ */
+export interface CompiledCallableRoute {
+    pattern: RegExp;
+    params: string[];
+    method: Schmock.HttpMethod;
+    path: string;
+    generator: Schmock.Generator;
+    config: Schmock.RouteConfig;
+}
+export declare function isGeneratorFunction(gen: Schmock.Generator): gen is Schmock.GeneratorFunction;
+/**
+ * Find a route that matches the given method and path
+ * Uses two-pass matching: static routes first, then parameterized routes
+ * Matches routes in registration order (first registered wins)
+ */
+export declare function findRoute(method: Schmock.HttpMethod, path: string, staticRoutes: Map<string, CompiledCallableRoute>, routes: CompiledCallableRoute[]): CompiledCallableRoute | undefined;
+/**
+ * Extract parameter values from path based on route pattern
+ * Maps capture groups from regex match to parameter names
+ */
+export declare function extractParams(route: CompiledCallableRoute, path: string): Record<string, string>;
+//# sourceMappingURL=route-matcher.d.ts.map

package/dist/route-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-matcher.d.ts","sourceRoot":"","sources":["../src/route-matcher.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC;CAC7B;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,OAAO,CAAC,SAAS,GACrB,GAAG,IAAI,OAAO,CAAC,iBAAiB,CAElC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,EAChD,MAAM,EAAE,qBAAqB,EAAE,GAC9B,qBAAqB,GAAG,SAAS,CAqBnC;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,qBAAqB,EAC5B,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUxB"}

package/dist/route-matcher.js

@@ -0,0 +1,39 @@
+export function isGeneratorFunction(gen) {
+    return typeof gen === "function";
+}
+/**
+ * Find a route that matches the given method and path
+ * Uses two-pass matching: static routes first, then parameterized routes
+ * Matches routes in registration order (first registered wins)
+ */
+export function findRoute(method, path, staticRoutes, routes) {
+    // O(1) lookup for static routes
+    const normalizedPath = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+    const staticMatch = staticRoutes.get(`${method} ${normalizedPath}`);
+    if (staticMatch) {
+        return staticMatch;
+    }
+    // Fall through to parameterized route scan
+    for (const route of routes) {
+        if (route.method === method &&
+            route.params.length > 0 &&
+            route.pattern.test(path)) {
+            return route;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract parameter values from path based on route pattern
+ * Maps capture groups from regex match to parameter names
+ */
+export function extractParams(route, path) {
+    const match = path.match(route.pattern);
+    if (!match)
+        return {};
+    const params = {};
+    route.params.forEach((param, index) => {
+        params[param] = match[index + 1];
+    });
+    return params;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/core",
   "description": "Core functionality for Schmock",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/builder.ts

@@ -1,8 +1,8 @@
 import type { Server } from "node:http";
 import { createServer } from "node:http";
-import { isStatusTuple, toHttpMethod } from "./constants.js";
+import { toHttpMethod } from "./constants.js";
 import {
-  PluginError,
+  errorMessage,
   RouteDefinitionError,
   RouteNotFoundError,
   SchmockError,
@@ -14,10 +14,14 @@ import {
   writeSchmockResponse,
 } from "./http-helpers.js";
 import { parseRouteKey } from "./parser.js";
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : "Unknown error";
-}
+import { runPluginPipeline } from "./plugin-pipeline.js";
+import { parseResponse } from "./response-parser.js";
+import type { CompiledCallableRoute } from "./route-matcher.js";
+import {
+  extractParams,
+  findRoute,
+  isGeneratorFunction,
+} from "./route-matcher.js";
 
 /**
  * Debug logger that respects debug mode configuration
@@ -49,37 +53,6 @@ class DebugLogger {
   }
 }
 
-/**
- * Compiled callable route with pattern matching
- */
-interface CompiledCallableRoute {
-  pattern: RegExp;
-  params: string[];
-  method: Schmock.HttpMethod;
-  path: string;
-  generator: Schmock.Generator;
-  config: Schmock.RouteConfig;
-}
-
-function isGeneratorFunction(
-  gen: Schmock.Generator,
-): gen is Schmock.GeneratorFunction {
-  return typeof gen === "function";
-}
-
-function isResponseObject(value: unknown): value is {
-  status: number;
-  body: unknown;
-  headers?: Record<string, string>;
-} {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "status" in value &&
-    "body" in value
-  );
-}
-
 /**
  * Callable mock instance that implements the new API.
  *
@@ -451,7 +424,12 @@ export class CallableMockInstance {
       }
 
       // Find matching route
-      const matchedRoute = this.findRoute(method, requestPath);
+      const matchedRoute = findRoute(
+        method,
+        requestPath,
+        this.staticRoutes,
+        this.routes,
+      );
 
       if (!matchedRoute) {
         this.logger.log(
@@ -481,7 +459,7 @@ export class CallableMockInstance {
       );
 
       // Extract parameters from the matched route
-      const params = this.extractParams(matchedRoute, requestPath);
+      const params = extractParams(matchedRoute, requestPath);
 
       this.emit("request:match", {
         method,
@@ -523,11 +501,11 @@ export class CallableMockInstance {
 
       // Run plugin pipeline to transform the response
       try {
-        const pipelineResult = await this.runPluginPipeline(
+        const pipelineResult = await runPluginPipeline(
+          this.plugins,
           pluginContext,
           result,
-          matchedRoute.config,
-          requestId,
+          this.logger,
         );
         pluginContext = pipelineResult.context;
         result = pipelineResult.response;
@@ -540,7 +518,7 @@ export class CallableMockInstance {
       }
 
       // Parse and prepare response
-      const response = this.parseResponse(result, matchedRoute.config);
+      const response = parseResponse(result, matchedRoute.config);
 
       // Apply delay (route-level overrides global)
       await this.applyDelay(matchedRoute.config.delay);
@@ -623,238 +601,4 @@ export class CallableMockInstance {
 
     await new Promise((resolve) => setTimeout(resolve, ms));
   }
-
-  /**
-   * Parse and normalize response result into Response object
-   * Handles tuple format [status, body, headers], direct values, and response objects
-   * @param result - Raw result from generator or plugin
-   * @param routeConfig - Route configuration for content-type defaults
-   * @returns Normalized Response object with status, body, and headers
-   * @private
-   */
-  private parseResponse(
-    result: unknown,
-    routeConfig: Schmock.RouteConfig,
-  ): Schmock.Response {
-    let status = 200;
-    let body: unknown = result;
-    let headers: Record<string, string> = {};
-
-    let tupleFormat = false;
-
-    // Handle already-formed response objects (from plugin error recovery)
-    if (isResponseObject(result)) {
-      return {
-        status: result.status,
-        body: result.body,
-        headers: result.headers || {},
-      };
-    }
-
-    // Handle tuple response format [status, body, headers?]
-    if (isStatusTuple(result)) {
-      [status, body, headers = {}] = result;
-      tupleFormat = true;
-    }
-
-    // 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) {
-      if (!tupleFormat) {
-        status = status === 200 ? 204 : status; // Only change to 204 if status wasn't explicitly set via tuple
-      }
-      body = undefined; // Ensure body is undefined for null responses
-    }
-
-    // Add content-type header from route config if it exists and headers don't already have it
-    // But only if this isn't a tuple response (where headers are explicitly controlled)
-    if (!headers["content-type"] && routeConfig.contentType && !tupleFormat) {
-      headers["content-type"] = routeConfig.contentType;
-
-      // Handle special conversion cases when contentType is explicitly set
-      if (routeConfig.contentType === "text/plain" && body !== undefined) {
-        if (typeof body === "object" && !Buffer.isBuffer(body)) {
-          body = JSON.stringify(body);
-        } else if (typeof body !== "string") {
-          body = String(body);
-        }
-      }
-    }
-
-    return {
-      status,
-      body,
-      headers,
-    };
-  }
-
-  /**
-   * Run all registered plugins in sequence
-   * First plugin to set response becomes generator, subsequent plugins transform
-   * Handles plugin errors via onError hooks
-   * @param context - Plugin context with request details
-   * @param initialResponse - Initial response from route generator
-   * @param _routeConfig - Route config (unused but kept for signature)
-   * @param _requestId - Request ID (unused but kept for signature)
-   * @returns Updated context and final response after all plugins
-   * @private
-   */
-  private async runPluginPipeline(
-    context: Schmock.PluginContext,
-    initialResponse?: unknown,
-    _routeConfig?: Schmock.RouteConfig,
-    _requestId?: string,
-  ): Promise<{ context: Schmock.PluginContext; response?: unknown }> {
-    let currentContext = context;
-    let response: unknown = initialResponse;
-
-    this.logger.log(
-      "pipeline",
-      `Running plugin pipeline for ${this.plugins.length} plugins`,
-    );
-
-    for (const plugin of this.plugins) {
-      this.logger.log("pipeline", `Processing plugin: ${plugin.name}`);
-
-      try {
-        const result = await plugin.process(currentContext, response);
-
-        if (!result || !result.context) {
-          throw new Error(`Plugin ${plugin.name} didn't return valid result`);
-        }
-
-        currentContext = result.context;
-
-        // First plugin to set response becomes the generator
-        if (
-          result.response !== undefined &&
-          (response === undefined || response === null)
-        ) {
-          this.logger.log(
-            "pipeline",
-            `Plugin ${plugin.name} generated response`,
-          );
-          response = result.response;
-        } else if (result.response !== undefined && response !== undefined) {
-          this.logger.log(
-            "pipeline",
-            `Plugin ${plugin.name} transformed response`,
-          );
-          response = result.response;
-        }
-      } catch (error) {
-        this.logger.log(
-          "pipeline",
-          `Plugin ${plugin.name} failed: ${errorMessage(error)}`,
-        );
-
-        // Try error handling if plugin has onError hook
-        if (plugin.onError) {
-          try {
-            const pluginError =
-              error instanceof Error ? error : new Error(errorMessage(error));
-            const errorResult = await plugin.onError(
-              pluginError,
-              currentContext,
-            );
-            if (errorResult) {
-              this.logger.log(
-                "pipeline",
-                `Plugin ${plugin.name} handled error`,
-              );
-
-              // Error return → transform the thrown error
-              if (errorResult instanceof Error) {
-                throw new PluginError(plugin.name, errorResult);
-              }
-
-              // ResponseResult return → recover, stop pipeline
-              if (
-                typeof errorResult === "object" &&
-                errorResult !== null &&
-                "status" in errorResult
-              ) {
-                response = errorResult;
-                break;
-              }
-            }
-            // void/falsy return → propagate original error below
-          } catch (hookError) {
-            // If the hook itself threw (including our PluginError above), re-throw it
-            if (hookError instanceof PluginError) {
-              throw hookError;
-            }
-            this.logger.log(
-              "pipeline",
-              `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`,
-            );
-          }
-        }
-
-        const cause =
-          error instanceof Error ? error : new Error(errorMessage(error));
-        throw new PluginError(plugin.name, cause);
-      }
-    }
-
-    return { context: currentContext, response };
-  }
-
-  /**
-   * Find a route that matches the given method and path
-   * Uses two-pass matching: static routes first, then parameterized routes
-   * Matches routes in registration order (first registered wins)
-   * @param method - HTTP method to match
-   * @param path - Request path to match
-   * @returns Matched compiled route or undefined if no match
-   * @private
-   */
-  private findRoute(
-    method: Schmock.HttpMethod,
-    path: string,
-  ): CompiledCallableRoute | undefined {
-    // O(1) lookup for static routes
-    const normalizedPath =
-      path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
-    const staticMatch = this.staticRoutes.get(`${method} ${normalizedPath}`);
-    if (staticMatch) {
-      return staticMatch;
-    }
-
-    // Fall through to parameterized route scan
-    for (const route of this.routes) {
-      if (
-        route.method === method &&
-        route.params.length > 0 &&
-        route.pattern.test(path)
-      ) {
-        return route;
-      }
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Extract parameter values from path based on route pattern
-   * Maps capture groups from regex match to parameter names
-   * @param route - Compiled route with pattern and param names
-   * @param path - Request path to extract values from
-   * @returns Object mapping parameter names to extracted values
-   * @private
-   */
-  private extractParams(
-    route: CompiledCallableRoute,
-    path: string,
-  ): Record<string, string> {
-    const match = path.match(route.pattern);
-    if (!match) return {};
-
-    const params: Record<string, string> = {};
-    route.params.forEach((param, index) => {
-      params[param] = match[index + 1];
-    });
-
-    return params;
-  }
 }

package/src/errors.ts

@@ -1,3 +1,7 @@
+export function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+
 /**
  * Base error class for all Schmock errors
  */

package/src/plugin-pipeline.ts

@@ -0,0 +1,100 @@
+import { errorMessage, PluginError } from "./errors.js";
+
+/** Structural typing — DebugLogger satisfies this without an import */
+interface PipelineLogger {
+  log(category: string, message: string, data?: unknown): void;
+}
+
+/**
+ * Run all registered plugins in sequence
+ * First plugin to set response becomes generator, subsequent plugins transform
+ * Handles plugin errors via onError hooks
+ */
+export async function runPluginPipeline(
+  plugins: Schmock.Plugin[],
+  context: Schmock.PluginContext,
+  initialResponse: unknown,
+  logger: PipelineLogger,
+): Promise<{ context: Schmock.PluginContext; response?: unknown }> {
+  let currentContext = context;
+  let response: unknown = initialResponse;
+
+  logger.log(
+    "pipeline",
+    `Running plugin pipeline for ${plugins.length} plugins`,
+  );
+
+  for (const plugin of plugins) {
+    logger.log("pipeline", `Processing plugin: ${plugin.name}`);
+
+    try {
+      const result = await plugin.process(currentContext, response);
+
+      if (!result || !result.context) {
+        throw new Error(`Plugin ${plugin.name} didn't return valid result`);
+      }
+
+      currentContext = result.context;
+
+      // First plugin to set response becomes the generator
+      if (
+        result.response !== undefined &&
+        (response === undefined || response === null)
+      ) {
+        logger.log("pipeline", `Plugin ${plugin.name} generated response`);
+        response = result.response;
+      } else if (result.response !== undefined && response !== undefined) {
+        logger.log("pipeline", `Plugin ${plugin.name} transformed response`);
+        response = result.response;
+      }
+    } catch (error) {
+      logger.log(
+        "pipeline",
+        `Plugin ${plugin.name} failed: ${errorMessage(error)}`,
+      );
+
+      // Try error handling if plugin has onError hook
+      if (plugin.onError) {
+        try {
+          const pluginError =
+            error instanceof Error ? error : new Error(errorMessage(error));
+          const errorResult = await plugin.onError(pluginError, currentContext);
+          if (errorResult) {
+            logger.log("pipeline", `Plugin ${plugin.name} handled error`);
+
+            // Error return → transform the thrown error
+            if (errorResult instanceof Error) {
+              throw new PluginError(plugin.name, errorResult);
+            }
+
+            // ResponseResult return → recover, stop pipeline
+            if (
+              typeof errorResult === "object" &&
+              errorResult !== null &&
+              "status" in errorResult
+            ) {
+              response = errorResult;
+              break;
+            }
+          }
+          // void/falsy return → propagate original error below
+        } catch (hookError) {
+          // If the hook itself threw (including our PluginError above), re-throw it
+          if (hookError instanceof PluginError) {
+            throw hookError;
+          }
+          logger.log(
+            "pipeline",
+            `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`,
+          );
+        }
+      }
+
+      const cause =
+        error instanceof Error ? error : new Error(errorMessage(error));
+      throw new PluginError(plugin.name, cause);
+    }
+  }
+
+  return { context: currentContext, response };
+}

package/src/response-parser.ts

@@ -0,0 +1,74 @@
+import { isStatusTuple } from "./constants.js";
+
+function isResponseObject(value: unknown): value is {
+  status: number;
+  body: unknown;
+  headers?: Record<string, string>;
+} {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "status" in value &&
+    "body" in value
+  );
+}
+
+/**
+ * Parse and normalize response result into Response object
+ * Handles tuple format [status, body, headers], direct values, and response objects
+ */
+export function parseResponse(
+  result: unknown,
+  routeConfig: Schmock.RouteConfig,
+): Schmock.Response {
+  let status = 200;
+  let body: unknown = result;
+  let headers: Record<string, string> = {};
+
+  let tupleFormat = false;
+
+  // Handle already-formed response objects (from plugin error recovery)
+  if (isResponseObject(result)) {
+    return {
+      status: result.status,
+      body: result.body,
+      headers: result.headers || {},
+    };
+  }
+
+  // Handle tuple response format [status, body, headers?]
+  if (isStatusTuple(result)) {
+    [status, body, headers = {}] = result;
+    tupleFormat = true;
+  }
+
+  // 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) {
+    if (!tupleFormat) {
+      status = status === 200 ? 204 : status; // Only change to 204 if status wasn't explicitly set via tuple
+    }
+    body = undefined; // Ensure body is undefined for null responses
+  }
+
+  // Add content-type header from route config if it exists and headers don't already have it
+  // But only if this isn't a tuple response (where headers are explicitly controlled)
+  if (!headers["content-type"] && routeConfig.contentType && !tupleFormat) {
+    headers["content-type"] = routeConfig.contentType;
+
+    // Handle special conversion cases when contentType is explicitly set
+    if (routeConfig.contentType === "text/plain" && body !== undefined) {
+      if (typeof body === "object" && !Buffer.isBuffer(body)) {
+        body = JSON.stringify(body);
+      } else if (typeof body !== "string") {
+        body = String(body);
+      }
+    }
+  }
+
+  return {
+    status,
+    body,
+    headers,
+  };
+}

package/src/route-matcher.ts

@@ -0,0 +1,69 @@
+/**
+ * Compiled callable route with pattern matching
+ */
+export interface CompiledCallableRoute {
+  pattern: RegExp;
+  params: string[];
+  method: Schmock.HttpMethod;
+  path: string;
+  generator: Schmock.Generator;
+  config: Schmock.RouteConfig;
+}
+
+export function isGeneratorFunction(
+  gen: Schmock.Generator,
+): gen is Schmock.GeneratorFunction {
+  return typeof gen === "function";
+}
+
+/**
+ * Find a route that matches the given method and path
+ * Uses two-pass matching: static routes first, then parameterized routes
+ * Matches routes in registration order (first registered wins)
+ */
+export function findRoute(
+  method: Schmock.HttpMethod,
+  path: string,
+  staticRoutes: Map<string, CompiledCallableRoute>,
+  routes: CompiledCallableRoute[],
+): CompiledCallableRoute | undefined {
+  // O(1) lookup for static routes
+  const normalizedPath =
+    path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+  const staticMatch = staticRoutes.get(`${method} ${normalizedPath}`);
+  if (staticMatch) {
+    return staticMatch;
+  }
+
+  // Fall through to parameterized route scan
+  for (const route of routes) {
+    if (
+      route.method === method &&
+      route.params.length > 0 &&
+      route.pattern.test(path)
+    ) {
+      return route;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Extract parameter values from path based on route pattern
+ * Maps capture groups from regex match to parameter names
+ */
+export function extractParams(
+  route: CompiledCallableRoute,
+  path: string,
+): Record<string, string> {
+  const match = path.match(route.pattern);
+  if (!match) return {};
+
+  const params: Record<string, string> = {};
+  route.params.forEach((param, index) => {
+    params[param] = match[index + 1];
+  });
+
+  return params;
+}