microsandbox-rb 0.17.1 → 0.17.2

data/ext/microsandbox/src/ssh.rs

@@ -52,7 +52,7 @@ impl SshClient {
             let guard = inner.lock().await;
             let client = guard.as_ref().ok_or_else(consumed)?;
             client.exec_with(command, |b| b.tty(tty)).await
-        });
+        })?;
         Ok(ssh_output_to_hash(result.map_err(error::to_ruby)?))
     }
 
@@ -74,7 +74,7 @@ impl SshClient {
                     b
                 })
                 .await
-        });
+        })?;
         result.map_err(error::to_ruby)
     }
 
@@ -85,7 +85,7 @@ impl SshClient {
             let guard = inner.lock().await;
             let client = guard.as_ref().ok_or_else(consumed)?;
             client.sftp().await
-        });
+        })?;
         Ok(SftpClient::from_core(result.map_err(error::to_ruby)?))
     }
 
@@ -101,7 +101,7 @@ impl SshClient {
                 Some(c) => c.close().await,
                 None => Ok(()),
             }
-        });
+        })?;
         result.map_err(error::to_ruby)
     }
 }
@@ -144,7 +144,7 @@ impl SftpClient {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
             sftp.read(path).await.map_err(sftp_str)
-        });
+        })?;
         Ok(ruby().str_from_slice(&result.map_err(error::base_error)?))
     }
 
@@ -158,7 +158,7 @@ impl SftpClient {
             file.write_all(&bytes).await.map_err(sftp_str)?;
             file.shutdown().await.map_err(sftp_str)?;
             Ok(())
-        });
+        })?;
         result.map_err(error::base_error)
     }
 
@@ -168,7 +168,7 @@ impl SftpClient {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
             sftp.create_dir(path).await.map_err(sftp_str)
-        });
+        })?;
         result.map_err(error::base_error)
     }
 
@@ -178,7 +178,7 @@ impl SftpClient {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
             sftp.remove_file(path).await.map_err(sftp_str)
-        });
+        })?;
         result.map_err(error::base_error)
     }
 
@@ -188,7 +188,7 @@ impl SftpClient {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
             sftp.remove_dir(path).await.map_err(sftp_str)
-        });
+        })?;
         result.map_err(error::base_error)
     }
 
@@ -198,7 +198,7 @@ impl SftpClient {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
             sftp.rename(old_path, new_path).await.map_err(sftp_str)
-        });
+        })?;
         result.map_err(error::base_error)
     }
 
@@ -208,7 +208,7 @@ impl SftpClient {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
             sftp.symlink(target, link_path).await.map_err(sftp_str)
-        });
+        })?;
         result.map_err(error::base_error)
     }
 
@@ -218,7 +218,7 @@ impl SftpClient {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
             sftp.canonicalize(path).await.map_err(sftp_str)
-        });
+        })?;
         result.map_err(error::base_error)
     }
 
@@ -228,7 +228,7 @@ impl SftpClient {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
             sftp.read_link(path).await.map_err(sftp_str)
-        });
+        })?;
         result.map_err(error::base_error)
     }
 
@@ -243,7 +243,7 @@ impl SftpClient {
                 Some(s) => s.close().await.map_err(sftp_str),
                 None => Ok(()),
             }
-        });
+        })?;
         result.map_err(error::base_error)
     }
 }
@@ -276,7 +276,7 @@ impl SshServer {
                 Some(s) => s.serve_connection(SshStdioStream::new()).await,
                 None => Err(consumed()),
             }
-        });
+        })?;
         result.map_err(error::to_ruby)
     }
 
