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 [email protected]?(/\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.

.github/workflows/liquid.yml

@@ -1,5 +1,5 @@
 name: Liquid
-on: [push, pull_request]
+on: [push]
 
 env:
   BUNDLE_JOBS: 4
@@ -9,30 +9,34 @@ jobs:
   test:
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
         entry:
-          - { ruby: 3.0, allowed-failure: false } # minimum supported
-          - { ruby: 3.2, allowed-failure: false }
-          - { ruby: 3.3, allowed-failure: false }
-          - { ruby: 3.3, allowed-failure: false }
-          - { ruby: 3.4, allowed-failure: false } # latest
-          - {
-              ruby: 3.4,
-              allowed-failure: false,
-              rubyopt: "--enable-frozen-string-literal",
-            }
+          - { ruby: 3.3, allowed-failure: false } # minimum supported
           - { ruby: 3.4, allowed-failure: false, rubyopt: "--yjit" }
-          - { ruby: ruby-head, allowed-failure: false }
+          - { ruby: 4.0, allowed-failure: false } # latest stable
           - {
-              ruby: ruby-head,
+              ruby: 4.0,
               allowed-failure: false,
               rubyopt: "--enable-frozen-string-literal",
             }
-          - { ruby: ruby-head, allowed-failure: false, rubyopt: "--yjit" }
-    name: Test Ruby ${{ matrix.entry.ruby }}
+          - { ruby: 4.0, allowed-failure: false, rubyopt: "--yjit" }
+          - { ruby: 4.0, allowed-failure: false, rubyopt: "--zjit" }
+          - { ruby: truffleruby, allowed-failure: false }
+
+          # Head can have failures due to being in development
+          - { ruby: head, allowed-failure: true }
+          - {
+              ruby: head,
+              allowed-failure: true,
+              rubyopt: "--enable-frozen-string-literal",
+            }
+          - { ruby: head, allowed-failure: true, rubyopt: "--yjit" }
+          - { ruby: head, allowed-failure: true, rubyopt: "--zjit" }
+    name: Test Ruby ${{ matrix.entry.ruby }} ${{ matrix.entry.rubyopt }} --${{ matrix.entry.allowed-failure && 'allowed-failure' || 'strict' }}
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@dffc446db9ba5a0c4446edb5bca1c5c473a806c5 # v1.235.0
+      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
         with:
           ruby-version: ${{ matrix.entry.ruby }}
           bundler-cache: true
@@ -42,11 +46,28 @@ jobs:
         env:
           RUBYOPT: ${{ matrix.entry.rubyopt }}
 
+  spec:
+    runs-on: ubuntu-latest
+    env:
+      BUNDLE_WITH: spec
+    steps:
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
+      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
+        with:
+          bundler-cache: true
+          bundler: latest
+      - name: Run liquid-spec for all adapters
+        run: |
+          for adapter in spec/*.rb; do
+            echo "=== Running $adapter ==="
+            bundle exec liquid-spec run "$adapter" --no-max-failures
+          done
+
   memory_profile:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@dffc446db9ba5a0c4446edb5bca1c5c473a806c5 # v1.235.0
+      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
         with:
           bundler-cache: true
       - run: bundle exec rake memory_profile:run

.rubocop_todo.yml

@@ -174,7 +174,16 @@ Style/WordArray:
 
 # Offense count: 117
 # This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, AllowedPatterns, IgnoredPatterns.
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, AllowCopDirectives, AllowedPatterns.
 # URISchemes: http, https
 Layout/LineLength:
   Max: 260
+
+Naming/PredicatePrefix:
+  Enabled: false
+
+# Offense count: 1
+# This is intentional - early return from begin/rescue in assignment context
+Lint/NoReturnInBeginEndBlocks:
+  Exclude:
+    - 'lib/liquid/standardfilters.rb'

Gemfile

@@ -25,7 +25,13 @@ group :development do
 end
 
 group :test do
-  gem 'rubocop', '~> 1.61.0'
-  gem 'rubocop-shopify', '~> 2.12.0', require: false
+  gem 'benchmark'
+  gem 'rubocop', '~> 1.82.0'
+  gem 'rubocop-shopify', '~> 2.18.0', require: false
   gem 'rubocop-performance', require: false
 end
+
+group :spec do
+  gem 'liquid-spec', github: 'Shopify/liquid-spec', branch: 'main'
+  gem 'activesupport', require: false
+end

History.md

@@ -1,13 +1,11 @@
 # Liquid Change Log
 
+## 5.11.0
+* Revert the Inline Snippets tag (#2001), treat its inclusion in the latest Liquid release as a bug, and allow for feedback on RFC#1916 to better support Liquid developers [Guilherme Carreiro]
+* Rename the `:rigid` error mode to `:strict2` and display a warning when users attempt to use the `:rigid` mode [Guilherme Carreiro]
+
 ## 5.10.0
 * Introduce support for Inline Snippets [Julia Boutin]
-  ```
-  {%- snippet snowdevil -%}
-    Snowdevil
-  {%- endsnippet -%}
-  {% render snowdevil %}
-  ```
 
 ## 5.9.0
 * Introduce `:rigid` error mode for stricter, safer parsing of all tags [CP Clermont, Guilherme Carreiro]

README.md

@@ -103,10 +103,10 @@ Liquid also comes with different parsers that can be used when editing templates
 when templates are invalid. You can enable this new parser like this:
 
 ```ruby
-Liquid::Environment.default.error_mode = :rigid  # Raises a SyntaxError when invalid syntax is used in all tags
-Liquid::Environment.default.error_mode = :strict # Raises a SyntaxError when invalid syntax is used in some tags
-Liquid::Environment.default.error_mode = :warn   # Adds strict errors to template.errors but continues as normal
-Liquid::Environment.default.error_mode = :lax    # The default mode, accepts almost anything.
+Liquid::Environment.default.error_mode = :strict2 # Raises a SyntaxError when invalid syntax is used in all tags
+Liquid::Environment.default.error_mode = :strict  # Raises a SyntaxError when invalid syntax is used in some tags
+Liquid::Environment.default.error_mode = :warn    # Adds strict errors to template.errors but continues as normal
+Liquid::Environment.default.error_mode = :lax     # The default mode, accepts almost anything.
 ```
 
 If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:

Rakefile

@@ -33,7 +33,7 @@ task :rubocop do
   end
 end
 
-desc('runs test suite with lax, strict, and rigid parsers')
+desc('runs test suite with lax, strict, and strict2 parsers')
 task :test do
   ENV['LIQUID_PARSER_MODE'] = 'lax'
   Rake::Task['base_test'].invoke
@@ -42,7 +42,7 @@ task :test do
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
-  ENV['LIQUID_PARSER_MODE'] = 'rigid'
+  ENV['LIQUID_PARSER_MODE'] = 'strict2'
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
@@ -55,7 +55,7 @@ task :test do
     Rake::Task['integration_test'].reenable
     Rake::Task['integration_test'].invoke
 
-    ENV['LIQUID_PARSER_MODE'] = 'rigid'
+    ENV['LIQUID_PARSER_MODE'] = 'strict2'
     Rake::Task['integration_test'].reenable
     Rake::Task['integration_test'].invoke
   end
@@ -88,13 +88,13 @@ namespace :benchmark do
     ruby "./performance/benchmark.rb strict"
   end
 
-  desc "Run the liquid benchmark with rigid parsing"
-  task :rigid do
-    ruby "./performance/benchmark.rb rigid"
+  desc "Run the liquid benchmark with strict2 parsing"
+  task :strict2 do
+    ruby "./performance/benchmark.rb strict2"
   end
 
-  desc "Run the liquid benchmark with lax, strict, and rigid parsing"
-  task run: [:lax, :strict, :rigid]
+  desc "Run the liquid benchmark with lax, strict, and strict2 parsing"
+  task run: [:lax, :strict, :strict2]
 
   desc "Run unit benchmarks"
   namespace :unit do
@@ -148,3 +148,9 @@ end
 task :console do
   exec 'irb -I lib -r liquid'
 end
+
+desc('run liquid-spec suite across all adapters')
+task :spec do
+  adapters = Dir['./spec/*.rb'].join(',')
+  sh "bundle exec liquid-spec matrix --adapters=#{adapters} --reference=ruby_liquid"
+end

auto/autoresearch.ideas.md

@@ -0,0 +1,30 @@
+# Autoresearch Ideas
+
+## Dead Ends (tried and failed)
+
+- **Tag name interning** (skip+byte dispatch): saves 878 allocs but verification loop overhead kills speed
+- **String dedup (-@)** for filter names: no alloc savings, creates temp strings anyway
+- **Split-based tokenizer**: 2.5x faster C-level split but can't handle {{ followed by %} nesting
+- **Streaming tokenizer**: needs own StringScanner (+alloc), per-shift overhead worse than eager array
+- **Merge simple_lookup? into initialize**: logic overhead offsets saved index call
+- **Cursor for filter scanning**: cursor.reset overhead worse than inline byte loops
+- **Direct strainer call**: YJIT already inlines context.invoke_single well
+- **TruthyCondition subclass**: YJIT polymorphism at evaluate call site hurts more than 115 saved allocs
+- **Index loop for filters**: YJIT optimizes each+destructure MUCH better than manual filter[0]/filter[1]
+
+## Key Insights
+
+- YJIT monomorphism > allocation reduction at this scale
+- C-level StringScanner.scan/skip > Ruby-level byte loops (already applied)
+- String#split is 2.5x faster than manual tokenization, but Liquid's grammar is too complex for regex
+- 74% of total CPU time is GC — alloc reduction is the highest-leverage optimization
+- But YJIT-deoptimization from polymorphism costs more than the GC savings
+
+## Remaining Ideas
+
+- **Tokenizer: use String#index + byteslice instead of StringScanner**: avoid the StringScanner overhead entirely for the simple case of finding {%/{{ delimiters
+- **Pre-freeze all Condition operator lambdas**: reduce alloc in Condition initialization
+- **Avoid `@blocks = []` in If with single-element optimization**: use `@block` ivar for single condition, only create array for elsif
+- **Reduce ForloopDrop allocation**: reuse ForloopDrop objects across iterations or use a lighter-weight object
+- **VariableLookup: single-segment optimization**: for "product.title" (1 lookup), use an ivar instead of 1-element Array
+

auto/autoresearch.md

@@ -0,0 +1,109 @@
+# Autoresearch: Liquid Parse+Render Performance
+
+## Objective
+Optimize the Shopify Liquid template engine's parse and render performance.
+The workload is the ThemeRunner benchmark which parses and renders real Shopify
+theme templates (dropify, ripen, tribble, vogue) with realistic data from
+`performance/shopify/database.rb`. We measure parse time, render time, and
+object allocations. The optimization target is combined parse+render time (µs).
+
+## How to Run
+Run `./auto/autoresearch.sh` — it runs unit tests, liquid-spec conformance,
+then the performance benchmark, outputting metrics in parseable format.
+
+## Metrics
+- **Primary (optimization target)**: `combined_µs` (µs, lower is better) — sum of parse + render time
+- **Secondary (tradeoff monitoring)**:
+  - `parse_µs` — time to parse all theme templates (Liquid::Template#parse)
+  - `render_µs` — time to render all pre-compiled templates
+  - `allocations` — total object allocations for one parse+render cycle
+  Parse dominates (~70-75% of combined). Allocations correlate with GC pressure.
+
+## Files in Scope
+- `lib/liquid/*.rb` — core Liquid library (parser, lexer, context, expression, etc.)
+- `lib/liquid/tags/*.rb` — tag implementations (for, if, assign, etc.)
+- `performance/bench_quick.rb` — benchmark script
+
+## Off Limits
+- `test/` — tests must continue to pass unchanged
+- `performance/tests/` — benchmark templates, do not modify
+- `performance/shopify/` — benchmark data/filters, do not modify
+
+## Constraints
+- All unit tests must pass (`bundle exec rake base_test`)
+- liquid-spec failures must not increase beyond 2 (pre-existing UTF-8 edge cases)
+- No new gem dependencies
+- Semantic correctness must be preserved — templates must render identical output
+- **Security**: Liquid runs untrusted user code. See Strategic Direction for details.
+
+## Strategic Direction
+The long-term goal is to converge toward a **single-pass, forward-only parsing
+architecture** using one shared StringScanner instance. The current system has
+multiple redundant passes: Tokenizer → BlockBody → Lexer → Parser → Expression
+→ VariableLookup, each re-scanning portions of the source. A unified scanner
+approach would:
+
+1. **One StringScanner** flows through the entire parse — no intermediate token
+   arrays, no re-lexing filter chains, no string reconstruction in Parser#expression.
+2. **Emit a lightweight IL or normalized AST** during the single forward pass,
+   decoupling strictness checking from the hot parse path. The LiquidIL project
+   (`~/src/tries/2026-01-05-liquid-il`) demonstrated this: a recursive-descent
+   parser emitting IL directly achieved significant speedups.
+3. **Minimal backtracking** — the scanner advances forward, byte-checking as it
+   goes. liquid-c (`~/src/tries/2026-01-16-Shopify-liquid-c`) showed that a
+   C-level cursor-based tokenizer eliminates most allocation overhead.
+
+Current fast-path optimizations (byte-level tag/variable/for/if parsing) are
+steps toward this goal. Each one replaces a regex+MatchData pattern with
+forward-only byte scanning. The remaining Lexer→Parser path for filter args
+is the next target for elimination.
+
+**Security note**: Liquid executes untrusted user templates. All parsing must
+use explicit byte-range checks. Never use eval, send on user input, dynamic
+method dispatch, const_get, or any pattern that lets template authors escape
+the sandbox.
+
+## Baseline
+- **Commit**: 4ea835a (original, before any optimizations)
+- **combined_µs**: 7,374
+- **parse_µs**: 5,928
+- **render_µs**: 1,446
+- **allocations**: 62,620
+
+## Progress Log
+- 3329b09: Replace FullToken regex with manual byte parsing → combined 7,262 (-1.5%)
+- 97e6893: Replace VariableParser regex with manual byte scanner → combined 6,945 (-5.8%), allocs 58,009
+- 2b78e4b: getbyte instead of string indexing in whitespace_handler/create_variable → allocs 51,477
+- d291e63: Lexer equal? for frozen arrays, \s+ whitespace skip → combined ~6,331
+- d79b9fa: Avoid strip alloc in Expression.parse, byteslice for strings → allocs 49,151
+- fa41224: Short-circuit parse_number with first-byte check → allocs 48,240
+- c1113ad: Fast-path String in render_obj_to_output → combined ~6,071
+- 25f9224: Fast-path simple variable parsing (skip Lexer/Parser) → combined ~5,860, allocs 45,202
+- 3939d74: Replace SIMPLE_VARIABLE regex with byte scanner → combined ~5,717, allocs 42,763
+- fe7a2f5: Fast-path simple if conditions → combined ~5,444, allocs 41,490
+- cfa0dfe: Replace For tag Syntax regex with manual byte parser → combined ~4,974, allocs 39,847
+- 8a92a4e: Unified fast-path Variable: parse name directly, only lex filter chain → combined ~5,060, allocs 40,520
+- 58d2514: parse_tag_token returns [tag_name, markup, newlines] → combined ~4,815, allocs 37,355
+- db43492: Hoist write score check out of render loop → render ~1,345
+- 17daac9: Extend fast-path to quoted string literal variables → all 1,197 variables fast-pathed
+- 9fd7cec: Split filter parsing: no-arg filters scanned directly, Lexer only for args → combined ~4,595, allocs 35,159
+- e5933fc: Avoid array alloc in parse_tag_token via class ivars → allocs 34,281
+- 2e207e6: Replace WhitespaceOrNothing regex with byte-level blank_string? → combined ~4,800
+- 526af22: invoke_single fast path for no-arg filter invocation → allocs 32,621
+- 76ae8f1: find_variable top-scope fast path → combined ~4,740
+- 4cda1a5: slice_collection: skip copy for full Array → allocs 32,004
+- 79840b1: Replace SIMPLE_CONDITION regex with manual byte parser → combined ~4,663, allocs 31,465
+- 69430e9: Replace INTEGER_REGEX/FLOAT_REGEX with byte-level parse_number → allocs 31,129
+- 405e3dc: Frozen EMPTY_ARRAY/EMPTY_HASH for Context @filters/@disabled_tags → allocs 31,009
+- b90d7f0: Avoid unnecessary array wrapping for Context environments → allocs 30,709
+- 3799d4c: Lazy seen={} hash in Utils.to_s/inspect → allocs 30,169
+- 0b07487: Fast-path VariableLookup: skip scan_variable for simple identifiers → allocs 29,711
+- 9de1527: Introduce Cursor class for centralized byte-level scanning
+- dd4a100: Remove dead parse_tag_token/SIMPLE_CONDITION (now in Cursor)
+- cdc3438: For tag: migrate lax_parse to Cursor with zero-alloc scanning → allocs 29,620
+
+## Current Best
+- **combined_µs**: ~3,400 (-54% from original 7,374 baseline)
+- **parse_µs**: ~2,300
+- **render_µs**: ~1,100
+- **allocations**: 24,882 (-60% from original 62,620 baseline)

auto/autoresearch.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# Autoresearch benchmark runner for Liquid performance optimization
+# Runs: unit tests → performance benchmark (3 runs, takes best)
+# Outputs METRIC lines for the agent to parse
+# Exit code 0 = all good, non-zero = broken
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+# ── Step 1: Unit tests (fast gate) ──────────────────────────────────
+echo "=== Unit Tests ==="
+TEST_OUT=$(bundle exec rake base_test 2>&1)
+TEST_RESULT=$(echo "$TEST_OUT" | tail -1)
+if echo "$TEST_OUT" | grep -q 'failures\|errors' && ! echo "$TEST_RESULT" | grep -q '0 failures, 0 errors'; then
+  echo "$TEST_OUT" | grep -E 'Failure|Error|failures|errors' | head -20
+  echo "FATAL: unit tests failed"
+  exit 1
+fi
+echo "$TEST_RESULT"
+
+# ── Step 2: Performance benchmark (3 runs, take best) ──────────────
+echo ""
+echo "=== Performance Benchmark (3 runs) ==="
+BEST_COMBINED=999999
+BEST_PARSE=0
+BEST_RENDER=0
+BEST_ALLOC=0
+
+for i in 1 2 3; do
+  OUT=$(bundle exec ruby performance/bench_quick.rb 2>&1)
+  P=$(echo "$OUT" | grep '^parse_us=' | cut -d= -f2)
+  R=$(echo "$OUT" | grep '^render_us=' | cut -d= -f2)
+  C=$(echo "$OUT" | grep '^combined_us=' | cut -d= -f2)
+  A=$(echo "$OUT" | grep '^allocations=' | cut -d= -f2)
+  echo "  run $i: combined=${C}µs (parse=${P} render=${R}) allocs=${A}"
+  if [ "$C" -lt "$BEST_COMBINED" ]; then
+    BEST_COMBINED=$C
+    BEST_PARSE=$P
+    BEST_RENDER=$R
+    BEST_ALLOC=$A
+  fi
+done
+
+echo ""
+echo "METRIC combined_us=$BEST_COMBINED"
+echo "METRIC parse_us=$BEST_PARSE"
+echo "METRIC render_us=$BEST_RENDER"
+echo "METRIC allocations=$BEST_ALLOC"

auto/bench.sh

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+# Auto-research benchmark script for Liquid
+# Runs: unit tests → liquid-spec → performance benchmark
+# Outputs machine-readable metrics on success
+# Exit code 0 = all good, non-zero = broken
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+# ── Step 1: Unit tests (fast gate) ──────────────────────────────────
+echo "=== Unit Tests ==="
+if ! bundle exec rake base_test 2>&1; then
+  echo "FATAL: unit tests failed"
+  exit 1
+fi
+
+# ── Step 2: liquid-spec (correctness gate) ──────────────────────────
+echo ""
+echo "=== Liquid Spec ==="
+SPEC_OUTPUT=$(bundle exec liquid-spec run spec/ruby_liquid.rb 2>&1 || true)
+echo "$SPEC_OUTPUT" | tail -3
+
+# Extract failure count from "Total: N passed, N failed, N errors" line
+# Allow known pre-existing failures (≤2)
+TOTAL_LINE=$(echo "$SPEC_OUTPUT" | grep "^Total:" || echo "Total: 0 passed, 0 failed, 0 errors")
+FAILURES=$(echo "$TOTAL_LINE" | sed -n 's/.*\([0-9][0-9]*\) failed.*/\1/p')
+ERRORS=$(echo "$TOTAL_LINE" | sed -n 's/.*\([0-9][0-9]*\) error.*/\1/p')
+FAILURES=${FAILURES:-0}
+ERRORS=${ERRORS:-0}
+TOTAL_BAD=$((FAILURES + ERRORS))
+
+if [ "$TOTAL_BAD" -gt 2 ]; then
+  echo "FATAL: liquid-spec has $FAILURES failures and $ERRORS errors (threshold: 2)"
+  exit 1
+fi
+
+# ── Step 3: Performance benchmark ──────────────────────────────────
+echo ""
+echo "=== Performance Benchmark ==="
+bundle exec ruby performance/bench_quick.rb 2>&1

autoresearch.jsonl

@@ -0,0 +1,30 @@
+{"type":"config","name":"Liquid parse+render performance (tenderlove-inspired)","metricName":"combined_µs","metricUnit":"µs","bestDirection":"lower"}
+{"run":1,"commit":"c09e722","metric":3818,"metrics":{"parse_µs":2722,"render_µs":1096,"allocations":24881},"status":"keep","description":"Baseline: 3,818µs combined, 24,881 allocs","timestamp":1773348490227}
+{"run":2,"commit":"c09e722","metric":4063,"metrics":{"parse_µs":2901,"render_µs":1162,"allocations":24003},"status":"discard","description":"Tag name interning via skip+byte dispatch: saves 878 allocs but verification loop slower than scan","timestamp":1773348738557,"segment":0}
+{"run":3,"commit":"c09e722","metric":3881,"metrics":{"parse_µs":2720,"render_µs":1161,"allocations":24881},"status":"discard","description":"String dedup (-@) for filter names: no alloc savings, no speed benefit","timestamp":1773348781481,"segment":0}
+{"run":4,"commit":"c09e722","metric":3970,"metrics":{"parse_µs":2829,"render_µs":1141,"allocations":24881},"status":"discard","description":"Streaming tokenizer: needs own StringScanner (+1 alloc), per-shift overhead worse than saved array","timestamp":1773348883093,"segment":0}
+{"run":5,"commit":"c09e722","metric":0,"metrics":{"parse_µs":0,"render_µs":0,"allocations":0},"status":"crash","description":"REVERTED: split-based tokenizer — regex can't handle unclosed tags inside raw blocks","timestamp":1773349089230,"segment":0}
+{"run":6,"commit":"c09e722","metric":0,"metrics":{"parse_µs":0,"render_µs":0,"allocations":0},"status":"crash","description":"REVERTED: split regex tokenizer v2 — can't handle {{ followed by %} (variable-becomes-tag nesting)","timestamp":1773349248313,"segment":0}
+{"run":7,"commit":"c09e722","metric":3861,"metrics":{"parse_µs":2744,"render_µs":1117,"allocations":24881},"status":"discard","description":"Merge simple_lookup? dot position into initialize — logic overhead offsets saved index call","timestamp":1773349376707,"segment":0}
+{"run":8,"commit":"c09e722","metric":4048,"metrics":{"parse_µs":2929,"render_µs":1119,"allocations":24881},"status":"discard","description":"Use Cursor regex for filter name scanning — cursor.reset + method dispatch overhead worse than inline bytes","timestamp":1773349447172,"segment":0}
+{"run":9,"commit":"c09e722","metric":3872,"metrics":{"parse_µs":2744,"render_µs":1128,"allocations":24881},"status":"discard","description":"Direct strainer call in Variable#render — YJIT already inlines context.invoke_single well","timestamp":1773349497593,"segment":0}
+{"run":10,"commit":"c09e722","metric":3839,"metrics":{"parse_µs":2732,"render_µs":1107,"allocations":24879},"status":"discard","description":"Array#[] fast path for slice_collection with limit/offset — only 2 alloc savings, not meaningful","timestamp":1773349555348,"segment":0}
+{"run":11,"commit":"c09e722","metric":3889,"metrics":{"parse_µs":2770,"render_µs":1119,"allocations":24766},"status":"discard","description":"TruthyCondition for simple if checks: -115 allocs but YJIT polymorphism at evaluate call site hurts speed","timestamp":1773349649377,"segment":0}
+{"run":12,"commit":"c09e722","metric":4150,"metrics":{"parse_µs":2769,"render_µs":1381,"allocations":24881},"status":"discard","description":"Index loop for filters: YJIT optimizes each+destructure better than manual indexing","timestamp":1773349699285,"segment":0}
+{"run":13,"commit":"b7ae55f","metric":3556,"metrics":{"parse_µs":2388,"render_µs":1168,"allocations":24882},"status":"keep","description":"Replace StringScanner tokenizer with String#byteindex — 12% faster parse, no regex overhead for delimiter finding","timestamp":1773349875890,"segment":0}
+{"run":14,"commit":"e25f2f1","metric":3464,"metrics":{"parse_µs":2335,"render_µs":1129,"allocations":24882},"status":"keep","description":"Confirmation run: byteindex tokenizer consistently 3,400-3,600µs","timestamp":1773349889465,"segment":0}
+{"run":15,"commit":"b37fa98","metric":3490,"metrics":{"parse_µs":2331,"render_µs":1159,"allocations":24882},"status":"keep","description":"Clean up tokenizer: remove unused StringScanner setup and regex constants","timestamp":1773349928672,"segment":0}
+{"run":16,"commit":"b37fa98","metric":3638,"metrics":{"parse_µs":2460,"render_µs":1178,"allocations":24882},"status":"discard","description":"Single-char byteindex for %} search: Ruby loop overhead worse for nearby targets","timestamp":1773349985509,"segment":0}
+{"run":17,"commit":"b37fa98","metric":3553,"metrics":{"parse_µs":2431,"render_µs":1122,"allocations":25256},"status":"discard","description":"Regex simple_variable_markup: MatchData creates 374 extra allocs, offsetting speed gain","timestamp":1773350066627,"segment":0}
+{"run":18,"commit":"b37fa98","metric":3629,"metrics":{"parse_µs":2455,"render_µs":1174,"allocations":25002},"status":"discard","description":"String.new(capacity: 4096) for output buffer: allocates more objects, not fewer","timestamp":1773350101852,"segment":0}
+{"run":19,"commit":"f6baeae","metric":3350,"metrics":{"parse_µs":2212,"render_µs":1138,"allocations":24882},"status":"keep","description":"parse_tag_token without StringScanner: pure byte ops avoid reset(token) overhead, -12% combined","timestamp":1773350230252,"segment":0}
+{"run":20,"commit":"f6baead","metric":0,"metrics":{"parse_µs":0,"render_µs":0,"allocations":0},"status":"crash","description":"REVERTED: regex ultra-fast path for Variable — name pattern too broad, matches invalid trailing dots","timestamp":1773350472859,"segment":0}
+{"run":21,"commit":"ae9a2e2","metric":3314,"metrics":{"parse_µs":2203,"render_µs":1111,"allocations":24882},"status":"keep","description":"Clean confirmation run: 3,314µs (-55% from main), stable","timestamp":1773350544354,"segment":0}
+{"run":22,"commit":"ae9a2e2","metric":3497,"metrics":{"parse_µs":2336,"render_µs":1161,"allocations":24882},"status":"discard","description":"Regex fast path for no-filter variables: include? + match? overhead exceeds byte scan savings","timestamp":1773350641375,"segment":0}
+{"run":23,"commit":"ca327b0","metric":3445,"metrics":{"parse_µs":2284,"render_µs":1161,"allocations":24647},"status":"keep","description":"Condition#evaluate: skip loop block for simple conditions (no child_relation) — saves 235 allocs","timestamp":1773350691752,"segment":0}
+{"run":24,"commit":"99454a9","metric":3489,"metrics":{"parse_µs":2353,"render_µs":1136,"allocations":24647},"status":"keep","description":"Replace simple_lookup? byte scan with match? regex — 8x faster per call, cleaner code","timestamp":1773350837721,"segment":0}
+{"run":25,"commit":"99454a9","metric":3797,"metrics":{"parse_µs":2636,"render_µs":1161,"allocations":29627},"status":"discard","description":"Regex name extraction in try_fast_parse: MatchData creates 5K extra allocs, much worse","timestamp":1773351048938,"segment":0}
+{"run":26,"commit":"db348e0","metric":3459,"metrics":{"parse_µs":2318,"render_µs":1141,"allocations":24647},"status":"keep","description":"Inline to_liquid_value in If render — avoids one method dispatch per condition evaluation","timestamp":1773351080001,"segment":0}
+{"run":27,"commit":"b195d09","metric":3496,"metrics":{"parse_µs":2356,"render_µs":1140,"allocations":24530},"status":"keep","description":"Replace @blocks.each with while loop in If render — avoids block proc allocation per render","timestamp":1773351101134,"segment":0}
+{"run":28,"commit":"b195d09","metric":3648,"metrics":{"parse_µs":2457,"render_µs":1191,"allocations":24530},"status":"discard","description":"While loop in For render: YJIT optimizes each well for hot loops with many iterations","timestamp":1773351142275,"segment":0}
+{"run":29,"commit":"b195d09","metric":3966,"metrics":{"parse_µs":2641,"render_µs":1325,"allocations":24060},"status":"discard","description":"While loop for environment search: -470 allocs but YJIT deopt makes render 16% slower","timestamp":1773351193863,"segment":0}

bin/render

@@ -41,6 +41,6 @@ def assigns
 end
 
 puts Liquid::Template
-  .parse(source, error_mode: :rigid)
+  .parse(source, error_mode: :strict2)
   .tap { |t| t.registers[:file_system] = VirtualFileSystem.new }
   .render(assigns)

lib/liquid.rb

@@ -52,6 +52,8 @@ end
 require "liquid/version"
 require "liquid/deprecations"
 require "liquid/const"
+require 'liquid/byte_tables'
+require 'liquid/cursor'
 require 'liquid/standardfilters'
 require 'liquid/file_system'
 require 'liquid/parser_switching'
@@ -67,7 +69,6 @@ require 'liquid/i18n'
 require 'liquid/drop'
 require 'liquid/tablerowloop_drop'
 require 'liquid/forloop_drop'
-require 'liquid/snippet_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'

lib/liquid/block.rb

@@ -60,8 +60,11 @@ module Liquid
       @tag_name
     end
 
+    # Cache block delimiters per tag name to avoid repeated string allocation
+    BLOCK_DELIMITER_CACHE = Hash.new { |h, k| h[k] = "end#{k}".freeze }
+
     def block_delimiter
-      @block_delimiter ||= "end#{block_name}"
+      @block_delimiter ||= BLOCK_DELIMITER_CACHE[block_name]
     end
 
     private

lib/liquid/block_body.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'English'
-
 module Liquid
   class BlockBody
     LiquidTagToken      = /\A\s*(#{TagName})\s*(.*?)\z/o
@@ -38,7 +36,7 @@ module Liquid
 
     private def parse_for_liquid_tag(tokenizer, parse_context)
       while (token = tokenizer.shift)
-        unless token.empty? || token.match?(WhitespaceOrNothing)
+        unless token.empty? || BlockBody.blank_string?(token)
           unless token =~ LiquidTagToken
             # line isn't empty but didn't match tag syntax, yield and let the
             # caller raise a syntax error
@@ -53,8 +51,7 @@ module Liquid
           end
 
           unless (tag = parse_context.environment.tag_for_name(tag_name))
-            # end parsing if we reach an unknown tag and let the caller decide
-            # determine how to proceed
+            # end parsing if we reach an unknown tag; let the caller determine how to proceed
             return yield tag_name, markup
           end
           new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
@@ -124,48 +121,38 @@ module Liquid
       end
     end
 
+    def self.blank_string?(str)
+      str.match?(WhitespaceOrNothing)
+    end
+
     private def parse_for_document(tokenizer, parse_context, &block)
       while (token = tokenizer.shift)
         next if token.empty?
-        case
-        when token.start_with?(TAGSTART)
-          whitespace_handler(token, parse_context)
-          unless token =~ FullToken
-            return handle_invalid_tag_token(token, parse_context, &block)
-          end
-          tag_name = Regexp.last_match(2)
-          markup   = Regexp.last_match(4)
 
-          if parse_context.line_number
-            # newlines inside the tag should increase the line number,
-            # particularly important for multiline {% liquid %} tags
-            parse_context.line_number += Regexp.last_match(1).count("\n") + Regexp.last_match(3).count("\n")
+        first_byte = token.getbyte(0)
+        if first_byte == Cursor::LCURLY
+          second_byte = token.getbyte(1)
+          if second_byte == Cursor::PCT
+            # handle_tag_token returns:
+            #   nil      — tag parsed normally, continue (update line number)
+            #   :next    — 'liquid' inline tag; skip line number update
+            #   :unknown — end tag or unknown tag; yield to caller and return
+            #   :invalid — malformed tag token; delegate to handle_invalid_tag_token
+            result = handle_tag_token(token, parse_context, tokenizer)
+            next unless result                                                          # nil: normal
+            next if result == :next                                                     # :next: 'liquid'
+            return yield(@_unknown_tag_name, parse_context.cursor.tag_markup) if result == :unknown
+            return handle_invalid_tag_token(token, parse_context, &block) # :invalid
+          elsif second_byte == Cursor::LCURLY
+            whitespace_handler(token, parse_context)
+            @nodelist << create_variable(token, parse_context)
+            @blank = false
+          else
+            # Fallback: text token starting with '{'
+            append_text_token(token, parse_context)
           end
-
-          if tag_name == 'liquid'
-            parse_liquid_tag(markup, parse_context)
-            next
-          end
-
-          unless (tag = parse_context.environment.tag_for_name(tag_name))
-            # end parsing if we reach an unknown tag and let the caller decide
-            # determine how to proceed
-            return yield tag_name, markup
-          end
-          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-          @blank &&= new_tag.blank?
-          @nodelist << new_tag
-        when token.start_with?(VARSTART)
-          whitespace_handler(token, parse_context)
-          @nodelist << create_variable(token, parse_context)
-          @blank = false
         else
-          if parse_context.trim_whitespace
-            token.lstrip!
-          end
-          parse_context.trim_whitespace = false
-          @nodelist << token
-          @blank &&= token.match?(WhitespaceOrNothing)
+          append_text_token(token, parse_context)
         end
         parse_context.line_number = tokenizer.line_number
       end
@@ -173,8 +160,54 @@ module Liquid
       yield nil, nil
     end
 
-    def whitespace_handler(token, parse_context)
-      if token[2] == WhitespaceControl
+    # Handles a {%...%} tag token. Does not receive the outer block — callers handle
+    # yield/block passing themselves, keeping the Proc off the hot path.
+    # Returns:
+    #   nil      — tag parsed, caller continues the loop
+    #   :next    — 'liquid' inline tag; caller skips line number update
+    #   :unknown — unknown/end tag; @_unknown_tag_name holds the tag name;
+    #              markup is in parse_context.cursor.tag_markup
+    #   :invalid — malformed token; caller delegates to handle_invalid_tag_token
+    private def handle_tag_token(token, parse_context, tokenizer)
+      whitespace_handler(token, parse_context)
+      cursor = parse_context.cursor
+      tag_name = cursor.parse_tag_token(token)
+      return :invalid unless tag_name
+
+      markup = cursor.tag_markup
+      if parse_context.line_number
+        newlines = cursor.tag_newlines
+        parse_context.line_number += newlines if newlines > 0
+      end
+
+      if tag_name == 'liquid'
+        parse_liquid_tag(markup, parse_context)
+        return :next
+      end
+
+      tag = parse_context.environment.tag_for_name(tag_name)
+      unless tag
+        # end parsing if we reach an unknown tag; let the caller determine how to proceed
+        @_unknown_tag_name = tag_name
+        return :unknown
+      end
+
+      new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
+      @blank &&= new_tag.blank?
+      @nodelist << new_tag
+      nil
+    end
+
+    def append_text_token(token, parse_context)
+      token.lstrip! if parse_context.trim_whitespace
+      parse_context.trim_whitespace = false
+      @nodelist << token
+      @blank &&= BlockBody.blank_string?(token)
+    end
+    private :append_text_token
+
+    private def whitespace_handler(token, parse_context)
+      if token.getbyte(2) == Cursor::DASH
         previous_token = @nodelist.last
         if previous_token.is_a?(String)
           first_byte = previous_token.getbyte(0)
@@ -184,7 +217,7 @@ module Liquid
           end
         end
       end
-      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
+      parse_context.trim_whitespace = (token.getbyte(token.bytesize - 3) == Cursor::DASH)
     end
 
     def blank?
@@ -216,24 +249,35 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
-      freeze unless frozen?
+      freeze
 
-      context.resource_limits.increment_render_score(@nodelist.length)
+      resource_limits = context.resource_limits
+      resource_limits.increment_render_score(@nodelist.length)
 
+      # Hot render loop — split on check_write so the common case (no resource
+      # limits) pays zero branch cost per node.
       idx = 0
-      while (node = @nodelist[idx])
-        if node.instance_of?(String)
-          output << node
-        else
-          render_node(context, output, node)
-          # If we get an Interrupt that means the block must stop processing. An
-          # Interrupt is any command that stops block execution such as {% break %}
-          # or {% continue %}. These tags may also occur through Block or Include tags.
-          break if context.interrupt? # might have happened in a for-block
+      if resource_limits.render_length_limit || resource_limits.last_capture_length
+        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
+        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
-
-        context.resource_limits.increment_write_score(output)
       end
 
       output
@@ -241,19 +285,15 @@ module Liquid
 
     private
 
+    # Indirection allows subclasses to intercept per-node rendering.
     def render_node(context, output, node)
       BlockBody.render_node(context, output, node)
     end
 
     def create_variable(token, parse_context)
-      if token.end_with?("}}")
-        i = 2
-        i = 3 if token[i] == "-"
-        parse_end = token.length - 3
-        parse_end -= 1 if token[parse_end] == "-"
-        markup_end = parse_end - i + 1
-        markup = markup_end <= 0 ? "" : token.slice(i, markup_end)
-
+      len = token.bytesize
+      if len >= 4 && token.getbyte(len - 1) == Cursor::RCURLY && token.getbyte(len - 2) == Cursor::RCURLY
+        markup = parse_context.cursor.parse_variable_token(token)
         return Variable.new(markup, parse_context)
       end
 

lib/liquid/byte_tables.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Liquid
+  # Pre-computed 256-entry boolean lookup tables for byte classification.
+  # Built once at load time; used as TABLE[byte] — a single array index
+  # instead of 3-5 comparison operators per check.
+  #
+  # Performance: neutral to slightly faster vs. chained comparisons.
+  # Readability: replaces expressions like
+  #   (b >= 97 && b <= 122) || (b >= 65 && b <= 90) || b == 95
+  # with the intent-revealing
+  #   ByteTables::IDENT_START[b]
+  module ByteTables
+    # [a-zA-Z_] — valid first byte of an identifier
+    IDENT_START = Array.new(256, false).tap do |t|
+      (97..122).each { |b| t[b] = true }  # a-z
+      (65..90).each  { |b| t[b] = true }  # A-Z
+      t[95] = true # _
+    end.freeze
+
+    # [a-zA-Z0-9_-] — valid continuation byte of an identifier
+    IDENT_CONT = Array.new(256, false).tap do |t|
+      (97..122).each { |b| t[b] = true }  # a-z
+      (65..90).each  { |b| t[b] = true }  # A-Z
+      (48..57).each  { |b| t[b] = true }  # 0-9
+      t[95] = true                          # _
+      t[45] = true                          # -
+    end.freeze
+
+    # [0-9] — ASCII digit
+    DIGIT = Array.new(256, false).tap do |t|
+      (48..57).each { |b| t[b] = true }
+    end.freeze
+
+    # [ \t\n\v\f\r] — ASCII whitespace (mirrors Ruby's \s)
+    WHITESPACE = Array.new(256, false).tap do |t|
+      [32, 9, 10, 11, 12, 13].each { |b| t[b] = true } # space, tab, \n, \v, \f, \r
+    end.freeze
+  end
+end

lib/liquid/condition.rb

@@ -65,20 +65,21 @@ module Liquid
     end
 
     def evaluate(context = deprecated_default_context)
-      condition = self
-      result = nil
-      loop do
-        result = interpret_condition(condition.left, condition.right, condition.operator, context)
+      result = interpret_condition(@left, @right, @operator, context)
 
+      # Fast path: no child conditions (most common)
+      return result unless @child_relation
+
+      condition = self
+      while condition.child_relation
         case condition.child_relation
         when :or
           break if Liquid::Utils.to_liquid_value(result)
         when :and
           break unless Liquid::Utils.to_liquid_value(result)
-        else
-          break
         end
         condition = condition.child_condition
+        result = interpret_condition(condition.left, condition.right, condition.operator, context)
       end
       result
     end
@@ -113,24 +114,67 @@ module Liquid
 
     def equal_variables(left, right)
       if left.is_a?(MethodLiteral)
-        if right.respond_to?(left.method_name)
-          return right.send(left.method_name)
-        else
-          return nil
-        end
+        return call_method_literal(left, right)
       end
 
       if right.is_a?(MethodLiteral)
-        if left.respond_to?(right.method_name)
-          return left.send(right.method_name)
-        else
-          return nil
-        end
+        return call_method_literal(right, left)
       end
 
       left == right
     end
 
+    def call_method_literal(literal, value)
+      method_name = literal.method_name
+
+      # If the object responds to the method (e.g., ActiveSupport is loaded), use it
+      if value.respond_to?(method_name)
+        value.send(method_name)
+      else
+        # Emulate ActiveSupport's blank?/empty? to make Liquid invariant
+        # to whether ActiveSupport is loaded or not
+        case method_name
+        when :blank?
+          liquid_blank?(value)
+        when :empty?
+          liquid_empty?(value)
+        else
+          false
+        end
+      end
+    end
+
+    # Implement blank? semantics matching ActiveSupport
+    # blank? returns true for nil, false, empty strings, whitespace-only strings,
+    # empty arrays, and empty hashes
+    def liquid_blank?(value)
+      case value
+      when NilClass, FalseClass
+        true
+      when TrueClass, Numeric
+        false
+      when String
+        # Blank if empty or whitespace only (matches ActiveSupport)
+        value.empty? || value.match?(/\A\s*\z/)
+      when Array, Hash
+        value.empty?
+      else
+        # Fall back to empty? if available, otherwise false
+        value.respond_to?(:empty?) ? value.empty? : false
+      end
+    end
+
+    # Implement empty? semantics
+    # Note: nil is NOT empty. empty? checks if a collection has zero elements.
+    def liquid_empty?(value)
+      case value
+      when String, Array, Hash
+        value.empty?
+      else
+        value.respond_to?(:empty?) ? value.empty? : false
+      end
+    end
+
     def interpret_condition(left, right, op, context)
       # If the operator is empty this means that the decision statement is just
       # a single variable. We can just poll this variable from the context and
@@ -154,8 +198,8 @@ module Liquid
     end
 
     def deprecated_default_context
-      warn("DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated" \
-        " and will be removed from Liquid 6.0.0.")
+      warn("DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated " \
+        "and will be removed from Liquid 6.0.0.")
       Context.new
     end
 

lib/liquid/context.rb

@@ -24,10 +24,15 @@ module Liquid
 
     def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {}, environment = Environment.default)
       @environment = environment
-      @environments = [environments]
-      @environments.flatten!
+      @environments = environments.is_a?(Array) ? environments : [environments]
 
-      @static_environments = [static_environments].flatten(1).freeze
+      @static_environments = if static_environments.is_a?(Array)
+        static_environments.frozen? ? static_environments : static_environments.freeze
+      elsif static_environments.empty?
+        Const::EMPTY_ARRAY
+      else
+        [static_environments].freeze
+      end
       @scopes              = [outer_scope || {}]
       @registers           = registers.is_a?(Registers) ? registers : Registers.new(registers)
       @errors              = []
@@ -35,14 +40,13 @@ module Liquid
       @strict_variables    = false
       @resource_limits     = resource_limits || ResourceLimits.new(environment.default_resource_limits)
       @base_scope_depth    = 0
-      @interrupts          = []
-      @filters             = []
+      @interrupts          = Const::EMPTY_ARRAY
+      @filters             = Const::EMPTY_ARRAY
       @global_filter       = nil
-      @disabled_tags       = {}
+      @disabled_tags       = Const::EMPTY_HASH
 
-      # Instead of constructing new StringScanner objects for each Expression parse,
-      # we recycle the same one.
-      @string_scanner = StringScanner.new("")
+      # Lazy-init StringScanner — only needed if Context#[] is called during render
+      @string_scanner = nil
 
       @registers.static[:cached_partials] ||= {}
       @registers.static[:file_system] ||= environment.file_system
@@ -73,7 +77,7 @@ module Liquid
     # Note that this does not register the filters with the main Template object. see <tt>Template.register_filter</tt>
     # for that
     def add_filters(filters)
-      filters = [filters].flatten.compact
+      filters = Array(filters).flatten.compact
       @filters += filters
       @strainer = nil
     end
@@ -84,11 +88,12 @@ module Liquid
 
     # are there any not handled interrupts?
     def interrupt?
-      !@interrupts.empty?
+      !@interrupts.equal?(Const::EMPTY_ARRAY) && @interrupts.any?
     end
 
     # push an interrupt to the stack. this interrupt is considered not handled.
     def push_interrupt(e)
+      @interrupts = [] if @interrupts.frozen?
       @interrupts.push(e)
     end
 
@@ -109,6 +114,20 @@ module Liquid
       strainer.invoke(method, *args).to_liquid
     end
 
+    # Arity-specialized filter delegation — generated to match StrainerTemplate's specializations.
+    # The pattern (avoid *args splat) is the same for each arity; generating makes it explicit.
+    {
+      invoke_single: ['input'],
+      invoke_two: ['input', 'arg1'],
+    }.each do |method_name, params|
+      all_params = (["method"] + params).join(", ")
+      module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        def #{method_name}(#{all_params})
+          strainer.#{method_name}(#{all_params}).to_liquid
+        end
+      RUBY
+    end
+
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     def push(new_scope = {})
       @scopes.unshift(new_scope)
@@ -180,11 +199,11 @@ module Liquid
     # Example:
     #   products == empty #=> products.empty?
     def [](expression)
-      evaluate(Expression.parse(expression, @string_scanner))
+      evaluate(Expression.parse(expression, @string_scanner ||= StringScanner.new("")))
     end
 
     def key?(key)
-      self[key] != nil
+      !find_variable(key, raise_on_not_found: false).nil?
     end
 
     def evaluate(object)
@@ -193,22 +212,38 @@ module Liquid
 
     # Fetches an object starting at the local scope and then moving up the hierachy
     def find_variable(key, raise_on_not_found: true)
-      # This was changed from find() to find_index() because this is a very hot
-      # path and find_index() is optimized in MRI to reduce object allocation
-      index = @scopes.find_index { |s| s.key?(key) }
-
-      variable = if index
-        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
+      # Fast path: check top scope first (most common in for loops)
+      scope = @scopes[0]
+      if scope.key?(key)
+        variable = lookup_and_evaluate(scope, key, raise_on_not_found: raise_on_not_found)
+      elsif @scopes.length == 1
+        # Only one scope and key not found — go straight to environments
+        variable = try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
       else
-        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
+        # Multiple scopes — search through all of them
+        scope = @scopes.find { |s| s.key?(key) }
+
+        variable = if scope
+          lookup_and_evaluate(scope, key, raise_on_not_found: raise_on_not_found)
+        else
+          try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
+        end
       end
 
       # update variable's context before invoking #to_liquid
+      # Fast path: primitive types don't need context= or to_liquid conversion
+      case variable
+      when String, Integer, Float, NilClass, TrueClass, FalseClass, Array, Hash, Time
+        return variable
+      end
+
       variable.context = self if variable.respond_to?(:context=)
 
       liquid_variable = variable.to_liquid
 
-      liquid_variable.context = self if variable != liquid_variable && liquid_variable.respond_to?(:context=)
+      if variable != liquid_variable
+        liquid_variable.context = self if liquid_variable.respond_to?(:context=)
+      end
 
       liquid_variable
     end
@@ -228,6 +263,7 @@ module Liquid
     end
 
     def with_disabled_tags(tag_names)
+      @disabled_tags = {} if @disabled_tags.frozen?
       tag_names.each do |name|
         @disabled_tags[name] = @disabled_tags.fetch(name, 0) + 1
       end
@@ -251,17 +287,16 @@ module Liquid
     attr_reader :base_scope_depth
 
     def try_variable_find_in_environments(key, raise_on_not_found:)
-      @environments.each do |environment|
+      found = find_in_envs(@environments, key, raise_on_not_found: raise_on_not_found)
+      return found unless found.nil? && !(@strict_variables && raise_on_not_found)
+
+      find_in_envs(@static_environments, key, raise_on_not_found: raise_on_not_found)
+    end
+
+    def find_in_envs(envs, key, raise_on_not_found:)
+      envs.each do |environment|
         found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          return found_variable
-        end
-      end
-      @static_environments.each do |environment|
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          return found_variable
-        end
+        return found_variable if !found_variable.nil? || (@strict_variables && raise_on_not_found)
       end
       nil
     end

lib/liquid/cursor.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Liquid
+  # Single-pass forward-only scanner for Liquid parsing.
+  # Wraps StringScanner with higher-level methods for common Liquid constructs.
+  # One Cursor per template parse — threaded through all parsing code.
+  class Cursor
+    # Byte constants
+    SPACE   = 32
+    TAB     = 9
+    NL      = 10
+    CR      = 13
+    FF      = 12
+    DASH    = 45  # '-'
+    DOT     = 46  # '.'
+    COLON   = 58  # ':'
+    PIPE    = 124 # '|'
+    QUOTE_S = 39  # "'"
+    QUOTE_D = 34  # '"'
+    LBRACK  = 91  # '['
+    RBRACK  = 93  # ']'
+    LPAREN  = 40  # '('
+    RPAREN  = 41  # ')'
+    QMARK   = 63  # '?'
+    HASH    = 35  # '#'
+    USCORE  = 95  # '_'
+    COMMA   = 44
+    ZERO    = 48
+    NINE    = 57
+    PCT     = 37  # '%'
+    LCURLY  = 123 # '{'
+    RCURLY  = 125 # '}'
+
+    attr_reader :ss
+
+    def initialize(source)
+      @source = source
+      @ss = StringScanner.new(source)
+    end
+
+    # ── Position ────────────────────────────────────────────────────
+    def pos = @ss.pos
+
+    def pos=(n)
+      @ss.pos = n
+    end
+
+    def eos? = @ss.eos?
+    def peek_byte = @ss.peek_byte
+    def scan_byte = @ss.scan_byte
+
+    # Reset scanner to a new string (for reuse on sub-markup)
+    def reset(source)
+      @source = source
+      @ss.string = source
+    end
+
+    # Extract a slice from the source (deferred allocation)
+    def slice(start, len)
+      @source.byteslice(start, len)
+    end
+
+    # ── Whitespace ──────────────────────────────────────────────────
+    # Skip spaces/tabs/newlines/cr
+    def skip_ws
+      while (b = @ss.peek_byte)
+        case b
+        when SPACE, TAB, CR, FF, NL then @ss.scan_byte
+        else break
+        end
+      end
+    end
+
+    # Check if remaining bytes are all whitespace (or EOS).
+    # exist?(/\S/) returns nil when no non-whitespace remains, without advancing position.
+    def rest_blank?
+      !@ss.exist?(/\S/)
+    end
+
+    # Regex for identifier: [a-zA-Z_][\w-]*\??
+    ID_REGEX = /[a-zA-Z_][\w-]*\??/
+
+    # ── Identifiers ─────────────────────────────────────────────────
+    # Skip an identifier without allocating a string. Returns length skipped, or 0.
+    def skip_id
+      @ss.skip(ID_REGEX) || 0
+    end
+
+    # Check if next id matches expected string, consume if so. No allocation.
+    def expect_id(expected)
+      start = @ss.pos
+      len = @ss.skip(ID_REGEX)
+      if len == expected.bytesize
+        # Compare bytes directly without allocating a string
+        i = 0
+        while i < len
+          unless @source.getbyte(start + i) == expected.getbyte(i)
+            @ss.pos = start
+            return false
+          end
+          i += 1
+        end
+        return true
+      end
+      @ss.pos = start if len
+      false
+    end
+
+    # Scan a single identifier: [a-zA-Z_][\w-]*\??
+    # Returns the string or nil if not at an identifier
+    def scan_id
+      @ss.scan(ID_REGEX)
+    end
+
+    # Scan a tag name: '#' or \w+
+    def scan_tag_name
+      if @ss.peek_byte == HASH
+        @ss.scan_byte
+        "#"
+      else
+        scan_id
+      end
+    end
+
+    # Regex for numbers: -?\d+(\.\d+)?
+    FLOAT_REGEX = /-?\d+\.\d+/
+    INT_REGEX = /-?\d+/
+
+    # ── Numbers ─────────────────────────────────────────────────────
+    # Try to scan an integer or float. Returns the number or nil.
+    def scan_number
+      if (s = @ss.scan(FLOAT_REGEX))
+        s.to_f
+      elsif (s = @ss.scan(INT_REGEX))
+        s.to_i
+      end
+    end
+
+    # Regex for quoted string content (without quotes)
+    SINGLE_QUOTED_CONTENT = /'([^']*)'/
+    DOUBLE_QUOTED_CONTENT = /"([^"]*)"/
+
+    # ── Strings ─────────────────────────────────────────────────────
+    # Scan a quoted string ('...' or "..."). Returns the content without quotes, or nil.
+    def scan_quoted_string
+      if @ss.scan(SINGLE_QUOTED_CONTENT) || @ss.scan(DOUBLE_QUOTED_CONTENT)
+        @ss[1]
+      end
+    end
+
+    # Regex for quoted strings (single or double quoted, including quotes)
+    QUOTED_STRING_RAW = /"[^"]*"|'[^']*'/
+
+    # Scan a quoted string including quotes. Returns the full "..." or '...' string, or nil.
+    def scan_quoted_string_raw
+      @ss.scan(QUOTED_STRING_RAW)
+    end
+
+    # Regex for dotted identifier: name(.name)*
+    DOTTED_ID_REGEX = /[a-zA-Z_][\w-]*\??(?:\.[a-zA-Z_][\w-]*\??)*/
+
+    # ── Expressions ─────────────────────────────────────────────────
+    # Scan a simple variable lookup: name(.name)* — no brackets, no filters
+    # Returns the string or nil
+    def scan_dotted_id
+      @ss.scan(DOTTED_ID_REGEX)
+    end
+
+    # Skip a fragment without allocating. Returns length skipped, or 0.
+    def skip_fragment
+      @ss.skip(QUOTED_STRING_RAW) || @ss.skip(UNQUOTED_FRAGMENT) || 0
+    end
+
+    # Regex for unquoted fragment: non-whitespace/comma/pipe sequence
+    UNQUOTED_FRAGMENT = /[^\s,|]+/
+
+    # Scan a "QuotedFragment" — a quoted string or non-whitespace/comma/pipe run
+    def scan_fragment
+      @ss.scan(QUOTED_STRING_RAW) || @ss.scan(UNQUOTED_FRAGMENT)
+    end
+
+    # ── Comparison operators ────────────────────────────────────────
+    # Identity map used for frozen string interning: StringScanner#scan returns a
+    # new unfrozen String on every call. Indexing into this hash returns the frozen
+    # literal stored here, avoiding a separate allocation and enabling faster
+    # equality checks downstream (frozen strings can be compared by identity).
+    COMPARISON_OPS = {
+      '==' => '==',
+      '!=' => '!=',
+      '<>' => '<>',
+      '<=' => '<=',
+      '>=' => '>=',
+      '<' => '<',
+      '>' => '>',
+      'contains' => 'contains',
+    }.freeze
+
+    # Scan a comparison operator. Returns frozen string or nil.
+    # Regex for comparison operators
+    COMPARISON_OP_REGEX = /==|!=|<>|<=|>=|<|>|contains(?!\w)/
+
+    def scan_comparison_op
+      if (op = @ss.scan(COMPARISON_OP_REGEX))
+        COMPARISON_OPS[op]
+      end
+    end
+
+    # ── Tag parsing helpers ─────────────────────────────────────────
+    # Results from last parse_tag_token call (avoids array allocation)
+    attr_reader :tag_markup, :tag_newlines
+
+    # Parse the interior of a tag token: "{%[-] tag_name markup [-]%}"
+    # Pure byte operations — avoids StringScanner reset overhead.
+    # Returns tag_name string or nil. Sets tag_markup and tag_newlines.
+    def parse_tag_token(token)
+      len = token.bytesize
+      pos = 2 # skip "{%"
+      pos += 1 if token.getbyte(pos) == DASH # skip '-'
+      nl = 0
+
+      # Skip whitespace, count newlines
+      while pos < len
+        b = token.getbyte(pos)
+        case b
+        when SPACE, TAB, CR, FF then pos += 1
+        when NL then pos += 1
+                     nl += 1
+        else break
+        end
+      end
+
+      # Scan tag name: '#' or [a-zA-Z_][\w-]*
+      name_start = pos
+      b = token.getbyte(pos)
+      if b == HASH
+        pos += 1
+      elsif b && ByteTables::IDENT_START[b]
+        pos += 1
+        while pos < len
+          b = token.getbyte(pos)
+          break unless ByteTables::IDENT_CONT[b]
+
+          pos += 1
+        end
+        pos += 1 if pos < len && token.getbyte(pos) == QMARK
+      else
+        return
+      end
+      tag_name = token.byteslice(name_start, pos - name_start)
+
+      # Skip whitespace after tag name, count newlines
+      while pos < len
+        b = token.getbyte(pos)
+        case b
+        when SPACE, TAB, CR, FF then pos += 1
+        when NL then pos += 1
+                     nl += 1
+        else break
+        end
+      end
+
+      # markup is everything up to optional '-' before '%}'
+      markup_end = len - 2
+      markup_end -= 1 if markup_end > pos && token.getbyte(markup_end - 1) == DASH
+      @tag_markup = pos >= markup_end ? "" : token.byteslice(pos, markup_end - pos)
+      @tag_newlines = nl
+
+      tag_name
+    end
+
+    # Parse variable token interior: extract markup from "{{[-] ... [-]}}"
+    def parse_variable_token(token)
+      len = token.bytesize
+      return if len < 4
+
+      i = 2
+      i = 3 if token.getbyte(i) == DASH
+      parse_end = len - 3
+      parse_end -= 1 if token.getbyte(parse_end) == DASH
+      markup_len = parse_end - i + 1
+      markup_len <= 0 ? "" : token.byteslice(i, markup_len)
+    end
+
+    # ── Simple condition parser ─────────────────────────────────────
+    # Results from last parse_simple_condition call
+    attr_reader :cond_left, :cond_op, :cond_right
+
+    # Parse "expr [op expr]" from current position to end.
+    # Returns true on success, nil on failure. Sets cond_left, cond_op, cond_right.
+    def parse_simple_condition
+      skip_ws
+      @cond_left = scan_fragment
+      return unless @cond_left
+
+      skip_ws
+      if eos?
+        @cond_op = nil
+        @cond_right = nil
+        return true
+      end
+
+      @cond_op = scan_comparison_op
+      return unless @cond_op
+
+      skip_ws
+      @cond_right = scan_fragment
+      return unless @cond_right
+
+      skip_ws
+      return unless eos? # trailing junk
+
+      true
+    end
+  end
+end

