kobako 0.12.1-aarch64-linux → 0.13.0-aarch64-linux

data/lib/kobako/sandbox_options.rb

@@ -1,17 +1,27 @@
 # frozen_string_literal: true
 
+require_relative "errors"
+
 module Kobako
   # Kobako::SandboxOptions — immutable Value Object holding the four
-  # per-Sandbox configuration caps. Built on the +class X <
-  # Data.define(...)+ subclass form (the Steep-friendly shape — see
-  # +lib/kobako/outcome/panic.rb+).
+  # per-Sandbox configuration caps and the requested isolation profile.
+  # Built on the +class X < Data.define(...)+ subclass form (the
+  # Steep-friendly shape — see +lib/kobako/outcome/panic.rb+).
   #
-  # The +initialize+ method does double duty: it applies DEFAULT fallback
-  # for absent values and normalises (timeout to Float seconds,
-  # memory_limit to positive Integer bytes) before delegating to Data's
-  # +super+. Anything that survives +SandboxOptions.new+ is a wire-ready
-  # cap bundle the +Kobako::Runtime+ constructor consumes as-is.
-  class SandboxOptions < Data.define(:timeout, :memory_limit, :stdout_limit, :stderr_limit)
+  # The +initialize+ normalises every option before delegating to Data's
+  # +super+: +timeout+ to Float seconds, +memory_limit+ / +stdout_limit+ /
+  # +stderr_limit+ to positive Integer bytes. Each cap is +nil+-disablable
+  # (an absent argument takes its DEFAULT; an explicit +nil+ leaves the
+  # bound off), so all four behave uniformly. +profile+ is the one
+  # non-cap: a Symbol on the PROFILES ladder naming the posture the
+  # runtime builds, which is also the weakest the Host App accepts —
+  # +nil+ is rejected because the weakest posture is requested as an
+  # explicit +:permissive+. Anything that survives +SandboxOptions.new+
+  # is a wire-ready bundle the +Kobako::Runtime+ constructor consumes
+  # as-is. The options also own the ladder comparison
+  # (+#enforce_floor!+) that +Kobako::Sandbox+ delegates its
+  # construction floor check to.
+  class SandboxOptions < Data.define(:timeout, :memory_limit, :stdout_limit, :stderr_limit, :profile)
     # Default wall-clock timeout for a single invocation: 60 seconds.
     DEFAULT_TIMEOUT_SECONDS = 60.0
 
@@ -23,17 +33,41 @@ module Kobako
     # Default per-channel capture ceiling: 1 MiB.
     DEFAULT_OUTPUT_LIMIT = 1 << 20
 
+    # The isolation ladder, weakest first — index order is rank order,
+    # so a floor check is an index comparison.
+    PROFILES = %i[permissive hermetic].freeze
+
+    # Default isolation profile: the strictest rung — opting down to
+    # +:permissive+ is the Host App's explicit trade.
+    DEFAULT_PROFILE = :hermetic
+
     def initialize(timeout: DEFAULT_TIMEOUT_SECONDS,
                    memory_limit: DEFAULT_MEMORY_LIMIT,
-                   stdout_limit: nil,
-                   stderr_limit: nil)
+                   stdout_limit: DEFAULT_OUTPUT_LIMIT,
+                   stderr_limit: DEFAULT_OUTPUT_LIMIT,
+                   profile: DEFAULT_PROFILE)
       timeout = normalize_timeout(timeout)
       memory_limit = normalize_memory_limit(memory_limit)
-      stdout_limit ||= DEFAULT_OUTPUT_LIMIT
-      stderr_limit ||= DEFAULT_OUTPUT_LIMIT
+      stdout_limit = normalize_output_limit(stdout_limit, "stdout_limit")
+      stderr_limit = normalize_output_limit(stderr_limit, "stderr_limit")
+      profile = normalize_profile(profile)
       super
     end
 
