@h-ai/crypto 1.0.0-beta.21 → 1.0.0-beta.22

package/README.en.md

@@ -60,9 +60,9 @@ Initialize crypto successfully before using algorithms. Check HaiResult.success
 | `manager.decryptRequest`              | Authenticate and decrypt a request    | `payload: EncryptedRequestPayload, expected: TransportRequestContext`     | `Promise<HaiResult<string>>`                           | `await manager.decryptRequest(encryptedRequest, requestContext)`                                        |
 | `manager.encryptResponse`             | Authenticate and encrypt a response   | `request: TransportMessageContext, data: string, status: number`          | `Promise<HaiResult<EncryptedPayload>>`                 | `await manager.encryptResponse(messageContext, "{}", 200)`                                              |
 | `manager.close`                       | Release manager resources             | `—`                                                                       | `Promise<void>`                                        | `await manager.close()`                                                                                 |
-| `session.init`                        | Initialize the encrypted session      | `—`                                                                       | `Promise<HaiResult<void>>`                             | `await session.init()`                                                                                  |
+| `session.init`                        | Obtain a usable transport session     | `—`                                                                       | `Promise<HaiResult<void>>`                             | `await session.init()`                                                                                  |
 | `session.encryptedFetch`              | Call an encrypted endpoint            | `input: RequestInfo / URL, init?: RequestInit`                            | `Promise<Response>`                                    | `await session.encryptedFetch("https://api.example.com/api/v1/orders")`                                 |
-| `session.ready`                       | Check handshake readiness             | `—`                                                                       | `boolean`                                              | `session.ready()`                                                                                       |
+| `session.ready`                       | Check readiness for a new request     | `—`                                                                       | `boolean`                                              | `session.ready()`                                                                                       |
 | `session.destroy`                     | Clear the local transport session     | `—`                                                                       | `void`                                                 | `session.destroy()`                                                                                     |
 
 Shared server/browser support (Node.js / browser)