lib/liquid/drop.rb

@@ -31,7 +31,7 @@ module Liquid
 
     # Catch all for the method
     def liquid_method_missing(method)
-      return nil unless @context&.strict_variables
+      return unless @context&.strict_variables
       raise Liquid::UndefinedDropMethod, "undefined method #{method}"
     end
 

lib/liquid/environment.rb

@@ -34,7 +34,7 @@ module Liquid
       # @param file_system The default file system that is used
       #  to load templates from.
       # @param error_mode [Symbol] The default error mode for all templates
-      #  (either :rigid, :strict, :warn, or :lax).
+      #  (either :strict2, :strict, :warn, or :lax).
       # @param exception_renderer [Proc] The exception renderer that is used to
       #   render exceptions.
       # @yieldparam environment [Environment] The environment instance that is being built.

lib/liquid/expression.rb

@@ -16,16 +16,9 @@ module Liquid
       '-' => VariableLookup.parse("-", nil).freeze,
     }.freeze
 
-    DOT = ".".ord
-    ZERO = "0".ord
-    NINE = "9".ord
-    DASH = "-".ord
-
     # Use an atomic group (?>...) to avoid pathological backtracing from
     # malicious input as described in https://github.com/Shopify/liquid/issues/1357
     RANGES_REGEX = /\A\(\s*(?>(\S+)\s*\.\.)\s*(\S+)\s*\)\z/
