kobako 0.20.0-aarch64-linux → 0.21.0-aarch64-linux

data/crates/kobako-transport/README.md

@@ -0,0 +1,43 @@
+# kobako-transport
+
+The fixed tier of the [kobako](https://github.com/elct9620/kobako) wire —
+an in-process Wasm sandbox for running untrusted mruby scripts.
+
+kobako is assembled from three parts chosen independently: a host, a
+payload codec, and a guest. That works only because two things are the
+same in every assembly. This crate is both of them, and nothing else:
+
+- `envelope` — the **core envelope**, the outer frame each message rides
+  in: `Call` / `Reply` / `YieldReply` for a dispatch round-trip,
+  `Outcome` / `Panic` for how an invocation ended, `Run` / `Preamble` /
+  `Snippets` for what an invocation is handed, and the `ErrorRecord` a
+  guest failure carries
+- `abi` — the values a host and a guest must already agree on to
+  exchange a byte: the version, the packed `(ptr, len)` return layout,
+  the invocation-channel frame prefix, and the message size cap
+
+The envelope reads a message's routing fields and its ok-versus-fault
+tag without decoding a payload byte; everything the resolved method
+consumes rides through as an opaque `payload` this layer never reads.
+A decoded envelope borrows the buffer it came from, so that payload
+reaches its reader as a view rather than a copy.
+
+This crate depends on no other, and every kobako tier depends on it:
+`kobako-runtime` and `kobako-wasmtime` on the host, `kobako-core` and
+`kobako-mruby` in the guest, and any third-party engine, codec, or
+guest that composes against them.
+
+The byte layout is specified in
+[`docs/wire/envelope.md`](https://github.com/elct9620/kobako/blob/main/docs/wire/envelope.md);
+the golden vectors in this crate are derived from that document.
+
+## Usage
+
+```toml
+[dependencies]
+kobako-transport = "0.13.0" # x-release-please-version
+```
+
+## License
+
+Apache-2.0

data/crates/kobako-wasmtime/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.13.0](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.12.0...kobako-wasmtime-v0.13.0) (2026-07-29)
+
+
+### ⚠ BREAKING CHANGES
+
+* **wasmtime:** put every cap in one struct, named the way the field is read
+* **runtime:** give the engine contract names an implementer can write
+* **transport:** name the core envelope's types after what they carry
+* **wire:** route every tier through the one envelope
+* **wire:** carry dispatch over the core envelope with an opaque payload
+
+### Features
+
+* **wire:** carry dispatch over the core envelope with an opaque payload ([556104b](https://github.com/elct9620/kobako/commit/556104bf86fdf481b5368b70af83eb0add4b2708))
+
+
+### Code Refactoring
+
+* **runtime:** give the engine contract names an implementer can write ([0a41491](https://github.com/elct9620/kobako/commit/0a41491360cf17def8245c0758679e92572b990f))
+* **transport:** name the core envelope's types after what they carry ([b44de65](https://github.com/elct9620/kobako/commit/b44de6502953826c567d4ef8a594561479f50c1d))
+* **wasmtime:** put every cap in one struct, named the way the field is read ([3f57860](https://github.com/elct9620/kobako/commit/3f578608b044d1ade0ae35231266cf3c9e517c02))
+* **wire:** route every tier through the one envelope ([c5cd33a](https://github.com/elct9620/kobako/commit/c5cd33a5346f49857fa6e1f45c9cf9b9bea0ff77))
+
 ## [0.12.0](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.11.0...kobako-wasmtime-v0.12.0) (2026-07-24)
 
 

data/crates/kobako-wasmtime/README.md

@@ -24,7 +24,7 @@ SDK consumes the same surface.
 
 ```toml
 [dependencies]
-kobako-wasmtime = "0.12.0" # x-release-please-version
+kobako-wasmtime = "0.13.0" # x-release-please-version
 ```
 
 ## License

data/lib/kobako/catalog/services.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require_relative "../codec"
 require_relative "../errors"
 
 module Kobako
   module Catalog
     # Kobako::Catalog::Services — per-Sandbox registry of Service
     # bindings keyed by their constant-path name. Holds the flat
-    # path→object table and the preamble emitted on Frame 1.
+    # path→object table and the declared path set every invocation
+    # announces on Frame 1.
     #
     # Public API:
     #
     #   services = Kobako::Catalog::Services.new
     #   services.bind("MyService::KV", kv_object)  # => services (chainable)
-    #   services.encode                            # => msgpack bytes for Frame 1
+    #   services.paths                             # => ["MyService::KV"]
     #   services.lookup("MyService::KV")           # => kv_object
     #
     # Per-dispatch routing is +Kobako::Transport::Dispatcher+'s
@@ -31,7 +31,6 @@ module Kobako
       def initialize
         @bindings = {} # : Hash[String, untyped]
         @sealed = false
-        @encoded = nil # : String?
       end
 
       # Bind +object+ as the Service reachable at +path+ — a +Symbol+ or
@@ -66,27 +65,20 @@ module Kobako
         @bindings[target_str]
       end
 
-      # Encode the preamble as msgpack bytes for stdin Frame 1 delivery —
-      # a flat array of the bound constant paths, in bind order:
-      # +["MyService::KV", "File"]+. Routes through Kobako::Codec::Encoder
-      # like every other host-side wire encode; the preamble carries only
-      # Strings, so none of the kobako ext types fire. Returns a binary
-      # +String+ of msgpack bytes.
-      #
-      # The bytes are pinned eagerly by #seal! at the first invocation, so
-      # every subsequent call is a pure read of the frozen preamble — a bind
-      # can never reach the registry after the seal to alter Frame 1.
-      def encode
-        @encoded || Codec::Encoder.encode(@bindings.keys).freeze
+      # The bound constant paths in bind order — +["MyService::KV",
+      # "File"]+ — which +Runtime#eval+ / +#run+ frame into the Frame 1
+      # preamble. The registry holds the bindings; the wire layout is the
+      # native side's.
+      def paths
+        @bindings.keys
       end
 
-      # Mark the registry as sealed and pin the Frame 1 preamble bytes so
-      # registration can never alter them afterwards. Called by +Sandbox+ on
-      # the first invocation; afterwards #bind raises ArgumentError.
-      # Idempotent; returns +self+.
+      # Mark the registry as sealed so registration can never alter the
+      # declared path set afterwards. Called by +Sandbox+ on the first
+      # invocation; afterwards #bind raises ArgumentError. Idempotent;
+      # returns +self+.
       def seal!
         @sealed = true
-        @encoded ||= Codec::Encoder.encode(@bindings.keys).freeze
         self
       end
 

data/lib/kobako/catalog/snippets.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../codec"
 require_relative "../snippet"
 
 module Kobako
@@ -28,32 +27,16 @@ module Kobako
 
       def initialize
         @entries = [] # : Array[Kobako::Snippet::Source | Kobako::Snippet::Binary]
-        @encoded = nil # : String?
       end
 
-      # Serialize the registered snippets to wire bytes. Each entry
-      # contributes a msgpack map shape; the collection rides as a single
-      # msgpack array. An empty registry serializes to an empty array, never
-      # absent. The wire codec is an implementation detail — callers
-      # receive a binary +String+ that the +Kobako::Runtime+ layer ships
-      # through the invocation channel. The entry value objects stay pure
-      # carriers — this collection-tier method reads their attributes
-      # externally via +entry_payload+ rather than asking each entry to
-      # self-encode.
-      #
-      # Before the first invocation this recomputes from the still-open
-      # table; #seal! then pins the bytes, so every later call is a pure
-      # read of the frozen memo.
-      def encode
-        @encoded || Codec::Encoder.encode(@entries.map { |entry| entry_payload(entry) }).freeze
-      end
-
-      # Freeze the Frame 3 table bytes at the first invocation so the
-      # replayed snippet set can never change afterwards. Called by +Sandbox+
-      # alongside the Service / Extension seals. Idempotent; returns +self+.
-      def seal!
-        @encoded ||= Codec::Encoder.encode(@entries.map { |entry| entry_payload(entry) }).freeze
-        self
+      # The registered snippets in insertion order, each projected as the
+      # +[kind, name, body]+ triple +Runtime#eval+ / +#run+ frame into
+      # Frame 3 — +kind+ names the form as a Symbol, +name+ is +nil+ for
+      # the bytecode form. The entry value objects stay pure carriers, so
+      # this collection-tier method reads their attributes externally
+      # rather than asking each entry to project itself.
+      def entries
+        @entries.map { |entry| entry_tuple(entry) }
       end
 
       # Register one preloaded snippet in either of two forms.
@@ -124,17 +107,16 @@ module Kobako
         nil
       end
 
-      # Build the msgpack-ready Hash for one entry. Source entries
-      # contribute their host-side +name+; Binary entries omit it
-      # because the canonical name lives in the bytecode's embedded
-      # +debug_info+ and is read by the guest at load time
-      # ({docs/wire-codec.md Invocation channels}[link:../../../docs/wire-codec.md]).
-      def entry_payload(entry)
+      # Project one entry as its +[kind, name, body]+ triple. Source
+      # entries contribute their host-side +name+; Binary entries carry
+      # +nil+ because the canonical name lives in the bytecode's embedded
+      # +debug_info+ and is read by the guest at load time.
+      def entry_tuple(entry)
         case entry
         when Snippet::Source
-          { "name" => entry.name.to_s, "kind" => Snippet::Source::KIND, "body" => entry.body }
-        when Snippet::Binary
-          { "kind" => Snippet::Binary::KIND, "body" => entry.body }
+          [Snippet::Source::KIND, entry.name.to_s, entry.body]
+        else
+          [Snippet::Binary::KIND, nil, entry.body]
         end
       end
 

data/lib/kobako/codec/decoder.rb

@@ -9,10 +9,10 @@ require_relative "utils"
 module Kobako
   module Codec
     # Module-level entry point for the host side of the kobako wire
-    # ({docs/wire-codec.md}[link:../../../docs/wire-codec.md] § Type Mapping).
+    # ({docs/wire/payload-msgpack.md}[link:../../../docs/wire/payload-msgpack.md] § Type Mapping).
     #
     # Translates msgpack gem exceptions into the kobako error taxonomy
-    # (Truncated, InvalidType, InvalidEncoding, UnsupportedType) so
+    # (TruncatedInputError, InvalidTypeError, InvalidEncodingError, UnsupportedTypeError) so
     # callers can pattern-match on the SPEC's wire-violation categories
     # without leaking the gem's internal exception classes.
     #
@@ -21,14 +21,14 @@ module Kobako
     # because callers always decode exactly one wire value at a time.
     module Decoder
       # Decode +bytes+ into one Ruby value and validate transitively
-      # against the SPEC type mapping. Raises Truncated, InvalidType,
-      # or InvalidEncoding on wire violations.
+      # against the SPEC type mapping. Raises TruncatedInputError, InvalidTypeError,
+      # or InvalidEncodingError on wire violations.
       #
       # When a block is given, the decoded value is yielded and the block's
       # result is returned — wire Value Objects use this to build themselves
       # from the decoded payload. The block runs inside this method's
       # rescue, so a Value Object's +ArgumentError+ invariant failure
-      # surfaces as InvalidType without a separate Utils.with_boundary
+      # surfaces as InvalidTypeError without a separate Utils.with_boundary
       # wrapper at the call site.
       def self.decode(bytes)
         value = FACTORY.load(bytes.b)
@@ -37,26 +37,23 @@ module Kobako
       # msgpack gem raises the format/type errors below; +ArgumentError+
       # comes from our ext-type validators (Handle id range, Exception type
       # whitelist) and from a yielded block's Value Object invariants — both
-      # are wire violations, so both map to InvalidType.
+      # are wire violations, so both map to InvalidTypeError.
       rescue ::MessagePack::UnknownExtTypeError, ::MessagePack::MalformedFormatError,
              ::MessagePack::StackError, ::ArgumentError => e
-        raise InvalidType, e.message
+        raise InvalidTypeError, e.message
       # +UnpackError+ is the gem's umbrella class for short-read /
       # incomplete-buffer faults; +EOFError+ covers underflow at the
       # buffer edge.
       rescue ::MessagePack::UnpackError, ::EOFError => e
-        raise Truncated, e.message
+        raise TruncatedInputError, e.message
       end
 
       # SPEC pins +str+ family payloads to UTF-8
-      # ({docs/wire-codec.md}[link:../../../docs/wire-codec.md] § str/bin
+      # ({docs/wire/payload-msgpack.md}[link:../../../docs/wire/payload-msgpack.md] § str/bin
       # Encoding Rules). The msgpack gem returns UTF-8-tagged Strings for
       # str family but does not validate the bytes; +bin+ family decodes
       # to ASCII-8BIT. Walk the tree once and reject invalid UTF-8 in any
-      # str-typed leaf via Utils.assert_utf8!. Kobako::Fault
-      # payloads are validated transitively: +ExtTypes#unpack_fault+
-      # feeds the inner ext-0x02 bytes back through this Decoder, so their
-      # +str+ fields are already covered by the time control returns here.
+      # str-typed leaf via Utils.assert_utf8!.
       class << self
         private
 

data/lib/kobako/codec/encoder.rb

@@ -8,13 +8,13 @@ require_relative "ext_types"
 module Kobako
   module Codec
     # Module-level entry point for the host side of the kobako wire
-    # ({docs/wire-codec.md}[link:../../../docs/wire-codec.md] § Type Mapping).
+    # ({docs/wire/payload-msgpack.md}[link:../../../docs/wire/payload-msgpack.md] § Type Mapping).
     #
     # The codec backbone is the official +msgpack+ gem: integers, floats,
     # strings, arrays, and maps go through the gem's narrowest-encoding
-    # logic; the three kobako-specific ext types (0x00 Symbol, 0x01
-    # Capability Handle, 0x02 Exception envelope) are registered by
-    # ExtTypes on the process-wide factory.
+    # logic; the two kobako-specific ext types (0x00 Symbol, 0x01
+    # Capability Handle) are registered by ExtTypes on the process-wide
+    # factory.
     #
     # Public API is a single function — +.encode+. The codec is stateless;
     # there is no buffer accumulator and no streaming write API. Callers
@@ -22,8 +22,8 @@ module Kobako
     # themselves.
     module Encoder
       # Encode +value+ to wire bytes (binary-encoded String).
-      # SPEC's 12-entry type mapping is a closed set: a value outside it is
-      # rejected as +UnsupportedType+ by the factory's +BasicObject+ guard
+      # SPEC's 11-entry type mapping is a closed set: a value outside it is
+      # rejected as +UnsupportedTypeError+ by the factory's +BasicObject+ guard
       # (ExtTypes#register_unrepresentable), which raises before the msgpack
       # gem can route the value through +to_msgpack+ — so a permissive
       # +method_missing+ object cannot answer that probe and mis-encode. The
@@ -33,7 +33,7 @@ module Kobako
       def self.encode(value)
         FACTORY.dump(value)
       rescue ::RangeError, ::NoMethodError => e
-        raise UnsupportedType, e.message
+        raise UnsupportedTypeError, e.message
       end
     end
   end

data/lib/kobako/codec/error.rb

@@ -5,7 +5,7 @@ module Kobako
     # Base class for all wire-codec faults raised by the pure-Ruby host codec.
     #
     # The wire codec implements the binary contract pinned in
-    # {docs/wire-codec.md}[link:../../../docs/wire-codec.md] § Type Mapping.
+    # {docs/wire/payload-msgpack.md}[link:../../../docs/wire/payload-msgpack.md] § Type Mapping.
     # Every wire violation surfaces as a
     # subclass of Error so callers can pattern-match on the specific
     # fault while still rescuing all codec faults via this base class.
@@ -15,20 +15,20 @@ module Kobako
     class Error < StandardError; end
 
     # Input ended before the type prefix or payload was fully consumed.
-    class Truncated < Error; end
+    class TruncatedInputError < Error; end
 
-    # The type byte at the current position is not in the 12-entry kobako
+    # The type byte at the current position is not in the 11-entry kobako
     # type mapping (e.g. an unknown ext code, or a reserved msgpack tag).
-    class InvalidType < Error; end
+    class InvalidTypeError < Error; end
 
     # A msgpack +str+ payload was not valid UTF-8, or an ext 0x00 Symbol
     # payload was not valid UTF-8 — both are wire violations per SPEC.
-    class InvalidEncoding < Error; end
+    class InvalidEncodingError < Error; end
 
     # The encoder was handed a Ruby object whose type has no wire
     # representation (e.g. Range, Time). Higher layers may catch this
     # and re-route the value through Handle allocation, but at the
     # codec level it is a hard error.
-    class UnsupportedType < Error; end
+    class UnsupportedTypeError < Error; end
   end
 end

data/lib/kobako/codec/ext_types.rb

@@ -6,45 +6,39 @@ require_relative "error"
 require_relative "utils"
 require_relative "state"
 require_relative "../handle"
-require_relative "../fault"
 
 module Kobako
   module Codec
     # The kobako wire ext-type conversions
-    # ({docs/wire-codec.md}[link:../../../docs/wire-codec.md] § Ext Types)
+    # ({docs/wire/payload-msgpack.md}[link:../../../docs/wire/payload-msgpack.md] § Ext Types)
     # as pure functions: per-operation decode state is threaded in as an
     # argument, so the module itself holds nothing. #build_factory assembles
     # the one +MessagePack::Factory+ these conversions are registered on.
     module ExtTypes
       # MessagePack ext type code reserved for Symbol
-      # ({docs/wire-codec.md}[link:../../../docs/wire-codec.md] § Ext Types
+      # ({docs/wire/payload-msgpack.md}[link:../../../docs/wire/payload-msgpack.md] § Ext Types
       # → ext 0x00). Module-private — mirrors +codec::EXT_SYMBOL+ on the
       # Rust side.
       EXT_SYMBOL = 0x00
       # MessagePack ext type code reserved for Capability Handle
-      # ({docs/wire-codec.md}[link:../../../docs/wire-codec.md] § Ext Types
+      # ({docs/wire/payload-msgpack.md}[link:../../../docs/wire/payload-msgpack.md] § Ext Types
       # → ext 0x01). Module-private — mirrors +codec::EXT_HANDLE+ on the
       # Rust side.
       EXT_HANDLE = 0x01
-      # MessagePack ext type code reserved for Exception envelope
-      # ({docs/wire-codec.md}[link:../../../docs/wire-codec.md] § Ext Types
-      # → ext 0x02). Module-private — mirrors +codec::EXT_ERRENV+ on the
-      # Rust side.
-      EXT_ERRENV = 0x02
-      private_constant :EXT_SYMBOL, :EXT_HANDLE, :EXT_ERRENV
+      private_constant :EXT_SYMBOL, :EXT_HANDLE
 
       # Inert ext id the unrepresentable-value guard registers under. It is
       # never emitted (the guard's packer always raises) and never decoded
       # (no unpacker is registered, so the id stays an UnknownExtTypeError on
       # the wire), so it is not a wire ext type: deliberately not named
-      # +EXT_*+ like the three real ext codes, since it has no Rust-side mirror
+      # +EXT_*+ like the two real ext codes, since it has no Rust-side mirror
       # and must stay outside the wire-symmetry inventory.
       UNREPRESENTABLE_GUARD_ID = 0x7F
       private_constant :UNREPRESENTABLE_GUARD_ID
 
       module_function
 
-      # Assemble a +MessagePack::Factory+ with the three kobako ext types plus
+      # Assemble a +MessagePack::Factory+ with the two kobako ext types plus
       # the unrepresentable-value guard registered, frozen because
       # registration is its only mutation and happens exactly once. The
       # stateful conversions resolve their per-operation state at call time,
@@ -53,7 +47,6 @@ module Kobako
         factory = MessagePack::Factory.new
         register_symbol(factory)
         register_handle(factory)
-        register_fault(factory)
         register_unrepresentable(factory)
         factory.freeze
       end
@@ -64,7 +57,7 @@ module Kobako
       end
 
       # Validate the ext-0x00 payload as UTF-8 and intern. Raises
-      # InvalidEncoding on invalid bytes — SPEC forbids the
+      # InvalidEncodingError on invalid bytes — SPEC forbids the
       # binary-encoding fallback that msgpack-gem's default unpacker
       # would otherwise apply. The re-tag step lives here because the
       # msgpack ext-type unpacker hands us binary bytes; the assertion
@@ -86,64 +79,19 @@ module Kobako
       # Peel off the fixext-4 frame, hand the bytes to the
       # Host-Gem-internal +Kobako::Handle.restore+ factory, and
       # translate the +ArgumentError+ raised by Handle's invariants
-      # into a wire-layer +InvalidType+ via Codec::Utils.with_boundary.
+      # into a wire-layer +InvalidTypeError+ via Codec::Utils.with_boundary.
       # The Value Object owns the id-range contract; this method only
       # owns the frame shape. Records the Handle sighting on +state+ so a
       # Handle-free decode can skip the downstream resolution walk.
       def unpack_handle(payload, state)
         state.record_handle!
         bytes = payload.b
-        raise InvalidType, "Handle payload must be 4 bytes, got #{bytes.bytesize}" unless bytes.bytesize == 4
+        raise InvalidTypeError, "Handle payload must be 4 bytes, got #{bytes.bytesize}" unless bytes.bytesize == 4
 
         id = bytes.unpack1("N") # : Integer
         Codec::Utils.with_boundary { Kobako::Handle.restore(id) }
       end
 
-      # Encode the inner ext-0x02 map via Encoder (not the raw factory) so
-      # the embedded payload flows through the same boundary as a top-level
-      # encode — nested kobako values (Handle, nested Fault) reach the
-      # registered ext-type packers. A +details+ chain nested past the
-      # +state+ depth cap has no wire representation and surfaces as
-      # +UnsupportedType+. In a payload position (+state+ inside a
-      # forbid_faults bracket) the envelope has no wire representation at
-      # all, so the refusal routes the value into the position's
-      # non-representable handling — the Dispatcher's auto-wrap rescue,
-      # or a raise at the yield site.
-      def pack_fault(fault, state)
-        if state.faults_forbidden?
-          raise UnsupportedType, "Kobako::Fault has no wire representation in a payload position"
-        end
-
-        state.within_ext_frame(UnsupportedType) do
-          Encoder.encode("type" => fault.type, "message" => fault.message, "details" => fault.details)
-        end
-      end
-
-      # Peel the embedded msgpack map and hand it to +Kobako::Fault.new+
-      # inside Decoder.decode's block form, so the value-object's
-      # +ArgumentError+ invariants surface as +InvalidType+ through the
-      # decoder boundary. Inner decode goes through Decoder (not the raw
-      # factory) so the embedded +str+ payloads flow through the same
-      # UTF-8 validation as a top-level decode. A nested ext 0x02 in
-      # +details+ re-enters this method, so the +state+ ext-frame guard
-      # bounds the chain depth to keep it from exhausting the native stack.
-      # In a payload position (+state+ inside a forbid_faults bracket) the
-      # envelope is a wire violation outright — its sole legal position is
-      # the Response fault field.
-      def unpack_fault(payload, state)
-        if state.faults_forbidden?
-          raise InvalidType, "Fault envelope (ext 0x02) is not a legal value in a payload position"
-        end
-
-        state.within_ext_frame(InvalidType) do
-          Decoder.decode(payload) do |map|
-            raise InvalidType, "Fault payload must be a map" unless map.is_a?(Hash)
-
-            Kobako::Fault.new(type: map["type"], message: map["message"], details: map["details"])
-          end
-        end
-      end
-
       def register_symbol(factory)
         factory.register_type(
           EXT_SYMBOL, Symbol,
@@ -160,17 +108,9 @@ module Kobako
         )
       end
 
-      def register_fault(factory)
-        factory.register_type(
-          EXT_ERRENV, Kobako::Fault,
-          packer: ->(fault) { ExtTypes.pack_fault(fault, State.current) },
-          unpacker: ->(payload) { ExtTypes.unpack_fault(payload, State.current) }
-        )
-      end
-
       # A catch-all packer that rejects any value with no wire representation
-      # as +UnsupportedType+. Registered on +BasicObject+ so it also covers
-      # BasicObject-based proxies; the narrower Symbol / Handle / Fault
+      # as +UnsupportedTypeError+. Registered on +BasicObject+ so it also covers
+      # BasicObject-based proxies; the narrower Symbol / Handle
       # registrations still win by most-specific match, and native types never
       # reach it. Packer-only: the guard never writes bytes, so its id is inert
       # and the decode surface stays fail-closed.
@@ -184,7 +124,7 @@ module Kobako
       def register_unrepresentable(factory)
         factory.register_type(
           UNREPRESENTABLE_GUARD_ID, BasicObject,
-          packer: ->(_value) { raise UnsupportedType, "value has no wire representation" }
+          packer: ->(_value) { raise UnsupportedTypeError, "value has no wire representation" }
         )
       end
     end

data/lib/kobako/codec/handle_walk.rb

@@ -11,8 +11,8 @@ module Kobako
     # path; #deep_restore resolves each wire-decoded Handle back to its
     # host object on every guest→host value path. #representable? is the
     # by-value codec-type predicate that decides which leaves #deep_wrap
-    # must wrap: the closed 12-entry wire type set
-    # ({docs/wire-codec.md}[link:../../../docs/wire-codec.md] § Type
+    # must wrap: the closed 11-entry wire type set
+    # ({docs/wire/payload-msgpack.md}[link:../../../docs/wire/payload-msgpack.md] § Type
     # Mapping).
     #
     # All helpers are pure except #deep_wrap, whose only side effect is
@@ -23,7 +23,7 @@ module Kobako
       # Inclusive Integer range the msgpack gem encodes without raising
       # +RangeError+ at encode time — signed +int 64+ minimum through
       # unsigned +uint 64+ maximum
-      # ({docs/wire-codec.md}[link:../../../docs/wire-codec.md] § Type
+      # ({docs/wire/payload-msgpack.md}[link:../../../docs/wire/payload-msgpack.md] § Type
       # Mapping #3, the +fixint+ / +int 8..64+ / +uint 8..64+ union).
       # Anchored as a +Range+ so #primitive_type? stays a single
       # dispatch line. This is the codec's encode domain — not to
@@ -33,16 +33,16 @@ module Kobako
       MSGPACK_INT_RANGE = (-(2**63)..((2**64) - 1))
 
       # Codec-type predicate
-      # ({docs/wire-codec.md}[link:../../../docs/wire-codec.md] § Type
+      # ({docs/wire/payload-msgpack.md}[link:../../../docs/wire/payload-msgpack.md] § Type
       # Mapping). Returns +true+ when +value+ belongs to the closed
-      # 12-entry codec type set — +nil+, +TrueClass+, +FalseClass+,
+      # 11-entry codec type set — +nil+, +TrueClass+, +FalseClass+,
       # +Integer+ (in the +i64..u64+ value domain), +Float+, +String+,
       # +Symbol+, +Kobako::Handle+, +Array+ whose every element is itself
       # representable, or +Hash+ whose every key and value are
       # representable. Integers outside the codec's signed-64 /
       # unsigned-64 union are rejected so the predicate agrees with the
       # msgpack gem's encode-time +RangeError+ behaviour the codec
-      # already surfaces as UnsupportedType.
+      # already surfaces as UnsupportedTypeError.
       #
       # The optional +depth+ bounds the recursive descent at the wire's
       # structural nesting cap so a self-referential container — reachable