Changelog

All notable changes to this project will be documented in this file.

Unreleased

⛰️ Features

• cli: Implement doc sub-command in the CLI tool (03cdc30)

  Integrate the mabo-doc crate into the CLI to be able to generate the docs for any project (or individual files).

• compiler: Introduce a simplified schema for easier codegen (131e7b4)

  The parser's data structures can be a bit hard to use in the code generator, and some upcoming features would need to be rebuilt in every code generator.

  By introducing a simplified version of the schema data structures, common conversion logic can be moved into the compiler and overall make the data structures more convenient to use.

• doc: Implement a HTML documentation generator (b72ba33)

  A new generator that doesn't create implementations for a language, but instead creates HTML documentation for a schema.

  This is the first building block to provide a new CLI command that can generate the documentation for any schema, similar to how rustdoc can generate local documentation for Rust files or projects.

• go: Generate new Size interface (5cc3c2f)

  The newly defined Size interface allows to calculate the encoded size of an instance and pre-allocate a byte vector. It can be helpful for significantly large payloads that would do several re-allocations of a buffer otherwise.

• go: Implement the CLI for the Go code generator (d3dc8d7)

  Although the Go code generator existed as library, it still needed the CLI binary to drive the actual codegen step and write files to disk.

• lsp: Properly handle UTF-16 char offsets (f74d625)

  The LSP requires all char indices to be in UTF-16 byte offsets by default. But Rust uses UTF-8, so the right offset has to be calculated accordingly.

• lsp: Improve logging setup (5962776)

  Overall improve the logging output for the LSP client, and write the logs to a file as well.

• lsp: Handle CLI args for different communication channels (670d9d1)

  Implement handling of the common CLI arguments that define how to establish the client/server communication channel.

  The options are defined, but not all are supported as of yet.

• lsp: Define and read configuration values (192d943)

  Create a sample configuration in the editor plugin and read it from the LSP side (as well as reloading it on changes).

• lsp: Setup semantic token provider (80d3c5f)

  Create a basic setup that allows for semantic token provision by the LSP server. This currently doesn't provide any actual tokens, just sets it up for future use.

• lsp: Exclude -lsp suffix from the config and naming (318dd7a)

  It's not needed to repeat the LSP naming everywhere in the config and naming of the VSCode extension, and can simply be omitted.

• lsp: Report schema validation errors (ca1f300)

  Extend the diagnostic capabilities by reporting validation errors from stef-compiler as well.

• lsp: Use local time with shorter format (e9407a4)

  Change from UTC time to local time in any log messages, and shorten the time format to only the time component (stripping off the date).

• lsp: Improve overall handling of code locations (dc61f6e)

  The first thing is the introduction of the line-index crate from rust-analyzer, which makes utf-16 conversions simple and fast.

  In addition, the Parser error variant now carries the location of where it occurred, rather than highlighting the whole schema file as the location.

• lsp: Support incremental file changes (0156f3e)

  This allows for faster updates as the editor can send only changed content instead of the whole document on each modification.

• lsp: Generate semantic tokens for schema files (57b59ee)

  Provide semantic tokens for schema files to provide better code highlighting. Currently, not all possible tokens are supplied yet.

• lsp: Provide document symbols (23ee2d3)

  Visible in VSCode in the outline component, this allows to render a tree view of a schema's structure.

• lsp: Provide hover information (db0c603)

  Generate hover information for any element that is hovered by the user. This currently only replies the documentation for the element (if present), and calculates the next available ID for struct fields, enum variants and enum variant fields.

• lsp: Calculate the wire size of fields on hover (2c7d8b3)

  The min and max required byte size on the wire (when encoded) can be calculated for all types except generics and external types.

  This will now be shown on hover allow users to guess the size of a struct or enum variant easier.

• lsp: Load all files at start and improve state updates (3b9e342)

  Scan the project during initialization and add all found files to the state. Also, only remove files from the state when they're deleted, not when closed.