-    INTEGER_REGEX = /\A(-?\d+)\z/
-    FLOAT_REGEX = /\A(-?\d+)\.\d+\z/
 
     class << self
       def safe_parse(parser, ss = StringScanner.new(""), cache = nil)
@@ -35,11 +28,17 @@ module Liquid
       def parse(markup, ss = StringScanner.new(""), cache = nil)
         return unless markup
 
-        markup = markup.strip # markup can be a frozen string
+        # Only strip if there's leading/trailing whitespace (avoids allocation)
+        first_byte = markup.getbyte(0)
+        if first_byte && ByteTables::WHITESPACE[first_byte]
+          markup = markup.strip
+        elsif first_byte
+          markup = markup.strip if ByteTables::WHITESPACE[markup.getbyte(markup.bytesize - 1)]
+        end
 
         if (markup.start_with?('"') && markup.end_with?('"')) ||
           (markup.start_with?("'") && markup.end_with?("'"))
-          return markup[1..-2]
+          return markup.byteslice(1, markup.bytesize - 2)
         elsif LITERALS.key?(markup)
           return LITERALS[markup]
         end
@@ -55,7 +54,7 @@ module Liquid
       end
 
       def inner_parse(markup, ss, cache)
-        if (markup.start_with?("(") && markup.end_with?(")")) && markup =~ RANGES_REGEX
+        if markup.start_with?("(") && markup.end_with?(")") && markup =~ RANGES_REGEX
           return RangeLookup.parse(
             Regexp.last_match(1),
             Regexp.last_match(2),
@@ -71,57 +70,85 @@ module Liquid
         end
       end
 
-      def parse_number(markup, ss)
-        # check if the markup is simple integer or float
-        case markup
-        when INTEGER_REGEX
+      def parse_number(markup, _ss = nil)
+        len = markup.bytesize
+        return if len == 0
+
+        # Quick reject: first byte must be digit or dash
+        pos = 0
+        first = markup.getbyte(pos)
+        if first == Cursor::DASH
+          pos += 1
+          return if pos >= len
+
+          b = markup.getbyte(pos)
+          return unless ByteTables::DIGIT[b]
+
+          pos += 1
+        elsif ByteTables::DIGIT[first]
+          pos += 1
+        else
+          return
+        end
+
+        # Scan digits
+        while pos < len
+          b = markup.getbyte(pos)
+          break unless ByteTables::DIGIT[b]
+
+          pos += 1
+        end
+
+        # If we consumed everything, it's a simple integer
+        if pos == len
           return Integer(markup, 10)
-        when FLOAT_REGEX
-          return markup.to_f
         end
 
-        ss.string = markup
-        # the first byte must be a digit or  a dash
-        byte = ss.scan_byte
+        # Check for dot (float)
+        if markup.getbyte(pos) == Cursor::DOT
+          dot_pos = pos
+          pos += 1
+          # Must have at least one digit after dot
+          digit_after_dot = pos
+          while pos < len
+            b = markup.getbyte(pos)
+            break unless ByteTables::DIGIT[b]
 
-        return false if byte != DASH && (byte < ZERO || byte > NINE)
+            pos += 1
+          end
 
-        if byte == DASH
-          peek_byte = ss.peek_byte
-
-          # if it starts with a dash, the next byte must be a digit
-          return false if peek_byte.nil? || !(peek_byte >= ZERO && peek_byte <= NINE)
-        end
-
-        # The markup could be a float with multiple dots
-        first_dot_pos = nil
-        num_end_pos = nil
-
-        while (byte = ss.scan_byte)
-          return false if byte != DOT && (byte < ZERO || byte > NINE)
-
-          # we found our number and now we are just scanning the rest of the string
-          next if num_end_pos
-
-          if byte == DOT
-            if first_dot_pos.nil?
-              first_dot_pos = ss.pos
-            else
-              # we found another dot, so we know that the number ends here
-              num_end_pos = ss.pos - 1
-            end
+          if pos > digit_after_dot && pos == len
+            # Simple float like "123.456"
+            return markup.to_f
+          elsif pos > digit_after_dot
+            # Float followed by more content: "1.2.3.4" — scan to find where the
+            # numeric portion ends (stop at next dot or non-digit).
+            return scan_float_with_trailing(markup, pos, len)
+          else
+            # dot at end: "123."
+            return markup.byteslice(0, dot_pos).to_f
           end
         end
 
-        num_end_pos = markup.length if ss.eos?
+        # Not a number (has non-digit, non-dot characters)
+        nil
+      end
 
-        if num_end_pos
-          # number ends with a number "123.123"
-          markup.byteslice(0, num_end_pos).to_f
-        else
-          # number ends with a dot "123."
-          markup.byteslice(0, first_dot_pos).to_f
+      private
+
+      # Scans forward from `pos` through digits, returning the float up to the
+      # next dot or the end of string. Returns nil when a non-digit, non-dot
+      # byte is found (not a valid number). Used by parse_number for inputs
+      # like "1.2.3.4" where the float literal ends at the second dot.
+      def scan_float_with_trailing(markup, pos, len)
+        while pos < len
+          b = markup.getbyte(pos)
+          return markup.byteslice(0, pos).to_f if b == Cursor::DOT
+          return unless ByteTables::DIGIT[b]
+
+          pos += 1
         end
+        markup.byteslice(0, pos).to_f
       end
     end
   end

lib/liquid/i18n.rb

@@ -28,7 +28,7 @@ module Liquid
     def interpolate(name, vars)
       name.gsub(/%\{(\w+)\}/) do
         # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        (vars[Regexp.last_match(1).to_sym]).to_s
+        vars[Regexp.last_match(1).to_sym].to_s
       end
     end
 

lib/liquid/lexer.rb

@@ -29,6 +29,7 @@ module Liquid
     RUBY_WHITESPACE = [" ", "\t", "\r", "\n", "\f"].freeze
     SINGLE_STRING_LITERAL = /'[^\']*'/
     WHITESPACE_OR_NOTHING = /\s*/
+    WHITESPACE = /\s+/
 
     SINGLE_COMPARISON_TOKENS = [].tap do |table|
       table["<".ord] = COMPARISON_LESS_THAN
@@ -104,7 +105,7 @@ module Liquid
         output = []
 
         until ss.eos?
-          ss.skip(WHITESPACE_OR_NOTHING)
+          ss.skip(WHITESPACE)
 
           break if ss.eos?
 
@@ -114,10 +115,10 @@ module Liquid
           if (special = SPECIAL_TABLE[peeked])
             ss.scan_byte
             # Special case for ".."
-            if special == DOT && ss.peek_byte == DOT_ORD
+            if special.equal?(DOT) && ss.peek_byte == DOT_ORD
               ss.scan_byte
               output << DOTDOT
-            elsif special == DASH
+            elsif special.equal?(DASH)
               # Special case for negative numbers
               if (peeked_byte = ss.peek_byte) && NUMBER_TABLE[peeked_byte]
                 ss.pos -= 1

lib/liquid/locales/en.yml

@@ -5,7 +5,6 @@
       block_tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: {% %{tag} %}{% end%{tag} %}"
       assign: "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]"
       capture: "Syntax Error in 'capture' - Valid syntax: capture [var]"
-      snippet: "Syntax Error in 'snippet' - Valid syntax: snippet [var]"
       case: "Syntax Error in 'case' - Valid syntax: case [condition]"
       case_invalid_when: "Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %}"
       case_invalid_else: "Syntax Error in tag 'case' - Valid else condition: {% else %} (no parameters) "
@@ -20,7 +19,6 @@
       invalid_delimiter: "'%{tag}' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
       invalid_template_encoding: "Invalid template encoding"
       render: "Syntax error in tag 'render' - Template name must be a quoted string"
-      render_invalid_template_name: "Syntax error in tag 'render' - Expected a string or identifier, found %{found}"
       table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
       table_row_invalid_attribute: "Invalid attribute '%{attribute}' in tablerow loop. Valid attributes are cols, limit, offset, and range"
       tag_never_closed: "'%{block_name}' tag was never closed"
@@ -31,6 +29,5 @@
       variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
     argument:
       include: "Argument error in tag 'include' - Illegal template name"
-      render: "Argument error in tag 'render' - Dynamically chosen templates are not allowed"
     disabled:
       tag: "usage is not allowed in this context"

lib/liquid/parse_context.rb

@@ -3,7 +3,7 @@
 module Liquid
   class ParseContext
     attr_accessor :locale, :line_number, :trim_whitespace, :depth
-    attr_reader :partial, :warnings, :error_mode, :environment
+    attr_reader :partial, :warnings, :error_mode, :environment, :expression_cache, :string_scanner, :cursor
 
     def initialize(options = Const::EMPTY_HASH)
       @environment = options.fetch(:environment, Environment.default)
@@ -24,6 +24,8 @@ module Liquid
         {}
       end
 
+      @cursor = Cursor.new("")
+
       self.depth   = 0
       self.partial = false
     end
@@ -55,15 +57,15 @@ module Liquid
     end
 
     def parse_expression(markup, safe: false)
-      if !safe && @error_mode == :rigid
+      if !safe && @error_mode == :strict2
         # parse_expression is a widely used API. To maintain backward
-        # compatibility while raising awareness about rigid parser standards,
+        # compatibility while raising awareness about strict2 parser standards,
         # the safe flag supports API users make a deliberate decision.
         #
-        # In rigid mode, markup MUST come from a string returned by the parser
+        # In strict2 mode, markup MUST come from a string returned by the parser
         # (e.g., parser.expression). We're not calling the parser here to
         # prevent redundant parser overhead.
-        raise Liquid::InternalError, "unsafe parse_expression cannot be used in rigid mode"
+        raise Liquid::InternalError, "unsafe parse_expression cannot be used in strict2 mode"
       end
 
       Expression.parse(markup, @string_scanner, @expression_cache)

lib/liquid/parser.rb

@@ -83,6 +83,9 @@ module Liquid
     end
 
     def variable_lookups
+      # Fast path: no lookups at all (most common case for simple identifiers)
+      return "" unless look(:dot) || look(:open_square)
+
       str = +""
       loop do
         if look(:open_square)

lib/liquid/parser_switching.rb

@@ -7,16 +7,19 @@ module Liquid
     # It's basically doing the same thing the {#parse_with_selected_parser},
     # except this will try the strict parser regardless of the error mode,
     # and fall back to the lax parser if the error mode is lax or warn,
-    # except when in rigid mode where it uses the rigid parser.
+    # except when in strict2 mode where it uses the strict2 parser.
     #
     # @deprecated Use {#parse_with_selected_parser} instead.
     def strict_parse_with_error_mode_fallback(markup)
-      return rigid_parse_with_error_context(markup) if rigid_mode?
+      return strict2_parse_with_error_context(markup) if strict2_mode?
 
       strict_parse_with_error_context(markup)
     rescue SyntaxError => e
       case parse_context.error_mode
       when :rigid
+        rigid_warn
+        raise
+      when :strict2
         raise
       when :strict
         raise
@@ -28,12 +31,13 @@ module Liquid
 
     def parse_with_selected_parser(markup)
       case parse_context.error_mode
-      when :rigid  then rigid_parse_with_error_context(markup)
-      when :strict then strict_parse_with_error_context(markup)
-      when :lax    then lax_parse(markup)
+      when :rigid   then rigid_warn && strict2_parse_with_error_context(markup)
+      when :strict2 then strict2_parse_with_error_context(markup)
+      when :strict  then strict_parse_with_error_context(markup)
+      when :lax     then lax_parse(markup)
       when :warn
         begin
-          rigid_parse_with_error_context(markup)
+          strict2_parse_with_error_context(markup)
         rescue SyntaxError => e
           parse_context.warnings << e
           lax_parse(markup)
@@ -41,14 +45,18 @@ module Liquid
       end
     end
 
-    def rigid_mode?
-      parse_context.error_mode == :rigid
+    def strict2_mode?
+      parse_context.error_mode == :strict2 || parse_context.error_mode == :rigid
     end
 
     private
 
-    def rigid_parse_with_error_context(markup)
-      rigid_parse(markup)
+    def rigid_warn
+      Deprecations.warn(':rigid', ':strict2')
+    end
+
+    def strict2_parse_with_error_context(markup)
+      strict2_parse(markup)
     rescue SyntaxError => e
       e.line_number    = line_number
       e.markup_context = markup_context(markup)

lib/liquid/registers.rb

@@ -6,15 +6,15 @@ module Liquid
 
     def initialize(registers = {})
       @static = registers.is_a?(Registers) ? registers.static : registers
-      @changes = {}
+      @changes = nil
     end
 
     def []=(key, value)
-      @changes[key] = value
+      (@changes ||= {})[key] = value
     end
 
     def [](key)
-      if @changes.key?(key)
+      if @changes&.key?(key)
         @changes[key]
       else
         @static[key]
@@ -22,13 +22,13 @@ module Liquid
     end
 
     def delete(key)
-      @changes.delete(key)
+      @changes&.delete(key)
     end
 
     UNDEFINED = Object.new
 
     def fetch(key, default = UNDEFINED, &block)
-      if @changes.key?(key)
+      if @changes&.key?(key)
         @changes.fetch(key)
       elsif default != UNDEFINED
         if block_given?
@@ -42,7 +42,7 @@ module Liquid
     end
 
     def key?(key)
-      @changes.key?(key) || @static.key?(key)
+      @changes&.key?(key) || @static.key?(key)
     end
   end
 

lib/liquid/resource_limits.rb

@@ -2,24 +2,40 @@
 
 module Liquid
   class ResourceLimits
-    attr_accessor :render_length_limit, :render_score_limit, :assign_score_limit
-    attr_reader :render_score, :assign_score
+    attr_accessor :render_length_limit,
+      :render_score_limit,
+      :assign_score_limit,
+      :cumulative_render_score_limit,
+      :cumulative_assign_score_limit
+    attr_reader :render_score,
+      :assign_score,
+      :last_capture_length,
+      :cumulative_render_score,
+      :cumulative_assign_score
 
     def initialize(limits)
-      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit  = limits[:render_score_limit]
-      @assign_score_limit  = limits[:assign_score_limit]
+      @render_length_limit           = limits[:render_length_limit]
+      @render_score_limit            = limits[:render_score_limit]
+      @assign_score_limit            = limits[:assign_score_limit]
+      @cumulative_render_score_limit = limits[:cumulative_render_score_limit]
+      @cumulative_assign_score_limit = limits[:cumulative_assign_score_limit]
+      @cumulative_render_score = 0
+      @cumulative_assign_score = 0
       reset
     end
 
     def increment_render_score(amount)
       @render_score += amount
+      @cumulative_render_score += amount
       raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
+      raise_limits_reached if @cumulative_render_score_limit && @cumulative_render_score > @cumulative_render_score_limit
     end
 
     def increment_assign_score(amount)
       @assign_score += amount
+      @cumulative_assign_score += amount
       raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
+      raise_limits_reached if @cumulative_assign_score_limit && @cumulative_assign_score > @cumulative_assign_score_limit
     end
 
     # update either render_length or assign_score based on whether or not the writes are captured
@@ -47,6 +63,8 @@ module Liquid
       @reached_limit = false
       @last_capture_length = nil
       @render_score = @assign_score = 0
+      raise_limits_reached if @cumulative_render_score_limit && @cumulative_render_score > @cumulative_render_score_limit
+      raise_limits_reached if @cumulative_assign_score_limit && @cumulative_assign_score > @cumulative_assign_score_limit
     end
 
     def with_capture

lib/liquid/snippet_drop.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class SnippetDrop < Drop
-    attr_reader :body, :name, :filename
-
-    def initialize(body, name, filename)
-      super()
-      @body = body
-      @name = name
-      @filename = filename
-    end
-
-    def to_partial
-      @body
-    end
-
-    def to_s
-      'SnippetDrop'
-    end
-  end
-end

lib/liquid/standardfilters.rb

@@ -8,10 +8,19 @@ module Liquid
     MAX_I32 = (1 << 31) - 1
     private_constant :MAX_I32
 
-    MIN_I64 = -(1 << 63)
-    MAX_I64 = (1 << 63) - 1
-    I64_RANGE = MIN_I64..MAX_I64
-    private_constant :MIN_I64, :MAX_I64, :I64_RANGE
+    supports_64bit_indices = begin
+      [][1 << 33, 1 << 33]
+      true
+    rescue RangeError
+      false
+    end
+
+    INDEX_RANGE = if supports_64bit_indices
+      (-(1 << 63))..((1 << 63) - 1)
+    else
+      (-(1 << 31))..((1 << 31) - 1)
+    end
+    private_constant :INDEX_RANGE
 
     HTML_ESCAPE = {
       '&' => '&amp;',
@@ -214,11 +223,11 @@ module Liquid
           Utils.to_s(input).slice(offset, length) || ''
         end
       rescue RangeError
-        if I64_RANGE.cover?(length) && I64_RANGE.cover?(offset)
+        if INDEX_RANGE.cover?(length) && INDEX_RANGE.cover?(offset)
           raise # unexpected error
         end
-        offset = offset.clamp(I64_RANGE)
-        length = length.clamp(I64_RANGE)
+        offset = offset.clamp(INDEX_RANGE)
+        length = length.clamp(INDEX_RANGE)
         retry
       end
     end
@@ -266,18 +275,71 @@ module Liquid
       words = Utils.to_integer(words)
       words = 1 if words <= 0
 
-      wordlist = begin
-        input.split(" ", words + 1)
-      rescue RangeError
-        # integer too big for String#split, but we can semantically assume no truncation is needed
-        return input if words + 1 > MAX_I32
-        raise # unexpected error
-      end
-      return input if wordlist.length <= words
+      return input if words + 1 > MAX_I32
 
-      wordlist.pop
-      truncate_string = Utils.to_s(truncate_string)
-      wordlist.join(" ").concat(truncate_string)
+      # 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
+      # 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
+        break unless ByteTables::WHITESPACE[input.getbyte(pos)]
+        pos += 1
+      end
+
+      while pos < len
+        word_start = pos
+        word_count += 1
+
+        # Scan to end of word
+        while pos < len
+          break if ByteTables::WHITESPACE[input.getbyte(pos)]
+          pos += 1
+        end
+
+        if word_count <= words
+          positions.push(word_start, pos) # [start, end, start, end, ...]
+        else
+          # 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
+          break unless ByteTables::WHITESPACE[input.getbyte(pos)]
+          pos += 1
+        end
+      end
+
+      # Fewer words than requested — no truncation needed, return original unchanged.
+      return input if word_count < words
+
+      # Exactly `words` words. Ruby's split(" ", words+1) would produce a words+1-th
+      # empty element when input has trailing whitespace, triggering the truncation path.
+      # Match that behaviour: if the input ends with whitespace, normalize and append
+      # truncate_string even though no word was cut.
+      if len > 0 && ByteTables::WHITESPACE[input.getbyte(len - 1)]
+        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
+
+      input
     end
 
     # @liquid_public_docs
@@ -293,6 +355,19 @@ module Liquid
       input.split(pattern)
     end
 
+    # @liquid_public_docs
+    # @liquid_type filter
+    # @liquid_category string
+    # @liquid_summary
+    #   Removes leading and trailing whitespace and collapses consecutive whitespace to a single space.
+    # @liquid_syntax string | squish
+    # @liquid_return [string]
+    def squish(input)
+      return if input.nil?
+
+      Utils.to_s(input).strip.gsub(/\s+/, ' ')
+    end
+
     # @liquid_public_docs
     # @liquid_type filter
     # @liquid_category string
@@ -768,6 +843,8 @@ module Liquid
     # @liquid_syntax array | first
     # @liquid_return [untyped]
     def first(array)
+      # ActiveSupport returns "" for empty strings, not nil
+      return array[0] || "" if array.is_a?(String)
       array.first if array.respond_to?(:first)
     end
 
@@ -779,6 +856,8 @@ module Liquid
     # @liquid_syntax array | last
     # @liquid_return [untyped]
     def last(array)
+      # ActiveSupport returns "" for empty strings, not nil
+      return array[-1] || "" if array.is_a?(String)
       array.last if array.respond_to?(:last)
     end
 

lib/liquid/strainer_template.rb

@@ -58,5 +58,31 @@ module Liquid
     rescue ::ArgumentError => e
       raise Liquid::ArgumentError, e.message, e.backtrace
     end
+
+    # Arity-specialized filter invocation.
+    # Avoids *args splat allocation for the common 0-arg and 1-arg cases.
+    # `invoke` (general case) still uses *args for 2+ extra arguments.
+    {
+      invoke_single: ['input'],
+      invoke_two: ['input', 'arg1'],
+    }.each do |method_name, params|
+      all_params = (["method"] + params).join(", ")
+      send_params = params.join(", ")
+      # __LINE__ + 1 is a parse-time constant; both generated methods will report
+      # the same file:line in backtraces. The method name in the trace distinguishes them.
+      module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        def #{method_name}(#{all_params})
+          if self.class.invokable?(method)
+            send(method, #{send_params})
+          elsif @context.strict_filters
+            raise Liquid::UndefinedFilter, "undefined filter \#{method}"
+          else
+            input
+          end
+        rescue ::ArgumentError => e
+          raise Liquid::ArgumentError, e.message, e.backtrace
+        end
+      RUBY
+    end
   end
 end

lib/liquid/tags.rb

@@ -20,7 +20,6 @@ require_relative "tags/raw"
 require_relative "tags/render"
 require_relative "tags/cycle"
 require_relative "tags/doc"
-require_relative "tags/snippet"
 
 module Liquid
   module Tags
@@ -45,7 +44,6 @@ module Liquid
       'echo' => Echo,
       'tablerow' => TableRow,
       'doc' => Doc,
-      'snippet' => Snippet,
     }.freeze
   end
 end

lib/liquid/tags/case.rb

@@ -86,7 +86,7 @@ module Liquid
 
     private
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       parser = @parse_context.new_parser(markup)
       @left = safe_parse_expression(parser)
       parser.consume(:end_of_string)
@@ -107,18 +107,18 @@ module Liquid
     def record_when_condition(markup)
       body = new_body
 
-      if rigid_mode?
-        parse_rigid_when(markup, body)
+      if strict2_mode?
+        parse_strict2_when(markup, body)
       else
         parse_lax_when(markup, body)
       end
     end
 
-    def parse_rigid_when(markup, body)
+    def parse_strict2_when(markup, body)
       parser = @parse_context.new_parser(markup)
 
       loop do
-        expr = safe_parse_expression(parser)
+        expr = Condition.parse_expression(parse_context, parser.expression, safe: true)
         block = Condition.new(@left, '==', expr)
         block.attach(body)
         @blocks << block

lib/liquid/tags/cycle.rb

@@ -56,7 +56,7 @@ module Liquid
     private
 
     # cycle [name:] expression(, expression)*
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @variables = []

lib/liquid/tags/for.rb

@@ -25,8 +25,6 @@ module Liquid
   # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
   # @liquid_optional_param reversed [untyped] Iterate in reverse order.
   class For < Block
-    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
-
     attr_reader :collection_name, :variable_name, :limit, :from
 
     def initialize(tag_name, markup, options)
@@ -72,18 +70,52 @@ module Liquid
 
     protected
 
+    # Fast byte-level parser for "var in collection [reversed] [limit:N] [offset:N]"
     def lax_parse(markup)
-      if markup =~ Syntax
-        @variable_name   = Regexp.last_match(1)
-        collection_name  = Regexp.last_match(2)
-        @reversed        = !!Regexp.last_match(3)
-        @name            = "#{@variable_name}-#{collection_name}"
-        @collection_name = parse_expression(collection_name)
-        markup.scan(TagAttributes) do |key, value|
-          set_attribute(key, value)
+      c = @parse_context.cursor
+      c.reset(markup)
+      c.skip_ws
+
+      # Parse variable name
+      var_start = c.pos
+      var_len = c.skip_id
+      raise SyntaxError, options[:locale].t("errors.syntax.for") if var_len == 0
+      @variable_name = c.slice(var_start, var_len)
+
+      # Expect "in"
+      c.skip_ws
+      raise SyntaxError, options[:locale].t("errors.syntax.for") unless c.expect_id("in")
+      c.skip_ws
+
+      # Parse collection name
+      col_start = c.pos
+      if c.peek_byte == Cursor::LPAREN
+        # Parenthesized range: (1..10)
+        depth = 1
+        c.scan_byte
+        while !c.eos? && depth > 0
+          b = c.scan_byte
+          depth += 1 if b == Cursor::LPAREN
+          depth -= 1 if b == Cursor::RPAREN
         end
       else
-        raise SyntaxError, options[:locale].t("errors.syntax.for")
+        c.skip_fragment
+      end
+      collection_name = c.slice(col_start, c.pos - col_start)
+
+      @name            = "#{@variable_name}-#{collection_name}"
+      @collection_name = parse_expression(collection_name)
+
+      c.skip_ws
+      @reversed = c.expect_id("reversed")
+      c.skip_ws
+
+      # Parse limit:/offset: if present.
+      # Cursor doesn't handle key:value attributes — delegate to regex for limit:/offset:.
+      if !c.eos? && (rest = c.slice(c.pos, markup.bytesize - c.pos)).include?(':')
+        rest.scan(TagAttributes) do |key, value|
+          set_attribute(key, value)
+        end
       end
     end
 
@@ -111,9 +143,7 @@ module Liquid
 
     private
 
-    def rigid_parse(markup)
-      strict_parse(markup)
-    end
+    alias_method :strict2_parse, :strict_parse
 
     def collection_segment(context)
       offsets = context.registers[:for] ||= {}
@@ -122,22 +152,14 @@ module Liquid
         offsets[@name].to_i
       else
         from_value = context.evaluate(@from)
-        if from_value.nil?
-          0
-        else
-          Utils.to_integer(from_value)
-        end
+        from_value.nil? ? 0 : Utils.to_integer(from_value)
       end
 
       collection = context.evaluate(@collection_name)
       collection = collection.to_a if collection.is_a?(Range)
 
       limit_value = context.evaluate(@limit)
-      to = if limit_value.nil?
-        nil
-      else
-        Utils.to_integer(limit_value) + from
-      end
+      to = limit_value && (Utils.to_integer(limit_value) + from)
 
       segment = Utils.slice_collection(collection, from, to)
       segment.reverse! if @reversed
@@ -192,11 +214,7 @@ module Liquid
     end
 
     def render_else(context, output)
-      if @else_block
-        @else_block.render_to_output_buffer(context, output)
-      else
-        output
-      end
+      @else_block ? @else_block.render_to_output_buffer(context, output) : output
     end
 
     class ParseTreeVisitor < Liquid::ParseTreeVisitor

lib/liquid/tags/if.rb

@@ -51,14 +51,17 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
-      @blocks.each do |block|
-        result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context),
-        )
+      idx = 0
+      blocks = @blocks
+      while idx < blocks.length
+        block = blocks[idx]
+        result = block.evaluate(context)
+        result = result.to_liquid_value if result.respond_to?(:to_liquid_value)
 
         if result
           return block.attachment.render_to_output_buffer(context, output)
         end
