specproof 0.1.0

data/examples/pairwise/three_boolean/test/boolean_batch_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Exercises all pairs among three boolean inputs with four calls.
+class BooleanBatchTest < Minitest::Test
+  def setup
+    @batch = BooleanBatch.new
+  end
+
+  def test_all_inputs_false
+    assert_equal([false, false, false],
+                 @batch.build(first: false, second: false, third: false))
+  end
+
+  def test_first_false_other_inputs_true
+    assert_equal([false, true, true],
+                 @batch.build(first: false, second: true, third: true))
+  end
+
+  def test_first_and_third_true
+    assert_equal([true, false, true],
+                 @batch.build(first: true, second: false, third: true))
+  end
+
+  def test_first_and_second_true
+    assert_equal([true, true, false],
+                 @batch.build(first: true, second: true, third: false))
+  end
+end

data/examples/pairwise/three_boolean_specification.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "specproof"
+
+SpecProof.define "BooleanBatch#build" do
+  input :first, values: [false, true]
+  input :second, values: [false, true]
+  input :third, values: [false, true]
+  combinations :first, :second, :third, all_allowed: true
+end

data/examples/pairwise_partitions/README.md

@@ -0,0 +1,34 @@
+# Pairwise coverage by integer partitions
+
+This example declares an age range split into the complete, non-overlapping
+categories `minor` (`0...18`) and `adult` (`18..120`), plus the finite country
+values `"ro"` and `"de"`. All combinations are allowed. The independent
+[requirement](requirements.md) says eligibility requires age 18 or older and
+does not depend on country.
+
+Run from the `gems/specproof` directory with the prepared Ruby and bundle for
+this checkout. Reports and suggestion output go under `tmp/`:
+
+```sh
+bundle exec ruby -Ilib exe/specproof plan examples/pairwise_partitions/specification.rb --criterion pairwise-partitions-v1 --format json
+bundle exec ruby examples/pairwise_partitions/run.rb initial
+bundle exec ruby -Ilib exe/specproof suggest examples/pairwise_partitions/specification.rb --report tmp/pairwise-partitions-initial.json --format json > tmp/pairwise-partitions-suggestions.json
+bundle exec ruby examples/pairwise_partitions/run.rb complete
+```
+
+The plan has four category-pair obligations: minor/adult crossed with each
+country. Its typed partition values include a name and inclusive bounds, such
+as `{ "kind": "partition", "name": "minor", "lower": "0", "upper": "17" }`.
+The initial process passes three requirement-backed calls and leaves
+minor/`"de"` unobserved. `suggest` reads the criterion from that validated
+coverage report and proposes the concrete input `age: 0, country: "de"` using
+the partition's lower endpoint. The suggestion supplies an input only. The
+complete process adds a separate assertion, justified by the under-18 rule,
+and exercises all four category pairs.
+
+Category coverage counts any in-domain age in the declared category. It is not
+boundary-value coverage, does not establish equivalence within a category, and
+does not infer expected outputs. The assertion oracle remains the separate
+requirement. Existing `pairwise-finite-v1` and scalar plans retain their
+behavior; this criterion supports only integer ranges with explicit complete,
+non-overlapping partitions and `all_allowed: true`.

data/examples/pairwise_partitions/lib/age_policy.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Applies the minimum age requirement to supported countries.
+class AgePolicy
+  def eligible?(age:, country:)
+    %w[ro de].include?(country) && age >= 18
+  end
+end

data/examples/pairwise_partitions/requirements.md

@@ -0,0 +1,8 @@
+# Age eligibility requirement
+
+For the supported countries `"ro"` and `"de"`, an applicant is eligible
+exactly when their age is at least 18. Country does not change the age rule.
+In particular, every applicant under 18 is ineligible.
+
+This requirement supplies the expected results in the example tests. Pairwise
+category coverage and a suggested input do not provide an output oracle.

data/examples/pairwise_partitions/run.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "minitest/autorun"
+require "specproof/minitest"
+require_relative "lib/age_policy"
+
+mode = ARGV.shift || "initial"
+abort "Choose initial or complete" unless %w[initial complete].include?(mode)
+
+ENV["ADD_MISSING_CATEGORY"] = mode == "complete" ? "1" : "0"
+root = File.expand_path("../..", __dir__)
+report = File.join(root, "tmp/pairwise-partitions-#{mode}.json")
+
+SpecProof::Minitest.install!(
+  specifications: [File.join(__dir__, "specification.rb")],
+  criterion: "pairwise-partitions-v1",
+  output: report,
+  fail_on_missing: false
+)
+
+require_relative "test_age_policy"

