bidi2pdf 0.1.15 → 0.1.17

data/sig/bidi2pdf/error_codes.rbs

@@ -0,0 +1,21 @@
+module Bidi2pdf
+  # Maps an exception to the stable, machine-readable code used by --json/--json-stream/manifests
+  # and recipe results. Derived from the existing Bidi2pdf::Error hierarchy rather than duplicated
+  # beside it: a new failure mode gets a new subclass in lib/bidi2pdf.rb and a row here, never a
+  # bare string minted ad hoc.
+  #
+  # MAPPING is ordered most-specific-subclass first - #for walks it in order and returns the first
+  # match, so a subclass must appear before any of its ancestors.
+  module ErrorCodes
+    MAPPING: ::Hash[untyped, "MISSING_INPUT" | "MULTIPLE_INPUT_SOURCES" | "EMPTY_INPUT" | "INVALID_CONFIG" | "INVALID_PRINT_OPTION" | "INVALID_RECIPE" | "PDF_INSPECTION_UNAVAILABLE" | "BROWSER_LAUNCH_FAILED" | "COMMAND_TIMEOUT" | "BROWSER_DISCONNECTED" | "NAVIGATION_TIMEOUT" | "NAVIGATION_AUTH" | "NAVIGATION_NOT_FOUND" | "DNS_ERROR" | "NAVIGATION_FAILED" | "SELECTOR_NOT_FOUND" | "PAGE_NOT_AS_EXPECTED" | "SCRIPT_ERROR" | "STYLE_ERROR" | "PDF_GENERATION_FAILED" | "SCREENSHOT_FAILED" | "OUTPUT_WRITE_FAILED" | "INTERNAL_ERROR"]
+
+    DEFAULT_CODE: "INTERNAL_ERROR"
+
+    def self.for: (untyped exception) -> untyped
+
+    # Builds the {code:, message:, retryable:, hint:, details:} hash used as Result#error and in
+    # recipe action/assertion failures. Works for any StandardError, not only a Bidi2pdf::Error -
+    # an unexpected exception still gets INTERNAL_ERROR with retryable/hint defaulted safely.
+    def self.describe: (untyped exception, ?details: ::Hash[untyped, untyped]) -> { code: untyped, message: untyped, retryable: untyped, hint: untyped, details: untyped }
+  end
+end

data/sig/bidi2pdf/exit_codes.rbs

@@ -0,0 +1,21 @@
+module Bidi2pdf
+  # Maps an ErrorCodes string to the process exit status the CLI reports. Centralized here so
+  # render/diagnose/run share one table instead of each re-deciding what a given failure is worth.
+  module ExitCodes
+    SUCCESS: 0
+
+    CLI_ERROR: 2
+
+    BROWSER_ERROR: 3
+
+    PAGE_NOT_AS_EXPECTED: 4
+
+    OUTPUT_ERROR: 6
+
+    INTERNAL_ERROR: 70
+
+    CODE_TO_EXIT: { "MISSING_INPUT" => untyped, "MULTIPLE_INPUT_SOURCES" => untyped, "EMPTY_INPUT" => untyped, "INVALID_CONFIG" => untyped, "INVALID_PRINT_OPTION" => untyped, "INVALID_RECIPE" => untyped, "PDF_INSPECTION_UNAVAILABLE" => untyped, "BROWSER_LAUNCH_FAILED" => untyped, "BROWSER_DISCONNECTED" => untyped, "COMMAND_TIMEOUT" => untyped, "NAVIGATION_FAILED" => untyped, "NAVIGATION_TIMEOUT" => untyped, "NAVIGATION_AUTH" => untyped, "NAVIGATION_NOT_FOUND" => untyped, "DNS_ERROR" => untyped, "SELECTOR_NOT_FOUND" => untyped, "PAGE_NOT_AS_EXPECTED" => untyped, "SCRIPT_ERROR" => untyped, "STYLE_ERROR" => untyped, "PDF_GENERATION_FAILED" => untyped, "SCREENSHOT_FAILED" => untyped, "OUTPUT_WRITE_FAILED" => untyped, "INTERNAL_ERROR" => untyped }
+
+    def self.for: (untyped code) -> untyped
+  end
+end

