kobako 0.3.0 → 0.4.0

data/lib/kobako/sandbox.rb

@@ -4,24 +4,28 @@ require "forwardable"
 
 require_relative "capture"
 require_relative "errors"
+require_relative "handle_table"
 require_relative "invocation"
 require_relative "outcome"
 require_relative "rpc/server"
 require_relative "rpc/envelope"
 require_relative "sandbox_options"
 require_relative "snippet"
+require_relative "usage"
 
 module Kobako
   # Kobako::Sandbox — the user-facing entry point for executing guest mruby
   # scripts inside a wasmtime-hosted Wasm module
   # ({docs/behavior.md B-01}[link:../../docs/behavior.md]).
   #
-  # The Sandbox owns the +Kobako::Wasm::Instance+, the per-instance RPC Server
-  # (which itself owns the per-run HandleTable), and the per-channel byte
-  # caches for guest stdout / stderr capture. The underlying wasmtime Engine
-  # and compiled Module are cached at process scope by the native ext and
-  # never surface to Ruby — constructing many Sandboxes amortises both costs
-  # automatically.
+  # The Sandbox owns the +Kobako::Wasm::Instance+, the per-Sandbox
+  # +Kobako::HandleTable+ ({docs/behavior.md B-19}[link:../../docs/behavior.md]),
+  # the per-instance RPC Server (which receives the HandleTable by
+  # injection so guest→host dispatch and host→guest auto-wrap share one
+  # allocator), and the per-channel byte caches for guest stdout / stderr
+  # capture. The underlying wasmtime Engine and compiled Module are cached
+  # at process scope by the native ext and never surface to Ruby —
+  # constructing many Sandboxes amortises both costs automatically.
   #
   # Output capture policy ({docs/behavior.md B-04}[link:../../docs/behavior.md]): the
   # per-channel cap (+stdout_limit+ / +stderr_limit+) is enforced inside the
@@ -72,6 +76,17 @@ module Kobako
       @stderr_capture.truncated?
     end
 
+    # Returns the +Kobako::Usage+ value object for the most recent
+    # invocation ({docs/behavior.md B-35}[link:../../docs/behavior.md]).
+    # Carries +wall_time+ (Float seconds the guest export call spent
+    # inside wasmtime) and +memory_peak+ (Integer bytes, high-water of
+    # the per-invocation +memory.grow+ delta past the entry-time
+    # baseline). Returns +Kobako::Usage::EMPTY+ before any invocation;
+    # populated on every outcome — including +TrapError+ — so the Host
+    # App can read it after rescuing a trap to diagnose budget
+    # consumption.
+    attr_reader :usage
+
     # Build a fresh Sandbox.
     #
     # +wasm_path+ is the absolute path to the Guest Binary; defaults to the
@@ -87,12 +102,13 @@ module Kobako
       @wasm_path = wasm_path || Kobako::Wasm.default_path
       @options = SandboxOptions.new(timeout: timeout, memory_limit: memory_limit, stdout_limit: stdout_limit,
                                     stderr_limit: stderr_limit)
-      @services = Kobako::RPC::Server.new
+      @handle_table = HandleTable.new
+      @services = Kobako::RPC::Server.new(handle_table: @handle_table)
       @snippets = Snippet::Table.new
       @instance = Kobako::Wasm::Instance.from_path(@wasm_path, @options.timeout, @options.memory_limit,
                                                    @options.stdout_limit, @options.stderr_limit)
       @instance.server = @services
-      clear_captures!
+      reset_invocation_state!
     end
 
     # Declare or retrieve the Namespace named +name+ on this Sandbox
@@ -154,7 +170,7 @@ module Kobako
     def run(target, *args, **kwargs)
       invocation = Invocation.new(entrypoint: target, args: args, kwargs: kwargs)
       invoke!(:run) do
-        @instance.run(@services.encoded_preamble, @snippets.encode, invocation.encode)
+        @instance.run(@services.encoded_preamble, @snippets.encode, invocation.encode(@handle_table))
       end
     end
 
@@ -195,28 +211,36 @@ module Kobako
     # B-33}[link:../../docs/behavior.md]). Seals the Service / snippet
     # registries on first call (idempotent) and zeros the per-invocation
     # capability state — capture buffers, truncation predicates, and the
