refkit 0.2.1__tar.gz → 0.3.0__tar.gz

{refkit-0.2.1 → refkit-0.3.0}/.agent-plugin/skills/refkit/references/inspect.md

@@ -31,6 +31,25 @@ Return the entry preview, diagnostic preview, and their total counts together. D
 
 Use `Library.read(path)` for files, `Library.parse_yaml(source)` for [Hayagriva bibliography YAML](https://github.com/typst/hayagriva), and `Library.select(selector)` for [Hayagriva selectors](https://github.com/typst/hayagriva#selectors). Use `project(..., keys=selected_keys)` to constrain subsequent output.
 
+Use `BibDocument.resolve()` for every source field, including custom fields,
+with string macros and concatenations expanded. It preserves TeX grouping and
+escapes. Results are detached records with `key`, `entry_type`, and `fields`.
+The call uses current edits and raises `ParseError` for ambiguous or invalid
+source. It resolves `crossref` and `xdata` as field text. Choose `Library` for
+inherited citation metadata.
+
+```python
+import refkit as rk
+
+document = rk.BibDocument.parse("""
+@string{host = {https://example.org/}}
+@misc{guide, custom_link = host # {guide}, title = {A {Guide}}}
+""")
+entry = document.resolve()[0]
+assert entry["fields"]["custom_link"] == "https://example.org/guide"
+assert entry["fields"]["title"] == "A {Guide}"
+```
+
 When parsing cannot retain an entry, handle the typed failure and report its diagnostics:
 
 ```python

{refkit-0.2.1 → refkit-0.3.0}/Cargo.lock

@@ -455,7 +455,7 @@ dependencies = [
 
 [[package]]
 name = "refkit-core"
-version = "0.2.1"
+version = "0.3.0"
 dependencies = [
  "biblatex",
  "hayagriva",
@@ -468,7 +468,7 @@ dependencies = [
 
 [[package]]
 name = "refkit-native"
-version = "0.2.1"
+version = "0.3.0"
 dependencies = [
  "pyo3",
  "refkit-core",

{refkit-0.2.1 → refkit-0.3.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/refkit-core", "packages/refkit/rust"]
 resolver = "3"
 
 [workspace.package]
-version = "0.2.1"
+version = "0.3.0"
 edition = "2024"
 rust-version = "1.88"
 license = "Apache-2.0"
@@ -11,7 +11,7 @@ repository = "https://github.com/peter-gy/refkit"
 
 [workspace.dependencies]
 pyo3 = "0.29.0"
-refkit-core = { version = "0.2.1", path = "crates/refkit-core" }
+refkit-core = { version = "0.3.0", path = "crates/refkit-core" }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.150"
 

{refkit-0.2.1 → refkit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refkit
-Version: 0.2.1
+Version: 0.3.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

{refkit-0.2.1 → refkit-0.3.0}/crates/refkit-core/src/lib.rs

@@ -15,6 +15,7 @@ pub use library::{
 };
 pub use raw::{
     RawBlockInfo, RawDocument, RawEditError, RawEntryId, RawEntryInfo, RawFieldId, RawFieldInfo,
+    ResolvedBibEntry,
 };
 pub use render::{
     RenderedOutput, is_bundled_locale, render_library_bibliography, render_library_citation,

{refkit-0.2.1 → refkit-0.3.0}/crates/refkit-core/src/library/guard.rs

@@ -11,7 +11,11 @@ const MAX_EXPANDED_BYTES: usize = 16 * 1024 * 1024;
 const MAX_STEPS: usize = 100_000;
 
 pub(crate) fn validate_source(source: &str) -> Result<(), Diagnostic> {
-    if source.len() > MAX_SOURCE_BYTES {
+    validate_source_size(source.len())
+}
+
+pub(crate) fn validate_source_size(bytes: usize) -> Result<(), Diagnostic> {
+    if bytes > MAX_SOURCE_BYTES {
         return Err(limit(None, "bibliography source exceeds 16 MiB"));
     }
     Ok(())
@@ -61,7 +65,7 @@ pub(crate) fn normalize_reference<'a>(
 ) -> Result<Vec<String>, Diagnostic> {
     let lookup = abbreviations
         .iter()
-        .map(|pair| (pair.key.v, &pair.value.v))
+        .map(|pair| (pair.key.v.to_string(), &pair.value.v))
         .collect();
     resolve_field(field, &lookup)?;
     let span = field.first().map_or(0, |chunk| chunk.span.start)
@@ -96,7 +100,7 @@ pub(crate) fn normalize_reference<'a>(
 
 pub(crate) fn resolve_field(
     field: &Field<'_>,
-    abbreviations: &HashMap<&str, &Field<'_>>,
+    abbreviations: &HashMap<String, &Field<'_>>,
 ) -> Result<String, Diagnostic> {
     let mut output = String::new();
     let mut ancestors = Vec::new();
@@ -107,18 +111,25 @@ pub(crate) fn resolve_field(
         &mut ancestors,
         &mut steps,
         &mut output,
+        false,
     )?;
     Ok(output)
 }
 
 fn expand<'a>(
     field: &Field<'a>,
-    abbreviations: &HashMap<&str, &Field<'a>>,
+    abbreviations: &HashMap<String, &Field<'a>>,
     ancestors: &mut Vec<String>,
     steps: &mut usize,
     output: &mut String,
+    strict: bool,
 ) -> Result<(), Diagnostic> {
-    validate_value(field)?;
+    validate_value(field).map_err(|mut diagnostic| {
+        if strict {
+            diagnostic.span = field.first().map(|chunk| chunk.span.clone());
+        }
+        diagnostic
+    })?;
     for chunk in field {
         *steps += 1;
         if *steps > MAX_STEPS || ancestors.len() >= MAX_DEPTH {
@@ -130,17 +141,33 @@ fn expand<'a>(
         match chunk.v {
             RawChunk::Normal(text) => output.push_str(text),
             RawChunk::Abbreviation(name) => {
-                if ancestors.iter().any(|ancestor| ancestor == name) {
+                let key = if strict {
+                    name.to_ascii_lowercase()
+                } else {
+                    name.to_string()
+                };
+                if ancestors.contains(&key) {
                     return Err(Diagnostic::error(
                         "cyclic_abbreviation",
                         Some(chunk.span.clone()),
                         format!("cyclic BibTeX abbreviation {name:?}"),
                     ));
                 }
-                if let Some(value) = abbreviations.get(name) {
-                    ancestors.push(name.to_string());
-                    expand(value, abbreviations, ancestors, steps, output)?;
+                if let Some(value) = abbreviations.get(&key) {
+                    ancestors.push(key);
+                    expand(value, abbreviations, ancestors, steps, output, strict)?;
                     ancestors.pop();
+                } else if strict {
+                    match month(&key) {
+                        Some(month) => output.push_str(month),
+                        None => {
+                            return Err(Diagnostic::error(
+                                "unknown_abbreviation",
+                                Some(chunk.span.clone()),
+                                format!("unknown BibTeX abbreviation {name:?}"),
+                            ));
+                        }
+                    }
                 } else {
                     output.push_str(name);
                 }
@@ -156,6 +183,60 @@ fn expand<'a>(
     Ok(())
 }
 
+pub(crate) struct FieldResolver<'a> {
+    abbreviations: HashMap<String, &'a Field<'a>>,
+    steps: usize,
+    bytes: usize,
+}
+
+impl<'a> FieldResolver<'a> {
+    pub(crate) fn new(abbreviations: HashMap<String, &'a Field<'a>>) -> Self {
+        Self {
+            abbreviations,
+            steps: 0,
+            bytes: 0,
+        }
+    }
+
+    pub(crate) fn resolve(&mut self, field: &Field<'a>) -> Result<String, Diagnostic> {
+        let mut output = String::new();
+        expand(
+            field,
+            &self.abbreviations,
+            &mut Vec::new(),
+            &mut self.steps,
+            &mut output,
+            true,
+        )?;
+        self.bytes = self.bytes.saturating_add(output.len());
+        if self.bytes > MAX_EXPANDED_BYTES {
+            return Err(limit(
+                field.first().map(|chunk| chunk.span.clone()),
+                "bibliography expansion exceeds 16 MiB",
+            ));
+        }
+        Ok(output)
+    }
+}
+
+fn month(name: &str) -> Option<&'static str> {
+    Some(match name {
+        "jan" => "January",
+        "feb" => "February",
+        "mar" => "March",
+        "apr" => "April",
+        "may" => "May",
+        "jun" => "June",
+        "jul" => "July",
+        "aug" => "August",
+        "sep" => "September",
+        "oct" => "October",
+        "nov" => "November",
+        "dec" => "December",
+        _ => return None,
+    })
+}
+
 pub(crate) fn validate_raw(raw: &RawBibliography<'_>) -> Result<(), Diagnostic> {
     for abbreviation in &raw.abbreviations {
         validate_value(&abbreviation.value.v)?;
@@ -163,7 +244,7 @@ pub(crate) fn validate_raw(raw: &RawBibliography<'_>) -> Result<(), Diagnostic>
     let abbreviations: HashMap<_, _> = raw
         .abbreviations
         .iter()
-        .map(|pair| (pair.key.v, &pair.value.v))
+        .map(|pair| (pair.key.v.to_string(), &pair.value.v))
         .collect();
     let has_references = raw
         .entries
@@ -183,6 +264,7 @@ pub(crate) fn validate_raw(raw: &RawBibliography<'_>) -> Result<(), Diagnostic>
                 &mut ancestors,
                 &mut expansion_steps,
                 &mut value,
+                false,
             )
             .map_err(|mut diagnostic| {
                 diagnostic.entry = Some(entry.v.key.v.to_string());

{refkit-0.2.1 → refkit-0.3.0}/crates/refkit-core/src/library/mod.rs

@@ -15,7 +15,9 @@ use crate::quoted;
 use crate::strings::entry_type_name;
 
 pub use self::diagnostic::{Diagnostic, DiagnosticAction, DiagnosticSeverity, ParseFailure};
-pub(crate) use self::guard::{normalize_reference, validate_literal, validate_source};
+pub(crate) use self::guard::{
+    FieldResolver, normalize_reference, validate_literal, validate_source, validate_source_size,
+};
 pub use self::parse::parse_bibtex_report;
 use self::parse::{parse_biblatex_library, parse_hayagriva_yaml};
 

{refkit-0.2.1 → refkit-0.3.0}/crates/refkit-core/src/raw/parse.rs

@@ -775,6 +775,11 @@ fn skip_field_trivia(body: &str, cursor: &mut usize) {
 }
 
 fn parse_assignment(body: &str) -> Option<(String, String)> {
+    let (key, value, _) = parse_assignment_atoms(body)?;
+    Some((key, value))
+}
+
+pub(super) fn parse_assignment_atoms(body: &str) -> Option<(String, String, Vec<RawValueAtom>)> {
     let equals = body.find('=')?;
     let key = body[..equals].trim().to_ascii_lowercase();
     if !is_valid_identifier(&key) {
@@ -782,13 +787,17 @@ fn parse_assignment(body: &str) -> Option<(String, String)> {
     }
     let mut cursor = equals + 1;
     skip_field_space(body, &mut cursor);
-    let (value, end, _, _, _) = parse_value(body, cursor, 0).ok()?;
+    let (value, end, _, _, atoms) = parse_value(body, cursor, 0).ok()?;
     cursor = end;
     skip_field_trivia(body, &mut cursor);
+    if body[cursor..].starts_with(',') {
+        cursor += 1;
+        skip_field_trivia(body, &mut cursor);
+    }
     if cursor != body.len() {
         return None;
     }
-    Some((key, value))
+    Some((key, value, atoms))
 }
 
 fn parse_preamble_value(body: &str) -> String {

refkit-0.3.0/crates/refkit-core/src/raw/resolve.rs

@@ -0,0 +1,384 @@
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::ops::Range;
+
+use biblatex::{Field, RawChunk, Spanned};
+
+use super::parse::{parse_assignment_atoms, parse_raw_document};
+use super::{RawBlock, RawDocument, RawValueAtom, RawValueMode, ResolvedBibEntry};
+use crate::library::{
+    Diagnostic, FieldResolver, ParseFailure, validate_source, validate_source_size,
+};
+
+pub(super) fn resolve_document(
+    document: &RawDocument,
+) -> Result<Vec<ResolvedBibEntry>, ParseFailure> {
+    let (changed, edited_bytes) = document
+        .data
+        .entry_blocks
+        .iter()
+        .flat_map(|entry| &entry.field_blocks)
+        .filter(|field| field.changed)
+        .fold((false, 0usize), |(_, bytes), field| {
+            (true, bytes.saturating_add(field.value.len()))
+        });
+    validate_source_size(edited_bytes)?;
+    let current;
+    let data = if changed {
+        let source = document
+            .render()
+            .map_err(|message| Diagnostic::error("syntax_error", None, message))?;
+        validate_source(&source)?;
+        current = parse_raw_document(&source);
+        &current
+    } else {
+        validate_source_size(
+            document
+                .data
+                .blocks
+                .last()
+                .map_or(0, |block| block.span().end),
+        )?;
+        &document.data
+    };
+    let mut definitions = Vec::new();
+    for block in &data.blocks {
+        match block {
+            RawBlock::StringDef { raw, span, .. } => {
+                let body_start = raw.find(['{', '(']).expect("parsed block has an opener") + 1;
+                let (key, _, atoms) = parse_assignment_atoms(&raw[body_start..raw.len() - 1])
+                    .ok_or_else(|| {
+                        Diagnostic::error(
+                            "syntax_error",
+                            Some(span.clone()),
+                            "invalid BibTeX string definition".to_string(),
+                        )
+                    })?;
+                definitions.push((key, atoms, span.clone()));
+            }
+            RawBlock::Failed { error, span, .. } => {
+                return Err(
+                    Diagnostic::error("syntax_error", Some(span.clone()), error.clone()).into(),
+                );
+            }
+            _ => {}
+        }
+    }
+    let definitions: Vec<_> = definitions
+        .iter()
+        .map(|(key, atoms, span)| (key, as_field(atoms, span)))
+        .collect();
+    let abbreviations: HashMap<_, _> = definitions
+        .iter()
+        .map(|(key, value)| ((*key).clone(), value))
+        .collect();
+    let mut resolver = FieldResolver::new(abbreviations);
+    let mut keys = HashSet::new();
+    let mut entries = Vec::with_capacity(data.entry_blocks.len());
+    for entry in &data.entry_blocks {
+        if entry.key.is_empty() || !keys.insert(&entry.key) {
+            let code = if entry.key.is_empty() {
+                "syntax_error"
+            } else {
+                "duplicate_key"
+            };
+            let mut diagnostic = Diagnostic::error(
+                code,
+                Some(entry.span.clone()),
+                format!(
+                    "BibTeX entry key {:?} must be nonempty and unique",
+                    entry.key
+                ),
+            );
+            diagnostic.entry = Some(entry.key.clone());
+            return Err(diagnostic.into());
+        }
+        let mut fields = BTreeMap::new();
+        for field in &entry.field_blocks {
+            let name = field.name.to_ascii_lowercase();
+            let result = if fields.contains_key(&name) {
+                Err(Diagnostic::error(
+                    "duplicate_field",
+                    Some(field.span.clone()),
+                    format!("duplicate BibTeX field {name:?}"),
+                ))
+            } else if field.value_mode == RawValueMode::Missing {
+                Err(Diagnostic::error(
+                    "syntax_error",
+                    Some(field.span.clone()),
+                    format!("BibTeX field {name:?} requires an assignment"),
+                ))
+            } else {
+                resolver.resolve(&as_field(&field.value_atoms, &field.span))
+            };
+            let value = result.map_err(|mut diagnostic| {
+                diagnostic.entry = Some(entry.key.clone());
+                diagnostic.field = Some(name.clone());
+                diagnostic
+            })?;
+            fields.insert(name, value);
+        }
+        entries.push(ResolvedBibEntry {
+            key: entry.key.clone(),
+            entry_type: entry.kind.to_ascii_lowercase(),
+            fields,
+        });
+    }
+    Ok(entries)
+}
+
+fn as_field<'a>(atoms: &'a [RawValueAtom], span: &Range<usize>) -> Field<'a> {
+    atoms
+        .iter()
+        .map(|atom| {
+            let value = if atom.value_mode == RawValueMode::Bare
+                && !atom.value.bytes().all(|byte| byte.is_ascii_digit())
+            {
+                RawChunk::Abbreviation(&atom.value)
+            } else {
+                RawChunk::Normal(&atom.value)
+            };
+            Spanned::new(value, span.clone())
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn resolves_source_fields_with_macros_and_preserves_tex() {
+        let source = r#"@string{publisher = "Example Press"}
+@string{URL = "https://example.test/"}
+@CustomType(Work, TITLE = {A {Protected} \LaTeX{} title},
+  HOWPUBLISHED = url # {paper}, publisher = PUBLISHER, year = 2026,
+  custom = {  keep spaces  }, month = SEP, crossref = {Parent})
+@book{Parent, title = {Parent Title}}"#;
+        let document = RawDocument::parse(source);
+        let entries = document.resolve().unwrap();
+        assert_eq!(
+            entries
+                .iter()
+                .map(|entry| entry.key.as_str())
+                .collect::<Vec<_>>(),
+            ["Work", "Parent"]
+        );
+        assert_eq!(entries[0].entry_type, "customtype");
+        assert_eq!(
+            entries[0].fields,
+            BTreeMap::from([
+                (
+                    "title".to_string(),
+                    r"A {Protected} \LaTeX{} title".to_string()
+                ),
+                (
+                    "howpublished".to_string(),
+                    "https://example.test/paper".to_string()
+                ),
+                ("publisher".to_string(), "Example Press".to_string()),
+                ("year".to_string(), "2026".to_string()),
+                ("custom".to_string(), "  keep spaces  ".to_string()),
+                ("month".to_string(), "September".to_string()),
+                ("crossref".to_string(), "Parent".to_string()),
+            ])
+        );
+        assert_eq!(document.render().unwrap(), source);
+    }
+
+    #[test]
+    fn resolution_observes_edits_and_matches_rendered_readback() {
+        let mut document = RawDocument::parse(
+            r#"@string{prefix="old"}@misc{work,title=prefix # { title},year=2025}"#,
+        );
+        let entry = document.unique_entry("work").unwrap().unwrap();
+        let field = document.unique_field(entry, "title").unwrap().unwrap();
+        document
+            .set_field_value(entry, field, r#"new # "literal""#.to_string())
+            .unwrap();
+        let before = document.render().unwrap();
+        let entries = document.resolve().unwrap();
+        assert_eq!(entries[0].fields["title"], r#"new # "literal""#);
+        assert_eq!(entries, RawDocument::parse(&before).resolve().unwrap());
+        assert_eq!(document.render().unwrap(), before);
+    }
+
+    #[test]
+    fn reference_fields_resolve_values_and_preserve_authored_fields() {
+        let entries = RawDocument::parse(
+            r#"@string{parent="P"}@book{P,title={Parent}}
+@misc{child,crossref=parent,xdata=parent # {, X},note={own}}"#,
+        )
+        .resolve()
+        .unwrap();
+        assert_eq!(
+            entries[1].fields,
+            BTreeMap::from([
+                ("crossref".to_string(), "P".to_string()),
+                ("xdata".to_string(), "P, X".to_string()),
+                ("note".to_string(), "own".to_string()),
+            ])
+        );
+    }
+
+    #[test]
+    fn macro_lookup_uses_final_definitions_and_preserves_literal_escapes() {
+        let entries = RawDocument::parse(
+            r#"@misc{Work,title=pub,month=JAN,note={A \} B}}
+@misc{work,title={lowercase key}}
+@string{PUB={old}}@string{pub=next,}@string{next={new}}@string{jan={Custom Month}}"#,
+        )
+        .resolve()
+        .unwrap();
+        assert_eq!(entries[0].fields["title"], "new");
+        assert_eq!(entries[0].fields["month"], "Custom Month");
+        assert_eq!(entries[0].fields["note"], r"A \} B");
+        assert_eq!(entries[1].key, "work");
+    }
+
+    #[test]
+    fn bounds_source_and_edited_input_size() {
+        let source = " ".repeat(16 * 1024 * 1024 + 1);
+        assert_eq!(
+            RawDocument::parse(&source)
+                .resolve()
+                .unwrap_err()
+                .diagnostics[0]
+                .code,
+            "resource_limit"
+        );
+        let mut document = RawDocument::parse("@misc{work,title={old}}");
+        let entry = document.unique_entry("work").unwrap().unwrap();
+        let field = document.unique_field(entry, "title").unwrap().unwrap();
+        document.set_field_value(entry, field, source).unwrap();
+        assert_eq!(
+            document.resolve().unwrap_err().diagnostics[0].code,
+            "resource_limit"
+        );
+    }
+
+    #[test]
+    fn resolves_edits_that_bring_source_within_the_size_limit() {
+        let source = format!("@misc{{work,title={{{}}}}}", "x".repeat(16 * 1024 * 1024));
+        let mut document = RawDocument::parse(&source);
+        let entry = document.unique_entry("work").unwrap().unwrap();
+        let field = document.unique_field(entry, "title").unwrap().unwrap();
+        document
+            .set_field_value(entry, field, "small".to_string())
+            .unwrap();
+
+        let entries = document.resolve().unwrap();
+        assert_eq!(entries[0].fields["title"], "small");
+        assert_eq!(
+            entries,
+            RawDocument::parse(&document.render().unwrap())
+                .resolve()
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn nesting_failures_have_valid_source_spans_for_unicode_expressions() {
+        let source = format!(
+            "@string{{accent=\"é\"}}@misc{{work,title=accent # {{{}é{}}}}}",
+            "{".repeat(64),
+            "}".repeat(64),
+        );
+        let failure = RawDocument::parse(&source).resolve().unwrap_err();
+        let diagnostic = &failure.diagnostics[0];
+        assert_eq!(diagnostic.code, "resource_limit");
+        assert_eq!(diagnostic.entry.as_deref(), Some("work"));
+        assert_eq!(diagnostic.field.as_deref(), Some("title"));
+        assert!(
+            diagnostic
+                .span
+                .as_ref()
+                .is_some_and(|span| source.get(span.clone()).is_some())
+        );
+    }
+
+    #[test]
+    fn rejects_ambiguous_fields_and_invalid_dependencies() {
+        for (source, code) in [
+            ("@misc{work,title=missing}", "unknown_abbreviation"),
+            (
+                "@string{a=B}@string{b=A}@misc{work,title=a}",
+                "cyclic_abbreviation",
+            ),
+            ("@misc{work,title={a},TITLE={b}}", "duplicate_field"),
+        ] {
+            let failure = RawDocument::parse(source).resolve().unwrap_err();
+            let diagnostic = &failure.diagnostics[0];
+            assert_eq!(diagnostic.code, code);
+            assert_eq!(diagnostic.entry.as_deref(), Some("work"));
+            assert_eq!(diagnostic.field.as_deref(), Some("title"));
+            assert!(
+                diagnostic
+                    .span
+                    .as_ref()
+                    .is_some_and(|span| source.get(span.clone()).is_some())
+            );
+        }
+        for (source, code) in [
+            ("@misc{work}@misc{work}", "duplicate_key"),
+            ("@misc{work,title={unfinished", "syntax_error"),
+            ("@string{a=}", "syntax_error"),
+        ] {
+            assert_eq!(
+                RawDocument::parse(source)
+                    .resolve()
+                    .unwrap_err()
+                    .diagnostics[0]
+                    .code,
+                code
+            );
+        }
+    }
+
+    #[test]
+    fn bounds_aggregate_expansion_and_dependency_depth() {
+        let mut source = "@string{x0={}}".to_string();
+        for index in 1..20 {
+            source.push_str(&format!(
+                "@string{{x{index}=x{} # x{}}}",
+                index - 1,
+                index - 1
+            ));
+        }
+        source.push_str("@misc{work,title=x19}");
+        assert_eq!(
+            RawDocument::parse(&source)
+                .resolve()
+                .unwrap_err()
+                .diagnostics[0]
+                .code,
+            "resource_limit"
+        );
+
+        let mut source = "@string{x0={ok}}".to_string();
+        for index in 1..65 {
+            source.push_str(&format!("@string{{x{index}=x{}}}", index - 1));
+        }
+        source.push_str("@misc{work,title=x64}");
+        assert_eq!(
+            RawDocument::parse(&source)
+                .resolve()
+                .unwrap_err()
+                .diagnostics[0]
+                .code,
+            "resource_limit"
+        );
+
+        let source = format!(
+            "@string{{a={{{}}}}}@misc{{work,a=a,b=a,c=a}}",
+            "x".repeat(6 * 1024 * 1024)
+        );
+        assert_eq!(
+            RawDocument::parse(&source)
+                .resolve()
+                .unwrap_err()
+                .diagnostics[0]
+                .code,
+            "resource_limit"
+        );
+    }
+}

{refkit-0.2.1 → refkit-0.3.0}/crates/refkit-core/src/raw.rs

@@ -1,3 +1,4 @@
+use std::collections::BTreeMap;
 use std::fmt;
 use std::ops::Range;
 
@@ -5,6 +6,7 @@ use indexmap::IndexMap;
 
 mod edit;
 mod parse;
+mod resolve;
 mod sanitize;
 #[cfg(test)]
 mod tests;
@@ -113,6 +115,13 @@ pub struct RawDocument {
     data: RawDocumentData,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ResolvedBibEntry {
+    pub key: String,
+    pub entry_type: String,
+    pub fields: BTreeMap<String, String>,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct RawEntryId(usize);
 
@@ -259,6 +268,10 @@ impl RawDocument {
         }
     }
 
+    pub fn resolve(&self) -> Result<Vec<ResolvedBibEntry>, crate::ParseFailure> {
+        resolve::resolve_document(self)
+    }
+
     pub fn entry_count(&self) -> usize {
         self.data.entry_blocks.len()
     }

{refkit-0.2.1 → refkit-0.3.0}/packages/refkit/rust/src/raw.rs

@@ -8,7 +8,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyModule};
 
 use crate::conversion::diagnostics_to_py;
-use crate::errors::RefkitError;
+use crate::errors::{RefkitError, library_error_to_py};
 use crate::filesystem::{read_bibtex, write_bibtex};
 use crate::repr::quoted;
 use crate::tidy::{TidyOptions, TidyResult, tidy_error_to_py};
@@ -103,6 +103,22 @@ impl BibDocument {
         py.detach(move || render_document(&data))
     }
 
+    fn resolve(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+        let data = self.doc.borrow().clone();
+        let entries = py
+            .detach(move || data.resolve())
+            .map_err(|error| library_error_to_py(py, refkit_core::LibraryError::Biblatex(error)))?;
+        let values = PyList::empty(py);
+        for entry in entries {
+            let value = PyDict::new(py);
+            value.set_item("key", entry.key)?;
+            value.set_item("entry_type", entry.entry_type)?;
+            value.set_item("fields", entry.fields)?;
+            values.append(value)?;
+        }
+        Ok(values.into_any().unbind())
+    }
+
     #[pyo3(signature = (*, options = None))]
     fn tidy(
         &self,

{refkit-0.2.1 → refkit-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refkit"
-version = "0.2.1"
+version = "0.3.0"
 description = "Fast Python citation parsing, rendering, and BibTeX editing backed by Rust"
 readme = "README.md"
 license = "Apache-2.0"

{refkit-0.2.1 → refkit-0.3.0}/src/refkit/_native.pyi

@@ -9,6 +9,7 @@ from .types import (
     RawBlock,
     RawFailedBlock,
     RenderedTree,
+    ResolvedBibEntry,
     TidyRename,
 )
 
@@ -268,5 +269,6 @@ class BibDocument:
     @property
     def blocks(self) -> list[RawBlock]: ...
     def to_bibtex(self) -> str: ...
+    def resolve(self) -> list[ResolvedBibEntry]: ...
     def tidy(self, *, options: TidyOptions | None = None) -> TidyResult: ...
     def write(self, path: str | PathLike[str]) -> None: ...

{refkit-0.2.1 → refkit-0.3.0}/src/refkit/types.py

@@ -62,6 +62,12 @@ class ProjectionRow(TypedDict, total=False):
     volume: str | None
 
 
+class ResolvedBibEntry(TypedDict):
+    key: str
+    entry_type: str
+    fields: dict[str, str]
+
+
 class RenderedFormatting(TypedDict):
     font_style: Literal["Normal", "Italic"]
     font_variant: Literal["Normal", "SmallCaps"]