llguidance 1.1.2__tar.gz → 1.3.0__tar.gz

llguidance-1.3.0/.github/workflows/code-coverage.yml

@@ -0,0 +1,126 @@
+name: Code Coverage
+permissions:
+  contents: read
+
+
+on:
+  pull_request:
+  push:
+    branches: [ "main" ]
+  workflow_dispatch:
+    inputs:
+      commit_id:
+        description: 'Branch or Commit ID (optional)'
+        required: false
+        type: string
+
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-Cinstrument-coverage"
+  LLVM_PROFILE_FILE: "llg-%p-%m.profraw"
+
+
+jobs:
+  code-cov-rust:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repo at ${{ github.event_name == 'workflow_dispatch' && inputs.commit_id || github.sha }}
+      uses: actions/checkout@v4
+      with:
+        ref: ${{ github.event_name == 'workflow_dispatch' && inputs.commit_id || github.sha }}
+
+    - name: Update toolchain
+      run: rustup component add llvm-tools
+
+    - name: Install grcov
+      run: cargo install grcov
+
+    - name: Build everything
+      run: cargo build
+
+    - name: Run tests
+      run: cargo test
+
+    - name: Check environment
+      run: |
+        echo "CARGO_TERM_COLOR: $CARGO_TERM_COLOR"
+        echo "RUSTFLAGS: $RUSTFLAGS"
+        echo "LLVM_PROFILE_FILE: $LLVM_PROFILE_FILE"
+
+    - name: Generate coverage report
+      run: |
+        grcov . -s . --binary-path target/debug/ -t html --branch --ignore-not-existing -o target/debug/coverage/
+
+    - name: Check output
+      run: ls target/debug/coverage/
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: coverage-report-rust
+        path: target/debug/coverage/
+
+  code-cov-python:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repo at ${{ github.event_name == 'workflow_dispatch' && inputs.commit_id || github.sha }}
+      uses: actions/checkout@v4
+      with:
+        ref: ${{ github.event_name == 'workflow_dispatch' && inputs.commit_id || github.sha }}
+
+    - name: Setup Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.11"
+
+    - name: Check environment
+      run: |
+        echo "CARGO_TERM_COLOR: $CARGO_TERM_COLOR"
+        echo "RUSTFLAGS: $RUSTFLAGS"
+        echo "LLVM_PROFILE_FILE: $LLVM_PROFILE_FILE"
+
+    - name: Update toolchain
+      run: rustup component add llvm-tools
+
+    - name: Install grcov
+      run: cargo install grcov
+
+    - name: Clone guidance
+      run: |
+        git clone -b main https://github.com/guidance-ai/guidance
+
+    - name: Install guidance
+      run: |
+        cd guidance
+        pip install .[all,test]
+
+    - name: Install local llguidance
+      run: |
+        pip uninstall -y llguidance || :
+        pip install -v -e .
+
+    - name: Verify llguidance being used
+      run: pip show llguidance
+
+    - name: Run tests
+      run: |
+        cd guidance
+        python -m pytest tests/unit
+
+    - name: See all outputs
+      run: ls -R
+
+    - name: Generate coverage report
+      run: |
+        grcov . -s . --binary-path . -t html --branch --ignore-not-existing -o target/debug/coverage/
+
+    - name: Check output
+      run: ls target/debug/coverage/
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: coverage-report-python
+        path: target/debug/coverage/
+

{llguidance-1.1.2 → llguidance-1.3.0}/.github/workflows/rust.yml

@@ -62,7 +62,7 @@ jobs:
     - uses: actions/checkout@v4
 
     - name: Set up Rust
-      uses: dtolnay/rust-toolchain@1.80.0
+      uses: dtolnay/rust-toolchain@1.87.0
       with:
         components: clippy
 

{llguidance-1.1.2 → llguidance-1.3.0}/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file. Dates are d
 
 If a release doesn't introduce any interesting changes (build fixes etc.), it's skipped.
 
