puppeteer-bidi 0.0.1.beta10 → 0.0.1

data/lib/puppeteer/bidi/browser_context.rb

@@ -1,11 +1,37 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
+require "uri"
+
 module Puppeteer
   module Bidi
     # BrowserContext represents an isolated browsing session
     # This is a high-level wrapper around Core::UserContext
     class BrowserContext
+      # Maps web permission names to protocol permission names
+      # Based on Puppeteer's WEB_PERMISSION_TO_PROTOCOL_PERMISSION
+      WEB_PERMISSION_TO_PROTOCOL_PERMISSION = {
+        'accelerometer' => 'sensors',
+        'ambient-light-sensor' => 'sensors',
+        'background-sync' => 'backgroundSync',
+        'camera' => 'videoCapture',
+        'clipboard-read' => 'clipboardReadWrite',
+        'clipboard-sanitized-write' => 'clipboardSanitizedWrite',
+        'clipboard-write' => 'clipboardReadWrite',
+        'geolocation' => 'geolocation',
+        'gyroscope' => 'sensors',
+        'idle-detection' => 'idleDetection',
+        'keyboard-lock' => 'keyboardLock',
+        'magnetometer' => 'sensors',
+        'microphone' => 'audioCapture',
+        'midi' => 'midi',
+        'midi-sysex' => 'midiSysex',
+        'notifications' => 'notifications',
+        'payment-handler' => 'paymentHandler',
+        'persistent-storage' => 'durableStorage',
+        'pointer-lock' => 'pointerLock'
+      }.freeze
+
       attr_reader :user_context #: Core::UserContext
       attr_reader :browser #: Browser
 
@@ -28,7 +54,103 @@ module Puppeteer
       # Get all pages in this context
       # @rbs return: Array[Page] -- All pages
       def pages
-        @pages.values
+        return [] if closed?
+
+        # Return pages for all currently-known top-level browsing contexts.
+        # Browsing contexts are synchronized from `browsingContext.getTree` during browser/session
+        # initialization, so this allows `Puppeteer::Bidi.connect` to expose existing pages without
+        # requiring an explicit enumeration via `wait_for_target`.
+        @user_context.browsing_contexts
+                     .reject(&:disposed?)
+                     .map { |browsing_context| page_for(browsing_context) }
+      end
+
+      # Get all cookies in this context.
+      # @rbs return: Array[Hash[String, untyped]] -- Cookies
+      def cookies
+        return [] if closed?
+
+        @user_context.get_cookies.wait.map do |cookie|
+          CookieUtils.bidi_to_puppeteer_cookie(cookie, return_composite_partition_key: true)
+        end
+      end
+
+      # Set cookies in this context.
+      # @rbs *cookies: Array[Hash[String, untyped]] -- Cookie data
+      # @rbs **cookie: untyped -- Single cookie via keyword arguments
+      # @rbs return: void
+      def set_cookie(*cookies, **cookie)
+        cookies = cookies.dup
+        cookies << cookie unless cookie.empty?
+
+        tasks = cookies.map do |raw_cookie|
+          normalized_cookie = CookieUtils.normalize_cookie_input(raw_cookie)
+          domain = normalized_cookie["domain"]
+          if domain.nil?
+            raise ArgumentError, "At least one of the url and domain needs to be specified"
+          end
+
+          bidi_cookie = {
+            "domain" => domain,
+            "name" => normalized_cookie["name"],
+            "value" => { "type" => "string", "value" => normalized_cookie["value"] },
+          }
+          bidi_cookie["path"] = normalized_cookie["path"] if normalized_cookie.key?("path")
+          bidi_cookie["httpOnly"] = normalized_cookie["httpOnly"] if normalized_cookie.key?("httpOnly")
+          bidi_cookie["secure"] = normalized_cookie["secure"] if normalized_cookie.key?("secure")
+          if normalized_cookie.key?("sameSite") && !normalized_cookie["sameSite"].nil?
+            bidi_cookie["sameSite"] = CookieUtils.convert_cookies_same_site_cdp_to_bidi(
+              normalized_cookie["sameSite"]
+            )
+          end
+          expiry = CookieUtils.convert_cookies_expiry_cdp_to_bidi(normalized_cookie["expires"])
+          bidi_cookie["expiry"] = expiry unless expiry.nil?
+          bidi_cookie.merge!(CookieUtils.cdp_specific_cookie_properties_from_puppeteer_to_bidi(
+                               normalized_cookie,
+                               "sameParty",
+                               "sourceScheme",
+                               "priority",
+                               "url"
+                             ))
+
+          partition_key = CookieUtils.convert_cookies_partition_key_from_puppeteer_to_bidi(
+            normalized_cookie["partitionKey"]
+          )
+          -> { @user_context.set_cookie(bidi_cookie, source_origin: partition_key).wait }
+        end
+
+        AsyncUtils.await_promise_all(*tasks) unless tasks.empty?
+      end
+
+      # Delete cookies in this context.
+      # @rbs *cookies: Array[Hash[String, untyped]] -- Cookies to delete
+      # @rbs **cookie: untyped -- Single cookie via keyword arguments
+      # @rbs return: void
+      def delete_cookie(*cookies, **cookie)
+        cookies = cookies.dup
+        cookies << cookie unless cookie.empty?
+
+        delete_candidates = cookies.map do |raw_cookie|
+          normalized_cookie = CookieUtils.normalize_cookie_input(raw_cookie)
+          normalized_cookie.merge("expires" => 1)
+        end
+
+        set_cookie(*delete_candidates)
+      end
+
+      # Delete cookies matching the provided filters.
+      # @rbs *filters: Array[Hash[String, untyped]] -- Cookie filters
+      # @rbs **filter: untyped -- Single cookie filter via keyword arguments
+      # @rbs return: void
+      def delete_matching_cookies(*filters, **filter)
+        filters = filters.dup
+        filters << filter unless filter.empty?
+
+        cookies_to_delete = cookies.select do |cookie|
+          filters.any? { |filter_entry| cookie_matches_filter?(cookie, filter_entry) }
+        end
+
+        delete_cookie(*cookies_to_delete)
       end
 
       # Get or create a Page for the given browsing context