+        idx += 1
       end
 
       output
@@ -66,7 +69,7 @@ module Liquid
 
     private
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       strict_parse(markup)
     end
 
@@ -86,6 +89,27 @@ module Liquid
     end
 
     def lax_parse(markup)
+      # Fastest path: simple identifier truthiness like "product.available" or "forloop.first"
+      if (simple = Variable.simple_variable_markup(markup))
+        return Condition.new(parse_expression(simple))
+      end
+
+      # Fast path: simple condition without and/or — use Cursor.
+      # The include? pre-checks are both a correctness guard (parse_simple_condition
+      # only handles a single comparison) and a perf gate (avoids cursor allocation
+      # for the compound-condition case that will always fall through to lax_parse).
+      if !markup.include?(' and ') && !markup.include?(' or ')
+        cursor = @parse_context.cursor
+        cursor.reset(markup)
+        if cursor.parse_simple_condition
+          return Condition.new(
+            parse_expression(cursor.cond_left),
+            cursor.cond_op,
+            cursor.cond_right ? parse_expression(cursor.cond_right) : nil,
+          )
+        end
+      end
+
       expressions = markup.scan(ExpressionsAndOperators)
       raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
 

lib/liquid/tags/include.rb

@@ -84,7 +84,7 @@ module Liquid
     alias_method :parse_context, :options
     private :parse_context
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @template_name_expr = safe_parse_expression(p)

lib/liquid/tags/render.rb

@@ -27,7 +27,7 @@ module Liquid
   # @liquid_syntax_keyword filename The name of the snippet to render, without the `.liquid` extension.
   class Render < Tag
     FOR = 'for'
