> ## 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.

# कैशिंग

> जाँचे जा चुके एजेंट एक्शन को बिना मॉडल कॉल के रीप्ले करें, और ऐप बदलने पर एजेंट को काम संभालने दें।

रीप्ले कैश किसी `agent.act()` चरण के एक्शन तब रिकॉर्ड करता है जब बाद की कोई जाँच
उसके नतीजे की पुष्टि कर देती है। अगले रन में रनर उन एक्शन को बिना मॉडल कॉल के
रीप्ले करता है। अगर कोई कंट्रोल अब मेल नहीं खाता या अपेक्षित आख़िरी स्थिति अब
मेल नहीं खाती, तो एजेंट मौजूदा स्क्रीन से काम संभाल लेता है।
[सेल्फ़-हीलिंग टेस्ट](https://e2e.com/docs/hi/self-healing) देखें।

`agent.assert`, `agent.waitFor` और `agent.extract` हमेशा लाइव चलते हैं। रन का
सारांश नतीजों की गिनती दिखाता है:

```text
           AI  4.1k tokens · 2 model calls · openai/gpt-6-luna-fast
        Cache  4 replayed · 1 handed off · 1 missed · 1 not saved
```

`not saved` पास हुए और फ़्लेकी टेस्ट के उन चरणों को गिनता है जिनका
[`step.cache.write`](#when-a-recording-is-written) पास हुए प्रयास में
`unconfirmed`, `no-change` या `not-written` था।

## रिकॉर्डिंग कब लिखी जाती है

टेस्ट को उसके नतीजे की जाँच से खत्म करें। `read-write` मोड में, जब बाद का कोई
वेरिफ़िकेशन चरण पास हुआ हो, तो रनर प्रयास के अंत में हर `act` की रिकॉर्डिंग सेव
करता है। आख़िर में की गई एक जाँच अपने से पहले के हर `act` की पुष्टि करती है।

```ts title="tests/cart.e2e.ts"

test('adds an item', async ({ app, agent, screen }) => {
  await app.open('/cart');

  await agent.act('add one item to the cart');

  await expect(screen.getByRole('status')).toHaveText('1 item');
});
```

| वेरिफ़िकेशन माना जाता है | वेरिफ़िकेशन नहीं माना जाता |
| --- | --- |
| `expect(locator).toHaveText(...)` और दूसरे लोकेटर मैचर | सादी वैल्यू पर `expect(value).toBe(...)` |
| `expect(browser).toHaveURL(...)` और दूसरे इंजन असर्शन | `expect.poll(...)` |
| `locator.waitFor()`, `browser.waitForURL()` | `locator.textContent()` और दूसरे रीड |
| `agent.assert(...)`, `agent.waitFor(...)` | `agent.extract(...)`, कोई दूसरा `act`, प्रयास का पास होना |

`step.cache.write` सिर्फ़ रिपोर्ट में होता है। यह बताता है कि प्रयास खत्म होने पर
रिकॉर्डिंग का क्या हुआ:

| `step.cache.write` | मतलब |
| --- | --- |
| `saved` | अगले रन के लिए रिकॉर्ड की गई। |
| `kept` | एंट्री जैसी थी, वैसी ही रहती है। |
| `unconfirmed` | सेव नहीं हुई: चरण के बाद कोई जाँच पास नहीं हुई। टेस्ट को लोकेटर या इंजन असर्शन या `agent.assert` से खत्म करें, या `locator.waitFor()` या `agent.waitFor` से उस स्थिति का इंतज़ार करें। |
| `evicted` | एंट्री डिलीट कर दी गई: उसका रीप्ले किसी विफलता या रिपेयर पर खत्म हुआ, या प्रयास फ़ेल होने से पहले किसी जाँच ने उसकी पुष्टि नहीं की। |
| `no-change` | कुछ रिकॉर्ड नहीं हुआ: न कोई कंट्रोल दिखा, न गायब हुआ, न उसकी स्थिति बदली, और रूट वही रहा। इसमें वह चरण भी शामिल है जिसका अकेला बदलाव [किसी दूसरी साइट के फ़्रेम](https://e2e.com/docs/hi/browser#reach-into-an-iframe) के अंदर है। ऐसा चरण हर रन में लाइव चलता है। |
| `not-written` | सेव नहीं हुई: स्टोर ने लिखने का अनुरोध अस्वीकार किया, या रिकॉर्डिंग लेने से मना किया, जैसे फ़ाइल स्टोर की साइज़ सीमा से बड़ी रिकॉर्डिंग। |

जिस चरण ने कोई एक्शन नहीं किया, वह कुछ रिकॉर्ड नहीं करता और कोई `write` रिपोर्ट
नहीं करता।

फ़ेल होने वाला प्रयास भी विफलता से पहले जाँचे गए चरण सेव करता है। वह बिना जाँची
एंट्री और विफलता में शामिल रीप्ले डिलीट करता है। जब आप किसी फ़ेल होते असर्शन को
ठीक कर रहे हों, तब सेटअप वाले लक्ष्यों की रिकॉर्डिंग बनाए रखने के लिए सेटअप को
उसकी स्थिति के इंतज़ार पर खत्म करें, जैसे `locator.waitFor()`। इसके लिए कस्टम
स्टोर में `delete` मेथड होना चाहिए। रन रद्द करने पर कैश नहीं बदलता।

<Accordion title="ऐसी विफलताएँ जिनमें किसी मॉडल ने जवाब नहीं दिया">
जिस प्रयास की सारी विफलताएँ ऐसी हों जिनमें किसी मॉडल ने जवाब नहीं दिया, वह कोई
एंट्री नहीं हटाता, क्योंकि इनसे ऐप के बारे में कुछ पता नहीं चलता:

- `MODEL_UNAVAILABLE`: कोई मॉडल कॉन्फ़िगर नहीं है, या GitHub Copilot उस खाते को
  यह मॉडल नहीं देता।
- `MODEL_PROVIDER_FAILED`: प्रोवाइडर ने एरर लौटाया, जैसे गायब या अस्वीकार की गई
  कुंजी, रेट लिमिट, या 5xx, या किसी अनुरोध को 120 सेकंड के अंदर जवाब नहीं मिला।

इसलिए मॉडल तक पहुँच के बिना `read-write` रन अपनी रिकॉर्डिंग रखता है। इसमें वह
चरण भी शामिल है जो किसी ऐसे `agent.assert` से पहले रीप्ले हुआ जो अपने मॉडल तक
नहीं पहुँच सका।

ये फ़्लो की विफलता मानी जाती हैं: मॉडल का ऐसा जवाब जिसे इस्तेमाल नहीं किया जा
सकता (`MODEL_OUTPUT_INVALID`, `CONTEXT_OVERFLOW`), इनकार (`MODEL_REFUSED`),
`STEP_TIMEOUT` (तब भी जब कोई अनुरोध अभी खुला हो), और उसी प्रयास की कोई भी दूसरी
विफलता, जैसे `afterEach` का कोई असर्शन।
</Accordion>

## क्या मेल खाना चाहिए

कैश एंट्री एक टेस्ट, टारगेट, निर्देश, पैरामीटर के एक सेट और एजेंट की होती है।
इनमें से हर बदलाव से कैश मिस होता है:

- टेस्ट, उसके `describe` ग्रुप या टारगेट का नाम बदलना, या टेस्ट फ़ाइल को कहीं और
  ले जाना,
- निर्देश या कोई सामान्य पैरामीटर बदलना,
- किसी दूसरे कॉन्फ़िगर किए गए एजेंट के साथ चलाना (`agent: ['buyer', 'admin']`
  हर एजेंट के लिए एक एंट्री रिकॉर्ड करता है), या एजेंट का `context` या टेस्ट का
  `agentContext` बदलना (अगर उसमें कोई सीक्रेट है, तो कैश कुंजी में सिर्फ़ उसका
  नाम जाता है),
- किसी दूसरे इंजन पर जाना, या प्रोजेक्ट id या ऐप की पहचान बदलना।

मॉडल बदलने या इंजन अपग्रेड करने से कैश मिस नहीं होता। अगर नया वर्ज़न किसी नोड
को अलग तरह से रिज़ॉल्व करता है, तो वह नोड रीप्ले के समय नहीं मिलता।

नए मॉडल को परखने के लिए `--no-cache` इस्तेमाल करें। जब एंट्री में यह दर्ज हो कि
उसे किसने रिकॉर्ड किया, तो रीप्ले `step.cache.recordedBy` दिखाते हैं। पुरानी
एंट्री और जिन एंट्री में यह जानकारी नहीं है, उनमें यह नहीं होता।

टाइमस्टैम्प या नया ईमेल पता हर रन में मिस होगा। ऐसी वैल्यू को `unique()` में
रखें, तो रनर रीप्ले के समय मौजूदा वैल्यू डाल देता है:

```ts

const name = `E2E ${Date.now()} Company`;
await agent.act('create a company named {name}', { params: { name: unique(name) } });
await expect(screen.getByRole('heading', { name })).toBeVisible();
```

जो डेटा फ़्लो में भरा या जाँचा जाता है, उसके लिए `unique()` इस्तेमाल करें। जो
विकल्प फ़्लो बदलते हैं, जैसे किसी प्लान का नाम, उनके लिए सामान्य पैरामीटर
इस्तेमाल करें। वैल्यू बदलने का यह नियम उस रूप पर भी लागू होता है जिसमें URL
वैल्यू को लिखता है (`%20`, `+`), और कई लाइनों वाली वैल्यू के उस रूप पर भी जिसमें
स्क्रीन उसे एक लाइन में दिखाती है। जब कोई `unique()` वैल्यू किसी दूसरे पैरामीटर
की वैल्यू के बराबर हो या उसके अंदर हो, तो चरण रिकॉर्ड नहीं होता:
`step.cache.notRecorded` में `param-collision` होता है, और अगला रन उसे रिकॉर्ड
करता है।

हर डिप्लॉय पर बदलने वाले प्रीव्यू URL के लिए कैश की एक ही पहचान रखने को
[`app.identity`](https://e2e.com/docs/hi/reference/config#the-app-under-test) सेट करें। डिवाइस पर रीप्ले
[स्क्रीन टाइटल](https://e2e.com/docs/hi/reference/mobile#replay-cache-on-a-device) को पाथ के रूप में
इस्तेमाल करता है।

## टेस्ट ठीक करते समय उसे दोबारा चलाएँ

जब आप कोई फ़ेल होता टेस्ट ठीक करें, तो कैश को `read-write` मोड में चालू रखें, जो
लोकल डिफ़ॉल्ट है, और [स्ट्रिक्ट कैश मोड](#fail-on-a-stale-recording) से बाहर
रखें, जो कभी नहीं लिखता। अगर `CI` सेट है और आपने कोई मोड नहीं चुना है, तो
डिफ़ॉल्ट `read-only` होता है। फ़ेल हुआ रन वे रिकॉर्डिंग रखता है जिनकी किसी जाँच
ने विफलता से पहले [पुष्टि की](#when-a-recording-is-written)। अगला रन उन लक्ष्यों
को बिना मॉडल कॉल के रीप्ले करता है, बशर्ते हर रीप्ले अब भी स्क्रीन से मेल खाता
हो।

1. सिर्फ़ वही टेस्ट चलाएँ। कमांड में उस लाइन का नंबर दें जिस पर उसका `test(`
   शुरू होता है:
   `npx e2e run tests/cart.e2e.ts:3`।
2. टेस्ट का नाम न बदलें, और पास होने वाले लक्ष्य के शब्द न बदलें। दोनों
   बदलावों से [कैश मिस होता है](#what-must-match)। टेस्ट का नाम बदलने पर उसके हर
   लक्ष्य के लिए कैश मिस होता है, और लक्ष्य के शब्द बदलने पर सिर्फ़ उसी लक्ष्य के
   लिए।
3. जब रीट्राई चालू हों (कॉन्फ़िग में `retries`, या `CI` सेट हो), तो
   `--retries 0` जोड़ें। टेस्ट या उसके `describe` पर दिया गया `retries` विकल्प
   फ़्लैग से ऊपर प्राथमिकता पाता है। रीट्राई रीप्ले नहीं करता, इसलिए वह हर लक्ष्य
   लाइव चलाता है।
4. जब टेस्ट पास हो जाए, तो उसे एक बार `--no-cache` के साथ चलाएँ। हर लक्ष्य लाइव
   चलता है, जिससे पता चलता है कि एजेंट रिकॉर्डिंग के बिना भी उस तक पहुँचता है।

## रीप्ले कैसे काम करता है

1. रनर शुरुआती स्क्रीन जाँचता है: उसका रूट वही होना चाहिए।
2. रनर हर रिकॉर्ड किए गए कंट्रोल को रोल, नाम, टेस्ट id और आसपास के कॉन्टेक्स्ट से
   ढूँढता है, और उसका एक्शन दोहराता है। रनर गायब कंट्रोल का इंतज़ार करता है, और
   जब कोई मैच अस्पष्ट हो, तो रुक जाता है।
3. रनर आख़िरी रूट और मूल चरण के बदलाव जाँचता है: कौन से कंट्रोल दिखे और उनकी
   चेक्ड, सिलेक्टेड, एक्सपैंडेड या प्रेस्ड स्थिति क्या थी, और कौन से कंट्रोल गायब
   हुए।
4. रनर बिना मॉडल कॉल के चरण पूरा करता है, या एजेंट को इस ब्योरे के साथ आगे बढ़ने
   देता है कि क्या चला और रीप्ले क्यों रुका।

टाइप की गई वैल्यू वैसे ही रीप्ले होती हैं जैसे रिकॉर्ड हुई थीं। सीक्रेट भरने वाला
एक्शन मौजूदा वैल्यू को नाम से रिज़ॉल्व करता है और फिर से ऑथराइज़ेशन से गुज़रता है।

रिकॉर्ड किए गए बदलाव दिखते ही रीप्ले पूरा हो जाता है। ऐसा उनके नीचे का कंटेंट
लोड होने से पहले भी हो सकता है। चरण के बाद लोड होने वाला कंटेंट जाँचने के लिए
`agent.assert` नहीं, `agent.waitFor` इस्तेमाल करें। `agent.waitFor` उसका इंतज़ार
करता है, जबकि `agent.assert` स्क्रीन का एक ही बार आकलन करता है।

<Accordion title="किसे वही रूट माना जाता है">
रूट में ऑरिजिन, पाथ और क्वेरी आते हैं। रिकॉर्ड की id और फ़्रैगमेंट नहीं गिने
जाते। पाथ या क्वेरी में id, टोकन, टाइमस्टैम्प और कैश बस्टर को id प्लेसहोल्डर के
रूप में पढ़ा जाता है, इसलिए `/orders/42?t=1727780000` और
`/orders/7?t=1727780999` एक ही रूट हैं।

क्वेरी की हर दूसरी वैल्यू रूट का हिस्सा है: `?mode=safe` और `?mode=unsafe` अलग
हैं, `/companies` और `/companies?tab=notes` भी अलग हैं, और कोई नया ट्रैकिंग
पैरामीटर भी रूट को अलग कर देता है। `/products/summer-sneaker` और
`/products/winter-boot` भी अलग रूट हैं।

ऐप के अपने ऑरिजिन की लोकेशन की तुलना उसके पाथ से होती है, इसलिए रिकॉर्डिंग ऐप के
साथ उस प्रीव्यू डिप्लॉयमेंट पर भी चलती है जिसका `app.identity` वही है। किसी भी
दूसरे ऑरिजिन का पेज दूसरा रूट है।
</Accordion>

<Accordion title="आख़िरी जाँच स्क्रीन को कैसे पढ़ती है">
- रीप्ले के दौरान कम से कम एक रिकॉर्ड किया गया बदलाव होना चाहिए। जो नतीजा रीप्ले
  के एक्शन शुरू होने से पहले ही स्क्रीन पर था, वह कुछ साबित नहीं करता। जब चरण का
  आख़िरी एक्शन किसी दूसरे रूट पर गया, तो रूट का वह बदलाव ही सबूत है।
- ऐसा अलर्ट, जो रीप्ले से आया और रिकॉर्डिंग में कभी नहीं दिखा, रीप्ले रोक देता
  है। वेब इंजन [Next.js](https://e2e.com/docs/hi/frameworks/nextjs#fix-next-js-problems) App Router के
  रूट अनाउंसर को नहीं देखता, इसलिए अनाउंसर का टाइटल दोहराना कभी नहीं गिना जाता।
- जो टेक्स्ट हर रन में अलग होता है, जैसे तारीख, अवधि या id, उसे तब छोड़ दिया जाता
  है जब चरण के डेल्टा (चरण से हुए बदलावों) के किसी भी पक्ष में कोई स्थिर बदलाव
  हो, चाहे कुछ दिखा हो या गायब हुआ हो। कुछ और न होने पर उसे रखा जाता है, और बदली
  हुई वैल्यू रीप्ले को एजेंट को सौंप देती है। अलर्ट में वह प्लेसहोल्डर के रूप में
  पढ़ा जाता है। जिस नोड की पहचान सिर्फ़ ऐप की बनाई टेस्ट id (`node-<uuid>`) से
  होती है, उसे भी इसी तरह छोड़ा जाता है। रखे जाने पर, दिखने वाले नोड की id उस
  पैटर्न वाली कोई भी हो सकती है। गायब हुए नोड की जाँच अब भी उसकी सटीक id से होती
  है।
- जो गिनती बताती है कि वह किस चीज़ की है, जैसे `3 records imported` या `42件`, वह
  रीप्ले में वैसी ही दिखनी चाहिए, अगर वह गिनती चरण की वजह से उसी स्क्रीन पर
  दिखने लगी हो जिस पर चरण ने एक्शन किया। जो गिनती सिर्फ़ बदली
  (`41 items` से `42 items`), या जो उस स्क्रीन पर है जिस पर चरण नेविगेट करके
  गया, उसे सिर्फ़ तब छोड़ा जाता है जब डेल्टा के उसके अपने पक्ष में कोई स्थिर
  बदलाव हो। नहीं तो गिनती बनी रहती है, तब भी जब उल्टे पक्ष में कोई स्थिर बदलाव
  हो। बैज जैसी अकेली संख्या ऊपर वाले टेक्स्ट नियम का पालन करती है।
- बिना नाम वाला कंट्रोल उसकी जगह से ढूँढा जाता है: नाम वाली उसी पंक्ति, लिस्ट
  आइटम या ग्रुप के अंदर, अपनी तरह के बिना नाम वाले कंट्रोल के बीच वह किस जगह पर
  है। जो कंट्रोल सिर्फ़ जनरेट की गई टेस्ट id से पहचाना जाता है, वह भी इसी तरह id
  पैटर्न से ढूँढा जाता है, या तब जब वह उस पैटर्न वाला अकेला कंट्रोल था।
</Accordion>

## कोई चरण रीप्ले क्यों नहीं हुआ

हर `act` चरण `step.cache` रिपोर्ट करता है। जब चरण के लिए कैशिंग बंद हो, तो यह
नहीं होता। `agent.act()` इसे `write` के बिना `result.cache` के रूप में लौटाता है,
और [ट्रेस पेज](https://e2e.com/docs/hi/debugging#traces) इसे चरण के नीचे दिखाता है।

| रन सारांश | `step.cache.mode` | मतलब |
| --- | --- | --- |
| `replayed` | `self-finalized` | रिकॉर्डिंग बिना मॉडल कॉल के पूरी हुई। |
| `handed off` | `agent-concluded` | रीप्ले शुरू हुआ, फिर एजेंट ने काम संभाल लिया। |
| `missed` | `missed` | एजेंट ने चरण शुरू से चलाया। |

`handed off` और `missed`, दोनों में `step.cache.reason` होता है, और
`step.cache.detail` बताता है कि रीप्ले कहाँ और क्यों रुका
(`at action 2 of 3, tap button "Apply": ...`)। `end-mismatch` के बाद यह रिकॉर्ड
किए गए उन नोड के नाम बताता है जो दिखे नहीं या गायब नहीं हुए। यह ऐसे हर अलर्ट का
नाम भी बताता है जो रिकॉर्डिंग में कभी नहीं दिखा। या फिर यह बताता है कि नतीजा
रीप्ले के एक्शन से पहले ही दिख चुका था। `step.cache.entry` एंट्री की कुंजी है,
और फ़ाइल स्टोर में उसकी फ़ाइल का नाम (`<entry>.json`) भी।

| कारण | क्या हुआ | क्या करें |
| --- | --- | --- |
| `no-entry` | कोई रिकॉर्डिंग इस चरण और इसके पैरामीटर से मेल नहीं खाती। | जिस अगले पास में इस चरण की पुष्टि होती है, वही इसे रिकॉर्ड करता है, बशर्ते चरण का `step.cache.write` `no-change` न हो। |
| `retry` | रीट्राई कभी रीप्ले नहीं करते, सिवाय `--strict-cache` या `cache.strict` के साथ। | कुछ नहीं। |
| `invalid-entry` | फ़ाइल पढ़ी नहीं जा सकती, 1 MiB से बड़ी है, या किसी दूसरे स्कीमा वर्ज़न की है। | `npx e2e cache clear`। |
| `truncated` | रिकॉर्डिंग किसी सीमा तक पहुँच गई, [नीचे](#limits-and-gaps) देखें। | चरण को बाँटें, या सीक्रेट को `Secret` के रूप में पास करें। |
| `wrong-context` | ऐप उस रूट से अलग रूट पर था जिस पर चरण रिकॉर्ड हुआ था। [रीप्ले कैसे काम करता है](#how-a-replay-works) देखें। | चरण से पहले वही स्क्रीन खोलें। |
| `target-not-found` | कोई रिकॉर्ड किया गया कंट्रोल 15 सेकंड के अंदर नहीं दिखा, या उसका कोई नाम नहीं है और उसे उसके जैसे दूसरे कंट्रोल से अलग पहचानने के लिए कोई नाम वाला कंटेनर नहीं है। | UI बदल गया है: अगला पास होने वाला रन इसे फिर से रिकॉर्ड करता है। बिना नाम वाले कंट्रोल को लेबल दें, या उसे नाम वाली पंक्ति या ग्रुप में रखें। |
| `target-ambiguous` | मेल खाने वाले कंट्रोल की संख्या बदल गई। | दोहराए गए कंट्रोल को अलग-अलग नाम दें, या यूनीक टेस्ट डेटा इस्तेमाल करें। |
| `gap` | किसी एक्शन को रीप्ले नहीं किया जा सकता, [नीचे](#limits-and-gaps) देखें। | एजेंट यह हिस्सा लाइव करता है। स्थिर वैल्यू `params` में रखें। |
| `action-failed` | ऐप ने रीप्ले किया गया एक्शन अस्वीकार कर दिया। | ऐप जाँचें। |
| `action-uncertain` | रीप्ले किया गया एक्शन फ़ेल हुआ, और यह पता नहीं कि उसका असर हुआ या नहीं। एजेंट से कहा जाता है कि अगला एक्शन करने से पहले वह जाँच ले कि उसका असर हुआ या नहीं। | ऐप जाँचें। |
| `viewport-changed` | सिर्फ़ एक बिंदु पर किया गया टैप, होवर या ड्रैग किसी दूसरे साइज़ के व्यूपोर्ट पर रिकॉर्ड हुआ था। | व्यूपोर्ट को तय रखें। |
| `end-mismatch` | हर एक्शन चला, लेकिन [आख़िरी जाँच](#how-a-replay-works) फ़ेल हुई। | पिछले रन का बचा हुआ डेटा, आने-जाने वाला बैनर, या कोई रिग्रेशन। यूनीक टेस्ट डेटा और `afterEach` में क्लीनअप मदद करते हैं। |

यह पक्का करने के लिए कि विफलता कैश की वजह से नहीं है, एक बार कैश के बिना
चलाएँ:

<CodeGroup>
```bash npm
npx e2e run --no-cache
```

```bash pnpm
pnpm exec e2e run --no-cache
```

```bash bun
bunx e2e run --no-cache
```
</CodeGroup>

### सीमाएँ और गैप

रिकॉर्डिंग `truncated` होती है जब चरण ने:

- 50 से ज़्यादा एक्शन किए, जो सिर्फ़ 50 से ऊपर `maxSteps` के साथ हो सकता है,
- 4,096 कैरेक्टर से लंबी वैल्यू या URL टाइप किया, या ऐसी वैल्यू जिसमें कोई
  रजिस्टर किया गया सीक्रेट हो,
- ऐसे कंट्रोल पर एक्शन किया जिसका कोई इस्तेमाल करने लायक विवरण नहीं है।

`gap` ऐसा एक्शन है जिसे कैश दोहरा नहीं सकता: कुछ बदलने वाला
[प्रोजेक्ट टूल](https://e2e.com/docs/hi/tools), या ऐसी वैल्यू जो एजेंट ने स्क्रीन से पढ़ी, स्क्रीनशॉट
देखने के बाद टाइप की, या तारीख से निकाली। `step.cache.derived` नियम का नाम बताता
है: `whole-node` (किसी कंट्रोल का पूरा नाम या टेक्स्ट), `minted-token` (ऐसा कोड
या id जो ऐप ने एक अलग शब्द के रूप में दिखाया, या
`autocomplete="one-time-code"` वाले फ़ील्ड में टाइप की गई कोई भी वैल्यू), `date`
या `pixels`। निर्देश या `params` से आई वैल्यू, और एजेंट की खुद बनाई वैल्यू,
रीप्ले होती हैं। one-time-code फ़ील्ड में सिर्फ़ वही पूरा कोड रीप्ले होता है जो
निर्देश या `params` में लिखा हो।

## रिकॉर्डिंग में क्या होता है

हर एंट्री `.e2e/cache/` के अंदर एक JSON फ़ाइल है, जिसका नाम उसकी कुंजी के हैश से
बनता है। इसमें एक्शन, जिन कंट्रोल पर एक्शन हुआ उनके विवरण, टाइप किया गया
टेक्स्ट, चरण का सारांश और आख़िरी जाँचें होती हैं: रूट, और दिखने वाले आठ तक
कंट्रोल और गायब होने वाले आठ तक कंट्रोल। एंट्री में प्रॉम्प्ट, बातचीत,
स्क्रीनशॉट, ऑब्ज़र्व किए गए ट्री या सीक्रेट की वैल्यू नहीं होतीं। सीक्रेट भरने पर
सिर्फ़ सीक्रेट का नाम सेव होता है।

<Warning>
टाइप की गई दूसरी वैल्यू वैसे ही सेव होती हैं जैसे टाइप की गई थीं। रिकॉर्डिंग
शेयर करने से पहले उन्हें जाँच लें। [कैश पर भरोसा](https://e2e.com/docs/hi/reference/security#cache-trust)
देखें।
</Warning>

## मोड

| मोड | रीप्ले करता है | रिकॉर्ड करता है | डिफ़ॉल्ट |
| --- | --- | --- | --- |
| `'read-write'` | हाँ | हाँ | लोकल में |
| `'read-only'` | हाँ | नहीं | CI में, जब `cache` सेट न हो |
| `'off'` | नहीं | नहीं | एक रन के लिए `--no-cache` |

```ts title="e2e.config.ts fragment"
cache: 'off',
// or
cache: { mode: 'read-write', dir: '.e2e/cache' },
```

`--no-cache` कॉन्फ़िग से ऊपर प्राथमिकता पाता है। `read-only` मोड में
पुरानी पड़ चुकी एंट्री तब तक रहती हैं जब तक कोई `read-write` रन उनकी जगह नई
एंट्री न लिख दे। कस्टम `cache.store` फ़ाइल स्टोर की जगह लेता है, और CI में उसका
डिफ़ॉल्ट `read-only` नहीं होता। `e2e explore` और `e2e mcp` सेशन कैश इस्तेमाल
नहीं करते। जो टेस्ट कोई सेशन चलाता है
([`open_session {test}`](https://e2e.com/docs/hi/reference/mcp#running-a-test)), वह कैश को वैसे ही
इस्तेमाल करता है जैसे किसी रन का पहला प्रयास करता है।

## कई चेकआउट में कैश साझा करें

`E2E_CACHE_DIR` से, या एक रन के लिए `--cache-dir` से, किसी प्रोजेक्ट के हर
चेकआउट को एक ही डायरेक्टरी की ओर पॉइंट करें। दोनों में से कोई भी `cache.dir` की जगह
लेता है, प्रोजेक्ट रूट के सापेक्ष रिज़ॉल्व होता है (`~` या शुरुआत का `~/` आपकी
होम डायरेक्टरी है), और मोड को नहीं बदलता। कस्टम `cache.store` के साथ
`--cache-dir` एरर है, और `E2E_CACHE_DIR` अनदेखा किया जाता है। पैरलल रन डायरेक्टरी
साझा कर सकते हैं: लिखने की हर कार्रवाई अपनी फ़ाइल को एटॉमिक तरीके से बदलती है।
एंट्री की कुंजी प्रोजेक्ट के हिसाब से बनती है, इसलिए हर चेकआउट को एक ही
`projectId` (या `package.json` का `name`) दें। दोनों न होने पर हर चेकआउट का
पाथ उसकी पहचान बन जाता है, और उनके बीच कुछ भी रीप्ले नहीं होता।

- चेकआउट एंट्री साझा करते हैं: इनमें से किसी में भी फ़ेल होने वाला रन एंट्री
  हटा देता है, और ऐप की एक ही पहचान लेकिन अलग ऐप कोड वाले चेकआउट एक-दूसरे
  की एंट्री ओवरराइट करते हैं (जो आख़िर में लिखता है, उसी की एंट्री रहती है)।
- जब तक ओवरराइड सेट है, `cache.dir` के अंदर कमिट किया गया कैश पढ़ा नहीं जाता।
- हर प्रोजेक्ट के लिए एक डायरेक्टरी इस्तेमाल करें। एक डायरेक्टरी में दो प्रोजेक्ट
  होने पर `cache.strict` के साथ गलत `REPLAY_STALE` मिल सकता है।

```bash
E2E_CACHE_DIR=~/.cache/my-app/e2e npx e2e run
```

## रीप्ले कैश कमिट करें

<span id="commit-your-traces" />

`e2e init` `.gitignore` में `.e2e/cache/` जोड़ता है, इसलिए हर मशीन अपनी
रिकॉर्डिंग खुद बनाती है और CI बिना किसी रिकॉर्डिंग के शुरू होता है। रीप्ले साझा
करने के लिए वह लाइन हटाएँ और डायरेक्टरी कमिट करें। जब तक आप
`cache: 'read-write'` सेट न करें, CI `read-only` रहता है। कमिट की गई एंट्री को
टेस्ट डेटा मानें, और जिस पुल रिक्वेस्ट ने उन्हें फिर से रिकॉर्ड किया, उसमें उनकी
समीक्षा करें।

जब तक कुछ बदला न हो, लोकल रन कमिट की गई कैश डायरेक्टरी में कोई बदलाव नहीं करते।
रीप्ले हुआ चरण अपनी एंट्री कभी दोबारा नहीं लिखता, और जिस लाइव रिकॉर्डिंग के
एक्शन, पाथ और एंकर पहले जैसे ही हों, वह लिखी नहीं जाती। इसलिए धीरे-धीरे बदलते UI
की एंट्री सिर्फ़ तब रिपेयर होती है जब कोई कंट्रोल अब मिल न सके। कोई फ़ाइल तब
बदलती है जब:

- कोई चरण पहली बार रिकॉर्ड होता है, या हैंड-ऑफ़ के बाद रिकॉर्ड होता है,
- कोई चरण रीप्ले के बाद फ़ेल होता है, ऐसे `end-mismatch` पर खत्म होता है जिसे
  एजेंट को रिपेयर करना पड़ा, रिकॉर्ड करने को कुछ न होने पर भी पास होता है, या
  प्रयास खत्म होने तक उसकी पुष्टि नहीं होती, जिससे एंट्री डिलीट हो जाती है,
- `e2e` का कोई अपग्रेड एंट्री मैच करने का तरीका बदलता है, जिससे हर एंट्री को नई
  कुंजी मिलती है, इसलिए अगला रन उन्हें फिर से रिकॉर्ड करता है।

## पुरानी पड़ चुकी रिकॉर्डिंग पर फ़ेल करें

डिफ़ॉल्ट रूप से, अगर कमिट की गई रिकॉर्डिंग रीप्ले होना बंद कर दे, तो कुछ भी फ़ेल
नहीं होता: एजेंट चरण संभाल लेता है, और जब तक कोई उसे फिर से रिकॉर्ड न करे, हर
CI रन में मॉडल कॉल का खर्च आता है। `--strict-cache` (या
`cache: { strict: true }`) के साथ चरण `REPLAY_STALE` के साथ फ़ेल होता है और कोई
मॉडल कॉल नहीं करता:

<CodeGroup>
```bash npm
CI=1 npx e2e run --strict-cache
```

```bash pnpm
CI=1 pnpm exec e2e run --strict-cache
```

```bash bun
CI=1 bunx e2e run --strict-cache
```
</CodeGroup>

`REPLAY_STALE` एग्ज़िट कोड 2 देता है, और उसका रीट्राई नहीं होता।

| स्ट्रिक्ट कैश मोड में फ़ेल होता है | फिर भी लाइव चलता है |
| --- | --- |
| `invalid-entry`, `wrong-context`, `target-not-found`, `target-ambiguous`, `viewport-changed`, `action-failed`, `action-uncertain`, `end-mismatch`: ऐप या एंट्री बदल गई | ऐसा चरण जो कभी रिकॉर्ड नहीं हुआ (नया या बदला गया निर्देश या पैरामीटर) |
| `no-entry`, जब कैश डायरेक्टरी में उसी चरण की रिकॉर्डिंग किसी दूसरी कुंजी के तहत हो | `gap` या `truncated` रिकॉर्डिंग |
| | ऐसा चरण जिसका स्टोर से पढ़ना फ़ेल हो |
| | ऐसा चरण जिसके टारगेट का नाम, एजेंट का नाम या `report.json` में दर्ज उसके टेस्ट का `testId` 300 कैरेक्टर से लंबा हो, जब `e2e` के किसी पुराने वर्ज़न ने उसे दूसरी कुंजी के तहत रिकॉर्ड किया हो और तब से इस वर्ज़न के किसी `read-write` रन ने उसे रीप्ले न किया हो |

दूसरी कुंजी के तहत रिकॉर्डिंग `e2e` के ऐसे अपग्रेड से आती है जिसने कुंजियाँ
बदलीं, या प्रोजेक्ट id, ऐप की पहचान या एजेंट के कॉन्टेक्स्ट में बदलाव से। संदेश उस
फ़ाइल का नाम बताता है, और मौजूदा वर्ज़न से बनी रिकॉर्डिंग के लिए यह भी कि क्या
बदला। जब कुछ भी उस फ़ाइल को रीप्ले न करे, तो उसे डिलीट करें। यह जाँच कस्टम
`cache.store` पर लागू नहीं होती।

स्ट्रिक्ट कैश मोड वाला रन न तो कोई एंट्री लिखता है, न कोई एंट्री डिलीट करता है,
`read-write` मोड में भी नहीं। इसलिए नया चरण सिर्फ़ उसी रन में रिकॉर्ड होता है
जिसमें स्ट्रिक्ट कैश मोड बंद हो। कॉन्फ़िग में `cache.strict` के बजाय CI में
`--strict-cache` को प्राथमिकता दें। पुरानी पड़ चुकी एंट्री ठीक करने के लिए:

1. टेस्ट को फ़्लैग के बिना `read-write` मोड में चलाएँ। अगर कॉन्फ़िग
   `cache.strict` सेट करता है, तो उसे बंद करें।
2. जो एंट्री बदली है, उसे कमिट करें। कस्टम `cache.store` को कमिट के बजाय
   उसी रन से नई एंट्री मिल जाती है।

## कैश की जाँच करें

<CodeGroup>
```bash npm
npx e2e cache ls      # one row per entry: test, target, instruction digest, age, actions
npx e2e cache stats   # entry count and size
npx e2e cache clear   # delete every entry
```

```bash pnpm
pnpm exec e2e cache ls      # one row per entry: test, target, instruction digest, age, actions
pnpm exec e2e cache stats   # entry count and size
pnpm exec e2e cache clear   # delete every entry
```

```bash bun
bunx e2e cache ls      # one row per entry: test, target, instruction digest, age, actions
bunx e2e cache stats   # entry count and size
bunx e2e cache clear   # delete every entry
```
</CodeGroup>

<Note>
AI उपयोग में दिखने वाला `cached` प्रतिशत प्रोवाइडर का प्रॉम्प्ट कैश है। यह मॉडल
कॉल का खर्च कम करता है। रीप्ले कैश कॉल को ही छोड़ देता है।
</Note>

## आगे

<CardGroup cols={2}>
  <Card title="कॉन्फ़िग रेफ़रेंस" icon="sliders" href="/reference/config#cache">
    `mode`, `store`, `dir`।
  </Card>
  <Card title="CLI रेफ़रेंस" icon="terminal" href="/reference/cli#e2e-cache">
    `e2e cache ls`, `stats`, `clear`।
  </Card>
</CardGroup>
