browserctl 0.11.0 → 0.13.0

data/lib/browserctl/workflow.rb

@@ -1,21 +1,79 @@
 # frozen_string_literal: true
 
-require "timeout"
+require_relative "callable_definition"
 require_relative "client"
+require_relative "contextual_persistence"
 require_relative "errors"
 require_relative "flow_registry"
 require_relative "replay/context"
 require_relative "replay/fingerprint_matcher"
 require_relative "replay/snapshot_diff"
-require_relative "secret_resolvers"
-require_relative "session"
 
 module Browserctl
-  ParamDef = Struct.new(:name, :required, :secret, :default, :secret_ref, keyword_init: true)
+  # Workflow-file format version. Workflows are Ruby files; the schema gate
+  # is a top-of-file comment header:
+  #
+  #   # format_version: 1
+  #
+  # Unlike bundles and recordings, an unsupported or missing version on a
+  # workflow file is a *warning*, not a hard failure. Workflows are
+  # human-authored Ruby — the loader prefers to surface drift via stderr
+  # and let the file run, rather than block execution. See
+  # docs/reference/format-versions.md.
+  WORKFLOW_FORMAT_VERSION = 1
+  SUPPORTED_WORKFLOW_FORMAT_VERSIONS = [WORKFLOW_FORMAT_VERSION].freeze
+
+  # Matches a leading-line comment of the form `# format_version: <int>`.
+  # Tolerates leading whitespace inside the comment body and ignores the
+  # `# frozen_string_literal: true` magic comment that conventionally
+  # precedes it.
+  WORKFLOW_FORMAT_VERSION_HEADER = /^\s*#\s*format_version:\s*(\d+)\s*$/
+
+  # Parses the `# format_version: N` header from a workflow file's source.
+  # Scans only the contiguous leading comment block (and blank lines) so
+  # the header cannot be smuggled in mid-file. Returns the integer if
+  # present, or nil if the file has no version header.
+  def self.parse_workflow_format_version(source)
+    source.each_line do |line|
+      stripped = line.strip
+      next if stripped.empty?
+      break unless stripped.start_with?("#")
+
+      if (m = line.match(WORKFLOW_FORMAT_VERSION_HEADER))
+        return Integer(m[1])
+      end
+    end
+    nil
+  end
+
+  # Reads a workflow file and warns to stderr when the `format_version:`
+  # header is missing or declares an unsupported version. Always returns
+  # the parsed integer (or nil) — never raises. Callers should still
+  # `load` the file regardless.
+  def self.verify_workflow_format_version!(path)
+    source = File.read(path)
+    version = parse_workflow_format_version(source)
+
+    if version.nil?
+      warn "[browserctl] workflow #{path} is missing a `# format_version: N` header " \
+           "(expected #{WORKFLOW_FORMAT_VERSION}); proceeding anyway"
+    elsif !SUPPORTED_WORKFLOW_FORMAT_VERSIONS.include?(version)
+      warn "[browserctl] workflow #{path} format_version=#{version} is not supported " \
+           "(expected #{WORKFLOW_FORMAT_VERSION}); proceeding anyway"
+    end
+
+    version
+  end
+
+  # Back-compat aliases — exposed in the public surface (flow_wrapper specs,
+  # workflow specs reference these directly).
+  ParamDef = CallableDefinition::ParamDef
+  StepDef  = CallableDefinition::StepDef
   StepResult = Struct.new(:name, :ok, :error, keyword_init: true)
-  StepDef = Struct.new(:label, :block, :retry_count, :timeout, keyword_init: true)
 
   class WorkflowContext
+    include ContextualPersistence
+
     attr_reader :client, :replay_context, :params
 
     def initialize(params, client, replay_context: nil)
@@ -24,20 +82,6 @@ module Browserctl
       @replay_context = replay_context
     end
 
-    def store(key, value)
-      res = @client.store(key.to_s, value)
-      raise WorkflowError, res[:error] if res[:error]
-
-      value
-    end
-
-    def fetch(key)
-      res = @client.fetch(key.to_s)
-      raise WorkflowError, res[:error] if res[:error]
-
-      res[:value]
-    end
-
     def method_missing(name, *args)
       return @params[name] if @params.key?(name)
 
@@ -66,66 +110,6 @@ module Browserctl
       res
     end
 