data/examples/pairwise_partitions/specification.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "specproof"
+
+SpecProof.define "AgePolicy#eligible?" do
+  input :age, range: 0..120, allow_gaps: false, allow_overlaps: false do
+    partition :minor, range: 0...18
+    partition :adult, range: 18..120
+  end
+
+  input :country, values: %w[ro de]
+  combinations :age, :country, all_allowed: true
+end

data/examples/pairwise_partitions/test_age_policy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "lib/age_policy"
+
+# Covers selected age-category and country pairs.
+class AgePolicyPairwiseTest < Minitest::Test
+  BASELINE_CASES = [
+    [16, "ro", false],
+    [30, "ro", true],
+    [30, "de", true]
+  ].freeze
+
+  def test_baseline_calls_follow_the_age_requirement
+    policy = AgePolicy.new
+
+    BASELINE_CASES.each do |age, country, expected|
+      assert_equal expected, policy.eligible?(age: age, country: country),
+                   "requirements.md: eligibility depends on age >= 18, not country"
+    end
+  end
+
+  if ENV["ADD_MISSING_CATEGORY"] == "1"
+    def test_minor_from_de_is_ineligible
+      refute AgePolicy.new.eligible?(age: 0, country: "de"),
+             "requirements.md: every applicant under 18 is ineligible"
+    end
+  end
+end

data/examples/pairwise_suggestions/README.md

@@ -0,0 +1,48 @@
+# Pairwise missing-pair suggestions
+
+Run these commands from `gems/specproof` with its development bundle. Reports
+and generated suggestion JSON go under the ignored `tmp/` directory. Each
+runner command starts a new Ruby process and writes a fresh coverage report.
+
+```sh
+bundle exec ruby examples/pairwise_suggestions/run.rb delivery-baseline tmp/suggestion-delivery-baseline.json
+bundle exec ruby -Ilib exe/specproof suggest examples/pairwise/specification.rb --report tmp/suggestion-delivery-baseline.json --format json > tmp/suggestion-delivery.json
+bundle exec ruby examples/pairwise_suggestions/run.rb delivery-gap tmp/suggestion-delivery-gap.json
+bundle exec ruby -Ilib exe/specproof suggest examples/pairwise/specification.rb --report tmp/suggestion-delivery-gap.json --format json > tmp/suggestion-after-gap.json
+bundle exec ruby examples/pairwise_suggestions/run.rb delivery-corrected tmp/suggestion-delivery-corrected.json
+bundle exec ruby examples/pairwise_suggestions/run.rb booleans-baseline tmp/suggestion-booleans-baseline.json
+bundle exec ruby -Ilib exe/specproof suggest examples/pairwise_suggestions/three_boolean/specification.rb --report tmp/suggestion-booleans-baseline.json --format json > tmp/suggestion-booleans.json
+bundle exec ruby examples/pairwise_suggestions/run.rb booleans-complete tmp/suggestion-booleans-complete.json
+```
+
+The DeliveryOptions declaration and [requirements](../pairwise/requirements.md)
+come from the existing pairwise example. Its baseline tests pass while
+exercising three of four pair obligations. The suggestion command returns an
+allowed `expedited: true, notify: true` assignment and the stable ID it covers.
+That row is a candidate only: the example's separate gap test asserts the
+independent requirement that the notification result equals `notify`. The
+assertion fails against the faulty implementation, even though its fresh
+report has exercised all four pairs. The corrected implementation passes that
+same assertion in a separate process and writes a different report.
+Running `suggest` on the failing gap report is also valid: it returns no rows
+because all pairs were reached, while preserving `source_tests_passed: false`.
+
+For three booleans, the baseline observes only `false, false, false`, leaving
+nine pair IDs missing. One full assignment in the suggestion covers multiple
+missing pairs. The group requires no joint restrictions, and the independent
+[requirements](three_boolean/requirements.md) define the expected result. The
+suggestion output lists the deliberately excluded `context` input as
+`unassigned_inputs`; callers must still provide it and satisfy its application
+contract. The completion run uses the three remaining assignments from the
+small four-row covering set and asserts the requirement for every call.
+
+Never turn suggestion output directly into a test call with generated or
+implementation-derived expected values. Compare the report with a fresh
+pairwise plan: it must be completed and intact, with the current digest, exact
+typed obligation denominator and scope, consistent counters and projections,
+and no errors or unknown observations. A failed assertion result is accepted
+and preserved. Filtered reports remain limited to their recorded scope. The
+digest does not fingerprint implementation or tests, so run the suite again
+after any such changes. The CLI validates the report before producing any
+suggestions; oversized or inconsistent evidence yields an error without
+partial results.

