bidi2pdf 0.1.17 → 0.1.19

data/sig/bidi2pdf/chrome_sweeper.rbs

@@ -0,0 +1,220 @@
+module Bidi2pdf
+  # Closes Chrome sessions a shared chromedriver holds that nobody will close any more - left behind
+  # by a process that died, or stuck in a tab that never returns - and keeps the number of sessions
+  # below a limit. chromedriver keeps every session (a whole Chrome) until someone deletes it.
+  #
+  # Which sessions it looks at (+scope+):
+  # - +:recorded+ (default) - only sessions a SessionRegistry proves were opened through bidi2pdf.
+  # - +:all+ - every session on that chromedriver (+GET /sessions+), aged by its first tab. Only for
+  #   a chromedriver the application owns: on a shared one it closes other clients' old sessions.
+  #
+  # What it closes, in this order - never a session of +own_sessions+, never one whose lease a live
+  # process keeps renewing (SessionRegistry#hold - a render in flight or a warm spare of another
+  # worker), and never one younger than +min_age+, not even over the limit:
+  # 1. sessions older than +orphan_age+;
+  # 2. sessions that failed +unresponsive_checks+ checks in a row (no answer, or a renderer burning
+  #    CPU at full speed between two sweeps - an endless loop);
+  # 3. while more sessions exist than +max_sessions+, the oldest remaining ones. When that is not
+  #    enough, the sweep reports +limit_exceeded+ and closes nothing more.
+  #
+  # Run it once (#sweep!, ChromeSweeper.sweep!) - e.g. when the application suspects a leak - or
+  # periodically (+interval+, #start/#stop). As a last resort when a render fails for lack of
+  # resources, #with_retry sweeps under +pressure+ - every session nobody holds and older than
+  # +min_age+ goes - and tries once more. One sweep at a time, across processes too (a lock file
+  # next to the registry). Fail-open: a sweep never raises; errors land in the Result. See Settings
+  # for every setting and its default.
+  #
+  # @example A periodic sweeper for an application's own chromedriver
+  #   sweeper = Bidi2pdf::ChromeSweeper.new("http://remote-chrome:3000/session", scope: :all,
+  #                                         max_sessions: :auto, pids_limit: 1024, interval: 60)
+  #   sweeper.start
+  class ChromeSweeper
+    @session_url: untyped
+
+    @settings: untyped
+
+    @own_sessions: untyped
+
+    @clock: untyped
+
+    @registry: untyped
+
+    @api: untyped
+
+    @inspector: untyped
+
+    @mutex: untyped
+
+    @wakeup: untyped
+
+    @failures: untyped
+
+    @first_seen: untyped
+
+    @cpu_samples: untyped
+
+    @thread: untyped
+
+    extend Forwardable
+
+    # One closed (or, in a dry run, would-be closed) session. +why+: :orphan, :unresponsive,
+    # :over_limit or :pressure.
+    Closed: untyped
+
+    # What one sweep saw and did.
+    Result: untyped
+
+    # A renderer that used at least this share of the wall-clock time between two sweeps counts as
+    # stuck in a loop.
+    BUSY_CPU_SHARE: ::Float
+
+    # Errors #with_retry sweeps and retries on by default: a session chromedriver refused, and a
+    # connection or command that died or timed out - what a Chrome out of memory or pids looks like.
+    # A command Chrome answered with an error (CmdError) is the page's problem, not a resource one.
+    RETRYABLE: untyped
+
+    # The bookkeeping of one sweep.
+    Sweep: untyped
+
+    attr_reader session_url: untyped
+
+    attr_reader settings: untyped
+
+    attr_reader registry: untyped
+
+    # One-shot sweep with a throw-away sweeper. Give it a +check_interval+ for the unresponsive rule
+    # to apply - see #sweep!.
+    #
+    # @return [Result]
+    def self.sweep!: (untyped session_url, ?reason: ::Symbol, ?check_interval: untyped?, ?pressure: bool, **untyped) -> untyped
+
+    # #with_retry with a throw-away sweeper.
+    def self.with_retry: (untyped session_url, ?retry_on: untyped, **untyped) { (?) -> untyped } -> untyped
+
+    # @param session_url [String] chromedriver's new-session URL (".../session").
+    # @param registry [SessionRegistry, nil] defaults to the one for +session_url+ in +registry_dir+.
+    # @param own_sessions [#call] returns the ids of the caller's live sessions - never touched.
+    # @param api [ChromedriverApi, nil], inspector [Inspector, nil], clock [#call] - for tests.
+    # @param settings see Settings.
+    # @raise [InvalidConfigError] for a setting out of range.
+    def initialize: (untyped session_url, ?registry: untyped?, ?registry_dir: untyped?, ?own_sessions: untyped, ?api: untyped?, ?inspector: untyped?, ?clock: untyped, **untyped settings) -> void
+
+    # Every session in scope, inspected (age, tabs, responsive) - for diagnostics; closes nothing.
+    #
+    # @return [Array<Inspector::SessionInfo>]
+    def sessions: () -> untyped
+
+    # Runs the block; when it fails with a resource error (+retry_on+: a callable or a list of error
+    # classes, RETRYABLE by default), sweeps under pressure and runs it once more. The block must
+    # be safe to run twice - it gets a new session the second time. Other errors, and a second
+    # failure, propagate unchanged.
+    def with_retry: (?retry_on: untyped) { () -> untyped } -> untyped
+
+    # Inspects every session in scope and counts its checks, like a sweep, but closes nothing.
+    #
+    # @return [Array<Inspector::SessionInfo>]
+    def observe: () -> untyped
+
+    # Sweeps once. Skipped (Result#skipped) when another sweep - in this or another process - is
+    # still running.
+    #
+    # A session counts as hung only after +unresponsive_checks+ failed checks, one per sweep - a
+    # one-shot sweep never gets there. With +check_interval+ it first checks
+    # +unresponsive_checks - 1+ times, +check_interval+ seconds apart (#observe), so a single call
+    # applies every rule. The periodic thread doesn't need that: its sweeps are the checks.
+    #
+    # @param reason [Symbol] why - reported in the notification (:manual, :periodic, :create_failed…).
+    # Under +pressure+ - the last resort when a render failed - every eligible session is closed:
+    # nobody holds it, and it is older than +min_age+; +orphan_age+, the unresponsive checks and the
+    # limit no longer matter.
+    #
+    # @param check_interval [Numeric, nil] seconds between those checks; nil sweeps right away.
+    # @param pressure [Boolean] close everything nobody holds that is past +min_age+.
+    # @return [Result]
+    def sweep!: (?reason: ::Symbol, ?check_interval: untyped?, ?pressure: bool) -> untyped
+
+    # Starts the periodic sweep thread (needs an +interval+). Idempotent.
+    def start: () -> self
+
+    # Stops the periodic sweep thread and waits for a sweep in progress to finish.
+    def stop: () -> (nil | untyped)
+
+    private
+
+    def run: (untyped reason, untyped started, untyped pressure) -> untyped
+
+    # A config error raises; a failed check only means the sweep has fewer checks to go on.
+    def check_first: (untyped check_interval) -> untyped
+
+    def observe_then_wait: (untyped check_interval) -> untyped
+
+    def sweep_sessions: (untyped pressure) -> ::Array[untyped]
+
+    # In-scope sessions not owned by the caller, not held by a live process and not known to be
+    # younger than min_age, with the registry time when there is one. None of the others is even
+    # attached to - a render in flight is left alone entirely.
+    def candidates: (untyped entries) -> untyped
+
+    def live_sessions: () -> untyped
+
+    def live_info: (untyped id, untyped recorded_at) -> untyped
+
+    def retryable?: (untyped retry_on, untyped error) -> untyped
+
+    def in_scope: (untyped entries, untyped recorded) -> untyped
+
+    def observe_entries: (untyped entries) -> untyped
+
+    # Sessions chromedriver no longer has are dropped from the registry and from this sweeper's own
+    # tracking - most sessions end normally, so a long-running sweeper would otherwise keep every id
+    # it ever saw.
+    def forget_gone: (untyped entries) -> untyped
+
+    def forget_tracking: (untyped id) -> untyped
+
+    # Counts failed checks per session across sweeps, and ages a session by when this sweeper first
+    # saw it when nothing better is known.
+    def track: (untyped info) -> untyped
+
+    def count_check: (untyped info) -> untyped
+
+    def busy?: (untyped info) -> (false | untyped)
+
+    def decide: (untyped eligible, untyped sweep) -> untyped
+
+    def close_reason: (untyped info, untyped sweep) -> (:orphan | untyped)
+
+    def note_unresponsive: (untyped info, untyped failed, untyped sweep) -> untyped
+
+    def enforce_limit: (untyped eligible, untyped sweep) -> (nil | untyped)
+
+    def over_limit?: (untyped sweep) -> untyped
+
+    def oldest_open: (untyped eligible, untyped sweep) -> untyped
+
+    def limit_exceeded: (untyped sweep) -> untyped
+
+    # Adds the session to the sweep's closed list unless chromedriver refused to close it.
+    def close_session: (untyped info, untyped why, untyped sweep) -> untyped
+
+    def announce: (untyped closed) -> untyped
+
+    def gone_after_delete?: (untyped id) -> (false | true)
+
+    def report: (untyped result) -> untyped
+
+    def sweep_payload: (untyped result) -> untyped
+
+    def result: (untyped reason, untyped started, ?sweep: untyped, ?inspected: untyped, ?skipped: bool) -> untyped
+
+    # A lock file next to the registry, so processes sharing it never sweep at the same time. When
+    # the file cannot be created at all the sweep still runs (fail-open, like the registry itself).
+    def with_lock_file: () { (untyped) -> untyped } -> untyped
+
+    def open_lock_file: () -> untyped
+
+    def now: () -> untyped
+
+    def monotonic: () -> untyped
+  end
+end

