@dokebi/template-inertia 0.1.3 → 0.2.0

package/AI.md

@@ -1,4 +1,4 @@
-# AI 작업 안내 — @dokebi/template-inertia 0.1.3
+# AI 작업 안내 — @dokebi/template-inertia 0.2.0
 
 Inertia(v3) 서버 어댑터다. 첫 요청은 HTML(+ `script[data-page]` JSON), 이후 `X-Inertia` 요청은 page JSON으로 답한다. Vite manifest를 읽어 스크립트·스타일·버전을 채우고 빌드 파일을 직접 내보낸다. 선택적으로 첫 HTML을 같은 프로세스에서 서버 렌더링(SSR, D-0039)한다. Vue·Vite는 서버 의존성이 아니다(앱의 개발 의존성). Node >=24.0.0, core ^0.2.0, @dokebi/web(peer). 세부는 [README](README.md)다.
 
@@ -22,6 +22,7 @@ npm run build                                       # dist/(브라우저) + dist
 | `version` · `scripts` · `styles` | 자산 버전과 URL(`/`로 시작하는 로컬 URL). 없으면 `INERTIA_VERSION_DEFAULT` 경고 |
 | `vite: { manifest, entry, base? }` | manifest에서 scripts·styles·version 계산. 위 셋과 함께 쓰면 거부 |
 | `ssr: { bundle, failure?, entry? }` | 서버 렌더링. `failure`: `fallback`(기본) · `error`. `entry`는 개발 모드에서 쓰는 번들의 원본 모듈(§5.1) |
+| `encryptHistory` | Inertia history 암호화: `true`·`false`·`'sealed'`(기본: 봉인 요청이면 켬, D-0062) |
 
 ## 3. 페이지 렌더
 
@@ -39,7 +40,7 @@ route.post('/orders', async (request, reply, page) => {
 });
 ```
 
-- `render(request, reply, component, props?)`: GET/HEAD에서만. 핸들러에서 반환·await. component는 `/`로 구분된 `[A-Za-z0-9][A-Za-z0-9_-]*` 조각.
+- `render(request, reply, component, props?, { encryptHistory?, clearHistory? }?)`: GET/HEAD에서만. 다섯째 인수는 이 응답의 history 설정(없으면 범위 설정과 세션 신호). 핸들러에서 반환·await. component는 `/`로 구분된 `[A-Za-z0-9][A-Za-z0-9_-]*` 조각.
 - props: JSON 값, 비동기 lazy 함수, 또는 §3.1 도우미. partial reload(`only`·`except`)는 선택된 것만 평가하고 `errors`는 항상 포함. 비JSON 값·순환은 실패.
 - `redirect(request, reply, localUrl)`: GET/HEAD 302, mutation 303, Inertia의 `#` 이동은 409 + `X-Inertia-Redirect`.
 - `location(request, reply, url)`: 로컬 또는 http(s) 외부 이동. Inertia 요청은 409 + `X-Inertia-Location`.