+    # Enforce the requested +profile+ as the floor against +declared+ —
+    # the posture a runtime reports having built — so a runtime that
+    # cannot honor the request fails construction with
+    # +Kobako::SetupError+ instead of weakening the posture silently.
+    # Both fallbacks fail closed: a declaration off the PROFILES ladder
+    # ranks below every request, and a request off the ladder
+    # (unreachable past +initialize+) refuses every declaration.
+    def enforce_floor!(declared)
+      return if (PROFILES.index(declared) || -1) >= (PROFILES.index(profile) || PROFILES.size)
+
+      raise Kobako::SetupError, "runtime declares isolation profile #{declared.inspect}, " \
+                                "below the requested floor #{profile.inspect}"
+    end
+
     private
 
     # Coerce +timeout+ into the Float seconds the ext expects, or +nil+
@@ -62,5 +96,29 @@ module Kobako
 
       memory_limit
     end
+
+    # Coerce a per-channel output cap (+stdout_limit+ / +stderr_limit+)
+    # into the byte cap the ext expects, or +nil+ to leave the channel
+    # uncapped. Same shape as +normalize_memory_limit+: a positive Integer
+    # when set, Float / zero / negative rejected. +name+ tags the
+    # +ArgumentError+ with the offending keyword.
+    def normalize_output_limit(limit, name)
+      return nil if limit.nil?
+      unless limit.is_a?(Integer) && limit.positive?
+        raise ArgumentError, "#{name} must be a positive Integer or nil, got #{limit.inspect}"
+      end
+
+      limit
+    end
+
+    # Validate +profile+ against the PROFILES ladder. Unlike the caps
+    # there is no +nil+ form: the weakest posture is requested as an
+    # explicit +:permissive+, so anything off the ladder — +nil+
+    # included — is rejected.
+    def normalize_profile(profile)
+      return profile if PROFILES.include?(profile)
+
+      raise ArgumentError, "profile must be one of #{PROFILES.map(&:inspect).join(", ")}, got #{profile.inspect}"
+    end
   end
 end

data/lib/kobako/transport/dispatcher.rb

@@ -72,8 +72,8 @@ module Kobako
       # closure so the Dispatcher stays stateless and the registry doesn't
       # need to publish accessors for the Sandbox-owned +Catalog::Handles+
       # or +Runtime+. +yield_to_guest+ is a +String → String+ callable
-      # (typically +Runtime#yield_to_active_invocation+ bound as a lambda)
-      # used only when the Request carries +block_given: true+. Always
+      # (the ext's per-dispatch +Kobako::Runtime::GuestYielder+) used only
+      # when the Request carries +block_given: true+. Always
       # returns a binary String — every failure path is reified as a
       # Response.error envelope so the guest sees a transport error rather
       # than a wasm trap.

data/lib/kobako/transport/response.rb

@@ -38,20 +38,6 @@ module Kobako
         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}"
@@ -71,6 +57,20 @@ module Kobako
       def encode
         Codec::Encoder.encode([status, payload])
       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
     end
   end
 end

data/lib/kobako/transport/run.rb

@@ -43,8 +43,8 @@ module Kobako
 
       def initialize(entrypoint:, args: [], kwargs: {})
         entrypoint = normalize_entrypoint(entrypoint)
-        args = validate_args!(args)
-        kwargs = validate_kwargs!(kwargs)
+        validate_args!(args)
+        validate_kwargs!(kwargs)
         super
       end
 
@@ -100,8 +100,6 @@ module Kobako
       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
 
       # Reject a non-Symbol kwargs key, and a +Kobako::Handle+ arriving
@@ -117,8 +115,6 @@ module Kobako
                 "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 forged-Handle reject message so the

data/lib/kobako/transport/yield.rb

@@ -67,7 +67,7 @@ module Kobako
         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) || +""
+        body = bytes.byteslice(1, bytes.bytesize - 1) # : String
 
         reject_dead_tag!(tag)
         new(tag: tag, value: Codec::Decoder.decode(body))

data/lib/kobako/transport/yielder.rb

@@ -28,8 +28,8 @@ module Kobako
     # dispatch completes; any later call to a stashed Yielder then raises
     # +LocalJumpError+ — the observable shape of an escaped Yielder.
     class Yielder