data/sig/bidi2pdf/chromedriver_api.rbs

@@ -0,0 +1,44 @@
+module Bidi2pdf
+  # The two chromedriver HTTP endpoints session cleanup needs, next to the BiDi protocol: the
+  # non-standard +GET /sessions+ (every session on that chromedriver - WebDriver itself has no way to
+  # list them, BiDi neither) and +DELETE /session/{id}+ (ends a session and its Chrome even when that
+  # Chrome no longer answers BiDi).
+  #
+  # Built from the new-session URL every other part of bidi2pdf is configured with
+  # ("http://host:3000/session").
+  class ChromedriverApi
+    @session_url: untyped
+
+    @timeout: untyped
+
+    @http: untyped
+
+    # One entry of +GET /sessions+: chromedriver gives no creation time, no owner, and no hint
+    # whether a client is still connected (checked against chromedriver 153/154).
+    Entry: untyped
+
+    DEFAULT_TIMEOUT: 30
+
+    attr_reader session_url: untyped
+
+    # @param session_url [String] chromedriver's new-session URL (".../session").
+    # @param http [#call, nil] (method, url) -> [status, body]; injectable for tests.
+    def initialize: (untyped session_url, ?http: untyped?, ?timeout: untyped) -> void
+
+    # @return [Array<Entry>] every session chromedriver holds right now.
+    def sessions: () -> untyped
+
+    # Ends a session. chromedriver answers 404 ("invalid session id") for one it no longer has.
+    #
+    # @return [Symbol] :closed, :gone or :failed
+    def delete_session: (untyped id) -> untyped
+
+    private
+
+    # "http://host:3000/session" -> "http://host:3000/sessions"; a chromedriver started with a
+    # --url-base keeps its prefix.
+    def sessions_url: () -> ::String
+
+    def net_http: (untyped method, untyped url) -> untyped
+  end
+end

