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

package/dist/index.js

@@ -35,7 +35,7 @@ var en_US_default = {
   crypto_hashFormatInvalid: "Invalid hash format",
   crypto_passwordVerifyFailed: "Password verification failed",
   crypto_transportClientKeyGenerateFailed: "Failed to generate transport client key pair",
-  crypto_transportServerKeyRingInvalid: "Transport server key ring is missing or invalid",
+  crypto_transportServerKeyRingInvalid: "The server transport key ring is missing or invalid. Check that private HAI_CRYPTO_TRANSPORT_SERVERKEYRING contains complete valid JSON and distribute the same ring to every node.",
   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",
@@ -55,7 +55,10 @@ var en_US_default = {
   crypto_transportResponseEncryptFailed: "Failed to encrypt transport response body",
   crypto_transportResponseDecryptFailed: "Failed to decrypt transport response body",
   crypto_transportSessionKeyEncryptFailed: "Failed to encrypt transport session key",
-  crypto_transportSessionKeyDecryptFailed: "Failed to decrypt transport session key"
+  crypto_transportSessionKeyDecryptFailed: "Failed to decrypt transport session key",
+  crypto_transportBodyLimitInvalid: "Transport plaintext limit must be an integer between 1024 and 67108864 bytes",
+  crypto_transportBodyTooLarge: "Encrypted transport payload exceeds the configured byte limit",
+  crypto_transportTimeInvalid: "Your device and server clocks may be out of sync, or the request has expired. Enable automatic time synchronization and refresh to retry. If this continues, ask an administrator to check the server clock."
 };
 
 // messages/ja-JP.json
@@ -90,7 +93,7 @@ var ja_JP_default = {
   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_transportServerKeyRingInvalid: "\u30B5\u30FC\u30D0\u30FC\u306E\u8EE2\u9001\u9375\u30EA\u30F3\u30B0\u304C\u4E0D\u8DB3\u307E\u305F\u306F\u4E0D\u6B63\u3067\u3059\u3002\u975E\u516C\u958B\u306E HAI_CRYPTO_TRANSPORT_SERVERKEYRING \u304C\u5B8C\u5168\u3067\u6709\u52B9\u306A JSON \u3067\u3042\u308B\u3053\u3068\u3092\u78BA\u8A8D\u3057\u3001\u5168\u30CE\u30FC\u30C9\u306B\u540C\u3058\u30EA\u30F3\u30B0\u3092\u914D\u5E03\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
   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",
@@ -110,7 +113,10 @@ var ja_JP_default = {
   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"
+  crypto_transportSessionKeyDecryptFailed: "\u901A\u4FE1\u30BB\u30C3\u30B7\u30E7\u30F3\u9375\u306E\u5FA9\u53F7\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+  crypto_transportBodyLimitInvalid: "\u901A\u4FE1\u5E73\u6587\u306E\u4E0A\u9650\u306F 1024 \u304B\u3089 67108864 \u30D0\u30A4\u30C8\u306E\u6574\u6570\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044",
+  crypto_transportBodyTooLarge: "\u6697\u53F7\u5316\u901A\u4FE1\u306E\u30C7\u30FC\u30BF\u304C\u8A2D\u5B9A\u3055\u308C\u305F\u30D0\u30A4\u30C8\u4E0A\u9650\u3092\u8D85\u3048\u3066\u3044\u307E\u3059",
+  crypto_transportTimeInvalid: "\u7AEF\u672B\u3068\u30B5\u30FC\u30D0\u30FC\u306E\u6642\u523B\u304C\u540C\u671F\u3057\u3066\u3044\u306A\u3044\u304B\u3001\u8981\u6C42\u306E\u6709\u52B9\u671F\u9650\u304C\u5207\u308C\u3066\u3044\u307E\u3059\u3002\u81EA\u52D5\u6642\u523B\u540C\u671F\u3092\u6709\u52B9\u306B\u3057\u3066\u30DA\u30FC\u30B8\u3092\u518D\u8AAD\u307F\u8FBC\u307F\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u89E3\u6D88\u3057\u306A\u3044\u5834\u5408\u306F\u7BA1\u7406\u8005\u306B\u30B5\u30FC\u30D0\u30FC\u306E\u6642\u523B\u78BA\u8A8D\u3092\u4F9D\u983C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
 };
 
 // messages/zh-CN.json
@@ -145,7 +151,7 @@ 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_transportServerKeyRingInvalid: "\u670D\u52A1\u7AEF\u4F20\u8F93\u5BC6\u94A5\u73AF\u7F3A\u5931\u6216\u65E0\u6548",
+  crypto_transportServerKeyRingInvalid: "\u670D\u52A1\u7AEF\u4F20\u8F93\u5BC6\u94A5\u73AF\u7F3A\u5931\u6216\u65E0\u6548\u3002\u8BF7\u68C0\u67E5\u79C1\u6709\u73AF\u5883\u53D8\u91CF HAI_CRYPTO_TRANSPORT_SERVERKEYRING \u662F\u5426\u4E3A\u5B8C\u6574\u6709\u6548\u7684 JSON\uFF0C\u5E76\u5411\u6240\u6709\u8282\u70B9\u5206\u53D1\u540C\u4E00\u5BC6\u94A5\u73AF\u3002",
   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",
@@ -165,7 +171,10 @@ var zh_CN_default = {
   crypto_transportResponseEncryptFailed: "\u4F20\u8F93\u52A0\u5BC6\u54CD\u5E94\u4F53\u52A0\u5BC6\u5931\u8D25",
   crypto_transportResponseDecryptFailed: "\u4F20\u8F93\u52A0\u5BC6\u54CD\u5E94\u4F53\u89E3\u5BC6\u5931\u8D25",
   crypto_transportSessionKeyEncryptFailed: "\u4F20\u8F93\u52A0\u5BC6\u4F1A\u8BDD\u5BC6\u94A5\u52A0\u5BC6\u5931\u8D25",
-  crypto_transportSessionKeyDecryptFailed: "\u4F20\u8F93\u52A0\u5BC6\u4F1A\u8BDD\u5BC6\u94A5\u89E3\u5BC6\u5931\u8D25"
+  crypto_transportSessionKeyDecryptFailed: "\u4F20\u8F93\u52A0\u5BC6\u4F1A\u8BDD\u5BC6\u94A5\u89E3\u5BC6\u5931\u8D25",
+  crypto_transportBodyLimitInvalid: "\u4F20\u8F93\u660E\u6587\u5BB9\u91CF\u5FC5\u987B\u662F 1024 \u5230 67108864 \u5B57\u8282\u4E4B\u95F4\u7684\u6574\u6570",
+  crypto_transportBodyTooLarge: "\u52A0\u5BC6\u4F20\u8F93\u62A5\u6587\u8D85\u8FC7\u914D\u7F6E\u7684\u5B57\u8282\u4E0A\u9650",
+  crypto_transportTimeInvalid: "\u8BBE\u5907\u4E0E\u670D\u52A1\u5668\u65F6\u95F4\u53EF\u80FD\u4E0D\u540C\u6B65\uFF0C\u6216\u8BF7\u6C42\u5DF2\u8FC7\u671F\u3002\u8BF7\u5F00\u542F\u81EA\u52A8\u6821\u65F6\u5E76\u5237\u65B0\u91CD\u8BD5\uFF1B\u82E5\u4ECD\u5931\u8D25\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u68C0\u67E5\u670D\u52A1\u5668\u65F6\u95F4\u3002"
 };
 
 // src/crypto-i18n.ts
@@ -186,7 +195,9 @@ var CryptoErrorInfo = {
   VERIFY_FAILED: "024:500",
   HASH_FAILED: "040:500",
   HMAC_FAILED: "041:500",
-  INVALID_IV: "060:400"
+  INVALID_IV: "060:400",
+  TRANSPORT_PAYLOAD_TOO_LARGE: "070:413",
+  TRANSPORT_TIME_INVALID: "071:400"
 };
 var HaiCryptoError = core.error.buildHaiErrorsDef("crypto", CryptoErrorInfo);
 
@@ -828,7 +839,8 @@ function decodeCiphertext(payload) {
 }
 
 // src/transport/crypto-transport-body.ts
-var TRANSPORT_BODY_LIMITS = {
+var TRANSPORT_PLAINTEXT_RANGE = Object.freeze({ min: 1024, max: 64 * 1024 * 1024 });
+var TRANSPORT_BODY_LIMITS = Object.freeze({
   /** 密钥协商 JSON 的 UTF-8 总字节数。 */
   keyExchangeBytes: 16384,
   /** GET/HEAD 请求及无正文响应的认证头封装 UTF-8 上限。 */
@@ -839,6 +851,26 @@ var TRANSPORT_BODY_LIMITS = {
   plaintextBytes: 1048576,
   /** 密文 JSON 的 UTF-8 总字节数（2 MiB + 32 KiB，含 CBC 填充与全部认证字段）。 */
   encryptedPayloadBytes: 2129920
+});
+function resolveTransportBodyLimits(maxPlaintextBytes = TRANSPORT_BODY_LIMITS.plaintextBytes) {
+  if (!Number.isSafeInteger(maxPlaintextBytes) || maxPlaintextBytes < TRANSPORT_PLAINTEXT_RANGE.min || maxPlaintextBytes > TRANSPORT_PLAINTEXT_RANGE.max)
+    throw new RangeError(cryptoM("crypto_transportBodyLimitInvalid"));
+  return Object.freeze({ ...TRANSPORT_BODY_LIMITS, plaintextBytes: maxPlaintextBytes, encryptedPayloadBytes: 2 * maxPlaintextBytes + 32768 });
+}
+var TransportBodyTooLargeError = class extends RangeError {
+  code = HaiCryptoError.TRANSPORT_PAYLOAD_TOO_LARGE.code;
+  direction;
+  stage;
+  limitBytes;
+  actualBytes;
+  constructor(limitBytes, actualBytes, options = {}) {
+    super(cryptoM("crypto_transportBodyTooLarge"));
+    this.name = "TransportBodyTooLargeError";
+    this.limitBytes = limitBytes;
+    this.actualBytes = actualBytes;
+    this.direction = options.direction ?? "request";
+    this.stage = options.stage ?? "plaintext";
+  }
 };
 async function readTransportBody(stream, options) {
   if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0)
@@ -870,7 +902,7 @@ async function readTransportBody(stream, options) {
       }
       bytes += chunk.value.byteLength;
       if (bytes > options.maxBytes)
-        throw new RangeError("Transport body byte limit exceeded");
+        throw new TransportBodyTooLargeError(options.maxBytes, bytes, options);
       text += decoder.decode(chunk.value, { stream: true });
     }
   } catch (error) {
@@ -942,8 +974,11 @@ function hashTransportPath(service, path) {
     return transportAuthenticationFailure();
   }
 }
-function sealTransportPayload(service, plaintext, context, direction, status, recipientPublicKey, senderPrivateKey) {
+function sealTransportPayload(service, plaintext, context, direction, status, recipientPublicKey, senderPrivateKey, limits = TRANSPORT_BODY_LIMITS) {
   try {
+    const bytes = new TextEncoder().encode(plaintext).byteLength;
+    if (bytes > limits.plaintextBytes)
+      return err(HaiCryptoError.TRANSPORT_PAYLOAD_TOO_LARGE, cryptoM("crypto_transportBodyTooLarge"), new TransportBodyTooLargeError(limits.plaintextBytes, bytes, { direction }));
     const encryptionKey = service.symmetric.generateKey();
     const authenticationKey = service.symmetric.generateKey() + service.symmetric.generateKey();
     const encrypted = service.symmetric.encryptWithIV(plaintext, encryptionKey);
@@ -959,14 +994,14 @@ function sealTransportPayload(service, plaintext, context, direction, status, re
     if (!signature.success)
       return transportAuthenticationFailure();
     const authenticated = { ...payload, tag: tag.data, signature: signature.data };
-    return isValidEncryptedPayload(authenticated) ? ok(authenticated) : transportAuthenticationFailure();
+    return isValidEncryptedPayload(authenticated, limits) ? ok(authenticated) : transportAuthenticationFailure();
   } catch {
     return transportAuthenticationFailure();
   }
 }
-function openTransportPayload(service, payload, recipientPrivateKey, senderPublicKey) {
+function openTransportPayload(service, payload, recipientPrivateKey, senderPublicKey, limits = TRANSPORT_BODY_LIMITS) {
   try {
-    if (!isValidEncryptedPayload(payload))
+    if (!isValidEncryptedPayload(payload, limits))
       return transportAuthenticationFailure();
     const text = authenticatedText(payload);
     const verified = service.asymmetric.verify(JSON.stringify([text, payload.tag]), payload.signature, senderPublicKey);
@@ -985,25 +1020,57 @@ function openTransportPayload(service, payload, recipientPrivateKey, senderPubli
     const plaintext = service.symmetric.decryptWithIV(payload.ciphertext, keys[0], payload.iv);
     if (!plaintext.success)
       return transportAuthenticationFailure();
+    const bytes = new TextEncoder().encode(plaintext.data).byteLength;
+    if (bytes > limits.plaintextBytes)
+      return err(HaiCryptoError.TRANSPORT_PAYLOAD_TOO_LARGE, cryptoM("crypto_transportBodyTooLarge"), new TransportBodyTooLargeError(limits.plaintextBytes, bytes, { direction: payload.direction }));
     return plaintext;
   } catch {
     return transportAuthenticationFailure();
   }
 }
-function isValidEncryptedPayload(value) {
+function isValidEncryptedPayload(value, limits = TRANSPORT_BODY_LIMITS) {
   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);
+  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 <= 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-error.ts
+var TransportTimeError = class extends Error {
+  constructor(context) {
+    super(cryptoM("crypto_transportTimeInvalid"));
+    this.context = context;
+    this.name = "TransportTimeError";
+  }
+  context;
+  code = HaiCryptoError.TRANSPORT_TIME_INVALID.code;
+};
+async function createTransportErrorResponse(error, authenticated) {
+  const status = error instanceof TransportTimeError ? 400 : error.direction === "request" ? 413 : 500;
+  const body = JSON.stringify({ success: false, error: { code: error.code, message: error.message, httpStatus: status, details: error instanceof TransportTimeError ? void 0 : {
+    direction: error.direction,
+    stage: error.stage,
+    limitBytes: error.limitBytes,
+    actualBytes: error.actualBytes
+  } } });
+  if (authenticated) {
+    const encrypted = await authenticated.manager.encryptResponse(authenticated.context, body, status);
+    if (encrypted.success) {
+      return Response.json(encrypted.data, { status, headers: { [TRANSPORT_PROTOCOL.ENCRYPTED_HEADER]: TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE } });
+    }
+  }
+  return new Response(body, { status, headers: { "Content-Type": "application/json; charset=utf-8" } });
+}
+
 // src/transport/crypto-transport-client.ts
 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;
@@ -1047,6 +1114,12 @@ function createTransportClient(options) {
       if (!isKeyExchangeResponse(body)) {
         return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportKeyExchangeMissingFields"));
       }
+      try {
+        const serverLimits = resolveTransportBodyLimits(body.maxPlaintextBytes);
+        bodyLimits = resolveTransportBodyLimits(Math.min(localLimits?.plaintextBytes ?? serverLimits.plaintextBytes, serverLimits.plaintextBytes));
+      } catch {
+        return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportBodyLimitInvalid"));
+      }
       keyPair = localKeyPair;
       serverPublicKey = body.serverPublicKey;
       serverKeyId = body.serverKeyId;
@@ -1071,12 +1144,12 @@ function createTransportClient(options) {
   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);
+    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);
+    return openTransportPayload(options.crypto, payload, keyPair.privateKey, serverPublicKey, bodyLimits);
   }
   const encryptedFetch = async (input, init) => {
     const requestInput = isRequestLike(input) ? input : void 0;
@@ -1109,7 +1182,7 @@ function createTransportClient(options) {
     if (rawBody == null && requestInput) {
       const method2 = (init?.method ?? requestInput.method).toUpperCase();
       if (method2 !== "GET" && method2 !== "HEAD") {
-        const text = await readTransportBody(requestInput.body, { maxBytes: TRANSPORT_BODY_LIMITS.plaintextBytes, signal });
+        const text = await readTransportBody(requestInput.body, { maxBytes: bodyLimits.plaintextBytes, signal });
         if (text)
           rawBody = text;
       }
@@ -1129,13 +1202,13 @@ function createTransportClient(options) {
       method,
       pathHash: pathHash.data
     };
-    const plaintext = rawBody == null ? "" : await readTransportBody(new Response(rawBody).body, { maxBytes: TRANSPORT_BODY_LIMITS.plaintextBytes, signal });
+    const plaintext = rawBody == null ? "" : await readTransportBody(new Response(rawBody).body, { maxBytes: bodyLimits.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");
+    if (new TextEncoder().encode(serialized).byteLength > bodyLimits.encryptedPayloadBytes)
+      throw new TransportBodyTooLargeError(bodyLimits.encryptedPayloadBytes, new TextEncoder().encode(serialized).byteLength, { stage: "encrypted" });
     let nextBody;
     headers.delete(TRANSPORT_PROTOCOL.ENVELOPE_HEADER);
     headers.set(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER, TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE);
@@ -1143,7 +1216,7 @@ function createTransportClient(options) {
     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");
+        throw new TransportBodyTooLargeError(TRANSPORT_BODY_LIMITS.envelopeHeaderBytes, new TextEncoder().encode(serialized).byteLength, { stage: "header" });
       headers.set(TRANSPORT_PROTOCOL.ENVELOPE_HEADER, serialized);
     } else {
       nextBody = serialized;
@@ -1169,6 +1242,8 @@ function createTransportClient(options) {
     if (response.headers.get(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER) !== TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE) {
       void response.body?.cancel().catch(() => {
       });
+      if (response.status === 413)
+        throw new TransportBodyTooLargeError(bodyLimits.encryptedPayloadBytes, void 0, { stage: "encrypted" });
       throw new Error(cryptoM("crypto_transportResponseDecryptFailed"));
     }
     let payload;
@@ -1180,19 +1255,44 @@ function createTransportClient(options) {
         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 {
+        throw new TransportBodyTooLargeError(TRANSPORT_BODY_LIMITS.envelopeHeaderBytes, new TextEncoder().encode(envelope).byteLength, { direction: "response", stage: "header" });
+      payload = JSON.parse(envelope ?? await readTransportBody(response.body, { maxBytes: bodyLimits.encryptedPayloadBytes, direction: "response", stage: "encrypted", signal }));
+    } catch (error) {
+      if (error instanceof TransportBodyTooLargeError)
+        throw error;
       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)) {
+    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 (!decResult.success)
+    if (!decResult.success) {
+      if (decResult.error.cause instanceof TransportBodyTooLargeError)
+        throw decResult.error.cause;
       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");
+    }
+    if (new TextEncoder().encode(decResult.data).byteLength > bodyLimits.plaintextBytes)
+      throw new TransportBodyTooLargeError(bodyLimits.plaintextBytes, new TextEncoder().encode(decResult.data).byteLength, { direction: "response" });
+    if (response.status === 400) {
+      let failure;
+      try {
+        failure = JSON.parse(decResult.data);
+      } catch {
+      }
+      if (failure?.success === false && failure.error?.code === HaiCryptoError.TRANSPORT_TIME_INVALID.code)
+        throw new TransportTimeError();
+    }
+    if (response.status === 500) {
+      let failure;
+      try {
+        failure = JSON.parse(decResult.data);
+      } catch {
+      }
+      const details = failure?.error?.details;
+      if (failure?.success === false && failure.error?.code === "hai:crypto:070" && details?.direction === "response" && (details.stage === "plaintext" || details.stage === "encrypted" || details.stage === "header") && typeof details.limitBytes === "number" && Number.isSafeInteger(details.limitBytes) && details.limitBytes >= 0) {
+        throw new TransportBodyTooLargeError(details.limitBytes, typeof details.actualBytes === "number" ? details.actualBytes : void 0, { direction: "response", stage: details.stage });
+      }
+    }
     const respHeaders = new Headers(response.headers);
     respHeaders.delete(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER);
     respHeaders.delete(TRANSPORT_PROTOCOL.ENVELOPE_HEADER);
@@ -1258,6 +1358,12 @@ function isTransportServerKeyRing(value) {
 
 // src/transport/crypto-transport-server.ts
 function createTransportEncryption(cryptoService, options) {
+  let bodyLimits;
+  try {
+    bodyLimits = resolveTransportBodyLimits(options?.maxPlaintextBytes);
+  } catch {
+    return err(HaiCryptoError.INVALID_INPUT, cryptoM("crypto_transportBodyLimitInvalid"));
+  }
   const ring = parseTransportServerKeyRing(options?.serverKeyRing);
   if (!ring.success)
     return ring;
@@ -1280,6 +1386,7 @@ function createTransportEncryption(cryptoService, options) {
   const serverKeyPair = serverKeys.get(activeKeyId);
   const keyStore = options.keyStore;
   const manager = {
+    bodyLimits,
     getServerKeyId() {
       return activeKeyId;
     },
@@ -1303,36 +1410,40 @@ function createTransportEncryption(cryptoService, options) {
         const key = serverKeys.get(context.serverKeyId);
         if (!key)
           return transportAuthenticationFailure();
-        return sealTransportPayload(cryptoService, data, context, "response", status, clientPublicKey, key.privateKey);
+        return sealTransportPayload(cryptoService, data, context, "response", status, clientPublicKey, key.privateKey, bodyLimits);
       } catch {
         return err(HaiCommonError.INTERNAL_ERROR, cryptoM("crypto_transportResponseEncryptFailed"));
       }
     },
     async decryptRequest(payload, expected) {
       try {
-        if (!isValidEncryptedPayload(payload) || payload.direction !== "request" || payload.status !== 0)
+        if (!isValidEncryptedPayload(payload, bodyLimits) || 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) {
+        if (!pathHash.success || c.clientId !== expected.clientId || c.method !== expected.method || c.pathHash !== pathHash.data) {
           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);
+        const plaintext = openTransportPayload(cryptoService, authenticated, key.privateKey, clientPublicKey, bodyLimits);
         if (!plaintext.success)
           return plaintext;
-        if (Date.now() >= c.issuedAt + TRANSPORT_PROTOCOL.REQUEST_WINDOW_MS)
-          return transportAuthenticationFailure();
+        const timeFailure = () => {
+          const error = new TransportTimeError(c);
+          return err(HaiCryptoError.TRANSPORT_TIME_INVALID, error.message, error);
+        };
+        const now = Date.now();
+        if (c.issuedAt > now + TRANSPORT_PROTOCOL.CLOCK_SKEW_MS || now >= c.issuedAt + TRANSPORT_PROTOCOL.REQUEST_WINDOW_MS)
+          return timeFailure();
         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 timeFailure();
         return plaintext;
       } catch {
         return transportAuthenticationFailure();
@@ -1480,9 +1591,10 @@ async function authenticateTransportRequest(manager, request) {
   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");
+    throw new TransportBodyTooLargeError(TRANSPORT_BODY_LIMITS.envelopeHeaderBytes, new TextEncoder().encode(envelope).byteLength, { stage: "header" });
   const text = envelope ?? await readTransportBody(request.body, {
-    maxBytes: TRANSPORT_BODY_LIMITS.encryptedPayloadBytes,
+    maxBytes: manager.bodyLimits.encryptedPayloadBytes,
+    stage: "encrypted",
     signal: request.signal
   });
   let payload;
@@ -1491,7 +1603,7 @@ async function authenticateTransportRequest(manager, request) {
   } catch {
     return transportAuthenticationFailure();
   }
-  if (!isValidEncryptedPayload(payload) || payload.direction !== "request" || payload.status !== 0)
+  if (!isValidEncryptedPayload(payload, manager.bodyLimits) || payload.direction !== "request" || payload.status !== 0)
     return transportAuthenticationFailure();
   const url = new URL(request.url);
   const decrypted = await manager.decryptRequest(payload, {
@@ -1499,10 +1611,13 @@ async function authenticateTransportRequest(manager, request) {
     method: request.method,
     path: url.pathname + url.search
   });
-  if (!decrypted.success)
+  if (!decrypted.success) {
+    if (decrypted.error.cause instanceof TransportBodyTooLargeError)
+      throw decrypted.error.cause;
     return decrypted;
-  if (new TextEncoder().encode(decrypted.data).byteLength > TRANSPORT_BODY_LIMITS.plaintextBytes)
-    throw new RangeError("Transport request plaintext byte limit exceeded");
+  }
+  if (new TextEncoder().encode(decrypted.data).byteLength > manager.bodyLimits.plaintextBytes)
+    throw new TransportBodyTooLargeError(manager.bodyLimits.plaintextBytes, new TextEncoder().encode(decrypted.data).byteLength);
   if (bodyless && decrypted.data !== "")
     return transportAuthenticationFailure();
   return ok({ plaintext: decrypted.data, context: payload.context });
@@ -1807,6 +1922,6 @@ function createReldbTransportKeyStore(options) {
   };
 }
 
-export { HaiCryptoError, TRANSPORT_BODY_LIMITS, TRANSPORT_PROTOCOL, authenticateTransportRequest, createInMemoryKeyStore, createRedisTransportKeyStore, createReldbTransportKeyStore, crypto2 as crypto, isValidSM2PublicKey, parseTransportServerKeyRing, readTransportBody };
+export { HaiCryptoError, TRANSPORT_BODY_LIMITS, TRANSPORT_PLAINTEXT_RANGE, TRANSPORT_PROTOCOL, TransportBodyTooLargeError, TransportTimeError, authenticateTransportRequest, createInMemoryKeyStore, createRedisTransportKeyStore, createReldbTransportKeyStore, createTransportErrorResponse, crypto2 as crypto, isValidSM2PublicKey, parseTransportServerKeyRing, readTransportBody, resolveTransportBodyLimits };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map