• lsp: Keep track of project file location (baca562)

  Extend the mabo-project crate to additional store the location from wheret the project file was loaded.

  This is currently used to log the location in the LPS when loading a folder and searching for Mabo projects in it.

• lsp: Support all official position encodings (e6d4884)

  Until now the server always assumed UTF-16, as that is the default in Visual Studio Code, but other editors like Neovim might ask for a different encoding.

  This now allows to run the LSP server with any of the official encodings UTF-8, UTF-16 and UTF-32.

• lsp: Make hover info configurable (2b22a2d)

  As a way to try out config loading from the LSP, create settings that allow to hide the next ID and wire size information in the hover of elements.

• parser: Add simd feature to the parser (443c32c)

  The winnow crate has a simd feature which enables some extra performance improvements. This might limit possible target platforms for compilations so the flag is exposed as optional feature on the parser crate instead.

  All binary crates will use this flag, but potential users of the parser crate can omit the feature if it causes issues.

• vscode: Provide command to restart the LSP server (21e5001)

  Although mostly useful during development, add a custom command to the VSCode extension, which allows to restart the LSP server.

• vscode: Extend metadata for the vscode extension (1dd3ca8)
• Implement encoding in the Rust codegen (2787b51)
• Simplify encoding logic (e8205bc)
• Implement basic decoding logic (f67c572)
• Skip any decoding for unit structs/variants (8f5a4ec)
• Create playground crate and fix issues (b55862f)
• Extend syntax highlighting (0d83290)
• Adjust encoding of option<T> (39c6ccb)
• Unroll container type en-/decoding (3d64436)

  Instead of relying on generic implementations for the Rust generated code that en- or decodes the data, these are defined as closures.

  The main benefit is that it allows optimized calls that would not be possible through the trait system (for example a fast encoding of Vec<u8> instead of the regular Vec<T> encoding that would write the bytes one-by-one).

• Implement Decode for non-zero types (8f7e85e)
• Accept glob patterns for schema input files (d8f5e43)
• Add non-zero collection types (e0fc43e)

  This expands from non-zero integer values to non-zero collections, meaning non_zero<T> specializations where T is one of string, bytes, vec<T>, hash_map<K, V> or hash_set<T>.

  Any other non_zero<T> types are now refused as there is no clear way of defining what non-zero means for other types (or at least not a single correct way).

  Also, snapshot tests includes missing adjustments from the last commits that introduced further #[allow(...)] attributes in the Rust implementation.

• Validate for unique IDs in structs and enums (3295f0c)

  Add the first "compiler" validation logic, which ensures that each ID:

  • in named or unnamed fields of a struct or enum variant is unique
  • in variants of an enum is unique

• Validate field and variant name uniqueness (9137e20)

  Ensure that all fields in a struct or enum variant are uniquely named, as well as all variants within a single enum.

• Nicely report compiler errors (2737f20)

  Extend parser structs with spans to generate nice error reports with annotated source code, like being done for parser errors.

• Verify that generics are unique and used (f3e0ced)

  All defined generics in structs or enums must have a unique name and be used in some way inside the definition of the element. These new verifications in the compiler ensure the rules are upheld.

• Improve error output on compile error (bd15eba)
• Enable glob parsing for CLI path arguments (b44bc1b)

  In addition to only accepting a list of files for the check and format command, the input is now treated as glob pattern.

• Add snapshot tests for compiler errors (0efc118)

  Verify good compiler error output by creating several snapshot tests. Also, slightly improve some of the messages.

• En-/decode non-zero integers directly (f165d61)

  Instead of driving the encoding and decoding of non-zero integer types through the Encode/Decode trait, use direct function calls which allows for specialized calls with better performance.

• Ensure uniqueness of all module declarations (d09e182)

  Verify that all declared elements within a module (including the schema root which is a module itself) have a unique name so they can't collide.

• Resolve all local types in schemas (2b518ab)

  Check that all external types defined in any struct or enum definition exist within the bounds of the schema and give nice error messages in case a type can't be located.

