Prepare Rizin 0.10 alpha release

Author: b1llow

Cargo.lock

@@ -1,3 +1,9 @@
 [workspace]
 resolver = "3"
-members = [ "rizin-rs","rizin-sys"]
+members = [ "rizin-rs", "rizin-sys" ]
+
+[workspace.package]
+version = "0.10.0-alpha.1"
+edition = "2024"
+repository = "https://github.com/b1llow/rizin-rs"
+readme = "README.md"

Cargo.toml

@@ -19,8 +19,11 @@ rizin-rs is a Rust library that provides bindings to the [Rizin](https://github.
 
 ## Installation
 
+This alpha targets the Rizin 0.10 development line and requires Rizin
+`>=0.10.0, <0.11.0`.
+
 ```bash
-cargo add rizin-rs
+cargo add rizin-rs@0.10.0-alpha.1
 ```
 
 ```nix
@@ -48,7 +51,8 @@ nix build .#rizin
 ```
 
 Rizin is pinned to a specific commit from its `dev` branch. Update it to the
-latest `dev` revision, including the source and Meson dependency hashes, with:
+latest `dev` revision, including the upstream version and source/Meson hashes,
+with:
 
 ```bash
 ./nix/rizin/update.sh
@@ -62,11 +66,37 @@ Pass a full 40-character commit SHA to pin a specific revision instead:
 
 ## Usage
 
-TODO
+```rust
+use rizin_rs::RzCore;
+
+fn main() {
+    let core = RzCore::new();
+    core.config_set("analysis.arch", "x86").unwrap();
+    core.config_set("analysis.bits", "64").unwrap();
+    let arch = core.config_get("analysis.arch").unwrap();
+    let bits = core.config_get("analysis.bits").unwrap();
+    println!("Rizin analysis target: {arch}-{bits}");
+}
+```
+
+Run the checked-in copy from the Nix development environment:
+
+```bash
+nix develop . --command cargo run -p rizin-rs --example basic
+```
+
+## Versioning
+
+The crate's major/minor version tracks the compatible Rizin line. Alpha
+releases use `0.10.0-alpha.N`; once `0.10.0` is published, Rust-only fixes use
+the crate patch version while the exact Rizin source remains recorded by the
+Nix pin. See [RELEASING.md](RELEASING.md) for the release order.
 
 ## License
 
-[LICENSE]
+The safe `rizin-rs` wrapper is released under
+[CC0-1.0](https://github.com/b1llow/rizin-rs/blob/main/LICENSE).
+The raw `rizin-sys` bindings and upstream Rizin are LGPL-3.0-only.
 
 ## Contributing
 

README.md

@@ -0,0 +1,38 @@
+# Releasing
+
+`rizin-rs` and `rizin-sys` release in lockstep. The `0.10` line targets Rizin
+`>=0.10.0, <0.11.0`; prereleases increment `alpha.N`, and the final `0.10.0`
+version is reserved until the bindings are ready to leave alpha.
+
+For every release, update both the workspace package version and the exact
+`rizin-sys` requirement in `rizin-rs/Cargo.toml`, then refresh `Cargo.lock`.
+
+## Verify the packages
+
+Run the repository checks, then verify the raw bindings package first:
+
+```bash
+nix develop . --command cargo publish --dry-run --locked -p rizin-sys
+nix develop . --command cargo package --list -p rizin-rs
+```
+
+Cargo cannot fully package or dry-run `rizin-rs` until the exact `rizin-sys`
+version is available from the registry. Before that point, inspect its package
+list and rely on the workspace tests and Nix build to verify both crates
+together.
+
+## Publish
+
+Authenticate Cargo using a scoped crates.io token outside the repository, then
+publish in dependency order:
+
+```bash
+nix develop . --command cargo publish --locked -p rizin-sys
+# Wait until 0.10.0-alpha.1 is visible in the crates.io index.
+nix develop . --command cargo publish --dry-run --locked -p rizin-rs
+nix develop . --command cargo publish --locked -p rizin-rs
+```
+
+Create the matching `v0.10.0-alpha.1` source tag only after both uploads
+succeed. Published versions are immutable; yank a broken release and publish
+the next `alpha.N` instead of attempting to reuse its version.

RELEASING.md

@@ -1,5 +1,5 @@
 {
-  description = "Rust rizin bindings";
+  description = "Safe Rust bindings for the Rizin reverse-engineering framework.";
 
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";

flake.nix

@@ -1,13 +1,17 @@
 {
+  lib,
   llvmPackages_18,
   pkg-config,
   rizin,
   rustPlatform,
 }:
 
+let
+  workspaceManifest = lib.importTOML ../../Cargo.toml;
+in
 rustPlatform.buildRustPackage {
   pname = "rizin-rs";
-  inherit (rizin) version;
+  version = workspaceManifest.workspace.package.version;
 
   src = ../..;
   cargoLock.lockFile = ../../Cargo.lock;

nix/rizin-rs/default.nix

@@ -1,4 +1,5 @@
 {
+  "version": "0.10.0",
   "rev": "26362e8c1888d4fec5d87068c08f313251cc64e1",
   "srcHash": "sha256-CFDvgM4Ct5ZNsi/CnWxq9aOaAhklvkwZd8aupTLay2E=",
   "mesonDepsHash": "sha256-MYRYrrhWbQRkHaYfSAxPMnhqxFFSb5xAHirqP8Zy2AY="

nix/rizin/checksum.json

@@ -59,7 +59,7 @@ let
   } ./meson-deps-config-hook.sh;
 in
 rizin.overrideAttrs (prevAttrs: {
-  version = "unstable-${builtins.substring 0 12 checksums.rev}";
+  version = "${checksums.version}-unstable-${builtins.substring 0 12 checksums.rev}";
   inherit src mesonDeps;
   patches = builtins.filter (
     patch: builtins.baseNameOf patch != "0001-fix-compilation-with-clang.patch"

nix/rizin/default.nix

@@ -39,11 +39,22 @@ source_url="https://github.com/rizinorg/rizin/archive/$rev.tar.gz"
 echo "Prefetching Rizin source at $rev"
 prefetch_json=$(nix store prefetch-file --json --unpack "$source_url")
 src_hash=$(printf '%s\n' "$prefetch_json" | sed -n 's/.*"hash"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')
+source_path=$(printf '%s\n' "$prefetch_json" | sed -n 's/.*"storePath"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')
 
 if [[ $src_hash != sha256-* ]]; then
     echo "Could not extract the Rizin source hash from: $prefetch_json" >&2
     exit 1
 fi
+if [[ ! -d $source_path ]]; then
+    echo "Could not extract the unpacked Rizin source path from: $prefetch_json" >&2
+    exit 1
+fi
+
+upstream_version=$(sed -n "s/^[[:space:]]*version: 'v\([^']*\)',/\1/p" "$source_path/meson.build" | head -n 1)
+if [[ ! $upstream_version =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+    echo "Could not extract a three-part Rizin version from $source_path/meson.build" >&2
+    exit 1
+fi
 
 backup=$(mktemp)
 cp -- "$checksum_file" "$backup"
@@ -59,17 +70,18 @@ restore_on_error() {
 trap restore_on_error EXIT
 
 write_checksums() {
-    target_rev=$1
-    target_src_hash=$2
-    target_deps_hash=$3
+    target_version=$1
+    target_rev=$2
+    target_src_hash=$3
+    target_deps_hash=$4
     tmp=$(mktemp "${checksum_file}.tmp.XXXXXX")
-    printf '{\n  "rev": "%s",\n  "srcHash": "%s",\n  "mesonDepsHash": "%s"\n}\n' \
-        "$target_rev" "$target_src_hash" "$target_deps_hash" >"$tmp"
+    printf '{\n  "version": "%s",\n  "rev": "%s",\n  "srcHash": "%s",\n  "mesonDepsHash": "%s"\n}\n' \
+        "$target_version" "$target_rev" "$target_src_hash" "$target_deps_hash" >"$tmp"
     mv -- "$tmp" "$checksum_file"
 }
 
 fake_hash="sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
-write_checksums "$rev" "$src_hash" "$fake_hash"
+write_checksums "$upstream_version" "$rev" "$src_hash" "$fake_hash"
 
 echo "Calculating the Meson dependency hash"
 set +e
@@ -89,12 +101,13 @@ if [[ $meson_deps_hash != sha256-* ]]; then
     exit 1
 fi
 
-write_checksums "$rev" "$src_hash" "$meson_deps_hash"
+write_checksums "$upstream_version" "$rev" "$src_hash" "$meson_deps_hash"
 echo "Validating Rizin and rizin-rs"
 nix build .#rizin --no-link --print-build-logs
 nix build .#rizin-rs --no-link --print-build-logs
 
 echo "Updated nix/rizin/checksum.json"
+echo "  version: $upstream_version"
 echo "  rev: $rev"
 echo "  srcHash: $src_hash"
 echo "  mesonDepsHash: $meson_deps_hash"

nix/rizin/update.sh

@@ -1,15 +1,21 @@
 [package]
 name = "rizin-rs"
-version = "0.1.0"
-edition = "2024"
+version.workspace = true
+edition.workspace = true
+license = "CC0-1.0"
+description = "Safe Rust bindings for the Rizin reverse-engineering framework."
+repository.workspace = true
+readme.workspace = true
+keywords = ["rizin", "reverse-engineering", "binary-analysis", "bindings"]
+categories = ["development-tools"]
 
 [[bench]]
 name = "my_benchmark"
 harness = false
 
 [dependencies]
 anyhow = "1.0.86"
-rizin-sys = { version = "0.9.1", path = "../rizin-sys" }
+rizin-sys = { version = "=0.10.0-alpha.1", path = "../rizin-sys" }
 
 [dev-dependencies]
 criterion = { version = "0.7.0", features = ["html_reports"] }