kobako 0.4.0 → 0.5.0

data/lib/kobako/transport/request.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../handle"
+require_relative "../codec"
+
+module Kobako
+  # See lib/kobako/transport.rb for the umbrella module doc; this file
+  # owns the Request value object and its +#encode+ / +.decode+ codec,
+  # plus the +STATUS_OK+ / +STATUS_ERROR+ constants shared with Response.
+  module Transport
+    # ---------------- Response status bytes (docs/wire-contract.md § Response Shape) ---
+
+    # Response variant marker for the success branch.
+    STATUS_OK    = 0
+    # Response variant marker for the fault branch.
+    STATUS_ERROR = 1
+
+    # Value object for a single guest-initiated Transport Request
+    # ({docs/wire-codec.md Envelope Encoding → Request}[link:../../../docs/wire-codec.md]).
+    #
+    # 5-element msgpack array:
+    # +[target, method_name, args, kwargs, block_given]+. +target+ is
+    # either a +String+ (+"Namespace::Member"+) or a {Handle}. SPEC pins
+    # +kwargs+ map keys to ext 0x00 Symbol; enforced at construction so
+    # the Value Object is the single source of truth. +block_given+ is a
+    # Boolean signalling whether the guest call site supplied a block
+    # (B-23); the block body itself never crosses the wire.
+    #
+    # Built on the +class X < Data.define(...)+ subclass form so the
+    # class body is fully Steep-visible; see +lib/kobako/outcome/panic.rb+
+    # for the rationale.
+    class Request < Data.define(:target, :method_name, :args, :kwargs, :block_given)
+      def initialize(target:, method_name:, args: [], kwargs: {}, block_given: false)
+        unless target.is_a?(String) || target.is_a?(Kobako::Handle)
+          raise ArgumentError, "Request target must be String or Kobako::Handle, got #{target.class}"
+        end
+        raise ArgumentError, "Request method_name must be String" unless method_name.is_a?(String)
+        raise ArgumentError, "Request args must be Array"         unless args.is_a?(Array)
+        unless block_given.is_a?(TrueClass) || block_given.is_a?(FalseClass)
+          raise ArgumentError, "Request block_given must be Boolean, got #{block_given.class}"
+        end
+
+        validate_kwargs!(kwargs)
+        super
+      end
+
+      # Encode this Request to msgpack bytes. The Value Object's own
+      # invariants are the contract; this method does not re-check the shape.
+      def encode
+        Codec::Encoder.encode([target, method_name, args, kwargs, block_given])
+      end
+
+      # Decode +bytes+ into a {Request}. Raises +Codec::InvalidType+ when the
+      # envelope is not the expected 5-element msgpack array, or when the
+      # Value Object's construction invariants reject the decoded fields.
+      def self.decode(bytes)
+        Codec::Decoder.decode(bytes) do |arr|
+          unless arr.is_a?(Array) && arr.length == 5
+            raise Codec::InvalidType, "Request envelope is malformed (expected a 5-element array)"
+          end
+
+          target, method_name, args, kwargs, block_given = arr
+          new(target: target, method_name: method_name, args: args, kwargs: kwargs, block_given: block_given)
+        end
+      end
+
+      private
+
+      def validate_kwargs!(kwargs)
+        raise ArgumentError, "Request kwargs must be Hash" unless kwargs.is_a?(Hash)
+
+        kwargs.each_key do |k|
+          raise ArgumentError, "Request kwargs keys must be Symbol, got #{k.class}" unless k.is_a?(Symbol)
+        end
+      end
+    end
+  end
+end

