Glossary

Short definitions of the terms that come up in the interview, each linking to the page where it matters.

__VUE_PROD_HYDRATION_MISMATCH_DETAILS__ Hydration: Vue compile-time flag (set via vite.define) that keeps detailed mismatch warnings in production builds for debugging.
_layersaka nuxt.options._layers Layers: The resolved list of layers on the Nuxt instance, project first, each entry holding cwd, config and meta. Modules read it to scan every layer's directories.
@nuxt/test-utils Modules: Testing toolkit with an e2e API (setup, $fetch, createPage) and a runtime Vitest environment (mountSuspended, mockNuxtImport).
#build Modules: Alias to generated templates in .nuxt; `import x from '#build/my-module/options.mjs'`.
#imports Internals: Virtual module exposing all auto-imports explicitly, so module runtime code works even when the consumer disables the auto-import transform.
#layers aliasaka #layers/<name> Layers: Import alias pointing at a named layer's root, so a project can import a layer file by path regardless of where either lives. Auto-scanned layers are named after their folder.
$meta Layers: Config block naming a layer (`$meta: { name }`). Gives layers listed in extends a stable name and alias.

addBuildPlugin Modules: Kit helper registering an unplugin factory once for Vite, webpack and Rspack.
addComponentsDir Modules: Kit helper registering a directory of components, optionally with a prefix, used per layer by layer-aware modules.
addImports Modules: Kit helper registering auto-imports (composables, utils) for the app registry; addServerImports targets Nitro.
addPlugin Modules: Kit helper registering a runtime plugin; normalises src, infers client/server mode from the filename and prepends to nuxt.options.plugins unless append is true.
addServerHandler Modules: Kit helper registering a Nitro route or middleware from a module's runtime directory.
addTemplate Modules: Kit helper generating a file into .nuxt at build time, virtual by default, importable as #build/<filename>; regenerate with updateTemplates.
addTypeTemplate Modules: Kit helper generating a .d.ts that Nuxt references from its generated tsconfigs, optionally per context (nuxt, nitro, node, shared).
app/ directory Layers: Nuxt 4's home for app code (components, composables, pages, layouts, plugins, app.config) inside a project or a layer; server/, shared/, public/ and modules/ stay at the root.
appConfigaka app.config.ts Layers: Reactive, bundled configuration merged across layers with the project winning; the right channel for theme tokens and UI defaults, not for secrets or per-environment values.
autocannon Memory: HTTP load generator used to warm and stress a server while taking heap snapshots or measuring TTFB.

c12 Internals: unjs config loader behind nuxt.config: loads TypeScript configs, applies $development/$production overrides, resolves extends layers and merges everything with defu.
callOnce Hydration: Runs a function once per navigation or per app, so setup logic does not repeat on the client after SSR already ran it.
changelogen Modules: Conventional-commit changelog and release tool used by the module starter's release script.
ClientOnly Hydration: Component rendering its children only on the client with an optional #fallback slot; the escape hatch, not the default.
compatibilityVersionaka future.compatibilityVersion Landscape: Opt-in switch for the next major's behaviour; `5` enables Nuxt 5 semantics on a 4.x project for testing.
configKey Modules: The nuxt.config property where consumers place a module's options, declared in the module's meta.
consola Modules: Logger behind useLogger(); gives modules scoped, level-aware output.
Core Web Vitalsaka LCPaka INPaka CLS Perf: Largest Contentful Paint, Interaction to Next Paint and Cumulative Layout Shift, the client metrics measured with Lighthouse or web-vitals.
createResolver Modules: Kit helper returning resolve() anchored to import.meta.url, the correct way to reference a module's own runtime files.
cross-request state pollution Memory: Request-scoped data stored at process lifetime and read by the next request, the security cousin of a memory leak; fixed with useState, event.context or per-app instances.

