Improves performance on hot parse and render paths

Splits the render loop in block_body.rb on the loop-invariant check_write
condition. The common case (no resource limits) now pays zero branch cost
per node.

Rewrites truncatewords in standardfilters.rb to scan word positions into a
flat int array and builds the result string only when truncation is confirmed.
No string allocation in the common no-truncation case beyond the array itself.

Simplifies rest_blank? in cursor.rb: replaces manual save/skip/restore of
StringScanner position with !@ss.exist?(/\S/). exist? does not advance
position; returns nil when no non-whitespace remains; handles EOS correctly.

Removes the nl newline counter from skip_ws in cursor.rb -- all callers
discarded the return value. NL now handled in the same when-branch as the
other whitespace bytes.

Author: cpakman

lib/liquid/block_body.rb

@@ -235,20 +235,31 @@ def render_to_output_buffer(context, output)
       resource_limits = context.resource_limits
       resource_limits.increment_render_score(@nodelist.length)
 
-      # Check if we need per-node write score tracking
-      check_write = resource_limits.render_length_limit || resource_limits.last_capture_length
-
-      idx = 0
-      while (node = @nodelist[idx])
-        if node.instance_of?(String)
-          output << node
-        else
-          render_node(context, output, node)
-          break if context.interrupt?
+      # Hot render loop — split on check_write so the common case (no resource
+      # limits) pays zero branch cost per node.
+      if resource_limits.render_length_limit || resource_limits.last_capture_length
+        idx = 0
+        while (node = @nodelist[idx])
+          if node.instance_of?(String)
+            output << node
+          else
+            render_node(context, output, node)
+            break if context.interrupt?
+          end
+          idx += 1
+          resource_limits.increment_write_score(output)
+        end
+      else
+        idx = 0
+        while (node = @nodelist[idx])
+          if node.instance_of?(String)
+            output << node
+          else
+            render_node(context, output, node)
+            break if context.interrupt?
+          end
+          idx += 1
         end
-        idx += 1
-
-        resource_limits.increment_write_score(output) if check_write
       end
 
       output

lib/liquid/cursor.rb

@@ -63,27 +63,20 @@ def slice(start, len)
     end
 
     # ── Whitespace ──────────────────────────────────────────────────
-    # Skip spaces/tabs/newlines/cr, return count of newlines skipped
+    # Skip spaces/tabs/newlines/cr
     def skip_ws
-      nl = 0
       while (b = @ss.peek_byte)
         case b
-        when SPACE, TAB, CR, FF then @ss.scan_byte
-        when NL then @ss.scan_byte
-                     nl += 1
+        when SPACE, TAB, CR, FF, NL then @ss.scan_byte
         else break
         end
       end
-      nl
     end
 
-    # Check if remaining bytes are all whitespace
+    # Check if remaining bytes are all whitespace (or EOS).
+    # exist?(/\S/) returns nil when no non-whitespace remains, without advancing position.
     def rest_blank?
-      saved = @ss.pos
-      @ss.skip(/\s*/)
-      result = @ss.eos?
-      @ss.pos = saved
-      result
+      !@ss.exist?(/\S/)
     end
 
     # Regex for identifier: [a-zA-Z_][\w-]*\??

lib/liquid/standardfilters.rb

@@ -277,52 +277,52 @@ def truncatewords(input, words = 15, truncate_string = "...")
 
       return input if words + 1 > MAX_I32
 
-      # Build result incrementally — avoids split() array + string allocations
+      # Scan words tracking byte positions; build the normalized (single-space)
+      # result string only when truncation is actually needed.
       len = input.bytesize
       pos = 0
       word_count = 0
-      result = nil
+      # Flat array of [start, end, start, end, ...] for up to `words` words.
+      # Avoids allocating a result string in the common no-truncation case.
+      positions = []
 
       # Skip leading whitespace
       while pos < len
-        b = input.getbyte(pos)
-        break unless ByteTables::WHITESPACE[b]
+        break unless ByteTables::WHITESPACE[input.getbyte(pos)]
         pos += 1
       end
 
       while pos < len
         word_start = pos
         word_count += 1
 
-        # Skip non-whitespace chars (word body)
+        # Scan to end of word
         while pos < len
-          b = input.getbyte(pos)
-          break if ByteTables::WHITESPACE[b]
+          break if ByteTables::WHITESPACE[input.getbyte(pos)]
           pos += 1
         end
 
-        if word_count > words
-          # Truncate — result already has the first N words
-          truncate_string = Utils.to_s(truncate_string)
-          return result.concat(truncate_string)
-        end
-
-        # Append word to result (only allocate result when we know truncation is possible)
-        if result
-          result << " " << input.byteslice(word_start, pos - word_start)
+        if word_count <= words
+          positions.push(word_start, pos) # [start, end, start, end, ...]
         else
-          result = +input.byteslice(word_start, pos - word_start)
+          # Truncation confirmed — build normalized result from stored positions
+          result = +input.byteslice(positions[0], positions[1] - positions[0])
+          i = 2
+          while i < positions.length
+            result << " " << input.byteslice(positions[i], positions[i + 1] - positions[i])
+            i += 2
+          end
+          return result << Utils.to_s(truncate_string)
         end
 
         # Skip whitespace between words
         while pos < len
-          b = input.getbyte(pos)
-          break unless ByteTables::WHITESPACE[b]
+          break unless ByteTables::WHITESPACE[input.getbyte(pos)]
           pos += 1
         end
       end
 
-      input
+      input # word_count <= words — no truncation needed, return input unchanged
     end
 
     # @liquid_public_docs