Major Feature Parity Update

.credo.exs

@@ -103,7 +103,8 @@
         {Credo.Check.Readability.ModuleNames, []},
         {Credo.Check.Readability.ParenthesesInCondition, []},
         {Credo.Check.Readability.ParenthesesOnZeroArityDefs, []},
-        {Credo.Check.Readability.PredicateFunctionNames, []},
+        # Disabled: is_* functions match Playwright's JavaScript API for consistency
+        {Credo.Check.Readability.PredicateFunctionNames, false},
         {Credo.Check.Readability.PreferImplicitTry, []},
         {Credo.Check.Readability.RedundantBlankLines, []},
         {Credo.Check.Readability.Semicolons, []},

.github/workflows/ci.yml

@@ -18,8 +18,8 @@ jobs:
     - name: Set up Elixir
       uses: erlef/setup-beam@v1
       with:
-        elixir-version: '1.16.2'
-        otp-version: '26.2.5'
+        elixir-version: '1.18.4'
+        otp-version: '27.3.4.6'
     - name: Install Elixir dependencies
       run: mix deps.get
     - name: Install Playwright dependencies (e.g., browsers)

.gitignore

@@ -38,4 +38,5 @@ playwright-*.tar
 .doctor.out
 .vscode
 *.iml
-/.idea/
+/.idea/
+.claude/

.mise.toml

@@ -0,0 +1,4 @@
+[tools]
+elixir = "1.18.4-otp-27"
+erlang = "27.3.4.6"
+nodejs = "22.21.1"

lib/playwright.ex

@@ -48,9 +48,9 @@ defmodule Playwright do
   | key/name  | typ   |             | description |
   | ----------| ----- | ----------- | ----------- |
   | `client`  | param | `client()`  | The type of client (browser) to launch. |
-  | `options` | param | `options()` | `Playwright.SDK.Config.connect_options()` |
+  | `options` | param | `options()` | Connection options (see Config module) |
   """
-  @spec launch(client(), Config.connect_options() | map()) :: {:ok, Playwright.Browser.t()}
+  @spec connect(client(), map()) :: {:ok, Playwright.Browser.t()}
   def connect(client, options \\ %{}) do
     options = Map.merge(Config.connect_options(), options)
     {:ok, session} = new_session(Playwright.SDK.Transport.WebSocket, options)
@@ -70,9 +70,9 @@ defmodule Playwright do
   | key/name  | typ   |             | description |
   | ----------| ----- | ----------- | ----------- |
   | `client`  | param | `client()`  | The type of client (browser) to launch. |
-  | `options` | param | `options()` | `Playwright.SDK.Config.launch_options()` |
+  | `options` | param | `options()` | Launch options (see Config module) |
   """
-  @spec launch(client(), Config.launch_options() | map()) :: {:ok, Playwright.Browser.t()}
+  @spec launch(client(), map()) :: {:ok, Playwright.Browser.t()}
   def launch(client, options \\ %{}) do
     options = Map.merge(Config.launch_options(), options)
     {:ok, session} = new_session(Playwright.SDK.Transport.Driver, options)

lib/playwright/api_request_context.ex

@@ -41,7 +41,7 @@ defmodule Playwright.APIRequestContext do
   # @spec patch(t(), binary(), options()) :: APIResponse.t()
   # def patch(context, url, options \\ %{})
 
