@schmock/openapi 1.2.0 → 1.4.0

package/dist/content-negotiation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Negotiate the best content type match for an Accept header.
+ * Supports quality values (q=0.8) and wildcards (*\/*).
+ * Returns the matched content type or null if no match.
+ */
+export declare function negotiateContentType(accept: string, available: string[]): string | null;
+//# sourceMappingURL=content-negotiation.d.ts.map

package/dist/content-negotiation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-negotiation.d.ts","sourceRoot":"","sources":["../src/content-negotiation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EAAE,GAClB,MAAM,GAAG,IAAI,CA4Cf"}

package/dist/content-negotiation.js

@@ -0,0 +1,46 @@
+/**
+ * Negotiate the best content type match for an Accept header.
+ * Supports quality values (q=0.8) and wildcards (*\/*).
+ * Returns the matched content type or null if no match.
+ */
+export function negotiateContentType(accept, available) {
+    if (!accept || accept === "*/*") {
+        return available[0] ?? null;
+    }
+    // Parse Accept header into sorted entries by quality
+    const entries = accept
+        .split(",")
+        .map((part) => {
+        const [type, ...params] = part.trim().split(";");
+        let q = 1;
+        for (const param of params) {
+            const match = param.trim().match(/^q\s*=\s*([\d.]+)$/);
+            if (match) {
+                q = Number.parseFloat(match[1]);
+            }
+        }
+        return { type: type.trim(), q };
+    })
+        .sort((a, b) => b.q - a.q);
+    for (const entry of entries) {
+        if (entry.q === 0)
+            continue;
+        // Wildcard matches anything
+        if (entry.type === "*/*") {
+            return available[0] ?? null;
+        }
+        // Type wildcard (e.g., "application/*")
+        if (entry.type.endsWith("/*")) {
+            const prefix = entry.type.slice(0, -1);
+            const match = available.find((ct) => ct.startsWith(prefix));
+            if (match)
+                return match;
+            continue;
+        }
+        // Exact match
+        if (available.includes(entry.type)) {
+            return entry.type;
+        }
+    }
+    return null;
+}

package/dist/crud-detector.d.ts

@@ -14,6 +14,8 @@ export interface CrudResource {
     operations: CrudOperation[];
     /** Response schema for the resource item */
     schema?: JSONSchema7;
+    /** Per-operation metadata auto-detected from spec */
+    operationMeta?: Map<CrudOperation, Schmock.CrudOperationMeta>;
 }
 interface DetectionResult {
     resources: CrudResource[];

package/dist/crud-detector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crud-detector.d.ts","sourceRoot":"","sources":["../src/crud-detector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE7E,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,4CAA4C;IAC5C,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,UAAU,eAAe;IACvB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,+CAA+C;IAC/C,YAAY,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,eAAe,CA6BxE"}
+{"version":3,"file":"crud-detector.d.ts","sourceRoot":"","sources":["../src/crud-detector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE7E,MAAM,WAAW,YAAY;IAC3B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,4CAA4C;IAC5C,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,qDAAqD;IACrD,aAAa,CAAC,EAAE,GAAG,CAAC,aAAa,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC/D;AAED,UAAU,eAAe;IACvB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,+CAA+C;IAC/C,YAAY,EAAE,UAAU,EAAE,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,eAAe,CA6BxE"}

package/dist/crud-detector.js

@@ -1,4 +1,5 @@
-/// <reference path="../../../types/schmock.d.ts" />
+/// <reference path="../../core/schmock.d.ts" />
+import { findArrayProperty } from "./generators.js";
 import { isRecord, toJsonSchema } from "./utils.js";
 /**
  * Detect CRUD resource patterns from parsed OpenAPI paths.
@@ -61,25 +62,38 @@ function buildResource(basePath, paths) {
     let itemPath = "";
     let idParam = "";
     let schema;
+    const operationMeta = new Map();
     for (const p of paths) {
         const isCollection = p.path === basePath;
         const isItem = !isCollection && p.path.startsWith(basePath);
         if (isCollection) {
             if (p.method === "GET") {
                 operations.push("list");
-                // Try to extract item schema from list response (array items)
                 const listSchema = getSuccessResponseSchema(p);
-                if (listSchema && listSchema.type === "array" && listSchema.items) {
-                    const items = Array.isArray(listSchema.items)
-                        ? listSchema.items[0]
-                        : listSchema.items;
-                    if (isRecord(items)) {
-                        schema = schema ?? toJsonSchema(items);
+                if (listSchema) {
+                    // Extract item schema from both flat arrays and wrapped lists
+                    const arrayInfo = findArrayProperty(listSchema);
+                    if (arrayInfo.itemSchema) {
+                        schema = schema ?? arrayInfo.itemSchema;
+                    }
+                    else if (listSchema.type === "array" && listSchema.items) {
+                        // Fallback: direct flat array
+                        const items = Array.isArray(listSchema.items)
+                            ? listSchema.items[0]
+                            : listSchema.items;
+                        if (isRecord(items)) {
+                            schema = schema ?? toJsonSchema(items);
+                        }
                     }
                 }
+                // Capture list operation metadata
+                const meta = buildOperationMeta(p, "list");
+                operationMeta.set("list", meta);
             }
             else if (p.method === "POST") {
                 operations.push("create");
+                const meta = buildOperationMeta(p, "create");
+                operationMeta.set("create", meta);
             }
         }
         else if (isItem) {
@@ -97,14 +111,20 @@ function buildResource(basePath, paths) {
                 if (p.method === "GET") {
                     operations.push("read");
                     schema = schema ?? getSuccessResponseSchema(p);
+                    const meta = buildOperationMeta(p, "read");
+                    operationMeta.set("read", meta);
                 }
                 else if (p.method === "PUT" || p.method === "PATCH") {
                     if (!operations.includes("update")) {
                         operations.push("update");
+                        const meta = buildOperationMeta(p, "update");
+                        operationMeta.set("update", meta);
                     }
                 }
                 else if (p.method === "DELETE") {
                     operations.push("delete");
+                    const meta = buildOperationMeta(p, "delete");
+                    operationMeta.set("delete", meta);
                 }
             }
         }
@@ -137,8 +157,35 @@ function buildResource(basePath, paths) {
         idParam,
         operations,
         schema,
+        operationMeta: operationMeta.size > 0 ? operationMeta : undefined,
     };
 }
+function buildOperationMeta(p, _operation) {
+    const meta = {};
+    // Capture full success response schema
+    const responseSchema = getSuccessResponseSchema(p);
+    if (responseSchema) {
+        meta.responseSchema = responseSchema;
+    }
+    // Capture success response headers
+    for (const [code, resp] of p.responses) {
+        if (code >= 200 && code < 300 && resp.headers) {
+            meta.responseHeaders = resp.headers;
+            break;
+        }
+    }
+    // Capture error response schemas (4xx)
+    const errorSchemas = new Map();
+    for (const [code, resp] of p.responses) {
+        if (code >= 400 && code < 600 && resp.schema) {
+            errorSchemas.set(code, resp.schema);
+        }
+    }
+    if (errorSchemas.size > 0) {
+        meta.errorSchemas = errorSchemas;
+    }
+    return meta;
+}
 function getSuccessResponseSchema(p) {
     // Try 200, then 201, then first 2xx
     for (const code of [200, 201]) {

package/dist/generators.d.ts

@@ -1,14 +1,34 @@
 import type { JSONSchema7 } from "json-schema";
 import type { CrudResource } from "./crud-detector.js";
 import type { ParsedPath } from "./parser.js";
-export declare function createListGenerator(resource: CrudResource): Schmock.GeneratorFunction;
-export declare function createCreateGenerator(resource: CrudResource): Schmock.GeneratorFunction;
-export declare function createReadGenerator(resource: CrudResource): Schmock.GeneratorFunction;
-export declare function createUpdateGenerator(resource: CrudResource): Schmock.GeneratorFunction;
-export declare function createDeleteGenerator(resource: CrudResource): Schmock.GeneratorFunction;
-export declare function createStaticGenerator(parsedPath: ParsedPath): Schmock.GeneratorFunction;
+/**
+ * Result of finding the array property in a response schema.
+ * If property is undefined, the schema is a flat array (or unknown).
+ */
+interface ArrayPropertyInfo {
+    /** Property name holding the array (e.g. "data"), undefined for flat arrays */
+    property?: string;
+    /** Schema for the array items */
+    itemSchema?: JSONSchema7;
+}
+/**
+ * Find which property in a response schema holds the array of items.
+ * Handles flat arrays, object wrappers (Stripe), and allOf compositions (Scalar Galaxy).
+ */
+export declare function findArrayProperty(schema: JSONSchema7): ArrayPropertyInfo;
+/**
+ * Generate header values from spec-defined response header definitions.
+ */
+export declare function generateHeaderValues(headerDefs: Record<string, Schmock.ResponseHeaderDef> | undefined): Record<string, string>;
+export declare function createListGenerator(resource: CrudResource, meta?: Schmock.CrudOperationMeta): Schmock.GeneratorFunction;
+export declare function createCreateGenerator(resource: CrudResource, meta?: Schmock.CrudOperationMeta): Schmock.GeneratorFunction;
+export declare function createReadGenerator(resource: CrudResource, meta?: Schmock.CrudOperationMeta): Schmock.GeneratorFunction;
+export declare function createUpdateGenerator(resource: CrudResource, meta?: Schmock.CrudOperationMeta): Schmock.GeneratorFunction;
+export declare function createDeleteGenerator(resource: CrudResource, meta?: Schmock.CrudOperationMeta): Schmock.GeneratorFunction;
+export declare function createStaticGenerator(parsedPath: ParsedPath, seed?: number): Schmock.GeneratorFunction;
 /**
  * Generate seed items for a resource using its schema.
  */
-export declare function generateSeedItems(schema: JSONSchema7, count: number, idParam: string): unknown[];
+export declare function generateSeedItems(schema: JSONSchema7, count: number, idParam: string, seed?: number): unknown[];
+export {};
 //# sourceMappingURL=generators.d.ts.map

package/dist/generators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generators.d.ts","sourceRoot":"","sources":["../src/generators.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAwC9C,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAK3B;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAkB3B;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAY3B;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAoB3B;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAa3B;AAED,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,iBAAiB,CAiC3B;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GACd,OAAO,EAAE,CAWX"}
+{"version":3,"file":"generators.d.ts","sourceRoot":"","sources":["../src/generators.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C;;;GAGG;AACH,UAAU,iBAAiB;IACzB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,UAAU,CAAC,EAAE,WAAW,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,iBAAiB,CA4CxE;AAiBD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,SAAS,GAChE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAaxB;AAuED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,YAAY,EACtB,IAAI,CAAC,EAAE,OAAO,CAAC,iBAAiB,GAC/B,OAAO,CAAC,iBAAiB,CAyB3B;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,IAAI,CAAC,EAAE,OAAO,CAAC,iBAAiB,GAC/B,OAAO,CAAC,iBAAiB,CAoB3B;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,YAAY,EACtB,IAAI,CAAC,EAAE,OAAO,CAAC,iBAAiB,GAC/B,OAAO,CAAC,iBAAiB,CAc3B;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,IAAI,CAAC,EAAE,OAAO,CAAC,iBAAiB,GAC/B,OAAO,CAAC,iBAAiB,CAsB3B;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,IAAI,CAAC,EAAE,OAAO,CAAC,iBAAiB,GAC/B,OAAO,CAAC,iBAAiB,CAa3B;AAED,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,EACtB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,iBAAiB,CAiC3B;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,EAAE,CAWX"}

package/dist/generators.js

@@ -1,7 +1,108 @@
-/// <reference path="../../../types/schmock.d.ts" />
-import { generateFromSchema } from "@schmock/schema";
+/// <reference path="../../core/schmock.d.ts" />
+import { randomUUID } from "node:crypto";
+import { generateFromSchema } from "@schmock/faker";
 import { isRecord } from "./utils.js";
 const COLLECTION_STATE_PREFIX = "openapi:collections:";
+/**
+ * Find which property in a response schema holds the array of items.
+ * Handles flat arrays, object wrappers (Stripe), and allOf compositions (Scalar Galaxy).
+ */
+export function findArrayProperty(schema) {
+    if (!schema || typeof schema === "boolean")
+        return {};
+    // Case 1: flat array
+    if (schema.type === "array") {
+        const items = Array.isArray(schema.items) ? schema.items[0] : schema.items;
+        const itemSchema = isRecord(items) ? items : undefined;
+        return { itemSchema };
+    }
+    // Case 2: object with properties — scan for the array property
+    if (schema.type === "object" && isRecord(schema.properties)) {
+        return findArrayInProperties(schema.properties);
+    }
+    // Case 3: allOf — merge branches into one virtual object, then scan
+    if (Array.isArray(schema.allOf)) {
+        const merged = {};
+        for (const branch of schema.allOf) {
+            if (isRecord(branch) && isRecord(branch.properties)) {
+                for (const [key, value] of Object.entries(branch.properties)) {
+                    if (isRecord(value)) {
+                        merged[key] = value;
+                    }
+                }
+            }
+        }
+        if (Object.keys(merged).length > 0) {
+            return findArrayInProperties(merged);
+        }
+    }
+    // Case 4: anyOf/oneOf — try first branch
+    for (const keyword of ["anyOf", "oneOf"]) {
+        const branches = schema[keyword];
+        if (Array.isArray(branches) && branches.length > 0) {
+            const first = branches[0];
+            if (isRecord(first)) {
+                return findArrayProperty(first);
+            }
+        }
+    }
+    return {};
+}
+function findArrayInProperties(properties) {
+    for (const [key, value] of Object.entries(properties)) {
+        if (!isRecord(value))
+            continue;
+        const prop = value;
+        if (prop.type === "array" && prop.items) {
+            const items = Array.isArray(prop.items) ? prop.items[0] : prop.items;
+            const itemSchema = isRecord(items) ? items : undefined;
+            return { property: key, itemSchema };
+        }
+    }
+    return {};
+}
+/**
+ * Generate header values from spec-defined response header definitions.
+ */
+export function generateHeaderValues(headerDefs) {
+    if (!headerDefs)
+        return {};
+    const headers = {};
+    for (const [name, def] of Object.entries(headerDefs)) {
+        const value = generateSingleHeaderValue(def.schema);
+        if (value !== undefined) {
+            headers[name] = value;
+        }
+    }
+    return headers;
+}
+function generateSingleHeaderValue(schema) {
+    if (!schema || typeof schema === "boolean")
+        return undefined;
+    // Has enum → first value
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        return String(schema.enum[0]);
+    }
+    // Has default (from example → default normalization)
+    if ("default" in schema && schema.default !== undefined) {
+        return String(schema.default);
+    }
+    // Format-based generation
+    if (schema.format === "uuid") {
+        return randomUUID();
+    }
+    if (schema.format === "date-time") {
+        return new Date().toISOString();
+    }
+    // Type-based fallback
+    if (schema.type === "integer" || schema.type === "number") {
+        return "0";
+    }
+    if (schema.type === "string") {
+        return "";
+    }
+    return undefined;
+}
 function toTuple(status, body) {
     return [status, body];
 }
@@ -27,13 +128,30 @@ function getNextId(state, resourceName) {
     state[counterKey] = next;
     return next;
 }
-export function createListGenerator(resource) {
+export function createListGenerator(resource, meta) {
+    // Pre-compute wrapper info at setup time
+    const wrapperInfo = meta?.responseSchema
+        ? findArrayProperty(meta.responseSchema)
+        : undefined;
+    const headerDefs = meta?.responseHeaders;
     return (ctx) => {
         const collection = getCollection(ctx.state, resource.name);
-        return [...collection];
+        const items = [...collection];
+        // If no wrapper detected or flat array, return items directly
+        if (!wrapperInfo?.property || !meta?.responseSchema) {
+            return addHeaders(items, headerDefs);
+        }
+        // Generate the full wrapper skeleton from schema, then inject live data
+        const skeleton = generateWrapperSkeleton(meta.responseSchema);
+        if (isRecord(skeleton)) {
+            skeleton[wrapperInfo.property] = items;
+            return addHeaders(skeleton, headerDefs);
+        }
+        return addHeaders(items, headerDefs);
     };
 }
-export function createCreateGenerator(resource) {
+export function createCreateGenerator(resource, meta) {
+    const headerDefs = meta?.responseHeaders;
     return (ctx) => {
         const collection = getCollection(ctx.state, resource.name);
         const id = getNextId(ctx.state, resource.name);
@@ -48,27 +166,29 @@ export function createCreateGenerator(resource) {
             item = { [resource.idParam]: id };
         }
         collection.push(item);
-        return toTuple(201, item);
+        return addHeaders(toTuple(201, item), headerDefs);
     };
 }
-export function createReadGenerator(resource) {
+export function createReadGenerator(resource, meta) {
+    const headerDefs = meta?.responseHeaders;
     return (ctx) => {
         const collection = getCollection(ctx.state, resource.name);
         const idValue = ctx.params[resource.idParam];
         const item = findById(collection, resource.idParam, idValue);
         if (!item) {
-            return toTuple(404, { error: "Not found", code: "NOT_FOUND" });
+            return generateErrorResponse(404, meta);
         }
-        return item;
+        return addHeaders(item, headerDefs);
     };
 }
-export function createUpdateGenerator(resource) {
+export function createUpdateGenerator(resource, meta) {
+    const headerDefs = meta?.responseHeaders;
     return (ctx) => {
         const collection = getCollection(ctx.state, resource.name);
         const idValue = ctx.params[resource.idParam];
         const index = findIndexById(collection, resource.idParam, idValue);
         if (index === -1) {
-            return toTuple(404, { error: "Not found", code: "NOT_FOUND" });
+            return generateErrorResponse(404, meta);
         }
         const existingRaw = collection[index];
         const existing = isRecord(existingRaw) ? existingRaw : {};
@@ -78,22 +198,22 @@ export function createUpdateGenerator(resource) {
             [resource.idParam]: existing[resource.idParam], // Preserve ID
         };
         collection[index] = updated;
-        return updated;
+        return addHeaders(updated, headerDefs);
     };
 }
-export function createDeleteGenerator(resource) {
+export function createDeleteGenerator(resource, meta) {
     return (ctx) => {
         const collection = getCollection(ctx.state, resource.name);
         const idValue = ctx.params[resource.idParam];
         const index = findIndexById(collection, resource.idParam, idValue);
         if (index === -1) {
-            return toTuple(404, { error: "Not found", code: "NOT_FOUND" });
+            return generateErrorResponse(404, meta);
         }
         collection.splice(index, 1);
         return toTuple(204, undefined);
     };
 }
-export function createStaticGenerator(parsedPath) {
+export function createStaticGenerator(parsedPath, seed) {
     // Get the success response schema
     let responseSchema;
     for (const code of [200, 201]) {
@@ -114,7 +234,7 @@ export function createStaticGenerator(parsedPath) {
     return () => {
         if (responseSchema) {
             try {
-                return generateFromSchema({ schema: responseSchema });
+                return generateFromSchema({ schema: responseSchema, seed });
             }
             catch (error) {
                 console.warn(`[@schmock/openapi] Schema generation failed for ${parsedPath.method} ${parsedPath.path}:`, error instanceof Error ? error.message : error);
@@ -127,10 +247,10 @@ export function createStaticGenerator(parsedPath) {
 /**
  * Generate seed items for a resource using its schema.
  */
-export function generateSeedItems(schema, count, idParam) {
+export function generateSeedItems(schema, count, idParam, seed) {
     const items = [];
     for (let i = 0; i < count; i++) {
-        const generated = generateFromSchema({ schema });
+        const generated = generateFromSchema({ schema, seed });
         const item = isRecord(generated)
             ? generated
             : { value: generated };
@@ -139,6 +259,58 @@ export function generateSeedItems(schema, count, idParam) {
     }
     return items;
 }
+/**
+ * Generate an error response using the spec's error schema if available,
+ * or fall back to the default { error, code } format.
+ */
+function generateErrorResponse(status, meta) {
+    const errorSchema = meta?.errorSchemas?.get(status);
+    if (errorSchema) {
+        try {
+            const body = generateFromSchema({ schema: errorSchema });
+            return toTuple(status, body);
+        }
+        catch {
+            // Fall through to default
+        }
+    }
+    // Default error format
+    const defaults = {
+        404: { error: "Not found", code: "NOT_FOUND" },
+        400: { error: "Bad request", code: "BAD_REQUEST" },
+        409: { error: "Conflict", code: "CONFLICT" },
+    };
+    return toTuple(status, defaults[status] ?? { error: "Error", code: "ERROR" });
+}
+/**
+ * Generate a skeleton object from a response schema.
+ * Used to create wrapper objects (e.g. { data: [], has_more: false, object: "list" })
+ */
+function generateWrapperSkeleton(schema) {
+    try {
+        return generateFromSchema({ schema });
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * If response headers are defined, convert a response value into a triple [status, body, headers].
+ * Otherwise return the value as-is.
+ */
+function addHeaders(value, headerDefs) {
+    const headers = generateHeaderValues(headerDefs);
+    if (Object.keys(headers).length === 0) {
+        return value;
+    }
+    // If already a tuple [status, body] or [status, body, headers]
+    if (Array.isArray(value) && value.length >= 2) {
+        const status = typeof value[0] === "number" ? value[0] : 200;
+        return [status, value[1], headers];
+    }
+    // Plain value → [200, body, headers]
+    return [200, value, headers];
+}
 function findById(collection, idParam, idValue) {
     return collection.find((item) => {
         if (!isRecord(item))