data-allow-mismatch Hydration: Vue 3.5 attribute whitelisting an expected mismatch on an element (text, children, class, style, attribute).
dedupe Internals: useAsyncData option deciding what happens when a request with the same key is already in flight: cancel (default) or defer.
defineCachedEventHandler Perf: Nitro wrapper caching a handler's response with maxAge, staleMaxAge, swr, getKey, varies and shouldBypassCache; storage defaults to memory.
defineNuxtModule Modules: Kit factory for a module: meta (name, configKey, compatibility), defaults, moduleDependencies, hooks and the setup(options, nuxt) function that runs at build time.
defu Internals: unjs deep-defaults merger. Objects deep-merge, arrays concatenate, the left-hand (higher-priority) scalar wins and undefined never overrides a default.
destr Modules: Safe JSON parsing used to coerce runtime-config environment variables to the type of their default (so "false" becomes false).
devalue Internals: Serialiser for the payload supporting Date, Map, Set, RegExp and BigInt; custom classes need definePayloadReducer/Reviver.

effectScopeaka onScopeDispose Memory: Vue API grouping effects so they can be stopped together; onScopeDispose registers cleanup for composables.
event.context Memory: Per-request storage on the h3 event, typed by augmenting H3EventContext; where request-scoped server state belongs instead of module scope.
extends Layers: The nuxt.config option listing layers to merge in, from a local path, an npm package or a git source. The first entry has the highest priority among extended layers.

fixture Layers: A minimal Nuxt app used in tests; for a layer, a fixture extends the layer and asserts what it ships and that overrides win.

getLayerDirectories() Layers: Kit helper returning each layer's resolved directories (root, app, server, shared, public, modules, appPages…) in priority order, project first.
giget Layers: unjs downloader used by c12 to fetch remote layers and templates from GitHub, GitLab, Bitbucket and sourcehut, with `GIGET_AUTH` for private repositories.

h3 Internals: The HTTP framework under Nitro: defineEventHandler, getQuery, readBody, readValidatedBody, createError, setResponseHeader.
heap snapshot Memory: A capture of the JS heap in Chrome DevTools; comparing snapshots before and after load and following retainers is how a leak is found.
hookable Modules: unjs hook system behind nuxt.hook / callHook. Listeners run serially by default; callHookParallel and hookOnce exist; hook() returns an unsubscribe function.
hydration mismatch Hydration: The client's first render disagreeing with the server HTML; logged in development, silently patched in production at the cost of layout shift and CPU.
hyperfine Perf: Command-line benchmarking tool used to time builds or dev startup with and without a module or layer.

installModule Modules: Kit helper that runs another module's setup immediately with given options, without version checks or dedupe awareness.