@@ -46,10 +168,37 @@ module Puppeteer
         end
       end
 
+      # Override permissions for an origin
+      # @rbs origin: String -- Origin URL
+      # @rbs permissions: Array[String] -- Permissions to grant
+      # @rbs return: void
+      def override_permissions(origin, permissions)
+        # Validate all permissions are known
+        permissions_set = permissions.map do |permission|
+          protocol_permission = WEB_PERMISSION_TO_PROTOCOL_PERMISSION[permission.to_s]
+          raise ArgumentError, "Unknown permission: #{permission}" unless protocol_permission
+
+          permission.to_s
+        end.to_set
+
+        # Set each permission
+        WEB_PERMISSION_TO_PROTOCOL_PERMISSION.each_key do |permission|
+          state = permissions_set.include?(permission) ? 'granted' : 'denied'
+          begin
+            @user_context.set_permissions(origin, { name: permission }, state).wait
+          rescue StandardError
+            # Ignore errors for denied permissions (some may not be supported)
+            raise if permissions_set.include?(permission)
+          end
+        end
+      end
+
       # Close the browser context
       # @rbs return: void
       def close
-        @user_context.close
+        return if closed?
+
+        @user_context.remove.wait
       end
 
       # Check if context is closed
@@ -57,6 +206,40 @@ module Puppeteer
       def closed?
         @user_context.disposed?
       end
+
+      private
+
+      def cookie_matches_filter?(cookie, raw_filter)
+        filter = CookieUtils.normalize_cookie_input(raw_filter)
+        return false unless filter["name"] == cookie["name"]
+
+        return true if filter.key?("domain") && filter["domain"] == cookie["domain"]
+        return true if filter.key?("path") && filter["path"] == cookie["path"]
+
+        if filter.key?("partitionKey") && cookie.key?("partitionKey")
+          cookie_partition = cookie["partitionKey"]
+          unless cookie_partition.is_a?(Hash)
+            raise Error, "Unexpected string partition key"
+          end
+
+          filter_partition = filter["partitionKey"]
+          if filter_partition.is_a?(String)
+            return true if filter_partition == cookie_partition["sourceOrigin"]
+          elsif filter_partition.is_a?(Hash)
+            normalized_partition = CookieUtils.normalize_cookie_input(filter_partition)
+            return true if normalized_partition["sourceOrigin"] == cookie_partition["sourceOrigin"]
+          end
+        end
+
+        if filter.key?("url")
+          url = URI.parse(filter["url"])
+          url_path = url.path
+          url_path = "/" if url_path.nil? || url_path.empty?
+          return true if url.host == cookie["domain"] && url_path == cookie["path"]
+        end
+
+        true
+      end
     end
   end
 end

