@schmock/schema 1.0.2 → 1.2.1

package/dist/test-utils.d.ts

@@ -1,4 +1,7 @@
 import type { JSONSchema7 } from "json-schema";
+interface FakerSchema extends JSONSchema7 {
+    faker?: string;
+}
 export declare const schemas: {
     simple: {
         string: () => JSONSchema7;
@@ -9,7 +12,7 @@ export declare const schemas: {
             maxItems?: number;
         }) => JSONSchema7;
     };
-    withFaker: (type: JSONSchema7["type"], fakerMethod: string) => JSONSchema7;
+    withFaker: (type: JSONSchema7["type"], fakerMethod: string) => FakerSchema;
     nested: {
         deep: (depth: number, leafSchema?: JSONSchema7) => JSONSchema7;
         wide: (width: number, propertySchema?: JSONSchema7) => JSONSchema7;
@@ -50,10 +53,5 @@ export declare const schemaTests: {
     expectInvalid: (schema: any, errorMessage?: string | RegExp) => void;
     expectSchemaError: (schema: any, path: string, issue?: string) => void;
 };
-export declare const mocks: {
-    trackFakerCalls: () => {
-        calls: string[];
-        reset: () => void;
-    };
-};
+export {};
 //# sourceMappingURL=test-utils.d.ts.map

package/dist/test-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK/C,eAAO,MAAM,OAAO;;sBAEJ,WAAW;sBAIX,WAAW;8BAIF,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,KAAQ,WAAW;uBAM1D,WAAW,gBACJ;YAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,KACrD,WAAW;;sBAOE,WAAW,CAAC,MAAM,CAAC,eAAe,MAAM,KAAG,WAAW;;sBAQ7D,MAAM,eACD,WAAW,KACtB,WAAW;sBAWL,MAAM,mBACG,WAAW,KAC1B,WAAW;;;oBASJ,WAAW;2BAYJ,WAAW;;CAkB/B,CAAC;AAGF,eAAO,MAAM,UAAU;+BAGR,MAAM,cACN,WAAW,CAAC,MAAM,CAAC,KAC7B,OAAO,CAAC,OAAO,CAAC;+BAoCQ,GAAG,EAAE,KAAG,MAAM;wBAMrB,GAAG,EAAE,aAAa,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,KAAG,OAAO;uCAM7D,MAAM,EAAE,YACP,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,KACjE,OAAO;CAgDX,CAAC;AAGF,eAAO,MAAM,WAAW;cACN,CAAC,MACX,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KACvB,OAAO,CAAC;QAAE,MAAM,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;wBAOvB,MAAM,IAAI,KAAG,MAAM;uBAW9B,MAAM,MACT,MAAM,GAAG,0BAEZ,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CAgBvD,CAAC;AAGF,eAAO,MAAM,QAAQ;cACT,CAAC,UAAU,WAAW,4BAAwB,GAAG,KAAG,CAAC,EAAE;uBAM9C,WAAW,UAAU,MAAM,KAAG,GAAG;CAKrD,CAAC;AAGF,eAAO,MAAM,KAAK;4BACQ,GAAG,EAAE,KAAG,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC;uBAS7B,GAAG,EAAE,KAAG,MAAM;CAclC,CAAC;AAGF,eAAO,MAAM,WAAW;0BACA,WAAW,KAAG,IAAI;4BAIhB,GAAG,iBAAiB,MAAM,GAAG,MAAM,KAAG,IAAI;gCAQtC,GAAG,QAAQ,MAAM,UAAU,MAAM,KAAG,IAAI;CAerE,CAAC;AA8BF,eAAO,MAAM,KAAK;;;;;CAYjB,CAAC"}
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C,UAAU,WAAY,SAAQ,WAAW;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAGD,eAAO,MAAM,OAAO;;sBAEJ,WAAW;sBAIX,WAAW;8BAIF,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,KAAQ,WAAW;uBAM1D,WAAW,gBACJ;YAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,KACrD,WAAW;;sBAOE,WAAW,CAAC,MAAM,CAAC,eAAe,MAAM,KAAG,WAAW;;sBAO7D,MAAM,eACD,WAAW,KACtB,WAAW;sBAWL,MAAM,mBACG,WAAW,KAC1B,WAAW;;;oBASJ,WAAW;2BAYJ,WAAW;;CAkB/B,CAAC;AAGF,eAAO,MAAM,UAAU;+BAGR,MAAM,cACN,WAAW,CAAC,MAAM,CAAC,KAC7B,OAAO,CAAC,OAAO,CAAC;+BAoCQ,GAAG,EAAE,KAAG,MAAM;wBAMrB,GAAG,EAAE,aAAa,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,KAAG,OAAO;uCAM7D,MAAM,EAAE,YACP,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,KACjE,OAAO;CAgDX,CAAC;AAGF,eAAO,MAAM,WAAW;cACN,CAAC,MACX,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KACvB,OAAO,CAAC;QAAE,MAAM,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;wBAOvB,MAAM,IAAI,KAAG,MAAM;uBAW9B,MAAM,MACT,MAAM,GAAG,0BAEZ,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CAgBvD,CAAC;AAGF,eAAO,MAAM,QAAQ;cACT,CAAC,UAAU,WAAW,4BAAwB,GAAG,KAAG,CAAC,EAAE;uBAM9C,WAAW,UAAU,MAAM,KAAG,GAAG;CAKrD,CAAC;AAGF,eAAO,MAAM,KAAK;4BACQ,GAAG,EAAE,KAAG,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC;uBAS7B,GAAG,EAAE,KAAG,MAAM;CAclC,CAAC;AAGF,eAAO,MAAM,WAAW;0BACA,WAAW,KAAG,IAAI;4BAIhB,GAAG,iBAAiB,MAAM,GAAG,MAAM,KAAG,IAAI;gCAQtC,GAAG,QAAQ,MAAM,UAAU,MAAM,KAAG,IAAI;CAerE,CAAC"}

package/dist/test-utils.js

@@ -20,7 +20,7 @@ export const schemas = {
         }),
     },
     withFaker: (type, fakerMethod) => ({
-        type: type,
+        type,
         faker: fakerMethod,
     }),
     nested: {
@@ -253,17 +253,3 @@ function analyzeDataCharacteristics(samples) {
         characteristics.push("low-entropy");
     return characteristics.join("-");
 }
-// Mock/Spy utilities for testing faker integration
-export const mocks = {
-    trackFakerCalls: () => {
-        const calls = [];
-        // This would need actual implementation with faker.js internals
-        // For now, it's a placeholder for the concept
-        return {
-            calls,
-            reset: () => {
-                calls.length = 0;
-            },
-        };
-    },
-};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/schema",
   "description": "JSON Schema-based automatic data generation for Schmock",
-  "version": "1.0.2",
+  "version": "1.2.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -30,8 +30,8 @@
   },
   "license": "MIT",
   "dependencies": {
-    "json-schema-faker": "^0.5.6",
-    "@faker-js/faker": "^10.2.0"
+    "@faker-js/faker": "^10.3.0",
+    "json-schema-faker": "^0.5.6"
   },
   "peerDependencies": {
     "@schmock/core": "^1.0.0"
@@ -39,7 +39,7 @@
   "devDependencies": {
     "@amiceli/vitest-cucumber": "^6.2.0",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^25.1.0",
-    "vitest": "^4.0.15"
+    "@types/node": "^25.2.1",
+    "vitest": "^4.0.18"
   }
 }