@@ -204,8 +204,8 @@ Call `crypto.transport.createServer({ serverKeyRing, keyStore })` / `createClien
 
 1. Call `await crypto.init()` to initialize `crypto.asymmetric` and `crypto.symmetric`.
 2. On the server, create a `manager` with `crypto.transport.createServer({ serverKeyRing, keyStore })`. It holds the server key pair and stores client public keys. Inject a shared `keyStore` for multi-node deployments.
-3. Expose a POST key exchange endpoint: accept `{ clientPublicKey }`, register it with `manager.registerClientKey()`, and return `{ serverKeyId: manager.getServerKeyId(), serverPublicKey: manager.getServerPublicKey(), clientId }`.
-4. On the client, create a session with `crypto.transport.createClient({ keyExchangeUrl })`. The first `client.init()` or `client.encryptedFetch()` automatically performs key exchange.
+3. The POST key exchange endpoint accepts `{ clientPublicKey }`, registers it with `manager.registerClientKey()`, and returns `clientId`, `serverKeyId`, `serverPublicKey`, `maxPlaintextBytes` and optional `clientKeyTtlSeconds`. Serv and Kit take the lifetime from the registry. Custom adapters can read `manager.clientKeyTtlSeconds`.
+4. On the client, create a session with `crypto.transport.createClient({ keyExchangeUrl })`. Both `client.init()` and `client.encryptedFetch()` exchange keys on first use and when the registration nears expiry. Concurrent requests share the handshake and wait for it to succeed before sending.
 5. Every request sends an authenticated envelope `{ context, direction, status, encryptedKey, ciphertext, iv, tag, signature }`, including empty POST and GET/HEAD.
 6. Custom adapters first await `authenticateTransportRequest(manager, request)`. Only successful `data.plaintext` reaches business code; retain `data.context`.
 7. Encrypt responses with `await manager.encryptResponse(context, data, response.status)`; clients verify context, status and authenticity before returning plaintext.

package/README.ja.md

@@ -60,9 +60,9 @@ if (!initialized.success)
 | `manager.decryptRequest`              | リクエストを認証して復号する           | `payload: EncryptedRequestPayload, expected: TransportRequestContext`     | `Promise<HaiResult<string>>`                           | `await manager.decryptRequest(encryptedRequest, requestContext)`                                        |
 | `manager.encryptResponse`             | 対応する応答を認証して暗号化する       | `request: TransportMessageContext, data: string, status: number`          | `Promise<HaiResult<EncryptedPayload>>`                 | `await manager.encryptResponse(messageContext, "{}", 200)`                                              |
 | `manager.close`                       | 管理器のリソースを解放する             | `—`                                                                       | `Promise<void>`                                        | `await manager.close()`                                                                                 |
-| `session.init`                        | 暗号化セッションを初期化する           | `—`                                                                       | `Promise<HaiResult<void>>`                             | `await session.init()`                                                                                  |
+| `session.init`                        | 利用可能な通信セッションを取得する     | `—`                                                                       | `Promise<HaiResult<void>>`                             | `await session.init()`                                                                                  |
 | `session.encryptedFetch`              | 暗号化エンドポイントを呼び出す         | `input: RequestInfo / URL, init?: RequestInit`                            | `Promise<Response>`                                    | `await session.encryptedFetch("https://api.example.com/api/v1/orders")`                                 |
-| `session.ready`                       | ハンドシェイク済みか確認する           | `—`                                                                       | `boolean`                                              | `session.ready()`                                                                                       |
+| `session.ready`                       | 新しいリクエストを送信できるか確認する | `—`                                                                       | `boolean`                                              | `session.ready()`                                                                                       |
 | `session.destroy`                     | ローカルの暗号化セッションを消去する   | `—`                                                                       | `void`                                                 | `session.destroy()`                                                                                     |
 
 サーバー・ブラウザー共通（Node.js / ブラウザー）
@@ -202,8 +202,8 @@ if (hashed.success) {
 
 1. `await crypto.init()` を呼び、`crypto.asymmetric` と `crypto.symmetric` を初期化します。
 2. サーバーで `crypto.transport.createServer({ serverKeyRing, keyStore })` を呼び、`manager` を作成します。サーバー鍵ペアとクライアント公開鍵を管理します。複数ノードでは共有 `keyStore` を注入できます。
-3. POST の鍵交換 endpoint を用意します。`{ clientPublicKey }` を受け取り、`manager.registerClientKey()` で登録し、`{ serverKeyId: manager.getServerKeyId(), serverPublicKey: manager.getServerPublicKey(), clientId }` を返します。
-4. クライアントで `crypto.transport.createClient({ keyExchangeUrl })` によりセッションを作成します。最初の `client.init()` または `client.encryptedFetch()` で鍵交換が自動実行されます。
+3. POST の鍵交換エンドポイントは `{ clientPublicKey }` を受け取り、`manager.registerClientKey()` で登録します。応答には `clientId`、`serverKeyId`、`serverPublicKey`、`maxPlaintextBytes`、設定時は `clientKeyTtlSeconds` が含まれます。Serv と Kit は登録ストアの有効期間を返します。独自アダプターでは `manager.clientKeyTtlSeconds` を参照できます。
+4. クライアントで `crypto.transport.createClient({ keyExchangeUrl })` によりセッションを作成します。`client.init()` と `client.encryptedFetch()` は、初回利用時と登録期限が近づいたときに鍵交換を行います。同時に発生したリクエストは鍵交換を共有し、成功してから送信します。
 5. 空の POST と GET/HEAD を含め、すべての要求が認証封装 `{ context, direction, status, encryptedKey, ciphertext, iv, tag, signature }` を送ります。
 6. 独自アダプターは先に `await authenticateTransportRequest(manager, request)` を実行し、成功時のみ `data.plaintext` を業務へ渡し、`data.context` を保持します。
 7. 応答は `await manager.encryptResponse(context, data, response.status)` で元要求に関連付け、クライアントがコンテキスト・status・完全性を検証してから平文を返します。

package/README.md

@@ -60,9 +60,9 @@ if (!initialized.success)
 | `manager.decryptRequest`              | 验证并解密请求            | `payload: EncryptedRequestPayload, expected: TransportRequestContext`     | `Promise<HaiResult<string>>`                           | `await manager.decryptRequest(encryptedRequest, requestContext)`                                        |
 | `manager.encryptResponse`             | 认证并加密关联响应        | `request: TransportMessageContext, data: string, status: number`          | `Promise<HaiResult<EncryptedPayload>>`                 | `await manager.encryptResponse(messageContext, "{}", 200)`                                              |
 | `manager.close`                       | 释放管理器资源            | `—`                                                                       | `Promise<void>`                                        | `await manager.close()`                                                                                 |
-| `session.init`                        | 显式执行握手              | `—`                                                                       | `Promise<HaiResult<void>>`                             | `await session.init()`                                                                                  |
+| `session.init`                        | 取得可用传输会话          | `—`                                                                       | `Promise<HaiResult<void>>`                             | `await session.init()`                                                                                  |
 | `session.encryptedFetch`              | 按 fetch 契约调用加密接口 | `input: RequestInfo / URL, init?: RequestInit`                            | `Promise<Response>`                                    | `await session.encryptedFetch("https://api.example.com/api/v1/orders")`                                 |
-| `session.ready`                       | 检查握手状态              | `—`                                                                       | `boolean`                                              | `session.ready()`                                                                                       |
+| `session.ready`                       | 检查会话能否发送新请求    | `—`                                                                       | `boolean`                                              | `session.ready()`                                                                                       |
 | `session.destroy`                     | 清除本地传输会话          | `—`                                                                       | `void`                                                 | `session.destroy()`                                                                                     |
 
 SM2/SM3/SM4 与传输支持 Node.js / 浏览器；密码哈希仅服务端
@@ -204,8 +204,8 @@ if (hashed.success) {
 
 1. 先 `await crypto.init()`，确保 `crypto.asymmetric` 与 `crypto.symmetric` 已初始化。
 2. 服务端调用 `crypto.transport.createServer({ serverKeyRing, keyStore })` 创建 `manager`；它持有服务端密钥对，并负责保存客户端公钥。多节点部署时可注入共享 `keyStore`。
-3. 服务端提供一个 POST 密钥协商端点：接收 `{ clientPublicKey }`，调用 `manager.registerClientKey()` 注册客户端，再返回 `{ serverKeyId: manager.getServerKeyId(), serverPublicKey: manager.getServerPublicKey(), clientId }`。
-4. 客户端调用 `crypto.transport.createClient({ keyExchangeUrl })` 创建会话；首次 `client.init()` 或 `client.encryptedFetch()` 会自动完成这次协商。
+3. 服务端的 POST 密钥协商端点接收 `{ clientPublicKey }`，调用 `manager.registerClientKey()` 后返回 `clientId`、`serverKeyId`、`serverPublicKey`、`maxPlaintextBytes` 和可选的 `clientKeyTtlSeconds`。Serv/Kit 自动从注册表取得有效期，自定义适配器可读取 `manager.clientKeyTtlSeconds`。
+4. 客户端调用 `crypto.transport.createClient({ keyExchangeUrl })` 创建会话。首次使用或登记临近到期时，`client.init()` 和 `client.encryptedFetch()` 按需协商。并发请求共享握手，协商成功后才发送业务请求。
 5. 每次请求都发送认证封装 `{ context, direction, status, encryptedKey, ciphertext, iv, tag, signature }`；空 POST 和 GET/HEAD 也必须认证。
 6. 自定义适配器先 `await authenticateTransportRequest(manager, request)`，成功后才将 `data.plaintext` 交给业务并保存 `data.context`。
 7. 响应用 `await manager.encryptResponse(context, data, response.status)` 关联原请求；客户端校验上下文、状态和完整性后才返回明文。

package/dist/index.d.ts

@@ -211,20 +211,28 @@ interface KeyExchangeRequest {
     readonly clientPublicKey: string;
 }
 /**
- * TLS协商响应，公开服务端版本、公钥和registry生成的clientId；不含服务端私钥。
+ * TLS 协商响应，包含服务端公钥、密钥版本和客户端登记信息。
  *
  * @example
  * ```ts
  * import type { KeyExchangeRequest, KeyExchangeResponse, TransportEncryptionManager } from '@h-ai/crypto'
  * async function exchange(manager: TransportEncryptionManager, body: KeyExchangeRequest): Promise<KeyExchangeResponse> {
  *   const clientId = await manager.registerClientKey(body.clientPublicKey)
- *   return { clientId, serverKeyId: manager.getServerKeyId(), serverPublicKey: manager.getServerPublicKey() }
+ *   return {
+ *     clientId,
+ *     serverKeyId: manager.getServerKeyId(),
+ *     serverPublicKey: manager.getServerPublicKey(),
+ *     maxPlaintextBytes: manager.bodyLimits.plaintextBytes,
+ *     clientKeyTtlSeconds: manager.clientKeyTtlSeconds,
+ *   }
  * }
  * ```
  */
 interface KeyExchangeResponse {
     /** 服务端业务明文 UTF-8 字节上限；缺省表示旧服务端的 1 MiB 默认值。 */
     readonly maxPlaintextBytes?: number;
+    /** 客户端公钥从登记起的寿命，单位为秒；省略时客户端按无已知期限处理。 */
+    readonly clientKeyTtlSeconds?: number;
     /** 服务端当前加密密钥版本；业务请求必须带回该值。 */
     readonly serverKeyId: string;
     readonly serverPublicKey: string;
@@ -441,6 +449,8 @@ interface TransportCryptoServiceLike {
 interface TransportKeyStore {
     /** 公钥与nonce状态的真实共享能力；生产只接受shared。 */
     readonly stateScope: 'local' | 'shared';
+    /** 登记时赋予新公钥的 TTL，整数秒，范围 1～2147483647；未指定期限时省略。 */
+    readonly clientKeyTtlSeconds?: number;
     /**
      * 注册有效 SM2 公钥，返回服务端生成的 clientId；格式/曲线点无效或存储故障必须 reject。
      * 容量策略见具体工厂契约：数据库满容量拒绝，开发/测试内存实现允许 FIFO 淘汰公钥。
@@ -631,6 +641,8 @@ interface TransportCreateServerOptions {
 interface TransportEncryptionManager {
     /** 本管理器不可变的双向预算；由 maxPlaintextBytes 推导，安全预算独立。 */
     readonly bodyLimits: TransportBodyLimits;
+    /** 共享 registry 的客户端公钥 TTL，单位为秒，由协商响应传给客户端。 */
+    readonly clientKeyTtlSeconds?: number;
     /**
      * 当前新协商使用的服务端密钥 ID。
      * @returns 直接返回值，使用前先初始化模块。
@@ -759,7 +771,7 @@ interface TransportEncryptionManager {
     close: () => Promise<void>;
 }
 /**
- * 客户端单会话；首次调用自动协商，后续请求生成随机nonce并认证响应关联/签名/MAC。
+ * 客户端传输会话；首次调用或登记临近到期时按需协商，随后认证本次请求和响应。
  * init返回HaiResult；encryptedFetch按fetch契约reject；destroy清本地会话，不代表撤销服务端registry。
  *
  * @example
@@ -782,9 +794,9 @@ interface TransportEncryptionManager {
  */
 interface TransportClient {
     /**
-     * 完成密钥协商；多次调用幂等（同一会话只协商一次）。
+     * 取得可用的传输会话；并发调用共享握手，有效期内复用已有会话。
      *
-     * 通常无需手动调用：`encryptedFetch` 在首次请求前会自动 `init()`。
+     * `encryptedFetch` 在发送请求前会自动取得可用会话。
      * 协商在 30 秒内完成，握手 JSON 与单个公钥分别受 TRANSPORT_BODY_LIMITS 限制。
      * @returns HaiResult，先检查success再读取data。
      *
@@ -834,8 +846,8 @@ interface TransportClient {
      */
     encryptedFetch: typeof fetch;
     /**
-     * 是否已完成密钥协商。
-     * @returns 直接boolean，false表示不匹配/未就绪。
+     * 检查本地会话是否可用于发起新请求。
+     * @returns 已完成协商且尚未到续期时间时返回 true。
      *
      * @example
      * ```ts