data/lib/puppeteer/bidi/connection.rb

@@ -68,14 +68,21 @@ module Puppeteer
               puts "[BiDi] Response for #{method}: #{result.inspect}"
             end
 
-            if result['error']
-              # BiDi error format: { "error": "error_type", "message": "detailed message", ... }
-              error_type = result['error']
+            unless result.is_a?(Hash) && result.key?('type')
+              raise ProtocolError, "Protocol Error. Message is not in BiDi protocol format: #{result.inspect}"
+            end
+
+            case result['type']
+            when 'success'
+              result['result']
+            when 'error'
+              # BiDi error format: { "type": "error", "error": "...", "message": "...", ... }
+              error_type = result['error'] || 'unknown error'
               error_message = result['message'] || error_type
               raise ProtocolError, "BiDi error (#{method}): #{error_message}"
+            else
+              raise ProtocolError, "Protocol Error. Unexpected BiDi message type: #{result['type'].inspect}"
             end
-
-            result['result']
           rescue Async::TimeoutError
             @pending_commands.delete(id)
             raise TimeoutError, "Timeout waiting for #{method} (#{timeout}ms)"
@@ -182,6 +189,10 @@ module Puppeteer
         method = message['method']
         params = message['params'] || {}
 
+        if ENV['DEBUG_BIDI_COMMAND']
+          puts "[BiDi] Event #{method}: #{params.inspect}"
+        end
+
         listeners = @event_listeners[method]
         return unless listeners
 

