@schmock/core 2.4.1 → 2.5.0

package/dist/response-normalizer.d.ts

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

package/dist/response-normalizer.js

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

package/dist/response-parser.d.ts

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

package/dist/response-parser.js

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

package/dist/route-matcher.d.ts

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

package/dist/route-table.d.ts

@@ -0,0 +1,64 @@
+import type { DebugLogger } from "./debug-logger.js";
+import type { CompiledCallableRoute } from "./route-matcher.js";
+/** The route containers an admitted request routes with. */
+export interface RouteTableSnapshot {
+    readonly routes: CompiledCallableRoute[];
+    readonly staticRoutes: Map<string, CompiledCallableRoute>;
+}
+/** The table as it stood before a `pipe()` install, for its rollback. */
+interface RouteTableCheckpoint extends RouteTableSnapshot {
+    readonly shared: boolean;
+}
+/**
+ * The mock's registered routes: every route in registration order, plus the
+ * static (parameterless) ones in a map for O(1) lookup.
+ *
+ * The containers are copy-on-write. An admitted request captures them by
+ * reference (`share()`), and the first registration after that copies them,
+ * so an in-flight snapshot never changes underneath its request and no
+ * request pays for a copy of the whole table.
+ */
+export declare class RouteTable {
+    #private;
+    /** O(1) snapshot for an admitted request. */
+    share(): RouteTableSnapshot;
+    define(input: {
+        route: Schmock.RouteKey;
+        generator: Schmock.Generator;
+        config: Schmock.RouteConfig;
+        logger: DebugLogger;
+    }): void;
+    list(): Schmock.RouteInfo[];
+    /**
+     * Start a transaction: later registrations go into fresh copies, and
+     * `rollback()` puts the table back exactly as it was.
+     */
+    checkpoint(): RouteTableCheckpoint;
+    rollback(checkpoint: RouteTableCheckpoint): void;
+    /**
+     * Empty the table. The containers are replaced, never cleared in place:
+     * in-flight admissions still route with the old ones.
+     */
+    clear(): void;
+}
+/**
+ * A per-request copy of a route's config for the plugin context.
+ *
+ * Shallow on purpose: plugin metadata under `openapi:*` keys is shared,
+ * read-only structure (and some of it is keyed by identity in WeakMaps), but a
+ * plugin that assigns `context.route.contentType` or edits the delay tuple must
+ * not change every later request.
+ */
+export declare function copyRouteConfig(config: Schmock.RouteConfig): Schmock.RouteConfig;
+/**
+ * Deep-copy the plain data (arrays and plain objects) of a static generator so
+ * plugins can edit their response in place without changing the route.
+ *
+ * Anything else — dates, binary values, class instances with a prototype
+ * `toJSON` — is passed by reference: `structuredClone` would strip those
+ * prototypes (a Buffer would come back as a bare Uint8Array) and change what
+ * the response serializes to. Enumerable symbol keys are kept so the response
+ * normalizer still sees, and rejects, them.
+ */
+export declare function copyStaticData(value: unknown, copies?: Map<object, unknown>): unknown;
+export {};

package/dist/route-table.js

