kobako 0.12.2-aarch64-linux → 0.13.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b158eb899218790e5b9d60b6a88b97fae15371873714400ec4c9f3c103ee8b79
-  data.tar.gz: f0959d351cb08559731e40a05c2ff110d6be742d77c8e82937778a1e0c5055b0
+  metadata.gz: c0a1b4ccd9f4e1debe32912b925847390d00fbf09e798b41eb54ac0756ef4ab3
+  data.tar.gz: 4819002a95e4407ebacb91d1ae77cd8a7c52d80a1eb0511dcc01ac405d6b7459
 SHA512:
-  metadata.gz: 2ec3c6ebaf456d264fbda02af9f97eabf73b57919b38abaee8ead0b360705b28aa3a76baddad1f20f224875f619abb3579c22ea653639498700f108525f1dfed
-  data.tar.gz: 7fb5554ec113663a5978094144b8f3dee1925b9e80cc8a27731877df6d5083472b463027ea0033d490297cc81518742e17540ec6f58745af888e86cb5144ee70
+  metadata.gz: 902954ca6a47611ab670ea52dbe5edc2268428128ffaac0dd9d55e309af6d5b4a70fc47d07eed4f31261bdcdc7158cbdd91fbfad32d56098c8a2c84077db2855
+  data.tar.gz: 53174e7d4e921b558bca17b3683c0865954ff73219a0c07d86d11e18e6e812506aece5d5dc0626ce021fe9342a63d8d3b5ab612f513d7349e939e0e6e08ed063

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"0.12.2","wasm/kobako-core":"0.6.1","wasm/kobako":"0.6.1","wasm/kobako-io":"0.6.1","wasm/kobako-json":"0.6.1","wasm/kobako-regexp":"0.6.1","wasm/kobako-baker":"0.6.1","crates/kobako-runtime":"0.6.1","crates/kobako-wasmtime":"0.6.1"}
+{".":"0.13.0","wasm/kobako-core":"0.7.0","wasm/kobako":"0.7.0","wasm/kobako-io":"0.7.0","wasm/kobako-json":"0.7.0","wasm/kobako-regexp":"0.7.0","wasm/kobako-baker":"0.7.0","crates/kobako-codec":"0.7.0","crates/kobako-runtime":"0.7.0","crates/kobako-wasmtime":"0.7.0"}

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.13.0](https://github.com/elct9620/kobako/compare/v0.12.2...v0.13.0) (2026-07-03)
+
+
+### Features
+
+* **crates:** build the requested isolation profile into the WASI context ([63c25d8](https://github.com/elct9620/kobako/commit/63c25d835d4d03010c1658217cee412318e6b5d8))
+* enforce the isolation-profile floor at Sandbox construction ([73f0dfe](https://github.com/elct9620/kobako/commit/73f0dfe34a144045a559a28caec31468351de64a))
+* forward the Sandbox profile request through the ext to the driver ([f47f906](https://github.com/elct9620/kobako/commit/f47f9063aa56462be023f5c76cbc73db6e4315ad))
+* keep guest output readable after a trap ([464454c](https://github.com/elct9620/kobako/commit/464454cd774db96ad72b3787007f2ce015673587))
+* **runtime:** runtimes declare their isolation profile ([f89717a](https://github.com/elct9620/kobako/commit/f89717a6bc9809f0de0df78f97da33a49a1474ac))
+
 ## [0.12.2](https://github.com/elct9620/kobako/compare/v0.12.1...v0.12.2) (2026-07-02)
 
 

data/README.md

@@ -154,6 +154,8 @@ sandbox = Kobako::Sandbox.new(
 
 `memory_limit` covers the per-invocation `memory.grow` delta from the entry baseline, so a Sandbox reused across invocations does not silently accumulate against a global budget.
 
+A fifth option, `profile:`, requests the Sandbox's isolation posture on the `:permissive` < `:hermetic` ladder (default `:hermetic`). `:hermetic` denies the guest ambient time and entropy; `:permissive` lets the guest's `wasi:clocks` / `wasi:random` read live host sources — an explicit trade of reproducibility, with filesystem, environment, and network still unreachable. The request is also a floor: construction fails with `Kobako::SetupError` on a runtime that declares a weaker posture than requested. See [`docs/security-model.md`](docs/security-model.md) § Isolation profiles.
+
 ### Invocation Lifecycle
 
 One Sandbox serves many invocations. Service bindings and preloaded snippets persist across calls; capability state (Handles, stdout, stderr, memory delta) resets between them.

data/crates/kobako-runtime/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.7.0](https://github.com/elct9620/kobako/compare/kobako-runtime-v0.6.1...kobako-runtime-v0.7.0) (2026-07-03)
+
+
+### Features
+
+* **crates:** build the requested isolation profile into the WASI context ([63c25d8](https://github.com/elct9620/kobako/commit/63c25d835d4d03010c1658217cee412318e6b5d8))
+* **runtime:** runtimes declare their isolation profile ([f89717a](https://github.com/elct9620/kobako/commit/f89717a6bc9809f0de0df78f97da33a49a1474ac))
+
 ## [0.6.1](https://github.com/elct9620/kobako/compare/kobako-runtime-v0.6.0...kobako-runtime-v0.6.1) (2026-07-02)
 
 

data/crates/kobako-runtime/README.md

@@ -26,7 +26,7 @@ map the neutral types onto their own language surface.
 
 ```toml
 [dependencies]
-kobako-runtime = "0.6.1" # x-release-please-version
+kobako-runtime = "0.7.0" # x-release-please-version
 ```
 
 ## License

data/crates/kobako-wasmtime/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.7.0](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.6.1...kobako-wasmtime-v0.7.0) (2026-07-03)
+
+
+### Features
+
+* **crates:** build the requested isolation profile into the WASI context ([63c25d8](https://github.com/elct9620/kobako/commit/63c25d835d4d03010c1658217cee412318e6b5d8))
+* **runtime:** runtimes declare their isolation profile ([f89717a](https://github.com/elct9620/kobako/commit/f89717a6bc9809f0de0df78f97da33a49a1474ac))
+
 ## [0.6.1](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.6.0...kobako-wasmtime-v0.6.1) (2026-07-02)
 
 

data/crates/kobako-wasmtime/README.md

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

data/lib/kobako/codec.rb

@@ -22,7 +22,7 @@ module Kobako
   # {Decoder} are thin wrappers that register the three kobako-specific
   # ext types (0x00 Symbol, 0x01 Capability Handle, 0x02 Exception
   # envelope) on a single +MessagePack::Factory+ instance. The Rust side
-  # mirrors this layer as the +codec+ module in the +kobako-core+ crate;
+  # mirrors this layer as the +codec+ module in the +kobako-codec+ crate;
   # the ext-code constants live as module-private values on {Factory}
   # alongside +codec::EXT_SYMBOL+ / +codec::EXT_HANDLE+ /
   # +codec::EXT_ERRENV+ on that side.

data/lib/kobako/sandbox.rb

@@ -38,14 +38,16 @@ module Kobako
 
     attr_reader :wasm_path, :options
 
-    # Per-cap accessors forward to the immutable +SandboxOptions+ Value
+    # Per-option accessors forward to the immutable +SandboxOptions+ Value
     # Object so the Host App still reads them off Sandbox directly.
-    def_delegators :@options, :timeout, :memory_limit, :stdout_limit, :stderr_limit
+    def_delegators :@options, :timeout, :memory_limit, :stdout_limit, :stderr_limit, :profile
 
     # Returns the bytes the guest wrote to stdout during the most recent
     # invocation as a UTF-8 String, clipped at +stdout_limit+. Empty before
     # any invocation; the byte content never contains a truncation sentinel,
-    # so use +#stdout_truncated?+ to observe overflow.
+    # so use +#stdout_truncated?+ to observe overflow. Populated on every
+    # outcome — including a rescued +TrapError+, after which it holds the
+    # bytes written before the trap fired — mirroring +#usage+.
     def stdout
       @stdout_capture.bytes
     end
@@ -83,25 +85,24 @@ module Kobako
     # Build a fresh Sandbox.
     #
     # +wasm_path+ is the absolute path to the Guest Binary; defaults to the
-    # gem-bundled +data/kobako.wasm+. The four caps (+stdout_limit+,
-    # +stderr_limit+, +timeout+, +memory_limit+) are forwarded verbatim to
-    # +Kobako::SandboxOptions+, which owns their DEFAULT fallback and
+    # gem-bundled +data/kobako.wasm+. Every other keyword — the four caps
+    # (+stdout_limit+, +stderr_limit+, +timeout+, +memory_limit+) and the
+    # requested isolation profile (+profile+) — is forwarded verbatim to
+    # +Kobako::SandboxOptions+, which owns the DEFAULT fallbacks and
     # normalisation. The constructed +SandboxOptions+ is exposed as
-    # +#options+ and the four caps remain readable directly on Sandbox via
-    # +Forwardable+ delegation.
-    def initialize(wasm_path: nil,
-                   stdout_limit: SandboxOptions::DEFAULT_OUTPUT_LIMIT,
-                   stderr_limit: SandboxOptions::DEFAULT_OUTPUT_LIMIT,
-                   timeout: SandboxOptions::DEFAULT_TIMEOUT_SECONDS,
-                   memory_limit: SandboxOptions::DEFAULT_MEMORY_LIMIT)
+    # +#options+ and every option remains readable directly on Sandbox via
+    # +Forwardable+ delegation. The runtime builds the requested profile —
+    # +:hermetic+ (the default) denies the guest ambient time and entropy,
+    # +:permissive+ leaves them live — and construction refuses a runtime
+    # whose declared profile falls below the request, raising
+    # +Kobako::SetupError+ before any invocation entry point runs.
+    def initialize(wasm_path: nil, **)
       @wasm_path = wasm_path || Kobako::Runtime.default_path
-      @options = SandboxOptions.new(timeout: timeout, memory_limit: memory_limit, stdout_limit: stdout_limit,
-                                    stderr_limit: stderr_limit)
+      @options = SandboxOptions.new(**)
       @handler = Catalog::Handles.new
       @services = Kobako::Catalog::Namespaces.new(handler: @handler)
       @snippets = Catalog::Snippets.new
-      @runtime = Kobako::Runtime.from_path(@wasm_path, @options.timeout, @options.memory_limit,
-                                           @options.stdout_limit, @options.stderr_limit)
+      @runtime = build_runtime!
       install_dispatch_proc!
       reset_invocation_state!
     end
@@ -209,6 +210,17 @@ module Kobako
 
     private
 
+    # Construct the +Runtime+ with the requested isolation profile and
+    # refuse one whose declared posture falls below the request —
+    # +SandboxOptions#enforce_floor!+ owns the ladder comparison, so a
+    # runtime that cannot honor the request never runs guest code.
+    def build_runtime!
+      runtime = Kobako::Runtime.from_path(@wasm_path, @options.timeout, @options.memory_limit,
+                                          @options.stdout_limit, @options.stderr_limit, profile)
+      @options.enforce_floor!(runtime.profile)
+      runtime
+    end
+
     # Configure the +Runtime+'s host↔guest dispatch wiring. Registers a
     # dispatch +Proc+ that routes guest→host calls through the stateless
     # +Transport::Dispatcher+, capturing +@services+ / +@handler+ in the
@@ -242,8 +254,8 @@ module Kobako
     # +TimeoutError+ / +MemoryLimitError+), +Kobako::SandboxError+,
     # and +Kobako::ServiceError+. +Runtime#usage+ is the single source for
     # both paths: the figures are stashed in the ext on every outcome, so
-    # unlike the +Snapshot+ (built only on success) the readout here also
-    # covers the trap path.
+    # the readout here also covers the trap path, where +Runtime#eval+ /
+    # +#run+ raise instead of returning outcome bytes.
     #
     # The ext returns a positional 2-tuple +[wall_time, memory_peak]+
     # whose order matches the +Kobako::Usage+ field order; the
@@ -269,33 +281,51 @@ module Kobako
       end
     end
 
+    # Read the per-last-invocation output captures from the ext and wrap
+    # them as +Kobako::Capture+ value objects. Runs in the +invoke!+
+    # +ensure+ block next to {#read_usage!} for the same reason: the ext
+    # stashes the captures on every outcome, so the readout also covers
+    # the trap path, where +Runtime#eval+ / +#run+ raise instead of
+    # returning outcome bytes — +#stdout+ / +#stderr+ keep the guest's
+    # partial output readable after a rescue.
+    #
+    # The ext returns a positional 4-tuple
+    # +[stdout_bytes, stdout_truncated, stderr_bytes, stderr_truncated]+;
+    # the destructure-then-kwargs handoff below is the explicit
+    # positional→keyword conversion point.
+    def read_captures!
+      stdout_bytes, stdout_truncated, stderr_bytes, stderr_truncated = @runtime.captures
+      @stdout_capture = Capture.new(bytes: stdout_bytes, truncated: stdout_truncated)
+      @stderr_capture = Capture.new(bytes: stderr_bytes, truncated: stderr_truncated)
+    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 yielded block must return a +Kobako::Snapshot+ — i.e. the
-    # value of +Runtime#eval+ / +#run+. The success path unpacks
-    # +#stdout+ / +#stderr+ into
-    # +Capture+ and feeds +#return_bytes+ to +Outcome.decode+; usage is
-    # populated by the +ensure+ readout ({#read_usage!}) on every outcome.
+    # The yielded block must return the invocation's raw outcome bytes —
+    # i.e. the value of +Runtime#eval+ / +#run+ — which the success path
+    # feeds to +Outcome.decode+. Captures and usage are populated by the
+    # +ensure+ readouts ({#read_usage!} / {#read_captures!}) on every
+    # outcome, so +#stdout+ / +#stderr+ / +#usage+ stay readable after a
+    # rescued trap.
     # The rescue chain is the single trap-translation boundary —
     # configured-cap paths surface as named TrapError subclasses
     # (+TimeoutError+ / +MemoryLimitError+); everything else surfaces as
     # the base +TrapError+.
     def invoke!(verb)
       begin_invocation!
-      snapshot = yield
-      @stdout_capture = snapshot.stdout
-      @stderr_capture = snapshot.stderr
+      return_bytes = yield
       # A Capability Handle in the result is decoded as a Kobako::Handle
       # token; restore it to the host object the guest referenced before
       # handing the value to the Host App. @handler still holds this
       # invocation's table — reset only happens at the next #begin_invocation!.
-      Codec::HandleWalk.deep_restore(Outcome.decode(snapshot.return_bytes), @handler)
+      Codec::HandleWalk.deep_restore(Outcome.decode(return_bytes), @handler)
     rescue Kobako::TrapError => e
       raise trap_class_for(e), "Sandbox##{verb} failed: #{e.message}"
     ensure
       read_usage!
+      read_captures!
     end
   end
 end

data/lib/kobako/sandbox_options.rb

@@ -1,19 +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+ normalises every cap before delegating to Data's
+  # 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. 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)
+  # 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
 
@@ -25,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: DEFAULT_OUTPUT_LIMIT,
-                   stderr_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 = 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+
@@ -78,5 +110,15 @@ module Kobako
 
       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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kobako
-  VERSION = "0.12.2"
+  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

@@ -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"
@@ -104,6 +114,26 @@
         }
       ]
     },
+    "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",
@@ -154,7 +184,7 @@
     {
       "type": "linked-versions",
       "groupName": "kobako crates",
-      "components": ["kobako-core", "kobako-rs", "kobako-io", "kobako-json", "kobako-regexp", "kobako-baker", "kobako-runtime", "kobako-wasmtime"]
+      "components": ["kobako-codec", "kobako-core", "kobako-rs", "kobako-io", "kobako-json", "kobako-regexp", "kobako-baker", "kobako-runtime", "kobako-wasmtime"]
     }
   ],
   "extra-files": [

data/sig/kobako/runtime.rbs

@@ -7,17 +7,22 @@ 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, Kobako::Transport::_GuestYielder) -> String dispatch_proc) -> void
 
-    def eval: (String preamble, String source, String snippets) -> Kobako::Snapshot
+    def eval: (String preamble, String source, String snippets) -> String
 
-    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.

data/sig/kobako/sandbox.rbs

@@ -10,13 +10,13 @@ module Kobako
     def memory_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,26 +3,33 @@ 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 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?
@@ -30,5 +37,7 @@ module Kobako
     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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kobako
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 0.13.0
 platform: aarch64-linux
 authors:
 - Aotokitsuruya
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-07-02 00:00:00.000000000 Z
+date: 2026-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -69,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
@@ -108,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,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "capture"
-
-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 five raw
-  # readers: +return_bytes+, +stdout_bytes+, +stdout_truncated+,
-  # +stderr_bytes+, +stderr_truncated+. This file reopens the class to add
-  # the Ruby-side helpers that pack those raw fields into the user-facing
-  # value object +Kobako::Capture+ — the same shape +Kobako::Sandbox+
-  # exposes to the Host App. Usage is not on the Snapshot; +Sandbox#usage+
-  # reads it from +Kobako::Runtime#usage+, which also covers the trap path
-  # where no Snapshot is produced.
-  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
-  end
-end

data/sig/kobako/snapshot.rbs

@@ -1,12 +0,0 @@
-module Kobako
-  class Snapshot
-    def return_bytes: () -> String
-    def stdout_bytes: () -> String
-    def stdout_truncated: () -> bool
-    def stderr_bytes: () -> String
-    def stderr_truncated: () -> bool
-
-    def stdout: () -> Kobako::Capture
-    def stderr: () -> Kobako::Capture
-  end
-end