data/sig/bidi2pdf/launcher.rbs

@@ -62,11 +62,20 @@ module Bidi2pdf
 
     @chrome_args: untyped
 
+    @diagnose_runner: untyped
+
     # rubocop:disable Metrics/ParameterLists
     def initialize: (url: untyped, inputfile: untyped, output: untyped, cookies: untyped, headers: untyped, auth: untyped, ?headless: bool, ?port: ::Integer, ?wait_window_loaded: bool, ?wait_network_idle: bool, ?print_options: ::Hash[untyped, untyped], ?remote_browser_url: untyped?, ?network_log_format: ::Symbol, ?chrome_args: untyped) -> void
 
     def launch: () -> untyped
 
+    # Like #launch, but navigates only (see SessionRunner#run_diagnose) and leaves the tab open -
+    # used by `bidi2pdf diagnose`, which has no PDF to produce. #stop closes it, same as it stops
+    # everything else #launch/#diagnose started.
+    #
+    # @return [Bidi2pdf::Bidi::BrowserTab] the navigated tab.
+    def diagnose: () -> untyped
+
     def stop: () -> untyped
 
     private

data/sig/bidi2pdf/manifest.rbs

@@ -0,0 +1,38 @@
+module Bidi2pdf
+  # Builds the render manifest (--manifest FILE) from a completed Bidi2pdf::Result plus the
+  # input/browser/header context around it. Redacts secret-
+  # bearing headers and never records cookie values at all.
+  class Manifest
+    @result: untyped
+
+    @input: untyped
+
+    @headers: untyped
+
+    @navigation_duration_ms: untyped
+
+    @browser: untyped
+
+    SCHEMA_VERSION: 1
+
+    REDACT_HEADER_NAMES: ::Array["authorization" | "proxy-authorization" | "cookie" | "set-cookie" | "x-api-key" | "api-key"]
+
+    SENSITIVE_SUBSTRINGS: ::Array["token" | "secret" | "password" | "authorization" | "api-key" | "apikey"]
+
+    def initialize: (result: untyped, input: untyped, ?headers: ::Hash[untyped, untyped], ?navigation_duration_ms: untyped?, ?browser: ::Hash[untyped, untyped]) -> void
+
+    def self.redact: (untyped headers) -> untyped
+
+    def self.sensitive?: (untyped key) -> untyped
+
+    def to_h: () -> untyped
+
+    def to_json: (*untyped) -> untyped
+
+    private
+
+    def output_section: () -> { path: untyped, pages: untyped, bytes: untyped, sha256: untyped }
+
+    def navigation_section: () -> untyped
+  end
+end

data/sig/bidi2pdf/notifications/json_subscriber.rbs

@@ -0,0 +1,45 @@
+module Bidi2pdf
+  module Notifications
+    # Emits one JSON object per line to an IO (stderr for --json-stream, docs/specs/llm-friendly-
+    # spec.md section 7) as a render progresses, by subscribing to the same Bidi2pdf::Notifications
+    # events Bidi2pdf::ResultCollector and LoggingSubscriber already use - no new instrumentation
+    # points needed. #emit_result writes the final "result" event once the caller has a Result.
+    class JsonSubscriber
+      @io: untyped
+
+      @start: untyped
+
+      @registered: untyped
+
+      SCHEMA_VERSION: 1
+
+      def initialize: (?io: untyped) -> void
+
+      def emit_result: (untyped result) -> untyped
+
+      def unsubscribe: () -> untyped
+
+      private
+
+      def now_ms: () -> untyped
+
+      def elapsed_ms: () -> untyped
+
+      def subscribe: () -> untyped
+
+      def on_navigate: (untyped event) -> untyped
+
+      def on_page_loaded: (untyped _event) -> untyped
+
+      def on_network_idle: (untyped _event) -> untyped
+
+      def on_console: (untyped event) -> untyped
+
+      def on_print: (untyped _event) -> untyped
+
+      def on_screenshot: (untyped _event) -> untyped
+
+      def write: (untyped fields) -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/pdf_inspection.rbs