• Resolve external schema imports (62feaa0)

  Implement the resolution of structs and enums that come from an external schemas, being used in the local schema file.

  Probably many edge cases can cause an error, dependency cycles for example. Also, error types are a bit of a mess and will be improved in coming commits.

• Improve error reporting for cross-schema errors (c380ace)

  Type resolution that goes across a single file now shows code snippets for both the use side and declaration side to better pinpoint the problem.

• Validate the element amount in tuples (abcee05)

  A valid tuple type must have between 2 and 12 elements. Empty tuples carry no data at all, tuples with one element are equivalent to the type of that single element and tuples with 13 or more elements are above a reasonable limit.

• Make bytes type customizable (eaa06ae)

  Add a new option to stef-build that allows to choose between the default Vec<u8> and bytes::Bytes as type used for the STEF bytes type in Rust.

• Create macro for easy code inclusion (7ec3e09)

  Provide a macro that makes inclusion of generates Rust source code easier. Also, generate all files into a subfolder to avoid any collisions with other generated files.

• Add basic Go code generator (e7394c7)

  Although incomplete in a few spots, this is a starting point for converting schema files to source code of the Go programming language.

• Create basic language server for schemas (4be4404)

  Using an LSP allows providing editor agnostic support for schema files. Currently only reporting errors in schemas (and not handling eventual UTF-16 encoding).

• Introduce sizing methods to calculate needed bytes (ab8f4f7)

  Each struct and enum in a schema can now calculate its total encoded byte size. As each collection must be iterated it can be a costly operation but it might be faster (or sometimes even required) to allocate a buffer upfront instead of dynamically growing it.

• Adjust encoding to include a field encoding marker (4dd6ba3)

  The decoding didn't properly handle unknown field IDs. By introducing a new marker that is combined with the field ID, it allows the decoder to skip over the content of a field and continue properly decoding any element, without knowing the exact detail of each field.

• Allow to put comments on the schema file itself (9200cf3)

  It's now possible to attach a global comment to the root of the schema by placing a comment on the very top. The comment block needs to be separated by a newline to split between schema and definition comments.

• Allow to omit IDs and derive them instead (76a8649)

  Similar to Rust basic enums, the identifier for each variant doesn't have to be specified explicitly. Instead it can be derived by continuing to count upwards from the last explicit value.

  Therefore, now the field IDs as well as enum variant IDs can be omitted and are derived by the compiler. They can be mixed as well to create gaps in the ID range.

• Rename project to Mabo (1085e24)
• Introduce Mabo project files (b5798cf)

  Adding dedicated Mabo.toml files allows to define the root of projects as well as kicking off the start of project metadata and future packaging.

  This can later extend into an ecosystem that allows to distribute schema file collections and consume them through a dependency management system.

• Account for optional IDs in the tmLanguage definition (d27361e)
• Switch from full/fat to thin LTO (d5ccf61)

  This slightly increases binary size, but provides much better compile speed in release mode. Overall performance should not decrease a lot and if needed later, full/fat LTO can be turned back on again.

• Track keywords, punctuation and delimiters (e8e42ef)

  In addition to the more valuable parts of a schema that describe the data structures, now the remaining pieces that make up a schema are tracked as well.

  That means characters like commas, semicolons, open/close braces and others are collected so their exact location in the source file can be used by the LSP and other components.

  A few places still don't track this information as they need some further refactoring first, but should be doing so in the following commits.

• Track double colon location in external type paths (6a6de5a)

  Keep track of the double colons that separate the individual segments of the path in external types.

• Track more element locations of import statements (ba12d5e)

  Only the keyword location was repoted as semantic token (in the LSP), but more information was already available which is now properly added to the token list.

• Improve CLI output coloring (c78dd04)

  Inspired by https://github.com/rustic-rs/rustic, adjust the clap default style for a more delightful color theme.

🐛 Bug Fixes

• book: Correct the favicon URL (d66ad2e)

  This was set to the root, but the site is currently deployed under the /stef/ path on Codeberg Pages.

• book: Point directly to first user guide/reference pages (22e20fe)

  Instead of pointing to an empty page, link to the first currently filled page of both the user guide and reference.