@@ -1804,7 +1816,7 @@ interface TransportOperations {
      * options.fetch：实际发送 HTTP 请求的 fetch（默认 `globalThis.fetch`）。
      *
      * @remarks
-     * 返回的是“单会话”客户端：同一个实例会复用已协商得到的 `clientId` 与服务端公钥；
+     * 同一实例在登记有效期内复用 `clientId` 与服务端公钥，临近到期时在新请求前按需协商。
      * 调用 `destroy()` 后会回到未协商状态。
      * @param options - 实际调用输入，按该方法约束验证。
      * @param options.keyExchangeUrl - 密钥协商端点完整 URL。

package/dist/index.js

@@ -1058,6 +1058,9 @@ var TRANSPORT_TIME_LIMITS = Object.freeze({
 });
 
 // src/transport/crypto-transport-codec.ts
+function isValidTransportKeyTtlSeconds(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 2147483647;
+}
 function authenticatedText(payload) {
   const c = payload.context;
   return JSON.stringify([
@@ -1217,15 +1220,14 @@ async function createTransportErrorResponse(error, authenticated) {
 }
 
 // src/transport/crypto-transport-client.ts
+function isSessionUsable(session) {
+  return Date.now() < session.renewAt && performance.now() < session.monotonicRenewAt;
+}
 function createTransportClient(options) {
   const baseFetch = options.fetch ?? fetch;
   const localLimits = options.maxPlaintextBytes === void 0 ? void 0 : resolveTransportBodyLimits(options.maxPlaintextBytes);
-  let bodyLimits = localLimits ?? resolveTransportBodyLimits();
-  let keyPair = null;
-  let serverPublicKey = null;
-  let serverKeyId = null;
-  let clientId = null;
-  let initPromise = null;
+  let session;
+  let initPromise;
   let generation = 0;
   let handshakeController;
   async function doInit(attemptGeneration) {
@@ -1237,6 +1239,8 @@ function createTransportClient(options) {
       return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientKeyGenerateFailed"));
     const controller = new AbortController();
     handshakeController = controller;
+    const exchangeStartedAt = Date.now();
+    const monotonicStart = performance.now();
     const timeout = setTimeout(() => controller.abort(new DOMException("Key exchange timed out", "TimeoutError")), 3e4);
     try {
       let response;
@@ -1269,6 +1273,7 @@ function createTransportClient(options) {
       if (!isKeyExchangeResponse(body)) {
         return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeMissingFields"));
       }
+      let bodyLimits;
       try {
         const serverLimits = resolveTransportBodyLimits(body.maxPlaintextBytes);
         bodyLimits = resolveTransportBodyLimits(Math.min(localLimits?.plaintextBytes ?? serverLimits.plaintextBytes, serverLimits.plaintextBytes));
@@ -1277,11 +1282,21 @@ function createTransportClient(options) {
       }
       if (attemptGeneration !== generation || controller.signal.aborted)
         return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientNotInitialized"));
-      keyPair = localKeyPair;
-      serverPublicKey = body.serverPublicKey;
-      serverKeyId = body.serverKeyId;
-      clientId = body.clientId;
-      return ok(void 0);
+      const ttlMs = body.clientKeyTtlSeconds === void 0 ? Number.POSITIVE_INFINITY : body.clientKeyTtlSeconds * 1e3;
+      const usableMs = ttlMs - Math.min(ttlMs / 10, 3e4);
+      const nextSession = {
+        keyPair: localKeyPair,
+        serverPublicKey: body.serverPublicKey,
+        serverKeyId: body.serverKeyId,
+        clientId: body.clientId,
+        bodyLimits,
+        renewAt: exchangeStartedAt + usableMs,
+        monotonicRenewAt: monotonicStart + usableMs
+      };
+      if (!isSessionUsable(nextSession))
+        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeRequestFailed"));
+      session = nextSession;
+      return ok(nextSession);
     } finally {
       clearTimeout(timeout);
       if (handshakeController === controller)
@@ -1289,39 +1304,23 @@ function createTransportClient(options) {
     }
   }
   async function ensureReady() {
-    if (clientId && serverPublicKey)
-      return ok(void 0);
+    if (session && isSessionUsable(session))
+      return ok(session);
     if (!initPromise) {
-      const pending = doInit(generation).then((result) => {
-        if (!result.success && initPromise === pending)
-          initPromise = null;
-        return result;
+      session = void 0;
+      const pending = doInit(generation).finally(() => {
+        if (initPromise === pending)
+          initPromise = void 0;
       });
       initPromise = pending;
     }
     return initPromise;
   }
-  function encryptBody(plaintext, context) {
-    if (!serverPublicKey || !serverKeyId || !keyPair)
-      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientNotInitialized"));
-    return sealTransportPayload(options.crypto, plaintext, context, "request", 0, serverPublicKey, keyPair.privateKey, bodyLimits);
-  }
-  function decryptPayload(payload) {
-    if (!keyPair || !serverPublicKey)
-      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientNotInitialized"));
-    return openTransportPayload(options.crypto, payload, keyPair.privateKey, serverPublicKey, bodyLimits);
-  }
-  const encryptedFetch = async (input, init) => {
-    const requestInput = isRequestLike(input) ? input : void 0;
-    const signal = init?.signal ?? requestInput?.signal ?? void 0;
+  async function waitForSession(signal) {
     signal?.throwIfAborted();
-    const targetUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : requestInput?.url ?? String(input);
-    if (targetUrl === options.keyExchangeUrl)
-      return baseFetch(input, init);
     let onAbort;
-    let ready;
     try {
-      ready = await (signal ? Promise.race([
+      const ready = await (signal ? Promise.race([
         ensureReady(),
         new Promise((_resolve, reject) => {
           onAbort = () => reject(signal.reason);
@@ -1330,24 +1329,36 @@ function createTransportClient(options) {
             onAbort();
         })
       ]) : ensureReady());
+      if (!ready.success)
+        throw new Error(ready.error.message);
+      return ready.data;
     } finally {
       if (onAbort)
         signal?.removeEventListener("abort", onAbort);
     }
-    if (!ready.success)
-      throw new Error(ready.error.message);
+  }
+  const encryptedFetch = async (input, init) => {
+    const requestInput = isRequestLike(input) ? input : void 0;
+    const signal = init?.signal ?? requestInput?.signal ?? void 0;
+    signal?.throwIfAborted();
+    const targetUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : requestInput?.url ?? String(input);
+    if (targetUrl === options.keyExchangeUrl)
+      return baseFetch(input, init);
+    const requestGeneration = generation;
+    let requestSession = await waitForSession(signal);
+    if (requestGeneration !== generation)
+      throw new Error(cryptoM("crypto_transportClientNotInitialized"));
+    const method = (init?.method ?? requestInput?.method ?? "GET").toUpperCase();
+    const requestBody = init?.body != null ? new Response(init.body).body : method === "GET" || method === "HEAD" ? null : requestInput?.body ?? null;
+    const plaintext = await readTransportBody(requestBody, { maxBytes: requestSession.bodyLimits.plaintextBytes, signal });
+    if (requestGeneration === generation && (requestSession !== session || !isSessionUsable(requestSession)))
+      requestSession = await waitForSession(signal);
+    signal?.throwIfAborted();
+    if (requestGeneration !== generation || !isSessionUsable(requestSession))
+      throw new Error(cryptoM("crypto_transportClientNotInitialized"));
+    const { bodyLimits, clientId, keyPair, serverKeyId, serverPublicKey } = requestSession;
     const headers = new Headers(init?.headers ?? requestInput?.headers);
     headers.set(TRANSPORT_PROTOCOL.CLIENT_ID_HEADER, clientId);
-    let rawBody = init?.body;
-    if (rawBody == null && requestInput) {
-      const method2 = (init?.method ?? requestInput.method).toUpperCase();
-      if (method2 !== "GET" && method2 !== "HEAD") {
-        const text = await readTransportBody(requestInput.body, { maxBytes: bodyLimits.plaintextBytes, signal });
-        if (text)
-          rawBody = text;
-      }
-    }
-    const method = (init?.method ?? requestInput?.method ?? "GET").toUpperCase();
     const base = new URL(options.keyExchangeUrl, globalThis.location?.href ?? "http://localhost");
     const url = new URL(targetUrl, base);
     const pathHash = hashTransportPath(options.crypto, url.pathname + url.search);
@@ -1362,10 +1373,12 @@ function createTransportClient(options) {
       method,
       pathHash: pathHash.data
     };
-    const plaintext = rawBody == null ? "" : await readTransportBody(new Response(rawBody).body, { maxBytes: bodyLimits.plaintextBytes, signal });
-    const encResult = encryptBody(plaintext, context);
-    if (!encResult.success)
+    const encResult = sealTransportPayload(options.crypto, plaintext, context, "request", 0, serverPublicKey, keyPair.privateKey, bodyLimits);
+    if (!encResult.success) {
+      if (encResult.error.cause instanceof TransportBodyTooLargeError)
+        throw encResult.error.cause;
       throw new Error(encResult.error.message);
+    }
     const serialized = JSON.stringify(encResult.data);
     if (new TextEncoder().encode(serialized).byteLength > bodyLimits.encryptedPayloadBytes)
       throw new TransportBodyTooLargeError(bodyLimits.encryptedPayloadBytes, new TextEncoder().encode(serialized).byteLength, { stage: "encrypted" });
@@ -1432,7 +1445,9 @@ function createTransportClient(options) {
     if (!isValidEncryptedPayload(payload, bodyLimits) || payload.direction !== "response" || payload.status !== response.status || !sameTransportContext(payload.context, context)) {
       throw new Error(cryptoM("crypto_transportResponseDecryptFailed"));
     }
-    const decResult = decryptPayload(payload);
+    if (requestGeneration !== generation)
+      throw new Error(cryptoM("crypto_transportClientNotInitialized"));
+    const decResult = openTransportPayload(options.crypto, payload, keyPair.privateKey, serverPublicKey, bodyLimits);
     if (!decResult.success) {
       if (decResult.error.cause instanceof TransportBodyTooLargeError)
         throw decResult.error.cause;
@@ -1474,18 +1489,18 @@ function createTransportClient(options) {
     });
   };
   return {
-    init: ensureReady,
+    async init() {
+      const ready = await ensureReady();
+      return ready.success ? ok(void 0) : ready;
+    },
     encryptedFetch,
-    ready: () => clientId !== null && serverPublicKey !== null,
+    ready: () => session !== void 0 && isSessionUsable(session),
     destroy() {
       generation++;
       handshakeController?.abort();
       handshakeController = void 0;
-      keyPair = null;
-      serverPublicKey = null;
-      serverKeyId = null;
-      clientId = null;
-      initPromise = null;
+      session = void 0;
+      initPromise = void 0;
     }
   };
 }
@@ -1500,7 +1515,7 @@ function isKeyExchangeResponse(body) {
   if (!body || typeof body !== "object")
     return false;
   const fields = body;
-  return typeof fields.serverPublicKey === "string" && fields.serverPublicKey.length > 0 && new TextEncoder().encode(fields.serverPublicKey).byteLength <= TRANSPORT_BODY_LIMITS.publicKeyBytes && typeof fields.clientId === "string" && fields.clientId.length > 0 && typeof fields.serverKeyId === "string" && /^[\w-]{1,64}$/.test(fields.serverKeyId);
+  return typeof fields.serverPublicKey === "string" && fields.serverPublicKey.length > 0 && new TextEncoder().encode(fields.serverPublicKey).byteLength <= TRANSPORT_BODY_LIMITS.publicKeyBytes && typeof fields.clientId === "string" && fields.clientId.length > 0 && typeof fields.serverKeyId === "string" && /^[\w-]{1,64}$/.test(fields.serverKeyId) && (fields.clientKeyTtlSeconds === void 0 || isValidTransportKeyTtlSeconds(fields.clientKeyTtlSeconds));
 }
 function parseTransportServerKeyRing(serialized) {
   try {
@@ -1554,6 +1569,9 @@ function createTransportEncryption(cryptoService, options) {
   }
   if (core.module.requiresSharedState(globalThis.process?.env ?? {}) && options.keyStore.stateScope !== "shared")
     return err(HaiCryptoError.INVALID_INPUT, cryptoM("crypto_transportKeyStoreRequired"));
+  const { clientKeyTtlSeconds } = options.keyStore;
+  if (clientKeyTtlSeconds !== void 0 && !isValidTransportKeyTtlSeconds(clientKeyTtlSeconds))
+    return err(HaiCryptoError.INVALID_INPUT, cryptoM("crypto_transportKeyStoreTtlInvalid"));
   const serverKeys = /* @__PURE__ */ new Map();
   for (const [id, key] of Object.entries(ring.data.keys)) {
     const probe = cryptoService.asymmetric.encrypt("hai-transport-key-check", key.publicKey);
@@ -1569,6 +1587,7 @@ function createTransportEncryption(cryptoService, options) {
   const keyStore = options.keyStore;
   const manager = {
     bodyLimits,
+    clientKeyTtlSeconds,
     getServerKeyId() {
       return activeKeyId;
     },
@@ -1886,13 +1905,6 @@ function createInMemoryKeyStore(maxClients = DEFAULT_MAX_CLIENTS) {
 
 // src/transport/store-provider/crypto-transport-store-redis.ts
 var TRANSPORT_KEY_CACHE_PREFIX = "hai:crypto:transport:client";
-function normalizeTtlSeconds(ttlSeconds) {
-  if (ttlSeconds === void 0)
-    return void 0;
-  if (!Number.isSafeInteger(ttlSeconds) || ttlSeconds <= 0 || ttlSeconds > 2147483647)
-    throw new TypeError(cryptoM("crypto_transportKeyStoreTtlInvalid"));
-  return ttlSeconds;
-}
 function createClientId2() {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function")
     return `c_${crypto.randomUUID()}`;
@@ -1909,11 +1921,14 @@ function unwrapResult(operation, result) {
   throw toOperationError(operation, result.error);
 }
 function createRedisTransportKeyStore(options) {
-  const ttlSeconds = normalizeTtlSeconds(options.ttlSeconds);
+  const { ttlSeconds } = options;
+  if (ttlSeconds !== void 0 && !isValidTransportKeyTtlSeconds(ttlSeconds))
+    throw new TypeError(cryptoM("crypto_transportKeyStoreTtlInvalid"));
   function buildCacheKey(clientId) {
     return `${TRANSPORT_KEY_CACHE_PREFIX}:${clientId}`;
   }
   return {
+    clientKeyTtlSeconds: ttlSeconds,
     get stateScope() {
       return options.cache.config?.type === "redis" ? "shared" : "local";
     },
@@ -1972,7 +1987,7 @@ function unwrapResult2(operation, result) {
 }
 function createReldbTransportKeyStore(options) {
   const { ttlSeconds } = options;
-  if (ttlSeconds !== void 0 && (!Number.isSafeInteger(ttlSeconds) || ttlSeconds <= 0 || ttlSeconds > 2147483647))
+  if (ttlSeconds !== void 0 && !isValidTransportKeyTtlSeconds(ttlSeconds))
     throw new TypeError(cryptoM("crypto_transportKeyStoreTtlInvalid"));
   const maxClients = options.maxClients ?? 1e4;
   if (!Number.isSafeInteger(maxClients) || maxClients <= 0)
@@ -2072,6 +2087,7 @@ function createReldbTransportKeyStore(options) {
     return withCapacityLock(pruneRows);
   }
   return {
+    clientKeyTtlSeconds: ttlSeconds,
     get stateScope() {
       return options.reldb.config?.type && options.reldb.config.type !== "sqlite" ? "shared" : "local";
     },