@schmock/core 1.0.0 → 1.0.2

package/dist/builder.d.ts

@@ -1,3 +1,4 @@
+import type { Generator, GlobalConfig, HttpMethod, Plugin, RequestOptions, Response, RouteConfig, RouteKey } from "./types.js";
 /**
  * Callable mock instance that implements the new API.
  *
@@ -8,10 +9,10 @@ export declare class CallableMockInstance {
     private routes;
     private plugins;
     private logger;
-    constructor(globalConfig?: Schmock.GlobalConfig);
-    defineRoute(route: Schmock.RouteKey, generator: Schmock.Generator, config: Schmock.RouteConfig): this;
-    pipe(plugin: Schmock.Plugin): this;
-    handle(method: Schmock.HttpMethod, path: string, options?: Schmock.RequestOptions): Promise<Schmock.Response>;
+    constructor(globalConfig?: GlobalConfig);
+    defineRoute(route: RouteKey, generator: Generator, config: RouteConfig): this;
+    pipe(plugin: Plugin): this;
+    handle(method: HttpMethod, path: string, options?: RequestOptions): Promise<Response>;
     /**
      * Apply configured response delay
      * Supports both fixed delays and random delays within a range

package/dist/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAkDA;;;;GAIG;AACH,qBAAa,oBAAoB;IAKnB,OAAO,CAAC,YAAY;IAJhC,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,MAAM,CAAc;gBAER,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;IA4DP,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI;IAe5B,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;IAmL5B;;;;OAIG;YACW,UAAU;IAcxB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IA6DrB;;;;;;;;;;OAUG;YACW,iBAAiB;IAmF/B;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS;IA+BjB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;CActB"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,SAAS,EAET,YAAY,EACZ,UAAU,EACV,MAAM,EAGN,cAAc,EACd,QAAQ,EACR,WAAW,EACX,QAAQ,EACT,MAAM,YAAY,CAAC;AA4CpB;;;;GAIG;AACH,qBAAa,oBAAoB;IAKnB,OAAO,CAAC,YAAY;IAJhC,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,MAAM,CAAc;gBAER,YAAY,GAAE,YAAiB;IAanD,WAAW,CACT,KAAK,EAAE,QAAQ,EACf,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,WAAW,GAClB,IAAI;IA4DP,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAepB,MAAM,CACV,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,QAAQ,CAAC;IAiLpB;;;;OAIG;YACW,UAAU;IAcxB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IA0DrB;;;;;;;;;;OAUG;YACW,iBAAiB;IAmF/B;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS;IA+BjB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;CActB"}

package/dist/builder.js

@@ -1,5 +1,5 @@
-import { PluginError, RouteDefinitionError, RouteNotFoundError, SchmockError, } from "./errors";
-import { parseRouteKey } from "./parser";
+import { PluginError, RouteDefinitionError, RouteNotFoundError, SchmockError, } from "./errors.js";
+import { parseRouteKey } from "./parser.js";
 /**
  * Debug logger that respects debug mode configuration
  */

package/dist/errors.d.ts

@@ -3,8 +3,8 @@
  */
 export declare class SchmockError extends Error {
     readonly code: string;
-    readonly context?: unknown;
-    constructor(message: string, code: string, context?: unknown);
+    readonly context?: unknown | undefined;
+    constructor(message: string, code: string, context?: unknown | undefined);
 }
 /**
  * Error thrown when a route is not found
@@ -54,3 +54,4 @@ export declare class SchemaGenerationError extends SchmockError {
 export declare class ResourceLimitError extends SchmockError {
     constructor(resource: string, limit: number, actual?: number);
 }
+//# sourceMappingURL=errors.d.ts.map

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import type { CallableMockInstance, GlobalConfig } from "./types.js";
 /**
  * Create a new Schmock mock instance with callable API.
  *
@@ -21,7 +22,7 @@
  * @param config Optional global configuration
  * @returns A callable mock instance
  */
