quonfig 1.6.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96d17a74751571b9c6099b8239b2ccaafb25a5f7e55d006cecae5cb1f8651979
-  data.tar.gz: 6bbe54bd07a5fb1e20b987ef8a8aaef417533ca8ef26000873db8a671142d4bb
+  metadata.gz: 1b22d7d46b27ff2ab1452b41eaa68940d886216aaeb16c61a3faddf0778d352c
+  data.tar.gz: 0ca1f8e621bcfcd839a28d1d754560b5cf023eff205b24b83049196e64a8e4b0
 SHA512:
-  metadata.gz: dcb86b3f98c5f986d61f0b0db084b992fe4c3bfefc86ef2f7d0f65487fa95dc6d66fdd4b5150dd2c0f8b6ddd819f6c0bc77980e4ae89d618d31daa3649bc48c6
-  data.tar.gz: 9faba58f93536256b216dd70dc95849adbb1c4e18b033feb9419d87d26dd8b04ec132738f4bfcbee3b0e7dca0b9051bad43971644b3312d0320ee496e8550efc
+  metadata.gz: 720d2acbfe8d30a785c1197fa319d608b1b4e11a1b60657b23d7b3dd921ed0c4882c99e7446b469a009552f09ca54538482509d9dc6a6968dc11df6f0e42d7c2
+  data.tar.gz: 11a8f0fbb7851dba082a46a7b657e9ec49aa61ae4af155cf9bf2272a35a3e5f75fa8148acdf0f3df8b936798cae5d8619dbc86bb981199f5bf29ceadf5f79567

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 1.7.1 - 2026-10-03
+
+- **Behaviour change (bug fix): weighted rollouts now hash non-ASCII text the same way as every other Quonfig SDK (qfg-1mvb).** The MurmurHash3 used to pick a weighted variant counted characters instead of UTF-8 bytes, so a config key or hash value containing non-ASCII text (for example `josé`, `日本語`, `🚀`) hashed to a different number than sdk-java, sdk-python, sdk-go and sdk-node. It now hashes the UTF-8 bytes. Ruby users whose hash value (or the flag's key) contains non-ASCII characters may move to a different variant on upgrade; afterwards they get the same variant as in the other SDKs. ASCII-only values and keys are unchanged.
+- **Fix: `Quonfig::Reason.compute` now returns `:SPLIT` for weighted bucket 0 (qfg-mn8f).** It returned `:SPLIT` only for buckets 1 and up, so bucket 0 was reported as `:DEFAULT`/`:RULE_MATCH`. The SDK's own evaluation path does not use this method and already reported bucket 0 as `SPLIT`; this only affects code that calls `Quonfig::Reason.compute` directly.
+
+## 1.7.0 - 2026-10-02
+
+- **New: public `Client#get_or_raise` and `Client#get_duration_details` (also on `BoundClient`) (qfg-2agi.27).** `get_or_raise(key, default:, context:)` returns the value like `get`; a missing key with no `default:` raises `MissingDefaultError` even under `on_no_default: :return_nil`, and an unset ENV_VAR (`MissingEnvVarError`), an uncoercible ENV_VAR or malformed stored duration (`EnvVarParseError`) or a decryption failure (`DecryptionError`) raises. `get_duration_details` returns integer milliseconds in `EvaluationDetails`; a non-duration config is `ERROR`/`TYPE_MISMATCH` and a malformed value is `ERROR` with a nil value. The shared integration suite's init-timeout `get_or_raise` case now calls the public method instead of falling back to `get`.
+- **Fix: durations follow the one grammar all Quonfig SDKs share, and a malformed duration returns the default instead of a made-up number (qfg-2agi.10).** Grammar (integration-test-data `tests/duration/grammar.yaml`): `P[nD][T[nH][nM][n[.fff]S]]`, at least one component, a fraction only on seconds (at most 9 digits), at most `P36500D`. Before, the pattern was unanchored, so `xxPT5Sxx` read as 5000 ms, `PT5M3H` as 300000 ms and `garbage` as 0. Milliseconds are now rounded half up on both the stored and the ENV_VAR path (`PT1.9999S` from an env var was 1999, now 2000).
+  - `get_duration` on a malformed value (stored or ENV_VAR) returns `default:` and logs one warning per key. With no default it returns `nil` under `on_no_default: :return_nil` and raises `Quonfig::Errors::EnvVarParseError` under the default `:raise` policy.
+  - `get_duration` on a config whose value type is not duration now raises `TypeMismatchError`, like `get_int` on a string config. Before, an int config's number was returned as milliseconds.
+  - `get` on a malformed stored duration returns `nil` (was `0` or a wrong number).
+  - `Quonfig::Duration.parse` raises `ArgumentError` on an invalid string (it returned `0`). New `Quonfig::Duration.parse_millis` (Integer ms or `nil`) and `Quonfig::Duration.valid?`. Values that used fractions on D/H/M (`PT0.5H`, `PT1.5M`) are now invalid; write `PT30M`, `PT90S`.
+- **Fix: `Client#get` on a duration provided by an ENV_VAR now returns integer milliseconds, the same as a stored duration (qfg-2agi.22).** Before, it returned the raw ISO string (`PT30M` came back as `"PT30M"` from the env var but `1800000` when stored). `get_duration` was already correct.
+- **Behaviour change (bug fix): a named context from a newer tier now replaces the whole same-named context from an older tier, instead of being merged into it property by property (qfg-2agi.36).** Tiers, oldest to newest: `global_context`, `with_context` / `in_context` scopes (outer to inner), per-call context. Example: with `global_context: { user: { 'role' => 'admin' } }`, a call passing `user: { 'plan' => 'pro' }` now evaluates with `user.plan` only; `user.role` is no longer present. Named contexts the newer tier does not mention (for example `team`) are still kept. A symbol name and a string name (`:user` vs `'user'`) count as the same named context. This is the documented rule. Callers that relied on the old property-level merge should pass every attribute of a named context they set.
+- **Fix (security): evaluation-summary telemetry no longer sends the plaintext of `confidential` or `decryptWith` config values (qfg-2agi.15).** `selectedValue` now carries the `*****<hash>` redacted form the resolver already computed; before, `Client#get` reported the decrypted value. Non-confidential values are reported unchanged.
+- **Tests: the shared integration suite now drives every case through the public `Quonfig::Client` (qfg-2agi.33).** Each case uses a datadir client and the typed getter named by its `type:` (`get_string`, `get_int`, `get_float`, `get_bool`, `get_string_list`, `get_json`, `get_duration`), `enabled?` or `get_or_raise`. Context tiers go through `global_context:`, `with_context` and `in_context`. Telemetry cases flush the client's real reporter to a local HTTP server and check the POST. Before, most cases called the internal resolver, and the harness redacted telemetry values itself, so a broken typed getter, a negated `enabled?` or dropped redaction left the suite green. No library change.
+- **Tests: the shared integration suite now checks every duration case through the public `Client#get_duration`, with an exact integer millisecond comparison (qfg-2agi.4).** Before, it checked the internal resolver, so a bug in `get_duration` could not fail the suite. No library change.
+
 ## 1.6.0 - 2026-09-28
 
 - **Change: a weighted rollout that hashes on a property missing from the context now hashes an empty value, so every such caller gets the same variant for that flag (qfg-9dxb.8).** Before, such evaluations got a random variant on every call. It is the same variant a context with the property set to `""` gets, and a variant with weight 0 is not served. The reason is still `SPLIT`. The `flag_metadata` of `get_*_details` results includes `'hashPropertyMissing' => true` when the property is missing, and the SDK logs one warning per flag. A weighted rollout with no hash property configured still picks a random variant on every evaluation, unchanged. Users whose context has the property keep the same variant as in 1.5.0.

data/README.md

@@ -259,7 +259,7 @@ Quonfig::Client.new(
   fallback_poll_enabled:     true,
   fallback_poll_interval_ms: 60_000,
   init_timeout_ms:           10_000,
-  on_no_default:             :error,
+  on_no_default:             :raise,
   global_context:            {},
   datadir:                   '/path/to/workspace',
   environment:               'production',
@@ -277,7 +277,7 @@ Quonfig::Client.new(
 | `fallback_poll_enabled`   | `Boolean`                  | `true`                                                              | Engage HTTP polling as a fallback when SSE is unavailable for >= 2x `fallback_poll_interval_ms`. Deprecated alias: `enable_polling`. |
 | `fallback_poll_interval_ms` | `Integer` (ms)           | `60_000`                                                            | Interval between fallback HTTP polls, in milliseconds. Deprecated alias: `poll_interval` (seconds, multiplied by 1000 internally). |
 | `init_timeout_ms` | `Integer` (ms)             | `10_000`                                                            | Maximum time to wait for the initial config load, in milliseconds. Deprecated alias: `initialization_timeout_sec` (seconds, multiplied by 1000 internally). |
-| `on_no_default`   | `Symbol`                   | `:error`                                                            | Behavior when a key has no value and no default: `:error`, `:warn`, or `:ignore`.                 |
+| `on_no_default`   | `Symbol`                   | `:raise`                                                            | Behavior when a key has no value and no default: `:raise` (raise `Quonfig::Errors::MissingDefaultError`) or `:return_nil`. |
 | `global_context`  | `Hash`                     | `{}`                                                                | Context applied to every evaluation.                                                              |
 | `datadir`         | `String`                   | `ENV['QUONFIG_DIR']`                                                | Path to a local workspace. When set, the SDK runs offline from disk.                              |
 | `environment`     | `String`                   | `ENV['QUONFIG_ENVIRONMENT']`                                        | Environment to evaluate in datadir mode. Required when `datadir` is set.                          |
@@ -361,6 +361,14 @@ client.get_json('homepage.layout')
 client.enabled?('beta-feature', user: { key: 'user-123' })
 ```
 
+`get_or_raise(key, default:, context:)` returns the value like `get`, but a
+missing key without a `default:` always raises
+`Quonfig::Errors::MissingDefaultError` (whatever `on_no_default` is set to), and
+an unset or malformed ENV_VAR value, a malformed stored duration, or a
+decryption failure raises its error. `get_duration_details(key, context:)`
+returns `Quonfig::EvaluationDetails` with the duration in integer milliseconds,
+like the other `*_details` getters.
+
 ## Dynamic log levels (SemanticLogger)
 
 Quonfig can drive per-class log levels at runtime. Set config keys like

data/lib/quonfig/bound_client.rb

@@ -40,6 +40,10 @@ module Quonfig
       @client.get_json(key, default: default, context: @context)
     end
 
+    def get_or_raise(key, default: NO_DEFAULT_PROVIDED)
+      @client.get_or_raise(key, default: default, context: @context)
+    end
+
     # ---- Details getters ----------------------------------------------
 
     def get_bool_details(key)
@@ -66,15 +70,18 @@ module Quonfig
       @client.get_json_details(key, context: @context)
     end
 
+    def get_duration_details(key)
+      @client.get_duration_details(key, context: @context)
+    end
+
     def enabled?(feature_name)
       @client.enabled?(feature_name, @context)
     end
 
-    # Returns a new BoundClient whose bound context is the merge of this
-    # bound context and +additional+. Merge is one level deep per named
-    # context (mirrors sdk-node's mergeContexts): later values override
-    # earlier within the same named context; keys unique to each side are
-    # preserved.
+    # Returns a new BoundClient whose bound context is this bound context
+    # plus +additional+ (qfg-2agi.24): a named context in +additional+
+    # REPLACES the whole same-named context (no per-property merge); named
+    # contexts it does not mention are kept. Names compare as strings.
     def in_context(additional)
       self.class.new(@client, merge_contexts(@context, additional || {}))
     end
@@ -87,9 +94,10 @@ module Quonfig
 
     def merge_contexts(left, right)
       merged = {}
-      left.each  { |name, ctx| merged[name] = ctx.dup }
+      left.each { |name, ctx| merged[name] = ctx.dup }
       right.each do |name, ctx|
-        merged[name] = merged[name] ? merged[name].merge(ctx) : ctx.dup
+        merged.delete_if { |existing, _| existing.to_s == name.to_s }
+        merged[name] = ctx.dup
       end
       merged
     end

data/lib/quonfig/client.rb

@@ -2,6 +2,7 @@
 
 require 'json'
 require 'timeout'
+require 'set'
 
 module Quonfig
   # Public Quonfig SDK client.
@@ -63,6 +64,9 @@ module Quonfig
       @evaluator = Quonfig::Evaluator.new(@store, env_id: @options.environment)
       @resolver = Quonfig::Resolver.new(@store, @evaluator)
       @semantic_logger_filters = {}
+      # Keys already warned about for a malformed duration value (qfg-2agi.10).
+      @malformed_duration_warned = Set.new
+      @malformed_duration_mutex = Mutex.new
       @sse_client = nil
       @poll_supervisor = nil
       @stopped = false
@@ -161,14 +165,70 @@ module Quonfig
       typed_get(key, :string_list, default: default, context: context)
     end
 
+    # Integer milliseconds for a duration config (qfg-2agi.10).
+    #
+    # - A config whose valueType is not duration raises TypeMismatchError,
+    #   like get_int on a string config.
+    # - Values follow the shared grammar (Quonfig::Duration); ms are rounded
+    #   half up on both the stored and the ENV_VAR path.
+    # - A malformed value (stored or ENV_VAR) returns +default+ and logs one
+    #   warning per key. With no default it returns nil under
+    #   on_no_default: :return_nil and raises EnvVarParseError under :raise.
     def get_duration(key, default: NO_DEFAULT_PROVIDED, context: NO_DEFAULT_PROVIDED)
-      typed_get(key, :duration, default: default, context: context)
+      ensure_initialized_after_fork
+      ctx = build_context(context)
+      record_context_for_telemetry(ctx)
+      result =
+        begin
+          @resolver.get(key, ctx)
+        rescue Quonfig::Errors::MissingDefaultError
+          nil
+        rescue Quonfig::Errors::EnvVarParseError => e
+          return malformed_duration(key, default, e)
+        end
+      return handle_missing(key, default) if result.nil?
+
+      record_evaluation_for_telemetry(result)
+      duration_millis(key, result, default)
     end
 
     def get_json(key, default: NO_DEFAULT_PROVIDED, context: NO_DEFAULT_PROVIDED)
       typed_get(key, :json, default: default, context: context)
     end
 
+    # Like +get+, but never applies the +on_no_default+ policy (qfg-2agi.27):
+    #
+    # - A missing key (or a config with no matching value) returns +default:+
+    #   when one is given and otherwise raises MissingDefaultError, even
+    #   under on_no_default: :return_nil.
+    # - A config provided by an unset ENV_VAR raises MissingEnvVarError; an
+    #   ENV_VAR value that cannot be coerced to the config's type raises
+    #   EnvVarParseError; a decryption failure raises DecryptionError.
+    # - A malformed stored duration raises EnvVarParseError (a given
+    #   +default:+ is not applied; it only covers a missing key).
+    def get_or_raise(key, default: NO_DEFAULT_PROVIDED, context: NO_DEFAULT_PROVIDED)
+      ensure_initialized_after_fork
+      ctx = build_context(context)
+      record_context_for_telemetry(ctx)
+      result =
+        begin
+          @resolver.get(key, ctx)
+        rescue Quonfig::Errors::MissingDefaultError
+          nil
+        end
+      if result.nil?
+        raise Quonfig::Errors::MissingDefaultError, key if default == NO_DEFAULT_PROVIDED
+
+        return default
+      end
+
+      record_evaluation_for_telemetry(result)
+      value = result.unwrapped_value
+      raise malformed_stored_duration_error(result) if malformed_stored_duration?(result, value)
+
+      value
+    end
+
     # ---- Details getters ----------------------------------------------
     #
     # Mirrors the typed getters above but returns a +Quonfig::EvaluationDetails+
@@ -201,6 +261,13 @@ module Quonfig
       evaluate_details(key, :json, context)
     end
 
+    # Integer milliseconds in +value+ (qfg-2agi.27). A config whose valueType
+    # is not duration is ERROR / TYPE_MISMATCH; a malformed value (stored or
+    # ENV_VAR) is ERROR with a nil value.
+    def get_duration_details(key, context: NO_DEFAULT_PROVIDED)
+      evaluate_details(key, :duration, context)
+    end
+
     def enabled?(feature_name, jit_context = NO_DEFAULT_PROVIDED)
       value = get(feature_name, false, jit_context)
       [true, 'true'].include?(value)
@@ -1153,7 +1220,9 @@ module Quonfig
         config_type: config_field(config, :type),
         conditional_value_index: result.rule_index,
         weighted_value_index: result.weighted_value_index,
-        selected_value: result.unwrapped_value,
+        # Confidential / decryptWith values ship as the `*****<hash>` redacted
+        # form, never the plaintext (qfg-2agi.15).
+        selected_value: result.reportable_value.nil? ? result.unwrapped_value : result.reportable_value,
         reason: result.wire_reason
       )
     rescue StandardError => e
@@ -1516,7 +1585,7 @@ module Quonfig
 
     # Combine the customer-supplied globalContext with the optional dev
     # context loaded from ~/.quonfig/tokens.json. Dev context goes UNDER the
-    # customer's so any explicit `quonfig-user` keys win on collision.
+    # customer's, so an explicit customer `quonfig-user` context replaces it.
     def build_initial_global_context(options)
       customer = normalize_context(options.global_context)
       return customer unless dev_context_enabled?(options)
@@ -1549,21 +1618,19 @@ module Quonfig
       raise ArgumentError, "Quonfig context must be a Hash, got #{ctx.class}"
     end
 
-    # One-level-deep merge per named context (mirrors sdk-node's mergeContexts):
-    # later values override earlier within the same named context; keys unique
-    # to each side are preserved.
+    # Combine two context tiers (qfg-2agi.24): a named context in +right+
+    # REPLACES the whole same-named context in +left+ (no per-property merge);
+    # named contexts only in +left+ survive. Names compare as strings, so
+    # +:user+ and +'user'+ are the same named context.
     def merge_contexts(left, right)
       return right || {} if left.nil? || left.empty?
       return left if right.nil? || right.empty?
 
       merged = {}
-      left.each  { |name, ctx| merged[name] = ctx.is_a?(Hash) ? ctx.dup : ctx }
+      left.each { |name, ctx| merged[name] = ctx.is_a?(Hash) ? ctx.dup : ctx }
       right.each do |name, ctx|
-        merged[name] = if merged[name].is_a?(Hash) && ctx.is_a?(Hash)
-                         merged[name].merge(ctx)
-                       else
-                         ctx.is_a?(Hash) ? ctx.dup : ctx
-                       end
+        merged.delete_if { |existing, _| existing.to_s == name.to_s }
+        merged[name] = ctx.is_a?(Hash) ? ctx.dup : ctx
       end
       merged
     end
@@ -1623,6 +1690,10 @@ module Quonfig
       raw_value = result.unwrapped_value
 
       begin
+        if expected_type == :duration
+          raise Quonfig::Errors::TypeMismatchError.new(key, 'ISO-8601 Duration', raw_value) unless duration_result?(result)
+          raise malformed_stored_duration_error(result) if malformed_stored_duration?(result, raw_value)
+        end
         coerced = coerce_and_check(key, raw_value, expected_type) unless raw_value.nil?
       rescue Quonfig::Errors::TypeMismatchError => e
         return Quonfig::EvaluationDetails.new(
@@ -1701,6 +1772,42 @@ module Quonfig
       coerce_and_check(key, value, expected_type)
     end
 
+    def duration_millis(key, result, default)
+      raise Quonfig::Errors::TypeMismatchError.new(key, 'ISO-8601 Duration', result.unwrapped_value) unless duration_result?(result)
+
+      value = result.unwrapped_value
+      millis = value.is_a?(Integer) ? value : Quonfig::Duration.parse_millis(value)
+      return millis unless millis.nil?
+
+      malformed_duration(key, default, malformed_stored_duration_error(result))
+    end
+
+    def duration_result?(result)
+      config = result.config || {}
+      value_type = config['valueType'] || config[:valueType] || config['value_type'] || config[:value_type]
+      value_type == 'duration' || result.type == 'duration'
+    end
+
+    # A stored duration string outside the shared grammar unwraps to nil.
+    def malformed_stored_duration?(result, unwrapped)
+      unwrapped.nil? && result.type == 'duration' && !result.raw_value.nil?
+    end
+
+    def malformed_stored_duration_error(result)
+      Quonfig::Errors::EnvVarParseError.new(result.raw_value, result.config || {}, 'stored value')
+    end
+
+    def malformed_duration(key, default, error)
+      if @malformed_duration_mutex.synchronize { @malformed_duration_warned.add?(key.to_s) }
+        LOG.warn "[quonfig] #{key} is not a valid ISO-8601 duration; " \
+                 "#{default == NO_DEFAULT_PROVIDED ? 'no default given' : 'returning the default'}"
+      end
+      return default unless default == NO_DEFAULT_PROVIDED
+      raise error if @options.on_no_default == Quonfig::Options::ON_NO_DEFAULT::RAISE
+
+      nil
+    end
+
     def coerce_and_check(key, value, expected_type)
       case expected_type
       when :bool
@@ -1713,10 +1820,12 @@ module Quonfig
 
         arr
       when :duration
-        return value.to_i if value.is_a?(Numeric)
-        return (Quonfig::Duration.parse(value) * 1000).to_i if value.is_a?(String)
+        return value if value.is_a?(Integer)
+
+        millis = Quonfig::Duration.parse_millis(value)
+        raise Quonfig::Errors::TypeMismatchError.new(key, 'ISO-8601 Duration', value) if millis.nil?
 
-        raise Quonfig::Errors::TypeMismatchError.new(key, 'ISO-8601 Duration', value)
+        millis
       when :json
         # JSON values are returned as-is (Hash, Array, or scalar from the wire).
         value

data/lib/quonfig/duration.rb

@@ -1,27 +1,76 @@
 # frozen_string_literal: true
 
 module Quonfig
+  # ISO-8601 duration parsing for the grammar every Quonfig SDK shares
+  # (integration-test-data/tests/duration/grammar.yaml, qfg-2agi.29):
+  #
+  #   \AP(?:[0-9]+D)?(?:T(?:[0-9]+H)?(?:[0-9]+M)?(?:[0-9]+(?:\.[0-9]{1,9})?S)?)?\z
+  #
+  # plus: at least one component, no dangling T, a fraction only on S (at
+  # most 9 digits), total magnitude <= P36500D. Anchored with \A/\z (Ruby's
+  # ^/$ match at line boundaries) and [0-9] (never \d).
+  #
+  # Milliseconds use exact Rational arithmetic, rounded half up.
   class Duration
-    PATTERN = /P(?:(?<days>\d+(?:\.\d+)?)D)?(?:T(?:(?<hours>\d+(?:\.\d+)?)H)?(?:(?<minutes>\d+(?:\.\d+)?)M)?(?:(?<seconds>\d+(?:\.\d+)?)S)?)?/
+    PATTERN = /\AP(?:(?<days>[0-9]+)D)?(?:T(?<time>(?:(?<hours>[0-9]+)H)?(?:(?<minutes>[0-9]+)M)?(?:(?<seconds>[0-9]+(?:\.[0-9]{1,9})?)S)?))?\z/
     MINUTES_IN_SECONDS = 60
     HOURS_IN_SECONDS = 60 * MINUTES_IN_SECONDS
     DAYS_IN_SECONDS = 24 * HOURS_IN_SECONDS
+    MAX_SECONDS = 36_500 * DAYS_IN_SECONDS
 
     def initialize(definition)
       @seconds = self.class.parse(definition)
     end
 
+    # Integer milliseconds for a valid duration string, or nil when +definition+
+    # is not a String or does not match the grammar.
+    def self.parse_millis(definition)
+      seconds = exact_seconds(definition)
+      return nil if seconds.nil?
+
+      (seconds * 1000).round(half: :up).to_i
+    end
+
+    def self.valid?(definition)
+      !exact_seconds(definition).nil?
+    end
+
+    # Seconds as a Float. Raises ArgumentError when +definition+ is not a valid
+    # duration (it used to return 0 for anything unparseable).
     def self.parse(definition)
+      seconds = exact_seconds(definition)
+      raise ArgumentError, "invalid ISO-8601 duration: #{definition.inspect}" if seconds.nil?
+
+      seconds.to_f
+    end
+
+    # Exact Rational seconds, or nil when invalid.
+    def self.exact_seconds(definition)
+      return nil unless definition.is_a?(String)
+
       match = PATTERN.match(definition)
-      return 0 unless match
+      return nil if match.nil?
+      return nil if match[:days].nil? && match[:time].nil?
+      return nil if match[:time] && match[:time].empty?
+
+      total = (Integer(match[:days] || '0', 10) * DAYS_IN_SECONDS) +
+              (Integer(match[:hours] || '0', 10) * HOURS_IN_SECONDS) +
+              (Integer(match[:minutes] || '0', 10) * MINUTES_IN_SECONDS) +
+              decimal_seconds(match[:seconds])
+      return nil if total > MAX_SECONDS
+
+      total
+    end
+
+    def self.decimal_seconds(text)
+      return 0 if text.nil?
 
-      days = match[:days]&.to_f || 0
-      hours = match[:hours]&.to_f || 0
-      minutes = match[:minutes]&.to_f || 0
-      seconds = match[:seconds]&.to_f || 0
+      whole, frac = text.split('.', 2)
+      return Integer(whole, 10) if frac.nil?
 
-      ((days * DAYS_IN_SECONDS) + (hours * HOURS_IN_SECONDS) + (minutes * MINUTES_IN_SECONDS) + seconds)
+      Integer(whole, 10) + Rational(Integer(frac, 10), 10**frac.length)
     end
+    private_class_method :decimal_seconds
 
     def in_seconds
       @seconds

data/lib/quonfig/evaluator.rb

@@ -556,8 +556,9 @@ module Quonfig
       when Numeric
         raw.to_i
       when String
-        seconds = Quonfig::Duration.parse(raw)
-        (seconds * 1000).round
+        # nil for a malformed value, so get() never returns the raw string or
+        # a made-up number; Client#get_duration applies the default.
+        Quonfig::Duration.parse_millis(raw)
       when Hash
         secs = (raw['seconds'] || raw[:seconds] || 0).to_f
         nanos = (raw['nanos'] || raw[:nanos] || 0).to_f

data/lib/quonfig/murmer3.rb

@@ -25,10 +25,14 @@ class Murmur3
     (k1 * 0x1b873593) & MASK32
   end
 
+  # Hashes the string's BYTES (UTF-8 for any normal Ruby string), like every
+  # other Quonfig SDK. Using the character count instead of the byte count put
+  # non-ASCII input in the wrong tail/length mix (qfg-1mvb).
   def self.murmur3_32(str, seed = 0)
+    bytes = str.b
     h1 = seed
-    numbers = str.unpack('V*C*')
-    tailn = str.length % 4
+    numbers = bytes.unpack('V*C*')
+    tailn = bytes.bytesize % 4
     tail = numbers.slice!(numbers.size - tailn, tailn)
     numbers.each do |k1|
       h1 ^= murmur3_32__mmix(k1)
@@ -44,7 +48,7 @@ class Murmur3
       h1 ^= murmur3_32__mmix(k1)
     end
 
-    h1 ^= str.length
+    h1 ^= bytes.bytesize
     murmur3_32_fmix(h1)
   end
 end

data/lib/quonfig/reason.rb

@@ -7,7 +7,7 @@ module Quonfig
   #   :DEFAULT     — config has no targeting rules; matched value is the static default
   #   :RULE_MATCH  — at least one targeting rule exists on the config (the matched
   #                  conditional may itself be ALWAYS_TRUE, but the *config* is targeted)
-  #   :SPLIT       — matched value came from a non-default weighted variant
+  #   :SPLIT       — matched value came from a weighted variant (any bucket, including 0)
   #   :ERROR       — evaluation failed
   #   :UNKNOWN     — unable to determine
   module Reason
@@ -20,7 +20,7 @@ module Quonfig
     module_function
 
     def compute(config:, conditional_value:, weighted_value_index: nil)
-      return SPLIT if weighted_value_index&.positive?
+      return SPLIT unless weighted_value_index.nil?
       return RULE_MATCH if targeting_rules?(config)
       return RULE_MATCH if non_always_true_criteria?(conditional_value)
 

data/lib/quonfig/resolver.rb

@@ -274,6 +274,8 @@ module Quonfig
       when 'string_list'
         env_value.split(/\s*,\s*/)
       when 'duration'
+        raise ArgumentError, 'invalid ISO-8601 duration' unless Quonfig::Duration.valid?(env_value)
+
         env_value
       else
         env_value
@@ -288,6 +290,9 @@ module Quonfig
       when 'double'      then 'double'
       when 'bool'        then 'bool'
       when 'string_list' then 'string_list'
+      # Keep 'duration' so Evaluator#unwrapped_value converts to ms and
+      # get() matches the stored path (qfg-2agi.22).
+      when 'duration'    then 'duration'
       else 'string'
       end
     end

data/lib/quonfig/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quonfig
-  VERSION = '1.6.0'
+  VERSION = '1.7.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quonfig
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-28 00:00:00.000000000 Z
+date: 2026-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport