restate-sdk 0.14.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98226ceeedf91fa42bbafa435efad5ee72571bea81cd7684a3e8726efafc049d
-  data.tar.gz: 87520432eed026201b420da367ecf89bb56d3ced49aa0de243ac6610f8cbd584
+  metadata.gz: 225624c7507997dff92b55064e95b9991183f8f568bee215b53e8f8d5a26bd4c
+  data.tar.gz: 00f16cae8ce1b3e2469aa55c60bfc8e41706589ee395a37972a300624e27f6c1
 SHA512:
-  metadata.gz: babf39022a0c123d246623a174afa5af2f56a6e552f6de2299b74fbe8845a98396a12842a818e91fb04a707f6a26054c28dace700362a6bf9ea0b89fe958dcab
-  data.tar.gz: 441dd64b8d55779837a3a819d9c30908fbfcff5c17c67db6f89dfd3906d4f7857e12347dcea860bb911c1ca3d617ab2292281a69a1124947e32740a04335948e
+  metadata.gz: 3dce3cb5a471d6b05a23459a42615704816a0b34b6fe72a8b9d3365f26223daca2f4837072ad1dca08127e17daa49f18b3ac306c7060756cd92da8f56960b139
+  data.tar.gz: 0374c779599422d0a5e09a59e5f1368901390917a0801c8ea5720c3fcf3195823331d17a919d79a87e485a57739e5a1c5f83635c155bb32d76ebf6a996c83657

data/Cargo.lock