data/lib/kobako/transport/response.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../codec"
+require_relative "../fault"
+require_relative "request"
+
+module Kobako
+  # See lib/kobako/transport.rb for the umbrella module doc; this file
+  # owns the Response value object and its +#encode+ / +.decode+ codec.
+  module Transport
+    # Value object for a single host-side Transport Response
+    # ({docs/wire-codec.md Envelope Encoding → Response}[link:../../../docs/wire-codec.md]).
+    #
+    # 2-element msgpack array: +[status, value-or-fault]+. +status+ is 0
+    # (success) or 1 (fault). For success the second element is the return
+    # value; for fault it is a {Fault} (ext 0x02 envelope).
+    #
+    # Built on the +class X < Data.define(...)+ subclass form so the
+    # class body is fully Steep-visible; see +lib/kobako/outcome/panic.rb+
+    # for the rationale.
+    class Response < Data.define(:status, :payload)
+      def self.ok(value)
+        new(status: STATUS_OK, payload: value)
+      end
+
+      def self.error(fault)
+        unless fault.is_a?(Kobako::Fault)
+          raise ArgumentError, "Response.error requires Kobako::Fault, got #{fault.class}"
+        end
+
+        new(status: STATUS_ERROR, payload: fault)
+      end
+
+      # Decode +bytes+ into a {Response}. Raises +Codec::InvalidType+ when the
+      # envelope is not the expected 2-element msgpack array, or when the
+      # Value Object's construction invariants reject the decoded fields.
+      def self.decode(bytes)
+        Codec::Decoder.decode(bytes) do |arr|
+          unless arr.is_a?(Array) && arr.length == 2
+            raise Codec::InvalidType, "Response envelope is malformed (expected a 2-element array)"
+          end
+
+          status, payload = arr
+          new(status: status, payload: payload)
+        end
+      end
+
+      def initialize(status:, payload:)
+        unless [STATUS_OK, STATUS_ERROR].include?(status)
+          raise ArgumentError, "Response status must be 0 (ok) or 1 (error), got #{status.inspect}"
+        end
+        if status == STATUS_ERROR && !payload.is_a?(Kobako::Fault)
+          raise ArgumentError, "Response with error status must carry a Kobako::Fault payload"
+        end
+
+        super
+      end
+
+      def ok?    = status == STATUS_OK
+      def error? = status == STATUS_ERROR
+
+      # Encode this Response to msgpack bytes as the 2-element
+      # +[status, payload]+ array.
+      def encode
+        Codec::Encoder.encode([status, payload])
+      end
+    end
+  end
+end

