whois-parser-next 0.3.2 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dd7f05a922301b74d2dccf983d9712ac9611198244bb84bf7da9d3106eb6985
-  data.tar.gz: 474233b88fad6dad201ca87d0d5c91e5a15a8abab76904192710d644a74420db
+  metadata.gz: '09b27e56a5225ea22fadb05db7497d93757e87e811520604377c2dcaa14900f8'
+  data.tar.gz: 7db37727a691aad97de784fb680da596ad79f5918df671a9f862becae1a0d37e
 SHA512:
-  metadata.gz: 0f041533d14ae1f57dfe6ea92e1967bb1ef5fdfb40379f4eea079c2bf37c58adadf53e8ed0685e0e55076ba9df44341b5a91f9115e59478a67f1c178d66fae76
-  data.tar.gz: 762d431b3ec1aa9b967a68b74f346ed41fbb37adbbb4f5304fb8e615dec298308f5f276f54a06e57da5b8a1bc217f6dd4b5f57c0df5e62c6142f1202d1069c41
+  metadata.gz: e71cf9f12d9602ad01877a3ab8592dfd387bc3f9afe6a01976a55a3d44af2e931ddd70debe9d9a60042b439712a4773cb4b65f29f5199f91d0815624ce749a7e
+  data.tar.gz: 3671c9bd5513063ebde38e00f07b39e26b3b00f2ad605ba6233a402cf5002a43cf75f0c0ce52bc3dcce376c860309a438530764d3dfb6494d76006c507927ccb