data/examples/pairwise_suggestions/run.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "minitest/autorun"
+require "specproof/minitest"
+
+mode = ARGV.shift || "delivery-corrected"
+output = ARGV.shift || File.expand_path("../../tmp/pairwise-suggestions-#{mode}.json", __dir__)
+
+pairwise_root = File.expand_path("../pairwise", __dir__)
+scenarios = {
+  "delivery-baseline" => {
+    implementation: "faulty/lib/delivery_options.rb",
+    specification: "specification.rb",
+    tests: ["faulty/test/initial_delivery_options_test.rb"]
+  },
+  "delivery-gap" => {
+    implementation: "faulty/lib/delivery_options.rb",
+    specification: "specification.rb",
+    tests: [
+      "faulty/test/initial_delivery_options_test.rb",
+      "faulty/test/gap_delivery_options_test.rb"
+    ]
+  },
+  "delivery-corrected" => {
+    implementation: "corrected/lib/delivery_options.rb",
+    specification: "specification.rb",
+    tests: ["corrected/test/delivery_options_test.rb"]
+  },
+  "booleans-baseline" => {
+    implementation: "pairwise_suggestions/three_boolean/lib/suggested_boolean_batch.rb",
+    specification: "pairwise_suggestions/three_boolean/specification.rb",
+    tests: ["pairwise_suggestions/three_boolean/test/baseline_test.rb"]
+  },
+  "booleans-complete" => {
+    implementation: "pairwise_suggestions/three_boolean/lib/suggested_boolean_batch.rb",
+    specification: "pairwise_suggestions/three_boolean/specification.rb",
+    tests: ["pairwise_suggestions/three_boolean/test/complete_test.rb"]
+  }
+}.freeze
+
+abort "Choose one of: #{scenarios.keys.join(", ")}" unless scenarios.key?(mode)
+
+scenario = scenarios.fetch(mode)
+root = mode.start_with?("delivery-") ? pairwise_root : File.expand_path("..", __dir__)
+require File.join(root, scenario.fetch(:implementation))
+
+SpecProof::Minitest.install!(
+  specifications: [File.join(root, scenario.fetch(:specification))],
+  criterion: "pairwise-finite-v1",
+  output: output,
+  fail_on_missing: false
+)
+
+scenario.fetch(:tests).each { |path| require File.join(root, path) }

data/examples/pairwise_suggestions/three_boolean/lib/suggested_boolean_batch.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Returns three finite boolean inputs as an ordered array.
+class SuggestedBooleanBatch
+  def build(first:, second:, third:, context:) # rubocop:disable Lint/UnusedMethodArgument
+    [first, second, third]
+  end
+end

data/examples/pairwise_suggestions/three_boolean/requirements.md

@@ -0,0 +1,7 @@
+# Boolean batch requirements
+
+`SuggestedBooleanBatch#build` returns the supplied three boolean values in
+`[first, second, third]` order. Every triple is permitted. `context` is an
+application value outside this finite pairwise scenario; callers must supply a
+value appropriate for their application. The pairwise suggestions specify
+neither that value nor an expected return value.

data/examples/pairwise_suggestions/three_boolean/specification.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "specproof"
+
+SpecProof.define "SuggestedBooleanBatch#build" do
+  input :first, values: [false, true]
+  input :second, values: [false, true]
+  input :third, values: [false, true]
+  exclude_input :context, reason: "Context behavior is outside this boolean interaction example"
+  combinations :first, :second, :third, all_allowed: true
+end

data/examples/pairwise_suggestions/three_boolean/test/baseline_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Verifies the single tuple observed before pairwise suggestions.
+class SuggestedBooleanBatchBaselineTest < Minitest::Test
+  def test_all_false_returns_the_input_values_in_order
+    assert_equal([false, false, false],
+                 SuggestedBooleanBatch.new.build(first: false, second: false, third: false, context: Object.new))
+  end
+end