-  @spec post(t(), binary(), fetch_options()) :: Playwright.APIResponse.t()
+  @spec post(t(), binary(), fetch_options()) :: struct()
   def post(%APIRequestContext{session: session} = context, url, options \\ %{}) do
     Channel.post(
       session,
@@ -64,7 +64,7 @@ defmodule Playwright.APIRequestContext do
   # def storage_state(context, options \\ %{})
 
   # TODO: move to `APIResponse.body`, probably.
-  @spec body(t(), Playwright.APIResponse.t()) :: any()
+  @spec body(t(), struct()) :: any()
   def body(%APIRequestContext{session: session} = context, response) do
     Channel.post(session, {:guid, context.guid}, :fetch_response_body, %{
       fetchUid: response.fetchUid

lib/playwright/artifact.ex

@@ -0,0 +1,64 @@
+defmodule Playwright.Artifact do
+  @moduledoc false
+  use Playwright.SDK.ChannelOwner
+
+  @doc """
+  Returns the path to the downloaded file after it has finished downloading.
+  """
+  @spec path_after_finished(t()) :: binary() | {:error, term()}
+  def path_after_finished(%__MODULE__{session: session} = artifact) do
+    case Channel.post(session, {:guid, artifact.guid}, :path_after_finished) do
+      %{value: path} -> path
+      path when is_binary(path) -> path
+      {:error, _} = error -> error
+    end
+  end
+
+  @doc """
+  Saves the artifact to the specified path.
+  """
+  @spec save_as(t(), binary()) :: :ok | {:error, term()}
+  def save_as(%__MODULE__{session: session} = artifact, path) do
+    case Channel.post(session, {:guid, artifact.guid}, :save_as, %{path: path}) do
+      {:ok, _} -> :ok
+      :ok -> :ok
+      {:error, _} = error -> error
+    end
+  end
+
+  @doc """
+  Returns the error message if the artifact failed to download, nil otherwise.
+  """
+  @spec failure(t()) :: binary() | nil | {:error, term()}
+  def failure(%__MODULE__{session: session} = artifact) do
+    case Channel.post(session, {:guid, artifact.guid}, :failure) do
+      %{error: error} -> error
+      %{} -> nil
+      {:error, _} = error -> error
+    end
+  end
+
+  @doc """
+  Cancels the download.
+  """
+  @spec cancel(t()) :: :ok | {:error, term()}
+  def cancel(%__MODULE__{session: session} = artifact) do
+    case Channel.post(session, {:guid, artifact.guid}, :cancel) do
+      {:ok, _} -> :ok
+      :ok -> :ok
+      {:error, _} = error -> error
+    end
+  end
+
+  @doc """
+  Deletes the downloaded file.
+  """
+  @spec delete(t()) :: :ok | {:error, term()}
+  def delete(%__MODULE__{session: session} = artifact) do
+    case Channel.post(session, {:guid, artifact.guid}, :delete) do
+      {:ok, _} -> :ok
+      :ok -> :ok
+      {:error, _} = error -> error
+    end
+  end
+end

lib/playwright/browser.ex

@@ -21,7 +21,7 @@ defmodule Playwright.Browser do
     - `:version`
   """
   use Playwright.SDK.ChannelOwner
-  alias Playwright.{Browser, BrowserContext, Page}
+  alias Playwright.{Browser, BrowserContext, BrowserType, CDPSession, Page}
   alias Playwright.SDK.{Channel, ChannelOwner, Extra}
 
   @property :name
@@ -44,8 +44,32 @@ defmodule Playwright.Browser do
   # API
   # ---------------------------------------------------------------------------
 
-  # @spec browser_type(t()) :: BrowserType.t()
-  # def browser_type(browser)
+  @doc """
+  Returns the BrowserType that was used to launch this browser.
+
+  ## Returns
+
+  - `BrowserType.t()`
+  """
+  @spec browser_type(t()) :: BrowserType.t()
+  def browser_type(%Browser{parent: parent}), do: parent
+
+  @doc """
+  Returns whether the browser is still connected.
+
+  Returns `false` after the browser has been closed.
+
+  ## Returns
+
+  - `boolean()`
+  """
+  @spec is_connected(t()) :: boolean()
+  def is_connected(%Browser{session: session, guid: guid}) do
+    case Channel.find(session, {:guid, guid}, %{timeout: 100}) do
+      %Browser{} -> true
+      {:error, _} -> false
+    end
+  end
 
   @doc """
   Closes the browser.
@@ -94,9 +118,6 @@ defmodule Playwright.Browser do
     Channel.list(browser.session, {:guid, browser.guid}, "BrowserContext")
   end
 
-  # @spec is_connected(BrowserContext.t()) :: boolean()
-  # def is_connected(browser)
-
   # @spec new_browser_cdp_session(BrowserContext.t()) :: Playwright.CDPSession.t()
   # def new_browser_cdp_session(browser)
 
@@ -146,33 +167,118 @@ defmodule Playwright.Browser do
   This is a convenience API function that should only be used for single-page
   scenarios and short snippets. Production code and testing frameworks should
   explicitly create via `Playwright.Browser.new_context/2` followed by
-  `Playwright.BrowserContext.new_page/2`, given the new context, to manage
+  `Playwright.BrowserContext.new_page/1`, given the new context, to manage
   resource lifecycles.
   """
-  @spec new_page(t(), options()) :: Page.t()
+  @spec new_page(t(), options()) :: {:ok, Page.t()} | {:error, term()}
   def new_page(browser, options \\ %{})
 
   def new_page(%Browser{session: session} = browser, options) do
-    context = new_context(browser, options)
-    page = BrowserContext.new_page(context)
+    with context when is_struct(context) <- new_context(browser, options),
+         page when is_struct(page) <- BrowserContext.new_page(context) do
+      # establish co-dependency
+      Channel.patch(session, {:guid, context.guid}, %{owner_page: page})
+      Channel.patch(session, {:guid, page.guid}, %{owned_context: context})
+      {:ok, page}
+    end
+  end
+
+  # ---
+
+  @doc """
+  Start tracing for Chromium browser.
+
+  Records a trace that can be viewed in Chrome DevTools or Playwright Trace Viewer.
+
+  ## Arguments
+
+  | key/name       | type          | description                              |
+  | -------------- | ------------- | ---------------------------------------- |
+  | `page`         | `Page.t()`    | Optional page to trace (default: all)    |
+  | `:screenshots` | `boolean()`   | Capture screenshots during trace         |
+  | `:categories`  | `[binary()]`  | Trace categories to record               |
+
+  ## Returns
 
-    # TODO: handle the following, for `page`:
-    # ** (KeyError) key :guid not found in: {:error, %Playwright.Channel.Error{message: "Target closed"}}
+  - `:ok`
 
-    # establish co-dependency
-    Channel.patch(session, {:guid, context.guid}, %{owner_page: page})
-    Channel.patch(session, {:guid, page.guid}, %{owned_context: context})
+  ## Example
+
+      Browser.start_tracing(browser)
+      # ... perform actions ...
+      trace = Browser.stop_tracing(browser)
+      File.write!("trace.json", trace)
+
+  ## Note
+
+  Only supported on Chromium browsers.
+  """
+  @spec start_tracing(t(), Page.t() | nil, options()) :: :ok
+  def start_tracing(%Browser{session: session, guid: guid}, page \\ nil, options \\ %{}) do
+    params = %{}
+    params = if page, do: Map.put(params, :page, %{guid: page.guid}), else: params
+    params = if options[:screenshots], do: Map.put(params, :screenshots, options[:screenshots]), else: params
+    params = if options[:categories], do: Map.put(params, :categories, options[:categories]), else: params
+
+    Channel.post(session, {:guid, guid}, :start_tracing, params)
+    :ok
   end
 
-  # ---
+  @doc """
+  Stop tracing and return the trace data.
+
+  Returns the trace data as binary which can be saved to a file.
+
+  ## Returns
+
+  - `binary()` - Trace data (JSON format, save as .json file)
+
+  ## Example
 
-  # test_chromium_tracing.py
-  # @spec start_tracing(t(), Page.t(), options()) :: :ok
-  # def start_tracing(browser, page \\ nil, options \\ %{})
+      Browser.start_tracing(browser, page, %{screenshots: true})
+      Page.goto(page, "https://example.com")
+      trace = Browser.stop_tracing(browser)
+      File.write!("trace.json", trace)
+  """
+  @spec stop_tracing(t()) :: binary()
+  def stop_tracing(%Browser{session: session, guid: guid}) do
+    artifact =
+      case Channel.post(session, {:guid, guid}, :stop_tracing, %{}) do
+        %{artifact: %{guid: artifact_guid}} ->
+          Channel.find(session, {:guid, artifact_guid})
+
+        %Playwright.Artifact{} = art ->
+          art
+      end
+
+    # Save to temp file, read contents, then clean up
+    temp_path = Path.join(System.tmp_dir!(), "pw_trace_#{:erlang.unique_integer([:positive])}.json")
+    Playwright.Artifact.save_as(artifact, temp_path)
+    data = File.read!(temp_path)
+    File.rm(temp_path)
+    Playwright.Artifact.delete(artifact)
+    data
+  end
 
-  # test_chromium_tracing.py
-  # @spec stop_tracing(t()) :: binary()
-  # def stop_tracing(browser)
+  @doc """
+  Creates a new CDP session attached to the browser.
+
+  This is Chromium-specific.
+
+  ## Returns
+
+  - `CDPSession.t()`
+
+  ## Example
+
+      session = Browser.new_browser_cdp_session(browser)
+      # Use CDP commands...
+      CDPSession.detach(session)
+  """
+  @spec new_browser_cdp_session(t()) :: CDPSession.t()
+  def new_browser_cdp_session(%Browser{session: session, guid: guid}) do
+    Channel.post(session, {:guid, guid}, "newBrowserCDPSession")
+  end
 
   # @spec version(BrowserContext.t()) :: binary
   # def version(browser)