ibex-runtime 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05a9f9e7cb92bb15ef6efbfb632e4d846a3b3f8c4eb2fbccba549001b5e970ab
-  data.tar.gz: d8c262daf2e6525c80bf475aaed6500ee28fc054c6ef6628d772ae337b6f6a12
+  metadata.gz: 6086c1dd68cc99d62aa03a04395e07790c29611e86aadf39a27380ed970517c3
+  data.tar.gz: 56653912d556177e7126e6075816d72f1183c86d1649e9c760466dd739874097
 SHA512:
-  metadata.gz: 20e654c2c2bac9452fa538a25918fd16475deb3bbd12a8491312709bc1623f7ac8f42381d3b191b061f244c617ca3b20c91528eda676d9ba3fe3f9af91c9dcc8
-  data.tar.gz: f69a58947420d425f9b6f957c680c16661272fb74f6bb9d3805584de74f66edb8ef141ee10c3eea7ab5fa84bb226101db63a14bd9e17f6c3690ed20c6374e46c
+  metadata.gz: acf1c8076df1e37169b4f8a4597cb4b9bb461b16b8878676032a558d3ba7cf6c7bcffda13e42d4eb6034d47b4cc8c1cfd8263b0b9af7f86429356a83e9a4eb22
+  data.tar.gz: 0be19823f4fd459cc60c9fe097d7b278ef2c92309858070aa0911e9032cd13250baa3ed6b9e23f00f85ce56ebbc569cdd655107ba61a50aa2f9511eef44d6a9f

data/README.md

@@ -1,71 +1,55 @@
 # Ibex
 
