ruby_llm-browser 0.1.0

data/docs/_config.yml

@@ -0,0 +1,109 @@
+title: "RubyLLM::Browser"
+description: "An unofficial RubyLLM extension for offline bounded browser inspection and schema-checked extraction."
+tagline: "Policy-bound browser tools for RubyLLM"
+url: https://rubyllm-browser.wangyaodi.com
+baseurl: ""
+lang: en-US
+repository: yorzi/ruby_llm-browser
+
+theme: jekyll-vitepress-theme
+
+markdown: kramdown
+kramdown:
+  input: GFM
+  syntax_highlighter_opts:
+    block:
+      line_numbers: false
+permalink: pretty
+
+collections:
+  getting_started:
+    permalink: "/:name/"
+    output: true
+  core_features:
+    permalink: "/:name/"
+    output: true
+  advanced:
+    permalink: "/:name/"
+    output: true
+  reference:
+    permalink: "/:name/"
+    output: true
+
+defaults:
+  - scope:
+      path: ""
+    values:
+      layout: default
+      jekyll_vitepress:
+        auto_title: false
+
+jekyll_vitepress:
+  seo:
+    page_type: TechArticle
+    publisher:
+      type: Organization
+      name: "RubyLLM::Browser"
+      url: https://rubyllm-browser.wangyaodi.com
+      same_as:
+        - https://github.com/yorzi/ruby_llm-browser
+  llms:
+    title: RubyLLM::Browser Documentation
+    description: "An unofficial RubyLLM extension for offline bounded browser inspection and schema-checked extraction."
+    full: true
+  branding:
+    site_title: "RubyLLM::Browser"
+  typography:
+    body_font_family: "'Inter', ui-sans-serif, system-ui, -apple-system, 'Segoe UI', sans-serif"
+    code_font_family: "'IBM Plex Mono', ui-monospace, monospace"
+    google_fonts_url: "https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:ital,wght@0,400;0,500;0,700;1,400&family=Inter:wght@300;400;500;600;700;900&display=swap"
+  syntax:
+    light_theme: github
+    dark_theme: github.dark
+  github_star:
+    enabled: true
+    repository: yorzi/ruby_llm-browser
+    text: Star
+    show_count: true
+  footer:
+    enabled: true
+    show_on_docs: false
+    message: "Released under the MIT License."
+    copyright: "Copyright © 2026 Andy Wang"
+  doc_footer:
+    enabled: true
+    previous_label: Previous page
+    next_label: Next page
+  last_updated:
+    enabled: true
+    text: Last updated
+    format: "%-d %b %Y"
+  edit_link:
+    enabled: true
+    pattern: https://github.com/yorzi/ruby_llm-browser/edit/main/docs/:path
+    text: Edit this page on GitHub
+
+plugins:
+  - jekyll-redirect-from
+  - jekyll-vitepress-theme
+
+exclude:
+  - bin
+  - vendor
+  - _site
+  - Gemfile
+  - Gemfile.lock
+  - README.md
+  - RELEASE_ACTION_PLAN.md
+  - SPEC_BASELINE.md
+  - WORK.md
+
+# The language of code examples; `project-docs` uses it for new pages.
+code_language: ruby
+
+# Values that change between releases. Pages read them as {{ site.version }}
+# and {{ site.examples.NAME }}. Keep `released: false` on main; the docs builder
+# reads a release's version from its matching Git tag.
+released: false
+version: "0.1.0"
+examples: {}

data/docs/_core_features/inspect-extract.md