jiti Internals: Runtime TypeScript loader used to import nuxt.config.ts and modules at build time (and by this app's validate script).

knitwork Modules: Code-generation helpers (genImport, genExport, genObjectFromRawEntries) for producing safe JavaScript in templates.

layer Layers: A Nuxt project fragment another project extends. Its directories are scanned like the app's and its config is merged; the project always has the highest priority.
lazy hydrationaka hydrate-on-visible Perf: Deferring a component's hydration until visible, idle, interaction or a media query, via Vue 3.5 strategies exposed on Lazy* components.
Leitner boxes: The spaced-repetition scheme this app uses: a correct answer moves a question up a box (due in 1, 3, 7, 14 days), a miss returns it to box 0.

magic-string Internals: Library for editing source text while producing source maps, the standard tool inside a transform plugin.
MaxListenersExceededWarning Memory: Node warning when an emitter exceeds ten listeners, the early smell of listeners registered per request on a process-lifetime emitter.
mlly Internals: ESM utilities (resolvePath, findExports, importModule) used by kit's resolver helpers.
module-builderaka @nuxt/module-builder Modules: Builds a module to dist/ (module.mjs, module.json, types) and transpiles src/runtime file by file so resolver paths keep working after publishing.
moduleDependencies Modules: Declarative dependencies between modules (Nuxt ≥ 4.1) with version constraints, defaults, overrides and optional flags; the replacement for imperative installModule calls.
mountSuspended Modules: Test helper mounting a component inside the Nuxt runtime environment so auto-imports and plugins resolve.

Nitro Internals: The server engine bundling server/ handlers and the SSR renderer into a deployable output for a preset. Nuxt 4 uses Nitro 2 with h3 v1; Nuxt 5 targets Nitro v3.
nuxt analyze Perf: CLI command producing client and server bundle treemaps to find heavy chunks and non-tree-shaken code.
nuxt-nightly Landscape: Nightly channel of Nuxt (`nuxt@npm:nuxt-nightly@5x`) used in CI matrices to catch upstream breakage early.
nypm Modules: Package-manager detection and install helper used by `nuxt module add`.

ofetch Internals: Fetch wrapper behind $fetch with automatic JSON handling, retries and interceptors.

pathe Internals: POSIX-style path utilities that behave identically on Windows; prefer it over node:path in module code.
payload Hydration: The serialised state (useState, async data, head) embedded in the SSR response and revived before the client renders; serialised with devalue.
playground Layers: The development app inside a layer or module repository (`.playground/` or `playground/`) that extends or installs it for manual testing.

Rolldown Landscape: Rust bundler powering Vite 8, which Nuxt 4.5 runs on.
rootDir Layers: The project root where nuxt.config, .env, package.json and the layers/ directory live.
route rulesaka routeRules Perf: Per-route configuration in nuxt.config (prerender, swr, isr, cache, redirect, headers, ssr: false); merged as an object across layers.
Rspack builder Landscape: Alternative Nuxt builder (`builder: '@nuxt/rspack-builder'`) using Rspack 2 with an Rsbuild pipeline.
runtimeConfig Modules: Per-environment values. The private part is server-only; `public` is serialised into every SSR payload; both are overridable at runtime by NUXT_* environment variables.

scule Modules: String-case helpers (pascalCase, kebabCase, camelCase) used for component and config names.
server componentaka islandaka NuxtIslandaka .server.vue Hydration: Component rendered only on the server (islands) so heavy markup and its dependencies never reach the client bundle.
Server-Timing Perf: Response header exposing server-side timings to browser DevTools; a Nitro plugin can add render and data durations.
shared/ Layers: Directory whose utils and types are auto-imported in both the Vue app and Nitro (Nuxt ≥ 3.14); must not import Vue or Nitro code. Scanned per layer.
size-limit Perf: Bundle-size budget tool for CI; use it to fail when a layer or module grows the client bundle past a threshold.
srcDir Layers: The directory Nuxt scans for app code; `app/` in Nuxt 4, resolved separately for every layer.

TTFB Perf: Time to first byte, the server-side metric driven by data waterfalls, plugin cost, cache hits and payload serialisation.

ufo Internals: unjs URL utilities (joinURL, withQuery, withTrailingSlash) used throughout Nuxt and worth using in module code instead of string concatenation.
unctx Internals: unjs async-context helper that lets useNuxt() and useNuxtApp() find the current instance without passing it around. Nuxt 4.5 moved to unctx v3.
unhead Internals: Head management library behind useHead, useSeoMeta and useHeadSafe; sorts tags for performance. Nuxt 4.5 runs unhead v3.
unimport Internals: unjs auto-import engine. Builds the registry of composables and utils, rewrites bare identifiers to explicit imports at build time and exposes the virtual #imports module.
unplugin Internals: unjs abstraction for writing one bundler plugin that works in Vite, webpack and Rspack; addBuildPlugin registers one.
unstorage Internals: unjs key-value storage layer with drivers (fs, memory, Redis, KV…) behind Nitro's useStorage and cache.
untyped Internals: unjs schema utility Nuxt uses to resolve every option's defaults and types ($resolve / $default) when building nuxt.options.
useId Hydration: Vue 3.5 composable generating ids that are stable between server and client, the correct fix for generated id/aria attributes.
useNuxt Modules: Returns the current Nuxt build instance from unctx; only works inside module setup and build hooks, never at runtime.
useState Hydration: SSR-shared reactive state keyed by name, serialised into the payload and revived on the client; the fix for module-scope refs polluting requests.

Vite Environment API Landscape: Vite 6+ model of one shared config with environment-specific plugins; Nuxt 5 uses it instead of separate client and server configs.