@@ -0,0 +1,33 @@
+module Bidi2pdf
+  # Lazy, optional wrapper around the pdf-reader gem. pdf-reader is deliberately NOT a bidi2pdf
+  # runtime dependency - render works fine without it,
+  # just with `pages` left nil and a warning, and a recipe assertion that needs it fails
+  # INVALID_RECIPE at validation time rather than crashing mid-render. The official Docker images
+  # (docker/Dockerfile, docker/Dockerfile.slim) install it, so a render inside one of them - the
+  # environment an agent or CI job actually uses - always has page counts and PDF assertions
+  # available without anyone opting in by hand.
+  module PdfInspection
+    self.@available: untyped
+
+    def self.available?: () -> untyped
+
+    # @param bytes [String, nil] raw PDF bytes.
+    # @return [Integer, nil] page count, or nil when pdf-reader is unavailable, bytes is nil,
+    #   or the PDF is malformed.
+    def self.page_count: (untyped bytes) -> untyped
+
+    # @param bytes [String, nil] raw PDF bytes.
+    # @return [String, nil] extracted text across all pages, joined with newlines.
+    def self.text: (untyped bytes) -> untyped
+
+    # Clears the memoized availability check - test-only, so a spec can exercise both branches
+    # of #available? regardless of load order elsewhere in the process.
+    def self.reset_for_testing!: () -> (untyped | nil)
+
+    private
+
+    def self.load_pdf_reader: () -> untyped
+
+    def self.reader_for: (untyped bytes) -> untyped
+  end
+end

data/sig/bidi2pdf/recipe/loader.rbs

@@ -0,0 +1,20 @@
+module Bidi2pdf
+  class Recipe
+    # Reads a recipe file (YAML, or JSON when the extension is .json) into a plain Hash. Never
+    # launches a browser - a malformed file fails right here.
+    #
+    # Security: YAML is parsed with Psych.safe_load and no extra options. Its defaults already
+    # refuse both custom type tags (no arbitrary Ruby object instantiation) and aliases - the
+    # latter matters concretely: a small file using nested YAML anchors/aliases ("billion laughs")
+    # can expand to millions of elements in memory; confirmed live, a 273-byte such file produced
+    # 10 million array elements in under 2ms. Neither aliases nor a Date/Time value are used by any
+    # field a recipe defines, so neither is turned back on "just in case" - only what the format
+    # actually needs is permitted. MAX_BYTES bounds the file itself before it is even parsed.
+    module Loader
+      MAX_BYTES: 1048576
+
+      # rubocop:disable-next Metrics/AbcSize
+      def self.load: (untyped path) -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/recipe/runner.rbs