-    def save_session(session_name, encrypt: false)
-      res = @client.session_save(session_name, encrypt: encrypt)
-      raise WorkflowError, res[:error] if res[:error]
-
-      res
-    end
-
-    # Persists the daemon's current cookies + storage as a .bctl bundle.
-    # Optional flow binding lets `load_state` auto-rotate when the bundle
-    # is detected as needing authentication.
-    def save_state(name, flow: nil, origins: nil, encrypt: false)
-      passphrase = encrypt ? ENV.fetch("BROWSERCTL_STATE_PASSPHRASE", nil) : nil
-      res = @client.state_save(name.to_s,
-                               flow: flow&.to_s, origins: origins, passphrase: passphrase)
-      raise WorkflowError, res[:error] if res[:error]
-
-      res
-    end
-
-    # Restores a .bctl bundle. When the daemon detects AUTH_REQUIRED before
-    # applying (e.g. expired cookies in the payload), this rotates the bound
-    # flow and retries — no caller code change required.
-    #
-    # @param on_auth_required [Proc, nil] override the auto-rotate path. The
-    #   block runs in the workflow context, in lieu of invoking the manifest's
-    #   bound flow. Use this when the recovery procedure is bespoke.
-    def load_state(name, on_auth_required: nil)
-      res = @client.state_load(name.to_s)
-      return res unless auth_required_response?(res)
-
-      recover_auth_required_state(name.to_s, res, on_auth_required)
-    end
-    DEPRECATED_LOAD_SESSION_FALLBACK = <<~MSG
-      [browserctl] DEPRECATION: `load_session(name, fallback:, expired_if:)` is superseded by
-      `load_state(name)` with a flow-bound bundle (`save_state(name, flow: :name)`).
-      `load_session` will be removed in v0.12. See docs/concepts/state.md.
-    MSG
-
-    def load_session(session_name, fallback: nil, expired_if: nil)
-      warn DEPRECATED_LOAD_SESSION_FALLBACK if fallback || expired_if
-      validate_expired_if!(expired_if)
-      fallback_name = fallback&.to_s
-      res = @client.session_load(session_name)
-
-      if res[:error]
-        raise WorkflowError, res[:error] unless fallback_name
-
-        invoke(fallback_name)
-        return load_after_fallback(session_name, fallback_name)
-      end
-
-      return res if expired_if.nil? || !call_expired_if(expired_if, session_name)
-
-      recover_expired_session(session_name, fallback_name, expired_if)
-    end
-
-    def list_sessions
-      @client.session_list[:sessions]
-    end
-
     def ask(prompt)
       $stderr.print("[browserctl] #{prompt} ")
       $stdin.gets.chomp
@@ -174,95 +158,6 @@ module Browserctl
 
     private
 