data/examples/pairwise_suggestions/three_boolean/test/complete_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Checks a compact covering set against the independent array requirement.
+class SuggestedBooleanBatchCompleteTest < Minitest::Test
+  def setup
+    @batch = SuggestedBooleanBatch.new
+  end
+
+  def test_each_requirement_backed_assignment_returns_values_in_order
+    [
+      [false, false, false],
+      [false, true, true],
+      [true, false, true],
+      [true, true, false]
+    ].each do |values|
+      first, second, third = values
+      assert_equal(values,
+                   @batch.build(first: first, second: second, third: third, context: Object.new),
+                   "Requirement: preserve boolean input order; see requirements.md")
+    end
+  end
+end

data/examples/partition_gap.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+SpecProof.define "AgePolicy#adult?" do
+  input :age, range: 0..120, allow_gaps: false, allow_overlaps: false do
+    partition :minor, range: 0..17
+    partition :adult, range: 18..64
+  end
+end

data/examples/rbs_registration/README.md

@@ -0,0 +1,58 @@
+# RBS-backed registration example
+
+This example imports `age: Integer` and optional nullable `consent: bool?`
+from [the explicit RBS signature](sig/registration.rbs), then uses the DSL
+only to refine age to `0..120` with complete, non-overlapping minor/adult
+partitions. The independent rule is in [requirements.md](requirements.md): an
+applicant is eligible exactly when age is at least 18 and consent is true.
+Missing consent and explicit false both deny eligibility.
+
+The composed plan has nine marginal obligations: six age candidates
+(`0`, `1`, `17`, `18`, `119`, `120`) and three consent values (`nil`, `false`,
+`true`). The nine obligations do not mean nine combinations and do not state
+any expected return value.
+
+Run all commands from the gem directory. The RBS parser is in the explicit
+optional bundle. Every command starts a fresh Ruby process. Offline check and
+plan emit JSON to stdout; the three runtime checkpoints below write separate
+coverage reports under `/private/tmp`:
+
+```sh
+cd gems/specproof
+BUNDLE_GEMFILE=Gemfile.rbs bundle exec ruby -Ilib exe/specproof check examples/rbs_registration/specification.rb --rbs examples/rbs_registration/sig/registration.rbs --target 'Registration#eligible?' --format json
+BUNDLE_GEMFILE=Gemfile.rbs bundle exec ruby -Ilib exe/specproof plan examples/rbs_registration/specification.rb --rbs examples/rbs_registration/sig/registration.rbs --target 'Registration#eligible?' --format json
+```
+
+The baseline implementation uses `age > 18`. It tests every declared age
+candidate except 18, across each consent value. Its meaningful assertions
+follow the written eligibility rule, and its fresh report should show eight of
+nine marginal obligations exercised, with only the age-18 obligation missing:
+
+```sh
+SPEC_PROOF_REPORT=/private/tmp/registration-baseline.json CHECKPOINT=baseline BUNDLE_GEMFILE=Gemfile.rbs bundle exec ruby -I examples/rbs_registration/implementations/age_gt examples/rbs_registration/test_registration.rb
+```
+
+Run the added age-18 assertion alongside the passing baseline cases against
+that same faulty implementation. The assertion should fail because an
+18-year-old who consents is eligible under the stated rule. The report should
+show all nine candidates hit but `tests_passed: false`, demonstrating that
+input coverage alone does not establish correctness:
+
+```sh
+SPEC_PROOF_REPORT=/private/tmp/registration-boundary-red.json CHECKPOINT=boundary BUNDLE_GEMFILE=Gemfile.rbs bundle exec ruby -I examples/rbs_registration/implementations/age_gt examples/rbs_registration/test_registration.rb
+```
+
+The final checkpoint loads the separate corrected implementation (`age >= 18`)
+and tests all six age candidates with all three consent values. Its new report
+should have a distinct run ID and all nine unchanged obligations exercised:
+
+```sh
+SPEC_PROOF_REPORT=/private/tmp/registration-corrected.json CHECKPOINT=complete BUNDLE_GEMFILE=Gemfile.rbs bundle exec ruby -I examples/rbs_registration/implementations/age_gte examples/rbs_registration/test_registration.rb
+```
+
+Inspect each fresh report's digest, obligation IDs, run ID, completion,
+integrity, `tests_passed`, and declaration scope. The digest covers normalized
+input domains and partition policy; it does not fingerprint all source text,
+the full signature, or implementation correctness. A passing input-coverage
+report is evidence that candidates reached the method, while the behavior
+assertions and their independent rule establish expected results.

data/examples/rbs_registration/implementations/age_gt/registration.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Registration example with the deliberate age-greater-than defect.
+class Registration
+  def eligible?(age:, consent: nil)
+    age > 18 && consent == true
+  end
+end