@@ -0,0 +1,220 @@
+import { isBinaryBody } from "./binary.js";
+import { normalizePath } from "./constants.js";
+import { RouteDefinitionError } from "./errors.js";
+import { parseRouteKey } from "./parser.js";
+function defaultContentType(generator) {
+    if (typeof generator === "function") {
+        // Default to JSON for function generators
+        return "application/json";
+    }
+    if (typeof generator === "string" ||
+        typeof generator === "number" ||
+        typeof generator === "boolean") {
+        // Default to plain text for primitives
+        return "text/plain";
+    }
+    if (isBinaryBody(generator)) {
+        // Default to octet-stream for browser and Node binary values
+        return "application/octet-stream";
+    }
+    // Default to JSON for objects/arrays
+    return "application/json";
+}
+/**
+ * The mock's registered routes: every route in registration order, plus the
+ * static (parameterless) ones in a map for O(1) lookup.
+ *
+ * The containers are copy-on-write. An admitted request captures them by
+ * reference (`share()`), and the first registration after that copies them,
+ * so an in-flight snapshot never changes underneath its request and no
+ * request pays for a copy of the whole table.
+ */
+export class RouteTable {
+    #routes = [];
+    #staticRoutes = new Map();
+    /** True once an admission holds the containers by reference. */
+    #shared = false;
+    /** O(1) snapshot for an admitted request. */
+    share() {
+        this.#shared = true;
+        return { routes: this.#routes, staticRoutes: this.#staticRoutes };
+    }
+    define(input) {
+        const { route, generator, logger } = input;
+        // FIX 1.2: shallow-clone the caller's config so mutations below stay private
+        const routeConfig = { ...input.config };
+        // Auto-detect contentType if not provided
+        if (!routeConfig.contentType) {
+            routeConfig.contentType = defaultContentType(generator);
+        }
+        // Validate generator matches contentType if it's static data
+        if (typeof generator !== "function" &&
+            routeConfig.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);
+        // FIX 2.2: normalize paths before duplicate check so /users and /users/ are
+        // treated as the same route (consistent with the static-route Map key below).
+        // Routes that differ only in parameter names (`/users/:id` and
+        // `/users/:userId`) compile to the same pattern and match the same
+        // requests, so the later one would be unreachable: it is a duplicate too.
+        const normalizedParsedPath = normalizePath(parsed.path);
+        const existing = this.#routes.find((r) => r.method === parsed.method &&
+            (normalizePath(r.path) === normalizedParsedPath ||
+                r.pattern.source === parsed.pattern.source));
+        if (existing) {
+            logger.log("warning", normalizePath(existing.path) === normalizedParsedPath
+                ? `Duplicate route: ${route} — first registration wins`
+                : `Duplicate route: ${route} matches the same requests as ${existing.method} ${existing.path} — first registration wins`);
+            return;
+        }
+        // Compile the route
+        const compiledRoute = {
+            pattern: parsed.pattern,
+            params: parsed.params,
+            method: parsed.method,
+            path: parsed.path,
+            generator,
+            config: routeConfig,
+        };
+        this.#writable();
+        this.#routes.push(compiledRoute);
+        // Store static routes (no params) in Map for O(1) lookup
+        if (parsed.params.length === 0) {
+            const key = `${parsed.method} ${normalizePath(parsed.path)}`;
+            this.#staticRoutes.set(key, compiledRoute);
+        }
+        logger.log("route", `Route defined: ${route}`, {
+            contentType: routeConfig.contentType,
+            generatorType: typeof generator,
+            hasParams: parsed.params.length > 0,
+        });
+    }
+    list() {
+        return this.#routes.map((r) => ({
+            method: r.method,
+            path: r.path,
+            hasParams: r.params.length > 0,
+        }));
+    }
+    /**
+     * Start a transaction: later registrations go into fresh copies, and
+     * `rollback()` puts the table back exactly as it was.
+     */
+    checkpoint() {
+        const checkpoint = {
+            routes: this.#routes,
+            staticRoutes: this.#staticRoutes,
+            shared: this.#shared,
+        };
+        this.#routes = checkpoint.routes.slice();
+        this.#staticRoutes = new Map(checkpoint.staticRoutes);
+        this.#shared = false;
+        return checkpoint;
+    }
+    rollback(checkpoint) {
+        this.#routes = checkpoint.routes;
+        this.#staticRoutes = checkpoint.staticRoutes;
+        this.#shared = checkpoint.shared;
+    }
+    /**
+     * Empty the table. The containers are replaced, never cleared in place:
+     * in-flight admissions still route with the old ones.
+     */
+    clear() {
+        this.#routes = [];
+        this.#staticRoutes = new Map();
+        this.#shared = false;
+    }
+    /**
+     * Copy-on-write for the route tables. An admitted request routes with the
+     * containers it captured, by reference; the first registration after that
+     * copies them so the in-flight snapshot never changes underneath it.
+     */
+    #writable() {
+        if (!this.#shared)
+            return;
+        this.#routes = this.#routes.slice();
+        this.#staticRoutes = new Map(this.#staticRoutes);
+        this.#shared = false;
+    }
+}
+/**
+ * A per-request copy of a route's config for the plugin context.
+ *
+ * Shallow on purpose: plugin metadata under `openapi:*` keys is shared,
+ * read-only structure (and some of it is keyed by identity in WeakMaps), but a
+ * plugin that assigns `context.route.contentType` or edits the delay tuple must
+ * not change every later request.
+ */
+export function copyRouteConfig(config) {
+    const copy = { ...config };
+    if (Array.isArray(config.delay)) {
+        copy.delay = [config.delay[0], config.delay[1]];
+    }
+    return copy;
+}
+function isPlainObject(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * Define an own enumerable data property. Plain assignment would run the
+ * `__proto__` setter for an own `__proto__` key (which `JSON.parse` creates),
+ * dropping the key and re-prototyping the copy.
+ */
+function defineDataProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true,
+    });
+}
+/**
+ * Deep-copy the plain data (arrays and plain objects) of a static generator so
+ * plugins can edit their response in place without changing the route.
+ *
+ * Anything else — dates, binary values, class instances with a prototype
+ * `toJSON` — is passed by reference: `structuredClone` would strip those
+ * prototypes (a Buffer would come back as a bare Uint8Array) and change what
+ * the response serializes to. Enumerable symbol keys are kept so the response
+ * normalizer still sees, and rejects, them.
+ */
+export function copyStaticData(value, copies = new Map()) {
+    if (typeof value !== "object" || value === null)
+        return value;
+    const existing = copies.get(value);
+    if (existing !== undefined)
+        return existing;
+    if (Array.isArray(value)) {
+        const copy = new Array(value.length);
+        copies.set(value, copy);
+        for (let index = 0; index < value.length; index += 1) {
+            if (index in value)
+                copy[index] = copyStaticData(value[index], copies);
+        }
+        for (const key of Object.getOwnPropertySymbols(value)) {
+            if (!Object.getOwnPropertyDescriptor(value, key)?.enumerable)
+                continue;
+            defineDataProperty(copy, key, copyStaticData(Reflect.get(value, key), copies));
+        }
+        return copy;
+    }
+    if (!isPlainObject(value))
+        return value;
+    const copy = Object.getPrototypeOf(value) === null ? Object.create(null) : {};
+    copies.set(value, copy);
+    for (const key of Reflect.ownKeys(value)) {
+        if (!Object.getOwnPropertyDescriptor(value, key)?.enumerable)
+            continue;
+        defineDataProperty(copy, key, copyStaticData(Reflect.get(value, key), copies));
+    }
+    return copy;
+}