@@ -0,0 +1,91 @@
+---
+layout: default
+title: Inspecting and extracting
+nav_order: 1
+description: Inspect allowlisted pages and extract data with a host-pinned JSON Schema.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* What Inspect returns and what it does not do.
+* How Extract uses a schema chosen by the host.
+* How tool hashes differ from direct Engine results.
+
+## Create the Read-only Tools
+
+The [offline example in Getting Started]({% link _getting_started/getting-started.md %}) creates a context and a fixed schema. Pass those objects when you construct the tools:
+
+```ruby
+require "ruby_llm/browser"
+
+class OfflineResolver
+  def getaddresses(_host) = [ "93.184.216.34" ]
+end
+
+context = RubyLLM::Browser::Context.new(
+  actor_id: "demo-actor", run_id: "demo-run",
+  backend: RubyLLM::Browser::FakeBackend.new,
+  source_policy: RubyLLM::Browser::Policy.new(
+    allowed_hosts: [ "docs.example.com" ], resolver: OfflineResolver.new
+  ),
+  operation_store: RubyLLM::Browser::InMemoryOperationStore.new
+)
+schema = {
+  "type" => "object",
+  "properties" => { "title" => { "type" => "string" } },
+  "required" => [ "title" ], "additionalProperties" => false
+}
+
+inspect_tool = RubyLLM::Browser::Inspect.new(context: context)
+extract_tool = RubyLLM::Browser::Extract.new(context: context, schema: schema)
+
+puts inspect_tool.execute(url: "https://docs.example.com/")[:status] # => ok
+puts extract_tool.execute(url: "https://docs.example.com/")[:data]   # => {"title"=>"Example"}
+```
+
+The tool returns a `Hash` with string status values. The fake backend used in the linked
+example supplies the exact sample output above. In an application, register these tool
+instances on a configured RubyLLM chat. The host should select the context and schema;
+the model supplies only the URL, optional instruction, and an optional positive
+`max_bytes` limit.
+
+## Inspect a Page
+
+`Inspect` navigates to one approved URL and asks the backend for observations. It does
+not click, type, submit forms, run arbitrary JavaScript, or download files. Its
+observations can still contain hostile instructions, false claims, or sensitive data.
+Treat them as untrusted evidence.
+
+## Extract a Known Shape
+
+`Extract` receives its JSON Schema when the host constructs the tool. The model cannot
+replace or widen that schema. The policy checks schema size, depth, property count, and
+supported keywords. Provider output is validated against the schema before it is
+redacted and bounded. A mismatched response is an error, not a successful extraction.
+
+Both tools accept an optional `instruction` to focus the operation and an optional
+`max_bytes` value. That value can tighten the policy and remaining operation limit, but
+cannot raise either limit. A successful status does not prove that a page claim is true.
+
+## Read the Result
+
+`Tool#execute` and RubyLLM `Tool#call` return hashes. A direct call to `Engine#inspect`
+or `Engine#extract` returns a `Result` object. Both forms include status and provenance.
+Check the status before consuming data. `truncated` is bounded output, while
+`unknown` and `cleanup_pending` need host review.
+
+`Act` is an opt-in offline simulation. It does not dispatch a real browser action. Read
+[Simulating approved actions]({% link _core_features/offline-act.md %}) to issue a host
+grant and use the FakeBackend contract. The full live Act protocol is deferred to a
+later version.
+
+## Next Steps
+
+* [Controlling source access]({% link _core_features/source-policy.md %}) - define allowed destinations.
+* [Bounding operation work]({% link _core_features/operation-lifecycle.md %}) - set budgets and store lifecycle state.
+* [API and configuration reference]({% link _reference/api-reference.md %}) - review fields and error codes.

data/docs/_core_features/offline-act.md