-      # +yield_to_guest+ is a +String → String+ callable (typically
-      # +Runtime#yield_to_active_invocation+ bound through a lambda) that
+      # +yield_to_guest+ is a +String → String+ callable (the ext's
+      # per-dispatch +Kobako::Runtime::GuestYielder+) 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+. +handler+ is the Sandbox's +Kobako::Catalog::Handles+,

data/lib/kobako/version.rb

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

data/lib/kobako.rb

@@ -13,6 +13,5 @@ require_relative "kobako/errors"
 require_relative "kobako/transport"
 require_relative "kobako/catalog"
 require_relative "kobako/runtime"
-require_relative "kobako/snapshot"
 require_relative "kobako/sandbox"
 require_relative "kobako/pool"

data/release-please-config.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
   "release-type": "ruby",
-  "last-release-sha": "5694da60b08931ea260e13025689b8d8c47d767a",
+  "last-release-sha": "98509af508988f708bf0d7a76a718bb0428a177e",
   "packages": {
     ".": {
       "component": "kobako",
@@ -18,6 +18,11 @@
           "path": "/wasm/Cargo.lock",
           "jsonpath": "$.package[?(@.name=='kobako-core')].version"
         },
+        {
+          "type": "toml",
+          "path": "/wasm/kobako-core/Cargo.toml",
+          "jsonpath": "$.dependencies['kobako-codec'].version"
+        },
         {
           "type": "generic",
           "path": "/wasm/kobako-core/README.md"
@@ -38,6 +43,11 @@
           "path": "/wasm/kobako/Cargo.toml",
           "jsonpath": "$.dependencies['kobako-core'].version"
         },
+        {
+          "type": "toml",
+          "path": "/wasm/kobako/Cargo.toml",
+          "jsonpath": "$.dependencies['kobako-codec'].version"
+        },
         {
           "type": "generic",
           "path": "/wasm/kobako/README.md"
@@ -103,13 +113,78 @@
           "path": "/wasm/kobako-baker/README.md"
         }
       ]
+    },
+    "crates/kobako-codec": {
+      "component": "kobako-codec",
+      "release-type": "rust",
+      "extra-files": [
+        {
+          "type": "toml",
+          "path": "/crates/Cargo.lock",
+          "jsonpath": "$.package[?(@.name=='kobako-codec')].version"
+        },
+        {
+          "type": "toml",
+          "path": "/wasm/Cargo.lock",
+          "jsonpath": "$.package[?(@.name=='kobako-codec')].version"
+        },
+        {
+          "type": "generic",
+          "path": "/crates/kobako-codec/README.md"
+        }
+      ]
+    },
+    "crates/kobako-runtime": {
+      "component": "kobako-runtime",
+      "release-type": "rust",
+      "extra-files": [
+        {
+          "type": "toml",
+          "path": "/crates/Cargo.lock",
+          "jsonpath": "$.package[?(@.name=='kobako-runtime')].version"
+        },
+        {
+          "type": "toml",
+          "path": "/Cargo.lock",
+          "jsonpath": "$.package[?(@.name=='kobako-runtime')].version"
+        },
+        {
+          "type": "generic",
+          "path": "/crates/kobako-runtime/README.md"
+        }
+      ]
+    },
+    "crates/kobako-wasmtime": {
+      "component": "kobako-wasmtime",
+      "release-type": "rust",
+      "extra-files": [
+        {
+          "type": "toml",
+          "path": "/crates/Cargo.lock",
+          "jsonpath": "$.package[?(@.name=='kobako-wasmtime')].version"
+        },
+        {
+          "type": "toml",
+          "path": "/Cargo.lock",
+          "jsonpath": "$.package[?(@.name=='kobako-wasmtime')].version"
+        },
+        {
+          "type": "toml",
+          "path": "/crates/kobako-wasmtime/Cargo.toml",
+          "jsonpath": "$.dependencies['kobako-runtime'].version"
+        },
+        {
+          "type": "generic",
+          "path": "/crates/kobako-wasmtime/README.md"
+        }
+      ]
     }
   },
   "plugins": [
     {
       "type": "linked-versions",
-      "groupName": "kobako guest crates",
-      "components": ["kobako-core", "kobako-rs", "kobako-io", "kobako-json", "kobako-regexp", "kobako-baker"]
+      "groupName": "kobako crates",
+      "components": ["kobako-codec", "kobako-core", "kobako-rs", "kobako-io", "kobako-json", "kobako-regexp", "kobako-baker", "kobako-runtime", "kobako-wasmtime"]
     }
   ],
   "extra-files": [

data/sig/kobako/codec/factory.rbs

@@ -8,6 +8,8 @@ module Kobako
       EXT_SYMBOL: Integer
       EXT_HANDLE: Integer
       EXT_ERRENV: Integer
+      MAX_EXT_DEPTH: Integer
+      EXT_DEPTH_KEY: Symbol
 
       def dump: (untyped value) -> String
       def load: (String bytes) -> untyped
@@ -26,6 +28,7 @@ module Kobako
       def unpack_handle: (String payload) -> Kobako::Handle
       def pack_fault: (Kobako::Fault fault) -> String
       def unpack_fault: (String payload) -> Kobako::Fault
+      def within_ext_frame: [T] (singleton(Kobako::Codec::Error) over_limit) { () -> T } -> T
     end
   end
 end

data/sig/kobako/errors.rbs

@@ -17,7 +17,7 @@ module Kobako
   class ModuleNotBuiltError < SetupError
   end
 
-  class SandboxError < Error
+  module StructuredError : Error
     attr_reader origin: String?
     attr_reader klass: String?
     attr_reader backtrace_lines: Array[String]?
@@ -32,22 +32,15 @@ module Kobako
     ) -> void
   end
 