+#### [v1.3.0](https://github.com/guidance-ai/llguidance/compare/v1.2.0...v1.3.0) 2025-10-20
+
+- change semantics of JSON separators (now regex patterns instead of text literals) [`#246`](https://github.com/guidance-ai/llguidance/pull/246)
+- fix Inconsistent handling of the EOS token in `try_consume_tokens` [`#244`](https://github.com/guidance-ai/llguidance/pull/244)
+- add option for initial skip of `%ignore` lexeme [`#235`](https://github.com/guidance-ai/llguidance/pull/235)
+- bump MSRV to 1.87.0 [`#243`](https://github.com/guidance-ai/llguidance/pull/243)
+
+#### [v1.2.0](https://github.com/guidance-ai/llguidance/compare/v1.1.2...v1.2.0) 2025-08-12
+
+- support multithreaded compute bitmask for speculative decoding [`#225`](https://github.com/guidance-ai/llguidance/pull/225)
+  - thank you [@ZonePG](https://github.com/ZonePG)!
+- `force_lexeme_end` -> `try_lexeme_end` in lark lexer when out of input [`#229`](https://github.com/guidance-ai/llguidance/pull/229); fixes [`#228`](https://github.com/guidance-ai/llguidance/issues/228)
+- more JSON test coverage
+
 #### [v1.1.2](https://github.com/guidance-ai/llguidance/compare/v1.1.1...v1.1.2) 2025-08-08
 
 - add flag in ParserLimits to disable verbose errors [`#227`](https://github.com/guidance-ai/llguidance/pull/227)

{llguidance-1.1.2 → llguidance-1.3.0}/Cargo.lock

@@ -1241,7 +1241,7 @@ checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
 
 [[package]]
 name = "llguidance"
-version = "1.1.2"
+version = "1.3.0"
 dependencies = [
  "anyhow",
  "derivre",
@@ -1260,7 +1260,7 @@ dependencies = [
 
 [[package]]
 name = "llguidance_py"
-version = "1.1.2"
+version = "1.3.0"
 dependencies = [
  "anyhow",
  "bytemuck",
@@ -2176,9 +2176,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "slab"
-version = "0.4.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "smallvec"
@@ -2478,7 +2478,7 @@ dependencies = [
 
 [[package]]
 name = "toktrie"
-version = "1.1.2"
+version = "1.3.0"
 dependencies = [
  "anyhow",
  "bytemuck",
@@ -2489,7 +2489,7 @@ dependencies = [
 
 [[package]]
 name = "toktrie_hf_downloader"
-version = "1.1.2"
+version = "1.3.0"
 dependencies = [
  "anyhow",
  "hf-hub",
@@ -2500,7 +2500,7 @@ dependencies = [
 
 [[package]]
 name = "toktrie_hf_tokenizers"
-version = "1.1.2"
+version = "1.3.0"
 dependencies = [
  "anyhow",
  "log",
@@ -2512,7 +2512,7 @@ dependencies = [
 
 [[package]]
 name = "toktrie_tiktoken"
-version = "1.1.2"
+version = "1.3.0"
 dependencies = [
  "anyhow",
  "log",

{llguidance-1.1.2 → llguidance-1.3.0}/Cargo.toml

@@ -21,6 +21,9 @@ default-members = [
 ]
 resolver = "2"
 
+[workspace.package]
+rust-version="1.87"
+
 [profile.release]
 debug = 1
 strip = "debuginfo"

{llguidance-1.1.2 → llguidance-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llguidance
-Version: 1.1.2
+Version: 1.3.0
 License-File: LICENSE
 Summary: Bindings for the Low-level Guidance (llguidance) Rust library for use within Guidance
 Author: Michal Moskal

{llguidance-1.1.2 → llguidance-1.3.0}/docs/json_schema.md

@@ -76,8 +76,8 @@ You can modify your grammar easily to allow initial or trailing whitespace.
 You can set top-level `"x-guidance"` key to control this.
 Following keys are available inside of it:
 
-- `item_separator`, defaults to `":"`
-- `key_separator`, defaults to `","`
+- `item_separator`, defaults to `","` - a regex pattern for the separator between array items or object properties
+- `key_separator`, defaults to `":"` - a regex pattern for the separator between object keys and values
 - `whitespace_flexible`, defaults to `true`; set to `false` to enforce compact JSON representation
 - `whitespace_pattern`, optional string, overrides `whitespace_flexible`;
   `whitespace_flexible: true` is equivalent to `whitespace_pattern: r"[\x20\x0A\x0D\x09]+"`
@@ -100,6 +100,26 @@ For example:
 }
 ```
 
+The separators are treated as regex patterns, allowing for flexible formatting:
+
+```json
+{
+   "x-guidance": {
+      "item_separator": "\\s{0,2},\\s{0,2}",
+      "key_separator": "\\s{0,2}:\\s{0,2}",
+      "whitespace_flexible": false
+   },
+   "type": "object",
+   "properties": {
+      "a": { "type": "number" },
+      "b": { "type": "number" }
+   }
+}
+```
+
+This will match JSON like `{"a":1,"b":2}`, `{"a": 1, "b": 2}`, or `{"a"  :  1 , "b":2}`,
+but not `{"a":1,   "b":2}` (too much whitespace after comma).
+
 The `"x-guidance"` key is only recognized at the top level of the schema.
 
 

{llguidance-1.1.2 → llguidance-1.3.0}/docs/syntax.md

@@ -318,7 +318,7 @@ MULT_NUM: %regex {
 
 Certain grammar options can be set by using `%llguidnace { ... }`,
 by passing it a JSON object with the options;
-see `LLGuidanceOptions` in [api.rs](../parser/src/api.rs#L24).
+see `LLGuidanceOptions` in [api.rs](../parser/src/api.rs#L36).
 Example: `%llguidance { "no_forcing": true }`.
 It can be specified multiple times, with the options being merged.
 

{llguidance-1.1.2 → llguidance-1.3.0}/parser/Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "llguidance"
-version = "1.1.2"
+version = "1.3.0"
 edition = "2021"
 license = "MIT"
 description = "Super-fast Structured Outputs"
 repository = "https://github.com/guidance-ai/llguidance"
+rust-version.workspace = true
 
 [dependencies]
 toktrie = { workspace = true }

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/api.rs

@@ -47,6 +47,13 @@ pub struct LLGuidanceOptions {
     /// This is very unlikely what you need.
     #[serde(default)]
     pub allow_invalid_utf8: bool,
+
+    /// If set, the grammar will allow the %ignore lexeme at the start of the grammar.
+    /// Otherwise, it will only be allowed after the first non-ignored lexeme.
+    /// This option (like the other options here) will apply to the entire grammar,
+    /// including nested sub-grammars.
+    #[serde(default)]
+    pub allow_initial_skip: bool,
 }
 
 impl LLGuidanceOptions {
@@ -57,6 +64,9 @@ impl LLGuidanceOptions {
         if other.allow_invalid_utf8 {
             self.allow_invalid_utf8 = true;
         }
+        if other.allow_initial_skip {
+            self.allow_initial_skip = true;
+        }
     }
 }
 

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/earley/grammar.rs

@@ -1322,7 +1322,7 @@ impl CGrammar {
                 outp.rhs_elements.push(CSymIdx::NULL);
                 outp.rhs_params.push(ParamExpr::Null);
             }
-            while outp.rhs_elements.len() % (1 << RULE_SHIFT) != 0 {
+            while !outp.rhs_elements.len().is_multiple_of(1 << RULE_SHIFT) {
                 outp.rhs_elements.push(CSymIdx::NULL);
                 outp.rhs_params.push(ParamExpr::Null);
             }

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/earley/parser.rs

@@ -132,7 +132,7 @@ impl XorShift {
     }
 
     pub fn one_in(&mut self, n: u32) -> bool {
-        self.next() % n == 0
+        self.next().is_multiple_of(n)
     }
 
     pub fn next_alt(&mut self) -> u32 {
@@ -1611,7 +1611,10 @@ impl ParserState {
 
         let curr = self.lexer_state();
 
-        let res = if byte.is_none() {
+        let res = if let Some(b) = byte {
+            self.stats.definitive_bytes += 1;
+            self.lexer_mut().advance(curr.lexer_state, b, true)
+        } else {
             let lexeme = self.lexer_mut().force_lexeme_end(curr.lexer_state);
             if lexeme.is_error() {
                 debug!(
@@ -1620,10 +1623,6 @@ impl ParserState {
                 );
             }
             lexeme
-        } else {
-            self.stats.definitive_bytes += 1;
-            self.lexer_mut()
-                .advance(curr.lexer_state, byte.unwrap(), true)
         };
 
         if res.is_error() {

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/earley/perf.rs

@@ -140,7 +140,7 @@ pub fn num_with_commas(x: usize) -> String {
 
     for (i, c) in s.chars().enumerate() {
         // Insert a comma once we've passed 'offset' and every 3 digits after that.
-        if i != 0 && i >= offset && (i - offset) % 3 == 0 {
+        if i != 0 && i >= offset && (i - offset).is_multiple_of(3) {
             result.push(',');
         }
         result.push(c);

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/earley/regexvec.rs

@@ -674,7 +674,7 @@ impl RegexVec {
         // if lst.len() == 0 {
         //     return StateID::DEAD;
         // }
-        assert!(lst.len() % 2 == 0);
+        assert!(lst.len().is_multiple_of(2));
         let id = StateID::new(self.rx_sets.insert(&lst));
         if id.as_usize() >= self.state_descs.len() {
             let state_desc = self.compute_state_desc(id);

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/grammar_builder.rs

@@ -233,6 +233,9 @@ impl GrammarBuilder {
         if options.no_forcing {
             self.regex.spec.no_forcing = true;
         }
+        if options.allow_initial_skip {
+            self.regex.spec.allow_initial_skip = true;
+        }
 
         // add root node
         self.curr_start_idx = self.new_node("start");

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/json/compiler.rs

@@ -58,6 +58,8 @@ struct Compiler {
 
     any_cache: Option<NodeRef>,
     string_cache: Option<NodeRef>,
+    item_separator_cache: Option<NodeRef>,
+    key_separator_cache: Option<NodeRef>,
 }
 
 macro_rules! cache {
@@ -136,6 +138,8 @@ impl Compiler {
             pending_definitions: vec![],
             any_cache: None,
             string_cache: None,
+            item_separator_cache: None,
+            key_separator_cache: None,
             pattern_cache: PatternPropertyCache::default(),
         }
     }
@@ -331,6 +335,26 @@ impl Compiler {
         })
     }
 
+    fn item_separator(&mut self) -> Result<NodeRef> {
+        if let Some(node) = self.item_separator_cache {
+            return Ok(node);
+        }
+        let rx = self.builder.regex.regex(&self.options.item_separator)?;
+        let node = self.builder.lexeme(rx);
+        self.item_separator_cache = Some(node);
+        Ok(node)
+    }
+
+    fn key_separator(&mut self) -> Result<NodeRef> {
+        if let Some(node) = self.key_separator_cache {
+            return Ok(node);
+        }
+        let rx = self.builder.regex.regex(&self.options.key_separator)?;
+        let node = self.builder.lexeme(rx);
+        self.key_separator_cache = Some(node);
+        Ok(node)
+    }
+
     fn get_definition(&mut self, reference: &str) -> Result<NodeRef> {
         if let Some(definition) = self.definitions.get(reference) {
             return Ok(*definition);
@@ -380,7 +404,7 @@ impl Compiler {
         let mut unquoted_taken_names: Vec<String> = vec![];
         let mut items: Vec<(NodeRef, bool)> = vec![];
 
-        let colon = self.builder.string(&self.options.key_separator);
+        let colon = self.key_separator()?;
 
         let mut num_required = 0;
         let mut num_optional = 0;
@@ -489,7 +513,7 @@ impl Compiler {
                 let sel_options = options
                     .iter()
                     .map(|v| self.object_fields(v))
-                    .collect::<Vec<_>>();
+                    .collect::<Result<Vec<_>>>()?;
                 return Ok(self.builder.select(&sel_options));
             }
 
@@ -568,7 +592,7 @@ impl Compiler {
         if !pattern_options.is_empty() && max_properties != Some(0) {
             let pattern = self.builder.select(&pattern_options);
             let required = min_properties > 0;
-            let seq = self.bounded_sequence(pattern, min_properties, max_properties);
+            let seq = self.bounded_sequence(pattern, min_properties, max_properties)?;
             items.push((seq, required));
         } else if min_properties > 0 {
             return Err(anyhow!(UnsatisfiableSchemaError {
@@ -578,14 +602,14 @@ impl Compiler {
             }));
         }
 
-        Ok(self.object_fields(&items))
+        self.object_fields(&items)
     }
 
-    fn object_fields(&mut self, items: &[(NodeRef, bool)]) -> NodeRef {
+    fn object_fields(&mut self, items: &[(NodeRef, bool)]) -> Result<NodeRef> {
         let opener = self.builder.string("{");
-        let inner = self.ordered_sequence(items, false, &mut HashMap::default());
+        let inner = self.ordered_sequence(items, false, &mut HashMap::default())?;
         let closer = self.builder.string("}");
-        self.builder.join(&[opener, inner, closer])
+        Ok(self.builder.join(&[opener, inner, closer]))
     }
 
     #[allow(clippy::type_complexity)]
@@ -594,22 +618,22 @@ impl Compiler {
         items: &'a [(NodeRef, bool)],
         prefixed: bool,
         cache: &mut HashMap<(&'a [(NodeRef, bool)], bool), NodeRef>,
-    ) -> NodeRef {
+    ) -> Result<NodeRef> {
         // Cache to reduce number of nodes from O(n^2) to O(n)
         if let Some(node) = cache.get(&(items, prefixed)) {
-            return *node;
+            return Ok(*node);
         }
         if items.is_empty() {
-            return self.builder.string("");
+            return Ok(self.builder.string(""));
         }
-        let comma = self.builder.string(&self.options.item_separator);
+        let comma = self.item_separator()?;
         let (item, required) = items[0];
         let rest = &items[1..];
 
         let node = match (prefixed, required) {
             (true, true) => {
                 // If we know we have preceeding elements, we can safely just add a (',' + e)
-                let rest_seq = self.ordered_sequence(rest, true, cache);
+                let rest_seq = self.ordered_sequence(rest, true, cache)?;
                 self.builder.join(&[comma, item, rest_seq])
             }
             (true, false) => {
@@ -617,26 +641,26 @@ impl Compiler {
                 // TODO optimization: if the rest is all optional, we can nest the rest in the optional
                 let comma_item = self.builder.join(&[comma, item]);
                 let optional_comma_item = self.builder.optional(comma_item);
-                let rest_seq = self.ordered_sequence(rest, true, cache);
+                let rest_seq = self.ordered_sequence(rest, true, cache)?;
                 self.builder.join(&[optional_comma_item, rest_seq])
             }
             (false, true) => {
                 // No preceding elements, so we just add the element (no comma)
-                let rest_seq = self.ordered_sequence(rest, true, cache);
+                let rest_seq = self.ordered_sequence(rest, true, cache)?;
                 self.builder.join(&[item, rest_seq])
             }
             (false, false) => {
                 // No preceding elements, but our element is optional. If we add the element, the remaining
                 // will be prefixed, else they are not.
                 // TODO: same nested optimization as above
-                let prefixed_rest = self.ordered_sequence(rest, true, cache);
-                let unprefixed_rest = self.ordered_sequence(rest, false, cache);
+                let prefixed_rest = self.ordered_sequence(rest, true, cache)?;
+                let unprefixed_rest = self.ordered_sequence(rest, false, cache)?;
                 let opts = [self.builder.join(&[item, prefixed_rest]), unprefixed_rest];
                 self.builder.select(&opts)
             }
         };
         cache.insert((items, prefixed), node);
-        node
+        Ok(node)
     }
 
     fn bounded_sequence(
@@ -644,20 +668,20 @@ impl Compiler {
         item: NodeRef,
         min_elts: usize,
         max_elts: Option<usize>,
-    ) -> NodeRef {
+    ) -> Result<NodeRef> {
         let min_elts = min_elts.saturating_sub(1);
         let max_elts = max_elts.map(|v| v.saturating_sub(1));
-        let comma = self.builder.string(&self.options.item_separator);
+        let comma = self.item_separator()?;
         let item_comma = self.builder.join(&[item, comma]);
         let item_comma_rep = self.builder.repeat(item_comma, min_elts, max_elts);
-        self.builder.join(&[item_comma_rep, item])
+        Ok(self.builder.join(&[item_comma_rep, item]))
     }
 
-    fn sequence(&mut self, item: NodeRef) -> NodeRef {
-        let comma = self.builder.string(&self.options.item_separator);
+    fn sequence(&mut self, item: NodeRef) -> Result<NodeRef> {
+        let comma = self.item_separator()?;
         let item_comma = self.builder.join(&[item, comma]);
         let item_comma_star = self.builder.zero_or_more(item_comma);
-        self.builder.join(&[item_comma_star, item])
+        Ok(self.builder.join(&[item_comma_star, item]))
     }
 
     fn json_quote(&self, ast: RegexAst) -> RegexAst {
@@ -864,12 +888,12 @@ impl Compiler {
         if max_items.is_none() {
             if let Some(additional_item) = additional_item_grm {
                 // Add an infinite tail of items
-                optional_items.push(self.sequence(additional_item));
+                optional_items.push(self.sequence(additional_item)?);
             }
         }
 
         let mut grammars: Vec<NodeRef> = vec![self.builder.string("[")];
-        let comma = self.builder.string(&self.options.item_separator);
+        let comma = self.item_separator()?;
 
         if !required_items.is_empty() {
             grammars.push(required_items[0]);

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/json/numeric.rs

@@ -19,7 +19,7 @@ impl Decimal {
         // reduce to simplest form
         let mut coef = coef;
         let mut exp = exp;
-        while exp > 0 && coef % 10 == 0 {
+        while exp > 0 && coef.is_multiple_of(10) {
             coef /= 10;
             exp -= 1;
         }

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/lark/lexer.rs

@@ -279,7 +279,7 @@ pub fn lex_lark(input: &str) -> Result<Vec<Lexeme>> {
     while idx <= input_bytes.len() {
         let mut b = b'\n';
         let res = if idx == input_bytes.len() {
-            lexer.force_lexeme_end(state)
+            lexer.try_lexeme_end(state)
         } else {
             b = input_bytes[idx];
             lexer.advance(state, b, false)

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/logging.rs

@@ -120,11 +120,11 @@ impl Logger {
         std::mem::take(&mut self.buffer)
     }
 
-    pub fn info_logger(&mut self) -> InfoLogger {
+    pub fn info_logger(&mut self) -> InfoLogger<'_> {
         InfoLogger { logger: self }
     }
 
-    pub fn warning_logger(&mut self) -> WarningLogger {
+    pub fn warning_logger(&mut self) -> WarningLogger<'_> {
         WarningLogger { logger: self }
     }
 }

{llguidance-1.1.2 → llguidance-1.3.0}/parser/src/matcher.rs

@@ -166,13 +166,12 @@ impl Matcher {
         self.with_inner(|inner| {
             for (idx, &t) in tokens.iter().enumerate() {
                 if !inner.parser.validate_token(t)? {
-                    let _ = inner.parser.check_stop()?;
                     return Ok(idx);
                 }
                 let bt = inner.parser.consume_token(t)?;
+                let _ = inner.parser.check_stop()?;
                 ensure!(bt == 0, "unexpected backtracking");
             }
-            let _ = inner.parser.check_stop()?;
             Ok(tokens.len())
         })
     }

{llguidance-1.1.2 → llguidance-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "llguidance"
-version = "1.1.2"
+version = "1.3.0"
 description = "Bindings for the Low-level Guidance (llguidance) Rust library for use within Guidance"
 requires-python = ">=3.9"
 license = "MIT"