data/lib/kobako/transport/run.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../handle"
+require_relative "../codec"
+
+module Kobako
+  # See lib/kobako/transport.rb for the umbrella module doc; this file
+  # owns the +Run+ envelope value object — the host→guest request shape
+  # consumed by +__kobako_run+.
+  module Transport
+    # Host-side value object for a single +Sandbox#run+ invocation
+    # ({docs/wire-codec.md Invocation channels}[link:../../../docs/wire-codec.md];
+    # {docs/behavior.md B-31}[link:../../../docs/behavior.md]).
+    #
+    # A Run captures the host-layer concept of "a single +#run+
+    # call": the entrypoint constant name plus its positional and keyword
+    # arguments. Host pre-flight (E-24 / E-25 / E-29 / E-30) is enforced at
+    # construction so the Value Object is the single source of truth —
+    # anything that passes +Run.new+ is safe to encode and ship to
+    # the guest.
+    #
+    # Run is the host→guest entrypoint dispatch envelope (the +#run+
+    # request shape), the symmetric counterpart to the guest→host
+    # +Request+ envelope. +#encode+ takes the Sandbox's
+    # +Catalog::Handles+ and routes any non-wire-representable +args+ /
+    # +kwargs+ leaf through it as a +Kobako::Handle+
+    # ({docs/behavior.md B-34}[link:../../../docs/behavior.md]) — the
+    # symmetric counterpart of the guest→host wrap path in the
+    # dispatcher (B-14). A +Kobako::Handle+ that arrives **already
+    # constructed** in the caller's +args+ / +kwargs+ is rejected at
+    # construction (E-29): legitimate Handles only enter Host App code
+    # through error fields, so a Handle reaching the call site is by
+    # definition smuggled in. The +#encode+ output is the "Run envelope"
+    # that ships through the +__kobako_run+ command buffer.
+    #
+    # Built on the +class X < Data.define(...)+ subclass form (the
+    # Steep-friendly shape — see +lib/kobako/outcome/panic.rb+).
+    class Run < Data.define(:entrypoint, :args, :kwargs)
+      # Ruby constant-name pattern enforced on the +entrypoint+ Symbol
+      # ({docs/behavior.md E-25}[link:../../../docs/behavior.md]). Parallel to
+      # +Kobako::Catalog::Snippets::NAME_PATTERN+; the two constants name the
+      # same regex but cover distinct surfaces (snippet identity vs.
+      # entrypoint resolution) so a future divergence stays local.
+      NAME_PATTERN = /\A[A-Z]\w*\z/
+
+      def initialize(entrypoint:, args: [], kwargs: {})
+        entrypoint = normalize_entrypoint(entrypoint)
+        args = validate_args!(args)
+        kwargs = validate_kwargs!(kwargs)
+        super
+      end
+
+      # Encode this Run to the msgpack bytes the guest's +__kobako_run+
+      # entry point consumes as its command-buffer payload
+      # ({docs/wire-codec.md Invocation channels}[link:../../../docs/wire-codec.md]).
+      # Walks +args+ / +kwargs+ through {Codec::Utils.deep_wrap} so any
+      # non-wire-representable leaf is allocated into +handler+ and
+      # replaced with a +Kobako::Handle+
+      # ({docs/behavior.md B-34}[link:../../../docs/behavior.md]); the
+      # +handler+ argument is the Sandbox's table, sharing the same
+      # allocator the guest→host return path (B-14) uses.
+      #
+      # Layout: msgpack map with string keys +"entrypoint"+ (Symbol via
+      # ext 0x00), +"args"+ (Array), +"kwargs"+ (Map with Symbol keys);
+      # any wrapped leaf rides as ext 0x01 in its original position
+      # (docs/wire-codec.md § ext 0x01 position rules).
+      def encode(handler)
+        Codec::Encoder.encode(
+          "entrypoint" => entrypoint,
+          "args" => Codec::Utils.deep_wrap(args, handler),
+          "kwargs" => Codec::Utils.deep_wrap(kwargs, handler)
+        )
+      end
+
+      private
+
+      # E-24: target must be a Symbol or String (TypeError, not
+      # ArgumentError — the wrong-type case is a Host App programming
+      # error before the run reaches the guest). E-25: after +.to_s+
+      # the value must match NAME_PATTERN (ArgumentError), rejecting
+      # +::+-segmented names and any non-constant form.
+      def normalize_entrypoint(target)
+        unless target.is_a?(Symbol) || target.is_a?(String)
+          raise TypeError, "entrypoint must be a Symbol or String, got #{target.class}"
+        end
+
+        target_str = target.to_s
+        unless NAME_PATTERN.match?(target_str)
+          raise ArgumentError,
+                "entrypoint must match #{NAME_PATTERN.inspect} (got #{target.inspect})"
+        end
+
+        target_str.to_sym
+      end
+
+      # E-29: +args+ must not contain a +Kobako::Handle+. The Handle
+      # allocator lives inside the Host Gem; legitimate paths surface
+      # Handle objects only through raised error fields, so a Handle
+      # reaching +args+ is a forged or smuggled token. Non-wire-
+      # representable arguments that are not Handles are handled by
+      # auto-wrap inside +#encode+ (B-34) — the reject path is reserved
+      # for Handle objects specifically.
+      def validate_args!(args)
+        raise ArgumentError, "arguments must be an Array" unless args.is_a?(Array)
+        raise ArgumentError, forged_handle_message("arguments") if args.any?(Kobako::Handle)
+
+        args
+      end
+
+      # E-30 covers the non-Symbol kwargs-key case; E-29 also rejects a
+      # +Kobako::Handle+ arriving as a kwargs value (same forged-token
+      # principle as the +args+ branch). Both checks live here so the
+      # Host App sees the host-side error message before any encode /
+      # decode boundary.
+      def validate_kwargs!(kwargs)
+        raise ArgumentError, "keyword arguments must be a Hash" unless kwargs.is_a?(Hash)
+
+        bad_keys = kwargs.each_key.grep_v(Symbol)
+        unless bad_keys.empty?
+          raise ArgumentError,
+                "keyword argument keys must be Symbols (got #{bad_keys.inspect})"
+        end
+        raise ArgumentError, forged_handle_message("keyword argument values") if kwargs.each_value.any?(Kobako::Handle)
+
+        kwargs
+      end
+
+      # Single source of truth for the E-29 reject message so the args
+      # and kwargs branches stay phrased identically. Message stays in
+      # caller vocabulary: it names the affected slot and the reason
+      # without leaking SPEC anchor identifiers (B-xx / E-xx live in
+      # source comments, not user-visible errors) or self-referential
+      # architecture terms — the error is raised BY kobako, so saying
+      # "allocated by the Host Gem" reads as third-person about self.
+      def forged_handle_message(slot)
+        "#{slot} must not contain a Kobako::Handle — " \
+          "Handles are created internally by the Sandbox and cannot be passed in"
+      end
+    end
+  end
+end