data/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 This project uses [Semantic Versioning 2.0.0](http://semver.org/).
 
+#### Release 0.4.1 (2026-10-17)
+
+- SAFETY: `.lu` records are registered only when the response contains a
+  domain name and an exact `domaintype: ACTIVE` field. The exact existing
+  absence marker is accepted only without a record; mixed, incomplete, or
+  ambiguous replies remain unknown.
+- SAFETY: `.lu` query-rate limits, including the registry's repeated-percent
+  `%% Maximum query rate reached` response, raise a throttled-response error
+  even when the reply also contains a domain record or absence marker.
+- TESTED: The parser suite passes 7,016 examples with 0 failures and the
+  package smoke check passes on Ruby 3.2 and 3.4.5.
+- EVIDENCE: The [2026-10-17 DomScan audit](docs/audits/domscan-whois-usage-2026-10-17.md)
+  documents the fixed false-availability path and explains why its fixture
+  overlap and bounded replay do not establish 99% live accuracy.
+
+#### Release 0.4.0 (2026-09-29)
+
+- ADDED: Expanded and tightened first-class parsing for current official WHOIS
+  hosts used by the pinned DomScan high-demand cohort. New parser examples
+  include `.biz`, `.click`, `.gift`, `.help`, `.homes`, `.ie`, `.org`, and
+  `.dk`; updated parser examples include `.mn`, `.cl`, `.eu`, `.giving`, `.id`,
+  `.mx`, `.love`, `.link`, `.icu`, `.lat`, `.to`, and `.open`. The audit tracks
+  all 153 suffixes with more than five observed endpoint requests (44,402
+  request items), with 94 registered/absence regression pairs and no
+  parser-pending rows. Restricted registry cases use minimal synthetic
+  fixtures. The audit keeps RDAP-only, retired, unsupported, and restricted
+  cases as separate outcomes; see the [full audit](docs/audits/domscan-whois-usage-2026-09-28.md)
+  for per-suffix evidence and route limitations.
+- SAFETY: Registration and absence require exact registry evidence. Denied,
+  throttled, malformed, incomplete, or contradictory responses do not become
+  positive registration or availability results. Unknown and unsupported
+  responses remain distinct from authoritative absence.
+- CLARIFIED: `.uk` remains a temporary WHOIS exception based on Nominet's
+  guidance that `whois.nic.uk` continues through 2027-02-09, despite IANA's
+  RDAP-only listing. The release tests current registered and absence response
+  shapes; DomScan's audited 30-day snapshot contained no traditional `.uk`
+  WHOIS calls.
+- SAFETY: `.open` registration is restricted by the registry's
+  [registration policy](https://web.aexp-static.com/content/dam/amex/us/staticassets/pdf/nic/Registry-Policies-OPEN.pdf).
+  A synthetic complete-record test checks the exact `nic.open` registered
+  shape. `No Data Found` remains unknown, and this release makes no
+  public-availability claim for `.open`.
+- TESTED: The integrated parser suite passes 7,001 examples with 0 failures;
+  the pinned-cohort coverage audit passes 3 examples with 0 failures. The
+  linked audit records the separate DomScan route checks and their local,
+  unreleased status.
+
 #### Release 0.3.2 (2026-09-25)
 
 - ADDED: Added host-keyed parsers for the current IANA-listed WHOIS hosts for

data/README.md

@@ -38,7 +38,7 @@ of current WHOIS responses, explicit unknown states, registry-specific
 fixtures, and safe handling of malformed, rate-limited, retired, or changed
 server responses.
 
-The current source version is `0.3.2`. Check the [RubyGems project
+The current source version is `0.4.0`. Check the [RubyGems project
 page](https://rubygems.org/gems/whois-parser-next) for its publication status
 and the latest published version.
 
@@ -54,10 +54,10 @@ Whois::Parser
 ```
 
 Existing applications can retain `require "whois-parser"` and their
-`Whois::Parser` integrations. To install version 0.3.2, pin it as follows:
+`Whois::Parser` integrations. To install version 0.4.0, pin it as follows:
 
 ```ruby
-gem "whois-parser-next", "= 0.3.2", require: "whois-parser"
+gem "whois-parser-next", "= 0.4.0", require: "whois-parser"
 ```
 
 ## Requirements

data/RELEASING.md

@@ -21,8 +21,8 @@ RubyGems API key to the repository or its Actions secrets.
 Create and push the annotated release tag only after the checks above pass:
 
 ```shell
-git tag -a v0.3.2 -m "whois-parser-next 0.3.2"
-git push origin v0.3.2
+git tag -a v0.4.0 -m "whois-parser-next 0.4.0"
+git push origin v0.4.0
 ```
 
 The release workflow repeats the full suite and package smoke test before it

data/lib/whois/parser/version.rb

@@ -1,6 +1,6 @@
 module Whois
   class Parser
     # The current library version.
-    VERSION = "0.3.2".freeze
+    VERSION = "0.4.1".freeze
   end
 end

data/lib/whois/parsers/registry_response_safety.rb

@@ -9,19 +9,21 @@ module Whois
 
       def response_throttled?
         content_for_scanner.match?(
-          /^(?:\s*(?:%|#)\s*)?(?:whois\s+)?query\s+(?:rate\s+)?limit\s+exceeded\b/i
+          /^(?:[ \t]*(?:%|#)[ \t]*)?(?:whois\s+)?query\s+(?:rate\s+)?limit\s+exceeded\b/i
         ) || content_for_scanner.match?(
-          /^(?:\s*(?:%|#)\s*)?maximum\s+query\s+rate\s+reached\b/i
+          /^(?:[ \t]*(?:%|#)+[ \t]*)?maximum\s+query\s+rate\s+reached\b/i
         ) || content_for_scanner.match?(
-          /^(?:\s*(?:%|#)\s*)?excessive\s+querying\b/i
+          /^(?:[ \t]*(?:%|#)[ \t]*)?excessive\s+querying\b/i
         ) || content_for_scanner.match?(
-          /^\s*(?:%|#)?\s*whois\s+limit\s+exceeded\b/i
+          /^[ \t]*(?:%|#)?[ \t]*whois\s+limit\s+exceeded\b/i
+        ) || content_for_scanner.match?(
+          /^[ \t]*(?:%|#)?[ \t]*(?:too\s+many\s+requests|rate\s+limit\s+exceeded)\b/i
         )
       end
 
       def response_unavailable?
         response_incomplete? || content_for_scanner.match?(
-          /^(?:\s*(?:%|#)\s*)?(?:requests of this client are not permitted|access to the whois service is denied|whois service is unavailable)\b/i
+          /^(?:[ \t]*(?:%|#)[ \t]*)?(?:requests of this client are not permitted|access to the whois service is denied|whois service is unavailable|access denied|permission denied|not authori[sz]ed|unauthori[sz]ed)\b/i
         ) || content_for_scanner.match?(
           /\ATLD is not supported\.[ \t]*(?:\n|\z)/i
         )

data/lib/whois/parsers/whois.auda.org.au.rb

@@ -1,11 +1,53 @@
 require_relative 'whois.audns.net.au'
+require_relative 'registry_response_safety'
 
 module Whois
   class Parsers
     # Parser for the whois.auda.org.au server.
     class WhoisAudaOrgAu < WhoisAudnsNetAu
+      include RegistryResponseSafety
+
+      KNOWN_STATUSES = %w[
+        clientDeleteProhibited clientHold clientRenewProhibited clientTransferProhibited
+        clientUpdateProhibited inactive ok pendingCreate pendingDelete pendingRenew
+        pendingRestore pendingTransfer pendingUpdate serverDeleteProhibited serverHold
+        serverRenewProhibited serverTransferProhibited serverUpdateProhibited
+      ].freeze
+
+      property_supported :status do
+        classify_status
+      end
+
       property_supported :available? do
-        super() || !!(content_for_scanner =~ /^Domain not found\.\n/)
+        classify_status == :available
+      end
+
+      property_supported :registered? do
+        classify_status == :registered
+      end
+
+      private
+
+      def classify_status
+        cached_properties_fetch(:classified_status) do
+          domain_values = content_for_scanner.scan(/^Domain Name:[ \t]*([^\r\n]+?)[ \t]*$/i).flatten
+          domain = domain_values.length == 1 && domain_values.first.match?(/\A(?:[a-z0-9-]+\.)+au\z/i)
+          statuses = content_for_scanner.scan(/^Status:[ \t]*([^\r\n]*)$/i).flatten.map(&:strip).reject(&:empty?)
+          known_statuses = statuses.map { |value| value.split(/[ \t]/, 2).first }.all? do |value|
+            KNOWN_STATUSES.include?(value)
+          end
+          record_fields = content_for_scanner.scan(/^(?:Registry Domain ID|Registrar Name|Name Server):[ \t]*\S[^\r\n]*$/i)
+          has_record_fields = content_for_scanner.match?(/^(?:Domain Name|Registry Domain ID|Registrar Name|Status|Name Server):[ \t]*\S/i)
+          available_marker = content_for_scanner.match?(/^Domain not found\.[ \t]*$/i)
+
+          if available_marker && !has_record_fields
+            :available
+          elsif domain && !statuses.empty? && known_statuses && record_fields.length >= 2 && !available_marker
+            :registered
+          else
+            :unknown
+          end
+        end
       end
     end
   end

data/lib/whois/parsers/whois.cctld.uz.rb

@@ -69,6 +69,12 @@ module Whois
       private
 
       def classify_status
+        cached_properties_fetch(:classified_status) do
+          classify_status_from_content
+        end
+      end
+
+      def classify_status_from_content
         return :unknown if absence_conflicts_with_record?
 
         evidence = []

data/lib/whois/parsers/whois.dns.lu.rb

@@ -27,17 +27,19 @@ module Whois
       include RegistryResponseSafety
 
       property_supported :status do
-        if content_for_scanner.match?(/domaintype:\s+active\s*$/i)
+        if response_unavailable? || response_throttled? || (lu_record? && lu_absence?)
+          :unknown
+        elsif lu_record? && content_for_scanner.match?(/^domaintype:[ \t]+active[ \t]*$/i)
           :registered
-        elsif available?
+        elsif lu_absence? && !lu_record?
           :available
         else
-          Whois::Parser.bug!(ParserError, "Unable to parse .lu response status.")
+          :unknown
         end
       end
 
       property_supported :available? do
-        !!(content_for_scanner =~ /% No such domain/)
+        status == :available
       end
 
       property_supported :registered? do
@@ -92,6 +94,14 @@ module Whois
 
       private
 
+      def lu_record?
+        content_for_scanner.match?(/^domainname:[ \t]+\S+[ \t]*$/i)
+      end
+
+      def lu_absence?
+        content_for_scanner.match?(/^%[ \t]+No such domain(?:[ \t]*[.:].*)?[ \t]*$/i)
+      end
+
       def build_contact(element, type)
         return unless (name = value_for_key(format("%s-name", element)))
 

data/lib/whois/parsers/whois.eu.rb

@@ -27,19 +27,15 @@ module Whois
 
 
       property_supported :status do
-        if available?
-          :available
-        else
-          :registered
-        end
+        classify_status
       end
 
       property_supported :available? do
-        !!(content_for_scanner =~ /Status:\s+AVAILABLE/)
+        classify_status == :available
       end
 
       property_supported :registered? do
-        !available?
+        classify_status == :registered
       end
 
 
@@ -124,6 +120,36 @@ module Whois
         !!(content_for_scanner =~ /Still in grace period/)
       end
 
+      private
+
+      def classify_status
+        cached_properties_fetch(:classified_status) do
+          status_values = content_for_scanner.scan(/^Status:[ \t]*([^\r\n]*)$/i).flatten.map(&:strip)
+          available = status_values == ['AVAILABLE']
+          domain_values = content_for_scanner.scan(/^Domain:[ \t]*([^\r\n]+?)[ \t]*$/i).flatten.map(&:downcase)
+          domain = domain_values.length == 1 && domain_values.first.match?(/\A(?:[a-z0-9-]+\.)+eu\z/i)
+          echoed_queries = content_for_scanner.scan(/^%?[ \t]*WHOIS[ \t]+((?:[a-z0-9-]+\.)+eu)[ \t]*$/i).flatten.map(&:downcase)
+          identity_matches = echoed_queries.empty? || (echoed_queries.length == 1 && echoed_queries.first == domain_values.first)
+          registrar = content_for_scanner.match?(/^Registrar:[ \t]*\r?\n[ \t]+Name:[ \t]*\S[^\r\n]*$/i)
+          nameservers = content_for_scanner.match?(
+            /^Name servers:[ \t]*\r?\n(?:[ \t]+(?:[a-z0-9-]+\.)+[a-z0-9-]+(?:[ \t]+\([^\r\n()]+\))?[ \t]*\r?\n?)+/i
+          )
+          record = registrar || nameservers
+          record_fields = content_for_scanner.match?(/^(?:Registrar|Name servers|Registrant|Onsite(?:\(s\))?|Technical|Created|Creation date|Updated|Last updated|Expires|Expiration date):/i)
+          denied_or_throttled = content_for_scanner.match?(
+            /\b(?:access\s+denied|permission\s+denied|not\s+authori[sz]ed|unauthori[sz]ed|not\s+allowed|too\s+many\s+requests|rate[- ]?limit(?:ed)?|temporarily\s+unavailable|service\s+unavailable|try\s+again\s+later|still\s+in\s+grace\s+period)\b/i
+          )
+
+          if !denied_or_throttled && available && domain && identity_matches && !record_fields
+            :available
+          elsif !denied_or_throttled && domain && identity_matches && record && (status_values.empty? || status_values == ['REGISTERED'])
+            :registered
+          else
+            :unknown
+          end
+        end
+      end
+
     end
 
   end

data/lib/whois/parsers/whois.id.rb

@@ -9,17 +9,37 @@ module Whois
 
     # Parser for the current whois.id registry service.
     class WhoisId < BaseIcannCompliant
+      NO_RECORD_MARKER = /^The queried object does not exist: (?:DOMAIN NOT FOUND|(?:[a-z0-9-]+\.)+id)\s*$/i
+      RECORD_EVIDENCE = /^(?:Domain Name|Registry Domain ID|Creation Date|Registrar|Domain Status|Name Server):[ \t]*\S/i
 
-      self.scanner = Scanners::BaseIcannCompliant
+      self.scanner = Scanners::BaseIcannCompliant, {
+        pattern_available: NO_RECORD_MARKER,
+      }
 
       property_supported :available? do
-        !!(content_for_scanner =~ /DOMAIN NOT FOUND/i)
+        raise ResponseIsThrottled if response_throttled?
+        raise ResponseIsUnavailable if response_unavailable?
+
+        no_record_marker_count == 1
       end
 
       property_supported :expires_on do
         node("Registry Expiry Date") { |value| parse_time(value) }
       end
 
+      def response_unavailable?
+        body = content_for_scanner
+        marker_count = no_record_marker_count
+
+        super || (marker_count.positive? && (marker_count != 1 || body.match?(RECORD_EVIDENCE)))
+      end
+
+      private
+
+      def no_record_marker_count
+        content_for_scanner.lines.count { |line| line.match?(NO_RECORD_MARKER) }
+      end
+
     end
 
   end

data/lib/whois/parsers/whois.nic.biz.rb

@@ -0,0 +1,38 @@
+require_relative 'whois.biz'
+
+module Whois
+  class Parsers
+    # The current IANA delegation points .biz to whois.nic.biz. Its record and
+    # absence formats match the existing .biz registry parser.
+    class WhoisNicBiz < WhoisBiz
+      DOMAIN_LINE = /^Domain Name:[ \t]*(\S+)[ \t]*$/i
+      REGISTERED_EVIDENCE = /^(?:Registry Domain ID|Creation Date|Updated Date|Registry Expiry Date|Registrar(?: IANA ID)?):[ \t]*\S/im
+      ABSENCE_LINE = /^No Data Found[ \t]*\r?$/i
+      RECORD_EVIDENCE = /^(?:Domain Name|Registry Domain ID|Creation Date|Updated Date|Registry Expiry Date|Registrar(?: IANA ID)?|Domain Status|Name Server):[ \t]*\S/im
+
+      property_supported :status do
+        body = content_for_scanner
+        absence_count = body.lines.count { |line| line.match?(ABSENCE_LINE) }
+
+        if absence_count.positive?
+          absence_count == 1 && !body.match?(RECORD_EVIDENCE) ? :available : :unknown
+        else
+          domains = body.scan(DOMAIN_LINE).flatten
+          if domains.length == 1 && domains.first.downcase.end_with?('.biz') && body.match?(REGISTERED_EVIDENCE)
+            :registered
+          else
+            :unknown
+          end
+        end
+      end
+
+      property_supported :available? do
+        status == :available
+      end
+
+      property_supported :registered? do
+        status == :registered
+      end
+    end
+  end
+end

data/lib/whois/parsers/whois.nic.cl.rb

@@ -27,20 +27,15 @@ module Whois
     class WhoisNicCl < Base
 
       property_supported :status do
-        if available?
-          :available
-        else
-          :registered
-        end
+        classify_status
       end
 
       property_supported :available? do
-        !!(content_for_scanner =~ /^(.+?): no existe$/i ||
-           content_for_scanner =~ /^.+:\s+no entries found\.$/i)
+        classify_status == :available
       end
 
       property_supported :registered? do
-        !available?
+        classify_status == :registered
       end
 
 
@@ -70,6 +65,35 @@ module Whois
         end
       end
 
+      private
+
+      # The current response layout in the DomScan corpus does not echo the
+      # queried domain. This parser can require a record-shaped response, but
+      # cannot independently verify that the returned record matches the query.
+      def classify_status
+        cached_properties_fetch(:classified_status) do
+          available = content_for_scanner.match?(/^(?:[a-z0-9-]+\.)+cl:[ \t]*(?:no existe|no entries found\.)[ \t]*$/i)
+          current_record = content_for_scanner.match?(/^Registrar name:[ \t]*\S[^\r\n]*$/i) &&
+                           content_for_scanner.match?(/^Creation date:[ \t]*\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])(?:[ \t]+\d{2}:\d{2}:\d{2}[ \t]+[A-Z]{2,5})?[ \t]*$/i) &&
+                           content_for_scanner.match?(/^Expiration date:[ \t]*\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])(?:[ \t]+\d{2}:\d{2}:\d{2}[ \t]+[A-Z]{2,5})?[ \t]*$/i) &&
+                           content_for_scanner.match?(/^Name server:[ \t]*(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?[ \t]*$/i)
+          legacy_record = content_for_scanner.match?(/^ACE:[ \t]*(?:[a-z0-9-]+\.)+cl[ \t]+\(RFC-3490, RFC-3491, RFC-3492\)/i) &&
+                          content_for_scanner.match?(/^Servidores de nombre \(Domain servers\):/i)
+          record = current_record || legacy_record
+          record_marker = content_for_scanner.match?(/^(?:Registrant(?: name| organisation| organization| email| address)?|Registrar(?: name| URL)?|Creation date|Expiration date|Name server|ACE):/i) ||
+                          content_for_scanner.match?(/^Servidores de nombre \(Domain servers\):/i)
+          denied = content_for_scanner.match?(/\b(?:not\s+authori[sz]ed|unauthori[sz]ed|access\s+denied|permission\s+denied|too\s+many\s+requests|rate[- ]?limited?)\b|\bno\s+autorizad[oa]\b|\bacceso\s+denegado\b/i)
+
+          if !denied && available && !record_marker
+            :available
+          elsif !denied && record && !available
+            :registered
+          else
+            :unknown
+          end
+        end
+      end
+
     end
 
   end

data/lib/whois/parsers/whois.nic.foundation.rb

@@ -3,6 +3,10 @@ require_relative 'base_icann_compliant'
 module Whois
   class Parsers
     class WhoisNicFoundation < BaseIcannCompliant
+      self.scanner = Scanners::BaseIcannCompliant, {
+        pattern_available: /^Domain not found\.[ \t]*$/i,
+      }
+
     end
   end
 end

data/lib/whois/parsers/whois.nic.ge.rb

@@ -34,6 +34,12 @@ module Whois
       private
 
       def classify_status
+        cached_properties_fetch(:classified_status) do
+          classify_status_from_content
+        end
+      end
+
+      def classify_status_from_content
         if registered_evidence?
           :registered
         elsif available_evidence?

data/lib/whois/parsers/whois.nic.gifts.rb

@@ -0,0 +1,13 @@
+require_relative 'base_unsupported_registry'
+
+module Whois
+  class Parsers
+    # Identity Digital's shared endpoint explicitly reports that .GIFTS is
+    # unsupported over WHOIS. The TLD's authoritative registry data is RDAP.
+    class WhoisNicGifts < BaseUnsupportedRegistry
+      def response_unavailable?
+        content_for_scanner.match?(/\A[ \t]*TLD is not supported\.[ \t]*(?:\r?\n|\z)/i)
+      end
+    end
+  end
+end

data/lib/whois/parsers/whois.nic.gives.rb

@@ -0,0 +1,46 @@
+require_relative 'base_icann_compliant'
+
+module Whois
+  class Parsers
+    # Parser for the PIR WHOIS service serving .GIVES.
+    class WhoisNicGives < BaseIcannCompliant
+      self.scanner = Scanners::BaseIcannCompliant, {
+        pattern_available: /^[ \t]*Domain not found\.[ \t\r]*$/i,
+      }
+
+      property_supported :status do
+        classify_status
+      end
+
+      property_supported :available? do
+        classify_status == :available
+      end
+
+      property_supported :registered? do
+        classify_status == :registered
+      end
+
+      private
+
+      def classify_status
+        cached_properties_fetch(:classified_status) do
+          response = content_for_scanner
+          missing = response.match?(/\A[ \t]*Domain not found\.[ \t]*(?:\r?\n|\z)/i)
+          denial = response.match?(/^[ \t]*(?:[%#][ \t]*)?(?:access denied|permission denied|request denied|forbidden)\b/i)
+          domains = response.scan(/^[ \t]*Domain Name:[ \t]*((?:[a-z0-9-]+\.)+gives)[ \t\r]*$/i).flatten.uniq
+          has_registrar = response.match?(/^[ \t]*Registrar:[ \t]*\S/i)
+          has_record_detail = response.match?(/^[ \t]*(?:Creation Date|Updated Date|Registry Expiry Date|Name Server):[ \t]*\S/i)
+          has_record = domains.one? && has_registrar && has_record_detail
+
+          if missing && domains.empty? && !denial && !response_throttled?
+            :available
+          elsif has_record && !missing && !denial && !response_throttled?
+            :registered
+          else
+            :unknown
+          end
+        end
+      end
+    end
+  end
+end

data/lib/whois/parsers/whois.nic.giving.rb

@@ -1,8 +1,52 @@
 require_relative 'base_icann_compliant'
+require_relative 'registry_response_safety'
 
 module Whois
   class Parsers
     class WhoisNicGiving < BaseIcannCompliant
+      include RegistryResponseSafety
+
+      DOMAIN_PATTERN = /\A(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+giving\z/i
+      NO_RECORD_MARKER = /^[ \t]*Domain not found\.[ \t]*$/i
+
+      self.scanner = Scanners::BaseIcannCompliant, {
+        pattern_available: NO_RECORD_MARKER,
+      }
+
+      property_supported :status do
+        classify_status
+      end
+
+      property_supported :available? do
+        classify_status == :available
+      end
+
+      property_supported :registered? do
+        classify_status == :registered
+      end
+
+      private
+
+      def classify_status
+        cached_properties_fetch(:classified_status) do
+          response = content_for_scanner
+          missing = response.lines.one? { |line| line.match?(NO_RECORD_MARKER) }
+          denial = response.match?(/^[ \t]*(?:[%#][ \t]*)?(?:access denied|permission denied|request denied|forbidden)\b/i)
+          domain_lines = response.scan(/^[ \t]*Domain Name:[ \t]*(.*?)[ \t\r]*$/i).flatten
+          domains = domain_lines.grep(DOMAIN_PATTERN)
+          has_registrar = response.match?(/^[ \t]*Registrar:[ \t]*\S/i)
+          has_record_detail = response.match?(/^[ \t]*(?:Creation Date|Updated Date|Registry Expiry Date|Name Server):[ \t]*\S/i)
+          has_record = domain_lines.one? && domains.one? && has_registrar && has_record_detail
+
+          if missing && domain_lines.empty? && !denial && !response_unavailable? && !response_throttled?
+            :available
+          elsif has_record && !missing && !denial && !response_unavailable? && !response_throttled?
+            :registered
+          else
+            :unknown
+          end
+        end
+      end
     end
   end
 end

data/lib/whois/parsers/whois.nic.help.rb

@@ -0,0 +1,12 @@
+require_relative 'base_identity_digital'
+
+module Whois
+  class Parsers
+    # CentralNic's .HELP registry endpoint uses its exact no-object marker.
+    class WhoisNicHelp < BaseIdentityDigital
+      self.scanner = Scanners::BaseIcannCompliant, {
+        pattern_available: /^The queried object does not exist: DOMAIN NOT FOUND\s*$/i,
+      }
+    end
+  end
+end

data/lib/whois/parsers/whois.nic.homes.rb

@@ -0,0 +1,12 @@
+require_relative 'base_identity_digital'
+
+module Whois
+  class Parsers
+    # CentralNic's .HOMES registry endpoint uses its exact no-object marker.
+    class WhoisNicHomes < BaseIdentityDigital
+      self.scanner = Scanners::BaseIcannCompliant, {
+        pattern_available: /^The queried object does not exist: DOMAIN NOT FOUND\s*$/i,
+      }
+    end
+  end
+end

data/lib/whois/parsers/whois.nic.icu.rb

@@ -4,9 +4,19 @@ module Whois
   class Parsers
     # Parser for the Identity Digital endpoint serving .ICU.
     class WhoisNicIcu < BaseIcannCompliant
+      NO_RECORD_MARKER = /^The queried object does not exist: DOMAIN NOT FOUND\s*$/i
+      RECORD_EVIDENCE = /^(?:Domain Name|Registry Domain ID|Creation Date|Registrar|Domain Status|Name Server):[ \t]*\S/i
+
       self.scanner = Scanners::BaseIcannCompliant, {
-        pattern_available: /^The queried object does not exist: DOMAIN NOT FOUND$/i,
+        pattern_available: NO_RECORD_MARKER,
       }
+
+      def response_unavailable?
+        body = content_for_scanner
+        marker_count = body.lines.count { |line| line.match?(NO_RECORD_MARKER) }
+
+        super || (marker_count.positive? && (marker_count != 1 || body.match?(RECORD_EVIDENCE)))
+      end
     end
   end
 end

data/lib/whois/parsers/whois.nic.lat.rb

@@ -2,7 +2,21 @@ require_relative 'base_identity_digital'
 module Whois
   class Parsers
     class WhoisNicLat < BaseIdentityDigital
-      self.scanner = Scanners::BaseIcannCompliant, { pattern_available: /^The queried object does not exist: DOMAIN NOT FOUND\s*$/i }
+      NO_RECORD_MARKER = /^The queried object does not exist: DOMAIN NOT FOUND\s*$/i
+      RECORD_EVIDENCE = /^[ \t]*(?:Domain Name|Registry Domain ID|Creation Date|Registrar|Domain Status|Name Server):[ \t]*\S/i
+
+      self.scanner = Scanners::BaseIcannCompliant, { pattern_available: NO_RECORD_MARKER }
+
+      property_supported :available? do
+        content_for_scanner.lines.one? { |line| line.match?(NO_RECORD_MARKER) }
+      end
+
+      def response_unavailable?
+        body = content_for_scanner
+        marker_count = body.lines.count { |line| line.match?(NO_RECORD_MARKER) }
+
+        super || (marker_count.positive? && (marker_count != 1 || body.match?(RECORD_EVIDENCE)))
+      end
     end
   end
 end