-    def auth_required_response?(res)
-      (res[:code] || res["code"]) == "AUTH_REQUIRED"
-    end
-
-    def recover_auth_required_state(name, initial_res, on_auth_required)
-      if on_auth_required
-        on_auth_required.call
-      else
-        flow_name = initial_res[:suggested_flow] || initial_res["suggested_flow"]
-        unless flow_name && !flow_name.to_s.empty?
-          raise WorkflowError,
-                "state '#{name}' needs auth but bundle has no bound flow — " \
-                "save with `save_state('#{name}', flow: :NAME)` or pass on_auth_required:"
-        end
-
-        # Match the daemon's `state load` preflight: it auth-checks the first
-        # open page (insertion order). Passing that same name to the flow
-        # gives stdlib flows a `page` proxy to drive (oauth_github reads
-        # `page.url`, totp_2fa calls `page.fill`, etc.). Falls back to no
-        # page only when nothing is open — `state_save` would have errored
-        # earlier in that case, so this is a defence-in-depth nil.
-        invoke(flow_name, page: first_open_page)
-      end
-
-      after_save = @client.state_save(name)
-      raise WorkflowError, after_save[:error] if after_save[:error]
-
-      retry_res = @client.state_load(name, skip_auth_check: true)
-      raise WorkflowError, retry_res[:error] if retry_res[:error]
-
-      retry_res.merge(rotated: true)
-    end
-
-    def first_open_page
-      res = @client.page_list
-      pages = res[:pages] || res["pages"] || []
-      pages.first
-    end
-
-    def validate_expired_if!(expired_if)
-      return unless expired_if
-
-      unless expired_if.lambda?
-        raise ArgumentError,
-              "expired_if: must be a lambda (-> { }), not a Proc — " \
-              "bare return inside a Proc unwinds the caller"
-      end
-
-      return if expired_if.arity.zero?
-
-      raise ArgumentError,
-            "expired_if: lambda must take zero arguments (got #{expired_if.arity}) — " \
-            "use -> { page(:name).url... } to access pages via the workflow context"
-    end
-
-    def call_expired_if(expired_if, session_name)
-      expired_if.call
-    rescue WorkflowError, StandardError => e
-      raise WorkflowError, "expired_if check failed for session '#{session_name}': #{e.message}"
-    end
-
-    def recover_expired_session(session_name, fallback_name, expired_if)
-      unless fallback_name
-        raise WorkflowError,
-              "session '#{session_name}' is expired; provide fallback: to auto-recover"
-      end
-
-      invoke(fallback_name)
-      res = load_after_fallback(session_name, fallback_name)
-
-      if call_expired_if(expired_if, session_name)
-        raise WorkflowError,
-              "session '#{session_name}' still expired after running fallback '#{fallback_name}'"
-      end
-
-      res
-    end
-
-    def load_after_fallback(session_name, fallback)
-      res = @client.session_load(session_name)
-      return res unless res[:error]
-
-      msg = "session '#{session_name}' still unavailable after running fallback '#{fallback}'"
-      unless Session.exist?(session_name)
-        msg += "\n  Hint: '#{fallback}' did not call save_session(\"#{session_name}\") — add it as the last step."
-      end
-      raise WorkflowError, msg
-    end
-
     def invoke_stack
       @invoke_stack ||= []
     end
@@ -301,6 +196,21 @@ module Browserctl
   class PageProxy
     attr_accessor :replay_context
 
+    # Declarative wrapper for `unwrap @client.METHOD(@name, ...)` one-liners.
+    # Forwards positional + keyword args verbatim. Pass `extract:` to return
+    # a single key from the client response instead of unwrapping.
+    def self.delegate_unwrap(method_name, extract: nil)
+      if extract
+        define_method(method_name) do |*args, **kwargs|
+          @client.public_send(method_name, @name, *args, **kwargs)[extract]
+        end
+      else
+        define_method(method_name) do |*args, **kwargs|
+          unwrap @client.public_send(method_name, @name, *args, **kwargs)
+        end
+      end
+    end
+
     def initialize(name, client, replay_context: nil, matcher: nil)
       @name           = name
       @client         = client
@@ -308,7 +218,20 @@ module Browserctl
       @matcher        = matcher || Replay::FingerprintMatcher.new
     end
 
-    def navigate(url) = unwrap @client.navigate(@name, url)
+    delegate_unwrap :navigate
+    delegate_unwrap :snapshot
+    delegate_unwrap :screenshot
+    delegate_unwrap :wait
+    delegate_unwrap :delete_cookies
+    delegate_unwrap :press
+    delegate_unwrap :storage_set
+    delegate_unwrap :dialog_accept
+    delegate_unwrap :dialog_dismiss
+
+    delegate_unwrap :devtools,    extract: :devtools_url
+    delegate_unwrap :url,         extract: :url
+    delegate_unwrap :evaluate,    extract: :result
+    delegate_unwrap :storage_get, extract: :value
 
     def fill(selector = nil, value = nil, ref: nil)
       with_selector_fallback(:fill, selector, ref) do |sel, r|
@@ -322,24 +245,6 @@ module Browserctl
       end
     end
 
-    def snapshot(**)              = unwrap @client.snapshot(@name, **)
-    def screenshot(**)            = unwrap @client.screenshot(@name, **)
-    def wait(sel, timeout: 30)    = unwrap @client.wait(@name, sel, timeout: timeout)
-    def delete_cookies             = unwrap @client.delete_cookies(@name)
-    def devtools                   = @client.devtools(@name)[:devtools_url]
-    def url                        = @client.url(@name)[:url]
-    def evaluate(expr)             = @client.evaluate(@name, expr)[:result]
-
-    def storage_get(key, store: "local")
-      @client.storage_get(@name, key, store: store)[:value]
-    end
-
-    def storage_set(key, value, store: "local")
-      unwrap @client.storage_set(@name, key, value, store: store)
-    end
-
-    def press(key) = unwrap @client.press(@name, key)
-
     def hover(selector = nil, ref: nil)
       with_selector_fallback(:hover, selector, ref) do |sel, r|
         @client.hover(@name, sel, ref: r)