-    SYNTAX = /(#{QuotedString}+|#{VariableSegment}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
 
     disable_tags "include"
 
@@ -47,23 +47,21 @@ module Liquid
     end
 
     def render_tag(context, output)
-      template = context.evaluate(@template_name_expr)
+      # The expression should be a String literal, which parses to a String object
+      template_name = @template_name_expr
+      raise ::ArgumentError unless template_name.is_a?(String)
 
-      if template.respond_to?(:to_partial)
-        partial = template.to_partial
-        template_name = template.filename
-        context_variable_name = @alias_name || template.name
-      elsif @template_name_expr.is_a?(String)
-        partial = PartialCache.load(template, context: context, parse_context: parse_context)
-        template_name = partial.name
-        context_variable_name = @alias_name || template_name.split('/').last
-      else
-        raise ::ArgumentError
-      end
+      partial = PartialCache.load(
+        template_name,
+        context: context,
+        parse_context: parse_context,
+      )
+
+      context_variable_name = @alias_name || template_name.split('/').last
 
       render_partial_func = ->(var, forloop) {
         inner_context               = context.new_isolated_subcontext
-        inner_context.template_name = template_name
+        inner_context.template_name = partial.name
         inner_context.partial       = true
         inner_context['forloop']    = forloop if forloop
 
@@ -87,10 +85,10 @@ module Liquid
     end
 
     # render (string) (with|for expression)? (as id)? (key: value)*
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
-      @template_name_expr = parse_expression(rigid_template_name(p), safe: true)
+      @template_name_expr = parse_expression(strict2_template_name(p), safe: true)
       with_or_for         = p.id?("for") || p.id?("with")
       @variable_name_expr = safe_parse_expression(p) if with_or_for
       @alias_name         = p.consume(:id) if p.id?("as")
@@ -103,18 +101,14 @@ module Liquid
         key = p.consume
         p.consume(:colon)
         @attributes[key] = safe_parse_expression(p)
-        p.consume?(:comma) # optional comma
+        p.consume?(:comma)
       end
 
       p.consume(:end_of_string)
     end
 
-    def rigid_template_name(p)
-      return p.consume(:string) if p.look(:string)
-      return p.consume(:id) if p.look(:id)
-
-      found = p.consume || "nothing"
-      raise SyntaxError, options[:locale].t("errors.syntax.render_invalid_template_name", found: found)
+    def strict2_template_name(p)
+      p.consume(:string)
     end
 
     def strict_parse(markup)

lib/liquid/tags/snippet.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category variable
-  # @liquid_name snippet
-  # @liquid_summary
-  #   Creates a new inline snippet.
-  # @liquid_description
-  #   You can create inline snippets to make your Liquid code more modular.
-  # @liquid_syntax
-  #   {% snippet snippet_name %}
-  #     value
-  #   {% endsnippet %}
-  class Snippet < Block
-    def initialize(tag_name, markup, options)
-      super
-      p = @parse_context.new_parser(markup)
-      if p.look(:id)
-        @to = p.consume(:id)
-        p.consume(:end_of_string)
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.snippet")
-      end
-    end
-
-    def render_to_output_buffer(context, output)
-      snippet_drop = SnippetDrop.new(@body, @to, context.template_name)
-      context.scopes.last[@to] = snippet_drop
-      context.resource_limits.increment_assign_score(assign_score_of(snippet_drop))
-      output
-    end
-
-    def blank?
-      true
-    end
-
-    private
-
-    def assign_score_of(snippet_drop)
-      snippet_drop.body.nodelist.sum { |node| node.to_s.bytesize }
-    end
-  end
-end

lib/liquid/tags/table_row.rb

@@ -34,7 +34,7 @@ module Liquid
       parse_with_selected_parser(markup)
     end
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @variable_name = p.consume(:id)

lib/liquid/template.rb

@@ -25,7 +25,7 @@ module Liquid
       # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
       # :warn is the default and will give deprecation warnings when invalid syntax is used.
       # :strict enforces correct syntax for most tags
-      # :rigid enforces correct syntax for all tags
+      # :strict2 enforces correct syntax for all tags
       def error_mode=(mode)
         Deprecations.warn("Template.error_mode=", "Environment#error_mode=")
         Environment.default.error_mode = mode

lib/liquid/tokenizer.rb

@@ -1,37 +1,23 @@
 # frozen_string_literal: true
 
-require "strscan"
-
 module Liquid
   class Tokenizer
     attr_reader :line_number, :for_liquid_tag
 
-    TAG_END = /%\}/
-    TAG_OR_VARIABLE_START = /\{[\{\%]/
-    NEWLINE = /\n/
-
-    OPEN_CURLEY = "{".ord
-    CLOSE_CURLEY = "}".ord
-    PERCENTAGE = "%".ord
-
     def initialize(
       source:,
-      string_scanner:,
+      string_scanner: nil,
       line_numbers: false,
       line_number: nil,
       for_liquid_tag: false
     )
       @line_number = line_number || (line_numbers ? 1 : nil)
       @for_liquid_tag = for_liquid_tag
-      @source = source.to_s.to_str
+      @source = source.to_s
       @offset = 0
       @tokens = []
 
-      if @source
-        @ss = string_scanner
-        @ss.string = @source
-        tokenize
-      end
+      tokenize
     end
 
     def shift
@@ -54,108 +40,113 @@ module Liquid
       if @for_liquid_tag
         @tokens = @source.split("\n")
       else
-        @tokens << shift_normal until @ss.eos?
+        tokenize_fast
       end
 
       @source = nil
-      @ss = nil
     end
 
-    def shift_normal
-      token = next_token
+    # Fast tokenizer using String#byteindex instead of StringScanner regex.
+    # String#byteindex is ~40% faster for finding { delimiters.
+    def tokenize_fast
+      src = @source
+      unless src.valid_encoding?
+        raise SyntaxError, "Invalid byte sequence in #{src.encoding}"
+      end
 
-      return unless token
+      len = src.bytesize
+      pos = 0
 
-      token
-    end
+      while pos < len
+        # Find next { which could start a tag or variable
+        idx = src.byteindex('{', pos)
 
-    def next_token
-      # possible states: :text, :tag, :variable
-      byte_a = @ss.peek_byte
-
-      if byte_a == OPEN_CURLEY
-        @ss.scan_byte
-
-        byte_b = @ss.peek_byte
-
-        if byte_b == PERCENTAGE
-          @ss.scan_byte
-          return next_tag_token
-        elsif byte_b == OPEN_CURLEY
-          @ss.scan_byte
-          return next_variable_token
+        unless idx
+          # No more tags/variables — rest is text
+          @tokens << src.byteslice(pos, len - pos) if pos < len
+          break
         end
 
-        @ss.pos -= 1
-      end
+        next_byte = idx + 1 < len ? src.getbyte(idx + 1) : nil
 
-      next_text_token
-    end
+        if next_byte == Cursor::PCT # {%
+          # Emit text before tag
+          @tokens << src.byteslice(pos, idx - pos) if idx > pos
 
-    def next_text_token
-      start = @ss.pos
-
-      unless @ss.skip_until(TAG_OR_VARIABLE_START)
-        token = @ss.rest
-        @ss.terminate
-        return token
-      end
-
-      pos = @ss.pos -= 2
-      @source.byteslice(start, pos - start)
-    rescue ::ArgumentError => e
-      if e.message == "invalid byte sequence in #{@ss.string.encoding}"
-        raise SyntaxError, "Invalid byte sequence in #{@ss.string.encoding}"
-      else
-        raise
-      end
-    end
-
-    def next_variable_token
-      start = @ss.pos - 2
-
-      byte_a = byte_b = @ss.scan_byte
-
-      while byte_b
-        byte_a = @ss.scan_byte while byte_a && (byte_a != CLOSE_CURLEY && byte_a != OPEN_CURLEY)
-
-        break unless byte_a
-
-        if @ss.eos?
-          return byte_a == CLOSE_CURLEY ? @source.byteslice(start, @ss.pos - start) : "{{"
-        end
-
-        byte_b = @ss.scan_byte
-
-        if byte_a == CLOSE_CURLEY
-          if byte_b == CLOSE_CURLEY
-            return @source.byteslice(start, @ss.pos - start)
-          elsif byte_b != CLOSE_CURLEY
-            @ss.pos -= 1
-            return @source.byteslice(start, @ss.pos - start)
+          # Find %} to close the tag
+          close = src.byteindex('%}', idx + 2)
+          if close
+            @tokens << src.byteslice(idx, close + 2 - idx)
+            pos = close + 2
+          else
+            # Emit malformed token to propagate a missing-terminator error in the parser
+            @tokens << "{%"
+            pos = idx + 2
+          end
+        elsif next_byte == Cursor::LCURLY # {{
+          # Emit text before variable, then scan for the closing }}.
+          @tokens << src.byteslice(pos, idx - pos) if idx > pos
+          pos = scan_variable_token(src, idx, len)
+        else
+          # Lone '{' — not the start of a tag or variable.
+          # Find the next '{{' or '{%' to know where this text token ends.
+          # Using two byteindex calls avoids a nested loop and is always O(n).
+          tag_start = src.byteindex('{%', idx + 1)
+          var_start = src.byteindex('{{', idx + 1)
+          next_token = [tag_start, var_start].compact.min
+          if next_token
+            @tokens << src.byteslice(pos, next_token - pos)
+            pos = next_token
+          else
+            @tokens << src.byteslice(pos, len - pos)
+            pos = len
           end
-        elsif byte_a == OPEN_CURLEY && byte_b == PERCENTAGE
-          return next_tag_token_with_start(start)
         end
-
-        byte_a = byte_b
-      end
-
-      "{{"
-    end
-
-    def next_tag_token
-      start = @ss.pos - 2
-      if (len = @ss.skip_until(TAG_END))
-        @source.byteslice(start, len + 2)
-      else
-        "{%"
       end
     end
 
-    def next_tag_token_with_start(start)
-      @ss.skip_until(TAG_END)
-      @source.byteslice(start, @ss.pos - start)
+    # Scans a {{ ... }} variable token starting at `idx` in `src`.
+    # Emits the token to @tokens and returns the new position after the token.
+    # Handles }}, single }, and embedded {% ... %} (nested tag inside variable).
+    private def scan_variable_token(src, idx, len)
+      # Byte-by-byte scan: find } or {, then inspect the next byte.
+      scan_pos = idx + 2
+      while scan_pos < len
+        b = src.getbyte(scan_pos)
+        if b == Cursor::RCURLY # }
+          if scan_pos + 1 >= len
+            # } at end of string — emit token up to here
+            @tokens << src.byteslice(idx, scan_pos + 1 - idx)
+            return scan_pos + 1
+          end
+          b2 = src.getbyte(scan_pos + 1)
+          if b2 == Cursor::RCURLY
+            # Found }} — close variable
+            @tokens << src.byteslice(idx, scan_pos + 2 - idx)
+            return scan_pos + 2
+          else
+            # } followed by non-} — emit token up to here (matches original: @ss.pos -= 1)
+            @tokens << src.byteslice(idx, scan_pos + 1 - idx)
+            return scan_pos + 1
+          end
+        elsif b == Cursor::LCURLY && scan_pos + 1 < len && src.getbyte(scan_pos + 1) == Cursor::PCT
+          # Found {% inside {{ — scan to %} and emit as one token
+          close = src.byteindex('%}', scan_pos + 2)
+          if close
+            @tokens << src.byteslice(idx, close + 2 - idx)
+            return close + 2
+          else
+            @tokens << src.byteslice(idx, len - idx)
+            return len
+          end
+        else
+          scan_pos += 1
+        end
+      end
+
+      # Reached end without finding }} — malformed
+      @tokens << "{{"
+      idx + 2
     end
   end
 end

lib/liquid/utils.rb

@@ -8,6 +8,9 @@ module Liquid
     def self.slice_collection(collection, from, to)
       if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
         collection.load_slice(from, to)
+      elsif from == 0 && to.nil? && collection.is_a?(Array)
+        # Fast path: no offset/limit on an Array — return as-is (avoid copy)
+        collection
       else
         slice_collection_using_each(collection, from, to)
       end
@@ -15,23 +18,17 @@ module Liquid
 
     def self.slice_collection_using_each(collection, from, to)
       segments = []
-      index    = 0
 
-      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
+      # String is Enumerable but #each is not defined; handle it as a single-element collection
       if collection.is_a?(String)
         return collection.empty? ? [] : [collection]
       end
       return [] unless collection.respond_to?(:each)
 
+      index = 0
       collection.each do |item|
-        if to && to <= index
-          break
-        end
-
-        if from <= index
-          segments << item
-        end
-
+        break if to && to <= index
+        segments << item if from <= index
         index += 1
       end
 
@@ -69,7 +66,7 @@ module Liquid
       return obj if obj.respond_to?(:strftime)
 
       if obj.is_a?(String)
-        return nil if obj.empty?
+        return if obj.empty?
         obj = obj.downcase
       end
 
@@ -93,37 +90,45 @@ module Liquid
       obj
     end
 
-    def self.to_s(obj, seen = {})
+    # Cached string representations for common small integers (0-999)
+    # Avoids repeated Integer#to_s allocations during rendering
+    SMALL_INT_STRINGS = Array.new(1000) { |i| i.to_s.freeze }.freeze
+
+    def self.to_s(obj, seen = nil)
       case obj
+      when Integer
+        obj >= 0 && obj < 1000 ? SMALL_INT_STRINGS[obj] : obj.to_s
+      when BigDecimal
+        obj.to_s("F")
       when Hash
         # If the custom hash implementation overrides `#to_s`, use their
         # custom implementation. Otherwise we use Liquid's default
         # implementation.
         if obj.class.instance_method(:to_s) == HASH_TO_S_METHOD
-          hash_inspect(obj, seen)
+          hash_inspect(obj, seen || {})
         else
           obj.to_s
         end
       when Array
-        array_inspect(obj, seen)
+        array_inspect(obj, seen || {})
       else
         obj.to_s
       end
     end
 
-    def self.inspect(obj, seen = {})
+    def self.inspect(obj, seen = nil)
       case obj
       when Hash
         # If the custom hash implementation overrides `#inspect`, use their
         # custom implementation. Otherwise we use Liquid's default
         # implementation.
         if obj.class.instance_method(:inspect) == HASH_INSPECT_METHOD
-          hash_inspect(obj, seen)
+          hash_inspect(obj, seen || {})
         else
           obj.inspect
         end
       when Array
-        array_inspect(obj, seen)
+        array_inspect(obj, seen || {})
       else
         obj.inspect
       end

lib/liquid/variable.rb

@@ -12,6 +12,26 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
+    # Checks if markup is a simple "name.lookup.chain" with no filters/brackets/quotes.
+    # Returns the trimmed markup string, or nil if not simple.
+    def self.simple_variable_markup(markup)
+      return if markup.empty?
+      return unless markup.match?(SIMPLE_VARIABLE_RE)
+      # Avoid allocation when there's no surrounding whitespace (the common case)
+      first = markup.getbyte(0)
+      last  = markup.getbyte(markup.bytesize - 1)
+      needs_strip = first == Cursor::SPACE || first == Cursor::TAB || first == Cursor::NL || first == Cursor::CR ||
+        last == Cursor::SPACE || last == Cursor::TAB || last == Cursor::NL || last == Cursor::CR
+      needs_strip ? markup.strip : markup
+    end
+
+    # Cache for [filtername, EMPTY_ARRAY] tuples — avoids repeated array creation
+    NO_ARG_FILTER_CACHE = Hash.new { |h, k| h[k] = [k, Const::EMPTY_ARRAY].freeze }
+
+    # Regex for a simple variable lookup with optional surrounding whitespace.
+    # Shares the identifier grammar with VariableLookup::SIMPLE_LOOKUP_RE.
+    SIMPLE_VARIABLE_RE = /\A\s*[\w-]+\??(?:\.[\w-]+\??)*\s*\z/
+
     FilterMarkupRegex        = /#{FilterSeparator}\s*(.*)/om
     FilterParser             = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
     FilterArgsRegex          = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
@@ -30,7 +50,278 @@ module Liquid
       @parse_context = parse_context
       @line_number   = parse_context.line_number
 
-      strict_parse_with_error_mode_fallback(markup)
+      # Fast path: try to parse without going through Lexer → Parser
+      # Skip for strict2/rigid modes which require different parsing
+      # Fast path only for lax/warn modes — strict modes need full error checking
+      error_mode = parse_context.error_mode
+      if error_mode == :strict2 || error_mode == :rigid || error_mode == :strict || !try_fast_parse(markup, parse_context)
+        strict_parse_with_error_mode_fallback(markup)
+      end
+    end
+
+    private def try_fast_parse(markup, parse_context)
+      pos = fast_scan_name(markup)
+      return false unless pos
+
+      # fast_resolve_name calls VariableLookup.parse_simple / Expression::LITERALS — the
+      # only sites that can raise SyntaxError on malformed input. The byte scanners return
+      # false instead of raising.
+      begin
+        fast_resolve_name(markup, parse_context)
+      rescue SyntaxError
+        return false
+      end
+
+      # End of markup — no filters
+      if pos >= markup.bytesize
+        @filters = Const::EMPTY_ARRAY
+        return true
+      end
+
+      # Must be followed by a pipe filter separator
+      return false unless markup.getbyte(pos) == Cursor::PIPE
+
+      fast_scan_filters(markup, pos, parse_context)
+    end
+
+    # Scan the variable name (quoted string or identifier chain) at the start of markup.
+    # Returns the position after the name + trailing whitespace, or false on failure.
+    # Sets @_fast_name_start and @_fast_name_end for fast_resolve_name.
+    private def fast_scan_name(markup)
+      len = markup.bytesize
+      return false if len == 0
+
+      # Skip leading whitespace
+      pos = 0
+      while pos < len
+        b = markup.getbyte(pos)
+        break unless b == Cursor::SPACE || b == Cursor::TAB || b == Cursor::NL || b == Cursor::CR
+        pos += 1
+      end
+      return false if pos >= len
+
+      b = markup.getbyte(pos)
+
+      if b == Cursor::QUOTE_S || b == Cursor::QUOTE_D
+        # Quoted string literal: scan to matching close quote
+        quote = b
+        @_fast_name_start = pos
+        pos += 1
+        pos += 1 while pos < len && markup.getbyte(pos) != quote
+        pos += 1 if pos < len # skip closing quote
+        @_fast_name_end = pos
+      elsif ByteTables::IDENT_START[b]
+        # Identifier chain: [a-zA-Z_][a-zA-Z0-9_-]*(.[a-zA-Z_][a-zA-Z0-9_-]*)*
+        @_fast_name_start = pos
+        pos += 1
+        while pos < len
+          b = markup.getbyte(pos)
+          if ByteTables::IDENT_CONT[b]
+            pos += 1
+          elsif b == Cursor::DOT
+            pos += 1
+            return false if pos >= len
+            b = markup.getbyte(pos)
+            return false unless ByteTables::IDENT_START[b]
+            pos += 1
+          else
+            break
+          end
+        end
+        @_fast_name_end = pos
+      else
+        return false
+      end
+
+      # Skip whitespace after name
+      while pos < len
+        b = markup.getbyte(pos)
+        break unless b == Cursor::SPACE || b == Cursor::TAB || b == Cursor::NL || b == Cursor::CR
+        pos += 1
+      end
+
+      pos
+    end
+
+    # Resolve the scanned name bytes to a Liquid expression object.
+    # Reads @_fast_name_start / @_fast_name_end set by fast_scan_name.
+    # Sets @name.  May raise SyntaxError (rescued in try_fast_parse).
+    private def fast_resolve_name(markup, parse_context)
+      name_start = @_fast_name_start
+      name_end   = @_fast_name_end
+      len        = markup.bytesize
+
+      # Avoid byteslice when the name spans the whole markup (no surrounding whitespace/filters)
+      expr_markup = name_start == 0 && name_end == len ? markup : markup.byteslice(name_start, name_end - name_start)
+
+      cache = parse_context.expression_cache
+      ss    = parse_context.string_scanner
+
+      first_byte = expr_markup.getbyte(0)
+      @name = if first_byte == Cursor::QUOTE_S || first_byte == Cursor::QUOTE_D
+        # String literal — strip enclosing quotes
+        expr_markup.byteslice(1, expr_markup.bytesize - 2)
+      elsif Expression::LITERALS.key?(expr_markup)
+        Expression::LITERALS[expr_markup]
+      elsif cache
+        cache[expr_markup] || (cache[expr_markup] = VariableLookup.parse_simple(expr_markup, ss, cache).freeze)
+      else
+        VariableLookup.parse_simple(expr_markup, ss || StringScanner.new(""), nil).freeze
+      end
+    end
+
+    # Scan the filter chain starting at `pos` (the first '|').
+    # Returns true on success (sets @filters), false to fall back to the Lexer.
+    # Rescues SyntaxError from Expression.parse inside fast_scan_filter_args.
+    private def fast_scan_filters(markup, pos, parse_context)
+      len = markup.bytesize
+      @filters = []
+      filter_pos = pos
+
+      while filter_pos < len && markup.getbyte(filter_pos) == Cursor::PIPE
+        filter_pos += 1
+        # Skip spaces after pipe (tabs/newlines handled in the between-filters skip below)
+        filter_pos += 1 while filter_pos < len && markup.getbyte(filter_pos) == Cursor::SPACE
+
+        # Scan filter name: must start with [a-zA-Z_]
+        fname_start = filter_pos
+        b = filter_pos < len ? markup.getbyte(filter_pos) : nil
+        break unless b && ByteTables::IDENT_START[b]
+        filter_pos += 1
+        while filter_pos < len
+          b = markup.getbyte(filter_pos)
+          break unless ByteTables::IDENT_CONT[b]
+          filter_pos += 1
+        end
+        filtername = markup.byteslice(fname_start, filter_pos - fname_start)
+
+        # Skip whitespace after filter name
+        filter_pos += 1 while filter_pos < len && markup.getbyte(filter_pos) == Cursor::SPACE
+
+        if filter_pos < len && markup.getbyte(filter_pos) == Cursor::COLON
+          # Has arguments — fast-scan positional args; fall to Lexer on keyword args
+          filter_pos += 1 # skip ':'
+          filter_pos += 1 while filter_pos < len && markup.getbyte(filter_pos) == Cursor::SPACE
+
+          result = fast_scan_filter_args(markup, filter_pos, parse_context)
+          return fall_to_lexer_filters(markup, pos, fname_start, len, parse_context) if result == :fall_to_lexer
+
+          filter_args, filter_pos = result
+          @filters << [filtername, filter_args]
+        else
+          # No-arg filter — reuse the cached [name, EMPTY_ARRAY] tuple
+          @filters << NO_ARG_FILTER_CACHE[filtername]
+        end
+
+        # Skip whitespace (including tabs and newlines) between filters
+        filter_pos += 1 while filter_pos < len && (
+          markup.getbyte(filter_pos) == Cursor::SPACE ||
+          markup.getbyte(filter_pos) == Cursor::TAB   ||
+          markup.getbyte(filter_pos) == Cursor::NL    ||
+          markup.getbyte(filter_pos) == Cursor::CR
+        )
+      end
+
+      # Trailing bytes that aren't a pipe mean something the fast path doesn't handle
+      return false if filter_pos < len
+
+      @filters = Const::EMPTY_ARRAY if @filters.empty?
+      true
+    rescue SyntaxError
+      # Expression.parse (called inside fast_scan_filter_args for identifier args) can
+      # raise SyntaxError on malformed input.  Fall back to full Lexer parse.
+      @name = nil
+      @filters = nil
+      false
+    end
+
+    # Called when fast_scan_filter_args encounters keyword args or an unrecognised
+    # token. Hands the remaining filter chain (from the pipe before fname_start)
+    # to the full Lexer-based parser, merges results into @filters, and returns true.
+    private def fall_to_lexer_filters(markup, pos, fname_start, len, parse_context)
+      # Walk back from fname_start to find the pipe that opened this filter.
+      # Equivalent to: markup.rindex('|', fname_start), bounded by pos.
+      rest_start = fname_start
+      rest_start -= 1 while rest_start > pos && markup.getbyte(rest_start) != Cursor::PIPE
+      rest_markup = markup.byteslice(rest_start, len - rest_start)
+      p = parse_context.new_parser(rest_markup)
+      while p.consume?(:pipe)
+        fn = p.consume(:id)
+        fa = p.consume?(:colon) ? parse_filterargs(p) : Const::EMPTY_ARRAY
+        @filters << lax_parse_filter_expressions(fn, fa)
+      end
+      p.consume(:end_of_string)
+      @filters = Const::EMPTY_ARRAY if @filters.empty?
+      true
+    end
+
+    # Scan positional filter arguments starting at `filter_pos`.
+    # Returns [filter_args_array, new_filter_pos] on success, or :fall_to_lexer when
+    # keyword args or unrecognised tokens are encountered.
+    private def fast_scan_filter_args(markup, filter_pos, parse_context)
+      len = markup.bytesize
+      filter_args = []
+
+      loop do
+        arg_start = filter_pos
+        b = filter_pos < len ? markup.getbyte(filter_pos) : nil
+
+        if b == Cursor::QUOTE_S || b == Cursor::QUOTE_D
+          # Quoted string argument
+          quote = b
+          filter_pos += 1
+          filter_pos += 1 while filter_pos < len && markup.getbyte(filter_pos) != quote
+          filter_pos += 1 if filter_pos < len # skip closing quote
+          filter_args << markup.byteslice(arg_start + 1, filter_pos - arg_start - 2)
+
+        elsif b && (ByteTables::DIGIT[b] ||
+                    (b == Cursor::DASH && filter_pos + 1 < len && ByteTables::DIGIT[markup.getbyte(filter_pos + 1)]))
+          # Numeric argument (integer or float, optionally negative)
+          filter_pos += 1 if b == Cursor::DASH
+          filter_pos += 1 while filter_pos < len && ByteTables::DIGIT[markup.getbyte(filter_pos)]
+          if filter_pos < len && markup.getbyte(filter_pos) == Cursor::DOT # float
+            filter_pos += 1
+            filter_pos += 1 while filter_pos < len && ByteTables::DIGIT[markup.getbyte(filter_pos)]
+          end
+          num_str = markup.byteslice(arg_start, filter_pos - arg_start)
+          filter_args << (num_str.include?('.') ? num_str.to_f : num_str.to_i)
+
+        elsif b && ByteTables::IDENT_START[b]
+          # Identifier argument — may be a variable lookup or keyword arg
+          id_start = filter_pos
+          filter_pos += 1
+          while filter_pos < len
+            b2 = markup.getbyte(filter_pos)
+            break unless ByteTables::IDENT_CONT[b2] || b2 == Cursor::DOT
+            filter_pos += 1
+          end
+          filter_pos += 1 if filter_pos < len && markup.getbyte(filter_pos) == Cursor::QMARK
+
+          # Peek past whitespace: if followed by ':', this is a keyword arg → fall to Lexer
+          kw_check = filter_pos
+          kw_check += 1 while kw_check < len && markup.getbyte(kw_check) == Cursor::SPACE
+          return :fall_to_lexer if kw_check < len && markup.getbyte(kw_check) == Cursor::COLON
+
+          id_markup = markup.byteslice(id_start, filter_pos - id_start)
+          filter_args << Expression.parse(id_markup, parse_context.string_scanner, parse_context.expression_cache)
+
+        else
+          return :fall_to_lexer
+        end
+
+        # Skip whitespace after argument
+        filter_pos += 1 while filter_pos < len && markup.getbyte(filter_pos) == Cursor::SPACE
+
+        # Comma: more arguments follow; anything else: done with this filter's args
+        if filter_pos < len && markup.getbyte(filter_pos) == Cursor::COMMA
+          filter_pos += 1
+          filter_pos += 1 while filter_pos < len && markup.getbyte(filter_pos) == Cursor::SPACE
+        else
+          break
+        end
+      end
+
+      [filter_args, filter_pos]
     end
 
     def raw
@@ -42,7 +333,7 @@ module Liquid
     end
 
     def lax_parse(markup)
-      @filters = []
+      @filters = Const::EMPTY_ARRAY
       return unless markup =~ MarkupWithQuotedFragment
 
       name_markup   = Regexp.last_match(1)
@@ -54,19 +345,21 @@ module Liquid
           next unless f =~ /\w+/
           filtername = Regexp.last_match(0)
           filterargs = f.scan(FilterArgsRegex).flatten
+          @filters = [] if @filters.frozen?
           @filters << lax_parse_filter_expressions(filtername, filterargs)
         end
       end
     end
 
     def strict_parse(markup)
-      @filters = []
+      @filters = Const::EMPTY_ARRAY
       p = @parse_context.new_parser(markup)
 
       return if p.look(:end_of_string)
 
       @name = parse_context.safe_parse_expression(p)
       while p.consume?(:pipe)
+        @filters = [] if @filters.frozen?
         filtername = p.consume(:id)
         filterargs = p.consume?(:colon) ? parse_filterargs(p) : Const::EMPTY_ARRAY
         @filters << lax_parse_filter_expressions(filtername, filterargs)
@@ -74,14 +367,17 @@ module Liquid
       p.consume(:end_of_string)
     end
 
-    def rigid_parse(markup)
-      @filters = []
+    def strict2_parse(markup)
+      @filters = Const::EMPTY_ARRAY
       p = @parse_context.new_parser(markup)
 
       return if p.look(:end_of_string)
 
       @name = parse_context.safe_parse_expression(p)
-      @filters << rigid_parse_filter_expressions(p) while p.consume?(:pipe)
+      while p.consume?(:pipe)
+        @filters = [] if @filters.frozen?
+        @filters << strict2_parse_filter_expressions(p)
+      end
       p.consume(:end_of_string)
     end
 
@@ -97,24 +393,37 @@ module Liquid
       obj = context.evaluate(@name)
 
       @filters.each do |filter_name, filter_args, filter_kwargs|
-        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        obj = context.invoke(filter_name, obj, *filter_args)
+        if filter_args.empty? && !filter_kwargs
+          obj = context.invoke_single(filter_name, obj)
+        elsif !filter_kwargs && filter_args.length == 1
+          # Single positional arg — most common after no-arg
+          obj = context.invoke_two(filter_name, obj, context.evaluate(filter_args[0]))
+        else
+          filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
+          obj = context.invoke(filter_name, obj, *filter_args)
+        end
       end
 
       context.apply_global_filter(obj)
     end
 
     def render_to_output_buffer(context, output)
-      obj = render(context)
+      # Fast path: no filters and no global filter
+      obj = if @filters.empty? && context.global_filter.nil?
+        context.evaluate(@name)
+      else
+        render(context)
+      end
       render_obj_to_output(obj, output)
       output
     end
 
     def render_obj_to_output(obj, output)
-      case obj
-      when NilClass
+      if obj.instance_of?(String)
+        output << obj
+      elsif obj.nil?
         # Do nothing
-      when Array
+      elsif obj.instance_of?(Array)
         obj.each do |o|
           render_obj_to_output(o, output)
         end
@@ -128,7 +437,7 @@ module Liquid
     end
 
     def disabled_tags
-      []
+      Const::EMPTY_ARRAY
     end
 
     private
@@ -137,7 +446,8 @@ module Liquid
       filter_args  = []
       keyword_args = nil
       unparsed_args.each do |a|
-        if (matches = a.match(JustTagAttributes))
+        # Fast check: keyword args must contain ':'
+        if a.include?(':') && (matches = a.match(JustTagAttributes))
           keyword_args           ||= {}
           keyword_args[matches[1]] = parse_context.parse_expression(matches[2])
         else
@@ -156,7 +466,7 @@ module Liquid
     # argument = (positional_argument | keyword_argument)
     # positional_argument = expression
     # keyword_argument = id ":" expression
-    def rigid_parse_filter_expressions(p)
+    def strict2_parse_filter_expressions(p)
       filtername = p.consume(:id)
       filter_args = []
       keyword_args = {}
@@ -190,15 +500,19 @@ module Liquid
     end
 
     def evaluate_filter_expressions(context, filter_args, filter_kwargs)
-      parsed_args = filter_args.map { |expr| context.evaluate(expr) }
       if filter_kwargs
+        parsed_args = filter_args.map { |expr| context.evaluate(expr) }
         parsed_kwargs = {}
         filter_kwargs.each do |key, expr|
           parsed_kwargs[key] = context.evaluate(expr)
         end
         parsed_args << parsed_kwargs
+        parsed_args
+      elsif filter_args.empty?
+        Const::EMPTY_ARRAY
+      else
+        filter_args.map { |expr| context.evaluate(expr) }
       end
-      parsed_args
     end
 
     class ParseTreeVisitor < Liquid::ParseTreeVisitor

lib/liquid/variable_lookup.rb

@@ -10,11 +10,108 @@ module Liquid
       new(markup, string_scanner, cache)
     end
 
-    def initialize(markup, string_scanner = StringScanner.new(""), cache = nil)
-      lookups = markup.scan(VariableParser)
+    # Fast parse that skips simple_lookup? check — caller guarantees simple identifier chain
+    def self.parse_simple(markup, string_scanner = nil, cache = nil)
+      new(markup, string_scanner, cache, true)
+    end
+
+    # Fast manual scanner replacing markup.scan(VariableParser)
+    # VariableParser = /\[(?>[^\[\]]+|\g<0>)*\]|[\w-]+\??/
+    # Splits "product.variants[0].title" into ["product", "variants", "[0]", "title"]
+    def self.scan_variable(markup)
+      result = []
+      pos = 0
+      len = markup.bytesize
+
+      while pos < len
+        byte = markup.getbyte(pos)
+
+        if byte == 91 # '['
+          # Scan balanced brackets
+          depth = 1
+          start = pos
+          pos += 1
+          while pos < len && depth > 0
+            b = markup.getbyte(pos)
+            depth += 1 if b == 91
+            depth -= 1 if b == 93
+            pos += 1
+          end
+          if depth == 0
+            result << markup.byteslice(start, pos - start)
+          else
+            # Unbalanced bracket - skip '[' and continue
+            pos = start + 1
+          end
+        elsif byte == 46 # '.'
+          pos += 1
+        elsif ByteTables::IDENT_CONT[byte] # [\w-]
+          start = pos
+          pos += 1
+          while pos < len
+            b = markup.getbyte(pos)
+            break unless ByteTables::IDENT_CONT[b]
+            pos += 1
+          end
+          # Check trailing '?'
+          if pos < len && markup.getbyte(pos) == 63
+            pos += 1
+          end
+          result << markup.byteslice(start, pos - start)
+        else
+          pos += 1
+        end
+      end
+
+      result
+    end
+
+    # Check if markup is a simple identifier chain: [\w-]+\??(.[\w-]+\??)*
+    # Uses C-level match? — 8x faster than Ruby byte scanning
+    SIMPLE_LOOKUP_RE = /\A[\w-]+\??(?:\.[\w-]+\??)*\z/
+
+    def self.simple_lookup?(markup)
+      markup.bytesize > 0 && markup.match?(SIMPLE_LOOKUP_RE)
+    end
+
+    def initialize(markup, string_scanner = StringScanner.new(""), cache = nil, simple = false)
+      # Fast path: simple identifier chain without brackets
+      if simple || self.class.simple_lookup?(markup)
+        dot_pos = markup.index('.')
+        if dot_pos.nil?
+          @name = markup
+          @lookups = Const::EMPTY_ARRAY
+          @command_flags = 0
+          return
+        end
+        @name = markup.byteslice(0, dot_pos)
+        # Build lookups array from remaining dot-separated segments
+        lookups = []
+        @command_flags = 0
+        pos = dot_pos + 1
+        len = markup.bytesize
+        while pos < len
+          seg_start = pos
+          while pos < len
+            b = markup.getbyte(pos)
+            break if b == 46 # '.'
+            pos += 1
+          end
+          seg = markup.byteslice(seg_start, pos - seg_start)
+          if COMMAND_METHODS.include?(seg)
+            @command_flags |= 1 << lookups.length
+          end
+          lookups << seg
+          pos += 1 # skip dot
+        end
+        @lookups = lookups
+        return
+      end
+
+      lookups = self.class.scan_variable(markup)
 
       name = lookups.shift
-      if name&.start_with?('[') && name&.end_with?(']')
+      if name&.start_with?('[') && name.end_with?(']')
         name = Expression.parse(
           name[1..-2],
           string_scanner,
@@ -26,9 +123,8 @@ module Liquid
       @lookups       = lookups
       @command_flags = 0
 
-      @lookups.each_index do |i|
-        lookup = lookups[i]
-        if lookup&.start_with?('[') && lookup&.end_with?(']')
+      @lookups.each_with_index do |lookup, i|
+        if lookup&.start_with?('[') && lookup.end_with?(']')
           lookups[i] = Expression.parse(
             lookup[1..-2],
             string_scanner,
@@ -49,26 +145,39 @@ module Liquid
       object = context.find_variable(name)
 
       @lookups.each_index do |i|
-        key = context.evaluate(@lookups[i])
+        lookup = @lookups[i]
+        key = lookup.instance_of?(String) ? lookup : context.evaluate(lookup)
 
         # Cast "key" to its liquid value to enable it to act as a primitive value
-        key = Liquid::Utils.to_liquid_value(key)
+        # Fast path: strings and integers (most common key types) don't need conversion
+        unless key.instance_of?(String) || key.instance_of?(Integer)
+          key = Liquid::Utils.to_liquid_value(key)
+        end
 
         # If object is a hash- or array-like object we look for the
         # presence of the key and if its available we return it
-        if object.respond_to?(:[]) &&
-            ((object.respond_to?(:key?) && object.key?(key)) ||
-             (object.respond_to?(:fetch) && key.is_a?(Integer)))
-
+        if accessible?(object, key)
           # if its a proc we will replace the entry with the proc
-          res    = context.lookup_and_evaluate(object, key)
-          object = res.to_liquid
+          object = context.lookup_and_evaluate(object, key)
+          # Skip to_liquid for common primitive types (they return self)
+          unless object.instance_of?(String) || object.instance_of?(Integer) || object.instance_of?(Float) ||
+              object.instance_of?(Array) || object.instance_of?(Hash) || object.nil?
+            object = liquidize(object, context)
+          end
 
           # Some special cases. If the part wasn't in square brackets and
           # no key with the same name was found we interpret following calls
           # as commands and call them on the current object
         elsif lookup_command?(i) && object.respond_to?(key)
-          object = object.send(key).to_liquid
+          object = object.send(key)
+          unless object.instance_of?(String) || object.instance_of?(Integer) || object.instance_of?(Array) || object.nil?
+            object = liquidize(object, context)
+          end
+
+        # Handle string first/last like ActiveSupport does (returns first/last character)
+        # ActiveSupport returns "" for empty strings, not nil
+        elsif lookup_command?(i) && object.is_a?(String) && (key == "first" || key == "last")
+          object = key == "first" ? (object[0] || "") : (object[-1] || "")
 
           # No key was present with the desired value and it wasn't one of the directly supported
           # keywords either. The only thing we got left is to return nil or
@@ -77,9 +186,6 @@ module Liquid
           return nil unless context.strict_variables
           raise Liquid::UndefinedVariable, "undefined variable #{key}"
         end
-
-        # If we are dealing with a drop here we have to
-        object.context = context if object.respond_to?(:context=)
       end
 
       object
@@ -89,6 +195,27 @@ module Liquid
       self.class == other.class && state == other.state
     end
 
+    private
+
+    # Returns true if +object+ has +key+ accessible via [] lookup.
+    def accessible?(object, key)
+      if object.instance_of?(Hash)
+        object.key?(key)
+      else
+        object.respond_to?(:[]) &&
+          ((object.respond_to?(:key?) && object.key?(key)) ||
+           (object.respond_to?(:fetch) && key.is_a?(Integer)))
+      end
+    end
+
+    # Calls to_liquid on +object+ and wires up the context reference if needed.
+    # Skipped for primitive types that return self from to_liquid.
+    def liquidize(object, context)
+      object = object.to_liquid
+      object.context = context if object.respond_to?(:context=)
+      object
+    end
+
     protected
 
     def state

lib/liquid/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Liquid
-  VERSION = "5.10.0"
+  VERSION = "5.12.0"
 end

performance/bench_quick.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Quick benchmark for autoresearch: measures parse µs, render µs, and object allocations
+# Outputs machine-readable metrics to stdout
+
+require_relative 'theme_runner'
+
+RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
+
+runner = ThemeRunner.new
+
+# Warmup — enough iterations for YJIT to fully optimize hot paths
+20.times { runner.compile }
+20.times { runner.render }
+
+GC.start
+GC.compact if GC.respond_to?(:compact)
+
+# Measure parse
+parse_times = []
+10.times do
+  GC.disable
+  t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  runner.compile
+  t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  GC.enable
+  GC.start
+  parse_times << (t1 - t0) * 1_000_000 # µs
+end
+
+# Measure render
+render_times = []
+10.times do
+  GC.disable
+  t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  runner.render
+  t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  GC.enable
+  GC.start
+  render_times << (t1 - t0) * 1_000_000 # µs
+end
+
+# Measure object allocations for one parse+render cycle
+require 'objspace'
+GC.start
+GC.disable
+before = ObjectSpace.count_objects.values_at(:TOTAL).first - ObjectSpace.count_objects.values_at(:FREE).first
+runner.compile
+runner.render
+after = ObjectSpace.count_objects.values_at(:TOTAL).first - ObjectSpace.count_objects.values_at(:FREE).first
+GC.enable
+allocations = after - before
+
+parse_us = parse_times.min.round(0)
+render_us = render_times.min.round(0)
+combined_us = parse_us + render_us
+
+puts "RESULTS"
+puts "parse_us=#{parse_us}"
+puts "render_us=#{render_us}"
+puts "combined_us=#{combined_us}"
+puts "allocations=#{allocations}"

spec/ruby_liquid.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Liquid Spec Adapter for Shopify/liquid (Ruby reference implementation)
+#
+# Run with: bundle exec liquid-spec run spec/ruby_liquid.rb
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'liquid'
+
+LiquidSpec.configure do |config|
+  # Run core Liquid specs
+  config.features = [:core]
+end
+
+# Compile a template string into a Liquid::Template
+LiquidSpec.compile do |ctx, source, options|
+  ctx[:template] = Liquid::Template.parse(source, **options)
+end
+
+# Render a compiled template with the given context
+# @param ctx [Hash] adapter context containing :template
+# @param assigns [Hash] environment variables
+# @param options [Hash] :registers, :strict_errors, :exception_renderer
+LiquidSpec.render do |ctx, assigns, options|
+  registers = Liquid::Registers.new(options[:registers] || {})
+
+  context = Liquid::Context.build(
+    static_environments: assigns,
+    registers: registers,
+    rethrow_errors: options[:strict_errors],
+  )
+
+  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
+
+  ctx[:template].render(context)
+end

spec/ruby_liquid_lax.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Liquid Spec Adapter for Shopify/liquid with lax parsing mode
+#
+# Run with: bundle exec liquid-spec run spec/ruby_liquid_lax.rb
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'liquid'
+
+LiquidSpec.configure do |config|
+  config.features = [:core, :lax_parsing]
+end
+
+# Compile a template string into a Liquid::Template
+LiquidSpec.compile do |ctx, source, options|
+  # Force lax mode
+  options = options.merge(error_mode: :lax)
+  ctx[:template] = Liquid::Template.parse(source, **options)
+end
+
+# Render a compiled template with the given context
+LiquidSpec.render do |ctx, assigns, options|
+  registers = Liquid::Registers.new(options[:registers] || {})
+
+  context = Liquid::Context.build(
+    static_environments: assigns,
+    registers: registers,
+    rethrow_errors: options[:strict_errors],
+  )
+
+  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
+
+  ctx[:template].render(context)
+end

spec/ruby_liquid_with_active_support.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Liquid Spec Adapter for Shopify/liquid with ActiveSupport loaded
+#
+# Run with: bundle exec liquid-spec run spec/ruby_liquid_with_active_support.rb
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'active_support/all'
+require 'liquid'
+
+LiquidSpec.configure do |config|
+  # Run core Liquid specs plus ActiveSupport SafeBuffer tests
+  config.features = [:core, :activesupport]
+end
+
+# Compile a template string into a Liquid::Template
+LiquidSpec.compile do |ctx, source, options|
+  ctx[:template] = Liquid::Template.parse(source, **options)
+end
+
+# Render a compiled template with the given context
+# @param ctx [Hash] adapter context containing :template
+# @param assigns [Hash] environment variables
+# @param options [Hash] :registers, :strict_errors, :exception_renderer
+LiquidSpec.render do |ctx, assigns, options|
+  registers = Liquid::Registers.new(options[:registers] || {})
+
+  context = Liquid::Context.build(
+    static_environments: assigns,
+    registers: registers,
+    rethrow_errors: options[:strict_errors],
+  )
+
+  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
+
+  ctx[:template].render(context)
+end

spec/ruby_liquid_yjit.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Liquid Spec Adapter for Shopify/liquid with YJIT + strict mode + ActiveSupport
+#
+# Run with: bundle exec liquid-spec run spec/ruby_liquid_yjit.rb
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+# Enable YJIT if available
+if defined?(RubyVM::YJIT) && RubyVM::YJIT.respond_to?(:enable)
+  RubyVM::YJIT.enable
+end
+
+require 'active_support/all'
+require 'liquid'
+
+LiquidSpec.configure do |config|
+  config.features = [:core, :activesupport]
+end
+
+# Compile a template string into a Liquid::Template
+LiquidSpec.compile do |ctx, source, options|
+  # Force strict mode
+  options = { error_mode: :strict }.merge(options)
+  ctx[:template] = Liquid::Template.parse(source, **options)
+end
+
+# Render a compiled template with the given context
+LiquidSpec.render do |ctx, assigns, options|
+  registers = Liquid::Registers.new(options[:registers] || {})
+
+  context = Liquid::Context.build(
+    static_environments: assigns,
+    registers: registers,
+    rethrow_errors: options[:strict_errors],
+  )
+
+  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
+
+  ctx[:template].render(context)
+end

test/integration/context_test.rb

@@ -639,6 +639,21 @@ class ContextTest < Minitest::Test
     end
   end
 
+  def test_key_lookup_will_raise_for_missing_keys_when_strict_variables_is_enabled
+    context = Context.new
+    context.strict_variables = true
+    assert_raises(Liquid::UndefinedVariable) do
+      context['unknown']
+    end
+  end
+
+  def test_has_key_will_not_raise_for_missing_keys_when_strict_variables_is_enabled
+    context = Context.new
+    context.strict_variables = true
+    refute(context.key?('unknown'))
+    assert_empty(context.errors)
+  end
+
   def test_context_always_uses_static_registers
     registers = {
       my_register: :my_value,

test/integration/hash_rendering_test.rb

@@ -88,17 +88,11 @@ class HashRenderingTest < Minitest::Test
   end
 
   def test_rendering_hash_with_custom_to_s_method_uses_custom_to_s
-    my_hash = Class.new(Hash) do
-      def to_s
-        "kewl"
-      end
-    end.new
-
-    assert_template_result("kewl", "{{ my_hash }}", { "my_hash" => my_hash })
+    assert_template_result("kewl", "{{ my_hash }}", { "my_hash" => HashWithCustomToS.new })
   end
 
   def test_rendering_hash_without_custom_to_s_uses_default_inspect
-    my_hash = Class.new(Hash).new
+    my_hash = HashWithoutCustomToS.new
     my_hash[:foo] = :bar
 
     assert_template_result("{:foo=>:bar}", "{{ my_hash }}", { "my_hash" => my_hash })

test/integration/security_test.rb

@@ -44,33 +44,40 @@ class SecurityTest < Minitest::Test
   end
 
   def test_does_not_permanently_add_filters_to_symbol_table
-    current_symbols = Symbol.all_symbols
+    assert_no_new_symbols do
+      # MRI imprecisely marks objects found on the C stack, which can result
+      # in uninitialized memory being marked. This can even result in the test failing
+      # deterministically for a given compilation of ruby. Using a separate thread will
+      # keep these writes of the symbol pointer on a separate stack that will be garbage
+      # collected after Thread#join.
+      Thread.new do
+        test = %( {{ "some_string" | a_bad_filter }} )
+        Template.parse(test).render!
+        nil
+      end.join
 
-    # MRI imprecisely marks objects found on the C stack, which can result
-    # in uninitialized memory being marked. This can even result in the test failing
-    # deterministically for a given compilation of ruby. Using a separate thread will
-    # keep these writes of the symbol pointer on a separate stack that will be garbage
-    # collected after Thread#join.
-    Thread.new do
-      test = %( {{ "some_string" | a_bad_filter }} )
-      Template.parse(test).render!
-      nil
-    end.join
-
-    GC.start
-
-    assert_equal([], (Symbol.all_symbols - current_symbols))
+      GC.start
+    end
   end
 
   def test_does_not_add_drop_methods_to_symbol_table
+    assert_no_new_symbols do
+      assigns = { 'drop' => Drop.new }
+      assert_equal("", Template.parse("{{ drop.custom_method_1 }}", assigns).render!)
+      assert_equal("", Template.parse("{{ drop.custom_method_2 }}", assigns).render!)
+      assert_equal("", Template.parse("{{ drop.custom_method_3 }}", assigns).render!)
+    end
+  end
+
+  def assert_no_new_symbols
+    # Run once to trigger any first-time initialization which might create some symbols,
+    # for example autoload or lazy method parsing might create symbols on first execution.
+    yield
+
+    # Ensure no new symbols for further runs, i.e. the code does not leak symbols
     current_symbols = Symbol.all_symbols
-
-    assigns = { 'drop' => Drop.new }
-    assert_equal("", Template.parse("{{ drop.custom_method_1 }}", assigns).render!)
-    assert_equal("", Template.parse("{{ drop.custom_method_2 }}", assigns).render!)
-    assert_equal("", Template.parse("{{ drop.custom_method_3 }}", assigns).render!)
-
-    assert_equal([], (Symbol.all_symbols - current_symbols))
+    yield
+    assert_equal([], Symbol.all_symbols - current_symbols)
   end
 
   def test_max_depth_nested_blocks_does_not_raise_exception

test/integration/standard_filter_test.rb

@@ -116,7 +116,7 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_slice_on_arrays
-    input = 'foobar'.split(//)
+    input = 'foobar'.split('')
     assert_equal(%w(o o b), @filters.slice(input, 1, 3))
     assert_equal(%w(o o b a r), @filters.slice(input, 1, 1000))
     assert_equal(%w(), @filters.slice(input, 1, 0))
@@ -164,6 +164,13 @@ class StandardFiltersTest < Minitest::Test
     assert_equal(['A', 'Z'], @filters.split('A1Z', 1))
   end
 
+  def test_squish_filter
+    assert_equal("foo bar boo", Liquid::Template.parse(%({{ " foo   bar
+\t   boo   " | squish }})).render)
+    assert_equal("", Liquid::Template.parse('{{ nil | squish }}').render)
+    assert_equal("", Liquid::Template.parse('{{ " " | squish }}').render)
+  end
+
   def test_escape
     assert_equal('&lt;strong&gt;', @filters.escape('<strong>'))
     assert_equal('1', @filters.escape(1))
@@ -294,13 +301,7 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_join_calls_to_liquid_on_each_element
-    drop = Class.new(Liquid::Drop) do
-      def to_liquid
-        'i did it'
-      end
-    end
-
-    assert_equal('i did it, i did it', @filters.join([drop.new, drop.new], ", "))
+    assert_equal('i did it, i did it', @filters.join([CustomToLiquidDrop.new('i did it'), CustomToLiquidDrop.new('i did it')], ", "))
   end
 
   def test_sort
@@ -633,6 +634,40 @@ class StandardFiltersTest < Minitest::Test
     assert_nil(@filters.last([]))
   end
 
+  def test_first_last_on_strings
+    # Ruby's String class does not have first/last methods by default.
+    # ActiveSupport adds String#first and String#last to return the first/last character.
+    # Liquid must work without ActiveSupport, so the first/last filters handle strings specially.
+    #
+    # This enables template patterns like:
+    #   {{ product.title | first }}  => "S" (for "Snowboard")
+    #   {{ customer.name | last }}   => "h" (for "Smith")
+    #
+    # Note: ActiveSupport returns "" for empty strings, not nil.
+    assert_equal('f', @filters.first('foo'))
+    assert_equal('o', @filters.last('foo'))
+    assert_equal('', @filters.first(''))
+    assert_equal('', @filters.last(''))
+  end
+
+  def test_first_last_on_unicode_strings
+    # Unicode strings should return the first/last grapheme cluster (character),
+    # not the first/last byte. Ruby's String#[] handles this correctly with index 0/-1.
+    # This ensures international text works properly:
+    #   {{ korean_name | first }} => "고" (not a partial byte sequence)
+    assert_equal('고', @filters.first('고스트빈'))
+    assert_equal('빈', @filters.last('고스트빈'))
+  end
+
+  def test_first_last_on_strings_via_template
+    # Integration test to verify the filter works end-to-end in templates.
+    # Empty strings return empty output (nil renders as empty string).
+    assert_template_result('f', '{{ name | first }}', { 'name' => 'foo' })
+    assert_template_result('o', '{{ name | last }}', { 'name' => 'foo' })
+    assert_template_result('', '{{ name | first }}', { 'name' => '' })
+    assert_template_result('', '{{ name | last }}', { 'name' => '' })
+  end
+
   def test_replace
     assert_equal('b b b b', @filters.replace('a a a a', 'a', 'b'))
     assert_equal('2 2 2 2', @filters.replace('1 1 1 1', 1, 2))
@@ -1146,6 +1181,8 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_all_filters_never_raise_non_liquid_exception
+    skip("too slow on non-CRuby due to many exceptions") unless RUBY_ENGINE == 'ruby'
+
     test_drop = TestDrop.new(value: "test")
     test_drop.context = Context.new
     test_enum = TestEnumerable.new
@@ -1302,7 +1339,7 @@ class StandardFiltersTest < Minitest::Test
     assert_equal(1, @filters.sum(input, true))
     assert_equal(0.2, @filters.sum(input, 1.0))
     assert_equal(-0.3, @filters.sum(input, 1))
-    assert_equal(0.4, @filters.sum(input, (1..5)))
+    assert_equal(0.4, @filters.sum(input, 1..5))
     assert_equal(0, @filters.sum(input, nil))
     assert_equal(0, @filters.sum(input, ""))
   end

test/integration/tags/cycle_tag_test.rb

@@ -101,7 +101,7 @@ class CycleTagTest < Minitest::Test
       assert_template_result("a", template2)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
       error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
 
@@ -129,7 +129,7 @@ class CycleTagTest < Minitest::Test
       assert_template_result("N", template5)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
       error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
       error3 = assert_raises(Liquid::SyntaxError) { Template.parse(template3) }
@@ -157,7 +157,7 @@ class CycleTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -174,7 +174,7 @@ class CycleTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/tags/include_tag_test.rb

@@ -204,7 +204,7 @@ class IncludeTagTest < Minitest::Test
     )
   end
 
-  def test_rigid_parsing_errors
+  def test_strict2_parsing_errors
     with_error_modes(:lax, :strict) do
       assert_template_result(
         'hello value1 value2',
@@ -213,7 +213,7 @@ class IncludeTagTest < Minitest::Test
       )
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_syntax_error(
         '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
       )
@@ -408,7 +408,7 @@ class IncludeTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -421,7 +421,7 @@ class IncludeTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -434,7 +434,7 @@ class IncludeTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/tags/render_tag_test.rb

@@ -101,7 +101,11 @@ class RenderTagTest < Minitest::Test
     end
   end
 
-  def test_rigid_parsing_errors
+  def test_dynamically_choosen_templates_are_not_allowed
+    assert_syntax_error("{% assign name = 'snippet' %}{% render name %}")
+  end
+
+  def test_strict2_parsing_errors
     with_error_modes(:lax, :strict) do
       assert_template_result(
         'hello value1 value2',
@@ -110,7 +114,7 @@ class RenderTagTest < Minitest::Test
       )
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_syntax_error(
         '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
       )
@@ -290,13 +294,6 @@ class RenderTagTest < Minitest::Test
     )
   end
 
-  def test_render_tag_with_snippet_drop
-    assert_template_result(
-      "Hello from snippet",
-      "{% snippet my_snippet %}Hello from snippet{% endsnippet %}{% render my_snippet %}",
-    )
-  end
-
   def test_render_tag_renders_error_with_template_name
     assert_template_result(
       'Liquid error (foo line 1): standard error',
@@ -325,7 +322,7 @@ class RenderTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -338,7 +335,7 @@ class RenderTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/tags/standard_tag_test.rb

@@ -117,7 +117,7 @@ class StandardTagTest < Minitest::Test
     assigns = { 'condition' => "bad string here" }
     assert_template_result(
       '',
-      '{% case condition %}{% when "string here" %} hit {% endcase %}',\
+      '{% case condition %}{% when "string here" %} hit {% endcase %}',
       assigns,
     )
   end

test/integration/tags/table_row_test.rb

@@ -259,7 +259,7 @@ class TableRowTest < Minitest::Test
     )
   end
 
-  def test_tablerow_with_cols_attribute_in_rigid_mode
+  def test_tablerow_with_cols_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..6) cols: 3 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -270,12 +270,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">4</td><td class="col2">5</td><td class="col3">6</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_with_limit_attribute_in_rigid_mode
+  def test_tablerow_with_limit_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..10) limit: 3 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -285,12 +285,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_with_offset_attribute_in_rigid_mode
+  def test_tablerow_with_offset_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..5) offset: 2 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -300,12 +300,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">3</td><td class="col2">4</td><td class="col3">5</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_with_range_attribute_in_rigid_mode
+  def test_tablerow_with_range_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..3) range: (1..10) %}{{ i }}{% endtablerow %}
     LIQUID
@@ -315,12 +315,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_with_multiple_attributes_in_rigid_mode
+  def test_tablerow_with_multiple_attributes_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..10) cols: 2, limit: 4, offset: 1 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -331,12 +331,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">4</td><td class="col2">5</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_with_variable_collection_in_rigid_mode
+  def test_tablerow_with_variable_collection_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow n in numbers cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -347,12 +347,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template, { 'numbers' => [1, 2, 3, 4] })
     end
   end
 
-  def test_tablerow_with_dotted_access_in_rigid_mode
+  def test_tablerow_with_dotted_access_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow n in obj.numbers cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -363,12 +363,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template, { 'obj' => { 'numbers' => [1, 2, 3, 4] } })
     end
   end
 
-  def test_tablerow_with_bracketed_access_in_rigid_mode
+  def test_tablerow_with_bracketed_access_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow n in obj["numbers"] cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -378,12 +378,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">10</td><td class="col2">20</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template, { 'obj' => { 'numbers' => [10, 20] } })
     end
   end
 
-  def test_tablerow_without_attributes_in_rigid_mode
+  def test_tablerow_without_attributes_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..3) %}{{ i }}{% endtablerow %}
     LIQUID