• book: Adjust path for the .nojekyll file (7c1d68c)

  The creation of the .nojekyll file was off, due to the previous cd into the book folder.

• doc: Collect overview docs until the first empty line (160fbcd)

  In Markdown, a line break is only inserted if there is at least one empty line between paragraphs. Therefore, collect all lines until the first empty line is found, instead of simply taking the first line only.

  This fixes potential cut-off of the overview item docs.

• doc: Fix broken PR links in the changelog (359f02f)

  Due to how repo placeholders were used in git-cliff, those were mangled and then later not properly replaced with the URL anymore.

• lsp: Remove closed documents from the state (a84018c)

  To avoid growing the list of open files indefinitely, remove them from the state of the server when closed in the editor.

• lsp: Properly reply with error messages (740c46d)

  If an error happens in the request handler, return a proper error to back to the client instead of shutting down the whole server.

• lsp: Properly reply to unknown requests (6bb08d5)
• lsp: Solve the hanging shutdown problem (a9836cb)

  The connection instance was kept alive, which caused the background threads to idle as they were waiting for all channels to be dropped.

• lsp: Work around missing initialized call (c197855)

  The client is supposed to send an initialized notification, but that never happens, so we call it ourselves and solve a few additional issues around the existing code that was never triggered due to the lack of the notification.

• Don't double wrap optional types in decode (a6d3d4b)
• Extend playground and correct issues (ed24491)
• Missing semicolon in tuple structs (d616e92)
• Adjust for new clippy lints (8855572)
• Compile more schemas and fix errors (ba90911)
• Create specialized encoding for non-zero types (39420b8)
• Suppress warning about dereference operator (21b2f69)
• Correctly check aliases and imports unique identifiers (9c88e32)

  Aliases couldn't be checked to a non-optimal struct format in its first version and imports were skipped when then don't have a final type element.

• Make tuple struct fields public in Rust (7dcc660)

  If defining a unnamed struct (tuple struct), the Rust generator wasn't marking the fields as public, making the inaccessible.

• Adjust imports to look in the parent module (ca222db)

  For now, all imports are for external schemas only and those are expected to be placed next to the module where these imports are declared. Therefore, the generated Rust code should look in the parent module instead of in its own modules.

• Encode options in unnamed fields properly (0a4f3d5)

  Special handling for optional values was already done for named fields, but the same behavior was missing from unnamed fields.

• Comments were rendered incorrectly after the type split (9116c87)

  When splitting up the Comment type to allow tracking the span of individual lines, the printing in both the schema formatter and code generators broke.

  In addition, several test snapshots were not updated during that change either.

• Size wasn't calculated correctly for zero value varints (e29ee00)

  A special case for zero integers wasn't covered when calculating the required size in the varint encoding.

  Also, extend the unit tests for the module to verify all en- and decoding functions work correctly.

• Save JSON version of the TextMate language definition (5f7838d)

  This definition was originally ignored as it is auto-generated from the YAML version. But the book no depends on it and including it in Git avoids suddenly build errors for fresh clones.

• Correct size calculation for field IDs (e56dd8d)

  The calculation for required bytes of a field ID did not take the recently added field encoding into account, which could potentially result in too small values.

• Expand tmLanguage regexes for tuples and arrays (b589eac)

  The tuples and arrays were correctly parsed for individual types, but the field regex didn't include possible token which made it fail to include those types in them matching.

• Update winnow to fix broken integer parsing (1f1790a)

  Version 0.6 introduced a bug that caused the literal 0 not to be parsed as valid integer anymore. This was fixed with 0.6.1.

• Properly calculate end marker size (27c1bf3)

  Properly calculate the end marker as always one byte, as the regular sizing functions for integers define it wrongly as zero-length. That is, because a value of 0 encoded as varint would have a length of zero.

📚 Documentation

• book: Extend the schema creation guide (f35a942)

  Explain the components of a simple schema and describe the commonly used data types.