@@ -358,9 +263,6 @@ module Browserctl
       end
     end
 
-    def dialog_accept(text: nil) = unwrap @client.dialog_accept(@name, text: text)
-    def dialog_dismiss           = unwrap @client.dialog_dismiss(@name)
-
     private
 
     # Issues the wrapped command. If the daemon returns selector_not_found
@@ -391,7 +293,7 @@ module Browserctl
     end
 
     def selector_not_found?(res)
-      res.is_a?(Hash) && res[:code] == "selector_not_found"
+      res.is_a?(Hash) && res[:code] == Browserctl::Error::Codes::SELECTOR_NOT_FOUND
     end
 
     def log_rematch(cmd, selector, match)
@@ -406,32 +308,24 @@ module Browserctl
     end
   end
 
-  class WorkflowDefinition
-    attr_reader :name, :description, :param_defs, :steps
-
-    def initialize(name)
-      @name = name
-      @description = nil
-      @param_defs  = {}
-      @steps       = []
-    end
-
-    def desc(text)
-      @description = text
-    end
-
-    def param(name, required: false, secret: false, default: nil, secret_ref: nil)
-      secret = true if secret_ref
-      @param_defs[name] =
-        ParamDef.new(name: name, required: required, secret: secret, default: default, secret_ref: secret_ref)
-    end
-
-    def step(label, retry_count: 0, timeout: nil, &block)
-      @steps << StepDef.new(label: label, block: block, retry_count: retry_count, timeout: timeout)
+  class WorkflowDefinition < CallableDefinition
+    def callable_kind
+      :workflow
     end
 
+    # Definition-time guard: composing a flow into a workflow would copy
+    # flow steps that may close over `page` (a flow-only DSL) into a
+    # context that doesn't expose it. Cross-kind composition is rejected
+    # here rather than failing later inside an `instance_exec`.
     def compose(workflow_name)
-      source = Browserctl.lookup_workflow(workflow_name.to_s)
+      name = workflow_name.to_s
+      if Browserctl.lookup_flow(name)
+        raise ArgumentError,
+              "workflow '#{@name}' cannot compose flow '#{name}': flows return state, " \
+              "workflows share state — composition across kinds is not supported"
+      end
+
+      source = Browserctl.lookup_workflow(name)
       raise WorkflowError, "workflow '#{workflow_name}' not found for composition" unless source
 
       @steps.concat(source.steps)
@@ -444,6 +338,14 @@ module Browserctl
 
     private
 
+    def missing_param_error(name)
+      WorkflowError.new("required param '#{name}' missing")
+    end
+
+    def step_timeout_error(defn)
+      WorkflowError.new("step '#{defn.label}' timed out after #{defn.timeout}s")
+    end
+
     def execute_steps(ctx)
       @steps.map { |defn| run_step(ctx, defn) }.each do |r|
         raise WorkflowError, "step '#{r.name}' failed: #{r.error}" unless r.ok
@@ -453,36 +355,13 @@ module Browserctl
     def run_step(ctx, defn)
       last_error = nil
       (defn.retry_count + 1).times do
-        execute_block(ctx, defn)
+        execute_step_block(ctx, defn)
         return StepResult.new(name: defn.label, ok: true)
       rescue StandardError => e
         last_error = e
       end
       StepResult.new(name: defn.label, ok: false, error: last_error.message)
     end
-
-    def execute_block(ctx, defn)
-      if defn.timeout
-        ::Timeout.timeout(defn.timeout) { ctx.instance_exec(&defn.block) }
-      else
-        ctx.instance_exec(&defn.block)
-      end
-    rescue ::Timeout::Error
-      raise WorkflowError, "step '#{defn.label}' timed out after #{defn.timeout}s"
-    end
-
-    def resolve_params(provided)
-      @param_defs.each_with_object({}) do |(name, defn), out|
-        val = if defn.secret_ref
-                SecretResolverRegistry.resolve(defn.secret_ref)
-              else
-                provided[name] || defn.default
-              end
-        raise WorkflowError, "required param '#{name}' missing" if defn.required && val.nil?
-
-        out[name] = val
-      end
-    end
   end
 
   @registry_mutex = Mutex.new

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: browserctl
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Patrick
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ferrum
@@ -127,8 +126,8 @@ description: Named browser sessions, Ruby workflow DSL, and a token-efficient DO
 email:
 - patrick204nqh@gmail.com
 executables:
