parsanol 1.3.115-aarch64-linux → 1.3.117-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4aae98fea1484f36f4dd03d57f8c2886262b8c81da3f452f47d5ff24bf2abd9a
-  data.tar.gz: 292ecec720a1458bc6b3aa4afcc2d3c2fc52a78b21eabee136cb47e14e9401be
+  metadata.gz: c3b437c6c7e0fb3a4455f0fdf304f0dac6168efcb7865c4d6fb36d5501105c80
+  data.tar.gz: 8f56aa483c8456e148a7453fe7843ec265b1ca1862ded288709a05ab97631400
 SHA512:
-  metadata.gz: 8f0725e8ff8a40a8c28aea7b8391a32ae3ac8600d4d1a1bf76fdd79ff5904adbaa12391d79e5e3e05321fed5fa17ee495861b7dbb3df46fd5f87e9efe15850fd
-  data.tar.gz: 752eb2a0233d01d21c7f8ec5ea88c583cdb26a4bce5a733aed9127c9bed593a07e5aef8e5b6ab7f040576579fa2e459861b4c21ecf2c513107c0ffcf6d70f919
+  metadata.gz: f11d4e285d3c83f31055bc2ac4d93ef6465d5c04f6eacedc8cc3e8047610d39b9b9137014a5522aad5f852072fec1f9e36f5352225820b87bff71d2fb071a68b
+  data.tar.gz: 25792217f32bb607978c22934e0fa8ccbb36d2cc0dfe9f8cd2c0cb5b35ef345f45a82d61f70f24b826b0b4b53e977ee7734ed2e6362508067fa61660121b6209

data/lib/parsanol/3.2/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.2/parsanol_native.so
-size: 46227560 bytes
-sha256: e2dd08164de84a67d1770657ccd6f8f2f10fa9be5975dfb0988661b3f49ca30e
+size: 46565312 bytes
+sha256: 3f157f1fa0af1004087c94c804cf9c4344085a1b50d67cd2eda349a36e697551

data/lib/parsanol/3.3/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.3/parsanol_native.so
-size: 46462584 bytes
-sha256: b00af7c8832169886f8f0f8ce6ec603151cc7c4a1aaaa1bb0de13f8cbed42c8a
+size: 46804488 bytes
+sha256: d3e84e55f95334893a64bb4a4643f85f8b7e717d47039b29be4c7e0b8bf62bf8

data/lib/parsanol/3.4/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.4/parsanol_native.so
-size: 46458256 bytes
-sha256: 33a5ee4a0819820fbde7cc0b5d9042aed3c7da353db9ac35ffd6c2a8e8b3aa61
+size: 46808544 bytes
+sha256: a0ebea5baf40f9e711bc83813866d20faf5e992ff8de3961db483afa69840b13

data/lib/parsanol/4.0/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/4.0/parsanol_native.so
-size: 46468248 bytes
-sha256: 402168ae3b00c8489f050c5dfbc30ce21eb702c2d363df14a2a182a86a8c94b6
+size: 46818520 bytes
+sha256: 2294a40d16a8f3586ee711363bc493171be5615f7fb2091d5bb3e7c0108d11f8

data/lib/parsanol/atoms/alternative.rb

@@ -117,7 +117,9 @@ module Parsanol
         # The reporting pass (the re-parse after a failure) must try every
         # branch so the failure cause tree stays complete; the literal index
         # only prunes the fast non-reporting pass.
-        unless context.reporting?
+        # Legacy memo answers depend on attempted branches, including a
+        # prefix success in a branch that later fails its literal suffix.
+        unless context.reporting? || context.parslet_compatible?
           indexed = candidate_indexes(source)
           if indexed
             return try_selected(indexed, options, source, context, consume_all)

data/lib/parsanol/atoms/base.rb

@@ -27,17 +27,27 @@ module Parsanol
       # @param options [Hash] parsing options
       # @option options [Parsanol::ErrorReporter] :reporter error collector
       # @option options [Boolean] :prefix allow partial parse (default: false)
+      # @option options [Symbol] :compatibility :strict (default), or :parslet
+      #   for legacy consume-all memo decisions on the Ruby interpreter
       # @return [Object] the parsed result
       # @raise [Parsanol::ParseFailed] on parse failure
       def parse(source, options = {})
         must_consume_all = !options[:prefix]
