castrum 0.9.7 → 0.9.8

package/dist/index.js

@@ -87,7 +87,8 @@ function createBunCodec() {
     },
     decodeUtf8: decodeUtf8Bun,
     decodeUtf8Fatal: decodeUtf8Bun,
-    decodeUtf8Range: decodeUtf8RangeBun
+    decodeUtf8Range: decodeUtf8RangeBun,
+    decodeUtf8RangeView: decodeUtf8RangeViewBun
   };
 }
 function bunEncodeUtf8Into(s, dest, offset = 0) {
@@ -122,6 +123,14 @@ function decodeUtf8RangeBun(bytes, start, end) {
   }
   return view.toString("latin1", base + start, base + end);
 }
+function decodeUtf8RangeViewBun(view, start, end) {
+  for (let i = start;i < end; i++) {
+    if ((view[i] ?? 0) >= 128) {
+      return view.toString("utf8", start, end);
+    }
+  }
+  return view.toString("latin1", start, end);
+}
 function createNodeCodec() {
   return {
     encodeUtf8(s) {
@@ -144,6 +153,14 @@ function createNodeCodec() {
         }
       }
       return view.toString("latin1", start, end);
+    },
+    decodeUtf8RangeView(view, start, end) {
+      for (let i = start;i < end; i++) {
+        if ((view[i] ?? 0) >= 128) {
+          return view.toString("utf8", start, end);
+        }
+      }
+      return view.toString("latin1", start, end);
     }
   };
 }
@@ -264,6 +281,362 @@ var init_builtins = __esm(() => {
   runtimeBuiltins = createBuiltins(detectedRuntime);
 });
 