@@ -0,0 +1,110 @@
+---
+layout: default
+title: Simulating approved actions
+nav_order: 4
+description: Simulate one host-approved browser action with FakeBackend.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* How the host issues and revokes an action grant.
+* Which action details the grant binds.
+* Why this simulation does not authorize a live browser action.
+
+A model can propose a click, but the host must decide whether that exact action is
+allowed. `FakeBackend` lets you exercise that approval flow without opening a browser or
+making a network request.
+
+## Issue a Grant and Run the Simulation
+
+Create the approval from the same action and URL that you pass to `Act`. Use host-owned
+actor and run identifiers. Do not take those values from model output.
+
+```ruby
+require "ruby_llm/browser"
+
+class OfflineResolver
+  def getaddresses(_host) = [ "93.184.216.34" ]
+end
+
+policy = RubyLLM::Browser::Policy.new(
+  allowed_hosts: [ "docs.example.com" ], resolver: OfflineResolver.new
+)
+approval_store = RubyLLM::Browser::InMemoryApprovalStore.new
+context = RubyLLM::Browser::Context.new(
+  actor_id: "demo-actor", run_id: "demo-run",
+  backend: RubyLLM::Browser::FakeBackend.new,
+  source_policy: policy,
+  operation_store: RubyLLM::Browser::InMemoryOperationStore.new,
+  approval_store: approval_store
+)
+
+url = policy.authorize_destination!("https://docs.example.com/").to_s
+action = policy.authorize_action!({ "method" => "click", "selector" => "a#docs" })
+approval = RubyLLM::Browser::Approval.for_action(
+  actor_id: context.actor_id, run_id: context.run_id,
+  url: url, action: action, ttl: 60, now: context.now
+)
+approval_store.issue(approval)
+
+act = RubyLLM::Browser::Act.new(context: context)
+result = act.execute(
+  url: url, approval_id: approval.id, method: "click", selector: "a#docs"
+)
+
+puts result[:status] # => "ok"
+puts result.dig(:locator, "approval_id") # => approval.id
+```
+
+The example uses one active grant. It does not call a model. `Act` is opt-in and is not
+registered by default.
+
+## Bind the Grant to the Request
+
+`Policy#authorize_action!` returns a canonical hash with `description`, `method`,
+`selector`, and `arguments`. The method is lowercase. Empty descriptions default to
+`"#{method} #{selector}"`; arguments are strings. A grant digest uses sorted-key,
+compact JSON for this normalized hash. The URL is the exact authorized URL returned by
+`Policy#authorize_destination!(url).to_s`.
+
+The host creates the grant with `Approval.for_action` and stores it with
+`ApprovalStore#issue`. It can revoke the grant with `ApprovalStore#revoke(id)` before
+the action consumes it. A grant expires when `now >= expires_at`. It cannot authorize a
+different actor, run, URL, or normalized action. Reads by the tool's resolver do not
+consume it. `consume_once` checks and marks the grant consumed atomically immediately
+before FakeBackend records the action.
+
+If two calls compete for one valid grant, one returns `ok`, one returns `APPROVAL_STALE`,
+and FakeBackend records one action. A durable store must preserve this result across
+workers and database connections. `InMemoryApprovalStore` is process-local; use a
+durable store for a multi-worker host.
+
+## Read Denial Results
+
+| Condition | Result |
+| --- | --- |
+| The context has no approval store or the ID is unknown | `APPROVAL_REQUIRED` |
+| The grant expired, was revoked or consumed, or does not match the request | `APPROVAL_STALE` |
+| Policy denies the action or URL | `NOT_AUTHORIZED` |
+
+Each denial records no simulated action. Check the returned `status` and `error.code`
+before using a result.
+
+## Know the Boundary
+
+The fake backend records an in-process action fixture. It does not click a page, change a
+website, or prove live authorization. First-release grants leave `page_revision`,
+`operation_id`, and `session_id` unset. The full live Act protocol needs a grant bound to
+the current page target and browser session; it is deferred to a later version. See
+[the security model]({% link SECURITY_MODEL.md %}) and [provider qualification]({% link _advanced/live-backend-qualification.md %}).
+
+## Next Steps
+
+* [Inspect and extract]({% link _core_features/inspect-extract.md %}) - read and structure offline page observations.
+* [Control source access]({% link _core_features/source-policy.md %}) - define the host allowlist.
+* [Review the operation lifecycle]({% link _core_features/operation-lifecycle.md %}) - handle reservations and cleanup states.

data/docs/_core_features/operation-lifecycle.md