@@ -0,0 +1,92 @@
+module Bidi2pdf
+  class Recipe
+    # Runs a validated recipe's actions and assertions against a navigated tab. A thin dispatch
+    # over BrowserTab's own methods, not a parallel action/assertion class hierarchy - a step
+    # that needs something BrowserTab cannot do belongs there, not here.
+    class Runner
+      @recipe: untyped
+
+      @tab: untyped
+
+      @collector: untyped
+
+      @state: untyped
+
+      @pdf_bytes: untyped
+
+      # Raised on the first failing action/assertion; #entries carries every step run so far
+      # (successes and the failure itself), for the caller to report in the recipe result.
+      class StepFailure < StandardError
+        @entries: untyped
+
+        @cause: untyped
+
+        attr_reader entries: untyped
+
+        attr_reader cause: untyped
+
+        def initialize: (untyped entries, untyped cause) -> void
+      end
+
+      attr_reader state: untyped
+
+      attr_accessor pdf_bytes: untyped
+
+      # @param recipe [Bidi2pdf::Recipe]
+      # @param tab [Bidi2pdf::Bidi::BrowserTab] a navigated tab (e.g. from Launcher#diagnose)
+      # @param collector [Bidi2pdf::ResultCollector] source of #console/#network_failures -
+      #   exposed live, so assertions can read them mid-run (see ResultCollector's own docs)
+      def initialize: (recipe: untyped, tab: untyped, collector: untyped) -> void
+
+      # @return [Array<Hash>] one entry per action actually run
+      # @raise [StepFailure] on the first failing action
+      def run_actions: () -> untyped
+
+      # @return [Array<Hash>] one entry per assertion actually run
+      # @raise [StepFailure] on the first failing assertion
+      def run_assertions: () -> untyped
+
+      private
+
+      # rubocop:disable-next Metrics/AbcSize
+      def run_steps: (untyped steps) { (untyped, untyped) -> untyped } -> untyped
+
+      def now_ms: () -> untyped
+
+      def elapsed_ms: (untyped start) -> untyped
+
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
+      def dispatch_action: (untyped name, untyped opts) -> untyped
+
+      def action_wait_for: (untyped opts) -> (nil | untyped)
+
+      def wait_for_condition: (untyped opts) -> ("document.querySelector('.pagedjs_page')" | ::String | untyped)
+
+      def action_click: (untyped opts) -> (nil | untyped)
+
+      def action_evaluate: (untyped opts) -> untyped
+
+      # rubocop:disable-next Metrics/CyclomaticComplexity
+      def dispatch_assertion: (untyped name, untyped step) -> untyped
+
+      def assertion_selector_exists: (untyped opts) -> ::Array[untyped | { selector: untyped }]
+
+      def assertion_text_present: (untyped opts) -> ::Array[untyped | { text: untyped }]
+
+      def assertion_no_console_errors: () -> ::Array[untyped]
+
+      # Filtering by resource type (a `types:` option) is not implemented: Bidi2pdf::Bidi::
+      # NetworkEvent carries an HTTP method, not a resource type, so there is nothing to filter
+      # by yet. Every captured failure counts.
+      def assertion_no_network_failures: () -> ::Array[untyped]
+
+      def assertion_fonts_loaded: () -> ::Array[untyped | nil]
+
+      def assertion_page_count: (untyped expected) -> ::Array[untyped | { expected: untyped, actual: untyped }]
+
+      def assertion_pdf_text_present: (untyped opts) -> ::Array[untyped | { text: untyped }]
+
+      def assertion_pdf_not_blank: () -> ::Array[untyped | { page_count: untyped, text_present: untyped }]
+    end
+  end
+end

data/sig/bidi2pdf/recipe/schema_shape.rbs