data/sig/bidi2pdf/cli/session_commands.rbs

@@ -0,0 +1,35 @@
+module Bidi2pdf
+  class CLI < Thor
+    # Output of `bidi2pdf sessions` and `bidi2pdf sweep` (ChromeSweeper). Never prints a tab URL or
+    # any page content - only ids, ages, tab counts and what was done.
+    module SessionCommands
+      # CLI flag => ChromeSweeper setting, for the ones that are only passed when given.
+      SWEEP_FLAGS: { older_than: :orphan_age, max_sessions: :max_sessions, min_age: :min_age, unresponsive_checks: :unresponsive_checks }
+
+      # Settings that are counts - Thor hands every numeric over as a Float.
+      COUNT_SETTINGS: ::Array[:max_sessions | :unresponsive_checks]
+
+      private
+
+      def chrome_sweeper: () -> untyped
+
+      def sweep_flags: () -> untyped
+
+      # --check-interval 0 means no checks before the sweep.
+      def run_sweep: () -> untyped
+
+      def session_hash: (untyped info) -> { id: untyped, age: untyped, source: untyped, tabs: untyped, responsive: untyped, live: untyped }
+
+      def print_sessions: (untyped infos) -> untyped
+
+      # A live session is not attached to, so there is nothing to say about its tabs.
+      def session_state: (untyped info) -> ("live (a running process holds it)" | untyped)
+
+      def sweep_hash: (untyped result) -> { reason: untyped, sessions: untyped, dry_run: untyped, skipped: untyped, closed: untyped, unresponsive: untyped, limit: untyped, limit_exceeded: untyped, errors: untyped }
+
+      def print_sweep: (untyped result) -> untyped
+
+      def print_sweep_problems: (untyped result) -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/cli.rbs

