@schmock/core 1.0.0

package/dist/builder.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Callable mock instance that implements the new API.
+ *
+ * @internal
+ */
+export declare class CallableMockInstance {
+    private globalConfig;
+    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>;
+    /**
+     * Apply configured response delay
+     * Supports both fixed delays and random delays within a range
+     * @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: exact routes first, then parameterized routes
+     * Searches in reverse order to prefer most recently defined routes
+     * @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

@@ -0,0 +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"}

package/dist/builder.js

@@ -0,0 +1,432 @@
+import { PluginError, RouteDefinitionError, RouteNotFoundError, SchmockError, } from "./errors";
+import { parseRouteKey } from "./parser";
+/**
+ * Debug logger that respects debug mode configuration
+ */
+class DebugLogger {
+    enabled;
+    constructor(enabled = false) {
+        this.enabled = enabled;
+    }
+    log(category, message, data) {
+        if (!this.enabled)
+            return;
+        const timestamp = new Date().toISOString();
+        const prefix = `[${timestamp}] [SCHMOCK:${category.toUpperCase()}]`;
+        if (data) {
+            console.log(`${prefix} ${message}`, data);
+        }
+        else {
+            console.log(`${prefix} ${message}`);
+        }
+    }
+    time(label) {
+        if (!this.enabled)
+            return;
+        console.time(`[SCHMOCK] ${label}`);
+    }
+    timeEnd(label) {
+        if (!this.enabled)
+            return;
+        console.timeEnd(`[SCHMOCK] ${label}`);
+    }
+}
+/**
+ * Callable mock instance that implements the new API.
+ *
+ * @internal
+ */
+export class CallableMockInstance {
+    globalConfig;
+    routes = [];
+    plugins = [];
+    logger;
+    constructor(globalConfig = {}) {
+        this.globalConfig = globalConfig;
+        this.logger = new DebugLogger(globalConfig.debug || false);
+        if (globalConfig.debug) {
+            this.logger.log("config", "Debug mode enabled");
+        }
+        this.logger.log("config", "Callable mock instance created", {
+            debug: globalConfig.debug,
+            namespace: globalConfig.namespace,
+            delay: globalConfig.delay,
+        });
+    }
+    // Method for defining routes (called when instance is invoked)
+    defineRoute(route, generator, config) {
+        // Auto-detect contentType if not provided
+        if (!config.contentType) {
+            if (typeof generator === "function") {
+                // Default to JSON for function generators
+                config.contentType = "application/json";
+            }
+            else if (typeof generator === "string" ||
+                typeof generator === "number" ||
+                typeof generator === "boolean") {
+                // Default to plain text for primitives
+                config.contentType = "text/plain";
+            }
+            else if (Buffer.isBuffer(generator)) {
+                // Default to octet-stream for buffers
+                config.contentType = "application/octet-stream";
+            }
+            else {
+                // Default to JSON for objects/arrays
+                config.contentType = "application/json";
+            }
+        }
+        // Validate generator matches contentType if it's static data
+        if (typeof generator !== "function" &&
+            config.contentType === "application/json") {
+            try {
+                JSON.stringify(generator);
+            }
+            catch (_error) {
+                throw new RouteDefinitionError(route, "Generator data is not valid JSON but contentType is application/json");
+            }
+        }
+        // Parse the route key to create pattern and extract parameters
+        const parsed = parseRouteKey(route);
+        // Compile the route
+        const compiledRoute = {
+            pattern: parsed.pattern,
+            params: parsed.params,
+            method: parsed.method,
+            path: parsed.path,
+            generator,
+            config,
+        };
+        this.routes.push(compiledRoute);
+        this.logger.log("route", `Route defined: ${route}`, {
+            contentType: config.contentType,
+            generatorType: typeof generator,
+            hasParams: parsed.params.length > 0,
+        });
+        return this;
+    }
+    pipe(plugin) {
+        this.plugins.push(plugin);
+        this.logger.log("plugin", `Registered plugin: ${plugin.name}@${plugin.version || "unknown"}`, {
+            name: plugin.name,
+            version: plugin.version,
+            hasProcess: typeof plugin.process === "function",
+            hasOnError: typeof plugin.onError === "function",
+        });
+        return this;
+    }
+    async handle(method, path, options) {
+        const requestId = Math.random().toString(36).substring(7);
+        this.logger.log("request", `[${requestId}] ${method} ${path}`, {
+            headers: options?.headers,
+            query: options?.query,
+            bodyType: options?.body ? typeof options.body : "none",
+        });
+        this.logger.time(`request-${requestId}`);
+        try {
+            // Apply namespace if configured
+            let requestPath = path;
+            if (this.globalConfig.namespace) {
+                // Normalize namespace to handle edge cases
+                const namespace = this.globalConfig.namespace;
+                if (namespace === "/") {
+                    // Root namespace means no transformation needed
+                    requestPath = path;
+                }
+                else {
+                    // Handle namespace without leading slash by normalizing both namespace and path
+                    const normalizedNamespace = namespace.startsWith("/")
+                        ? namespace
+                        : `/${namespace}`;
+                    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+                    // Remove trailing slash from namespace unless it's root
+                    const finalNamespace = normalizedNamespace.endsWith("/") && normalizedNamespace !== "/"
+                        ? normalizedNamespace.slice(0, -1)
+                        : normalizedNamespace;
+                    if (!normalizedPath.startsWith(finalNamespace)) {
+                        this.logger.log("route", `[${requestId}] Path doesn't match namespace ${namespace}`);
+                        const error = new RouteNotFoundError(method, path);
+                        const response = {
+                            status: 404,
+                            body: { error: error.message, code: error.code },
+                            headers: {},
+                        };
+                        this.logger.timeEnd(`request-${requestId}`);
+                        return response;
+                    }
+                    // Remove namespace prefix, ensuring we always start with /
+                    requestPath = normalizedPath.substring(finalNamespace.length);
+                    if (!requestPath.startsWith("/")) {
+                        requestPath = `/${requestPath}`;
+                    }
+                }
+            }
+            // Find matching route
+            const matchedRoute = this.findRoute(method, requestPath);
+            if (!matchedRoute) {
+                this.logger.log("route", `[${requestId}] No route found for ${method} ${requestPath}`);
+                const error = new RouteNotFoundError(method, path);
+                const response = {
+                    status: 404,
+                    body: { error: error.message, code: error.code },
+                    headers: {},
+                };
+                this.logger.timeEnd(`request-${requestId}`);
+                return response;
+            }
+            this.logger.log("route", `[${requestId}] Matched route: ${method} ${matchedRoute.path}`);
+            // Extract parameters from the matched route
+            const params = this.extractParams(matchedRoute, requestPath);
+            // Generate initial response from route handler
+            const context = {
+                method,
+                path: requestPath,
+                params,
+                query: options?.query || {},
+                headers: options?.headers || {},
+                body: options?.body,
+                state: this.globalConfig.state || {},
+            };
+            let result;
+            if (typeof matchedRoute.generator === "function") {
+                result = await matchedRoute.generator(context);
+            }
+            else {
+                result = matchedRoute.generator;
+            }
+            // Build plugin context
+            let pluginContext = {
+                path: requestPath,
+                route: matchedRoute.config,
+                method,
+                params,
+                query: options?.query || {},
+                headers: options?.headers || {},
+                body: options?.body,
+                state: new Map(),
+                routeState: this.globalConfig.state || {},
+            };
+            // Run plugin pipeline to transform the response
+            try {
+                const pipelineResult = await this.runPluginPipeline(pluginContext, result, matchedRoute.config, requestId);
+                pluginContext = pipelineResult.context;
+                result = pipelineResult.response;
+            }
+            catch (error) {
+                this.logger.log("error", `[${requestId}] Plugin pipeline error: ${error.message}`);
+                throw error;
+            }
+            // Parse and prepare response
+            const response = this.parseResponse(result, matchedRoute.config);
+            // Apply global delay if configured
+            await this.applyDelay();
+            // Log successful response
+            this.logger.log("response", `[${requestId}] Sending response ${response.status}`, {
+                status: response.status,
+                headers: response.headers,
+                bodyType: typeof response.body,
+            });
+            this.logger.timeEnd(`request-${requestId}`);
+            return response;
+        }
+        catch (error) {
+            this.logger.log("error", `[${requestId}] Error processing request: ${error.message}`, error);
+            // Return error response
+            const errorResponse = {
+                status: 500,
+                body: {
+                    error: error.message,
+                    code: error instanceof SchmockError
+                        ? error.code
+                        : "INTERNAL_ERROR",
+                },
+                headers: {},
+            };
+            // Apply global delay if configured (even for error responses)
+            await this.applyDelay();
+            this.logger.log("error", `[${requestId}] Returning error response 500`);
+            this.logger.timeEnd(`request-${requestId}`);
+            return errorResponse;
+        }
+    }
+    /**
+     * Apply configured response delay
+     * Supports both fixed delays and random delays within a range
+     * @private
+     */
+    async applyDelay() {
+        if (!this.globalConfig.delay) {
+            return;
+        }
+        const delay = 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((resolve) => setTimeout(resolve, delay));
+    }
+    /**
+     * 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 (result &&
+            typeof result === "object" &&
+            "status" in result &&
+            "body" in result) {
+            return {
+                status: result.status,
+                body: result.body,
+                headers: result.headers || {},
+            };
+        }
+        // Handle tuple response format [status, body, headers?]
+        if (Array.isArray(result) && typeof result[0] === "number") {
+            [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: ${error.message}`);
+                // Try error handling if plugin has onError hook
+                if (plugin.onError) {
+                    try {
+                        const errorResult = await plugin.onError(error, currentContext);
+                        if (errorResult) {
+                            this.logger.log("pipeline", `Plugin ${plugin.name} handled error`);
+                            // If error handler returns response, use it and stop pipeline
+                            if (typeof errorResult === "object" && errorResult.status) {
+                                // Return the error response as the current response, stop pipeline
+                                response = errorResult;
+                                break;
+                            }
+                        }
+                    }
+                    catch (hookError) {
+                        this.logger.log("pipeline", `Plugin ${plugin.name} error handler failed: ${hookError.message}`);
+                    }
+                }
+                throw new PluginError(plugin.name, error);
+            }
+        }
+        return { context: currentContext, response };
+    }
+    /**
+     * Find a route that matches the given method and path
+     * Uses two-pass matching: exact routes first, then parameterized routes
+     * Searches in reverse order to prefer most recently defined routes
+     * @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) {
+        // First pass: Look for exact matches (routes without parameters)
+        for (let i = this.routes.length - 1; i >= 0; i--) {
+            const route = this.routes[i];
+            if (route.method === method &&
+                route.params.length === 0 &&
+                route.pattern.test(path)) {
+                return route;
+            }
+        }
+        // Second pass: Look for parameterized routes
+        for (let i = this.routes.length - 1; i >= 0; i--) {
+            const route = this.routes[i];
+            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

@@ -0,0 +1,56 @@
+/**
+ * Base error class for all Schmock errors
+ */
+export declare class SchmockError extends Error {
+    readonly code: string;
+    readonly context?: unknown;
+    constructor(message: string, code: string, context?: unknown);
+}
+/**
+ * Error thrown when a route is not found
+ */
+export declare class RouteNotFoundError extends SchmockError {
+    constructor(method: string, path: string);
+}
+/**
+ * Error thrown when route parsing fails
+ */
+export declare class RouteParseError extends SchmockError {
+    constructor(routeKey: string, reason: string);
+}
+/**
+ * Error thrown when response generation fails
+ */
+export declare class ResponseGenerationError extends SchmockError {
+    constructor(route: string, error: Error);
+}
+/**
+ * Error thrown when a plugin fails
+ */
+export declare class PluginError extends SchmockError {
+    constructor(pluginName: string, error: Error);
+}
+/**
+ * Error thrown when route definition is invalid
+ */
+export declare class RouteDefinitionError extends SchmockError {
+    constructor(routeKey: string, reason: string);
+}
+/**
+ * Error thrown when schema validation fails
+ */
+export declare class SchemaValidationError extends SchmockError {
+    constructor(schemaPath: string, issue: string, suggestion?: string);
+}
+/**
+ * Error thrown when schema generation fails
+ */
+export declare class SchemaGenerationError extends SchmockError {
+    constructor(route: string, error: Error, schema?: unknown);
+}
+/**
+ * Error thrown when resource limits are exceeded
+ */
+export declare class ResourceLimitError extends SchmockError {
+    constructor(resource: string, limit: number, actual?: number);
+}

package/dist/errors.d.ts.map

@@ -0,0 +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;CAMpC;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

@@ -0,0 +1,92 @@
+/**
+ * Base error class for all Schmock errors
+ */
+export class SchmockError extends Error {
+    code;
+    context;
+    constructor(message, code, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        this.name = "SchmockError";
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+/**
+ * Error thrown when a route is not found
+ */
+export class RouteNotFoundError extends SchmockError {
+    constructor(method, path) {
+        super(`Route not found: ${method} ${path}`, "ROUTE_NOT_FOUND", {
+            method,
+            path,
+        });
+        this.name = "RouteNotFoundError";
+    }
+}
+/**
+ * Error thrown when route parsing fails
+ */
+export class RouteParseError extends SchmockError {
+    constructor(routeKey, reason) {
+        super(`Invalid route key format: "${routeKey}". ${reason}`, "ROUTE_PARSE_ERROR", { routeKey, reason });
+        this.name = "RouteParseError";
+    }
+}
+/**
+ * Error thrown when response generation fails
+ */
+export class ResponseGenerationError extends SchmockError {
+    constructor(route, error) {
+        super(`Failed to generate response for route ${route}: ${error.message}`, "RESPONSE_GENERATION_ERROR", { route, originalError: error });
+        this.name = "ResponseGenerationError";
+    }
+}
+/**
+ * Error thrown when a plugin fails
+ */
+export class PluginError extends SchmockError {
+    constructor(pluginName, error) {
+        super(`Plugin "${pluginName}" failed: ${error.message}`, "PLUGIN_ERROR", {
+            pluginName,
+            originalError: error,
+        });
+        this.name = "PluginError";
+    }
+}
+/**
+ * Error thrown when route definition is invalid
+ */
+export class RouteDefinitionError extends SchmockError {
+    constructor(routeKey, reason) {
+        super(`Invalid route definition for "${routeKey}": ${reason}`, "ROUTE_DEFINITION_ERROR", { routeKey, reason });
+        this.name = "RouteDefinitionError";
+    }
+}
+/**
+ * Error thrown when schema validation fails
+ */
+export class SchemaValidationError extends SchmockError {
+    constructor(schemaPath, issue, suggestion) {
+        super(`Schema validation failed at ${schemaPath}: ${issue}${suggestion ? `. ${suggestion}` : ""}`, "SCHEMA_VALIDATION_ERROR", { schemaPath, issue, suggestion });
+        this.name = "SchemaValidationError";
+    }
+}
+/**
+ * Error thrown when schema generation fails
+ */
+export class SchemaGenerationError extends SchmockError {
+    constructor(route, error, schema) {
+        super(`Schema generation failed for route ${route}: ${error.message}`, "SCHEMA_GENERATION_ERROR", { route, originalError: error, schema });
+        this.name = "SchemaGenerationError";
+    }
+}
+/**
+ * Error thrown when resource limits are exceeded
+ */
+export class ResourceLimitError extends SchmockError {
+    constructor(resource, limit, actual) {
+        super(`Resource limit exceeded for ${resource}: limit=${limit}${actual ? `, actual=${actual}` : ""}`, "RESOURCE_LIMIT_ERROR", { resource, limit, actual });
+        this.name = "ResourceLimitError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 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";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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"}