@h-ai/crypto 0.1.0-alpha.66 → 0.1.0-alpha.68

package/dist/index.js

@@ -35,7 +35,15 @@ var en_US_default = {
   crypto_hashFormatInvalid: "Invalid hash format",
   crypto_passwordVerifyFailed: "Password verification failed",
   crypto_transportClientKeyGenerateFailed: "Failed to generate transport client key pair",
-  crypto_transportServerKeyGenerateFailed: "Failed to generate transport server key pair",
+  crypto_transportServerKeyRingInvalid: "Transport server key ring is missing or invalid",
+  crypto_transportServerKeyUnknown: "Transport server key version is unknown or revoked",
+  crypto_transportKeyStoreRequired: "Transport encryption requires an explicit client public key store",
+  crypto_transportKeyStoreTtlInvalid: "Public-key store TTL must be an integer between 1 and 2147483647 seconds",
+  crypto_transportKeyStoreCapacityInvalid: "Public-key store capacity must be a positive safe integer",
+  crypto_transportKeyStoreCapacityMismatch: "Public-key store shared capacity settings do not match",
+  crypto_transportKeyStoreCapacityReached: "Public-key store capacity has been reached",
+  crypto_transportKeyStoreOperationFailed: "Public-key store operation failed",
+  crypto_transportAuthenticationFailed: "Transport authentication, request binding or replay validation failed",
   crypto_transportKeyExchangeRequestFailed: "Transport key exchange request failed",
   crypto_transportKeyExchangeHttpFailed: "Transport key exchange returned HTTP {status}",
   crypto_transportKeyExchangeInvalidJson: "Transport key exchange response is not valid JSON",
@@ -50,6 +58,61 @@ var en_US_default = {
   crypto_transportSessionKeyDecryptFailed: "Failed to decrypt transport session key"
 };
 
+// messages/ja-JP.json
+var ja_JP_default = {
+  $schema: "https://inlang.com/schema/inlang-message-format",
+  crypto_notInitialized: "\u6697\u53F7\u30E2\u30B8\u30E5\u30FC\u30EB\u304C\u521D\u671F\u5316\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002\u5148\u306Bcrypto.init()\u3092\u547C\u3073\u51FA\u3057\u3066\u304F\u3060\u3055\u3044",
+  crypto_initFailed: "\u6697\u53F7\u30E2\u30B8\u30E5\u30FC\u30EB\u306E\u521D\u671F\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_sm2PublicKeyInvalid: "SM2\u516C\u958B\u9375\u306E\u5F62\u5F0F\u304C\u7121\u52B9\u3067\u3059",
+  crypto_sm2PrivateKeyInvalid: "SM2\u79D8\u5BC6\u9375\u306E\u5F62\u5F0F\u304C\u7121\u52B9\u3067\u3059",
+  crypto_sm2EncryptEmpty: "SM2\u6697\u53F7\u5316\u306E\u7D50\u679C\u304C\u7A7A\u3067\u3059",
+  crypto_sm2DecryptFailed: "SM2\u5FA9\u53F7\u306B\u5931\u6557\u3057\u305F\u304B\u3001\u7D50\u679C\u304C\u7121\u52B9\u3067\u3059",
+  crypto_sm2SignEmpty: "SM2\u7F72\u540D\u306E\u7D50\u679C\u304C\u7A7A\u3067\u3059",
+  crypto_sm2KeyPairGenerateFailed: "SM2\u9375\u30DA\u30A2\u306E\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_sm2EncryptFailed: "SM2\u6697\u53F7\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_sm2DecryptFailedWithError: "SM2\u5FA9\u53F7\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_sm2SignFailed: "SM2\u7F72\u540D\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_sm2VerifyFailed: "SM2\u7F72\u540D\u306E\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_sm3HashEmpty: "SM3\u30CF\u30C3\u30B7\u30E5\u306E\u7D50\u679C\u304C\u7A7A\u3067\u3059",
+  crypto_sm3HashFailed: "SM3\u30CF\u30C3\u30B7\u30E5\u306E\u8A08\u7B97\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_sm3HmacFailed: "HMAC-SM3\u306E\u8A08\u7B97\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_sm3VerifyFailed: "SM3\u30CF\u30C3\u30B7\u30E5\u306E\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_sm4KeyInvalid: "SM4\u9375\u306F16\u30D0\u30A4\u30C8\uFF0816\u9032\u657032\u6587\u5B57\uFF09\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+  crypto_sm4CbcNeedIv: "CBC\u30E2\u30FC\u30C9\u306B\u306FIV\u304C\u5FC5\u8981\u3067\u3059",
+  crypto_sm4IvInvalid: "SM4\u306EIV\u306F16\u30D0\u30A4\u30C8\uFF0816\u9032\u657032\u6587\u5B57\uFF09\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059",
+  crypto_sm4EncryptEmpty: "SM4\u6697\u53F7\u5316\u306E\u7D50\u679C\u304C\u7A7A\u3067\u3059",
+  crypto_sm4DecryptFailed: "SM4\u5FA9\u53F7\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_sm4EncryptFailed: "SM4\u6697\u53F7\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_sm4DecryptFailedWithError: "SM4\u5FA9\u53F7\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {error}",
+  crypto_passwordEmpty: "\u30D1\u30B9\u30EF\u30FC\u30C9\u3092\u7A7A\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093",
+  crypto_passwordHashEmpty: "\u30D1\u30B9\u30EF\u30FC\u30C9\u3068\u30CF\u30C3\u30B7\u30E5\u3092\u7A7A\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093",
+  crypto_passwordHashFailed: "\u30D1\u30B9\u30EF\u30FC\u30C9\u306E\u30CF\u30C3\u30B7\u30E5\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_hashFormatInvalid: "\u30CF\u30C3\u30B7\u30E5\u306E\u5F62\u5F0F\u304C\u7121\u52B9\u3067\u3059",
+  crypto_passwordVerifyFailed: "\u30D1\u30B9\u30EF\u30FC\u30C9\u306E\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportClientKeyGenerateFailed: "\u901A\u4FE1\u30AF\u30E9\u30A4\u30A2\u30F3\u30C8\u306E\u9375\u30DA\u30A2\u306E\u751F\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportServerKeyRingInvalid: "\u30C8\u30E9\u30F3\u30B9\u30DD\u30FC\u30C8\u306E\u30B5\u30FC\u30D0\u30FC\u30AD\u30FC\u30EA\u30F3\u30B0\u304C\u672A\u8A2D\u5B9A\u307E\u305F\u306F\u7121\u52B9\u3067\u3059",
+  crypto_transportServerKeyUnknown: "\u30C8\u30E9\u30F3\u30B9\u30DD\u30FC\u30C8\u306E\u30B5\u30FC\u30D0\u30FC\u30AD\u30FC\u30D0\u30FC\u30B8\u30E7\u30F3\u304C\u4E0D\u660E\u3001\u307E\u305F\u306F\u5931\u52B9\u3057\u3066\u3044\u307E\u3059",
+  crypto_transportKeyStoreRequired: "\u30C8\u30E9\u30F3\u30B9\u30DD\u30FC\u30C8\u6697\u53F7\u5316\u306B\u306F\u30AF\u30E9\u30A4\u30A2\u30F3\u30C8\u516C\u958B\u30AD\u30FC\u30B9\u30C8\u30A2\u306E\u660E\u793A\u7684\u306A\u6307\u5B9A\u304C\u5FC5\u8981\u3067\u3059",
+  crypto_transportKeyStoreTtlInvalid: "\u516C\u958B\u30AD\u30FC\u30B9\u30C8\u30A2\u306E TTL \u306F1\u301C2147483647\u79D2\u306E\u6574\u6570\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044",
+  crypto_transportKeyStoreCapacityInvalid: "\u516C\u958B\u30AD\u30FC\u30B9\u30C8\u30A2\u306E\u5BB9\u91CF\u306F\u6B63\u306E\u5B89\u5168\u306A\u6574\u6570\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044",
+  crypto_transportKeyStoreCapacityMismatch: "\u516C\u958B\u30AD\u30FC\u30B9\u30C8\u30A2\u306E\u5171\u6709\u5BB9\u91CF\u8A2D\u5B9A\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093",
+  crypto_transportKeyStoreCapacityReached: "\u516C\u958B\u30AD\u30FC\u30B9\u30C8\u30A2\u306E\u5BB9\u91CF\u4E0A\u9650\u306B\u9054\u3057\u307E\u3057\u305F",
+  crypto_transportKeyStoreOperationFailed: "\u516C\u958B\u30AD\u30FC\u30B9\u30C8\u30A2\u306E\u64CD\u4F5C\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportAuthenticationFailed: "\u30C8\u30E9\u30F3\u30B9\u30DD\u30FC\u30C8\u8A8D\u8A3C\u3001\u30EA\u30AF\u30A8\u30B9\u30C8\u3068\u306E\u7D10\u4ED8\u3051\u3001\u307E\u305F\u306F\u30EA\u30D7\u30EC\u30A4\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportKeyExchangeRequestFailed: "\u901A\u4FE1\u306E\u9375\u4EA4\u63DB\u30EA\u30AF\u30A8\u30B9\u30C8\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportKeyExchangeHttpFailed: "\u901A\u4FE1\u306E\u9375\u4EA4\u63DB\u3067HTTP {status}\u304C\u8FD4\u3055\u308C\u307E\u3057\u305F",
+  crypto_transportKeyExchangeInvalidJson: "\u901A\u4FE1\u306E\u9375\u4EA4\u63DB\u30EC\u30B9\u30DD\u30F3\u30B9\u304C\u6709\u52B9\u306AJSON\u3067\u306F\u3042\u308A\u307E\u305B\u3093",
+  crypto_transportKeyExchangeMissingFields: "\u901A\u4FE1\u306E\u9375\u4EA4\u63DB\u30EC\u30B9\u30DD\u30F3\u30B9\u306B\u5FC5\u9808\u30D5\u30A3\u30FC\u30EB\u30C9\u304C\u3042\u308A\u307E\u305B\u3093",
+  crypto_transportClientNotInitialized: "\u901A\u4FE1\u30AF\u30E9\u30A4\u30A2\u30F3\u30C8\u306E\u9375\u4EA4\u63DB\u304C\u5B8C\u4E86\u3057\u3066\u3044\u307E\u305B\u3093",
+  crypto_transportClientNotRegistered: "\u901A\u4FE1\u30AF\u30E9\u30A4\u30A2\u30F3\u30C8\u304C\u767B\u9332\u3055\u308C\u3066\u3044\u306A\u3044\u304B\u3001\u6709\u52B9\u671F\u9650\u304C\u5207\u308C\u3066\u3044\u307E\u3059",
+  crypto_transportRequestEncryptFailed: "\u901A\u4FE1\u30EA\u30AF\u30A8\u30B9\u30C8\u672C\u6587\u306E\u6697\u53F7\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportRequestDecryptFailed: "\u901A\u4FE1\u30EA\u30AF\u30A8\u30B9\u30C8\u672C\u6587\u306E\u5FA9\u53F7\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportResponseEncryptFailed: "\u901A\u4FE1\u30EC\u30B9\u30DD\u30F3\u30B9\u672C\u6587\u306E\u6697\u53F7\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportResponseDecryptFailed: "\u901A\u4FE1\u30EC\u30B9\u30DD\u30F3\u30B9\u672C\u6587\u306E\u5FA9\u53F7\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportSessionKeyEncryptFailed: "\u901A\u4FE1\u30BB\u30C3\u30B7\u30E7\u30F3\u9375\u306E\u6697\u53F7\u5316\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportSessionKeyDecryptFailed: "\u901A\u4FE1\u30BB\u30C3\u30B7\u30E7\u30F3\u9375\u306E\u5FA9\u53F7\u306B\u5931\u6557\u3057\u307E\u3057\u305F"
+};
+
 // messages/zh-CN.json
 var zh_CN_default = {
   $schema: "https://inlang.com/schema/inlang-message-format",
@@ -82,7 +145,15 @@ var zh_CN_default = {
   crypto_hashFormatInvalid: "\u65E0\u6548\u7684\u54C8\u5E0C\u683C\u5F0F",
   crypto_passwordVerifyFailed: "\u5BC6\u7801\u9A8C\u8BC1\u5931\u8D25",
   crypto_transportClientKeyGenerateFailed: "\u4F20\u8F93\u52A0\u5BC6\u5BA2\u6237\u7AEF\u5BC6\u94A5\u751F\u6210\u5931\u8D25",
-  crypto_transportServerKeyGenerateFailed: "\u4F20\u8F93\u52A0\u5BC6\u670D\u52A1\u7AEF\u5BC6\u94A5\u751F\u6210\u5931\u8D25",
+  crypto_transportServerKeyRingInvalid: "\u670D\u52A1\u7AEF\u4F20\u8F93\u5BC6\u94A5\u73AF\u7F3A\u5931\u6216\u65E0\u6548",
+  crypto_transportServerKeyUnknown: "\u670D\u52A1\u7AEF\u4F20\u8F93\u5BC6\u94A5\u7248\u672C\u672A\u77E5\u6216\u5DF2\u64A4\u9500",
+  crypto_transportKeyStoreRequired: "\u4F20\u8F93\u52A0\u5BC6\u5FC5\u987B\u663E\u5F0F\u63D0\u4F9B\u5BA2\u6237\u7AEF\u516C\u94A5\u5B58\u50A8",
+  crypto_transportKeyStoreTtlInvalid: "\u516C\u94A5\u5B58\u50A8 TTL \u5FC5\u987B\u4E3A 1 \u5230 2147483647 \u4E4B\u95F4\u7684\u6574\u6570\u79D2",
+  crypto_transportKeyStoreCapacityInvalid: "\u516C\u94A5\u5B58\u50A8\u5BB9\u91CF\u5FC5\u987B\u4E3A\u6B63\u5B89\u5168\u6574\u6570",
+  crypto_transportKeyStoreCapacityMismatch: "\u516C\u94A5\u5B58\u50A8\u7684\u5171\u4EAB\u5BB9\u91CF\u914D\u7F6E\u4E0D\u4E00\u81F4",
+  crypto_transportKeyStoreCapacityReached: "\u516C\u94A5\u5B58\u50A8\u5BB9\u91CF\u5DF2\u6EE1",
+  crypto_transportKeyStoreOperationFailed: "\u516C\u94A5\u5B58\u50A8\u64CD\u4F5C\u5931\u8D25",
+  crypto_transportAuthenticationFailed: "\u4F20\u8F93\u6D88\u606F\u8BA4\u8BC1\u3001\u8BF7\u6C42\u7ED1\u5B9A\u6216\u9632\u91CD\u653E\u6821\u9A8C\u5931\u8D25",
   crypto_transportKeyExchangeRequestFailed: "\u4F20\u8F93\u52A0\u5BC6\u5BC6\u94A5\u534F\u5546\u8BF7\u6C42\u5931\u8D25",
   crypto_transportKeyExchangeHttpFailed: "\u4F20\u8F93\u52A0\u5BC6\u5BC6\u94A5\u534F\u5546\u8FD4\u56DE HTTP {status}",
   crypto_transportKeyExchangeInvalidJson: "\u4F20\u8F93\u52A0\u5BC6\u5BC6\u94A5\u534F\u5546\u54CD\u5E94\u4E0D\u662F\u6709\u6548 JSON",
@@ -100,7 +171,8 @@ var zh_CN_default = {
 // src/crypto-i18n.ts
 var cryptoM = core.i18n.createMessageGetter({
   "zh-CN": zh_CN_default,
-  "en-US": en_US_default
+  "en-US": en_US_default,
+  "ja-JP": ja_JP_default
 });
 var CryptoErrorInfo = {
   INVALID_INPUT: "002:400",
@@ -241,6 +313,13 @@ function createPasswordFunctions(deps) {
     }
   };
 }
+var SM2_PUBLIC_KEY_REGEX = /^(?:04)?[0-9a-f]{128}$/i;
+function isValidSM2PublicKey(publicKey) {
+  if (typeof publicKey !== "string" || publicKey.length !== 128 && publicKey.length !== 130 || !SM2_PUBLIC_KEY_REGEX.test(publicKey))
+    return false;
+  const encoded = publicKey.length === 128 ? `04${publicKey}` : publicKey;
+  return smCrypto.sm2.verifyPublicKey(encoded) === true;
+}
 
 // src/crypto-utils.ts
 function isBase64(str) {
@@ -264,7 +343,6 @@ function base64ToHex(base64) {
 
 // src/crypto-sm2.ts
 var { sm2 } = smCrypto;
-var SM2_PUBLIC_KEY_REGEX = /^[0-9a-f]{128}$/i;
 var SM2_PRIVATE_KEY_REGEX = /^[0-9a-f]{64}$/i;
 function createSM2() {
   return {
@@ -307,7 +385,7 @@ function createSM2() {
         );
       }
       try {
-        const key = publicKey.startsWith("04") ? publicKey : `04${publicKey}`;
+        const key = publicKey.length === 130 ? publicKey : `04${publicKey}`;
         const encrypted = sm2.doEncrypt(data, key, cipherMode);
         if (!encrypted) {
           return err(
@@ -421,7 +499,7 @@ function createSM2() {
         );
       }
       try {
-        const key = publicKey.startsWith("04") ? publicKey : `04${publicKey}`;
+        const key = publicKey.length === 130 ? publicKey : `04${publicKey}`;
         const isValid = sm2.doVerifySignature(data, signature, key, { hash, userId });
         return ok(!!isValid);
       } catch (error) {
@@ -433,18 +511,16 @@ function createSM2() {
       }
     },
     /**
-     * 校验公钥格式是否合法
+     * 校验公钥编码及曲线点是否合法
      *
      * 合法格式：128 字符十六进制（无前缀）或 130 字符（含 04 前缀）。
      *
      * @param key - 待校验公钥
-     * @returns 格式合法返回 true
+     * @returns 编码有效且为 SM2 曲线上的非无穷远点时返回 true
+     * @example `crypto.asymmetric.isValidPublicKey(clientPublicKey)`
      */
     isValidPublicKey(key) {
-      if (!key || typeof key !== "string")
-        return false;
-      const cleanKey = key.startsWith("04") ? key.slice(2) : key;
-      return SM2_PUBLIC_KEY_REGEX.test(cleanKey);
+      return isValidSM2PublicKey(key);
     },
     /**
      * 校验私钥格式是否合法
@@ -573,7 +649,7 @@ function stringToBytes(str) {
   const encoder = new TextEncoder();
   return Array.from(encoder.encode(str));
 }
-var { sm3: sm32, sm4 } = smCrypto;
+var { sm4 } = smCrypto;
 var SM4_HEX_32_REGEX = /^[0-9a-f]{32}$/i;
 function createSM4() {
   return {
@@ -591,7 +667,7 @@ function createSM4() {
      * 默认使用 CBC 并自动生成随机 IV，返回结构化字段。
      *
      * ⚠️ 安全警告：ECB 模式会让相同明文块产生相同密文块，泄漏结构信息。
-     * 生产场景请使用默认 CBC，或显式传入 `{ mode: 'cbc', iv }`。
+     * 新数据使用默认 CBC，或每次显式传入新的随机 IV；CBC 仍需独立完整性认证，HTTP 使用 transport。
      *
      * @param data - 待加密明文
      * @param key - 密钥（32 字符十六进制）
@@ -701,7 +777,7 @@ function createSM4() {
      *
      * @param data - 待加密明文
      * @param key - 密钥（32 字符十六进制）
-     * @returns 成功时返回 { ciphertext, iv }；失败时同 encrypt
+     * @returns 成功时返回完整 { mode, ciphertext, iv, encoding }；失败时同 encrypt
      */
     encryptWithIV(data, key) {
       const iv = this.generateIV();
@@ -719,6 +795,8 @@ function createSM4() {
     /**
      * 带 IV 解密（CBC 模式）
      *
+     * 这是不含认证的底层 primitive；传输数据必须经 transport 验签及 MAC 后再调用，禁止直接用于 HTTP 解密。
+     *
      * @param ciphertext - 密文
      * @param key - 密钥
      * @param iv - 加密时使用的 IV
@@ -727,26 +805,6 @@ function createSM4() {
     decryptWithIV(ciphertext, key, iv) {
       return this.decrypt({ mode: "cbc", ciphertext, iv, encoding: "hex" }, key);
     },
-    /**
-     * 从密码和盐值派生密钥
-     *
-     * 内部仅执行单次 SM3 哈希(password + salt)，取前 32 字符作为密钥。
-     *
-     * ⚠️ 安全警告：**此实现不是标准 KDF**，不具备密码爆破抗性（无迭代、无内存硬化）。
-     * - **禁止用于密码存储**：密码散列请用 `crypto.password.hash()`。
-     * - **禁止用于高价值密钥派生**：如需从密码派生加密密钥，请在应用层自行实现 PBKDF2 / scrypt / Argon2。
-     * - 仅适用于测试、迭代兼容或不敏感的场景。
-     *
-     * @deprecated 未来版本可能移除。密码散列请用 `crypto.password.hash`；密钥派生请使用标准 KDF。
-     * @param password - 密码
-     * @param salt - 盐值
-     * @returns 32 字符十六进制密钥
-     */
-    deriveKey(password, salt) {
-      const combined = password + salt;
-      const hash = sm32(combined);
-      return hash.slice(0, 32);
-    },
     /** 校验密钥格式是否合法（32 字符十六进制） */
     isValidKey(key) {
       return SM4_HEX_32_REGEX.test(key);
@@ -769,10 +827,81 @@ function decodeCiphertext(payload) {
   return payload.encoding === "base64" ? base64ToHex(payload.ciphertext) : payload.ciphertext;
 }
 
+// src/transport/crypto-transport-body.ts
+var TRANSPORT_BODY_LIMITS = {
+  /** 密钥协商 JSON 的 UTF-8 总字节数。 */
+  keyExchangeBytes: 16384,
+  /** GET/HEAD 请求及无正文响应的认证头封装 UTF-8 上限。 */
+  envelopeHeaderBytes: 16384,
+  /** 单个协商公钥的 UTF-8 字节数。 */
+  publicKeyBytes: 4096,
+  /** 解密后的请求/加密前的响应明文字节数。 */
+  plaintextBytes: 1048576,
+  /** 密文 JSON 的 UTF-8 总字节数（2 MiB + 32 KiB，含 CBC 填充与全部认证字段）。 */
+  encryptedPayloadBytes: 2129920
+};
+async function readTransportBody(stream, options) {
+  if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0)
+    throw new RangeError("Invalid transport body byte limit");
+  if (!stream) {
+    options.signal?.throwIfAborted();
+    return "";
+  }
+  const reader = stream.getReader();
+  const signal = options.signal;
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let completed = false;
+  let failure;
+  let onAbort;
+  try {
+    signal?.throwIfAborted();
+    const aborted = signal ? new Promise((_resolve, reject) => {
+      onAbort = () => reject(signal.reason);
+      signal.addEventListener("abort", onAbort, { once: true });
+    }) : void 0;
+    let bytes = 0;
+    let text = "";
+    while (true) {
+      const next = reader.read();
+      const chunk = await (aborted ? Promise.race([next, aborted]) : next);
+      if (chunk.done) {
+        completed = true;
+        return text + decoder.decode();
+      }
+      bytes += chunk.value.byteLength;
+      if (bytes > options.maxBytes)
+        throw new RangeError("Transport body byte limit exceeded");
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+  } catch (error) {
+    failure = error;
+    throw error;
+  } finally {
+    if (onAbort)
+      signal?.removeEventListener("abort", onAbort);
+    if (!completed) {
+      try {
+        void reader.cancel(failure).catch(() => {
+        });
+      } catch {
+      }
+    }
+    reader.releaseLock();
+  }
+}
+
 // src/transport/crypto-transport-types.ts
 var TRANSPORT_PROTOCOL = {
   /** 客户端 ID 请求头名。 */
   CLIENT_ID_HEADER: "X-Client-Id",
+  /** GET/HEAD 等无正文请求的认证封装；禁止与正文封装同时出现。 */
+  ENVELOPE_HEADER: "X-Hai-Transport",
+  /** 唯一支持的认证协议版本；旧未认证格式拒绝。 */
+  VERSION: 2,
+  /** 请求允许的过去时间窗口（毫秒）。 */
+  REQUEST_WINDOW_MS: 3e5,
+  /** 节点时钟允许的最大未来偏差（毫秒）。 */
+  CLOCK_SKEW_MS: 3e4,
   /** 标识响应体已加密的响应头名。 */
   ENCRYPTED_HEADER: "X-Encrypted",
   /** `X-Encrypted` 响应头的开启值。 */
@@ -781,11 +910,103 @@ var TRANSPORT_PROTOCOL = {
   DEFAULT_KEY_EXCHANGE_PATH: "/_hai/key-exchange"
 };
 
+// src/transport/crypto-transport-codec.ts
+function authenticatedText(payload) {
+  const c = payload.context;
+  return JSON.stringify([
+    "hai-transport",
+    c.version,
+    payload.direction,
+    c.serverKeyId,
+    c.clientId,
+    c.requestId,
+    c.issuedAt,
+    c.method,
+    c.pathHash,
+    payload.status,
+    payload.encryptedKey,
+    payload.ciphertext,
+    payload.iv
+  ]);
+}
+function transportAuthenticationFailure() {
+  return err(HaiCryptoError.INVALID_INPUT, cryptoM("crypto_transportAuthenticationFailed"));
+}
+function hashTransportPath(service, path) {
+  try {
+    if (!path.startsWith("/") || new TextEncoder().encode(path).byteLength > 8192)
+      return transportAuthenticationFailure();
+    const digest = service.hash.hash(path);
+    return digest.success && /^[a-f0-9]{64}$/.test(digest.data) ? digest : transportAuthenticationFailure();
+  } catch {
+    return transportAuthenticationFailure();
+  }
+}
+function sealTransportPayload(service, plaintext, context, direction, status, recipientPublicKey, senderPrivateKey) {
+  try {
+    const encryptionKey = service.symmetric.generateKey();
+    const authenticationKey = service.symmetric.generateKey() + service.symmetric.generateKey();
+    const encrypted = service.symmetric.encryptWithIV(plaintext, encryptionKey);
+    const wrapped = service.asymmetric.encrypt(JSON.stringify([encryptionKey, authenticationKey]), recipientPublicKey);
+    if (!encrypted.success || !wrapped.success)
+      return transportAuthenticationFailure();
+    const payload = { context: { ...context }, direction, status, encryptedKey: wrapped.data, ciphertext: encrypted.data.ciphertext, iv: encrypted.data.iv };
+    const text = authenticatedText(payload);
+    const tag = service.hash.hmac(text, authenticationKey);
+    if (!tag.success)
+      return transportAuthenticationFailure();
+    const signature = service.asymmetric.sign(JSON.stringify([text, tag.data]), senderPrivateKey);
+    if (!signature.success)
+      return transportAuthenticationFailure();
+    const authenticated = { ...payload, tag: tag.data, signature: signature.data };
+    return isValidEncryptedPayload(authenticated) ? ok(authenticated) : transportAuthenticationFailure();
+  } catch {
+    return transportAuthenticationFailure();
+  }
+}
+function openTransportPayload(service, payload, recipientPrivateKey, senderPublicKey) {
+  try {
+    if (!isValidEncryptedPayload(payload))
+      return transportAuthenticationFailure();
+    const text = authenticatedText(payload);
+    const verified = service.asymmetric.verify(JSON.stringify([text, payload.tag]), payload.signature, senderPublicKey);
+    if (!verified.success || !verified.data)
+      return transportAuthenticationFailure();
+    const unwrapped = service.asymmetric.decrypt(payload.encryptedKey, recipientPrivateKey);
+    if (!unwrapped.success)
+      return transportAuthenticationFailure();
+    const keys = JSON.parse(unwrapped.data);
+    if (!Array.isArray(keys) || keys.length !== 2 || typeof keys[0] !== "string" || !/^[a-f0-9]{32}$/.test(keys[0]) || typeof keys[1] !== "string" || !/^[a-f0-9]{64}$/.test(keys[1])) {
+      return transportAuthenticationFailure();
+    }
+    const tag = service.hash.hmac(text, keys[1]);
+    if (!tag.success || !core.string.constantTimeEqual(tag.data, payload.tag))
+      return transportAuthenticationFailure();
+    const plaintext = service.symmetric.decryptWithIV(payload.ciphertext, keys[0], payload.iv);
+    if (!plaintext.success)
+      return transportAuthenticationFailure();
+    return plaintext;
+  } catch {
+    return transportAuthenticationFailure();
+  }
+}
+function isValidEncryptedPayload(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const p = value;
+  const c = p.context;
+  return Object.keys(p).length === 8 && !!c && typeof c === "object" && Object.keys(c).length === 7 && c.version === TRANSPORT_PROTOCOL.VERSION && typeof c.serverKeyId === "string" && /^[\w-]{1,64}$/.test(c.serverKeyId) && typeof c.clientId === "string" && /^[\w-]{1,128}$/.test(c.clientId) && typeof c.requestId === "string" && /^[a-f0-9]{32}$/.test(c.requestId) && Number.isSafeInteger(c.issuedAt) && c.issuedAt > 0 && typeof c.method === "string" && /^[A-Z]{1,16}$/.test(c.method) && typeof c.pathHash === "string" && /^[a-f0-9]{64}$/.test(c.pathHash) && (p.direction === "request" || p.direction === "response") && Number.isInteger(p.status) && (p.direction === "request" ? p.status === 0 : Number(p.status) >= 100 && Number(p.status) <= 599) && typeof p.encryptedKey === "string" && /^[a-f0-9]{1,8192}$/i.test(p.encryptedKey) && typeof p.ciphertext === "string" && p.ciphertext.length <= TRANSPORT_BODY_LIMITS.encryptedPayloadBytes && p.ciphertext.length > 0 && p.ciphertext.length % 32 === 0 && /^[a-f0-9]+$/i.test(p.ciphertext) && typeof p.iv === "string" && /^[a-f0-9]{32}$/i.test(p.iv) && typeof p.tag === "string" && /^[a-f0-9]{64}$/.test(p.tag) && typeof p.signature === "string" && /^[a-f0-9]{128}$/i.test(p.signature);
+}
+function sameTransportContext(a, b) {
+  return a.version === b.version && a.serverKeyId === b.serverKeyId && a.clientId === b.clientId && a.requestId === b.requestId && a.issuedAt === b.issuedAt && a.method === b.method && a.pathHash === b.pathHash;
+}
+
 // src/transport/crypto-transport-client.ts
 function createTransportClient(options) {
   const baseFetch = options.fetch ?? fetch;
   let keyPair = null;
   let serverPublicKey = null;
+  let serverKeyId = null;
   let clientId = null;
   let initPromise = null;
   async function doInit() {
@@ -793,30 +1014,47 @@ function createTransportClient(options) {
     if (!kpResult.success)
       return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientKeyGenerateFailed"), kpResult.error);
     const localKeyPair = kpResult.data;
-    let response;
-    try {
-      response = await baseFetch(options.keyExchangeUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ clientPublicKey: localKeyPair.publicKey })
-      });
-    } catch (cause) {
-      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeRequestFailed"), cause);
-    }
-    if (!response.ok)
-      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeHttpFailed", { params: { status: response.status } }));
-    let body;
+    if (new TextEncoder().encode(localKeyPair.publicKey).byteLength > TRANSPORT_BODY_LIMITS.publicKeyBytes)
+      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientKeyGenerateFailed"));
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(new DOMException("Key exchange timed out", "TimeoutError")), 3e4);
     try {
-      body = await response.json();
-    } catch (cause) {
-      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeInvalidJson"), cause);
+      let response;
+      try {
+        response = await baseFetch(options.keyExchangeUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ clientPublicKey: localKeyPair.publicKey }),
+          signal: controller.signal
+        });
+      } catch (cause) {
+        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeRequestFailed"), cause);
+      }
+      if (!response.ok) {
+        void response.body?.cancel().catch(() => {
+        });
+        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeHttpFailed", { params: { status: response.status } }));
+      }
+      let body;
+      try {
+        body = JSON.parse(await readTransportBody(response.body, {
+          maxBytes: TRANSPORT_BODY_LIMITS.keyExchangeBytes,
+          signal: controller.signal
+        }));
+      } catch {
+        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeInvalidJson"));
+      }
+      if (!isKeyExchangeResponse(body)) {
+        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeMissingFields"));
+      }
+      keyPair = localKeyPair;
+      serverPublicKey = body.serverPublicKey;
+      serverKeyId = body.serverKeyId;
+      clientId = body.clientId;
+      return ok(void 0);
+    } finally {
+      clearTimeout(timeout);
     }
-    if (!body.serverPublicKey || !body.clientId)
-      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeMissingFields"));
-    keyPair = localKeyPair;
-    serverPublicKey = body.serverPublicKey;
-    clientId = body.clientId;
-    return ok(void 0);
   }
   async function ensureReady() {
     if (clientId && serverPublicKey)
@@ -830,66 +1068,91 @@ function createTransportClient(options) {
     }
     return initPromise;
   }
-  function encryptBody(plaintext) {
-    if (!serverPublicKey)
+  function encryptBody(plaintext, context) {
+    if (!serverPublicKey || !serverKeyId || !keyPair)
       return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientNotInitialized"));
-    const symKey = options.crypto.symmetric.generateKey();
-    const encResult = options.crypto.symmetric.encryptWithIV(plaintext, symKey);
-    if (!encResult.success)
-      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportRequestEncryptFailed"), encResult.error);
-    const keyEncResult = options.crypto.asymmetric.encrypt(symKey, serverPublicKey);
-    if (!keyEncResult.success)
-      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportSessionKeyEncryptFailed"), keyEncResult.error);
-    return ok({
-      encryptedKey: keyEncResult.data,
-      ciphertext: encResult.data.ciphertext,
-      iv: encResult.data.iv
-    });
+    return sealTransportPayload(options.crypto, plaintext, context, "request", 0, serverPublicKey, keyPair.privateKey);
   }
   function decryptPayload(payload) {
-    if (!keyPair)
+    if (!keyPair || !serverPublicKey)
       return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportClientNotInitialized"));
-    const keyDec = options.crypto.asymmetric.decrypt(payload.encryptedKey, keyPair.privateKey);
-    if (!keyDec.success)
-      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportSessionKeyDecryptFailed"), keyDec.error);
-    const dec = options.crypto.symmetric.decryptWithIV(payload.ciphertext, keyDec.data, payload.iv);
-    if (!dec.success)
-      return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportResponseDecryptFailed"), dec.error);
-    return ok(dec.data);
+    return openTransportPayload(options.crypto, payload, keyPair.privateKey, serverPublicKey);
   }
   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 ready = await ensureReady();
+    let onAbort;
+    let ready;
+    try {
+      ready = await (signal ? Promise.race([
+        ensureReady(),
+        new Promise((_resolve, reject) => {
+          onAbort = () => reject(signal.reason);
+          signal.addEventListener("abort", onAbort, { once: true });
+          if (signal.aborted)
+            onAbort();
+        })
+      ]) : ensureReady());
+    } finally {
+      if (onAbort)
+        signal?.removeEventListener("abort", onAbort);
+    }
     if (!ready.success)
       throw new Error(ready.error.message);
     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 method = (init?.method ?? requestInput.method).toUpperCase();
-      if (method !== "GET" && method !== "HEAD") {
-        const text = await requestInput.clone().text();
+      const method2 = (init?.method ?? requestInput.method).toUpperCase();
+      if (method2 !== "GET" && method2 !== "HEAD") {
+        const text = await readTransportBody(requestInput.body, { maxBytes: TRANSPORT_BODY_LIMITS.plaintextBytes, signal });
         if (text)
           rawBody = text;
       }
     }
-    let nextBody = rawBody;
-    if (rawBody != null) {
-      const plaintext = await bodyToText(rawBody);
-      const encResult = encryptBody(plaintext);
-      if (!encResult.success)
-        throw new Error(encResult.error.message);
-      nextBody = JSON.stringify(encResult.data);
+    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);
+    if (!pathHash.success)
+      throw new Error(pathHash.error.message);
+    const context = {
+      version: TRANSPORT_PROTOCOL.VERSION,
+      serverKeyId,
+      clientId,
+      requestId: options.crypto.symmetric.generateKey(),
+      issuedAt: Date.now(),
+      method,
+      pathHash: pathHash.data
+    };
+    const plaintext = rawBody == null ? "" : await readTransportBody(new Response(rawBody).body, { maxBytes: TRANSPORT_BODY_LIMITS.plaintextBytes, signal });
+    const encResult = encryptBody(plaintext, context);
+    if (!encResult.success)
+      throw new Error(encResult.error.message);
+    const serialized = JSON.stringify(encResult.data);
+    if (new TextEncoder().encode(serialized).byteLength > TRANSPORT_BODY_LIMITS.encryptedPayloadBytes)
+      throw new RangeError("Transport request envelope byte limit exceeded");
+    let nextBody;
+    headers.delete(TRANSPORT_PROTOCOL.ENVELOPE_HEADER);
+    headers.set(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER, TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE);
+    headers.delete("Content-Length");
+    headers.delete("Content-Encoding");
+    if (method === "GET" || method === "HEAD") {
+      if (new TextEncoder().encode(serialized).byteLength > TRANSPORT_BODY_LIMITS.envelopeHeaderBytes)
+        throw new RangeError("Transport request envelope header byte limit exceeded");
+      headers.set(TRANSPORT_PROTOCOL.ENVELOPE_HEADER, serialized);
+    } else {
+      nextBody = serialized;
       headers.set("Content-Type", "application/json");
-      headers.set(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER, TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE);
     }
     const finalInput = requestInput ? requestInput.url : input;
     const finalInit = {
       ...init,
-      method: init?.method ?? requestInput?.method,
+      method,
       headers,
       body: nextBody,
       cache: init?.cache ?? requestInput?.cache,
@@ -903,24 +1166,39 @@ function createTransportClient(options) {
       signal: init?.signal ?? requestInput?.signal
     };
     const response = await baseFetch(finalInput, finalInit);
-    if (response.headers.get(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER) !== TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE)
-      return response;
-    const cloned = response.clone();
+    if (response.headers.get(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER) !== TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE) {
+      void response.body?.cancel().catch(() => {
+      });
+      throw new Error(cryptoM("crypto_transportResponseDecryptFailed"));
+    }
     let payload;
     try {
-      payload = await cloned.json();
+      const envelope = response.headers.get(TRANSPORT_PROTOCOL.ENVELOPE_HEADER);
+      if (envelope && response.body !== null) {
+        void response.body.cancel().catch(() => {
+        });
+        throw new Error(cryptoM("crypto_transportResponseDecryptFailed"));
+      }
+      if (envelope && new TextEncoder().encode(envelope).byteLength > TRANSPORT_BODY_LIMITS.envelopeHeaderBytes)
+        throw new RangeError("Transport response envelope byte limit exceeded");
+      payload = JSON.parse(envelope ?? await readTransportBody(response.body, { maxBytes: TRANSPORT_BODY_LIMITS.encryptedPayloadBytes, signal }));
     } catch {
-      return response;
+      throw new Error(cryptoM("crypto_transportResponseDecryptFailed"), signal?.aborted ? { cause: signal.reason } : void 0);
+    }
+    if (!isValidEncryptedPayload(payload) || payload.direction !== "response" || payload.status !== response.status || !sameTransportContext(payload.context, context)) {
+      throw new Error(cryptoM("crypto_transportResponseDecryptFailed"));
     }
-    if (!isEncryptedPayload(payload))
-      return response;
     const decResult = decryptPayload(payload);
     if (!decResult.success)
       throw new Error(decResult.error.message);
+    if (new TextEncoder().encode(decResult.data).byteLength > TRANSPORT_BODY_LIMITS.plaintextBytes)
+      throw new RangeError("Transport response plaintext byte limit exceeded");
     const respHeaders = new Headers(response.headers);
     respHeaders.delete(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER);
+    respHeaders.delete(TRANSPORT_PROTOCOL.ENVELOPE_HEADER);
     respHeaders.delete("Content-Length");
-    return new Response(decResult.data, {
+    respHeaders.delete("Content-Encoding");
+    return new Response(method === "HEAD" || [204, 304].includes(response.status) ? null : decResult.data, {
       status: response.status,
       statusText: response.statusText,
       headers: respHeaders
@@ -933,24 +1211,12 @@ function createTransportClient(options) {
     destroy() {
       keyPair = null;
       serverPublicKey = null;
+      serverKeyId = null;
       clientId = null;
       initPromise = null;
     }
   };
 }
-async function bodyToText(body) {
-  if (typeof body === "string")
-    return body;
-  if (body instanceof URLSearchParams)
-    return body.toString();
-  if (body instanceof Blob)
-    return body.text();
-  if (body instanceof ArrayBuffer)
-    return new TextDecoder().decode(body);
-  if (ArrayBuffer.isView(body))
-    return new TextDecoder().decode(body.buffer);
-  return new Response(body).text();
-}
 function isRequestLike(input) {
   if (typeof input !== "object" || input === null)
     return false;
@@ -958,95 +1224,119 @@ function isRequestLike(input) {
   const headers = candidate.headers;
   return typeof candidate.url === "string" && typeof headers?.get === "function" && typeof candidate.method === "string" && typeof candidate.clone === "function";
 }
-function isEncryptedPayload(payload) {
-  if (!payload || typeof payload !== "object")
+function isKeyExchangeResponse(body) {
+  if (!body || typeof body !== "object")
     return false;
-  const p = payload;
-  return typeof p.encryptedKey === "string" && typeof p.ciphertext === "string" && typeof p.iv === "string";
-}
-
-// src/transport/store-provider/crypto-transport-store-memory.ts
-var DEFAULT_MAX_CLIENTS = 1e4;
-function normalizeMaxClients(maxClients) {
-  if (!Number.isFinite(maxClients))
-    return DEFAULT_MAX_CLIENTS;
-  return Math.max(1, Math.floor(maxClients));
+  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);
 }
-function createClientId(counter) {
-  const entropy = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID().replace(/-/g, "") : Math.random().toString(36).slice(2, 12);
-  return `c_${counter}_${Date.now()}_${entropy}`;
+function parseTransportServerKeyRing(serialized) {
+  try {
+    const value = typeof serialized === "string" ? JSON.parse(serialized) : serialized;
+    if (isTransportServerKeyRing(value))
+      return ok(value);
+  } catch {
+  }
+  return err(HaiCryptoError.INVALID_KEY, cryptoM("crypto_transportServerKeyRingInvalid"));
 }
-function createInMemoryKeyStore(maxClients = DEFAULT_MAX_CLIENTS) {
-  const clientKeys = /* @__PURE__ */ new Map();
-  const capacity = normalizeMaxClients(maxClients);
-  let counter = 0;
-  return {
-    async register(publicKey) {
-      counter++;
-      const clientId = createClientId(counter);
-      if (clientKeys.size >= capacity) {
-        const oldest = clientKeys.keys().next().value;
-        if (oldest !== void 0)
-          clientKeys.delete(oldest);
-      }
-      clientKeys.set(clientId, publicKey);
-      return clientId;
-    },
-    async get(clientId) {
-      return clientKeys.get(clientId);
-    },
-    async delete(clientId) {
-      clientKeys.delete(clientId);
-    },
-    async close() {
-      clientKeys.clear();
-    }
-  };
+function isTransportServerKeyRing(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const ring = value;
+  if (typeof ring.activeKeyId !== "string" || !/^[\w-]{1,64}$/.test(ring.activeKeyId) || !ring.keys || typeof ring.keys !== "object" || Array.isArray(ring.keys)) {
+    return false;
+  }
+  if (!Object.hasOwn(ring.keys, ring.activeKeyId))
+    return false;
+  return Object.entries(ring.keys).every(([id, pair]) => {
+    if (!/^[\w-]{1,64}$/.test(id) || !pair || typeof pair !== "object")
+      return false;
+    const fields = pair;
+    return typeof fields.publicKey === "string" && fields.publicKey.length > 0 && new TextEncoder().encode(fields.publicKey).byteLength <= TRANSPORT_BODY_LIMITS.publicKeyBytes && typeof fields.privateKey === "string" && fields.privateKey.length > 0 && fields.privateKey.length <= TRANSPORT_BODY_LIMITS.publicKeyBytes;
+  });
 }
 
 // src/transport/crypto-transport-server.ts
-function createTransportEncryption(cryptoService, options = {}) {
-  const keyPairResult = cryptoService.asymmetric.generateKeyPair();
-  if (!keyPairResult.success)
-    return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportServerKeyGenerateFailed"), keyPairResult.error);
-  const serverKeyPair = keyPairResult.data;
-  const keyStore = options.keyStore ?? createInMemoryKeyStore(options.maxClients);
+function createTransportEncryption(cryptoService, options) {
+  const ring = parseTransportServerKeyRing(options?.serverKeyRing);
+  if (!ring.success)
+    return ring;
+  if (!options.keyStore || typeof options.keyStore.register !== "function" || typeof options.keyStore.get !== "function" || typeof options.keyStore.claimRequest !== "function") {
+    return err(HaiCryptoError.INVALID_INPUT, cryptoM("crypto_transportKeyStoreRequired"));
+  }
+  if (core.module.requiresSharedState(globalThis.process?.env ?? {}) && options.keyStore.stateScope !== "shared")
+    return err(HaiCryptoError.INVALID_INPUT, cryptoM("crypto_transportKeyStoreRequired"));
+  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);
+    if (!probe.success)
+      return err(HaiCryptoError.INVALID_KEY, cryptoM("crypto_transportServerKeyRingInvalid"));
+    const checked = cryptoService.asymmetric.decrypt(probe.data, key.privateKey);
+    if (!checked.success || checked.data !== "hai-transport-key-check")
+      return err(HaiCryptoError.INVALID_KEY, cryptoM("crypto_transportServerKeyRingInvalid"));
+    serverKeys.set(id, { publicKey: key.publicKey, privateKey: key.privateKey });
+  }
+  const activeKeyId = ring.data.activeKeyId;
+  const serverKeyPair = serverKeys.get(activeKeyId);
+  const keyStore = options.keyStore;
   const manager = {
+    getServerKeyId() {
+      return activeKeyId;
+    },
     getServerPublicKey() {
       return serverKeyPair.publicKey;
     },
     async registerClientKey(clientPublicKey) {
+      if (!isValidSM2PublicKey(clientPublicKey))
+        throw new TypeError(cryptoM("crypto_sm2PublicKeyInvalid"));
       return keyStore.register(clientPublicKey);
     },
     async getClientPublicKey(clientId) {
       return keyStore.get(clientId);
     },
-    async encryptResponse(clientId, data) {
-      const clientPublicKey = await keyStore.get(clientId);
-      if (!clientPublicKey)
-        return err(HaiCommonError.NOT_FOUND, cryptoM("crypto_transportClientNotRegistered"));
-      const symmetricKey = cryptoService.symmetric.generateKey();
-      const encResult = cryptoService.symmetric.encryptWithIV(data, symmetricKey);
-      if (!encResult.success)
-        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportResponseEncryptFailed"), encResult.error);
-      const keyEncResult = cryptoService.asymmetric.encrypt(symmetricKey, clientPublicKey);
-      if (!keyEncResult.success)
-        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportSessionKeyEncryptFailed"), keyEncResult.error);
-      const payload = {
-        encryptedKey: keyEncResult.data,
-        ciphertext: encResult.data.ciphertext,
-        iv: encResult.data.iv
-      };
-      return ok(payload);
+    async encryptResponse(request, data, status) {
+      try {
+        const context = { ...request };
+        const clientPublicKey = await keyStore.get(context.clientId);
+        if (!clientPublicKey)
+          return err(HaiCommonError.NOT_FOUND, cryptoM("crypto_transportClientNotRegistered"));
+        const key = serverKeys.get(context.serverKeyId);
+        if (!key)
+          return transportAuthenticationFailure();
+        return sealTransportPayload(cryptoService, data, context, "response", status, clientPublicKey, key.privateKey);
+      } catch {
+        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportResponseEncryptFailed"));
+      }
     },
-    decryptRequest(payload) {
-      const keyDecResult = cryptoService.asymmetric.decrypt(payload.encryptedKey, serverKeyPair.privateKey);
-      if (!keyDecResult.success)
-        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportSessionKeyDecryptFailed"), keyDecResult.error);
-      const decResult = cryptoService.symmetric.decryptWithIV(payload.ciphertext, keyDecResult.data, payload.iv);
-      if (!decResult.success)
-        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportRequestDecryptFailed"), decResult.error);
-      return ok(decResult.data);
+    async decryptRequest(payload, expected) {
+      try {
+        if (!isValidEncryptedPayload(payload) || payload.direction !== "request" || payload.status !== 0)
+          return transportAuthenticationFailure();
+        const authenticated = { ...payload, context: { ...payload.context } };
+        const c = authenticated.context;
+        const now = Date.now();
+        const pathHash = hashTransportPath(cryptoService, expected.path);
+        if (!pathHash.success || c.clientId !== expected.clientId || c.method !== expected.method || c.pathHash !== pathHash.data || c.issuedAt > now + TRANSPORT_PROTOCOL.CLOCK_SKEW_MS || now >= c.issuedAt + TRANSPORT_PROTOCOL.REQUEST_WINDOW_MS) {
+          return transportAuthenticationFailure();
+        }
+        const key = serverKeys.get(c.serverKeyId);
+        const clientPublicKey = await keyStore.get(c.clientId);
+        if (!key || !clientPublicKey)
+          return transportAuthenticationFailure();
+        const plaintext = openTransportPayload(cryptoService, authenticated, key.privateKey, clientPublicKey);
+        if (!plaintext.success)
+          return plaintext;
+        if (Date.now() >= c.issuedAt + TRANSPORT_PROTOCOL.REQUEST_WINDOW_MS)
+          return transportAuthenticationFailure();
+        if (!await keyStore.claimRequest(c.clientId, c.requestId, c.issuedAt + TRANSPORT_PROTOCOL.REQUEST_WINDOW_MS + 2 * TRANSPORT_PROTOCOL.CLOCK_SKEW_MS)) {
+          return transportAuthenticationFailure();
+        }
+        if (Date.now() >= c.issuedAt + TRANSPORT_PROTOCOL.REQUEST_WINDOW_MS)
+          return transportAuthenticationFailure();
+        return plaintext;
+      } catch {
+        return transportAuthenticationFailure();
+      }
     },
     async close() {
       await keyStore.close?.();
@@ -1075,7 +1365,7 @@ function getCrypto() {
   return crypto2;
 }
 var transportOperations = {
-  createServer: (options) => createTransportEncryption(getCrypto(), options),
+  createServer: (options) => getCrypto().isInitialized ? createTransportEncryption(getCrypto(), options) : notInitialized.result(),
   createClient: (options) => createTransportClient({ crypto: getCrypto(), ...options }),
   protocol: TRANSPORT_PROTOCOL
 };
@@ -1148,8 +1438,7 @@ var crypto2 = {
   /**
    * 传输加密操作（端到端混合加密）
    *
-   * createServer 内部直接复用 asymmetric/symmetric，因此未初始化时
-   * 自动通过 asymmetric proxy 返回 NOT_INITIALIZED 错误。
+   * createServer 检查初始化后复用 asymmetric/symmetric；未初始化返回 NOT_INITIALIZED。
    */
   transport: transportOperations,
   /** 是否已初始化 */
@@ -1175,13 +1464,116 @@ var crypto2 = {
     logger.info("Crypto module closed");
   }
 };
+async function authenticateTransportRequest(manager, request) {
+  const reject = () => {
+    void request.body?.cancel().catch(() => {
+    });
+    return transportAuthenticationFailure();
+  };
+  if (request.headers.get(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER) !== TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE)
+    return reject();
+  const clientId = request.headers.get(TRANSPORT_PROTOCOL.CLIENT_ID_HEADER);
+  if (!clientId)
+    return reject();
+  const envelope = request.headers.get(TRANSPORT_PROTOCOL.ENVELOPE_HEADER);
+  const bodyless = request.method === "GET" || request.method === "HEAD";
+  if (bodyless && (!envelope || request.body !== null) || !bodyless && envelope !== null)
+    return reject();
+  if (envelope && new TextEncoder().encode(envelope).byteLength > TRANSPORT_BODY_LIMITS.envelopeHeaderBytes)
+    throw new RangeError("Transport request envelope byte limit exceeded");
+  const text = envelope ?? await readTransportBody(request.body, {
+    maxBytes: TRANSPORT_BODY_LIMITS.encryptedPayloadBytes,
+    signal: request.signal
+  });
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    return transportAuthenticationFailure();
+  }
+  if (!isValidEncryptedPayload(payload) || payload.direction !== "request" || payload.status !== 0)
+    return transportAuthenticationFailure();
+  const url = new URL(request.url);
+  const decrypted = await manager.decryptRequest(payload, {
+    clientId,
+    method: request.method,
+    path: url.pathname + url.search
+  });
+  if (!decrypted.success)
+    return decrypted;
+  if (new TextEncoder().encode(decrypted.data).byteLength > TRANSPORT_BODY_LIMITS.plaintextBytes)
+    throw new RangeError("Transport request plaintext byte limit exceeded");
+  if (bodyless && decrypted.data !== "")
+    return transportAuthenticationFailure();
+  return ok({ plaintext: decrypted.data, context: payload.context });
+}
+
+// src/transport/store-provider/crypto-transport-store-memory.ts
+var DEFAULT_MAX_CLIENTS = 1e4;
+function normalizeMaxClients(maxClients) {
+  if (!Number.isFinite(maxClients))
+    return DEFAULT_MAX_CLIENTS;
+  return Math.max(1, Math.floor(maxClients));
+}
+function createClientId(counter) {
+  const entropy = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID().replace(/-/g, "") : Math.random().toString(36).slice(2, 12);
+  return `c_${counter}_${Date.now()}_${entropy}`;
+}
+function createInMemoryKeyStore(maxClients = DEFAULT_MAX_CLIENTS) {
+  const clientKeys = /* @__PURE__ */ new Map();
+  const requests = /* @__PURE__ */ new Map();
+  const capacity = normalizeMaxClients(maxClients);
+  let counter = 0;
+  return {
+    get stateScope() {
+      return "local";
+    },
+    async register(publicKey) {
+      if (!isValidSM2PublicKey(publicKey))
+        throw new TypeError(cryptoM("crypto_sm2PublicKeyInvalid"));
+      counter++;
+      const clientId = createClientId(counter);
+      if (clientKeys.size >= capacity) {
+        const oldest = clientKeys.keys().next().value;
+        if (oldest !== void 0)
+          clientKeys.delete(oldest);
+      }
+      clientKeys.set(clientId, publicKey);
+      return clientId;
+    },
+    async get(clientId) {
+      return clientKeys.get(clientId);
+    },
+    async claimRequest(clientId, requestId, expiresAt) {
+      const now = Date.now();
+      for (const [id2, expiry] of requests) {
+        if (expiry <= now)
+          requests.delete(id2);
+      }
+      const id = JSON.stringify([clientId, requestId]);
+      if (requests.has(id) || expiresAt <= now)
+        return false;
+      requests.set(id, expiresAt);
+      return true;
+    },
+    async delete(clientId) {
+      clientKeys.delete(clientId);
+    },
+    async close() {
+      clientKeys.clear();
+      requests.clear();
+    }
+  };
+}
 
 // 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 || !Number.isFinite(ttlSeconds) || ttlSeconds <= 0)
+  if (ttlSeconds === void 0)
     return void 0;
-  return Math.floor(ttlSeconds);
+  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")
@@ -1204,9 +1596,14 @@ function createRedisTransportKeyStore(options) {
     return `${TRANSPORT_KEY_CACHE_PREFIX}:${clientId}`;
   }
   return {
+    get stateScope() {
+      return options.cache.config?.type === "redis" ? "shared" : "local";
+    },
     async register(publicKey) {
+      if (!isValidSM2PublicKey(publicKey))
+        throw new TypeError(cryptoM("crypto_sm2PublicKeyInvalid"));
       const clientId = createClientId2();
-      unwrapResult(
+      const applied = unwrapResult(
         "cache.kv.set",
         await options.cache.kv.set(
           buildCacheKey(clientId),
@@ -1214,6 +1611,8 @@ function createRedisTransportKeyStore(options) {
           ttlSeconds === void 0 ? void 0 : { ex: ttlSeconds }
         )
       );
+      if (!applied)
+        throw new Error(cryptoM("crypto_transportClientNotRegistered"));
       return clientId;
     },
     async get(clientId) {
@@ -1223,6 +1622,17 @@ function createRedisTransportKeyStore(options) {
       );
       return publicKey ?? void 0;
     },
+    async claimRequest(clientId, requestId, expiresAt) {
+      const ttl = expiresAt - Date.now();
+      if (ttl <= 0)
+        return false;
+      return unwrapResult("cache.kv.compareAndSwap", await options.cache.kv.compareAndSwap(
+        `hai:crypto:transport:request:${clientId}:${requestId}`,
+        void 0,
+        true,
+        { px: ttl }
+      ));
+    },
     async delete(clientId) {
       unwrapResult("cache.kv.del", await options.cache.kv.del(buildCacheKey(clientId)));
     }
@@ -1231,20 +1641,11 @@ function createRedisTransportKeyStore(options) {
 
 // src/transport/store-provider/crypto-transport-store-reldb.ts
 var TRANSPORT_KEY_TABLE = "hai_crypto_transport_client_keys";
-function normalizeTtlSeconds2(ttlSeconds) {
-  if (ttlSeconds === void 0 || !Number.isFinite(ttlSeconds) || ttlSeconds <= 0)
-    return void 0;
-  return Math.floor(ttlSeconds);
-}
-function createClientId3() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function")
-    return `c_${crypto.randomUUID()}`;
-  return `c_${Date.now()}_${Math.random().toString(36).slice(2, 12)}`;
-}
+var TRANSPORT_REQUEST_TABLE = "hai_crypto_transport_requests";
+var TRANSPORT_CAPACITY_TABLE = "hai_crypto_transport_capacity";
+var PRUNE_BATCH_SIZE = 100;
 function toOperationError2(operation, error) {
-  const wrapped = new Error(`${operation} failed: ${error.message}`, { cause: error });
-  wrapped.code = error.code;
-  return wrapped;
+  return Object.assign(new Error(cryptoM("crypto_transportKeyStoreOperationFailed")), { operation, code: error.code });
 }
 function unwrapResult2(operation, result) {
   if (result.success)
@@ -1252,21 +1653,66 @@ function unwrapResult2(operation, result) {
   throw toOperationError2(operation, result.error);
 }
 function createReldbTransportKeyStore(options) {
-  const ttlSeconds = normalizeTtlSeconds2(options.ttlSeconds);
+  const { ttlSeconds } = options;
+  if (ttlSeconds !== void 0 && (!Number.isSafeInteger(ttlSeconds) || ttlSeconds <= 0 || ttlSeconds > 2147483647))
+    throw new TypeError(cryptoM("crypto_transportKeyStoreTtlInvalid"));
+  const maxClients = options.maxClients ?? 1e4;
+  if (!Number.isSafeInteger(maxClients) || maxClients <= 0)
+    throw new TypeError(cryptoM("crypto_transportKeyStoreCapacityInvalid"));
   let ensureTablePromise = null;
+  function nowSql() {
+    switch (options.reldb.config?.type) {
+      case "postgresql":
+        return "CAST(FLOOR(EXTRACT(EPOCH FROM clock_timestamp()) * 1000) AS BIGINT)";
+      case "mysql":
+        return "CAST(FLOOR(UNIX_TIMESTAMP(CURRENT_TIMESTAMP(3)) * 1000) AS SIGNED)";
+      default:
+        return "(CAST(strftime('%s', 'now') AS INTEGER) * 1000 + CAST(substr(strftime('%f', 'now'), 4, 3) AS INTEGER))";
+    }
+  }
+  function insertIfAbsent(table, columns, placeholders, key) {
+    return options.reldb.config?.type === "mysql" ? `INSERT IGNORE INTO ${table} (${columns}) VALUES (${placeholders})` : `INSERT INTO ${table} (${columns}) VALUES (${placeholders}) ON CONFLICT (${key}) DO NOTHING`;
+  }
   async function ensureTable() {
     if (!ensureTablePromise) {
-      ensureTablePromise = (async () => {
+      const initialization = (async () => {
         unwrapResult2(
           "reldb.ddl.createTable",
           await options.reldb.ddl.createTable(TRANSPORT_KEY_TABLE, {
             client_id: { type: "TEXT", primaryKey: true },
             public_key: { type: "TEXT", notNull: true },
-            created_at: { type: "TIMESTAMP", notNull: true },
-            expires_at: { type: "TIMESTAMP" }
+            created_at_ms: { type: "BIGINT", notNull: true },
+            expires_at_ms: { type: "BIGINT" }
           }, true)
         );
+        unwrapResult2("reldb.ddl.createTable", await options.reldb.ddl.createTable(TRANSPORT_REQUEST_TABLE, {
+          request_key: { type: "TEXT", primaryKey: true },
+          expires_at: { type: "BIGINT", notNull: true }
+        }, true));
+        unwrapResult2("reldb.ddl.createTable", await options.reldb.ddl.createTable(TRANSPORT_CAPACITY_TABLE, {
+          id: { type: "INTEGER", primaryKey: true },
+          max_clients: { type: "BIGINT", notNull: true },
+          revision: { type: "BIGINT", notNull: true }
+        }, true));
+        unwrapResult2("reldb.sql.execute", await options.reldb.sql.execute(
+          insertIfAbsent(TRANSPORT_CAPACITY_TABLE, "id, max_clients, revision", "?, ?, ?", "id"),
+          [1, maxClients, 0]
+        ));
+        const capacity = unwrapResult2("reldb.sql.get", await options.reldb.sql.get(
+          `SELECT max_clients FROM ${TRANSPORT_CAPACITY_TABLE} WHERE id = ?`,
+          [1]
+        ));
+        if (!capacity || Number(capacity.max_clients) !== maxClients)
+          throw new Error(cryptoM("crypto_transportKeyStoreCapacityMismatch"));
       })();
+      ensureTablePromise = initialization;
+      try {
+        await initialization;
+      } catch (error) {
+        if (ensureTablePromise === initialization)
+          ensureTablePromise = null;
+        throw error;
+      }
     }
     return ensureTablePromise;
   }
@@ -1279,45 +1725,88 @@ function createReldbTransportKeyStore(options) {
       )
     );
   }
+  async function withCapacityLock(operation) {
+    await ensureTable();
+    const result = await options.reldb.tx.wrap(async (tx) => {
+      const locked = unwrapResult2("tx.execute", await tx.execute(
+        `UPDATE ${TRANSPORT_CAPACITY_TABLE} SET revision = revision + 1 WHERE id = ? AND max_clients = ?`,
+        [1, maxClients]
+      ));
+      if (locked.changes !== 1)
+        throw new Error(cryptoM("crypto_transportKeyStoreCapacityMismatch"));
+      return operation(tx);
+    });
+    return unwrapResult2("reldb.tx.wrap", result);
+  }
+  async function pruneRows(tx) {
+    let removed = 0;
+    for (const [table, id, expiry] of [[TRANSPORT_KEY_TABLE, "client_id", "expires_at_ms"], [TRANSPORT_REQUEST_TABLE, "request_key", "expires_at"]]) {
+      removed += unwrapResult2("tx.execute", await tx.execute(
+        `DELETE FROM ${table} WHERE ${expiry} <= ${nowSql()} AND ${id} IN (SELECT ${id} FROM (SELECT ${id} FROM ${table} WHERE ${expiry} <= ${nowSql()} LIMIT ${PRUNE_BATCH_SIZE}) AS expired)`
+      )).changes;
+    }
+    return removed;
+  }
+  async function pruneExpired() {
+    return withCapacityLock(pruneRows);
+  }
   return {
+    get stateScope() {
+      return options.reldb.config?.type && options.reldb.config.type !== "sqlite" ? "shared" : "local";
+    },
     async register(publicKey) {
-      await ensureTable();
-      const clientId = createClientId3();
-      const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-      const expiresAt = ttlSeconds === void 0 ? null : new Date(Date.now() + ttlSeconds * 1e3).toISOString();
-      unwrapResult2(
-        "reldb.sql.execute",
-        await options.reldb.sql.execute(
-          `INSERT INTO ${TRANSPORT_KEY_TABLE} (client_id, public_key, created_at, expires_at) VALUES (?, ?, ?, ?)`,
-          [clientId, publicKey, createdAt, expiresAt]
-        )
-      );
-      return clientId;
+      if (!isValidSM2PublicKey(publicKey))
+        throw new TypeError(cryptoM("crypto_sm2PublicKeyInvalid"));
+      const clientId = `c_${globalThis.crypto.randomUUID()}`;
+      return withCapacityLock(async (tx) => {
+        await pruneRows(tx);
+        const count = unwrapResult2("tx.get", await tx.get(
+          `SELECT COUNT(*) AS total FROM ${TRANSPORT_KEY_TABLE} WHERE expires_at_ms IS NULL OR expires_at_ms > ${nowSql()}`
+        ));
+        const total = Number(count?.total);
+        if (!Number.isSafeInteger(total) || total < 0)
+          throw new Error(cryptoM("crypto_transportKeyStoreOperationFailed"));
+        if (total >= maxClients)
+          throw new Error(cryptoM("crypto_transportKeyStoreCapacityReached"));
+        const inserted = unwrapResult2("tx.execute", await tx.execute(
+          `INSERT INTO ${TRANSPORT_KEY_TABLE} (client_id, public_key, created_at_ms, expires_at_ms) VALUES (?, ?, ${nowSql()}, ${ttlSeconds === void 0 ? "NULL" : `${nowSql()} + ?`})`,
+          ttlSeconds === void 0 ? [clientId, publicKey] : [clientId, publicKey, ttlSeconds * 1e3]
+        ));
+        if (inserted.changes !== 1)
+          throw new Error(cryptoM("crypto_transportClientNotRegistered"));
+        return clientId;
+      });
     },
     async get(clientId) {
       await ensureTable();
       const row = unwrapResult2(
         "reldb.sql.get",
         await options.reldb.sql.get(
-          `SELECT public_key, expires_at FROM ${TRANSPORT_KEY_TABLE} WHERE client_id = ?`,
+          `SELECT public_key FROM ${TRANSPORT_KEY_TABLE} WHERE client_id = ? AND (expires_at_ms IS NULL OR expires_at_ms > ${nowSql()})`,
           [clientId]
         )
       );
-      if (!row)
-        return void 0;
-      if (row.expires_at && Date.parse(row.expires_at) <= Date.now()) {
-        await deleteClientKey(clientId);
-        return void 0;
-      }
-      return row.public_key;
+      return row?.public_key;
+    },
+    async claimRequest(clientId, requestId, expiresAt) {
+      await ensureTable();
+      if (!Number.isSafeInteger(expiresAt) || expiresAt <= Date.now())
+        return false;
+      const insertSql = options.reldb.config?.type === "mysql" ? `INSERT IGNORE INTO ${TRANSPORT_REQUEST_TABLE} (request_key, expires_at) VALUES (?, ?)` : `INSERT INTO ${TRANSPORT_REQUEST_TABLE} (request_key, expires_at) VALUES (?, ?) ON CONFLICT (request_key) DO NOTHING`;
+      const inserted = unwrapResult2("reldb.sql.execute", await options.reldb.sql.execute(
+        insertSql,
+        [JSON.stringify([clientId, requestId]), expiresAt]
+      ));
+      return inserted.changes === 1;
     },
     async delete(clientId) {
       await ensureTable();
       await deleteClientKey(clientId);
-    }
+    },
+    pruneExpired
   };
 }
 
-export { HaiCryptoError, TRANSPORT_PROTOCOL, createInMemoryKeyStore, createRedisTransportKeyStore, createReldbTransportKeyStore, crypto2 as crypto };
+export { HaiCryptoError, TRANSPORT_BODY_LIMITS, TRANSPORT_PROTOCOL, authenticateTransportRequest, createInMemoryKeyStore, createRedisTransportKeyStore, createReldbTransportKeyStore, crypto2 as crypto, isValidSM2PublicKey, parseTransportServerKeyRing, readTransportBody };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map