@@ -17,12 +17,6 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
-[[package]]
-name = "autocfg"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
-
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -38,7 +32,7 @@ dependencies = [
  "bitflags",
  "cexpr",
  "clang-sys",
- "itertools 0.12.1",
+ "itertools",
  "proc-macro2",
  "quote",
  "regex",
@@ -55,11 +49,11 @@ checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
 
 [[package]]
 name = "block-buffer"
-version = "0.11.0-pre.5"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ded684142010808eb980d9974ef794da2bcf97d13396143b1515e9f0fb4a10e"
+checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be"
 dependencies = [
- "crypto-common",
+ "hybrid-array",
 ]
 
 [[package]]
@@ -93,16 +87,6 @@ dependencies = [
  "either",
 ]
 
-[[package]]
-name = "cc"
-version = "1.2.56"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
-dependencies = [
- "find-msvc-tools",
- "shlex",
-]
-
 [[package]]
 name = "cexpr"
 version = "0.6.0"
@@ -131,44 +115,33 @@ dependencies = [
 
 [[package]]
 name = "const-oid"
-version = "0.10.0-pre.2"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7e3352a27098ba6b09546e5f13b15165e6a88b5c2723afecb3ea9576b27e3ea"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.17"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "crypto-common"
-version = "0.2.0-pre.5"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7aa2ec04f5120b830272a481e8d9d8ba4dda140d2cda59b0f1110d5eb93c38e"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
 dependencies = [
- "getrandom",
  "hybrid-array",
- "rand_core",
-]
-
-[[package]]
-name = "deranged"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
-dependencies = [
- "powerfmt",
 ]
 
 [[package]]
 name = "digest"
-version = "0.11.0-pre.8"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "065d93ead7c220b85d5b4be4795d8398eac4ff68b5ee63895de0a3c1fb6edf25"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
 dependencies = [
  "block-buffer",
  "const-oid",
@@ -181,12 +154,6 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
-[[package]]
-name = "find-msvc-tools"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
-
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -194,10 +161,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
  "wasi",
- "wasm-bindgen",
 ]
 
 [[package]]
@@ -214,9 +179,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "hybrid-array"
-version = "0.2.3"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2d35805454dc9f8662a98d6d61886ffe26bd465f5960e0e55345c70d5c0d2a9"
+checksum = "9155a582abd142abc056962c29e3ce5ff2ad5469f4246b537ed42c5deba857da"
 dependencies = [
  "typenum",
 ]
@@ -230,15 +195,6 @@ dependencies = [
  "either",
 ]
 
-[[package]]
-name = "itertools"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itoa"
 version = "1.0.17"
@@ -257,17 +213,17 @@ dependencies = [
 
 [[package]]
 name = "jsonwebtoken"
-version = "9.3.1"
+version = "10.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a87cc7a48537badeae96744432de36f4be2b4a34a05a5ef32e9dd8a1c169dde"
+checksum = "eba32bfb4ffdeaca3e34431072faf01745c9b26d25504aa7a6cf5684334fc4fc"
 dependencies = [
  "base64",
+ "getrandom",
  "js-sys",
- "pem",
- "ring",
  "serde",
  "serde_json",
- "simple_asn1",
+ "signature",
+ "zeroize",
 ]
 
 [[package]]
@@ -358,41 +314,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
-]
-
-[[package]]
-name = "num-bigint"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
-dependencies = [
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-conv"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
-
-[[package]]
-name = "num-integer"
-version = "0.1.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
-dependencies = [
- "autocfg",
+ "windows-sys",
 ]
 
 [[package]]
@@ -402,20 +324,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
-name = "paste"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
-
-[[package]]
-name = "pem"
-version = "3.0.6"
+name = "pastey"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d30c53c26bc5b31a98cd02d20f25a7c8567146caf63ed593a9d87b2775291be"
-dependencies = [
- "base64",
- "serde_core",
-]
+checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
 
 [[package]]
 name = "pin-project-lite"
@@ -423,12 +335,6 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
-[[package]]
-name = "powerfmt"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.106"
@@ -440,9 +346,9 @@ dependencies = [
 
 [[package]]
 name = "prost"
-version = "0.13.5"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
+checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
 dependencies = [
  "bytes",
  "prost-derive",
@@ -450,12 +356,12 @@ dependencies = [
 
 [[package]]
 name = "prost-derive"
-version = "0.13.5"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
+checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
 dependencies = [
  "anyhow",
- "itertools 0.14.0",
+ "itertools",
  "proc-macro2",
  "quote",
  "syn",
@@ -540,18 +446,17 @@ checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
 [[package]]
 name = "restate-sdk-shared-core"
-version = "0.7.0"
+version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc31df792d23376df8d3a6d4264ec3ce658bf68f0ec5296da43de8377c9352aa"
+checksum = "9bf02583379fc28d6386bd864629ba6553ce942124956b862fa9e95a4d836558"
 dependencies = [
  "base64",
  "bs58",
  "bytes",
  "bytes-utils",
  "jsonwebtoken",
- "paste",
+ "pastey",
  "prost",
- "ring",
  "serde",
  "sha2",
  "strum",
@@ -561,7 +466,7 @@ dependencies = [
 
 [[package]]
 name = "restate_internal"
-version = "0.14.0"
+version = "1.0.0"
 dependencies = [
  "magnus",
  "rb-sys",
@@ -569,20 +474,6 @@ dependencies = [
  "tracing-subscriber",
 ]
 
-[[package]]
-name = "ring"
-version = "0.17.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
-dependencies = [
- "cc",
- "cfg-if",
- "getrandom",
- "libc",
- "untrusted",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "rustc-hash"
 version = "2.1.2"
@@ -646,9 +537,9 @@ dependencies = [
 
 [[package]]
 name = "sha2"
-version = "0.11.0-pre.3"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f33549bf3064b62478926aa89cbfc7c109aab66ae8f0d5d2ef839e482cc30d6"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
 dependencies = [
  "cfg-if",
  "cpufeatures",
@@ -677,15 +568,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
-name = "simple_asn1"
-version = "0.6.4"
+name = "signature"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d585997b0ac10be3c5ee635f1bab02d512760d14b7c468801ac8a01d9ae5f1d"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
 dependencies = [
- "num-bigint",
- "num-traits",
- "thiserror",
- "time",
+ "rand_core",
 ]
 
 [[package]]
@@ -755,37 +643,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "time"
-version = "0.3.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
-dependencies = [
- "deranged",
- "itoa",
- "num-conv",
- "powerfmt",
- "serde_core",
- "time-core",
- "time-macros",
-]
-
-[[package]]
-name = "time-core"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
-
-[[package]]
-name = "time-macros"
-version = "0.2.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
-dependencies = [
- "num-conv",
- "time-core",
-]
-
 [[package]]
 name = "tinyvec"
 version = "1.10.0"
@@ -864,9 +721,9 @@ dependencies = [
 
 [[package]]
 name = "typenum"
-version = "1.19.0"
+version = "1.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
 
 [[package]]
 name = "unicode-ident"
@@ -874,12 +731,6 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
-[[package]]
-name = "untrusted"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
-
 [[package]]
 name = "valuable"
 version = "0.1.1"
@@ -943,15 +794,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
-[[package]]
-name = "windows-sys"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
-dependencies = [
- "windows-targets",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -962,68 +804,24 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.52.6"
+name = "zeroize"
+version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "zeroize_derive",
 ]
 
 [[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
+name = "zeroize_derive"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "zmij"

data/ext/restate_internal/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "restate_internal"
-version = "0.14.0"
+version = "1.0.0"
 edition = "2021"
 publish = false
 
@@ -12,5 +12,5 @@ doc = false
 [dependencies]
 magnus = { version = "0.8", features = ["rb-sys"] }
 rb-sys = { version = "0.9", features = ["stable-api-compiled-fallback"] }
-restate-sdk-shared-core = { version = "=0.7.0", features = ["request_identity", "sha2_random_seed"] }
+restate-sdk-shared-core = { version = "7.0.0" , features = ["request_identity", "sha2_random_seed"] }
 tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }

data/ext/restate_internal/src/lib.rs

@@ -1,14 +1,13 @@
 use magnus::{
     function, method,
-    prelude::*,
     value::ReprValue,
-    Error, ExceptionClass, Module, Object, RArray, RString, Ruby, Value,
+    Error, ExceptionClass, Module, Object, RArray, RString, Ruby, Symbol, TryConvert, Value,
 };
 use restate_sdk_shared_core::{
-    CallHandle, CoreVM, DoProgressResponse, Error as CoreError, Header, IdentityVerifier, Input,
-    NonEmptyValue, NotificationHandle, ResponseHead, RetryPolicy, RunExitResult,
-    TakeOutputResult, Target, TerminalFailure, VMOptions, Value as CoreValue, VM,
-    CANCEL_NOTIFICATION_HANDLE,
+    AwaitResponse, CallHandle, CoreVM, Error as CoreError, Header, IdentityVerifier, Input,
+    NonEmptyValue, NotificationHandle, OnMaxAttempts, ResponseHead, RetryPolicy, RunExitResult,
+    RunHandle, State, Target, TerminalFailure, UnresolvedFuture, VMOptions, Value as CoreValue,
+    VM, CANCEL_NOTIFICATION_HANDLE,
 };
 use std::cell::RefCell;
 use std::fmt;
@@ -299,6 +298,7 @@ impl From<RbExponentialRetryConfig> for RetryPolicy {
                     .max_interval
                     .map(Duration::from_millis)
                     .or_else(|| Some(Duration::from_secs(10))),
+                on_max_attempts: OnMaxAttempts::FailAsTerminal,
             }
         } else {
             RetryPolicy::Infinite
@@ -355,6 +355,30 @@ impl From<CallHandle> for RbCallHandle {
     }
 }
 
+#[magnus::wrap(class = "Restate::Internal::Run")]
+struct RbRun {
+    replayed: bool,
+    handle: u32,
+}
+
+impl RbRun {
+    fn replayed(&self) -> bool {
+        self.replayed
+    }
+    fn handle(&self) -> u32 {
+        self.handle
+    }
+}
+
+impl From<RunHandle> for RbRun {
+    fn from(r: RunHandle) -> Self {
+        RbRun {
+            replayed: r.replayed,
+            handle: r.handle.into(),
+        }
+    }
+}
+
 // ── VM ──
 
 #[magnus::wrap(class = "Restate::Internal::VM")]
@@ -418,10 +442,8 @@ impl RbVM {
 
     fn take_output(&self) -> Result<Value, Error> {
         let ruby = Ruby::get().map_err(|_| Error::new(vm_error_class(), "Ruby not available"))?;
-        Ok(match self.vm.borrow_mut().take_output() {
-            TakeOutputResult::Buffer(b) => ruby.str_from_slice(&b).as_value(),
-            TakeOutputResult::EOF => ruby.qnil().as_value(),
-        })
+        let buffer = self.vm.borrow_mut().take_output();
+        Ok(ruby.str_from_slice(&buffer).as_value())
     }
 
     fn is_ready_to_execute(&self) -> Result<bool, Error> {
@@ -435,33 +457,39 @@ impl RbVM {
         self.vm.borrow().is_completed(handle.into())
     }
 
-    fn do_progress(&self, handles: RArray) -> Result<Value, Error> {
+    // Drive the VM forward against an UnresolvedFuture tree. The Ruby-side
+    // encoding is:
+    //   Integer handle                                  → Single(handle)
+    //   [:first_completed,              [child, ...]]   → race / wait_any
+    //   [:all_completed,                [child, ...]]   → all_settled
+    //   [:first_succeeded_or_all_failed,[child, ...]]   → any
+    //   [:all_succeeded_or_first_failed,[child, ...]]   → all
+    //   [:unknown,                      [child, ...]]   → unknown combinator
+    fn do_await(&self, future_value: Value) -> Result<Value, Error> {
         let ruby = Ruby::get().map_err(|_| Error::new(vm_error_class(), "Ruby not available"))?;
-        let handle_vec: Vec<u32> = handles.to_vec()?;
-        let notification_handles: Vec<NotificationHandle> =
-            handle_vec.into_iter().map(NotificationHandle::from).collect();
-
-        let res = self.vm.borrow_mut().do_progress(notification_handles);
+        let future = parse_unresolved_future(future_value)?;
+        let res = self.vm.borrow_mut().do_await(future);
 
         match res {
             Err(e) if e.is_suspended_error() => Ok(ruby.into_value(RbSuspended)),
             Err(e) => Err(core_error_to_magnus(e)),
-            Ok(DoProgressResponse::AnyCompleted) => {
+            Ok(AwaitResponse::AnyCompleted) => {
                 Ok(ruby.into_value(RbDoProgressAnyCompleted))
             }
-            Ok(DoProgressResponse::ReadFromInput) => {
-                Ok(ruby.into_value(RbDoProgressReadFromInput))
-            }
-            Ok(DoProgressResponse::ExecuteRun(handle)) => Ok(ruby.into_value(
+            Ok(AwaitResponse::ExecuteRun(handle)) => Ok(ruby.into_value(
                 RbDoProgressExecuteRun {
                     handle: handle.into(),
                 },
             )),
-            Ok(DoProgressResponse::CancelSignalReceived) => {
+            Ok(AwaitResponse::CancelSignalReceived) => {
                 Ok(ruby.into_value(RbDoProgressCancelSignalReceived))
             }
-            Ok(DoProgressResponse::WaitingPendingRun) => {
-                Ok(ruby.into_value(RbDoWaitForPendingRun))
+            Ok(AwaitResponse::WaitingExternalProgress { waiting_input, .. }) => {
+                if waiting_input {
+                    Ok(ruby.into_value(RbDoProgressReadFromInput))
+                } else {
+                    Ok(ruby.into_value(RbDoWaitForPendingRun))
+                }
             }
         }
     }
@@ -590,9 +618,12 @@ impl RbVM {
                     handler,
                     key: key_opt,
                     idempotency_key: idem_opt,
+                    scope: None,
+                    limit_key: None,
                     headers: hdr_vec,
                 },
                 bytes.into(),
+                None,
                 Default::default(),
             )
             .map(Into::into)
@@ -639,6 +670,8 @@ impl RbVM {
                     handler,
                     key: key_opt,
                     idempotency_key: idem_opt,
+                    scope: None,
+                    limit_key: None,
                     headers: hdr_vec,
                 },
                 bytes.into(),
@@ -648,13 +681,14 @@ impl RbVM {
                         .expect("Duration since unix epoch cannot fail")
                         + Duration::from_millis(millis)
                 }),
+                None,
                 Default::default(),
             )
             .map(|s| s.invocation_id_notification_handle.into())
             .map_err(core_error_to_magnus)
     }
 
-    fn sys_run(&self, name: String) -> Result<u32, Error> {
+    fn sys_run(&self, name: String) -> Result<RbRun, Error> {
         self.vm
             .borrow_mut()
             .sys_run(name)
@@ -727,21 +761,21 @@ impl RbVM {
     }
 
     fn is_replaying(&self) -> bool {
-        self.vm.borrow().is_replaying()
+        matches!(self.vm.borrow().state(), State::Replaying)
     }
 
     // ── Awakeables ──
 
     fn sys_awakeable(&self) -> Result<Value, Error> {
         let ruby = Ruby::get().map_err(|_| Error::new(vm_error_class(), "Ruby not available"))?;
-        let (id, handle) = self
+        let awakeable = self
             .vm
             .borrow_mut()
             .sys_awakeable()
             .map_err(core_error_to_magnus)?;
         let ary = ruby.ary_new_capa(2);
-        ary.push(ruby.str_new(&id))?;
-        ary.push(u32::from(handle))?;
+        ary.push(ruby.str_new(&awakeable.id))?;
+        ary.push(u32::from(awakeable.handle))?;
         Ok(ary.as_value())
     }
 
@@ -926,6 +960,54 @@ Or remove the begin/rescue altogether if you don't need it.
 
 // ── Helpers ──
 
+// Recursive Ruby → UnresolvedFuture parser. Accepts an Integer handle, or a
+// [Symbol, Array[children]] pair encoding a combinator node. See the do_await
+// docstring for the variant tags.
+fn parse_unresolved_future(value: Value) -> Result<UnresolvedFuture, Error> {
+    let ruby = Ruby::get().map_err(|_| Error::new(vm_error_class(), "Ruby not available"))?;
+
+    if let Ok(handle) = u32::try_convert(value) {
+        return Ok(UnresolvedFuture::Single(NotificationHandle::from(handle)));
+    }
+
+    let pair = RArray::try_convert(value).map_err(|_| {
+        Error::new(
+            ruby.exception_arg_error(),
+            "UnresolvedFuture must be a Integer handle or [Symbol, Array] pair",
+        )
+    })?;
+    if pair.len() != 2 {
+        return Err(Error::new(
+            ruby.exception_arg_error(),
+            "UnresolvedFuture combinator pair must be [Symbol, Array]",
+        ));
+    }
+    let tag: Symbol = pair.entry(0)?;
+    let children_arr: RArray = pair.entry(1)?;
+    let mut children = Vec::with_capacity(children_arr.len());
+    for child in children_arr.into_iter() {
+        children.push(parse_unresolved_future(child)?);
+    }
+    let tag_name = tag.name().map_err(|_| {
+        Error::new(ruby.exception_arg_error(), "UnresolvedFuture tag is not a Symbol")
+    })?;
+    match tag_name.as_ref() {
+        "first_completed" => Ok(UnresolvedFuture::FirstCompleted(children)),
+        "all_completed" => Ok(UnresolvedFuture::AllCompleted(children)),
+        "first_succeeded_or_all_failed" => {
+            Ok(UnresolvedFuture::FirstSucceededOrAllFailed(children))
+        }
+        "all_succeeded_or_first_failed" => {
+            Ok(UnresolvedFuture::AllSucceededOrFirstFailed(children))
+        }
+        "unknown" => Ok(UnresolvedFuture::Unknown(children)),
+        other => Err(Error::new(
+            ruby.exception_arg_error(),
+            format!("Unknown UnresolvedFuture combinator: {other}"),
+        )),
+    }
+}
+
 fn parse_headers_array(ary: RArray) -> Result<Vec<Header>, Error> {
     let mut result = Vec::new();
     for item in ary.into_iter() {
@@ -1083,6 +1165,11 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     )?;
     ch_class.define_method("result_handle", method!(RbCallHandle::result_handle, 0))?;
 
+    // Run
+    let run_class = internal.define_class("Run", ruby.class_object())?;
+    run_class.define_method("replayed", method!(RbRun::replayed, 0))?;
+    run_class.define_method("handle", method!(RbRun::handle, 0))?;
+
     // VM - all methods use explicit arities
     let vm_class = internal.define_class("VM", ruby.class_object())?;
     vm_class.define_singleton_method("new", function!(RbVM::new, 1))?;
@@ -1093,7 +1180,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     vm_class.define_method("take_output", method!(RbVM::take_output, 0))?;
     vm_class.define_method("is_ready_to_execute", method!(RbVM::is_ready_to_execute, 0))?;
     vm_class.define_method("is_completed", method!(RbVM::is_completed, 1))?;
-    vm_class.define_method("do_progress", method!(RbVM::do_progress, 1))?;
+    vm_class.define_method("do_await", method!(RbVM::do_await, 1))?;
     vm_class.define_method("take_notification", method!(RbVM::take_notification, 1))?;
     vm_class.define_method("sys_input", method!(RbVM::sys_input, 0))?;
     vm_class.define_method("sys_get_state", method!(RbVM::sys_get_state, 1))?;

data/lib/restate/discovery.rb

@@ -41,7 +41,7 @@ module Restate
       compact(
         protocolMode: protocol_mode,
         minProtocolVersion: 5,
-        maxProtocolVersion: 6,
+        maxProtocolVersion: 7,
         services: services
       )
     end

data/lib/restate/durable_future.rb

@@ -15,15 +15,16 @@ module Restate
       @value = nil
     end
 
-    # Block until the result is available and return it. Caches across calls.
+    # Block until the result is available and return it. Caches across calls,
+    # including failures — a second await on a failed future re-raises the
+    # same +TerminalError+ rather than re-fetching from the VM (the notification
+    # is single-shot).
     #
     # @return [Object] the deserialized result
     def await
-      unless @resolved
-        raw = @ctx.resolve_handle(@handle)
-        @value = @serde ? @serde.deserialize(raw) : raw
-        @resolved = true
-      end
+      resolve! unless @resolved
+      raise @error if @error
+
       @value
     end
 
@@ -46,6 +47,17 @@ module Restate
 
       raise TimeoutError
     end
+
+    private
+
+    def resolve!
+      raw = @ctx.resolve_handle(@handle)
+      @value = @serde ? @serde.deserialize(raw) : raw
+    rescue TerminalError => e
+      @error = e
+    ensure
+      @resolved = true
+    end
   end
 
   # A durable future for service/object/workflow calls.
@@ -61,19 +73,31 @@ module Restate
     end
 
     # Block until the result is available and return it. Deserializes via +output_serde+.
+    # Caches both successes and TerminalError failures across calls.
     def await
-      unless @resolved
-        raw = @ctx.resolve_handle(@handle)
-        @value = if raw.nil? || @output_serde.nil?
-                   raw
-                 else
-                   @output_serde.deserialize(raw)
-                 end
-        @resolved = true
-      end
+      resolve_call! unless @resolved
+      raise @error if @error
+
       @value
     end
 
+    private
+
+    def resolve_call!
+      raw = @ctx.resolve_handle(@handle)
+      @value = if raw.nil? || @output_serde.nil?
+                 raw
+               else
+                 @output_serde.deserialize(raw)
+               end
+    rescue TerminalError => e
+      @error = e
+    ensure
+      @resolved = true
+    end
+
+    public
+
     # Returns the invocation ID of the remote call. Lazily resolved.
     #
     # @return [String] the invocation ID
@@ -91,6 +115,122 @@ module Restate
     end
   end
 
+  # A lazy combinator over one or more child futures. The child set can mix
+  # +DurableFuture+ leaves (with raw handles) and nested +CombinedFuture+ nodes.
+  # The shared-core uses the tree shape to make suspension decisions; nothing
+  # blocks until +.await+ is called, so combinators are composable:
+  #
+  #   Restate.race(Restate.all(a, b), c).await
+  #
+  # Supported variants (mirroring +UnresolvedFuture+ in restate-sdk-shared-core):
+  #   :first_completed                 → JS Promise.race
+  #   :all_succeeded_or_first_failed   → JS Promise.all
+  #   :first_succeeded_or_all_failed   → JS Promise.any
+  #   :all_completed                   → JS Promise.allSettled
+  class CombinedFuture
+    VALID_VARIANTS = %i[
+      first_completed
+      all_succeeded_or_first_failed
+      first_succeeded_or_all_failed
+      all_completed
+    ].freeze
+
+    def initialize(ctx, variant, children)
+      raise ArgumentError, "unknown combinator variant: #{variant}" unless VALID_VARIANTS.include?(variant)
+
+      @ctx = ctx
+      @variant = variant
+      @children = children
+      @resolved = false
+      @value = nil
+      @error = nil
+    end
+
+    # Recursive tree representation the native +do_await+ binding consumes.
+    # Leaves are integer handles; inner nodes are +[variant, [child...]]+ pairs.
+    def tree
+      [@variant, @children.map { |c| c.is_a?(CombinedFuture) ? c.tree : c.handle }]
+    end
+
+    # Block until this combinator settles per its variant. Caches results
+    # (including failures) across calls.
+    def await
+      resolve_combined! unless @resolved
+      raise @error if @error
+
+      @value
+    end
+
+    # Non-blocking introspection. True iff calling +.await+ is guaranteed not to
+    # block. Conservative for the variants that allow early-completion on failure
+    # (+:all_succeeded_or_first_failed+, +:first_succeeded_or_all_failed+) — we
+    # report false until every child is settled, because checking failure status
+    # of a leaf would require consuming its notification.
+    def completed?
+      return true if @resolved
+
+      case @variant
+      when :first_completed
+        @children.any?(&:completed?)
+      else
+        @children.all?(&:completed?)
+      end
+    end
+
+    private
+
+    def resolve_combined!
+      @ctx.wait_combined(tree)
+      @value = finalize_value
+    rescue TerminalError => e
+      @error = e
+    ensure
+      @resolved = true
+    end
+
+    def finalize_value
+      case @variant
+      when :first_completed then finalize_first_completed
+      when :all_succeeded_or_first_failed then finalize_all_succeeded
+      when :all_completed then finalize_all_completed
+      when :first_succeeded_or_all_failed then finalize_first_succeeded
+      end
+    end
+
+    def finalize_first_completed
+      @children.find(&:completed?).await
+    end
+
+    def finalize_all_succeeded
+      # Surface any settled-and-failed child first (short-circuit). After this
+      # scan, if no failure was raised, every child must be settled-and-success
+      # per AllSucceededOrFirstFailed semantics.
+      @children.each { |c| c.await if c.completed? }
+      @children.map(&:await)
+    end
+
+    def finalize_all_completed
+      @children.map do |c|
+        { status: :fulfilled, value: c.await }
+      rescue TerminalError => e
+        { status: :rejected, reason: e }
+      end
+    end
+
+    def finalize_first_succeeded
+      errors = [] # : Array[TerminalError]
+      @children.each do |c|
+        next unless c.completed?
+
+        return c.await
+      rescue TerminalError => e
+        errors << e
+      end
+      raise TerminalError.new("all futures failed: #{errors.map(&:message).join('; ')}",
+                              status_code: 500)
+    end
+  end
+
   # A handle for fire-and-forget send operations.
   # Returned by +ctx.service_send+, +ctx.object_send+, +ctx.workflow_send+.
   class SendHandle

data/lib/restate/server/context.rb

@@ -169,6 +169,44 @@ module Restate
         futures.partition(&:completed?)
       end
 
+      # Build a lazy combinator over the given futures and return it as a
+      # +CombinedFuture+. Nothing blocks until +.await+ is called, so the
+      # combinators compose: +Restate.race(Restate.all(a, b), c).await+.
+      #
+      # Semantics match JS +Promise.all+ — when awaited, returns the values in
+      # input order, short-circuiting on the first +TerminalError+.
+      def all(*futures)
+        futures = futures.first if futures.length == 1 && futures.first.is_a?(Array)
+        CombinedFuture.new(self, :all_succeeded_or_first_failed, futures)
+      end
+
+      # Lazy combinator. Awaiting returns the value of the first future to settle,
+      # or raises if it settled with a +TerminalError+. Matches JS +Promise.race+.
+      def race(*futures)
+        futures = futures.first if futures.length == 1 && futures.first.is_a?(Array)
+        raise ArgumentError, 'race requires at least one future' if futures.empty?
+
+        CombinedFuture.new(self, :first_completed, futures)
+      end
+
+      # Lazy combinator. Awaiting returns the value of the first successful future;
+      # raises only if every future fails terminally. Matches JS +Promise.any+.
+      def any(*futures)
+        futures = futures.first if futures.length == 1 && futures.first.is_a?(Array)
+        raise ArgumentError, 'any requires at least one future' if futures.empty?
+
+        CombinedFuture.new(self, :first_succeeded_or_all_failed, futures)
+      end
+
+      # Lazy combinator. Awaiting waits for every future to settle and returns
+      # an Array of +{ status: :fulfilled, value: ... }+ or
+      # +{ status: :rejected, reason: TerminalError }+ entries, in input order.
+      # Matches JS +Promise.allSettled+.
+      def all_settled(*futures)
+        futures = futures.first if futures.length == 1 && futures.first.is_a?(Array)
+        CombinedFuture.new(self, :all_completed, futures)
+      end
+
       # ── Durable run (side effect) ──
 
       # Executes a durable side effect. The block runs at most once; its result is
@@ -178,14 +216,18 @@ module Restate
       # fiber event loop responsive for other concurrent handlers. Use this for
       # CPU-intensive work.
       def run(name, serde: JsonSerde, retry_policy: nil, background: false, &action)
-        handle = @vm.sys_run(name)
-
-        @run_coros_to_execute[handle] =
-          if background
-            -> { execute_run_threaded(handle, action, serde, retry_policy) }
-          else
-            -> { execute_run(handle, action, serde, retry_policy) }
-          end
+        run = @vm.sys_run(name)
+        handle = run.handle
+
+        # Schedule the run closure only if the run wasn't replayed.
+        unless run.replayed
+          @run_coros_to_execute[handle] =
+            if background
+              -> { execute_run_threaded(handle, action, serde, retry_policy) }
+            else
+              -> { execute_run(handle, action, serde, retry_policy) }
+            end
+        end
 
         DurableFuture.new(self, handle, serde: serde)
       end
@@ -401,6 +443,14 @@ module Restate
         @invocation.key
       end
 
+      # Drive progress over a combinator tree. Returns when the combinator
+      # logically completes (the shared-core decides based on the tree shape).
+      # +future_tree+ follows the encoding documented in lib/restate/vm.rb#do_await.
+      # Public so +CombinedFuture#await+ can drive it via +@ctx.wait_combined+.
+      def wait_combined(future_tree)
+        progress_loop { @vm.do_await(future_tree) }
+      end
+
       private
 
       # ── Progress loop ──
@@ -411,13 +461,24 @@ module Restate
         must_take_notification(handle, &)
       end
 
+      # Wait for any of the given handles to complete. Wraps the flat handle
+      # list into a +FirstCompleted+ subtree (or a +Single+ leaf for one handle)
+      # and drives the VM via +do_await+ — same path as +wait_combined+.
       def poll_or_cancel(handles)
+        tree = handles.length == 1 ? handles.first : [:first_completed, handles]
+        wait_combined(tree)
+      end
+
+      # Shared progress-loop body for both the simple poll_or_cancel and the
+      # tree-aware wait_combined. The block makes one VM call per iteration and
+      # returns the response; this loop interprets it.
+      def progress_loop
         loop do
           flush_output
-          response = @vm.do_progress(handles)
+          response = yield
 
           if response.is_a?(Exception)
-            LOGGER.error("Exception in do_progress: #{response}")
+            LOGGER.error("Exception in progress loop: #{response}")
             raise InternalError
           end
 

data/lib/restate/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Restate
-  VERSION = '0.14.0'
+  VERSION = '1.0.0'
 end

data/lib/restate/vm.rb

@@ -90,8 +90,12 @@ module Restate
       @vm.is_completed(handle)
     end
 
-    def do_progress(handles)
-      result = @vm.do_progress(handles)
+    # Drive the VM forward against an +UnresolvedFuture+ tree. +future+ is either
+    # an Integer handle (Single leaf) or a +[tag_symbol, [children...]]+ pair
+    # (combinator node). See the Rust-side +parse_unresolved_future+ for the
+    # supported tags.
+    def do_await(future)
+      result = @vm.do_await(future)
       map_do_progress(result)
     rescue Internal::VMError => e
       e

data/lib/restate.rb

@@ -293,6 +293,34 @@ module Restate # rubocop:disable Metrics/ModuleLength
     fetch_context!.wait_any(*futures)
   end
 
+  # Wait for every future to complete and return their values in input order.
+  # Short-circuits on the first +TerminalError+. Accepts either splat futures or
+  # a single Array. Semantics match JS +Promise.all+.
+  def all(*futures)
+    fetch_context!.all(*futures)
+  end
+
+  # Wait for the first future to settle and return its value. Raises if the
+  # winning future failed. Accepts either splat futures or a single Array.
+  # Semantics match JS +Promise.race+.
+  def race(*futures)
+    fetch_context!.race(*futures)
+  end
+
+  # Wait for the first successful future and return its value. Raises only if
+  # every future failed terminally. Accepts splat or single Array.
+  # Semantics match JS +Promise.any+.
+  def any(*futures)
+    fetch_context!.any(*futures)
+  end
+
+  # Wait for every future to settle. Returns an Array of outcome descriptors
+  # (+{status: :fulfilled, value: ...}+ or +{status: :rejected, reason: ...}+),
+  # in input order. Semantics match JS +Promise.allSettled+.
+  def all_settled(*futures)
+    fetch_context!.all_settled(*futures)
+  end
+
   # ── Request metadata ──
 
   # Returns metadata about the current invocation (id, headers, raw body).

data/sig/restate.rbs

@@ -60,6 +60,10 @@ module Restate
   # ── Futures / Metadata / Control ──
 
   def self.wait_any: (*DurableFuture futures) -> [Array[DurableFuture], Array[DurableFuture]]
+  def self.all: (*untyped futures) -> CombinedFuture
+  def self.race: (*untyped futures) -> CombinedFuture
+  def self.any: (*untyped futures) -> CombinedFuture
+  def self.all_settled: (*untyped futures) -> CombinedFuture
   def self.request: () -> untyped
   def self.key: () -> String
   def self.cancel_invocation: (String invocation_id) -> void
@@ -97,12 +101,34 @@ module Restate
     def await: () -> untyped
     def completed?: () -> bool
     def or_timeout: (Numeric duration) -> untyped
+
+    private
+    def resolve!: () -> void
   end
 
   class DurableCallFuture < DurableFuture
     def initialize: (untyped ctx, Integer result_handle, Integer invocation_id_handle, output_serde: untyped) -> void
     def invocation_id: () -> String
     def cancel: () -> void
+
+    private
+    def resolve_call!: () -> void
+  end
+
+  class CombinedFuture
+    VALID_VARIANTS: Array[Symbol]
+    def initialize: (untyped ctx, Symbol variant, Array[untyped] children) -> void
+    def tree: () -> untyped
+    def await: () -> untyped
+    def completed?: () -> bool
+
+    private
+    def resolve_combined!: () -> void
+    def finalize_value: () -> untyped
+    def finalize_first_completed: () -> untyped
+    def finalize_all_succeeded: () -> Array[untyped]
+    def finalize_all_completed: () -> Array[Hash[Symbol, untyped]]
+    def finalize_first_succeeded: () -> untyped
   end
 
   class SendHandle

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restate-sdk
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Restate Developers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-29 00:00:00.000000000 Z
+date: 2026-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async