+        compatibility = options.fetch(:compatibility, :strict)
+        unless %i[strict parslet].include?(compatibility)
+          raise ArgumentError, "Unknown compatibility policy: #{compatibility}"
+        end
+
+        context_options = compatibility == :strict ? {} : { compatibility: compatibility }
 
         # Compiled-VM fast path: String input, full-consumption semantics.
         # On failure (or unsupported grammar / budget exhaustion) fall
         # through to the interpreter, which also produces the exact
         # cause-tree diagnostics. run_for memoizes heavy-backtracking
         # grammars transparently.
-        if must_consume_all && source.is_a?(String) &&
+        # The VM implements strict memo semantics. The opt-in legacy policy
+        # is currently supported by the Ruby interpreter only.
+        if compatibility == :strict && must_consume_all && source.is_a?(String) &&
             (program = VM.program_for(self))
           begin
             result = VM.run_for(self, program, source, true)
@@ -62,12 +72,12 @@ module Parsanol
         input = normalize_input(source)
 
         # Initial parse attempt (no error collection)
-        success, value = run_with_context(input, nil, must_consume_all)
+        success, value = run_with_context(input, nil, must_consume_all, **context_options)
         return finalize_result(value) if success
 
         # Reparse with error reporting for diagnostics
         report_detailed_error(input, must_consume_all, options[:reporter],
-                              value)
+                              value, **context_options)
       end
 
       # Creates a new parsing context and executes the atom.
@@ -76,10 +86,11 @@ module Parsanol
       # @param reporter [Object, nil] error reporter
       # @param consume_all [Boolean] require complete consumption
       # @return [Array(Boolean, Object)] outcome tuple
-      def run_with_context(input, reporter, consume_all)
+      def run_with_context(input, reporter, consume_all, compatibility: :strict)
         parser_class = detect_parser_class
         context = Parsanol::Atoms::Context.new(reporter,
-                                               parser_class: parser_class)
+                                               parser_class: parser_class,
+                                               compatibility: compatibility)
         apply(input, context, consume_all)
       end
 
@@ -242,10 +253,12 @@ module Parsanol
       # consumer's file:line:col degrades to "line 1 char 1" when the
       # interpreter raises the outermost sequence instead. Explicit
       # reporters (Tree for full cause trees) are honored unchanged.
-      def report_detailed_error(input, consume_all, reporter, _initial_error)
+      def report_detailed_error(input, consume_all, reporter, _initial_error, compatibility: :strict)
         input.bytepos = 0
-        error_reporter = reporter || Parsanol::ErrorReporter::Deepest.new
-        success, cause = run_with_context(input, error_reporter, consume_all)
+        error_reporter = reporter ||
+          (compatibility == :parslet ? Parsanol::ErrorReporter::Tree.new : Parsanol::ErrorReporter::Deepest.new)
+        context_options = compatibility == :strict ? {} : { compatibility: compatibility }
+        success, cause = run_with_context(input, error_reporter, consume_all, **context_options)
 
         # Second parse should also fail
         raise "Invariant violation: parse succeeded during error reporting" if success

data/lib/parsanol/atoms/context.rb

@@ -44,11 +44,24 @@ module Parsanol
       # @param interval_cache: [Boolean] enable GPeg-style interval caching
       # @param adaptive_cache_threshold: [Integer, nil] minimum input size for caching
       # @param parser_class: [Class, nil] parser class for threshold selection
+      # @param compatibility: [Symbol] :strict or opt-in :parslet. Legacy
+      #   decisions use eager, parse-lifetime memo entries; mutable capture
+      #   and dynamic evaluations still retain their cache barriers.
       #
       def initialize(error_reporter = Parsanol::ErrorReporter::Tree.new,
                      interval_cache: false,
                      adaptive_cache_threshold: nil,
-                     parser_class: nil)
+                     parser_class: nil,
+                     compatibility: :strict)
+        unless %i[strict parslet].include?(compatibility)
+          raise ArgumentError, "Unknown compatibility policy: #{compatibility}"
+        end
+
+        @parslet_compatibility = compatibility == :parslet
+        if @parslet_compatibility && interval_cache
+          raise NotImplementedError, "Parslet compatibility does not yet support interval caching"
+        end
+
         # Core memoization cache: position -> { atom_id -> [result, advance] }
         # Auto-vivifying sub-hashes: a probe-phase position can reach the
         # active-path lookup before any entry exists at that position
