← NetlifyCONTENT HISTORY

Update to Netlify

Snapshot Nov 19, 2026 · 00:11 UTC · version 1.9.0

Collection source: downloaded plugin package.

WHAT CHANGED

Instructions updated for netlify-caching

Full description — Now says: (fetchWithCache/cacheHeaders/getCacheStatus/purgeCache),

Observed in instructions or declared skills. Runtime behavior has not been tested.

Save Netlify and check future changes in Following.

Up to 3 plugins free · no card required.

All fields and original values.

Full description

Before

Oct 7, 2026 · 00:02 UTC

(fetchWithCache/cacheHeaders/getCacheStatus),

After

Nov 19, 2026 · 00:11 UTC

(fetchWithCache/cacheHeaders/getCacheStatus/purgeCache),

Skill instructions

Before

Oct 7, 2026 · 00:02 UTC

(fetchWithCache/cacheHeaders/getCacheStatus), speed up an expensive API call, add ISR or on-demand revalidation, or debug why a response is or isn't cached via the Cache-Status header. Dynamic responses (Functions, Edge Functions, proxie...

After

Nov 19, 2026 · 00:11 UTC

(fetchWithCache/cacheHeaders/getCacheStatus/purgeCache), speed up an expensive API call, add ISR or on-demand revalidation, or debug why a response is or isn't cached via the Cache-Status header. Dynamic responses (Functions, Edge Functi...

Compare saved observations

Download comparison JSON

SKILL.md text changes

− removed · + added

--- before
+++ after
@@ -1,13 +1,13 @@
 ---
 name: netlify-caching
-description: Cache dynamic and static responses on Netlify's CDN from Functions, Edge Functions, and proxies. Use when you add caching or cache-control headers to a function response, tune cache TTL or stale-while-revalidate, set up the durable cache, vary a cache key by query/header/cookie/country/language, purge or invalidate the cache by site or cache tag, use the programmatic Cache API (caches.open/match/put) or @netlify/cache helpers (fetchWithCache/cacheHeaders/getCacheStatus), speed up an expensive API call, add ISR or on-demand revalidation, or debug why a response is or isn't cached via the Cache-Status header.
+description: Cache dynamic and static responses on Netlify's CDN from Functions, Edge Functions, and proxies. Use when you add caching or cache-control headers to a function response, tune cache TTL or stale-while-revalidate, set up the durable cache, vary a cache key by query/header/cookie/country/language, purge or invalidate the cache by site or cache tag, use the programmatic Cache API (caches.open/match/put) or @netlify/cache helpers (fetchWithCache/cacheHeaders/getCacheStatus/purgeCache), speed up an expensive API call, add ISR or on-demand revalidation, or debug why a response is or isn't cached via the Cache-Status header.
 ---
 
 # Netlify caching
 
 ## Cache-control header to reach for
 
-Dynamic responses (Functions, Edge Functions, proxies) are **NOT cached by default** — you must opt in. Set `Netlify-CDN-Cache-Control` on the response:
+Dynamic responses (Functions, Edge Functions, proxies) are **NOT cached by default**. You must opt in. Set `Netlify-CDN-Cache-Control` on the response:
 
 ```ts
 import type { Context } from "@netlify/functions";
@@ -22,31 +22,31 @@
 ```
 
 Header choice (most specific wins; `CDN-Cache-Control`/`Cache-Control` always pass downstream):
-- `Netlify-CDN-Cache-Control` — Netlify CDN only. **Reach for this.**
-- `CDN-Cache-Control` — all CDNs that support it.
-- `Cache-Control` — any CDN or the browser.
+- `Netlify-CDN-Cache-Control` applies to the Netlify CDN only. **Reach for this.**
+- `CDN-Cache-Control` applies to all CDNs that support it.
+- `Cache-Control` applies to any CDN or the browser.
 
-**Legacy path to avoid:** On-demand Builders do **not** support these headers or `Netlify-Vary` — they use a TTL pattern and key on URL path only. Don't reach for ODBs in new code.
+**Legacy path to avoid:** On-demand Builders do **not** support these headers or `Netlify-Vary`. They use a TTL pattern and key on URL path only. Don't reach for ODBs in new code.
 
 ## Footguns (read first)
 
-- **Only `GET` is cached.** POST/PUT/etc. are never cached regardless of headers — expose cacheable data on a GET route (inputs in the URL or query string).
-- **`netlify dev` does not emulate the CDN cache.** A local cache miss every time is expected. Verify caching on a deployed URL (Deploy Preview or production) via its `Cache-Status` header.
-- **Without `Netlify-Vary: query=...`, the full query string is the cache key** — every distinct query string (`utm_*`, `fbclid`, …) is a separate cache entry. Enumerate only the params that change the response.
-- **Static assets are fresh for up to a year** — a shorter `max-age` is ignored. They change only on a new deploy or manual purge.
+- **Static assets are fresh for up to a year.** A shorter `max-age` is ignored. They change only on a new deploy or manual purge.
 - **basic-auth on ANY page disables caching for the ENTIRE site.**
-- **`durable` is serverless-only** — it has no effect on Edge Function responses.
-- Never opt sensitive content out of automatic invalidation — it can stay publicly cached after deploys/firewall changes.
+- **`durable` is serverless-only.** It has no effect on Edge Function responses.
+- **Cache API silently drops responses over 10 MB.** `cache.put()` doesn't store them and later lookups miss. Compress the content or split it across multiple entries.
+- Never opt sensitive content out of automatic invalidation. It can stay publicly cached after deploys/firewall changes.
 
 ## Directives
 
-- `public` cache it / `private` browser-only, not Netlify's shared cache / `no-store` don't cache.
-- `s-maxage=N` seconds in Netlify's shared cache (overrides `max-age` there).
-- `max-age=N` seconds in any cache.
-- `stale-while-revalidate=N` serve stale for N seconds after expiry while revalidating in background.
-- `durable` (serverless only) store in Netlify's durable cache so other edge nodes reuse it instead of re-invoking the function.
-
-Defaults when no header is set — static: `Netlify-CDN-Cache-Control: public, s-maxage=31536000, must-revalidate`; dynamic: `Cache-Control: public, max-age=0, must-revalidate`.
+- `public` caches the response. `private` caches it in the browser only, not in Netlify's shared cache. `no-store` prevents caching.
+- `s-maxage=N` sets seconds in Netlify's shared cache (overrides `max-age` there).
+- `max-age=N` sets seconds in any cache.
+- `stale-while-revalidate=N` serves stale for N seconds after expiry while revalidating in the background.
+- `durable` (serverless only) stores the response in Netlify's durable cache so other edge nodes reuse it instead of re-invoking the function.
+
+Defaults when no header is set:
+- Static: `Netlify-CDN-Cache-Control: public, s-maxage=31536000, must-revalidate`
+- Dynamic: `Cache-Control: public, max-age=0, must-revalidate`
 
 ## Cache key variation — `Netlify-Vary`
 
@@ -56,15 +56,17 @@
 Netlify-Vary: query=item_id|page, country=es+de|us, cookie=ab_test|is_logged_in
 ```
 
-- `query=a|b` subset, or bare `query` for all params. Keys case-sensitive; param order irrelevant.
-- `header=Device-Type|App-Version` — custom + most standard headers.
-- `language=en|es+pt` — `+` groups; checked against `Accept-Language` with quality weighting.
-- `country=us|es+pt` — GeoIP, ISO 3166-1 two-letter codes; `+` groups.
-- `cookie=ab_test|is_logged_in` — target specific keys, not the whole `Cookie` header.
+- `query=a|b` varies on a subset; bare `query` varies on all params. Keys are case-sensitive; param order is irrelevant.
+- `header=Device-Type|App-Version` supports custom and most standard headers.
+- `language=en|es+pt` uses `+` for groups. It is checked against `Accept-Language` with quality weighting.
+- `country=us|es+pt` uses GeoIP with ISO 3166-1 two-letter codes; `+` groups.
+- `cookie=ab_test|is_logged_in` targets specific keys, not the whole `Cookie` header.
+
+**Cannot vary by header on:** `Accept*`, `Cache-Control`, `Connection`, `Content-Length`, `Cookie`, `Host`, `If-*`, `Range`, `Referer`, `Upgrade`, `User-Agent`. For language/cookie/format, use `Vary: Accept-Language`/`Vary: Cookie` or the specific `Netlify-Vary` instruction.
 
-**Cannot vary by header on:** `Accept*`, `Cache-Control`, `Connection`, `Content-Length`, `Cookie`, `Host`, `If-*`, `Range`, `Referer`, `Upgrade`, `User-Agent`. For language/cookie/format use `Vary: Accept-Language`/`Vary: Cookie` or the specific `Netlify-Vary` instruction.
+**Consistency rule:** a URL must return the same `Netlify-Vary` on every response. The first cached response's instructions win and later ones are ignored.
 
-**Consistency rule:** a URL must return the same `Netlify-Vary` on every response — the first cached response's instructions win and later ones are ignored. `Netlify-Vary` + standard `Vary` are both respected (use `Vary` for format/encoding, and to pass instructions to an upstream CDN like Cloudflare).
+`Netlify-Vary` and standard `Vary` are both respected. Use `Vary` for format/encoding, and to pass instructions to an upstream CDN like Cloudflare.
 
 ## Cache tags & opt-out
 
@@ -74,23 +76,23 @@
 Netlify-Cache-Tag: tag1,tag2,tag3
 ```
 