-    # HandleTable counter — before the guest runs.
+    # HandleTable counter — before the guest runs. The HandleTable
+    # itself is held as +@handle_table+ and never exposed beyond
+    # this class: SPEC.md Terminology pins it as "Not exposed to the
+    # Host App" (B-19 / B-20 / E-29).
     def begin_invocation!
       @services.seal!
-      @services.reset_handles!
-      clear_captures!
+      @handle_table.reset!
+      reset_invocation_state!
     end
 
-    # Reset both per-channel captures to the pre-invocation sentinel
-    # ({docs/behavior.md B-05}[link:../../docs/behavior.md]). Shared by +#initialize+
-    # (first-time setup) and +#begin_invocation!+ (between-invocation
-    # reset) so both paths agree on what "empty capture" means.
-    def clear_captures!
+    # Reset all per-invocation observable state to its pre-invocation
+    # sentinels — both per-channel captures
+    # ({docs/behavior.md B-05}[link:../../docs/behavior.md]) and the
+    # per-last-invocation usage record
+    # ({docs/behavior.md B-35}[link:../../docs/behavior.md]). Shared by
+    # +#initialize+ (first-time setup) and +#begin_invocation!+
+    # (between-invocation reset) so both paths agree on what
+    # "pre-invocation state" means.
+    def reset_invocation_state!
       @stdout_capture = Capture::EMPTY
       @stderr_capture = Capture::EMPTY
+      @usage = Usage::EMPTY
     end
 
     # Read the per-channel capture pairs (+[bytes, truncated]+) from the
     # ext after an invocation completes and wrap each as a +Capture+ value
     # object. The ext clips +bytes+ to the configured cap and sets
     # +truncated+ when the guest produced strictly more than +cap+ bytes
-    # ({docs/behavior.md B-04}[link:../../docs/behavior.md]). Mirror of {#clear_captures!}
-    # at the post-invocation boundary.
+    # ({docs/behavior.md B-04}[link:../../docs/behavior.md]). Mirror of
+    # {#reset_invocation_state!} at the post-invocation boundary.
     def read_captures!
       out_bytes, out_truncated = @instance.stdout
       err_bytes, err_truncated = @instance.stderr
@@ -224,6 +248,37 @@ module Kobako
       @stderr_capture = Capture.from_ext(err_bytes, err_truncated)
     end
 
+    # Read the per-last-invocation +wall_time+ and +memory_peak+ from
+    # the ext and wrap them as a +Kobako::Usage+ value object
+    # ({docs/behavior.md B-35}[link:../../docs/behavior.md]). Runs in
+    # the +invoke!+ +ensure+ block so the usage record is populated on
+    # every outcome — value return, +Kobako::TrapError+ (including
+    # +TimeoutError+ / +MemoryLimitError+), +Kobako::SandboxError+,
+    # and +Kobako::ServiceError+.
+    #
+    # The ext returns a positional 2-tuple +[wall_time, memory_peak]+
+    # whose order matches the +Kobako::Usage+ field order; the
+    # destructure-then-kwargs handoff below is the explicit
+    # positional→keyword conversion point, mirroring
+    # +#read_captures!+'s +Capture.from_ext(bytes, truncated)+ shape.
+    def read_usage!
+      wall_time, memory_peak = @instance.usage
+      @usage = Usage.new(wall_time: wall_time, memory_peak: memory_peak)
+    end
+
+    # Map a wasmtime trap class to the matching three-layer Ruby
+    # exception class. Cap-trap subclasses
+    # ({docs/behavior.md E-19 / E-20}[link:../../docs/behavior.md])
+    # select their named +TrapError+ subclass; everything else
+    # collapses to the base +Kobako::TrapError+.
+    def trap_class_for(err)
+      case err
+      when Kobako::Wasm::TimeoutError     then TimeoutError
+      when Kobako::Wasm::MemoryLimitError then MemoryLimitError
+      else TrapError
+      end
+    end
+
     # Shared prologue / epilogue + trap-class translator for both
     # invocation verbs. +verb+ is +:eval+ or +:run+; it tags the
     # TrapError message so the failing export is identifiable. The