@@ -13,6 +13,8 @@ module Bidi2pdf
 
     include JsonOutput
 
+    include SessionCommands
+
     def self.exit_on_failure?: () -> true
 
     def render: () -> (nil | untyped)
@@ -28,6 +30,10 @@ module Bidi2pdf
     # below is what makes `bidi2pdf run recipe.yml` dispatch here.
     def run_recipe: (untyped recipe_path) -> untyped
 
+    def sessions: () -> untyped
+
+    def sweep: () -> untyped
+
     def template: () -> untyped
 
     private

data/sig/bidi2pdf/session_registry/heartbeat.rbs

@@ -0,0 +1,50 @@
+module Bidi2pdf
+  class SessionRegistry
+    # Keeps the leases of every session this process holds fresh: one thread per process renews
+    # them in their registry files every +interval+ seconds, so a sweeper in another process (a
+    # second Puma worker, a job worker sharing the registry directory) can tell a live session
+    # from one whose process died. The thread runs only while something is held.
+    #
+    # Fork-aware: a child process (Puma forks its workers) starts with nothing held and without the
+    # parent's thread - the parent's sessions are the parent's to renew.
+    module Heartbeat
+      self.@mutex: untyped
+
+      self.@held: untyped
+
+      self.@pid: untyped
+
+      self.@thread: untyped
+
+      DEFAULT_INTERVAL: untyped
+
+      # @return [Numeric] seconds between renewals - keep it well below the sweeper's lease_ttl.
+      attr_writer self.interval: untyped
+
+      def self.interval: () -> untyped
+
+      # The TTL this process writes into its leases: three missed renewals and it is taken for dead.
+      def self.lease_ttl: () -> untyped
+
+      def self.hold: (untyped registry, untyped session_id) -> untyped
+
+      def self.release: (untyped registry, untyped session_id) -> untyped
+
+      # @return [Array<String>] the session ids this process holds in +registry+'s file.
+      def self.held_ids: (untyped registry) -> untyped
+
+      # Renews every held lease now.
+      def self.beat!: (?now: untyped) -> untyped
+
+      private
+
+      def self.beat_loop: () -> untyped
+
+      def self.held: () -> untyped
+
+      def self.reset_after_fork: () -> (nil | untyped)
+
+      def self.synchronize: () { (?) -> untyped } -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/session_registry.rbs

@@ -1,15 +1,23 @@
 module Bidi2pdf
-  # Remembers which sessions a SessionWarmer opened on a shared (remote) chromedriver, and when, in a
-  # small JSON file per chromedriver URL - so a process started later can find and close the ones a
-  # process that died without a clean shutdown left behind (see SessionSweeper). chromedriver itself
-  # keeps a session until someone deletes it, and it drops any tag we could attach to one (a custom
-  # capability is accepted but echoed nowhere - checked against chromedriver 153), hence a file.
+  # Remembers which sessions bidi2pdf opened on a shared (remote) chromedriver, when, by which
+  # process, and whether that process is still alive - in a small JSON file per chromedriver URL - so
+  # a process started later, or a ChromeSweeper, can find and close the ones a process that died
+  # without a clean shutdown left behind (see SessionSweeper). chromedriver itself keeps a session
+  # until someone deletes it, and it drops any tag we could attach to one (a custom capability is
+  # accepted but echoed nowhere - checked against chromedriver 153), hence a file.
+  #
+  # Liveness is a lease: a session the process #hold s is renewed by its Heartbeat every
+  # Heartbeat.interval seconds, and every entry carries its own TTL - the time the owner promises to
+  # renew it within (three heartbeats) - so a sweeper in another process never has to guess how
+  # often that owner renews. A session whose lease is fresh belongs to a live process - a render in
+  # flight or a warm spare - and no sweeper closes it; one whose lease ran out belongs to a dead
+  # process. #record alone writes an entry nobody renews.
   #
   # Everything here is best effort and fail-open: a directory that is not writable, a locked-out or
   # corrupt file only switches orphan tracking off for this process (one warning, one
   # +session_warmer.registry_unavailable.bidi2pdf+ notification) - rendering never depends on it.
   # The file is created 0600 and every change happens under an exclusive lock, so processes sharing