@@ -84,11 +97,6 @@ module Parsanol
         @array_pool = Parsanol::Pools::ArrayPool.new(size: 10_000, preallocate: false)
         @buffer_pool = Parsanol::Pools::BufferPool.new(pool_size: 100)
 
-        # Selective memoization tracking
-        @hit_stats = Hash.new(0)
-        @miss_stats = Hash.new(0)
-        @min_hits_for_cache = 2
-
         # Optional GPeg-style interval caching
         @use_intervals = interval_cache
         if @use_intervals
@@ -117,7 +125,7 @@ module Parsanol
 
         @adaptive_threshold = threshold
         @input_len = nil
-        @caching_active = false
+        @caching_active = @parslet_compatibility
         @backtrack_events = 0
 
         # Monotonic counter of cache-unsafe events (dynamic-atom evaluations
@@ -132,6 +140,10 @@ module Parsanol
       # @return [Integer] monotonic count of cache-unsafe events so far
       attr_reader :cache_unsafe_events
 
+      def parslet_compatible?
+        @parslet_compatibility
+      end
+
       # Records that mutable parse state was read or written (dynamic atom
       # evaluated, capture stored). Called by atoms; results computed across
       # such events are excluded from memoization.
@@ -152,7 +164,11 @@ module Parsanol
       #
       def try_with_cache(atom, src, must_consume_all)
         # Skip caching for atoms that don't benefit from it
-        return atom.try(src, self, must_consume_all) unless atom.cached?
+        legacy_pure = @parslet_compatibility &&
+          (atom.instance_of?(Parsanol::Atoms::Entity) ||
+           atom.instance_of?(Parsanol::Atoms::Str) || atom.instance_of?(Parsanol::Atoms::Re))
+        cacheable = atom.cached? || legacy_pure
+        return atom.try(src, self, must_consume_all) unless cacheable
 
         # Use interval-based caching if enabled
         return try_with_interval(atom, src, must_consume_all) if @use_intervals
@@ -171,7 +187,9 @@ module Parsanol
           @furthest_pos = pos
           @evict_counter += 1
 
-          if @evict_counter >= @evict_interval
+          # Legacy prefix decisions remain observable on later backtracking;
+          # retain them for this parse rather than silently re-evaluating.
+          if !@parslet_compatibility && @evict_counter >= @evict_interval
             @evict_counter = 0
             cutoff = pos - @evict_threshold
             @memo.delete_if { |p, _| p < cutoff }
@@ -182,26 +200,21 @@ module Parsanol
         # prefix-success fallback for ordered choice)
         cached_key = cached_entry_key(@memo[pos], atom, must_consume_all)
         if cached_key
-          @hit_stats[cached_key] += 1
           outcome, delta = @memo[pos][cached_key]
           src.bytepos = pos + delta
           return outcome
         end
 
         # Cache miss - execute and store
-        @miss_stats[key] += 1
         unsafe_before = @cache_unsafe_events
         outcome = atom.try(src, self, must_consume_all)
         delta = src.bytepos - pos
 
-        # Never store results spanning cache-unsafe events (dynamic
-        # blocks, capture writes); keep the beneficial-attempts
-        # heuristic to avoid one-shot memo pollution.
-        if storable_outcome?(key, outcome, unsafe_before)
-          attempts = @hit_stats[key] + @miss_stats[key]
-          if attempts <= @min_hits_for_cache || @hit_stats[key].positive?
-            (@memo[pos] ||= {})[key] = [outcome, delta]
-          end
+        # Once backtracking activates memoization, retain every safe answer.
+        # An atom-wide attempts limit suppresses its entries at later positions
+        # and can leave recursive alternatives with exponential repeated work.
+        if @cache_unsafe_events == unsafe_before
+          (@memo[pos] ||= {})[key] = [outcome, delta]
         end
 
         outcome
@@ -217,23 +230,21 @@ module Parsanol
       def try_with_interval(atom, src, must_consume_all)
         pos = src.bytepos
         key = scoped_cache_key(atom, must_consume_all)
-        cached_key, cached = cached_interval_entry(atom, pos,
-                                                   must_consume_all)
+        _cached_key, cached = cached_interval_entry(atom, pos,
+                                                    must_consume_all)
 
         if cached
-          @hit_stats[cached_key] += 1
           outcome, delta = cached
           src.bytepos = pos + delta
           return outcome
         end
 