-- `Netlify-Cache-Tag` (Netlify CDN) wins over `Cache-Tag` (passed downstream). Some providers strip `Cache-Tag` — set both when proxying through them.
+- `Netlify-Cache-Tag` (Netlify CDN) wins over `Cache-Tag` (passed downstream). Some providers strip `Cache-Tag`, so set both when proxying through them.
 - Constraints: case-insensitive, UTF-8 only, ≤1024 chars/tag, ≤500 tags/response.
 
-Opt a response out of automatic atomic-deploy invalidation with `Netlify-Cache-ID` (comma-separated; auto-registered as cache tags for purging; separate 500-ID limit):
+Opt a response out of automatic atomic-deploy invalidation with `Netlify-Cache-ID`. Values are comma-separated, auto-registered as cache tags for purging, and have a separate 500-ID limit:
 
 ```
 Netlify-Cache-ID: cms-proxy,product,image
 ```
 
-After opting out, purge on-demand after relevant changes (e.g. redirect/proxy or function changes behind a `Netlify-Cache-ID`).
+After opting out, purge on demand after relevant changes, e.g. redirect/proxy or function changes behind a `Netlify-Cache-ID`.
 
 ## On-demand invalidation (purge)
 
-Purge from a **deployed function** with `purgeCache` (site ID is passed automatically):
+Purge from a **deployed function or edge function** with `purgeCache` from `@netlify/cache`. The site and purge token are configured automatically. Purging covers everything cached for the site, including Cache API entries:
 
 ```ts
-import { purgeCache } from "@netlify/functions";
+import { purgeCache } from "@netlify/cache";
 
 export default async () => {
   await purgeCache(); // no args = purge everything for the site
@@ -101,7 +103,7 @@
 Purge by tag, optionally targeting a deploy/subdomain:
 
 ```ts
-import { purgeCache } from "@netlify/functions";
+import { purgeCache } from "@netlify/cache";
 
 export default async (req: Request) => {
   const cacheTag = new URL(req.url).searchParams.get("tag");
@@ -115,12 +117,18 @@
 };
 ```
 
-**Ambient credentials only work inside a deployed function.** From CI, local scripts, or the build, pass `token` (a personal access token read from an env var — never hardcoded) and `siteID`.
+`purgeCache(options?)` options:
+- `tags`: tags to purge. Omit to purge the whole site. Tag purges apply to all deploys unless you target one.
+- `deployAlias` (e.g. `deploy-preview-11`): targets that alias on the primary domain.
+- `domain` (e.g. `early-access.company.com`): targets the published production deploy on that domain.
+- `siteID` / `siteSlug`: the site to purge. Use only one. Defaults to the request's site.
+- `token` (defaults to the token Netlify provides) and `userAgent`.
+- Returns a Promise that resolves once the purge is **accepted** (not propagated). It rejects if the API call fails.
 
-**Lambda-compatible functions** use the legacy `module.exports.handler = async (event, context) => {…}` signature and must pass `context.clientContext.custom.purge_api_token`:
+**Lambda-compatible functions** use the legacy `module.exports.handler = async (event, context) => {…}` signature. They must pass `context.clientContext.custom.purge_api_token`:
 
 ```ts
-import { purgeCache } from "@netlify/functions";
+import { purgeCache } from "@netlify/cache";
 
 module.exports.handler = async (event, context) => {
   const token = context.clientContext.custom.purge_api_token;
@@ -129,7 +137,7 @@
 };
 ```
 
-Direct API (from outside a function) — `POST https://api.netlify.com/api/v1/purge` with `Authorization: Bearer <personal_access_token>` and `Content-Type: application/json`:
+Direct API (from outside a function): `POST https://api.netlify.com/api/v1/purge` with `Authorization: Bearer <personal_access_token>` and `Content-Type: application/json`:
 
 ```sh
 curl -X POST \
@@ -139,15 +147,17 @@
   'https://api.netlify.com/api/v1/purge'
 ```
 
-- Purge by site: `site_id` or `site_slug`. By tag: `cache_tags` + site. Omitting `cache_tags` purges the whole site; an **empty** `cache_tags` list purges NOTHING.
-- Identifier mapping: in the UI (Project configuration > General > Project details), **Project ID** = `site_id`, **Project name** = `site_slug`. See https://docs.netlify.com/api-and-cli-guides/api-guides/get-started-with-api#get-site.
-- **Rate limit:** each tag or site can be purged only twice per 5s — exceeding returns `429`.
+- Purge by site: pass `site_id` or `site_slug`.
+- Purge by tag: pass `cache_tags` plus the site.
+- Omitting `cache_tags` purges the whole site. An **empty** `cache_tags` list purges NOTHING.
+- Identifier mapping: in the UI (Project configuration > General > Project details > Project information), **Project ID** = `site_id` and **Project name** = `site_slug`. See https://docs.netlify.com/api-and-cli-guides/api-guides/get-started-with-api#get-site.
+- **Rate limit:** each tag or site can be purged only twice per 5s. Exceeding it returns `429`.
 
 ## Cache API (`caches` global)
 
-Programmatic read/write of HTTP responses from Functions/Edge Functions. Use for caching individual components of a route or arbitrary fetches, alongside header-based route caching.
+Programmatic read/write of HTTP responses from Functions/Edge Functions. Use it to cache individual components of a route or arbitrary fetches, alongside header-based route caching.
 
-**Scope rule:** `caches.open()` anywhere, but `match`/`put`/`delete` **only inside the request handler** — doing them at module/global scope throws.
+**Scope rule:** call `caches.open()` anywhere, but call `match`/`put`/`delete` **only inside the request handler**. Doing them at module/global scope throws.
 
 ```ts
 import type { Config, Context } from "@netlify/functions";
@@ -172,38 +182,49 @@
 ```
 
 `CacheStorage` subset:
-- `caches.match(request)` → `Response` from any cache, or `undefined`.
-- `caches.open(name)` → `Cache`. Distinct names fragment the cache and lower hit ratio — use few, meaningful names.
+- `caches.match(request)` returns a `Response` from any cache, or `undefined`.
+- `caches.open(name)` returns a `Cache`. Distinct names fragment the cache and lower the hit ratio, so use few, meaningful names.
 
 `Cache` methods (all require `caches.open()`):
-- `cache.match(request)` → `Response` | `undefined`.
-- `cache.put(request, response)` → adds a response.
-- `cache.add(request)` / `cache.addAll(requests)` → fetch + store.
-- `cache.delete(request)` → `true`.
-- `keys()` is **not implemented** — no way to list contents.
+- `cache.match(request)` returns a `Response` or `undefined`.
+- `cache.put(request, response)` adds a response.
+- `cache.add(request)` / `cache.addAll(requests)` fetch and store.
+- `cache.delete(request)` returns `true`.
+- `keys()` is **not implemented**, so there is no way to list contents.
+
+Consistency: reads/writes are strongly consistent. **Deletes are eventually consistent**, so a deleted entry may still return briefly.
 
-Consistency: reads/writes strongly consistent; **deletes eventually consistent** (a deleted entry may still return briefly).
+**Cannot cache:**
+- Partial responses (206), `Vary: *`, or non-`GET` methods.
+- Responses over **10 MB**. These are silently not stored.
 
-**Cannot cache:** partial responses (206), `Vary: *`, or non-`GET` methods. Responses need a cache-control header with `max-age`/`s-maxage` ≥ 1s, `public` (not `private`/`no-cache`/`no-store`), and a 2xx status — otherwise storage errors. For responses you don't control, rewrite headers with `fetchWithCache`.
+Responses also need all of the following, otherwise storage errors:
+- a cache-control header with `max-age`/`s-maxage` ≥ 1s
+- `public` (not `private`/`no-cache`/`no-store`)
+- a 2xx status
 
-**Limits per invocation:** 100 lookups, 20 insertions/deletions. Exceeding: further lookups return nothing; writes/deletes no-op. Limits are shared across edge functions in a request but separate between serverless and edge functions. Cache data is per-region (not replicated), auto-invalidated on redeploy and on `max-age`/`s-maxage` expiry.
+For responses you don't control, rewrite headers with `fetchWithCache`.
+
+**Limits per invocation:** 100 lookups, 20 insertions/deletions. Beyond these, further lookups return nothing and writes/deletes no-op. Limits are shared across edge functions in a request, but separate between serverless and edge functions.
+
+Cache data is per-region (not replicated). It is auto-invalidated on redeploy and on `max-age`/`s-maxage` expiry, and is cleared by `purgeCache` (site or tag).
 
 ## `@netlify/cache` module
 
-Install to get helpers, time constants (`MINUTE`/`HOUR`/`DAY`), and a `caches` export for local dev:
+Install to get helpers (including `purgeCache`), time constants (`MINUTE`/`HOUR`/`DAY`), and a `caches` export for local dev:
 
 ```
 npm install @netlify/cache
 ```
 
-**Local-dev workaround:** the `caches` global isn't part of Node.js. Netlify provides it in its Functions/Edge runtimes (live and under `netlify dev`), but if you run your framework's own dev server the global is undefined and throws — import it instead:
+**Local-dev workaround:** the `caches` global isn't part of Node.js. Netlify provides it in its Functions/Edge runtimes, both live and under `netlify dev`. If you run your framework's own dev server, the global is undefined and throws. Import it instead:
 
 ```ts
 import { caches } from "@netlify/cache";
 const cache = await caches.open("my-cache");
 ```
 