-  # the directory (a dev server, a job worker, a spec run) can record at the same time.
+  # the directory (Puma workers, a job worker, a spec run) can record at the same time.
   class SessionRegistry
     @path: untyped
 
@@ -17,16 +25,42 @@ module Bidi2pdf
 
     FILE_PREFIX: "bidi2pdf-sessions-"
 
+    # Seconds a lease stays fresh without a renewal when its entry carries no TTL of its own (written
+    # by bidi2pdf 0.1.18) - matches that version's fixed 20 s heartbeat.
+    DEFAULT_LEASE_TTL: 60
+
     attr_reader path: untyped
 
+    def self.owner: () -> ::String
+
     def initialize: (untyped session_url, ?dir: untyped?) -> void
 
-    # Records a session the caller just opened.
-    def record: (untyped session_id, ?created_at: untyped) -> (false | untyped)
+    # Records a session the caller opened and keeps its lease fresh while this process lives.
+    def hold: (untyped session_id) -> (false | untyped)
+
+    # Stops renewing the lease but keeps the entry - for a session this process could not close, so
+    # a sweeper takes it once the lease ran out.
+    def release: (untyped session_id) -> (untyped | nil)
+
+    # Writes an entry, leased from +created_at+ on for +ttl+ seconds (nil: the reader's default) but
+    # not renewed (see #hold).
+    # Times are stored as fractions of a second: a whole-second timestamp could cost a short lease
+    # (0.5 s heartbeats: 1.5 s) up to a second of its life. Entries of whole seconds still read.
+    def record: (untyped session_id, ?created_at: untyped, ?ttl: untyped?) -> (false | untyped)
 
     # Forgets a session the caller closed itself (or found gone).
     def forget: (untyped session_id) -> (false | untyped)
 
+    # Renews the leases of +session_ids+ that are still recorded, for +ttl+ seconds when given.
+    def renew: (untyped session_ids, ?at: untyped, ?ttl: untyped?) -> untyped
+
+    # Every recorded session: { id => opened at (epoch seconds) }.
+    def recorded: () -> untyped
+
+    # The recorded session ids whose lease is still fresh at +now+ - sessions of a live process. An
+    # entry's own TTL wins; +ttl+ is only for entries without one.
+    def leased: (?now: untyped, ?ttl: untyped) -> untyped
+
     # The recorded session ids opened at or before +cutoff+ (epoch seconds).
     def recorded_before: (untyped cutoff) -> untyped
 
@@ -36,9 +70,12 @@ module Bidi2pdf
 
     def update: () { (untyped) -> untyped } -> untyped
 
-    # A corrupt or foreign file counts as empty rather than as an error.
+    # A corrupt or foreign file counts as empty rather than as an error; an entry of the first
+    # format (just the creation time) has no lease.
     def parse: (untyped text) -> untyped
 
+    def normalize: (untyped entry) -> ({ "created_at" => untyped } | untyped)
+
     def unavailable!: (untyped error) -> (nil | untyped)
   end
 end

data/sig/bidi2pdf/session_sweeper.rbs

@@ -4,7 +4,8 @@ module Bidi2pdf
   # whole Chrome each until someone deletes them. Run once when a warmer starts.
   #
   # Only recorded sessions are ever touched - another tool's sessions on the same chromedriver never
-  # are. A recorded session that is already gone ("invalid session id" / 404) is just forgotten.
+  # are, and neither is one whose lease a live process keeps renewing (SessionRegistry#hold). A
+  # recorded session that is already gone ("invalid session id" / 404) is just forgotten.
   # Fail-open: any error is logged and ends the sweep; it never raises.
   class SessionSweeper
     @session_url: untyped

data/sig/bidi2pdf/session_warmer.rbs

@@ -42,8 +42,12 @@ module Bidi2pdf
 
     @reaper_wakeup: untyped
 
+    @own_sessions: untyped
+
     @registry: untyped
 
+    @sweeper: untyped
+
     @reaper: untyped
 
     # Configuration for the session warmer.
@@ -64,6 +68,10 @@ module Bidi2pdf
 
       @registry_dir: untyped
 