-  class ServiceError < Error
-    attr_reader origin: String?
-    attr_reader klass: String?
-    attr_reader backtrace_lines: Array[String]?
-    attr_reader details: untyped
+  class SandboxError < Error
+    include StructuredError
+  end
 
-    def initialize: (
-      String message,
-      ?origin: String?,
-      ?klass: String?,
-      ?backtrace_lines: Array[String]?,
-      ?details: untyped
-    ) -> void
+  class ServiceError < Error
+    include StructuredError
   end
 
-  class HandlerExhaustedError < SandboxError
+  class HandleExhaustedError < SandboxError
   end
 
   class BytecodeError < SandboxError

data/sig/kobako/runtime.rbs

@@ -7,17 +7,27 @@ module Kobako
       (Float | Integer)? timeout_seconds,
       Integer? memory_limit,
       Integer? stdout_limit_bytes,
-      Integer? stderr_limit_bytes
+      Integer? stderr_limit_bytes,
+      Symbol profile
     ) -> Runtime
 
-    def on_dispatch=: (^(String) -> String dispatch_proc) -> void
+    def on_dispatch=: (^(String, Kobako::Transport::_GuestYielder) -> String dispatch_proc) -> void
 
-    def yield_to_active_invocation: (String args_bytes) -> String
+    def eval: (String preamble, String source, String snippets) -> String
 
-    def eval: (String preamble, String source, String snippets) -> Kobako::Snapshot
-
-    def run: (String preamble, String snippets, String envelope) -> Kobako::Snapshot
+    def run: (String preamble, String snippets, String envelope) -> String
 
     def usage: () -> [Float, Integer]
+
+    def captures: () -> [String, bool, String, bool]
+
+    def profile: () -> Symbol
+
+    # Frame-scoped guest re-entry handle the ext hands the dispatch Proc as
+    # its second argument; stands in as the +String -> String+ callable the
+    # host +Transport::Yielder+ invokes for a block yield.
+    class GuestYielder
+      def call: (String args_bytes) -> String
+    end
   end
 end

data/sig/kobako/sandbox.rbs

@@ -8,15 +8,15 @@ module Kobako
     # Forwarded to @options via Forwardable#def_delegators.
     def timeout: () -> Float?
     def memory_limit: () -> Integer?
-    def stdout_limit: () -> Integer
-    def stderr_limit: () -> Integer
+    def stdout_limit: () -> Integer?
+    def stderr_limit: () -> Integer?
+    def profile: () -> Symbol
 