-Requires Netlify CLI 20.0.3+; nothing persists locally (lookups return nothing, writes/deletes don't mutate). No functional change from the global.
+This requires Netlify CLI 20.0.3+. Nothing persists locally: lookups return nothing, and writes/deletes don't mutate. There is no functional change from the global.
 
 ### `cacheHeaders(settings)` → header object
 
@@ -233,7 +254,7 @@
 
 ### `fetchWithCache(resource, options?, cacheSettings?)`
 
-Drop-in `fetch` that returns a cached response or fetches, stores, and returns. `cacheSettings` override conflicting response headers; with `swr`, background revalidation is handled automatically.
+Drop-in `fetch` that returns a cached response, or fetches, stores, and returns. `cacheSettings` override conflicting response headers. With `swr`, background revalidation is handled automatically.
 
 ```ts
 import { fetchWithCache, DAY } from "@netlify/cache";
@@ -255,7 +276,7 @@
 
 ### `needsRevalidation(response)` → boolean
 
-Only needed when calling `cache.match`/`cache.put` directly (not with `fetchWithCache`+`swr`). True when a Cache-API response is stale within its SWR window — return it, then revalidate in `context.waitUntil` and `cache.put` the fresh copy:
+Only needed when calling `cache.match`/`cache.put` directly (not with `fetchWithCache` + `swr`). It is true when a Cache-API response is stale within its SWR window. Return the stale response, then revalidate in `context.waitUntil` and `cache.put` the fresh copy:
 
 ```ts
 if (cached) {
@@ -275,21 +296,27 @@
 
 ## Durable cache
 
-Add `durable` (serverless only) so edge nodes lacking a local copy check the shared durable cache before invoking the function — fewer invocations, better cache-miss latency. Eventually consistent, so multiple regions may still invoke the function a few times per version. Co-located with the site's functions region. Works with `Netlify-Vary`, SWR, and on-demand invalidation. **Next.js:** Next Runtime 5.5.0+ uses the durable cache automatically.
+Add `durable` (serverless only) so edge nodes lacking a local copy check the shared durable cache before invoking the function. This means fewer invocations and better cache-miss latency.
+
+- It is eventually consistent, so multiple regions may still invoke the function a few times per version.
+- It is co-located with the site's functions region.
+- It works with `Netlify-Vary`, SWR, and on-demand invalidation.
+- **Next.js:** Next Runtime 5.5.0+ uses the durable cache automatically.
 
 ## Debugging with `Cache-Status`
 
-Netlify sets `Cache-Status` (RFC 9211) on all responses. Check it on a **deployed** URL. Look for values starting `"Netlify Edge"` or `"Netlify Durable"`:
+Netlify sets `Cache-Status` (RFC 9211) on all responses. Check it on a **deployed** URL. Look for values starting with `"Netlify Edge"` or `"Netlify Durable"`:
 
-- `"Netlify Edge"; fwd=miss` — nothing cached.
-- `"Netlify Edge"; hit` — served from cache.
-- `"Netlify Edge"; hit; fwd=stale` — stale served while revalidating (SWR).
-- Durable stored on miss: `"Netlify Durable"; fwd=uri-miss; stored=true; ttl=3600`.
-- Durable hit: `"Netlify Durable"; hit; ttl=1234`.
+- `"Netlify Edge"; fwd=miss` means nothing was cached.
+- `"Netlify Edge"; hit` means the response was served from cache.
+- `"Netlify Edge"; hit; fwd=stale` means a stale response was served while revalidating (SWR).
+- `"Netlify Durable"; fwd=uri-miss; stored=true; ttl=3600` means a durable miss that was then stored.
+- `"Netlify Durable"; hit; ttl=1234` means a durable hit.
 
-`ttl` negative = seconds since expiry. Each request may hit a different cache instance — without production traffic or `durable`, expect several empty caches before a hit; repeat requests to warm one.
+A negative `ttl` is the number of seconds since expiry. Each request may hit a different cache instance. Without production traffic or `durable`, expect several empty caches before a hit; repeat requests to warm one.
 
-<!-- Gaps: package/method inconsistency in @netlify/cache local-dev docs (caches import shown with cache.set, not the documented cache.put) resolved to cache.put per Cache API surface. -->
+<!-- Gaps: @netlify/cache local-dev docs show cache.set; resolved to the documented cache.put. 10 MB limit doesn't say compressed vs uncompressed size, or whether it covers add/addAll/fetchWithCache.
+purgeCache `domain` is documented both as a site selector and as a deploy target; whether a 429 rate limit surfaces as a Promise rejection is unstated. -->
 
 <!-- system: agent-context/caching/system.md — human-owned, merged by ctx-gen; edit system.md, not this section -->
 # Netlify house rules (caching)
Full technical diff · 2 changed fields

changed /description

BEFORE
"Cache dynamic and static responses on Netlify's CDN from Functions, Edge Functions, and proxies. Use when you add caching or cache-control headers to a function response, tune cache TTL or stale-while-revalidate, set up the durable cache, vary a cache key by query/header/cookie/country/language, purge or invalidate the cache by site or cache tag, use the programmatic Cache API (caches.open/match/put) or @netlify/cache helpers (fetchWithCache/cacheHeaders/getCacheStatus), speed up an expensive API call, add ISR or on-demand revalidation, or debug why a response is or isn't cached via the Cache-Status header."
AFTER
"Cache dynamic and static responses on Netlify's CDN from Functions, Edge Functions, and proxies. Use when you add caching or cache-control headers to a function response, tune cache TTL or stale-while-revalidate, set up the durable cache, vary a cache key by query/header/cookie/country/language, purge or invalidate the cache by site or cache tag, use the programmatic Cache API (caches.open/match/put) or @netlify/cache helpers (fetchWithCache/cacheHeaders/getCacheStatus/purgeCache), speed up an expensive API call, add ISR or on-demand revalidation, or debug why a response is or isn't cached via the Cache-Status header."

changed /skill_md_contents

BEFORE
"---\nname: netlify-caching\ndescription: Cache dynamic and static responses on Netlify's CDN from Functions, Edge Functions, and proxies. Use when you add caching or cache-control headers to a function response, tune cache TTL or stale-while-revalidate, set up the durable cache, vary a cache key by query/header/cookie/country/language, purge or invalidate the cache by site or cache tag, use the programmatic Cache API (caches.open/match/put) or @netlify/cache helpers (fetchWithCache/cacheHeaders/getCacheStatus), speed up an expensive API call, add ISR or on-demand revalidation, or debug why a response is or isn't cached via the Cache-Status header.\n---\n\n# Netlify caching\n\n## Cache-control header to reach for\n\nDynamic responses (Functions, Edge Functions, proxies) are **NOT cached by default** — you must opt in. Set `Netlify-CDN-Cache-Control` on the response:\n\n```ts\nimport type { Context } from \"@netlify/functions\";\n\nexport default async (req: Request, context: Context) => {\n  return new Response(\"Hello world\", {\n    headers: {\n      'Netlify-CDN-Cache-Control': 'public, durable, max-age=60, stale-while-revalidate=120'\n    }\n  });\n};\n```\n\nHeader choice (most specific wins; `CDN-Cache-Control`/`Cache-Control` always pass downstream):\n- `Netlify-CDN-Cache-Control` — Netlify CDN only. **Reach for this.**\n- `CDN-Cache-Control` — all CDNs that support it.\n- `Cache-Control` — any CDN or the browser.\n\n**Legacy path to avoid:** On-demand Builders do **not** support these headers or `Netlify-Vary` — they use a TTL pattern and key on URL path only. Don't reach for ODBs in new code.\n\n## Footguns (read first)\n\n- **Only `GET` is cached.** POST/PUT/etc. are never cached regardless of headers — expose cacheable data on a GET route (inputs in the URL or query string).\n- **`netlify dev` does not emulate the CDN cache.** A local cache miss every time is expected. Verify caching on a deployed URL (Deploy Preview or production) via its `Cache-Status` header.\n- **Without `Netlify-Vary: query=...`, the full query string is the cache key** — every distinct query string (`utm_*`, `fbclid`, …) is a separate cache entry. Enumerate only the params that change the response.\n- **Static assets are fresh for up to a year** — a shorter `max-age` is ignored. They change only on a new deploy or manual purge.\n- **basic-auth on ANY page disables caching for the ENTIRE site.**\n- **`durable` is serverless-only** — it has no effect on Edge Function responses.\n- Never opt sensitive content out of automatic invalidation — it can stay publicly cached after deploys/firewall changes.\n\n## Directives\n\n- `public` cache it / `private` browser-only, not Netlify's shared cache / `no-store` don't cache.\n- `s-maxage=N` seconds in Netlify's shared cache (overrides `max-age` there).\n- `max-age=N` seconds in any cache.\n- `stale-while-revalidate=N` serve stale for N seconds after expiry while revalidating in background.\n- `durable` (serverless only) store in Netlify's durable cache so other edge nodes reuse it instead of re-invoking the function.\n\nDefaults when no header is set — static: `Netlify-CDN-Cache-Control: public, s-maxage=31536000, must-revalidate`; dynamic: `Cache-Control: public, max-age=0, must-revalidate`.\n\n## Cache key variation — `Netlify-Vary`\n\nComma-delimited instructions on the response; pipe-delimited value lists:\n\n```\nNetlify-Vary: query=item_id|page, country=es+de|us, cookie=ab_test|is_logged_in\n```\n\n- `query=a|b` subset, or bare `query` for all params. Keys case-sensitive; param order irrelevant.\n- `header=Device-Type|App-Version` — custom + most standard headers.\n- `language=en|es+pt` — `+` groups; checked against `Accept-Language` with quality weighting.\n- `country=us|es+pt` — GeoIP, ISO 3166-1 two-letter codes; `+` groups.\n- `cookie=ab_test|is_logged_in` — target specific keys, not the whole `Cookie` header.\n\n**Cannot vary by header on:** `Accept*`, `Cache-Control`, `Connection`, `Content-Length`, `Cookie`, `Host`, `If-*`, `Range`, `Referer`, `Upgrade`, `User-Agent`. For language/cookie/format use `Vary: Accept-Language`/`Vary: Cookie` or the specific `Netlify-Vary` instruction.\n\n**Consistency rule:** a URL must return the same `Netlify-Vary` on every response — the first cached response's instructions win and later ones are ignored. `Netlify-Vary` + standard `Vary` are both respected (use `Vary` for format/encoding, and to pass instructions to an upstream CDN like Cloudflare).\n\n## Cache tags & opt-out\n\nTag responses for taggable purging:\n\n```\nNetlify-Cache-Tag: tag1,tag2,tag3\n```\n\n- `Netlify-Cache-Tag` (Netlify CDN) wins over `Cache-Tag` (passed downstream). Some providers strip `Cache-Tag` — set both when proxying through them.\n- Constraints: case-insensitive, UTF-8 only, ≤1024 chars/tag, ≤500 tags/response.\n\nOpt a response out of automatic atomic-deploy invalidation with `Netlify-Cache-ID` (comma-separated; auto-registered as cache tags for purging; separate 500-ID limit):\n\n```\nNetlify-Cache-ID: cms-proxy,product,image\n```\n\nAfter opting out, purge on-demand after relevant changes (e.g. redirect/proxy or function changes behind a `Netlify-Cache-ID`).\n\n## On-demand invalidation (purge)\n\nPurge from a **deployed function** with `purgeCache` (site ID is passed automatically):\n\n```ts\nimport { purgeCache } from \"@netlify/functions\";\n\nexport default async () => {\n  await purgeCache(); // no args = purge everything for the site\n  return new Response(\"Purged!\", { status: 202 });\n};\n```\n\nPurge by tag, optionally targeting a deploy/subdomain:\n\n```ts\nimport { purgeCache } from \"@netlify/functions\";\n\nexport default async (req: Request) => {\n  const cacheTag = new URL(req.url).searchParams.get(\"tag\");\n  if (!cacheTag) return;\n  await purgeCache({\n    tags: [cacheTag],\n    deployAlias: \"deploy-preview-11\",\n    domain: \"early-access.company.com\",\n  });\n  return new Response(\"Purged!\", { status: 202 });\n};\n```\n\n**Ambient credentials only work inside a deployed function.** From CI, local scripts, or the build, pass `token` (a personal access token read from an env var — never hardcoded) and `siteID`.\n\n**Lambda-compatible functions** use the legacy `module.exports.handler = async (event, context) => {…}` signature and must pass `context.clientContext.custom.purge_api_token`:\n\n```ts\nimport { purgeCache } from \"@netlify/functions\";\n\nmodule.exports.handler = async (event, context) => {\n  const token = context.clientContext.custom.purge_api_token;\n  await purgeCache({ tags: [\"tag1\", \"tag2\"], token });\n  return { body: \"Purged!\", statusCode: 202 };\n};\n```\n\nDirect API (from outside a function) — `POST https://api.netlify.com/api/v1/purge` with `Authorization: Bearer <personal_access_token>` and `Content-Type: application/json`:\n\n```sh\ncurl -X POST \\\n  -H \"Content-Type: application/json\" \\\n  -H \"Authorization: Bearer <personal_access_token>\" \\\n  --data '{\"site_slug\": \"mysitename\", \"cache_tags\": [\"news\"], \"deploy_alias\": \"deploy-preview-11\", \"domain\": \"early-access.company.com\"}' \\\n  'https://api.netlify.com/api/v1/purge'\n```\n\n- Purge by site: `site_id` or `site_slug`. By tag: `cache_tags` + site. Omitting `cache_tags` purges the whole site; an **empty** `cache_tags` list purges NOTHING.\n- Identifier mapping: in the UI (Project configuration > General > Project details), **Project ID** = `site_id`, **Project name** = `site_slug`. See https://docs.netlify.com/api-and-cli-guides/api-guides/get-started-with-api#get-site.\n- **Rate limit:** each tag or site can be purged only twice per 5s — exceeding returns `429`.\n\n## Cache API (`caches` global)\n\nProgrammatic read/write of HTTP responses from Functions/Edge Functions. Use for caching individual components of a route or arbitrary fetches, alongside header-based route caching.\n\n**Scope rule:** `caches.open()` anywhere, but `match`/`put`/`delete` **only inside the request handler** — doing them at module/global scope throws.\n\n```ts\nimport type { Config, Context } from \"@netlify/functions\";\n\nconst cache = await caches.open(\"my-cache\"); // ok in global scope\n\nexport default async (req: Request, context: Context) => {\n  const request = new Request(\"https://example.com/expensive-api\");\n  const cached = await cache.match(request);\n  if (cached) return cached;\n\n  const fresh = await fetch(request);\n  if (fresh.ok) {\n    cache.put(request, fresh.clone()).catch((error) => {\n      console.error(\"Failed to add to the cache:\", error);\n    });\n  }\n  return fresh;\n};\n\nexport const config: Config = { path: \"/cache-api-example\" };\n```\n\n`CacheStorage` subset:\n- `caches.match(request)` → `Response` from any cache, or `undefined`.\n- `caches.open(name)` → `Cache`. Distinct names fragment the cache and lower hit ratio — use few, meaningful names.\n\n`Cache` methods (all require `caches.open()`):\n- `cache.match(request)` → `Response` | `undefined`.\n- `cache.put(request, response)` → adds a response.\n- `cache.add(request)` / `cache.addAll(requests)` → fetch + store.\n- `cache.delete(request)` → `true`.\n- `keys()` is **not implemented** — no way to list contents.\n\nConsistency: reads/writes strongly consistent; **deletes eventually consistent** (a deleted entry may still return briefly).\n\n**Cannot cache:** partial responses (206), `Vary: *`, or non-`GET` methods. Responses need a cache-control header with `max-age`/`s-maxage` ≥ 1s, `public` (not `private`/`no-cache`/`no-store`), and a 2xx status — otherwise storage errors. For responses you don't control, rewrite headers with `fetchWithCache`.\n\n**Limits per invocation:** 100 lookups, 20 insertions/deletions. Exceeding: further lookups return nothing; writes/deletes no-op. Limits are shared across edge functions in a request but separate between serverless and edge functions. Cache data is per-region (not replicated), auto-invalidated on redeploy and on `max-age`/`s-maxage` expiry.\n\n## `@netlify/cache` module\n\nInstall to get helpers, time constants (`MINUTE`/`HOUR`/`DAY`), and a `caches` export for local dev:\n\n```\nnpm install @netlify/cache\n```\n\n**Local-dev workaround:** the `caches` global isn't part of Node.js. Netlify provides it in its Functions/Edge runtimes (live and under `netlify dev`), but if you run your framework's own dev server the global is undefined and throws — import it instead:\n\n```ts\nimport { caches } from \"@netlify/cache\";\nconst cache = await caches.open(\"my-cache\");\n```\n\nRequires Netlify CLI 20.0.3+; nothing persists locally (lookups return nothing, writes/deletes don't mutate). No functional change from the global.\n\n### `cacheHeaders(settings)` → header object\n\n```ts\nimport { cacheHeaders, DAY } from \"@netlify/cache\";\n\nconst headers = {\n  \"x-custom-header\": \"some value\",\n  ...cacheHeaders({\n    ttl: 2 * DAY,          // s-maxage\n    swr: HOUR,             // stale-while-revalidate\n    durable: true,\n    tags: [\"product\", \"sale\"],\n    overrideDeployRevalidation: [\"tag\"], // opt out of atomic-deploy invalidation\n    vary: {\n      cookie: [\"ab_test_name\", \"ab_test_bucket\"],\n      query: [\"item_id\", \"page\"], // or true for all\n      country: [\"us\", [\"es\", \"pt\"]], // nested = OR\n      language: [\"en\"],\n      header: [\"Device-Type\"],\n    },\n  }),\n};\n```\n\nFor only generic (non-Netlify) headers, use the `cdn-cache-control` npm module instead.\n\n### `fetchWithCache(resource, options?, cacheSettings?)`\n\nDrop-in `fetch` that returns a cached response or fetches, stores, and returns. `cacheSettings` override conflicting response headers; with `swr`, background revalidation is handled automatically.\n\n```ts\nimport { fetchWithCache, DAY } from \"@netlify/cache\";\n\nconst response = await fetchWithCache(\"https://example.com/expensive-api\", {\n  ttl: 2 * DAY,\n  tags: [\"product\", \"sale\"],\n  vary: { cookie: [\"ab_test_name\"], query: [\"item_id\", \"page\"] },\n});\n```\n\n### `getCacheStatus(response | headers | headerString)`\n\nReturns `{ hit, caches: { durable: { hit, stale, stored, ttl }, edge: { hit, stale } } }`.\n\n```ts\nconst { hit, edge, durable } = getCacheStatus(response);\n```\n\n### `needsRevalidation(response)` → boolean\n\nOnly needed when calling `cache.match`/`cache.put` directly (not with `fetchWithCache`+`swr`). True when a Cache-API response is stale within its SWR window — return it, then revalidate in `context.waitUntil` and `cache.put` the fresh copy:\n\n```ts\nif (cached) {\n  if (needsRevalidation(cached)) {\n    context.waitUntil(\n      fetch(request).then((fresh) => {\n        const response = new Response(fresh.body, {\n          headers: { ...Object.fromEntries(fresh.headers), ...cacheHeaders({ ttl: MINUTE, swr: HOUR }) },\n        });\n        return cache.put(request, response);\n      })\n    );\n  }\n  return cached;\n}\n```\n\n## Durable cache\n\nAdd `durable` (serverless only) so edge nodes lacking a local copy check the shared durable cache before invoking the function — fewer invocations, better cache-miss latency. Eventually consistent, so multiple regions may still invoke the function a few times per version. Co-located with the site's functions region. Works with `Netlify-Vary`, SWR, and on-demand invalidation. **Next.js:** Next Runtime 5.5.0+ uses the durable cache automatically.\n\n## Debugging with `Cache-Status`\n\nNetlify sets `Cache-Status` (RFC 9211) on all responses. Check it on a **deployed** URL. Look for values starting `\"Netlify Edge\"` or `\"Netlify Durable\"`:\n\n- `\"Netlify Edge\"; fwd=miss` — nothing cached.\n- `\"Netlify Edge\"; hit` — served from cache.\n- `\"Netlify Edge\"; hit; fwd=stale` — stale served while revalidating (SWR).\n- Durable stored on miss: `\"Netlify Durable\"; fwd=uri-miss; stored=true; ttl=3600`.\n- Durable hit: `\"Netlify Durable\"; hit; ttl=1234`.\n\n`ttl` negative = seconds since expiry. Each request may hit a different cache instance — without production traffic or `durable`, expect several empty caches before a hit; repeat requests to warm one.\n\n<!-- Gaps: package/method inconsistency in @netlify/cache local-dev docs (caches import shown with cache.set, not the documented cache.put) resolved to cache.put per Cache API surface. -->\n\n<!-- system: agent-context/caching/system.md — human-owned, merged by ctx-gen; edit system.md, not this section -->\n# Netlify house rules (caching)\n\nThese are org conventions, not docs facts — merged into the rendered skill by\nctx-gen and never generated. Owned by the skills maintainer.\n\n1. Only `GET` responses are cached by the CDN. `POST`/`PUT`/etc. are never\n   cached regardless of headers — expose cacheable data on a `GET` route\n   (put the inputs in the URL or query string).\n2. Without `Netlify-Vary: query=...`, the full query string is the cache key —\n   every distinct query string (`utm_*`, `fbclid`, ...) is a separate cache\n   entry. Enumerate only the params that actually change the response.\n3. `netlify dev` does not emulate the CDN cache — a cache miss every time\n   locally is expected, not a bug. Verify caching behavior on a deployed URL\n   (Deploy Preview or production) via its `Cache-Status` header.\n4. `purgeCache()` has ambient credentials only inside a deployed function.\n   From CI, local scripts, or the build, pass `token` (a personal access\n   token read from an env var, never hardcoded) and `siteID`.\n"
AFTER
"---\nname: netlify-caching\ndescription: Cache dynamic and static responses on Netlify's CDN from Functions, Edge Functions, and proxies. Use when you add caching or cache-control headers to a function response, tune cache TTL or stale-while-revalidate, set up the durable cache, vary a cache key by query/header/cookie/country/language, purge or invalidate the cache by site or cache tag, use the programmatic Cache API (caches.open/match/put) or @netlify/cache helpers (fetchWithCache/cacheHeaders/getCacheStatus/purgeCache), speed up an expensive API call, add ISR or on-demand revalidation, or debug why a response is or isn't cached via the Cache-Status header.\n---\n\n# Netlify caching\n\n## Cache-control header to reach for\n\nDynamic responses (Functions, Edge Functions, proxies) are **NOT cached by default**. You must opt in. Set `Netlify-CDN-Cache-Control` on the response:\n\n```ts\nimport type { Context } from \"@netlify/functions\";\n\nexport default async (req: Request, context: Context) => {\n  return new Response(\"Hello world\", {\n    headers: {\n      'Netlify-CDN-Cache-Control': 'public, durable, max-age=60, stale-while-revalidate=120'\n    }\n  });\n};\n```\n\nHeader choice (most specific wins; `CDN-Cache-Control`/`Cache-Control` always pass downstream):\n- `Netlify-CDN-Cache-Control` applies to the Netlify CDN only. **Reach for this.**\n- `CDN-Cache-Control` applies to all CDNs that support it.\n- `Cache-Control` applies to any CDN or the browser.\n\n**Legacy path to avoid:** On-demand Builders do **not** support these headers or `Netlify-Vary`. They use a TTL pattern and key on URL path only. Don't reach for ODBs in new code.\n\n## Footguns (read first)\n\n- **Static assets are fresh for up to a year.** A shorter `max-age` is ignored. They change only on a new deploy or manual purge.\n- **basic-auth on ANY page disables caching for the ENTIRE site.**\n- **`durable` is serverless-only.** It has no effect on Edge Function responses.\n- **Cache API silently drops responses over 10 MB.** `cache.put()` doesn't store them and later lookups miss. Compress the content or split it across multiple entries.\n- Never opt sensitive content out of automatic invalidation. It can stay publicly cached after deploys/firewall changes.\n\n## Directives\n\n- `public` caches the response. `private` caches it in the browser only, not in Netlify's shared cache. `no-store` prevents caching.\n- `s-maxage=N` sets seconds in Netlify's shared cache (overrides `max-age` there).\n- `max-age=N` sets seconds in any cache.\n- `stale-while-revalidate=N` serves stale for N seconds after expiry while revalidating in the background.\n- `durable` (serverless only) stores the response in Netlify's durable cache so other edge nodes reuse it instead of re-invoking the function.\n\nDefaults when no header is set:\n- Static: `Netlify-CDN-Cache-Control: public, s-maxage=31536000, must-revalidate`\n- Dynamic: `Cache-Control: public, max-age=0, must-revalidate`\n\n## Cache key variation — `Netlify-Vary`\n\nComma-delimited instructions on the response; pipe-delimited value lists:\n\n```\nNetlify-Vary: query=item_id|page, country=es+de|us, cookie=ab_test|is_logged_in\n```\n\n- `query=a|b` varies on a subset; bare `query` varies on all params. Keys are case-sensitive; param order is irrelevant.\n- `header=Device-Type|App-Version` supports custom and most standard headers.\n- `language=en|es+pt` uses `+` for groups. It is checked against `Accept-Language` with quality weighting.\n- `country=us|es+pt` uses GeoIP with ISO 3166-1 two-letter codes; `+` groups.\n- `cookie=ab_test|is_logged_in` targets specific keys, not the whole `Cookie` header.\n\n**Cannot vary by header on:** `Accept*`, `Cache-Control`, `Connection`, `Content-Length`, `Cookie`, `Host`, `If-*`, `Range`, `Referer`, `Upgrade`, `User-Agent`. For language/cookie/format, use `Vary: Accept-Language`/`Vary: Cookie` or the specific `Netlify-Vary` instruction.\n\n**Consistency rule:** a URL must return the same `Netlify-Vary` on every response. The first cached response's instructions win and later ones are ignored.\n\n`Netlify-Vary` and standard `Vary` are both respected. Use `Vary` for format/encoding, and to pass instructions to an upstream CDN like Cloudflare.\n\n## Cache tags & opt-out\n\nTag responses for taggable purging:\n\n```\nNetlify-Cache-Tag: tag1,tag2,tag3\n```\n\n- `Netlify-Cache-Tag` (Netlify CDN) wins over `Cache-Tag` (passed downstream). Some providers strip `Cache-Tag`, so set both when proxying through them.\n- Constraints: case-insensitive, UTF-8 only, ≤1024 chars/tag, ≤500 tags/response.\n\nOpt a response out of automatic atomic-deploy invalidation with `Netlify-Cache-ID`. Values are comma-separated, auto-registered as cache tags for purging, and have a separate 500-ID limit:\n\n```\nNetlify-Cache-ID: cms-proxy,product,image\n```\n\nAfter opting out, purge on demand after relevant changes, e.g. redirect/proxy or function changes behind a `Netlify-Cache-ID`.\n\n## On-demand invalidation (purge)\n\nPurge from a **deployed function or edge function** with `purgeCache` from `@netlify/cache`. The site and purge token are configured automatically. Purging covers everything cached for the site, including Cache API entries:\n\n```ts\nimport { purgeCache } from \"@netlify/cache\";\n\nexport default async () => {\n  await purgeCache(); // no args = purge everything for the site\n  return new Response(\"Purged!\", { status: 202 });\n};\n```\n\nPurge by tag, optionally targeting a deploy/subdomain:\n\n```ts\nimport { purgeCache } from \"@netlify/cache\";\n\nexport default async (req: Request) => {\n  const cacheTag = new URL(req.url).searchParams.get(\"tag\");\n  if (!cacheTag) return;\n  await purgeCache({\n    tags: [cacheTag],\n    deployAlias: \"deploy-preview-11\",\n    domain: \"early-access.company.com\",\n  });\n  return new Response(\"Purged!\", { status: 202 });\n};\n```\n\n`purgeCache(options?)` options:\n- `tags`: tags to purge. Omit to purge the whole site. Tag purges apply to all deploys unless you target one.\n- `deployAlias` (e.g. `deploy-preview-11`): targets that alias on the primary domain.\n- `domain` (e.g. `early-access.company.com`): targets the published production deploy on that domain.\n- `siteID` / `siteSlug`: the site to purge. Use only one. Defaults to the request's site.\n- `token` (defaults to the token Netlify provides) and `userAgent`.\n- Returns a Promise that resolves once the purge is **accepted** (not propagated). It rejects if the API call fails.\n\n**Lambda-compatible functions** use the legacy `module.exports.handler = async (event, context) => {…}` signature. They must pass `context.clientContext.custom.purge_api_token`:\n\n```ts\nimport { purgeCache } from \"@netlify/cache\";\n\nmodule.exports.handler = async (event, context) => {\n  const token = context.clientContext.custom.purge_api_token;\n  await purgeCache({ tags: [\"tag1\", \"tag2\"], token });\n  return { body: \"Purged!\", statusCode: 202 };\n};\n```\n\nDirect API (from outside a function): `POST https://api.netlify.com/api/v1/purge` with `Authorization: Bearer <personal_access_token>` and `Content-Type: application/json`:\n\n```sh\ncurl -X POST \\\n  -H \"Content-Type: application/json\" \\\n  -H \"Authorization: Bearer <personal_access_token>\" \\\n  --data '{\"site_slug\": \"mysitename\", \"cache_tags\": [\"news\"], \"deploy_alias\": \"deploy-preview-11\", \"domain\": \"early-access.company.com\"}' \\\n  'https://api.netlify.com/api/v1/purge'\n```\n\n- Purge by site: pass `site_id` or `site_slug`.\n- Purge by tag: pass `cache_tags` plus the site.\n- Omitting `cache_tags` purges the whole site. An **empty** `cache_tags` list purges NOTHING.\n- Identifier mapping: in the UI (Project configuration > General > Project details > Project information), **Project ID** = `site_id` and **Project name** = `site_slug`. See https://docs.netlify.com/api-and-cli-guides/api-guides/get-started-with-api#get-site.\n- **Rate limit:** each tag or site can be purged only twice per 5s. Exceeding it returns `429`.\n\n## Cache API (`caches` global)\n\nProgrammatic read/write of HTTP responses from Functions/Edge Functions. Use it to cache individual components of a route or arbitrary fetches, alongside header-based route caching.\n\n**Scope rule:** call `caches.open()` anywhere, but call `match`/`put`/`delete` **only inside the request handler**. Doing them at module/global scope throws.\n\n```ts\nimport type { Config, Context } from \"@netlify/functions\";\n\nconst cache = await caches.open(\"my-cache\"); // ok in global scope\n\nexport default async (req: Request, context: Context) => {\n  const request = new Request(\"https://example.com/expensive-api\");\n  const cached = await cache.match(request);\n  if (cached) return cached;\n\n  const fresh = await fetch(request);\n  if (fresh.ok) {\n    cache.put(request, fresh.clone()).catch((error) => {\n      console.error(\"Failed to add to the cache:\", error);\n    });\n  }\n  return fresh;\n};\n\nexport const config: Config = { path: \"/cache-api-example\" };\n```\n\n`CacheStorage` subset:\n- `caches.match(request)` returns a `Response` from any cache, or `undefined`.\n- `caches.open(name)` returns a `Cache`. Distinct names fragment the cache and lower the hit ratio, so use few, meaningful names.\n\n`Cache` methods (all require `caches.open()`):\n- `cache.match(request)` returns a `Response` or `undefined`.\n- `cache.put(request, response)` adds a response.\n- `cache.add(request)` / `cache.addAll(requests)` fetch and store.\n- `cache.delete(request)` returns `true`.\n- `keys()` is **not implemented**, so there is no way to list contents.\n\nConsistency: reads/writes are strongly consistent. **Deletes are eventually consistent**, so a deleted entry may still return briefly.\n\n**Cannot cache:**\n- Partial responses (206), `Vary: *`, or non-`GET` methods.\n- Responses over **10 MB**. These are silently not stored.\n\nResponses also need all of the following, otherwise storage errors:\n- a cache-control header with `max-age`/`s-maxage` ≥ 1s\n- `public` (not `private`/`no-cache`/`no-store`)\n- a 2xx status\n\nFor responses you don't control, rewrite headers with `fetchWithCache`.\n\n**Limits per invocation:** 100 lookups, 20 insertions/deletions. Beyond these, further lookups return nothing and writes/deletes no-op. Limits are shared across edge functions in a request, but separate between serverless and edge functions.\n\nCache data is per-region (not replicated). It is auto-invalidated on redeploy and on `max-age`/`s-maxage` expiry, and is cleared by `purgeCache` (site or tag).\n\n## `@netlify/cache` module\n\nInstall to get helpers (including `purgeCache`), time constants (`MINUTE`/`HOUR`/`DAY`), and a `caches` export for local dev:\n\n```\nnpm install @netlify/cache\n```\n\n**Local-dev workaround:** the `caches` global isn't part of Node.js. Netlify provides it in its Functions/Edge runtimes, both live and under `netlify dev`. If you run your framework's own dev server, the global is undefined and throws. Import it instead:\n\n```ts\nimport { caches } from \"@netlify/cache\";\nconst cache = await caches.open(\"my-cache\");\n```\n\nThis requires Netlify CLI 20.0.3+. Nothing persists locally: lookups return nothing, and writes/deletes don't mutate. There is no functional change from the global.\n\n### `cacheHeaders(settings)` → header object\n\n```ts\nimport { cacheHeaders, DAY } from \"@netlify/cache\";\n\nconst headers = {\n  \"x-custom-header\": \"some value\",\n  ...cacheHeaders({\n    ttl: 2 * DAY,          // s-maxage\n    swr: HOUR,             // stale-while-revalidate\n    durable: true,\n    tags: [\"product\", \"sale\"],\n    overrideDeployRevalidation: [\"tag\"], // opt out of atomic-deploy invalidation\n    vary: {\n      cookie: [\"ab_test_name\", \"ab_test_bucket\"],\n      query: [\"item_id\", \"page\"], // or true for all\n      country: [\"us\", [\"es\", \"pt\"]], // nested = OR\n      language: [\"en\"],\n      header: [\"Device-Type\"],\n    },\n  }),\n};\n```\n\nFor only generic (non-Netlify) headers, use the `cdn-cache-control` npm module instead.\n\n### `fetchWithCache(resource, options?, cacheSettings?)`\n\nDrop-in `fetch` that returns a cached response, or fetches, stores, and returns. `cacheSettings` override conflicting response headers. With `swr`, background revalidation is handled automatically.\n\n```ts\nimport { fetchWithCache, DAY } from \"@netlify/cache\";\n\nconst response = await fetchWithCache(\"https://example.com/expensive-api\", {\n  ttl: 2 * DAY,\n  tags: [\"product\", \"sale\"],\n  vary: { cookie: [\"ab_test_name\"], query: [\"item_id\", \"page\"] },\n});\n```\n\n### `getCacheStatus(response | headers | headerString)`\n\nReturns `{ hit, caches: { durable: { hit, stale, stored, ttl }, edge: { hit, stale } } }`.\n\n```ts\nconst { hit, edge, durable } = getCacheStatus(response);\n```\n\n### `needsRevalidation(response)` → boolean\n\nOnly needed when calling `cache.match`/`cache.put` directly (not with `fetchWithCache` + `swr`). It is true when a Cache-API response is stale within its SWR window. Return the stale response, then revalidate in `context.waitUntil` and `cache.put` the fresh copy:\n\n```ts\nif (cached) {\n  if (needsRevalidation(cached)) {\n    context.waitUntil(\n      fetch(request).then((fresh) => {\n        const response = new Response(fresh.body, {\n          headers: { ...Object.fromEntries(fresh.headers), ...cacheHeaders({ ttl: MINUTE, swr: HOUR }) },\n        });\n        return cache.put(request, response);\n      })\n    );\n  }\n  return cached;\n}\n```\n\n## Durable cache\n\nAdd `durable` (serverless only) so edge nodes lacking a local copy check the shared durable cache before invoking the function. This means fewer invocations and better cache-miss latency.\n\n- It is eventually consistent, so multiple regions may still invoke the function a few times per version.\n- It is co-located with the site's functions region.\n- It works with `Netlify-Vary`, SWR, and on-demand invalidation.\n- **Next.js:** Next Runtime 5.5.0+ uses the durable cache automatically.\n\n## Debugging with `Cache-Status`\n\nNetlify sets `Cache-Status` (RFC 9211) on all responses. Check it on a **deployed** URL. Look for values starting with `\"Netlify Edge\"` or `\"Netlify Durable\"`:\n\n- `\"Netlify Edge\"; fwd=miss` means nothing was cached.\n- `\"Netlify Edge\"; hit` means the response was served from cache.\n- `\"Netlify Edge\"; hit; fwd=stale` means a stale response was served while revalidating (SWR).\n- `\"Netlify Durable\"; fwd=uri-miss; stored=true; ttl=3600` means a durable miss that was then stored.\n- `\"Netlify Durable\"; hit; ttl=1234` means a durable hit.\n\nA negative `ttl` is the number of seconds since expiry. Each request may hit a different cache instance. Without production traffic or `durable`, expect several empty caches before a hit; repeat requests to warm one.\n\n<!-- Gaps: @netlify/cache local-dev docs show cache.set; resolved to the documented cache.put. 10 MB limit doesn't say compressed vs uncompressed size, or whether it covers add/addAll/fetchWithCache.\npurgeCache `domain` is documented both as a site selector and as a deploy target; whether a 429 rate limit surfaces as a Promise rejection is unstated. -->\n\n<!-- system: agent-context/caching/system.md — human-owned, merged by ctx-gen; edit system.md, not this section -->\n# Netlify house rules (caching)\n\nThese are org conventions, not docs facts — merged into the rendered skill by\nctx-gen and never generated. Owned by the skills maintainer.\n\n1. Only `GET` responses are cached by the CDN. `POST`/`PUT`/etc. are never\n   cached regardless of headers — expose cacheable data on a `GET` route\n   (put the inputs in the URL or query string).\n2. Without `Netlify-Vary: query=...`, the full query string is the cache key —\n   every distinct query string (`utm_*`, `fbclid`, ...) is a separate cache\n   entry. Enumerate only the params that actually change the response.\n3. `netlify dev` does not emulate the CDN cache — a cache miss every time\n   locally is expected, not a bug. Verify caching behavior on a deployed URL\n   (Deploy Preview or production) via its `Cache-Status` header.\n4. `purgeCache()` has ambient credentials only inside a deployed function.\n   From CI, local scripts, or the build, pass `token` (a personal access\n   token read from an env var, never hardcoded) and `siteID`.\n"
Full snapshot data
{
  "description": "Cache dynamic and static responses on Netlify's CDN from Functions, Edge Functions, and proxies. Use when you add caching or cache-control headers to a function response, tune cache TTL or stale-while-revalidate, set up the durable cache, vary a cache key by query/header/cookie/country/language, purge or invalidate the cache by site or cache tag, use the programmatic Cache API (caches.open/match/put) or @netlify/cache helpers (fetchWithCache/cacheHeaders/getCacheStatus/purgeCache), speed up an expensive API call, add ISR or on-demand revalidation, or debug why a response is or isn't cached via the Cache-Status header.",
  "included_files": [],
  "name": "netlify-caching",
  "skill_md_contents": "---\nname: netlify-caching\ndescription: Cache dynamic and static responses on Netlify's CDN from Functions, Edge Functions, and proxies. Use when you add caching or cache-control headers to a function response, tune cache TTL or stale-while-revalidate, set up the durable cache, vary a cache key by query/header/cookie/country/language, purge or invalidate the cache by site or cache tag, use the programmatic Cache API (caches.open/match/put) or @netlify/cache helpers (fetchWithCache/cacheHeaders/getCacheStatus/purgeCache), speed up an expensive API call, add ISR or on-demand revalidation, or debug why a response is or isn't cached via the Cache-Status header.\n---\n\n# Netlify caching\n\n## Cache-control header to reach for\n\nDynamic responses (Functions, Edge Functions, proxies) are **NOT cached by default**. You must opt in. Set `Netlify-CDN-Cache-Control` on the response:\n\n```ts\nimport type { Context } from \"@netlify/functions\";\n\nexport default async (req: Request, context: Context) => {\n  return new Response(\"Hello world\", {\n    headers: {\n      'Netlify-CDN-Cache-Control': 'public, durable, max-age=60, stale-while-revalidate=120'\n    }\n  });\n};\n```\n\nHeader choice (most specific wins; `CDN-Cache-Control`/`Cache-Control` always pass downstream):\n- `Netlify-CDN-Cache-Control` applies to the Netlify CDN only. **Reach for this.**\n- `CDN-Cache-Control` applies to all CDNs that support it.\n- `Cache-Control` applies to any CDN or the browser.\n\n**Legacy path to avoid:** On-demand Builders do **not** support these headers or `Netlify-Vary`. They use a TTL pattern and key on URL path only. Don't reach for ODBs in new code.\n\n## Footguns (read first)\n\n- **Static assets are fresh for up to a year.** A shorter `max-age` is ignored. They change only on a new deploy or manual purge.\n- **basic-auth on ANY page disables caching for the ENTIRE site.**\n- **`durable` is serverless-only.** It has no effect on Edge Function responses.\n- **Cache API silently drops responses over 10 MB.** `cache.put()` doesn't store them and later lookups miss. Compress the content or split it across multiple entries.\n- Never opt sensitive content out of automatic invalidation. It can stay publicly cached after deploys/firewall changes.\n\n## Directives\n\n- `public` caches the response. `private` caches it in the browser only, not in Netlify's shared cache. `no-store` prevents caching.\n- `s-maxage=N` sets seconds in Netlify's shared cache (overrides `max-age` there).\n- `max-age=N` sets seconds in any cache.\n- `stale-while-revalidate=N` serves stale for N seconds after expiry while revalidating in the background.\n- `durable` (serverless only) stores the response in Netlify's durable cache so other edge nodes reuse it instead of re-invoking the function.\n\nDefaults when no header is set:\n- Static: `Netlify-CDN-Cache-Control: public, s-maxage=31536000, must-revalidate`\n- Dynamic: `Cache-Control: public, max-age=0, must-revalidate`\n\n## Cache key variation — `Netlify-Vary`\n\nComma-delimited instructions on the response; pipe-delimited value lists:\n\n```\nNetlify-Vary: query=item_id|page, country=es+de|us, cookie=ab_test|is_logged_in\n```\n\n- `query=a|b` varies on a subset; bare `query` varies on all params. Keys are case-sensitive; param order is irrelevant.\n- `header=Device-Type|App-Version` supports custom and most standard headers.\n- `language=en|es+pt` uses `+` for groups. It is checked against `Accept-Language` with quality weighting.\n- `country=us|es+pt` uses GeoIP with ISO 3166-1 two-letter codes; `+` groups.\n- `cookie=ab_test|is_logged_in` targets specific keys, not the whole `Cookie` header.\n\n**Cannot vary by header on:** `Accept*`, `Cache-Control`, `Connection`, `Content-Length`, `Cookie`, `Host`, `If-*`, `Range`, `Referer`, `Upgrade`, `User-Agent`. For language/cookie/format, use `Vary: Accept-Language`/`Vary: Cookie` or the specific `Netlify-Vary` instruction.\n\n**Consistency rule:** a URL must return the same `Netlify-Vary` on every response. The first cached response's instructions win and later ones are ignored.\n\n`Netlify-Vary` and standard `Vary` are both respected. Use `Vary` for format/encoding, and to pass instructions to an upstream CDN like Cloudflare.\n\n## Cache tags & opt-out\n\nTag responses for taggable purging:\n\n```\nNetlify-Cache-Tag: tag1,tag2,tag3\n```\n\n- `Netlify-Cache-Tag` (Netlify CDN) wins over `Cache-Tag` (passed downstream). Some providers strip `Cache-Tag`, so set both when proxying through them.\n- Constraints: case-insensitive, UTF-8 only, ≤1024 chars/tag, ≤500 tags/response.\n\nOpt a response out of automatic atomic-deploy invalidation with `Netlify-Cache-ID`. Values are comma-separated, auto-registered as cache tags for purging, and have a separate 500-ID limit:\n\n```\nNetlify-Cache-ID: cms-proxy,product,image\n```\n\nAfter opting out, purge on demand after relevant changes, e.g. redirect/proxy or function changes behind a `Netlify-Cache-ID`.\n\n## On-demand invalidation (purge)\n\nPurge from a **deployed function or edge function** with `purgeCache` from `@netlify/cache`. The site and purge token are configured automatically. Purging covers everything cached for the site, including Cache API entries:\n\n```ts\nimport { purgeCache } from \"@netlify/cache\";\n\nexport default async () => {\n  await purgeCache(); // no args = purge everything for the site\n  return new Response(\"Purged!\", { status: 202 });\n};\n```\n\nPurge by tag, optionally targeting a deploy/subdomain:\n\n```ts\nimport { purgeCache } from \"@netlify/cache\";\n\nexport default async (req: Request) => {\n  const cacheTag = new URL(req.url).searchParams.get(\"tag\");\n  if (!cacheTag) return;\n  await purgeCache({\n    tags: [cacheTag],\n    deployAlias: \"deploy-preview-11\",\n    domain: \"early-access.company.com\",\n  });\n  return new Response(\"Purged!\", { status: 202 });\n};\n```\n\n`purgeCache(options?)` options:\n- `tags`: tags to purge. Omit to purge the whole site. Tag purges apply to all deploys unless you target one.\n- `deployAlias` (e.g. `deploy-preview-11`): targets that alias on the primary domain.\n- `domain` (e.g. `early-access.company.com`): targets the published production deploy on that domain.\n- `siteID` / `siteSlug`: the site to purge. Use only one. Defaults to the request's site.\n- `token` (defaults to the token Netlify provides) and `userAgent`.\n- Returns a Promise that resolves once the purge is **accepted** (not propagated). It rejects if the API call fails.\n\n**Lambda-compatible functions** use the legacy `module.exports.handler = async (event, context) => {…}` signature. They must pass `context.clientContext.custom.purge_api_token`:\n\n```ts\nimport { purgeCache } from \"@netlify/cache\";\n\nmodule.exports.handler = async (event, context) => {\n  const token = context.clientContext.custom.purge_api_token;\n  await purgeCache({ tags: [\"tag1\", \"tag2\"], token });\n  return { body: \"Purged!\", statusCode: 202 };\n};\n```\n\nDirect API (from outside a function): `POST https://api.netlify.com/api/v1/purge` with `Authorization: Bearer <personal_access_token>` and `Content-Type: application/json`:\n\n```sh\ncurl -X POST \\\n  -H \"Content-Type: application/json\" \\\n  -H \"Authorization: Bearer <personal_access_token>\" \\\n  --data '{\"site_slug\": \"mysitename\", \"cache_tags\": [\"news\"], \"deploy_alias\": \"deploy-preview-11\", \"domain\": \"early-access.company.com\"}' \\\n  'https://api.netlify.com/api/v1/purge'\n```\n\n- Purge by site: pass `site_id` or `site_slug`.\n- Purge by tag: pass `cache_tags` plus the site.\n- Omitting `cache_tags` purges the whole site. An **empty** `cache_tags` list purges NOTHING.\n- Identifier mapping: in the UI (Project configuration > General > Project details > Project information), **Project ID** = `site_id` and **Project name** = `site_slug`. See https://docs.netlify.com/api-and-cli-guides/api-guides/get-started-with-api#get-site.\n- **Rate limit:** each tag or site can be purged only twice per 5s. Exceeding it returns `429`.\n\n## Cache API (`caches` global)\n\nProgrammatic read/write of HTTP responses from Functions/Edge Functions. Use it to cache individual components of a route or arbitrary fetches, alongside header-based route caching.\n\n**Scope rule:** call `caches.open()` anywhere, but call `match`/`put`/`delete` **only inside the request handler**. Doing them at module/global scope throws.\n\n```ts\nimport type { Config, Context } from \"@netlify/functions\";\n\nconst cache = await caches.open(\"my-cache\"); // ok in global scope\n\nexport default async (req: Request, context: Context) => {\n  const request = new Request(\"https://example.com/expensive-api\");\n  const cached = await cache.match(request);\n  if (cached) return cached;\n\n  const fresh = await fetch(request);\n  if (fresh.ok) {\n    cache.put(request, fresh.clone()).catch((error) => {\n      console.error(\"Failed to add to the cache:\", error);\n    });\n  }\n  return fresh;\n};\n\nexport const config: Config = { path: \"/cache-api-example\" };\n```\n\n`CacheStorage` subset:\n- `caches.match(request)` returns a `Response` from any cache, or `undefined`.\n- `caches.open(name)` returns a `Cache`. Distinct names fragment the cache and lower the hit ratio, so use few, meaningful names.\n\n`Cache` methods (all require `caches.open()`):\n- `cache.match(request)` returns a `Response` or `undefined`.\n- `cache.put(request, response)` adds a response.\n- `cache.add(request)` / `cache.addAll(requests)` fetch and store.\n- `cache.delete(request)` returns `true`.\n- `keys()` is **not implemented**, so there is no way to list contents.\n\nConsistency: reads/writes are strongly consistent. **Deletes are eventually consistent**, so a deleted entry may still return briefly.\n\n**Cannot cache:**\n- Partial responses (206), `Vary: *`, or non-`GET` methods.\n- Responses over **10 MB**. These are silently not stored.\n\nResponses also need all of the following, otherwise storage errors:\n- a cache-control header with `max-age`/`s-maxage` ≥ 1s\n- `public` (not `private`/`no-cache`/`no-store`)\n- a 2xx status\n\nFor responses you don't control, rewrite headers with `fetchWithCache`.\n\n**Limits per invocation:** 100 lookups, 20 insertions/deletions. Beyond these, further lookups return nothing and writes/deletes no-op. Limits are shared across edge functions in a request, but separate between serverless and edge functions.\n\nCache data is per-region (not replicated). It is auto-invalidated on redeploy and on `max-age`/`s-maxage` expiry, and is cleared by `purgeCache` (site or tag).\n\n## `@netlify/cache` module\n\nInstall to get helpers (including `purgeCache`), time constants (`MINUTE`/`HOUR`/`DAY`), and a `caches` export for local dev:\n\n```\nnpm install @netlify/cache\n```\n\n**Local-dev workaround:** the `caches` global isn't part of Node.js. Netlify provides it in its Functions/Edge runtimes, both live and under `netlify dev`. If you run your framework's own dev server, the global is undefined and throws. Import it instead:\n\n```ts\nimport { caches } from \"@netlify/cache\";\nconst cache = await caches.open(\"my-cache\");\n```\n\nThis requires Netlify CLI 20.0.3+. Nothing persists locally: lookups return nothing, and writes/deletes don't mutate. There is no functional change from the global.\n\n### `cacheHeaders(settings)` → header object\n\n```ts\nimport { cacheHeaders, DAY } from \"@netlify/cache\";\n\nconst headers = {\n  \"x-custom-header\": \"some value\",\n  ...cacheHeaders({\n    ttl: 2 * DAY,          // s-maxage\n    swr: HOUR,             // stale-while-revalidate\n    durable: true,\n    tags: [\"product\", \"sale\"],\n    overrideDeployRevalidation: [\"tag\"], // opt out of atomic-deploy invalidation\n    vary: {\n      cookie: [\"ab_test_name\", \"ab_test_bucket\"],\n      query: [\"item_id\", \"page\"], // or true for all\n      country: [\"us\", [\"es\", \"pt\"]], // nested = OR\n      language: [\"en\"],\n      header: [\"Device-Type\"],\n    },\n  }),\n};\n```\n\nFor only generic (non-Netlify) headers, use the `cdn-cache-control` npm module instead.\n\n### `fetchWithCache(resource, options?, cacheSettings?)`\n\nDrop-in `fetch` that returns a cached response, or fetches, stores, and returns. `cacheSettings` override conflicting response headers. With `swr`, background revalidation is handled automatically.\n\n```ts\nimport { fetchWithCache, DAY } from \"@netlify/cache\";\n\nconst response = await fetchWithCache(\"https://example.com/expensive-api\", {\n  ttl: 2 * DAY,\n  tags: [\"product\", \"sale\"],\n  vary: { cookie: [\"ab_test_name\"], query: [\"item_id\", \"page\"] },\n});\n```\n\n### `getCacheStatus(response | headers | headerString)`\n\nReturns `{ hit, caches: { durable: { hit, stale, stored, ttl }, edge: { hit, stale } } }`.\n\n```ts\nconst { hit, edge, durable } = getCacheStatus(response);\n```\n\n### `needsRevalidation(response)` → boolean\n\nOnly needed when calling `cache.match`/`cache.put` directly (not with `fetchWithCache` + `swr`). It is true when a Cache-API response is stale within its SWR window. Return the stale response, then revalidate in `context.waitUntil` and `cache.put` the fresh copy:\n\n```ts\nif (cached) {\n  if (needsRevalidation(cached)) {\n    context.waitUntil(\n      fetch(request).then((fresh) => {\n        const response = new Response(fresh.body, {\n          headers: { ...Object.fromEntries(fresh.headers), ...cacheHeaders({ ttl: MINUTE, swr: HOUR }) },\n        });\n        return cache.put(request, response);\n      })\n    );\n  }\n  return cached;\n}\n```\n\n## Durable cache\n\nAdd `durable` (serverless only) so edge nodes lacking a local copy check the shared durable cache before invoking the function. This means fewer invocations and better cache-miss latency.\n\n- It is eventually consistent, so multiple regions may still invoke the function a few times per version.\n- It is co-located with the site's functions region.\n- It works with `Netlify-Vary`, SWR, and on-demand invalidation.\n- **Next.js:** Next Runtime 5.5.0+ uses the durable cache automatically.\n\n## Debugging with `Cache-Status`\n\nNetlify sets `Cache-Status` (RFC 9211) on all responses. Check it on a **deployed** URL. Look for values starting with `\"Netlify Edge\"` or `\"Netlify Durable\"`:\n\n- `\"Netlify Edge\"; fwd=miss` means nothing was cached.\n- `\"Netlify Edge\"; hit` means the response was served from cache.\n- `\"Netlify Edge\"; hit; fwd=stale` means a stale response was served while revalidating (SWR).\n- `\"Netlify Durable\"; fwd=uri-miss; stored=true; ttl=3600` means a durable miss that was then stored.\n- `\"Netlify Durable\"; hit; ttl=1234` means a durable hit.\n\nA negative `ttl` is the number of seconds since expiry. Each request may hit a different cache instance. Without production traffic or `durable`, expect several empty caches before a hit; repeat requests to warm one.\n\n<!-- Gaps: @netlify/cache local-dev docs show cache.set; resolved to the documented cache.put. 10 MB limit doesn't say compressed vs uncompressed size, or whether it covers add/addAll/fetchWithCache.\npurgeCache `domain` is documented both as a site selector and as a deploy target; whether a 429 rate limit surfaces as a Promise rejection is unstated. -->\n\n<!-- system: agent-context/caching/system.md — human-owned, merged by ctx-gen; edit system.md, not this section -->\n# Netlify house rules (caching)\n\nThese are org conventions, not docs facts — merged into the rendered skill by\nctx-gen and never generated. Owned by the skills maintainer.\n\n1. Only `GET` responses are cached by the CDN. `POST`/`PUT`/etc. are never\n   cached regardless of headers — expose cacheable data on a `GET` route\n   (put the inputs in the URL or query string).\n2. Without `Netlify-Vary: query=...`, the full query string is the cache key —\n   every distinct query string (`utm_*`, `fbclid`, ...) is a separate cache\n   entry. Enumerate only the params that actually change the response.\n3. `netlify dev` does not emulate the CDN cache — a cache miss every time\n   locally is expected, not a bug. Verify caching behavior on a deployed URL\n   (Deploy Preview or production) via its `Cache-Status` header.\n4. `purgeCache()` has ambient credentials only inside a deployed function.\n   From CI, local scripts, or the build, pass `token` (a personal access\n   token read from an env var, never hardcoded) and `siteID`.\n"
}

SHA-256 of public snapshot: 3ae5846bfa8bb7f9dd27fd2c5bbf089b89acb1455deab5fd0da635976006db84