data/lib/puppeteer/bidi/cookie_utils.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Puppeteer
+  module Bidi
+    module CookieUtils
+      CDP_SPECIFIC_PREFIX = "goog:"
+
+      # @rbs cookie: Hash[untyped, untyped] -- Cookie with symbol or string keys
+      # @rbs return: Hash[String, untyped] -- Cookie with string keys
+      def self.normalize_cookie_input(cookie)
+        cookie.transform_keys(&:to_s)
+      end
+
+      # @rbs bidi_cookie: Hash[String, untyped] -- BiDi cookie
+      # @rbs return_composite_partition_key: bool -- Whether to return composite partition key
+      # @rbs return: Hash[String, untyped] -- Puppeteer cookie
+      def self.bidi_to_puppeteer_cookie(bidi_cookie, return_composite_partition_key: false)
+        value = bidi_cookie["value"]
+        value = value["value"] if value.is_a?(Hash)
+
+        expiry = bidi_cookie["expiry"]
+        partition_key = bidi_cookie["#{CDP_SPECIFIC_PREFIX}partitionKey"]
+
+        cookie = {
+          "name" => bidi_cookie["name"],
+          "value" => value,
+          "domain" => bidi_cookie["domain"],
+          "path" => bidi_cookie["path"],
+          "size" => bidi_cookie["size"],
+          "httpOnly" => bidi_cookie["httpOnly"],
+          "secure" => bidi_cookie["secure"],
+          "sameSite" => convert_cookies_same_site_bidi_to_cdp(bidi_cookie["sameSite"]),
+          "expires" => expiry.nil? ? -1 : expiry,
+          "session" => expiry.nil? || expiry <= 0,
+        }.compact
+
+        cookie.merge!(cdp_specific_cookie_properties_from_bidi(bidi_cookie, "sameParty", "sourceScheme",
+                                                              "partitionKeyOpaque", "priority"))
+        cookie.merge!(partition_key_from_bidi(partition_key, return_composite_partition_key))
+
+        cookie
+      end
+
+      # @rbs same_site: String? -- BiDi SameSite value
+      # @rbs return: String -- Puppeteer SameSite
+      def self.convert_cookies_same_site_bidi_to_cdp(same_site)
+        case same_site
+        when "strict"
+          "Strict"
+        when "lax"
+          "Lax"
+        else
+          "None"
+        end
+      end
+
+      # @rbs same_site: String? -- Puppeteer SameSite
+      # @rbs return: String? -- BiDi SameSite
+      def self.convert_cookies_same_site_cdp_to_bidi(same_site)
+        case same_site
+        when "Strict"
+          "strict"
+        when "Lax"
+          "lax"
+        when "None"
+          "none"
+        else
+          nil
+        end
+      end
+
+      # @rbs expiry: Numeric? -- Cookie expiry
+      # @rbs return: Numeric? -- BiDi expiry
+      def self.convert_cookies_expiry_cdp_to_bidi(expiry)
+        return nil if expiry.nil? || expiry == -1
+
+        expiry
+      end
+
+      # @rbs partition_key: String | Hash[String, untyped] | Hash[Symbol, untyped] | nil -- Partition key
+      # @rbs return: String? -- BiDi partition key
+      def self.convert_cookies_partition_key_from_puppeteer_to_bidi(partition_key)
+        return partition_key if partition_key.nil? || partition_key.is_a?(String)
+
+        normalized = normalize_cookie_input(partition_key)
+        if normalized["hasCrossSiteAncestor"]
+          raise UnsupportedOperationError, "WebDriver BiDi does not support `hasCrossSiteAncestor` yet."
+        end
+
+        normalized["sourceOrigin"]
+      end
+
+      # @rbs cookie: Hash[String, untyped] -- Cookie data
+      # @rbs *property_names: Array[String] -- Cookie property names
+      # @rbs return: Hash[String, untyped] -- CDP-specific properties with goog: prefix
+      def self.cdp_specific_cookie_properties_from_puppeteer_to_bidi(cookie, *property_names)
+        property_names.each_with_object({}) do |property, result|
+          next unless cookie.key?(property)
+
+          value = cookie[property]
+          next if value.nil?
+
+          result["#{CDP_SPECIFIC_PREFIX}#{property}"] = value
+        end
+      end
+
+      # @rbs cookie: Hash[String, untyped] -- BiDi cookie data
+      # @rbs *property_names: Array[String] -- Cookie property names
+      # @rbs return: Hash[String, untyped] -- CDP-specific properties
+      def self.cdp_specific_cookie_properties_from_bidi(cookie, *property_names)
+        property_names.each_with_object({}) do |property, result|
+          key = "#{CDP_SPECIFIC_PREFIX}#{property}"
+          next unless cookie.key?(key)
+
+          result[property] = cookie[key]
+        end
+      end
+
+      # @rbs cookie: Hash[String, untyped] -- Puppeteer cookie
+      # @rbs normalized_url: URI::Generic -- URL to match
+      # @rbs return: bool -- Whether cookie matches URL
+      def self.test_url_match_cookie(cookie, normalized_url)
+        return false unless test_url_match_cookie_hostname(cookie, normalized_url)
+
+        test_url_match_cookie_path(cookie, normalized_url)
+      end
+
+      # @rbs cookie: Hash[String, untyped] -- Puppeteer cookie
+      # @rbs normalized_url: URI::Generic -- URL to match
+      # @rbs return: bool -- Whether hostname matches
+      def self.test_url_match_cookie_hostname(cookie, normalized_url)
+        url_hostname = normalized_url.host
+        return false if url_hostname.nil?
+
+        cookie_domain = cookie.fetch("domain", "").downcase
+        url_hostname = url_hostname.downcase
+
+        return true if cookie_domain == url_hostname
+
+        cookie_domain.start_with?(".") && url_hostname.end_with?(cookie_domain)
+      end
+
+      # @rbs cookie: Hash[String, untyped] -- Puppeteer cookie
+      # @rbs normalized_url: URI::Generic -- URL to match
+      # @rbs return: bool -- Whether path matches
+      def self.test_url_match_cookie_path(cookie, normalized_url)
+        uri_path = normalized_url.path
+        uri_path = "/" if uri_path.nil? || uri_path.empty?
+
+        cookie_path = cookie["path"] || "/"
+
+        return true if uri_path == cookie_path
+
+        if uri_path.start_with?(cookie_path)
+          return true if cookie_path.end_with?("/")
+          return true if uri_path[cookie_path.length] == "/"
+        end
+
+        false
+      end
+
+      # @rbs partition_key: untyped -- BiDi partition key
+      # @rbs return_composite_partition_key: bool -- Whether to return composite partition key
+      # @rbs return: Hash[String, untyped] -- Partition key info
+      def self.partition_key_from_bidi(partition_key, return_composite_partition_key)
+        return {} if partition_key.nil?
+
+        if partition_key.is_a?(String)
+          return { "partitionKey" => partition_key }
+        end
+
+        return {} unless partition_key.is_a?(Hash)
+
+        normalized = normalize_cookie_input(partition_key)
+        top_level_site = normalized["topLevelSite"]
+        has_cross_site_ancestor = normalized["hasCrossSiteAncestor"]
+
+        if return_composite_partition_key
+          return {
+            "partitionKey" => {
+              "sourceOrigin" => top_level_site,
+              "hasCrossSiteAncestor" => has_cross_site_ancestor.nil? ? false : has_cross_site_ancestor,
+            },
+          }
+        end
+
+        { "partitionKey" => top_level_site }
+      end
+    end
+  end
+end