@@ -393,30 +393,30 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_without_in_keyword_in_rigid_mode
+  def test_tablerow_without_in_keyword_in_strict2_mode
     template = '{% tablerow i (1..10) %}{{ i }}{% endtablerow %}'
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(SyntaxError) { Template.parse(template) }
       assert_equal("Liquid syntax error: For loops require an 'in' clause in \"i (1..10)\"", error.message)
     end
   end
 
-  def test_tablerow_with_multiple_invalid_attributes_reports_first_in_rigid_mode
+  def test_tablerow_with_multiple_invalid_attributes_reports_first_in_strict2_mode
     template = '{% tablerow i in (1..10) invalid1: 5, invalid2: 10 %}{{ i }}{% endtablerow %}'
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(SyntaxError) { Template.parse(template) }
       assert_equal("Liquid syntax error: Invalid attribute 'invalid1' in tablerow loop. Valid attributes are cols, limit, offset, and range in \"i in (1..10) invalid1: 5, invalid2: 10\"", error.message)
     end
   end
 
-  def test_tablerow_with_empty_collection_in_rigid_mode
+  def test_tablerow_with_empty_collection_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in empty_array cols: 2 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -426,12 +426,12 @@ class TableRowTest < Minitest::Test
       </tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template, { 'empty_array' => [] })
     end
   end
 