+    # Every keyword beyond wasm_path forwards verbatim to
+    # SandboxOptions.new (the four caps + the profile floor).
     def initialize: (
       ?wasm_path: String?,
-      ?stdout_limit: Integer?,
-      ?stderr_limit: Integer?,
-      ?timeout: (Float | Integer)?,
-      ?memory_limit: Integer?
+      **untyped options
     ) -> void
 
     def stdout: () -> String
@@ -42,14 +42,18 @@ module Kobako
 
     private
 
+    def build_runtime!: () -> Kobako::Runtime
+
     def install_dispatch_proc!: () -> void
 
     def begin_invocation!: () -> void
 
     def read_usage!: () -> void
 
+    def read_captures!: () -> void
+
     def trap_class_for: (Kobako::TrapError err) -> singleton(Kobako::TrapError)
 
-    def invoke!: (Symbol verb) { () -> Kobako::Snapshot } -> untyped
+    def invoke!: (Symbol verb) { () -> String } -> untyped
   end
 end

data/sig/kobako/sandbox_options.rbs

@@ -3,30 +3,41 @@ module Kobako
     DEFAULT_TIMEOUT_SECONDS: Float
     DEFAULT_MEMORY_LIMIT: Integer
     DEFAULT_OUTPUT_LIMIT: Integer
+    DEFAULT_PROFILE: Symbol
+    PROFILES: Array[Symbol]
 
     attr_reader timeout: Float?
     attr_reader memory_limit: Integer?
-    attr_reader stdout_limit: Integer
-    attr_reader stderr_limit: Integer
+    attr_reader stdout_limit: Integer?
+    attr_reader stderr_limit: Integer?
+    attr_reader profile: Symbol
 
     def self.new: (
       ?timeout: (Float | Integer)?,
       ?memory_limit: Integer?,
       ?stdout_limit: Integer?,
-      ?stderr_limit: Integer?
+      ?stderr_limit: Integer?,
+      ?profile: Symbol
     ) -> SandboxOptions
 
     def initialize: (
       ?timeout: (Float | Integer)?,
       ?memory_limit: Integer?,
       ?stdout_limit: Integer?,
-      ?stderr_limit: Integer?
+      ?stderr_limit: Integer?,
+      ?profile: Symbol
     ) -> void
 
+    def enforce_floor!: (Symbol declared) -> void
+
     private
 
     def normalize_timeout: ((Float | Integer)? timeout) -> Float?
 
     def normalize_memory_limit: (Integer? memory_limit) -> Integer?
+
+    def normalize_output_limit: (Integer? limit, String name) -> Integer?
+
+    def normalize_profile: (untyped profile) -> Symbol
   end
 end

data/sig/kobako/transport/dispatcher.rbs

@@ -12,7 +12,7 @@ module Kobako
 
       CALLABLE_ALLOW: Array[Symbol]
 
-      def self?.dispatch: (String request_bytes, Kobako::Catalog::Namespaces namespaces, Kobako::Catalog::Handles handler, ^(String) -> String yield_to_guest) -> String
+      def self?.dispatch: (String request_bytes, Kobako::Catalog::Namespaces namespaces, Kobako::Catalog::Handles handler, Kobako::Transport::_GuestYielder yield_to_guest) -> String
 
       def self?.resolve_call_args: (Kobako::Transport::Request request, Kobako::Catalog::Handles handler) -> [Array[untyped], Hash[Symbol, untyped]]
 

data/sig/kobako/transport/run.rbs

@@ -17,9 +17,9 @@ module Kobako
 
       def normalize_entrypoint: (Symbol | String target) -> Symbol
 
-      def validate_args!: (Array[untyped] args) -> Array[untyped]
+      def validate_args!: (Array[untyped] args) -> void
 
-      def validate_kwargs!: (Hash[untyped, untyped] kwargs) -> Hash[Symbol, untyped]
+      def validate_kwargs!: (Hash[untyped, untyped] kwargs) -> void
 
       def forged_handle_message: (String slot) -> String
     end

data/sig/kobako/transport/yielder.rbs