data/lib/puppeteer/bidi/core/browsing_context.rb

@@ -35,6 +35,7 @@ module Puppeteer
           @children = {}
           @realms = {}
           @requests = {}
+          @inflight_request_ids = {}
           @navigation = nil
           @emulation_state = { javascript_enabled: true }
           @inflight_requests = 0
@@ -136,32 +137,32 @@ module Puppeteer
           raise BrowsingContextClosedError, @reason if closed?
 
           Async do
-            # Close all children first
-            children.each do |child|
-              begin
-                child.close(prompt_unload: prompt_unload).wait
-              rescue BrowsingContextClosedError
-                # Child already closed (e.g., iframe removed mid-operation)
-              end
+            # Close all children first (matches Puppeteer's Promise.all pattern)
+            child_close_tasks = children.map do |child|
+              -> { child.close(prompt_unload: prompt_unload).wait rescue BrowsingContextClosedError }
             end
+            AsyncUtils.promise_all(*child_close_tasks).wait unless child_close_tasks.empty?
+
+            # Ensure page.closed? is true and that the context has been removed
+            # from parent registries once this call returns.
+            # Register listener BEFORE sending close command to avoid race condition.
+            closed_promise = Async::Promise.new
+            closed_listener = ->(_) { closed_promise.resolve(nil) }
+            on(:closed, &closed_listener)
 
-            # Send close command
-            # Note: For non-top-level contexts (iframes), this may fail with
-            # "Browsing context ... is not top-level" error, which is expected
-            # because parent closure automatically closes children in BiDi protocol
             begin
               session.async_send_command('browsingContext.close', {
                 context: @id,
                 promptUnload: prompt_unload
-              })
+              }).wait
+              # Wait for :closed event to ensure state is updated
+              closed_promise.wait
             rescue Connection::ProtocolError => e
-              # Ignore "not top-level" errors for iframe contexts
-              # This happens when parent context closes and BiDi auto-closes children
-              # The error message is in format: "BiDi error (browsingContext.close): Browsing context with id ... is not top-level"
-              if ENV['DEBUG_BIDI_COMMAND']
-                puts "[BiDi] Close error for context #{@id}: #{e.message.inspect}"
-              end
+              # "is not top-level" error occurs for iframes - they are closed
+              # automatically when parent closes, so we don't need to wait
               raise unless e.message.include?('is not top-level')
+            ensure
+              off(:closed, &closed_listener)
             end
           end
         end
@@ -255,16 +256,37 @@ module Puppeteer
 
         # Add network intercept
         # @rbs **options: untyped -- Intercept options
-        # @rbs return: String -- Intercept ID
+        # @rbs return: Async::Task[String] -- Intercept ID
         def add_intercept(**options)
           raise BrowsingContextClosedError, @reason if closed?
-          result = session.async_send_command('network.addIntercept', options.merge(contexts: [@id]))
-          result['intercept']
+          Async do
+            result = session.async_send_command('network.addIntercept', options.merge(contexts: [@id])).wait
+            result['intercept']
+          end
+        end
+
+        # Set extra HTTP headers for this context
+        # @rbs headers: Hash[String, String] -- Extra headers
+        # @rbs return: Async::Task[untyped]
+        def set_extra_http_headers(headers)
+          raise BrowsingContextClosedError, @reason if closed?
+
+          normalized = headers.map do |key, value|
+            {
+              name: key.to_s.downcase,
+              value: { type: 'string', value: value.to_s }
+            }
+          end
+
+          session.async_send_command('network.setExtraHeaders', {
+            contexts: [@id],
+            headers: normalized
+          })
         end
 
         # Get cookies
         # @rbs **options: untyped -- Cookie filter options
-        # @rbs return: Array[Hash[String, untyped]] -- Cookies
+        # @rbs return: Async::Task[Array[Hash[String, untyped]]] -- Cookies
         def get_cookies(**options)
           raise BrowsingContextClosedError, @reason if closed?
           params = options.dup
@@ -272,8 +294,10 @@ module Puppeteer
             type: 'context',
             context: @id
           }