-        @miss_stats[key] += 1
         unsafe_before = @cache_unsafe_events
         outcome = atom.try(src, self, must_consume_all)
         delta = src.bytepos - pos
         end_pos = pos + delta
 
-        if storable_outcome?(key, outcome, unsafe_before)
+        if @cache_unsafe_events == unsafe_before
           @interval_trees[key].insert(pos, end_pos, [outcome, delta])
         end
 
@@ -533,6 +544,8 @@ module Parsanol
       end
 
       def scoped_cache_key(atom, must_consume_all)
+        return shared_cache_key(atom) if @parslet_compatibility
+
         must_consume_all ? strict_cache_key(atom) : shared_cache_key(atom)
       end
 
@@ -554,17 +567,6 @@ module Parsanol
         !must_consume_all && share_prefix_success_cache?(atom)
       end
 
-      # An outcome may be memoized only when no cache-unsafe event (dynamic
-      # evaluation, capture write) happened while computing it, and the
-      # attempts heuristic deems the entry worthwhile.
-      def storable_outcome?(key, outcome, unsafe_before)
-        return false unless @cache_unsafe_events == unsafe_before
-
-        outcome.first ||
-          @hit_stats[key] + @miss_stats[key] <= @min_hits_for_cache ||
-          @hit_stats[key].positive?
-      end
-
       def successful_prefix_entry?(entry)
         entry && entry[0].is_a?(Array) && entry[0].first == true
       end

data/lib/parsanol/atoms/repetition.rb

@@ -74,6 +74,8 @@ module Parsanol
       # @param consume_all [Boolean] require full consumption
       # @return [Array(Boolean, Object)] result
       def try(source, context, consume_all)
+        return try_compatible(source, context, consume_all) if context.parslet_compatible?
+
         # Check for tree memoization support
         if context.use_tree_memoization?
           return with_tree_cache(source, context, consume_all)
@@ -119,6 +121,37 @@ module Parsanol
         first
       end
 
+      # Legacy repetition checks all children as prefixes. A bounded success
+      # returns before the outer consume-all guard; an exhausted optional
+      # failure checks consume-all inside #try. Their raw memo answers differ.
+      def try_compatible(source, context, consume_all)
+        start_pos = source.bytepos
+        result = [@result_tag]
+        count = 0
+        failure = nil
+        loop do
+          previous = source.bytepos
+          success, value = @parslet.apply(source, context, false)
+          unless success
+            failure = value
+            source.bytepos = previous
+            break
+          end
+
+          count += 1
+          result << value
+          return ok(result) if @max && count >= @max
+          # Retain the current engine's protection against empty loops.
+          break if source.bytepos == previous
+        end
+        return context.err_at(self, source, min_error, start_pos, [failure]) if count < @min
+        if consume_all && source.chars_left.positive?
+          return context.err(self, source, @extra_error, [failure])
+        end
+
+        ok(result)
+      end
+
       # Optional match (0 or 1)
       def try_maybe(source, context, _consume_all)
         success, value = @parslet.apply(source, context, false)

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 41996048 bytes
-sha256: d133d437f480d85579247e97876a1a6072f7b25165a329906fb11882c0e1becb
+size: 42274720 bytes
+sha256: 2b4ed62ee2d5a06171575e2c61ecbbec68772143eb8350678b9b90e3a5f18bad

data/lib/parsanol/native/parser.rb

@@ -57,9 +57,9 @@ module Parsanol
         #
         # @param grammar [Parsanol::Atoms::Base] Ruby grammar or JSON string
         # @param input [String] Input string to parse
-        def parse(grammar, input)
+        def parse(grammar, input, **)
           # Delegate to Parsanol::Native.parse for consistency
-          Parsanol::Native.parse(grammar, input)
+          Parsanol::Native.parse(grammar, input, **)
         end
 
         # Parse input with a Ruby grammar, returning the parslet-shaped
@@ -84,8 +84,13 @@ module Parsanol
         # Resolve a Rust-side handle for the grammar, registering it once.
         # Per-call cost is the memoized structure-hash lookup plus one Hash
         # access — no JSON marshal, no re-hash inside Rust.