+// src/native/ffi/symbols.ts
+function buildFFISymbolMap(useBufferLength) {
+  const inputAbi = useBufferLength ? ["buffer", "buffer_length"] : ["ptr", "usize"];
+  const abi = (shape) => {
+    if (!useBufferLength)
+      return shape;
+    const out = [];
+    for (let i = 0;i < shape.length; i++) {
+      const t = shape[i];
+      if (t === "ptr") {
+        out.push("buffer");
+        out.push("buffer_length");
+        i++;
+      } else {
+        out.push(t);
+      }
+    }
+    return out;
+  };
+  const U64_FAST = "u64_fast";
+  return {
+    castrum_crc32: { args: inputAbi, returns: "u32" },
+    castrum_fnv1a64: { args: inputAbi, returns: "u64" },
+    castrum_xxh3: { args: inputAbi, returns: "u64" },
+    castrum_json_valid: { args: inputAbi, returns: "u8" },
+    castrum_utf8_valid: { args: inputAbi, returns: "u8" },
+    castrum_hex_encode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_hex_decode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_url_encode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_url_decode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_validate_email: { args: ["cstring"], returns: "u8" },
+    castrum_validate_uuid: { args: ["cstring"], returns: "u8" },
+    castrum_validate_ipv4: { args: ["cstring"], returns: "u8" },
+    castrum_validate_ipv6: { args: ["cstring"], returns: "u8" },
+    castrum_validate_email_bytes: { args: inputAbi, returns: "u8" },
+    castrum_validate_uuid_bytes: { args: inputAbi, returns: "u8" },
+    castrum_validate_ipv4_bytes: { args: inputAbi, returns: "u8" },
+    castrum_validate_ipv6_bytes: { args: inputAbi, returns: "u8" },
+    castrum_json_sum_ids: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_hmac_sha256_verify: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: "u8"
+    },
+    castrum_csrf_verify: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "u8" },
+    castrum_password_verify: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "u8" },
+    castrum_password_verify_bcrypt: {
+      args: abi(["ptr", "usize", "cstring"]),
+      returns: "u8"
+    },
+    castrum_ws_accept_key: { args: ["cstring"], returns: "cstring" },
+    castrum_ws_accept_key_into: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_etag: { args: abi(["ptr", "usize", "u8"]), returns: "cstring" },
+    castrum_etag_into: { args: abi(["ptr", "usize", "u8", "ptr", "usize"]), returns: U64_FAST },
+    castrum_conditional_is_not_modified: {
+      args: abi(["usize", "ptr", "usize", "ptr", "usize", "u8"]),
+      returns: "u8"
+    },
+    castrum_media_type_matcher_matches: {
+      args: abi(["usize", "ptr", "usize"]),
+      returns: "u8"
+    },
+    castrum_accept_negotiator_negotiate: {
+      args: abi(["usize", "ptr", "usize"]),
+      returns: "cstring"
+    },
+    castrum_accept_negotiator_negotiate_server: {
+      args: ["usize", "cstring"],
+      returns: "cstring"
+    },
+    castrum_jwt_signer_sign: {
+      args: abi(["usize", "ptr", "usize", "i64", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_jwt_signer_verify: {
+      args: abi(["usize", "ptr", "usize", "i64", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_template_render: {
+      args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_schema_validator_validate: {
+      args: abi(["usize", "ptr", "usize"]),
+      returns: "u8"
+    },
+    castrum_rate_limiter_check: {
+      args: abi(["usize", "cstring", "i64", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_rate_limiter_check_key: {
+      args: abi(["usize", "i64", "i64", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_random_token: { args: ["u32"], returns: "cstring" },
+    castrum_random_token_into: { args: ["u32", ...abi(["ptr", "usize"])], returns: U64_FAST },
+    castrum_base64_encode: {
+      args: abi(["ptr", "usize", "ptr", "usize", "u8", "u8"]),
+      returns: U64_FAST
+    },
+    castrum_base64_decode: {
+      args: abi(["ptr", "usize", "ptr", "usize", "u8", "u8"]),
+      returns: U64_FAST
+    },
+    castrum_hmac_sha256: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_sign_cookie: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "cstring" },
+    castrum_sign_cookie_into: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_verify_cookie: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "cstring" },
+    castrum_verify_cookie_into: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_csrf_token: { args: abi(["ptr", "usize"]), returns: "cstring" },
+    castrum_csrf_token_into: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_password_hash: {
+      args: abi(["ptr", "usize", "ptr", "usize", "u32", "u32", "u32", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_password_hash_bcrypt: {
+      args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_pbkdf2_sha256: {
+      args: abi(["ptr", "usize", "ptr", "usize", "u32", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_aead_encrypt: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_aead_decrypt: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_ws_frame_encode: {
+      args: abi(["u8", "ptr", "usize", "u8", "u8", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_json_patch: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_gzip_compress: {
+      args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_gzip_decompress: {
+      args: abi(["ptr", "usize", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_brotli_compress: {
+      args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_brotli_decompress: {
+      args: abi(["ptr", "usize", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_gzip_isize: { args: abi(["ptr", "usize"]), returns: "u32" },
+    castrum_http_parse_request_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_query_parse_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_cookie_parse_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_http_date_into: { args: ["f64", ...abi(["ptr", "usize"])], returns: U64_FAST },
+    castrum_sse_encode_into: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_jwt_sign_bytes: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64"]),
+      returns: "cstring"
+    },
+    castrum_jwt_sign_bytes_into: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_ed25519_generate_keypair: {
+      args: abi(["ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_ed25519_sign: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_ed25519_verify: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: "u32"
+    },
+    castrum_jwt_eddsa_sign: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64"]),
+      returns: "cstring"
+    },
+    castrum_jwt_eddsa_verify: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64"]),
+      returns: "cstring"
+    },
+    castrum_ws_frame_decode_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_multipart_parse_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_form_parse_packed: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_json_parse_packed: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_parse_media_type: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_parse_http_date: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_parse_accept_encoding: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_url_encode_query: { args: abi(["ptr", "usize"]), returns: "cstring" },
+    castrum_url_resolve: {
+      args: abi(["ptr", "usize", "ptr", "usize"]),
+      returns: "cstring"
+    },
+    castrum_url_builder_resolve: {
+      args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_mime_from_extension: { args: ["cstring"], returns: "cstring" },
+    castrum_jwt_verify: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64"]),
+      returns: "cstring"
+    },
+    castrum_ingress_handle_packed: {
+      args: abi(["usize", "ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_ingress_handle_components: {
+      args: abi([
+        "usize",
+        "u8",
+        "cstring",
+        "cstring",
+        "ptr",
+        "usize",
+        "ptr",
+        "usize",
+        "ptr",
+        "usize",
+        "ptr",
+        "usize"
+      ]),
+      returns: U64_FAST
+    },
+    castrum_ingress_layout: { args: abi(["ptr", "usize"]), returns: U64_FAST },
+    castrum_route_compile: { args: abi(["ptr", "usize"]), returns: U64_FAST },
+    castrum_route_run: {
+      args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_route_destroy: { args: ["usize"], returns: "void" },
+    castrum_hex_validate_batch: {
+      args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_regex_escape: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_metrics_create: { args: [], returns: U64_FAST },
+    castrum_metrics_counter: { args: ["usize", "cstring", "cstring"], returns: "u32" },
+    castrum_metrics_gauge: { args: ["usize", "cstring", "cstring"], returns: "u32" },
+    castrum_metrics_histogram: {
+      args: ["usize", "cstring", "cstring", "cstring"],
+      returns: "u32"
+    },
+    castrum_metrics_record: {
+      args: abi(["usize", "u32", "ptr", "usize", "f64"]),
+      returns: "u8"
+    },
+    castrum_metrics_gauge_set: {
+      args: abi(["usize", "u32", "ptr", "usize", "f64"]),
+      returns: "u8"
+    },
+    castrum_metrics_record_str: {
+      args: ["usize", "u32", "cstring", "f64"],
+      returns: "u8"
+    },
+    castrum_metrics_gauge_set_str: {
+      args: ["usize", "u32", "cstring", "f64"],
+      returns: "u8"
+    },
+    castrum_regex_escape_str: { args: ["cstring"], returns: "cstring" },
+    castrum_hex_validate_batch_str: {
+      args: abi(["cstring", "u32", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_metrics_render: { args: abi(["usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_metrics_snapshot: { args: abi(["usize", "ptr", "usize"]), returns: U64_FAST },
+    castrum_metrics_record_batch: {
+      args: abi(["usize", "ptr", "usize"]),
+      returns: "u8"
+    },
+    castrum_query_validate: { args: ["usize", "cstring"], returns: "u8" },
+    castrum_cookie_validate: { args: ["usize", "cstring"], returns: "u8" },
+    castrum_session_seal: {
+      args: ["cstring", "cstring", "i64", "cstring"],
+      returns: "cstring"
+    },
+    castrum_session_open: {
+      args: abi(["cstring", "cstring", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_session_seal_bytes: {
+      args: abi(["ptr", "usize", "ptr", "usize", "i64", "ptr", "usize"]),
+      returns: "cstring"
+    },
+    castrum_session_open_bytes: {
+      args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
+      returns: U64_FAST
+    },
+    castrum_task_init: { args: ["u32"], returns: "u32" },
+    castrum_task_submit: { args: abi(["u32", "ptr", "usize", "usize"]), returns: "u32" },
+    castrum_task_submit_slice: {
+      args: abi(["u32", "ptr", "usize", "ptr", "usize", "usize"]),
+      returns: "u32"
+    },
+    castrum_task_submit_out: {
+      args: abi(["u32", "ptr", "usize", "usize", "ptr", "usize"]),
+      returns: "u32"
+    },
+    castrum_task_drain: { args: abi(["ptr", "usize"]), returns: U64_FAST },
+    castrum_task_pending: { args: [], returns: "u32" },
+    castrum_task_cancel: { args: ["usize"], returns: "u32" },
+    castrum_task_set_doorbell: { args: ["ptr"], returns: "u32" },
+    castrum_task_shutdown: { args: [], returns: "u32" },
+    castrum_task_threads: { args: [], returns: "u32" },
+    castrum_metrics_destroy: { args: ["usize"], returns: "void" }
+  };
+}
+
 // src/shared/runtime.ts
 var isBun;
 var init_runtime = __esm(() => {
@@ -272,29 +645,17 @@ var init_runtime = __esm(() => {
 });
 
 // src/shared/codec.ts
-var encodeUtf8, encodeUtf8Into, decodeUtf8, decodeUtf8Range, decodeUtf8Fatal;
+var encodeUtf8, encodeUtf8Into, decodeUtf8, decodeUtf8Range, decodeUtf8RangeView, decodeUtf8Fatal;
 var init_codec2 = __esm(() => {
   init_codec();
   encodeUtf8 = runtimeCodec.encodeUtf8;
   encodeUtf8Into = runtimeCodec.encodeUtf8Into;
   decodeUtf8 = runtimeCodec.decodeUtf8;
   decodeUtf8Range = runtimeCodec.decodeUtf8Range;
+  decodeUtf8RangeView = runtimeCodec.decodeUtf8RangeView ? runtimeCodec.decodeUtf8RangeView : (view, start, end) => decodeUtf8Range(view, start, end);
   decodeUtf8Fatal = runtimeCodec.decodeUtf8Fatal;
 });
 
-// src/native/ffi/constants.ts
-var MAX_DECOMPRESSED, MAX_JSON_PATCH_OUTPUT, COMPRESS_INITIAL_CAP, COMPRESS_MAX_CAP, COMPRESS_HEADROOM = 64, DECOMPRESS_GUESS_MULTIPLIER_GZIP = 16, DECOMPRESS_GUESS_MULTIPLIER_BROTLI = 32, DECOMPRESS_FALLBACK_CAP, DECOMPRESS_MIN_INITIAL = 1024, SELFTEST_HEX, SELFTEST_JSON, EMPTY_VIEW;
-var init_constants = __esm(() => {
-  MAX_DECOMPRESSED = 64 * 1024 * 1024;
-  MAX_JSON_PATCH_OUTPUT = 128 * 1024 * 1024;
-  COMPRESS_INITIAL_CAP = 16 * 1024;
-  COMPRESS_MAX_CAP = 1024 * 1024;
-  DECOMPRESS_FALLBACK_CAP = 4 * 1024 * 1024;
-  SELFTEST_HEX = new Uint8Array([104, 101, 108, 108, 111]);
-  SELFTEST_JSON = new Uint8Array([123, 34, 97, 34, 58, 49, 125]);
-  EMPTY_VIEW = new Uint8Array(0);
-});
-
 // src/shared/bytes.ts
 function toBytes(v) {
   return typeof v === "string" ? encodeUtf8(v) : v;
@@ -696,365 +1057,160 @@ function buildCodecs(sym, ctx) {
     }
   };
 }
-function selfTestCodecs(b) {
+var init_codecs = __esm(() => {
+  init_codec2();
+  init_util();
+});
+
+// src/native/ffi/constants.ts
+var MAX_DECOMPRESSED, MAX_JSON_PATCH_OUTPUT, COMPRESS_INITIAL_CAP, COMPRESS_MAX_CAP, COMPRESS_HEADROOM = 64, DECOMPRESS_GUESS_MULTIPLIER_GZIP = 16, DECOMPRESS_GUESS_MULTIPLIER_BROTLI = 32, DECOMPRESS_FALLBACK_CAP, DECOMPRESS_MIN_INITIAL = 1024, SELFTEST_HEX, SELFTEST_JSON, EMPTY_VIEW;
+var init_constants = __esm(() => {
+  MAX_DECOMPRESSED = 64 * 1024 * 1024;
+  MAX_JSON_PATCH_OUTPUT = 128 * 1024 * 1024;
+  COMPRESS_INITIAL_CAP = 16 * 1024;
+  COMPRESS_MAX_CAP = 1024 * 1024;
+  DECOMPRESS_FALLBACK_CAP = 4 * 1024 * 1024;
+  SELFTEST_HEX = new Uint8Array([104, 101, 108, 108, 111]);
+  SELFTEST_JSON = new Uint8Array([123, 34, 97, 34, 58, 49, 125]);
+  EMPTY_VIEW = new Uint8Array(0);
+});
+
+// src/native/ffi/build/compress.ts
+function buildCompress(sym, ctx) {
+  const { lenOrView, scratchFor } = ctx;
+  const gzipCompress = sym.castrum_gzip_compress;
+  const gzipDecompress = sym.castrum_gzip_decompress;
+  const brotliCompress = sym.castrum_brotli_compress;
+  const brotliDecompress = sym.castrum_brotli_decompress;
+  const gzipIsize = sym.castrum_gzip_isize;
+  const jsonPatch = sym.castrum_json_patch;
+  return {
+    jsonPatch(doc, patch) {
+      let out = scratchFor(Math.min(Math.max(doc.length, patch.length) + 16, 64 * 1024));
+      let w = Number(jsonPatch(doc, lenOrView(doc), patch, lenOrView(patch), out, lenOrView(out)));
+      if (w > out.length && w <= MAX_JSON_PATCH_OUTPUT) {
+        out = new Uint8Array(w);
+        w = Number(jsonPatch(doc, lenOrView(doc), patch, lenOrView(patch), out, lenOrView(out)));
+      }
+      if (w === 0 || w > out.length) {
+        throw new Error("json patch: output buffer too small or patch inapplicable");
+      }
+      return decodeUtf8(out.subarray(0, w));
+    },
+    gzipCompress(data, level = 6) {
+      return growExact((out) => Number(gzipCompress(data, lenOrView(data), Math.min(level, 9), out, lenOrView(out))), Math.min(data.length + COMPRESS_HEADROOM, COMPRESS_INITIAL_CAP), Math.max(data.length * 2 + COMPRESS_HEADROOM, COMPRESS_MAX_CAP), "gzip compress: output buffer too small");
+    },
+    gzipCompressInto(data, output, level = 6) {
+      const w = Number(gzipCompress(data, lenOrView(data), Math.min(level, 9), output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("gzip compress: invalid input");
+      }
+      if (w > output.length) {
+        throw new Error("gzip compress: output buffer too small");
+      }
+      return w;
+    },
+    gzipDecompress(data, maxDecompressed) {
+      const max = maxDecompressed ?? MAX_DECOMPRESSED;
+      const isize = Number(gzipIsize(data, lenOrView(data)));
+      const initial = isize !== 0 ? Math.min(isize, max) : Math.min(data.length * DECOMPRESS_GUESS_MULTIPLIER_GZIP, DECOMPRESS_FALLBACK_CAP);
+      return growExact((out) => Number(gzipDecompress(data, lenOrView(data), max, out, lenOrView(out))), initial, max, "gzip decompress: invalid stream or exceeded max decompressed size");
+    },
+    gzipDecompressInto(data, output, maxDecompressed) {
+      const max = maxDecompressed ?? MAX_DECOMPRESSED;
+      const w = Number(gzipDecompress(data, lenOrView(data), max, output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("gzip decompress: invalid stream or exceeded max decompressed size");
+      }
+      if (w > output.length) {
+        throw new Error("gzip decompress: output buffer too small");
+      }
+      return w;
+    },
+    gzipIsize(data) {
+      return Number(gzipIsize(data, lenOrView(data)));
+    },
+    brotliCompress(data, quality = 5) {
+      return growExact((out) => Number(brotliCompress(data, lenOrView(data), Math.min(quality, 11), out, lenOrView(out))), Math.min(data.length + COMPRESS_HEADROOM, COMPRESS_INITIAL_CAP), Math.max(data.length * 2 + COMPRESS_HEADROOM, COMPRESS_MAX_CAP), "brotli compress: output buffer too small");
+    },
+    brotliCompressInto(data, output, quality = 5) {
+      const w = Number(brotliCompress(data, lenOrView(data), Math.min(quality, 11), output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("brotli compress: invalid input");
+      }
+      if (w > output.length) {
+        throw new Error("brotli compress: output buffer too small");
+      }
+      return w;
+    },
+    brotliDecompress(data, maxDecompressed) {
+      const max = maxDecompressed ?? MAX_DECOMPRESSED;
+      return growExact((out) => Number(brotliDecompress(data, lenOrView(data), max, out, lenOrView(out))), Math.min(Math.max(data.length * DECOMPRESS_GUESS_MULTIPLIER_BROTLI, DECOMPRESS_MIN_INITIAL), DECOMPRESS_FALLBACK_CAP), max, "brotli decompress: invalid stream or exceeded max decompressed size");
+    },
+    brotliDecompressInto(data, output, maxDecompressed) {
+      const max = maxDecompressed ?? MAX_DECOMPRESSED;
+      const w = Number(brotliDecompress(data, lenOrView(data), max, output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("brotli decompress: invalid stream or exceeded max decompressed size");
+      }
+      if (w > output.length) {
+        throw new Error("brotli decompress: output buffer too small");
+      }
+      return w;
+    }
+  };
+}
+function selfTestCompress(b) {
   const enc = { encode: encodeUtf8 };
   const dec = { decode: decodeUtf8 };
-  if (b.crc32(enc.encode("123456789")) !== 3421780262)
-    return false;
-  if (b.fnv1a64(enc.encode("foobar")) !== 0x85944171f73967e8n)
-    return false;
-  if (b.xxh3(new Uint8Array(0)) !== 0x2d06800538d394c2n)
-    return false;
-  if (b.jsonValid(SELFTEST_JSON) !== true || b.jsonValid(enc.encode("{not json")) !== false) {
-    return false;
-  }
-  if (!b.utf8Valid(enc.encode("héllo")) || b.utf8Valid(new Uint8Array([255, 254]))) {
-    return false;
-  }
-  const hexOut = new Uint8Array(SELFTEST_HEX.length * 2);
-  if (b.hexEncodeInto(SELFTEST_HEX, hexOut) !== 10 || dec.decode(hexOut) !== "68656c6c6f") {
-    return false;
-  }
-  const urlInput = enc.encode("a b/c");
-  const urlOut = new Uint8Array(9);
-  if (b.urlEncodeInto(urlInput, urlOut) !== 9 || dec.decode(urlOut) !== "a%20b%2Fc") {
+  const patched = b.jsonPatch(enc.encode(`{"a":"b"}`), enc.encode(`[{"op":"add","path":"/c","value":"d"}]`));
+  if (!patched.includes(`"c":"d"`)) {
     return false;
   }
-  if (!b.validateEmail("a@b.com") || !b.validateUuid("550e8400-e29b-41d4-a716-446655440000") || !b.validateIpv4("192.168.0.1") || !b.validateIpv6("2001:db8::1") || b.validateEmail("not-an-email") || b.validateUuid("not-a-uuid")) {
+  const gz = b.gzipCompress(SELFTEST_HEX);
+  if (dec.decode(b.gzipDecompress(gz)) !== "hello") {
     return false;
   }
-  if (!b.validateEmailBytes(enc.encode("a@b.com")) || !b.validateUuidBytes(enc.encode("550e8400-e29b-41d4-a716-446655440000")) || !b.validateIpv4Bytes(enc.encode("192.168.0.1")) || !b.validateIpv6Bytes(enc.encode("2001:db8::1")) || b.validateEmailBytes(enc.encode("not-an-email")) || b.validateIpv6Bytes(enc.encode("999"))) {
+  const br = b.brotliCompress(SELFTEST_HEX);
+  if (dec.decode(b.brotliDecompress(br)) !== "hello") {
     return false;
   }
-  if (b.jsonSumIds(enc.encode(`[{"id":1},{"id":2}]`)) !== 3n)
-    return false;
-  if (b.jsonSumIds(enc.encode(`[{"id":0},{"id":0}]`)) !== 0n)
-    return false;
-  let sumInvalidThrew = false;
+  let decompressThrew = false;
   try {
-    b.jsonSumIds(enc.encode("nope"));
+    b.gzipDecompress(enc.encode("not-a-gzip-stream"));
   } catch {
-    sumInvalidThrew = true;
-  }
-  if (!sumInvalidThrew)
-    return false;
-  {
-    const ids = enc.encode(`507f1f77bcf86cd799439011
-zz
-507F1F77BCF86CD799439012`);
-    const tiny = new Uint8Array(2);
-    const needed = b.hexValidateBatchInto(ids, 24, tiny);
-    if (needed !== 3)
-      return false;
-    const out = new Uint8Array(needed);
-    if (b.hexValidateBatchInto(ids, 24, out) !== 3)
-      return false;
-    if (out[0] !== 1 || out[1] !== 0 || out[2] !== 1)
-      return false;
-    let widthThrew = false;
-    try {
-      b.hexValidateBatchInto(ids, 0, new Uint8Array(3));
-    } catch {
-      widthThrew = true;
-    }
-    if (!widthThrew)
-      return false;
-  }
-  {
-    const out = new Uint8Array(64);
-    const w = b.regexEscapeInto(enc.encode("a.c(x)"), out);
-    if (w !== 9 || dec.decode(out.subarray(0, w)) !== "a\\.c\\(x\\)")
-      return false;
-    const plain = new Uint8Array(16);
-    const wp = b.regexEscapeInto(enc.encode("hello"), plain);
-    if (wp !== 5 || dec.decode(plain.subarray(0, wp)) !== "hello")
-      return false;
-    if (b.regexEscapeInto(enc.encode("a.b"), new Uint8Array(2)) !== 4)
-      return false;
-    if (b.regexEscapeStr("a.c(x)") !== "a\\.c\\(x\\)")
-      return false;
-    if (b.regexEscapeStr("plain text") !== "plain text")
-      return false;
-  }
-  {
-    const out = new Uint8Array(8);
-    const w = b.hexValidateBatchStr(`507f1f77bcf86cd799439011
-zz`, 24, out);
-    if (w !== 2 || out[0] !== 1 || out[1] !== 0)
-      return false;
+    decompressThrew = true;
   }
-  const hmacKey = new Uint8Array(20).fill(11);
-  const hmacData = enc.encode("Hi There");
-  const hmacSig = enc.encode("b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
-  if (b.hmacSha256(hmacKey, hmacData) !== "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7") {
+  if (!decompressThrew) {
     return false;
   }
-  if (!b.hmacSha256Verify(hmacKey, hmacData, hmacSig)) {
-    return false;
+  decompressThrew = false;
+  try {
+    b.brotliDecompress(enc.encode("not-brotli-stream"));
+  } catch {
+    decompressThrew = true;
   }
-  const decoded = b.hexDecode(enc.encode("68656c6c6f"));
-  if (dec.decode(decoded) !== "hello" || dec.decode(b.urlDecode(enc.encode("a%20b%2Fc"))) !== "a b/c") {
+  if (!decompressThrew) {
     return false;
   }
-  if (b.wsAcceptKey("dGhlIHNhbXBsZSBub25jZQ==") !== "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=") {
+  const gzInto = new Uint8Array(64);
+  const gzW = b.gzipCompressInto(SELFTEST_HEX, gzInto);
+  if (gzW === 0 || dec.decode(b.gzipDecompress(gzInto.subarray(0, gzW))) !== "hello") {
     return false;
   }
-  if (b.etag(SELFTEST_HEX).length !== 10 || b.etag(SELFTEST_HEX, true).length !== 12) {
+  const brInto = new Uint8Array(64);
+  const brW = b.brotliCompressInto(SELFTEST_HEX, brInto);
+  if (brW === 0 || dec.decode(b.brotliDecompress(brInto.subarray(0, brW))) !== "hello") {
     return false;
   }
-  if (b.base64Encode(SELFTEST_HEX) !== "aGVsbG8=") {
+  const gzDst = new Uint8Array(16);
+  const gzDW = b.gzipDecompressInto(gzInto.subarray(0, gzW), gzDst);
+  if (gzDW === 0 || dec.decode(gzDst.subarray(0, gzDW)) !== "hello") {
     return false;
   }
-  if (dec.decode(b.base64Decode(enc.encode("aGVsbG8="))) !== "hello") {
-    return false;
-  }
-  const secret = enc.encode("s3cr3t-secret");
-  const signed = b.signCookie(SELFTEST_HEX, secret);
-  const verified = b.verifyCookie(enc.encode(signed), secret);
-  if (verified === null || verified !== "hello") {
-    return false;
-  }
-  if (b.verifyCookie(enc.encode("tampered.0000"), secret) !== null) {
-    return false;
-  }
-  const csrfTokenStr = b.csrfToken(secret);
-  if (csrfTokenStr.length !== 129 || !b.csrfVerify(enc.encode(csrfTokenStr), secret)) {
-    return false;
-  }
-  const pw = enc.encode("correct horse battery staple");
-  const salt = enc.encode("salty-salt-16b");
-  const phc = b.passwordHash(pw, salt, 8, 1, 1, 16);
-  if (phc.length === 0 || !b.passwordVerify(pw, enc.encode(phc))) {
-    return false;
-  }
-  const bcryptPhc = b.passwordHashBcrypt(pw, 4);
-  if (bcryptPhc.length === 0 || !b.passwordVerifyBcrypt(pw, bcryptPhc)) {
-    return false;
-  }
-  const dk = b.pbkdf2Sha256(enc.encode("password"), enc.encode("salt"), 1, 32);
-  if (b.hexEncode(dk) !== "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b") {
-    return false;
-  }
-  const aeadKey = new Uint8Array(32).fill(66);
-  const nonce = new Uint8Array(12).fill(7);
-  const ct = b.aeadEncrypt(aeadKey, nonce, SELFTEST_HEX, 0);
-  const pt = b.aeadDecrypt(aeadKey, nonce, ct, 0);
-  if (pt === null || dec.decode(pt) !== "hello") {
-    return false;
-  }
-  const rtOut = new Uint8Array(32);
-  const rtW = b.randomTokenInto(16, rtOut);
-  if (rtW !== 32 || !/^[0-9a-f]{32}$/.test(dec.decode(rtOut))) {
-    return false;
-  }
-  try {
-    b.randomTokenInto(16, new Uint8Array(8));
-    return false;
-  } catch {}
-  const waOut = new Uint8Array(28);
-  const waW = b.wsAcceptKeyInto(enc.encode("dGhlIHNhbXBsZSBub25jZQ=="), waOut);
-  const waExpected = b.wsAcceptKey("dGhlIHNhbXBsZSBub25jZQ==");
-  if (waW !== 28 || dec.decode(waOut) !== waExpected) {
-    return false;
-  }
-  const etagData = enc.encode("hello");
-  const etagOut = new Uint8Array(16);
-  const etagW = b.etagInto(etagData, etagOut);
-  if (etagW !== 10 || dec.decode(etagOut.subarray(0, etagW)) !== b.etag(etagData)) {
-    return false;
-  }
-  const csrfOut = new Uint8Array(129);
-  const csrfW = b.csrfTokenInto(enc.encode("csrf-secret"), csrfOut);
-  if (csrfW !== 129 || csrfOut[64] !== 46) {
-    return false;
-  }
-  const ckVal = enc.encode("session-value");
-  const ckSec = enc.encode("s3cr3t-secret");
-  const ckOut = new Uint8Array(256);
-  const ckW = b.signCookieInto(ckVal, ckSec, ckOut);
-  if (ckW !== ckVal.length + 65) {
-    return false;
-  }
-  const ckVerifyOut = new Uint8Array(256);
-  const ckV = b.verifyCookieInto(ckOut.subarray(0, ckW), ckSec, ckVerifyOut);
-  if (ckV !== ckVal.length || dec.decode(ckVerifyOut.subarray(0, ckV)) !== "session-value") {
-    return false;
-  }
-  if (b.urlEncode(enc.encode("a b/c")) !== "a%20b%2Fc") {
-    return false;
-  }
-  const hdInto = new Uint8Array(8);
-  if (b.hexDecodeInto(enc.encode("68656c6c6f"), hdInto) !== 5 || dec.decode(hdInto.subarray(0, 5)) !== "hello") {
-    return false;
-  }
-  const udInto = new Uint8Array(16);
-  if (b.urlDecodeInto(enc.encode("a%20b%2Fc"), udInto) !== 5 || dec.decode(udInto.subarray(0, 5)) !== "a b/c") {
-    return false;
-  }
-  const b64Into = new Uint8Array(16);
-  if (b.base64EncodeInto(SELFTEST_HEX, b64Into) !== 8 || dec.decode(b64Into.subarray(0, 8)) !== "aGVsbG8=") {
-    return false;
-  }
-  const bdInto = new Uint8Array(8);
-  if (b.base64DecodeInto(enc.encode("aGVsbG8="), bdInto) !== 5 || dec.decode(bdInto.subarray(0, 5)) !== "hello") {
-    return false;
-  }
-  if (!/^[0-9a-f]{32}$/.test(b.randomToken(16))) {
-    return false;
-  }
-  const hmacInto = new Uint8Array(64);
-  if (b.hmacSha256Into(hmacKey, hmacData, hmacInto) !== 64 || dec.decode(hmacInto) !== "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7") {
-    return false;
-  }
-  const ctInto = new Uint8Array(64);
-  const ctW = b.aeadEncryptInto(aeadKey, nonce, SELFTEST_HEX, ctInto, 0);
-  if (ctW === 0 || b.aeadDecrypt(aeadKey, nonce, ctInto.subarray(0, ctW), 0) === null) {
-    return false;
-  }
-  return true;
-}
-var init_codecs = __esm(() => {
-  init_codec2();
-  init_constants();
-  init_util();
-});
-
-// src/native/ffi/build/compress.ts
-function buildCompress(sym, ctx) {
-  const { lenOrView, scratchFor } = ctx;
-  const gzipCompress = sym.castrum_gzip_compress;
-  const gzipDecompress = sym.castrum_gzip_decompress;
-  const brotliCompress = sym.castrum_brotli_compress;
-  const brotliDecompress = sym.castrum_brotli_decompress;
-  const gzipIsize = sym.castrum_gzip_isize;
-  const jsonPatch = sym.castrum_json_patch;
-  return {
-    jsonPatch(doc, patch) {
-      let out = scratchFor(Math.min(Math.max(doc.length, patch.length) + 16, 64 * 1024));
-      let w = Number(jsonPatch(doc, lenOrView(doc), patch, lenOrView(patch), out, lenOrView(out)));
-      if (w > out.length && w <= MAX_JSON_PATCH_OUTPUT) {
-        out = new Uint8Array(w);
-        w = Number(jsonPatch(doc, lenOrView(doc), patch, lenOrView(patch), out, lenOrView(out)));
-      }
-      if (w === 0 || w > out.length) {
-        throw new Error("json patch: output buffer too small or patch inapplicable");
-      }
-      return decodeUtf8(out.subarray(0, w));
-    },
-    gzipCompress(data, level = 6) {
-      return growExact((out) => Number(gzipCompress(data, lenOrView(data), Math.min(level, 9), out, lenOrView(out))), Math.min(data.length + COMPRESS_HEADROOM, COMPRESS_INITIAL_CAP), Math.max(data.length * 2 + COMPRESS_HEADROOM, COMPRESS_MAX_CAP), "gzip compress: output buffer too small");
-    },
-    gzipCompressInto(data, output, level = 6) {
-      const w = Number(gzipCompress(data, lenOrView(data), Math.min(level, 9), output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("gzip compress: invalid input");
-      }
-      if (w > output.length) {
-        throw new Error("gzip compress: output buffer too small");
-      }
-      return w;
-    },
-    gzipDecompress(data, maxDecompressed) {
-      const max = maxDecompressed ?? MAX_DECOMPRESSED;
-      const isize = Number(gzipIsize(data, lenOrView(data)));
-      const initial = isize !== 0 ? Math.min(isize, max) : Math.min(data.length * DECOMPRESS_GUESS_MULTIPLIER_GZIP, DECOMPRESS_FALLBACK_CAP);
-      return growExact((out) => Number(gzipDecompress(data, lenOrView(data), max, out, lenOrView(out))), initial, max, "gzip decompress: invalid stream or exceeded max decompressed size");
-    },
-    gzipDecompressInto(data, output, maxDecompressed) {
-      const max = maxDecompressed ?? MAX_DECOMPRESSED;
-      const w = Number(gzipDecompress(data, lenOrView(data), max, output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("gzip decompress: invalid stream or exceeded max decompressed size");
-      }
-      if (w > output.length) {
-        throw new Error("gzip decompress: output buffer too small");
-      }
-      return w;
-    },
-    gzipIsize(data) {
-      return Number(gzipIsize(data, lenOrView(data)));
-    },
-    brotliCompress(data, quality = 5) {
-      return growExact((out) => Number(brotliCompress(data, lenOrView(data), Math.min(quality, 11), out, lenOrView(out))), Math.min(data.length + COMPRESS_HEADROOM, COMPRESS_INITIAL_CAP), Math.max(data.length * 2 + COMPRESS_HEADROOM, COMPRESS_MAX_CAP), "brotli compress: output buffer too small");
-    },
-    brotliCompressInto(data, output, quality = 5) {
-      const w = Number(brotliCompress(data, lenOrView(data), Math.min(quality, 11), output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("brotli compress: invalid input");
-      }
-      if (w > output.length) {
-        throw new Error("brotli compress: output buffer too small");
-      }
-      return w;
-    },
-    brotliDecompress(data, maxDecompressed) {
-      const max = maxDecompressed ?? MAX_DECOMPRESSED;
-      return growExact((out) => Number(brotliDecompress(data, lenOrView(data), max, out, lenOrView(out))), Math.min(Math.max(data.length * DECOMPRESS_GUESS_MULTIPLIER_BROTLI, DECOMPRESS_MIN_INITIAL), DECOMPRESS_FALLBACK_CAP), max, "brotli decompress: invalid stream or exceeded max decompressed size");
-    },
-    brotliDecompressInto(data, output, maxDecompressed) {
-      const max = maxDecompressed ?? MAX_DECOMPRESSED;
-      const w = Number(brotliDecompress(data, lenOrView(data), max, output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("brotli decompress: invalid stream or exceeded max decompressed size");
-      }
-      if (w > output.length) {
-        throw new Error("brotli decompress: output buffer too small");
-      }
-      return w;
-    }
-  };
-}
-function selfTestCompress(b) {
-  const enc = { encode: encodeUtf8 };
-  const dec = { decode: decodeUtf8 };
-  const patched = b.jsonPatch(enc.encode(`{"a":"b"}`), enc.encode(`[{"op":"add","path":"/c","value":"d"}]`));
-  if (!patched.includes(`"c":"d"`)) {
-    return false;
-  }
-  const gz = b.gzipCompress(SELFTEST_HEX);
-  if (dec.decode(b.gzipDecompress(gz)) !== "hello") {
-    return false;
-  }
-  const br = b.brotliCompress(SELFTEST_HEX);
-  if (dec.decode(b.brotliDecompress(br)) !== "hello") {
-    return false;
-  }
-  let decompressThrew = false;
-  try {
-    b.gzipDecompress(enc.encode("not-a-gzip-stream"));
-  } catch {
-    decompressThrew = true;
-  }
-  if (!decompressThrew) {
-    return false;
-  }
-  decompressThrew = false;
-  try {
-    b.brotliDecompress(enc.encode("not-brotli-stream"));
-  } catch {
-    decompressThrew = true;
-  }
-  if (!decompressThrew) {
-    return false;
-  }
-  const gzInto = new Uint8Array(64);
-  const gzW = b.gzipCompressInto(SELFTEST_HEX, gzInto);
-  if (gzW === 0 || dec.decode(b.gzipDecompress(gzInto.subarray(0, gzW))) !== "hello") {
-    return false;
-  }
-  const brInto = new Uint8Array(64);
-  const brW = b.brotliCompressInto(SELFTEST_HEX, brInto);
-  if (brW === 0 || dec.decode(b.brotliDecompress(brInto.subarray(0, brW))) !== "hello") {
-    return false;
-  }
-  const gzDst = new Uint8Array(16);
-  const gzDW = b.gzipDecompressInto(gzInto.subarray(0, gzW), gzDst);
-  if (gzDW === 0 || dec.decode(gzDst.subarray(0, gzDW)) !== "hello") {
-    return false;
-  }
-  const brDst = new Uint8Array(16);
-  const brDW = b.brotliDecompressInto(brInto.subarray(0, brW), brDst);
-  if (brDW === 0 || dec.decode(brDst.subarray(0, brDW)) !== "hello") {
+  const brDst = new Uint8Array(16);
+  const brDW = b.brotliDecompressInto(brInto.subarray(0, brW), brDst);
+  if (brDW === 0 || dec.decode(brDst.subarray(0, brDW)) !== "hello") {
     return false;
   }
   return true;
@@ -1113,7 +1269,10 @@ function buildInstances(sym, ctx) {
       return acceptNegotiatorNegotiateRaw(inner, header, lenOrView(header));
     },
     acceptNegotiatorNegotiateServer(inner, header) {
-      return acceptNegotiatorNegotiateServerRaw(inner, decodeUtf8(header));
+      const text = decodeUtf8(header);
+      if (hasNul(text))
+        return null;
+      return acceptNegotiatorNegotiateServerRaw(inner, text);
     },
     jwtSignerSign(inner, claimsJson, nowSeconds) {
       return growExact((out) => Number(jwtSignerSignRaw(inner, claimsJson, lenOrView(claimsJson), BigInt(nowSeconds), out, lenOrView(out))), Math.min(claimsJson.length + 128, 64 * 1024), 1024 * 1024, "jwt signer: invalid claims JSON or output buffer too small");
@@ -1160,6 +1319,8 @@ function buildInstances(sym, ctx) {
       return Number(sessionOpenBytesSym(token, lenOrView(token), secret, lenOrView(secret), output, lenOrView(output)));
     },
     rateLimiterCheck(inner, key, nowMs) {
+      if (hasNul(key))
+        return { allowed: false, remaining: 0, resetMs: 0 };
       const out = rateScratch;
       const w = Number(rateLimiterCheckRaw(inner, key, BigInt(Math.trunc(nowMs)), out, lenOrView(out)));
       if (w === 0)
@@ -1252,190 +1413,6 @@ function buildInstances(sym, ctx) {
     }
   };
 }
-function selfTestInstances(b) {
-  const enc = { encode: encodeUtf8 };
-  const dec = { decode: decodeUtf8 };
-  const layoutBuf = new Uint8Array(38 * 4);
-  b.ingressLayout(layoutBuf);
-  const layoutView = new DataView(layoutBuf.buffer, layoutBuf.byteOffset, layoutBuf.byteLength);
-  if (layoutView.getUint32(0, true) !== 0 || layoutView.getUint32(2 * 4, true) !== 2 || layoutView.getUint32(12 * 4, true) !== 48 || layoutView.getUint32(13 * 4, true) !== 1 || layoutView.getUint32(28 * 4, true) !== 32 || layoutView.getUint32(37 * 4, true) !== 8) {
-    return false;
-  }
-  try {
-    b.ingressHandlePacked(0, enc.encode("/"), null, new Uint8Array(64));
-    return false;
-  } catch {}
-  try {
-    b.ingressHandleComponents(0, 0, "/", "", enc.encode("rid"), new Uint8Array(2), null, new Uint8Array(64));
-    return false;
-  } catch {}
-  const routeDesc = new Uint8Array(33);
-  const rd = new DataView(routeDesc.buffer);
-  rd.setUint32(0, 1380930900, true);
-  rd.setUint32(4, 3, true);
-  rd.setUint32(8, 2 * 1024 * 1024, true);
-  rd.setUint32(12, 8192, true);
-  rd.setUint32(16, 8192, true);
-  rd.setUint32(20, 0, true);
-  rd.setUint32(24, 1, true);
-  routeDesc[28] = 0;
-  rd.setUint32(29, 0, true);
-  const routeHandle = b.routeCompile(routeDesc);
-  if (routeHandle === 0) {
-    return false;
-  }
-  const routeFrame = new Uint8Array(15);
-  const rf = new DataView(routeFrame.buffer);
-  rf.setUint32(0, 0, true);
-  rf.setUint32(4, 3, true);
-  routeFrame.set(enc.encode("a=1"), 8);
-  rf.setUint32(11, 0, true);
-  const routeOut = new Uint8Array(64);
-  const routeW = b.routeRun(routeHandle, routeFrame, routeOut);
-  if (routeW <= 8) {
-    return false;
-  }
-  const rv = new DataView(routeOut.buffer);
-  const rFlags = rv.getUint32(0, true);
-  if ((rFlags & 1) === 0 || (rFlags & 4) === 0) {
-    return false;
-  }
-  b.routeDestroy(routeHandle);
-  if (b.conditionalIsNotModified(0, null, null) !== false) {
-    return false;
-  }
-  if (b.mediaTypeMatcherMatches(0, enc.encode("x")) !== false)
-    return false;
-  if (b.acceptNegotiatorNegotiate(0, enc.encode("gzip")) !== null)
-    return false;
-  if (b.acceptNegotiatorNegotiateServer(0, enc.encode("gzip")) !== null)
-    return false;
-  if (b.schemaValidatorValidate(0, enc.encode("{}")) !== false)
-    return false;
-  if (b.jwtSignerVerify(0, enc.encode("a.b.c"), 0) !== null)
-    return false;
-  let phase6Threw = false;
-  try {
-    b.jwtSignerSign(0, enc.encode("{}"), 0);
-  } catch {
-    phase6Threw = true;
-  }
-  if (!phase6Threw)
-    return false;
-  phase6Threw = false;
-  try {
-    b.templateRender(0, enc.encode("{}"));
-  } catch {
-    phase6Threw = true;
-  }
-  if (!phase6Threw)
-    return false;
-  phase6Threw = false;
-  try {
-    b.rateLimiterCheck(0, "k", 0);
-  } catch {
-    phase6Threw = true;
-  }
-  if (!phase6Threw)
-    return false;
-  const jwtClaims = enc.encode('{"sub":"user-1"}');
-  const jwtSecret2 = enc.encode("my-secret");
-  const jwtOut = new Uint8Array(512);
-  const jwtW = b.jwtSignBytesInto(jwtClaims, jwtSecret2, 0, 0, jwtOut);
-  if (jwtW === 0 || dec.decode(jwtOut.subarray(0, jwtW)).split(".").length !== 3) {
-    return false;
-  }
-  const jwtSecret = enc.encode("my-secret");
-  const jwt = b.jwtSignBytes(enc.encode('{"sub":"user-1"}'), jwtSecret, 0, 0);
-  const jwtStr = jwt;
-  const segs = jwtStr.split(".");
-  if (segs.length !== 3 || segs[0] === "" || segs[1] === "" || segs[2] === "") {
-    return false;
-  }
-  const signingInput = enc.encode(`${segs[0]}.${segs[1]}`);
-  const sigHex = b.hmacSha256(jwtSecret, signingInput);
-  const sigBytes = b.base64Decode(enc.encode(segs[2] ?? ""), true, false);
-  if (sigBytes === null || b.hexEncode(sigBytes) !== sigHex) {
-    return false;
-  }
-  const vjwtSecret = enc.encode("verify-secret");
-  const vjwt = b.jwtSignBytes(enc.encode('{"sub":"u-1"}'), vjwtSecret, 0, 0);
-  const vjwtClaims = b.jwtVerify(enc.encode(vjwt), vjwtSecret, 0);
-  if (vjwtClaims === null || !vjwtClaims.includes('"sub":"u-1"')) {
-    return false;
-  }
-  if (b.jwtVerify(enc.encode("tampered.token.value"), vjwtSecret, 0) !== null) {
-    return false;
-  }
-  const edKp = b.ed25519GenerateKeypair();
-  const edMsg = enc.encode("ed25519 bind-time self-test");
-  const edSig = b.ed25519Sign(edMsg, edKp.privateKey);
-  if (edSig.byteLength !== 64 || !b.ed25519Verify(edMsg, edSig, edKp.publicKey)) {
-    return false;
-  }
-  const edTampered = edSig.slice();
-  edTampered[0] = (edTampered[0] ?? 0) ^ 255;
-  if (b.ed25519Verify(edMsg, edTampered, edKp.publicKey)) {
-    return false;
-  }
-  const edToken = b.jwtEdDSASign(enc.encode('{"sub":"ffi-self-test"}'), edKp.privateKey, 0, 0);
-  if (edToken === null || edToken.split(".").length !== 3) {
-    return false;
-  }
-  const edClaims = b.jwtEdDSAVerify(enc.encode(edToken), edKp.publicKey, 0);
-  if (edClaims === null || !edClaims.includes('"sub":"ffi-self-test"')) {
-    return false;
-  }
-  if (b.jwtEdDSAVerify(enc.encode("tampered.token.value"), edKp.publicKey, 0) !== null) {
-    return false;
-  }
-  let urlBuilderThrew = false;
-  try {
-    b.urlBuilderResolve(0, enc.encode("g"));
-  } catch {
-    urlBuilderThrew = true;
-  }
-  if (!urlBuilderThrew) {
-    return false;
-  }
-  if (b.queryValidate(0, "route=/a") !== false)
-    return false;
-  if (b.cookieValidate(0, "route=/a") !== false)
-    return false;
-  {
-    const tok = b.sessionSeal("sess-9", '{"n":1}', 1234567, "sekrit");
-    if (tok === null || !tok.includes(".") || !tok.startsWith('{"id":"sess-9"'))
-      return false;
-    const out = new Uint8Array(256);
-    const w = b.sessionOpen(tok, "sekrit", out);
-    if (w <= 13 || out[0] !== 1)
-      return false;
-    if (b.sessionOpen(tok, "wrong", out) !== 0)
-      return false;
-    const enc = new TextEncoder;
-    const tokB = b.sessionSealBytes(enc.encode("sess-9"), enc.encode('{"n":1}'), 1234567, enc.encode("sekrit"));
-    if (tokB === null || tokB !== tok)
-      return false;
-    const outB = new Uint8Array(256);
-    const wB = b.sessionOpenBytes(enc.encode(tokB), enc.encode("sekrit"), outB);
-    if (wB !== w || outB[0] !== 1)
-      return false;
-    if (b.sessionOpenBytes(enc.encode(tokB), enc.encode("wrong"), outB) !== 0)
-      return false;
-    if (b.sessionOpenBytes(enc.encode(tokB), enc.encode("sekrit"), outB.subarray(0, 4)) !== wB)
-      return false;
-  }
-  let rlKeyThrew = false;
-  try {
-    b.rateLimiterCheckKey(0, 12345, 0);
-  } catch {
-    rlKeyThrew = true;
-  }
-  if (!rlKeyThrew) {
-    return false;
-  }
-  return true;
-}
 var init_instances = __esm(() => {
   init_codec2();
   init_constants();
@@ -1623,15 +1600,702 @@ function selfTestMetrics(b) {
   } catch (err) {
     console.error("METRICS SELFTEST THROW:", err);
     return false;
-  } finally {
-    b.metricsDestroy(handle);
+  } finally {
+    b.metricsDestroy(handle);
+  }
+}
+var METRICS_DECLARE_ERR = 4294967295, EMPTY;
+var init_metrics = __esm(() => {
+  init_codec2();
+  init_util();
+  EMPTY = new Uint8Array(0);
+});
+
+// src/native/ffi/build/parse.ts
+function sseMemoEncode(slot, s) {
+  if (s === slot.str)
+    return slot.bytes;
+  const bytes = encodeUtf8(s);
+  slot.str = s;
+  slot.bytes = bytes;
+  return bytes;
+}
+function buildParse(sym, ctx) {
+  const { lenOrView, scratchFor, dateScratch, dateScratchView } = ctx;
+  const httpParsePacked = sym.castrum_http_parse_request_packed;
+  const queryParsePacked = sym.castrum_query_parse_packed;
+  const cookieParsePacked = sym.castrum_cookie_parse_packed;
+  const httpDateIntoRaw = sym.castrum_http_date_into;
+  const sseEncodeIntoRaw = sym.castrum_sse_encode_into;
+  const jsonParsePackedSym = sym.castrum_json_parse_packed;
+  const wsFrameDecodePacked = sym.castrum_ws_frame_decode_packed;
+  const multipartParsePacked = sym.castrum_multipart_parse_packed;
+  const formParsePacked = sym.castrum_form_parse_packed;
+  const wsFrameEncode = sym.castrum_ws_frame_encode;
+  const parseMediaTypeSym = sym.castrum_parse_media_type;
+  const parseHttpDateSym = sym.castrum_parse_http_date;
+  const parseAcceptEncodingSym = sym.castrum_parse_accept_encoding;
+  const urlEncodeQuerySym = sym.castrum_url_encode_query;
+  const urlResolveSym = sym.castrum_url_resolve;
+  const mimeFromExtensionSym = sym.castrum_mime_from_extension;
+  return {
+    httpParseRequestPackedInto(input, output) {
+      const w = Number(httpParsePacked(input, lenOrView(input), output, lenOrView(output)));
+      if (w === 0 && input.length !== 0) {
+        throw new Error("http parse: output buffer too small or malformed request");
+      }
+      return w;
+    },
+    queryParsePackedInto(input, output) {
+      const w = Number(queryParsePacked(input, lenOrView(input), output, lenOrView(output)));
+      if (w === 0 || w > output.length) {
+        throw new Error("query parse: output buffer too small");
+      }
+      return w;
+    },
+    cookieParsePackedInto(input, output) {
+      const w = Number(cookieParsePacked(input, lenOrView(input), output, lenOrView(output)));
+      if (w === 0 || w > output.length) {
+        throw new Error("cookie parse: output buffer too small");
+      }
+      return w;
+    },
+    wsFrameEncode(opcode, payload, mask, fin) {
+      const out = allocOut(payload.length + 14);
+      const w = Number(wsFrameEncode(opcode, payload, lenOrView(payload), flag(mask), flag(fin), out, lenOrView(out)));
+      if (w === 0) {
+        throw new Error("ws frame encode: output buffer too small");
+      }
+      return out.subarray(0, w);
+    },
+    wsFrameEncodeInto(opcode, payload, mask, fin, output) {
+      const need = payload.length + 14;
+      if (output.length < need) {
+        throw new Error("ws frame encode: output buffer too small");
+      }
+      const w = Number(wsFrameEncode(opcode, payload, lenOrView(payload), flag(mask), flag(fin), output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("ws frame encode: output buffer too small");
+      }
+      return w;
+    },
+    wsFrameDecodePacked(data) {
+      const out = new Uint8Array(data.length + 6);
+      const w = Number(wsFrameDecodePacked(data, lenOrView(data), out, lenOrView(out)));
+      return w === 0 ? null : out.subarray(0, w);
+    },
+    wsFrameDecodePackedInto(data, output) {
+      const w = Number(wsFrameDecodePacked(data, lenOrView(data), output, lenOrView(output)));
+      return w === 0 ? null : w;
+    },
+    multipartParsePacked(body, boundary) {
+      return growExact((out) => Number(multipartParsePacked(body, lenOrView(body), boundary, lenOrView(boundary), out, lenOrView(out))), Math.min(body.length + boundary.length + 64, 64 * 1024), 128 * 1024 * 1024, "multipart parse: output buffer too small");
+    },
+    multipartParsePackedInto(body, boundary, output) {
+      const w = Number(multipartParsePacked(body, lenOrView(body), boundary, lenOrView(boundary), output, lenOrView(output)));
+      if (w === 0 || w > output.length) {
+        throw new Error("multipart parse: output buffer too small or malformed body");
+      }
+      return w;
+    },
+    formParsePackedInto(input, output) {
+      const w = Number(formParsePacked(input, lenOrView(input), output, lenOrView(output)));
+      if (w === 0 || w > output.length) {
+        throw new Error("form parse: output buffer too small");
+      }
+      return w;
+    },
+    jsonParsePacked(input) {
+      return growExact((out) => Number(jsonParsePackedSym(input, lenOrView(input), out, lenOrView(out))), Math.min(input.length + (input.length >> 1), 16 * 1024 * 1024), Math.max(1024 * 1024, input.length * 16), "json parse packed: invalid JSON or output buffer too small");
+    },
+    parseMediaType(input) {
+      let out = scratchFor(input.length * 2 + 128);
+      let w = Number(parseMediaTypeSym(input, lenOrView(input), out, lenOrView(out)));
+      if (w > out.length) {
+        out = new Uint8Array(w);
+        w = Number(parseMediaTypeSym(input, lenOrView(input), out, lenOrView(out)));
+      }
+      if (w === 0 || w > out.length) {
+        throw new Error("media type parse: invalid media type or output buffer too small");
+      }
+      return out.subarray(0, w);
+    },
+    parseHttpDate(input) {
+      const out = dateScratch;
+      const w = Number(parseHttpDateSym(input, lenOrView(input), out, lenOrView(out)));
+      if (w === 0) {
+        throw new Error("http date parse: output buffer too small");
+      }
+      if (out[0] === 0)
+        return null;
+      return dateScratchView.getBigInt64(1, true);
+    },
+    parseAcceptEncoding(input) {
+      let out = scratchFor(input.length * 2 + 128);
+      let w = Number(parseAcceptEncodingSym(input, lenOrView(input), out, lenOrView(out)));
+      if (w > out.length) {
+        out = new Uint8Array(w);
+        w = Number(parseAcceptEncodingSym(input, lenOrView(input), out, lenOrView(out)));
+      }
+      if (w === 0 || w > out.length) {
+        throw new Error("accept encoding parse: output buffer too small");
+      }
+      return out.subarray(0, w);
+    },
+    urlEncodeQuery(input) {
+      return urlEncodeQuerySym(input, lenOrView(input));
+    },
+    urlResolve(base, reference) {
+      return urlResolveSym(base, lenOrView(base), reference, lenOrView(reference));
+    },
+    mimeFromExtension(ext) {
+      return mimeFromExtensionSym(ext);
+    },
+    httpDateInto(secs, output) {
+      const w = Number(httpDateIntoRaw(secs, output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("http date: output buffer too small or year out of range");
+      }
+      return w;
+    },
+    httpDate(secs) {
+      const out = scratchFor(32);
+      const w = Number(httpDateIntoRaw(secs ?? 0, out, lenOrView(out)));
+      if (w !== 0)
+        return decodeUtf8(out.subarray(0, w));
+      return new Date((secs ?? 0) * 1000).toUTCString();
+    },
+    sseEncodeEvent(event, data, id, retry) {
+      const ev = event === null ? EMPTY_VIEW : sseMemoEncode(sseMemoEvent, event);
+      const idv = id === null ? EMPTY_VIEW : sseMemoEncode(sseMemoId, id);
+      const flags = (event === null ? 0 : 1) | (id === null ? 0 : 2) | (retry === null ? 0 : 4);
+      return growExact((out) => Number(sseEncodeIntoRaw(ev, lenOrView(ev), data, lenOrView(data), idv, lenOrView(idv), flags, retry ?? 0, out, lenOrView(out))), data.length + 64, 1 << 20, "sse encode: output buffer too small");
+    },
+    sseEncodeEventInto(event, data, id, retry, output) {
+      const ev = event === null ? EMPTY_VIEW : sseMemoEncode(sseMemoEvent, event);
+      const idv = id === null ? EMPTY_VIEW : sseMemoEncode(sseMemoId, id);
+      const flags = (event === null ? 0 : 1) | (id === null ? 0 : 2) | (retry === null ? 0 : 4);
+      const w = Number(sseEncodeIntoRaw(ev, lenOrView(ev), data, lenOrView(data), idv, lenOrView(idv), flags, retry ?? 0, output, lenOrView(output)));
+      if (w === 0) {
+        throw new Error("sse encode: invalid UTF-8 in event/id");
+      }
+      if (w > output.length) {
+        throw new Error("sse encode: output buffer too small");
+      }
+      return w;
+    }
+  };
+}
+var sseMemoEvent, sseMemoId;
+var init_parse = __esm(() => {
+  init_codec2();
+  init_constants();
+  init_util();
+  sseMemoEvent = { str: null, bytes: EMPTY_VIEW };
+  sseMemoId = { str: null, bytes: EMPTY_VIEW };
+});
+
+// src/native/ffi/build/task.ts
+function buildTask(sym, ctx) {
+  const { lenOrView } = ctx;
+  const init = sym.castrum_task_init;
+  const submit = sym.castrum_task_submit;
+  const submitOut = sym.castrum_task_submit_out;
+  const submitSlice = sym.castrum_task_submit_slice;
+  const drain = sym.castrum_task_drain;
+  const pending = sym.castrum_task_pending;
+  const cancel = sym.castrum_task_cancel;
+  const setDoorbell = sym.castrum_task_set_doorbell;
+  const shutdown = sym.castrum_task_shutdown;
+  const threads = sym.castrum_task_threads;
+  return {
+    taskInit: (n) => Number(init(n)),
+    taskSubmit: (op, args, taskId) => Number(submit(op, args, lenOrView(args), taskId)),
+    taskSubmitOut: (op, args, taskId, output) => Number(submitOut(op, args, lenOrView(args), taskId, output, lenOrView(output))),
+    taskSubmitSlice: (op, hdr, data, taskId) => Number(submitSlice(op, hdr, lenOrView(hdr), data, lenOrView(data), taskId)),
+    taskDrain: (output) => Number(drain(output, lenOrView(output))),
+    taskPending: () => Number(pending()),
+    taskCancel: (taskId) => Number(cancel(taskId)),
+    taskSetDoorbell: (ptr) => Number(setDoorbell(ptr)),
+    taskShutdown: () => Number(shutdown()),
+    taskThreads: () => Number(threads())
+  };
+}
+function selfTestTask(b) {
+  try {
+    if (typeof b.taskPending() !== "number")
+      return false;
+    if (typeof b.taskThreads() !== "number" || b.taskThreads() < 0)
+      return false;
+    if (b.taskSetDoorbell(0) !== 1)
+      return false;
+    if (typeof b.taskDrain(new Uint8Array(4)) !== "number")
+      return false;
+    if (typeof b.taskSubmitOut !== "function")
+      return false;
+    if (typeof b.taskSubmitSlice !== "function")
+      return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/native/ffi/build.ts
+function build(sym, useBufferLength) {
+  const oneArg = (raw, v) => useBufferLength ? raw(v, v) : raw(v, v.length);
+  const lenOrView = (v) => useBufferLength ? v : v.length;
+  let encodeScratch = new Uint8Array(0);
+  const scratchFor = (size) => {
+    if (encodeScratch.byteLength < size)
+      encodeScratch = new Uint8Array(size);
+    return encodeScratch;
+  };
+  const jsonSumOut = new Uint8Array(9);
+  const jsonSumView = new DataView(jsonSumOut.buffer);
+  const dateScratch = new Uint8Array(9);
+  const dateScratchView = new DataView(dateScratch.buffer);
+  const rateScratch = new Uint8Array(13);
+  const rateScratchView = new DataView(rateScratch.buffer);
+  const ctx = {
+    useBufferLength,
+    lenOrView,
+    oneArg,
+    scratchFor,
+    jsonSumOut,
+    jsonSumView,
+    dateScratch,
+    dateScratchView,
+    rateScratch,
+    rateScratchView
+  };
+  return {
+    ...buildCodecs(sym, ctx),
+    ...buildCompress(sym, ctx),
+    ...buildParse(sym, ctx),
+    ...buildInstances(sym, ctx),
+    ...buildMetrics(sym, ctx),
+    ...buildTask(sym, ctx)
+  };
+}
+var init_build = __esm(() => {
+  init_codecs();
+  init_compress();
+  init_instances();
+  init_metrics();
+  init_parse();
+});
+
+// src/native/ffi/build/codecs-selftest.ts
+function selfTestCodecs(b) {
+  const enc = { encode: encodeUtf8 };
+  const dec = { decode: decodeUtf8 };
+  if (b.crc32(enc.encode("123456789")) !== 3421780262)
+    return false;
+  if (b.fnv1a64(enc.encode("foobar")) !== 0x85944171f73967e8n)
+    return false;
+  if (b.xxh3(new Uint8Array(0)) !== 0x2d06800538d394c2n)
+    return false;
+  if (b.jsonValid(SELFTEST_JSON) !== true || b.jsonValid(enc.encode("{not json")) !== false) {
+    return false;
+  }
+  if (!b.utf8Valid(enc.encode("héllo")) || b.utf8Valid(new Uint8Array([255, 254]))) {
+    return false;
+  }
+  const hexOut = new Uint8Array(SELFTEST_HEX.length * 2);
+  if (b.hexEncodeInto(SELFTEST_HEX, hexOut) !== 10 || dec.decode(hexOut) !== "68656c6c6f") {
+    return false;
+  }
+  const urlInput = enc.encode("a b/c");
+  const urlOut = new Uint8Array(9);
+  if (b.urlEncodeInto(urlInput, urlOut) !== 9 || dec.decode(urlOut) !== "a%20b%2Fc") {
+    return false;
+  }
+  if (!b.validateEmail("a@b.com") || !b.validateUuid("550e8400-e29b-41d4-a716-446655440000") || !b.validateIpv4("192.168.0.1") || !b.validateIpv6("2001:db8::1") || b.validateEmail("not-an-email") || b.validateUuid("not-a-uuid")) {
+    return false;
+  }
+  if (!b.validateEmailBytes(enc.encode("a@b.com")) || !b.validateUuidBytes(enc.encode("550e8400-e29b-41d4-a716-446655440000")) || !b.validateIpv4Bytes(enc.encode("192.168.0.1")) || !b.validateIpv6Bytes(enc.encode("2001:db8::1")) || b.validateEmailBytes(enc.encode("not-an-email")) || b.validateIpv6Bytes(enc.encode("999"))) {
+    return false;
+  }
+  if (b.jsonSumIds(enc.encode(`[{"id":1},{"id":2}]`)) !== 3n)
+    return false;
+  if (b.jsonSumIds(enc.encode(`[{"id":0},{"id":0}]`)) !== 0n)
+    return false;
+  let sumInvalidThrew = false;
+  try {
+    b.jsonSumIds(enc.encode("nope"));
+  } catch {
+    sumInvalidThrew = true;
+  }
+  if (!sumInvalidThrew)
+    return false;
+  {
+    const ids = enc.encode(`507f1f77bcf86cd799439011
+zz
+507F1F77BCF86CD799439012`);
+    const tiny = new Uint8Array(2);
+    const needed = b.hexValidateBatchInto(ids, 24, tiny);
+    if (needed !== 3)
+      return false;
+    const out = new Uint8Array(needed);
+    if (b.hexValidateBatchInto(ids, 24, out) !== 3)
+      return false;
+    if (out[0] !== 1 || out[1] !== 0 || out[2] !== 1)
+      return false;
+    let widthThrew = false;
+    try {
+      b.hexValidateBatchInto(ids, 0, new Uint8Array(3));
+    } catch {
+      widthThrew = true;
+    }
+    if (!widthThrew)
+      return false;
+  }
+  {
+    const out = new Uint8Array(64);
+    const w = b.regexEscapeInto(enc.encode("a.c(x)"), out);
+    if (w !== 9 || dec.decode(out.subarray(0, w)) !== "a\\.c\\(x\\)")
+      return false;
+    const plain = new Uint8Array(16);
+    const wp = b.regexEscapeInto(enc.encode("hello"), plain);
+    if (wp !== 5 || dec.decode(plain.subarray(0, wp)) !== "hello")
+      return false;
+    if (b.regexEscapeInto(enc.encode("a.b"), new Uint8Array(2)) !== 4)
+      return false;
+    if (b.regexEscapeStr("a.c(x)") !== "a\\.c\\(x\\)")
+      return false;
+    if (b.regexEscapeStr("plain text") !== "plain text")
+      return false;
+  }
+  {
+    const out = new Uint8Array(8);
+    const w = b.hexValidateBatchStr(`507f1f77bcf86cd799439011
+zz`, 24, out);
+    if (w !== 2 || out[0] !== 1 || out[1] !== 0)
+      return false;
+  }
+  const hmacKey = new Uint8Array(20).fill(11);
+  const hmacData = enc.encode("Hi There");
+  const hmacSig = enc.encode("b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
+  if (b.hmacSha256(hmacKey, hmacData) !== "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7") {
+    return false;
+  }
+  if (!b.hmacSha256Verify(hmacKey, hmacData, hmacSig)) {
+    return false;
+  }
+  const decoded = b.hexDecode(enc.encode("68656c6c6f"));
+  if (dec.decode(decoded) !== "hello" || dec.decode(b.urlDecode(enc.encode("a%20b%2Fc"))) !== "a b/c") {
+    return false;
+  }
+  if (b.wsAcceptKey("dGhlIHNhbXBsZSBub25jZQ==") !== "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=") {
+    return false;
+  }
+  if (b.etag(SELFTEST_HEX).length !== 10 || b.etag(SELFTEST_HEX, true).length !== 12) {
+    return false;
+  }
+  if (b.base64Encode(SELFTEST_HEX) !== "aGVsbG8=") {
+    return false;
+  }
+  if (dec.decode(b.base64Decode(enc.encode("aGVsbG8="))) !== "hello") {
+    return false;
+  }
+  const secret = enc.encode("s3cr3t-secret");
+  const signed = b.signCookie(SELFTEST_HEX, secret);
+  const verified = b.verifyCookie(enc.encode(signed), secret);
+  if (verified === null || verified !== "hello") {
+    return false;
+  }
+  if (b.verifyCookie(enc.encode("tampered.0000"), secret) !== null) {
+    return false;
+  }
+  const csrfTokenStr = b.csrfToken(secret);
+  if (csrfTokenStr.length !== 129 || !b.csrfVerify(enc.encode(csrfTokenStr), secret)) {
+    return false;
+  }
+  const pw = enc.encode("correct horse battery staple");
+  const salt = enc.encode("salty-salt-16b");
+  const phc = b.passwordHash(pw, salt, 8, 1, 1, 16);
+  if (phc.length === 0 || !b.passwordVerify(pw, enc.encode(phc))) {
+    return false;
+  }
+  const bcryptPhc = b.passwordHashBcrypt(pw, 4);
+  if (bcryptPhc.length === 0 || !b.passwordVerifyBcrypt(pw, bcryptPhc)) {
+    return false;
+  }
+  const dk = b.pbkdf2Sha256(enc.encode("password"), enc.encode("salt"), 1, 32);
+  if (b.hexEncode(dk) !== "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b") {
+    return false;
+  }
+  const aeadKey = new Uint8Array(32).fill(66);
+  const nonce = new Uint8Array(12).fill(7);
+  const ct = b.aeadEncrypt(aeadKey, nonce, SELFTEST_HEX, 0);
+  const pt = b.aeadDecrypt(aeadKey, nonce, ct, 0);
+  if (pt === null || dec.decode(pt) !== "hello") {
+    return false;
+  }
+  const rtOut = new Uint8Array(32);
+  const rtW = b.randomTokenInto(16, rtOut);
+  if (rtW !== 32 || !/^[0-9a-f]{32}$/.test(dec.decode(rtOut))) {
+    return false;
+  }
+  try {
+    b.randomTokenInto(16, new Uint8Array(8));
+    return false;
+  } catch {}
+  const waOut = new Uint8Array(28);
+  const waW = b.wsAcceptKeyInto(enc.encode("dGhlIHNhbXBsZSBub25jZQ=="), waOut);
+  const waExpected = b.wsAcceptKey("dGhlIHNhbXBsZSBub25jZQ==");
+  if (waW !== 28 || dec.decode(waOut) !== waExpected) {
+    return false;
+  }
+  const etagData = enc.encode("hello");
+  const etagOut = new Uint8Array(16);
+  const etagW = b.etagInto(etagData, etagOut);
+  if (etagW !== 10 || dec.decode(etagOut.subarray(0, etagW)) !== b.etag(etagData)) {
+    return false;
+  }
+  const csrfOut = new Uint8Array(129);
+  const csrfW = b.csrfTokenInto(enc.encode("csrf-secret"), csrfOut);
+  if (csrfW !== 129 || csrfOut[64] !== 46) {
+    return false;
+  }
+  const ckVal = enc.encode("session-value");
+  const ckSec = enc.encode("s3cr3t-secret");
+  const ckOut = new Uint8Array(256);
+  const ckW = b.signCookieInto(ckVal, ckSec, ckOut);
+  if (ckW !== ckVal.length + 65) {
+    return false;
+  }
+  const ckVerifyOut = new Uint8Array(256);
+  const ckV = b.verifyCookieInto(ckOut.subarray(0, ckW), ckSec, ckVerifyOut);
+  if (ckV !== ckVal.length || dec.decode(ckVerifyOut.subarray(0, ckV)) !== "session-value") {
+    return false;
+  }
+  if (b.urlEncode(enc.encode("a b/c")) !== "a%20b%2Fc") {
+    return false;
+  }
+  const hdInto = new Uint8Array(8);
+  if (b.hexDecodeInto(enc.encode("68656c6c6f"), hdInto) !== 5 || dec.decode(hdInto.subarray(0, 5)) !== "hello") {
+    return false;
+  }
+  const udInto = new Uint8Array(16);
+  if (b.urlDecodeInto(enc.encode("a%20b%2Fc"), udInto) !== 5 || dec.decode(udInto.subarray(0, 5)) !== "a b/c") {
+    return false;
+  }
+  const b64Into = new Uint8Array(16);
+  if (b.base64EncodeInto(SELFTEST_HEX, b64Into) !== 8 || dec.decode(b64Into.subarray(0, 8)) !== "aGVsbG8=") {
+    return false;
+  }
+  const bdInto = new Uint8Array(8);
+  if (b.base64DecodeInto(enc.encode("aGVsbG8="), bdInto) !== 5 || dec.decode(bdInto.subarray(0, 5)) !== "hello") {
+    return false;
+  }
+  if (!/^[0-9a-f]{32}$/.test(b.randomToken(16))) {
+    return false;
+  }
+  const hmacInto = new Uint8Array(64);
+  if (b.hmacSha256Into(hmacKey, hmacData, hmacInto) !== 64 || dec.decode(hmacInto) !== "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7") {
+    return false;
+  }
+  const ctInto = new Uint8Array(64);
+  const ctW = b.aeadEncryptInto(aeadKey, nonce, SELFTEST_HEX, ctInto, 0);
+  if (ctW === 0 || b.aeadDecrypt(aeadKey, nonce, ctInto.subarray(0, ctW), 0) === null) {
+    return false;
+  }
+  return true;
+}
+var init_codecs_selftest = __esm(() => {
+  init_codec2();
+  init_constants();
+});
+
+// src/native/ffi/build/instances-selftest.ts
+function selfTestInstances(b) {
+  const enc = { encode: encodeUtf8 };
+  const dec = { decode: decodeUtf8 };
+  const layoutBuf = new Uint8Array(38 * 4);
+  b.ingressLayout(layoutBuf);
+  const layoutView = new DataView(layoutBuf.buffer, layoutBuf.byteOffset, layoutBuf.byteLength);
+  if (layoutView.getUint32(0, true) !== 0 || layoutView.getUint32(2 * 4, true) !== 2 || layoutView.getUint32(12 * 4, true) !== 48 || layoutView.getUint32(13 * 4, true) !== 1 || layoutView.getUint32(28 * 4, true) !== 32 || layoutView.getUint32(37 * 4, true) !== 8) {
+    return false;
+  }
+  try {
+    b.ingressHandlePacked(0, enc.encode("/"), null, new Uint8Array(64));
+    return false;
+  } catch {}
+  try {
+    b.ingressHandleComponents(0, 0, "/", "", enc.encode("rid"), new Uint8Array(2), null, new Uint8Array(64));
+    return false;
+  } catch {}
+  const routeDesc = new Uint8Array(33);
+  const rd = new DataView(routeDesc.buffer);
+  rd.setUint32(0, 1380930900, true);
+  rd.setUint32(4, 3, true);
+  rd.setUint32(8, 2 * 1024 * 1024, true);
+  rd.setUint32(12, 8192, true);
+  rd.setUint32(16, 8192, true);
+  rd.setUint32(20, 0, true);
+  rd.setUint32(24, 1, true);
+  routeDesc[28] = 0;
+  rd.setUint32(29, 0, true);
+  const routeHandle = b.routeCompile(routeDesc);
+  if (routeHandle === 0) {
+    return false;
+  }
+  const routeFrame = new Uint8Array(15);
+  const rf = new DataView(routeFrame.buffer);
+  rf.setUint32(0, 0, true);
+  rf.setUint32(4, 3, true);
+  routeFrame.set(enc.encode("a=1"), 8);
+  rf.setUint32(11, 0, true);
+  const routeOut = new Uint8Array(64);
+  const routeW = b.routeRun(routeHandle, routeFrame, routeOut);
+  if (routeW <= 8) {
+    return false;
+  }
+  const rv = new DataView(routeOut.buffer);
+  const rFlags = rv.getUint32(0, true);
+  if ((rFlags & 1) === 0 || (rFlags & 4) === 0) {
+    return false;
+  }
+  b.routeDestroy(routeHandle);
+  if (b.conditionalIsNotModified(0, null, null) !== false) {
+    return false;
+  }
+  if (b.mediaTypeMatcherMatches(0, enc.encode("x")) !== false)
+    return false;
+  if (b.acceptNegotiatorNegotiate(0, enc.encode("gzip")) !== null)
+    return false;
+  if (b.acceptNegotiatorNegotiateServer(0, enc.encode("gzip")) !== null)
+    return false;
+  if (b.schemaValidatorValidate(0, enc.encode("{}")) !== false)
+    return false;
+  if (b.jwtSignerVerify(0, enc.encode("a.b.c"), 0) !== null)
+    return false;
+  let phase6Threw = false;
+  try {
+    b.jwtSignerSign(0, enc.encode("{}"), 0);
+  } catch {
+    phase6Threw = true;
+  }
+  if (!phase6Threw)
+    return false;
+  phase6Threw = false;
+  try {
+    b.templateRender(0, enc.encode("{}"));
+  } catch {
+    phase6Threw = true;
+  }
+  if (!phase6Threw)
+    return false;
+  phase6Threw = false;
+  try {
+    b.rateLimiterCheck(0, "k", 0);
+  } catch {
+    phase6Threw = true;
+  }
+  if (!phase6Threw)
+    return false;
+  const jwtClaims = enc.encode('{"sub":"user-1"}');
+  const jwtSecret2 = enc.encode("my-secret");
+  const jwtOut = new Uint8Array(512);
+  const jwtW = b.jwtSignBytesInto(jwtClaims, jwtSecret2, 0, 0, jwtOut);
+  if (jwtW === 0 || dec.decode(jwtOut.subarray(0, jwtW)).split(".").length !== 3) {
+    return false;
+  }
+  const jwtSecret = enc.encode("my-secret");
+  const jwt = b.jwtSignBytes(enc.encode('{"sub":"user-1"}'), jwtSecret, 0, 0);
+  const jwtStr = jwt;
+  const segs = jwtStr.split(".");
+  if (segs.length !== 3 || segs[0] === "" || segs[1] === "" || segs[2] === "") {
+    return false;
+  }
+  const signingInput = enc.encode(`${segs[0]}.${segs[1]}`);
+  const sigHex = b.hmacSha256(jwtSecret, signingInput);
+  const sigBytes = b.base64Decode(enc.encode(segs[2] ?? ""), true, false);
+  if (sigBytes === null || b.hexEncode(sigBytes) !== sigHex) {
+    return false;
+  }
+  const vjwtSecret = enc.encode("verify-secret");
+  const vjwt = b.jwtSignBytes(enc.encode('{"sub":"u-1"}'), vjwtSecret, 0, 0);
+  const vjwtClaims = b.jwtVerify(enc.encode(vjwt), vjwtSecret, 0);
+  if (vjwtClaims === null || !vjwtClaims.includes('"sub":"u-1"')) {
+    return false;
+  }
+  if (b.jwtVerify(enc.encode("tampered.token.value"), vjwtSecret, 0) !== null) {
+    return false;
+  }
+  const edKp = b.ed25519GenerateKeypair();
+  const edMsg = enc.encode("ed25519 bind-time self-test");
+  const edSig = b.ed25519Sign(edMsg, edKp.privateKey);
+  if (edSig.byteLength !== 64 || !b.ed25519Verify(edMsg, edSig, edKp.publicKey)) {
+    return false;
+  }
+  const edTampered = edSig.slice();
+  edTampered[0] = (edTampered[0] ?? 0) ^ 255;
+  if (b.ed25519Verify(edMsg, edTampered, edKp.publicKey)) {
+    return false;
+  }
+  const edToken = b.jwtEdDSASign(enc.encode('{"sub":"ffi-self-test"}'), edKp.privateKey, 0, 0);
+  if (edToken === null || edToken.split(".").length !== 3) {
+    return false;
+  }
+  const edClaims = b.jwtEdDSAVerify(enc.encode(edToken), edKp.publicKey, 0);
+  if (edClaims === null || !edClaims.includes('"sub":"ffi-self-test"')) {
+    return false;
+  }
+  if (b.jwtEdDSAVerify(enc.encode("tampered.token.value"), edKp.publicKey, 0) !== null) {
+    return false;
+  }
+  let urlBuilderThrew = false;
+  try {
+    b.urlBuilderResolve(0, enc.encode("g"));
+  } catch {
+    urlBuilderThrew = true;
+  }
+  if (!urlBuilderThrew) {
+    return false;
+  }
+  if (b.queryValidate(0, "route=/a") !== false)
+    return false;
+  if (b.cookieValidate(0, "route=/a") !== false)
+    return false;
+  {
+    const tok = b.sessionSeal("sess-9", '{"n":1}', 1234567, "sekrit");
+    if (tok === null || !tok.includes(".") || !tok.startsWith('{"id":"sess-9"'))
+      return false;
+    const out = new Uint8Array(256);
+    const w = b.sessionOpen(tok, "sekrit", out);
+    if (w <= 13 || out[0] !== 1)
+      return false;
+    if (b.sessionOpen(tok, "wrong", out) !== 0)
+      return false;
+    const enc = new TextEncoder;
+    const tokB = b.sessionSealBytes(enc.encode("sess-9"), enc.encode('{"n":1}'), 1234567, enc.encode("sekrit"));
+    if (tokB === null || tokB !== tok)
+      return false;
+    const outB = new Uint8Array(256);
+    const wB = b.sessionOpenBytes(enc.encode(tokB), enc.encode("sekrit"), outB);
+    if (wB !== w || outB[0] !== 1)
+      return false;
+    if (b.sessionOpenBytes(enc.encode(tokB), enc.encode("wrong"), outB) !== 0)
+      return false;
+    if (b.sessionOpenBytes(enc.encode(tokB), enc.encode("sekrit"), outB.subarray(0, 4)) !== wB)
+      return false;
+  }
+  let rlKeyThrew = false;
+  try {
+    b.rateLimiterCheckKey(0, 12345, 0);
+  } catch {
+    rlKeyThrew = true;
+  }
+  if (!rlKeyThrew) {
+    return false;
   }
+  return true;
 }
-var METRICS_DECLARE_ERR = 4294967295, EMPTY;
-var init_metrics = __esm(() => {
+var init_instances_selftest = __esm(() => {
   init_codec2();
-  init_util();
-  EMPTY = new Uint8Array(0);
 });
 
 // src/rust-ffi/scalar/json-packed.ts
@@ -1743,181 +2407,7 @@ var init_json_packed = __esm(() => {
   init_runtime();
 });
 
-// src/native/ffi/build/parse.ts
-function sseMemoEncode(slot, s) {
-  if (s === slot.str)
-    return slot.bytes;
-  const bytes = encodeUtf8(s);
-  slot.str = s;
-  slot.bytes = bytes;
-  return bytes;
-}
-function buildParse(sym, ctx) {
-  const { lenOrView, scratchFor, dateScratch, dateScratchView } = ctx;
-  const httpParsePacked = sym.castrum_http_parse_request_packed;
-  const queryParsePacked = sym.castrum_query_parse_packed;
-  const cookieParsePacked = sym.castrum_cookie_parse_packed;
-  const httpDateIntoRaw = sym.castrum_http_date_into;
-  const sseEncodeIntoRaw = sym.castrum_sse_encode_into;
-  const jsonParsePackedSym = sym.castrum_json_parse_packed;
-  const wsFrameDecodePacked = sym.castrum_ws_frame_decode_packed;
-  const multipartParsePacked = sym.castrum_multipart_parse_packed;
-  const formParsePacked = sym.castrum_form_parse_packed;
-  const wsFrameEncode = sym.castrum_ws_frame_encode;
-  const parseMediaTypeSym = sym.castrum_parse_media_type;
-  const parseHttpDateSym = sym.castrum_parse_http_date;
-  const parseAcceptEncodingSym = sym.castrum_parse_accept_encoding;
-  const urlEncodeQuerySym = sym.castrum_url_encode_query;
-  const urlResolveSym = sym.castrum_url_resolve;
-  const mimeFromExtensionSym = sym.castrum_mime_from_extension;
-  return {
-    httpParseRequestPackedInto(input, output) {
-      const w = Number(httpParsePacked(input, lenOrView(input), output, lenOrView(output)));
-      if (w === 0 && input.length !== 0) {
-        throw new Error("http parse: output buffer too small or malformed request");
-      }
-      return w;
-    },
-    queryParsePackedInto(input, output) {
-      const w = Number(queryParsePacked(input, lenOrView(input), output, lenOrView(output)));
-      if (w === 0 || w > output.length) {
-        throw new Error("query parse: output buffer too small");
-      }
-      return w;
-    },
-    cookieParsePackedInto(input, output) {
-      const w = Number(cookieParsePacked(input, lenOrView(input), output, lenOrView(output)));
-      if (w === 0 || w > output.length) {
-        throw new Error("cookie parse: output buffer too small");
-      }
-      return w;
-    },
-    wsFrameEncode(opcode, payload, mask, fin) {
-      const out = allocOut(payload.length + 14);
-      const w = Number(wsFrameEncode(opcode, payload, lenOrView(payload), flag(mask), flag(fin), out, lenOrView(out)));
-      if (w === 0) {
-        throw new Error("ws frame encode: output buffer too small");
-      }
-      return out.subarray(0, w);
-    },
-    wsFrameEncodeInto(opcode, payload, mask, fin, output) {
-      const need = payload.length + 14;
-      if (output.length < need) {
-        throw new Error("ws frame encode: output buffer too small");
-      }
-      const w = Number(wsFrameEncode(opcode, payload, lenOrView(payload), flag(mask), flag(fin), output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("ws frame encode: output buffer too small");
-      }
-      return w;
-    },
-    wsFrameDecodePacked(data) {
-      const out = new Uint8Array(data.length + 6);
-      const w = Number(wsFrameDecodePacked(data, lenOrView(data), out, lenOrView(out)));
-      return w === 0 ? null : out.subarray(0, w);
-    },
-    wsFrameDecodePackedInto(data, output) {
-      const w = Number(wsFrameDecodePacked(data, lenOrView(data), output, lenOrView(output)));
-      return w === 0 ? null : w;
-    },
-    multipartParsePacked(body, boundary) {
-      return growExact((out) => Number(multipartParsePacked(body, lenOrView(body), boundary, lenOrView(boundary), out, lenOrView(out))), Math.min(body.length + boundary.length + 64, 64 * 1024), 128 * 1024 * 1024, "multipart parse: output buffer too small");
-    },
-    multipartParsePackedInto(body, boundary, output) {
-      const w = Number(multipartParsePacked(body, lenOrView(body), boundary, lenOrView(boundary), output, lenOrView(output)));
-      if (w === 0 || w > output.length) {
-        throw new Error("multipart parse: output buffer too small or malformed body");
-      }
-      return w;
-    },
-    formParsePackedInto(input, output) {
-      const w = Number(formParsePacked(input, lenOrView(input), output, lenOrView(output)));
-      if (w === 0 || w > output.length) {
-        throw new Error("form parse: output buffer too small");
-      }
-      return w;
-    },
-    jsonParsePacked(input) {
-      return growExact((out) => Number(jsonParsePackedSym(input, lenOrView(input), out, lenOrView(out))), Math.min(input.length + (input.length >> 1), 16 * 1024 * 1024), Math.max(1024 * 1024, input.length * 16), "json parse packed: invalid JSON or output buffer too small");
-    },
-    parseMediaType(input) {
-      let out = scratchFor(input.length * 2 + 128);
-      let w = Number(parseMediaTypeSym(input, lenOrView(input), out, lenOrView(out)));
-      if (w > out.length) {
-        out = new Uint8Array(w);
-        w = Number(parseMediaTypeSym(input, lenOrView(input), out, lenOrView(out)));
-      }
-      if (w === 0 || w > out.length) {
-        throw new Error("media type parse: invalid media type or output buffer too small");
-      }
-      return out.subarray(0, w);
-    },
-    parseHttpDate(input) {
-      const out = dateScratch;
-      const w = Number(parseHttpDateSym(input, lenOrView(input), out, lenOrView(out)));
-      if (w === 0) {
-        throw new Error("http date parse: output buffer too small");
-      }
-      if (out[0] === 0)
-        return null;
-      return dateScratchView.getBigInt64(1, true);
-    },
-    parseAcceptEncoding(input) {
-      let out = scratchFor(input.length * 2 + 128);
-      let w = Number(parseAcceptEncodingSym(input, lenOrView(input), out, lenOrView(out)));
-      if (w > out.length) {
-        out = new Uint8Array(w);
-        w = Number(parseAcceptEncodingSym(input, lenOrView(input), out, lenOrView(out)));
-      }
-      if (w === 0 || w > out.length) {
-        throw new Error("accept encoding parse: output buffer too small");
-      }
-      return out.subarray(0, w);
-    },
-    urlEncodeQuery(input) {
-      return urlEncodeQuerySym(input, lenOrView(input));
-    },
-    urlResolve(base, reference) {
-      return urlResolveSym(base, lenOrView(base), reference, lenOrView(reference));
-    },
-    mimeFromExtension(ext) {
-      return mimeFromExtensionSym(ext);
-    },
-    httpDateInto(secs, output) {
-      const w = Number(httpDateIntoRaw(secs, output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("http date: output buffer too small or year out of range");
-      }
-      return w;
-    },
-    httpDate(secs) {
-      const out = scratchFor(32);
-      const w = Number(httpDateIntoRaw(secs ?? 0, out, lenOrView(out)));
-      if (w !== 0)
-        return decodeUtf8(out.subarray(0, w));
-      return new Date((secs ?? 0) * 1000).toUTCString();
-    },
-    sseEncodeEvent(event, data, id, retry) {
-      const ev = event === null ? EMPTY_VIEW : sseMemoEncode(sseMemoEvent, event);
-      const idv = id === null ? EMPTY_VIEW : sseMemoEncode(sseMemoId, id);
-      const flags = (event === null ? 0 : 1) | (id === null ? 0 : 2) | (retry === null ? 0 : 4);
-      return growExact((out) => Number(sseEncodeIntoRaw(ev, lenOrView(ev), data, lenOrView(data), idv, lenOrView(idv), flags, retry ?? 0, out, lenOrView(out))), data.length + 64, 1 << 20, "sse encode: output buffer too small");
-    },
-    sseEncodeEventInto(event, data, id, retry, output) {
-      const ev = event === null ? EMPTY_VIEW : sseMemoEncode(sseMemoEvent, event);
-      const idv = id === null ? EMPTY_VIEW : sseMemoEncode(sseMemoId, id);
-      const flags = (event === null ? 0 : 1) | (id === null ? 0 : 2) | (retry === null ? 0 : 4);
-      const w = Number(sseEncodeIntoRaw(ev, lenOrView(ev), data, lenOrView(data), idv, lenOrView(idv), flags, retry ?? 0, output, lenOrView(output)));
-      if (w === 0) {
-        throw new Error("sse encode: invalid UTF-8 in event/id");
-      }
-      if (w > output.length) {
-        throw new Error("sse encode: output buffer too small");
-      }
-      return w;
-    }
-  };
-}
+// src/native/ffi/build/parse-selftest.ts
 function selfTestParse(b) {
   const enc = { encode: encodeUtf8 };
   const dec = { decode: decodeUtf8 };
@@ -2087,114 +2577,19 @@ data: hello
   if (b.mimeFromExtension("nope") !== "application/octet-stream") {
     return false;
   }
-  if (b.httpDate(784111777) !== "Sun, 06 Nov 1994 08:49:37 GMT") {
-    return false;
-  }
-  const frameInto = new Uint8Array(64);
-  if (b.wsFrameEncodeInto(1, SELFTEST_HEX, false, true, frameInto) === 0 || frameInto[0] !== 129) {
-    return false;
-  }
-  return true;
-}
-var sseMemoEvent, sseMemoId;
-var init_parse = __esm(() => {
-  init_json_packed();
-  init_codec2();
-  init_constants();
-  init_util();
-  sseMemoEvent = { str: null, bytes: EMPTY_VIEW };
-  sseMemoId = { str: null, bytes: EMPTY_VIEW };
-});
-
-// src/native/ffi/build/task.ts
-function buildTask(sym, ctx) {
-  const { lenOrView } = ctx;
-  const init = sym.castrum_task_init;
-  const submit = sym.castrum_task_submit;
-  const submitOut = sym.castrum_task_submit_out;
-  const submitSlice = sym.castrum_task_submit_slice;
-  const drain = sym.castrum_task_drain;
-  const pending = sym.castrum_task_pending;
-  const cancel = sym.castrum_task_cancel;
-  const setDoorbell = sym.castrum_task_set_doorbell;
-  const shutdown = sym.castrum_task_shutdown;
-  const threads = sym.castrum_task_threads;
-  return {
-    taskInit: (n) => Number(init(n)),
-    taskSubmit: (op, args, taskId) => Number(submit(op, args, lenOrView(args), taskId)),
-    taskSubmitOut: (op, args, taskId, output) => Number(submitOut(op, args, lenOrView(args), taskId, output, lenOrView(output))),
-    taskSubmitSlice: (op, hdr, data, taskId) => Number(submitSlice(op, hdr, lenOrView(hdr), data, lenOrView(data), taskId)),
-    taskDrain: (output) => Number(drain(output, lenOrView(output))),
-    taskPending: () => Number(pending()),
-    taskCancel: (taskId) => Number(cancel(taskId)),
-    taskSetDoorbell: (ptr) => Number(setDoorbell(ptr)),
-    taskShutdown: () => Number(shutdown()),
-    taskThreads: () => Number(threads())
-  };
-}
-function selfTestTask(b) {
-  try {
-    if (typeof b.taskPending() !== "number")
-      return false;
-    if (typeof b.taskThreads() !== "number" || b.taskThreads() < 0)
-      return false;
-    if (b.taskSetDoorbell(0) !== 1)
-      return false;
-    if (typeof b.taskDrain(new Uint8Array(4)) !== "number")
-      return false;
-    if (typeof b.taskSubmitOut !== "function")
-      return false;
-    if (typeof b.taskSubmitSlice !== "function")
-      return false;
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/native/ffi/build.ts
-function build(sym, useBufferLength) {
-  const oneArg = (raw, v) => useBufferLength ? raw(v, v) : raw(v, v.length);
-  const lenOrView = (v) => useBufferLength ? v : v.length;
-  let encodeScratch = new Uint8Array(0);
-  const scratchFor = (size) => {
-    if (encodeScratch.byteLength < size)
-      encodeScratch = new Uint8Array(size);
-    return encodeScratch;
-  };
-  const jsonSumOut = new Uint8Array(9);
-  const jsonSumView = new DataView(jsonSumOut.buffer);
-  const dateScratch = new Uint8Array(9);
-  const dateScratchView = new DataView(dateScratch.buffer);
-  const rateScratch = new Uint8Array(13);
-  const rateScratchView = new DataView(rateScratch.buffer);
-  const ctx = {
-    useBufferLength,
-    lenOrView,
-    oneArg,
-    scratchFor,
-    jsonSumOut,
-    jsonSumView,
-    dateScratch,
-    dateScratchView,
-    rateScratch,
-    rateScratchView
-  };
-  return {
-    ...buildCodecs(sym, ctx),
-    ...buildCompress(sym, ctx),
-    ...buildParse(sym, ctx),
-    ...buildInstances(sym, ctx),
-    ...buildMetrics(sym, ctx),
-    ...buildTask(sym, ctx)
-  };
+  if (b.httpDate(784111777) !== "Sun, 06 Nov 1994 08:49:37 GMT") {
+    return false;
+  }
+  const frameInto = new Uint8Array(64);
+  if (b.wsFrameEncodeInto(1, SELFTEST_HEX, false, true, frameInto) === 0 || frameInto[0] !== 129) {
+    return false;
+  }
+  return true;
 }
-var init_build = __esm(() => {
-  init_codecs();
-  init_compress();
-  init_instances();
-  init_metrics();
-  init_parse();
+var init_parse_selftest = __esm(() => {
+  init_json_packed();
+  init_codec2();
+  init_constants();
 });
 
 // src/native/ffi/selftest.ts
@@ -2202,11 +2597,11 @@ function selfTest(b) {
   return selfTestCodecs(b) && selfTestCompress(b) && selfTestParse(b) && selfTestInstances(b) && selfTestMetrics(b) && selfTestTask(b);
 }
 var init_selftest = __esm(() => {
-  init_codecs();
+  init_codecs_selftest();
   init_compress();
-  init_instances();
+  init_instances_selftest();
   init_metrics();
-  init_parse();
+  init_parse_selftest();
 });
 
 // src/native/loader.ts
@@ -2366,6 +2761,12 @@ function getBunFFI() {
   cached = bind();
   return cached;
 }
+function ffiAddonPath() {
+  if (cached === undefined) {
+    getBunFFI();
+  }
+  return boundAddonPath;
+}
 function probeBufferLength(dlopen, path) {
   try {
     const { symbols, close } = dlopen(path, {
@@ -2399,358 +2800,7 @@ function bind(forcedPath, tried = []) {
     const { dlopen } = __require("bun:ffi");
     const useBufferLength = probeBufferLength(dlopen, path);
     bufferAbiMode = useBufferLength ? "buffer-pair" : "ptr-len";
-    const inputAbi = useBufferLength ? ["buffer", "buffer_length"] : ["ptr", "usize"];
-    const abi = (shape) => {
-      if (!useBufferLength)
-        return shape;
-      const out = [];
-      for (let i = 0;i < shape.length; i++) {
-        const t = shape[i];
-        if (t === "ptr") {
-          out.push("buffer");
-          out.push("buffer_length");
-          i++;
-        } else {
-          out.push(t);
-        }
-      }
-      return out;
-    };
-    const U64_FAST = "u64_fast";
-    const { symbols } = dlopen(path, {
-      castrum_crc32: { args: inputAbi, returns: "u32" },
-      castrum_fnv1a64: { args: inputAbi, returns: "u64" },
-      castrum_xxh3: { args: inputAbi, returns: "u64" },
-      castrum_json_valid: { args: inputAbi, returns: "u8" },
-      castrum_utf8_valid: { args: inputAbi, returns: "u8" },
-      castrum_hex_encode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_hex_decode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_url_encode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_url_decode: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_validate_email: { args: ["cstring"], returns: "u8" },
-      castrum_validate_uuid: { args: ["cstring"], returns: "u8" },
-      castrum_validate_ipv4: { args: ["cstring"], returns: "u8" },
-      castrum_validate_ipv6: { args: ["cstring"], returns: "u8" },
-      castrum_validate_email_bytes: { args: inputAbi, returns: "u8" },
-      castrum_validate_uuid_bytes: { args: inputAbi, returns: "u8" },
-      castrum_validate_ipv4_bytes: { args: inputAbi, returns: "u8" },
-      castrum_validate_ipv6_bytes: { args: inputAbi, returns: "u8" },
-      castrum_json_sum_ids: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_hmac_sha256_verify: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: "u8"
-      },
-      castrum_csrf_verify: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "u8" },
-      castrum_password_verify: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "u8" },
-      castrum_password_verify_bcrypt: {
-        args: abi(["ptr", "usize", "cstring"]),
-        returns: "u8"
-      },
-      castrum_ws_accept_key: { args: ["cstring"], returns: "cstring" },
-      castrum_ws_accept_key_into: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_etag: { args: abi(["ptr", "usize", "u8"]), returns: "cstring" },
-      castrum_etag_into: { args: abi(["ptr", "usize", "u8", "ptr", "usize"]), returns: U64_FAST },
-      castrum_conditional_is_not_modified: {
-        args: abi(["usize", "ptr", "usize", "ptr", "usize", "u8"]),
-        returns: "u8"
-      },
-      castrum_media_type_matcher_matches: {
-        args: abi(["usize", "ptr", "usize"]),
-        returns: "u8"
-      },
-      castrum_accept_negotiator_negotiate: {
-        args: abi(["usize", "ptr", "usize"]),
-        returns: "cstring"
-      },
-      castrum_accept_negotiator_negotiate_server: {
-        args: ["usize", "cstring"],
-        returns: "cstring"
-      },
-      castrum_jwt_signer_sign: {
-        args: abi(["usize", "ptr", "usize", "i64", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_jwt_signer_verify: {
-        args: abi(["usize", "ptr", "usize", "i64", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_template_render: {
-        args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_schema_validator_validate: {
-        args: abi(["usize", "ptr", "usize"]),
-        returns: "u8"
-      },
-      castrum_rate_limiter_check: {
-        args: abi(["usize", "cstring", "i64", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_rate_limiter_check_key: {
-        args: abi(["usize", "i64", "i64", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_random_token: { args: ["u32"], returns: "cstring" },
-      castrum_random_token_into: { args: ["u32", ...abi(["ptr", "usize"])], returns: U64_FAST },
-      castrum_base64_encode: {
-        args: abi(["ptr", "usize", "ptr", "usize", "u8", "u8"]),
-        returns: U64_FAST
-      },
-      castrum_base64_decode: {
-        args: abi(["ptr", "usize", "ptr", "usize", "u8", "u8"]),
-        returns: U64_FAST
-      },
-      castrum_hmac_sha256: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_sign_cookie: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "cstring" },
-      castrum_sign_cookie_into: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_verify_cookie: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: "cstring" },
-      castrum_verify_cookie_into: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_csrf_token: { args: abi(["ptr", "usize"]), returns: "cstring" },
-      castrum_csrf_token_into: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_password_hash: {
-        args: abi(["ptr", "usize", "ptr", "usize", "u32", "u32", "u32", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_password_hash_bcrypt: {
-        args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_pbkdf2_sha256: {
-        args: abi(["ptr", "usize", "ptr", "usize", "u32", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_aead_encrypt: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_aead_decrypt: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_ws_frame_encode: {
-        args: abi(["u8", "ptr", "usize", "u8", "u8", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_json_patch: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_gzip_compress: {
-        args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_gzip_decompress: {
-        args: abi(["ptr", "usize", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_brotli_compress: {
-        args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_brotli_decompress: {
-        args: abi(["ptr", "usize", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_gzip_isize: { args: abi(["ptr", "usize"]), returns: "u32" },
-      castrum_http_parse_request_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_query_parse_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_cookie_parse_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_http_date_into: { args: ["f64", ...abi(["ptr", "usize"])], returns: U64_FAST },
-      castrum_sse_encode_into: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize", "u8", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_jwt_sign_bytes: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64"]),
-        returns: "cstring"
-      },
-      castrum_jwt_sign_bytes_into: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_ed25519_generate_keypair: {
-        args: abi(["ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_ed25519_sign: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_ed25519_verify: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: "u32"
-      },
-      castrum_jwt_eddsa_sign: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64", "i64"]),
-        returns: "cstring"
-      },
-      castrum_jwt_eddsa_verify: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64"]),
-        returns: "cstring"
-      },
-      castrum_ws_frame_decode_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_multipart_parse_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_form_parse_packed: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_json_parse_packed: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_parse_media_type: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_parse_http_date: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_parse_accept_encoding: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_url_encode_query: { args: abi(["ptr", "usize"]), returns: "cstring" },
-      castrum_url_resolve: {
-        args: abi(["ptr", "usize", "ptr", "usize"]),
-        returns: "cstring"
-      },
-      castrum_url_builder_resolve: {
-        args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_mime_from_extension: { args: ["cstring"], returns: "cstring" },
-      castrum_jwt_verify: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64"]),
-        returns: "cstring"
-      },
-      castrum_ingress_handle_packed: {
-        args: abi(["usize", "ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_ingress_handle_components: {
-        args: abi([
-          "usize",
-          "u8",
-          "cstring",
-          "cstring",
-          "ptr",
-          "usize",
-          "ptr",
-          "usize",
-          "ptr",
-          "usize",
-          "ptr",
-          "usize"
-        ]),
-        returns: U64_FAST
-      },
-      castrum_ingress_layout: { args: abi(["ptr", "usize"]), returns: U64_FAST },
-      castrum_route_compile: { args: abi(["ptr", "usize"]), returns: U64_FAST },
-      castrum_route_run: {
-        args: abi(["usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_route_destroy: { args: ["usize"], returns: "void" },
-      castrum_hex_validate_batch: {
-        args: abi(["ptr", "usize", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_regex_escape: { args: abi(["ptr", "usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_metrics_create: { args: [], returns: U64_FAST },
-      castrum_metrics_counter: { args: ["usize", "cstring", "cstring"], returns: "u32" },
-      castrum_metrics_gauge: { args: ["usize", "cstring", "cstring"], returns: "u32" },
-      castrum_metrics_histogram: {
-        args: ["usize", "cstring", "cstring", "cstring"],
-        returns: "u32"
-      },
-      castrum_metrics_record: {
-        args: abi(["usize", "u32", "ptr", "usize", "f64"]),
-        returns: "u8"
-      },
-      castrum_metrics_gauge_set: {
-        args: abi(["usize", "u32", "ptr", "usize", "f64"]),
-        returns: "u8"
-      },
-      castrum_metrics_record_str: {
-        args: ["usize", "u32", "cstring", "f64"],
-        returns: "u8"
-      },
-      castrum_metrics_gauge_set_str: {
-        args: ["usize", "u32", "cstring", "f64"],
-        returns: "u8"
-      },
-      castrum_regex_escape_str: { args: ["cstring"], returns: "cstring" },
-      castrum_hex_validate_batch_str: {
-        args: abi(["cstring", "u32", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_metrics_render: { args: abi(["usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_metrics_snapshot: { args: abi(["usize", "ptr", "usize"]), returns: U64_FAST },
-      castrum_metrics_record_batch: {
-        args: abi(["usize", "ptr", "usize"]),
-        returns: "u8"
-      },
-      castrum_query_validate: { args: ["usize", "cstring"], returns: "u8" },
-      castrum_cookie_validate: { args: ["usize", "cstring"], returns: "u8" },
-      castrum_session_seal: {
-        args: ["cstring", "cstring", "i64", "cstring"],
-        returns: "cstring"
-      },
-      castrum_session_open: {
-        args: abi(["cstring", "cstring", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_session_seal_bytes: {
-        args: abi(["ptr", "usize", "ptr", "usize", "i64", "ptr", "usize"]),
-        returns: "cstring"
-      },
-      castrum_session_open_bytes: {
-        args: abi(["ptr", "usize", "ptr", "usize", "ptr", "usize"]),
-        returns: U64_FAST
-      },
-      castrum_task_init: { args: ["u32"], returns: "u32" },
-      castrum_task_submit: { args: abi(["u32", "ptr", "usize", "usize"]), returns: "u32" },
-      castrum_task_submit_slice: {
-        args: abi(["u32", "ptr", "usize", "ptr", "usize", "usize"]),
-        returns: "u32"
-      },
-      castrum_task_submit_out: {
-        args: abi(["u32", "ptr", "usize", "usize", "ptr", "usize"]),
-        returns: "u32"
-      },
-      castrum_task_drain: { args: abi(["ptr", "usize"]), returns: U64_FAST },
-      castrum_task_pending: { args: [], returns: "u32" },
-      castrum_task_cancel: { args: ["usize"], returns: "u32" },
-      castrum_task_set_doorbell: { args: ["ptr"], returns: "u32" },
-      castrum_task_shutdown: { args: [], returns: "u32" },
-      castrum_task_threads: { args: [], returns: "u32" },
-      castrum_metrics_destroy: { args: ["usize"], returns: "void" }
-    });
+    const { symbols } = dlopen(path, buildFFISymbolMap(useBufferLength));
     const bindings = build(symbols, useBufferLength);
     if (!selfTest(bindings)) {
       throw new Error(`bun:ffi bind-time self-test failed on ${path}`);
@@ -3425,24 +3475,53 @@ var init_wire = __esm(() => {
 });
 
 // src/shared/packed/parsers.ts
-function parseQueryString(query) {
-  const packed = addon2.queryParsePacked(encoder.encode(query));
+function scratchFor(kind, input) {
+  const need = input.length * 9 + 16;
+  let s = ffiCaches[kind];
+  if (s === null || s.length < need) {
+    s = new Uint8Array(need);
+    ffiCaches[kind] = s;
+  }
+  return s;
+}
+function parsePackedInto(kind, input) {
+  const f = getBunFFI();
+  if (!f)
+    return null;
+  const out = scratchFor(kind, input);
+  const w = kind === "query" ? f.queryParsePackedInto(input, out) : kind === "cookie" ? f.cookieParsePackedInto(input, out) : f.formParsePackedInto(input, out);
+  if (w === 0 || w > out.length)
+    return null;
+  return pairsToObject(readPairsPacked(out.subarray(0, w)));
+}
+function parseVia(kind, input) {
+  const fast = parsePackedInto(kind, input);
+  if (fast)
+    return fast;
+  const packed = kind === "query" ? addon2.queryParsePacked(input) : kind === "cookie" ? addon2.cookieParsePacked(input) : addon2.formParsePacked(input);
   return pairsToObject(readPairsPacked(packed));
 }
+function parseQueryString(query) {
+  return parseVia("query", encoder.encode(query));
+}
 function parseCookieHeader(header) {
-  const packed = addon2.cookieParsePacked(encoder.encode(header));
-  return pairsToObject(readPairsPacked(packed));
+  return parseVia("cookie", encoder.encode(header));
 }
 function parseFormBody(body) {
-  const packed = addon2.formParsePacked(body);
-  return pairsToObject(readPairsPacked(packed));
+  return parseVia("form", body);
 }
-var addon2;
+var addon2, ffiCaches;
 var init_parsers = __esm(() => {
+  init_ffi();
   init_native();
   init_bytes();
   init_wire();
   addon2 = lazyAddon(getAddon);
+  ffiCaches = {
+    query: null,
+    cookie: null,
+    form: null
+  };
 });
 
 // src/shared/packed/schema.ts
@@ -3507,6 +3586,11 @@ function asNumber(value) {
   }
   return 0;
 }
+function assertNonEmptySecret(secret, op) {
+  if (secret.byteLength === 0) {
+    throw new Error(`${op}: secret must not be empty`);
+  }
+}
 function normalizeExt(ext) {
   let s;
   try {
@@ -3674,17 +3758,29 @@ function buildBatch(ctx) {
     gzipDecompress: (items, maxDecompressed) => via(ctx, "gzipDecompressBatchPacked", unpackByteResults, [maxDecompressed ?? null])(items),
     brotliCompress: (items, quality) => via(ctx, "brotliCompressBatchPacked", unpackByteResults, [quality ?? null])(items),
     brotliDecompress: (items, maxDecompressed) => via(ctx, "brotliDecompressBatchPacked", unpackByteResults, [maxDecompressed ?? null])(items),
-    jwtVerify: (tokens, secret, nowSeconds) => via(ctx, "jwtVerifyBatchPacked", unpackBitset, [secret, nowSeconds])(tokens),
-    hmacSha256: (items, key) => via(ctx, "hmacSha256BatchPacked", unpackByteResults, [key])(items),
-    hmacSha256Verify: (items, sigs, key) => via2(ctx, "hmacSha256VerifyBatchPacked", unpackBitset, [key])(items, sigs),
+    jwtVerify: (tokens, secret, nowSeconds) => {
+      assertNonEmptySecret(secret, "batch.jwtVerify");
+      return via(ctx, "jwtVerifyBatchPacked", unpackBitset, [secret, nowSeconds])(tokens);
+    },
+    hmacSha256: (items, key) => {
+      assertNonEmptySecret(key, "batch.hmacSha256");
+      return via(ctx, "hmacSha256BatchPacked", unpackByteResults, [key])(items);
+    },
+    hmacSha256Verify: (items, sigs, key) => {
+      assertNonEmptySecret(key, "batch.hmacSha256Verify");
+      return via2(ctx, "hmacSha256VerifyBatchPacked", unpackBitset, [key])(items, sigs);
+    },
     passwordVerify: (items, phcs) => via2(ctx, "passwordVerifyBatchPacked", unpackBitset)(items, phcs),
     urlResolve: (bases, references) => via2(ctx, "urlResolveBatchPacked", unpackByteResults)(bases, references),
     templateRender: (source, contexts) => via(ctx, "templateRenderBatchPacked", unpackByteResults, [source])(contexts),
-    jwtSign: (items, secret, ttlSeconds, nowSeconds) => via(ctx, "jwtSignBatchPacked", unpackByteResults, [
-      secret,
-      ttlSeconds ?? null,
-      nowSeconds ?? Math.floor(Date.now() / 1000)
-    ])(items),
+    jwtSign: (items, secret, ttlSeconds, nowSeconds) => {
+      assertNonEmptySecret(secret, "batch.jwtSign");
+      return via(ctx, "jwtSignBatchPacked", unpackByteResults, [
+        secret,
+        ttlSeconds ?? null,
+        nowSeconds ?? Math.floor(Date.now() / 1000)
+      ])(items);
+    },
     sseEncode: (items, event, id, retry) => via(ctx, "sseEncodeBatchPacked", unpackByteResults, [
       event ?? null,
       id ?? null,
@@ -3698,6 +3794,7 @@ function buildBatch(ctx) {
 var init_build2 = __esm(() => {
   init_packed();
   init_context();
+  init_options();
 });
 
 // src/rust-ffi/batch/index.ts
@@ -3959,18 +4056,22 @@ function buildCrypto(ctx) {
       return writeInto("verify cookie", output, value);
     },
     csrfToken(secret) {
+      assertNonEmptySecret(secret, "csrfToken");
       return resolveNative(ctx, "csrfToken")(secret);
     },
     csrfTokenInto(secret, output) {
+      assertNonEmptySecret(secret, "csrfTokenInto");
       const f = ffi();
       if (f)
         return f.csrfTokenInto(secret, output);
       return writeInto("csrf token", output, addon.csrfToken(secret));
     },
     csrfVerify(token, secret) {
+      assertNonEmptySecret(secret, "csrfVerify");
       return resolveNative(ctx, "csrfVerify")(token, secret);
     },
     jwtSign(claims, secret, ttlSeconds, nowSeconds) {
+      assertNonEmptySecret(secret, "jwtSign");
       const f = ffi();
       if (f) {
         const token = f.jwtSignBytes(encoder.encode(JSON.stringify(claims)), secret, ttlSeconds ?? 0, nowSeconds ?? Math.floor(Date.now() / 1000));
@@ -3979,6 +4080,7 @@ function buildCrypto(ctx) {
       return addon.jwtSign(claims, secret, ttlSeconds ?? null, nowSeconds ?? Math.floor(Date.now() / 1000));
     },
     jwtSignBytes(claimsJson, secret, ttlSeconds, nowSeconds) {
+      assertNonEmptySecret(secret, "jwtSignBytes");
       const f = ffi();
       if (f) {
         return f.jwtSignBytes(claimsJson, secret, ttlSeconds ?? 0, nowSeconds ?? Math.floor(Date.now() / 1000));
@@ -3986,6 +4088,7 @@ function buildCrypto(ctx) {
       return addon.jwtSignBytes(claimsJson, secret, ttlSeconds ?? null, nowSeconds ?? Math.floor(Date.now() / 1000));
     },
     jwtSignBytesInto(claimsJson, secret, output, ttlSeconds, nowSeconds) {
+      assertNonEmptySecret(secret, "jwtSignBytesInto");
       const f = ffi();
       if (f) {
         return f.jwtSignBytesInto(claimsJson, secret, ttlSeconds ?? 0, nowSeconds ?? Math.floor(Date.now() / 1000), output);
@@ -3993,6 +4096,7 @@ function buildCrypto(ctx) {
       return writeInto("jwt sign", output, addon.jwtSignBytes(claimsJson, secret, ttlSeconds ?? null, nowSeconds ?? Math.floor(Date.now() / 1000)));
     },
     jwtVerify(token, secret, nowSeconds) {
+      assertNonEmptySecret(secret, "jwtVerify");
       const f = ffi();
       if (f) {
         const claims = f.jwtVerify(token, secret, nowSeconds ?? Math.floor(Date.now() / 1000));
@@ -4053,9 +4157,17 @@ function buildCrypto(ctx) {
 var init_crypto = __esm(() => {
   init_bytes();
   init_context();
+  init_options();
 });
 
 // src/rust-ffi/scalar/factories.ts
+function handlePtr(inner) {
+  const v = inner ?? 0n;
+  if (v < 0n || v > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("castrum: native handle exceeds Number.MAX_SAFE_INTEGER");
+  }
+  return Number(v);
+}
 function ffiHmacSigner(key, ffi) {
   return {
     sign(data) {
@@ -4236,47 +4348,55 @@ function ffiFormParser(ffi) {
   };
 }
 function ffiMetricsRegistry(ffi) {
-  const handle = ffi.metricsCreate();
+  let handle = ffi.metricsCreate();
+  const live = () => {
+    if (handle === 0)
+      throw new Error("metrics registry: already destroyed");
+    return handle;
+  };
   return {
     counter(name, labelKeys) {
-      return ffi.metricsCounter(handle, name, (labelKeys ?? []).join("\x1F"));
+      return ffi.metricsCounter(live(), name, (labelKeys ?? []).join("\x1F"));
     },
     gauge(name, labelKeys) {
-      return ffi.metricsGauge(handle, name, (labelKeys ?? []).join("\x1F"));
+      return ffi.metricsGauge(live(), name, (labelKeys ?? []).join("\x1F"));
     },
     histogram(name, labelKeys, buckets) {
-      return ffi.metricsHistogram(handle, name, (labelKeys ?? []).join("\x1F"), (buckets ?? []).join(","));
+      return ffi.metricsHistogram(live(), name, (labelKeys ?? []).join("\x1F"), (buckets ?? []).join(","));
     },
     record(series, values, amount) {
       const joined = (values ?? []).join("\x1F");
-      if (!ffi.metricsRecordStr(handle, series, joined, amount ?? 1)) {
+      if (!ffi.metricsRecordStr(live(), series, joined, amount ?? 1)) {
         throw new Error("metrics record: unknown series / arity mismatch / invalid amount");
       }
     },
     gaugeSet(series, values, value) {
       const joined = (values ?? []).join("\x1F");
-      if (!ffi.metricsGaugeSetStr(handle, series, joined, value)) {
+      if (!ffi.metricsGaugeSetStr(live(), series, joined, value)) {
         throw new Error("metrics gauge set: unknown series / arity mismatch");
       }
     },
     render() {
       let out = new Uint8Array(8192);
-      let w = ffi.metricsRender(handle, out);
+      let w = ffi.metricsRender(live(), out);
       if (w > out.length) {
         out = new Uint8Array(w);
-        w = ffi.metricsRender(handle, out);
+        w = ffi.metricsRender(live(), out);
       }
       return decodeUtf8(out.subarray(0, w));
     },
     destroy() {
-      ffi.metricsDestroy(handle);
+      if (handle !== 0) {
+        ffi.metricsDestroy(handle);
+        handle = 0;
+      }
     },
     snapshot() {
       let out = new Uint8Array(4096);
-      let w = ffi.metricsSnapshot(handle, out);
+      let w = ffi.metricsSnapshot(live(), out);
       if (w > out.length) {
         out = new Uint8Array(w);
-        w = ffi.metricsSnapshot(handle, out);
+        w = ffi.metricsSnapshot(live(), out);
       }
       return out.subarray(0, w);
     }
@@ -4290,11 +4410,12 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.SchemaValidator(schema);
-        return ffiSchemaValidator(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiSchemaValidator(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.SchemaValidator(schema);
     },
     createHmacSigner(key) {
+      assertNonEmptySecret(key, "createHmacSigner");
       const ffi = transport.ffi;
       if (ffi)
         return ffiHmacSigner(key, ffi);
@@ -4304,7 +4425,7 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.TemplateRenderer(source);
-        return ffiTemplateRenderer(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiTemplateRenderer(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.TemplateRenderer(source);
     },
@@ -4321,7 +4442,7 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.ConditionalRequest(etagValue, lastModifiedSecs ?? undefined);
-        return ffiConditionalRequest(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiConditionalRequest(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.ConditionalRequest(etagValue, lastModifiedSecs ?? undefined);
     },
@@ -4329,7 +4450,7 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.AcceptNegotiator(supported);
-        return ffiAcceptNegotiator(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiAcceptNegotiator(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.AcceptNegotiator(supported);
     },
@@ -4340,12 +4461,14 @@ function buildFactories(ctx) {
       return new addon.Base64Codec(urlSafe ?? undefined, padding ?? undefined);
     },
     createCookieSigner(secret) {
+      assertNonEmptySecret(secret, "createCookieSigner");
       const ffi = transport.ffi;
       if (ffi)
         return ffiCookieSigner(secret, ffi);
       return new addon.CookieSigner(secret);
     },
     createCsrfProtector(secret) {
+      assertNonEmptySecret(secret, "createCsrfProtector");
       const ffi = transport.ffi;
       if (ffi)
         return ffiCsrfProtector(secret, ffi);
@@ -4355,15 +4478,16 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.UrlBuilder(base);
-        return ffiUrlBuilder(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiUrlBuilder(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.UrlBuilder(base);
     },
     createJwtSigner(secret, ttlSeconds) {
+      assertNonEmptySecret(secret, "createJwtSigner");
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.JwtSigner(secret, ttlSeconds ?? undefined);
-        return ffiJwtSigner(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiJwtSigner(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.JwtSigner(secret, ttlSeconds ?? undefined);
     },
@@ -4383,7 +4507,7 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.MediaTypeMatcher(expected);
-        return ffiMediaTypeMatcher(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiMediaTypeMatcher(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.MediaTypeMatcher(expected);
     },
@@ -4391,7 +4515,7 @@ function buildFactories(ctx) {
       const ffi = transport.ffi;
       if (ffi) {
         const napi = new addon.RateLimiter(limit, windowMs, maxEntries ?? undefined);
-        return ffiRateLimiter(napi, Number(napi.innerPtr?.() ?? 0n), ffi);
+        return ffiRateLimiter(napi, handlePtr(napi.innerPtr?.()), ffi);
       }
       return new addon.RateLimiter(limit, windowMs, maxEntries ?? undefined);
     },
@@ -4492,37 +4616,63 @@ function ensureValidUtf8(bytes, ffi) {
 function u32LE(b, off) {
   return ((b[off] ?? 0) | (b[off + 1] ?? 0) << 8 | (b[off + 2] ?? 0) << 16 | (b[off + 3] ?? 0) << 24) >>> 0;
 }
+function keyBytesEqual(b, off, lit) {
+  for (let i = 0;i < lit.length; i++) {
+    if ((b[off + i] ?? 0) !== (lit[i] ?? 0))
+      return false;
+  }
+  return true;
+}
 function unpackMediaType(packed) {
+  const view = Buffer.from(packed.buffer, packed.byteOffset, packed.byteLength);
   let off = 0;
   const mtLen = u32LE(packed, off);
   off += 4;
-  const mediaType = decodeUtf8Range(packed, off, off + mtLen);
+  const mediaType = decodeUtf8RangeView(view, off, off + mtLen);
   off += mtLen;
   let charset = null;
   const csLen = u32LE(packed, off);
   off += 4;
   if (csLen !== 4294967295) {
-    charset = decodeUtf8Range(packed, off, off + csLen);
+    charset = decodeUtf8RangeView(view, off, off + csLen);
     off += csLen;
   }
   let boundary = null;
   const bLen = u32LE(packed, off);
   off += 4;
   if (bLen !== 4294967295) {
-    boundary = decodeUtf8Range(packed, off, off + bLen);
+    boundary = decodeUtf8RangeView(view, off, off + bLen);
     off += bLen;
   }
   const count = u32LE(packed, off);
   off += 4;
   const params = {};
+  let charsetTaken = charset === null;
+  let boundaryTaken = boundary === null;
   for (let i = 0;i < count; i++) {
     const kLen = u32LE(packed, off);
     off += 4;
-    const key = decodeUtf8Range(packed, off, off + kLen);
+    let key;
+    if (kLen === 7 && keyBytesEqual(packed, off, CHARSET_KEY_BYTES)) {
+      key = "charset";
+    } else if (kLen === 8 && keyBytesEqual(packed, off, BOUNDARY_KEY_BYTES)) {
+      key = "boundary";
+    } else {
+      key = decodeUtf8RangeView(view, off, off + kLen);
+    }
     off += kLen;
     const vLen = u32LE(packed, off);
     off += 4;
-    const val = decodeUtf8Range(packed, off, off + vLen);
+    let val;
+    if (!charsetTaken && key === "charset" && charset !== null) {
+      val = charset;
+      charsetTaken = true;
+    } else if (!boundaryTaken && key === "boundary" && boundary !== null) {
+      val = boundary;
+      boundaryTaken = true;
+    } else {
+      val = decodeUtf8RangeView(view, off, off + vLen);
+    }
     off += vLen;
     params[key] = val;
   }
@@ -4653,7 +4803,7 @@ function buildHttp(ctx) {
     queryParsePacked(input) {
       const f = ffi();
       if (f) {
-        const out = new Uint8Array(input.length * 9 + 16);
+        const out = new Uint8Array(input.length * 5 + 8);
         const w = f.queryParsePackedInto(input, out);
         return out.subarray(0, w);
       }
@@ -4665,7 +4815,7 @@ function buildHttp(ctx) {
     cookieParsePacked(input) {
       const f = ffi();
       if (f) {
-        const out = new Uint8Array(input.length * 9 + 16);
+        const out = new Uint8Array(input.length * 5 + 8);
         const w = f.cookieParsePackedInto(input, out);
         return out.subarray(0, w);
       }
@@ -4677,7 +4827,7 @@ function buildHttp(ctx) {
     formParsePacked(input) {
       const f = ffi();
       if (f) {
-        const out = new Uint8Array(input.length * 9 + 16);
+        const out = new Uint8Array(input.length * 5 + 8);
         const w = f.formParsePackedInto(input, out);
         return out.subarray(0, w);
       }
@@ -4749,13 +4899,15 @@ function buildHttp(ctx) {
     }
   };
 }
-var WS_ACCEPT_SCRATCH, f32Bits, f32BitsU32;
+var WS_ACCEPT_SCRATCH, CHARSET_KEY_BYTES, BOUNDARY_KEY_BYTES, f32Bits, f32BitsU32;
 var init_http = __esm(() => {
   init_bytes();
   init_codec2();
   init_packed();
   init_context();
   WS_ACCEPT_SCRATCH = new Uint8Array(64);
+  CHARSET_KEY_BYTES = new Uint8Array([99, 104, 97, 114, 115, 101, 116]);
+  BOUNDARY_KEY_BYTES = new Uint8Array([98, 111, 117, 110, 100, 97, 114, 121]);
   f32Bits = new Float32Array(1);
   f32BitsU32 = new Uint32Array(f32Bits.buffer);
 });
@@ -4835,6 +4987,7 @@ function buildPayload(ctx) {
   const { builtins, transport } = ctx.runtime;
   const HAS = { gzipCompress: builtins.has("gzipCompress") };
   const ffi = memoizeFfi(transport);
+  let SCRATCH = null;
   return {
     gzipCompress(data, level) {
       if (HAS.gzipCompress)
@@ -4888,8 +5041,20 @@ function buildPayload(ctx) {
     },
     multipartParse(body, boundary) {
       const f = ffi();
-      if (f)
-        return unpackMultipart(f.multipartParsePacked(body, boundary));
+      if (f) {
+        const need = body.length + boundary.length + 64;
+        if (need > 64 * 1024)
+          return unpackMultipart(f.multipartParsePacked(body, boundary));
+        if (!SCRATCH || SCRATCH.length < need)
+          SCRATCH = new Uint8Array(need);
+        let w;
+        try {
+          w = f.multipartParsePackedInto(body, boundary, SCRATCH);
+        } catch {
+          return unpackMultipart(f.multipartParsePacked(body, boundary));
+        }
+        return unpackMultipart(SCRATCH.subarray(0, w));
+      }
       return addon.multipartParse(body, boundary).map((p) => ({
         name: p.name,
         filename: p.filename ?? null,
@@ -5318,10 +5483,13 @@ function createNativeRoute(plan = {}) {
   const parseQuery = plan.parseQuery === true;
   const parseCookies = plan.parseCookies === true;
   const bunFFI = getBunFFI();
-  const ffiHandle = bunFFI !== null ? compileFfi(bunFFI, descriptor) : 0;
-  const napiRoute = bunFFI === null ? compileNapi(descriptor) : null;
+  let ffiHandle = bunFFI !== null ? compileFfi(bunFFI, descriptor) : 0;
+  let napiRoute = bunFFI === null || ffiHandle === 0 ? compileNapi(descriptor) : null;
   let out = new Uint8Array(256);
   const runFrame = (frame) => {
+    if (ffiHandle === 0 && napiRoute === null) {
+      throw new Error("native route: already destroyed");
+    }
     let written;
     if (ffiHandle !== 0 && bunFFI !== null) {
       written = bunFFI.routeRun(ffiHandle, frame, out);
@@ -5354,7 +5522,10 @@ function createNativeRoute(plan = {}) {
     destroy: () => {
       if (ffiHandle !== 0 && bunFFI !== null) {
         bunFFI.routeDestroy(ffiHandle);
+        ffiHandle = 0;
       }
+      napiRoute?.destroy?.();
+      napiRoute = null;
     }
   };
 }
@@ -5378,6 +5549,17 @@ function compileNapi(descriptor) {
   }
 }
 
+// src/ingress/headers/memoized-headers.ts
+var CACHE = new WeakMap;
+function memoizedHeaders(entries) {
+  const existing = CACHE.get(entries);
+  if (existing !== undefined)
+    return existing;
+  const built = new Headers(entries);
+  CACHE.set(entries, built);
+  return built;
+}
+
 // src/ingress/shared.ts
 var DEFAULT_MAX_BODY_BYTES = 1048576;
 var DEFAULT_FAST_OUTPUT_BUFFER_SIZE = 262144;
@@ -5420,10 +5602,9 @@ function resolveIp(req, srv, opts) {
   return opts.getIp ? opts.getIp(req, srv) : undefined;
 }
 function buildSuccessInit(ingress, result, ctx, status = 200) {
-  return {
-    status,
-    headers: ingress.responseHeaders(result.headerVariant, ctx.requestIdHeader, ctx.origin, result.rateRemaining, result.rateResetMs > 0 ? secondsFromMs(result.rateResetMs) : undefined)
-  };
+  const rateResetSecs = result.rateResetMs > 0 ? secondsFromMs(result.rateResetMs) : undefined;
+  const headers = ingress.successHeaders ? ingress.successHeaders(result.headerVariant, ctx.requestIdHeader, ctx.origin, result.rateRemaining, rateResetSecs) : memoizedHeaders(ingress.responseHeaders(result.headerVariant, ctx.requestIdHeader, ctx.origin, result.rateRemaining, rateResetSecs));
+  return { status, headers };
 }
 function runBaked(ingress, opts, respond) {
   return (req, srv) => ingress.run(req, resolveIp(req, srv, opts), null, respond);
@@ -5802,6 +5983,18 @@ function rateLimitedBody(retryAfterMs) {
 }
 
 // src/ingress/routes/echo.ts
+var SAFE_ECHO_CONTENT_TYPES = new Set([
+  "application/json",
+  "application/octet-stream",
+  "text/plain"
+]);
+function echoMediaTypeOf(contentType) {
+  const semi = contentType.indexOf(";");
+  return (semi >= 0 ? contentType.slice(0, semi) : contentType).trim().toLowerCase();
+}
+function safeEchoContentType(contentType) {
+  return SAFE_ECHO_CONTENT_TYPES.has(echoMediaTypeOf(contentType)) ? contentType : "application/octet-stream";
+}
 function echoHandler(ingress, opts = {}) {
   const maxBodyBytes = opts.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
   const bodyTimeoutMs = opts.bodyTimeoutMs ?? DEFAULT_BODY_TIMEOUT_MS;
@@ -5822,32 +6015,39 @@ function echoHandler(ingress, opts = {}) {
     if (prep.terminal)
       return prep.terminal;
     const baseHeaders = prep.headers ?? [];
-    const requestedContentType = req.headers.get("content-type") ?? "application/octet-stream";
+    const requestedContentType = safeEchoContentType(req.headers.get("content-type") ?? "application/octet-stream");
+    const withEchoHeaders = (contentType) => {
+      const headers = ingress.withContentType(baseHeaders, contentType);
+      if (!headers.some(([name]) => name.toLowerCase() === "x-content-type-options")) {
+        headers.push(["x-content-type-options", "nosniff"]);
+      }
+      return headers;
+    };
     const contentLengthHeader = req.headers.get("content-length");
     const contentLength = contentLengthHeader === null ? NaN : Number(contentLengthHeader);
     if (Number.isFinite(contentLength)) {
       if (contentLength > maxBodyBytes) {
         return new Response(ERROR_BODIES.body_too_large, {
           status: 413,
-          headers: ingress.withContentType(baseHeaders, "application/json")
+          headers: withEchoHeaders("application/json")
         });
       }
       if (contentLength <= 0 || req.body === null) {
         return new Response(null, {
           status: 200,
-          headers: ingress.withContentType(baseHeaders, requestedContentType)
+          headers: withEchoHeaders(requestedContentType)
         });
       }
       return new Response(req.body, {
         status: 200,
-        headers: ingress.withContentType(baseHeaders, requestedContentType)
+        headers: withEchoHeaders(requestedContentType)
       });
     }
     try {
       const bodyBytes = await readBodyWithLimit(req, maxBodyBytes, true, bodyTimeoutMs);
       return new Response(bodyBytes.byteLength > 0 ? bodyBytes : null, {
         status: 200,
-        headers: ingress.withContentType(baseHeaders, requestedContentType)
+        headers: withEchoHeaders(requestedContentType)
       });
     } catch (err) {
       const code = err?.code;
@@ -5855,7 +6055,7 @@ function echoHandler(ingress, opts = {}) {
       const isTimeout = code === "REQUEST_TIMEOUT";
       return new Response(isTooLarge ? ERROR_BODIES.body_too_large : isTimeout ? ERROR_BODIES.request_timeout : ERROR_BODIES.bad_request, {
         status: isTooLarge ? 413 : isTimeout ? 408 : 400,
-        headers: ingress.withContentType(baseHeaders, "application/json")
+        headers: withEchoHeaders("application/json")
       });
     }
   };
@@ -5893,6 +6093,11 @@ function defaultJsonValid(bytes) {
     return false;
   }
 }
+function isJsonContentType(contentType) {
+  const semi = contentType.indexOf(";");
+  const mediaType = (semi >= 0 ? contentType.slice(0, semi) : contentType).trim().toLowerCase();
+  return mediaType === "application/json" || mediaType.endsWith("+json");
+}
 function jsonWriteHandler(ingress, opts = {}) {
   const maxBodyBytes = opts.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
   const fallback = opts.fallback ?? ingress;
@@ -5902,13 +6107,8 @@ function jsonWriteHandler(ingress, opts = {}) {
   return async (req, srv) => {
     const ip = resolveIp(req, srv, opts);
     const contentType = req.headers.get("content-type") ?? "";
-    if (!contentType.includes("application/json")) {
-      return fallback.run(req, ip, null, (result, ctx) => {
-        const terminal = fallback.terminalResponse(req, result, ctx);
-        if (terminal)
-          return terminal;
-        return fallback.errorResponse(req, result, 415, "unsupported_media_type", "Content-Type must be application/json", ctx);
-      });
+    if (!isJsonContentType(contentType)) {
+      return fallback.run(req, ip, null, (result, ctx) => fallback.errorResponse(req, result, 415, "unsupported_media_type", "Content-Type must be application/json", ctx));
     }
     let bodyBytes;
     try {
@@ -6093,7 +6293,7 @@ function safeTerminalStatus(r) {
 }
 
 // src/ingress/routes/responder.ts
-var IGNGEX_SECURITY_HEADERS = [
+var IGNEX_SECURITY_HEADERS = [
   ["x-frame-options", "DENY"],
   ["x-content-type-options", "nosniff"],
   ["referrer-policy", "no-referrer"]
@@ -6101,7 +6301,7 @@ var IGNGEX_SECURITY_HEADERS = [
 function buildIgngexTerminal(result, _ctx) {
   const preflightAllowed = result.isPreflight && result.corsAllowed;
   if (preflightAllowed) {
-    return new Response(null, { status: 204, headers: IGNGEX_SECURITY_HEADERS });
+    return new Response(null, { status: 204, headers: IGNEX_SECURITY_HEADERS });
   }
   const status = safeTerminalStatus(result);
   const body = JSON.stringify({
@@ -6109,7 +6309,7 @@ function buildIgngexTerminal(result, _ctx) {
     status,
     code: errorCodeName(result.errorCode)
   });
-  const headers = new Headers(IGNGEX_SECURITY_HEADERS);
+  const headers = new Headers(IGNEX_SECURITY_HEADERS);
   headers.set("content-type", "application/json; charset=utf-8");
   return new Response(body, { status, headers });
 }
@@ -6137,7 +6337,7 @@ function nativeResponderRoute(ingress, responder, opts = {}) {
         const code = err.code;
         const status = code === "REQUEST_TIMEOUT" ? 408 : code === "BODY_TOO_LARGE" ? 413 : 400;
         const payload = JSON.stringify({ error: "Bad Request", status, code: "BAD_REQUEST" });
-        const headers = new Headers(IGNGEX_SECURITY_HEADERS);
+        const headers = new Headers(IGNEX_SECURITY_HEADERS);
         headers.set("content-type", "application/json; charset=utf-8");
         return new Response(payload, { status, headers });
       }
@@ -6468,7 +6668,7 @@ function nodeRequestToWebRequest(req) {
   }
   const method = req.method ?? "GET";
   const bodyForbidden = method === "GET" || method === "HEAD";
-  const hasBody = Number(req.headers["content-length"] ?? 0) > 0 || req.headers["transfer-encoding"] !== undefined;
+  const hasBody = requestHasBody(req);
   const init = { method, headers };
   if (hasBody && !bodyForbidden) {
     init.body = Readable.toWeb(req);
@@ -6512,7 +6712,7 @@ async function writeResponse(res, response) {
 }
 function drainUnreadBody(res) {
   const req = res.req;
-  if (req !== undefined && req !== null && !req.complete && hasBody(req)) {
+  if (req !== undefined && req !== null && !req.complete && requestHasBody(req)) {
     req.resume();
     res.shouldKeepAlive = false;
     if (!res.headersSent) {
@@ -6520,7 +6720,7 @@ function drainUnreadBody(res) {
     }
   }
 }
-function hasBody(req) {
+function requestHasBody(req) {
   return Number(req.headers["content-length"] ?? 0) > 0 || req.headers["transfer-encoding"] !== undefined;
 }
 function makeRequestListener(options, routes, baseOpts) {
@@ -6576,6 +6776,23 @@ function makeRequestListener(options, routes, baseOpts) {
     }
   };
 }
+var WS_PROTOCOL_TOKEN = /^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/;
+function formatWebSocketHandshake(accept, protocol) {
+  if (/[\r\n]/.test(accept)) {
+    throw new Error("invalid Sec-WebSocket-Accept value");
+  }
+  let raw = `HTTP/1.1 101 Switching Protocols\r
+` + `Upgrade: websocket\r
+` + `Connection: Upgrade\r
+` + `Sec-WebSocket-Accept: ${accept}\r
+`;
+  if (protocol && WS_PROTOCOL_TOKEN.test(protocol)) {
+    raw += `Sec-WebSocket-Protocol: ${protocol}\r
+`;
+  }
+  return `${raw}\r
+`;
+}
 function makeUpgradeListener(options) {
   return async (req, socket, head) => {
     try {
@@ -6585,18 +6802,7 @@ function makeUpgradeListener(options) {
         socket.destroy();
         return;
       }
-      let raw = `HTTP/1.1 101 Switching Protocols\r
-` + `Upgrade: websocket\r
-` + `Connection: Upgrade\r
-` + `Sec-WebSocket-Accept: ${handshake.accept}\r
-`;
-      if (handshake.protocol) {
-        raw += `Sec-WebSocket-Protocol: ${handshake.protocol}\r
-`;
-      }
-      raw += `\r
-`;
-      socket.write(raw);
+      socket.write(formatWebSocketHandshake(handshake.accept, handshake.protocol));
       options.onUpgrade?.(socket, req, head);
     } catch {
       socket.destroy();
@@ -6820,6 +7026,7 @@ class IngressResultBase {
   bodyTruncated = false;
   body = EMPTY_BODY2;
   _buf = EMPTY_BODY2;
+  _len = 0;
   _bodyJsonStart = OUT_DATA_START;
   _bodyJsonLen = 0;
   _cookiesBuf = null;
@@ -6845,6 +7052,7 @@ class IngressResultBase {
     this.bodyTruncated = false;
     this.body = EMPTY_BODY2;
     this._buf = EMPTY_BODY2;
+    this._len = 0;
     this._bodyJsonStart = OUT_DATA_START;
     this._bodyJsonLen = 0;
     this._cookiesBuf = null;
@@ -6869,8 +7077,9 @@ class IngressResultBase {
       this.retryAfterMs = 0;
     }
   }
-  setSections(buf, layout, bodyJsonLen) {
+  setSections(buf, layout, bodyJsonLen, len = buf.byteLength) {
     this._buf = buf;
+    this._len = len;
     this._bodyJsonStart = layout.bodyJsonStart;
     this._bodyJsonLen = bodyJsonLen;
     this._cookiesBuf = layout.safeCookiesLen > 0 ? buf.subarray(OUT_DATA_START, OUT_DATA_START + layout.safeCookiesLen) : null;
@@ -6900,7 +7109,7 @@ class IngressResultBase {
     if (this._bodyJsonLen === 0)
       return EMPTY_BODY2;
     const end = this._bodyJsonStart + this._bodyJsonLen;
-    if (end > this._buf.byteLength)
+    if (end > this._len)
       return EMPTY_BODY2;
     return this._buf.subarray(this._bodyJsonStart, end);
   }
@@ -6964,7 +7173,7 @@ class FastIngressResult extends IngressResultBase {
     this.isPreflight = (flags & FLAG_IS_PREFLIGHT) !== 0;
     this.rateLimited = (flags & FLAG_RATE_LIMITED) !== 0;
     const layout = sectionLayout(buf.byteLength, cookiesJsonLen, queryJsonLen, bodyJsonLen);
-    this.setSections(buf, layout, bodyJsonLen);
+    this.setSections(buf, layout, bodyJsonLen, buf.byteLength);
     this.bodyTruncated = (flags & FLAG_BODY_TRUNCATED) !== 0 || layout.truncated;
   }
   invalidate() {
@@ -7056,7 +7265,14 @@ function warnTrustProxyDeprecated() {
   if (trustProxyWarned)
     return;
   trustProxyWarned = true;
-  console.warn("[castrum] WARN: `trustProxy: true` is deprecated and trusts EVERY hop — " + "clients can spoof X-Forwarded-For / X-Real-IP to bypass IP-based rate " + "limiting. Use `trustedProxies: { enabled: true, networks: [...] }` and " + "only enable proxy trust behind a trusted edge.");
+  console.warn("[castrum] WARN: `trustProxy: true` is deprecated and trusts EVERY hop — " + "clients can spoof X-Forwarded-For / X-Real-IP to bypass IP-based rate " + "limiting. Use `trustedProxies: { enabled: true, networks: [...] }` " + "(which takes precedence) and only enable proxy trust behind a trusted edge.");
+}
+var rateLimitNoIpWarned = false;
+function warnRateLimitWithoutGetIp() {
+  if (rateLimitNoIpWarned)
+    return;
+  rateLimitNoIpWarned = true;
+  console.warn("[castrum] WARN: rate limiting is enabled without `getIp` — every client " + "shares ONE bucket, so one client can exhaust it for everyone. Provide " + "`getIp` for per-client limits (or use a global limit deliberately).");
 }
 
 // src/ingress/packing/header-packing.ts
@@ -7622,6 +7838,11 @@ class BufferPool {
     this.estimate = options.adaptive === true ? new AdaptiveEstimate({ alpha: 0.25, min: this.initialSize }) : null;
     this.free.push(new Uint8Array(this.initialSize));
     this.created = 1;
+    const prefill = Math.min(Math.max(0, Math.floor(options.prefill ?? 0)), this.maxBuffers - 1, options.prefillBytes !== undefined ? Math.max(0, Math.floor(options.prefillBytes / this.initialSize)) : Number.POSITIVE_INFINITY);
+    for (let i = 0;i < prefill; i++) {
+      this.free.push(new Uint8Array(this.initialSize));
+      this.created++;
+    }
   }
   get freeCount() {
     return this.free.length;
@@ -7655,7 +7876,9 @@ class BufferPool {
     for (let i = 0;i < this.free.length; i++) {
       const candidate = this.free[i];
       if (candidate.byteLength >= minSize) {
-        this.free.splice(i, 1);
+        const last = this.free.pop();
+        if (i < this.free.length)
+          this.free[i] = last;
         return candidate;
       }
     }
@@ -7670,7 +7893,9 @@ class BufferPool {
       }
     }
     if (largestBuf !== null) {
-      this.free.splice(largest, 1);
+      const last = this.free.pop();
+      if (largest < this.free.length)
+        this.free[largest] = last;
       this.created++;
       return new Uint8Array(target);
     }
@@ -7679,16 +7904,15 @@ class BufferPool {
   }
   releaseBuffer(buffer) {
     if (this.free.length >= this.maxBuffers) {
-      let smallestBuf = null;
       let smallest = 0;
-      for (let i = 0;i < this.free.length; i++) {
-        const candidate = this.free[i];
-        if (smallestBuf === null || candidate.byteLength < smallestBuf.byteLength) {
-          smallestBuf = candidate;
+      for (let i = 1;i < this.free.length; i++) {
+        if (this.free[i].byteLength < this.free[smallest].byteLength) {
           smallest = i;
         }
       }
-      this.free.splice(smallest, 1);
+      const last = this.free.pop();
+      if (smallest < this.free.length)
+        this.free[smallest] = last;
     }
     this.free.push(buffer);
   }
@@ -7748,8 +7972,8 @@ function createStructuredLogger(stream = process.stderr, env = process.env) {
 
 // src/ingress/decode/baked-result.ts
 class BakedIngressResult extends IngressResultBase {
-  refresh(buf, body, view) {
-    if (buf.byteLength < OUT_DATA_START) {
+  refresh(buf, body, view, len = buf.byteLength) {
+    if (len < OUT_DATA_START) {
       this.setInternalError();
       return;
     }
@@ -7762,7 +7986,7 @@ class BakedIngressResult extends IngressResultBase {
     const queryLenRaw = view.getUint32(OUT_QUERY_JSON_LEN, true);
     const headerVariant = view.getUint8(OUT_HEADER_VARIANT);
     const bodyJsonLenRaw = view.getUint32(OUT_BODY_JSON_LEN, true);
-    const layout = sectionLayout(buf.byteLength, cookiesLenRaw, queryLenRaw, bodyJsonLenRaw);
+    const layout = sectionLayout(len, cookiesLenRaw, queryLenRaw, bodyJsonLenRaw);
     if (h0 === 0 && h1 === 0) {
       this.verdict = 1;
       this.errorCode = ERR_CODE_INTERNAL;
@@ -7777,7 +8001,7 @@ class BakedIngressResult extends IngressResultBase {
     this.rateRemaining = h3;
     this.setRateWindow(h2, (flags & FLAG_RATE_LIMITED) !== 0, view);
     this.headerVariant = headerVariant;
-    this.setSections(buf, layout, layout.safeBodyJsonLen);
+    this.setSections(buf, layout, layout.safeBodyJsonLen, len);
     this.updateOkTerminal();
     this.isPreflight = (flags & FLAG_IS_PREFLIGHT) !== 0;
     this.corsAllowed = (flags & FLAG_CORS_ALLOWED) !== 0;
@@ -7800,8 +8024,16 @@ class BakedIngressResult extends IngressResultBase {
     this.ok = false;
   }
   bodyJson(copy) {
+    if (copy) {
+      if (this._bodyJsonLen === 0)
+        return this._buf.slice(0, 0);
+      const end = this._bodyJsonStart + this._bodyJsonLen;
+      if (end > this._len)
+        return this._buf.slice(0, 0);
+      return this._buf.slice(this._bodyJsonStart, end);
+    }
     const slice = this.bodyJsonSlice();
-    return copy ? slice.slice() : slice;
+    return slice;
   }
 }
 
@@ -7925,6 +8157,13 @@ function cachedOriginBlock(origin) {
   ORIGIN_BLOCK_CACHE.set(origin, block);
   return block;
 }
+function prewarmOriginBlocks(origins) {
+  for (const origin of origins) {
+    if (typeof origin === "string" && origin.length > 0 && origin.length <= MAX_SMALL_HEADER_BYTES && !origin.includes("*")) {
+      cachedOriginBlock(origin);
+    }
+  }
+}
 
 // src/ingress/response/baked-response.ts
 init_bytes();
@@ -7977,6 +8216,12 @@ function pooledBodyResponse(handle, bytes, init = {}, timeoutMs = 0) {
 
 // src/ingress/response/baked-response.ts
 var EMPTY_BODY4 = new Uint8Array(0);
+var ORIGIN_HEADER_CACHE_MAX = 64;
+function prewarmOriginHeaders(responseHeaders, origins, variant) {
+  for (const origin of origins) {
+    memoizedHeaders(responseHeaders(variant, null, origin));
+  }
+}
 function buildBakedResponseBuilders(deps) {
   const {
     headerTemplates,
@@ -7986,6 +8231,45 @@ function buildBakedResponseBuilders(deps) {
     originHeaderCache,
     state
   } = deps;
+  function originBaseEntries(variant, origin) {
+    const key = `${variant & 31}\x00${origin}`;
+    const cached = originHeaderCache.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const template = headerTemplates[variant & 31] ?? headerTemplates[0] ?? [];
+    const entries = new Array(template.length + 1);
+    let i = 0;
+    for (const pair of template) {
+      entries[i++] = pair;
+    }
+    entries[i] = ["access-control-allow-origin", origin];
+    if (originHeaderCache.size >= ORIGIN_HEADER_CACHE_MAX) {
+      const oldest = originHeaderCache.keys().next().value;
+      if (oldest !== undefined)
+        originHeaderCache.delete(oldest);
+    }
+    originHeaderCache.set(key, entries);
+    return entries;
+  }
+  function successHeaders(variant, requestIdHeader, origin, rateRemaining, rateResetSecs) {
+    const needsRequestId = emitRequestIdHeader && requestIdHeader !== null;
+    const needsOrigin = ((variant & HV_CORS_SIMPLE) !== 0 || (variant & HV_CORS_PREFLIGHT) !== 0) && origin !== null;
+    const needsRate = (variant & HV_RATE_ACTIVE) !== 0;
+    const base = needsOrigin ? memoizedHeaders(originBaseEntries(variant, origin)) : memoizedHeaders(headerTemplates[variant & 31] ?? headerTemplates[0] ?? []);
+    if (!needsRequestId && !needsRate) {
+      return base;
+    }
+    const headers = new Headers(base);
+    if (needsRequestId) {
+      headers.set("x-request-id", requestIdHeader);
+    }
+    if (needsRate) {
+      headers.set("ratelimit-remaining", String(rateRemaining ?? 0));
+      headers.set("ratelimit-reset", String(rateResetSecs ?? 0));
+    }
+    return headers;
+  }
   function responseHeaders(variant, requestIdHeader, origin, rateRemaining, rateResetSecs, retryAfterSecs) {
     const template = headerTemplates[variant & 31] ?? headerTemplates[0] ?? [];
     const needsRequestId = emitRequestIdHeader && requestIdHeader !== null;
@@ -7996,19 +8280,7 @@ function buildBakedResponseBuilders(deps) {
       return template;
     }
     if (!needsRequestId && !needsRate && !needsRetry && needsOrigin) {
-      const key = `${variant & 31}\x00${origin}`;
-      const cached = originHeaderCache.get(key);
-      if (cached !== undefined) {
-        return cached;
-      }
-      const entries = new Array(template.length + 1);
-      let i = 0;
-      for (const pair of template) {
-        entries[i++] = pair;
-      }
-      entries[i] = ["access-control-allow-origin", origin];
-      originHeaderCache.set(key, entries);
-      return entries;
+      return originBaseEntries(variant, origin);
     }
     let extra = 0;
     if (needsRequestId)
@@ -8069,27 +8341,27 @@ function buildBakedResponseBuilders(deps) {
     if (preflightAllowed) {
       return new Response(null, {
         status: 204,
-        headers: responseHeaders(result.headerVariant, ctx.requestIdHeader, ctx.origin, result.rateRemaining, result.rateResetMs > 0 ? secondsFromMs(result.rateResetMs) : undefined, result.retryAfterMs > 0 ? secondsFromMs(result.retryAfterMs) : undefined)
+        headers: memoizedHeaders(responseHeaders(result.headerVariant, ctx.requestIdHeader, ctx.origin, result.rateRemaining, result.rateResetMs > 0 ? secondsFromMs(result.rateResetMs) : undefined, result.retryAfterMs > 0 ? secondsFromMs(result.retryAfterMs) : undefined))
       });
     }
     const status = safeTerminalStatus(result);
     const body = result.errorCode === ERR_CODE_RATE_LIMITED ? rateLimitedBody(result.retryAfterMs) : ERROR_CODE_BODIES[result.errorCode] ?? ERROR_BODIES.internal ?? EMPTY_BODY4;
     return new Response(body, {
       status,
-      headers: terminalHeaders(result.headerVariant, ctx, result)
+      headers: memoizedHeaders(terminalHeaders(result.headerVariant, ctx, result))
     });
   }
   function errorResponse(_req, result, status, code, message, ctx) {
     const body = ERROR_BODIES[code] ?? encoder.encode(JSON.stringify({ ok: false, error: { code, message } }));
     return new Response(body, {
       status,
-      headers: terminalHeaders(result?.headerVariant ?? HV_JSON, ctx, result)
+      headers: memoizedHeaders(terminalHeaders(result?.headerVariant ?? HV_JSON, ctx, result))
     });
   }
   function internalErrorResponse(ctx, result) {
     return new Response(ERROR_BODIES.internal, {
       status: 500,
-      headers: terminalHeaders(result?.headerVariant ?? HV_JSON, ctx, result ?? null)
+      headers: memoizedHeaders(terminalHeaders(result?.headerVariant ?? HV_JSON, ctx, result ?? null))
     });
   }
   function withContentType(headers, contentType) {
@@ -8110,6 +8382,7 @@ function buildBakedResponseBuilders(deps) {
   }
   return {
     responseHeaders,
+    successHeaders,
     terminalHeaders,
     terminalResponse,
     errorResponse,
@@ -8124,6 +8397,8 @@ var EMPTY_BODY5 = new Uint8Array(0);
 var EMPTY_IP = "0.0.0.0";
 var RATE_LIMIT_U32_MAX = 4294967295;
 var MAX_FFI_FAILURES = 3;
+var PREWARM_POOL_BUFFERS = 16;
+var PREWARM_POOL_BYTES = 4 * 1024 * 1024;
 function pathForLog(req) {
   try {
     return new URL(req.url).pathname;
@@ -8160,14 +8435,24 @@ function createIngressHandler(options = {}, runtime = {}) {
   const outputBufferSize = clampIngressBufferSize(runtime.outputBufferSize ?? DEFAULT_BAKED_OUTPUT_BUFFER_SIZE, OUT_DATA_START);
   const logger = runtime.logger ?? (runtime.structuredLog === true ? createStructuredLogger() : null);
   const needRequestIdString = !!(emitRequestIdHeader || runtime.onRequest || runtime.onError || runtime.onResponse || logger);
+  const hasOnRequest = runtime.onRequest !== undefined;
+  const hasOnResponse = runtime.onResponse !== undefined;
   const outputPool = new BufferPool({
     initialSize: outputBufferSize,
-    maxInFlight: runtime.maxInFlight
+    maxInFlight: runtime.maxInFlight,
+    prefill: PREWARM_POOL_BUFFERS,
+    prefillBytes: PREWARM_POOL_BYTES
   });
   const inputPacker = new IngressInputPacker;
   const responseState = { currentHandle: null, responseBorrowsBuffer: false };
   let ffiFailures = 0;
   let ffiDisabled = false;
+  const noteFfiFailure = () => {
+    ffiFailures++;
+    if (ffiFailures >= MAX_FFI_FAILURES) {
+      ffiDisabled = true;
+    }
+  };
   const originHeaderCache = new Map;
   const cors = options.cors;
   const securityEntries = runtime.enableSecurityHeaders === false ? Object.freeze([]) : Object.freeze(buildBakedSecurityEntries(options.security, options.https, runtime.securityHeaders));
@@ -8193,6 +8478,17 @@ function createIngressHandler(options = {}, runtime = {}) {
     originHeaderCache,
     state: responseState
   });
+  if (headerPlan.cors && typeof cors?.allowOrigin === "object") {
+    const exactOrigins = [];
+    for (const origin of cors.allowOrigin) {
+      if (typeof origin === "string" && origin.length > 0 && origin.length <= 512 && !origin.includes("*")) {
+        exactOrigins.push(origin);
+      }
+    }
+    prewarmOriginBlocks(exactOrigins);
+    const successVariant = HV_JSON | HV_CORS_SIMPLE | (rateEnabled ? HV_RATE_ACTIVE : 0);
+    prewarmOriginHeaders(responseBuilders.responseHeaders, exactOrigins, successVariant);
+  }
   const result = new BakedIngressResult;
   const ctx = {
     requestIdHeader: null,
@@ -8205,7 +8501,8 @@ function createIngressHandler(options = {}, runtime = {}) {
     const requestIdStr = needRequestIdString ? decoder.decode(ridBytes) : "";
     ctx.requestIdHeader = emitRequestIdHeader ? requestIdStr : null;
     ctx.origin = headerPlan.cors ? req.headers.get("origin") : null;
-    runtime.onRequest?.(req, requestIdStr, ip);
+    if (hasOnRequest)
+      runtime.onRequest?.(req, requestIdStr, ip);
     const ipStr = ip ?? EMPTY_IP;
     let handle = null;
     responseState.currentHandle = null;
@@ -8223,10 +8520,7 @@ function createIngressHandler(options = {}, runtime = {}) {
             written = bunFFI.ingressHandleComponents(ingressPtr, methodKind, packUrl, packIp ?? "", ridBytes, packedHeaders, body, handle.buffer);
             ffiFailures = 0;
           } catch {
-            ffiFailures++;
-            if (ffiFailures >= MAX_FFI_FAILURES) {
-              ffiDisabled = true;
-            }
+            noteFfiFailure();
             const input = inputPacker.packParts(methodKind, packUrl, packIp, ridBytes, packedHeaders);
             written = handler.handleRequestPacked(input, body, handle.buffer);
           }
@@ -8236,18 +8530,14 @@ function createIngressHandler(options = {}, runtime = {}) {
             written = bunFFI.ingressHandlePacked(ingressPtr, input, body, handle.buffer);
             ffiFailures = 0;
           } catch {
-            ffiFailures++;
-            if (ffiFailures >= MAX_FFI_FAILURES) {
-              ffiDisabled = true;
-            }
+            noteFfiFailure();
             written = handler.handleRequestPacked(input, body, handle.buffer);
           }
         } else {
           const input = inputPacker.packParts(methodKind, packUrl, packIp, ridBytes, packedHeaders);
           written = handler.handleRequestPacked(input, body, handle.buffer);
         }
-        const used = handle.buffer.subarray(0, written);
-        result.refresh(used, body ?? EMPTY_BODY5, viewForArrayBuffer(used.buffer, used.byteOffset));
+        result.refresh(handle.buffer, body ?? EMPTY_BODY5, viewForArrayBuffer(handle.buffer.buffer, handle.buffer.byteOffset), written);
       } catch (err) {
         result.setInternalError();
         const error = err instanceof Error ? err : new Error(String(err));
@@ -8263,17 +8553,20 @@ function createIngressHandler(options = {}, runtime = {}) {
       try {
         const out = fn(result, ctx);
         assertSyncCallback(out, "createIngressHandler().run()");
-        const status = out instanceof Response ? out.status : safeTerminalStatus(result);
-        runtime.onResponse?.(req, result, status, requestIdStr);
-        if (logger) {
-          logger.request({
-            requestId: requestIdStr,
-            method: req.method,
-            path: pathForLog(req),
-            status,
-            durationMs: Math.round((performance.now() - startedAt) * 1000) / 1000,
-            ip: ipStr
-          });
+        if (hasOnResponse || logger !== null) {
+          const status = out instanceof Response ? out.status : safeTerminalStatus(result);
+          if (hasOnResponse)
+            runtime.onResponse?.(req, result, status, requestIdStr);
+          if (logger !== null) {
+            logger.request({
+              requestId: requestIdStr,
+              method: req.method,
+              path: pathForLog(req),
+              status,
+              durationMs: Math.round((performance.now() - startedAt) * 1000) / 1000,
+              ip: ipStr
+            });
+          }
         }
         return out;
       } finally {
@@ -8587,6 +8880,10 @@ function createIngressRouter(options) {
     }
     const handler = createIngressHandler(spec.options ?? {}, runtime);
     compiled[path] = handler;
+    const routeLimit = spec.options?.rateLimit?.limit;
+    if (typeof routeLimit === "number" && routeLimit > 0 && routeLimit !== RATE_LIMIT_U32_MAX && options.getIp === undefined) {
+      warnRateLimitWithoutGetIp();
+    }
     if (spec.responder) {
       bakedRoutes[path] = {
         responder: {
@@ -8811,6 +9108,22 @@ function createIngress(options = {}) {
     }
   };
 }
+// src/native/ingress-binding.ts
+init_ffi();
+var cached2;
+function getIngressBinding() {
+  if (cached2 !== undefined)
+    return cached2;
+  const ffi = getBunFFI();
+  const addonPath = ffiAddonPath();
+  cached2 = ffi && addonPath ? {
+    addonPath,
+    ingressHandleComponents: ffi.ingressHandleComponents,
+    ingressHandlePacked: ffi.ingressHandlePacked,
+    ingressLayout: ffi.ingressLayout
+  } : null;
+  return cached2;
+}
 // src/loader/index.ts
 init_rust_ffi();
 init_bytes();
@@ -10228,6 +10541,7 @@ function createTaskRuntime(options = {}) {
     queueMicrotask(drainNow);
   }
   function submit(op, args, runOptions) {
+    ensureDoorbell();
     const id = nextId++;
     return new Promise((resolve, reject) => {
       inflight.set(id, { out: null, keep: null, resolve, reject });
@@ -10249,6 +10563,7 @@ function createTaskRuntime(options = {}) {
     });
   }
   function submitInto(op, args, output, runOptions) {
+    ensureDoorbell();
     const id = nextId++;
     return new Promise((resolve, reject) => {
       inflight.set(id, { out: output, keep: null, resolve, reject });
@@ -10270,6 +10585,7 @@ function createTaskRuntime(options = {}) {
     });
   }
   function submitSlice(op, hdr, data, runOptions) {
+    ensureDoorbell();
     const id = nextId++;
     return new Promise((resolve, reject) => {
       inflight.set(id, { out: null, keep: data, resolve, reject });
@@ -10291,11 +10607,16 @@ function createTaskRuntime(options = {}) {
     });
   }
   const { JSCallback } = __require("bun:ffi");
-  const cb = new JSCallback(() => {
-    drainNow();
-  }, { args: [], returns: "void", threadsafe: true });
-  doorbell = cb;
-  ffi.taskSetDoorbell(Number(cb.ptr));
+  function ensureDoorbell() {
+    if (doorbell !== null)
+      return;
+    const cb = new JSCallback(() => {
+      drainNow();
+    }, { args: [], returns: "void", threadsafe: true });
+    doorbell = cb;
+    ffi.taskSetDoorbell(Number(cb.ptr));
+  }
+  ensureDoorbell();
   schedule();
   const runtime = {
     gzipDecompress(data, runOptions) {
@@ -10339,6 +10660,7 @@ function createTaskRuntime(options = {}) {
         deferred.reject(cancelledError());
       }
       inflight.clear();
+      ffi.taskSetDoorbell(0);
       ffi.taskShutdown();
       release();
       doorbell?.close();
@@ -10475,6 +10797,7 @@ export {
   errorMessage,
   fallbackHandler,
   generateRequestId,
+  getIngressBinding,
   gracefulShutdown,
   gzipCompressUpperBound,
   headHandler,