convex-rust 0.0.0-stage → 0.1.0

package/rust/convex_fn_macros/src/lib.rs

@@ -0,0 +1,338 @@
+//! Proc macros for `convex_fn`. See `contracts/ABI.md` and `contracts/MANIFEST.md`.
+
+mod derive;
+
+use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+use syn::{
+    parse_macro_input, DeriveInput, FnArg, GenericArgument, ItemFn, Meta, PathArguments,
+    ReturnType, Token, Type,
+};
+
+/// Marks an `async fn(&Ctx, Args) -> convex_fn::Result<R>` as a Convex action.
+///
+/// `#[action]` makes it public (`action`), `#[action(internal)]` makes it an
+/// `internalAction`. `Args` must implement `serde::DeserializeOwned` and `R`
+/// `serde::Serialize`.
+///
+/// On every target this emits the `convex_run:<module_path>:<name>` export. The
+/// manifest entry goes into a `convex:manifest` custom section on `wasm32` and
+/// into an exported `convex_mf:<module_path>:<name>` static elsewhere. The
+/// function itself is left as-is so `cargo test` can call it directly through
+/// `convex_fn_test`.
+#[proc_macro_attribute]
+pub fn action(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let metas = parse_macro_input!(
+        attr with syn::punctuated::Punctuated::<Meta, Token![,]>::parse_terminated
+    );
+    let mut visibility = "public";
+    for meta in &metas {
+        match meta {
+            Meta::Path(p) if p.is_ident("internal") => visibility = "internal",
+            other => {
+                return syn::Error::new_spanned(other, "expected `internal` or nothing")
+                    .to_compile_error()
+                    .into()
+            }
+        }
+    }
+
+    let func = parse_macro_input!(item as ItemFn);
+    if let Err(e) = check_signature(&func) {
+        return e.to_compile_error().into();
+    }
+    expand_action(&func, visibility, false).into()
+}
+
+/// Marks an `async fn(&Ctx, HttpRequest) -> convex_fn::Result<HttpResponse>` as a Convex HTTP action.
+///
+/// It becomes an `httpAction` that is routed in `convex/http.ts` (`http.route({ path, method, handler:
+/// rust.<module>.<name> })`). The request body is read as a stream (`HttpRequest::chunk`) or whole
+/// (`bytes`, `text`, `json`); the response is buffered or streamed (`HttpResponse::streaming`). The
+/// manifest entry has `"kind":"http"` and no validators. V8 host (cloud) only for now.
+#[proc_macro_attribute]
+pub fn http_action(attr: TokenStream, item: TokenStream) -> TokenStream {
+    if !attr.is_empty() {
+        return syn::Error::new(proc_macro2::Span::call_site(), "`#[http_action]` takes no arguments")
+            .to_compile_error()
+            .into();
+    }
+    let func = parse_macro_input!(item as ItemFn);
+    if let Err(e) = check_signature(&func) {
+        return e.to_compile_error().into();
+    }
+    expand_action(&func, "public", true).into()
+}
+
+/// The expansion of `#[action]` for a validated function.
+fn expand_action(func: &ItemFn, visibility: &str, http: bool) -> proc_macro2::TokenStream {
+    let name = &func.sig.ident;
+    let name_str = name.to_string();
+    let export_fn = format_ident!("__convex_run_{}", name);
+    let kind = if http { "http" } else { "" };
+    let (args_ty, returns_ty): (Type, Type) = if http {
+        (syn::parse_quote!(::convex_fn::__rt::NoReturnType), syn::parse_quote!(::convex_fn::__rt::NoReturnType))
+    } else {
+        (args_type(func), returns_type(func))
+    };
+    let run = if http {
+        quote! { ::convex_fn::__rt::run_http_export(args_ptr, args_len, |ctx, req| async move { #name(&ctx, req).await }) }
+    } else {
+        quote! { ::convex_fn::__rt::run_export(args_ptr, args_len, |ctx, args| async move { #name(&ctx, args).await }) }
+    };
+
+    // Split builds (`convex-rust build`, zero-config per-module wasm): the CLI compiles the crate once per
+    // Convex module with `--cfg convex_split --cfg 'convex_keep="<fn>"'` for that module's functions. A
+    // function without the cfg loses its exports (the linker's GC roots), so wasm-ld drops its code and
+    // everything only it uses. Without `convex_split` (cargo test, plain builds) nothing is gated.
+    quote! {
+        #[allow(dead_code)]
+        #func
+
+        #[allow(unexpected_cfgs)]
+        const _: () = {
+            #[cfg(any(not(convex_split), convex_keep = #name_str))]
+            #[doc(hidden)]
+            #[export_name = concat!("convex_run:", module_path!(), ":", #name_str)]
+            pub extern "C" fn #export_fn(args_ptr: *mut u8, args_len: usize) -> i64 {
+                #run
+            }
+
+            // `Probe::<T>::VALIDATOR` is `Some(..)` when `T` implements
+            // `ConvexType` (derive `ConvexArgs`/`ConvexValue`), else `None`.
+            use ::convex_fn::__rt::NoValidator as _;
+            const __ARGS: ::core::option::Option<&'static ::convex_fn::Validator> =
+                ::convex_fn::__rt::Probe::<#args_ty>::VALIDATOR;
+            const __RETURNS: ::core::option::Option<&'static ::convex_fn::Validator> =
+                ::convex_fn::__rt::Probe::<#returns_ty>::VALIDATOR;
+            const __LEN: usize = ::convex_fn::__rt::manifest_len(
+                module_path!(), #name_str, #visibility, #kind, __ARGS, __RETURNS,
+            );
+            #[cfg(all(target_arch = "wasm32", any(not(convex_split), convex_keep = #name_str)))]
+            #[used]
+            #[link_section = "convex:manifest"]
+            static __CONVEX_MANIFEST: [u8; __LEN] = ::convex_fn::__rt::manifest_bytes::<__LEN>(
+                module_path!(), #name_str, #visibility, #kind, __ARGS, __RETURNS,
+            );
+            // Native: an exported symbol, found by name in the dynamic symbol table.
+            #[cfg(all(not(target_arch = "wasm32"), any(not(convex_split), convex_keep = #name_str)))]
+            #[used]
+            #[doc(hidden)]
+            #[export_name = concat!("convex_mf:", module_path!(), ":", #name_str)]
+            pub static __CONVEX_MANIFEST: [u8; __LEN] = ::convex_fn::__rt::manifest_bytes::<__LEN>(
+                module_path!(), #name_str, #visibility, #kind, __ARGS, __RETURNS,
+            );
+        };
+    }
+}
+
+/// The type of the second parameter.
+fn args_type(func: &ItemFn) -> Type {
+    match func.sig.inputs.iter().nth(1) {
+        Some(FnArg::Typed(pt)) => (*pt.ty).clone(),
+        _ => syn::parse_quote!(()),
+    }
+}
+
+/// `R` of `Result<R>` / `convex_fn::Result<R>` / `Result<R, E>`; `()` otherwise
+/// (no validator).
+fn returns_type(func: &ItemFn) -> Type {
+    if let ReturnType::Type(_, ty) = &func.sig.output {
+        if let Type::Path(p) = &**ty {
+            if let Some(seg) = p.path.segments.last() {
+                if seg.ident == "Result" {
+                    if let PathArguments::AngleBracketed(a) = &seg.arguments {
+                        if let Some(GenericArgument::Type(t)) = a.args.first() {
+                            return t.clone();
+                        }
+                    }
+                }
+            }
+        }
+    }
+    syn::parse_quote!(::convex_fn::__rt::NoReturnType)
+}
+
+/// Derives `convex_fn::ConvexType` for action arguments: a static Convex
+/// `v.object({...})` validator that matches what serde (de)serialises.
+/// `#[action]` embeds it in the `convex:manifest`, so the backend validates
+/// arguments like it does for TypeScript functions and the dashboard shows the
+/// argument form.
+///
+/// ```ignore
+/// #[derive(Deserialize, ConvexArgs)]
+/// struct Args {
+///     body: String,
+///     #[convex(id = "users")] author: String,
+///     limit: Option<f64>,
+/// }
+/// ```
+///
+/// Field types: `String`, `bool`, floats and integers (`v.float64()`),
+/// `convex_fn::Int64` (`v.int64()`), `convex_fn::Bytes` (`v.bytes()`),
+/// `Vec<T>`, `Option<T>` (optional field), `HashMap<String, T>`,
+/// `serde_json::Value` (`v.any()`) and other `ConvexArgs`/`ConvexValue` types.
+/// `#[convex(id = "table")]` marks a `String` as `v.id("table")`,
+/// `#[convex(any)]` as `v.any()`. It follows the serde attributes `rename`,
+/// `rename_all`, `default` and `skip*`.
+#[proc_macro_derive(ConvexArgs, attributes(convex, serde))]
+pub fn derive_convex_args(item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as DeriveInput);
+    derive::expand(input, derive::Mode::Args)
+        .unwrap_or_else(|e| e.to_compile_error())
+        .into()
+}
+
+/// Like [`ConvexArgs`](derive@ConvexArgs) for any serde-shaped value: structs
+/// and enums (externally, internally or adjacently tagged, or untagged).
+/// Use it for return types and nested values.
+#[proc_macro_derive(ConvexValue, attributes(convex, serde))]
+pub fn derive_convex_value(item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as DeriveInput);
+    derive::expand(input, derive::Mode::Value)
+        .unwrap_or_else(|e| e.to_compile_error())
+        .into()
+}
+
+fn check_signature(func: &ItemFn) -> syn::Result<()> {
+    if func.sig.asyncness.is_none() {
+        return Err(syn::Error::new_spanned(
+            func.sig.fn_token,
+            "actions must be `async fn`",
+        ));
+    }
+    let inputs: Vec<&FnArg> = func.sig.inputs.iter().collect();
+    if inputs.len() != 2 {
+        return Err(syn::Error::new_spanned(
+            &func.sig,
+            "a Convex action takes exactly two parameters: `(ctx: &Ctx, args: Args)`",
+        ));
+    }
+    match inputs[0] {
+        FnArg::Receiver(r) => {
+            return Err(syn::Error::new_spanned(r, "actions cannot take `self`"));
+        }
+        FnArg::Typed(pt) => match &*pt.ty {
+            Type::Reference(r) if r.mutability.is_none() => {}
+            other => {
+                return Err(syn::Error::new_spanned(
+                    other,
+                    "the first parameter must be `ctx: &Ctx` (a shared reference)",
+                ))
+            }
+        },
+    }
+    if let FnArg::Receiver(r) = inputs[1] {
+        return Err(syn::Error::new_spanned(r, "actions cannot take `self`"));
+    }
+    if matches!(func.sig.output, ReturnType::Default) {
+        return Err(syn::Error::new_spanned(
+            &func.sig,
+            "actions must return `convex_fn::Result<R>`",
+        ));
+    }
+    if !func.sig.generics.params.is_empty() {
+        return Err(syn::Error::new_spanned(
+            &func.sig.generics,
+            "actions cannot be generic",
+        ));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn check(src: &str) -> Result<(), String> {
+        let f: ItemFn = syn::parse_str(src).unwrap();
+        check_signature(&f).map_err(|e| e.to_string())
+    }
+
+    fn expansion(src: &str, vis: &str) -> String {
+        let f: ItemFn = syn::parse_str(src).unwrap();
+        let ts = expand_action(&f, vis, false);
+        // Normalise whitespace so the assertions do not depend on token printing.
+        ts.to_string().split_whitespace().collect::<Vec<_>>().join(" ")
+    }
+
+    #[test]
+    fn expansion_exports_on_all_targets() {
+        let out = expansion("async fn f(ctx: &Ctx, a: A) -> Result<R> { todo!() }", "public");
+        // The run export is not gated on the target.
+        let run = out.find("convex_run:").expect("run export");
+        assert!(!out[..run].contains("# [cfg (target_arch"), "{out}");
+        assert!(out.contains("pub extern \"C\" fn __convex_run_f"), "{out}");
+        assert!(out.contains("__rt :: run_export"), "{out}");
+        // wasm manifest: custom section; native manifest: exported symbol.
+        assert!(out.contains(
+            "# [cfg (all (target_arch = \"wasm32\" , any (not (convex_split) , convex_keep = \"f\")))] # [used] # [link_section = \"convex:manifest\"] static __CONVEX_MANIFEST"
+        ), "{out}");
+        assert!(out.contains(
+            "# [cfg (all (not (target_arch = \"wasm32\") , any (not (convex_split) , convex_keep = \"f\")))] # [used] # [doc (hidden)] # [export_name = concat ! (\"convex_mf:\" , module_path ! () , \":\" , \"f\")] pub static __CONVEX_MANIFEST"
+        ), "{out}");
+        assert!(!out.contains("convex_native"), "{out}");
+    }
+
+    #[test]
+    fn http_expansion_runs_the_http_export_and_marks_the_manifest() {
+        let f: ItemFn = syn::parse_str("async fn h(ctx: &Ctx, r: HttpRequest) -> Result<HttpResponse> { todo!() }").unwrap();
+        let out = expand_action(&f, "public", true).to_string().split_whitespace().collect::<Vec<_>>().join(" ");
+        assert!(out.contains("__rt :: run_http_export"), "{out}");
+        assert!(!out.contains("__rt :: run_export"), "{out}");
+        assert!(out.contains("\"public\" , \"http\" , __ARGS , __RETURNS"), "{out}");
+        assert!(out.contains("Probe :: < :: convex_fn :: __rt :: NoReturnType >"), "{out}");
+        // Actions carry an empty kind (omitted from the manifest).
+        let a = expansion("async fn f(ctx: &Ctx, a: A) -> Result<R> { todo!() }", "public");
+        assert!(a.contains("\"public\" , \"\" , __ARGS"), "{a}");
+    }
+
+    #[test]
+    fn expansion_internal_visibility() {
+        let out = expansion("async fn g(ctx: &Ctx, a: A) -> Result<R> { todo!() }", "internal");
+        assert!(out.contains("\"internal\""), "{out}");
+        assert!(out.contains("\"convex_mf:\""), "{out}");
+    }
+
+    #[test]
+    fn accepts_valid_signature() {
+        assert!(check("async fn f(ctx: &Ctx, a: Args) -> Result<R> { todo!() }").is_ok());
+        assert!(check("async fn f(_: &Ctx, _: ()) -> convex_fn::Result<()> { Ok(()) }").is_ok());
+    }
+
+    #[test]
+    fn rejects_non_async() {
+        let e = check("fn f(ctx: &Ctx, a: A) -> Result<R> { todo!() }").unwrap_err();
+        assert!(e.contains("async fn"), "{e}");
+    }
+
+    #[test]
+    fn rejects_wrong_arity() {
+        for src in [
+            "async fn f(ctx: &Ctx) -> Result<R> { todo!() }",
+            "async fn f(ctx: &Ctx, a: A, b: B) -> Result<R> { todo!() }",
+            "async fn f() -> Result<R> { todo!() }",
+        ] {
+            let e = check(src).unwrap_err();
+            assert!(e.contains("exactly two parameters"), "{e}");
+        }
+    }
+
+    #[test]
+    fn rejects_bad_ctx_and_receivers() {
+        let e = check("async fn f(ctx: Ctx, a: A) -> Result<R> { todo!() }").unwrap_err();
+        assert!(e.contains("ctx: &Ctx"), "{e}");
+        let e = check("async fn f(ctx: &mut Ctx, a: A) -> Result<R> { todo!() }").unwrap_err();
+        assert!(e.contains("shared reference"), "{e}");
+        let e = check("async fn f(&self, a: A) -> Result<R> { todo!() }").unwrap_err();
+        assert!(e.contains("self"), "{e}");
+    }
+
+    #[test]
+    fn rejects_generics_and_missing_return() {
+        let e = check("async fn f<T>(ctx: &Ctx, a: T) -> Result<R> { todo!() }").unwrap_err();
+        assert!(e.contains("generic"), "{e}");
+        let e = check("async fn f(ctx: &Ctx, a: A) { }").unwrap_err();
+        assert!(e.contains("convex_fn::Result"), "{e}");
+    }
+}

package/rust/convex_reqwest/Cargo.toml

@@ -0,0 +1,69 @@
+[package]
+# Named `reqwest` so `[patch.crates-io] reqwest = { path = ... }` swaps it in.
+# The version only has to satisfy the `0.12` requirement of vendor crates.
+name = "reqwest"
+version = "0.12.99"
+edition = "2021"
+license = "Apache-2.0"
+description = "reqwest-compatible HTTP client for \"use rust\" actions, backed by the Convex fetch task (DX-06 / D-010)"
+publish = false
+
+[lib]
+path = "src/lib.rs"
+
+[dependencies]
+convex_fn = { path = "../convex_fn", features = ["tokio-rt"] }
+bytes = "1"
+http = "1"
+http-body = "1"
+url = "2"
+serde = "1"
+serde_json = "1"
+serde_urlencoded = "0.7"
+futures-core = { version = "0.3", default-features = false }
+futures-util = { version = "0.3", default-features = false }
+base64 = "0.22"
+tokio = { version = "1", default-features = false, features = ["rt", "time"] }
+
+
+[features]
+default = ["default-tls", "charset", "http2", "macos-system-configuration"]
+default-tls = []
+native-tls = []
+native-tls-vendored = []
+native-tls-alpn = []
+rustls-tls = []
+rustls-tls-no-provider = []
+rustls-tls-manual-roots = []
+rustls-tls-manual-roots-no-provider = []
+rustls-tls-webpki-roots = []
+rustls-tls-webpki-roots-no-provider = []
+rustls-tls-native-roots = []
+rustls-tls-native-roots-no-provider = []
+blocking = []
+json = []
+multipart = []
+stream = []
+query = []
+form = []
+gzip = []
+brotli = []
+zstd = []
+deflate = []
+cookies = []
+socks = []
+hickory-dns = []
+trust-dns = []
+http2 = []
+http3 = []
+charset = []
+macos-system-configuration = []
+system-proxy = []
+native-roots = []
+webpki-roots = []
+# reqwest 0.13 names
+rustls = []
+rustls-no-provider = []
+rustls-native-roots = []
+rustls-webpki-roots = []
+native-tls-no-alpn = []

package/rust/convex_reqwest/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright 2026 Tomás Domingos
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.