data/lib/kobako/transport/yield.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../codec"
+
+module Kobako
+  # See lib/kobako/transport.rb for the umbrella module doc; this file
+  # owns the +Yield+ envelope value object plus its +#encode+ / +.decode+
+  # codec for the +__kobako_yield_to_block+ wire form.
+  module Transport
+    # First byte of the YieldResponse for the success branch — body is
+    # the block's return value encoded as a single msgpack value.
+    TAG_OK = 0x01
+    # First byte for `break val` — body is the break value.
+    TAG_BREAK = 0x02
+    # Reserved for future `return val` support; both sides reject this
+    # tag as a wire violation (YieldResponse envelope contract).
+    TAG_RESERVED = 0x03
+    # First byte for an error / fault outcome — body is a
+    # +{"class", "message", "backtrace"}+ Hash.
+    TAG_ERROR = 0x04
+
+    # Tags both sides currently accept on the wire.
+    LIVE_TAGS = [TAG_OK, TAG_BREAK, TAG_ERROR].freeze
+
+    # Value object for a single YieldResponse envelope
+    # ({docs/wire-codec.md YieldResponse Envelope}[link:../../../docs/wire-codec.md]).
+    #
+    # The wire form is a one-byte tag followed by an msgpack payload.
+    # The three live tags are +0x01+ (ok), +0x02+ (break), and +0x04+
+    # (error); +0x03+ is reserved and rejected by both sides.
+    #
+    # +value+ carries whatever the wire payload decoded to — a plain
+    # Ruby value for the +ok+ / +break+ tags, and a +{"class",
+    # "message", "backtrace"}+ Hash for the +error+ tag. No further
+    # shape constraint is enforced here; the host-side dispatcher
+    # decides how to translate each variant into Ruby control flow.
+    #
+    # Lives alongside the other envelope value objects (+Request+,
+    # +Response+) since it is the guest-to-host shape used
+    # mid-dispatch-frame to answer a +__kobako_yield_to_block+ re-entry.
+    class Yield < Data.define(:tag, :value)
+      def initialize(tag:, value:)
+        unless Kobako::Transport::LIVE_TAGS.include?(tag)
+          raise ArgumentError,
+                "Yield tag must be one of #{Kobako::Transport::LIVE_TAGS.inspect}, got #{tag.inspect}"
+        end
+
+        super
+      end
+
+      def ok?    = tag == Kobako::Transport::TAG_OK
+      def break? = tag == Kobako::Transport::TAG_BREAK
+      def error? = tag == Kobako::Transport::TAG_ERROR
+
+      # Encode this Yield to YieldResponse bytes: one tag byte followed
+      # by an msgpack-encoded +value+.
+      def encode
+        [tag].pack("C") + Codec::Encoder.encode(value)
+      end
+
+      # Decode +bytes+ into a {Yield}. Rejects empty input, the reserved
+      # tag 0x03, and any tag outside +LIVE_TAGS+ by raising
+      # +Kobako::Codec::InvalidType+ — these are wire violations per the
+      # SPEC's YieldResponse envelope contract.
+      def self.decode(bytes)
+        bytes = bytes.b
+        raise Codec::InvalidType, "YieldResponse must carry at least one byte" if bytes.empty?
+
+        tag = bytes.getbyte(0) # : Integer
+        body = bytes.byteslice(1, bytes.bytesize - 1) || +""
+
+        reject_dead_tag!(tag)
+        new(tag: tag, value: Codec::Decoder.decode(body))
+      end
+
+      def self.reject_dead_tag!(tag)
+        return if LIVE_TAGS.include?(tag)
+
+        msg = if tag == TAG_RESERVED
+                "YieldResponse tag 0x03 is reserved"
+              else
+                format(
+                  "YieldResponse tag 0x%02x is not recognised", tag
+                )
+              end
+        raise Codec::InvalidType, msg
+      end
+      private_class_method :reject_dead_tag!
+    end
+  end
+end