+      @sweeper: untyped
+
+      @retry_refused_sessions: untyped
+
       # @return [Integer] Number of Chrome slots to keep pre-warmed.
       attr_accessor size: untyped
 
@@ -101,6 +109,17 @@ module Bidi2pdf
       #   Dir.tmpdir. Every process that should clean up after the others must share it.
       attr_accessor registry_dir: untyped
 
+      # @return [Hash, nil] Options for a ChromeSweeper on the remote chromedriver (+scope+,
+      #   +orphan_age+, +min_age+, +unresponsive_checks+, +max_sessions+, +pids_limit+, +interval+,
+      #   ...), or +nil+ (default) for none. This warmer's own sessions are never touched by it; with
+      #   an +interval+ it sweeps in the background, and a session that fails to start triggers one
+      #   pressure sweep and one retry (see +retry_refused_sessions+). Remote mode only.
+      attr_accessor sweeper: untyped
+
+      # @return [Boolean] With a +sweeper+: when chromedriver refuses a new session, sweep under
+      #   pressure and try once more. Default true; false leaves a refused session to the caller.
+      attr_accessor retry_refused_sessions: untyped
+
       DEFAULT_MAX_IDLE_AGE: 300
 
       def initialize: () -> void
@@ -119,6 +138,8 @@ module Bidi2pdf
       def validate_max_idle_age!: () -> (nil | untyped)
 
       def validate_orphan_age!: () -> (nil | untyped)
+
+      def validate_sweeper!: () -> (nil | untyped)
     end
 
     # Configures the warmer and eagerly (re)creates the singleton, warming config.size slots right
@@ -149,6 +170,10 @@ module Bidi2pdf
     # Checks out a slot, yields a fresh tab for one render, then retires the slot.
     def self.with_tab: () { (?) -> untyped } -> untyped
 
+    # Sweeps the remote chromedriver with the configured sweeper; nil when there is none (or no
+    # warmer yet - this never creates one).
+    def self.sweep!: (?reason: ::Symbol) -> untyped
+
     # Retires every currently-warm spare and resets the singleton.
     def self.shutdown: () -> untyped
 
@@ -166,6 +191,11 @@ module Bidi2pdf
 
     def initialize: (untyped config, ?slot_factory: untyped?) -> void
 
+    # Sweeps the remote chromedriver now - for an application that suspects leaked sessions.
+    #
+    # @return [ChromeSweeper::Result, nil] nil when no sweeper is configured.
+    def sweep!: (?reason: ::Symbol) -> untyped
+
     # Checks out a slot, creates an isolated UserContext/Window/Tab for one render, yields the tab,
     # then unconditionally closes those resources and retires the underlying slot.
     def with_tab: () { (untyped) -> untyped } -> untyped
@@ -184,8 +214,18 @@ module Bidi2pdf
 
     def create_slot: () -> untyped
 
-    # Remote mode with an orphan age: sessions are recorded, so a later start can close the ones
-    # this process leaves behind if it dies uncleanly - and this start closes others' leftovers.
+    # A chromedriver out of room for another Chrome refuses the session; with a sweeper, close
+    # everything nobody holds (a pressure sweep) and try once more.
+    def new_slot: () -> untyped
+
+    def start_background_work: () -> untyped
+
+    def build_sweeper: () -> (nil | untyped)
+
+    # Remote mode: every session is leased, so no sweeper in any process takes a warm spare or a
+    # render in flight, and a later start (or a sweeper) can close the ones this process leaves
+    # behind if it dies uncleanly. The start-up sweep itself needs the orphan age - see
+    # #sweep_leftovers.
     def build_registry: () -> (nil | untyped)
 
     def sweep_leftovers: () -> (nil | untyped)

data/sig/bidi2pdf/version.rbs

@@ -1,3 +1,3 @@
 module Bidi2pdf
-  VERSION: "0.1.17"
+  VERSION: "0.1.19"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bidi2pdf
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.1.19
 platform: ruby
 authors:
 - Dieter S.
@@ -429,11 +429,13 @@ files:
 - lib/bidi2pdf/bidi/commands/browser_create_user_context.rb
 - lib/bidi2pdf/bidi/commands/browser_remove_user_context.rb
 - lib/bidi2pdf/bidi/commands/browsing_context_close.rb
