> ## Documentation Index
> Fetch the complete documentation index at: https://e2e.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# वेब

> वेब इंजन को अपने ऐप की ओर पॉइंट करें या रनर से उसे शुरू करवाएँ, और एक सूट को कई व्यूपोर्ट साइज़ पर चलाएँ।

`@e2e-dev/web` आपके ऐप के URL पर ब्राउज़र में टेस्ट चलाता है। रूट, कुकी,
डायलॉग और डाउनलोड के लिए [ब्राउज़र के साथ काम करना](https://e2e.com/docs/hi/browser) देखें।

## अपना ऐप शुरू करना

टारगेट के `app` में अपने ऐप का URL सेट करें। `app.open('/path')` का पाथ इसी
URL के आधार पर तय होता है:

```ts title="Target fragment"
engine: web(),
app: { url: process.env.APP_URL ?? 'http://localhost:3000' },
```

बिना स्कीम वाला URL HTTPS इस्तेमाल करता है। लूपबैक होस्ट के लिए वह HTTP इस्तेमाल
करता है। सादा HTTP सिर्फ़ लूपबैक होस्ट पर काम करता है।

### रनर से इसे शुरू करवाएँ

`app.command` जोड़ें, तो रनर डेव सर्वर शुरू कर देता है। यह तब तक इंतज़ार करता है
जब तक `app.url` जवाब न दे। जो सर्वर इसने शुरू किया था, उसे यह रन खत्म होने,
विफल होने या बीच में रोके जाने पर बंद कर देता है:

```ts title="e2e.config.ts"

export default {
  targets: [{
    engine: web(),
    app: {
      url: process.env.APP_URL ?? 'http://localhost:3000',
      command: {
        executable: 'npm',
        args: ['run', 'dev'],
        reuseExisting: true,
        log: '.e2e/logs/app.log',
      },
    },
  }],
} satisfies E2EConfig;
```

```text
 ✓ target "web" command at http://localhost:3000/ ready 1.20s
```

कमांड बिना शेल के चलती है: `executable` को `PATH` से ढूँढा जाता है और `args`
जैसे लिखे हैं, वैसे ही पास होते हैं। चाइल्ड प्रोसेस को सिर्फ़ `PATH`, `HOME`,
temp-डायरेक्टरी वाले वेरिएबल, `inheritEnv` और `env` मिलते हैं।

| विकल्प | उद्देश्य |
| --- | --- |
| `reuseExisting: true` | पहले से चल रहा सर्वर इस्तेमाल करें, जैसे वह सर्वर जिसे किसी [MCP सेशन](https://e2e.com/docs/hi/mcp-server#run-tests-next-to-a-session) ने शुरू किया। CI में e2e इसे अनदेखा करता है, और पहले से जवाब दे रहे सर्वर पर `APP_ALREADY_RUNNING` मिलता है। |
| `log` | ऐप का stdout और stderr प्रोजेक्ट के सापेक्ष पाथ वाली किसी फ़ाइल में सेव करें। स्टार्टअप एरर पर, या `e2e run` के दौरान ऐप के अचानक बंद होने पर, संदेश में वे लाइनें उद्धृत होती हैं जो कमांड शुरू होने के बाद किसी भी प्रोसेस ने फ़ाइल में जोड़ीं। 8 KiB के अंदर 40 लाइनों तक का लॉग पूरा उद्धृत होता है। नहीं तो उद्धरण में हर सिरे से 20 लाइनें तक रहती हैं, जिनके बीच `[startup output omitted]` होता है, और 8 KiB से बड़े लॉग के लिए ये लाइनें उसके पहले और आखिरी 4 KiB से आती हैं। कम से कम चार अक्षरों वाले `command.env` और `inheritEnv` मान उद्धरण में छिपा दिए जाते हैं। फ़ाइल में खुद कुछ नहीं छिपाया जाता। |
| `env` | ऐप के लिए एनवायरनमेंट वेरिएबल। |
| `inheritEnv` | होस्ट के वे वेरिएबल जो सेट होने पर आगे पास किए जाते हैं, नाम या प्रीफ़िक्स से: `['DATABASE_URL', 'STRIPE_*']`। `env` को इनसे ऊपर प्राथमिकता मिलती है। |
| `startupTimeout` | ऐप के जवाब का कितनी देर इंतज़ार करना है। डिफ़ॉल्ट 60 सेकंड। |
| `readyUrl` | `app.url` की जगह किसी हेल्थ एंडपॉइंट को जाँचने के लिए। इसे `command` के अंदर नहीं, उसके बगल में सेट करें। |

सभी विकल्पों के लिए [command रेफ़रेंस](https://e2e.com/docs/hi/reference/config#command) देखें।

<Note>
रनर सिर्फ़ `app.command` शुरू करता है। डेटाबेस, मॉक और दूसरी सेवाएँ रन से पहले
शुरू करें, या `app.command` को ऐसी स्क्रिप्ट बनाएँ जो उन्हें शुरू करे और ऐप को
सर्व करे। सेवाओं का API बाद की किसी रिलीज़ में वापस आएगा।
</Note>

### रनर से पोर्ट चुनवाएँ

पोर्ट के टकराव के बिना एक ही रिपॉज़िटरी की कई वर्किंग कॉपी चलाने के लिए पोर्ट `0` इस्तेमाल करें। रनर एक
खाली पोर्ट चुनता है और कमांड के `args` और `env` में `{port}` की जगह वह पोर्ट लिख
देता है:

```ts title="Target fragment"
engine: web(),
app: {
  url: 'http://127.0.0.1:0',
  command: { executable: 'pnpm', args: ['dev', '--port', '{port}'], env: { PORT: '{port}' } },
},
```

- `127.0.0.1` या `[::1]` लिखें, यानी वह पता जिस पर कमांड बाइंड करती है।
  `localhost:0` अस्वीकार किया जाता है।
- टेस्ट असली पोर्ट वाला URL `app.baseUrl` से पढ़ते हैं।
- पोर्ट बदलने पर भी कैश एंट्री मान्य रहती हैं।
- `reuseExisting` पोर्ट `0` के साथ काम नहीं करता।

[फ़्री पोर्ट](https://e2e.com/docs/hi/reference/config#free-ports) देखें।

<Accordion title="Next.js डेव सर्वर रेंडर करता है, लेकिन कभी हाइड्रेट नहीं होता">
Next.js 16 अपने डेव रिसोर्स के लिए क्रॉस-ऑरिजिन अनुरोध ब्लॉक करता है। जब टारगेट
`127.0.0.1` या `[::1]` खोलता है, तब भी `next dev` खुद को `localhost` के रूप में
पहचानता है। पेज रेंडर होता है, लोकेटर अपना एलिमेंट ढूँढ लेते हैं और क्लिक भी पहुँचते हैं,
लेकिन कोई React हैंडलर नहीं चलता।

टारगेट जो होस्ट खोलता है, उसे `allowedDevOrigins` में जोड़ें। जब `app.url`
`http://[::1]:0` खोलता है, तो `'[::1]'` इस्तेमाल करें:

```ts title="next.config.ts"

const nextConfig: NextConfig = {
  allowedDevOrigins: ['127.0.0.1'],
};

export default nextConfig;
```

`localhost` टारगेट और प्रोडक्शन `next start` टारगेट को किसी एंट्री की ज़रूरत नहीं होती।
</Accordion>

## सुरक्षित प्रीव्यू

सुरक्षित प्रीव्यू खोलने या किसी टनल का चेतावनी पेज छोड़ने के लिए `headers`
इस्तेमाल करें। उदाहरण के लिए, Vercel प्रीव्यू एक प्रोटेक्शन बायपास हेडर लेता है:

```ts title="Target fragment"
engine: web({
  headers: {
    'x-vercel-protection-bypass': process.env.VERCEL_AUTOMATION_BYPASS_SECRET ?? '',
  },
}),
app: {
  url: process.env.PREVIEW_URL ?? 'http://localhost:3000',
  identity: 'storefront',
},
```

ब्राउज़र `headers` सिर्फ़ उन अनुरोधों में जोड़ता है जो `app.url` के ऑरिजिन से
शुरू होते हैं, यानी उसकी स्कीम, होस्ट और पोर्ट से। कोई अनुरोध अपने रीडायरेक्ट के
दौरान भी इन्हें साथ रखता है, चाहे रीडायरेक्ट किसी भी ऑरिजिन पर जाए। किसी दूसरे
ऑरिजिन के लिए इन्हें जोड़ने के लिए, जैसे उसी गेट के पीछे का कोई API होस्ट, उस
ऑरिजिन को `credentialOrigins` में लिखें।
[अनुरोध क्रेडेंशियल](https://e2e.com/docs/hi/reference/security#request-credentials) देखें। ngrok के लिए
`'ngrok-skip-browser-warning': '1'` इस्तेमाल करें।
प्रीव्यू URL बदलने पर भी `app.identity` कैश की पहचान स्थिर रखता है।

<Note>
`headers` सेट करने से ब्राउज़र का HTTP कैश बंद हो जाता है और सर्विस वर्कर
ब्लॉक हो जाते हैं।
</Note>

HTTP basic ऑथेंटिकेशन के लिए `basicAuth` इस्तेमाल करें। ब्राउज़र `app.url` के
ऑरिजिन से, और `credentialOrigins` के हर ऑरिजिन से आए `401` ऑथेंटिकेशन चैलेंज का जवाब
देता है। अगर इनमें से कोई ऑरिजिन डिफ़ॉल्ट पोर्ट पर है, जैसे बिना पोर्ट वाला
`https://` URL, या उसका होस्ट IPv6 है, तो WebKit किसी भी ऑरिजिन को जवाब देता है।
पासवर्ड को `secrets` के अंदर घोषित करें और `secrets.get(name)` पास करें:

```ts title="e2e.config.ts"

export default {
  targets: [
    {
      engine: web({
        basicAuth: { username: 'preview', password: secrets.get('previewPassword') },
      }),
      app: { url: 'https://staging.example.com' },
    },
  ],
  secrets: { previewPassword: () => process.env.PREVIEW_PASSWORD ?? '' },
} satisfies E2EConfig;
```

हर प्रयास शुरू होने पर इंजन सीक्रेट का मान निकालता है, और रनर उस मान को रिपोर्ट,
लॉग और एजेंट को पढ़ने के लिए दी जाने वाली सामग्री से बाहर रखता है। अघोषित नाम
होने पर कॉन्फ़िग
लोड `INVALID_CONFIG` के साथ विफल होता है। सादी स्ट्रिंग वाला पासवर्ड भी काम करता
है, लेकिन e2e सिर्फ़ `secrets.get` वाले पासवर्ड को छिपाता है।

## व्यूपोर्ट

किसी सूट को एक साइज़ पर चलाने के लिए टारगेट पर व्यूपोर्ट सेट करें, या टेस्ट के
दौरान `browser.setViewport()` कॉल करें। एजेंट अपने
[`resize_viewport`](https://e2e.com/docs/hi/reference/agent#action-tools) टूल से साइज़ बदलता है।

### हर टारगेट के लिए एक साइज़

`viewport` हर प्रयास का शुरुआती साइज़ पिक्सल में तय करता है। डिफ़ॉल्ट 1280 x 720
है। हर साइज़ के लिए एक टारगेट जोड़ें:

```ts title="e2e.config.ts"

const app = { url: 'http://localhost:3000' };

export default {
  targets: [
    { name: 'desktop', engine: web(), app },
    { name: 'tablet', engine: web({ viewport: { width: 820, height: 1180 } }), app },
    { name: 'phone', engine: web({ browser: 'webkit', viewport: { width: 390, height: 844 } }), app },
  ],
} satisfies E2EConfig;
```

हर टेस्ट हर टारगेट पर चलता है, और हर टारगेट नाम का नतीजा अलग आता है। हर रीट्राई
टारगेट के साइज़ से शुरू होता है।

- एक साइज़ `npx e2e run --target phone` से चलाएँ। टेस्ट-टारगेट जोड़ियों की सूची
  `npx e2e list` से देखें।
- जो टारगेट एक ही `app.command` घोषित करते हैं, वे एक ही डेव सर्वर साझा करते हैं।
- डिवाइस टारगेट भी इसी सूची में रह सकता है।
  [मोबाइल इंजन रेफ़रेंस](https://e2e.com/docs/hi/reference/mobile) देखें।

### विंडो भरें

`viewport: null` कोई साइज़ तय नहीं करता, इसलिए पेज ब्राउज़र विंडो को भर देता है,
और एजेंट, स्क्रीनशॉट और वीडियो वही साइज़ इस्तेमाल करते हैं। इसे हेडेड रन में
इस्तेमाल करें, या ऐसे होस्टेड ब्राउज़र के साथ जिसके लाइव व्यू में वरना 1280 x 720 का
पेज एक कोने में दिखता:

```ts title="Target fragment"
{ name: 'window', engine: web({ viewport: null }), app }
```

लोकल हेडेड लॉन्च एक छोटी विंडो खोलता है। होस्टेड ब्राउज़र वही विंडो साइज़
इस्तेमाल करता है जो आपने सेवा से माँगा था। `browser.setViewport` तब भी काम
करता है।

### टेस्ट के अंदर साइज़ बदलें

`browser.setViewport` प्रयास के बाकी हिस्से के लिए पेज का साइज़ बदल देता है,
`app.restart()` और `app.clearState()` के बाद भी। इसे तब इस्तेमाल करें जब एक
टेस्ट साइज़ बदलने से पहले और बाद का लेआउट जाँचता हो:

```ts

test('the menu collapses on a narrow screen', async ({ app, screen, browser }) => {
  await app.open('/');
  await expect(screen.getByRole('navigation')).toBeVisible();

  await browser.setViewport({ width: 390, height: 844 });
  await expect(screen.getByRole('button', 'Menu')).toBeVisible();
  await expect(screen.getByRole('navigation')).toBeHidden();
});
```

पहला पेज उसी साइज़ पर लोड करने के लिए इसे `app.open` से पहले कॉल करें। तब पहले
कोई डेस्कटॉप रेंडर नहीं होता।

### एजेंट क्या देखता है

एजेंट को हर ऑब्ज़र्वेशन के साथ मौजूदा व्यूपोर्ट साइज़ मिलता है, इसलिए
`agent.act` से पहले साइज़ बदलें। स्क्रीनशॉट व्यूपोर्ट को कवर करते हैं। स्क्रीन से
बाहर के एलिमेंट फिर भी ट्री में हो सकते हैं, टैप उन्हें स्क्रोल करके सामने ले आता
है, और एजेंट स्क्रोल करके लेज़ी-लोडेड कंटेंट लोड कर सकता है।

लिंक, ज़ोर दिए गए टेक्स्ट या कोड वाला वाक्य एजेंट तक पूरा पहुँचता है,
और लिंक एक कंट्रोल के रूप में भी सूची में आता है। एजेंट टेक्स्ट के हर ब्लॉक के
पहले 512 अक्षर पढ़ता है। इससे लंबे ब्लॉक में e2e उसके लिंक और ज़ोर दिए गए
टेक्स्ट को अलग से भी सूची में रखता है।

अगर कोई कंपोनेंट लाइब्रेरी किसी चेकबॉक्स या रेडियो का साइज़ उसके अपने लेबल के
नीचे शून्य कर देती है, जैसा Element Plus करता है, तब भी एजेंट उसे देखता है।
एजेंट यह भी देखता है कि वह चेक है या नहीं। उस पर टैप करने से लेबल पर क्लिक होता है। जब वह लेबल खुद
कोई लिंक या दूसरा कंट्रोल हो, या उसके अंदर ऐसा कंट्रोल हो, तो एजेंट लेबल का
टेक्स्ट और वह कंट्रोल देखता है, चेकबॉक्स नहीं, क्योंकि लेबल पर क्लिक लिंक पर जा
सकता है। लोकेटर फिर भी उस कंट्रोल को छिपा हुआ (hidden) मानते हैं, जैसा Playwright करता है, इसलिए उसे `toBeVisible()` से नहीं,
`toBeChecked()` से जाँचें।

### टेस्ट को एक साइज़ तक सीमित करना

`platforms` और `requires` व्यूपोर्ट नहीं चुन सकते, क्योंकि हर ब्राउज़र टारगेट का
प्लेटफ़ॉर्म `web` होता है। कुछ साइज़ पर टेस्ट छोड़ने के लिए टेस्ट में चौड़ाई पढ़ें:

```ts
test('the sidebar stays open', async ({ app, screen, browser }) => {
  await app.open('/');
  test.skip((await browser.evaluate(() => window.innerWidth)) < 768, 'desktop layout only');
  await expect(screen.getByRole('complementary')).toBeVisible();
});
```

किसी खास साइज़ वाले टेस्ट के समूह को अलग रखने के लिए उन्हें उनका अपना कॉन्फ़िग
दें और उसे `--config` से चलाएँ।

### सीमाएँ

पतला व्यूपोर्ट सिर्फ़ रिस्पॉन्सिव लेआउट टेस्ट करता है। ब्राउज़र तब भी डेस्कटॉप
ब्राउज़र ही रहता है: स्केल फ़ैक्टर 1, डेस्कटॉप पॉइंटर, और उसका सामान्य यूज़र
एजेंट। यह टच को इम्युलेट नहीं करता। सिम्युलेटर या एम्युलेटर पर टेस्ट करने के लिए
[मोबाइल इंजन](https://e2e.com/docs/hi/mobile) इस्तेमाल करें। डार्क मोड और कम मोशन (reduced motion) के लिए
[डार्क मोड और कम मोशन को इम्युलेट करें](https://e2e.com/docs/hi/browser#emulate-dark-mode-and-reduced-motion) देखें।

वीडियो वही साइज़ रखता है जो रिकॉर्डिंग शुरू होने के समय पेज का था। एक तय साइज़
के लिए `web({ screencast: { size } })` सेट करें। जो ब्राउज़र प्रोवाइडर खुद रिकॉर्ड
करता है, जैसे [Kernel](https://e2e.com/docs/hi/integrations/kernel#recordings), वह इसकी जगह पूरी
स्क्रीन रिकॉर्ड करता है।

## ब्राउज़र इजाज़तें देना

हेडलेस Chromium वह इजाज़त नहीं देता जो टारगेट ग्रांट नहीं करता, इसलिए क्लिक के
बाद भी `navigator.clipboard.writeText` विफल होता है। ऐप को क्लिपबोर्ड इस्तेमाल
करने देने के लिए टारगेट पर उसकी इजाज़त दें:

```ts
{
  engine: web(),
  app: {
    url: 'http://localhost:3000',
    permissions: { 'clipboard-read': 'grant', 'clipboard-write': 'grant' },
  },
}
```

- हर प्रयास के हर पेज पर, किसी भी ऑरिजिन पर, यह इजाज़त रहती है।
- वेब टारगेट सिर्फ़ `'grant'` लेता है। `'deny'` और `'reset'` पर `INVALID_CONFIG`
  मिलता है: इसकी जगह उस इजाज़त को कॉन्फ़िग में शामिल न करें।
- नाम Playwright के हैं, और हर ब्राउज़र अपनी इजाज़तों का अलग सेट देता है।
  [`permissions`](https://e2e.com/docs/hi/reference/config#permissions) देखें।

## आगे

<CardGroup cols={2}>
  <Card title="ब्राउज़र के साथ काम करना" icon="globe" href="/browser">
    रूट मॉक करें, कुकी सेट करें, डायलॉग संभालें और फ़ाइलें डाउनलोड करें।
  </Card>
  <Card title="वेब इंजन रेफ़रेंस" icon="masks-theater" href="/reference/web">
    हर `web()` विकल्प और हर `browser` मेथड।
  </Card>
</CardGroup>