• book: Use Vuepress for the book (9a0b0d9)
• book: Tweak colors and page details (c43d077)

  Adjust the branding colors for better visual contrast and flip a few config values of Vitepress.

• book: Expand the introduction page (6f3c902)
• book: Explain how identifiers are encoded in the wire format (e45b743)
• book: Fix a few typos (c891908)
• book: Include the changelog in the book (5b32249)
• book: Describe the content of the Mabo.toml project files (a31ecc2)

  Explain the need for the project files as well as all the possible settings that can be set as content.

• book: Add additional metadata to each page (601ac4c)

  Apply a few metadata improvements reported in Lighthouse, as well as increasing the information for OpenGraph display.

  This allows for a richer link display on several platforms when shared.

• book: Describe details about derived identifiers (616dfbf)

  Explain that it is possible to automatically derive identifiers instead of always explicitly defining them. Also, move some encoding details from the ideas section to the wire format as those are already implemented.

• book: Remove table of contents (aeaa69d)

  The table of contents isn't needed as the automatic "On this page" navigation fulfills the same purpose.

• book: Create files for each navigation element (9f45b86)

  Some sections in the navigation didn't have a file associated with it yet, leading to 404 pages. Also, extend the generators category with all planned language generators (still empty though).

• book: Extend the docs about cli and generators (a1474d9)

  Extend the docs around these sections and create an example in mabo-cli which auto-generates the doc pages for the CLI subcommands.

• book: Remove implemented ideas (d8b987f)

  Remove the sections from the ideas sections that have already been implemented recently.

• book: Remove incomplete sections (e06754d)

  Remove the sections from the config which are clearly not ready and basically a blank space. The Markdown files are kept in place as reminder for these features.

• book: Explain the schema importing mechanism (c6b3688)

  This section was still empty and despite even now being somewhat incomplete, at least provides some basic explanation of the importing system.

• doc: Replace askama with rinja (23e943b)

  The maintainers of rustdoc and docs.rs forked the askama crate and fixed a lot of the pain points existing in askama.

  Therefore, switch to rinja (the fork) as a better alternative for rendering the docs of Mabo schemas.

• parser: Add missing doc for new field (7f4ca98)
• vscode: Add dedicated readme for the extension (38af273)
• Generate more stylish changelog (5319fb3)
• Add changelog (5b2a15c)
• Update flatbuffers homepage in the book (c469e4e)
• Update Java links to 21 release (e151095)
• Expand user guide for basic setup (d44c12d)
• Add a few (far) future ideas (bbdc490)

  Outline a few ideas that would be great to have in the future, but require a significant amount of work. Therefore, these have no time frame attached to them.

• Update changelog and improve change items (fa01844)

  Re-generate the changelog and in addition, tweak the configuration for changelog generation for a better formatted output and fix the commit links as well.

• Adjust git-cliff config for latest version (7d58f6b)

  The latest v1.4.0 of git-cliff changes the tag_pattern setting from a glob pattern to a RegEx pattern. Therefore, the current setting needs slight tweaking.

• Slightly tweak the git-cliff configuration (d7dc280)

  Simplify a few settings in git-cliff, but most importantly escape the commit messages as they can contain some characters that can be misinterpreted as HTML tags.

• Update project setup instructions (66b95bf)

  Correct the code samples in the guide to use the new APIs for generating Rust code and including the files.

• Explain the min/max amount of tuple elements (5e74489)

  Clarify why tuples must contain between 2 and 12 types, especially the arbitrary limit of 12 elements.

• Highlight schema files (b6b595c)

  Adjust the highlighting component of mdbook to get syntax highlighting for the Stef schema files. As a nice side effect, remove any unused languages from the highlighter to reduce the file size.

• Fix a few formatting errors in the book (78ba8eb)

  Some anchors were named wrong and offsets in the Python files were wrong, resulting in unwanted whitespace.

• Add (empty) entries for existing generators (078c50a)
• Vastly improve API docs throughout all crates (afb8a0e)

⚡ Performance