+- lib/bidi2pdf/bidi/commands/browsing_context_get_tree.rb
 - lib/bidi2pdf/bidi/commands/browsing_context_navigate.rb
 - lib/bidi2pdf/bidi/commands/browsing_context_print.rb
 - lib/bidi2pdf/bidi/commands/cancel_auth.rb
 - lib/bidi2pdf/bidi/commands/capture_screenshot.rb
 - lib/bidi2pdf/bidi/commands/cdp_get_session.rb
+- lib/bidi2pdf/bidi/commands/cdp_send_command.rb
 - lib/bidi2pdf/bidi/commands/create_tab.rb
 - lib/bidi2pdf/bidi/commands/create_window.rb
 - lib/bidi2pdf/bidi/commands/get_user_contexts.rb
@@ -463,9 +465,14 @@ files:
 - lib/bidi2pdf/bidi/session.rb
 - lib/bidi2pdf/bidi/user_context.rb
 - lib/bidi2pdf/bidi/web_socket_dispatcher.rb
+- lib/bidi2pdf/chrome_sweeper.rb
+- lib/bidi2pdf/chrome_sweeper/inspector.rb
+- lib/bidi2pdf/chrome_sweeper/settings.rb
+- lib/bidi2pdf/chromedriver_api.rb
 - lib/bidi2pdf/chromedriver_manager.rb
 - lib/bidi2pdf/cli.rb
 - lib/bidi2pdf/cli/json_output.rb
+- lib/bidi2pdf/cli/session_commands.rb
 - lib/bidi2pdf/diagnose.rb
 - lib/bidi2pdf/dsl.rb
 - lib/bidi2pdf/error_codes.rb
@@ -488,6 +495,7 @@ files:
 - lib/bidi2pdf/result_collector.rb
 - lib/bidi2pdf/schema.rb
 - lib/bidi2pdf/session_registry.rb
+- lib/bidi2pdf/session_registry/heartbeat.rb
 - lib/bidi2pdf/session_runner.rb
 - lib/bidi2pdf/session_sweeper.rb
 - lib/bidi2pdf/session_warmer.rb
@@ -529,11 +537,13 @@ files:
 - sig/bidi2pdf/bidi/commands/browser_create_user_context.rbs
 - sig/bidi2pdf/bidi/commands/browser_remove_user_context.rbs
 - sig/bidi2pdf/bidi/commands/browsing_context_close.rbs
+- sig/bidi2pdf/bidi/commands/browsing_context_get_tree.rbs
 - sig/bidi2pdf/bidi/commands/browsing_context_navigate.rbs
 - sig/bidi2pdf/bidi/commands/browsing_context_print.rbs
 - sig/bidi2pdf/bidi/commands/cancel_auth.rbs
 - sig/bidi2pdf/bidi/commands/capture_screenshot.rbs
 - sig/bidi2pdf/bidi/commands/cdp_get_session.rbs
+- sig/bidi2pdf/bidi/commands/cdp_send_command.rbs
 - sig/bidi2pdf/bidi/commands/create_tab.rbs
 - sig/bidi2pdf/bidi/commands/create_window.rbs
 - sig/bidi2pdf/bidi/commands/get_user_contexts.rbs
@@ -563,9 +573,14 @@ files:
 - sig/bidi2pdf/bidi/session.rbs
 - sig/bidi2pdf/bidi/user_context.rbs
 - sig/bidi2pdf/bidi/web_socket_dispatcher.rbs
+- sig/bidi2pdf/chrome_sweeper.rbs
+- sig/bidi2pdf/chrome_sweeper/inspector.rbs
+- sig/bidi2pdf/chrome_sweeper/settings.rbs
+- sig/bidi2pdf/chromedriver_api.rbs
 - sig/bidi2pdf/chromedriver_manager.rbs
 - sig/bidi2pdf/cli.rbs
 - sig/bidi2pdf/cli/json_output.rbs
+- sig/bidi2pdf/cli/session_commands.rbs
 - sig/bidi2pdf/diagnose.rbs
 - sig/bidi2pdf/dsl.rbs
 - sig/bidi2pdf/error_codes.rbs
@@ -588,6 +603,7 @@ files:
 - sig/bidi2pdf/result_collector.rbs
 - sig/bidi2pdf/schema.rbs
 - sig/bidi2pdf/session_registry.rbs
+- sig/bidi2pdf/session_registry/heartbeat.rbs
 - sig/bidi2pdf/session_runner.rbs
 - sig/bidi2pdf/session_sweeper.rbs
 - sig/bidi2pdf/session_warmer.rbs