-        def grammar_handle(root_atom)
-          cache_key = grammar_cache_key(root_atom)
+        def grammar_handle(root_atom, compatibility: :strict)
+          root_atom = root_atom.root if root_atom.is_a?(::Parsanol::Parser)
+          legacy = compatibility == :parslet
+          # Legacy decisions depend on the exact shared-node graph. The
+          # strict structure hash deliberately omits repeated-node targets.
+          # Retaining the root in this bounded key also prevents id recycling.
+          cache_key = legacy ? [:parslet, root_atom] : grammar_cache_key(root_atom)
           handle = HANDLE_CACHE[cache_key]
           if handle
             # Refresh recency: reinsertion moves the entry to the end,
@@ -94,7 +99,8 @@ module Parsanol
             return handle
           end
 
-          handle = Native._register_grammar(grammar_json(root_atom))
+          json = legacy ? GrammarSerializer.serialize(root_atom) : grammar_json(root_atom)
+          handle = Native._register_grammar(json)
           HANDLE_CACHE[cache_key] = handle
           trim_caches
           handle

data/lib/parsanol/native.rb

@@ -58,9 +58,24 @@ module Parsanol
       #   result = Parsanol::Native.parse(str('hello').as(:greeting), "hello\nworld")
       #   result[:greeting].line_and_column  # => [1, 1]
       #
-      def parse(grammar, input)
+      def parse(grammar, input, compatibility: :strict)
+        unless %i[strict parslet].include?(compatibility)
+          raise ArgumentError, "Unknown compatibility policy: #{compatibility}"
+        end
         raise LoadError, "Native parser not available" unless available?
 
+        if compatibility == :parslet
+          unless Parser.extension_loaded? && respond_to?(:_parse_handle_with_compatibility)
+            raise NotImplementedError,
+                  "Native Parslet compatibility requires an extension with _parse_handle_with_compatibility"
+          end
+          if grammar.is_a?(String)
+            raise NotImplementedError, "Native Parslet compatibility requires grammar atoms, not JSON"
+          end
+
+          return parse_compatible_atom_grammar(grammar, input)
+        end
+
         # ffi-gem tier (JRuby/TruffleRuby/no-binary MRI): same contract,
         # batch-decoded results, single reporter-pass error fallback.
         return Ffi.parse(grammar, input) unless Parser.extension_loaded?
@@ -366,6 +381,35 @@ module Parsanol
         end
       end
 
+      # Compatibility failures are authoritative native refusals. Unlike the
+      # legacy strict helper, this path never reparses or accepts in Ruby.
+      def parse_compatible_atom_grammar(grammar, input)
+        handle = Parser.grammar_handle(grammar, compatibility: :parslet)
+        raw = begin
+          _parse_handle_with_compatibility(handle, input, "parslet")
+        rescue ArgumentError
+          Parser.invalidate_handle(handle)
+          begin
+            _parse_handle_with_compatibility(
+              Parser.grammar_handle(grammar, compatibility: :parslet), input, "parslet"
+            )
+          rescue RuntimeError => e
+            raise_compatible_parse_error(e, input)
+          end
+        rescue RuntimeError => e
+          raise_compatible_parse_error(e, input)
+        end
+        BatchDecoder.decode_and_flatten(raw, input, Parsanol::Slice)
+      end
+
+      def raise_compatible_parse_error(error, input)
+        message = error.message
+        position = message[NATIVE_POS_MARKER, 1].to_i
+        cause = Parsanol::Cause.new(message.sub(NATIVE_POS_MARKER, ""),
+                                    Parsanol::Source.new(input), position)
+        raise Parsanol::ParseFailed.new(cause.to_s, cause), cause: nil
+      end
+
       # Reference-walker path (TODO.sota/8 B1): the plain recursive
       # relation — no VM, no memo tables, no fused scans, no terminal
       # fast paths. Deliberately slow; the cross-engine differential

data/lib/parsanol/parg/artifact.rb

@@ -86,6 +86,12 @@ module Parsanol
 
       def compiler_version = envelope["compiler_version"]
 
+      # The behavior fingerprint (ruby#377): stable across producer
+      # metadata, so freshness gates can tell "re-baked by a newer
+      # compiler" from "the grammar changed". nil on artifacts baked
+      # before the field existed.
+      def semantics_hash = envelope["semantics_hash"]
+
       def fresh_against?(source_text)
         return false if source_hash.nil?
 

data/lib/parsanol/parg/bindings.rb