@@ -0,0 +1,85 @@
+module Bidi2pdf
+  class Recipe
+    # Structural validation against Schema::RECIPE itself, not a hand-duplicated parallel list of
+    # rules. Validator's other #check_* methods each enforce one *semantic* rule (an action name
+    # is known, a source key is truthy, a presence assertion is `true`) with a friendly, specific
+    # message - none of them enforce the schema's own `additionalProperties: false` at every
+    # level, so an extra, unrecognized key sitting alongside an otherwise-valid one used to pass
+    # silently even though `bidi2pdf schema recipe` would reject it (`{url: "...", stdin: false}`,
+    # `{wait_for: {...}, extra: 1}` - two action names in one step, `wait_for: {selector: "#x",
+    # bogus: "y"}`). #check_shape (see Validator) closes that whole class of gap generically by
+    # walking the schema the CLI already publishes, instead of re-describing "what's allowed" a
+    # second time in Ruby - the schema is the one place that description can't drift from itself.
+    #
+    # Deliberately not a general JSON Schema engine and not a gem dependency: only the keywords
+    # Schema::RECIPE actually uses (type, const, enum, required, additionalProperties, properties,
+    # oneOf, anyOf, items, minimum, maximum). Extend the keyword list only if a future schema
+    # branch genuinely needs one this doesn't cover yet.
+    module SchemaShape
+      TYPE_CHECKS: { "object" => untyped, "array" => untyped, "string" => untyped, "integer" => untyped, "number" => untyped, "boolean" => untyped, "null" => untyped }
+
+      CHECKS: ::Array[:const_ok? | :enum_ok? | :type_ok? | :one_of_ok? | :any_of_ok? | :required_ok? | :additional_properties_ok? | :properties_ok? | :items_ok? | :bounds_ok?]
+
+      # @return [Boolean] whether value satisfies schema
+      def self?.matches?: (untyped schema, untyped value) -> untyped
+
+      VIOLATION_CHECKS: ::Array[:oneof_violation | :anyof_violation | :required_violation | :additional_properties_violation | :const_violation | :enum_violation | :type_violation | :bounds_violation | :nested_violation]
+
+      # @return [Hash, nil] {path:, reason:} for the first violation a depth-first walk finds, or
+      #   nil if value already satisfies schema. Not necessarily *the* most relevant violation
+      #   when several exist at once - good enough to point an agent at the right neighborhood,
+      #   not a substitute for reading `bidi2pdf schema recipe` for the exact shape.
+      def self?.first_violation: (untyped schema, untyped value, ?untyped path) -> (nil | untyped | { path: untyped, reason: "does not match the schema" })
+
+      def self?.const_ok?: (untyped schema, untyped value) -> untyped
+
+      def self?.enum_ok?: (untyped schema, untyped value) -> untyped
+
+      def self?.type_ok?: (untyped schema, untyped value) -> (true | untyped)
+
+      def self?.one_of_ok?: (untyped schema, untyped value) -> (true | untyped)
+
+      def self?.any_of_ok?: (untyped schema, untyped value) -> (true | untyped)
+
+      def self?.required_ok?: (untyped schema, untyped value) -> (true | untyped)
+
+      def self?.additional_properties_ok?: (untyped schema, untyped value) -> (true | untyped)
+
+      def self?.properties_ok?: (untyped schema, untyped value) -> (true | untyped)
+
+      def self?.items_ok?: (untyped schema, untyped value) -> (true | untyped)
+
+      def self?.bounds_ok?: (untyped schema, untyped value) -> (true | untyped)
+
+      def self?.display_path: (untyped path) -> untyped
+
+      # When zero branches match but exactly one is "plausible" (its own required key(s) are
+      # present, ignoring additionalProperties), recurse into that one branch for a specific
+      # reason/path instead of a bare "matched 0 of N" - this is what turns "actions[0] doesn't
+      # match any known action" into "actions[0].wait_for: unknown key(s): bogus".
+      def self?.oneof_violation: (untyped schema, untyped value, untyped path) -> (nil | untyped)
+
+      def self?.single_plausible_violation: (untyped schema, untyped value, untyped path) -> (nil | untyped)
+
+      def self?.anyof_violation: (untyped schema, untyped value, untyped path) -> (nil | { path: untyped, reason: ::String })
+
+      def self?.required_violation: (untyped schema, untyped value, untyped path) -> (nil | { path: untyped, reason: ::String })
+
+      def self?.additional_properties_violation: (untyped schema, untyped value, untyped path) -> (nil | { path: untyped, reason: ::String })
+
+      def self?.const_violation: (untyped schema, untyped value, untyped path) -> (nil | { path: untyped, reason: ::String })
+
+      def self?.enum_violation: (untyped schema, untyped value, untyped path) -> (nil | { path: untyped, reason: ::String })
+
+      def self?.type_violation: (untyped schema, untyped value, untyped path) -> (nil | { path: untyped, reason: ::String })
+
+      def self?.bounds_violation: (untyped schema, untyped value, untyped path) -> (nil | { path: untyped, reason: ::String })
+
+      def self?.nested_violation: (untyped schema, untyped value, untyped path) -> untyped
+
+      def self?.properties_violation: (untyped schema, untyped value, untyped path) -> (nil | untyped)
+
+      def self?.items_violation: (untyped schema, untyped value, untyped path) -> (nil | untyped)
+    end
+  end
+end