@@ -239,12 +294,10 @@ module Kobako
       yield
       read_captures!
       Outcome.decode(@instance.outcome!)
-    rescue Kobako::Wasm::TimeoutError => e
-      raise TimeoutError, "guest exceeded timeout: #{e.message}"
-    rescue Kobako::Wasm::MemoryLimitError => e
-      raise MemoryLimitError, "guest exceeded memory_limit: #{e.message}"
     rescue Kobako::Wasm::Error => e
-      raise TrapError, "guest __kobako_#{verb} trapped: #{e.message}"
+      raise trap_class_for(e), "Sandbox##{verb} failed: #{e.message}"
+    ensure
+      read_usage!
     end
   end
 end

data/lib/kobako/usage.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Kobako
+  # Per-last-invocation resource accounting for a +Kobako::Sandbox+
+  # ({docs/behavior.md B-35}[link:../../docs/behavior.md]). Carries two
+  # readers populated by every +#eval+ / +#run+ invocation:
+  #
+  #   * +wall_time+ — the Float number of seconds the guest export call
+  #     spent inside wasmtime during the most recent invocation. The
+  #     measurement bracket aligns with the +timeout+ deadline
+  #     ({docs/behavior.md B-01}[link:../../docs/behavior.md]); time spent
+  #     in host Service callbacks is included, but everything that runs
+  #     after the guest export returns — the post-export
+  #     +OUTCOME_BUFFER+ fetch and decode, plus stdout / stderr capture
+  #     readout — is excluded.
+  #   * +memory_peak+ — the Integer high-water mark, in bytes, of the
+  #     per-invocation +memory.grow+ delta past the linear-memory size
+  #     captured at invocation entry. Same baseline accounting as
+  #     +memory_limit+ ({docs/behavior.md E-20}[link:../../docs/behavior.md]):
+  #     the mruby image's initial allocation and any prior-invocation
+  #     watermark sit outside the measurement. On +MemoryLimitError+
+  #     +memory_peak+ never exceeds the configured cap because the
+  #     rejected +desired+ value is not promoted into the high-water.
+  #
+  # Both readers are populated on every outcome, including +TrapError+
+  # branches, so the Host App can read +Sandbox#usage+ after rescuing a
+  # trap to diagnose how much of the budget the failing invocation
+  # consumed. Before the first invocation +Sandbox#usage+ returns the
+  # pre-invocation sentinel +Kobako::Usage::EMPTY+.
+  #
+  # Built on the +class X < Data.define(...)+ subclass form so the
+  # class body is fully Steep-visible; ruby/rbs upstream documents this
+  # as the Steep-friendly shape and the +Style/DataInheritance+ cop is
+  # disabled on that basis (see +.rubocop.yml+).
+  class Usage < Data.define(:wall_time, :memory_peak)
+    # Pre-invocation sentinel ({docs/behavior.md B-35}[link:../../docs/behavior.md]).
+    # Reused by +Sandbox+ before any invocation has run so callers do not
+    # need to handle a +nil+ +#usage+.
+    EMPTY = new(wall_time: 0.0, memory_peak: 0)
+  end
+end

data/lib/kobako/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kobako
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/kobako.rb

@@ -4,6 +4,7 @@ require_relative "kobako/version"
 require "kobako/kobako"
 require_relative "kobako/errors"
 require_relative "kobako/rpc"
+require_relative "kobako/rpc/wire_error"
 require_relative "kobako/rpc/server"
 require_relative "kobako/wasm"
 require_relative "kobako/sandbox"

data/sig/kobako/codec/factory.rbs

@@ -23,7 +23,7 @@ module Kobako
       def unpack_symbol: (String payload) -> Symbol
       def register_handle: () -> void
       def register_fault: () -> void
-      def unpack_handle: (String payload) -> Kobako::RPC::Handle
+      def unpack_handle: (String payload) -> Kobako::Handle
       def pack_fault: (Kobako::RPC::Fault fault) -> String
       def unpack_fault: (String payload) -> Kobako::RPC::Fault
     end

data/sig/kobako/codec/utils.rbs

@@ -1,9 +1,19 @@
 module Kobako
   module Codec
     module Utils
+      MSGPACK_INT_RANGE: Range[Integer]
+
       def self?.assert_utf8!: (String string, String label) -> void
 
       def self?.wire_boundary: [T] () { () -> T } -> T
