Glossary
Next.js’s vocabulary keeps shifting version to version — a “Router Cache” becomes a “Client Cache,” middleware.ts becomes proxy.ts, a caching model built on segment-config exports becomes one built on a single cacheComponents flag. When a lesson uses a term you’re unsure about, or unsure whether it’s still current, look it up here.
| Term | Meaning | Lesson |
|---|---|---|
| action ID | The 'use server' compiler replaces a Server Action’s implementation in the client bundle with an encrypted action ID plus a dispatcher that POSTs back to the server. That ID is a real, public endpoint — anyone who can send the same POST request can call it, whether or not they ever loaded your UI — so every action must authorize and validate on its own. | What Are Server Actions? |
| AGENTS.md | A project-root file create-next-app writes by default (or with --agents-md), giving AI coding agents version-specific rules so they don’t rely on stale training data. next dev re-adds its managed block automatically, so deleting it from a diff without fixing the underlying cause just recreates an uncommitted change. | Project Setup and the Toolchain |
| App Router vs. Pages Router | The App Router (app/) is the current model, built on React Server Components, with components as Server Components by default and inline async/await data fetching. The Pages Router (pages/) is the older model where every component is a Client Component fed by functions like getServerSideProps; both are supported, but new features land only in the App Router. | What Is Next.js and the App Router |
boundary ('use client' / 'use server') | The line a 'use client' or 'use server' directive draws between what runs on the server and what ships to the browser. 'use client' is transitive — everything imported into that file’s tree becomes part of the client bundle — so where the boundary sits decides how much JavaScript the browser downloads. | Server and Client Components |
| cacheComponents | The next.config.ts flag that replaces the previous Route Segment Config caching model (dynamic, revalidate, fetchCache, dynamicParams, runtime) with 'use cache', cacheLife, and cacheTag, and is also how Next.js 16 enables Partial Prerendering. Turning it on makes the old segment-config exports fail the build with Route segment config "…" is not compatible with nextConfig.cacheComponents. | use cache and Cache Components |
| cacheHandler / cacheHandlers | Two different self-hosting config keys: cacheHandler (singular) overrides the legacy full-route/ISR cache behind revalidatePath/revalidateTag; cacheHandlers (plural, an object, added in v16.0.0) configures backends for the 'use cache' directive family — default and remote among them. | Deployment and Self-Hosting |
| cacheLife | Sets how long a 'use cache' entry stays fresh, either with a named profile (cacheLife('hours')) or a custom one defined in next.config.ts. It is the cacheComponents replacement for the old export const revalidate segment config. | use cache and Cache Components |
| cacheTag | Tags a 'use cache' entry so it can be invalidated on demand with revalidateTag or updateTag. It accepts multiple tags in a single call, so a cached entry can carry both a collection-level and an item-level tag without two separate calls. | use cache and Cache Components |
| Client Cache (formerly Router Cache) | The fourth caching layer: RSC payloads of visited and prefetched routes held in the browser’s memory so back/forward navigation is instant. Since v15 the default staleTimes.dynamic is 0, and it is invalidated by a page refresh, router.refresh(), a cookie write, or revalidateTag/revalidatePath/updateTag. | The Four Caching Layers |
| connection() | Forces prerendering to stop and the rest of a component to run only at request time, for code with no Dynamic API to reach for (Math.random(), a synchronous DB driver). It replaced unstable_noStore; under cacheComponents, io() is the usually-preferred alternative because it stays cacheable inside a 'use cache' scope. | Partial Prerendering |
| create-next-app | The scaffolding CLI. Its recommended defaults are TypeScript, ESLint, Tailwind CSS, the App Router, and an AGENTS.md file — every toggle it offers (React Compiler, typed routes, src/, import alias) has a real, checkable effect on the generated project, not just a cosmetic difference. | Project Setup and the Toolchain |
| Term | Meaning | Lesson |
|---|---|---|
| DAL / verifySession() | The Data Access Layer pattern this course uses for authorization: a verifySession() helper that every Server Action and Route Handler calls before touching data. verifySession() calls redirect() on a missing session, so it must never sit inside a try/catch that swallows Next.js’s own redirect control flow. | Authentication Patterns |
| Data Cache | The server-side, persistent layer that stores fetch results across requests and deploys. Since Next.js 15 it is opt-in per call (cache: 'force-cache' or next: { revalidate }) — a plain fetch writes nothing to it. | The Four Caching Layers |
| Edge runtime (deprecated) | A smaller, Web-API-only execution environment, set with export const runtime = 'edge'. As of Next.js 16 it is deprecated as a route runtime — next build prints a deprecation warning and Cache Components rejects the export outright — though it lives on for proxy.ts. | Route Segment Config and Runtimes |
| error.tsx / global-error.tsx / retry() | error.tsx is a Client Component error boundary that catches errors from the segment below it — an error thrown in a layout is caught by the parent segment’s boundary, not its own — and receives a reset() function to retry rendering. global-error.tsx catches errors the root layout itself throws, so it must render its own <html> and <body>. | Pages, Layouts, and Nested Routing |
| filesystem cache | Turbopack’s incremental compilation cache on disk, on by default for both next dev and next build, so a repeat build or restart reuses prior work instead of recompiling from scratch. | Turbopack and Build Performance |
| forbidden() / unauthorized() | Purpose-built functions (behind the authInterrupts experimental flag) that throw and render the nearest forbidden.tsx or unauthorized.tsx boundary with the matching HTTP status, instead of a plain redirect('/login'). unauthorized() is for “not signed in”; forbidden() is for “signed in, but not allowed.” | Authentication Patterns |
| Full Route Cache | The server-side, persistent layer that stores the rendered RSC payload plus HTML of a statically-rendered route, so a matching request can skip rendering entirely. It stays valid until a redeploy or until the underlying data revalidates. | The Four Caching Layers |
| generateMetadata / streaming metadata / metadataBase / htmlLimitedBots | generateMetadata computes <title>/OG tags from route params on the server; since 15.2 its output streams into <body> for regular browsers (the page ships before it resolves) but blocks and renders into <head> for the htmlLimitedBots list (Twitterbot, Slackbot, Bingbot by default) that can’t run JavaScript. metadataBase sets the base URL relative metadata (like an OG image path) resolves against; without it, relative URLs can resolve against localhost in production. | Metadata and SEO |
| generateStaticParams / dynamicParams | generateStaticParams returns the list of dynamic-segment values to prerender at build time. The dynamicParams segment-config export controls what happens to a value it didn’t return: true (the default) renders it on demand, false returns a 404 instead — under cacheComponents that false case is expressed with notFound() in the page instead. | Route Segment Config and Runtimes |
| generateViewport | The viewport-specific counterpart to generateMetadata, for values (like themeColor or width) that must be computed per-request rather than declared as a static viewport export. | Metadata and SEO |
| hydration / hydration mismatch | Hydration is React attaching event handlers and state to server-rendered HTML in the browser. A mismatch happens when that HTML differs from what the client render produces — common causes are Date/random values, locale formatting, typeof window checks, or invalid HTML nesting — and React 19 reports it with a real, readable diff instead of a generic warning. | Static and Dynamic Rendering |
| instrumentation.ts / onRequestError | instrumentation.ts’s register() runs once when the server starts, the standard place to initialize telemetry; its onRequestError hook receives every server-side error so it can be forwarded to a real logging destination — logging only to console there is invisible the moment a container’s stdout isn’t being collected anywhere. | Deployment and Self-Hosting |
| intercepting route | A route convention ((.), (..), (...) folder prefixes) that renders a matched route inside the current layout — a modal over a feed, for instance — instead of navigating to its own page. The prefix’s meaning is about segment level, not literal folder depth, and named parallel-route slots (@slot) don’t count toward that level. | Parallel and Intercepting Routes |
| ISR (Incremental Static Regeneration) | Time-based background revalidation of a statically rendered route, turned on with export const revalidate = <seconds> under the Route Segment Config model (or a cacheLife profile under cacheComponents). | Route Segment Config and Runtimes |
| Term | Meaning | Lesson |
|---|---|---|
| loading.tsx | A file convention that automatically wraps a segment’s page.tsx in a <Suspense> boundary with the given fallback UI, shown while the segment’s data is loading. It gives coarse, per-segment streaming granularity; a manual <Suspense> further down the tree gives finer control. | Streaming and Suspense |
| matcher | The config.matcher export in proxy.ts that scopes which paths run the proxy. Without one, proxy runs on every request — including _next/static, _next/image, and prefetch requests — so an unscoped auth check can unintentionally block your own assets or fire on links a user only scrolled past. | Proxy (Middleware) and the Request Lifecycle |
| next/dynamic | A wrapper around import() for lazily loading a component, most often used with ssr: false to load a browser-only dependency (like a canvas library) without including it in the server render or the initial bundle. | Scripts and Bundle Optimization |
| next experimental-analyze | The Turbopack-based bundle analyzer, run with npx next experimental-analyze; it opens an interactive UI (or writes .next/diagnostics/analyze with --output) showing what’s actually inside a route’s client bundle — useful for catching a 'use client' boundary placed too high. | Scripts and Bundle Optimization |
| next/font | Self-hosts font files at build time and inlines the @font-face CSS, so there is no runtime request to Google Fonts (or any other host) and no layout shift from a late-loading font. | Images and Fonts |
| next/image (sizes, remotePatterns, minimumCacheTTL) | The built-in image component that resizes, converts, and lazy-loads images with no layout shift. sizes tells the browser which rendered width to expect at each breakpoint (get it wrong and the browser downloads an oversized image); remotePatterns allowlists external image hosts; minimumCacheTTL is the minimum time an optimized image is cached, changed from 60 seconds to 4 hours (14400s) as of Next.js 16. | Images and Fonts |
| NEXT_PUBLIC_ | The prefix that inlines an environment variable into the client bundle at build time. It must be accessed as a static literal — process.env.NEXT_PUBLIC_X, never process.env[key] — because the replacement is a build-time string substitution, not a runtime lookup. | Environment and Configuration |
| NextRequest / NextResponse | The extended Request/Response classes used in proxy.ts and Route Handlers — NextRequest adds convenience like cookie helpers, NextResponse adds .redirect(), .rewrite(), and .next() for continuing the request unmodified (optionally with headers attached for a downstream Server Component to read). | Proxy (Middleware) and the Request Lifecycle |
| Node.js runtime | The default execution environment for every route, giving the full Node API surface — as opposed to the smaller, Web-API-only Edge runtime, which is deprecated as a route runtime in Next.js 16. | Route Segment Config and Runtimes |
| not-found.tsx / notFound() | notFound() throws to render the nearest not-found.tsx boundary with a 404 status; a root not-found.tsx handles unmatched routes anywhere in the app, while a nested one only handles notFound() calls (or unmatched dynamic segments) inside its own subtree. | Pages, Layouts, and Nested Routing |
| Term | Meaning | Lesson |
|---|---|---|
| output: ‘standalone’ | A next.config.ts setting that makes Next.js trace exactly which files the server needs and copy them into .next/standalone, producing a small self-hosting image that doesn’t need the full node_modules. | Deployment and Self-Hosting |
| parallel route | Named slots (@slot folders) that let one layout render several independent pages at once — a dashboard’s @analytics and @team panes, for example. A slot without a matching default.tsx 404s on a hard navigation that doesn’t match it, and a slot is not itself a URL segment. | Parallel and Intercepting Routes |
| PPR (Partial Prerendering) / static shell | Combines a static shell with dynamic holes in one route: everything outside a <Suspense> boundary (or a 'use cache' scope) prerenders once at build time, and each hole streams in at request time. Enabled by the same cacheComponents: true flag as 'use cache' — the older ppr/experimental_ppr flags were removed. | Partial Prerendering |
| proxy (proxy.ts, formerly middleware) | The Next.js 16 name for middleware.ts — code that runs before a request completes on every matching route. It always runs on the Node.js runtime (not configurable; exporting runtime from it is a build error), and it also runs on <Link> prefetch requests, not just full navigations. | Proxy (Middleware) and the Request Lifecycle |
| React Compiler | An opt-in (reactCompiler: true) compiler that auto-memoizes components, removing most hand-written useMemo/useCallback. In Next.js 16.3 it isn’t bundled — it requires installing babel-plugin-react-compiler yourself, or the build fails with a clear “Failed to resolve package” error. | Project Setup and the Toolchain |
| React.cache() | Wraps a non-fetch read (a database query, for example) to get the same per-request deduplication fetch gets automatically. It compares arguments the way Object.is does, not deep-equal, so a freshly-created object argument on each call defeats the dedupe. | Fetching in Server Components |
| redirect() / NEXT_REDIRECT | redirect() (and permanentRedirect()) work by throwing a special NEXT_REDIRECT error that Next.js’s own boundary catches — which means a try/catch wrapped around the call silently swallows the redirect instead of letting it navigate. | Linking and Navigation |
| Request Memoization | The first caching layer: within one render pass, identical fetch (or React.cache()) calls are deduped automatically so the network sees one request no matter how many components call it. It lives only for that single request/render and is not shared with a Route Handler call. | The Four Caching Layers |
| request-time (dynamic) API | A function whose result can only be known once an actual request arrives — cookies(), headers(), searchParams, or connection() — and whose use forces the segment that calls it to render dynamically instead of being prerendered once at build time. | Static and Dynamic Rendering |
| revalidatePath() | Invalidates cache entries by route path rather than by tag — revalidatePath('/', 'layout'), for instance, has an intentionally wide blast radius, clearing everything cached under that layout regardless of what tags it carries. | Revalidation and Cache Invalidation |
| revalidateTag(tag, profile) | Marks every Data Cache entry carrying tag stale so the next request re-fetches it. In Next.js 16 the profile argument — a cacheLife profile such as 'max' — is required; the old one-argument form is deprecated and is now a TypeScript error. | Revalidation and Cache Invalidation |
| route group | A (name) folder that organizes routes or opts a subtree into its own root layout, without adding a segment to the URL. Two route groups do not share a layout with each other, and having more than one root layout means navigating between them is a full page reload, not a client-side transition. | Dynamic Segments and Route Groups |
| Route Handler | A route.ts file that defines a request handler for a URL — GET, POST, etc. — typically used for a real public API, a webhook, or an on-demand revalidation endpoint guarded by a secret, since it sits outside the React component tree and its own request memoization scope. | Revalidation and Cache Invalidation |
| route segment config | The previous per-segment caching/runtime model — exports like dynamic, revalidate, fetchCache, dynamicParams, and runtime. Every one of them fails the build once cacheComponents: true is set, with the error Route segment config "…" is not compatible with nextConfig.cacheComponents (preferredRegion and maxDuration are the two exceptions). | Route Segment Config and Runtimes |
| RSC (React Server Component) | A component that renders on the server and never ships its own code to the browser — in the App Router, every component is one by default until a file (or an ancestor in its import chain) declares 'use client'. | Server and Client Components |
| RSC payload / Flight | The serialized description of the rendered Server Component tree that the server sends the client — internally a streaming format the docs and this course’s Server Actions lesson call the Flight stream. It’s what the Client Cache actually stores per route, and what a Server Action response carries alongside its return value when it triggers an immediate revalidation. | Server and Client Components |
| Term | Meaning | Lesson |
|---|---|---|
| segment | A folder in app/ maps to one segment of the URL path; a special file inside it (page.tsx, layout.tsx, loading.tsx, and so on) defines that segment’s behavior. | Pages, Layouts, and Nested Routing |
| Server Action / Server Function | A function marked 'use server' (inline or in a whole file) that runs only on the server but can be called directly from a Client Component or a <form action={...}>. The compiler replaces it in the client bundle with a reference to its action ID, not the code itself. | What Are Server Actions? |
| server-only / client-only | Packages that turn an accidental cross-boundary import into a build-time error instead of a silent runtime leak: importing server-only into a Client Component (or client-only into a Server Component) fails next build with a clear message. | Server and Client Components |
| slot | A named @folder passed as a prop to its parent layout under Parallel Routes. It is not itself a URL segment, and it needs its own default.tsx to avoid 404ing on a hard navigation that doesn’t explicitly match it. | Parallel and Intercepting Routes |
| streaming | Sending a response to the browser in pieces as they become ready, instead of waiting for the whole page to finish rendering. It requires the response not be buffered end-to-end — a reverse proxy sitting in front (nginx, for instance) needs proxy_buffering off or streaming degrades into one big flush. | Streaming and Suspense |
| Suspense boundary | A <Suspense fallback={...}> wrapped around a part of the tree that can pause (an await in an async Server Component, or a Promise passed to use()), so that part streams in once ready while the rest of the page renders immediately. Wrapping one <Suspense> around an entire await-heavy page gives none of that benefit — it just delays everything behind one boundary. | Streaming and Suspense |
| Turbopack | The Rust-based, incremental bundler that is now the default for next dev and next build (--webpack opts back into the previous bundler). It’s built for faster cold starts and HMR, backed by a filesystem cache that’s on by default. | Turbopack and Build Performance |
| unstable_rethrow() | Re-throws Next.js’s own internal control-flow errors (from redirect(), notFound(), and similar) that got caught by a surrounding try/catch you didn’t intend to swallow them with, letting Next.js’s own boundary handle them as it normally would. | Linking and Navigation |
| updateTag() | Expires a cache entry immediately rather than marking it stale-and-refresh-in-background — the right choice when the calling user must see the effect of their own write on the very next request. Unlike revalidateTag/revalidatePath, it’s Server-Action-only. | Revalidation and Cache Invalidation |
| ’use cache’ (+ private / remote) | A directive that caches a function’s or component’s return value under cacheComponents: true, replacing manual cache keys with cacheLife and cacheTag declared right next to the logic they describe. 'use cache: private' scopes an entry per-user instead of sharing it; 'use cache: remote' stores it in a configured remote handler rather than the default in-memory one. | use cache and Cache Components |
| use() | The React API that unwraps a Promise (or a Context) inside render. Passing a Promise from a Server Component down to a Client Component and unwrapping it with use() — inside a <Suspense> boundary — lets the static shell stream before the slow data arrives, since a Client Component’s render function itself cannot be async. | Server and Client Components |
| useActionState | Wraps a Server Action so a component gets back its latest returned state, a form action to bind, and a pending flag. The wrapped action’s signature is (previousState, formData) — different from a plain action’s (formData) — and swapping one shape for the other is a real TypeScript error, not just a style choice. | Forms and Progressive Enhancement |
| useFormStatus | Reads the pending status of the nearest parent <form>’s submission. It only works when called from a component that is a child of the <form> — calling it in the same component that renders the form always reports pending: false. | Forms and Progressive Enhancement |
| useOptimistic | Shows an expected result immediately, before a Server Action’s response arrives, then reconciles once the real data resolves. If the action throws instead of resolving, React discards the pending optimistic update and the UI reverts to the last confirmed state. | Forms and Progressive Enhancement |