data/sig/bidi2pdf/recipe/validator.rbs

@@ -0,0 +1,54 @@
+module Bidi2pdf
+  class Recipe
+    # Validates a loaded recipe against the schema `bidi2pdf schema recipe` publishes, before any
+    # browser is launched - `bidi2pdf run --validate` runs exactly this and nothing else. Every
+    # failure is Bidi2pdf::InvalidRecipeError (or Bidi2pdf::PdfInspectionUnavailableError for a
+    # PDF assertion without pdf-reader installed), details carrying a `path` an agent can act on
+    # directly.
+    class Validator
+      @recipe: untyped
+
+      def initialize: (untyped recipe) -> void
+
+      def validate!: () -> untyped
+
+      private
+
+      def check_version: () -> (nil | untyped)
+
+      def check_top_level_keys: () -> (nil | untyped)
+
+      def check_source: () -> untyped
+
+      def check_steps: (untyped section, untyped steps, untyped known) -> untyped
+
+      # Mirrors Schema::RECIPE_ACTIONS' own wait_for oneOf: exactly one of selector/paged_js/script.
+      # --validate runs this check itself rather than relying on Runner#wait_for_condition, whose
+      # own "needs one of" error only fires mid-run (after a browser is already launched) and does
+      # not catch "more than one given" at all - it just silently prefers paged_js, then selector.
+      def check_wait_for_conditions: () -> untyped
+
+      # Mirrors Schema::RECIPE_ASSERT's own const: true for the 4 presence-only assertions -
+      # Runner never reads the value beside them, so anything but `true` is misleading rather than
+      # merely unusual (see Recipe::PRESENCE_ONLY_ASSERTIONS' own comment).
+      def check_presence_assertions: () -> untyped
+
+      def check_pdf_assertions_need_pdf_inspection: () -> (nil | untyped)
+
+      def check_output: () -> (nil | untyped)
+
+      def check_print_options: () -> untyped
+
+      def symbolize: (untyped hash) -> untyped
+
+      # Runs last, deliberately: everything above gives a friendlier, more specific message for
+      # the case it already knows about (an unknown action name, a non-true presence assertion, a
+      # real PrintParametersValidator error, ...), so this only ever fires for a shape violation
+      # none of them catches - an extra/unrecognized key sitting alongside an otherwise-valid one
+      # (SchemaShape's own doc comment has the concrete examples this closes).
+      def check_shape: () -> (nil | untyped)
+
+      def fail!: (untyped reason, path: untyped) -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/recipe.rbs