package/dist/types.d.ts

@@ -15,6 +15,7 @@ export type CallableMockInstance = Schmock.CallableMockInstance;
 export type Plugin = Schmock.Plugin;
 export type PluginContext = Schmock.PluginContext;
 export type PluginResult = Schmock.PluginResult;
+export type PluginHookResult = Schmock.PluginHookResult;
 export type StaticData = Schmock.StaticData;
 export type RequestRecord = Schmock.RequestRecord;
 export type ServerInfo = Schmock.ServerInfo;
@@ -24,9 +25,22 @@ export type ResponseHeaderDef = Schmock.ResponseHeaderDef;
 export type CrudOperationMeta = Schmock.CrudOperationMeta;
 export type SchemaGenerationContext = Schmock.SchemaGenerationContext;
 export type FakerPluginOptions = Schmock.FakerPluginOptions;
+/**
+ * @deprecated Import `ExpressAdapterOptions` from `@schmock/express`, which
+ * types `req`/`res` as Express's `Request`/`Response`. This copy types them
+ * `unknown` and will be removed in the next major version.
+ */
 export type ExpressAdapterOptions = Schmock.ExpressAdapterOptions;
+/**
+ * @deprecated Import `AngularAdapterOptions` from `@schmock/angular`, which
+ * types `request` as Angular's `HttpRequest`. This copy types it `unknown` and
+ * will be removed in the next major version.
+ */
 export type AngularAdapterOptions = Schmock.AngularAdapterOptions;
 export type OpenApiOptions = Schmock.OpenApiOptions;
+export type OpenApiRefPolicy = Schmock.OpenApiRefPolicy;
+export type OnSchemaContext = Schmock.OnSchemaContext;
+export type OnSchemaCallback = Schmock.OnSchemaCallback;
 export type OpenApiCallbackRequest = Schmock.OpenApiCallbackRequest;
 export type OpenApiCallbackOptions = Schmock.OpenApiCallbackOptions;
 export type SeedSource = Schmock.SeedSource;
@@ -36,4 +50,16 @@ export type AdapterResponse = Schmock.AdapterResponse;
 export type InterceptOptions = Schmock.InterceptOptions;
 export type InterceptHandle = Schmock.InterceptHandle;
 export type AdapterRequestOverride = Schmock.AdapterRequestOverride;
-//# sourceMappingURL=types.d.ts.map
+export type PaginateOptions = Schmock.PaginateOptions;
+export type PaginatedResponse<T> = Schmock.PaginatedResponse<T>;
+export type RequestStartEvent = Schmock.RequestStartEvent;
+export type RequestMatchEvent = Schmock.RequestMatchEvent;
+export type RequestNotFoundEvent = Schmock.RequestNotFoundEvent;
+export type RequestEndEvent = Schmock.RequestEndEvent;
+export type SchmockEventMap = Schmock.SchmockEventMap;
+export type SchmockEvent = Schmock.SchmockEvent;
+export type ResponseParts = Schmock.ResponseParts;
+export type PathPrefix = Schmock.PathPrefix;
+export type FormattedErrorOptions = Schmock.FormattedErrorOptions;
+export type MockRequestHandler = Schmock.MockRequestHandler;
+export type RequestAdmission = Schmock.RequestAdmission;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/core",
   "description": "Core functionality for Schmock",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -27,6 +27,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./adapter": {
+      "types": "./dist/adapter.d.ts",
+      "import": "./dist/adapter.js",
+      "default": "./dist/adapter.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -39,8 +44,8 @@
     "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": "biome check src/",
+    "lint:fix": "biome check --write --unsafe src/",
     "check:publish": "publint && attw --pack --ignore-rules cjs-resolves-to-esm"
   },
   "license": "MIT",