familia 2.9.0 → 2.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42bbbbcb737ab4222505955e5b1af2ab72ed962ba80a02cf324206b4f2379b94
-  data.tar.gz: 331b1d0bb0808618a87d962e1b09af61a31d59b7b8d56b0f49513cb9f3fec63d
+  metadata.gz: d24c3b38092f1192f8e250553e8ef4d51b05c1bb00c48dfd7f6520d3a48a9a0e
+  data.tar.gz: 1dd0a2aa47682736209f116adf378eb4a0eccafffd7c151b02a8ef4573e52551
 SHA512:
-  metadata.gz: 9ff40710ce23c2f3dadbfbf68142800b8f10590c898f30f424819a4f0efea9aa545c52307c487c6fd96bf0c0f95f7504e5614056a30039f75f9db84fe1fcd595
-  data.tar.gz: be6c618b3fab3eb5ac8577c8a4bd7fbbbc53ce300da750baf3f64d70807a0aeb2a3a7a7f28da91d7637ebe86d9f2ccc86b677478ed90ab3ae7878d6d8816cd09
+  metadata.gz: 10d69edb30370c7dba83b387f53429878fded6bf736e04fbefec4c228baf375806eeefa6c1d44c45c296e5d79b82345d1bc9cfbb0992ee18fc4c204dac250e10
+  data.tar.gz: 9b52e601ae93d44a6db8b0f995828ae45d55872377a471658a8d63210607c56f70958e372654ac20a13b07344e9b9da0afcdaaa50203f0796326d5d08e93bf6b

data/CHANGELOG.rst

@@ -7,6 +7,50 @@ The format is based on `Keep a Changelog <https://keepachangelog.com/en/1.1.0/>`
 
    <!--scriv-insert-here-->
 