@@ -0,0 +1,63 @@
+---
+layout: default
+title: Bounding operation work
+nav_order: 3
+description: Limit browser work by time, steps, retained bytes, and actor concurrency.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* Which limits a `Budget` applies to an operation.
+* How operation states prevent unsafe retries.
+* When a durable store and independent reaper are required.
+
+## Set a Budget
+
+Each context receives a `Budget`. Defaults are 60 seconds, 12 provider steps, 262,144
+retained bytes, and one concurrent operation per actor. A smaller budget can cap one
+workflow:
+
+```ruby
+require "ruby_llm/browser"
+
+budget = RubyLLM::Browser::Budget.new(
+  max_seconds: 30, max_steps: 6, max_bytes: 32_768,
+  max_concurrent: 1, max_cost_usd: 0.25
+)
+puts budget.to_h
+```
+
+Steps count navigation, observation, extraction, and action calls. Byte limits count
+retained sanitized result data, not all bytes the remote browser receives. The optional
+`max_cost_usd` value is advisory metadata. It is not a provider billing cap.
+
+## Track an Operation
+
+An operation is claimed before it starts. The Engine records state changes, step and byte
+usage, session identity, and cleanup status. A duplicate start cannot run the same
+operation again. SDK retries are disabled, and unknown outcomes are not automatically
+replayed.
+
+The in-memory store is useful for examples or a single process. It does not survive a
+restart or coordinate workers. Use the Rails adapter or implement a durable
+`OperationStore` when operations can outlive a process. Keep `unknown` and
+`cleanup_pending` operations visible and retain their quota until closure is confirmed.
+
+## Reap Independently
+
+Cancellation fences workers but cannot undo a request already in flight. A reaper should
+run on an independent schedule so it can reconcile and close known sessions after a job
+worker exits. Provider time passing is not proof that a session closed or stopped
+incurring costs.
+
+The Rails adapter and its scheduling requirements are described in [Running work in Rails]({% link _advanced/rails-integration.md %}). Result limits and status meanings are in the [API reference]({% link _reference/api-reference.md %}).
+
+## Next Steps
+
+* [Running work in Rails]({% link _advanced/rails-integration.md %}) - persist operations across workers.
+* [API and configuration reference]({% link _reference/api-reference.md %}) - inspect status fields and defaults.

data/docs/_core_features/source-policy.md

@@ -0,0 +1,61 @@
+---
+layout: default
+title: Controlling source access
+nav_order: 2
+description: Restrict navigation to approved public hosts, schemes, and ports.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* How the host allowlist matches names.
+* Which URL checks happen before a backend starts.
+* Why a Ruby URL allowlist does not replace browser-side egress control.
+
+## Allow a Destination
+
+The host creates a `Policy` and supplies it through the operation context. Exact host
+names make the intended scope clear. This offline check injects a resolver so it makes no
+DNS request:
+
+```ruby
+require "ruby_llm/browser"
+
+class OfflineResolver
+  def getaddresses(_host) = [ "93.184.216.34" ]
+end
+
+policy = RubyLLM::Browser::Policy.new(
+  allowed_hosts: [ "docs.example.com" ], resolver: OfflineResolver.new
+)
+puts policy.authorize_destination!("https://docs.example.com/").host
+# => "docs.example.com"
+```
+
+The default scheme allowlist is HTTP and HTTPS, and the default ports are 80 and 443.
+DNS verification is enabled. Public address checks reject loopback, private, link-local,
+multicast, documentation, and cloud metadata ranges. A wildcard such as
+`*.example.com` matches subdomains and does not allow the bare `example.com` host.
+
+## Keep Host and Browser Policy Aligned
+
+The host allowlist checks the requested destination before navigation. It cannot
+sandbox a remote browser. Provider-side enforcement must also cover DNS at connection
+time, redirects, frames, popups, WebSockets, scripts, and all other subresources. Pages
+can initiate requests even when the gem only observes them.
+
+The backend must report enforced egress isolation before a live session can start.
+The built-in `StagehandBackend` always reports `:unverified` and refuses live calls in
+the first release. No caller option can override that posture. A custom backend must
+provide its own enforceable egress control; a host assertion does not install a firewall
+or prove provider behavior. See [backend qualification]({% link _advanced/live-backend-qualification.md %}) before selecting a live backend.
+
+## Next Steps
+
+* [Inspecting and extracting]({% link _core_features/inspect-extract.md %}) - use the read-only tools.
+* [Configuration]({% link _getting_started/configuration.md %}) - keep policy and identity host-owned.
+* [Security model]({% link SECURITY_MODEL.md %}) - review trust boundaries and open limits.

data/docs/_data/navigation.yml

@@ -0,0 +1,12 @@
+- title: Guides
+  url: /getting-started/
+  collections:
+    - getting_started
+    - core_features
+    - advanced
+- title: Reference
+  url: /api-reference/
+  collections:
+    - reference
+- title: Releases
+  url: https://github.com/yorzi/ruby_llm-browser/releases

data/docs/_data/sidebar.yml

@@ -0,0 +1,8 @@
+- title: Start Here
+  collection: getting_started
+- title: Core Features
+  collection: core_features
+- title: Advanced
+  collection: advanced
+- title: Reference
+  collection: reference

data/docs/_data/social_links.yml

@@ -0,0 +1,3 @@
+- icon: github
+  url: https://github.com/yorzi/ruby_llm-browser
+  label: GitHub

data/docs/_getting_started/configuration.md

@@ -0,0 +1,68 @@
+---
+layout: default
+title: Configuration
+nav_order: 3
+description: Set process defaults while keeping identity, authorization, schemas, and credentials in the host.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* Which process-wide defaults RubyLLM::Browser can hold.
+* Which trusted values belong in each `Context` and `Policy`.
+* Why backend credentials and extraction schemas stay outside model arguments.
+
+## Set Process Defaults
+
+`RubyLLM::Browser.configure` sets defaults for new objects. Existing contexts and
+policies keep the values they received when they were created.
+
+```ruby
+require "ruby_llm/browser"
+
+RubyLLM::Browser.configure do |config|
+  config.default_budget = RubyLLM::Browser::Budget.new(max_seconds: 30, max_steps: 6)
+  config.max_result_bytes = 32_768
+end
+
+policy = RubyLLM::Browser::Policy.new(allowed_hosts: [ "docs.example.com" ])
+```
+
+The gem does not load provider credentials from the environment when you require it.
+The host creates the backend and passes it to every context. The `configuration.backend`
+slot is reserved for host integration and is not a fallback used by `Context`.
+
+## Choose a Source Policy
+
+Pass exact host names when possible. A pattern such as `*.example.com` allows matching
+subdomains but not the bare `example.com` host. The defaults allow HTTP and HTTPS on
+ports 80 and 443. DNS verification is enabled by default. Keep it enabled for real use;
+inject a resolver only in controlled offline fixtures.
+
+`Policy` also sets `max_result_bytes`, extraction schema limits, and the set of allowed
+action methods for the experimental Act path. Browser-side egress must separately cover
+redirects, frames, popups, WebSockets, assets, and other subresources before any live
+backend can be used. The built-in Stagehand adapter remains unsupported in this release.
+
+## Defaults and Ownership
+
+| Setting | Default | Owner |
+| --- | --- | --- |
+| `default_budget` | 60 seconds, 12 steps, 262,144 bytes, 1 concurrent operation, no cost estimate | Host process |
+| `max_result_bytes` | 65,536 bytes | Host process and new policies |
+| `clock` | `Time.now.utc` | Host process or context |
+| `logger` | RubyLLM logger when present, otherwise a warning-level stderr logger | Host process |
+| `backend` | `nil`, unused as a fallback | Host; pass explicitly to `Context` |
+
+`Budget#max_cost_usd` is advisory metadata. It does not enforce provider billing. The
+host must also reauthorize the actor and run when creating a context, including from a
+background job. For all context and policy options, see the [API and configuration reference]({% link _reference/api-reference.md %}).
+
+## Next Steps
+
+* [Controlling source access]({% link _core_features/source-policy.md %}) - review URL and DNS rules.
+* [Bounding operation work]({% link _core_features/operation-lifecycle.md %}) - understand limits and cleanup.

data/docs/_getting_started/getting-started.md

@@ -0,0 +1,77 @@
+---
+layout: default
+title: Getting Started
+nav_order: 1
+description: Install the gem and run a read-only operation with its offline backend.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* How to install the published gem or the current source version.
+* How to run Inspect and Extract without a provider or network request.
+* Where to review live-provider limitations.
+
+## Installation
+
+The stable release is `{{ site.version }}`. Add it to your Gemfile:
+
+```ruby
+gem "ruby_llm-browser", "~> {{ site.version }}"
+```
+
+For unreleased development changes, install the default branch instead:
+
+```sh
+bundle add ruby_llm-browser --git https://github.com/yorzi/ruby_llm-browser --branch main
+```
+
+Use Ruby 3.2 or later. The gem supports RubyLLM `>= 2.0, < 3` and pins Stagehand to the
+3.21.x series. Rails is optional and is not loaded by the core entry point. See
+[configuration]({% link _getting_started/configuration.md %}) for host-owned settings.
+
+## Run a Read-only Operation Offline
+
+This complete example needs no credentials and makes no network request. Its resolver
+returns a public test address so URL policy can be exercised without DNS.
+
+```ruby
+require "ruby_llm/browser"
+
+class OfflineResolver
+  def getaddresses(_host) = [ "93.184.216.34" ]
+end
+
+context = RubyLLM::Browser::Context.new(
+  actor_id: "demo-actor", run_id: "demo-run",
+  backend: RubyLLM::Browser::FakeBackend.new,
+  source_policy: RubyLLM::Browser::Policy.new(
+    allowed_hosts: [ "docs.example.com" ], resolver: OfflineResolver.new
+  ),
+  operation_store: RubyLLM::Browser::InMemoryOperationStore.new
+)
+schema = {
+  "type" => "object",
+  "properties" => { "title" => { "type" => "string" } },
+  "required" => [ "title" ], "additionalProperties" => false
+}
+
+inspect_tool = RubyLLM::Browser::Inspect.new(context: context)
+extract_tool = RubyLLM::Browser::Extract.new(context: context, schema: schema)
+puts inspect_tool.execute(url: "https://docs.example.com/")[:status] # => ok
+puts extract_tool.execute(url: "https://docs.example.com/")[:data]   # => {"title"=>"Example"}
+```
+
+`FakeBackend` supplies deterministic responses. The built-in Stagehand adapter is not
+supported for live operations in this release. Use a custom backend only after you have
+reviewed the [security boundaries]({% link _advanced/live-backend-qualification.md %}).
+
+## Next Steps
+
+* [How RubyLLM::Browser Works]({% link _getting_started/overview.md %}) - follow the objects through an operation.
+* [Configuration]({% link _getting_started/configuration.md %}) - set process defaults and build a trusted context.
+* [Inspecting and extracting]({% link _core_features/inspect-extract.md %}) - register tools and interpret their results.

data/docs/_getting_started/overview.md

@@ -0,0 +1,52 @@
+---
+layout: default
+title: How RubyLLM::Browser Works
+nav_order: 2
+description: See how trusted host inputs, tools, policy, backends, and operation stores fit together.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* Which objects the host creates and which inputs the model can supply.
+* How a tool call moves through policy checks and the backend.
+* Which result and lifecycle guarantees the gem provides.
+
+## The Public API
+
+The host creates a `Context` for an authenticated actor and run. It supplies the backend,
+source policy, operation store, optional approval store, and budget. The model does not
+choose those objects.
+
+`Inspect` observes an allowlisted page. `Extract` reads fields using a schema fixed by
+the host when the tool is constructed. The tools return hashes that RubyLLM can pass to
+the model. Direct calls to `Engine#inspect` and `Engine#extract` return a `Result` object.
+
+## How It Fits Together
+
+The Engine checks the destination and backend capability before a session starts. It
+reserves and updates an operation, tracks time, steps, and retained bytes, then asks the
+backend to navigate and observe or extract. The Engine attempts session cleanup before
+it returns. If the remote outcome or cleanup cannot be confirmed, the operation remains
+`unknown` or `cleanup_pending`; it is not treated as a successful result.
+
+`Policy` controls URL destinations, extraction schemas, output limits, and the restricted
+Act simulation. `FakeBackend` runs without network access and is the only supported
+backend in the first release. `StagehandBackend` adapts the Stagehand Ruby SDK but refuses
+live operations until provider egress and cleanup are qualified. In-memory stores are
+useful for a single process and offline examples; use the Rails adapter or another durable
+store when work must survive restarts or worker changes.
+
+The output is evidence with provenance, not a verified statement of fact. Page content
+can be adversarial and can initiate requests inside the remote browser even when the gem
+does not click or submit forms.
+
+## Next Steps
+
+* [Getting Started]({% link _getting_started/getting-started.md %}) - install and run the offline example.
+* [Configuration]({% link _getting_started/configuration.md %}) - choose host-owned defaults.
+* [API and configuration reference]({% link _reference/api-reference.md %}) - see options, statuses, and result fields.