cridecoder 0.3.3__tar.gz → 0.3.5__tar.gz

{cridecoder-0.3.3 → cridecoder-0.3.5}/AGENTS.md

@@ -6,7 +6,7 @@
 
 ### Credits
 
-CRI format implementation is based on [vgmstream](https://github.com/vgmstream/vgmstream).
+CRI format implementation is based on [vgmstream](https://github.com/vgmstream/vgmstream) and [PyCriCodecs](https://github.com/Youjose/PyCriCodecs/).
 
 ## Architecture
 
@@ -20,10 +20,13 @@ src/
 │   ├── utf.rs      # CRI UTF table parser
 │   ├── afs.rs      # AFS2 archive parser
 │   ├── track.rs    # Track list extraction from ACB
-│   └── extractor.rs # ACB extraction logic
+│   ├── extractor.rs # ACB extraction logic (disk + in-memory + de-duplicated)
+│   ├── decode.rs   # High-level ACB → WAV decoding (extract + HCA decode + subkey)
+│   └── builder.rs  # ACB/AWB/UTF table builders
 ├── hca.rs          # HCA module root (re-exports submodules)
 ├── hca/
 │   ├── decoder.rs  # Core HCA decoder (ClHca, header parsing, block decoding)
+│   ├── encoder.rs  # HCA encoder (PCM/WAV → HCA, optional encryption)
 │   ├── hca_file.rs # High-level HcaDecoder with streaming, WAV output, key testing
 │   ├── tables.rs   # Lookup tables for HCA decoding
 │   ├── cipher.rs   # HCA encryption/decryption cipher
@@ -33,16 +36,33 @@ src/
 ├── usm.rs          # USM module root (re-exports submodules)
 ├── usm/
 │   ├── extractor.rs # USM extraction (video/audio stream demuxing)
+│   ├── builder.rs   # USM container builder
 │   └── metadata.rs  # USM metadata reading and JSON export
 └── python.rs       # Python bindings (behind "python" feature)
 ```
 
 ## Key Types
 
-- `extract_acb_from_file()` / `extract_acb()` — ACB extraction entry points
-- `HcaDecoder` — High-level HCA to WAV/PCM decoder
-- `extract_usm_file()` / `extract_usm()` — USM extraction entry points
-- `ClHca` — Low-level HCA decoder state machine
+ACB extraction has three flavors, each with a disk and an in-memory variant:
+
+- `extract_acb_from_file()` / `extract_acb()` — extract tracks to a directory (returns written paths)
+- `extract_acb_tracks_from_file()` / `extract_acb_tracks()` — same, plus per-track metadata (`ExtractedTrackFile` with `name`, `cue_id`, `subkey`)
+- `extract_acb_to_memory()` — extract waveform bytes per cue without touching disk (`ExtractedAcbTrack`)
+- `extract_acb_unique_to_memory()` — extract each physical waveform **once**, mapping shared cues onto it (`UniqueWaveform` + `AcbCueRef`); ACBs often point several cues at one waveform
+
+High-level decode (extract + HCA decode in one call, per-AWB AFS2 subkey applied automatically):
+
+- `decode_acb_to_wav_from_file()` / `decode_acb_to_wav()` — write decoded WAVs to a directory
+- `decode_acb_to_wav_to_memory()` — return decoded `DecodedAcbTrack`s in memory; encrypted (type-56) ACBs need only the global keycode
+
+Other entry points:
+
+- `AcbBuilder` / `TrackInput` — build ACB/AWB containers
+- `HcaDecoder` — high-level HCA to WAV/PCM decoder; `HcaEncoder` — PCM/WAV to HCA
+- `ClHca` — low-level HCA decoder state machine
+- `extract_usm_file()` / `extract_usm()` — USM extraction (disk); `extract_usm_to_memory()` — in-memory; `UsmBuilder` — build USM
+
+**Python bindings** (`src/python.rs`, behind the `python` feature) mirror this surface. Each disk function has a `*_bytes` in-memory counterpart that takes/returns `bytes` via `Cursor` (no `.to_vec()` copy). The `.pyi` stubs in `cridecoder.pyi` are the source of truth for the Python signatures and must stay in sync with the bindings.
 
 ## Building
 
@@ -89,6 +109,7 @@ Allowed types:
 | `[Fix]`   | Bug fix                                               |
 | `[Chore]` | Maintenance, refactoring, dependency or build changes |
 | `[Docs]`  | Documentation-only changes                            |
+| `[Perf]`  | Performance improvement (no behavior change)          |
 
 Rules:
 

{cridecoder-0.3.3 → cridecoder-0.3.5}/Cargo.lock

@@ -28,7 +28,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cridecoder"
-version = "0.3.3"
+version = "0.3.5"
 dependencies = [
  "byteorder",
  "encoding_rs",
@@ -277,9 +277,9 @@ checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
 [[package]]
 name = "rustc-hash"
-version = "2.1.2"
+version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
 
 [[package]]
 name = "rustix"

{cridecoder-0.3.3 → cridecoder-0.3.5}/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "cridecoder"
-version = "0.3.3"
+version = "0.3.5"
 edition = "2021"
 description = "CRI codec library for ACB/AWB, HCA audio, and USM video extraction"
 license = "MIT"
-authors = ["Team-Haruki"]
-repository = "https://github.com/Team-Haruki/cridecoder"
-homepage = "https://github.com/Team-Haruki/cridecoder"
+authors = ["Seiunx Dev"]
+repository = "https://github.com/seiunx-dev/cridecoder"
+homepage = "https://github.com/seiunx-dev/cridecoder"
 readme = "README.md"
 keywords = ["cri", "hca", "acb", "usm", "audio"]
 categories = ["multimedia::audio", "multimedia::video", "parser-implementations"]

{cridecoder-0.3.3 → cridecoder-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cridecoder
-Version: 0.3.3
+Version: 0.3.5
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -11,7 +11,7 @@ Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: Multimedia :: Video
 License-File: LICENSE
 Summary: CRI codec library for ACB/AWB, HCA audio, and USM video extraction
-Home-Page: https://github.com/Team-Haruki/cridecoder
+Home-Page: https://github.com/seiunx-dev/cridecoder
 License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
@@ -22,16 +22,25 @@ A pure Rust library for CRI Middleware codec encoding and decoding. Supports ACB
 
 ## Credits
 
-This project's CRI format implementation is based on and inspired by [vgmstream](https://github.com/vgmstream/vgmstream), a library for playing streamed audio from video games. Many thanks to the vgmstream contributors for their reverse-engineering work on CRI Middleware formats.
+This project's CRI format implementation is based on and inspired by:
+
+- [vgmstream](https://github.com/vgmstream/vgmstream) — a library for playing streamed audio from video games.
+- [PyCriCodecs](https://github.com/Youjose/PyCriCodecs/) — a Python library for CRI Middleware codecs.
+
+Many thanks to the vgmstream and PyCriCodecs contributors for their reverse-engineering work on CRI Middleware formats.
 
 ## Features
 
 - **ACB/AWB Extraction & Building** — Parse and create CRI ACB audio containers
+- **ACB → WAV in one call** — Extract and decode an ACB straight to WAV; the per-AWB AFS2 subkey is applied automatically for encrypted (type-56) HCA
+- **In-memory APIs** — Every extract/decode/build operation has a variant that works on `bytes`/`Vec<u8>` without touching disk
+- **De-duplicated extraction** — Emit each physical waveform once even when several cues share it
 - **HCA Encoding & Decoding** — Encode PCM to HCA, decode HCA to PCM/WAV
 - **USM Extraction & Building** — Extract or create USM video containers
 - **USM Metadata** — Read and export USM metadata as structured JSON
 - **Key Testing** — Test decryption keys for encrypted HCA files
 - **Encryption Support** — Encode HCA with encryption keys
+- **Python bindings** — `pip install cridecoder` exposes the full API via PyO3
 - **Pure Rust** — No C dependencies, works on any platform Rust supports
 
 ## Usage
@@ -40,7 +49,7 @@ Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-cridecoder = "0.1"
+cridecoder = "0.3"
 ```
 
 ### ACB Extraction
@@ -61,6 +70,46 @@ if let Some(tracks) = tracks {
 }
 ```
 
+### ACB → WAV (decode in one call)
+
+Extract an ACB and decode its HCA tracks straight to WAV. The per-AWB AFS2
+subkey is applied automatically, so encrypted (type-56) ACBs only need the
+global keycode (pass `None` for unencrypted ACBs):
+
+```rust
+use std::path::Path;
+use cridecoder::decode_acb_to_wav_from_file;
+
+let paths = decode_acb_to_wav_from_file(
+    Path::new("audio.acb"),
+    Path::new("output/"),
+    None, // Option<u64> global keycode
+).unwrap();
+
+for path in &paths {
+    println!("Wrote: {path}");
+}
+```
+
+### In-memory extraction (no disk I/O)
+
+`extract_acb_to_memory` returns the waveform bytes per cue. For ACBs where
+several cues share one physical waveform, `extract_acb_unique_to_memory`
+emits each waveform once and lists the cues that reference it:
+
+```rust
+use std::io::Cursor;
+use cridecoder::extract_acb_unique_to_memory;
+
+let acb = std::fs::read("audio.acb").unwrap();
+let waveforms = extract_acb_unique_to_memory(Cursor::new(acb), None).unwrap();
+
+for wf in &waveforms {
+    let cue_names: Vec<_> = wf.cues.iter().map(|c| c.name.as_str()).collect();
+    println!("{} bytes ({}) → {:?}", wf.data.len(), wf.extension, cue_names);
+}
+```
+
 ### ACB Building
 
 ```rust
@@ -141,6 +190,34 @@ let mut output = Cursor::new(Vec::new());
 builder.build(&mut output).unwrap();
 ```
 
+## Python
+
+The same API is available from Python via PyO3 bindings:
+
+```bash
+pip install cridecoder
+```
+
+```python
+import cridecoder
+
+# Extract + decode an ACB to WAV bytes in one call (no disk I/O).
+# Encrypted (type-56) ACBs only need the global key; pass key=None otherwise.
+acb = open("audio.acb", "rb").read()
+for track in cridecoder.decode_acb_to_wav_bytes(acb, key=None):
+    print(track["name"], track["extension"], len(track["data"]))
+
+# De-duplicated extraction: each physical waveform once, with its cues.
+for wf in cridecoder.extract_acb_unique_bytes(acb):
+    print(wf["extension"], [c["name"] for c in wf["cues"]])
+
+# Decode a standalone HCA (key/subkey for encrypted files).
+wav = cridecoder.decode_hca_bytes(open("audio.hca", "rb").read())
+```
+
+Every disk-based function has an in-memory `*_bytes` counterpart that takes and
+returns `bytes`. See `cridecoder.pyi` for the full typed signatures.
+
 ## Supported Formats
 
 | Format | Description | Operations |

{cridecoder-0.3.3 → cridecoder-0.3.5}/README.md

@@ -4,16 +4,25 @@ A pure Rust library for CRI Middleware codec encoding and decoding. Supports ACB
 
 ## Credits
 
-This project's CRI format implementation is based on and inspired by [vgmstream](https://github.com/vgmstream/vgmstream), a library for playing streamed audio from video games. Many thanks to the vgmstream contributors for their reverse-engineering work on CRI Middleware formats.
+This project's CRI format implementation is based on and inspired by:
+
+- [vgmstream](https://github.com/vgmstream/vgmstream) — a library for playing streamed audio from video games.
+- [PyCriCodecs](https://github.com/Youjose/PyCriCodecs/) — a Python library for CRI Middleware codecs.
+
+Many thanks to the vgmstream and PyCriCodecs contributors for their reverse-engineering work on CRI Middleware formats.
 
 ## Features
 
 - **ACB/AWB Extraction & Building** — Parse and create CRI ACB audio containers
+- **ACB → WAV in one call** — Extract and decode an ACB straight to WAV; the per-AWB AFS2 subkey is applied automatically for encrypted (type-56) HCA
+- **In-memory APIs** — Every extract/decode/build operation has a variant that works on `bytes`/`Vec<u8>` without touching disk
+- **De-duplicated extraction** — Emit each physical waveform once even when several cues share it
 - **HCA Encoding & Decoding** — Encode PCM to HCA, decode HCA to PCM/WAV
 - **USM Extraction & Building** — Extract or create USM video containers
 - **USM Metadata** — Read and export USM metadata as structured JSON
 - **Key Testing** — Test decryption keys for encrypted HCA files
 - **Encryption Support** — Encode HCA with encryption keys
+- **Python bindings** — `pip install cridecoder` exposes the full API via PyO3
 - **Pure Rust** — No C dependencies, works on any platform Rust supports
 
 ## Usage
@@ -22,7 +31,7 @@ Add to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-cridecoder = "0.1"
+cridecoder = "0.3"
 ```
 
 ### ACB Extraction
@@ -43,6 +52,46 @@ if let Some(tracks) = tracks {
 }
 ```
 
+### ACB → WAV (decode in one call)
+
+Extract an ACB and decode its HCA tracks straight to WAV. The per-AWB AFS2
+subkey is applied automatically, so encrypted (type-56) ACBs only need the
+global keycode (pass `None` for unencrypted ACBs):
+
+```rust
+use std::path::Path;
+use cridecoder::decode_acb_to_wav_from_file;
+
+let paths = decode_acb_to_wav_from_file(
+    Path::new("audio.acb"),
+    Path::new("output/"),
+    None, // Option<u64> global keycode
+).unwrap();
+
+for path in &paths {
+    println!("Wrote: {path}");
+}
+```
+
+### In-memory extraction (no disk I/O)
+
+`extract_acb_to_memory` returns the waveform bytes per cue. For ACBs where
+several cues share one physical waveform, `extract_acb_unique_to_memory`
+emits each waveform once and lists the cues that reference it:
+
+```rust
+use std::io::Cursor;
+use cridecoder::extract_acb_unique_to_memory;
+
+let acb = std::fs::read("audio.acb").unwrap();
+let waveforms = extract_acb_unique_to_memory(Cursor::new(acb), None).unwrap();
+
+for wf in &waveforms {
+    let cue_names: Vec<_> = wf.cues.iter().map(|c| c.name.as_str()).collect();
+    println!("{} bytes ({}) → {:?}", wf.data.len(), wf.extension, cue_names);
+}
+```
+
 ### ACB Building
 
 ```rust
@@ -123,6 +172,34 @@ let mut output = Cursor::new(Vec::new());
 builder.build(&mut output).unwrap();
 ```
 
+## Python
+
+The same API is available from Python via PyO3 bindings:
+
+```bash
+pip install cridecoder
+```
+
+```python
+import cridecoder
+
+# Extract + decode an ACB to WAV bytes in one call (no disk I/O).
+# Encrypted (type-56) ACBs only need the global key; pass key=None otherwise.
+acb = open("audio.acb", "rb").read()
+for track in cridecoder.decode_acb_to_wav_bytes(acb, key=None):
+    print(track["name"], track["extension"], len(track["data"]))
+
+# De-duplicated extraction: each physical waveform once, with its cues.
+for wf in cridecoder.extract_acb_unique_bytes(acb):
+    print(wf["extension"], [c["name"] for c in wf["cues"]])
+
+# Decode a standalone HCA (key/subkey for encrypted files).
+wav = cridecoder.decode_hca_bytes(open("audio.hca", "rb").read())
+```
+
+Every disk-based function has an in-memory `*_bytes` counterpart that takes and
+returns `bytes`. See `cridecoder.pyi` for the full typed signatures.
+
 ## Supported Formats
 
 | Format | Description | Operations |

{cridecoder-0.3.3 → cridecoder-0.3.5}/cridecoder.pyi

@@ -71,19 +71,26 @@ def extract_acb_unique_bytes(acb_data: bytes) -> list[dict[str, object]]:
     ...
 
 def decode_acb_to_wav(
-    acb_path: str, output_dir: str, key: Optional[int] = ...
+    acb_path: str,
+    output_dir: str,
+    key: Optional[int] = ...,
+    threads: Optional[int] = ...,
 ) -> list[str]:
     """Extract an ACB and decode its HCA tracks straight to WAV files.
 
     The per-AWB AFS2 subkey is applied automatically, so encrypted (type-56)
     ACBs only need the global ``key`` (omit/``None`` for unencrypted ACBs).
-    Non-HCA tracks are written verbatim with their original extension. Returns
+    Non-HCA tracks are written verbatim with their original extension.
+    ``threads`` selects multithreaded decoding (``None`` = serial, ``0`` = all
+    CPU cores, ``N`` = N threads); output is identical regardless. Returns
     the list of written file paths.
     """
     ...
 
 def decode_acb_to_wav_bytes(
-    acb_data: bytes, key: Optional[int] = ...
+    acb_data: bytes,
+    key: Optional[int] = ...,
+    threads: Optional[int] = ...,
 ) -> list[dict[str, object]]:
     """In-memory counterpart of :func:`decode_acb_to_wav` (no disk I/O).
 
@@ -134,11 +141,14 @@ def decode_hca(
     wav_path: str,
     key: Optional[int] = ...,
     subkey: Optional[int] = ...,
+    threads: Optional[int] = ...,
 ) -> dict[str, int]:
     """Decode an HCA file to a WAV file.
 
     ``key``/``subkey`` apply the type-56 decryption keycode for encrypted HCA
-    (no-op for unencrypted files). Returns a dict with ``sample_rate``,
+    (no-op for unencrypted files). ``threads`` selects multithreaded decoding:
+    ``None`` decodes serially, ``0`` uses all CPU cores, ``N`` uses N threads;
+    output is byte-identical regardless. Returns a dict with ``sample_rate``,
     ``channels``, ``block_count``, ``block_size``, ``encoder_delay`` and
     ``samples_per_block``.
     """
@@ -148,8 +158,9 @@ def decode_hca_bytes(
     hca_data: bytes,
     key: Optional[int] = ...,
     subkey: Optional[int] = ...,
+    threads: Optional[int] = ...,
 ) -> bytes:
-    """Decode HCA bytes to WAV bytes in memory (``key``/``subkey`` as in :func:`decode_hca`)."""
+    """Decode HCA bytes to WAV bytes in memory (``key``/``subkey``/``threads`` as in :func:`decode_hca`)."""
     ...
 
 def encode_hca_bytes(

cridecoder-0.3.5/examples/hca_attrib.rs

@@ -0,0 +1,63 @@
+//! In-memory HCA decode benchmark: decodes every block from a preloaded buffer
+//! (no file I/O in the loop) and prints an FNV hash of the PCM output so
+//! optimizations can be checked for bit-exactness against a baseline.
+use cridecoder::hca::ClHca;
+use std::env;
+use std::time::Instant;
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let hca_file = args.get(1).map(|s| s.as_str()).unwrap_or("music_5031.hca");
+    let iters: usize = args.get(2).and_then(|s| s.parse().ok()).unwrap_or(400);
+
+    let data = std::fs::read(hca_file).unwrap();
+    let mut hca = Box::new(ClHca::new());
+    hca.decode_header(&data).unwrap();
+    let info = hca.get_info().unwrap();
+    println!(
+        "blocks={} block_size={} ch={} encrypted={}",
+        info.block_count, info.block_size, info.channel_count, info.encryption_enabled
+    );
+    println!(
+        "version={:#x} min_res={} max_res={} stereo_bands={} hfr_bands_per_group={} ms_stereo={}",
+        hca.version,
+        hca.min_resolution,
+        hca.max_resolution,
+        hca.stereo_band_count,
+        hca.bands_per_hfr_group,
+        hca.ms_stereo
+    );
+
+    let hs = info.header_size as usize;
+    let bs = info.block_size as usize;
+    let n = info.block_count as usize;
+    let mut frame = vec![0u8; bs];
+    let mut pcm = vec![0i16; info.samples_per_block * info.channel_count as usize];
+
+    // Correctness hash over one full decode.
+    let mut hash: u64 = 0xcbf29ce484222325;
+    for b in 0..n {
+        frame.copy_from_slice(&data[hs + b * bs..hs + (b + 1) * bs]);
+        hca.decode_block(&mut frame).unwrap();
+        hca.read_samples_16(&mut pcm);
+        for &s in &pcm {
+            hash = (hash ^ (s as u16 as u64)).wrapping_mul(0x100000001b3);
+        }
+    }
+    println!("pcm fnv hash: {:016x}", hash);
+
+    let start = Instant::now();
+    for _ in 0..iters {
+        for b in 0..n {
+            frame.copy_from_slice(&data[hs + b * bs..hs + (b + 1) * bs]);
+            hca.decode_block(&mut frame).unwrap();
+            hca.read_samples_16(&mut pcm);
+            std::hint::black_box(&pcm);
+        }
+    }
+    let el = start.elapsed();
+    println!(
+        "in-memory decode: {:.3} ms/decode",
+        el.as_secs_f64() * 1000.0 / iters as f64
+    );
+}

cridecoder-0.3.5/examples/hca_parallel.rs

@@ -0,0 +1,60 @@
+//! Benchmark and verify decode_to_wav_parallel against the serial decoder.
+use cridecoder::HcaDecoder;
+use std::env;
+use std::time::Instant;
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let hca_file = args.get(1).map(|s| s.as_str()).unwrap_or("music_5031.hca");
+    let iters: usize = args.get(2).and_then(|s| s.parse().ok()).unwrap_or(50);
+    let threads: usize = args.get(3).and_then(|s| s.parse().ok()).unwrap_or_else(|| {
+        std::thread::available_parallelism()
+            .map(|n| n.get())
+            .unwrap_or(1)
+    });
+
+    // Correctness: byte-identical WAV output.
+    let mut serial_out = Vec::new();
+    let mut parallel_out = Vec::new();
+    {
+        let mut d = HcaDecoder::from_file(hca_file).unwrap();
+        d.decode_to_wav(&mut serial_out).unwrap();
+        let mut d = HcaDecoder::from_file(hca_file).unwrap();
+        d.decode_to_wav_parallel(&mut parallel_out, threads)
+            .unwrap();
+    }
+    assert_eq!(serial_out.len(), parallel_out.len(), "length mismatch");
+    assert!(serial_out == parallel_out, "WAV bytes differ");
+    println!(
+        "byte-identical: yes ({} bytes, {} threads)",
+        serial_out.len(),
+        threads
+    );
+
+    let start = Instant::now();
+    for _ in 0..iters {
+        let mut d = HcaDecoder::from_file(hca_file).unwrap();
+        let mut sink = std::io::sink();
+        d.decode_to_wav(&mut sink).unwrap();
+    }
+    let serial = start.elapsed();
+
+    let start = Instant::now();
+    for _ in 0..iters {
+        let mut d = HcaDecoder::from_file(hca_file).unwrap();
+        let mut sink = std::io::sink();
+        d.decode_to_wav_parallel(&mut sink, threads).unwrap();
+    }
+    let parallel = start.elapsed();
+
+    println!(
+        "serial:   {:.3} ms/decode",
+        serial.as_secs_f64() * 1000.0 / iters as f64
+    );
+    println!(
+        "parallel: {:.3} ms/decode ({} threads, {:.2}x)",
+        parallel.as_secs_f64() * 1000.0 / iters as f64,
+        threads,
+        serial.as_secs_f64() / parallel.as_secs_f64()
+    );
+}

{cridecoder-0.3.3 → cridecoder-0.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "cridecoder"
-version = "0.3.3"
+version = "0.3.5"
 description = "CRI codec library for ACB/AWB, HCA audio, and USM video extraction"
 readme = "README.md"
 license = { text = "MIT" }