-export declare function schmock(config?: Schmock.GlobalConfig): Schmock.CallableMockInstance;
-export { PluginError, ResourceLimitError, ResponseGenerationError, RouteDefinitionError, RouteNotFoundError, RouteParseError, SchemaGenerationError, SchemaValidationError, SchmockError, } from "./errors";
-export type { CallableMockInstance, Generator, GeneratorFunction, GlobalConfig, HttpMethod, Plugin, PluginContext, PluginResult, RequestContext, RequestOptions, Response, ResponseResult, RouteConfig, RouteKey, } from "./types";
+export declare function schmock(config?: GlobalConfig): CallableMockInstance;
+export { PluginError, ResourceLimitError, ResponseGenerationError, RouteDefinitionError, RouteNotFoundError, RouteParseError, SchemaGenerationError, SchemaValidationError, SchmockError, } from "./errors.js";
+export type { CallableMockInstance, Generator, GeneratorFunction, GlobalConfig, HttpMethod, Plugin, PluginContext, PluginResult, RequestContext, RequestOptions, Response, ResponseResult, RouteConfig, RouteKey, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CACrB,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,GAC5B,OAAO,CAAC,oBAAoB,CAsB9B;AAGD,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,oBAAoB,EACpB,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,MAAM,EACN,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,EACd,QAAQ,EACR,cAAc,EACd,WAAW,EACX,QAAQ,GACT,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EAEpB,YAAY,EAIb,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,oBAAoB,CAsBnE;AAGD,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,oBAAoB,EACpB,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,MAAM,EACN,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,EACd,QAAQ,EACR,cAAc,EACd,WAAW,EACX,QAAQ,GACT,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1 +1,42 @@
-class X extends Error{code;context;constructor(A,B,G){super(A);this.code=B;this.context=G;this.name="SchmockError",Error.captureStackTrace(this,this.constructor)}}class _ extends X{constructor(A,B){super(`Route not found: ${A} ${B}`,"ROUTE_NOT_FOUND",{method:A,path:B});this.name="RouteNotFoundError"}}class $ extends X{constructor(A,B){super(`Invalid route key format: "${A}". ${B}`,"ROUTE_PARSE_ERROR",{routeKey:A,reason:B});this.name="RouteParseError"}}class z extends X{constructor(A,B){super(`Failed to generate response for route ${A}: ${B.message}`,"RESPONSE_GENERATION_ERROR",{route:A,originalError:B});this.name="ResponseGenerationError"}}class j extends X{constructor(A,B){super(`Plugin "${A}" failed: ${B.message}`,"PLUGIN_ERROR",{pluginName:A,originalError:B});this.name="PluginError"}}class O extends X{constructor(A,B){super(`Invalid route definition for "${A}": ${B}`,"ROUTE_DEFINITION_ERROR",{routeKey:A,reason:B});this.name="RouteDefinitionError"}}class M extends X{constructor(A,B,G){super(`Schema validation failed at ${A}: ${B}${G?`. ${G}`:""}`,"SCHEMA_VALIDATION_ERROR",{schemaPath:A,issue:B,suggestion:G});this.name="SchemaValidationError"}}class N extends X{constructor(A,B,G){super(`Schema generation failed for route ${A}: ${B.message}`,"SCHEMA_GENERATION_ERROR",{route:A,originalError:B,schema:G});this.name="SchemaGenerationError"}}class K extends X{constructor(A,B,G){super(`Resource limit exceeded for ${A}: limit=${B}${G?`, actual=${G}`:""}`,"RESOURCE_LIMIT_ERROR",{resource:A,limit:B,actual:G});this.name="ResourceLimitError"}}function S(A){let B=A.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS) (.+)$/);if(!B)throw new $(A,'Expected format: "METHOD /path" (e.g., "GET /users")');let[,G,H]=B,J=[],Q=/:([^/]+)/g,T;T=Q.exec(H);while(T!==null)J.push(T[1]),T=Q.exec(H);let U=H.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace(/:([^/]+)/g,"([^/]+)"),V=new RegExp(`^${U}$`);return{method:G,path:H,pattern:V,params:J}}class k{enabled;constructor(A=!1){this.enabled=A}log(A,B,G){if(!this.enabled)return;let J=`[${new Date().toISOString()}] [SCHMOCK:${A.toUpperCase()}]`;if(G)console.log(`${J} ${B}`,G);else console.log(`${J} ${B}`)}time(A){if(!this.enabled)return;console.time(`[SCHMOCK] ${A}`)}timeEnd(A){if(!this.enabled)return;console.timeEnd(`[SCHMOCK] ${A}`)}}class L{globalConfig;routes=[];plugins=[];logger;constructor(A={}){this.globalConfig=A;if(this.logger=new k(A.debug||!1),A.debug)this.logger.log("config","Debug mode enabled");this.logger.log("config","Callable mock instance created",{debug:A.debug,namespace:A.namespace,delay:A.delay})}defineRoute(A,B,G){if(!G.contentType)if(typeof B==="function")G.contentType="application/json";else if(typeof B==="string"||typeof B==="number"||typeof B==="boolean")G.contentType="text/plain";else if(Buffer.isBuffer(B))G.contentType="application/octet-stream";else G.contentType="application/json";if(typeof B!=="function"&&G.contentType==="application/json")try{JSON.stringify(B)}catch(Q){throw new O(A,"Generator data is not valid JSON but contentType is application/json")}let H=S(A),J={pattern:H.pattern,params:H.params,method:H.method,path:H.path,generator:B,config:G};return this.routes.push(J),this.logger.log("route",`Route defined: ${A}`,{contentType:G.contentType,generatorType:typeof B,hasParams:H.params.length>0}),this}pipe(A){return this.plugins.push(A),this.logger.log("plugin",`Registered plugin: ${A.name}@${A.version||"unknown"}`,{name:A.name,version:A.version,hasProcess:typeof A.process==="function",hasOnError:typeof A.onError==="function"}),this}async handle(A,B,G){let H=Math.random().toString(36).substring(7);this.logger.log("request",`[${H}] ${A} ${B}`,{headers:G?.headers,query:G?.query,bodyType:G?.body?typeof G.body:"none"}),this.logger.time(`request-${H}`);try{let J=B;if(this.globalConfig.namespace){let W=this.globalConfig.namespace;if(W==="/")J=B;else{let Y=W.startsWith("/")?W:`/${W}`,w=B.startsWith("/")?B:`/${B}`,F=Y.endsWith("/")&&Y!=="/"?Y.slice(0,-1):Y;if(!w.startsWith(F)){this.logger.log("route",`[${H}] Path doesn't match namespace ${W}`);let v=new _(A,B),I={status:404,body:{error:v.message,code:v.code},headers:{}};return this.logger.timeEnd(`request-${H}`),I}if(J=w.substring(F.length),!J.startsWith("/"))J=`/${J}`}}let Q=this.findRoute(A,J);if(!Q){this.logger.log("route",`[${H}] No route found for ${A} ${J}`);let W=new _(A,B),Y={status:404,body:{error:W.message,code:W.code},headers:{}};return this.logger.timeEnd(`request-${H}`),Y}this.logger.log("route",`[${H}] Matched route: ${A} ${Q.path}`);let T=this.extractParams(Q,J),U={method:A,path:J,params:T,query:G?.query||{},headers:G?.headers||{},body:G?.body,state:this.globalConfig.state||{}},V;if(typeof Q.generator==="function")V=await Q.generator(U);else V=Q.generator;let D={path:J,route:Q.config,method:A,params:T,query:G?.query||{},headers:G?.headers||{},body:G?.body,state:new Map,routeState:this.globalConfig.state||{}};try{let W=await this.runPluginPipeline(D,V,Q.config,H);D=W.context,V=W.response}catch(W){throw this.logger.log("error",`[${H}] Plugin pipeline error: ${W.message}`),W}let Z=this.parseResponse(V,Q.config);return await this.applyDelay(),this.logger.log("response",`[${H}] Sending response ${Z.status}`,{status:Z.status,headers:Z.headers,bodyType:typeof Z.body}),this.logger.timeEnd(`request-${H}`),Z}catch(J){this.logger.log("error",`[${H}] Error processing request: ${J.message}`,J);let Q={status:500,body:{error:J.message,code:J instanceof X?J.code:"INTERNAL_ERROR"},headers:{}};return await this.applyDelay(),this.logger.log("error",`[${H}] Returning error response 500`),this.logger.timeEnd(`request-${H}`),Q}}async applyDelay(){if(!this.globalConfig.delay)return;let A=Array.isArray(this.globalConfig.delay)?Math.random()*(this.globalConfig.delay[1]-this.globalConfig.delay[0])+this.globalConfig.delay[0]:this.globalConfig.delay;await new Promise((B)=>setTimeout(B,A))}parseResponse(A,B){let G=200,H=A,J={},Q=!1;if(A&&typeof A==="object"&&"status"in A&&"body"in A)return{status:A.status,body:A.body,headers:A.headers||{}};if(Array.isArray(A)&&typeof A[0]==="number")[G,H,J={}]=A,Q=!0;if(H===null||H===void 0){if(!Q)G=G===200?204:G;H=void 0}if(!J["content-type"]&&B.contentType&&!Q){if(J["content-type"]=B.contentType,B.contentType==="text/plain"&&H!==void 0){if(typeof H==="object"&&!Buffer.isBuffer(H))H=JSON.stringify(H);else if(typeof H!=="string")H=String(H)}}return{status:G,body:H,headers:J}}async runPluginPipeline(A,B,G,H){let J=A,Q=B;this.logger.log("pipeline",`Running plugin pipeline for ${this.plugins.length} plugins`);for(let T of this.plugins){this.logger.log("pipeline",`Processing plugin: ${T.name}`);try{let U=await T.process(J,Q);if(!U||!U.context)throw Error(`Plugin ${T.name} didn't return valid result`);if(J=U.context,U.response!==void 0&&(Q===void 0||Q===null))this.logger.log("pipeline",`Plugin ${T.name} generated response`),Q=U.response;else if(U.response!==void 0&&Q!==void 0)this.logger.log("pipeline",`Plugin ${T.name} transformed response`),Q=U.response}catch(U){if(this.logger.log("pipeline",`Plugin ${T.name} failed: ${U.message}`),T.onError)try{let V=await T.onError(U,J);if(V){if(this.logger.log("pipeline",`Plugin ${T.name} handled error`),typeof V==="object"&&V.status){Q=V;break}}}catch(V){this.logger.log("pipeline",`Plugin ${T.name} error handler failed: ${V.message}`)}throw new j(T.name,U)}}return{context:J,response:Q}}findRoute(A,B){for(let G=this.routes.length-1;G>=0;G--){let H=this.routes[G];if(H.method===A&&H.params.length===0&&H.pattern.test(B))return H}for(let G=this.routes.length-1;G>=0;G--){let H=this.routes[G];if(H.method===A&&H.params.length>0&&H.pattern.test(B))return H}return}extractParams(A,B){let G=B.match(A.pattern);if(!G)return{};let H={};return A.params.forEach((J,Q)=>{H[J]=G[Q+1]}),H}}function b(A){let B=new L(A||{}),G=(H,J,Q={})=>{return B.defineRoute(H,J,Q),G};return G.pipe=(H)=>{return B.pipe(H),G},G.handle=B.handle.bind(B),G}export{b as schmock,X as SchmockError,M as SchemaValidationError,N as SchemaGenerationError,$ as RouteParseError,_ as RouteNotFoundError,O as RouteDefinitionError,z as ResponseGenerationError,K as ResourceLimitError,j as PluginError};
+import { CallableMockInstance as CallableMockInstanceImpl } from "./builder.js";
+/**
+ * Create a new Schmock mock instance with callable API.
+ *
+ * @example
+ * ```typescript
+ * // New callable API (default)
+ * const mock = schmock({ debug: true })
+ * mock('GET /users', () => [{ id: 1, name: 'John' }])
+ *   .pipe(authPlugin())
+ *
+ * const response = await mock.handle('GET', '/users')
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Simple usage with defaults
+ * const mock = schmock()
+ * mock('GET /users', [{ id: 1, name: 'John' }])
+ * ```
+ *
+ * @param config Optional global configuration
+ * @returns A callable mock instance
+ */
+export function schmock(config) {
+    // Always use new callable API
+    const instance = new CallableMockInstanceImpl(config || {});
+    // Create a callable function that wraps the instance
+    const callableInstance = ((route, generator, routeConfig = {}) => {
+        instance.defineRoute(route, generator, routeConfig);
+        return callableInstance; // Return the callable function for chaining
+    });
+    // Manually bind all instance methods to the callable function with proper return values
+    callableInstance.pipe = (plugin) => {
+        instance.pipe(plugin);
+        return callableInstance; // Return callable function for chaining
+    };
+    callableInstance.handle = instance.handle.bind(instance);
+    return callableInstance;
+}
+// Re-export errors
+export { PluginError, ResourceLimitError, ResponseGenerationError, RouteDefinitionError, RouteNotFoundError, RouteParseError, SchemaGenerationError, SchemaValidationError, SchmockError, } from "./errors.js";

