spinel_kit 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a45aac9b6f91813e7d837ea8878d4dcee1731b5582f4a42e5fae4f73e9f764ce
-  data.tar.gz: f201acc7e5c64ba8f5666e4c9c454440c7d1cc6835a30dd8adfb07442b1b42e8
+  metadata.gz: 84664f6fb19c07c1e9d4db180b7f9eb34a0499e6210de5acc764708b923aed72
+  data.tar.gz: 4a7894dca8991b6daf713423d04b33e35ef48678de58ea53112267a9cd7d679a
 SHA512:
-  metadata.gz: 5a6f770a93f9975455637ed2fb2ffd8874dcc69d1e6fdf8547b7120c13ea341f2154a0427f2bf317851d0cb86072232649f6e1b011354c8ab68760f120a4bc2e
-  data.tar.gz: 45d722737fce1cce7d606765af43f405fa6f34c96fa8a0167c8794262dee1ffebaa034600d865399577aaf9e826491059f338a8e688502bfd52b00c1071157b3
+  metadata.gz: e0599c94cabe3f168c4b1262e70dc66ef71eb2b9fc4a986e258a0040f1951c1e0ce59441f5d9eb881d251e16de7774ef0eb6a5f9b4b50c05969ccce9c2b6ebb9
+  data.tar.gz: 66a6080818ef6dd1d0ed4e9f19567ba903c4109cec84427971d7264cb3d316953db200c1fba64bab840f366a369f53b4bed789b253a43f788c2383092d6bce9d

data/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 All notable changes to SpinelKit are documented here.
 