• Extend the benchmark for better resolving checks (2074449)

  The current schema generated for benchmarks on large schemas didn't generate any definitions that use type references. Therefore, the benchmark didn't give good insight on type resolution timing.

• Use a faster hasher in compiler and LSP (4eb37aa)

  By applying the same hasher as in Rust's compiler, performance can be improved wherever a hash map or set is used.

  This currently has the most visible impact on the compiler's validation step as it internally makes heavy use of hash maps.

• Add benchmark for vu128 varint encoding (d9448f4)

  Add a benchmark for a different approach to variable-length integer encoding called vu128, described in https://john-millikin.com/vu128-efficient-variable-length-integers

🚜 Refactor

• compiler: Simplify some type resolution steps (ae1cf34)
• go: Simplify indenting logic (7425a11)

  Use a dedicated type that implements the Display trait, which allows for a much simpler way of expressing and forwarding indents.

• lsp: Avoid unwraps and properly handle errors (bcbb016)
• lsp: Move logging logic into its own module (ef1139b)
• lsp: Replace tower-lsp with lsp-server (51645a8)

  The tower-lsp crate appears to be somewhat unmaintained in the recent months and the lsp-server crate is made by the people behind rust-analyzer.

  In addition, the LSP server doesn't need a full async runtime as LSP communication is only with a single client and done in serial.

  This change cuts down on several dependencies, reducing both build time and binary size.

• lsp: Move elements out of main.rs (225a683)
• lsp: Group handler related modules together (f80d7da)

  Move all the modules that are specific to the handler into their own module to thin out the root module.

• lsp: Use the same pattern for similar functions (0e15394)

  Adjust a few internal functions with similar patterns to behave the same way.

• lsp: Remove unused env var settings (d8d57f1)

  These environment variables (which controlled the logging output) were originally used, but for some while the logging settings are already fixed in code.

• vscode: Run TypeScript compiler on the extension (d926afa)

  As part of the linting step, run the tsc TypeScript compiler on the code base to ensure the type usage is actually correct, as esbuild only strips type information.

  Also, apply the default tsconfig.json from fresh Bun projects (bun init).

• Generate definitions and impls together (b32bcfd)
• Rename test file (86536c9)
• Switch to more lightweight bench crate (3870a6c)
• Move common deps to the workspace root (584fa3e)
• Create benchmarks for the compiler (f31f94e)
• Enable more clippy lints and unify them (3c206de)

  Ensuring consistent code quality through lints within all the crates that are part of this project.

• Transform some tests into snapshot tests (0f69ed5)
• Rename stef-cli crates binary to stef (92f039b)

  Although the package is named stef-cli to not clash with the stef library crate, the binary should still be named stef.

• Use underscore in schema file names (b43e779)

  As part of the type resolution, module names are derived from the file name. Thus, the file name must adhere to the module naming rules.

  This replaces all dashes - with underscores _ in the schema files used for snapshot testing.

• Simplify transformation of name elements (2acd7b7)

  Instead of manually constructing the Name instances, use the From/Into traits to do so automatically and with less code.

• Add schema as snapshot description (137d2cd)

  Include the source schema into snapshots for easier verification as this displays the schema together with the output of each snapshot in review mode.

• Reorganize the stef-compiler crate (5d430be)

  Shift several components around for better structure, expose all the possible errors on the API and document any publicly visible types.

• Improve syntax highlighting (827ae44)

  Add a few more token markers for literals and overall improve the way elements are detected and marked.

• Centralize lint settings with new Rust 1.74 feature (a9e0800)

  Rust 1.75 stabilizes a new [lints] setting in Cargo.toml, that allows to define common lints in a central place instead of having to repeatedly define them and keep them in sync in each crate of the workspace.

• Simplify several code definitions (b166664)

  Besides minor code cleanups and deduplications, an explicit lifetime could often be elided.

• Omit spans from debug prints (5b79acb)

  Spans are rarely useful in the Debug representation of a struct and clutter the snapshots a lot. A custom derive macro mimics the stdlib's macro but filters out any fields that use the Span struct.