data/examples/rbs_registration/implementations/age_gte/registration.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Registration example with the corrected inclusive adulthood boundary.
+class Registration
+  def eligible?(age:, consent: nil)
+    age >= 18 && consent == true
+  end
+end

data/examples/rbs_registration/requirements.md

@@ -0,0 +1,9 @@
+# Registration eligibility rule
+
+An applicant is eligible exactly when they are at least 18 years old and have
+given consent. Applicants younger than 18 are ineligible. Missing consent and
+explicitly false consent both mean the applicant has not given consent and are
+ineligible. An 18-year-old who consents is eligible.
+
+This is the expected-result rule for the example tests. The RBS signature only
+describes accepted input types; it does not provide this behavior rule.

data/examples/rbs_registration/sig/registration.rbs

@@ -0,0 +1,3 @@
+class Registration
+  def eligible?: (age: Integer, ?consent: bool?) -> bool
+end

data/examples/rbs_registration/specification.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "specproof"
+
+SpecProof.define "Registration#eligible?" do
+  input :age, range: 0..120, allow_gaps: false, allow_overlaps: false do
+    partition :minor, range: 0...18
+    partition :adult, range: 18..120
+  end
+end

data/examples/rbs_registration/test_registration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "registration"
+require "specproof/minitest"
+
+REPORT = ENV.fetch("SPEC_PROOF_REPORT", "/private/tmp/specproof-registration-#{Process.pid}.json")
+RBS_PATH = File.join(__dir__, "sig/registration.rbs")
+SPECIFICATION = File.join(__dir__, "specification.rb")
+
+SpecProof::Minitest.install!(
+  specifications: [SPECIFICATION],
+  rbs: [RBS_PATH],
+  targets: ["Registration#eligible?"],
+  output: REPORT,
+  fail_on_missing: false
+)
+
+# Exercises only explicit RBS-backed input obligations for the example method.
+class RegistrationExampleTest < Minitest::Test
+  CONSENT_VALUES = [nil, false, true].freeze
+  COMPLETE_AGES = [0, 1, 17, 18, 119, 120].freeze
+  GAP_AGES = [0, 1, 17, 119, 120].freeze
+
+  if ENV["CHECKPOINT"] == "boundary"
+    def test_age_18_with_consent_is_eligible
+      assert Registration.new.eligible?(age: 18, consent: true),
+             "requirements.md: an 18-year-old who consents is eligible"
+    end
+  end
+
+  def test_declared_age_and_consent_candidates_follow_the_eligibility_rule
+    ages = %w[baseline boundary].include?(ENV["CHECKPOINT"]) ? GAP_AGES : COMPLETE_AGES
+
+    ages.product(CONSENT_VALUES).each do |age, consent|
+      expected = age >= 18 && consent == true
+      message = "requirements.md: eligible iff age >= 18 and consent is true " \
+                "(age=#{age}, consent=#{consent.inspect})"
+      assert_equal expected, Registration.new.eligible?(age: age, consent: consent),
+                   message
+    end
+  end
+end

data/examples/rbs_string_literals/README.md

@@ -0,0 +1,34 @@
+# RBS finite string literal example
+
+This example imports `country: ("ro" | "de")` and `expedited: bool` from the
+explicit RBS signature. The DSL declares only that every combination is
+allowed; it does not duplicate either input. The independent
+[requirement](requirements.md) says `build` preserves the requested country and
+uses `express` exactly when expedited is true.
+
+Run from the gem directory. The RBS parser is in the optional `Gemfile.rbs`
+bundle. Each command starts a fresh Ruby process and writes its report under
+`tmp/`:
+
+```sh
+BUNDLE_GEMFILE=Gemfile.rbs bundle exec ruby -Ilib exe/specproof plan examples/rbs_string_literals/specification.rb --rbs examples/rbs_string_literals/sig/delivery_options.rbs --target 'DeliveryOptions#build' --criterion pairwise-finite-v1 --format json
+BUNDLE_GEMFILE=Gemfile.rbs bundle exec ruby examples/rbs_string_literals/test_delivery_options.rb
+BUNDLE_GEMFILE=Gemfile.rbs bundle exec ruby -Ilib exe/specproof suggest examples/rbs_string_literals/specification.rb --rbs examples/rbs_string_literals/sig/delivery_options.rbs --target 'DeliveryOptions#build' --report tmp/rbs-string-baseline.json --format json
+SPEC_PROOF_REPORT=tmp/rbs-string-complete.json CHECK_GAP=1 BUNDLE_GEMFILE=Gemfile.rbs bundle exec ruby examples/rbs_string_literals/test_delivery_options.rb
+```
+
+The first coverage run passes three requirement-backed calls: `ro` with each
+boolean value and `de` with false. Its fresh report leaves the pair
+`country: "de", expedited: true` unobserved. `suggest` proposes that allowed
+assignment; the suggestion supplies an input only, with no expected result.
+The final fresh run adds a separate assertion justified by the requirement and
+exercises the missing assignment. The example uses the correct implementation
+throughout; it demonstrates a coverage gap without manufacturing a behavior
+defect. Inspect both reports' run IDs, digests, completion, integrity, test
+results, and input scope.
+
+RBS `String` is unrestricted and remains unsupported. A selected union with an
+unsupported member also fails atomically. Return types do not provide an
+expected-result oracle. Finite-string support is feature-specific, not
+guaranteed by a `0.1.x` version number; confirm typed string obligations in a
+fresh plan from the installed build.

