restate-sdk 0.14.0 → 1.1.0

data/ext/restate_internal/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "restate_internal"
-version = "0.14.0"
+version = "1.1.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", "rust_crypto"] }
 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.1.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).