-  def test_tablerow_with_invalid_attribute_strict_vs_rigid
+  def test_tablerow_with_invalid_attribute_strict_vs_strict2
     template = '{% tablerow i in (1..5) invalid_attr: 10 %}{{ i }}{% endtablerow %}'
 
     expected = <<~OUTPUT
@@ -443,13 +443,13 @@ class TableRowTest < Minitest::Test
       assert_template_result(expected, template)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(SyntaxError) { Template.parse(template) }
       assert_match(/Invalid attribute 'invalid_attr'/, error.message)
     end
   end
 
-  def test_tablerow_with_invalid_expression_strict_vs_rigid
+  def test_tablerow_with_invalid_expression_strict_vs_strict2
     template = '{% tablerow i in (1..5) limit: foo=>bar %}{{ i }}{% endtablerow %}'
 
     with_error_modes(:lax, :strict) do
@@ -460,7 +460,7 @@ class TableRowTest < Minitest::Test
       assert_template_result(expected, template)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/template_test.rb

@@ -133,7 +133,7 @@ class TemplateTest < Minitest::Test
     assert(t.resource_limits.reached?)
 
     t.resource_limits.render_score_limit = 200
-    assert_equal((" foo " * 100), t.render!)
+    assert_equal(" foo " * 100, t.render!)
     refute_nil(t.resource_limits.render_score)
   end
 
@@ -179,6 +179,86 @@ class TemplateTest < Minitest::Test
     assert_equal("すごい", t.render)
   end
 
+  def test_cumulative_render_score_limit_across_render_tags
+    file_system = StubFileSystem.new(
+      'loop' => '{% for a in (1..10) %} foo {% endfor %}',
+    )
+    environment = Liquid::Environment.build(file_system: file_system)
+
+    # Without cumulative limit, all 5 partials render successfully
+    t = Template.parse(
+      '{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}',
+      environment: environment,
+    )
+    unlimited_output = t.render!
+    total_cumulative = t.resource_limits.cumulative_render_score
+
+    # With cumulative limit set below the total, rendering stops early
+    t2 = Template.parse(
+      '{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}',
+      environment: environment,
+    )
+    t2.resource_limits.cumulative_render_score_limit = total_cumulative / 2
+    limited_output = t2.render
+    assert(t2.resource_limits.reached?)
+    assert_operator(limited_output.length, :<, unlimited_output.length)
+  end
+
+  def test_cumulative_render_score_limit_raises_on_render_bang
+    file_system = StubFileSystem.new(
+      'loop' => '{% for a in (1..10) %} foo {% endfor %}',
+    )
+    environment = Liquid::Environment.build(file_system: file_system)
+    t = Template.parse(
+      '{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}',
+      environment: environment,
+    )
+    t.resource_limits.cumulative_render_score_limit = 20
+    assert_raises(Liquid::MemoryError) do
+      t.render!
+    end
+  end
+
+  def test_cumulative_assign_score_limit_across_include_tags
+    file_system = StubFileSystem.new(
+      'assign_partial' => '{% assign x = "a long string value here" %}',
+    )
+    environment = Liquid::Environment.build(file_system: file_system)
+
+    # Without cumulative limit, all 5 partials render
+    t = Template.parse(
+      '{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}',
+      environment: environment,
+    )
+    t.render!
+    total_cumulative = t.resource_limits.cumulative_assign_score
+
+    # With cumulative limit set below the total, rendering stops early
+    t2 = Template.parse(
+      '{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}',
+      environment: environment,
+    )
+    t2.resource_limits.cumulative_assign_score_limit = total_cumulative / 2
+    t2.render
+    assert(t2.resource_limits.reached?)
+  end
+
+  def test_cumulative_render_score_tracks_across_partials_without_limit
+    file_system = StubFileSystem.new(
+      'loop' => '{% for a in (1..10) %} foo {% endfor %}',
+    )
+    environment = Liquid::Environment.build(file_system: file_system)
+    t = Template.parse(
+      '{% render "loop" %}{% render "loop" %}{% render "loop" %}',
+      environment: environment,
+    )
+    t.render!
+    assert(
+      t.resource_limits.cumulative_render_score > t.resource_limits.render_score,
+      "cumulative should exceed per-template score after multiple partials",
+    )
+  end
+
   def test_default_resource_limits_unaffected_by_render_with_context
     context = Context.new
     t = Template.parse("{% for a in (1..100) %}x{% assign foo = 1 %} {% endfor %}")

test/integration/variable_test.rb

@@ -218,7 +218,7 @@ class VariableTest < Minitest::Test
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result('helloworld', template)
     end
   end
@@ -231,7 +231,7 @@ class VariableTest < Minitest::Test
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result('hello12', template)
     end
   end
@@ -244,7 +244,7 @@ class VariableTest < Minitest::Test
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result('TEST', template)
     end
   end
@@ -257,7 +257,7 @@ class VariableTest < Minitest::Test
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result('TESTX', template)
     end
   end
@@ -270,7 +270,7 @@ class VariableTest < Minitest::Test
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result('TESTX', template)
     end
   end

test/test_helper.rb

@@ -199,6 +199,26 @@ class ErrorDrop < Liquid::Drop
   end
 end
 
+class CustomToLiquidDrop < Liquid::Drop
+  def initialize(value)
+    @value = value
+    super()
+  end
+
+  def to_liquid
+    @value
+  end
+end
+
+class HashWithCustomToS < Hash
+  def to_s
+    "kewl"
+  end
+end
+
+class HashWithoutCustomToS < Hash
+end
+
 class StubFileSystem
   attr_reader :file_read_count
 

test/unit/condition_unit_test.rb

@@ -161,8 +161,8 @@ class ConditionUnitTest < Minitest::Test
       assert_equal(true, Condition.new(1, '==', 1).evaluate)
     end
 
-    expected = "DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated" \
-      " and will be removed from Liquid 6.0.0."
+    expected = "DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated " \
+      "and will be removed from Liquid 6.0.0."
     assert_includes(err.lines.map(&:strip), expected)
   end
 
@@ -176,19 +176,19 @@ class ConditionUnitTest < Minitest::Test
     assert_equal(['title'], result.lookups)
   end
 
-  def test_parse_expression_in_rigid_mode_raises_internal_error
-    environment = Environment.build(error_mode: :rigid)
+  def test_parse_expression_in_strict2_mode_raises_internal_error
+    environment = Environment.build(error_mode: :strict2)
     parse_context = ParseContext.new(environment: environment)
 
     error = assert_raises(Liquid::InternalError) do
       Condition.parse_expression(parse_context, 'product.title')
     end
 
-    assert_match(/unsafe parse_expression cannot be used in rigid mode/, error.message)
+    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
   end
 
-  def test_parse_expression_with_safe_true_in_rigid_mode
-    environment = Environment.build(error_mode: :rigid)
+  def test_parse_expression_with_safe_true_in_strict2_mode
+    environment = Environment.build(error_mode: :strict2)
     parse_context = ParseContext.new(environment: environment)
     result = Condition.parse_expression(parse_context, 'product.title', safe: true)
 
@@ -197,6 +197,172 @@ class ConditionUnitTest < Minitest::Test
     assert_equal(['title'], result.lookups)
   end
 