data/examples/rbs_string_literals/lib/delivery_options.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Builds delivery labels from explicit country and shipping options.
+class DeliveryOptions
+  def build(country:, expedited:)
+    shipping = expedited ? "express" : "standard"
+    "#{country}:#{shipping}"
+  end
+end

data/examples/rbs_string_literals/requirements.md

@@ -0,0 +1,11 @@
+# Delivery options requirement
+
+For the supported country values `"ro"` and `"de"`,
+`DeliveryOptions#build(country:, expedited:)` preserves the supplied country
+string in its result. It selects `"express"` when `expedited` is true and
+`"standard"` when it is false. The country and expedited choice are independent
+options, so every combination is allowed.
+
+This requirement is the expected-result source for the example's assertions.
+The RBS signature describes accepted input values only; its return type is not
+used as a behavior oracle.

data/examples/rbs_string_literals/sig/delivery_options.rbs

@@ -0,0 +1,3 @@
+class DeliveryOptions
+  def build: (country: ("ro" | "de"), expedited: bool) -> String
+end

data/examples/rbs_string_literals/specification.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "specproof"
+
+SpecProof.define "DeliveryOptions#build" do
+  combinations :country, :expedited, all_allowed: true
+end

data/examples/rbs_string_literals/test_delivery_options.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "lib/delivery_options"
+require "specproof/minitest"
+
+ROOT = File.expand_path("../..", __dir__)
+SPECIFICATION = File.join(__dir__, "specification.rb")
+RBS_SIGNATURE = File.join(__dir__, "sig/delivery_options.rbs")
+REPORT = ENV.fetch("SPEC_PROOF_REPORT", File.join(ROOT, "tmp/rbs-string-baseline.json"))
+
+SpecProof::Minitest.install!(
+  specifications: [SPECIFICATION],
+  rbs: [RBS_SIGNATURE],
+  targets: ["DeliveryOptions#build"],
+  criterion: "pairwise-finite-v1",
+  output: REPORT,
+  fail_on_missing: false
+)
+
+# Exercises the RBS-backed delivery options contract.
+class DeliveryOptionsExampleTest < Minitest::Test
+  BASELINE_ASSIGNMENTS = [
+    ["ro", false],
+    ["ro", true],
+    ["de", false]
+  ].freeze
+
+  def test_baseline_assignments_follow_delivery_requirement
+    delivery = DeliveryOptions.new
+
+    BASELINE_ASSIGNMENTS.each do |country, expedited|
+      expected_shipping = expedited ? "express" : "standard"
+      expected = "#{country}:#{expected_shipping}"
+      assert_equal expected, delivery.build(country: country, expedited: expedited),
+                   "requirements.md: preserve country and select shipping by expedited"
+    end
+  end
+
+  if ENV["CHECK_GAP"] == "1"
+    def test_suggested_de_expedited_assignment_follows_requirement
+      assert_equal "de:express", DeliveryOptions.new.build(country: "de", expedited: true),
+                   "requirements.md: preserve de and select express when expedited"
+    end
+  end
+end

data/examples/shipping.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+SpecProof.define "Shipping#available?" do
+  input :country, values: %i[ca gb us], allow_gaps: false, allow_overlaps: false do
+    partition :supported, values: %i[ca gb us]
+  end
+
+  input :expedited, values: [false, true] do
+    partition :standard, values: [false]
+    partition :express, values: [true]
+  end
+end

data/exe/specproof

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "specproof"
+require "specproof/cli"
+
+exit SpecProof::CLI.new.run(ARGV)