@@ -20,7 +20,7 @@ module Parsanol
           assign_scalar(out, artifact, binding, captures)
         end
         arrays.group_by { |binding| binding["path"].split("[]").first }.each do |prefix, group|
-          assign_array(out, artifact, prefix, group, captures)
+          assign_array(out, artifact, prefix, group, captures, shape)
         end
         out
       end
@@ -63,7 +63,32 @@ module Parsanol
         out[leaf_key(binding)] = finalize(artifact, binding, value)
       end
 
-      def assign_array(out, artifact, prefix, group, captures)
+      def assign_array(out, artifact, prefix, group, captures, shape = nil)
+        # Position-aware pairing (parsanol-ruby#381): when the shape
+        # nests the group's instances under the prefix key, each
+        # instance's subtree owns its captures — pairing by OCCURRENCE
+        # index landed a sparse capture (one that fires in only some
+        # instances) on the wrong instance. Per-instance collection
+        # fixes the pairing and is identical to the old flat pairing
+        # when every instance fires every capture. Captures outside
+        # any instance keep the legacy occurrence pairing.
+        instances = shape && group_instances(shape, prefix)
+        if instances
+          list = (out[prefix.to_sym] ||= [])
+          instances.each do |instance|
+            found = collect_captures(instance)
+            element = {}
+            group.each do |binding|
+              value = found[binding["capture"].to_sym].first
+              next if value.nil?
+
+              element[leaf_key(binding)] = finalize(artifact, binding, value)
+            end
+            list << element
+          end
+          return
+        end
+
         count = group.map { |binding| captures[binding["capture"].to_sym].length }.max || 0
         return if count.zero?
 
@@ -82,6 +107,27 @@ module Parsanol
         end
       end
 
+      # The `prefix[]` group's instance subtrees: the first array under
+      # a key naming the prefix, walked in collect_captures' BFS order.
+      # A repetition-root entry's shape IS the instances array (the wire
+      # has no key for it) — that is the fallback when no key matches.
+      def group_instances(shape, prefix)
+        queue = [shape]
+        until queue.empty?
+          node = queue.shift
+          case node
+          when Hash
+            node.each do |key, value|
+              return value if key.to_s == prefix && value.is_a?(Array)
+
+              queue << value if value.is_a?(Hash) || value.is_a?(Array)
+            end
+          when Array then queue.concat(node)
+          end
+        end
+        shape if shape.is_a?(Array) && shape.any?(Hash)
+      end
+
       def validate_path!(binding)
         path = binding["path"].to_s
         return unless path.include?(".") || path.include?("[")

data/lib/parsanol/parg/compiler.rb

@@ -32,6 +32,18 @@ module Parsanol
         "sha256:#{Digest::SHA256.hexdigest(JSON.generate(canonicalize(payload)))}"
       end
 
+      # Producer metadata: the checksum pins the exact producer, but the
+      # semantics hash (ruby#377) skips these fields so a re-bake by a
+      # newer compiler — or a different Ruby patch stamping
+      # unicode_tables — is byte-stable when the grammar's behavior is
+      # unchanged. Mirrors the cross-engine parity view.
+      SEMANTICS_EXCLUDED = %w[checksum compiler_version unicode_tables semantics_hash].freeze
+
+      def self.semantics_hash(envelope)
+        payload = envelope.except(*SEMANTICS_EXCLUDED)
+        "sha256:#{Digest::SHA256.hexdigest(JSON.generate(canonicalize(payload)))}"
+      end
+
       def self.canonicalize(obj)
         case obj
         when Hash then obj.sort.to_h.transform_values { |value| canonicalize(value) }
@@ -137,14 +149,24 @@ module Parsanol
 
         artifact = Artifact.from_json(JSON.generate(envelope), tables_dir: tables_dir)
         default = envelope["default_entry"] || artifact.entries.first
+        # `Native.available?` is true under either engine tier, but the
+        # JSON-grammar fast path rides the MRI C-API extension's
+        # `_parse_raw` — an ffi-cdylib install is available without it.
+        # Probe rather than assume (same doctrine as
+        # Native.reference_available?): without the C-API symbol the
+        # self-test runs through the artifact's own parse lane, which
+        # picks native-or-pure-Ruby honestly instead of raising
+        # NoMethodError mid-run.
+        json_capable = Native.respond_to?(:_parse_raw)
         grammars = {}
         tests.filter_map do |test|
           entry = test["entry"] || default
