httpcloak 1.6.1-beta.3 → 1.6.5

package/lib/index.js

@@ -31,7 +31,13 @@ class HTTPCloakError extends Error {
  *   const session = new httpcloak.Session({ preset: httpcloak.Preset.FIREFOX_133 });
  */
 const Preset = {
-  // Chrome 145 (latest)
+  // Chrome 146 (latest)
+  CHROME_146: "chrome-146",
+  CHROME_146_WINDOWS: "chrome-146-windows",
+  CHROME_146_LINUX: "chrome-146-linux",
+  CHROME_146_MACOS: "chrome-146-macos",
+
+  // Chrome 145
   CHROME_145: "chrome-145",
   CHROME_145_WINDOWS: "chrome-145-windows",
   CHROME_145_LINUX: "chrome-145-linux",
@@ -59,9 +65,11 @@ const Preset = {
   CHROME_143_IOS: "chrome-143-ios",
   CHROME_144_IOS: "chrome-144-ios",
   CHROME_145_IOS: "chrome-145-ios",
+  CHROME_146_IOS: "chrome-146-ios",
   CHROME_143_ANDROID: "chrome-143-android",
   CHROME_144_ANDROID: "chrome-144-android",
   CHROME_145_ANDROID: "chrome-145-android",
+  CHROME_146_ANDROID: "chrome-146-android",
 
   // Firefox
   FIREFOX_133: "firefox-133",
@@ -75,9 +83,11 @@ const Preset = {
   IOS_CHROME_143: "chrome-143-ios",
   IOS_CHROME_144: "chrome-144-ios",
   IOS_CHROME_145: "chrome-145-ios",
+  IOS_CHROME_146: "chrome-146-ios",
   ANDROID_CHROME_143: "chrome-143-android",
   ANDROID_CHROME_144: "chrome-144-android",
   ANDROID_CHROME_145: "chrome-145-android",
+  ANDROID_CHROME_146: "chrome-146-android",
   IOS_SAFARI_17: "safari-17-ios",
   IOS_SAFARI_18: "safari-18-ios",
 
@@ -87,12 +97,13 @@ const Preset = {
    */
   all() {
     return [
+      this.CHROME_146, this.CHROME_146_WINDOWS, this.CHROME_146_LINUX, this.CHROME_146_MACOS,
       this.CHROME_145, this.CHROME_145_WINDOWS, this.CHROME_145_LINUX, this.CHROME_145_MACOS,
       this.CHROME_144, this.CHROME_144_WINDOWS, this.CHROME_144_LINUX, this.CHROME_144_MACOS,
       this.CHROME_143, this.CHROME_143_WINDOWS, this.CHROME_143_LINUX, this.CHROME_143_MACOS,
       this.CHROME_141, this.CHROME_133,
-      this.CHROME_145_IOS, this.CHROME_144_IOS, this.CHROME_143_IOS,
-      this.CHROME_145_ANDROID, this.CHROME_144_ANDROID, this.CHROME_143_ANDROID,
+      this.CHROME_146_IOS, this.CHROME_145_IOS, this.CHROME_144_IOS, this.CHROME_143_IOS,
+      this.CHROME_146_ANDROID, this.CHROME_145_ANDROID, this.CHROME_144_ANDROID, this.CHROME_143_ANDROID,
       this.FIREFOX_133,
       this.SAFARI_18, this.SAFARI_17_IOS, this.SAFARI_18_IOS,
     ];
@@ -205,11 +216,28 @@ class Response {
    * @param {Object} data - Response data from native library
    * @param {number} [elapsed=0] - Elapsed time in milliseconds
    */
-  constructor(data, elapsed = 0) {
+  constructor(data, elapsed = 0, rawBody = null) {
     this.statusCode = data.status_code || 0;
     this.headers = data.headers || {};
-    this._body = Buffer.from(data.body || "", "utf8");
-    this._text = data.body || "";
+    if (rawBody !== null) {
+      // Raw-path: body arrived as binary bytes alongside metadata JSON
+      // (httpcloak_*_raw + response_finalize). No base64 round trip — fastest
+      // and loss-free for PDFs/images/etc.
+      this._body = rawBody;
+      this._text = rawBody.toString("utf8"); // best-effort text view
+    } else {
+      // JSON path: body is a string inside the JSON blob. Non-UTF-8 bodies
+      // arrive base64-encoded (Go side since 98e4228). Valid UTF-8 passes
+      // through as plain text.
+      const bodyStr = data.body || "";
+      if (data.body_encoding === "base64") {
+        this._body = Buffer.from(bodyStr, "base64");
+        this._text = this._body.toString("utf8");
+      } else {
+        this._body = Buffer.from(bodyStr, "utf8");
+        this._text = bodyStr;
+      }
+    }
     this.finalUrl = data.final_url || "";
     this.protocol = data.protocol || "";
     this.elapsed = elapsed; // milliseconds
@@ -776,25 +804,37 @@ function getLib() {
     const libPath = getLibPath();
     nativeLibHandle = koffi.load(libPath);
 
-    // Use str for string returns - koffi handles the string copy automatically
-    // Note: The C strings allocated by Go are not freed, but Go's GC handles them
+    // Declare the free function first so we can hand it to koffi.disposable.
+    // httpcloak_free_string is NULL-safe on the Go side (no-op on nil).
+    const httpcloakFreeString = nativeLibHandle.func("httpcloak_free_string", "void", ["void*"]);
+
+    // Named disposable type derived from "str": koffi decodes the C string
+    // into a JS string AND then calls httpcloakFreeString on the original
+    // malloc'd pointer. Every function below that returned plain "str"
+    // previously leaked that malloc (issue #48: customers reported ~48MB/h
+    // RSS growth in sustained production traffic). Using HeapStr closes the
+    // leak without any call-site changes.
+    const HeapStr = koffi.disposable("HeapStr", "str", httpcloakFreeString);
+
     lib = {
       httpcloak_session_new: nativeLibHandle.func("httpcloak_session_new", "int64", ["str"]),
       httpcloak_session_free: nativeLibHandle.func("httpcloak_session_free", "void", ["int64"]),
       httpcloak_session_refresh: nativeLibHandle.func("httpcloak_session_refresh", "void", ["int64"]),
-      httpcloak_session_refresh_protocol: nativeLibHandle.func("httpcloak_session_refresh_protocol", "str", ["int64", "str"]),
-      httpcloak_session_warmup: nativeLibHandle.func("httpcloak_session_warmup", "str", ["int64", "str", "int64"]),
+      httpcloak_session_refresh_protocol: nativeLibHandle.func("httpcloak_session_refresh_protocol", HeapStr, ["int64", "str"]),
+      httpcloak_session_warmup: nativeLibHandle.func("httpcloak_session_warmup", HeapStr, ["int64", "str", "int64"]),
       httpcloak_session_fork: nativeLibHandle.func("httpcloak_session_fork", "int64", ["int64"]),
-      httpcloak_get: nativeLibHandle.func("httpcloak_get", "str", ["int64", "str", "str"]),
-      httpcloak_post: nativeLibHandle.func("httpcloak_post", "str", ["int64", "str", "str", "str"]),
-      httpcloak_request: nativeLibHandle.func("httpcloak_request", "str", ["int64", "str"]),
-      httpcloak_get_cookies: nativeLibHandle.func("httpcloak_get_cookies", "str", ["int64"]),
-      httpcloak_set_cookie: nativeLibHandle.func("httpcloak_set_cookie", "void", ["int64", "str", "str"]),
-      httpcloak_free_string: nativeLibHandle.func("httpcloak_free_string", "void", ["void*"]),
-      httpcloak_version: nativeLibHandle.func("httpcloak_version", "str", []),
-      httpcloak_available_presets: nativeLibHandle.func("httpcloak_available_presets", "str", []),
-      httpcloak_set_ech_dns_servers: nativeLibHandle.func("httpcloak_set_ech_dns_servers", "str", ["str"]),
-      httpcloak_get_ech_dns_servers: nativeLibHandle.func("httpcloak_get_ech_dns_servers", "str", []),
+      httpcloak_get: nativeLibHandle.func("httpcloak_get", HeapStr, ["int64", "str", "str"]),
+      httpcloak_post: nativeLibHandle.func("httpcloak_post", HeapStr, ["int64", "str", "str", "str"]),
+      httpcloak_request: nativeLibHandle.func("httpcloak_request", HeapStr, ["int64", "str"]),
+      httpcloak_get_cookies: nativeLibHandle.func("httpcloak_get_cookies", HeapStr, ["int64"]),
+      httpcloak_set_cookie: nativeLibHandle.func("httpcloak_set_cookie", "void", ["int64", "str"]),
+      httpcloak_delete_cookie: nativeLibHandle.func("httpcloak_delete_cookie", "void", ["int64", "str", "str"]),
+      httpcloak_clear_cookies: nativeLibHandle.func("httpcloak_clear_cookies", "void", ["int64"]),
+      httpcloak_free_string: httpcloakFreeString,
+      httpcloak_version: nativeLibHandle.func("httpcloak_version", HeapStr, []),
+      httpcloak_available_presets: nativeLibHandle.func("httpcloak_available_presets", HeapStr, []),
+      httpcloak_set_ech_dns_servers: nativeLibHandle.func("httpcloak_set_ech_dns_servers", HeapStr, ["str"]),
+      httpcloak_get_ech_dns_servers: nativeLibHandle.func("httpcloak_get_ech_dns_servers", HeapStr, []),
       // Async functions
       httpcloak_register_callback: nativeLibHandle.func("httpcloak_register_callback", "int64", [koffi.pointer(AsyncCallbackProto)]),
       httpcloak_unregister_callback: nativeLibHandle.func("httpcloak_unregister_callback", "void", ["int64"]),
@@ -805,41 +845,41 @@ function getLib() {
       httpcloak_stream_get: nativeLibHandle.func("httpcloak_stream_get", "int64", ["int64", "str", "str"]),
       httpcloak_stream_post: nativeLibHandle.func("httpcloak_stream_post", "int64", ["int64", "str", "str", "str"]),
       httpcloak_stream_request: nativeLibHandle.func("httpcloak_stream_request", "int64", ["int64", "str"]),
-      httpcloak_stream_get_metadata: nativeLibHandle.func("httpcloak_stream_get_metadata", "str", ["int64"]),
-      httpcloak_stream_read: nativeLibHandle.func("httpcloak_stream_read", "str", ["int64", "int64"]),
+      httpcloak_stream_get_metadata: nativeLibHandle.func("httpcloak_stream_get_metadata", HeapStr, ["int64"]),
+      httpcloak_stream_read: nativeLibHandle.func("httpcloak_stream_read", HeapStr, ["int64", "int64"]),
       httpcloak_stream_close: nativeLibHandle.func("httpcloak_stream_close", "void", ["int64"]),
       // Raw response functions for fast-path (zero-copy)
       httpcloak_get_raw: nativeLibHandle.func("httpcloak_get_raw", "int64", ["int64", "str", "str"]),
       httpcloak_post_raw: nativeLibHandle.func("httpcloak_post_raw", "int64", ["int64", "str", "void*", "int", "str"]),
       httpcloak_request_raw: nativeLibHandle.func("httpcloak_request_raw", "int64", ["int64", "str", "void*", "int"]),
-      httpcloak_response_get_metadata: nativeLibHandle.func("httpcloak_response_get_metadata", "str", ["int64"]),
+      httpcloak_response_get_metadata: nativeLibHandle.func("httpcloak_response_get_metadata", HeapStr, ["int64"]),
       httpcloak_response_get_body_len: nativeLibHandle.func("httpcloak_response_get_body_len", "int", ["int64"]),
       httpcloak_response_copy_body_to: nativeLibHandle.func("httpcloak_response_copy_body_to", "int", ["int64", "void*", "int"]),
       httpcloak_response_free: nativeLibHandle.func("httpcloak_response_free", "void", ["int64"]),
       // Combined finalize function (copy + metadata + free in one call)
-      httpcloak_response_finalize: nativeLibHandle.func("httpcloak_response_finalize", "str", ["int64", "void*", "int"]),
+      httpcloak_response_finalize: nativeLibHandle.func("httpcloak_response_finalize", HeapStr, ["int64", "void*", "int"]),
       // Session persistence functions
-      httpcloak_session_save: nativeLibHandle.func("httpcloak_session_save", "str", ["int64", "str"]),
+      httpcloak_session_save: nativeLibHandle.func("httpcloak_session_save", HeapStr, ["int64", "str"]),
       httpcloak_session_load: nativeLibHandle.func("httpcloak_session_load", "int64", ["str"]),
-      httpcloak_session_marshal: nativeLibHandle.func("httpcloak_session_marshal", "str", ["int64"]),
+      httpcloak_session_marshal: nativeLibHandle.func("httpcloak_session_marshal", HeapStr, ["int64"]),
       httpcloak_session_unmarshal: nativeLibHandle.func("httpcloak_session_unmarshal", "int64", ["str"]),
       // Proxy management functions
-      httpcloak_session_set_proxy: nativeLibHandle.func("httpcloak_session_set_proxy", "str", ["int64", "str"]),
-      httpcloak_session_set_tcp_proxy: nativeLibHandle.func("httpcloak_session_set_tcp_proxy", "str", ["int64", "str"]),
-      httpcloak_session_set_udp_proxy: nativeLibHandle.func("httpcloak_session_set_udp_proxy", "str", ["int64", "str"]),
-      httpcloak_session_get_proxy: nativeLibHandle.func("httpcloak_session_get_proxy", "str", ["int64"]),
-      httpcloak_session_get_tcp_proxy: nativeLibHandle.func("httpcloak_session_get_tcp_proxy", "str", ["int64"]),
-      httpcloak_session_get_udp_proxy: nativeLibHandle.func("httpcloak_session_get_udp_proxy", "str", ["int64"]),
+      httpcloak_session_set_proxy: nativeLibHandle.func("httpcloak_session_set_proxy", HeapStr, ["int64", "str"]),
+      httpcloak_session_set_tcp_proxy: nativeLibHandle.func("httpcloak_session_set_tcp_proxy", HeapStr, ["int64", "str"]),
+      httpcloak_session_set_udp_proxy: nativeLibHandle.func("httpcloak_session_set_udp_proxy", HeapStr, ["int64", "str"]),
+      httpcloak_session_get_proxy: nativeLibHandle.func("httpcloak_session_get_proxy", HeapStr, ["int64"]),
+      httpcloak_session_get_tcp_proxy: nativeLibHandle.func("httpcloak_session_get_tcp_proxy", HeapStr, ["int64"]),
+      httpcloak_session_get_udp_proxy: nativeLibHandle.func("httpcloak_session_get_udp_proxy", HeapStr, ["int64"]),
       // Header order customization
-      httpcloak_session_set_header_order: nativeLibHandle.func("httpcloak_session_set_header_order", "str", ["int64", "str"]),
-      httpcloak_session_get_header_order: nativeLibHandle.func("httpcloak_session_get_header_order", "str", ["int64"]),
+      httpcloak_session_set_header_order: nativeLibHandle.func("httpcloak_session_set_header_order", HeapStr, ["int64", "str"]),
+      httpcloak_session_get_header_order: nativeLibHandle.func("httpcloak_session_get_header_order", HeapStr, ["int64"]),
       // Local proxy functions
       httpcloak_local_proxy_start: nativeLibHandle.func("httpcloak_local_proxy_start", "int64", ["str"]),
       httpcloak_local_proxy_stop: nativeLibHandle.func("httpcloak_local_proxy_stop", "void", ["int64"]),
       httpcloak_local_proxy_get_port: nativeLibHandle.func("httpcloak_local_proxy_get_port", "int", ["int64"]),
       httpcloak_local_proxy_is_running: nativeLibHandle.func("httpcloak_local_proxy_is_running", "int", ["int64"]),
-      httpcloak_local_proxy_get_stats: nativeLibHandle.func("httpcloak_local_proxy_get_stats", "str", ["int64"]),
-      httpcloak_local_proxy_register_session: nativeLibHandle.func("httpcloak_local_proxy_register_session", "str", ["int64", "str", "int64"]),
+      httpcloak_local_proxy_get_stats: nativeLibHandle.func("httpcloak_local_proxy_get_stats", HeapStr, ["int64"]),
+      httpcloak_local_proxy_register_session: nativeLibHandle.func("httpcloak_local_proxy_register_session", HeapStr, ["int64", "str", "int64"]),
       httpcloak_local_proxy_unregister_session: nativeLibHandle.func("httpcloak_local_proxy_unregister_session", "int", ["int64", "str"]),
       // Session cache callbacks
       httpcloak_set_session_cache_callbacks: nativeLibHandle.func("httpcloak_set_session_cache_callbacks", "void", [
@@ -863,6 +903,23 @@ function getLib() {
       // Async cache result functions (called by JS to provide results to Go)
       httpcloak_async_cache_get_result: nativeLibHandle.func("httpcloak_async_cache_get_result", "void", ["int64", "str"]),
       httpcloak_async_cache_op_result: nativeLibHandle.func("httpcloak_async_cache_op_result", "void", ["int64", "int"]),
+      // Custom preset loading (void* returns for manual free)
+      httpcloak_preset_load_file: nativeLibHandle.func("httpcloak_preset_load_file", "void*", ["str"]),
+      httpcloak_preset_load_json: nativeLibHandle.func("httpcloak_preset_load_json", "void*", ["str"]),
+      httpcloak_preset_unregister: nativeLibHandle.func("httpcloak_preset_unregister", "void", ["str"]),
+      // Describe uses HeapStr (issue #48 leak-safe disposable) — koffi
+      // auto-frees the malloc'd C string after decode.
+      httpcloak_describe_preset: nativeLibHandle.func("httpcloak_describe_preset", HeapStr, ["str"]),
+      // Preset pool functions (void* returns for manual free)
+      httpcloak_pool_load_file: nativeLibHandle.func("httpcloak_pool_load_file", "void*", ["str"]),
+      httpcloak_pool_load_json: nativeLibHandle.func("httpcloak_pool_load_json", "void*", ["str"]),
+      httpcloak_pool_pick: nativeLibHandle.func("httpcloak_pool_pick", "void*", ["int64"]),
+      httpcloak_pool_random: nativeLibHandle.func("httpcloak_pool_random", "void*", ["int64"]),
+      httpcloak_pool_next: nativeLibHandle.func("httpcloak_pool_next", "void*", ["int64"]),
+      httpcloak_pool_get: nativeLibHandle.func("httpcloak_pool_get", "void*", ["int64", "int64"]),
+      httpcloak_pool_size: nativeLibHandle.func("httpcloak_pool_size", "int64", ["int64"]),
+      httpcloak_pool_name: nativeLibHandle.func("httpcloak_pool_name", "void*", ["int64"]),
+      httpcloak_pool_free: nativeLibHandle.func("httpcloak_pool_free", "void", ["int64"]),
     };
   }
   return lib;
@@ -1016,6 +1073,38 @@ function parseResponse(resultPtr, elapsed = 0) {
   return new Response(data, elapsed);
 }
 
+/**
+ * Parse a raw response handle returned by httpcloak_*_raw into a Response
+ * with a binary Buffer body. Avoids the base64 round trip used by the JSON
+ * path — binary bodies (PDFs, images, streams) land in memory once.
+ * @param {Object} lib - Native library binding
+ * @param {number|bigint} responseHandle
+ * @param {number} [elapsed=0] - Elapsed milliseconds
+ * @returns {Response}
+ */
+function parseRawResponse(lib, responseHandle, elapsed = 0) {
+  const bodyLen = lib.httpcloak_response_get_body_len(responseHandle);
+  if (bodyLen < 0) {
+    lib.httpcloak_response_free(responseHandle);
+    throw new HTTPCloakError("Failed to get response body length");
+  }
+
+  const buffer = Buffer.allocUnsafe(bodyLen);
+  // finalize() copies body into buffer, returns metadata JSON (no body), and
+  // frees the handle — a single FFI call instead of three.
+  const metadataStr = lib.httpcloak_response_finalize(responseHandle, buffer, bodyLen);
+  if (!metadataStr) {
+    throw new HTTPCloakError("Failed to finalize response");
+  }
+
+  const metadata = JSON.parse(metadataStr);
+  if (metadata.error) {
+    throw new HTTPCloakError(metadata.error);
+  }
+
+  return new Response(metadata, elapsed, buffer);
+}
+
 /**
  * Add query parameters to URL
  */
@@ -1162,7 +1251,7 @@ function version() {
 /**
  * Get available browser presets with their supported protocols.
  * Returns an object mapping preset names to their info:
- *   { "chrome-145": { protocols: ["h1", "h2", "h3"] }, ... }
+ *   { "chrome-146": { protocols: ["h1", "h2", "h3"] }, ... }
  */
 function availablePresets() {
   const nativeLib = getLib();
@@ -1228,7 +1317,7 @@ class Session {
   /**
    * Create a new session
    * @param {Object} options - Session options
-   * @param {string} [options.preset="chrome-145"] - Browser preset to use
+   * @param {string} [options.preset="chrome-146"] - Browser preset to use
    * @param {string} [options.proxy] - Proxy URL (e.g., "http://user:pass@host:port" or "socks5://host:port")
    * @param {string} [options.tcpProxy] - Proxy URL for TCP protocols (HTTP/1.1, HTTP/2) - use with udpProxy for split config
    * @param {string} [options.udpProxy] - Proxy URL for UDP protocols (HTTP/3 via MASQUE) - use with tcpProxy for split config
@@ -1237,8 +1326,8 @@ class Session {
    * @param {boolean} [options.verify=true] - SSL certificate verification
    * @param {boolean} [options.allowRedirects=true] - Follow redirects
    * @param {number} [options.maxRedirects=10] - Maximum number of redirects to follow
-   * @param {number} [options.retry=3] - Number of retries on failure (set to 0 to disable)
-   * @param {number[]} [options.retryOnStatus] - Status codes to retry on
+   * @param {number} [options.retry=0] - Number of retries on failure (default 0 = no retries; set positive to enable. Issue #57: prior default 3 silently retried POST/PUT/PATCH on 5xx, violating idempotency expectations)
+   * @param {number[]} [options.retryOnStatus] - Status codes to retry on (only consulted when retry > 0)
    * @param {number} [options.retryWaitMin=500] - Minimum wait time between retries in milliseconds
    * @param {number} [options.retryWaitMax=10000] - Maximum wait time between retries in milliseconds
    * @param {Array} [options.auth] - Default auth [username, password] for all requests
@@ -1249,7 +1338,7 @@ class Session {
    */
   constructor(options = {}) {
     const {
-      preset = "chrome-145",
+      preset = "chrome-146",
       proxy = null,
       tcpProxy = null,
       udpProxy = null,
@@ -1258,7 +1347,7 @@ class Session {
       verify = true,
       allowRedirects = true,
       maxRedirects = 10,
-      retry = 3,
+      retry = 0,
       retryOnStatus = null,
       retryWaitMin = 500,
       retryWaitMax = 10000,
@@ -1279,6 +1368,7 @@ class Session {
       tcpMss = null,
       tcpWindowSize = null,
       tcpWindowScale = null,
+      tcpDf = null,
     } = options;
 
     this._lib = getLib();
@@ -1366,6 +1456,9 @@ class Session {
     if (tcpWindowScale != null) {
       config.tcp_window_scale = tcpWindowScale;
     }
+    if (tcpDf != null) {
+      config.tcp_df = tcpDf;
+    }
 
     this._handle = this._lib.httpcloak_session_new(JSON.stringify(config));
 
@@ -1505,7 +1598,7 @@ class Session {
    * @returns {Response} Response object
    */
   getSync(url, options = {}) {
-    const { headers = null, params = null, cookies = null, auth = null } = options;
+    const { headers = null, params = null, cookies = null, auth = null, fetchMode = null } = options;
 
     url = addParamsToUrl(url, params);
     let mergedHeaders = this._mergeHeaders(headers);
@@ -1519,12 +1612,18 @@ class Session {
     if (mergedHeaders) {
       reqOptions.headers = mergedHeaders;
     }
+    if (fetchMode) {
+      reqOptions.fetch_mode = fetchMode;
+    }
     const optionsJson = Object.keys(reqOptions).length > 0 ? JSON.stringify(reqOptions) : null;
 
     const startTime = Date.now();
-    const result = this._lib.httpcloak_get(this._handle, url, optionsJson);
+    const responseHandle = this._lib.httpcloak_get_raw(this._handle, url, optionsJson);
     const elapsed = Date.now() - startTime;
-    return parseResponse(result, elapsed);
+    if (responseHandle < 0 || responseHandle === 0 || responseHandle === 0n) {
+      throw new HTTPCloakError("Request failed");
+    }
+    return parseRawResponse(this._lib, responseHandle, elapsed);
   }
 
   /**
@@ -1545,38 +1644,36 @@ class Session {
    * @returns {Response} Response object
    */
   postSync(url, options = {}) {
-    let { body = null, json = null, data = null, files = null, headers = null, params = null, cookies = null, auth = null } = options;
+    let { body = null, json = null, data = null, files = null, headers = null, params = null, cookies = null, auth = null, fetchMode = null } = options;
 
     url = addParamsToUrl(url, params);
     let mergedHeaders = this._mergeHeaders(headers);
 
-    // Handle multipart file upload
+    // Normalize body to a Buffer so the raw path can pass (ptr, len) without
+    // null-terminator truncation or utf8 mangling.
+    let bodyBuffer = null;
     if (files !== null) {
       const formData = (data !== null && typeof data === "object") ? data : null;
       const multipart = encodeMultipart(formData, files);
-      body = multipart.body.toString("latin1"); // Preserve binary data
+      bodyBuffer = multipart.body;
       mergedHeaders = mergedHeaders || {};
       mergedHeaders["Content-Type"] = multipart.contentType;
-    }
-    // Handle JSON body
-    else if (json !== null) {
-      body = JSON.stringify(json);
+    } else if (json !== null) {
+      bodyBuffer = Buffer.from(JSON.stringify(json), "utf8");
       mergedHeaders = mergedHeaders || {};
       if (!mergedHeaders["Content-Type"]) {
         mergedHeaders["Content-Type"] = "application/json";
       }
-    }
-    // Handle form data
-    else if (data !== null && typeof data === "object") {
-      body = new URLSearchParams(data).toString();
+    } else if (data !== null && typeof data === "object") {
+      bodyBuffer = Buffer.from(new URLSearchParams(data).toString(), "utf8");
       mergedHeaders = mergedHeaders || {};
       if (!mergedHeaders["Content-Type"]) {
         mergedHeaders["Content-Type"] = "application/x-www-form-urlencoded";
       }
-    }
-    // Handle Buffer body
-    else if (Buffer.isBuffer(body)) {
-      body = body.toString("utf8");
+    } else if (Buffer.isBuffer(body)) {
+      bodyBuffer = body;
+    } else if (typeof body === "string") {
+      bodyBuffer = Buffer.from(body, "utf8");
     }
 
     // Use request auth if provided, otherwise fall back to session auth
@@ -1589,12 +1686,21 @@ class Session {
     if (mergedHeaders) {
       reqOptions.headers = mergedHeaders;
     }
+    if (fetchMode) {
+      reqOptions.fetch_mode = fetchMode;
+    }
     const optionsJson = Object.keys(reqOptions).length > 0 ? JSON.stringify(reqOptions) : null;
 
+    const bodyPtr = bodyBuffer || Buffer.alloc(0);
+    const bodyLen = bodyBuffer ? bodyBuffer.length : 0;
+
     const startTime = Date.now();
-    const result = this._lib.httpcloak_post(this._handle, url, body, optionsJson);
+    const responseHandle = this._lib.httpcloak_post_raw(this._handle, url, bodyPtr, bodyLen, optionsJson);
     const elapsed = Date.now() - startTime;
-    return parseResponse(result, elapsed);
+    if (responseHandle < 0 || responseHandle === 0 || responseHandle === 0n) {
+      throw new HTTPCloakError("Request failed");
+    }
+    return parseRawResponse(this._lib, responseHandle, elapsed);
   }
 
   /**
@@ -1607,38 +1713,35 @@ class Session {
    * @returns {Response} Response object
    */
   requestSync(method, url, options = {}) {
-    let { body = null, json = null, data = null, files = null, headers = null, params = null, cookies = null, auth = null, timeout = null } = options;
+    let { body = null, json = null, data = null, files = null, headers = null, params = null, cookies = null, auth = null, timeout = null, fetchMode = null } = options;
 
     url = addParamsToUrl(url, params);
     let mergedHeaders = this._mergeHeaders(headers);
 
-    // Handle multipart file upload
+    // Normalize body to a Buffer so the raw path can pass (ptr, len).
+    let bodyBuffer = null;
     if (files !== null) {
       const formData = (data !== null && typeof data === "object") ? data : null;
       const multipart = encodeMultipart(formData, files);
-      body = multipart.body.toString("latin1"); // Preserve binary data
+      bodyBuffer = multipart.body;
       mergedHeaders = mergedHeaders || {};
       mergedHeaders["Content-Type"] = multipart.contentType;
-    }
-    // Handle JSON body
-    else if (json !== null) {
-      body = JSON.stringify(json);
+    } else if (json !== null) {
+      bodyBuffer = Buffer.from(JSON.stringify(json), "utf8");
       mergedHeaders = mergedHeaders || {};
       if (!mergedHeaders["Content-Type"]) {
         mergedHeaders["Content-Type"] = "application/json";
       }
-    }
-    // Handle form data
-    else if (data !== null && typeof data === "object") {
-      body = new URLSearchParams(data).toString();
+    } else if (data !== null && typeof data === "object") {
+      bodyBuffer = Buffer.from(new URLSearchParams(data).toString(), "utf8");
       mergedHeaders = mergedHeaders || {};
       if (!mergedHeaders["Content-Type"]) {
         mergedHeaders["Content-Type"] = "application/x-www-form-urlencoded";
       }
-    }
-    // Handle Buffer body
-    else if (Buffer.isBuffer(body)) {
-      body = body.toString("utf8");
+    } else if (Buffer.isBuffer(body)) {
+      bodyBuffer = body;
+    } else if (typeof body === "string") {
+      bodyBuffer = Buffer.from(body, "utf8");
     }
 
     // Use request auth if provided, otherwise fall back to session auth
@@ -1651,16 +1754,24 @@ class Session {
       url,
     };
     if (mergedHeaders) requestConfig.headers = mergedHeaders;
-    if (body) requestConfig.body = body;
     if (timeout) requestConfig.timeout = timeout;
+    if (fetchMode) requestConfig.fetch_mode = fetchMode;
+
+    const bodyPtr = bodyBuffer || Buffer.alloc(0);
+    const bodyLen = bodyBuffer ? bodyBuffer.length : 0;
 
     const startTime = Date.now();
-    const result = this._lib.httpcloak_request(
+    const responseHandle = this._lib.httpcloak_request_raw(
       this._handle,
-      JSON.stringify(requestConfig)
+      JSON.stringify(requestConfig),
+      bodyPtr,
+      bodyLen
     );
     const elapsed = Date.now() - startTime;
-    return parseResponse(result, elapsed);
+    if (responseHandle < 0 || responseHandle === 0 || responseHandle === 0n) {
+      throw new HTTPCloakError("Request failed");
+    }
+    return parseRawResponse(this._lib, responseHandle, elapsed);
   }
 
   // ===========================================================================
@@ -1675,7 +1786,7 @@ class Session {
    * @returns {Promise<Response>} Response object
    */
   get(url, options = {}) {
-    const { headers = null, params = null, cookies = null, auth = null } = options;
+    const { headers = null, params = null, cookies = null, auth = null, fetchMode = null, timeout = null } = options;
 
     url = addParamsToUrl(url, params);
     let mergedHeaders = this._mergeHeaders(headers);
@@ -1689,6 +1800,15 @@ class Session {
     if (mergedHeaders) {
       reqOptions.headers = mergedHeaders;
     }
+    if (fetchMode) {
+      reqOptions.fetch_mode = fetchMode;
+    }
+    if (timeout) {
+      // Public API: seconds (matches Session({ timeout }) and the
+      // existing request()/put()/delete()/etc. methods which forward to
+      // httpcloak_request_async — that path also uses time.Second).
+      reqOptions.timeout = timeout;
+    }
     const optionsJson = Object.keys(reqOptions).length > 0 ? JSON.stringify(reqOptions) : null;
 
     // Register async request with callback manager
@@ -1709,7 +1829,7 @@ class Session {
    * @returns {Promise<Response>} Response object
    */
   post(url, options = {}) {
-    let { body = null, json = null, data = null, files = null, headers = null, params = null, cookies = null, auth = null } = options;
+    let { body = null, json = null, data = null, files = null, headers = null, params = null, cookies = null, auth = null, fetchMode = null, timeout = null } = options;
 
     url = addParamsToUrl(url, params);
     let mergedHeaders = this._mergeHeaders(headers);
@@ -1753,6 +1873,13 @@ class Session {
     if (mergedHeaders) {
       reqOptions.headers = mergedHeaders;
     }
+    if (fetchMode) {
+      reqOptions.fetch_mode = fetchMode;
+    }
+    if (timeout) {
+      // Public API: seconds. clib post_async path enforces in seconds.
+      reqOptions.timeout = timeout;
+    }
     const optionsJson = Object.keys(reqOptions).length > 0 ? JSON.stringify(reqOptions) : null;
 
     // Register async request with callback manager
@@ -1774,7 +1901,7 @@ class Session {
    * @returns {Promise<Response>} Response object
    */
   request(method, url, options = {}) {
-    let { body = null, json = null, data = null, files = null, headers = null, params = null, cookies = null, auth = null, timeout = null } = options;
+    let { body = null, json = null, data = null, files = null, headers = null, params = null, cookies = null, auth = null, timeout = null, fetchMode = null } = options;
 
     url = addParamsToUrl(url, params);
     let mergedHeaders = this._mergeHeaders(headers);
@@ -1820,6 +1947,7 @@ class Session {
     if (mergedHeaders) requestConfig.headers = mergedHeaders;
     if (body) requestConfig.body = body;
     if (timeout) requestConfig.timeout = timeout;
+    if (fetchMode) requestConfig.fetch_mode = fetchMode;
 
     // Register async request with callback manager
     const manager = getAsyncManager();
@@ -1871,58 +1999,101 @@ class Session {
   // ===========================================================================
 
   /**
-   * Get all cookies from the session
-   * @returns {Object} Cookies as key-value pairs
+   * Get all cookies with full metadata (domain, path, expiry, flags).
+   * @returns {Cookie[]} Array of Cookie objects
    */
-  getCookies() {
+  getCookiesDetailed() {
     const resultPtr = this._lib.httpcloak_get_cookies(this._handle);
     const result = resultToString(resultPtr);
     if (result) {
-      return JSON.parse(result);
+      const parsed = JSON.parse(result);
+      return parsed.map(c => new Cookie(c));
     }
-    return {};
+    return [];
+  }
+
+  /**
+   * Get all cookies from the session with full metadata.
+   *
+   * Returns Cookie[] with domain/path/expiry/flags. For the older flat
+   * name->value object, build it yourself:
+   * `Object.fromEntries(session.getCookies().map(c => [c.name, c.value]))`.
+   * @returns {Cookie[]}
+   */
+  getCookies() {
+    return this.getCookiesDetailed();
   }
 
   /**
-   * Get a specific cookie by name
+   * Get a specific cookie by name with full metadata.
    * @param {string} name - Cookie name
-   * @returns {string|null} Cookie value or null if not found
+   * @returns {Cookie|null} Cookie object or null if not found
+   */
+  getCookieDetailed(name) {
+    const cookies = this.getCookiesDetailed();
+    return cookies.find(c => c.name === name) || null;
+  }
+
+  /**
+   * Get a specific cookie by name.
+   *
+   * Returns a Cookie object (with domain/path/expiry/flags) or null. For just
+   * the string value: `const c = session.getCookie('foo'); const v = c?.value`.
+   * @param {string} name - Cookie name
+   * @returns {Cookie|null}
    */
   getCookie(name) {
-    const cookies = this.getCookies();
-    return cookies[name] || null;
+    return this.getCookieDetailed(name);
   }
 
   /**
    * Set a cookie in the session
    * @param {string} name - Cookie name
    * @param {string} value - Cookie value
-   */
-  setCookie(name, value) {
-    this._lib.httpcloak_set_cookie(this._handle, name, value);
+   * @param {Object} [options] - Cookie options
+   * @param {string} [options.domain] - Cookie domain
+   * @param {string} [options.path] - Cookie path (default: "/")
+   * @param {boolean} [options.secure] - Secure flag
+   * @param {boolean} [options.httpOnly] - HttpOnly flag
+   * @param {string} [options.sameSite] - SameSite attribute (Strict, Lax, None)
+   * @param {number} [options.maxAge] - Max age in seconds (0 means not set)
+   * @param {string} [options.expires] - Expiration date (RFC1123 format)
+   */
+  setCookie(name, value, options = {}) {
+    const cookie = {
+      name,
+      value,
+      domain: options.domain || "",
+      path: options.path || "/",
+      secure: options.secure || false,
+      http_only: options.httpOnly || false,
+      same_site: options.sameSite || "",
+      max_age: options.maxAge || 0,
+      expires: options.expires || "",
+    };
+    this._lib.httpcloak_set_cookie(this._handle, JSON.stringify(cookie));
   }
 
   /**
    * Delete a specific cookie by name
    * @param {string} name - Cookie name to delete
+   * @param {string} [domain] - Domain to delete from (omit to delete from all domains)
    */
-  deleteCookie(name) {
-    // Set cookie to empty value - effectively deletes it
-    this._lib.httpcloak_set_cookie(this._handle, name, "");
+  deleteCookie(name, domain = "") {
+    this._lib.httpcloak_delete_cookie(this._handle, name, domain);
   }
 
   /**
    * Clear all cookies from the session
    */
   clearCookies() {
-    const cookies = this.getCookies();
-    for (const name of Object.keys(cookies)) {
-      this.deleteCookie(name);
-    }
+    this._lib.httpcloak_clear_cookies(this._handle);
   }
 
   /**
-   * Get cookies as a property
+   * Get cookies as a property.
+   * @deprecated This property will return Cookie[] with full metadata in a future release.
+   * @returns {Object} Cookies as key-value pairs
    */
   get cookies() {
     return this.getCookies();
@@ -2093,7 +2264,7 @@ class Session {
    * @param {string} path - Path to save the session file
    *
    * Example:
-   *   const session = new httpcloak.Session({ preset: "chrome-145" });
+   *   const session = new httpcloak.Session({ preset: "chrome-146" });
    *   await session.get("https://example.com");  // Acquire cookies
    *   session.save("session.json");
    *
@@ -2731,7 +2902,7 @@ let _defaultConfig = {};
 /**
  * Configure defaults for module-level functions
  * @param {Object} options - Configuration options
- * @param {string} [options.preset="chrome-145"] - Browser preset
+ * @param {string} [options.preset="chrome-146"] - Browser preset
  * @param {Object} [options.headers] - Default headers
  * @param {Array} [options.auth] - Default basic auth [username, password]
  * @param {string} [options.proxy] - Proxy URL
@@ -2740,12 +2911,12 @@ let _defaultConfig = {};
  * @param {boolean} [options.verify=true] - SSL certificate verification
  * @param {boolean} [options.allowRedirects=true] - Follow redirects
  * @param {number} [options.maxRedirects=10] - Maximum number of redirects to follow
- * @param {number} [options.retry=3] - Number of retries on failure (set to 0 to disable)
- * @param {number[]} [options.retryOnStatus] - Status codes to retry on
+ * @param {number} [options.retry=0] - Number of retries on failure (default 0 = no retries; set positive to enable. See issue #57)
+ * @param {number[]} [options.retryOnStatus] - Status codes to retry on (only consulted when retry > 0)
  */
 function configure(options = {}) {
   const {
-    preset = "chrome-145",
+    preset = "chrome-146",
     headers = null,
     auth = null,
     proxy = null,
@@ -2754,7 +2925,7 @@ function configure(options = {}) {
     verify = true,
     allowRedirects = true,
     maxRedirects = 10,
-    retry = 3,
+    retry = 0,
     retryOnStatus = null,
   } = options;
 
@@ -2803,14 +2974,14 @@ function configure(options = {}) {
  */
 function _getDefaultSession() {
   if (!_defaultSession) {
-    const preset = _defaultConfig.preset || "chrome-145";
+    const preset = _defaultConfig.preset || "chrome-146";
     const proxy = _defaultConfig.proxy || null;
     const timeout = _defaultConfig.timeout || 30;
     const httpVersion = _defaultConfig.httpVersion || "auto";
     const verify = _defaultConfig.verify !== undefined ? _defaultConfig.verify : true;
     const allowRedirects = _defaultConfig.allowRedirects !== undefined ? _defaultConfig.allowRedirects : true;
     const maxRedirects = _defaultConfig.maxRedirects || 10;
-    const retry = _defaultConfig.retry !== undefined ? _defaultConfig.retry : 3;
+    const retry = _defaultConfig.retry !== undefined ? _defaultConfig.retry : 0;
     const retryOnStatus = _defaultConfig.retryOnStatus || null;
     const headers = _defaultConfig.headers || {};
 
@@ -2906,7 +3077,7 @@ function request(method, url, options = {}) {
  * Without registration, cache callbacks will not be triggered for that session.
  *
  * @example
- * const proxy = new LocalProxy({ preset: "chrome-145", tlsOnly: true });
+ * const proxy = new LocalProxy({ preset: "chrome-146", tlsOnly: true });
  * console.log(`Proxy running on ${proxy.proxyUrl}`);
  *
  * // Use with any HTTP client pointing to the proxy
@@ -2935,7 +3106,7 @@ class LocalProxy {
    * Create and start a local HTTP proxy server.
    * @param {Object} options - Proxy configuration options
    * @param {number} [options.port=0] - Port to listen on (0 = auto-select)
-   * @param {string} [options.preset="chrome-145"] - Browser fingerprint preset
+   * @param {string} [options.preset="chrome-146"] - Browser fingerprint preset
    * @param {number} [options.timeout=30] - Request timeout in seconds
    * @param {number} [options.maxConnections=1000] - Maximum concurrent connections
    * @param {string} [options.tcpProxy] - Default upstream TCP proxy URL
@@ -2945,7 +3116,7 @@ class LocalProxy {
   constructor(options = {}) {
     const {
       port = 0,
-      preset = "chrome-145",
+      preset = "chrome-146",
       timeout = 30,
       maxConnections = 1000,
       tcpProxy = null,
@@ -3457,10 +3628,247 @@ function clearSessionCache() {
 }
 
 
+// --- String Memory Management for Preset/Pool Functions ---
+
+/**
+ * Read a C string from a void pointer and free the native memory.
+ * Returns null if the pointer is null/0.
+ * @param {*} ptr - Native void pointer
+ * @returns {string|null}
+ */
+function readAndFreeString(ptr) {
+  if (!ptr) return null;
+  const lib = getLib();
+  try {
+    return koffi.decode(ptr, "char", -1);
+  } finally {
+    lib.httpcloak_free_string(ptr);
+  }
+}
+
+// --- Custom Preset Loading ---
+
+/**
+ * Load a custom preset from a JSON file and register it.
+ * @param {string} filePath - Path to the preset JSON file
+ * @returns {string} The registered preset name
+ */
+function loadPreset(filePath) {
+  const lib = getLib();
+  const result = readAndFreeString(lib.httpcloak_preset_load_file(filePath));
+  if (!result) {
+    throw new HTTPCloakError("Failed to load preset from file");
+  }
+  const data = JSON.parse(result);
+  if (data.error) {
+    throw new HTTPCloakError(data.error);
+  }
+  return data.name;
+}
+
+/**
+ * Load a custom preset from a JSON string and register it.
+ * @param {string} jsonData - JSON string defining the preset
+ * @returns {string} The registered preset name
+ */
+function loadPresetFromJSON(jsonData) {
+  const lib = getLib();
+  const result = readAndFreeString(lib.httpcloak_preset_load_json(jsonData));
+  if (!result) {
+    throw new HTTPCloakError("Failed to load preset from JSON");
+  }
+  const data = JSON.parse(result);
+  if (data.error) {
+    throw new HTTPCloakError(data.error);
+  }
+  return data.name;
+}
+
+/**
+ * Unregister a custom preset by name.
+ * @param {string} name - The preset name to unregister
+ */
+function unregisterPreset(name) {
+  const lib = getLib();
+  lib.httpcloak_preset_unregister(name);
+}
+
+/**
+ * Return a fully-resolved JSON document for the given preset.
+ *
+ * The output flattens any inheritance chain and resolves H2/H3 defaults
+ * (Chrome unless the preset overrides) into explicit values, so the
+ * result is suitable for saving, editing, and reloading via
+ * loadPresetFromJSON. Two consecutive calls return byte-identical JSON.
+ *
+ * @param {string} name - The preset name (built-in or custom-registered).
+ * @returns {string} JSON string of the form {"version":1,"preset":{...}}.
+ * @throws {HTTPCloakError} If the preset is not registered or references
+ *   an unknown utls ClientHelloID.
+ */
+function describePreset(name) {
+  const lib = getLib();
+  const result = lib.httpcloak_describe_preset(name);
+  if (!result) {
+    throw new HTTPCloakError(`Failed to describe preset: ${name}`);
+  }
+  // The error envelope ({"error": "..."}) is also a valid JSON document.
+  // A successful describe always carries a top-level "preset" field, so
+  // distinguishing the two is straightforward.
+  let parsed;
+  try {
+    parsed = JSON.parse(result);
+  } catch (err) {
+    throw new HTTPCloakError(`Invalid describe_preset response: ${err.message}`);
+  }
+  if (parsed && parsed.error && !parsed.preset) {
+    throw new HTTPCloakError(parsed.error);
+  }
+  return result;
+}
+
+/**
+ * A pool of custom fingerprint presets for rotation.
+ *
+ * Pools load multiple presets from a single JSON file and provide
+ * round-robin or random selection. All presets are auto-registered
+ * on construction, so you can pass the returned name directly to
+ * Session({ preset: name }).
+ */
+class PresetPool {
+  /**
+   * Load a preset pool from a JSON file.
+   * @param {string} filePath - Path to the pool JSON file
+   */
+  constructor(filePath) {
+    this._lib = getLib();
+    const result = readAndFreeString(this._lib.httpcloak_pool_load_file(filePath));
+    if (!result) {
+      throw new HTTPCloakError(`Failed to load preset pool from file: ${filePath}`);
+    }
+    const data = JSON.parse(result);
+    if (data.error) {
+      throw new HTTPCloakError(data.error);
+    }
+    this._handle = BigInt(data.handle);
+  }
+
+  /**
+   * Load a preset pool from a JSON string.
+   * @param {string} jsonData - JSON string defining the pool
+   * @returns {PresetPool}
+   */
+  static fromJSON(jsonData) {
+    const pool = Object.create(PresetPool.prototype);
+    pool._lib = getLib();
+    const result = readAndFreeString(pool._lib.httpcloak_pool_load_json(jsonData));
+    if (!result) {
+      throw new HTTPCloakError("Failed to load preset pool from JSON");
+    }
+    const data = JSON.parse(result);
+    if (data.error) {
+      throw new HTTPCloakError(data.error);
+    }
+    pool._handle = BigInt(data.handle);
+    return pool;
+  }
+
+  /**
+   * Pick a preset using the pool's configured strategy.
+   * @returns {string} Preset name
+   */
+  pick() {
+    this._checkHandle();
+    return this._parsePoolResult(this._lib.httpcloak_pool_pick(this._handle));
+  }
+
+  /**
+   * Pick a random preset from the pool.
+   * @returns {string} Preset name
+   */
+  random() {
+    this._checkHandle();
+    return this._parsePoolResult(this._lib.httpcloak_pool_random(this._handle));
+  }
+
+  /**
+   * Pick the next preset in round-robin order.
+   * @returns {string} Preset name
+   */
+  next() {
+    this._checkHandle();
+    return this._parsePoolResult(this._lib.httpcloak_pool_next(this._handle));
+  }
+
+  /**
+   * Get a preset by index.
+   * @param {number} index - Zero-based index
+   * @returns {string} Preset name
+   */
+  get(index) {
+    this._checkHandle();
+    return this._parsePoolResult(this._lib.httpcloak_pool_get(this._handle, index));
+  }
+
+  /**
+   * Number of presets in the pool.
+   * @type {number}
+   */
+  get size() {
+    this._checkHandle();
+    const s = this._lib.httpcloak_pool_size(this._handle);
+    if (s < 0) {
+      throw new HTTPCloakError("Failed to get pool size");
+    }
+    return Number(s);
+  }
+
+  /**
+   * Name of the preset pool.
+   * @type {string}
+   */
+  get name() {
+    this._checkHandle();
+    return this._parsePoolResult(this._lib.httpcloak_pool_name(this._handle));
+  }
+
+  /**
+   * Free the pool handle and unregister all its presets.
+   */
+  close() {
+    if (this._handle && this._handle !== 0n && this._handle !== 0) {
+      this._lib.httpcloak_pool_free(this._handle);
+      this._handle = 0n;
+    }
+  }
+
+  _parsePoolResult(resultPtr) {
+    const result = readAndFreeString(resultPtr);
+    if (!result) {
+      throw new HTTPCloakError("No result from preset pool");
+    }
+    // Error responses are JSON with {"error":"..."}
+    if (result.startsWith("{")) {
+      const data = JSON.parse(result);
+      if (data.error) {
+        throw new HTTPCloakError(data.error);
+      }
+    }
+    return result;
+  }
+
+  _checkHandle() {
+    if (!this._handle || this._handle === 0n || this._handle === 0) {
+      throw new HTTPCloakError("PresetPool is closed");
+    }
+  }
+}
+
 module.exports = {
   // Classes
   Session,
   LocalProxy,
+  PresetPool,
   Response,
   FastResponse,
   StreamResponse,
@@ -3470,6 +3878,11 @@ module.exports = {
   SessionCacheBackend,
   // Presets
   Preset,
+  // Custom preset loading
+  loadPreset,
+  loadPresetFromJSON,
+  unregisterPreset,
+  describePreset,
   // Configuration
   configure,
   configureSessionCache,