+## [0.3.1] - 2026-11-12
+
+### Fixed
+- **`SpinelKit::Url.escape` dropped all but the first byte of a multi-byte
+  character.** It indexed with `String#[]` and encoded `c.getbyte(0)`, on the
+  documented premise that `[]` indexes bytes under Spinel. It does not —
+  `"café".length` is 4 there and `[3]` is a two-byte `"é"` — so `"café"`
+  escaped to `"caf%C3"` on both runtimes, and that does not unescape back.
+  It now walks `bytesize`/`getbyte`. ASCII input and the `.b` form that the
+  parity test used are unchanged; what changes is that a plain UTF-8 string
+  now answers the same as its binary form.
+
+## [0.3.0] - 2026-07-09
+
+### Changed
+- **Converted to a spin package** (spin is Spinel's package system;
+  [#3](https://github.com/OriPekelman/spinelkit/issues/3)). The package root
+  is now the require root: `lib/spinel_kit{,.rb}` moved to the repo top level,
+  `spin.toml` carries the identity (`name = "spinel_kit"`), and the gem
+  mirrors the layout with `require_paths = ["."]` — one tree serves both
+  consumers. Tests split by oracle: `test/*.rb` are compiled `spin test`
+  snapshot programs with committed `.expected` files (verified byte-identical
+  under CRuby and under spinel master `f9a81b1d`, 4/4); the CRuby minitest
+  parity suite moved to `test/parity/`.
+
+### Removed
+- **`SpinelKit::Json` and `SpinelKit::Json::Builder`** (`lib/spinel_kit/json.rb`,
+  `json_decoder.rb`, `json_builder.rb`, their `sig/` RBS and the parity test).
+  Spinel now bundles `json` as a require-gated stdlib package — a typed native
+  binding (`native_func :parse/:generate/:dump`) into the runtime's
+  `sp_json.c` — so the compiler provides the stdlib surface SpinelKit was
+  shimming ([#3](https://github.com/OriPekelman/spinelkit/issues/3)).
+  Verified on spinel master `f9a81b1d` with a tep-shaped consumer under
+  `SPINEL_REQUIRE_GATE=1`: byte-identical CRuby parity and **no
+  cross-degrade**; values from `JSON.parse` must be coerced at the boundary
+  (`.to_s`/`.to_i`/`.to_f`/`.map { |x| x.to_i }`) to stay fully typed —
+  without coercion, direct sinks widen to `untyped` (slow path, still
+  correct output).
+
+  **Migration:** `require "json"`; `JSON.parse(s)["k"].to_i` replaces
+  `SpinelKit::Json.get_int(s, "k")` (same shape for `get_str`/`get_float`/
+  `get_int_array`); `h.key?("k")` replaces `has_key?(s, "k")`;
+  `JSON.generate(hash)` replaces `encode_pair_*`/`from_*` and the Builder
+  (Ruby hashes are insertion-ordered; `native_obj_reflect` covers Structs).
+
 ## [0.2.0] - 2026-06-08
 
 ### Added

data/README.md

@@ -6,18 +6,38 @@
 ![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.2-CC342D)
 ![Pure Ruby](https://img.shields.io/badge/native%20ext-none-brightgreen)
 
-**The Spinel stdlib-surface gem.** A pure-Ruby, Spinel-safe toolkit holding
-the generic "stdlib substitute" shims that every Spinel-compiled project would
-otherwise hand-roll.
-
-[Spinel](https://github.com/matz/spinel) is a Ruby→native AOT compiler. It
-cannot lower large chunks of the CRuby standard library — the `json` gem's
-C-extension fast path and its metaprogrammed pure-Ruby fallback, stdlib
-`Logger`, C-extension git bindings, and more. So every Spinel project re-derives
-the same shims. [toy](https://github.com/OriPekelman/toy) and
-[tep](https://github.com/OriPekelman/tep) grew theirs independently, and the
-JSON escape/quote/hex code came out *byte-identical*. SpinelKit is that code,
-consolidated once.
+**The non-stdlib toolkit for Spinel-compiled apps.** A pure-Ruby, Spinel-safe
+library holding the shims [Spinel](https://github.com/matz/spinel) (the
+Ruby→native AOT compiler) does not provide and that every Spinel project
+would otherwise hand-roll: **git provenance, URL percent-codec + query
+parsing, a minimal levelled logger, and a hex codec**.
+[toy](https://github.com/OriPekelman/toy) and
+[tep](https://github.com/OriPekelman/tep) grew these independently — parts
+came out *byte-identical* — and SpinelKit is that code, consolidated once.
+
+## Where JSON went
+
+SpinelKit began as "the stdlib-surface gem," and its founding surface was a
+JSON codec. Spinel now **bundles `json` as a require-gated stdlib package** —
+a typed native binding straight into the runtime's `sp_json.c` — so the
+compiler provides the stdlib surface itself and `SpinelKit::Json` was retired
+in 0.3.0 ([#3](https://github.com/OriPekelman/spinelkit/issues/3)). Migration:
+
+```ruby
+require "json"                        # bare stdlib require, no manifest entry
+
+h = JSON.parse(body)
+model      = h["model"].to_s          # coerce at the parse boundary and
+max_tokens = h["max_tokens"].to_i     # everything downstream stays fully
+temp       = h["temperature"].to_f    # specialized under whole-program
+ids        = h["prompt"].map { |x| x.to_i }  # inference
+
+JSON.generate({ "ok" => true, "n" => max_tokens })   # replaces the Builder
+```
+
+Coerce parsed values once at the boundary (`.to_s`/`.to_i`/`.to_f`/mapped
+`.to_i`) — verified against spinel master: byte-identical CRuby parity, no
+cross-degrade, and full re-typification with the coercions in place.
 
 ## Installation
 
@@ -38,20 +58,20 @@ cleanly into a Spinel build via [bundler-spinel](https://github.com/OriPekelman/
 
 The first thing we did was audit the
 [spinelgems](https://github.com/OriPekelman/spinelgems) compatibility catalog
-(verdict ladder: `verified > loaded > clean > risky > rejected`) for an existing
-gem to reuse — that would have been the biggest win. **There wasn't one.** These
-shims *are* the ecosystem's gaps:
+(verdict ladder: `verified > loaded > clean > risky > rejected`) for existing
+gems to reuse — that would have been the biggest win. **There weren't any.**
+These shims *are* the ecosystem's gaps:
 
 | Surface | Catalog finding | Decision |
 |---------|-----------------|----------|
-| JSON    | `json` **rejected** (C-ext + metaprogrammed fallback); `oj` **risky** (C-ext) | implement |
 | Log     | `logger` **rejected** (unresolved calls) | implement |
 | Git     | `rugged` **rejected** (C); `gitkite`/`git_manager` only **clean**, unmet `needs:` | implement (read `.git/HEAD`) |
+| Url/Hex | `CGI`/`URI` stdlib not lowered; no verified gem | implement |
 | Path    | `hike` **verified** at an older rev, only **loaded** now; overkill for basename/join | deferred |
 | Bytes   | `unicode_utils`/`utf8-cleaner` **clean** only; toy's need is tokenizer-specific | deferred |
 
-See [`docs/gem-audit-first.md`](docs/gem-audit-first.md) for the full audit and
-the verification-request issues we filed on spinelgems.
+See [`docs/gem-audit-first.md`](docs/gem-audit-first.md) for the full audit
+(which also covers the since-retired JSON surface).
 
 ## What's in it
 
@@ -61,31 +81,8 @@ require "spinel_kit"   # everything (CRuby / convenience)
 
 For a **Spinel-compiled** consumer, require only the surface you use — Spinel
 has no tree-shaking, so every loaded method is compiled (and an uncalled one
-can degrade). The Json surface is split into three files for exactly this
-reason: `spinel_kit/json` (encoders), `spinel_kit/json_decoder` (decoders), and
-`spinel_kit/json_builder` (the builder). e.g. tep requires `json` + `json_decoder`;
-toy requires `json_builder`.
-
-- **`SpinelKit::Json`** — a JSON-over-HTTP codec: encoders
-  (`escape`/`quote`/`encode_pair_*`/`from_*`, in `spinel_kit/json`) and flat-key
-  decoders (`get_str`/`get_int`/`get_float`/`get_int_array`/`has_key?`, in
-  `spinel_kit/json_decoder`).
-
-  ```ruby
-  SpinelKit::Json.get_int('{"age":33}', "age")             # => 33
-  SpinelKit::Json.from_int_hash({"a" => 1, "b" => 2})      # => {"a":1,"b":2}
-  ```
-
-- **`SpinelKit::Json::Builder`** — an incremental ordered-object builder
-  (`add_str`/`add_num`/`add_bool`/`add_raw`/`add_obj`/`dump`), in its own file
-  so a builder-only consumer never compiles the codec, and vice versa.
-
-  ```ruby
-  j = SpinelKit::Json::Builder.new
-  j.add_str("kind", "run_start")
-  j.add_num("t", 1715000000)
-  j.dump                                     # => {"kind":"run_start","t":1715000000}
-  ```
+can degrade): `spinel_kit/hex`, `spinel_kit/url` (pulls in hex),
+`spinel_kit/git`, `spinel_kit/log`.
 
 - **`SpinelKit::Git`** — git provenance from `.git/HEAD`.
 
@@ -95,6 +92,15 @@ toy requires `json_builder`.
   g.branch       # => "main"
   ```
 
+- **`SpinelKit::Url`** — the `CGI`/`URI`-component surface:
+  `escape`/`unescape` (RFC 3986 percent-codec), `parse_query`
+  (form-urlencoded → Hash), `split_url` (scheme/host/port/path/query).
+
+  ```ruby
+  SpinelKit::Url.escape("a b&c")            # => "a%20b%26c"
+  SpinelKit::Url.parse_query("x=1&y=z")     # => {"x"=>"1", "y"=>"z"}
+  ```
+
 - **`SpinelKit::Log`** — a minimal levelled logger (CRuby `Logger` doesn't
   compile under Spinel).
 
@@ -104,6 +110,9 @@ toy requires `json_builder`.
   log.info("server up")
   ```
 
+- **`SpinelKit::Hex`** — hex digit/byte encode + decode (`nibble`,
+  `nibble_char`, `byte2`, `to_int`); the shared surface `Url` builds on.
+
 ## Design constraints (read before editing)
 
 SpinelKit is **pure Ruby, no native extension** (`spinel-ext.json` is `[]`) and
@@ -111,24 +120,44 @@ has **no runtime dependencies**, so it vendors cleanly via `bundler-spinel`. The
 surface uses plain, standard names; the `j_`/`tj_`/`gi_` prefixes the donor
 copies carried were a workaround for a Spinel whole-program-inference bug that
 has since been fixed upstream (verified with toy's `gate-poly-degrade` on the
-current compiler). One numeric caveat remains for `add_num` — see
-[`docs/spinel-discipline.md`](docs/spinel-discipline.md).
+current compiler). See [`docs/spinel-discipline.md`](docs/spinel-discipline.md).
+
+## Package formats: spin package + gem, one tree
+
+This repo **is a [spin](https://github.com/matz/spin-index) package** (spin is
+Spinel's package system): the package root is the require root
+(`spinel_kit.rb` + `spinel_kit/` at top level), `spin.toml` carries the
+identity, and the top-level `test/*.rb` programs are compiled snapshot tests
+(`spin test` — each diffs against its committed `.expected`, byte-identical
+under CRuby too). Spinel projects take it with:
+
+```sh
+spin add spinel_kit            # index form, once seeded — or:
+spin add spinel_kit --git https://github.com/OriPekelman/spinelkit
+```
+
+The same tree still ships as the `spinel_kit` **gem** for CRuby-side
+consumers (`require_paths` is the package root), and vendors via
+`bundler-spinel` as before.
 
 ## Status
 
-Pre-alpha (`0.1.0`). The shims are implemented, CRuby-verified, and the surface
-is the single canonical one (the donor prefixes and duplicated escapers are
-gone — the Spinel inference bug that motivated them is fixed). Consumer adoption
-is the next phase: because we author every repo in this set, tep and toy
-**migrate to `SpinelKit::*` directly and delete their donor modules** — we
-standardize and clean rather than leave compatibility aliases behind. See
-[`docs/adoption.md`](docs/adoption.md). Tracking issue:
-[OriPekelman/toy#44](https://github.com/OriPekelman/toy/issues/44).
+Pre-alpha (`0.3.0` — the JSON retirement + spin package conversion). tep and
+toy migrated to `SpinelKit::*` directly and deleted their donor modules (see
+[`docs/adoption.md`](docs/adoption.md)); their JSON call sites migrate to the
+bundled stdlib `json` next
+([tep#217](https://github.com/OriPekelman/tep/issues/217),
+[tep#213](https://github.com/OriPekelman/tep/issues/213)), and their
+dependency declarations move to `spin.toml`
+([tep#234](https://github.com/OriPekelman/tep/issues/234),
+[toy#107](https://github.com/OriPekelman/toy/issues/107)). Repositioning
+tracked in [#3](https://github.com/OriPekelman/spinelkit/issues/3).
 
 ## Development
 
 ```sh
-rake test            # CRuby-side parity tests (never compiled)
+rake test            # CRuby-side parity tests, test/parity/ (never compiled)
+spin test            # compiled snapshot tests, test/*.rb vs .expected
 rake rbs:validate    # syntax-check the advisory RBS in sig/
 gem build spinel_kit.gemspec
 ```

data/docs/adoption.md

@@ -1,5 +1,13 @@
 # Adoption — standardize and clean (not shim-and-alias)
 
+> **Historical note (2026-07-08).** This doc describes the 0.1–0.2 era
+> migration of tep and toy onto `SpinelKit::*`, including the Json surface.
+> `SpinelKit::Json`/`Builder` were **retired in 0.3.0** — Spinel now bundles
+> `json` as a stdlib package, and the Json call sites below migrate again, to
+> bare `require "json"` (see
+> [#3](https://github.com/OriPekelman/spinelkit/issues/3) and the CHANGELOG
+> migration note). The Git/Url/Log/Hex parts remain accurate.
+
 Bootstrap landed the gem and its three shims. Adoption by tep and toy is the
 next phase. **Because we author every repo in this set — toy, tep, spinelgems,
 and Spinel itself — the goal is to standardize and clean, not to bolt

data/docs/spinel-discipline.md

@@ -2,7 +2,7 @@
 
 SpinelKit ships code that gets compiled into *other* programs by Spinel's
 whole-program AOT compiler. That changes the rules for how it must be written.
-This doc is the contract for anyone editing `lib/spinel_kit/*.rb`.
+This doc is the contract for anyone editing `spinel_kit/*.rb`.
 
 ## 1. The name-keyed inference bug — FIXED, prefixes dropped
 
@@ -35,28 +35,24 @@ names (`escape`/`quote`/`add_str`/`sha`/`branch`/plain `value`).
 - **Split the surface so consumers don't compile dead code.** Spinel has no
   tree-shaking: every loaded method is compiled, and a *set* of uncalled
   methods can degrade each other's (and nearby live methods') param types. We
-  saw this concretely — with the encoders and decoders in one class, an
-  encode-only program left the 9 decoder walkers dead; their `s` params
-  collapsed to `int` and dragged `escape`'s `s` to `int` too, silently
-  emitting `""` keys from `from_*_hash`. The fix was structural: encoders
-  (`json.rb`), decoders (`json_decoder.rb`), and builder (`json_builder.rb`)
-  live in separate files, so a consumer loads only a coherent surface it
-  actually exercises. Verified clean (0 emit-0, correct output) for the real
-  consumer shapes — builder-only (toy) and encode+decode (tep) — on rev
-  `57af7f9`. A consumer that loads a surface but leaves part of it uncalled can
-  still trip the gate; that's expected, and the gate is what flags it.
-- **`escape`/`quote`/`hex2` are single canonical methods** — the builder
-  carries its own byte-identical copies (so a builder-only compile pulls in no
-  codec); there is no `tj_*` prefix any more.
-- **Keep `get_float` inlined** (it does NOT delegate to a `parse_float_value`
-  helper). This is unrelated to the name bug — it's a value-walk *indirection*
-  issue where Spinel mis-widened the string arg `s` to int through the helper
-  call. Until that's separately confirmed fixed, leave it inlined.
+  saw this concretely in the retired Json surface — with the encoders and
+  decoders in one class, an encode-only program left the 9 decoder walkers
+  dead; their `s` params collapsed to `int` and dragged `escape`'s `s` to
+  `int` too, silently emitting `""` keys. The fix was structural: one
+  coherent surface per file (today: `hex.rb`, `url.rb`, `git.rb`, `log.rb`),
+  so a consumer loads only what it actually exercises. A consumer that loads
+  a surface but leaves part of it uncalled can still trip the gate; that's
+  expected, and the gate is what flags it.
 - **Never override `to_s`** — it merges across the whole program.
 - The stale cautionary comments in toy's `toy_json.rb`/`toy_git.rb` and the
   landmine memory note should be annotated "fixed upstream by `ac7720e`/
   `23ba632`, verified on `57af7f9`" when those repos are next touched.
 
+(Historical, retired with the Json surface in 0.3.0: the three-file Json
+split, the builder's byte-identical private escapers, and the keep-`get_float`
+-inlined rule. The last known instance of the value-walk indirection issue was
+verified fixed on master `b60fbd7`.)
+
 ## 2. The poly-degrade gate (how consumers verify SpinelKit is safe)
 
 Each consumer has a poly-degrade scan that compiles a canonical entrypoint and
@@ -101,6 +97,7 @@ destined for Spinel. SpinelKit's own decoders follow this rule.
   runs, but file output is the portable path.
 - `Time.now` exposes integer seconds only (no rich `strftime`) — `Log` formats
   with `Time.now.to_i`.
-- `Integer#chr` is not uniform for arbitrary bytes — `Json.byte_to_chr` uses a
-  printable-ASCII table with a `"?"` fallback.
+- `Integer#chr` is not uniform for arbitrary bytes — the retired Json surface
+  used a printable-ASCII table with a `"?"` fallback; apply the same pattern
+  if a surface ever needs byte→char again.
 - No C extensions — `spinel-ext.json` is `[]`.

data/spin.toml

@@ -0,0 +1,6 @@
+# spin package manifest — SpinelKit as an ordinary spin package.
+# The package NAME is the require string (`require "spinel_kit/git"` etc.);
+# the repo keeps its historical name. See issue #3 for the repositioning.
+[package]
+name = "spinel_kit"
+version = "0.3.1"

data/{lib/spinel_kit → spinel_kit}/hex.rb

@@ -1,12 +1,8 @@
 # SpinelKit::Hex -- hex digit/byte encode + decode: the pieces every Spinel
 # project re-rolls. The decode nibble appeared BYTE-IDENTICAL in Tep::Url,
-# inside SpinelKit::Json's string decoder, and (as a multi-digit variant) in
-# Tep::Llm's chunked-transfer size parser. Pure string/byte ops, Spinel-safe.
-#
-# NOTE on the Json overlap: SpinelKit::Json keeps its OWN private `hex2`/
-# `hex_nibble` so a JSON-only consumer never compiles this file (Spinel has no
-# tree-shaking — see json.rb). Hex is the shared surface for everyone else,
-# e.g. SpinelKit::Url.
+# in the retired SpinelKit::Json string decoder, and (as a multi-digit
+# variant) in Tep::Llm's chunked-transfer size parser. Pure string/byte ops,
+# Spinel-safe. Hex is the shared surface, e.g. for SpinelKit::Url.
 module SpinelKit
   class Hex
     # Hex digit char -> int 0..15, or -1 if not a hex digit (upper or lower).

data/{lib/spinel_kit → spinel_kit}/url.rb

@@ -42,20 +42,26 @@ module SpinelKit
     # (ALPHA / DIGIT / `-._~`); the rest becomes `%XX` with UPPERCASE hex.
     # (Space -> `%20`, not `+` -- this is the URI-component, not form, encoder.)
     #
-    # Byte-oriented: under Spinel `String#[]` indexes BYTES, so a multi-byte
-    # UTF-8 char is encoded byte-by-byte (correct %XX of each byte). Under CRuby,
-    # pass a binary string for the same behaviour (else `[]` splits on chars).
+    # Byte-oriented, and it walks BYTES to be so: `bytesize`/`getbyte` mean
+    # a multi-byte UTF-8 character becomes the %XX of each of its bytes on
+    # both runtimes, with no binary-string dance at the call site.
+    #
+    # It used to index with `String#[]` and encode `c.getbyte(0)` -- the
+    # FIRST byte of the character -- on the premise that `[]` indexes bytes
+    # under Spinel. It does not: `"caf\u00e9".length` is 4 there and `[3]`
+    # is a two-byte "\u00e9", so every byte but the first was DROPPED and
+    # "caf\u00e9" escaped to "caf%C3", which does not unescape back.
     def self.escape(s)
       out = ""
       i = 0
-      while i < s.length
-        c = s[i]
-        if (c >= "a" && c <= "z") || (c >= "A" && c <= "Z") ||
-           (c >= "0" && c <= "9") || c == "-" || c == "." ||
-           c == "_" || c == "~"
-          out = out + c
+      n = s.bytesize
+      while i < n
+        b = s.getbyte(i)
+        if (b >= 0x61 && b <= 0x7A) || (b >= 0x41 && b <= 0x5A) ||
+           (b >= 0x30 && b <= 0x39) || b == 0x2D || b == 0x2E ||
+           b == 0x5F || b == 0x7E
+          out = out + b.chr
         else
-          b = c.getbyte(0)
           out = out + "%" + Hex.nibble_char(b / 16) + Hex.nibble_char(b % 16)
         end
         i += 1

data/spinel_kit/version.rb

@@ -0,0 +1,6 @@
+# SpinelKit version. Kept in its own file so the gemspec can read it
+# without loading the rest of the library (the modules pull in no deps,
+# but this matches the toy/tep convention exactly).
+module SpinelKit
+  VERSION = "0.3.1"
+end

data/spinel_kit.rb

@@ -0,0 +1,39 @@
+# SpinelKit -- the non-stdlib toolkit for Spinel-compiled apps.
+#
+# A pure-Ruby, Spinel-safe toolkit holding the shims Spinel (the Ruby->native
+# AOT compiler) does not provide and that every Spinel-compiled project would
+# otherwise hand-roll:
+#
+#   SpinelKit::Hex -- hex digit/byte encode + decode.
+#   SpinelKit::Url -- percent-encode/decode + form-query + URL split.
+#   SpinelKit::Git -- git provenance from .git/HEAD (was Toy::Git).
+#   SpinelKit::Log -- minimal levelled logger (was Tep::Logger).
+#
+# JSON is NOT here any more. Spinel bundles `json` as a require-gated stdlib
+# package (a typed native binding into sp_json.c), so consumers write a bare
+# `require "json"` and use JSON.parse / JSON.generate, coercing parsed values
+# at the boundary (`.to_s` / `.to_i` / `.to_f` / `.map { |x| x.to_i }`) to
+# keep inference fully typed. The old SpinelKit::Json codec + Builder were
+# retired in 0.3.0 -- see CHANGELOG.md and issue #3.
+#
+# MINIMAL-SURFACE REQUIRING. This umbrella requires everything for
+# convenience (and for CRuby use). But because Spinel compiles every loaded
+# method with no tree-shaking, a Spinel-compiled consumer should require ONLY
+# the file(s) it uses, to avoid compiling -- and degrading -- code it never
+# calls:
+#
+#   require "spinel_kit/hex"           # hex digit/byte codec
+#   require "spinel_kit/url"           # percent-codec + query (pulls in hex)
+#   require "spinel_kit/git"
+#   require "spinel_kit/log"
+#
+# No native extension (spinel-ext.json is []), no runtime dependencies. See
+# docs/adoption.md and docs/spinel-discipline.md.
+require_relative "spinel_kit/version"
+require_relative "spinel_kit/hex"
+require_relative "spinel_kit/url"
+require_relative "spinel_kit/git"
+require_relative "spinel_kit/log"
+
+module SpinelKit
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spinel_kit
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Ori Pekelman
@@ -10,14 +10,14 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |-
-  SpinelKit consolidates the pure-Ruby "stdlib substitute" shims that every
-  Spinel-compiled project would otherwise hand-roll. Spinel (the Ruby->native
-  AOT compiler) cannot lower the json gem's C-ext fast path / metaprogrammed
-  fallback, stdlib Logger, or C-ext git bindings -- and the spinelgems
-  compatibility catalog confirms no verified gem exists to reuse. So this gem
-  ships a JSON encoder+decoder+builder, .git/HEAD provenance, and a minimal
-  levelled logger. Pure Ruby, no native extension, no runtime dependencies --
-  it vendors cleanly via bundler-spinel. Pre-alpha.
+  SpinelKit consolidates the pure-Ruby shims that every Spinel-compiled
+  project would otherwise hand-roll and that Spinel (the Ruby->native AOT
+  compiler) does not provide: .git/HEAD provenance, URL percent-codec +
+  query parsing, a minimal levelled logger, and a hex digit/byte codec.
+  (JSON left in 0.3.0: Spinel now bundles `json` as a require-gated stdlib
+  package, so consumers use JSON.parse/JSON.generate directly.) Pure Ruby,
+  no native extension, no runtime dependencies -- it vendors cleanly via
+  bundler-spinel. Pre-alpha.
 email:
 - ori@pekelman.com
 executables: []
@@ -31,24 +31,19 @@ files:
 - docs/gem-audit-first.md
 - docs/spinel-discipline.md
 - docs/spinelgems-issues.md
-- lib/spinel_kit.rb
-- lib/spinel_kit/git.rb
-- lib/spinel_kit/hex.rb
-- lib/spinel_kit/json.rb
-- lib/spinel_kit/json_builder.rb
-- lib/spinel_kit/json_decoder.rb
-- lib/spinel_kit/log.rb
-- lib/spinel_kit/url.rb
-- lib/spinel_kit/version.rb
 - sig/spinel_kit/git.rbs
 - sig/spinel_kit/hex.rbs
-- sig/spinel_kit/json.rbs
-- sig/spinel_kit/json_builder.rbs
-- sig/spinel_kit/json_decoder.rbs
 - sig/spinel_kit/log.rbs
 - sig/spinel_kit/url.rbs
 - sig/spinel_kit/version.rbs
+- spin.toml
 - spinel-ext.json
+- spinel_kit.rb
+- spinel_kit/git.rb
+- spinel_kit/hex.rb
+- spinel_kit/log.rb
+- spinel_kit/url.rb
+- spinel_kit/version.rb
 homepage: https://github.com/OriPekelman/spinelkit
 licenses:
 - MIT
@@ -60,7 +55,7 @@ metadata:
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
-- lib
+- "."
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -74,6 +69,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: 'The Spinel stdlib-surface gem: pure-Ruby JSON/Git/Log shims for AOT-compiled
-  apps'
+summary: Pure-Ruby Git/Url/Log/Hex shims for Spinel AOT-compiled apps
 test_files: []