-- browserd
 - browserctl
+- browserd
 extensions: []
 extra_rdoc_files: []
 files:
@@ -139,7 +138,6 @@ files:
 - bin/browserd
 - bin/setup
 - examples/cloudflare_hitl.rb
-- examples/session_reuse.rb
 - examples/test_automation_practices/advanced/ab_testing.rb
 - examples/test_automation_practices/advanced/broken_images.rb
 - examples/test_automation_practices/advanced/file_download.rb
@@ -166,6 +164,7 @@ files:
 - examples/the_internet/dynamic_loading.rb
 - examples/the_internet/login.rb
 - lib/browserctl.rb
+- lib/browserctl/callable_definition.rb
 - lib/browserctl/client.rb
 - lib/browserctl/commands/ask.rb
 - lib/browserctl/commands/cli_output.rb
@@ -176,22 +175,28 @@ files:
 - lib/browserctl/commands/fill.rb
 - lib/browserctl/commands/flow.rb
 - lib/browserctl/commands/init.rb
+- lib/browserctl/commands/migrate.rb
+- lib/browserctl/commands/output_format.rb
 - lib/browserctl/commands/page.rb
-- lib/browserctl/commands/record.rb
+- lib/browserctl/commands/recording.rb
 - lib/browserctl/commands/resume.rb
 - lib/browserctl/commands/screenshot.rb
-- lib/browserctl/commands/session.rb
 - lib/browserctl/commands/snapshot.rb
 - lib/browserctl/commands/state.rb
 - lib/browserctl/commands/storage.rb
+- lib/browserctl/commands/trace.rb
 - lib/browserctl/commands/workflow.rb
 - lib/browserctl/constants.rb
+- lib/browserctl/contextual_persistence.rb
+- lib/browserctl/crash_report.rb
 - lib/browserctl/detectors.rb
 - lib/browserctl/detectors/auth_required.rb
-- lib/browserctl/driver.rb
-- lib/browserctl/driver/base.rb
 - lib/browserctl/driver/cdp.rb
 - lib/browserctl/driver/cdp_page.rb
+- lib/browserctl/encryption_service.rb
+- lib/browserctl/error/codes.rb
+- lib/browserctl/error/exit_codes.rb
+- lib/browserctl/error/suggested_actions.rb
 - lib/browserctl/errors.rb
 - lib/browserctl/flow.rb
 - lib/browserctl/flow_registry.rb
@@ -201,13 +206,21 @@ files:
 - lib/browserctl/flows/stdlib/oauth_github.rb
 - lib/browserctl/flows/stdlib/oauth_google.rb
 - lib/browserctl/flows/stdlib/totp_2fa.rb
+- lib/browserctl/format_version.rb
 - lib/browserctl/logger.rb
+- lib/browserctl/migrations.rb
 - lib/browserctl/policy.rb
 - lib/browserctl/recording.rb
+- lib/browserctl/recording/log_writer.rb
+- lib/browserctl/recording/redactor.rb
+- lib/browserctl/recording/state.rb
+- lib/browserctl/recording/workflow_renderer.rb
+- lib/browserctl/redactor.rb
 - lib/browserctl/replay/context.rb
 - lib/browserctl/replay/fingerprint_matcher.rb
 - lib/browserctl/replay/snapshot_diff.rb
 - lib/browserctl/replay/telemetry.rb
+- lib/browserctl/rubocop/cops/typed_error.rb
 - lib/browserctl/runner.rb
 - lib/browserctl/secret_resolver_registry.rb
 - lib/browserctl/secret_resolvers.rb
@@ -220,18 +233,17 @@ files:
 - lib/browserctl/server/handlers/cookies.rb
 - lib/browserctl/server/handlers/daemon_control.rb
 - lib/browserctl/server/handlers/devtools.rb