-          result = session.async_send_command('storage.getCookies', params)
-          result['cookies']
+          Async do
+            result = session.async_send_command('storage.getCookies', params).wait
+            result['cookies']
+          end
         end
 
         # Set a cookie
@@ -292,17 +316,21 @@ module Puppeteer
 
         # Delete cookies
         # @rbs *cookie_filters: Hash[String, untyped] -- Cookie filters
-        # @rbs return: void
+        # @rbs return: Async::Task[untyped]
         def delete_cookie(*cookie_filters)
           raise BrowsingContextClosedError, @reason if closed?
-          cookie_filters.each do |filter|
-            session.async_send_command('storage.deleteCookies', {
-              filter: filter,
-              partition: {
-                type: 'context',
-                context: @id
-              }
-            })
+          Async do
+            tasks = cookie_filters.map do |filter|
+              session.async_send_command('storage.deleteCookies', {
+                filter: filter,
+                partition: {
+                  type: 'context',
+                  context: @id
+                }
+              })
+            end
+
+            AsyncUtils.promise_all(*tasks).wait unless tasks.empty?
           end
         end
 
@@ -311,7 +339,7 @@ module Puppeteer
         # @rbs return: Async::Task[untyped]
         def set_geolocation_override(**options)
           raise BrowsingContextClosedError, @reason if closed?
-          raise 'Missing coordinates' unless options[:coordinates]
+          raise 'Missing coordinates' unless options.key?(:coordinates)
 
           session.async_send_command('emulation.setGeolocationOverride', {
             coordinates: options[:coordinates],
@@ -319,6 +347,18 @@ module Puppeteer
           })
         end
 
+        # Set user agent override
+        # @rbs user_agent: String? -- User agent string or nil to restore original
+        # @rbs return: Async::Task[void]
+        def set_user_agent(user_agent)
+          raise BrowsingContextClosedError, @reason if closed?
+
+          session.async_send_command("emulation.setUserAgentOverride", {
+            userAgent: user_agent,
+            contexts: [@id]
+          })
+        end
+
         # Set timezone override
         # @rbs timezone_id: String? -- Timezone ID
         # @rbs return: Async::Task[untyped]
@@ -542,13 +582,16 @@ module Puppeteer
           session.on('network.beforeRequestSent') do |event|
             next unless event['context'] == @id
 
-            request_id = event['request']['request']
+            request_id = event.dig('request', 'request')
             next if @requests.key?(request_id)
 
-            @requests[request_id] = true
+            request = Request.from(self, event)
+            @requests[request_id] = request
+            emit(:request, { request: request })
 
             # Increment inflight requests counter
             @inflight_mutex.synchronize do
+              @inflight_request_ids[request_id] = true
               @inflight_requests += 1
               emit(:inflight_changed, { inflight: @inflight_requests })
             end
@@ -557,8 +600,8 @@ module Puppeteer
           session.on('network.responseCompleted') do |event|
             next unless event['context'] == @id
 
-            request_id = event['request']['request']
-            next unless @requests.delete(request_id)
+            request_id = event.dig('request', 'request')
+            next unless @inflight_request_ids.delete(request_id)
 
             # Decrement inflight requests counter
             @inflight_mutex.synchronize do
@@ -570,8 +613,8 @@ module Puppeteer
           session.on('network.fetchError') do |event|
             next unless event['context'] == @id
 
-            request_id = event['request']['request']
-            next unless @requests.delete(request_id)
+            request_id = event.dig('request', 'request')
+            next unless @inflight_request_ids.delete(request_id)
 
             # Decrement inflight requests counter
             @inflight_mutex.synchronize do

data/lib/puppeteer/bidi/core/realm.rb

@@ -44,6 +44,9 @@ module Puppeteer
         def call_function(function_declaration, await_promise, **options)
           raise RealmDestroyedError, @reason if disposed?
 
+          options = options.dup
+          options[:userActivation] = true unless options.key?(:userActivation) || options.key?("userActivation")
+
           # Note: In Puppeteer, returnByValue controls serialization, not awaitPromise
           # awaitPromise controls whether to wait for promises
           # For BiDi, we use 'root' ownership by default to keep handles alive
@@ -67,6 +70,9 @@ module Puppeteer
         def evaluate(expression, await_promise, **options)
           raise RealmDestroyedError, @reason if disposed?
 
+          options = options.dup
+          options[:userActivation] = true unless options.key?(:userActivation) || options.key?("userActivation")
+
           # Use 'root' ownership by default to keep handles alive
           params = {
             expression: expression,