@schmock/core 2.3.0 → 2.4.0

package/dist/index.d.ts

@@ -7,6 +7,84 @@ declare global {
 
 namespace Schmock {
   type JSONSchema7 = import("json-schema").JSONSchema7;
+
+  /**
+   * A `Schema` or the boolean shorthand, wherever draft-07 allows a subschema.
+   */
+  type SchemaDefinition = Schema | boolean;
+
+  /**
+   * JSON Schema draft-07 plus the keywords Schmock's own tooling understands,
+   * applied recursively so nested subschemas accept them too.
+   *
+   * `JSONSchema7` rejects these keywords in an object literal, which is why
+   * schemas carrying them otherwise need a cast at every level that uses one.
+   * A `Schema` is assignable to `JSONSchema7`, so it can be handed to
+   * `fakerPlugin`, `validationPlugin` or any other schema-typed option.
+   *
+   * Only `@schmock/*` packages know these keywords. `@schmock/validation`
+   * registers them on its own Ajv instance; a strict Ajv of your own throws
+   * `strict mode: unknown keyword` until you do the same.
+   *
+   * @example
+   * ```typescript
+   * const schema: Schmock.Schema = {
+   *   type: 'object',
+   *   properties: {
+   *     name: { type: 'string', faker: 'person.fullName' },
+   *     nickname: { type: ['string', 'null'], schmockNullable: true },
+   *     active: { type: 'boolean', schmockTrueProbability: 0.8 },
+   *   },
+   * }
+   * ```
+   */
+  interface Schema
+    extends Omit<
+      JSONSchema7,
+      | "properties"
+      | "patternProperties"
+      | "additionalProperties"
+      | "items"
+      | "additionalItems"
+      | "contains"
+      | "propertyNames"
+      | "allOf"
+      | "anyOf"
+      | "oneOf"
+      | "not"
+      | "if"
+      | "then"
+      | "else"
+      | "$defs"
+      | "definitions"
+      | "dependencies"
+    > {
+    /** json-schema-faker method path, e.g. `"person.fullName"`. */
+    faker?: string | Record<string, unknown>;
+    /** Marks a null-permitting field: ~5% of generated values are `null`. */
+    schmockNullable?: boolean;
+    /** Probability (0–1) that a generated boolean is `true`. */
+    schmockTrueProbability?: number;
+
+    properties?: Record<string, SchemaDefinition>;
+    patternProperties?: Record<string, SchemaDefinition>;
+    additionalProperties?: SchemaDefinition;
+    items?: SchemaDefinition | SchemaDefinition[];
+    additionalItems?: SchemaDefinition;
+    contains?: SchemaDefinition;
+    propertyNames?: SchemaDefinition;
+    allOf?: SchemaDefinition[];
+    anyOf?: SchemaDefinition[];
+    oneOf?: SchemaDefinition[];
+    not?: SchemaDefinition;
+    if?: SchemaDefinition;
+    then?: SchemaDefinition;
+    else?: SchemaDefinition;
+    $defs?: Record<string, SchemaDefinition>;
+    definitions?: Record<string, SchemaDefinition>;
+    dependencies?: Record<string, SchemaDefinition | string[]>;
+  }
+
   /**
    * HTTP methods supported by Schmock
    */
@@ -22,12 +100,17 @@ namespace Schmock {
   /**
    * Route key format: 'METHOD /path'
    *
+   * The path must start with '/': transports always deliver a leading-slash
+   * pathname, so a slash-less key would register a route no request can reach.
+   * `parseRouteKey` rejects it at runtime; the template type surfaces the same
+   * mistake at compile time.
+   *
    * @example
    * 'GET /users'
    * 'POST /users/:id'
    * 'DELETE /api/posts/:postId/comments/:commentId'
    */
-  type RouteKey = `${HttpMethod} ${string}`;
+  type RouteKey = `${HttpMethod} /${string}`;
 
   /**
    * Plugin interface for extending Schmock functionality
@@ -40,11 +123,19 @@ namespace Schmock {
 
     /**
      * Called once when the plugin is added via .pipe()
-     * Use this to register routes or configure the instance at setup time
-     * @param instance - The callable mock instance
+     * Route registrations are committed atomically only when this hook returns
+     * synchronously. The scoped instance must not be retained or used later.
+     * Returning a Promise is unsupported and leaves the plugin inactive.
+     * @param instance - A synchronous, installation-scoped callable instance
      */
     install?(instance: CallableMockInstance): void;
 
+    /**
+     * Called during reset after every request admitted with this plugin settles.
+     * Cleanup runs in reverse registration order and must complete synchronously.
+     */
+    uninstall?(instance: CallableMockInstance): void;
+
     /**
      * Inspect or transform a request before its route generator executes.
      * Returning a response short-circuits the generator, while returning only
@@ -118,6 +209,8 @@ namespace Schmock {
     requestShortCircuited?: boolean;
     /** Route-specific state */
     routeState?: Record<string, unknown>;
+    /** Abort signal associated with the admitted request */
+    readonly signal?: AbortSignal;
   }
 
   // ===== Callable API Types =====
@@ -137,6 +230,10 @@ namespace Schmock {
     /**
      * Maximum number of requests retained in history (FIFO eviction).
      * Defaults to unbounded; set this to cap memory growth in long-running servers.
+     *
+     * Must be a non-negative integer — `0` disables history entirely, and any
+     * other value (negative, fractional, NaN, Infinity) is rejected with a
+     * `SchmockError` (`INVALID_CONFIG`) when the mock is created.
      */
     maxHistorySize?: number;
   }
@@ -153,8 +250,10 @@ namespace Schmock {
      * Extension point for plugin-specific metadata.
      *
      * Intentionally open: `@schmock/openapi` stores "openapi:*" keys here
-     * (e.g. `"openapi:operationId"`, `"openapi:tags"`), and third-party plugins
-     * may do the same. Removing this signature would be a breaking change.
+     * (e.g. `"openapi:operationId"`, `"openapi:tags"`, `"openapi:owner"`,
+     * `"openapi:requestContent"`), and
+     * third-party plugins may do the same. Removing this signature would be a
+     * breaking change.
      *
      * **Known tradeoff:** typos in known keys (e.g. `{ contenType: "…" }`) compile
      * silently. Prefer using the explicitly typed properties above when possible.
@@ -163,9 +262,15 @@ namespace Schmock {
   }
 
   /**
-   * Generator types that can be passed to route definitions
+   * Generator types that can be passed to route definitions.
+   *
+   * Core dispatches on exactly two shapes: a function is called per request,
+   * and anything else is returned verbatim as static data. There is no
+   * schema-generation arm — a JSON Schema handed to a route is serialized back
+   * to the client as a literal schema document. Schema-driven responses come
+   * from a plugin: `.pipe(fakerPlugin({ schema }))`.
    */
-  type Generator = GeneratorFunction | StaticData | JSONSchema7;
+  type Generator = GeneratorFunction | StaticData;
 
   /**
    * Function that generates responses
@@ -175,7 +280,11 @@ namespace Schmock {
   ) => ResponseResult | Promise<ResponseResult>;
 
   /**
-   * Static data (non-function) that gets returned as-is
+   * Static data (non-function) that gets returned as-is.
+   *
+   * `Record<string, unknown>` accepts object literals but not a value whose
+   * declared type is an interface without an index signature (e.g. a variable
+   * typed `JSONSchema7`); pass such values as literals or widen them.
    */
   type StaticData =
     | string
@@ -206,6 +315,16 @@ namespace Schmock {
     body?: unknown;
     /** Shared mutable state */
     state: Record<string, unknown>;
+    /**
+     * Per-request plugin state — the same `Map` as `PluginContext.state`.
+     *
+     * Lets a generator hand request-scoped data to the plugins that post-process
+     * its response (e.g. mutations staged until the final status is known).
+     * Absent when a generator is invoked outside the request pipeline.
+     */
+    pluginState?: Map<string, unknown>;
+    /** Abort signal associated with the request */
+    readonly signal?: AbortSignal;
   }
 
   /**
@@ -213,11 +332,22 @@ namespace Schmock {
    * - Any value: returns as 200 OK
    * - [status, body]: custom status with body
    * - [status, body, headers]: custom status, body, and headers
+   * - { status, body, headers? }: object envelope, equivalent to the tuple
+   *   forms and produced by plugin error recovery
+   *
+   * The object envelope is detected by shape, so any returned object carrying a
+   * numeric `status` alongside a `body` is unwrapped rather than delivered as
+   * the payload — a domain object such as `{ status: 200, body: "draft" }` is
+   * indistinguishable from an envelope. An object whose `headers` is present
+   * but not a string record is *not* an envelope and is delivered whole. To
+   * return such a shape as data, nest it (`{ value: { status, body } }`) or use
+   * an explicit `[status, body]` tuple for the envelope instead.
    */
   type ResponseResult =
     | ResponseBody
     | [number, unknown]
-    | [number, unknown, Record<string, string>];
+    | [number, unknown, Record<string, string>]
+    | { status: number; body: unknown; headers?: Record<string, string> };
 
   /**
    * Response object returned by handle method
@@ -235,6 +365,7 @@ namespace Schmock {
     headers?: Record<string, string>;
     body?: unknown;
     query?: Record<string, string>;
+    signal?: AbortSignal;
   }
 
   /**
@@ -267,7 +398,9 @@ namespace Schmock {
      * 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 generator - Response generator: a function called per request, or
+     *   static data returned verbatim. There is no schema arm — use
+     *   `.pipe(fakerPlugin({ schema }))` for schema-driven responses.
      * @param config - Route-specific configuration
      * @returns The same instance for method chaining
      *
@@ -360,7 +493,9 @@ namespace Schmock {
     // ===== Reset / Lifecycle =====
 
     /**
-     * Clear all routes, state, plugins, and history
+     * Clear routes, state, plugins, listeners, and history, and stop the Node
+     * server. An explicitly acquired fetch interception remains active until
+     * its InterceptHandle is restored.
      */
     reset(): void;
 
@@ -427,9 +562,14 @@ namespace Schmock {
      * Intercept globalThis.fetch and route requests through this mock.
      * Client-side equivalent of listen().
      *
+     * A mock may hold any number of concurrent leases — nested providers,
+     * separate roots, or an adapter alongside a manual call. Each lease owns
+     * its own options and is released independently; the newest lease is
+     * consulted first.
+     *
      * @param options - Intercept configuration
-     * @returns Handle with restore() to stop intercepting
-     * @throws If already intercepting (call restore() first)
+     * @returns Handle with restore() to release this lease and update() to
+     *   change its options without changing its position in the stack
      */
     intercept(options?: InterceptOptions): InterceptHandle;
   }
@@ -476,6 +616,7 @@ namespace Schmock {
     headers: Record<string, string>;
     body?: unknown;
     query: Record<string, string>;
+    readonly signal?: AbortSignal;
   }
 
   interface AdapterResponse {
@@ -515,37 +656,52 @@ namespace Schmock {
   }
 
   interface InterceptHandle {
-    /** Stop intercepting and restore original fetch */
+    /** Release this lease; restores original fetch once the last lease goes */
     restore(): void;
+    /**
+     * Reconfigure this lease in place, keeping its position in the
+     * interception stack. Options are replaced wholesale — omitted fields fall
+     * back to their defaults, so `update({})` restores `passthrough: true`.
+     * No-op once the lease has been restored.
+     */
+    update(options?: InterceptOptions): void;
     /** Whether this interceptor is currently active */
     readonly active: boolean;
   }
 
   // ===== Lifecycle Events =====
 
+  /**
+   * Every lifecycle event carries `path`: the ORIGINAL request path in its
+   * canonical percent-encoded form, namespace prefix included. The
+   * namespace-stripped route form is available only as `routePath` on
+   * `request:match`.
+   */
   interface RequestStartEvent {
-    method: HttpMethod;
-    path: string;
-    headers: Record<string, string>;
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly headers: Readonly<Record<string, string>>;
   }
 
   interface RequestMatchEvent {
-    method: HttpMethod;
-    path: string;
-    routePath: string;
-    params: Record<string, string>;
+    readonly method: HttpMethod;
+    /** Original request path, namespace prefix included */
+    readonly path: string;
+    /** Registered route path, namespace prefix stripped */
+    readonly routePath: string;
+    readonly params: Readonly<Record<string, string>>;
   }
 
   interface RequestNotFoundEvent {
-    method: HttpMethod;
-    path: string;
+    readonly method: HttpMethod;
+    readonly path: string;
   }
 
   interface RequestEndEvent {
-    method: HttpMethod;
-    path: string;
-    status: number;
-    duration: number;
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly status: number;
+    readonly duration: number;
   }
 
   type SchmockEventMap = {
@@ -599,6 +755,14 @@ namespace Schmock {
     responseHeaders?: Record<string, ResponseHeaderDef>;
     /** Error response schemas keyed by status code */
     errorSchemas?: Map<number, JSONSchema7>;
+    /** Declared media types for the success response, in spec order. */
+    responseContentTypes?: string[];
+    /**
+     * Success response schemas keyed by declared media type (OAS3 `content`).
+     * When present it takes precedence over `responseSchema`, so anything that
+     * replaces `responseSchema` must clear this map too.
+     */
+    responseSchemasByMediaType?: Map<string, JSONSchema7>;
   }
 
   // ===== Faker Plugin Types =====
@@ -685,12 +849,51 @@ namespace Schmock {
     dispatch(request: OpenApiCallbackRequest): void | Promise<void>;
   }
 
+  /**
+   * Policy governing `$ref`s that leave the root spec document.
+   *
+   * A spec is untrusted input — on the CLI it is a path a caller hands over —
+   * and `$ref` is a file-read and network primitive, so nothing outside the
+   * root document resolves unless it is opted into here.
+   */
+  interface OpenApiRefPolicy {
+    /** Allow any `$ref` that leaves the root document. Default `false`. */
+    external?: boolean;
+    /** Allow `http(s)` `$ref`s. Requires `external`. Default `false`. */
+    allowHttp?: boolean;
+    /**
+     * Hostnames an `http(s)` `$ref` may target. Empty or omitted means any
+     * host, still minus loopback, link-local and private ranges.
+     */
+    allowedHosts?: string[];
+    /** Per-request timeout for http `$ref`s, in ms. Default 5000. */
+    timeoutMs?: number;
+    /**
+     * Redirects to follow for an http `$ref`. Default 0.
+     *
+     * `fetch` exposes no numeric redirect cap, so this behaves as a boolean:
+     * `0` refuses redirects, any positive value follows up to the platform
+     * default. Use `allowedHosts` when the exact destination matters.
+     */
+    redirects?: number;
+    /** Maximum size of a single http `$ref` document, in bytes. Default 1 MB. */
+    maxBytes?: number;
+  }
+
   /**
    * Options for the OpenAPI plugin
    */
   interface OpenApiOptions {
     spec: string | object;
     seed?: SeedConfig;
+    /**
+     * Validate the spec against the OpenAPI schema and specification when it is
+     * loaded. Default `false`: incomplete specs are deliberately tolerated, and
+     * validation is expensive on large documents.
+     */
+    strict?: boolean;
+    /** External `$ref` resolution policy. External refs are off by default. */
+    refs?: OpenApiRefPolicy;
     validateRequests?: boolean;
     validateResponses?: boolean;
     /** @deprecated Unsupported. Supplying this option throws OPENAPI_UNSUPPORTED_OPTION. */
@@ -750,16 +953,69 @@ namespace Schmock {
     errors?: boolean;
     watch?: boolean;
     admin?: boolean;
+    /**
+     * Bearer token required by every `/schmock-admin/*` request
+     * (`--admin-token`). When `admin` is on and this is omitted, a random
+     * token is minted once and surfaced on {@link CliServer.adminToken}.
+     */
+    adminToken?: string;
+    /**
+     * How many requests the mock retains for `GET /schmock-admin/history`
+     * (`--admin-history-limit`, default 500). Ignored — history is disabled
+     * entirely — when `admin` is off.
+     */
+    adminHistoryLimit?: number;
+    /** Validate the spec against the OpenAPI schema at startup (`--strict`). */
+    strict?: boolean;
+    /** Resolve `$ref`s outside the spec document (`--refs-external`). */
+    refsExternal?: boolean;
+    /**
+     * Hosts an `http(s)` `$ref` may target (`--refs-allow-http`). Supplying
+     * this also enables http resolution, which still requires `refsExternal`.
+     */
+    refsAllowHttp?: string[];
+    /**
+     * How long {@link CliServer.close} waits for in-flight requests before
+     * the remaining sockets are destroyed (default 5000 ms). A half-sent
+     * request never completes on its own, so without a bound the close would
+     * hang.
+     */
+    shutdownGraceMs?: number;
+  }
+
+  /** Browser-safe subset of the Node server exposed by a CLI instance. */
+  interface CliHttpServer {
+    readonly listening: boolean;
+    address():
+      | string
+      | { address: string; family: string; port: number }
+      | null;
+    close(callback?: (error?: Error) => void): this;
+    closeAllConnections(): void;
+    closeIdleConnections(): void;
+    ref(): this;
+    unref(): this;
   }
 
   /**
-   * Running CLI server instance
+   * Running CLI server instance. Import `CliServer` from `@schmock/cli` for
+   * the exact Node.js server type.
    */
   interface CliServer {
-    server: import("node:http").Server;
+    server: CliHttpServer;
     port: number;
     hostname: string;
-    close(): void;
+    /**
+     * The bearer token this server requires on `/schmock-admin/*`. Present
+     * only when admin is enabled.
+     */
+    adminToken?: string;
+    /**
+     * Stop watching, stop accepting, and settle once the socket is released —
+     * within {@link CliOptions.shutdownGraceMs}. Memoized: closing twice is
+     * safe and resolves twice.
+     */
+    close(): Promise<void>;
   }
 }
 }
@@ -789,10 +1045,12 @@ namespace Schmock {
  */
 export declare function schmock(config?: Schmock.GlobalConfig): Schmock.CallableMockInstance;
 export { isBinaryBody } from "./binary.js";
-export { HTTP_METHODS, isHttpMethod, isRouteNotFound, isStatusTuple, ROUTE_NOT_FOUND_CODE, toHttpMethod, toRouteKey, } from "./constants.js";
-export { PluginError, ResourceLimitError, ResponseGenerationError, RouteDefinitionError, RouteNotFoundError, RouteParseError, SchemaGenerationError, SchemaValidationError, SchmockError, } from "./errors.js";
+export { getResponseException, HTTP_METHODS, isHttpMethod, isRouteNotFound, isStatusTuple, ROUTE_NOT_FOUND_CODE, toHttpMethod, toRouteKey, } from "./constants.js";
+export { InvalidResponseError, PluginError, ResourceLimitError, RouteDefinitionError, RouteNotFoundError, RouteParseError, SchemaGenerationError, SchemaValidationError, SchmockError, } from "./errors.js";
 export { badRequest, created, forbidden, noContent, notFound, paginate, serverError, unauthorized, } from "./helpers.js";
-export { collectBody, parseNodeHeaders, parseNodeQuery, writeSchmockResponse, } from "./http-helpers.js";
+export type { HttpIngressErrorCode } from "./http-helpers.js";
+export { collectBody, HttpIngressError, parseNodeHeaders, parseNodeQuery, writeRejectedSchmockResponse, writeSchmockResponse, } from "./http-helpers.js";
 export { createFetchInterceptor } from "./interceptor.js";
-export type { AdapterRequest, AdapterResponse, CallableMockInstance, Generator, GeneratorFunction, GlobalConfig, HttpMethod, InterceptHandle, InterceptOptions, Plugin, PluginContext, PluginResult, RequestContext, RequestOptions, RequestRecord, Response, ResponseBody, ResponseResult, RouteConfig, RouteInfo, RouteKey, ServerInfo, StaticData, } from "./types.js";
+export { normalizeResponse, serializeResponseBody, } from "./response-normalizer.js";
+export type { AdapterRequest, AdapterRequestOverride, AdapterResponse, AngularAdapterOptions, CallableMockInstance, CrudOperationMeta, ExpressAdapterOptions, FakerPluginOptions, Generator, GeneratorFunction, GlobalConfig, HttpMethod, InterceptHandle, InterceptOptions, OpenApiCallbackOptions, OpenApiCallbackRequest, OpenApiOptions, Plugin, PluginContext, PluginResult, RequestContext, RequestOptions, RequestRecord, ResourceOverride, Response, ResponseBody, ResponseHeaderDef, ResponseResult, RouteConfig, RouteInfo, RouteKey, Schema, SchemaDefinition, SchemaGenerationContext, SeedConfig, SeedSource, ServerInfo, StaticData, } 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,CAqD9B;AAED,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,YAAY,EACZ,UAAU,GACX,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,UAAU,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,YAAY,GACb,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,YAAY,EACV,cAAc,EACd,eAAe,EACf,oBAAoB,EACpB,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,MAAM,EACN,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,EACd,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,WAAW,EACX,SAAS,EACT,QAAQ,EACR,UAAU,EACV,UAAU,GACX,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CACrB,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,GAC5B,OAAO,CAAC,oBAAoB,CAyD9B;AAED,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EACL,oBAAoB,EACpB,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,YAAY,EACZ,UAAU,GACX,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,kBAAkB,EAClB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,UAAU,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,YAAY,GACb,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,4BAA4B,EAC5B,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EACL,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,0BAA0B,CAAC;AAElC,YAAY,EACV,cAAc,EACd,sBAAsB,EACtB,eAAe,EACf,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAClB,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,EACtB,cAAc,EACd,MAAM,EACN,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,QAAQ,EACR,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,SAAS,EACT,QAAQ,EACR,MAAM,EACN,gBAAgB,EAChB,uBAAuB,EACvB,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,4 +1,5 @@
 import { CallableMockInstance } from "./builder.js";
+const REQUEST_ADMISSION = Symbol.for("@schmock/core.request-admission");
 /**
  * Create a new Schmock mock instance with callable API.
  *
@@ -56,18 +57,22 @@ export function schmock(config) {
         close: instance.close.bind(instance),
         intercept: (options) => instance.intercept(options),
     });
+    Object.defineProperty(callableInstance, REQUEST_ADMISSION, {
+        value: () => instance.createRequestAdmission(),
+    });
     instance.setCallableRef(callableInstance);
     return callableInstance;
 }
 export { isBinaryBody } from "./binary.js";
 // Re-export constants and utilities
-export { HTTP_METHODS, isHttpMethod, isRouteNotFound, isStatusTuple, ROUTE_NOT_FOUND_CODE, toHttpMethod, toRouteKey, } from "./constants.js";
+export { getResponseException, HTTP_METHODS, isHttpMethod, isRouteNotFound, isStatusTuple, ROUTE_NOT_FOUND_CODE, toHttpMethod, toRouteKey, } from "./constants.js";
 // Re-export errors
-export { PluginError, ResourceLimitError, ResponseGenerationError, RouteDefinitionError, RouteNotFoundError, RouteParseError, SchemaGenerationError, SchemaValidationError, SchmockError, } from "./errors.js";
+export { InvalidResponseError, PluginError, ResourceLimitError, RouteDefinitionError, RouteNotFoundError, RouteParseError, SchemaGenerationError, SchemaValidationError, SchmockError, } from "./errors.js";
 // Re-export response helpers
 export { badRequest, created, forbidden, noContent, notFound, paginate, serverError, unauthorized, } from "./helpers.js";
 // Re-export HTTP server helpers
-export { collectBody, parseNodeHeaders, parseNodeQuery, writeSchmockResponse, } from "./http-helpers.js";
+export { collectBody, HttpIngressError, parseNodeHeaders, parseNodeQuery, writeRejectedSchmockResponse, writeSchmockResponse, } from "./http-helpers.js";
 // Re-export types
 // Re-export interceptor
 export { createFetchInterceptor } from "./interceptor.js";
+export { normalizeResponse, serializeResponseBody, } from "./response-normalizer.js";

package/dist/interceptor.d.ts

@@ -1,5 +1,15 @@
+type InterceptRequestHandler = (method: Schmock.HttpMethod, path: string, requestOptions?: Schmock.RequestOptions) => Promise<Schmock.Response>;
+interface InterceptRequestAdmission {
+    handle: InterceptRequestHandler;
+    release(): void;
+}
 /**
  * Create a fetch interceptor that routes requests through mock.handle().
+ *
+ * `owner` identifies the mock behind the lease. Leases sharing an owner are
+ * consulted at most once per request, so a mock held by several leases runs
+ * its handler — and emits its lifecycle events — once per network request.
  */
-export declare function createFetchInterceptor(handle: (method: Schmock.HttpMethod, path: string, requestOptions?: Schmock.RequestOptions) => Promise<Schmock.Response>, options?: Schmock.InterceptOptions): Schmock.InterceptHandle;
+export declare function createFetchInterceptor(handle: InterceptRequestHandler, options?: Schmock.InterceptOptions, admitRequest?: () => InterceptRequestAdmission, owner?: symbol): Schmock.InterceptHandle;
+export {};
 //# sourceMappingURL=interceptor.d.ts.map

package/dist/interceptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interceptor.d.ts","sourceRoot":"","sources":["../src/interceptor.ts"],"names":[],"mappings":"AAwPA;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,CACN,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,MAAM,EACZ,cAAc,CAAC,EAAE,OAAO,CAAC,cAAc,KACpC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC9B,OAAO,GAAE,OAAO,CAAC,gBAAqB,GACrC,OAAO,CAAC,eAAe,CAoJzB"}
+{"version":3,"file":"interceptor.d.ts","sourceRoot":"","sources":["../src/interceptor.ts"],"names":[],"mappings":"AAkCA,KAAK,uBAAuB,GAAG,CAC7B,MAAM,EAAE,OAAO,CAAC,UAAU,EAC1B,IAAI,EAAE,MAAM,EACZ,cAAc,CAAC,EAAE,OAAO,CAAC,cAAc,KACpC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAU/B,UAAU,yBAAyB;IACjC,MAAM,EAAE,uBAAuB,CAAC;IAChC,OAAO,IAAI,IAAI,CAAC;CACjB;AAqYD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,uBAAuB,EAC/B,OAAO,GAAE,OAAO,CAAC,gBAAqB,EACtC,YAAY,CAAC,EAAE,MAAM,yBAAyB,EAC9C,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,CAqKzB"}