+.. _changelog-2.9.1:
+
+2.9.1 — 2026-05-18
+==================
+
+Added
+-----
+
+- ``SortedSet#update`` (aliased ``merge!``) for bulk member insertion. A sorted
+  set is ``member => score`` -- the same pair shape as ``HashKey``'s
+  ``field => value`` -- so it follows the established ``HashKey#update``/``merge!``
+  convention (a single Hash argument) rather than the variadic splat used by the
+  value-only ``UnsortedSet``/``ListKey``. Pass ``{member => score}`` to issue one
+  ``ZADD`` instead of one round-trip per member. Validates the argument is a Hash
+  and that every score is ``Numeric`` (a missing/``nil`` score raises a clear
+  ``ArgumentError`` instead of a low-level client error -- unlike single-value
+  ``#add``, the bulk path does not default a missing score to ``Familia.now``).
+  Cascades expiration, and is a no-op returning ``0`` for empty input. The
+  single-value ``SortedSet#add`` (and its array-as-single-member contract) is
+  unchanged. PR #269
+
+Changed
+-------
+
+- Bulk-write optimization for multi-value collection mutations. ``UnsortedSet#add``,
+  ``ListKey#push``, and ``ListKey#unshift`` previously issued one Redis command per
+  element (a loop of ``SADD``/``RPUSH``/``LPUSH`` calls), making large populations
+  slow even when pipelined. They now serialize all values and issue a single bulk
+  ``SADD``/``RPUSH``/``LPUSH`` command. Element ordering, ``nil`` compaction, nested
+  array flattening, return values, dirty-write warnings, and expiration cascading
+  are unchanged; empty calls remain no-ops. PR #269
+
+AI Assistance
+-------------
+
+- AI investigated all collection ``DataType`` classes for the same per-element
+  loop anti-pattern, identified the three affected methods, verified
+  behavior-preservation (ordering, edge cases, chainability) at the Redis wire
+  level, and confirmed zero regressions against the existing test suites. The
+  ``SortedSet#update`` API shape was chosen by priority order: existing Familia
+  conventions first (the ``HashKey#update``/``merge!`` precedent for keyed
+  collections), then the upstream redis-rb bulk ``ZADD`` form, then Ruby
+  ``Hash#merge!`` semantics as confirmation.
+
 .. _changelog-2.9.0:
 
 2.9.0 — 2026-05-17

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    familia (2.9.0)
+    familia (2.9.1)
       concurrent-ruby (~> 1.3)
       connection_pool (>= 2.4, < 4.0)
       csv (~> 3.3)

data/docs/guides/datatype-collections.md

@@ -0,0 +1,159 @@
+# docs/guides/datatype-collections.md
+---
+
+# DataType - Collection classes
+
+UnsortedSet, Sorted Set, List, and Hash data types all include the `Collection` module. This guide covers two performance-sensitive concerns: writing many elements efficiently (a single bulk command instead of one round-trip per element), and iterating large collections efficiently via `each` and `each_record`.
+
+## Bulk writes — single round-trip mutations
+
+Collection mutations are **immediate** — every call hits Valkey/Redis right away, unlike scalar `field` setters which are deferred until `save`. Each call also runs `warn_if_dirty!` and cascades expiration. (See the write-model notes in `CLAUDE.md` for the deferred-vs-immediate split.)
+
+Multi-element adds issue **one** command for the whole batch, not one per element. Populating a large collection is therefore a single round-trip even without an explicit pipeline.
+
+The argument shape follows the collection's structure, and is consistent across the codebase:
+
+- **Value-only** collections (`UnsortedSet`, `ListKey`) take a **variadic splat**; arguments are flattened and `nil`-compacted.
+- **Keyed/pair** collections (`HashKey` is `field => value`, `SortedSet` is `member => score`) take a **single Hash** via `update` (aliased `merge!`), raising `ArgumentError` on a non-Hash.
+
+| Type | Bulk method | Call shape | Redis command |
+|---|---|---|---|
+| `UnsortedSet` | `add(*values)` | `tags.add(:a, :b, :c)` | one `SADD` |
+| `ListKey` | `push(*values)` / `unshift(*values)` | `log.push(1, 2, 3)` | one `RPUSH` / `LPUSH` |
+| `HashKey` | `update(hash)` / `merge!` | `cfg.update(a: 1, b: 2)` | one `HMSET` |
+| `SortedSet` | `update(hash)` / `merge!` | `board.update("alice" => 1000, "bob" => 850)` | one `ZADD` |
+
+```ruby
+tags.add(:ruby, :redis, :valkey)              # 1 SADD, returns self
+log.push("a", "b", "c")                        # 1 RPUSH → [a, b, c]
+board.update("alice" => 1000, "bob" => 850)    # 1 ZADD, returns new-member count (2)
+board.merge!("alice" => 1200)                  # 1 ZADD, score updated → returns 0
+```
+
+Behavior notes:
+
+- **Ordering**: `push` preserves argument order; `unshift` prepends each element in turn, so `unshift(a, b, c)` leaves the list head as `c, b, a` (Redis `LPUSH` semantics — unchanged from the prior per-element implementation). Sets are unordered; sorted sets order by score.
+- **Empty input is a no-op**: `add()` / `push()` / `update({})` issue no command. Set/list adds return `self`; `SortedSet#update` returns `0`.
+- **`SortedSet#add(val, score, …)` is unchanged and not bulk** — it takes a single member plus score and the conditional ZADD options (`nx:`, `xx:`, `gt:`, `lt:`, `ch:`). An Array passed as `val` is stored as one JSON-encoded member, not exploded into many. Use `update`/`merge!` for bulk insertion.
+
+The iteration methods `each` and `each_record` efficiently handle large collections by paginating through Valkey/Redis data structures, but they serve different purposes and yield different results. Here's how the two iterate, using `ModelClass.instances` (a `SortedSet` with `reference: true`) as the running example.
+
+## `each` — yields **members** (identifiers, raw strings)
+
+`each` is implemented per type. For the `instances` SortedSet, it pages through the ZSET with either `ZRANGEBYSCORE` (when `since:`/`until:` are given) or `ZSCAN` (unbounded), yielding one deserialized member at a time.
+
+```mermaid
+flowchart TD
+  Caller["ModelClass.instances.each { |id| ... }"] --> EachImpl["SortedSet#each"]
+  EachImpl --> Decide{since/until?}
+  Decide -- yes --> ZRBS["ZRANGEBYSCORE key min max LIMIT 0 batch_size WITHSCORES"]
+  Decide -- no --> ZSCAN["ZSCAN key cursor COUNT batch_size"]
+  ZRBS --> Page["Page of raw members"]
+  ZSCAN --> Page
+  Page --> Yield["yield deserialize_value(member)"]
+  Yield --> More{more pages?}
+  More -- yes --> Decide
+  More -- no --> Done["return self"]
+```
+
+Per-type variations:
+- `ListKey#each` — paginates with `LRANGE start stop` (no SCAN equivalent)
+- `UnsortedSet#each` / `HashKey#each` — `SSCAN` / `HSCAN`, optional `matching:` glob
+- `SortedSet#each` — `ZRANGEBYSCORE` (bounded) or `ZSCAN` (unbounded)
+
+You get **identifiers only**. No record loading. One Redis round-trip per page.
+
+## `each_record` — yields **loaded Horreum records**
+
+`each_record` is defined once in `CollectionBase` and delegates to `each` to collect identifiers, then batches them into `record_class.load_multi` (pipelined `HGETALL`s), filters ghosts, and yields the live records.
+
+```mermaid
+flowchart TD
+  Caller["ModelClass.instances.each_record { |rec| ... }"] --> ER["each_record(batch_size, pipeline, **filters)"]
+  ER --> Validate{"pipeline <= batch_size?"}
+  Validate -- no --> Raise["raise ArgumentError"]
+  Validate -- yes --> CallEach["each(**filters) do |member|"]
+  CallEach --> Extract["id = member.is_a?(Array) ? member.first : member"]
+  Extract --> Buffer["buffer << id"]
+  Buffer --> Full{"buffer.size >= batch_size?"}
+  Full -- no --> CallEach
+  Full -- yes --> Load["record_class.load_multi(ids)  -- pipelined HGETALLs"]
+  Load --> Compact["live = records.compact  -- drop ghosts"]
+  Compact --> Mode{pipeline?}
+  Mode -- nil --> Serial["live.each { |r| block.call(r) }"]
+  Mode -- positive --> Pipe["live.each_slice(pipeline) do |group|<br/>record_class.pipelined { group.each &block }<br/>end"]
+  Serial --> Clear["buffer.clear; resume each"]
+  Pipe --> Clear
+  Clear --> CallEach
+  CallEach -. each exhausted .-> Flush["process_batch(buffer) if any remain"]
+  Flush --> Return["return self"]
+```
+
+### Concrete timeline for `User.instances.each_record(batch_size: 100, pipeline: 25) { |u| u.touch! }`
+
+```
+SortedSet#each (ZSCAN page 1, 100 ids)
+   ├─ buffer fills to 100
+   ├─ load_multi(ids)        → 1 pipeline of 100 HGETALLs
+   ├─ compact ghosts          → e.g. 97 live records
+   ├─ slice(25):
+   │     pipelined { 25 × u.touch! }   ← 1 Redis pipeline
+   │     pipelined { 25 × u.touch! }   ← 1 Redis pipeline
+   │     pipelined { 25 × u.touch! }   ← 1 Redis pipeline
+   │     pipelined { 22 × u.touch! }   ← 1 Redis pipeline
+   └─ buffer.clear
+SortedSet#each (ZSCAN page 2, 100 ids)
+   └─ … repeat …
+SortedSet#each exhausted
+   └─ flush any remaining buffered ids the same way
+```
+
+## Key differences
+
+| Aspect | `each` | `each_record` |
+|---|---|---|
+| Yields | raw identifier (or `[field, value]` for `HashKey`) | loaded Horreum instance |
+| Redis ops per yield | 0 extra (already paged) | amortized `HGETALL` via `load_multi` batch |
+| Requires `reference: true` + `:class` | no | yes (raises `Familia::Problem` otherwise) |
+| Ghost handling | yields the dangling id | `compact` drops them silently |
+| Write pipelining | not built-in | `pipeline:` groups block-body writes into `pipelined` blocks |
+| Filters | type-specific (`since:`, `matching:`, …) | forwarded to underlying `each` |
+
+So `each_record` is a thin orchestration layer: it leans on the type's own `each` for read pagination, then layers (1) batched record hydration and (2) optional write pipelining on top.
+
+## Choosing a `pipeline` mode
+
+`each_record` has two dispatch modes, controlled by `pipeline:`. The parameter answers a single question: **may the dispatch loop wrap your block in a `pipelined { }`?**
+
+| Value | Dispatch | Use when the block… |
+|---|---|---|
+| `nil` (default) | Each record runs in its own connection context, no pipeline wrapper | …reads, OR calls `save` / `commit_fields` / `transaction` / anything with its own internal MULTI |
+| positive integer | Groups of `pipeline` records run inside `record_class.pipelined { ... }` | …only issues fast writers (`record.field!`) that tolerate being queued |
+
+Note: `pipeline: 0` raises `ArgumentError`. Use `pipeline: nil` to disable pipelining.
+
+The read-only case and the serial-write case collapse into the same mode because both require **immediate** execution with real return values. Wrapping `save` in an outer `pipelined` would either return `Redis::Future` objects or raise `ConflictingContextError` when `save`'s internal transaction tries to open.
+
+### The three idiomatic patterns
+
+```ruby
+# 1. Read-only iteration — the default (pipeline: nil) is correct
+User.instances.each_record do |user|
+  puts "#{user.email} #{user.last_login}"
+end
+
+# 2. Serial writes — the default (pipeline: nil) is required for save / commit_fields / transaction
+User.instances.each_record do |user|
+  user.score = recompute(user)
+  user.save
+end
+
+# 3. Pipelined fast writers — opt-in optimization
+User.instances.each_record(pipeline: 50) do |user|
+  user.last_seen_at! Familia.now   # single HSET, safe to queue in pipeline
+end
+```
+
+### Pipelining footgun
+
+If you enable pipelining and your block reads from a related collection (e.g. `user.sessions.size`), that read is queued into the pipeline and returns a `Redis::Future` rather than a value. Omit the `pipeline:` parameter (or explicitly pass `pipeline: nil`) whenever the block needs real return values from Redis.

data/docs/migrating/v2.9.0.md

@@ -82,12 +82,12 @@ Org.instances.each_record(batch_size: 100) do |org|
 end
 
 # Control pipelining depth separately from fetch batch size
-Org.instances.each_record(batch_size: 500, write_size: 50) do |org|
+Org.instances.each_record(batch_size: 500, pipeline: 50) do |org|
   org.status!("active")
 end
 
-# Serial execution (no pipelining)
-Org.instances.each_record(batch_size: 100, write_size: nil) do |org|
+# Serial execution (no pipelining) — this is the default
+Org.instances.each_record(batch_size: 100) do |org|
   org.complex_operation
 end
 ```

data/lib/familia/data_type/collection_base.rb

@@ -45,10 +45,10 @@ module Familia
       # filtered out.
       #
       # @param batch_size [Integer] Number of identifiers to load per batch
-      # @param write_size [Integer, nil] Controls pipelining depth for writes
-      #   in the block. When nil or 0, writes are serial (no pipelining).
-      #   When positive, fast writers in the block will be pipelined in
-      #   groups of this size.
+      # @param pipeline [Integer, nil] Controls pipelining depth for writes
+      #   in the block. When nil (default), writes are serial (no pipelining).
+      #   When a positive integer, fast writers in the block will be pipelined
+      #   in groups of this size. Must not exceed batch_size.
       # @param filters [Hash] Additional filter parameters passed to `each`.
       #   Available filters depend on the collection type:
       #   - SortedSet: `since:`, `until:`, `cursor_batch_size:`
@@ -58,20 +58,17 @@ module Familia
       # @yield [record] Each loaded Horreum record (non-nil)
       # @return [Enumerator, self] Returns Enumerator if no block given, self otherwise
       #
-      # @example Iterate over all records
+      # @example Iterate over all records (no pipelining, safe default)
       #   User.instances.each_record { |user| user.deactivate! }
       #
       # @example With time filter (for SortedSet)
       #   User.instances.each_record(since: 1.day.ago) { |u| notify(u) }
       #
       # @example Pipeline writes in groups
-      #   items.each_record(batch_size: 500, write_size: 50) { |r| r.foo! 'bar' }
+      #   items.each_record(batch_size: 500, pipeline: 50) { |r| r.foo! 'bar' }
       #
-      # @example Serial writes (no pipelining)
-      #   items.each_record(write_size: nil) { |r| r.save }
-      #
-      def each_record(batch_size: 100, write_size: batch_size, **filters, &block)
-        return to_enum(:each_record, batch_size: batch_size, write_size: write_size, **filters) unless block
+      def each_record(batch_size: 100, pipeline: nil, **filters, &block)
+        return to_enum(:each_record, batch_size: batch_size, pipeline: pipeline, **filters) unless block
 
         # Determine the class to load records from
         # For reference DataTypes, @opts[:class] holds the Horreum class
@@ -80,10 +77,10 @@ module Familia
           raise Familia::Problem, "each_record requires a reference DataType with a :class option that responds to load_multi"
         end
 
-        # Validate write_size constraints
-        if write_size && write_size > batch_size
-          raise ArgumentError, "write_size (#{write_size}) cannot exceed batch_size (#{batch_size})"
-        end
+        # Validate batch_size and pipeline constraints
+        raise ArgumentError, "batch_size must be a positive integer (got #{batch_size.inspect})" unless batch_size.is_a?(Integer) && batch_size.positive?
+        raise ArgumentError, "pipeline must be nil or a positive integer (got #{pipeline.inspect})" unless pipeline.nil? || (pipeline.is_a?(Integer) && pipeline.positive?)
+        raise ArgumentError, "pipeline (#{pipeline}) cannot exceed batch_size (#{batch_size})" if pipeline&.> batch_size
 
         # Collect identifiers in batches
         buffer = []
@@ -97,12 +94,12 @@ module Familia
           # Filter out ghosts (nil results from expired keys)
           live_records = records.compact
 
-          if write_size.nil? || write_size.zero?
+          if pipeline.nil?
             # Serial mode - no pipelining, execute block for each record directly
             live_records.each { |record| block.call(record) }
           else
             # Pipelined mode - group records and wrap each group in a pipeline
-            live_records.each_slice(write_size) do |group|
+            live_records.each_slice(pipeline) do |group|
               record_class.pipelined do
                 group.each { |record| block.call(record) }
               end

data/lib/familia/data_type/types/json_stringkey.rb

@@ -108,7 +108,7 @@ module Familia
     #
     def del
       ret = dbclient.del dbkey
-      ret.positive?
+      Familia.positive?(ret)
     end
 
     # Checks if the value is nil (key does not exist or has no value).

data/lib/familia/data_type/types/listkey.rb

@@ -25,7 +25,8 @@ module Familia
     def push *values
       warn_if_dirty!
       echo :push, Familia.pretty_stack(limit: 1) if Familia.debug
-      values.flatten.compact.each { |v| dbclient.rpush dbkey, serialize_value(v) }
+      serialized = values.flatten.compact.map { |v| serialize_value(v) }
+      dbclient.rpush(dbkey, serialized) unless serialized.empty?
       dbclient.ltrim dbkey, -@opts[:maxlength], -1 if @opts[:maxlength]
       update_expiration
       self
@@ -43,7 +44,8 @@ module Familia
     #   scalar field changes, consider calling save first to avoid split-brain state.
     def unshift *values
       warn_if_dirty!
-      values.flatten.compact.each { |v| dbclient.lpush dbkey, serialize_value(v) }
+      serialized = values.flatten.compact.map { |v| serialize_value(v) }
+      dbclient.lpush(dbkey, serialized) unless serialized.empty?
       # TODO: test maxlength
       dbclient.ltrim dbkey, 0, @opts[:maxlength] - 1 if @opts[:maxlength]
       update_expiration
@@ -228,7 +230,7 @@ module Familia
               raise ArgumentError, "position must be :before or :after, got #{position.inspect}"
             end
       result = dbclient.linsert dbkey, pos, serialize_value(pivot), serialize_value(value)
-      update_expiration if result.positive?
+      update_expiration if Familia.positive?(result) == true
       result
     end
     alias linsert insert
@@ -265,7 +267,7 @@ module Familia
 
       warn_if_dirty!
       result = dbclient.rpushx(dbkey, serialized_values)
-      update_expiration if result.positive?
+      update_expiration if Familia.positive?(result) == true
       result
     end
     alias rpushx pushx
@@ -281,7 +283,7 @@ module Familia
 
       warn_if_dirty!
       result = dbclient.lpushx(dbkey, serialized_values)
-      update_expiration if result.positive?
+      update_expiration if Familia.positive?(result) == true
       result
     end
     alias lpushx unshiftx

data/lib/familia/data_type/types/sorted_set.rb

@@ -135,6 +135,51 @@ module Familia
     end
     alias add_element add
 
+    # Bulk-adds or updates multiple members in a single ZADD.
+    #
+    # Mirrors HashKey#update/merge! -- the established Familia pattern for
+    # bulk-setting keyed collections. A sorted set is member => score, the
+    # same pair shape as HashKey's field => value, so it takes a Hash rather
+    # than the variadic splat used by the value-only UnsortedSet/ListKey.
+    #
+    # Issues exactly one ZADD instead of one round-trip per member, which is
+    # what makes populating a large sorted set fast.
+    #
+    # @param hsh [Hash] Mapping of member => score (Object => Numeric)
+    # @return [Integer] Number of new members added (members whose score was
+    #   merely updated are not counted), per redis-rb's bulk ZADD return value
+    # @raise [ArgumentError] If the argument is not a Hash, or any score is
+    #   not Numeric
+    #
+    # @example
+    #   board.update("alice" => 1000, "bob" => 850)  #=> 2
+    #   board.merge!("alice" => 1200)                 #=> 0 (score updated)
+    #
+    # @note Unlike single-value #add, scores are required: this bulk path does
+    #   not default a missing score to Familia.now. A non-Numeric score (e.g.
+    #   nil) raises ArgumentError rather than surfacing a low-level client
+    #   error.
+    #
+    # @note Like #add, this executes immediately (not deferred) and cascades
+    #   expiration. Empty input is a no-op returning 0.
+    def update(hsh = {})
+      warn_if_dirty!
+      raise ArgumentError, 'Argument to bulk add must be a hash' unless hsh.is_a?(Hash)
+      return 0 if hsh.empty?
+
+      pairs = hsh.map do |member, score|
+        unless score.is_a?(Numeric)
+          raise ArgumentError, "SortedSet#update score for #{member.inspect} must be Numeric, got #{score.class}"
+        end
+
+        [score, serialize_value(member)]
+      end
+      ret = dbclient.zadd(dbkey, pairs)
+      update_expiration
+      ret
+    end
+    alias merge! update
+
     def score(val)
       ret = dbclient.zscore dbkey, serialize_value(val)
       ret&.to_f

data/lib/familia/data_type/types/stringkey.rb

@@ -233,7 +233,7 @@ module Familia
 
     def del
       ret = dbclient.del dbkey
-      ret.positive?
+      Familia.positive?(ret)
     end
 
     # Class methods for multi-key operations

data/lib/familia/data_type/types/unsorted_set.rb

@@ -26,7 +26,8 @@ module Familia
     #   scalar field changes, consider calling save first to avoid split-brain state.
     def add *values
       warn_if_dirty!
-      values.flatten.compact.each { |v| dbclient.sadd? dbkey, serialize_value(v) }
+      serialized = values.flatten.compact.map { |v| serialize_value(v) }
+      dbclient.sadd?(dbkey, serialized) unless serialized.empty?
       update_expiration
       self
     end

data/lib/familia/features/encrypted_fields/encrypted_field_type.rb

@@ -108,25 +108,7 @@ module Familia
         klass.define_method fast_method_name do |val|
           raise ArgumentError, "#{fast_method_name} requires a value" if val.nil?
 
-          # Prevent fast writer within transaction/pipeline - the return value
-          # would be Redis::Future which doesn't support zero?/positive? checks
-          if Fiber[:familia_transaction]
-            Familia.trace :FAST_WRITER_BLOCKED, dbkey,
-                         "#{fast_method_name} blocked by active transaction context"
-            raise Familia::OperationModeError, <<~ERROR_MESSAGE.chomp
-              Cannot call fast writer #{fast_method_name} within a transaction.
-              Use multi_field_update or commit_fields instead.
-            ERROR_MESSAGE
-          elsif Fiber[:familia_pipeline]
-            Familia.trace :FAST_WRITER_BLOCKED, dbkey,
-                         "#{fast_method_name} blocked by active pipeline context"
-            raise Familia::OperationModeError, <<~ERROR_MESSAGE.chomp
-              Cannot call fast writer #{fast_method_name} within a pipeline.
-              Restructure to call fast writers outside the pipeline.
-            ERROR_MESSAGE
-          end
-
-          # UnsortedSet via the setter method to get proper ConcealedString wrapping
+          # Use via the setter method to get proper ConcealedString wrapping
           send(:"#{method_name}=", val) if method_name
 
           # Get the ConcealedString and extract encrypted data for storage
@@ -136,7 +118,7 @@ module Familia
           return false if encrypted_data.nil?
 
           ret = hset(field_name, encrypted_data)
-          ret.zero? || ret.positive?
+          Familia.success?(ret)
         end
       end
     end

data/lib/familia/features/expiration.rb

@@ -342,7 +342,7 @@ module Familia
       # @return [Boolean] true if TTL is set, false if data persists indefinitely
       #
       def expires?
-        ttl.positive?
+        Familia.positive?(ttl)
       end
 
       # Check if this object's data has expired or will expire soon
@@ -377,7 +377,7 @@ module Familia
       #
       def extend_expiration(duration)
         current_ttl = ttl
-        return false unless current_ttl.positive? # no current expiration set
+        return false unless Familia.positive?(current_ttl) == true # no current expiration set
 
         new_ttl = current_ttl + duration.to_f
         expire(new_ttl)

data/lib/familia/field_type.rb

@@ -154,24 +154,6 @@ module Familia
           # Handle Redis::Future objects during transactions
           return hget(field_name) if val.nil? || val.is_a?(Redis::Future)
 
-          # Prevent fast writer within transaction/pipeline - the return value
-          # would be Redis::Future which doesn't support zero?/positive? checks
-          if Fiber[:familia_transaction]
-            Familia.trace :FAST_WRITER_BLOCKED, dbkey,
-                         "#{fast_method_name} blocked by active transaction context"
-            raise Familia::OperationModeError, <<~ERROR_MESSAGE.chomp
-              Cannot call fast writer #{fast_method_name} within a transaction.
-              Use multi_field_update or commit_fields instead.
-            ERROR_MESSAGE
-          elsif Fiber[:familia_pipeline]
-            Familia.trace :FAST_WRITER_BLOCKED, dbkey,
-                         "#{fast_method_name} blocked by active pipeline context"
-            raise Familia::OperationModeError, <<~ERROR_MESSAGE.chomp
-              Cannot call fast writer #{fast_method_name} within a pipeline.
-              Restructure to call fast writers outside the pipeline.
-            ERROR_MESSAGE
-          end
-
           begin
             # Trace the operation if debugging is enabled
             Familia.trace :FAST_WRITER, nil, "#{field_name}: #{val.inspect}" if Familia.debug?
@@ -192,7 +174,7 @@ module Familia
 
             clear_dirty!(field_name) if respond_to?(:clear_dirty!)
 
-            ret.zero? || ret.positive?
+            Familia.success?(ret)
           rescue Familia::Problem => e
             raise "#{fast_method_name} method failed: #{e.message}", e.backtrace
           end

data/lib/familia/horreum/definition.rb

@@ -480,24 +480,6 @@ module Familia
             # Handle Redis::Future objects during transactions
             return hget field_name if val.nil? || val.is_a?(Redis::Future)
 
-            # Prevent fast writer within transaction/pipeline - the return value
-            # would be Redis::Future which doesn't support zero?/positive? checks
-            if Fiber[:familia_transaction]
-              Familia.trace :FAST_WRITER_BLOCKED, dbkey,
-                           "#{fast_method_name} blocked by active transaction context"
-              raise Familia::OperationModeError, <<~ERROR_MESSAGE.chomp
-                Cannot call fast writer #{fast_method_name} within a transaction.
-                Use multi_field_update or commit_fields instead.
-              ERROR_MESSAGE
-            elsif Fiber[:familia_pipeline]
-              Familia.trace :FAST_WRITER_BLOCKED, dbkey,
-                           "#{fast_method_name} blocked by active pipeline context"
-              raise Familia::OperationModeError, <<~ERROR_MESSAGE.chomp
-                Cannot call fast writer #{fast_method_name} within a pipeline.
-                Restructure to call fast writers outside the pipeline.
-              ERROR_MESSAGE
-            end
-
             begin
               # Trace the operation if debugging is enabled.
               Familia.trace :FAST_WRITER, nil, "#{field_name}: #{val.inspect}" if Familia.debug?
@@ -518,7 +500,7 @@ module Familia
 
               clear_dirty!(field_name) if respond_to?(:clear_dirty!)
 
-              ret.zero? || ret.positive?
+              Familia.success?(ret)
             rescue Familia::Problem => e
               # Raise a custom error message if an exception occurs during the execution of the method.
               raise "#{fast_method_name} method failed: #{e.message}", e.backtrace

data/lib/familia/horreum/management.rb

@@ -158,7 +158,7 @@ module Familia
           # Safe mode: Check existence first (original behavior)
           # We use a lower-level method here b/c we're working with the
           # full key and not just the identifier.
-          does_exist = dbclient.exists(objkey).positive?
+          does_exist = Familia.positive?(dbclient.exists(objkey))
 
           Familia.debug "[find_by_key] #{self} from key #{objkey} (exists: #{does_exist})"
           Familia.trace :FIND_BY_DBKEY_KEY, nil, objkey

data/lib/familia/utils.rb

@@ -8,6 +8,54 @@ module Familia
   module Utils
     using Familia::Refinements::TimeLiterals
 
+    # Future-aware success check for Redis command return values.
+    #
+    # Redis commands like HSET return 0 (updated existing) or 1 (created new).
+    # Both are success states. Inside a pipeline or transaction, the return
+    # value is a Redis::Future which cannot be inspected until the block
+    # completes.
+    #
+    # @param ret [Integer, Redis::Future] The return value from a Redis command
+    # @return [Boolean, Redis::Future] true/false for concrete values,
+    #   passthrough for Futures
+    #
+    # @example Normal usage
+    #   ret = dbclient.hset(key, field, value)
+    #   Familia.success?(ret)  #=> true (for 0 or 1)
+    #
+    # @example Inside pipeline
+    #   pipelined do
+    #     ret = dbclient.hset(key, field, value)
+    #     Familia.success?(ret)  #=> Redis::Future (passthrough)
+    #   end
+    #
+    def success?(ret)
+      ret.is_a?(Redis::Future) ? ret : (ret.zero? || ret.positive?)
+    end
+
+    # Future-aware positive check for Redis command return values.
+    #
+    # For commands where 0 means "nothing happened" and positive means
+    # "something happened" (e.g., EXISTS, DEL, LINSERT, TTL checks).
+    #
+    # @param ret [Integer, Redis::Future] The return value from a Redis command
+    # @return [Boolean, Redis::Future] true/false for concrete values,
+    #   passthrough for Futures
+    #
+    # @example Check if key exists
+    #   ret = dbclient.exists(key)
+    #   Familia.positive?(ret)  #=> true if key exists
+    #
+    # @example Check TTL inside pipeline
+    #   pipelined do
+    #     ret = dbclient.ttl(key)
+    #     Familia.positive?(ret)  #=> Redis::Future (passthrough)
+    #   end
+    #
+    def positive?(ret)
+      ret.is_a?(Redis::Future) ? ret : ret.positive?
+    end
+
     # Joins array elements with Familia delimiter
     # @param val [Array] elements to join
     # @return [String] joined string

data/lib/familia/version.rb

@@ -2,5 +2,5 @@
 
 module Familia
   # Version information for the Familia
-  VERSION = '2.9.0'.freeze
+  VERSION = '2.9.1'.freeze
 end

data/try/edge_cases/fast_writer_pipeline_support_try.rb

@@ -0,0 +1,80 @@
+require_relative '../support/helpers/test_helpers'
+
+Familia.debug = false
+
+# Test class for fast writer pipeline/transaction support
+class FastWriterPipelineTest < Familia::Horreum
+  identifier_field :testid
+  field :testid
+  field :name
+  field :planid
+  field :region
+end
+
+# Clean slate
+@obj = FastWriterPipelineTest.new(testid: 'fw-pipeline-test', name: 'initial', planid: 'old_plan')
+@obj.destroy!
+@obj.save
+
+## Fast writer inside pipeline returns Redis::Future
+result = nil
+@obj.pipelined do
+  result = @obj.planid!('new_plan_v1')
+end
+result.is_a?(Redis::Future)
+#=> true
+
+## Fast writer value is persisted after pipeline completes
+@obj.refresh!
+@obj.planid
+#=> 'new_plan_v1'
+
+## Multiple fast writers inside single pipeline all return Futures
+results = []
+@obj.pipelined do
+  results << @obj.planid!('plan_v2')
+  results << @obj.region!('ca-east-1')
+end
+results.all? { |r| r.is_a?(Redis::Future) }
+#=> true
+
+## Multiple fast writer values persisted after pipeline
+@obj.refresh!
+[@obj.planid, @obj.region]
+#=> ['plan_v2', 'ca-east-1']
+
+## Fast writer inside transaction returns Redis::Future
+result = nil
+@obj.transaction do
+  result = @obj.name!('tx-updated')
+end
+result.is_a?(Redis::Future)
+#=> true
+
+## Fast writer value is persisted after transaction completes
+@obj.refresh!
+@obj.name
+#=> 'tx-updated'
+
+## touch_instances! is called during pipelined fast writer
+@obj.class.instances.remove(@obj)
+raise "Setup failed: should not be member" if @obj.class.instances.member?(@obj.identifier)
+@obj.pipelined do
+  @obj.planid!('plan_v3')
+end
+@obj.class.instances.member?(@obj.identifier)
+#=> true
+
+## touch_instances! is called during transaction fast writer
+@obj.class.instances.remove(@obj)
+raise "Setup failed: should not be member" if @obj.class.instances.member?(@obj.identifier)
+@obj.transaction do
+  @obj.name!('tx-touch-test')
+end
+@obj.class.instances.member?(@obj.identifier)
+#=> true
+
+## Cleanup
+@obj.destroy!
+true
+#=> true

data/try/edge_cases/fast_writer_transaction_guard_try.rb

@@ -8,7 +8,7 @@ test_keys = { v1: Base64.strict_encode64('a' * 32) }
 Familia.config.encryption_keys = test_keys
 Familia.config.current_key_version = :v1
 
-# Test class for fast writer transaction/pipeline guards
+# Test class for fast writer transaction/pipeline behavior
 class FastWriterGuardTest < Familia::Horreum
   identifier_field :testid
   field :testid
@@ -16,7 +16,7 @@ class FastWriterGuardTest < Familia::Horreum
   field :value
 end
 
-# Test class for encrypted fast writer guards
+# Test class for encrypted fast writer behavior
 class EncryptedFastWriterGuardTest < Familia::Horreum
   feature :encrypted_fields
   identifier_field :testid
@@ -29,61 +29,43 @@ end
 @testobj.destroy!
 @testobj.save
 
-## Fast writer raises OperationModeError inside transaction
-begin
-  @testobj.transaction do
-    @testobj.name!('inside-transaction')
-  end
-  :should_have_raised
-rescue Familia::OperationModeError => e
-  e.message.include?('Cannot call fast writer')
-end
-#=> true
-
-## Fast writer raises OperationModeError inside pipeline
-begin
-  @testobj.pipelined do
-    @testobj.name!('inside-pipeline')
-  end
-  :should_have_raised
-rescue Familia::OperationModeError => e
-  e.message.include?('Cannot call fast writer')
+## Fast writer inside transaction returns Redis::Future
+result = nil
+@testobj.transaction do
+  result = @testobj.name!('inside-transaction')
 end
+result.is_a?(Redis::Future)
 #=> true
 
-## Transaction error message suggests multi_field_update or commit_fields
-begin
-  @testobj.transaction do
-    @testobj.name!('inside-transaction')
-  end
-  :should_have_raised
-rescue Familia::OperationModeError => e
-  e.message.include?('multi_field_update') && e.message.include?('commit_fields')
-end
-#=> true
+## Fast writer value is persisted after transaction completes
+@testobj.refresh
+@testobj.name
+#=> 'inside-transaction'
 
-## Pipeline error message suggests restructuring (not multi_field_update)
-begin
-  @testobj.pipelined do
-    @testobj.name!('inside-pipeline')
-  end
-  :should_have_raised
-rescue Familia::OperationModeError => e
-  e.message.include?('Restructure') && !e.message.include?('multi_field_update')
+## Fast writer inside pipeline returns Redis::Future
+result = nil
+@testobj.pipelined do
+  result = @testobj.value!('inside-pipeline')
 end
+result.is_a?(Redis::Future)
 #=> true
 
-## Fast writer works normally outside transaction
-@testobj.value!('direct-write')
+## Fast writer value is persisted after pipeline completes
+@testobj.refresh
 @testobj.value
-#=> 'direct-write'
+#=> 'inside-pipeline'
+
+## Fast writer works normally outside transaction (returns boolean)
+result = @testobj.name!('direct-write')
+[true, false].include?(result)
+#=> true
 
 ## Fast writer as getter works inside transaction (returns Future)
 result = nil
 @testobj.transaction do
   result = @testobj.value!
 end
-result.is_a?(Redis::Future) || result == 'direct-write'
+result.is_a?(Redis::Future) || result == 'inside-pipeline'
 #=> true
 
 ## Fast writer works after transaction completes
@@ -94,29 +76,28 @@ end
 @testobj.value
 #=> 'after-transaction'
 
-## Encrypted fast writer raises OperationModeError inside transaction
+## Encrypted fast writer inside transaction returns Redis::Future
 @encrypted = EncryptedFastWriterGuardTest.new(testid: 'enc-fw-guard-test')
 @encrypted.destroy!
 @encrypted.save
-begin
-  @encrypted.transaction do
-    @encrypted.secret!('sensitive-data')
-  end
-  :should_have_raised
-rescue Familia::OperationModeError => e
-  e.message.include?('Cannot call fast writer')
+result = nil
+@encrypted.transaction do
+  result = @encrypted.secret!('sensitive-data')
 end
+result.is_a?(Redis::Future)
 #=> true
 
-## Encrypted fast writer raises OperationModeError inside pipeline
-begin
-  @encrypted.pipelined do
-    @encrypted.secret!('sensitive-data')
-  end
-  :should_have_raised
-rescue Familia::OperationModeError => e
-  e.message.include?('Cannot call fast writer')
+## Encrypted fast writer value is persisted after transaction
+@encrypted.refresh
+@encrypted.secret.to_s.length > 0
+#=> true
+
+## Encrypted fast writer inside pipeline returns Redis::Future
+result = nil
+@encrypted.pipelined do
+  result = @encrypted.secret!('updated-secret')
 end
+result.is_a?(Redis::Future)
 #=> true
 
 ## Cleanup

data/try/unit/data_types/each_record_try.rb

@@ -89,26 +89,33 @@ records.size
 #=> 5
 
 # ============================================================
-# write_size parameter for pipelining
+# pipeline parameter for pipelining (renamed from write_size)
 # ============================================================
 
-## each_record with write_size for batched writes
-# write_size controls how many records are processed before flushing writes
+## each_record with no pipeline param uses serial execution (safe-by-default)
+# Default behavior is no pipelining - each record processed individually
 records = []
-Customer.instances.each_record(write_size: 2) { |r| records << r if r.custid.start_with?(@test_prefix) }
+Customer.instances.each_record { |r| records << r if r.custid.start_with?(@test_prefix) }
 records.size
 #=> 5
 
-## each_record with write_size: nil for serial execution
+## each_record with pipeline: for batched writes
+# pipeline controls how many records are processed before flushing writes
+records = []
+Customer.instances.each_record(pipeline: 2) { |r| records << r if r.custid.start_with?(@test_prefix) }
+records.size
+#=> 5
+
+## each_record with pipeline: nil for explicit serial execution
 # Serial execution processes one at a time without batching
 records = []
-Customer.instances.each_record(write_size: nil) { |r| records << r if r.custid.start_with?(@test_prefix) }
+Customer.instances.each_record(pipeline: nil) { |r| records << r if r.custid.start_with?(@test_prefix) }
 records.size
 #=> 5
 
-## each_record with both batch_size and write_size
+## each_record with both batch_size and pipeline
 records = []
-Customer.instances.each_record(batch_size: 3, write_size: 2) { |r| records << r if r.custid.start_with?(@test_prefix) }
+Customer.instances.each_record(batch_size: 3, pipeline: 2) { |r| records << r if r.custid.start_with?(@test_prefix) }
 records.size
 #=> 5
 
@@ -244,24 +251,94 @@ records.size
 # Argument validation
 # ============================================================
 
-## each_record raises ArgumentError when write_size exceeds batch_size
+## each_record raises ArgumentError when batch_size is nil
+begin
+  Customer.instances.each_record(batch_size: nil) { |r| }
+  raised = false
+rescue ArgumentError => e
+  raised = e.message.include?('batch_size') && e.message.include?('positive')
+end
+raised
+#=> true
+
+## each_record raises ArgumentError when batch_size is 0
+begin
+  Customer.instances.each_record(batch_size: 0) { |r| }
+  raised = false
+rescue ArgumentError => e
+  raised = e.message.include?('batch_size') && e.message.include?('positive')
+end
+raised
+#=> true
+
+## each_record raises ArgumentError when batch_size is negative
+begin
+  Customer.instances.each_record(batch_size: -5) { |r| }
+  raised = false
+rescue ArgumentError => e
+  raised = e.message.include?('batch_size') && e.message.include?('positive')
+end
+raised
+#=> true
+
+## each_record raises ArgumentError when batch_size is non-integer
+begin
+  Customer.instances.each_record(batch_size: "100") { |r| }
+  raised = false
+rescue ArgumentError => e
+  raised = e.message.include?('batch_size') && e.message.include?('positive')
+end
+raised
+#=> true
+
+## each_record raises ArgumentError when pipeline exceeds batch_size
 begin
-  Customer.instances.each_record(batch_size: 10, write_size: 20) { |r| }
+  Customer.instances.each_record(batch_size: 10, pipeline: 20) { |r| }
   raised = false
 rescue ArgumentError => e
-  raised = e.message.include?('write_size') && e.message.include?('batch_size')
+  raised = e.message.include?('pipeline') && e.message.include?('batch_size')
 end
 raised
 #=> true
 
 ## each_record error message includes both values
 begin
-  Customer.instances.each_record(batch_size: 10, write_size: 20) { |r| }
+  Customer.instances.each_record(batch_size: 10, pipeline: 20) { |r| }
   ''
 rescue ArgumentError => e
   e.message
 end
-#=~ /write_size.*20.*batch_size.*10|batch_size.*10.*write_size.*20/
+#=~ /pipeline.*20.*batch_size.*10|batch_size.*10.*pipeline.*20/
+
+## each_record raises ArgumentError when pipeline is 0
+begin
+  Customer.instances.each_record(pipeline: 0) { |r| }
+  raised = false
+rescue ArgumentError => e
+  raised = e.message.include?('pipeline') && e.message.include?('positive')
+end
+raised
+#=> true
+
+## each_record raises ArgumentError when pipeline is negative
+begin
+  Customer.instances.each_record(pipeline: -1) { |r| }
+  raised = false
+rescue ArgumentError => e
+  raised = e.message.include?('pipeline') && e.message.include?('positive')
+end
+raised
+#=> true
+
+## each_record raises ArgumentError when pipeline is non-integer
+begin
+  Customer.instances.each_record(pipeline: "10") { |r| }
+  raised = false
+rescue ArgumentError => e
+  raised = e.message.include?('pipeline') && e.message.include?('positive')
+end
+raised
+#=> true
 
 # ============================================================
 # Non-reference DataType error handling

data/try/unit/data_types/sorted_set_try.rb

@@ -69,4 +69,48 @@ require_relative '../../support/helpers/test_helpers'
 @a.metrics.members
 #=> ['metric2']
 
+## Familia::SortedSet#update bulk-adds a Hash of member => score in one ZADD, returns new count
+@u = Bone.new 'zset_bulk_update'
+@u.metrics.update(alpha: 1, gamma: 3, beta: 2)
+#=> 3
+
+## Familia::SortedSet#update orders members by their given scores
+@u.metrics.members
+#=> ['alpha', 'beta', 'gamma']
+
+## Familia::SortedSet#merge! is an alias and updates existing scores (0 new members)
+@u.metrics.merge!(alpha: 10)
+#=> 0
+
+## Familia::SortedSet#merge! re-scored member moves position
+@u.metrics.members
+#=> ['beta', 'gamma', 'alpha']
+
+## Familia::SortedSet#update with empty Hash is a no-op returning 0
+@u.metrics.update({})
+#=> 0
+
+## Familia::SortedSet#update raises ArgumentError on non-Hash argument
+begin
+  @u.metrics.update([:not, :a, :hash])
+  :no_error
+rescue ArgumentError => e
+  e.message
+end
+#=> 'Argument to bulk add must be a hash'
+
+## Familia::SortedSet#update raises a clear ArgumentError on a non-Numeric score (not auto-defaulted like #add)
+begin
+  @u.metrics.update('alice' => 1000, 'bob' => nil)
+  :no_error
+rescue ArgumentError => e
+  e.message
+end
+#=> 'SortedSet#update score for "bob" must be Numeric, got NilClass'
+
+## Familia::SortedSet#update rejects a bad score before issuing the ZADD (alice not added)
+@u.metrics.member?('alice')
+#=> false
+
+@u.metrics.delete!
 @a.metrics.delete!

data/try/unit/horreum/destroy_related_fields_cleanup_try.rb

@@ -314,19 +314,19 @@ class TestModelWithInit < Familia::Horreum
 end
 
 # Create object - init should set region based on user_id
-init_obj = TestModelWithInit.new(user_id: "us-west-123")
+init_obj = TestModelWithInit.new(user_id: "ca-west-123")
 init_obj.save
 init_obj.activities << "login"
 init_obj.activities << "purchase"
 
 # Verify init worked and region is set
-region_set_correctly = init_obj.region == "us"
+region_set_correctly = init_obj.region == "ca"
 
 # Verify related field key includes region (would be nil without fix)
 activities_key = init_obj.activities.dbkey
 
 # Destroy using class method - temp instance init should execute with identifier
-TestModelWithInit.destroy!("us-west-123")
+TestModelWithInit.destroy!("ca-west-123")
 
 # Verify all keys are cleaned up (including activities with correct key)
 activities_cleaned = TestModelWithInit.dbclient.exists(activities_key).zero?

data/try/unit/utils/future_aware_helpers_try.rb

@@ -0,0 +1,128 @@
+# try/unit/utils/future_aware_helpers_try.rb
+#
+# frozen_string_literal: true
+
+# Direct unit tests for Familia.success? and Familia.positive? —
+# the Future-aware utility methods added to Familia::Utils.
+#
+# These methods handle two cases:
+#   1. Concrete Integer return values from Redis commands
+#   2. Redis::Future objects inside pipelines/transactions (passthrough)
+#
+# Call sites include fast writers, DEL operations, EXISTS checks,
+# LINSERT results, and TTL comparisons.
+
+require_relative '../../support/helpers/test_helpers'
+
+Familia.debug = false
+
+@test_key = 'familia:test:future_aware_helpers'
+
+##
+## Familia.success? — concrete values
+##
+
+## success? returns true for positive integer (new key created)
+Familia.success?(1)
+#=> true
+
+## success? returns true for zero (existing key updated)
+Familia.success?(0)
+#=> true
+
+## success? returns false for negative integer
+Familia.success?(-1)
+#=> false
+
+## success? returns false for large negative
+Familia.success?(-100)
+#=> false
+
+##
+## Familia.positive? — concrete values
+##
+
+## positive? returns true for positive integer
+Familia.positive?(1)
+#=> true
+
+## positive? returns true for large positive integer
+Familia.positive?(5)
+#=> true
+
+## positive? returns false for zero (nothing happened)
+Familia.positive?(0)
+#=> false
+
+## positive? returns false for negative integer
+Familia.positive?(-1)
+#=> false
+
+##
+## Redis::Future passthrough — inside a pipeline
+##
+
+## success? returns the Future unchanged inside a pipeline
+@success_future = nil
+Familia.dbclient.pipelined do |pipe|
+  fut = pipe.hset(@test_key, 'field', 'val')
+  @success_future = Familia.success?(fut)
+end
+@success_future.is_a?(Redis::Future)
+#=> true
+
+## success? Future resolves to a truthy result after pipeline completes
+@success_future.value.zero? || @success_future.value.positive?
+#=> true
+
+## positive? returns the Future unchanged inside a pipeline
+@positive_future = nil
+Familia.dbclient.pipelined do |pipe|
+  fut = pipe.exists(@test_key)
+  @positive_future = Familia.positive?(fut)
+end
+@positive_future.is_a?(Redis::Future)
+#=> true
+
+## positive? Future resolves to truthy for an existing key after pipeline
+@positive_future.value.positive?
+#=> true
+
+##
+## Edge cases — nil and non-numeric raise NoMethodError
+##
+
+## success? raises for nil input (no guard — explicit contract)
+begin
+  Familia.success?(nil)
+rescue NoMethodError => e
+  e.class
+end
+#=> NoMethodError
+
+## positive? raises for nil input
+begin
+  Familia.positive?(nil)
+rescue NoMethodError => e
+  e.class
+end
+#=> NoMethodError
+
+## success? raises for string input
+begin
+  Familia.success?('ok')
+rescue NoMethodError => e
+  e.class
+end
+#=> NoMethodError
+
+## positive? raises for string input
+begin
+  Familia.positive?('ok')
+rescue NoMethodError => e
+  e.class
+end
+#=> NoMethodError
+
+# Teardown
+Familia.dbclient.del(@test_key)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: familia
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.9.1
 platform: ruby
 authors:
 - Delano Mandelbaum
@@ -177,9 +177,9 @@ files:
 - changelog.d/README.md
 - changelog.d/scriv.ini
 - docs/1106-participates_in-bidirectional-solution.md
-- docs/archive/.gitignore
 - docs/conf.py
 - docs/guides/.gitignore
+- docs/guides/datatype-collections.md
 - docs/guides/encryption.md
 - docs/guides/feature-encrypted-fields.md
 - docs/guides/feature-expiration.md
@@ -366,6 +366,7 @@ files:
 - try/audit/repair_score_correctness_try.rb
 - try/audit/scan_keys_try.rb
 - try/edge_cases/empty_identifiers_try.rb
+- try/edge_cases/fast_writer_pipeline_support_try.rb
 - try/edge_cases/fast_writer_transaction_guard_try.rb
 - try/edge_cases/find_by_dbkey_race_condition_try.rb
 - try/edge_cases/hash_symbolization_try.rb
@@ -656,6 +657,7 @@ files:
 - try/unit/refinements/time_literals_numeric_methods_try.rb
 - try/unit/refinements/time_literals_string_methods_try.rb
 - try/unit/thread_safety_monitor_try.rb
+- try/unit/utils/future_aware_helpers_try.rb
 - try/valkey.conf
 homepage: https://github.com/delano/familia
 licenses:

data/docs/archive/.gitignore

@@ -1,2 +0,0 @@
-# Even all uppercase markdown docs get the blues
-!*.md