@@ -0,0 +1,72 @@
+module Bidi2pdf
+  # A recipe is a rendering contract: the waits and preparation a page needs before it is printed,
+  # and the properties the resulting PDF must have - not a general browser-automation script.
+  # `bidi2pdf run recipe.yml` is Loader -> (an invalid recipe stops here, no browser ever
+  # launches) -> Validator -> Runner.
+  class Recipe
+    @data: untyped
+
+    @path: untyped
+
+    KNOWN_TOP_LEVEL_KEYS: ::Array["version" | "source" | "browser" | "headers" | "cookies" | "auth" | "actions" | "assert" | "print" | "output"]
+
+    KNOWN_ACTIONS: ::Array["wait_for" | "click" | "evaluate" | "inject_script" | "inject_style" | "set_viewport" | "wait_network_idle"]
+
+    PAGE_ASSERTIONS: ::Array["selector_exists" | "text_present" | "no_console_errors" | "no_network_failures" | "fonts_loaded"]
+
+    PDF_ASSERTIONS: ::Array["page_count" | "pdf_text_present" | "pdf_not_blank"]
+
+    KNOWN_ASSERTIONS: untyped
+
+    KNOWN_OUTPUTS: ::Array["pdf" | "manifest" | "screenshot"]
+
+    # These four assertions are pure presence checks - Runner never reads the value beside them
+    # (see #assertion_no_console_errors and friends), so a bare key is really what's being
+    # asserted. `false`/anything but `true` is therefore misleading, not merely unusual: schema
+    # recipe encodes this as `const: true` and Validator#check_presence_assertions enforces it too.
+    PRESENCE_ONLY_ASSERTIONS: ::Array["no_console_errors" | "no_network_failures" | "fonts_loaded" | "pdf_not_blank"]
+
+    attr_reader data: untyped
+
+    attr_reader path: untyped
+
+    def self.load: (untyped path) -> untyped
+
+    def initialize: (untyped data, ?path: untyped?) -> void
+
+    def validate!: () -> untyped
+
+    def actions: () -> untyped
+
+    def assertions: () -> untyped
+
+    def source: () -> untyped
+
+    def browser_options: () -> untyped
+
+    def headers: () -> untyped
+
+    def cookies: () -> untyped
+
+    def auth: () -> untyped
+
+    def print_options: () -> untyped
+
+    def output: () -> untyped
+
+    def needs_pdf?: () -> untyped
+
+    def self.step_name: (untyped step) -> untyped
+
+    def step_name: (untyped step) -> untyped
+
+    # The value beside a step's name - a Hash of options (`wait_for: {selector: ..., timeout:
+    # ...}`), a bare scalar (`page_count: 2`, `no_console_errors: true`), or nil.
+    def step_value: (untyped step) -> (untyped | nil)
+
+    # step_value coerced to a Hash of options - most actions/assertions take this shape; a bare
+    # scalar step (page_count: 2, no_console_errors: true) has no options of its own to offer here,
+    # so callers that need the scalar itself use #step_value directly.
+    def step_options: (untyped step) -> untyped
+  end
+end

data/sig/bidi2pdf/result.rbs

@@ -0,0 +1,71 @@
+module Bidi2pdf
+  # Structured result of a CLI command (render/diagnose/run) - the shape behind --json output, a
+  # render manifest, and the final "result" event of --json-stream. Construct via .success/
+  # .failure rather than .new directly so every Result is unambiguously one or the other.
+  class Result
+    @command: untyped
+
+    @ok: untyped
+
+    @output: untyped
+
+    @bytes: untyped
+
+    @sha256: untyped
+
+    @pages: untyped
+
+    @duration_ms: untyped
+
+    @navigation: untyped
+
+    @console: untyped
+
+    @network_failures: untyped
+
+    @warnings: untyped
+
+    @error: untyped
+
+    @metadata: untyped
+
+    SCHEMA_VERSION: 1
+
+    attr_reader command: untyped
+
+    attr_reader output: untyped
+
+    attr_reader bytes: untyped
+
+    attr_reader sha256: untyped
+
+    attr_reader pages: untyped
+
+    attr_reader duration_ms: untyped
+
+    attr_reader navigation: untyped
+
+    attr_reader console: untyped
+
+    attr_reader network_failures: untyped
+
+    attr_reader warnings: untyped
+
+    attr_reader error: untyped
+
+    attr_reader metadata: untyped
+
+    # rubocop:disable-next Metrics/ParameterLists, Naming/MethodParameterName
+    def initialize: (command: untyped, ok: untyped, ?output: untyped?, ?bytes: untyped?, ?sha256: untyped?, ?pages: untyped?, ?duration_ms: untyped?, ?navigation: untyped?, ?console: untyped, ?network_failures: untyped, ?warnings: untyped, ?error: untyped?, ?metadata: ::Hash[untyped, untyped]) -> void
+
+    def self.success: (**untyped) -> untyped
+
+    def self.failure: (error: untyped, **untyped) -> untyped
+
+    def ok?: () -> untyped
+
+    def to_h: () -> untyped
+
+    def to_json: (*untyped) -> untyped
+  end
+end