+- lib/browserctl/server/handlers/error_payload.rb
 - lib/browserctl/server/handlers/hitl.rb
 - lib/browserctl/server/handlers/interaction.rb
 - lib/browserctl/server/handlers/navigation.rb
 - lib/browserctl/server/handlers/observation.rb
 - lib/browserctl/server/handlers/page_lifecycle.rb
-- lib/browserctl/server/handlers/session.rb
 - lib/browserctl/server/handlers/state.rb
 - lib/browserctl/server/handlers/storage.rb
 - lib/browserctl/server/idle_watcher.rb
 - lib/browserctl/server/page_session.rb
 - lib/browserctl/server/snapshot_builder.rb
-- lib/browserctl/session.rb
 - lib/browserctl/snapshot/annotator.rb
 - lib/browserctl/snapshot/extractor.rb
 - lib/browserctl/snapshot/fingerprint.rb
@@ -248,6 +260,7 @@ files:
 - lib/browserctl/workflow/flow_wrapper.rb
 - lib/browserctl/workflow/promoter.rb
 - lib/browserctl/workflow/promotion_ledger.rb
+- lib/browserctl/workflow/recovery_manager.rb
 homepage: https://github.com/patrick204nqh/browserctl
 licenses:
 - MIT
@@ -258,7 +271,6 @@ metadata:
   bug_tracker_uri: https://github.com/patrick204nqh/browserctl/issues
   documentation_uri: https://github.com/patrick204nqh/browserctl/tree/main/docs
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -273,8 +285,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Persistent browser automation daemon and CLI for AI agents and developer
   workflows

data/examples/session_reuse.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-# Demonstrates the authenticate-once, reuse-forever pattern.
-#
-# The first run (no saved session) invokes `login_once` to authenticate,
-# which saves the session. Every subsequent run loads the saved session
-# directly — no re-authentication needed.
-#
-# `expired_if:` detects when the saved session exists but server-side auth
-# has lapsed (rotated cookie, token TTL), and automatically re-authenticates.
-#
-# Run:
-#   browserctl workflow run examples/session_reuse.rb \
-#     --app_url https://the-internet.herokuapp.com \
-#     --username tomsmith \
-#     --password "SuperSecretPassword!"
-#
-# On the first run: authenticates and saves the session.
-# On subsequent runs: loads the session and skips the login page entirely.
-
-# --- Step 1: define the login workflow (run once, triggered automatically on missing/expired session) ---
-
-Browserctl.workflow "session_reuse/login_once" do
-  desc "Authenticate and save session — called automatically by session_reuse when needed"
-
-  param :app_url,  required: true
-  param :username, required: true
-  param :password, required: true, secret: true
-
-  step "open login page" do
-    open_page(:main, url: "#{app_url}/login")
-  end
-
-  step "fill and submit credentials" do
-    page(:main).fill("input#username", username)
-    page(:main).fill("input#password", password)
-    page(:main).click("button[type=submit]")
-  end
-
-  step "verify login succeeded" do
-    assert page(:main).url.include?("/secure"), "login failed — still on login page"
-  end
-
-  step "save authenticated session" do
-    save_session("session_reuse_demo")
-    puts "  ✓ Session saved — future runs will skip this step"
-  end
-end
-
-# --- Step 2: the main workflow that reuses the saved session ---
-
-Browserctl.workflow "session_reuse" do
-  desc "Authenticate once, reuse forever — demonstrates load_session with fallback and expired_if"
-
-  param :app_url,  default: "https://the-internet.herokuapp.com"
-  param :username, default: "tomsmith"
-  param :password, default: "SuperSecretPassword!", secret: true
-
-  step "restore session or log in" do
-    load_session("session_reuse_demo",
-                 fallback: "session_reuse/login_once",
-                 expired_if: lambda {
-                   page(:main).navigate("#{app_url}/secure")
-                   !page(:main).url.include?("/secure")
-                 })
-    puts "  ✓ Session ready — authenticated as #{username}"
-  end
-
-  step "do authenticated work" do
-    page(:main).navigate("#{app_url}/secure")
-    heading = page(:main).evaluate("document.querySelector('h2')?.textContent?.trim()")
-    assert heading&.include?("Secure Area"), "expected to be in secure area, got: #{heading.inspect}"
-    puts "  ✓ Landed in secure area without re-authenticating"
-  end
-end