package/dist/parser.d.ts

@@ -1,4 +1,4 @@
-import type { HttpMethod } from "./types";
+import type { HttpMethod } from "./types.js";
 export interface ParsedRoute {
     method: HttpMethod;
     path: string;
@@ -17,3 +17,4 @@ export interface ParsedRoute {
  * // => { method: 'GET', path: '/users/:id', pattern: /^\/users\/([^/]+)$/, params: ['id'] }
  */
 export declare function parseRouteKey(routeKey: string): ParsedRoute;
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,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,CAuC3D"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAgB7C,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,CA4C3D"}

package/dist/parser.js

@@ -1,4 +1,16 @@
-import { RouteParseError } from "./errors";
+import { RouteParseError } from "./errors.js";
+const HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "HEAD",
+    "OPTIONS",
+];
+function isHttpMethod(method) {
+    return HTTP_METHODS.includes(method);
+}
 /**
  * Parse 'METHOD /path' route key format
  *
@@ -31,8 +43,12 @@ export function parseRouteKey(routeKey) {
         .replace(/[.*+?^${}()|[\]\\]/g, "\\$&") // Escape special regex chars except :
         .replace(/:([^/]+)/g, "([^/]+)"); // Replace :param with capture group
     const pattern = new RegExp(`^${regexPath}$`);
+    // The regex guarantees method is valid, but we use the type guard for type safety
+    if (!isHttpMethod(method)) {
+        throw new RouteParseError(routeKey, `Invalid HTTP method: ${method}`);
+    }
     return {
-        method: method,
+        method,
         path,
         pattern,
         params,

package/dist/types.d.ts

@@ -1,15 +1,211 @@
-export type HttpMethod = Schmock.HttpMethod;
-export type RouteKey = Schmock.RouteKey;
-export type ResponseResult = Schmock.ResponseResult;
-export type RequestContext = Schmock.RequestContext;
-export type Response = Schmock.Response;
-export type RequestOptions = Schmock.RequestOptions;
-export type GlobalConfig = Schmock.GlobalConfig;
-export type RouteConfig = Schmock.RouteConfig;
-export type Generator = Schmock.Generator;
-export type GeneratorFunction = Schmock.GeneratorFunction;
-export type CallableMockInstance = Schmock.CallableMockInstance;
-export type Plugin = Schmock.Plugin;
-export type PluginContext = Schmock.PluginContext;
-export type PluginResult = Schmock.PluginResult;
+/**
+ * JSON Schema type (simplified for core package)
+ * Full schema support available via @schmock/schema
+ */
+export interface JSONSchema {
+    type?: string | string[];
+    properties?: Record<string, JSONSchema>;
+    items?: JSONSchema | JSONSchema[];
+    required?: string[];
+    enum?: any[];
+    const?: any;
+    [key: string]: any;
+}
+/**
+ * HTTP methods supported by Schmock
+ */
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+/**
+ * Route key format: 'METHOD /path'
+ *
+ * @example
+ * 'GET /users'
+ * 'POST /users/:id'
+ * 'DELETE /api/posts/:postId/comments/:commentId'
+ */
+export type RouteKey = `${HttpMethod} ${string}`;
+/**
+ * Plugin interface for extending Schmock functionality
+ */
+export interface Plugin {
+    /** Unique plugin identifier */
+    name: string;
+    /** Plugin version (semver) */
+    version?: string;
+    /**
+     * Process the request through this plugin
+     * First plugin to set response becomes the generator, others transform
+     * @param context - Plugin context with request details
+     * @param response - Response from previous plugin (if any)
+     * @returns Updated context and response
+     */
+    process(context: PluginContext, response?: any): PluginResult | Promise<PluginResult>;
+    /**
+     * Called when an error occurs
+     * Can handle, transform, or suppress errors
+     * @param error - The error that occurred
+     * @param context - Plugin context
+     * @returns Modified error, response data, or void to continue error propagation
+     */
+    onError?(error: Error, context: PluginContext): Error | ResponseResult | undefined | Promise<Error | ResponseResult | undefined>;
+}
+/**
+ * Result returned by plugin process method
+ */
+export interface PluginResult {
+    /** Updated context */
+    context: PluginContext;
+    /** Response data (if generated/modified) */
+    response?: any;
+}
+/**
+ * Context passed through plugin pipeline
+ */
+export interface PluginContext {
+    /** Request path */
+    path: string;
+    /** Matched route configuration */
+    route: any;
+    /** HTTP method */
+    method: HttpMethod;
+    /** Route parameters */
+    params: Record<string, string>;
+    /** Query parameters */
+    query: Record<string, string>;
+    /** Request headers */
+    headers: Record<string, string>;
+    /** Request body */
+    body?: any;
+    /** Shared state between plugins for this request */
+    state: Map<string, any>;
+    /** Route-specific state */
+    routeState?: any;
+}
+/**
+ * Global configuration options for the mock instance
+ */
+export interface GlobalConfig {
+    /** Base path prefix for all routes */
+    namespace?: string;
+    /** Response delay in ms, or [min, max] for random delay */
+    delay?: number | [number, number];
+    /** Enable debug mode for detailed logging */
+    debug?: boolean;
+    /** Initial shared state object */
+    state?: any;
+}
+/**
+ * Route-specific configuration options
+ */
+export interface RouteConfig {
+    /** MIME type for content type validation (auto-detected if not provided) */
+    contentType?: string;
+    /** Additional route-specific options */
+    [key: string]: any;
+}
+/**
+ * Generator types that can be passed to route definitions
+ */
+export type Generator = GeneratorFunction | StaticData | JSONSchema;
+/**
+ * Function that generates responses
+ */
+export type GeneratorFunction = (context: RequestContext) => ResponseResult | Promise<ResponseResult>;
+/**
+ * Static data (non-function) that gets returned as-is
+ */
+export type StaticData = any;
+/**
+ * Context passed to generator functions
+ */
+export interface RequestContext {
+    /** HTTP method */
+    method: HttpMethod;
+    /** Request path */
+    path: string;
+    /** Route parameters (e.g., :id) */
+    params: Record<string, string>;
+    /** Query string parameters */
+    query: Record<string, string>;
+    /** Request headers */
+    headers: Record<string, string>;
+    /** Request body (for POST, PUT, PATCH) */
+    body?: any;
+    /** Shared mutable state */
+    state: any;
+}
+/**
+ * Response result types:
+ * - Any value: returns as 200 OK
+ * - [status, body]: custom status with body
+ * - [status, body, headers]: custom status, body, and headers
+ */
+export type ResponseResult = any | [number, any] | [number, any, Record<string, string>];
+/**
+ * Response object returned by handle method
+ */
+export interface Response {
+    status: number;
+    body: any;
+    headers: Record<string, string>;
+}
+/**
+ * Options for handle method
+ */
+export interface RequestOptions {
+    headers?: Record<string, string>;
+    body?: any;
+    query?: Record<string, string>;
+}
+/**
+ * Main callable mock instance interface
+ */
+export interface CallableMockInstance {
+    /**
+     * Define a route by calling the instance directly
+     *
+     * @param route - Route pattern in format 'METHOD /path'
+     * @param generator - Response generator (function, static data, or schema)
+     * @param config - Route-specific configuration
+     * @returns The same instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * const mock = schmock()
+     * mock('GET /users', () => [...users], { contentType: 'application/json' })
+     * mock('POST /users', userData, { contentType: 'application/json' })
+     * ```
+     */
+    (route: RouteKey, generator: Generator, config?: RouteConfig): CallableMockInstance;
+    /**
+     * Add a plugin to the pipeline
+     *
+     * @param plugin - Plugin to add to the pipeline
+     * @returns The same instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * mock('GET /users', generator, config)
+     *   .pipe(authPlugin())
+     *   .pipe(corsPlugin())
+     * ```
+     */
+    pipe(plugin: Plugin): CallableMockInstance;
+    /**
+     * Handle a request and return a response
+     *
+     * @param method - HTTP method
+     * @param path - Request path
+     * @param options - Request options (headers, body, query)
+     * @returns Promise resolving to response object
+     *
+     * @example
+     * ```typescript
+     * const response = await mock.handle('GET', '/users', {
+     *   headers: { 'Authorization': 'Bearer token' }
+     * })
+     * ```
+     */
+    handle(method: HttpMethod, path: string, options?: RequestOptions): Promise<Response>;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;AAC5C,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;AACxC,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;AACpD,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;AACpD,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;AACxC,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;AACpD,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;AAChD,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;AAC9C,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;AAC1C,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;AAC1D,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAChE,MAAM,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;AACpC,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAClD,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -1,2 +1 @@
-/// <reference path="../../../types/schmock.d.ts" />
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/core",
   "description": "Core functionality for Schmock",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -18,16 +18,16 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "bun build:lib && bun build:types",
-    "build:lib": "bun build --minify --outdir=dist src/index.ts",
-    "build:types": "tsc -p tsconfig.json",
+    "build": "rm -rf dist tsconfig.tsbuildinfo && tsc --build",
+    "build:types": "rm -f tsconfig.tsbuildinfo && tsc --build",
     "pretest": "rm -f src/*.js src/*.d.ts || true",
     "test": "vitest",
     "test:watch": "vitest --watch",
     "pretest:bdd": "rm -f src/*.js src/*.d.ts || true",
     "test:bdd": "vitest run --config vitest.config.bdd.ts",
     "lint": "biome check src/*.ts",
-    "lint:fix": "biome check --write --unsafe src/*.ts"
+    "lint:fix": "biome check --write --unsafe src/*.ts",
+    "check:publish": "publint && attw --pack --ignore-rules cjs-resolves-to-esm"
   },
   "license": "MIT",
   "devDependencies": {

package/src/builder.ts

@@ -3,8 +3,21 @@ import {
   RouteDefinitionError,
   RouteNotFoundError,
   SchmockError,
-} from "./errors";
-import { parseRouteKey } from "./parser";
+} from "./errors.js";
+import { parseRouteKey } from "./parser.js";
+import type {
+  Generator,
+  GeneratorFunction,
+  GlobalConfig,
+  HttpMethod,
+  Plugin,
+  PluginContext,
+  RequestContext,
+  RequestOptions,
+  Response,
+  RouteConfig,
+  RouteKey,
+} from "./types.js";
 
 /**
  * Debug logger that respects debug mode configuration
@@ -42,10 +55,10 @@ class DebugLogger {
 interface CompiledCallableRoute {
   pattern: RegExp;
   params: string[];
-  method: Schmock.HttpMethod;
+  method: HttpMethod;
   path: string;
-  generator: Schmock.Generator;
-  config: Schmock.RouteConfig;
+  generator: Generator;
+  config: RouteConfig;
 }
 
 /**
@@ -55,10 +68,10 @@ interface CompiledCallableRoute {
  */
 export class CallableMockInstance {
   private routes: CompiledCallableRoute[] = [];
-  private plugins: Schmock.Plugin[] = [];
+  private plugins: Plugin[] = [];
   private logger: DebugLogger;
 
-  constructor(private globalConfig: Schmock.GlobalConfig = {}) {
+  constructor(private globalConfig: GlobalConfig = {}) {
     this.logger = new DebugLogger(globalConfig.debug || false);
     if (globalConfig.debug) {
       this.logger.log("config", "Debug mode enabled");
@@ -72,9 +85,9 @@ export class CallableMockInstance {
 
   // Method for defining routes (called when instance is invoked)
   defineRoute(
-    route: Schmock.RouteKey,
-    generator: Schmock.Generator,
-    config: Schmock.RouteConfig,
+    route: RouteKey,
+    generator: Generator,
+    config: RouteConfig,
   ): this {
     // Auto-detect contentType if not provided
     if (!config.contentType) {
@@ -135,7 +148,7 @@ export class CallableMockInstance {
     return this;
   }
 
-  pipe(plugin: Schmock.Plugin): this {
+  pipe(plugin: Plugin): this {
     this.plugins.push(plugin);
     this.logger.log(
       "plugin",
@@ -151,10 +164,10 @@ export class CallableMockInstance {
   }
 
   async handle(
-    method: Schmock.HttpMethod,
+    method: HttpMethod,
     path: string,
-    options?: Schmock.RequestOptions,
-  ): Promise<Schmock.Response> {
+    options?: RequestOptions,
+  ): Promise<Response> {
     const requestId = Math.random().toString(36).substring(7);
     this.logger.log("request", `[${requestId}] ${method} ${path}`, {
       headers: options?.headers,
@@ -235,7 +248,7 @@ export class CallableMockInstance {
       const params = this.extractParams(matchedRoute, requestPath);
 
       // Generate initial response from route handler
-      const context: Schmock.RequestContext = {
+      const context: RequestContext = {
         method,
         path: requestPath,
         params,
@@ -247,15 +260,13 @@ export class CallableMockInstance {
 
       let result: any;
       if (typeof matchedRoute.generator === "function") {
-        result = await (matchedRoute.generator as Schmock.GeneratorFunction)(
-          context,
-        );
+        result = await (matchedRoute.generator as GeneratorFunction)(context);
       } else {
         result = matchedRoute.generator;
       }
 
       // Build plugin context
-      let pluginContext: Schmock.PluginContext = {
+      let pluginContext: PluginContext = {
         path: requestPath,
         route: matchedRoute.config,
         method,
@@ -360,10 +371,7 @@ export class CallableMockInstance {
    * @returns Normalized Response object with status, body, and headers
    * @private
    */
-  private parseResponse(
-    result: any,
-    routeConfig: Schmock.RouteConfig,
-  ): Schmock.Response {
+  private parseResponse(result: any, routeConfig: RouteConfig): Response {
     let status = 200;
     let body = result;
     let headers: Record<string, string> = {};
@@ -433,11 +441,11 @@ export class CallableMockInstance {
    * @private
    */
   private async runPluginPipeline(
-    context: Schmock.PluginContext,
+    context: PluginContext,
     initialResponse?: any,
-    _routeConfig?: Schmock.RouteConfig,
+    _routeConfig?: RouteConfig,
     _requestId?: string,
-  ): Promise<{ context: Schmock.PluginContext; response?: any }> {
+  ): Promise<{ context: PluginContext; response?: any }> {
     let currentContext = context;
     let response: any = initialResponse;
 
@@ -525,7 +533,7 @@ export class CallableMockInstance {
    * @private
    */
   private findRoute(
-    method: Schmock.HttpMethod,
+    method: HttpMethod,
     path: string,
   ): CompiledCallableRoute | undefined {
     // First pass: Look for exact matches (routes without parameters)

package/src/index.ts

@@ -1,4 +1,12 @@
-import { CallableMockInstance } from "./builder";
+import { CallableMockInstance as CallableMockInstanceImpl } from "./builder.js";
+import type {
+  CallableMockInstance,
+  Generator,
+  GlobalConfig,
+  Plugin,
+  RouteConfig,
+  RouteKey,
+} from "./types.js";
 
 /**
  * Create a new Schmock mock instance with callable API.
@@ -23,30 +31,28 @@ import { CallableMockInstance } from "./builder";
  * @param config Optional global configuration
  * @returns A callable mock instance
  */
-export function schmock(
-  config?: Schmock.GlobalConfig,
-): Schmock.CallableMockInstance {
+export function schmock(config?: GlobalConfig): CallableMockInstance {
   // Always use new callable API
-  const instance = new CallableMockInstance(config || {});
+  const instance = new CallableMockInstanceImpl(config || {});
 
   // Create a callable function that wraps the instance
   const callableInstance = ((
-    route: Schmock.RouteKey,
-    generator: Schmock.Generator,
-    config: Schmock.RouteConfig = {},
+    route: RouteKey,
+    generator: Generator,
+    routeConfig: RouteConfig = {},
   ) => {
-    instance.defineRoute(route, generator, config);
+    instance.defineRoute(route, generator, routeConfig);
     return callableInstance; // Return the callable function for chaining
   }) as any;
 
   // Manually bind all instance methods to the callable function with proper return values
-  callableInstance.pipe = (plugin: Schmock.Plugin) => {
+  callableInstance.pipe = (plugin: Plugin) => {
     instance.pipe(plugin);
     return callableInstance; // Return callable function for chaining
   };
   callableInstance.handle = instance.handle.bind(instance);
 
-  return callableInstance as Schmock.CallableMockInstance;
+  return callableInstance as CallableMockInstance;
 }
 
 // Re-export errors
@@ -60,7 +66,8 @@ export {
   SchemaGenerationError,
   SchemaValidationError,
   SchmockError,
-} from "./errors";
+} from "./errors.js";
+
 // Re-export types
 export type {
   CallableMockInstance,
@@ -77,4 +84,4 @@ export type {
   ResponseResult,
   RouteConfig,
   RouteKey,
-} from "./types";
+} from "./types.js";

package/src/parser.ts

@@ -1,5 +1,19 @@
-import { RouteParseError } from "./errors";
-import type { HttpMethod } from "./types";
+import { RouteParseError } from "./errors.js";
+import type { HttpMethod } from "./types.js";
+
+const HTTP_METHODS: readonly HttpMethod[] = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+];
+
+function isHttpMethod(method: string): method is HttpMethod {
+  return HTTP_METHODS.includes(method as HttpMethod);
+}
 
 export interface ParsedRoute {
   method: HttpMethod;
@@ -52,8 +66,13 @@ export function parseRouteKey(routeKey: string): ParsedRoute {
 
   const pattern = new RegExp(`^${regexPath}$`);
 
+  // The regex guarantees method is valid, but we use the type guard for type safety
+  if (!isHttpMethod(method)) {
+    throw new RouteParseError(routeKey, `Invalid HTTP method: ${method}`);
+  }
+
   return {
-    method: method as HttpMethod,
+    method,
     path,
     pattern,
     params,

package/src/types.ts

@@ -1,17 +1,259 @@
-/// <reference path="../../../types/schmock.d.ts" />
-
-// Re-export types for internal use
-export type HttpMethod = Schmock.HttpMethod;
-export type RouteKey = Schmock.RouteKey;
-export type ResponseResult = Schmock.ResponseResult;
-export type RequestContext = Schmock.RequestContext;
-export type Response = Schmock.Response;
-export type RequestOptions = Schmock.RequestOptions;
-export type GlobalConfig = Schmock.GlobalConfig;
-export type RouteConfig = Schmock.RouteConfig;
-export type Generator = Schmock.Generator;
-export type GeneratorFunction = Schmock.GeneratorFunction;
-export type CallableMockInstance = Schmock.CallableMockInstance;
-export type Plugin = Schmock.Plugin;
-export type PluginContext = Schmock.PluginContext;
-export type PluginResult = Schmock.PluginResult;
+/**
+ * JSON Schema type (simplified for core package)
+ * Full schema support available via @schmock/schema
+ */
+export interface JSONSchema {
+  type?: string | string[];
+  properties?: Record<string, JSONSchema>;
+  items?: JSONSchema | JSONSchema[];
+  required?: string[];
+  enum?: any[];
+  const?: any;
+  [key: string]: any;
+}
+
+/**
+ * HTTP methods supported by Schmock
+ */
+export type HttpMethod =
+  | "GET"
+  | "POST"
+  | "PUT"
+  | "DELETE"
+  | "PATCH"
+  | "HEAD"
+  | "OPTIONS";
+
+/**
+ * Route key format: 'METHOD /path'
+ *
+ * @example
+ * 'GET /users'
+ * 'POST /users/:id'
+ * 'DELETE /api/posts/:postId/comments/:commentId'
+ */
+export type RouteKey = `${HttpMethod} ${string}`;
+
+/**
+ * Plugin interface for extending Schmock functionality
+ */
+export interface Plugin {
+  /** Unique plugin identifier */
+  name: string;
+  /** Plugin version (semver) */
+  version?: string;
+
+  /**
+   * Process the request through this plugin
+   * First plugin to set response becomes the generator, others transform
+   * @param context - Plugin context with request details
+   * @param response - Response from previous plugin (if any)
+   * @returns Updated context and response
+   */
+  process(
+    context: PluginContext,
+    response?: any,
+  ): PluginResult | Promise<PluginResult>;
+
+  /**
+   * Called when an error occurs
+   * Can handle, transform, or suppress errors
+   * @param error - The error that occurred
+   * @param context - Plugin context
+   * @returns Modified error, response data, or void to continue error propagation
+   */
+  onError?(
+    error: Error,
+    context: PluginContext,
+  ):
+    | Error
+    | ResponseResult
+    | undefined
+    | Promise<Error | ResponseResult | undefined>;
+}
+
+/**
+ * Result returned by plugin process method
+ */
+export interface PluginResult {
+  /** Updated context */
+  context: PluginContext;
+  /** Response data (if generated/modified) */
+  response?: any;
+}
+
+/**
+ * Context passed through plugin pipeline
+ */
+export interface PluginContext {
+  /** Request path */
+  path: string;
+  /** Matched route configuration */
+  route: any;
+  /** HTTP method */
+  method: HttpMethod;
+  /** Route parameters */
+  params: Record<string, string>;
+  /** Query parameters */
+  query: Record<string, string>;
+  /** Request headers */
+  headers: Record<string, string>;
+  /** Request body */
+  body?: any;
+  /** Shared state between plugins for this request */
+  state: Map<string, any>;
+  /** Route-specific state */
+  routeState?: any;
+}
+
+/**
+ * Global configuration options for the mock instance
+ */
+export interface GlobalConfig {
+  /** Base path prefix for all routes */
+  namespace?: string;
+  /** Response delay in ms, or [min, max] for random delay */
+  delay?: number | [number, number];
+  /** Enable debug mode for detailed logging */
+  debug?: boolean;
+  /** Initial shared state object */
+  state?: any;
+}
+
+/**
+ * Route-specific configuration options
+ */
+export interface RouteConfig {
+  /** MIME type for content type validation (auto-detected if not provided) */
+  contentType?: string;
+  /** Additional route-specific options */
+  [key: string]: any;
+}
+
+/**
+ * Generator types that can be passed to route definitions
+ */
+export type Generator = GeneratorFunction | StaticData | JSONSchema;
+
+/**
+ * Function that generates responses
+ */
+export type GeneratorFunction = (
+  context: RequestContext,
+) => ResponseResult | Promise<ResponseResult>;
+
+/**
+ * Static data (non-function) that gets returned as-is
+ */
+export type StaticData = any;
+
+/**
+ * Context passed to generator functions
+ */
+export interface RequestContext {
+  /** HTTP method */
+  method: HttpMethod;
+  /** Request path */
+  path: string;
+  /** Route parameters (e.g., :id) */
+  params: Record<string, string>;
+  /** Query string parameters */
+  query: Record<string, string>;
+  /** Request headers */
+  headers: Record<string, string>;
+  /** Request body (for POST, PUT, PATCH) */
+  body?: any;
+  /** Shared mutable state */
+  state: any;
+}
+
+/**
+ * Response result types:
+ * - Any value: returns as 200 OK
+ * - [status, body]: custom status with body
+ * - [status, body, headers]: custom status, body, and headers
+ */
+export type ResponseResult =
+  | any
+  | [number, any]
+  | [number, any, Record<string, string>];
+
+/**
+ * Response object returned by handle method
+ */
+export interface Response {
+  status: number;
+  body: any;
+  headers: Record<string, string>;
+}
+
+/**
+ * Options for handle method
+ */
+export interface RequestOptions {
+  headers?: Record<string, string>;
+  body?: any;
+  query?: Record<string, string>;
+}
+
+/**
+ * Main callable mock instance interface
+ */
+export interface CallableMockInstance {
+  /**
+   * Define a route by calling the instance directly
+   *
+   * @param route - Route pattern in format 'METHOD /path'
+   * @param generator - Response generator (function, static data, or schema)
+   * @param config - Route-specific configuration
+   * @returns The same instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * const mock = schmock()
+   * mock('GET /users', () => [...users], { contentType: 'application/json' })
+   * mock('POST /users', userData, { contentType: 'application/json' })
+   * ```
+   */
+  (
+    route: RouteKey,
+    generator: Generator,
+    config?: RouteConfig,
+  ): CallableMockInstance;
+
+  /**
+   * Add a plugin to the pipeline
+   *
+   * @param plugin - Plugin to add to the pipeline
+   * @returns The same instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * mock('GET /users', generator, config)
+   *   .pipe(authPlugin())
+   *   .pipe(corsPlugin())
+   * ```
+   */
+  pipe(plugin: Plugin): CallableMockInstance;
+
+  /**
+   * Handle a request and return a response
+   *
+   * @param method - HTTP method
+   * @param path - Request path
+   * @param options - Request options (headers, body, query)
+   * @returns Promise resolving to response object
+   *
+   * @example
+   * ```typescript
+   * const response = await mock.handle('GET', '/users', {
+   *   headers: { 'Authorization': 'Bearer token' }
+   * })
+   * ```
+   */
+  handle(
+    method: HttpMethod,
+    path: string,
+    options?: RequestOptions,
+  ): Promise<Response>;
+}