-          grammar_json = (grammars[entry] ||= JSON.generate(artifact.entry(entry)["grammar"]))
-          artifact.run_test_list(
-            [test],
-            parse_with: ->(input) { Native.parse_json_grammar(grammar_json, input) },
-          )
+          parse_with =
+            if json_capable
+              grammar_json = (grammars[entry] ||= JSON.generate(artifact.entry(entry)["grammar"]))
+              ->(input) { Native.parse_json_grammar(grammar_json, input) }
+            end
+          artifact.run_test_list([test], parse_with: parse_with)
         end.flatten
       end
 
@@ -1352,6 +1374,7 @@ module Parsanol
         envelope["customs"] = @document.customs unless @document.customs.empty?
         envelope["states"] = @document.states unless @document.states.empty?
         envelope["dynamic"] = true if @dynamic
+        envelope["semantics_hash"] = Compiler.semantics_hash(envelope)
         envelope["checksum"] = Compiler.checksum(envelope)
         envelope
       end

data/lib/parsanol/parg/parser.rb

@@ -571,11 +571,16 @@ module Parsanol
 
       def parse_postfixed
         sign, behind = parse_guard_sign
-        node = capture_postfix(parse_primary)
+        node = parse_primary
         if sign.nil?
-          node
+          capture_postfix(node)
         else
-          Node.new(:pred, sign, node, behind ? :behind : nil)
+          # The capture binds the GUARD, not the guarded primary
+          # (parsanol-ruby#380): `!digit as year` is `( !digit ) as
+          # year` — a capture inside the lookahead would never bind
+          # (a negated guard consumes nothing), so `as` must wrap the
+          # pred, matching the rep path's postfix order (ruby#197).
+          capture_postfix(Node.new(:pred, sign, node, behind ? :behind : nil))
         end
       end
 

data/lib/parsanol/parser.rb

@@ -176,6 +176,9 @@ module Parsanol
     # Options:
     # - :reporter - Custom error reporter instance
     # - :prefix - Allow partial matching (default: false)
+    # - :compatibility - :strict (default), or :parslet for legacy memo
+    #   decisions. Auto mode selects native when available; an older native
+    #   extension without the compatibility entrypoint raises unsupported.
     #
     # @return [Hash, Array, Parsanol::Slice] parsed result with position info
     # @raise [Parsanol::ParseFailed] when parsing fails
@@ -200,8 +203,22 @@ module Parsanol
       # parse(input, {mode: :ruby, ...}) is the same call shape a subclass
       # forwarding options via super produces; :mode must be honored
       # wherever it appears, or those callers silently get the native path.
-      mode = opts.delete(:mode) ||
-        (Parsanol::Native.available? && native_expressible? ? :native : :ruby)
+      compatibility = opts.fetch(:compatibility, :strict)
+      unless %i[strict parslet].include?(compatibility)
+        raise ArgumentError, "Unknown compatibility policy: #{compatibility}"
+      end
+
+      requested_mode = opts.delete(:mode)
+      mode = requested_mode ||
+        if compatibility == :parslet
+          Parsanol::Native.available? ? :native : :ruby
+        else
+          Parsanol::Native.available? && native_expressible? ? :native : :ruby
+        end
+      if compatibility == :parslet && mode == :json
+        raise NotImplementedError, "Parslet compatibility does not yet support JSON mode"
+      end
+
       case mode
       when :ruby
         super(input, opts)
@@ -291,6 +308,14 @@ module Parsanol
     # @return [Object] parse result with Slice objects for position info
     #
     def parse_native(input, opts)
+      if opts[:compatibility] == :parslet
+        if opts[:prefix]
+          raise NotImplementedError, "Native Parslet compatibility does not yet support prefix mode"
+        end
+
+        return Parsanol::Native.parse(root, input, compatibility: :parslet)
+      end
+
       unless Parsanol::Native.available?
         Parsanol::Atoms::Base.instance_method(:parse).bind_call(self, input,
                                                                 opts)

data/lib/parsanol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parsanol
-  VERSION = "1.3.115"
+  VERSION = "1.3.117"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.115
+  version: 1.3.117
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-29 00:00:00.000000000 Z
+date: 2026-10-31 00:00:00.000000000 Z
 dependencies: []
 description: A small Ruby library for constructing parsers in the PEG (Parsing Expression
   Grammar) fashion. Parsanol provides Parslet-compatible API with additional features