data/lib/kobako/transport/yielder.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "../codec"
+require_relative "yield"
+
+module Kobako
+  # See lib/kobako/transport.rb for the umbrella module doc; this file
+  # owns the host-side object that materialises a guest-supplied block as
+  # a Ruby callable the Service method can yield into.
+  module Transport
+    # Host-side stand-in for a guest-supplied block (B-23).
+    #
+    # Each guest call that carries +block_given: true+ gets a Yielder
+    # that the Dispatcher hands to the Service method as +&block+. The
+    # Service method observes it as an ordinary Ruby Proc through
+    # {#to_proc}; +yield val+ / +block.call(val)+ invokes {#yield}, which
+    # serialises the positional args, re-enters the guest via the injected
+    # +yield_to_guest+ lambda
+    # ({docs/behavior.md B-24}[link:../../../docs/behavior.md]), and
+    # reifies the +YieldResponse+ into Ruby control flow:
+    #
+    #   * +tag 0x01+ ok    — return the decoded value to +yield+'s caller
+    #   * +tag 0x02+ break — +throw break_tag, value+ so the Dispatcher's
+    #     +catch+ frame unwinds the Service method
+    #     ({docs/behavior.md B-25}[link:../../../docs/behavior.md])
+    #   * +tag 0x04+ error — raise the +{class, message}+ payload at the
+    #     Service's yield site
+    #
+    # The Dispatcher calls {#invalidate!} from its +ensure+ block once
+    # dispatch completes; any later call to a stashed Yielder then raises
+    # +LocalJumpError+ — the observable shape of
+    # {docs/behavior.md E-23}[link:../../../docs/behavior.md] (escaped
+    # Yielder).
+    class Yielder
+      # +yield_to_guest+ is a +String → String+ callable (typically
+      # +Runtime#yield_to_active_invocation+ bound through a lambda) that
+      # {#yield} invokes to re-enter the guest; +break_tag+ is the +catch+
+      # throw tag the Dispatcher matches against to unwind the Service on
+      # +tag 0x02+.
+      def initialize(yield_to_guest, break_tag)
+        @yield_to_guest = yield_to_guest
+        @break_tag = break_tag
+        @active = true
+      end
+
+      # Re-enter the guest with +args+ and reify the YieldResponse into
+      # Ruby control flow. Raises +LocalJumpError+ if called after
+      # {#invalidate!} (E-23).
+      def yield(*args)
+        raise LocalJumpError, "guest block invoked after host dispatch frame returned" unless @active
+
+        response = Kobako::Transport::Yield.decode(@yield_to_guest.call(Kobako::Codec::Encoder.encode(args)))
+        return response.value if response.ok?
+
+        throw @break_tag, response.value if response.break?
+
+        raise yield_failure(response.value, default: "yield error")
+      end
+
+      # The Proc the Dispatcher passes as +&block+, binding {#yield} so a
+      # Service method's +yield+ / +block.call+ drives the round-trip.
+      def to_proc
+        method(:yield).to_proc
+      end
+
+      # Mark this Yielder dead. Called by the Dispatcher's +ensure+ block
+      # when the originating dispatch frame returns; any later {#yield}
+      # call then raises +LocalJumpError+ (E-23).
+      def invalidate!
+        @active = false
+      end
+
+      private
+
+      # Reify a +YieldResponse+ tag 0x04 payload into a +RuntimeError+ the
+      # Service method observes at its +yield+ site. The +{class, message,
+      # backtrace}+ shape mirrors the +Kobako::Transport::Yield+ tag 0x04
+      # payload; +default+ provides a fallback when the payload is not a
+      # Hash.
+      def yield_failure(payload, default:)
+        return RuntimeError.new(default) unless payload.is_a?(Hash)
+
+        klass = payload["class"] || "RuntimeError"
+        message = payload["message"] || default
+        RuntimeError.new("#{klass}: #{message}")
+      end
+    end
+  end
+end

data/lib/kobako/transport.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "transport/request"
+require_relative "transport/response"
+require_relative "transport/run"
+require_relative "transport/yield"
+require_relative "transport/yielder"
+require_relative "transport/error"
+require_relative "transport/dispatcher"
+
+module Kobako
+  # Kobako::Transport — host↔guest message transport namespace.
+  # Houses the envelope value objects (Request / Response / Run / Yield),
+  # the guest→host +Dispatcher+, and the host→guest +Yielder+.
+  # +Sandbox#initialize+ composes them onto the
+  # +Runtime+ as a dispatch +Proc+ + +yield_to_guest+ lambda pair
+  # ({docs/behavior.md B-12}[link:../../docs/behavior.md]). "RPC" was
+  # deliberately not chosen — it implies a cross-process boundary that
+  # kobako does not have, since host and guest share one OS thread and
+  # one wasm linear memory. See
+  # {SPEC.md Refinement → Internal Concepts}[link:../../SPEC.md].
+  module Transport
+  end
+end

data/lib/kobako/version.rb

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