@@ -1,12 +1,12 @@
 module Kobako
   module Transport
     class Yielder
-      @yield_to_guest: ^(String) -> String
+      @yield_to_guest: Kobako::Transport::_GuestYielder
       @break_tag: Symbol
       @handler: Kobako::Catalog::Handles
       @active: bool
 
-      def initialize: (^(String) -> String yield_to_guest, Symbol break_tag, Kobako::Catalog::Handles handler) -> void
+      def initialize: (Kobako::Transport::_GuestYielder yield_to_guest, Symbol break_tag, Kobako::Catalog::Handles handler) -> void
 
       def yield: (*untyped args) -> untyped
 

data/sig/kobako/transport.rbs

@@ -1,4 +1,12 @@
 module Kobako
   module Transport
+    # The guest re-entry callable a dispatch hands to a Yielder: invoked
+    # with the encoded yield args, it returns the encoded YieldResponse.
+    # The ext's Kobako::Runtime::GuestYielder is the production conformer;
+    # modelled structurally so the Transport layer needs no upward
+    # dependency on Runtime.
+    interface _GuestYielder
+      def call: (String) -> String
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kobako
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.13.0
 platform: aarch64-linux
 authors:
 - Aotokitsuruya
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-06-27 00:00:00.000000000 Z
+date: 2026-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -38,6 +38,10 @@ files:
 - LICENSE
 - README.md
 - SECURITY.md
+- crates/kobako-runtime/CHANGELOG.md
+- crates/kobako-runtime/README.md
+- crates/kobako-wasmtime/CHANGELOG.md
+- crates/kobako-wasmtime/README.md
 - data/kobako.wasm
 - lib/kobako.rb
 - lib/kobako/3.3/kobako.so
@@ -65,7 +69,6 @@ files:
 - lib/kobako/runtime.rb
 - lib/kobako/sandbox.rb
 - lib/kobako/sandbox_options.rb
-- lib/kobako/snapshot.rb
 - lib/kobako/snippet.rb
 - lib/kobako/snippet/binary.rb
 - lib/kobako/snippet/source.rb
@@ -104,7 +107,6 @@ files:
 - sig/kobako/runtime.rbs
 - sig/kobako/sandbox.rbs
 - sig/kobako/sandbox_options.rbs
-- sig/kobako/snapshot.rbs
 - sig/kobako/snippet.rbs
 - sig/kobako/snippet/binary.rbs
 - sig/kobako/snippet/source.rbs

data/lib/kobako/snapshot.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "capture"
-require_relative "usage"
-
-module Kobako
-  # Kobako::Snapshot — per-invocation observable bundle returned from
-  # +Kobako::Runtime#eval+ and +#run+.
-  #
-  # The magnus class (see ext/kobako/src/snapshot.rs) carries seven raw
-  # readers: +return_bytes+, +stdout_bytes+, +stdout_truncated+,
-  # +stderr_bytes+, +stderr_truncated+, +wall_time+, +memory_peak+. This
-  # file reopens the class to add the Ruby-side helpers that pack those
-  # raw fields into the user-facing value objects +Kobako::Capture+ and
-  # +Kobako::Usage+ — the same shape +Kobako::Sandbox+ exposes to the
-  # Host App.
-  class Snapshot
-    # Wrap the stdout capture pair (+stdout_bytes+, +stdout_truncated+)
-    # as a +Kobako::Capture+ value object. The byte content never carries
-    # a truncation sentinel; +#truncated?+ is the only way to observe
-    # that the cap was hit.
-    def stdout
-      Capture.new(bytes: stdout_bytes, truncated: stdout_truncated)
-    end
-
-    # Wrap the stderr capture pair as a +Kobako::Capture+ value object.
-    # Mirror of +#stdout+.
-    def stderr
-      Capture.new(bytes: stderr_bytes, truncated: stderr_truncated)
-    end
-
-    # Wrap the per-last-invocation usage pair (+wall_time+,
-    # +memory_peak+) as a +Kobako::Usage+ value object.
-    def usage
-      Usage.new(wall_time: wall_time, memory_peak: memory_peak)
-    end
-  end
-end