@@ -123,3 +124,10 @@ route.post('/orders', async (request, reply, page) => {
 - 앱 인스턴스마다 새 플러그인. 전체 drain 뒤에 responder가 닫힌다.
 
 근거: `examples/24-template-inertia`(실제 Chrome: CSR·SSR·cluster, 측정), `examples/26-scaffold`(CLI가 만든 SSR 앱의 빌드·서버 렌더), `examples/25-playground`, `tests/flash.test.ts`(세션 flash), D-0027·D-0031·D-0039·D-0045·D-0052·D-0055.
+
+## 봉인 호스트와 브라우저 기록(D-0062, 0.2.0)
+
+- seal 호스트(@dokebi/app `domains.<host>.seal: true`)의 요청이면 첫 HTML의 `data-page`가 봉인 프레임 하나(`data-sealed="true"`, `E:<ts>:<b64>`)이고, 방문(JSON) 응답은 dokebi-web이 봉인한다. 판단은 dokebi-web `sealOf(request)`. 브라우저는 `views/app.js`에서 `createInertiaApp` 전에 `await sealInertia(http)`(`@dokebi/seal/http`; CLI 템플릿은 `data-sealed`일 때만 `/dokebi/seal/http.mjs`를 동적 import)로 연다.
+- **페이지 모듈 맨 위에서 `data-page`를 읽지 않는다**: `import.meta.glob(..., { eager: true })`로 들어온 페이지·모듈은 `sealInertia`보다 먼저 실행되므로 아직 봉인된 글을 JSON으로 읽다 앱이 멈춘다. `usePage()`나 연결할 때 읽는다.
+- SSR과 함께 쓸 수 없다: `scope({ sealed: true, ssr })`는 시작 실패 `SEAL_SSR_CONFLICT`(dokebi-app이 seal 도메인 앱에 `sealed`를 넘긴다), SSR 범위에 봉인 요청이 오면 그 요청이 `SEAL_SSR_CONFLICT`.
+- `encryptHistory`(기본 `'sealed'`)가 켜진 페이지는 브라우저 기록에 암호화돼 저장된다(보안 문맥에서만: HTTPS·`*.localhost`). `clearHistory`는 @dokebi/session 0.2의 `historyReset()`(이 요청에서 `destroy`·`regenerate`)이면 그 페이지에, 페이지를 그리지 않는 요청(로그인 POST → 303)이면 쿠키 `dokebi.history-reset`(10분)으로 **다음 페이지**에 실린다. 로그아웃 뒤 「뒤로」는 예전 props를 보이지 못하고 서버에서 다시 받는다.

package/README.md

@@ -1,4 +1,4 @@
-# @dokebi/template-inertia 0.1.3
+# @dokebi/template-inertia 0.2.0
 
 Node >=24.0.0, core ^0.2.0, 선택 패키지다(npm 공개). ID는 `dokebi-template-inertia`이며 `dokebi-web`에 의존한다. `@dokebi/web`은 peer 의존성이다(예전의 고정 버전 dependency가 아니다). EJS·Vue·Vite를 서버 패키지의 필수 의존성으로 설치하지 않는다.
 
@@ -78,3 +78,10 @@ Vue 페이지 이동·초기 props는 Inertia, 이후 조회·수정은 `fetch('
 ## 개발 모드(HMR, [D-0045](../../docs/decisions/D-0045-inertia-vite-dev.md))
 
 `DOKEBI_VITE_DEV=1`(`dokebi dev`가 넣는다)이면 빌드 없이 프로젝트의 Vite를 미들웨어 모드로 띄워 `<base>*`를 Vite가 답하고, 페이지는 `@vite/client`와 원본 진입을 불러온다. `.vue`를 고치면 새로고침 없이 바뀐다(HMR 소켓은 프로세스마다 따로 잡은 빈 포트). SSR은 요청마다 Vite로 원본(`ssr.entry`, 없으면 `vite.entry` 옆 `ssr.js`)을 그린다. 운영에는 영향이 없다.
+
+## 봉인 호스트와 history(D-0062, 0.2.0)
+
+[D-0062](../../docs/decisions/D-0062-http-seal.md). 봉인 요청(dokebi-web `sealOf`)의 첫 HTML은 `<script data-page="app" type="application/json" data-sealed="true">E:…</script>`만 싣고(제목은 설정값), 방문 JSON은 dokebi-web이 봉인한다. 브라우저는 `@dokebi/seal/http`의 `sealInertia(http)`로 연다. SSR과 함께 쓰면 `SEAL_SSR_CONFLICT`.
+
+- `encryptHistory: true | false | 'sealed'`(옵션·`scope`, 기본 `'sealed'`)와 `render(..., props, { encryptHistory, clearHistory })`.
+- 로그인·로그아웃(@dokebi/session 0.2 `historyReset()`) 다음 페이지가 `clearHistory: true`를 싣는다. 페이지를 그리지 않은 요청에서 일어났으면 쿠키 `dokebi.history-reset`(Path=/, 10분, HttpOnly, SameSite=Lax, https면 Secure)이 다음 페이지까지 들고 가고 그 페이지가 지운다.

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { type Awaitable } from '@dokebi/core';
 import type { FastifyRequest } from 'fastify';
 import { type InertiaApi, type Props } from './responder.js';
 export { type DeferOptions, deepMerge, defer, InertiaProp, isInertiaProp, type MergeOptions, merge, type OnceOptions, once, type PropValue, } from './props.js';
-export type { InertiaApi, InertiaFlash, InertiaOptions, InertiaPage, InertiaSsrResult, Json, Props, } from './responder.js';
+export type { InertiaApi, InertiaFlash, InertiaOptions, InertiaPage, InertiaRenderOptions, InertiaSsrResult, Json, Props, } from './responder.js';
 export type InertiaShared = (request: FastifyRequest) => Awaitable<Props>;
 export interface InertiaEntry {
     readonly shared?: InertiaShared;
@@ -46,6 +46,13 @@ export interface InertiaScopeOptions {
     readonly ssr?: InertiaSsrOptions | false;
     /** Props merged after the plugin's shared props for every page of this scope. */
     readonly shared?: InertiaShared;
+    /** History encryption of this scope's pages (default `'sealed'`: on for sealed requests). */
+    readonly encryptHistory?: boolean | 'sealed';
+    /**
+     * This scope answers seal hosts (dokebi-app sets it, D-0062). Server rendering would write the
+     * props as plain HTML, so `sealed` with SSR stops the start (`SEAL_SSR_CONFLICT`).
+     */
+    readonly sealed?: boolean;
 }
 export interface InertiaPluginApi extends InertiaApi {
     /**

package/dist/index.js

@@ -137,14 +137,30 @@ async function viteAssets(vite) {
 // Written here so the provider package resolves from @dokebi/template-inertia, not from core.
 const web = providerDependency({
     name: 'dokebi-web',
-    version: '^0.1.0',
+    version: '^0.2.0',
     packageName: '@dokebi/web',
     load: () => import('@dokebi/web'),
 });
+/**
+ * Carries a history reset (login, logout) to the next page when the request that did it shows
+ * no page itself (a POST that redirects): `clearHistory` then goes out with that next page.
+ */
+const HISTORY_RESET_COOKIE = 'dokebi.history-reset';
+const HISTORY_RESET_SECONDS = 600;
+function hasCookie(header, name) {
+    const text = Array.isArray(header) ? header.join('; ') : (header ?? '');
+    if (text.length > 16_384)
+        return false;
+    return text.split(';').some((part) => part.slice(0, part.indexOf('=')).trim() === name);
+}
 const session = optionalDependency({
     name: 'dokebi-session',
-    version: '^0.1.0',
+    version: '^0.1.0 || ^0.2.0',
 });
+/** SSR writes props as plain HTML: it cannot serve a sealed scope (D-0062). */
+function sealSsrConflict() {
+    return Object.assign(new Error('An Inertia scope of seal hosts cannot use SSR: server rendering writes the props as plain HTML. Set ssr: false for this app or drop seal from its hosts.'), { code: 'SEAL_SSR_CONFLICT' });
+}
 function parseOptions(input) {
     const { vite, ssr: ssrInput, ...rest } = (input ?? {});
     const ssr = parseSsr(ssrInput);
@@ -208,6 +224,47 @@ class InertiaRuntime {
         const flash = sessions
             ? async (request) => (await sessions.of(request).takeFlash())
             : undefined;
+        // D-0062: sealed requests (dokebi-web decides) and the session's history reset (logout, login).
+        // A page shown in the request that reset uses it at once; otherwise the reset cookie carries
+        // it to the next page, which also clears that cookie.
+        const resets = new WeakMap();
+        const sessionOf = (request) => 
+        // Static paths excluded by the session plugin have none (`request.session` is null).
+        request.session ? sessions?.of(request) : undefined;
+        const hooks = Object.freeze({
+            sealOf: (request) => server.sealOf(request),
+            ...(sessions
+                ? {
+                    historyReset: async (request) => {
+                        const now = sessionOf(request)?.historyReset?.() === true;
+                        const carried = hasCookie(request.headers.cookie, HISTORY_RESET_COOKIE);
+                        if (now || carried)
+                            resets.set(request, { served: now, read: carried });
+                        return now || carried;
+                    },
+                }
+                : {}),
+        });
+        if (sessions) {
+            const carry = async (scope) => {
+                scope.addHook('onSend', async (request, reply, payload) => {
+                    const state = resets.get(request);
+                    const reset = sessionOf(request)?.historyReset?.() === true;
+                    if (!(reset && !state?.served) && !state?.read)
+                        return payload;
+                    const set = reset && !state?.served;
+                    reply.header('set-cookie', `${HISTORY_RESET_COOKIE}=${set ? '1' : ''}; Path=/; Max-Age=${set ? HISTORY_RESET_SECONDS : 0}; HttpOnly; SameSite=Lax${request.protocol === 'https' ? '; Secure' : ''}`);
+                    if (logger.isEnabled('debug'))
+                        logger.log('debug', 'Inertia history reset cookie', {
+                            operation: set ? 'set' : 'clear',
+                        });
+                    return payload;
+                });
+            };
+            // Without encapsulation (skip-override), so the hook sees every route.
+            carry[Symbol.for('skip-override')] = true;
+            server.register(carry, {});
+        }
         // Development (D-0045): one Vite dev server for every scope, started by the first `vite`.
         const develop = viteDevRequested();
         logger.log('debug', 'Inertia settings resolved', {
@@ -217,6 +274,8 @@ class InertiaRuntime {
             defaultVersion: this.settings.defaultVersion,
             shared: this.shared !== undefined,
             flash: flash !== undefined,
+            historyReset: hooks.historyReset !== undefined,
+            encryptHistory: this.settings.document.encryptHistory,
         });
         // Per-request failures are logged once per interval with the count of repeats (D-0047).
         const repeats = new Repeats();
@@ -411,9 +470,9 @@ class InertiaRuntime {
             const render = responder.render.bind(responder);
             return Object.freeze({
                 render: develop
-                    ? (request, reply, component, props) => {
+                    ? (request, reply, component, props, options) => {
                         pageHosts.add(hostName(request));
-                        return render(request, reply, component, props);
+                        return render(request, reply, component, props, options);
                     }
                     : render,
                 redirect: responder.redirect.bind(responder),
@@ -422,14 +481,24 @@ class InertiaRuntime {
         };
         // Prop evaluation (debug) and rescued deferred props (error) are logged by every scope.
         const diagnostics = Object.freeze({ logger, repeats });
-        const root = api(new InertiaResponder(document, this.shared, await serverRendering(this.settings.ssr, this.settings.vite), diagnostics, flash));
+        const root = api(new InertiaResponder(document, this.shared, await serverRendering(this.settings.ssr, this.settings.vite), diagnostics, flash, hooks));
         const shared = this.shared;
         return Object.freeze({
             ...root,
             ssrStats: () => Object.freeze({ ...stats }),
             scope: async (options) => {
-                const { shared: extra, vite, ssr: ssrInput, ...fields } = (options ?? {});
+                const { shared: extra, vite, ssr: ssrInput, sealed = false, ...fields } = (options ?? {});
+                if (typeof sealed !== 'boolean')
+                    throw new TypeError('Inertia scope sealed must be a boolean');
                 const ssr = ssrInput === undefined ? this.settings.ssr : parseSsr(ssrInput);
+                if (sealed && ssr) {
+                    logger.log('error', 'Inertia scope of seal hosts with SSR', {
+                        code: 'SEAL_SSR_CONFLICT',
+                        title: typeof fields.title === 'string' ? fields.title.slice(0, 100) : null,
+                        fix: 'Set inertia.ssr: false for this app, or remove seal: true from its domains',
+                    });
+                    throw sealSsrConflict();
+                }
                 if (extra !== undefined && typeof extra !== 'function')
                     throw new TypeError('Inertia scope shared must be a function');
                 if (vite !== undefined && ['version', 'scripts', 'styles'].some((key) => key in fields))
@@ -443,13 +512,15 @@ class InertiaRuntime {
                     ? async (request) => ({ ...(await shared(request)), ...(await extra(request)) })
                     : (extra ?? shared);
                 const scopedVite = vite === undefined ? this.settings.vite : parseVite(vite);
-                const responder = new InertiaResponder(scoped, merged, await serverRendering(ssr, scopedVite), diagnostics, flash);
+                const responder = new InertiaResponder(scoped, merged, await serverRendering(ssr, scopedVite), diagnostics, flash, hooks);
                 logger.log('debug', 'Inertia scope created', {
                     title: scoped.title,
                     rootId: scoped.rootId,
                     vite: scopedVite ? scopedVite.entry : false,
                     ssr: ssr ? ssr.bundle : false,
                     shared: merged !== undefined,
+                    sealed,
+                    encryptHistory: scoped.encryptHistory,
                 });
                 return api(responder);
             },
@@ -458,7 +529,7 @@ class InertiaRuntime {
 }
 export const createPlugin = definePlugin({
     name: 'dokebi-template-inertia',
-    version: '0.1.3',
+    version: '0.2.0',
     core: '^0.2.0',
     options: parseOptions,
     entry: parseEntry,

package/dist/responder.d.ts

@@ -13,6 +13,31 @@ export interface InertiaOptions {
     title?: string;
     scripts?: readonly string[];
     styles?: readonly string[];
+    /**
+     * Inertia history encryption of the pages (D-0062): `true`, `false`, or `'sealed'` (default):
+     * on for sealed requests (seal hosts), so props kept in the browser history are encrypted too.
+     */
+    encryptHistory?: boolean | 'sealed';
+}
+/** Per response history settings; unset values come from the scope (`encryptHistory`) and session. */
+export interface InertiaRenderOptions {
+    /** Encrypt this page in the browser history (Inertia `encryptHistory`). */
+    readonly encryptHistory?: boolean;
+    /**
+     * Clear the encrypted history before showing this page. Unset: true for the first page after
+     * the session was destroyed or regenerated (@dokebi/session 0.2 `historyReset`, logout, login).
+     */
+    readonly clearHistory?: boolean;
+}
+/**
+ * What the plugin gives a responder besides its options: the sealing of a request (dokebi-web
+ * `sealOf`) and the session's history reset signal.
+ */
+export interface InertiaHooks {
+    readonly sealOf?: (request: FastifyRequest) => {
+        encode(text: string): string;
+    } | undefined;
+    readonly historyReset?: (request: FastifyRequest) => Promise<boolean>;
 }
 /** The page object Inertia hands to the client and to the SSR bundle. */
 export interface InertiaPage {
@@ -66,7 +91,7 @@ export interface InertiaSsr {
     readonly failed?: (error: unknown, component: string) => void;
 }
 export interface InertiaApi {
-    render(request: FastifyRequest, reply: FastifyReply, component: string, props?: Props): Promise<FastifyReply>;
+    render(request: FastifyRequest, reply: FastifyReply, component: string, props?: Props, options?: InertiaRenderOptions): Promise<FastifyReply>;
     redirect(request: FastifyRequest, reply: FastifyReply, url: string): FastifyReply;
     location(request: FastifyRequest, reply: FastifyReply, url: string): FastifyReply;
 }
@@ -79,10 +104,11 @@ export declare class InertiaResponder implements InertiaApi {
     readonly ssr?: InertiaSsr | undefined;
     readonly diagnostics?: InertiaDiagnostics | undefined;
     readonly flash?: InertiaFlash | undefined;
+    readonly hooks: InertiaHooks;
     readonly options: NormalizedInertiaOptions;
-    constructor(options?: InertiaOptions, shared?: ((request: FastifyRequest) => Awaitable<Props>) | undefined, ssr?: InertiaSsr | undefined, diagnostics?: InertiaDiagnostics | undefined, flash?: InertiaFlash | undefined);
+    constructor(options?: InertiaOptions, shared?: ((request: FastifyRequest) => Awaitable<Props>) | undefined, ssr?: InertiaSsr | undefined, diagnostics?: InertiaDiagnostics | undefined, flash?: InertiaFlash | undefined, hooks?: InertiaHooks);
     close(): void;
-    render(request: FastifyRequest, reply: FastifyReply, component: string, input?: Props): Promise<never>;
+    render(request: FastifyRequest, reply: FastifyReply, component: string, input?: Props, history?: InertiaRenderOptions): Promise<never>;
     redirect(request: FastifyRequest, reply: FastifyReply, url: string): FastifyReply<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
     location(request: FastifyRequest, reply: FastifyReply, url: string): FastifyReply<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
 }

package/dist/responder.js

@@ -25,7 +25,7 @@ export function normalizeInertiaOptions(options = {}) {
     if (!options ||
         typeof options !== 'object' ||
         Array.isArray(options) ||
-        Object.keys(options).some((key) => !['version', 'rootId', 'title', 'scripts', 'styles'].includes(key)))
+        Object.keys(options).some((key) => !['version', 'rootId', 'title', 'scripts', 'styles', 'encryptHistory'].includes(key)))
         throw new TypeError('Invalid Inertia options');
     for (const assets of [options.scripts, options.styles]) {
         if (assets !== undefined &&
@@ -38,11 +38,13 @@ export function normalizeInertiaOptions(options = {}) {
         title: options.title ?? '',
         scripts: Object.freeze([...(options.scripts ?? [])]),
         styles: Object.freeze([...(options.styles ?? [])]),
+        encryptHistory: options.encryptHistory ?? 'sealed',
     };
     if (typeof normalized.version !== 'string' ||
         typeof normalized.title !== 'string' ||
         typeof normalized.rootId !== 'string' ||
-        !/^[A-Za-z][A-Za-z0-9_-]*$/.test(normalized.rootId))
+        !/^[A-Za-z][A-Za-z0-9_-]*$/.test(normalized.rootId) ||
+        (typeof normalized.encryptHistory !== 'boolean' && normalized.encryptHistory !== 'sealed'))
         throw new TypeError('Invalid Inertia document settings');
     for (const asset of [...normalized.scripts, ...normalized.styles])
         localUrl(asset);
@@ -53,13 +55,15 @@ export class InertiaResponder {
     ssr;
     diagnostics;
     flash;
+    hooks;
     options;
     #closed = false;
-    constructor(options = {}, shared, ssr, diagnostics, flash) {
+    constructor(options = {}, shared, ssr, diagnostics, flash, hooks = {}) {
         this.shared = shared;
         this.ssr = ssr;
         this.diagnostics = diagnostics;
         this.flash = flash;
+        this.hooks = hooks;
         this.options = normalizeInertiaOptions(options);
     }
     close() {
@@ -69,8 +73,13 @@ export class InertiaResponder {
         if (this.#closed)
             throw new Error('Inertia responder is closed');
     }
-    async render(request, reply, component, input = {}) {
+    async render(request, reply, component, input = {}, history = {}) {
         this.#check();
+        if (history === null ||
+            typeof history !== 'object' ||
+            (history.encryptHistory !== undefined && typeof history.encryptHistory !== 'boolean') ||
+            (history.clearHistory !== undefined && typeof history.clearHistory !== 'boolean'))
+            throw new TypeError('Inertia render options are { encryptHistory?, clearHistory? } booleans');
         if (!['GET', 'HEAD'].includes(request.method))
             throw new Error('Render pages using GET/HEAD; redirect mutations or use REST');
         if (typeof component !== 'string' ||
@@ -88,6 +97,10 @@ export class InertiaResponder {
                 .header('X-Inertia-Version', this.options.version)
                 .send();
         }
+        // A sealed request (seal host, D-0062): the props leave as one sealed frame, never as HTML.
+        const sealer = this.hooks.sealOf?.(request);
+        if (sealer && this.ssr && !inertia)
+            throw Object.assign(new Error('A sealed page cannot be server rendered: SSR writes the props as plain HTML. Turn off ssr for this app or seal for its hosts.'), { code: 'SEAL_SSR_CONFLICT' });
         const props = { ...(await this.shared?.(request)), ...input };
         const partial = inertia && request.headers['x-inertia-partial-component'] === component;
         const list = (key) => typeof request.headers[key] === 'string'
@@ -111,6 +124,11 @@ export class InertiaResponder {
         const values = await Promise.all(meta.selected.map(([key, value, prop]) => this.#evaluate(component, key, value, prop, meta.rescued)));
         // Read after the props: a failed render leaves the flash for the next page.
         const flash = this.flash && !deferredFetch ? await this.flash(request) : undefined;
+        // Read like the flash: once, by the page that shows it (logout or login happened before).
+        const clearHistory = history.clearHistory ??
+            (this.hooks.historyReset && !deferredFetch ? await this.hooks.historyReset(request) : false);
+        const configured = this.options.encryptHistory;
+        const encryptHistory = history.encryptHistory ?? (configured === 'sealed' ? sealer !== undefined : configured);
         const resolved = Object.create(null);
         resolved.errors = {};
         meta.selected.forEach(([key], index) => {
@@ -132,8 +150,8 @@ export class InertiaResponder {
             props: resolved,
             url: request.url,
             version: this.options.version,
-            clearHistory: false,
-            encryptHistory: false,
+            clearHistory,
+            encryptHistory,
             ...meta.page,
             ...(meta.rescued.length ? { rescuedProps: meta.rescued } : {}),
             ...(flash && Object.keys(flash).length ? { flash } : {}),
@@ -148,9 +166,25 @@ export class InertiaResponder {
                 throw new TypeError('Page props must be JSON serializable');
             return value;
         });
+        if (logger?.isEnabled('debug') && (sealer || clearHistory))
+            logger.log('debug', 'Inertia page history and seal', {
+                component,
+                sealed: sealer !== undefined,
+                encryptHistory,
+                clearHistory,
+            });
+        // The XHR answer is JSON: dokebi-web seals it on the way out for a sealed request.
         if (inertia)
             return reply.header('X-Inertia', 'true').type('application/json; charset=utf-8').send(json);
         const { rootId, title, scripts, styles } = this.options;
+        if (sealer) {
+            // `E:<ts>:<base64>` holds no HTML specials; the client opens it before Inertia starts
+            // (`sealInertia` of @dokebi/seal/http). No SSR here (refused above).
+            const frame = sealer.encode(json);
+            return reply
+                .type('text/html; charset=utf-8')
+                .send(`<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${escapeHtml(title)}</title>${styles.map((url) => `<link rel="stylesheet" href="${escapeHtml(url)}">`).join('')}${scripts.map((url) => `<script type="module" src="${escapeHtml(url)}"></script>`).join('')}</head><body><script data-page="${rootId}" type="application/json" data-sealed="true">${escapeHtml(frame)}</script><div id="${rootId}"></div></body></html>`);
+        }
         // Only the first HTML is server rendered; Inertia visits above stay JSON.
         const rendered = this.ssr ? await this.#serverRender(JSON.parse(json), rootId) : undefined;
         const safeJson = json

package/options.schema.json

@@ -66,6 +66,18 @@
           "description": "When render throws: answer the client-rendered page and log (fallback, default) or fail the request (error)"
         }
       }
+    },
+    "encryptHistory": {
+      "default": "sealed",
+      "oneOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "const": "sealed"
+        }
+      ],
+      "description": "Inertia history encryption (D-0062): true, false, or sealed (default) = on for requests of seal hosts"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dokebi/template-inertia",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   },
   "peerDependencies": {
     "@dokebi/core": "^0.2.0",
-    "@dokebi/web": "^0.1.0",
+    "@dokebi/web": "^0.2.0",
     "fastify": "^5.12.7"
   },
   "dokebi": {
@@ -40,11 +40,11 @@
     "dependencies": [
       {
         "name": "dokebi-web",
-        "version": "^0.1.0"
+        "version": "^0.2.0"
       },
       {
         "name": "dokebi-session",
-        "version": "^0.1.0",
+        "version": "^0.1.0 || ^0.2.0",
         "optional": true
       }
     ],
@@ -58,8 +58,8 @@
     "documentation": "AI.md"
   },
   "devDependencies": {
-    "@dokebi/session": "0.1.0",
-    "@dokebi/web": "0.1.2"
+    "@dokebi/session": "0.2.0",
+    "@dokebi/web": "0.2.0"
   },
   "publishConfig": {
     "access": "public",