docs: extract template extensions and session cache into standalone pages

- Move globals + filters out of plugin-options into features/code-based/template-extensions,
  with built-in filters table and LiquidJS cross-reference
- Move cache setup out of plugin-options into session-cache, clarifying
  named catbox cache (simple) vs CacheService subclass (full lifecycle override)
- Collapse both plugin-options sections to signposts
- Add template-extensions to code-based index
- Expose session-cache in Reference nav sidebar

Author: alexluckett

docs/features/code-based/template-extensions.md

@@ -0,0 +1,70 @@
+# Template extensions
+
+The `globals` and `filters` plugin options let you extend the Nunjucks template environment with custom functions and filters. Both are available across all form page templates and in [page templates](../configuration-based/page-templates) (LiquidJS).
+
+## Globals
+
+Globals are functions you call directly in templates, without needing an input value. Register them via the `globals` plugin option:
+
+```js
+await server.register({
+  plugin,
+  options: {
+    globals: {
+      getCurrentYear: () => new Date().getFullYear(),
+      formatCurrency: (amount) =>
+        new Intl.NumberFormat('en-GB', {
+          style: 'currency',
+          currency: 'GBP'
+        }).format(amount)
+    }
+  }
+})
+```
+
+Use them in any Nunjucks template:
+
+```njk
+<p>Copyright {{ getCurrentYear() }}</p>
+<p>Total: {{ formatCurrency(123.45) }}</p>
+```
+
+## Filters
+
+Filters transform a value passed on the left side of the `|` operator. Register them via the `filters` plugin option:
+
+```js
+const formatter = new Intl.NumberFormat('en-GB')
+
+await server.register({
+  plugin,
+  options: {
+    filters: {
+      money: (value) => formatter.format(value),
+      upper: (value) => (typeof value === 'string' ? value.toUpperCase() : value)
+    }
+  }
+})
+```
+
+Use them in any Nunjucks template, or in [LiquidJS page templates](../configuration-based/page-templates):
+
+```njk
+<p>{{ amount | money }}</p>
+<p>{{ name | upper }}</p>
+```
+
+## Built-in filters
+
+forms-engine-plugin registers several filters automatically. These are available in all templates without any configuration:
+
+| Filter     | Description                                                                    |
+| ---------- | ------------------------------------------------------------------------------ |
+| `markdown` | Renders a Markdown string to HTML                                              |
+| `answer`   | Returns the user's answer for a given component name (LiquidJS only)           |
+| `page`     | Returns the page definition for a given path (LiquidJS only)                   |
+| `field`    | Returns the component definition for a given name (LiquidJS only)              |
+| `href`     | Returns the full page href for a given path (LiquidJS only)                    |
+| `evaluate` | Evaluates a nested LiquidJS template using the current context (LiquidJS only) |
+
+The LiquidJS-only filters are documented in full in [Page templates](../configuration-based/page-templates#built-in-filters).

docs/session-cache.md

@@ -0,0 +1,58 @@
+# Session cache
+
+The plugin stores form answers in a server-side cache keyed by the user's session. By default it uses the [hapi in-memory cache](https://hapi.dev/api/?v=21.4.0#-serveroptionscache), which is fine for development but unsuitable for production — sessions are lost on restart and are not shared across instances.
+
+Configure the cache via the `cache` plugin option.
+
+## Option 1 — named cache (recommended)
+
+For most deployments, register a named [catbox](https://hapi.dev/module/catbox/) cache on the hapi server and pass its name as the `cache` plugin option. The plugin handles all cache reads and writes internally — you only need to supply the backing store.
+
+```js
+import { Engine as CatboxRedis } from '@hapi/catbox-redis'
+
+const server = new Hapi.Server({
+  cache: [
+    {
+      name: 'session',
+      provider: {
+        constructor: CatboxRedis,
+        options: {
+          host: process.env.REDIS_HOST,
+          port: 6379
+        }
+      }
+    }
+  ]
+})
+
+await server.register({
+  plugin,
+  options: {
+    cache: 'session',
+    // ...
+  }
+})
+```
+
+Any catbox adapter works — Redis (`@hapi/catbox-redis`), Memcached (`@hapi/catbox-memcached`), or a custom implementation.
+
+## Option 2 — CacheService instance
+
+Use this when you need to subclass `CacheService` to customise its behaviour. The class exposes the full state lifecycle as overridable methods — key construction, TTL, state reads and writes, confirmation state, flash messages, and component state resets — so you can override whichever parts your use case requires. Pass your subclass instance directly:
+
+```js
+import { CacheService } from '@defra/forms-engine-plugin/cache-service.js'
+
+const cacheService = new CacheService({ server, cacheName: 'session' })
+
+await server.register({
+  plugin,
+  options: {
+    cache: cacheService,
+    // ...
+  }
+})
+```
+
+`CacheService` accepts `{ server, cacheName }` where `cacheName` must match a cache already registered on the hapi server. Omitting `cacheName` falls back to the default in-memory cache with a warning logged.