-[![Gem Version](https://badge.fury.io/rb/ibex.svg)](https://badge.fury.io/rb/ibex)
+[![Gem](https://badge.fury.io/rb/ibex.svg)](https://rubygems.org/gems/ibex)
 [![CI](https://github.com/ydah/ibex/actions/workflows/main.yml/badge.svg)](https://github.com/ydah/ibex/actions/workflows/main.yml)
+[![Docs](https://img.shields.io/badge/docs-GitHub%20Pages-4ade80)](https://ydah.github.io/ibex/)
+[![License](https://img.shields.io/badge/license-MIT-4ade80.svg)](LICENSE.txt)
 
 Ibex is a Pure Ruby LR parser generator. It reads racc-compatible grammar
 files, generates parsers with the familiar `do_parse` / `yyparse` API, and
-requires no C or Java extension.
-
-> [!IMPORTANT]
-> Ibex is pre-1.0. The current v1.0 decision is
-> [**HOLD**](docs/release-readiness.md): compatibility and scale evidence pass,
-> but cold generation and new-instance runtime still trail Racc's Ruby backend,
-> and the error UX evidence still needs independent review. Compatible mode is
-> the stable baseline; opt-in features have the maturity levels documented in
-> the [stability policy](docs/stability.md).
-
-- Try grammar analysis in the
-  [browser playground](https://ydah.github.io/ibex/playground/).
-- Start with the [grammar reference](docs/grammar-reference.md).
-- Build lossless and incremental tooling with the
-  [Red/Green CST guide](docs/cst.md).
-- Migrate an existing parser with the
-  [racc migration guide](docs/racc-migration.md).
-- Browse the [API reference](https://ydah.github.io/ibex/api/).
-
-The playground runs in a local Web Worker. It does not upload grammar source
-or execute semantic action bodies.
-
-## At a glance
-
-| Concern | Ibex default |
-| --- | --- |
-| Grammar input | racc-compatible `.y` source |
-| Construction | Direct LALR(1) |
-| Generated tables | Compact, immutable Ruby data |
-| Parser API | Pull parsing with `do_parse` / `yyparse` |
-| Generated dependency | The separately versioned `ibex-runtime` gem |
-| Ruby support | Ruby 3.0 or later |
-| Extensions | Disabled unless `pragma extended` or `--mode=extended` is used |
-| Concrete syntax | Stable format-v6 Red/Green CST with `pragma cst` |
-| Semantic actions | Opaque during generation and analysis; executed only by a running parser |
-
-The generator and runtime are deliberately separate:
+requires no native extension.
 
-```text
-grammar.y + lexer contract
-          |
-          v
-        ibex  -----> parser.rb --------> ibex-runtime
-          |
-          +--------> optional RBS, IR, reports, diagrams, and docs
-```
+The shortest path is the [Getting Started guide](https://ydah.github.io/ibex/getting-started/):
+install the gem, try the calculator grammar, and then choose the compatible or
+extended contract you need. You can also [inspect a grammar in the browser](https://ydah.github.io/ibex/playground/)
+without uploading its source.
+
+## Release status
 
-Use `-E` when a generated parser must embed the runtime instead of depending
-on `ibex-runtime`.
+Ibex is pre-1.0. The v1.0 publication decision is on hold pending an
+independent review of the published error-experience evidence; feature
+development continues. The default compatible mode and its current IR
+contracts are the conservative adoption baseline. See the [release status](https://ydah.github.io/ibex/project/status/)
+and [stability policy](docs/stability.md) for the human-readable boundaries.
 
-## Quick start from a checkout
+<!-- r001-review-status:start -->
+R001: `HOLD` — [`awaiting_independent_review`](docs/error-ux-review-status-v1.json).
+<!-- r001-review-status:end -->
 
-Clone the repository and install its locked development dependencies:
+<!-- type-stats:start -->
+The current whole-library `steep stats` result is 28,836 typed calls and 2,734 untyped calls out of 31,610 (91.2% typed).
+The generated signature tree contains 492 explicit `untyped` occurrences across 39 files.
+<!-- type-stats:end -->
+
+## Install
+
+Add the generator to an application or tool project:
 
 ```sh
-git clone https://github.com/ydah/ibex.git
-cd ibex
-bundle install
+gem install ibex
+# or, in a Gemfile:
+bundle add ibex
+```
+
+Applications that only run generated parsers can depend on the smaller runtime:
+
+```sh
+bundle add ibex-runtime
 ```
 
-Save this grammar as `calculator.y`:
+## First parser
+
+Save this as `calculator.y`:
 
 <!-- calculator-grammar:start -->
 ```text
@@ -97,241 +81,80 @@ end
 ```
 <!-- calculator-grammar:end -->
 
-Generate and run the parser without installing local gems:
-
-```sh
-bundle exec ruby -Ilib exe/ibex calculator.y
-bundle exec ruby -Ilib calculator.rb
-# 14
-```
-
-With the local gems installed, the equivalent commands are:
+Generate and run it:
 
 ```sh
-ibex calculator.y
+ibex -o calculator.rb calculator.y
 ruby calculator.rb
+# 14
 ```
 
-Ibex writes `calculator.rb`, uses compact tables, and generates a parser that
-requires `ibex-runtime`. Use `-o PATH` to choose the output, `--table=plain`
-for inspectable Hash rows, `--check` to compare without rewriting, or `-E` to
-embed the runtime.
-
-## Generated parser contract
-
-### Tokens and lexers
-
-A handwritten pull lexer implements `next_token` and returns:
-
-```ruby
-[token, value]
-[token, value, location]
-```
-
-`false` or `nil` marks EOF. Bare grammar tokens use Ruby symbols such as
-`:NUM`; quoted terminals use strings such as `'+'`. Locations are
-application-owned objects and remain optional.
-
-Existing lexers can use the [lexer migration guide](docs/lexer-migration.md).
-Extended grammars may instead generate a streaming lexer from declarative
-regular-expression rules.
-
-### Semantic actions and locations
-
-Actions read RHS values through `val`. `@1`, `@2`, and so on address parallel
-semantic locations, while `@$` is the span of the current reduction. Action
-source remains opaque Ruby: Ibex preserves its source mapping but does not
-parse, type-check, or sandbox it.
-
-### Parse lifecycles and errors
-
-Generated parsers support:
-
-- `do_parse` and yielding `yyparse` for racc-compatible pull parsing;
-- `push(token, value, location)` and `finish(location:)` for caller-driven
-  streaming;
-- structured `Ibex::ParseError` values containing the token, expected tokens,
-  state, location, and spelling suggestions;
-- yacc-style recovery through `on_error`, `yyerror`, `yyerrok`, and
-  `yyaccept`; and
-- immutable, shareable generated tables.
-
-Use one parser instance per concurrent parse. Isolated runtime sessions and
-resource budgets are opt-in when application code needs explicit execution
-boundaries.
+The generated parser uses compact immutable tables and depends on
+`ibex-runtime`. Use `-E` when a single self-contained generated file is more
+convenient. Use `--check` in CI to detect stale generated output.
 
-## Choose a grammar mode
+## Choose a contract
 
-| Mode | Use it for | Contract |
+| Surface | Use it for | Maturity |
 | --- | --- | --- |
-| `default` | Existing racc grammars and conservative migrations | Compatible syntax and runtime behavior |
-| `extended` | New grammars that need composition or generated tooling | Preview, explicitly enabled |
-
-Enable extended syntax with `pragma extended` in the grammar or
-`--mode=extended` on the command line:
-
-```text
-class ExtendedParser
-pragma extended
-token NUM KEY VALUE
-rule
-  arguments : separated_list(NUM, ',')
-  sum       : NUM:left '+' NUM:right { result = left + right }
-  maybe     : NUM?
-  many      : NUM*
-  groups    : (KEY VALUE)+
-  list(X)   : X | list(X) ',' X
-  %inline signed(X): '-' X { result = -val[1] }
-  negative  : signed(NUM)
-end
-```
-
-Extended mode includes nested EBNF groups, named references, parameterized and
-inline rules, multiple entry points, canonical fragment imports, generated
-lexers, CST or typed `Data` AST generation, declarative recovery, semantic
-types, and grammar-declared tests. These features do not silently change the
-default compatible frontend. Maturity is assigned per API: format-v6 batch
-Red/Green CST is Stable, while the wider extended grammar surface remains
-Preview and incremental CST sessions remain Experimental.
-
-## Choose a construction algorithm
-
-| Option | When to use it |
-| --- | --- |
-| `--algorithm=lalr` | Default direct LALR(1) construction |
-| `--algorithm=slr` | Grammars whose FOLLOW-set reductions are sufficient |
-| `--algorithm=ielr` | Preview backend for conflicts introduced by LALR state merging |
-| `--algorithm=lr1` | Canonical LR(1) analysis when the larger automaton is acceptable |
-
-`--suggest-ielr` checks whether IELR removes an unexpected LALR conflict and
-prints an advisory note when it does.
-That note does not change the selected algorithm or exit status.
-
-Conflict freedom is not the same as a proof of unambiguity. `ibex check
---ambiguity` searches for a concrete sentence with two interpretations, but
-the token and configuration budgets make every result explicitly bounded.
-
-## Integrate generation into a build
-
-Treat grammar source as the input and generated Ruby as a reproducible build
-artifact:
-
-```sh
-ibex --warnings=error -o lib/calculator.rb grammar/calculator.y
-ibex --warnings=error --check -o lib/calculator.rb grammar/calculator.y
-```
-
-The first command writes the parser. The second is suitable for CI and fails
-when the committed output is stale without modifying it.
-
-Rake projects can declare the dependency directly:
-
-```ruby
-require "ibex/rake_task"
-
-Ibex::RakeTask.new("lib/calculator.rb") do |task|
-  task.grammar = "grammar/calculator.y"
-  task.options = ["--warnings=error"]
-end
-```
-
-The task follows the grammar's fragment dependency closure. Multi-output
-generation can additionally publish a manifest containing input identities,
-output paths, sizes, and SHA-256 digests. Generation renders all requested
-outputs before publishing them; `--watch` retains the last successful output
-when a later edit is invalid.
-
-Applications that only execute generated parsers need `ibex-runtime`, not the
-generator. To build and install both current local gems:
-
-```sh
-gem build ibex-runtime.gemspec
-gem build ibex.gemspec
-gem install ./ibex-runtime-0.1.0.gem
-gem install ./ibex-0.1.0.gem
-```
-
-## Diagnose, verify, and inspect
-
-| Goal | Command |
-| --- | --- |
-| Promote grammar warnings to errors | `ibex --warnings=error -C grammar.y` |
-| Collect structured frontend diagnostics | `ibex diagnose --format=json grammar.y` |
-| Explain one conflict | `ibex explain --state=7 --token=ELSE grammar.y` |
-| Search for a concrete ambiguity | `ibex check --ambiguity --algorithm=lr1 grammar.y` |
-| Run grammar-declared tests | `ibex test --coverage=100 grammar.y` |
-| Check canonical formatting | `ibex fmt --check grammar.y` |
-| Render grammar documentation | `ibex doc --format=html -o grammar.html grammar.y` |
-| Emit Automaton IR | `ibex --emit=automaton-ir grammar.y > automaton.json` |
-| Simulate table behavior without actions | `ibex debug automaton.json NUMBER PLUS NUMBER` |
-| Check a racc migration | `ibex migrate-check grammar.y` |
-| Start the language server | `ibex lsp --stdio` |
-
-Grammar IR, Automaton IR, generated table formats, diagnostic JSON, runtime
-events, coverage, and manifests are versioned contracts. Reports can also be
-rendered as text, DOT, Mermaid, HTML, railroad SVG, samples, or conflict
-counterexamples.
-
-## Safety boundaries and non-goals
-
-- Frontend parsing, diagnosis, formatting, documentation, LSP, static
-  migration checks, IR validation, and table simulation do not execute
-  semantic actions or user-code sections.
-- Generated parsers, grammar-declared tests, and explicit migration harnesses
-  do execute application Ruby. They are not sandboxes.
-- Fragment imports are confined to the declared source root and reject
-  traversal, cycles, and symlink escapes.
-- Counterexample, ambiguity, sample, repair, and runtime-budget searches are
-  bounded. Exhausting a budget is distinct from finding no witness within it.
-- Ibex generates deterministic LR parsers. It does not provide GLR or
-  generalized ambiguity handling. Incremental CST sessions are syntax-only
-  and experimental.
-- racc compatibility is a migration surface, not a claim that every generated
-  parser is a byte-for-byte or adapter-free replacement.
-- Preview and experimental features may have weaker compatibility guarantees
-  than the default mode.
-
-## Documentation by task
-
-| When you need to... | Start here |
-| --- | --- |
-| Write a grammar or use the runtime | [Grammar reference](docs/grammar-reference.md) |
-| Build, edit, serialize, or incrementally update syntax trees | [Red/Green CST guide](docs/cst.md) and [migration guide](docs/cst-migration.md) |
-| Learn from executable grammars | [Examples](examples/README.md) |
-| Migrate from racc | [racc migration guide](docs/racc-migration.md) |
-| Adapt a handwritten lexer | [Lexer migration guide](docs/lexer-migration.md) |
-| Configure an editor or LSP client | [Editor setup](docs/editor-setup.md) |
-| Understand the pipeline, IR, algorithms, or tables | [Architecture](docs/architecture.md) |
-| Check API maturity and deprecation rules | [Stability policy](docs/stability.md) |
-| Evaluate readiness, performance, or error UX | [Release readiness](docs/release-readiness.md), [benchmarks](benchmark/README.md), and [error UX](docs/error-ux.md) |
-| Contribute or run every quality gate | [Development guide](docs/development.md) |
-| Review implementation decisions | [Architecture decision records](docs/decisions/README.md) |
-
-The published documentation separates the
-[compatibility contract](https://ydah.github.io/ibex/compatibility/),
-[opt-in extensions](https://ydah.github.io/ibex/extensions/), and
-[experimental surfaces](https://ydah.github.io/ibex/experimental/). The
-[grammar gallery](https://ydah.github.io/ibex/gallery/) contains executable
-examples whose declared tests reach complete production coverage.
+| Compatible mode | Existing racc grammars and conservative migrations | Stable baseline |
+| Extended mode | EBNF, imports, generated lexers, trees, types, and tooling | Preview; explicit opt-in |
+| Browser playground and incremental CST sessions | Local analysis and evaluation | Preview/Experimental; bounded |
+
+The default frontend remains unchanged unless a grammar opts into
+`pragma extended` or the command line uses `--mode=extended`. Read the
+[grammar reference](https://ydah.github.io/ibex/docs/grammar-reference/),
+[racc migration guide](https://ydah.github.io/ibex/docs/racc-migration/), and
+[maturity audit](https://ydah.github.io/ibex/docs/maturity/) before adopting a
+Preview or Experimental surface.
+
+IELR is also explicit: `--algorithm=ielr` uses the conservative partition
+strategy by default, while `--ielr-strategy=direct` enables the experimental
+LR(0)-based construction. Direct IELR is profiled and reviewable, but it is not
+the default release strategy; see the [IELR guide](docs/ielr.md).
+
+## Trust boundary
+
+Static frontend, formatting, documentation, LSP, IR, verification, and
+browser analysis treat grammar actions and user sections as opaque source.
+Generated parsers and semantic parses execute application Ruby and are not
+sandboxes. The playground runs in a local Web Worker, does not upload grammar
+source, and never executes parser actions or user-code sections. Its limits and
+non-goals are documented in the [playground guide](https://ydah.github.io/ibex/playground/).
+
+## Where to go next
+
+- [Documentation hub](https://ydah.github.io/ibex/docs/) — task-oriented entry points.
+- [Grammar gallery](https://ydah.github.io/ibex/gallery/) — executable examples with declared tests.
+- [API reference](https://ydah.github.io/ibex/api/) — generated Ruby API documentation.
+- [Configuration model](https://ydah.github.io/ibex/docs/configuration-model/) — grammar-owned and invocation-owned settings.
+- [Project status and evidence](https://ydah.github.io/ibex/project/) — release, roadmap, and bounded claims.
+- [Contributing](CONTRIBUTING.md) and [security reporting](SECURITY.md) — community workflow.
 
 ## Development
 
-The [development guide](docs/development.md) contains frontend regeneration,
-RBS/Steep validation, grammar coverage, browser checks, mutation analysis, and
-workflow lint commands. The default local gate is:
+Clone the repository only when you need to contribute or run the complete
+quality suite:
 
 ```sh
+git clone https://github.com/ydah/ibex.git
+cd ibex
 bundle install
 bundle exec rake
+npm ci
+npm run test:site
 ```
 
-<!-- type-stats:start -->
-The current whole-library `steep stats` result is 20,629 typed calls and 2,275 untyped calls out of 22,904 (90.1% typed).
-The generated signature tree contains 2,084 explicit `untyped` occurrences across 103 files.
-<!-- type-stats:end -->
+The [development guide](https://ydah.github.io/ibex/docs/development/) lists
+the focused frontend, type, evidence, browser, and workflow checks.
+
+## Decisions and evidence
 
-Performance measurements are evidence, not portable scores or CI timing
-thresholds. Follow the [benchmark guide](benchmark/README.md) to reproduce and
-compare results under the same environment and configuration.
+The public reference also indexes the [direct IELR decision](docs/direct-ielr-decision.md),
+[direct multi-entry decision](docs/direct-multi-entry-decision.md),
+[verifier trust boundary](docs/verifier-trust-boundary.md), and the
+[error-experience review status](docs/error-ux-review-status-v1.json). These
+records scope claims to their evidence and revision; they do not change the
+compatible installation path above.
 
 Ibex is available under the [MIT License](LICENSE.txt).

data/lib/ibex/runtime/cst/green/node.rb

@@ -53,7 +53,7 @@ module Ibex
           source
         end
 
-        # @rbs (untyped other) -> bool
+        # @rbs (Object? other) -> bool
         def ==(other)
           other.is_a?(GreenNode) && @kind == other.kind && @intrinsic_flags == other.intrinsic_flags &&
             @annotations == other.annotations && @children == other.children

data/lib/ibex/runtime/cst/green/token.rb

@@ -66,7 +66,7 @@ module Ibex
           source
         end
 
-        # @rbs (untyped other) -> bool
+        # @rbs (Object? other) -> bool
         def ==(other)
           other.is_a?(GreenToken) &&
             @kind == other.kind &&

data/lib/ibex/runtime/cst/green/trivia.rb

@@ -23,7 +23,7 @@ module Ibex
         # @rbs () -> String
         def to_source = @text
 
-        # @rbs (untyped other) -> bool
+        # @rbs (Object? other) -> bool
         def ==(other)
           other.is_a?(GreenTrivia) && @kind == other.kind && @text == other.text
         end

data/lib/ibex/runtime/cst/incremental/blender.rb

@@ -75,7 +75,7 @@ module Ibex
         end
 
         # Return the next token or a whole nonterminal valid in the current LR state.
-        # @rbs (Integer state) -> (Array[untyped] | ReusableSubtree | false)
+        # @rbs (Integer state) -> (Array[Object?] | ReusableSubtree | false)
         def next_for_state(state)
           candidates = @candidates[@token_index]
           candidate = candidates&.find { |item| item.entry.left_state == state }

data/lib/ibex/runtime/cst/incremental/lexed_syntax.rb

@@ -6,10 +6,10 @@ module Ibex
     module CST
       # One complete generated-lexer pass, including the explicit EOF token.
       class LexedSyntax
-        attr_reader :raw_tokens #: Array[Array[untyped]]
+        attr_reader :raw_tokens #: Array[Array[Object?]]
         attr_reader :memo #: TokenMemo
 
-        # @rbs (raw_tokens: Array[Array[untyped]], memo: TokenMemo) -> void
+        # @rbs (raw_tokens: Array[Array[Object?]], memo: TokenMemo) -> void
         def initialize(raw_tokens:, memo:)
           raise ArgumentError, "raw and Green token counts differ" unless raw_tokens.length == memo.tokens.length
 

data/lib/ibex/runtime/cst/incremental/parse_memo.rb

@@ -39,7 +39,7 @@ module Ibex
           raise IndexError, "parse memo subtree range is outside the preorder state array"
         end
 
-        # @rbs (Hash[Symbol, untyped] tables) -> bool
+        # @rbs (Hash[Symbol, String | Integer] tables) -> bool
         def compatible?(tables)
           @grammar_digest == tables[:grammar_digest] &&
             @state_count == tables[:state_count] &&
@@ -49,7 +49,7 @@ module Ibex
         # @rbs () -> Integer
         def estimated_bytes = @left_states.length * ENTRY_BYTES
 
-        # @rbs () -> Hash[String, untyped]
+        # @rbs () -> Hash[String, Integer | Array[Integer?]]
         def to_h
           { "version" => VERSION, "left_states" => @left_states }.freeze
         end

data/lib/ibex/runtime/cst/incremental/relexer.rb

@@ -123,6 +123,9 @@ module Ibex
 
         # @rbs (TokenMemo previous, Integer old_index, TokenMemo current, Integer new_index) -> bool
         def self.reusable_token?(previous, old_index, current, new_index)
+          return false unless old_index.between?(0, previous.tokens.length - 1)
+          return false unless new_index.between?(0, current.tokens.length - 1)
+
           previous.states.fetch(old_index) == current.states.fetch(new_index) &&
             previous.tokens.fetch(old_index) == current.tokens.fetch(new_index)
         end

data/lib/ibex/runtime/cst/incremental/session.rb

@@ -22,8 +22,9 @@ module Ibex
         # @rbs @blender_enabled: bool
         # @rbs @mutex: Mutex
 
-        # @rbs (Class parser_class, SourceText source_text, ?resource_limits: ResourceLimits?, ?blender: bool) -> void
-        def initialize(parser_class, source_text, resource_limits: nil, blender: true)
+        # @rbs (Class parser_class, SourceText source_text, ?resource_limits: ResourceLimits?,
+        #   ?blender: bool, ?event_observer: Proc?) -> void
+        def initialize(parser_class, source_text, resource_limits: nil, blender: true, event_observer: nil)
           unless source_text.is_a?(SourceText)
             raise ArgumentError, "incremental_session requires an Ibex::Runtime::CST::SourceText"
           end
@@ -31,10 +32,12 @@ module Ibex
           @resource_limits = resource_limits || ResourceLimits.new #: ResourceLimits
           @parser = parser_class.__send__(:new, resource_limits: @resource_limits) #: Parser
           validate_parser!
+          @parser.observe { |event| event_observer.call(event, @parser) } if event_observer
           @cache = NodeCache.new #: NodeCache
           @source_text = source_text
           @last_relex_result = nil #: RelexResult?
           @last_blender = nil #: Blender?
+          @last_full_fallback = false #: bool
           @blender_enabled = blender
           @mutex = Mutex.new
           @result, @token_memo, @parse_memo = parse_current(0.0)
@@ -58,15 +61,25 @@ module Ibex
           @parser.unobserve(subscription)
         end
 
+        # Whether the last completed edit discarded all incremental reuse and
+        # reparsed the current source from a fresh token stream.
+        # @rbs () -> bool
+        def last_full_fallback? = @last_full_fallback
+
         private
 
         # @rbs (Array[TextEdit] edits) -> SyntaxResult
         def edit_locked(edits)
           return @result if edits.empty?
 
+          previous_source = @source_text
           previous_memo = @token_memo
           previous_root = @result.syntax_root
           previous_parse_memo = @parse_memo
+          previous_result = @result
+          previous_relex_result = @last_relex_result
+          previous_blender = @last_blender
+          previous_full_fallback = @last_full_fallback
           @source_text = @source_text.apply(edits)
           lexed = scan_current
           return finish_full_fallback(previous_memo, edits, :lexical_error) unless lexed
@@ -74,6 +87,15 @@ module Ibex
           relexed = Relexer.reconcile(previous_memo, lexed.memo, edits)
           blender = build_blender(previous_root, previous_parse_memo, lexed.with_memo(relexed.memo), edits)
           finish_blended_edit(relexed, blender)
+        rescue StandardError
+          @source_text = previous_source
+          @token_memo = previous_memo
+          @parse_memo = previous_parse_memo
+          @result = previous_result
+          @last_relex_result = previous_relex_result
+          @last_blender = previous_blender
+          @last_full_fallback = previous_full_fallback
+          raise
         end
 
         # @rbs () -> LexedSyntax?
@@ -99,6 +121,7 @@ module Ibex
         def finish_blended_edit(relexed, blender)
           @last_relex_result = relexed
           @last_blender = blender
+          @last_full_fallback = false
           parsed = @parser.__send__(:parse_syntax_token_source, blender, @cache)
           reused_ratio = blender_reused_ratio(blender, parsed.syntax_root.green, relexed)
           @token_memo = relexed.memo
@@ -197,6 +220,7 @@ module Ibex
           fresh_result, fresh_memo, fresh_parse_memo = parse_current(0.0)
           @last_relex_result = Relexer.reconcile(previous_memo, fresh_memo, edits)
           @last_blender = nil
+          @last_full_fallback = true
           @token_memo = fresh_memo
           @parse_memo = fresh_parse_memo
           @result = fresh_result

data/lib/ibex/runtime/cst/parse_result.rb

@@ -6,11 +6,11 @@ module Ibex
     module CST
       # Immutable result returned by syntax-aware parser entry points.
       class ParseResult
-        attr_reader :value #: untyped
+        attr_reader :value #: Object
         attr_reader :syntax_root #: SyntaxNode
-        attr_reader :diagnostics #: Array[untyped]
+        attr_reader :diagnostics #: Array[Object]
 
-        # @rbs (value: untyped, syntax_root: SyntaxNode, diagnostics: Array[untyped]) -> void
+        # @rbs (value: Object, syntax_root: SyntaxNode, diagnostics: Array[Object]) -> void
         def initialize(value:, syntax_root:, diagnostics:)
           @value = value
           @syntax_root = syntax_root
@@ -22,10 +22,10 @@ module Ibex
       # Syntax-only result used by incremental sessions.
       class SyntaxResult
         attr_reader :syntax_root #: SyntaxNode
-        attr_reader :diagnostics #: Array[untyped]
+        attr_reader :diagnostics #: Array[Object]
         attr_reader :reused_ratio #: Float
 
-        # @rbs (syntax_root: SyntaxNode, diagnostics: Array[untyped], reused_ratio: Float) -> void
+        # @rbs (syntax_root: SyntaxNode, diagnostics: Array[Object], reused_ratio: Float) -> void
         def initialize(syntax_root:, diagnostics:, reused_ratio:)
           @syntax_root = syntax_root
           @diagnostics = diagnostics.dup.freeze
@@ -35,7 +35,7 @@ module Ibex
       end
     end
 
-    ParseResult = CST::ParseResult
-    SyntaxResult = CST::SyntaxResult
+    ParseResult = CST::ParseResult #: singleton(CST::ParseResult)
+    SyntaxResult = CST::SyntaxResult #: singleton(CST::SyntaxResult)
   end
 end