+
+      def self?.wire_representable?: (untyped value) -> bool
+
+      def self?.deep_wrap: (untyped value, Kobako::HandleTable handle_table) -> untyped
+
+      def self?.primitive_wire_type?: (untyped value) -> bool
+
+      def self?.container_wire_representable?: (untyped value) -> bool
     end
   end
 end

data/sig/kobako/handle.rbs

@@ -0,0 +1,19 @@
+module Kobako
+  class Handle
+    MIN_ID: Integer
+    MAX_ID: Integer
+
+    attr_reader id: Integer
+
+    def initialize: (Integer id) -> void
+                  | (id: Integer) -> void
+
+    def self.from_wire: (Integer id) -> Handle
+
+    def with: (?id: Integer) -> Handle
+
+    def ==: (untyped other) -> bool
+
+    def hash: () -> Integer
+  end
+end

data/sig/kobako/handle_table.rbs

@@ -0,0 +1,23 @@
+module Kobako
+  class HandleTable
+    def initialize: (?next_id: Integer) -> void
+
+    def alloc: (untyped object) -> Kobako::Handle
+
+    def fetch: (Integer id) -> untyped
+
+    def release: (Integer id) -> untyped
+
+    def reset!: () -> self
+
+    def mark_disconnected: (Integer id) -> self
+
+    def size: () -> Integer
+
+    def include?: (Integer id) -> bool
+
+    private
+
+    def require_bound!: (Integer id) -> void
+  end
+end

data/sig/kobako/invocation.rbs

@@ -10,7 +10,7 @@ module Kobako
 
     def initialize: (entrypoint: Symbol | String, ?args: Array[untyped], ?kwargs: Hash[untyped, untyped]) -> void
 
-    def encode: () -> String
+    def encode: (Kobako::HandleTable handle_table) -> String
 
     private
 
@@ -19,5 +19,7 @@ module Kobako
     def validate_args!: (Array[untyped] args) -> Array[untyped]
 
     def validate_kwargs!: (Hash[untyped, untyped] kwargs) -> Hash[Symbol, untyped]
+
+    def forged_handle_message: (String slot) -> String
   end
 end

data/sig/kobako/outcome.rbs

@@ -19,6 +19,6 @@ module Kobako
 
     def self?.panic_target_class: (Panic panic) -> (singleton(SandboxError) | singleton(ServiceError))
 
-    def self?.build_wire_violation_error: (String message) -> SandboxError
+    def self?.build_wire_violation_error: (String message, ?wire_error: String?) -> RPC::WireError
   end
 end

data/sig/kobako/rpc/dispatcher.rbs

@@ -7,25 +7,25 @@ module Kobako
       class DisconnectedTargetError < StandardError
       end
 
-      def self?.dispatch: (String request_bytes, Server server) -> String
+      def self?.dispatch: (String request_bytes, Server server, Kobako::HandleTable handle_table) -> String
 
       def self?.encode_caught_error: (StandardError error) -> String
 
       def self?.invoke: (untyped target, String method, Array[untyped] args, Hash[Symbol, untyped] kwargs) -> untyped
 
-      def self?.resolve_arg: (untyped value, HandleTable handle_table) -> untyped
+      def self?.resolve_arg: (untyped value, Kobako::HandleTable handle_table) -> untyped
 
-      def self?.resolve_target: (String | Kobako::RPC::Handle target, Server server, HandleTable handle_table) -> untyped
+      def self?.resolve_target: (String | Kobako::Handle target, Server server, Kobako::HandleTable handle_table) -> untyped
 
       def self?.resolve_path: (String path, Server server) -> untyped
 
-      def self?.resolve_handle: (Kobako::RPC::Handle handle, HandleTable handle_table) -> untyped
+      def self?.resolve_handle: (Kobako::Handle handle, Kobako::HandleTable handle_table) -> untyped
 
-      def self?.require_live_object!: (Integer id, HandleTable handle_table) -> untyped
+      def self?.require_live_object!: (Integer id, Kobako::HandleTable handle_table) -> untyped
 
-      def self?.encode_ok: (untyped value, Server server) -> String
+      def self?.encode_ok: (untyped value, Kobako::HandleTable handle_table) -> String
 