+  # Tests for blank? comparison without ActiveSupport
+  #
+  # Ruby's standard library does not include blank? on String, Array, Hash, etc.
+  # ActiveSupport adds blank? but Liquid must work without it. These tests verify
+  # that Liquid implements blank? semantics internally for use in templates like:
+  #   {% if x == blank %}...{% endif %}
+  #
+  # The blank? semantics match ActiveSupport's behavior:
+  # - nil and false are blank
+  # - Strings are blank if empty or contain only whitespace
+  # - Arrays and Hashes are blank if empty
+  # - true and numbers are never blank
+
+  def test_blank_with_whitespace_string
+    # Template authors expect "   " to be blank since it has no visible content.
+    # This matches ActiveSupport's String#blank? which returns true for whitespace-only strings.
+    @context['whitespace'] = '   '
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_true(VariableLookup.new('whitespace'), '==', blank_literal)
+  end
+
+  def test_blank_with_empty_string
+    # An empty string has no content, so it should be considered blank.
+    # This is the most basic case of a blank string.
+    @context['empty_string'] = ''
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_true(VariableLookup.new('empty_string'), '==', blank_literal)
+  end
+
+  def test_blank_with_empty_array
+    # Empty arrays have no elements, so they are blank.
+    # Useful for checking if a collection has items: {% if products == blank %}
+    @context['empty_array'] = []
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_true(VariableLookup.new('empty_array'), '==', blank_literal)
+  end
+
+  def test_blank_with_empty_hash
+    # Empty hashes have no key-value pairs, so they are blank.
+    # Useful for checking if settings/options exist: {% if settings == blank %}
+    @context['empty_hash'] = {}
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_true(VariableLookup.new('empty_hash'), '==', blank_literal)
+  end
+
+  def test_blank_with_nil
+    # nil represents "nothing" and is the canonical blank value.
+    # Unassigned variables resolve to nil, so this enables: {% if missing_var == blank %}
+    @context['nil_value'] = nil
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_true(VariableLookup.new('nil_value'), '==', blank_literal)
+  end
+
+  def test_blank_with_false
+    # false is considered blank to match ActiveSupport semantics.
+    # This allows {% if some_flag == blank %} to work when flag is false.
+    @context['false_value'] = false
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_true(VariableLookup.new('false_value'), '==', blank_literal)
+  end
+
+  def test_not_blank_with_true
+    # true is a definite value, not blank.
+    # Ensures {% if flag == blank %} works correctly for boolean flags.
+    @context['true_value'] = true
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_false(VariableLookup.new('true_value'), '==', blank_literal)
+  end
+
+  def test_not_blank_with_number
+    # Numbers (including zero) are never blank - they represent actual values.
+    # 0 is a valid quantity, not the absence of a value.
+    @context['number'] = 42
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_false(VariableLookup.new('number'), '==', blank_literal)
+  end
+
+  def test_not_blank_with_string_content
+    # A string with actual content is not blank.
+    # This is the expected behavior for most template string comparisons.
+    @context['string'] = 'hello'
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_false(VariableLookup.new('string'), '==', blank_literal)
+  end
+
+  def test_not_blank_with_non_empty_array
+    # An array with elements has content, so it's not blank.
+    # Enables patterns like {% unless products == blank %}Show products{% endunless %}
+    @context['array'] = [1, 2, 3]
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_false(VariableLookup.new('array'), '==', blank_literal)
+  end
+
+  def test_not_blank_with_non_empty_hash
+    # A hash with key-value pairs has content, so it's not blank.
+    # Useful for checking if configuration exists: {% if config != blank %}
+    @context['hash'] = { 'a' => 1 }
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
+
+    assert_evaluates_false(VariableLookup.new('hash'), '==', blank_literal)
+  end
+
+  # Tests for empty? comparison without ActiveSupport
+  #
+  # empty? is distinct from blank? - it only checks if a collection has zero elements.
+  # For strings, empty? checks length == 0, NOT whitespace content.
+  # Ruby's standard library has empty? on String, Array, and Hash, but Liquid
+  # provides a fallback implementation for consistency.
+
+  def test_empty_with_empty_string
+    # An empty string ("") has length 0, so it's empty.
+    # Different from blank - empty is a stricter check.
+    @context['empty_string'] = ''
+    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
+
+    assert_evaluates_true(VariableLookup.new('empty_string'), '==', empty_literal)
+  end
+
+  def test_empty_with_whitespace_string_not_empty
+    # Whitespace strings have length > 0, so they are NOT empty.
+    # This is the key difference between empty and blank:
+    # "   ".empty? => false, but "   ".blank? => true
+    @context['whitespace'] = '   '
+    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
+
+    assert_evaluates_false(VariableLookup.new('whitespace'), '==', empty_literal)
+  end
+
+  def test_empty_with_empty_array
+    # An array with no elements is empty.
+    # [].empty? => true
+    @context['empty_array'] = []
+    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
+
+    assert_evaluates_true(VariableLookup.new('empty_array'), '==', empty_literal)
+  end
+
+  def test_empty_with_empty_hash
+    # A hash with no key-value pairs is empty.
+    # {}.empty? => true
+    @context['empty_hash'] = {}
+    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
+
+    assert_evaluates_true(VariableLookup.new('empty_hash'), '==', empty_literal)
+  end
+
+  def test_nil_is_not_empty
+    # nil is NOT empty - empty? checks if a collection has zero elements.
+    # nil is not a collection, so it cannot be empty.
+    # This differs from blank: nil IS blank, but nil is NOT empty.
+    @context['nil_value'] = nil
+    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
+
+    assert_evaluates_false(VariableLookup.new('nil_value'), '==', empty_literal)
+  end
+
   private
 
   def assert_evaluates_true(left, op, right)

test/unit/parse_context_unit_test.rb

@@ -9,32 +9,32 @@ class ParseContextUnitTest < Minitest::Test
     parser_strict = strict_parse_context.new_parser('product.title')
     result_strict = strict_parse_context.safe_parse_expression(parser_strict)
 
-    parser_rigid = rigid_parse_context.new_parser('product.title')
-    result_rigid = rigid_parse_context.safe_parse_expression(parser_rigid)
+    parser_strict2 = strict2_parse_context.new_parser('product.title')
+    result_strict2 = strict2_parse_context.safe_parse_expression(parser_strict2)
 
     assert_instance_of(VariableLookup, result_strict)
     assert_equal('product', result_strict.name)
     assert_equal(['title'], result_strict.lookups)
 
-    assert_instance_of(VariableLookup, result_rigid)
-    assert_equal('product', result_rigid.name)
-    assert_equal(['title'], result_rigid.lookups)
+    assert_instance_of(VariableLookup, result_strict2)
+    assert_equal('product', result_strict2.name)
+    assert_equal(['title'], result_strict2.lookups)
   end
 
   def test_safe_parse_expression_raises_syntax_error_for_invalid_expression
     parser_strict = strict_parse_context.new_parser('')
-    parser_rigid = rigid_parse_context.new_parser('')
+    parser_strict2 = strict2_parse_context.new_parser('')
 
     error_strict = assert_raises(Liquid::SyntaxError) do
       strict_parse_context.safe_parse_expression(parser_strict)
     end
     assert_match(/is not a valid expression/, error_strict.message)
 
-    error_rigid = assert_raises(Liquid::SyntaxError) do
-      rigid_parse_context.safe_parse_expression(parser_rigid)
+    error_strict2 = assert_raises(Liquid::SyntaxError) do
+      strict2_parse_context.safe_parse_expression(parser_strict2)
     end
 
-    assert_match(/is not a valid expression/, error_rigid.message)
+    assert_match(/is not a valid expression/, error_strict2.message)
   end
 
   def test_parse_expression_with_variable_lookup
@@ -45,10 +45,10 @@ class ParseContextUnitTest < Minitest::Test
     assert_equal(['title'], result_strict.lookups)
 
     error = assert_raises(Liquid::InternalError) do
-      rigid_parse_context.parse_expression('product.title')
+      strict2_parse_context.parse_expression('product.title')
     end
 
-    assert_match(/unsafe parse_expression cannot be used in rigid mode/, error.message)
+    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
   end
 
   def test_parse_expression_with_safe_true
@@ -58,11 +58,11 @@ class ParseContextUnitTest < Minitest::Test
     assert_equal('product', result_strict.name)
     assert_equal(['title'], result_strict.lookups)
 
-    result_rigid = rigid_parse_context.parse_expression('product.title', safe: true)
+    result_strict2 = strict2_parse_context.parse_expression('product.title', safe: true)
 
-    assert_instance_of(VariableLookup, result_rigid)
-    assert_equal('product', result_rigid.name)
-    assert_equal(['title'], result_rigid.lookups)
+    assert_instance_of(VariableLookup, result_strict2)
+    assert_equal('product', result_strict2.name)
+    assert_equal(['title'], result_strict2.lookups)
   end
 
   def test_parse_expression_with_empty_string
@@ -70,40 +70,40 @@ class ParseContextUnitTest < Minitest::Test
     assert_nil(result_strict)
 
     error = assert_raises(Liquid::InternalError) do
-      rigid_parse_context.parse_expression('')
+      strict2_parse_context.parse_expression('')
     end
 
-    assert_match(/unsafe parse_expression cannot be used in rigid mode/, error.message)
+    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
   end
 
   def test_parse_expression_with_empty_string_and_safe_true
     result_strict = strict_parse_context.parse_expression('', safe: true)
     assert_nil(result_strict)
 
-    result_rigid = rigid_parse_context.parse_expression('', safe: true)
-    assert_nil(result_rigid)
+    result_strict2 = strict2_parse_context.parse_expression('', safe: true)
+    assert_nil(result_strict2)
   end
 
   def test_safe_parse_expression_advances_parser_pointer
-    parser = rigid_parse_context.new_parser('foo, bar')
+    parser = strict2_parse_context.new_parser('foo, bar')
 
     # safe_parse_expression consumes "foo"
-    first_result = rigid_parse_context.safe_parse_expression(parser)
+    first_result = strict2_parse_context.safe_parse_expression(parser)
     assert_instance_of(VariableLookup, first_result)
     assert_equal('foo', first_result.name)
 
     parser.consume(:comma)
 
     # safe_parse_expression consumes "bar"
-    second_result = rigid_parse_context.safe_parse_expression(parser)
+    second_result = strict2_parse_context.safe_parse_expression(parser)
     assert_instance_of(VariableLookup, second_result)
     assert_equal('bar', second_result.name)
 
     parser.consume(:end_of_string)
   end
 
-  def test_parse_expression_with_whitespace_in_rigid_mode
-    result = rigid_parse_context.parse_expression('   ', safe: true)
+  def test_parse_expression_with_whitespace_in_strict2_mode
+    result = strict2_parse_context.parse_expression('   ', safe: true)
     assert_nil(result)
   end
 
@@ -115,9 +115,9 @@ class ParseContextUnitTest < Minitest::Test
     )
   end
 
-  def rigid_parse_context
-    @rigid_parse_context ||= ParseContext.new(
-      environment: Environment.build(error_mode: :rigid),
+  def strict2_parse_context
+    @strict2_parse_context ||= ParseContext.new(
+      environment: Environment.build(error_mode: :strict2),
     )
   end
 end

test/unit/partial_cache_unit_test.rb

@@ -184,7 +184,7 @@ class PartialCacheUnitTest < Minitest::Test
       },
     )
 
-    [:lax, :warn, :strict, :rigid].each do |error_mode|
+    [:lax, :warn, :strict, :strict2].each do |error_mode|
       Liquid::PartialCache.load(
         'my_partial',
         context: context,
@@ -193,7 +193,7 @@ class PartialCacheUnitTest < Minitest::Test
     end
 
     assert_equal(
-      ["my_partial:lax", "my_partial:warn", "my_partial:strict", "my_partial:rigid"],
+      ["my_partial:lax", "my_partial:warn", "my_partial:strict", "my_partial:strict2"],
       context.registers[:cached_partials].keys,
     )
   end

test/unit/resource_limits_unit_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class ResourceLimitsUnitTest < Minitest::Test
+  def test_cumulative_scores_initialize_to_zero
+    limits = Liquid::ResourceLimits.new({})
+    assert_equal(0, limits.cumulative_render_score)
+    assert_equal(0, limits.cumulative_assign_score)
+  end
+
+  def test_cumulative_limits_default_to_nil
+    limits = Liquid::ResourceLimits.new({})
+    assert_nil(limits.cumulative_render_score_limit)
+    assert_nil(limits.cumulative_assign_score_limit)
+  end
+
+  def test_cumulative_limits_configurable_via_hash
+    limits = Liquid::ResourceLimits.new(
+      cumulative_render_score_limit: 500,
+      cumulative_assign_score_limit: 300,
+    )
+    assert_equal(500, limits.cumulative_render_score_limit)
+    assert_equal(300, limits.cumulative_assign_score_limit)
+  end
+
+  def test_cumulative_limits_configurable_via_accessor
+    limits = Liquid::ResourceLimits.new({})
+    limits.cumulative_render_score_limit = 500
+    assert_equal(500, limits.cumulative_render_score_limit)
+  end
+
+  def test_cumulative_scores_survive_reset
+    limits = Liquid::ResourceLimits.new({})
+    limits.increment_render_score(10)
+    limits.increment_assign_score(5)
+
+    limits.reset
+
+    assert_equal(0, limits.render_score)
+    assert_equal(0, limits.assign_score)
+    assert_equal(10, limits.cumulative_render_score)
+    assert_equal(5, limits.cumulative_assign_score)
+  end
+
+  def test_cumulative_scores_accumulate_across_resets
+    limits = Liquid::ResourceLimits.new({})
+    limits.increment_render_score(10)
+    limits.reset
+    limits.increment_render_score(20)
+    limits.reset
+    limits.increment_render_score(30)
+
+    assert_equal(30, limits.render_score)
+    assert_equal(60, limits.cumulative_render_score)
+  end
+
+  def test_cumulative_render_score_limit_raises
+    limits = Liquid::ResourceLimits.new(cumulative_render_score_limit: 25)
+    limits.increment_render_score(10)
+    limits.reset
+    limits.increment_render_score(10)
+    limits.reset
+
+    assert_raises(Liquid::MemoryError) do
+      limits.increment_render_score(10)
+    end
+    assert(limits.reached?)
+  end
+
+  def test_cumulative_assign_score_limit_raises
+    limits = Liquid::ResourceLimits.new(cumulative_assign_score_limit: 15)
+    limits.increment_assign_score(8)
+    limits.reset
+
+    assert_raises(Liquid::MemoryError) do
+      limits.increment_assign_score(8)
+    end
+    assert(limits.reached?)
+  end
+
+  def test_per_template_limits_still_work_with_cumulative
+    limits = Liquid::ResourceLimits.new(
+      render_score_limit: 50,
+      cumulative_render_score_limit: 1000,
+    )
+    assert_raises(Liquid::MemoryError) do
+      limits.increment_render_score(51)
+    end
+  end
+end

test/unit/strainer_template_unit_test.rb

@@ -8,7 +8,7 @@ class StrainerTemplateUnitTest < Minitest::Test
   def test_add_filter_when_wrong_filter_class
     c = Context.new
     s = c.strainer
-    wrong_filter = ->(v) { v.reverse }
+    wrong_filter = lambda(&:reverse)
 
     exception = assert_raises(TypeError) do
       s.class.add_filter(wrong_filter)

test/unit/tags/case_tag_unit_test.rb

@@ -24,7 +24,7 @@ class CaseTagUnitTest < Minitest::Test
       assert_template_result("one", template)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Expected end_of_string but found/, error.message)
@@ -45,7 +45,7 @@ class CaseTagUnitTest < Minitest::Test
       assert_template_result("one", template)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Expected end_of_string but found/, error.message)
@@ -62,7 +62,7 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_modes(:lax, :strict, :rigid) do
+    with_error_modes(:lax, :strict, :strict2) do
       assert_template_result("one", template)
     end
   end
@@ -77,11 +77,31 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_modes(:lax, :strict, :rigid) do
+    with_error_modes(:lax, :strict, :strict2) do
       assert_template_result("one", template)
     end
   end
 
+  def test_case_when_empty
+    template = <<~LIQUID
+      {%- case x -%}
+        {%- when 2 or empty -%}
+          2 or empty
+        {%- else -%}
+          not 2 or empty
+      {%- endcase -%}
+    LIQUID
+
+    with_error_modes(:lax, :strict, :strict2) do
+      assert_template_result("2 or empty", template, { 'x' => 2 })
+      assert_template_result("2 or empty", template, { 'x' => {} })
+      assert_template_result("2 or empty", template, { 'x' => [] })
+      assert_template_result("not 2 or empty", template, { 'x' => { 'a' => 'b' } })
+      assert_template_result("not 2 or empty", template, { 'x' => ['a'] })
+      assert_template_result("not 2 or empty", template, { 'x' => 4 })
+    end
+  end
+
   def test_case_with_invalid_expression
     template = <<~LIQUID
       {%- case foo=>bar -%}
@@ -97,7 +117,7 @@ class CaseTagUnitTest < Minitest::Test
       assert_template_result("one", template, assigns)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Unexpected character =/, error.message)
@@ -119,7 +139,7 @@ class CaseTagUnitTest < Minitest::Test
       assert_template_result("one", template, assigns)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Unexpected character =/, error.message)

test/unit/tokenizer_unit_test.rb

@@ -48,6 +48,33 @@ class TokenizerTest < Minitest::Test
     assert_equal(["{%%}", "}"], tokenize('{%%}}'))
   end
 
+  # Regression: lone '{' at or near end of string previously caused an infinite
+  # loop. The stray-{ else branch left `pos` unchanged when no further '{{' or
+  # '{%' existed, so the outer loop found the same '{' on every iteration.
+  def test_lone_brace_does_not_loop
+    assert_equal(["{"],              tokenize('{'))
+    assert_equal(["a{"],             tokenize('a{'))
+    assert_equal(["hello { world {"], tokenize('hello { world {'))
+    assert_equal(["{ world"],         tokenize('{ world'))
+    assert_equal(["x{y"],             tokenize('x{y'))
+    assert_equal(["{b{c"],            tokenize('{b{c'))
+  end
+
+  def test_lone_brace_before_real_token
+    assert_equal(
+      ["a { b ", "{% if x %}", "yes", "{% endif %}", " c"],
+      tokenize('a { b {% if x %}yes{% endif %} c'),
+    )
+    assert_equal(
+      ["x { ", "{{ var }}", " y"],
+      tokenize('x { {{ var }} y'),
+    )
+    assert_equal(
+      ["{ ", "{{ var }}"],
+      tokenize('{ {{ var }}'),
+    )
+  end
+
   private
 
   def new_tokenizer(source, parse_context: Liquid::ParseContext.new, start_line_number: nil)

test/unit/variable_fast_parse_test.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+# Tests that the fast-path parser (try_fast_parse) produces the same result as the
+# full Lexer → Parser pipeline for every input we expect it to handle.
+#
+# This protects against silent regressions where a change to try_fast_parse causes it
+# to produce different output from the slow path (the existing test suite would still
+# pass because the slow path catches it, but correctness would be silently lost).
+class VariableFastParseTest < Minitest::Test
+  include Liquid
+
+  EQUIVALENCE_CASES = [
+    # Simple lookups
+    "product",
+    "product.title",
+    "product.variants.first.title",
+    # Quoted string literals
+    "'hello'",
+    '"hello"',
+    # Variables with no-arg filters
+    "product | upcase",
+    "product | upcase | downcase",
+    "product | strip | upcase | downcase",
+    # Variables with single-arg filters
+    "product | truncate: 50",
+    "product | plus: 1",
+    "product | plus: -3",
+    "product | round: 2",
+    "product | append: ' world'",
+    # Variables with multi-arg filters
+    "product | replace: 'a', 'b'",
+    "product | pluralize: 'item', 'items'",
+    "product | slice: 0, 5",
+    # Chained mixed filters
+    "product.title | truncate: 50",
+    "'hello' | append: ' world' | upcase",
+    "name | prepend: 'Dr. ' | append: ' PhD' | upcase",
+    # Numeric args
+    "count | plus: 1.5",
+    "price | minus: 0.99",
+    # No whitespace around pipe
+    "x|upcase",
+    "x|replace:'a','b'|upcase",
+    # Leading/trailing whitespace
+    "  product  ",
+    "  product.title | upcase  ",
+  ].freeze
+
+  EQUIVALENCE_CASES.each_with_index do |markup, i|
+    define_method(:"test_fast_parse_equivalence_#{i.to_s.rjust(2, "0")}") do
+      lax_ctx    = Liquid::ParseContext.new(error_mode: :lax)
+      strict_ctx = Liquid::ParseContext.new(error_mode: :strict)
+
+      lax_var    = Liquid::Variable.new(markup, lax_ctx)
+      strict_var = Liquid::Variable.new(markup, strict_ctx)
+
+      assert_equal strict_var.name,
+        lax_var.name,
+        "Name mismatch for #{markup.inspect}: " \
+          "lax=#{lax_var.name.inspect} strict=#{strict_var.name.inspect}"
+      assert_equal strict_var.filters.length,
+        lax_var.filters.length,
+        "Filter count mismatch for #{markup.inspect}: " \
+          "lax=#{lax_var.filters.inspect} strict=#{strict_var.filters.inspect}"
+      strict_var.filters.each_with_index do |(s_name, *), i|
+        l_name = lax_var.filters[i][0]
+        assert_equal s_name,
+          l_name,
+          "Filter name mismatch at index #{i} for #{markup.inspect}"
+      end
+    end
+  end
+
+  # Verify the fast path is actually taken for simple variables (i.e. filters is the
+  # shared frozen EMPTY_ARRAY, not a newly allocated array).
+  def test_fast_path_taken_for_simple_variable
+    ctx = Liquid::ParseContext.new(error_mode: :lax)
+    var = Liquid::Variable.new("product.title", ctx)
+    assert_same(
+      Liquid::Const::EMPTY_ARRAY,
+      var.filters,
+      "Expected fast path (frozen EMPTY_ARRAY) for simple variable",
+    )
+  end
+
+  def test_fast_path_taken_for_no_arg_filter
+    ctx = Liquid::ParseContext.new(error_mode: :lax)
+    var = Liquid::Variable.new("product | upcase", ctx)
+    assert_equal(1, var.filters.length)
+    assert_equal("upcase", var.filters[0][0])
+    # The no-arg filter tuple should come from NO_ARG_FILTER_CACHE (frozen)
+    assert_predicate(var.filters[0], :frozen?)
+  end
+
+  def test_fast_path_taken_for_single_arg_filter
+    ctx = Liquid::ParseContext.new(error_mode: :lax)
+    var = Liquid::Variable.new("product | truncate: 50", ctx)
+    assert_equal(1, var.filters.length)
+    assert_equal("truncate", var.filters[0][0])
+    assert_equal([50], var.filters[0][1])
+  end
+
+  # Keyword args must fall through to the Lexer — verify the result is still correct.
+  def test_keyword_arg_falls_to_lexer_and_parses_correctly
+    ctx = Liquid::ParseContext.new(error_mode: :lax)
+    var = Liquid::Variable.new("img | img_tag: class: 'hero'", ctx)
+    assert_equal(1, var.filters.length)
+    assert_equal("img_tag", var.filters[0][0])
+  end
+
+  # Numeric filter arguments: integers and floats
+  def test_numeric_filter_args
+    ctx = Liquid::ParseContext.new(error_mode: :lax)
+
+    int_var = Liquid::Variable.new("price | plus: 3", ctx)
+    assert_equal([3], int_var.filters[0][1])
+
+    neg_var = Liquid::Variable.new("price | minus: -1", ctx)
+    assert_equal([-1], neg_var.filters[0][1])
+
+    float_var = Liquid::Variable.new("price | round: 2.5", ctx)
+    assert_equal([2.5], float_var.filters[0][1])
+  end
+end

test/unit/variable_unit_test.rb

@@ -161,8 +161,8 @@ class VariableUnitTest < Minitest::Test
     end
   end
 
-  def test_rigid_filter_argument_parsing
-    with_error_modes(:rigid) do
+  def test_strict2_filter_argument_parsing
+    with_error_modes(:strict2) do
       # optional colon
       var = create_variable(%(n | f1 | f2:))
       assert_equal([['f1', []], ['f2', []]], var.filters)