kobako 0.18.0-aarch64-linux → 0.20.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d3a966a5daad9bfb2b5cf7028fb6a4dddc6ac35aa78c98e422bb002fd5a2a16
-  data.tar.gz: 8e30613f0ad120fe93018dfe21941b7efc3df089a423cc3b060a435dcf7a5426
+  metadata.gz: b09a439fa6c5bfc4598a565bc0ec6cfd026c65c48a39e9c9c0ae73c53ffb00d9
+  data.tar.gz: 0b1a09a6af7b5eabf918667c9efcc434952d693322fda2f71cf0195df174d21a
 SHA512:
-  metadata.gz: e532f115cb783909d7d8f858ed88ca3f1ebbb9221cb8ab16f2194197647f19b7aeeb07152877e2d4671845e364776b1c286c4db98fb16b756fb71b9cbb03fe14
-  data.tar.gz: b48605e8cd709a5b7cef9648d245c215eae4191d9bc2941fe8ead0e560c4cfe704eaf44d98309490f37f45705c385c1055ac8ed9388a05703a08c01d82299a05
+  metadata.gz: b5475e836c30518290c9b94eab8c0fe92c222efea64c93d909a099d50612e674a75733777fd3c37e884b7564dbc40fa46a3f90a04a26c9be40aa5d54dc548f1f
+  data.tar.gz: d76951bea7e5eae63d2c79052dcd3d2e03204afa738020f958139a7b293ae55624d94b8e11a6aa1a124f5b9094b281852e4fca6042c6dbf5d797e29dac874fc5

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"0.18.0","wasm/kobako-core":"0.10.2","wasm/kobako-mruby":"0.10.2","wasm/kobako-io":"0.10.2","wasm/kobako-json":"0.10.2","wasm/kobako-regexp":"0.10.2","wasm/kobako-baker":"0.10.2","crates/kobako-codec":"0.10.2","crates/kobako-runtime":"0.10.2","crates/kobako-wasmtime":"0.10.2","crates/kobako":"0.10.2"}
+{".":"0.20.0","wasm/kobako-core":"0.12.0","wasm/kobako-mruby":"0.12.0","wasm/kobako-io":"0.12.0","wasm/kobako-json":"0.12.0","wasm/kobako-regexp":"0.12.0","wasm/kobako-baker":"0.12.0","crates/kobako-codec":"0.12.0","crates/kobako-runtime":"0.12.0","crates/kobako-wasmtime":"0.12.0","crates/kobako":"0.12.0"}

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [0.20.0](https://github.com/elct9620/kobako/compare/v0.19.0...v0.20.0) (2026-07-24)
+
+
+### Features
+
+* **bench:** mark a run in progress with a pid lock file ([3ca85fb](https://github.com/elct9620/kobako/commit/3ca85fbe9860ce32d58c1a5bf4ff85cbdc210780))
+* **execution:** tell a nil-value success from a failure with #failed? ([2f3d382](https://github.com/elct9620/kobako/commit/2f3d382b24d65fabda7771429cd3adfc90a8c7e8))
+* **extension:** declare a backend's kind by explicit keyword ([3f6c628](https://github.com/elct9620/kobako/commit/3f6c6283080ba4346ac8ef878e469dab8039e650))
+* **sandbox:** add the gvl: hold/release scheduling option ([ca2a884](https://github.com/elct9620/kobako/commit/ca2a884415b3271c44b20d131536b3fe7c5a3077))
+* **sandbox:** declare fillable Service paths defaulting to Kobako::Unresolved ([1d60f76](https://github.com/elct9620/kobako/commit/1d60f764ddff3b5b10206993e2b281c838ec0022))
+* **sandbox:** fill and override declared paths per invocation with ctx.bind ([629ef7d](https://github.com/elct9620/kobako/commit/629ef7dfa35273c952685fefb4c5793b11886aee))
+* **sandbox:** return a frozen Kobako::Invocation from #eval and #run ([e9f4634](https://github.com/elct9620/kobako/commit/e9f463403bea26fad32e52d560b979684f555ed1))
+* **tasks:** gate the wasmtime driver against a magnus dependency ([268c3f6](https://github.com/elct9620/kobako/commit/268c3f65f53d64b465458bca5c0c9b0d0467df44))
+
+
+### Bug Fixes
+
+* **context:** raise ArgumentError for a spent ctx.bind ([2783bba](https://github.com/elct9620/kobako/commit/2783bba20f139554178389d4c860e0c280cab550))
+* **extension:** re-assert dependencies after a failed seal ([72839ba](https://github.com/elct9620/kobako/commit/72839bac6186e81a1d4323bd3f1eb4f10abf3d64))
+
+## [0.19.0](https://github.com/elct9620/kobako/compare/v0.18.0...v0.19.0) (2026-07-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* **readme:** guest scripts using `class X < Kobako::Member` must switch to `extend Kobako::Proxy`; Kobako::Member no longer exists in the guest.
+
+### Bug Fixes
+
+* **readme:** switch the Extension File idiom off the removed Kobako::Member ([0d96b9e](https://github.com/elct9620/kobako/commit/0d96b9eafed11df6fa030c38f93b2a0e9b190ed8))
+
 ## [0.18.0](https://github.com/elct9620/kobako/compare/v0.17.0...v0.18.0) (2026-07-18)
 
 

data/README.md

@@ -388,7 +388,8 @@ An Extension teaches the guest a native-style constant by pairing a guest idiom
 
 ```ruby
 FILE = <<~'MRUBY'
-  class File < Kobako::Member
+  class File
+    extend Kobako::Proxy
     def self.basename(path) = path.split("/").last || ""  # pure: runs in-guest
     # read / write are undefined here, so they dispatch to the backend
   end
@@ -476,6 +477,8 @@ Building from source requires a WASI-capable Rust toolchain in addition to the s
 
 Bug reports and pull requests are welcome at <https://github.com/elct9620/kobako>. Please open an issue before starting on non-trivial changes so we can align on scope.
 
+Releases are automated with release-please across two tracks — the gem and the linked guest-crate group. The version rules, commit conventions, and how to cut each release live in [`docs/releasing.md`](docs/releasing.md).
+
 ## License
 
 Kobako is released under the [Apache License 2.0](https://opensource.org/licenses/Apache-2.0).

data/crates/kobako-runtime/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.12.0](https://github.com/elct9620/kobako/compare/kobako-runtime-v0.11.0...kobako-runtime-v0.12.0) (2026-07-24)
+
+
+### Miscellaneous Chores
+
+* **kobako-runtime:** Synchronize kobako crates versions
+
+## [0.11.0](https://github.com/elct9620/kobako/compare/kobako-runtime-v0.10.2...kobako-runtime-v0.11.0) (2026-07-19)
+
+
+### Miscellaneous Chores
+
+* **kobako-runtime:** Synchronize kobako crates versions
+
 ## [0.10.2](https://github.com/elct9620/kobako/compare/kobako-runtime-v0.10.1...kobako-runtime-v0.10.2) (2026-07-18)
 
 

data/crates/kobako-runtime/README.md

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

data/crates/kobako-wasmtime/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.12.0](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.11.0...kobako-wasmtime-v0.12.0) (2026-07-24)
+
+
+### Miscellaneous Chores
+
+* **kobako-wasmtime:** Synchronize kobako crates versions
+
+## [0.11.0](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.10.2...kobako-wasmtime-v0.11.0) (2026-07-19)
+
+
+### Miscellaneous Chores
+
+* **kobako-wasmtime:** Synchronize kobako crates versions
+
 ## [0.10.2](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.10.1...kobako-wasmtime-v0.10.2) (2026-07-18)
 
 

data/crates/kobako-wasmtime/README.md

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

data/lib/kobako/catalog/extensions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../unresolved"
+
 module Kobako
   module Catalog
     # Kobako::Catalog::Extensions — per-Sandbox registry of installed
@@ -7,7 +9,9 @@ module Kobako
     # install time (its +source+ into +Catalog::Snippets+, its +backend+
     # path into +Catalog::Services+), asserts declared dependencies are
     # present when the Sandbox seals, and resolves each callable-backed
-    # path to a fresh object at the start of every invocation.
+    # path to a fresh object for every invocation — returning that map to the
+    # driving +Context+ rather than mutating the shared registry, so
+    # concurrent invocations stay shared-nothing.
     #
     # Sealing and the reject-after-install guard are governed by the owning
     # Sandbox through +Catalog::Services#sealed?+, the shared seal signal;
@@ -21,77 +25,87 @@ module Kobako
 
       # Install +extension+: validate its shape, register its +source+ as a
       # preloaded snippet, and — when it carries a +backend+ — reserve the
-      # backend path in +services+. A callable provider reserves the path
-      # with a placeholder the per-invocation refresh replaces; a fixed
-      # provider binds its object directly. Raises +ArgumentError+ for the two
-      # shapes +#validate!+ owns — +source+ not a String, or a present
-      # +backend+ that omits +path+ / +provider+. The Extension readers are
-      # duck-typed, so an object missing them surfaces the underlying
-      # +NoMethodError+, and a malformed +name+ or +backend.path+ surfaces
-      # through the +snippets+ / +services+ registration it routes to.
+      # backend path in +services+. A static +object:+ binds directly; a
+      # per-invocation +provider:+ or a fillable backend reserves the path with
+      # +Kobako::Unresolved+ (the per-invocation result is layered onto the
+      # Context, a fillable stays Unresolved until filled). Raises
+      # +ArgumentError+ for the two shapes +#validate!+ owns — +source+ not a
+      # String, or a present +backend+ that omits +path+ / +object+ /
+      # +provider+. The Extension readers are duck-typed, so an object missing
+      # them surfaces the underlying +NoMethodError+, and a malformed +name+ or
+      # +backend.path+ surfaces through the +snippets+ / +services+
+      # registration it routes to.
       def install(extension, snippets:, services:)
         validate!(extension)
         snippets.register(code: extension.source, name: extension.name)
         backend = extension.backend
-        services.bind(backend.path, initial_object(backend.provider)) if backend
+        services.bind(backend.path, install_object(backend)) if backend
         @entries << extension
         self
       end
 
       # Assert every installed Extension's +depends_on+ names a fellow
-      # installed Extension. Runs once, when the Sandbox first seals; an
-      # unmet dependency raises +ArgumentError+ naming the gap, before the
-      # guest runs. Idempotent across later invocations.
+      # installed Extension. Runs once, when the Sandbox first seals
+      # successfully; an unmet dependency raises +ArgumentError+ naming the
+      # gap, before the guest runs. The asserted flag flips only on success,
+      # so a seal that failed re-checks on the next attempt rather than
+      # silently passing a broken Sandbox. Idempotent across later invocations.
       def seal!
         return self if @asserted
 
-        @asserted = true
         assert_dependencies!
+        @asserted = true
         self
       end
 
-      # Resolve each callable-backed path to this invocation's object and
-      # refresh it behind its already-sealed path in +services+. Distinct
-      # providers yield distinct objects; one provider shared by several
-      # Extensions is invoked once and its result shared, so provider
-      # identity is resource identity. Fixed providers are left untouched —
-      # they stay the object bound at install.
-      def refresh_backends!(services)
-        resolved = {} # : Hash[untyped, untyped]
-        resolved.compare_by_identity
-        @entries.each { |extension| refresh_backend(extension, services, resolved) }
-        self
+      # Resolve each +provider:+-backed path to this invocation's object and
+      # return the +path => object+ map the driving +Context+ layers over the
+      # static base bindings. Distinct providers yield distinct objects; one
+      # provider shared by several Extensions is invoked once and its result
+      # shared, so provider identity is resource identity. Static and fillable
+      # backends are omitted — they stay the object bound at install in the
+      # base registry (+Kobako::Unresolved+ for a fillable).
+      def resolve
+        resolved = {} # : Hash[String, untyped]
+        by_provider = {} # : Hash[untyped, untyped]
+        by_provider.compare_by_identity
+        @entries.each { |extension| resolve_backend(extension, resolved, by_provider) }
+        resolved
       end
 
       private
 
-      # Resolve one Extension's callable-backed path against the shared
-      # per-invocation +resolved+ cache (keyed by provider identity) and
-      # refresh it in +services+. A fixed provider is skipped — its object
-      # stays as bound at install.
-      def refresh_backend(extension, services, resolved)
+      # The object a backend binds at install: a static +object:+ directly, or
+      # +Kobako::Unresolved+ as the placeholder for a per-invocation +provider:+
+      # (layered onto the Context) or a fillable (neither keyword).
+      def install_object(backend) = backend.object.nil? ? Kobako::Unresolved : backend.object
+
+      # Resolve one Extension's +provider:+-backed path against the shared
+      # per-invocation identity cache (keyed by provider identity) and record
+      # it in +resolved+. A static or fillable backend is skipped — its object
+      # stays as bound at install in the base registry.
+      def resolve_backend(extension, resolved, by_provider)
         backend = extension.backend
         return unless backend
 
         provider = backend.provider
-        return unless callable?(provider)
+        return if provider.nil?
 
-        object = resolved.fetch(provider) { resolved[provider] = provider.call }
-        services.refresh(backend.path, object)
+        resolved[backend.path.to_s] = by_provider.fetch(provider) { by_provider[provider] = provider.call }
       end
 
       # Enforce the Extension-shape checks +#preload+ / +#bind+ do not: a
       # mandatory String +source+ (the install/bind boundary) and a
-      # +backend+ that, when present, exposes +path+ and +provider+.
+      # +backend+ that, when present, exposes +path+ / +object+ / +provider+.
       def validate!(extension)
         source = extension.source
         raise ArgumentError, "Extension #source must be a String, got #{source.class}" unless source.is_a?(String)
 
         backend = extension.backend
         return if backend.nil?
-        return if backend.respond_to?(:path) && backend.respond_to?(:provider)
+        return if backend.respond_to?(:path) && backend.respond_to?(:object) && backend.respond_to?(:provider)
 
-        raise ArgumentError, "Extension #backend must expose #path and #provider"
+        raise ArgumentError, "Extension #backend must expose #path, #object, and #provider"
       end
 
       def assert_dependencies!
@@ -110,13 +124,6 @@ module Kobako
       # of a constant token are interchangeable; a value that is neither
       # falls through unchanged to the not-installed path.
       def symbolize(name) = name.is_a?(String) ? name.to_sym : name
-
-      def callable?(provider) = provider.respond_to?(:call)
-
-      # A callable provider reserves its path with a placeholder that the
-      # per-invocation refresh replaces before any dispatch; a fixed
-      # provider is the bound object itself.
-      def initial_object(provider) = callable?(provider) ? nil : provider
     end
   end
 end

data/lib/kobako/catalog/handles.rb

@@ -5,10 +5,10 @@ require_relative "../handle"
 module Kobako
   module Catalog
     # Host-side mapping from opaque integer Handle IDs to Ruby objects.
-    # The table is owned by +Kobako::Sandbox+ and injected
-    # into the per-Sandbox +Kobako::Catalog::Services+ so guest→host dispatch
-    # resolves Handle targets and arguments against the same table that
-    # host→guest wire encoding allocates into.
+    # Each invocation's +Kobako::Context+ mints its own table and hands it to
+    # the dispatcher, so guest→host dispatch resolves Handle targets and
+    # arguments against the same table that host→guest wire encoding allocates
+    # into for that run.
     #
     # Lifecycle invariants:
     #
@@ -17,10 +17,9 @@ module Kobako
     #     invocation is 1; ID 0 is reserved as the invalid sentinel and is
     #     never returned by +#alloc+.
     #
-    #   - At every invocation boundary (via +#reset!+), every Handle issued
-    #     under the old state becomes invalid. Reset applies uniformly
-    #     regardless of allocation source (Service return or host-injected
-    #     argument).
+    #   - A fresh table backs each invocation, so a Handle issued in one
+    #     invocation resolves in no other — uniformly regardless of
+    #     allocation source (Service return or host-injected argument).
     #
     #   - The cap is +0x7fff_ffff+ (2³¹ − 1). Allocation beyond the cap
     #     raises immediately — no silent truncation, no wrap, no ID reuse.
@@ -63,14 +62,6 @@ module Kobako
         @entries[id]
       end
 
-      # Clear all entries AND reset the counter to 1. Called at the
-      # per-invocation boundary by +Kobako::Sandbox+. Returns +self+.
-      def reset!
-        @entries.clear
-        @next_id = 1
-        self
-      end
-
       # Number of currently-bound entries. Used by tests of the Dispatcher
       # and Codec::HandleWalk#deep_wrap to observe whether each path allocates
       # exactly the Handle entries it should — the +Handles+ table itself never

data/lib/kobako/catalog/services.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "handles"
 require_relative "../codec"
 require_relative "../errors"
 
@@ -18,23 +17,19 @@ module Kobako
     #   services.lookup("MyService::KV")           # => kv_object
     #
     # Per-dispatch routing is +Kobako::Transport::Dispatcher+'s
-    # responsibility — the Dispatcher receives this registry and the
-    # +Catalog::Handles+ as arguments from the +Runtime#on_dispatch+ Proc
-    # that +Kobako::Sandbox#initialize+ installs. The registry holds an
-    # injected +Catalog::Handles+ reference so dispatch target resolution
-    # and host→guest auto-wrap share the same Sandbox-owned allocator.
+    # responsibility — the Dispatcher resolves a path against the invocation's
+    # +Kobako::Context+ (which layers per-invocation providers and +ctx.bind+
+    # overrides over these base bindings) and the +Catalog::Handles+, both
+    # passed in the per-invocation dispatch Proc the Context hands to
+    # +Runtime#eval+ / +#run+.
     class Services
       # Ruby constant-name pattern each +::+-separated bind-path segment
       # must match.
       NAME_PATTERN = /\A[A-Z]\w*\z/
 
-      # Build a fresh registry. +handler+ is an internal seam that injects
-      # a pre-configured +Catalog::Handles+; tests pass one whose +next_id+
-      # is pinned near +MAX_ID+ to exercise the cap-exhaustion path
-      # without 2³¹ allocations. Production callers leave it at the default.
-      def initialize(handler: Catalog::Handles.new)
+      # Build a fresh registry.
+      def initialize
         @bindings = {} # : Hash[String, untyped]
-        @handler = handler
         @sealed = false
         @encoded = nil # : String?
       end
@@ -56,6 +51,12 @@ module Kobako
         self
       end
 
+      # Returns +true+ iff a Service is bound at +path+ — the declared (Frame 1)
+      # key set a per-invocation +ctx.bind+ override may target.
+      def bound?(path)
+        @bindings.key?(path.to_s)
+      end
+
       # Resolve a +target+ constant path to the bound Service. Raises
       # +KeyError+ when no Service is bound at +target+.
       def lookup(target)
@@ -65,18 +66,6 @@ module Kobako
         @bindings[target_str]
       end
 
-      # Replace the object bound at an already-registered +path+ without the
-      # collision or seal checks +#bind+ applies. +Catalog::Extensions+ calls
-      # this during +begin_invocation!+ to swap a callable backend provider's
-      # per-invocation result behind a path whose Frame 1 membership was
-      # fixed at the seal. A path that was never registered is left untouched,
-      # so the sealed key set can never grow here.
-      def refresh(path, object)
-        key = path.to_s
-        @bindings[key] = object if @bindings.key?(key)
-        self
-      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
@@ -84,23 +73,20 @@ module Kobako
       # Strings, so none of the kobako ext types fire. Returns a binary
       # +String+ of msgpack bytes.
       #
-      # Once sealed, the bytes are computed once and reused for every
-      # subsequent invocation: sealing freezes Service registration at the
-      # first invocation, so a bind reaching the registry after the seal
-      # raises +ArgumentError+ and never alters Frame 1.
+      # 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
-        return @encoded if @encoded
-
-        bytes = Codec::Encoder.encode(@bindings.keys).freeze
-        @encoded = bytes if @sealed
-        bytes
+        @encoded || Codec::Encoder.encode(@bindings.keys).freeze
       end
 
-      # Mark the registry as sealed. Called by +Sandbox+ on the first
-      # invocation; afterwards #bind raises ArgumentError. Idempotent;
-      # returns +self+.
+      # 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+.
       def seal!
         @sealed = true
+        @encoded ||= Codec::Encoder.encode(@bindings.keys).freeze
         self
       end
 

data/lib/kobako/catalog/snippets.rb

@@ -41,17 +41,19 @@ module Kobako
       # externally via +entry_payload+ rather than asking each entry to
       # self-encode.
       #
-      # The bytes are memoized — the table is replayed verbatim on every
-      # invocation after sealing, so Frame 3 never changes between
-      # encodes; #register drops the memo while the table is still open.
-      # Unlike +Catalog::Services#encode+, which gates its memo on the
-      # seal, this one can fill eagerly and invalidate in +#register+
-      # because every mutation funnels through that single method — there is
-      # no out-of-sight child object to change the result behind its back.
+      # 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
-        return @encoded if @encoded
+        @encoded || Codec::Encoder.encode(@entries.map { |entry| entry_payload(entry) }).freeze
+      end
 
-        @encoded = Codec::Encoder.encode(@entries.map { |entry| entry_payload(entry) }).freeze
+      # 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
       end
 
       # Register one preloaded snippet in either of two forms.
@@ -73,7 +75,6 @@ module Kobako
       # missing keywords, wrong types, malformed +name+, or
       # duplicate +code:+ +name+.
       def register(code: nil, name: nil, binary: nil)
-        @encoded = nil
         if binary
           raise ArgumentError, "cannot combine binary: with code: / name:" if code || name