• Move doc, lsp and meta over to the compiler structs (facee4a)

  These crates were still working directly on top of the stef_parser crate's types, but can get the same benefits as the other crates by depending on the stef_compiler's simplified structs instead.

• Replace owo-colors with anstream/anstyle (e831c05)

  The anstream and anstyle crates look more promising and additionally allow to expose the on the API if needed, without restricting to a specific terminal coloring crate.

  Also, the owo-colors crate contained some unmaintained dependencies.

• Switch generic types from unnamed to named (d0e6ec1)

  As the amount of values contained in generic built-in types grows, it's better to convert these to named structs so the values have a clearer meaning. Also, the hash_map type is now split into individual fields for the key and value type.

• Introduce a container for punctuation (554008d)

  Many elements in Mabo schema files use some form of punctuation to separate from another. This common logic could be centralized in a custom container that keeps track of punctuation spans and takes care of formatting logic.

  This adds missing tracking of token spans that haven't be tracked before yet.

• Simplify token parsing (2a9167c)

  Create a surround parser for delimiters that performs the common task of wrapping any parser with an opening and closing delimiter.

  Also, create some helper parsers for each token to reduce the amount of boilerplate wherever the tokens are used together with other parsers.

• Fix new lints and some typos (4a782f5)

  Adjust to the new lints from Rust 1.78 and fix some small typos along the way.

🧪 Testing

• Add snapshot tests to stef-build (1313fe9)
• Enable more snapshot tests and fix errors (85938a4)
• Add playground sample for tuple structs (6f9e8ab)

  To ensure the tuple variant is working and doesn't include oversights like the previous missing pub visibility modifier.

• Use runtime arguments in Divan benchmarks (#1) (07da8a0)

  This greatly reduces compile times and is not limited to arrays/slices.

⚙️ Miscellaneous Tasks

• book: Fix a minor typo (b04202d)
• ci: Setup GitHub Actions to deploy the book (cf24bbb)
• ci: Improve path filters for book deployment (8b79f6f)
• ci: Create .nojekyll marker file for the book (b51681f)
• ci: Bump GH Actions versions (88ee4f4)
• doc: Fix ambiguous links in the Rust docs (e5d73fe)
• lsp: Remove duplicate log message (e8cfa08)
• Initial commit (5eb2f2b)
• Update checkout action to v4 (4d753d8)
• Minor code cleanup of unused code (a624300)
• Correct several typos (c74b3a7)

  Correct some spelling mistakes and configure the typos tool for a few false-positives.

• Add cargo-release configuration (4f2c951)

  Should make releasing new versions easier, once a point of a somewhat stable first version is reached.

• Create helper tasks to install the LSP server and VSCode extension (035c1aa)
• Update helper script from full project builds (c44888a)

  The script was still using pnpm in places and the custom highlighting component wasn't built before building the full book.

• Remove outdated GitHub Actions config (cd9877f)
• Fix Just task for link checking (24e1520)
• Improve readme with badges and project status (069f788)
• Update snapshots after several Go codegen fixes (b38e1ca)
• Bump MSRV to 1.76 and update dependencies (554b05b)

  Deprecations in winnow as well as increases in MSRVs in the dependencies. Bumping the MSRV to the very latest Rust version as there are no MSRV promises as of now and clap bumped their MSRV.

• Update cargo-deny config to v2 (5cba463)

  New configuration layouts were introduced for advisories and licenses sections. These will become the default at some point and it's good to adopt early.

• Limit log level to info for release builds (dda49f6)

  Trace and debug logs are mostly useful during development and not needed for release builds. By activacting the log crate's feature flag, these levels can be filtered out during compile time.

  The effects are likely better runtime performance and most notably reduced binary size.

• Update license link in readme (d8f7061)
• Use new expect attribute over allow (3c71f36)

  The latest Rust version introduced a new expect attribute which verifies that the allowed lint is actually being triggered by the code it's used for.

  This allows to keep the amount of extra allow rules down by only really having those that are needed to make Clippy happy.