data/lib/kobako.rb

@@ -3,8 +3,8 @@
 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/transport"
+require_relative "kobako/catalog"
+require_relative "kobako/runtime"
+require_relative "kobako/snapshot"
 require_relative "kobako/sandbox"

data/release-please-config.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+  "release-type": "ruby",
+  "last-release-sha": "5694da60b08931ea260e13025689b8d8c47d767a",
+  "packages": {
+    ".": {
+      "component": "kobako",
+      "include-component-in-tag": false,
+      "release-type": "ruby"
+    }
+  },
+  "extra-files": [
+    {
+      "type": "toml",
+      "path": "ext/kobako/Cargo.toml",
+      "jsonpath": "$.package.version"
+    },
+    {
+      "type": "toml",
+      "path": "Cargo.lock",
+      "jsonpath": "$.package[?(@.name=='kobako')].version"
+    }
+  ]
+}

data/sig/kobako/capture.rbs

@@ -7,7 +7,5 @@ module Kobako
     def initialize: (bytes: String, truncated: bool) -> void
 
     def truncated?: () -> bool
-
-    def self.from_ext: (String bytes, bool truncated) -> Capture
   end
 end

data/sig/kobako/catalog/handles.rbs

@@ -0,0 +1,19 @@
+module Kobako
+  module Catalog
+    class Handles
+      def initialize: (?next_id: Integer) -> void
+
+      def alloc: (untyped object) -> Kobako::Handle
+
+      def fetch: (Integer id) -> untyped
+
+      def reset!: () -> self
+
+      def size: () -> Integer
+
+      private
+
+      def require_bound!: (Integer id) -> void
+    end
+  end
+end

data/sig/kobako/catalog/namespaces.rbs

@@ -0,0 +1,17 @@
+module Kobako
+  module Catalog
+    class Namespaces
+      def initialize: (?handler: Kobako::Catalog::Handles) -> void
+
+      def define: (Symbol | String name) -> Kobako::Namespace
+
+      def lookup: (String target) -> untyped
+
+      def encode: () -> String
+
+      def seal!: () -> self
+
+      def sealed?: () -> bool
+    end
+  end
+end

data/sig/kobako/{snippet/table.rbs → catalog/snippets.rbs}

@@ -1,6 +1,6 @@
 module Kobako
-  module Snippet
-    class Table
+  module Catalog
+    class Snippets
       NAME_PATTERN: Regexp
 
       type entry = Kobako::Snippet::Source | Kobako::Snippet::Binary
@@ -11,15 +11,6 @@ module Kobako
 
       def encode: () -> String
 
-      def each: () { (entry) -> void } -> Array[entry]
-              | () -> Enumerator[entry, Array[entry]]
-
-      def names: () -> Array[Symbol]
-
-      def size: () -> Integer
-
-      def empty?: () -> bool
-
       private
 
       def register_source!: (String? code, (Symbol | String)? name) -> Symbol

data/sig/kobako/{rpc.rbs → catalog.rbs}

@@ -1,4 +1,4 @@
 module Kobako
-  module RPC
+  module Catalog
   end
 end

data/sig/kobako/codec/decoder.rbs

@@ -1,7 +1,8 @@
 module Kobako
   module Codec
     module Decoder
-      def self.decode: (String bytes) -> untyped
+      def self.decode: [T] (String bytes) { (untyped value) -> T } -> T
+                     | (String bytes) -> untyped
 
       private
 

data/sig/kobako/codec/factory.rbs

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

data/sig/kobako/codec/utils.rbs

@@ -5,15 +5,15 @@ module Kobako
 
       def self?.assert_utf8!: (String string, String label) -> void
 
-      def self?.wire_boundary: [T] () { () -> T } -> T
+      def self?.with_boundary: [T] () { () -> T } -> T
 
-      def self?.wire_representable?: (untyped value) -> bool
+      def self?.representable?: (untyped value) -> bool
 
-      def self?.deep_wrap: (untyped value, Kobako::HandleTable handle_table) -> untyped
+      def self?.deep_wrap: (untyped value, Kobako::Catalog::Handles handler) -> untyped
 
-      def self?.primitive_wire_type?: (untyped value) -> bool
+      def self?.primitive_type?: (untyped value) -> bool
 
-      def self?.container_wire_representable?: (untyped value) -> bool
+      def self?.container_representable?: (untyped value) -> bool
     end
   end
 end