-      def self?.wrap_as_handle: (untyped value, Server server) -> Kobako::RPC::Handle
+      def self?.wrap_as_handle: (untyped value, Kobako::HandleTable handle_table) -> Kobako::Handle
 
       def self?.encode_error: (String type, String message) -> String
     end

data/sig/kobako/rpc/envelope.rbs

@@ -4,14 +4,14 @@ module Kobako
     STATUS_ERROR: Integer
 
     class Request
-      attr_reader target: String | Kobako::RPC::Handle
+      attr_reader target: String | Kobako::Handle
       attr_reader method_name: String
       attr_reader args: Array[untyped]
       attr_reader kwargs: Hash[Symbol, untyped]
 
-      def initialize: (target: String | Kobako::RPC::Handle, method: String, ?args: Array[untyped], ?kwargs: Hash[Symbol, untyped]) -> void
+      def initialize: (target: String | Kobako::Handle, method: String, ?args: Array[untyped], ?kwargs: Hash[Symbol, untyped]) -> void
 
-      def with: (?target: String | Kobako::RPC::Handle, ?method: String, ?args: Array[untyped], ?kwargs: Hash[Symbol, untyped]) -> Request
+      def with: (?target: String | Kobako::Handle, ?method: String, ?args: Array[untyped], ?kwargs: Hash[Symbol, untyped]) -> Request
 
       def ==: (untyped other) -> bool
 

data/sig/kobako/rpc/server.rbs

@@ -1,9 +1,7 @@
 module Kobako
   module RPC
     class Server
-      attr_reader handle_table: HandleTable
-
-      def initialize: (?handle_table: HandleTable) -> void
+      def initialize: (?handle_table: Kobako::HandleTable) -> void
 
       def define: (Symbol | String name) -> Kobako::RPC::Namespace
 
@@ -11,8 +9,6 @@ module Kobako
 
       def bound?: (String target) -> bool
 
-      def namespaces: () -> Array[Kobako::RPC::Namespace]
-
       def size: () -> Integer
 
       def empty?: () -> bool
@@ -25,8 +21,6 @@ module Kobako
 
       def sealed?: () -> bool
 
-      def reset_handles!: () -> HandleTable
-
       def dispatch: (String request_bytes) -> String
 
       private

data/sig/kobako/rpc/wire_error.rbs

@@ -0,0 +1,6 @@
+module Kobako
+  module RPC
+    class WireError < Kobako::SandboxError
+    end
+  end
+end

data/sig/kobako/sandbox.rbs

@@ -30,6 +30,8 @@ module Kobako
 
     def stderr_truncated?: () -> bool
 
+    attr_reader usage: Kobako::Usage
+
     def define: (Symbol | String name) -> Kobako::RPC::Namespace
 
     def preload: (code: String, name: Symbol | String) -> Kobako::Sandbox
@@ -41,12 +43,16 @@ module Kobako
 
     private
 
-    def clear_captures!: () -> void
+    def reset_invocation_state!: () -> void
 
     def begin_invocation!: () -> void
 
     def read_captures!: () -> void
 
+    def read_usage!: () -> void
+
+    def trap_class_for: (Kobako::Wasm::Error err) -> singleton(Kobako::TrapError)
+
     def invoke!: (Symbol verb) { () -> void } -> untyped
   end
 end

data/sig/kobako/usage.rbs

@@ -0,0 +1,11 @@
+module Kobako
+  class Usage < Data
+    EMPTY: Usage
+
+    attr_reader wall_time: Float
+    attr_reader memory_peak: Integer
+
+    def self.new: (wall_time: Float, memory_peak: Integer) -> Usage
+                | (Float wall_time, Integer memory_peak) -> Usage
+  end
+end

data/sig/kobako/wasm.rbs

@@ -34,6 +34,8 @@ module Kobako
       def stderr: () -> [String, bool]
 
       def outcome!: () -> String
+
+      def usage: () -> [Float, Integer]
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kobako
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Aotokitsuruya
@@ -69,6 +69,8 @@ files:
 - lib/kobako/codec/factory.rb
 - lib/kobako/codec/utils.rb
 - lib/kobako/errors.rb