@@ -285,19 +285,23 @@ impl SshServer {
         let inner = Arc::clone(&self.inner);
         block_on(async move {
             inner.lock().await.take();
-        });
+        })?;
         Ok(())
     }
 }
 
 pub fn define(ruby: &Ruby, native: &RModule) -> Result<(), Error> {
     let client = native.define_class("SshClient", ruby.class_object())?;
+    // Resolve the wrapper class now, not on first use (see `preload_class`).
+    crate::runtime::preload_class::<SshClient>(ruby);
     client.define_method("exec", method!(SshClient::exec, 2))?;
     client.define_method("attach", method!(SshClient::attach, 2))?;
     client.define_method("sftp", method!(SshClient::sftp, 0))?;
     client.define_method("close", method!(SshClient::close, 0))?;
 
     let sftp = native.define_class("SftpClient", ruby.class_object())?;
+    // Resolve the wrapper class now, not on first use (see `preload_class`).
+    crate::runtime::preload_class::<SftpClient>(ruby);
     sftp.define_method("read", method!(SftpClient::read, 1))?;
     sftp.define_method("write", method!(SftpClient::write, 2))?;
     sftp.define_method("mkdir", method!(SftpClient::mkdir, 1))?;
@@ -310,6 +314,8 @@ pub fn define(ruby: &Ruby, native: &RModule) -> Result<(), Error> {
     sftp.define_method("close", method!(SftpClient::close, 0))?;
 
     let server = native.define_class("SshServer", ruby.class_object())?;
+    // Resolve the wrapper class now, not on first use (see `preload_class`).
+    crate::runtime::preload_class::<SshServer>(ruby);
     server.define_method("serve_connection", method!(SshServer::serve_connection, 0))?;
     server.define_method("close", method!(SshServer::close, 0))?;
 

data/ext/microsandbox/src/stream.rs

@@ -41,7 +41,7 @@ impl LogStream {
     fn recv(&self) -> Result<Option<RHash>, Error> {
         use futures::StreamExt;
         let inner = Arc::clone(&self.inner);
-        match block_on(async move { inner.lock().await.next().await }) {
+        match block_on(async move { inner.lock().await.next().await })? {
             Some(Ok(entry)) => Ok(Some(log_entry_to_hash(&entry))),
             Some(Err(e)) => Err(error::to_ruby(e)),
             None => Ok(None),
@@ -67,7 +67,7 @@ impl MetricsStream {
     fn recv(&self) -> Result<Option<RHash>, Error> {
         use futures::StreamExt;
         let inner = Arc::clone(&self.inner);
-        match block_on(async move { inner.lock().await.next().await }) {
+        match block_on(async move { inner.lock().await.next().await })? {
             Some(Ok(metrics)) => Ok(Some(metrics_to_hash(&metrics))),
             Some(Err(e)) => Err(error::to_ruby(e)),
             None => Ok(None),
@@ -77,9 +77,13 @@ impl MetricsStream {
 
 pub fn define(ruby: &Ruby, native: &RModule) -> Result<(), Error> {
     let logs = native.define_class("LogStream", ruby.class_object())?;
+    // Resolve the wrapper class now, not on first use (see `preload_class`).
+    crate::runtime::preload_class::<LogStream>(ruby);
     logs.define_method("recv", method!(LogStream::recv, 0))?;
 
     let metrics = native.define_class("MetricsStream", ruby.class_object())?;
+    // Resolve the wrapper class now, not on first use (see `preload_class`).
+    crate::runtime::preload_class::<MetricsStream>(ruby);
     metrics.define_method("recv", method!(MetricsStream::recv, 0))?;
 
     Ok(())

data/ext/microsandbox/src/volume.rs

@@ -68,7 +68,7 @@ fn create(name: String, opts: RHash) -> Result<RHash, Error> {
         builder = builder.label(k, v);
     }
 
-    let vol = block_on(builder.create()).map_err(error::to_ruby)?;
+    let vol = block_on(builder.create())?.map_err(error::to_ruby)?;
     let hash = ruby().hash_new();
     hash.aset("name", vol.name().to_string())?;
     // `path()` is fallible as of v0.5.8 (returns `Unsupported` for cloud
@@ -81,19 +81,19 @@ fn create(name: String, opts: RHash) -> Result<RHash, Error> {
 }
 
 fn get(name: String) -> Result<RHash, Error> {
-    let handle = block_on(microsandbox::Volume::get(&name)).map_err(error::to_ruby)?;
+    let handle = block_on(microsandbox::Volume::get(&name))?.map_err(error::to_ruby)?;
     Ok(handle_to_hash(&handle))
 }
 
 /// The backend's default volume (v0.6.9). Cloud-backend only — the local
 /// backend rejects it (Unsupported) to avoid accidental host access.
 fn get_default() -> Result<RHash, Error> {
-    let handle = block_on(microsandbox::Volume::get_default()).map_err(error::to_ruby)?;
+    let handle = block_on(microsandbox::Volume::get_default())?.map_err(error::to_ruby)?;
     Ok(handle_to_hash(&handle))
 }
 
 fn list() -> Result<RArray, Error> {
-    let handles = block_on(microsandbox::Volume::list()).map_err(error::to_ruby)?;
+    let handles = block_on(microsandbox::Volume::list())?.map_err(error::to_ruby)?;
     let arr = ruby().ary_new();
     for h in handles.iter() {
         arr.push(handle_to_hash(h))?;
@@ -102,7 +102,7 @@ fn list() -> Result<RArray, Error> {
 }
 
 fn remove(name: String) -> Result<(), Error> {
-    block_on(microsandbox::Volume::remove(&name)).map_err(error::to_ruby)
+    block_on(microsandbox::Volume::remove(&name))?.map_err(error::to_ruby)
 }
 
 /// Volume paths are relative to the volume root and never need a `..` segment,
@@ -151,14 +151,14 @@ impl VolumeFs {
     fn read(&self, path: String) -> Result<RString, Error> {
         let path = contained(&path)?;
         let fs = self.fs();
-        let bytes = block_on(fs.read(path)).map_err(error::to_ruby)?;
+        let bytes = block_on(fs.read(path))?.map_err(error::to_ruby)?;
         Ok(ruby().str_from_slice(bytes.as_ref()))
     }
 
     fn read_text(&self, path: String) -> Result<String, Error> {
         let path = contained(&path)?;
         let fs = self.fs();
-        block_on(fs.read_to_string(path)).map_err(error::to_ruby)
+        block_on(fs.read_to_string(path))?.map_err(error::to_ruby)
     }
 
     fn write(&self, path: String, data: RString) -> Result<(), Error> {
@@ -166,13 +166,13 @@ impl VolumeFs {
         let bytes = unsafe { data.as_slice() }.to_vec();
         let path = contained(&path)?;
         let fs = self.fs();
-        block_on(fs.write(path, &bytes)).map_err(error::to_ruby)
+        block_on(fs.write(path, &bytes))?.map_err(error::to_ruby)
     }
 
     fn list(&self, path: String) -> Result<RArray, Error> {
         let path = contained(&path)?;
         let fs = self.fs();
-        let entries = block_on(fs.list(path)).map_err(error::to_ruby)?;
+        let entries = block_on(fs.list(path))?.map_err(error::to_ruby)?;
         let arr = ruby().ary_new();
         for entry in &entries {
             arr.push(fs_entry_to_hash(entry))?;
@@ -183,45 +183,45 @@ impl VolumeFs {
     fn mkdir(&self, path: String) -> Result<(), Error> {
         let path = contained(&path)?;
         let fs = self.fs();
-        block_on(fs.mkdir(path)).map_err(error::to_ruby)
+        block_on(fs.mkdir(path))?.map_err(error::to_ruby)
     }
 
     fn remove_file(&self, path: String) -> Result<(), Error> {
         let path = contained(&path)?;
         let fs = self.fs();
-        block_on(fs.remove(path)).map_err(error::to_ruby)
+        block_on(fs.remove(path))?.map_err(error::to_ruby)
     }
 
     fn remove_dir(&self, path: String) -> Result<(), Error> {
         let path = contained(&path)?;
         let fs = self.fs();
-        block_on(fs.remove_dir(path)).map_err(error::to_ruby)
+        block_on(fs.remove_dir(path))?.map_err(error::to_ruby)
     }
 
     fn exists(&self, path: String) -> Result<bool, Error> {
         let path = contained(&path)?;
         let fs = self.fs();
-        block_on(fs.exists(path)).map_err(error::to_ruby)
+        block_on(fs.exists(path))?.map_err(error::to_ruby)
     }
 
     fn copy(&self, from: String, to: String) -> Result<(), Error> {
         let from = contained(&from)?;
         let to = contained(&to)?;
         let fs = self.fs();
-        block_on(fs.copy(from, to)).map_err(error::to_ruby)
+        block_on(fs.copy(from, to))?.map_err(error::to_ruby)
     }
 
     fn rename(&self, from: String, to: String) -> Result<(), Error> {
         let from = contained(&from)?;
         let to = contained(&to)?;
         let fs = self.fs();
-        block_on(fs.rename(from, to)).map_err(error::to_ruby)
+        block_on(fs.rename(from, to))?.map_err(error::to_ruby)
     }
 
     fn stat(&self, path: String) -> Result<RHash, Error> {
         let path = contained(&path)?;
         let fs = self.fs();
-        let meta = block_on(fs.stat(path)).map_err(error::to_ruby)?;
+        let meta = block_on(fs.stat(path))?.map_err(error::to_ruby)?;
         Ok(fs_metadata_to_hash(&meta))
     }
 }
@@ -241,6 +241,8 @@ pub fn define(ruby: &Ruby, native: &RModule) -> Result<(), Error> {
     class.define_singleton_method("fs", function!(fs, 1))?;
 
     let vfs = native.define_class("VolumeFs", ruby.class_object())?;
+    // Resolve the wrapper class now, not on first use (see `preload_class`).
+    crate::runtime::preload_class::<VolumeFs>(ruby);
     vfs.define_method("read", method!(VolumeFs::read, 1))?;
     vfs.define_method("read_text", method!(VolumeFs::read_text, 1))?;
     vfs.define_method("write", method!(VolumeFs::write, 2))?;

data/lib/microsandbox/sandbox.rb

@@ -496,7 +496,10 @@ module Microsandbox
       def create(name, **kwargs, &block)
         opts = build_create_opts(**kwargs)
         Microsandbox.ensure_runtime!
-        sandbox = new(Native::Sandbox.create(name.to_s, opts))
+        # Everything Ruby-level happens BEFORE `acquire`: its interrupt mask must
+        # cover only the native call plus the wrap, never caller-supplied code.
+        sandbox_name = name.to_s
+        sandbox = acquire { Native::Sandbox.create(sandbox_name, opts) }
         return sandbox unless block_given?
 
         begin
@@ -553,7 +556,8 @@ module Microsandbox
       def connect_or_create(name, **kwargs, &block)
         opts = build_create_opts(**kwargs)
         Microsandbox.ensure_runtime!
-        sandbox = new(Native::Sandbox.connect_or_create(name.to_s, opts))
+        sandbox_name = name.to_s # outside the interrupt mask, like in {create}
+        sandbox = acquire { Native::Sandbox.connect_or_create(sandbox_name, opts) }
         return sandbox unless block_given?
 
         begin
@@ -588,6 +592,65 @@ module Microsandbox
         PullSession.new(Native::Sandbox.create_with_progress(name.to_s, opts))
       end
 
+      # @api private
+      # Wrap the native sandbox the block acquires, and stop it again if an
+      # interrupt cuts in before the caller has it.
+      #
+      # A native call cannot be interrupted while it runs, so a `Thread#raise`
+      # (what `Timeout.timeout` uses) or a `Thread#kill` that arrives during the
+      # block is delivered after it — at the next interrupt checkpoint, which is
+      # still in here, before the caller ever sees the object. Left alone the
+      # sandbox would be garbage and only GC would stop it, "eventually"; for
+      # `Timeout.timeout { Sandbox.create(...) }` that is not good enough. So:
+      #
+      # - the acquisition runs under `Thread.handle_interrupt(Object => :never)`,
+      #   which holds a queued exception (or kill) back until the wrapper is
+      #   assigned. The mask covers only the uninterruptible native call plus
+      #   the wrap, so it changes no observable timing; runtime provisioning
+      #   ({Microsandbox.ensure_runtime!}) and the block forms' `yield` stay
+      #   outside it, with normal interrupt handling. For the same reason the
+      #   block passed here must contain NOTHING but the native call: argument
+      #   conversion (`name.to_s`, option Hashes) is the caller's own code and
+      #   has to run before `acquire`, where it stays interruptible;
+      # - the `ensure` plus the `acquired` flag — not `rescue Exception; raise` —
+      #   is what also covers `Thread#kill`, which no `rescue` can catch.
+      #
+      # A SIGINT (Ctrl-C on the main thread) is the exception: it is not queued
+      # like those two and cannot be masked. One that lands during the native
+      # call is raised the moment the call returns — the VM checks interrupts
+      # as it pops the native method's frame, before any Ruby code here can
+      # hold the result — so no assignment order would catch it; the sandbox
+      # is then torn down when the unreferenced object is garbage-collected.
+      #
+      # Ownership: {connect_or_create} can hand back a sandbox that was already
+      # running for someone else, and {start} restarts a persisted one. The
+      # cleanup therefore applies EXACTLY the predicate the block form of
+      # {connect_or_create} uses — {Sandbox#owns_lifecycle?} — in all three
+      # callers, {create} included: a sandbox this call does not own is never
+      # stopped here. Its reference is just let go (GC closes the handle, the
+      # sandbox keeps running).
+      # @yieldreturn [Native::Sandbox]
+      # @return [Sandbox]
+      def acquire
+        sandbox = nil
+        acquired = false
+        begin
+          Thread.handle_interrupt(Object => :never) do
+            sandbox = new(yield)
+          end
+          acquired = true
+        ensure
+          if sandbox && !acquired && sandbox.owns_lifecycle?
+            begin
+              sandbox.stop
+            rescue Microsandbox::Error
+              # best-effort cleanup; the interrupt is what the caller must see
+            end
+          end
+        end
+        sandbox
+      end
+
       # @api private
       # Shared keyword-option builder for {create}/{connect_or_create}/
       # {create_with_progress}. Pure validation and normalization: the callers
@@ -705,7 +768,9 @@ module Microsandbox
       # @return [Sandbox]
       def start(name, detached: false)
         Microsandbox.ensure_runtime!
-        new(Native::Sandbox.start(name.to_s, {"detached" => detached}))
+        sandbox_name = name.to_s # outside the interrupt mask, like in {create}
+        opts = {"detached" => detached}
+        acquire { Native::Sandbox.start(sandbox_name, opts) }
       end
 
       # Fetch a controllable handle for a sandbox by name (running or not).
@@ -1998,10 +2063,16 @@ module Microsandbox
     # {Sandbox} is live — stop it when done. Memoized: the native result can be
     # taken only once, so a later call returns the same {Sandbox}, or re-raises
     # the same error if the create failed.
+    #
+    # Interrupt-safe like {Sandbox.create}: if a `Timeout.timeout` (or another
+    # `Thread#raise`/`Thread#kill`) arrives while this is waiting, the sandbox
+    # the session produced is stopped before the exception propagates rather
+    # than left running with nothing referring to it. The result is consumed
+    # by then, so a later call raises instead of returning a sandbox.
     # @return [Sandbox]
     def sandbox
       raise @failure if @failure
-      @sandbox ||= Sandbox.new(@native.result)
+      @sandbox ||= Sandbox.acquire { @native.result }
     rescue Microsandbox::Error => e
       @failure ||= e
       raise

data/lib/microsandbox/version.rb

@@ -8,7 +8,7 @@ module Microsandbox
   # Versioning section of the README for the full gem-to-runtime map. Must equal
   # the native ext's Cargo crate version (`Native.version`), enforced by
   # spec/unit/version_spec.rb.
-  VERSION = "0.17.1"
+  VERSION = "0.17.2"
 
   # The upstream microsandbox runtime release this gem build embeds — the `tag`
   # pinned on the `microsandbox`/`microsandbox-network` git deps in

data/sig/microsandbox.rbs

@@ -82,6 +82,7 @@ module Microsandbox
   end
 
   class FsEntry
+    def initialize: (Hash[String, untyped] data) -> void
     def path: () -> String
     def name: () -> String
     def type: () -> Symbol
@@ -94,6 +95,7 @@ module Microsandbox
   end
 
   class FsMetadata
+    def initialize: (Hash[String, untyped] data) -> void
     def type: () -> Symbol
     def size: () -> Integer
     def mode: () -> Integer
@@ -106,6 +108,7 @@ module Microsandbox
   end
 
   class FS
+    def initialize: (untyped native) -> void
     def read: (String path) -> String
     def read_text: (String path) -> String
     def write: (String path, String data) -> nil
@@ -125,17 +128,20 @@ module Microsandbox
 
   class FsReadStream
     include Enumerable[String]
+    def initialize: (untyped native) -> void
     def each: () { (String) -> void } -> self
             | () -> Enumerator[String, self]
     def read: () -> String
   end
 
   class FsWriteSink
+    def initialize: (untyped native) -> void
     def write: (String data) -> self
     def close: () -> nil
   end
 
   class Metrics
+    def initialize: (Hash[String, untyped] data) -> void
     def cpu_percent: () -> Float
     def vcpu_time_ns: () -> Integer
     def memory_bytes: () -> Integer
@@ -154,6 +160,7 @@ module Microsandbox
   end
 
   class LogEntry
+    def initialize: (Hash[String, untyped] entry) -> void
     def source: () -> Symbol
     def session_id: () -> Integer?
     def cursor: () -> String
@@ -163,6 +170,7 @@ module Microsandbox
   end
 
   class SandboxHandle
+    def initialize: (untyped native) -> void
     def name: () -> String
     def id: () -> String
     def status: () -> Symbol
@@ -200,6 +208,7 @@ module Microsandbox
   SandboxInfo: singleton(SandboxHandle)
 
   class SandboxStopResult
+    def initialize: (Hash[String, untyped] data) -> void
     def name: () -> String
     def status: () -> Symbol
     def exit_code: () -> Integer?
@@ -290,6 +299,7 @@ module Microsandbox
     def self.list_with: (?labels: Hash[untyped, untyped], ?limit: Integer?, ?cursor: String?) -> SandboxPage
     def self.remove: (String name) -> nil
 
+    def initialize: (untyped native) -> void
     def name: () -> String
     def id: () -> String
     def exec: (String command, ?Array[String] args, ?cwd: String?, ?user: String?,
@@ -354,17 +364,20 @@ module Microsandbox
 
   class LogStream
     include Enumerable[LogEntry]
+    def initialize: (untyped native) -> void
     def each: () { (LogEntry) -> void } -> self
             | () -> Enumerator[LogEntry, self]
   end
 
   class MetricsStream
     include Enumerable[Metrics]
+    def initialize: (untyped native) -> void
     def each: () { (Metrics) -> void } -> self
             | () -> Enumerator[Metrics, self]
   end
 
   class ExecEvent
+    def initialize: (Hash[String, untyped] event) -> void
     def type: () -> Symbol
     def pid: () -> Integer?
     def code: () -> Integer?
@@ -379,18 +392,21 @@ module Microsandbox
   end
 
   class ExitStatus
+    def initialize: (Hash[String, untyped] data) -> void
     def exit_code: () -> Integer?
     def success?: () -> bool
     def failure?: () -> bool
   end
 
   class ExecStdin
+    def initialize: (untyped native) -> void
     def write: (String data) -> self
     def close: () -> nil
   end
 
   class ExecHandle
     include Enumerable[ExecEvent]
+    def initialize: (untyped native) -> void
     def id: () -> String
     def each: () { (ExecEvent) -> void } -> self
             | () -> Enumerator[ExecEvent, self]
@@ -403,6 +419,7 @@ module Microsandbox
   end
 
   class ImageInfo
+    def initialize: (Hash[String, untyped] data) -> void
     def reference: () -> String
     def size_bytes: () -> Integer?
     def manifest_digest: () -> String?
@@ -414,6 +431,7 @@ module Microsandbox
   end
 
   class ImageDetail
+    def initialize: (Hash[String, untyped] data) -> void
     def handle: () -> ImageInfo
     def config: () -> Hash[String, untyped]?
     def layers: () -> Array[Hash[String, untyped]]
@@ -421,6 +439,7 @@ module Microsandbox
   end
 
   class ImagePruneReport
+    def initialize: (Hash[String, untyped] data) -> void
     def image_refs_removed: () -> Integer
     def manifests_removed: () -> Integer
     def layers_removed: () -> Integer
@@ -441,6 +460,7 @@ module Microsandbox
   end
 
   class VolumeInfo
+    def initialize: (Hash[String, untyped] data) -> void
     def name: () -> String
     def path: () -> String?
     def kind: () -> Symbol?
@@ -481,6 +501,7 @@ module Microsandbox
   end
 
   class SnapshotInfo
+    def initialize: (Hash[String, untyped] data) -> void
     def digest: () -> String
     def path: () -> String
     def name: () -> String?
@@ -506,6 +527,7 @@ module Microsandbox
   end
 
   class SnapshotVerifyReport
+    def initialize: (Hash[String, untyped] data) -> void
     def digest: () -> String
     def path: () -> String
     def status: () -> Symbol
@@ -569,6 +591,7 @@ module Microsandbox
   end
 
   class BackendInfo
+    def initialize: (Hash[String, untyped] data) -> void
     def kind: () -> Symbol
     def api_url: () -> String?
     def source: () -> Symbol
@@ -643,6 +666,7 @@ module Microsandbox
 
   class AgentStream
     include Enumerable[AgentFrame]
+    def initialize: (untyped native, Integer id, Integer handle) -> void
     def id: () -> Integer
     def recv: () -> AgentFrame?
     def each: () { (AgentFrame) -> void } -> self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: microsandbox-rb
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 0.17.2
 platform: ruby
 authors:
 - ya-luotao