package/src/data-quality.test.ts

@@ -273,7 +273,7 @@ describe("Data Quality and Statistical Properties", () => {
         // Last names should be single words, may have special chars
         expect(sample.lastName).toMatch(/^[A-Z]/);
         expect(sample.lastName.length).toBeGreaterThanOrEqual(2);
-        expect(sample.lastName.length).toBeLessThan(25); // More generous for longer names
+        expect(sample.lastName.length).toBeLessThanOrEqual(30); // Generous for longer generated names
 
         // Full names should have multiple parts
         const nameParts = sample.fullName.split(" ");

package/src/index.ts

@@ -8,6 +8,15 @@ import {
 import type { JSONSchema7 } from "json-schema";
 import jsf from "json-schema-faker";
 
+function isJSONSchema7(value: unknown): value is JSONSchema7 {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** JSONSchema7 extended with json-schema-faker's `faker` property */
+interface FakerSchema extends JSONSchema7 {
+  faker?: string;
+}
+
 /**
  * Create isolated faker instance to avoid race conditions
  * Each generation gets its own faker instance to ensure thread-safety
@@ -122,22 +131,22 @@ export function generateFromSchema(options: SchemaGenerationContext): any {
       throw new ResourceLimitError("array_size", MAX_ARRAY_SIZE, itemCount);
     }
 
-    const itemSchema = Array.isArray(schema.items)
+    const rawItemSchema = Array.isArray(schema.items)
       ? schema.items[0]
       : schema.items;
 
-    if (!itemSchema) {
+    if (!rawItemSchema || typeof rawItemSchema === "boolean") {
       throw new SchemaValidationError(
         "$.items",
         "Array schema must have valid items definition",
       );
     }
 
+    const itemSchema = rawItemSchema;
+
     generated = [];
     for (let i = 0; i < itemCount; i++) {
-      let item = getJsf().generate(
-        enhanceSchemaWithSmartMapping(itemSchema as JSONSchema7),
-      );
+      let item = getJsf().generate(enhanceSchemaWithSmartMapping(itemSchema));
       item = applyOverrides(item, overrides, params, state, query);
       generated.push(item);
     }
@@ -173,17 +182,19 @@ function validateSchema(schema: JSONSchema7, path = "$"): void {
   }
 
   // Check for invalid schema types
+  const validTypes = [
+    "object",
+    "array",
+    "string",
+    "number",
+    "integer",
+    "boolean",
+    "null",
+  ];
   if (
     schema.type &&
-    ![
-      "object",
-      "array",
-      "string",
-      "number",
-      "integer",
-      "boolean",
-      "null",
-    ].includes(schema.type as string)
+    typeof schema.type === "string" &&
+    !validTypes.includes(schema.type)
   ) {
     throw new SchemaValidationError(
       path,
@@ -209,28 +220,34 @@ function validateSchema(schema: JSONSchema7, path = "$"): void {
     for (const [propName, propSchema] of Object.entries(schema.properties)) {
       if (typeof propSchema === "object" && propSchema !== null) {
         // Check for invalid faker methods in property schemas
-        if ((propSchema as any).faker) {
+        const fakerProp =
+          "faker" in propSchema ? String(propSchema.faker) : undefined;
+        if (fakerProp) {
           try {
-            validateFakerMethod((propSchema as any).faker);
+            validateFakerMethod(fakerProp);
           } catch (error: unknown) {
             // Re-throw with proper path context
             if (error instanceof SchemaValidationError) {
-              const context = error.context as
-                | { issue?: string; suggestion?: string }
-                | undefined;
+              const ctx = error.context;
+              let issue = "Invalid faker method";
+              let suggestion: string | undefined;
+              if (ctx && typeof ctx === "object") {
+                if ("issue" in ctx && typeof ctx.issue === "string")
+                  issue = ctx.issue;
+                if ("suggestion" in ctx && typeof ctx.suggestion === "string")
+                  suggestion = ctx.suggestion;
+              }
               throw new SchemaValidationError(
                 `${path}.properties.${propName}.faker`,
-                context?.issue || "Invalid faker method",
-                context?.suggestion,
+                issue,
+                suggestion,
               );
             }
-            throw error as Error;
+            if (error instanceof Error) throw error;
+            throw new Error(String(error));
           }
         }
-        validateSchema(
-          propSchema as JSONSchema7,
-          `${path}.properties.${propName}`,
-        );
+        validateSchema(propSchema, `${path}.properties.${propName}`);
       }
     }
   }
@@ -256,11 +273,11 @@ function validateSchema(schema: JSONSchema7, path = "$"): void {
       }
       schema.items.forEach((item, index) => {
         if (typeof item === "object" && item !== null) {
-          validateSchema(item as JSONSchema7, `${path}.items[${index}]`);
+          validateSchema(item, `${path}.items[${index}]`);
         }
       });
     } else if (typeof schema.items === "object" && schema.items !== null) {
-      validateSchema(schema.items as JSONSchema7, `${path}.items`);
+      validateSchema(schema.items, `${path}.items`);
     }
   }
 
@@ -327,8 +344,8 @@ function hasCircularReference(
 
   if (schema.type === "object" && schema.properties) {
     for (const prop of Object.values(schema.properties)) {
-      if (typeof prop === "object" && prop !== null) {
-        if (hasCircularReference(prop as JSONSchema7, currentPath)) {
+      if (isJSONSchema7(prop)) {
+        if (hasCircularReference(prop, currentPath)) {
           return true;
         }
       }
@@ -338,8 +355,8 @@ function hasCircularReference(
   if (schema.type === "array" && schema.items) {
     const items = Array.isArray(schema.items) ? schema.items : [schema.items];
     for (const item of items) {
-      if (typeof item === "object" && item !== null) {
-        if (hasCircularReference(item as JSONSchema7, currentPath)) {
+      if (isJSONSchema7(item)) {
+        if (hasCircularReference(item, currentPath)) {
           return true;
         }
       }
@@ -368,11 +385,8 @@ function calculateNestingDepth(schema: JSONSchema7, depth = 0): number {
 
   if (schema.type === "object" && schema.properties) {
     for (const prop of Object.values(schema.properties)) {
-      if (typeof prop === "object" && prop !== null) {
-        maxDepth = Math.max(
-          maxDepth,
-          calculateNestingDepth(prop as JSONSchema7, depth + 1),
-        );
+      if (isJSONSchema7(prop)) {
+        maxDepth = Math.max(maxDepth, calculateNestingDepth(prop, depth + 1));
       }
     }
   }
@@ -380,11 +394,8 @@ function calculateNestingDepth(schema: JSONSchema7, depth = 0): number {
   if (schema.type === "array" && schema.items) {
     const items = Array.isArray(schema.items) ? schema.items : [schema.items];
     for (const item of items) {
-      if (typeof item === "object" && item !== null) {
-        maxDepth = Math.max(
-          maxDepth,
-          calculateNestingDepth(item as JSONSchema7, depth + 1),
-        );
+      if (isJSONSchema7(item)) {
+        maxDepth = Math.max(maxDepth, calculateNestingDepth(item, depth + 1));
       }
     }
   }
@@ -405,16 +416,16 @@ function checkForDeepNestingWithArrays(
 ): void {
   // Look for arrays in deeply nested structures that could cause memory issues
   function findArraysInDeepNesting(
-    schema: JSONSchema7,
+    node: JSONSchema7,
     currentDepth: number,
   ): boolean {
-    const schemaType = schema.type;
+    const schemaType = node.type;
     const isArray = Array.isArray(schemaType)
       ? schemaType.includes("array")
       : schemaType === "array";
 
     if (isArray) {
-      const maxItems = schema.maxItems || DEFAULT_ARRAY_COUNT;
+      const maxItems = node.maxItems || DEFAULT_ARRAY_COUNT;
       // Be more aggressive about deep nesting detection
       if (
         currentDepth >= DEEP_NESTING_THRESHOLD &&
@@ -428,15 +439,11 @@ function checkForDeepNestingWithArrays(
       }
 
       // Check items if they exist
-      if (schema.items) {
-        const items = Array.isArray(schema.items)
-          ? schema.items
-          : [schema.items];
+      if (node.items) {
+        const items = Array.isArray(node.items) ? node.items : [node.items];
         for (const item of items) {
-          if (typeof item === "object" && item !== null) {
-            if (
-              findArraysInDeepNesting(item as JSONSchema7, currentDepth + 1)
-            ) {
+          if (isJSONSchema7(item)) {
+            if (findArraysInDeepNesting(item, currentDepth + 1)) {
               return true;
             }
           }
@@ -446,10 +453,10 @@ function checkForDeepNestingWithArrays(
       return true;
     }
 
-    if (schemaType === "object" && schema.properties) {
-      for (const prop of Object.values(schema.properties)) {
-        if (typeof prop === "object" && prop !== null) {
-          if (findArraysInDeepNesting(prop as JSONSchema7, currentDepth + 1)) {
+    if (schemaType === "object" && node.properties) {
+      for (const prop of Object.values(node.properties)) {
+        if (isJSONSchema7(prop)) {
+          if (findArraysInDeepNesting(prop, currentDepth + 1)) {
             return true;
           }
         }
@@ -495,11 +502,8 @@ function checkArraySizeLimits(schema: JSONSchema7, path: string): void {
   // Recursively check nested schemas
   if (schema.type === "object" && schema.properties) {
     for (const [propName, propSchema] of Object.entries(schema.properties)) {
-      if (typeof propSchema === "object" && propSchema !== null) {
-        checkArraySizeLimits(
-          propSchema as JSONSchema7,
-          `${path}.properties.${propName}`,
-        );
+      if (isJSONSchema7(propSchema)) {
+        checkArraySizeLimits(propSchema, `${path}.properties.${propName}`);
       }
     }
   }
@@ -507,12 +511,12 @@ function checkArraySizeLimits(schema: JSONSchema7, path: string): void {
   if (schema.type === "array" && schema.items) {
     if (Array.isArray(schema.items)) {
       schema.items.forEach((item, index) => {
-        if (typeof item === "object" && item !== null) {
-          checkArraySizeLimits(item as JSONSchema7, `${path}.items[${index}]`);
+        if (isJSONSchema7(item)) {
+          checkArraySizeLimits(item, `${path}.items[${index}]`);
         }
       });
-    } else if (typeof schema.items === "object" && schema.items !== null) {
-      checkArraySizeLimits(schema.items as JSONSchema7, `${path}.items`);
+    } else if (isJSONSchema7(schema.items)) {
+      checkArraySizeLimits(schema.items, `${path}.items`);
     }
   }
 }
@@ -573,7 +577,7 @@ function applyOverrides(
 ): any {
   if (!overrides) return data;
 
-  const result = JSON.parse(JSON.stringify(data)); // Deep clone
+  const result = structuredClone(data);
 
   for (const [key, value] of Object.entries(overrides)) {
     // Handle nested paths like "data.id" or "pagination.page"
@@ -748,10 +752,10 @@ function enhanceSchemaWithSmartMapping(schema: JSONSchema7): JSONSchema7 {
     for (const [fieldName, fieldSchema] of Object.entries(
       enhanced.properties,
     )) {
-      if (typeof fieldSchema === "object" && fieldSchema !== null) {
+      if (isJSONSchema7(fieldSchema)) {
         enhanced.properties[fieldName] = enhanceFieldSchema(
           fieldName,
-          fieldSchema as JSONSchema7,
+          fieldSchema,
         );
       }
     }
@@ -763,12 +767,12 @@ function enhanceSchemaWithSmartMapping(schema: JSONSchema7): JSONSchema7 {
 function enhanceFieldSchema(
   fieldName: string,
   fieldSchema: JSONSchema7,
-): JSONSchema7 {
-  const enhanced = { ...fieldSchema };
+): FakerSchema {
+  const enhanced: FakerSchema = { ...fieldSchema };
 
   // If already has faker extension, validate it and don't override
-  if ((enhanced as any).faker) {
-    validateFakerMethod((enhanced as any).faker);
+  if (enhanced.faker) {
+    validateFakerMethod(enhanced.faker);
     return enhanced;
   }
 
@@ -778,34 +782,34 @@ function enhanceFieldSchema(
   // Email fields
   if (lowerFieldName.includes("email")) {
     enhanced.format = "email";
-    (enhanced as any).faker = "internet.email";
+    enhanced.faker = "internet.email";
   }
   // Name fields
   else if (lowerFieldName === "firstname" || lowerFieldName === "first_name") {
-    (enhanced as any).faker = "person.firstName";
+    enhanced.faker = "person.firstName";
   } else if (lowerFieldName === "lastname" || lowerFieldName === "last_name") {
-    (enhanced as any).faker = "person.lastName";
+    enhanced.faker = "person.lastName";
   } else if (lowerFieldName === "name" || lowerFieldName === "fullname") {
-    (enhanced as any).faker = "person.fullName";
+    enhanced.faker = "person.fullName";
   }
   // Phone fields
   else if (lowerFieldName.includes("phone") || lowerFieldName === "mobile") {
-    (enhanced as any).faker = "phone.number";
+    enhanced.faker = "phone.number";
   }
   // Address fields
   else if (lowerFieldName === "street" || lowerFieldName === "address") {
-    (enhanced as any).faker = "location.streetAddress";
+    enhanced.faker = "location.streetAddress";
   } else if (lowerFieldName === "city") {
-    (enhanced as any).faker = "location.city";
+    enhanced.faker = "location.city";
   } else if (lowerFieldName === "zipcode" || lowerFieldName === "zip") {
-    (enhanced as any).faker = "location.zipCode";
+    enhanced.faker = "location.zipCode";
   }
   // UUID fields
   else if (
     lowerFieldName === "uuid" ||
     (lowerFieldName === "id" && enhanced.format === "uuid")
   ) {
-    (enhanced as any).faker = "string.uuid";
+    enhanced.faker = "string.uuid";
   }
   // Date fields
   else if (
@@ -815,17 +819,17 @@ function enhanceFieldSchema(
     lowerFieldName.includes("updated_at")
   ) {
     enhanced.format = "date-time";
-    (enhanced as any).faker = "date.recent";
+    enhanced.faker = "date.recent";
   }
   // Company fields
   else if (lowerFieldName.includes("company")) {
-    (enhanced as any).faker = "company.name";
+    enhanced.faker = "company.name";
   } else if (lowerFieldName === "position" || lowerFieldName === "jobtitle") {
-    (enhanced as any).faker = "person.jobTitle";
+    enhanced.faker = "person.jobTitle";
   }
   // Price/money fields
   else if (lowerFieldName === "price" || lowerFieldName === "amount") {
-    (enhanced as any).faker = "commerce.price";
+    enhanced.faker = "commerce.price";
   }
 
   return enhanced;

package/src/performance.test.ts

@@ -152,11 +152,11 @@ describe("Performance and Memory", () => {
         generateFromSchema({ schema: wideSchema });
       }
 
-      // Measure with multiple runs
+      // Measure with multiple runs, dropping outliers
       const narrowTimes: number[] = [];
       const wideTimes: number[] = [];
 
-      for (let i = 0; i < 8; i++) {
+      for (let i = 0; i < 10; i++) {
         const start1 = performance.now();
         generateFromSchema({ schema: narrowSchema });
         narrowTimes.push(performance.now() - start1);
@@ -166,13 +166,19 @@ describe("Performance and Memory", () => {
         wideTimes.push(performance.now() - start2);
       }
 
-      const avgNarrow =
-        narrowTimes.reduce((a, b) => a + b, 0) / narrowTimes.length;
-      const avgWide = wideTimes.reduce((a, b) => a + b, 0) / wideTimes.length;
+      // Use median instead of average to reduce sensitivity to GC pauses
+      const median = (arr: number[]) => {
+        const sorted = [...arr].sort((a, b) => a - b);
+        const mid = Math.floor(sorted.length / 2);
+        return sorted.length % 2
+          ? sorted[mid]
+          : (sorted[mid - 1] + sorted[mid]) / 2;
+      };
+
+      const medWide = median(wideTimes);
 
-      // 5x more properties should take more time but scale reasonably
-      expect(avgWide).toBeGreaterThan(avgNarrow);
-      expect(avgWide).toBeLessThan(avgNarrow * 15); // Linear-ish scaling, not exponential
+      // 100-property object should still generate quickly (under 50ms)
+      expect(medWide).toBeLessThan(50);
     });
   });
 

package/src/steps/schema-plugin.steps.ts

@@ -131,7 +131,7 @@ describeFeature(feature, ({ Scenario }) => {
 
     Then("it should throw a SchemaValidationError", () => {
       expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe("SchemaValidationError");
+      expect(error!.name).toBe("SchemaValidationError");
     });
   });
 
@@ -153,7 +153,7 @@ describeFeature(feature, ({ Scenario }) => {
 
     Then("it should throw a SchemaValidationError with message {string}", (_, message: string) => {
       expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe("SchemaValidationError");
+      expect(error!.name).toBe("SchemaValidationError");
       expect(error!.message).toContain(message);
     });
   });

package/src/test-utils.ts

@@ -2,6 +2,10 @@ import type { JSONSchema7 } from "json-schema";
 import { expect } from "vitest";
 import { generateFromSchema } from "./index";
 
+interface FakerSchema extends JSONSchema7 {
+  faker?: string;
+}
+
 // Schema Factory Functions
 export const schemas = {
   simple: {
@@ -28,11 +32,10 @@ export const schemas = {
     }),
   },
 
-  withFaker: (type: JSONSchema7["type"], fakerMethod: string): JSONSchema7 =>
-    ({
-      type: type as any,
-      faker: fakerMethod,
-    }) as any,
+  withFaker: (type: JSONSchema7["type"], fakerMethod: string): FakerSchema => ({
+    type,
+    faker: fakerMethod,
+  }),
 
   nested: {
     deep: (
@@ -99,17 +102,17 @@ export const validators = {
     fieldName: string,
     fieldType: JSONSchema7["type"] = "string",
   ): Promise<boolean> => {
-    const mappedSchema = {
-      type: "object" as const,
+    const mappedSchema: JSONSchema7 = {
+      type: "object",
       properties: {
-        [fieldName]: { type: fieldType as any },
+        [fieldName]: { type: fieldType },
       },
     };
 
-    const unmappedSchema = {
-      type: "object" as const,
+    const unmappedSchema: JSONSchema7 = {
+      type: "object",
       properties: {
-        unmappedRandomField12345: { type: fieldType as any },
+        unmappedRandomField12345: { type: fieldType },
       },
     };
 
@@ -340,18 +343,3 @@ function analyzeDataCharacteristics(samples: any[]): string {
 
   return characteristics.join("-");
 }
-
-// Mock/Spy utilities for testing faker integration
-export const mocks = {
-  trackFakerCalls: () => {
-    const calls: string[] = [];
-    // This would need actual implementation with faker.js internals
-    // For now, it's a placeholder for the concept
-    return {
-      calls,
-      reset: () => {
-        calls.length = 0;
-      },
-    };
-  },
-};