+- lib/kobako/handle.rb
+- lib/kobako/handle_table.rb
 - lib/kobako/invocation.rb
 - lib/kobako/outcome.rb
 - lib/kobako/outcome/panic.rb
@@ -76,16 +78,16 @@ files:
 - lib/kobako/rpc/dispatcher.rb
 - lib/kobako/rpc/envelope.rb
 - lib/kobako/rpc/fault.rb
-- lib/kobako/rpc/handle.rb
-- lib/kobako/rpc/handle_table.rb
 - lib/kobako/rpc/namespace.rb
 - lib/kobako/rpc/server.rb
+- lib/kobako/rpc/wire_error.rb
 - lib/kobako/sandbox.rb
 - lib/kobako/sandbox_options.rb
 - lib/kobako/snippet.rb
 - lib/kobako/snippet/binary.rb
 - lib/kobako/snippet/source.rb
 - lib/kobako/snippet/table.rb
+- lib/kobako/usage.rb
 - lib/kobako/version.rb
 - lib/kobako/wasm.rb
 - sig/kobako.rbs
@@ -96,6 +98,8 @@ files:
 - sig/kobako/codec/factory.rbs
 - sig/kobako/codec/utils.rbs
 - sig/kobako/errors.rbs
+- sig/kobako/handle.rbs
+- sig/kobako/handle_table.rbs
 - sig/kobako/invocation.rbs
 - sig/kobako/outcome.rbs
 - sig/kobako/outcome/panic.rbs
@@ -103,16 +107,16 @@ files:
 - sig/kobako/rpc/dispatcher.rbs
 - sig/kobako/rpc/envelope.rbs
 - sig/kobako/rpc/fault.rbs
-- sig/kobako/rpc/handle.rbs
-- sig/kobako/rpc/handle_table.rbs
 - sig/kobako/rpc/namespace.rbs
 - sig/kobako/rpc/server.rbs
+- sig/kobako/rpc/wire_error.rbs
 - sig/kobako/sandbox.rbs
 - sig/kobako/sandbox_options.rbs
 - sig/kobako/snippet.rbs
 - sig/kobako/snippet/binary.rbs
 - sig/kobako/snippet/source.rbs
 - sig/kobako/snippet/table.rbs
+- sig/kobako/usage.rbs
 - sig/kobako/wasm.rbs
 homepage: https://github.com/elct9620/kobako
 licenses:

data/lib/kobako/rpc/handle.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Kobako
-  module RPC
-    # Wire-level value object for an ext-0x01 Capability Handle.
-    #
-    # SPEC pins the binary layout to fixext 4 with a 4-byte big-endian u32
-    # payload ({docs/wire-codec.md}[link:../../../docs/wire-codec.md]
-    # § Ext Types → ext 0x01). ID 0 is reserved as the invalid sentinel;
-    # the maximum valid ID is 0x7fff_ffff (2^31 - 1).
-    #
-    # This is intentionally a thin value object built on +Data.define+ so
-    # equality, hash, and immutability are inherited. The runtime-facing
-    # +Kobako::RPC::Handle+ class lives at a higher layer and may add behaviour
-    # (HandleTable bookkeeping, reset semantics). The codec only needs to
-    # carry the opaque integer ID across the wire.
-    Handle = Data.define(:id) do
-      # +MIN_ID+ / +MAX_ID+ live on the Handle class (defined below this
-      # block), not in this block's binding — Data.define's block scope
-      # resolves bare constants against the enclosing +Wire+ module, so
-      # +MIN_ID+ would raise +NameError+. Use +self.class::CONST+ to
-      # reach the constants attached to the Handle class itself. Do not
-      # "simplify" this back to bare +MIN_ID+/+MAX_ID+.
-      # steep:ignore:start
-      def initialize(id:)
-        min = self.class::MIN_ID
-        max = self.class::MAX_ID
-        raise ArgumentError, "Handle id must be Integer" unless id.is_a?(Integer)
-        raise ArgumentError, "Handle id #{id} out of range [#{min}, #{max}]" unless id.between?(min, max)
-
-        super
-      end
-      # steep:ignore:end
-    end
-
-    Handle::MIN_ID = 1
-    Handle::MAX_ID = 0x7fff_ffff
-  end
-end