spinel_kit 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a45aac9b6f91813e7d837ea8878d4dcee1731b5582f4a42e5fae4f73e9f764ce
-  data.tar.gz: f201acc7e5c64ba8f5666e4c9c454440c7d1cc6835a30dd8adfb07442b1b42e8
+  metadata.gz: fca4df06c4d57130a5053954a6429beac7d6ce0d6f6d1ee26194753aea11732c
+  data.tar.gz: 496c1116e14068768cb482723d1be6c6daebfc26f45d9972da3ab36d572eae69
 SHA512:
-  metadata.gz: 5a6f770a93f9975455637ed2fb2ffd8874dcc69d1e6fdf8547b7120c13ea341f2154a0427f2bf317851d0cb86072232649f6e1b011354c8ab68760f120a4bc2e
-  data.tar.gz: 45d722737fce1cce7d606765af43f405fa6f34c96fa8a0167c8794262dee1ffebaa034600d865399577aaf9e826491059f338a8e688502bfd52b00c1071157b3
+  metadata.gz: 1d15a4186fd29c584767e64c7f015b6424ce72bae04d39b283529f48478923075662bc2ecdc5e0ac03a73c51bcc344a9140cc775123a33c02e2dc76f9860cf73
+  data.tar.gz: 4d0ee98f92b44fa1e1345efdac6378626c31ba11c42cf0a6be12ab065f9e9854799eec16edb363da670b01eacd8421623631d2259c296f66f8b9892cd6f2eaa5

data/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 All notable changes to SpinelKit are documented here.
 
+## [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.0"

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/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.0"
+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.0
 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: []

data/lib/spinel_kit/json.rb

@@ -1,149 +0,0 @@
-# SpinelKit::Json -- Spinel-safe JSON ENCODERS (stateless).
-#
-# This file holds the encode half of the codec; the decode half lives in
-# spinel_kit/json_decoder.rb (also `SpinelKit::Json`), and the incremental
-# object builder in spinel_kit/json_builder.rb (`SpinelKit::Json::Builder`).
-# The three are split because Spinel has no tree-shaking: every loaded method
-# is compiled, and a set of uncalled methods can degrade each other's params
-# (e.g. the dead decoder walkers collectively widening `escape`'s string arg
-# to int, which silently miscompiled string keys to ""). Keeping
-# encode/decode/build in separate files means a consumer compiles only the
-# surface it calls, and each surface is independently warning-clean. Require
-# only what you use:
-#
-#   require "spinel_kit/json"          # encoders (this file)
-#   require "spinel_kit/json_decoder"  # decoders
-#   require "spinel_kit/json_builder"  # builder
-#
-# WHY HAND-ROLLED. Spinel cannot lower the stdlib `json` gem (C-ext fast path
-# + metaprogrammed pure fallback); `oj`/`yajl`/`multi_json` are C extensions.
-# The spinelgems catalog confirms no verified pure-Ruby JSON gem exists. This
-# is tep's encoder, standardized (the `j_`/`tj_` prefixes that worked around a
-# now-fixed Spinel inference bug are gone -- see docs/spinel-discipline.md).
-#
-# Compose objects in user code by concatenation:
-#
-#   "{" + SpinelKit::Json.encode_pair_str("name", name) + "," +
-#         SpinelKit::Json.encode_pair_int("age", age) + "}"
-module SpinelKit
-  class Json
-    # Escape a string for inclusion inside a JSON string literal (does NOT
-    # add the surrounding quotes -- use `quote(s)` for that). Handles ", \,
-    # and the JSON-required control-char escapes (\b, \f, \n, \r, \t);
-    # other control bytes go through \u00XX. Forward slash is left
-    # unescaped (legal either way; unescaped is shorter/readable).
-    def self.escape(s)
-      out = ""
-      i = 0
-      n = s.length
-      while i < n
-        c = s[i]
-        if c == "\""
-          out = out + "\\\""
-        elsif c == "\\"
-          out = out + "\\\\"
-        elsif c == "\n"
-          out = out + "\\n"
-        elsif c == "\r"
-          out = out + "\\r"
-        elsif c == "\t"
-          out = out + "\\t"
-        elsif c == "\b"
-          out = out + "\\b"
-        elsif c == "\f"
-          out = out + "\\f"
-        elsif c < " "
-          # Other control byte -- emit \u00XX. c.getbyte(0) is the raw
-          # byte value, mapped to two hex digits.
-          b = c.getbyte(0)
-          out = out + "\\u00" + Json.hex2(b)
-        else
-          out = out + c
-        end
-        i += 1
-      end
-      out
-    end
-
-    # Two-digit lowercase hex of a byte (0..255).
-    def self.hex2(n)
-      hex = "0123456789abcdef"
-      out = ""
-      out = out + hex[(n / 16) % 16, 1]
-      out = out + hex[n % 16, 1]
-      out
-    end
-
-    # Wrap a string in JSON quotes, escaping its body.
-    def self.quote(s)
-      "\"" + Json.escape(s) + "\""
-    end
-
-    # Encode a single key/value pair as `"k":"v"` (escaped both sides).
-    def self.encode_pair_str(k, v)
-      Json.quote(k) + ":" + Json.quote(v)
-    end
-
-    # Same shape, integer value side. `v` is rendered via `.to_s` so
-    # JSON-numeric output without quoting.
-    def self.encode_pair_int(k, v)
-      Json.quote(k) + ":" + v.to_s
-    end
-
-    # Encode a Hash<String,String> as a JSON object.
-    def self.from_str_hash(h)
-      out = "{"
-      first = true
-      h.each do |k, v|
-        if !first
-          out = out + ","
-        end
-        first = false
-        out = out + Json.quote(k) + ":" + Json.quote(v)
-      end
-      out + "}"
-    end
-
-    # Same shape with integer values. JSON-numeric, no quoting.
-    def self.from_int_hash(h)
-      out = "{"
-      first = true
-      h.each do |k, v|
-        if !first
-          out = out + ","
-        end
-        first = false
-        out = out + Json.quote(k) + ":" + v.to_s
-      end
-      out + "}"
-    end
-
-    # Encode a string array as a JSON array of quoted strings.
-    def self.from_str_array(a)
-      out = "["
-      i = 0
-      while i < a.length
-        if i > 0
-          out = out + ","
-        end
-        out = out + Json.quote(a[i])
-        i += 1
-      end
-      out + "]"
-    end
-
-    # Encode an int array as a JSON array of numbers.
-    def self.from_int_array(a)
-      out = "["
-      i = 0
-      while i < a.length
-        if i > 0
-          out = out + ","
-        end
-        out = out + a[i].to_s
-        i += 1
-      end
-      out + "]"
-    end
-  end
-end

data/lib/spinel_kit/json_builder.rb

@@ -1,142 +0,0 @@
-# SpinelKit::Json::Builder -- an incremental, ordered JSON-object builder.
-#
-# WHY A SEPARATE FILE/CLASS. This is toy's hand-rolled builder; the codec
-# (SpinelKit::Json, encode/decode) is tep's. They are split so a consumer
-# compiles only the surface it uses: Spinel has no tree-shaking, so an
-# uncalled method is still compiled and degrades its params, emitting benign
-# but gate-tripping `emitting 0` warnings. A builder-only consumer requires
-# THIS file and never pays for the decoder walkers; a codec-only consumer
-# requires spinel_kit/json and never pays for the builder.
-#
-# To stay self-contained, Builder carries its OWN escape/quote/hex2 rather
-# than calling SpinelKit::Json.* (which would drag the whole codec, decoders
-# included, into a builder-only compile). These are byte-identical to the
-# codec's; the small duplication buys surface isolation. The same-named
-# methods across the two classes are safe -- the Spinel name-collision bug
-# that once made that dangerous is fixed (see docs/spinel-discipline.md).
-#
-# USAGE (mutating appenders, NOT method-chaining -- chaining is a Spinel
-# poly-degradation risk):
-#
-#   j = SpinelKit::Json::Builder.new
-#   j.add_str("kind", "run_start")
-#   j.add_num("t", now)                  # int OR float via .to_s
-#   host = SpinelKit::Json::Builder.new
-#   host.add_str("name", host_name)
-#   j.add_obj("host", host)              # nest a sub-builder
-#   j.add_raw("lr", "0.001")             # already-encoded JSON literal
-#   ev = j.dump                          # "{...}"
-#
-# NUMERIC NOTE: if a single compiled program passes BOTH Integer and Float to
-# `add_num`'s `value`, Spinel unifies the param to Float and an Integer
-# renders as "N.0". For hardcoded numeric literals where byte-exact output
-# matters, use `add_raw` with an already-encoded string instead of relying on
-# `value.to_s`.
-module SpinelKit
-  class Json
-    class Builder
-      def initialize
-        @buf   = "{"
-        @first = true
-      end
-
-      # Append `"key":"escaped-value"`.
-      def add_str(key, value)
-        comma
-        @buf = @buf + Builder.quote(key) + ":" + Builder.quote(value)
-      end
-
-      # Append `"key":<number>` -- `value.to_s` covers Integer ("5") and
-      # Float ("1.5"). For hardcoded literals prefer add_raw.
-      def add_num(key, value)
-        comma
-        @buf = @buf + Builder.quote(key) + ":" + value.to_s
-      end
-
-      # Append `"key":true|false`.
-      def add_bool(key, value)
-        comma
-        @buf = @buf + Builder.quote(key) + ":" + (value ? "true" : "false")
-      end
-
-      # Append `"key":<already-encoded JSON>` -- for arrays / numeric literals.
-      def add_raw(key, raw)
-        comma
-        @buf = @buf + Builder.quote(key) + ":" + raw
-      end
-
-      # Append `"key":<nested object>` from another Builder.
-      def add_obj(key, child)
-        comma
-        @buf = @buf + Builder.quote(key) + ":" + child.dump
-      end
-
-      # Close the object and return the JSON string.
-      def dump
-        @buf + "}"
-      end
-
-      # Emit a separator before every entry except the first.
-      def comma
-        if @first
-          @first = false
-        else
-          @buf = @buf + ","
-        end
-      end
-
-      # ---- self-contained string escaping (byte-identical to
-      #      SpinelKit::Json.escape/quote/hex2; kept local so a builder-only
-      #      compile never pulls in the codec) ----
-
-      # Wrap a string in JSON quotes, escaping its body.
-      def self.quote(s)
-        "\"" + Builder.escape(s) + "\""
-      end
-
-      # Escape a string for inclusion inside a JSON string literal (no
-      # surrounding quotes). Handles ", \, and the JSON control-char escapes
-      # (\b \f \n \r \t); other control bytes go through \u00XX. ASCII-clean
-      # input passes through unchanged.
-      def self.escape(s)
-        out = ""
-        i = 0
-        n = s.length
-        while i < n
-          c = s[i]
-          if c == "\""
-            out = out + "\\\""
-          elsif c == "\\"
-            out = out + "\\\\"
-          elsif c == "\n"
-            out = out + "\\n"
-          elsif c == "\r"
-            out = out + "\\r"
-          elsif c == "\t"
-            out = out + "\\t"
-          elsif c == "\b"
-            out = out + "\\b"
-          elsif c == "\f"
-            out = out + "\\f"
-          elsif c < " "
-            b = c.getbyte(0)
-            out = out + "\\u00" + Builder.hex2(b)
-          else
-            out = out + c
-          end
-          i += 1
-        end
-        out
-      end
-
-      # Two-digit lowercase hex of a byte (0..255).
-      def self.hex2(n)
-        hex = "0123456789abcdef"
-        out = ""
-        out = out + hex[(n / 16) % 16, 1]
-        out = out + hex[n % 16, 1]
-        out
-      end
-    end
-  end
-end

data/lib/spinel_kit/json_decoder.rb

@@ -1,394 +0,0 @@
-# SpinelKit::Json -- Spinel-safe JSON DECODERS (flat-key, top-level only).
-#
-# The decode half of the codec; encoders are in spinel_kit/json.rb. Split out
-# so an encode-only consumer never compiles these walkers (their dead-code
-# degradation otherwise widens the encoders' string args to int -- see the
-# header of json.rb and docs/spinel-discipline.md).
-#
-# `get_str(s, key)` finds the entry for `key` in the top-level object literal
-# `s` and returns its value as a string. Returns "" when `key` is absent or
-# the value isn't a string. Same shape for `get_int`. `has_key?(s, key)`
-# returns a boolean independent of value type. The parser is a hand-rolled
-# state machine that walks one `{ "k": <value>, ... }` pair at a time,
-# skipping over any value (including nested objects / arrays) it doesn't need.
-# Strings inside values are honoured for escape sequences so that `\"` doesn't
-# terminate the string and corrupt the walk. Decodes the escape sequences
-# `SpinelKit::Json.escape` produces.
-module SpinelKit
-  class Json
-    def self.get_str(s, key)
-      pos = Json.find_value_start(s, key)
-      if pos < 0
-        return ""
-      end
-      Json.parse_str_value(s, pos)
-    end
-
-    def self.get_int(s, key)
-      pos = Json.find_value_start(s, key)
-      if pos < 0
-        return 0
-      end
-      Json.parse_int_value(s, pos)
-    end
-
-    # Decode a JSON number value at `key` -> Float. Accepts both
-    # integer-literal (`42`) and float-literal (`3.14`, `-0.5`, `1e2`)
-    # JSON-number syntax; the integer form returns N.0. Missing key or
-    # malformed value returns 0.0 (consistent with the other getters'
-    # missing-key defaults).
-    #
-    # Implementation: delegates the value-span walking to skip_value (already
-    # handles all JSON-number syntax + structural-char boundaries), then
-    # String#to_f on the substring. Inlined rather than factored into a
-    # parse_float_value helper because spinel's type inference mis-widens `s`
-    # to int through the indirection. NOTE: that is a value-walk indirection
-    # concern, NOT the name-collision bug (which was fixed) -- keep it inlined.
-    def self.get_float(s, key)
-      pos = Json.find_value_start(s, key)
-      if pos < 0
-        return 0.0
-      end
-      pos = Json.skip_ws(s, pos)
-      if pos >= s.length
-        return 0.0
-      end
-      end_pos = Json.skip_value(s, pos)
-      if end_pos <= pos
-        return 0.0
-      end
-      s[pos, end_pos - pos].to_f
-    end
-
-    def self.has_key?(s, key)
-      Json.find_value_start(s, key) >= 0
-    end
-
-    # Decode a flat JSON array of integers at `key` -> Array[Integer].
-    # A missing or non-array value yields [] (the typed-empty-array idiom);
-    # non-int elements are skipped.
-    def self.get_int_array(s, key)
-      out = [0]
-      out.delete_at(0)
-      pos = Json.find_value_start(s, key)
-      if pos < 0
-        return out
-      end
-      pos = Json.skip_ws(s, pos)
-      if pos >= s.length || s[pos] != "["
-        return out
-      end
-      pos += 1
-      while pos < s.length
-        pos = Json.skip_ws(s, pos)
-        if pos >= s.length
-          return out
-        end
-        c = s[pos]
-        if c == "]"
-          return out
-        elsif c == ","
-          pos += 1
-        elsif (c >= "0" && c <= "9") || c == "-"
-          out.push(Json.parse_int_value(s, pos))
-          # Advance past the number parse_int_value just consumed
-          # (optional '-' then digits).
-          if s[pos] == "-"
-            pos += 1
-          end
-          while pos < s.length && s[pos] >= "0" && s[pos] <= "9"
-            pos += 1
-          end
-        else
-          # Non-int element (string / object / etc.): skip it.
-          pos = Json.skip_value(s, pos)
-        end
-      end
-      out
-    end
-
-    # ---- Internal helpers ----
-
-    # Skip whitespace starting at `pos`, return the new position.
-    def self.skip_ws(s, pos)
-      while pos < s.length
-        c = s[pos]
-        if c == " " || c == "\t" || c == "\n" || c == "\r"
-          pos += 1
-        else
-          return pos
-        end
-      end
-      pos
-    end
-
-    # Walk a JSON-quoted string starting at `pos` (which must point at the
-    # opening `"`). Returns the position one past the closing `"`. Returns
-    # -1 on malformed input.
-    def self.skip_str(s, pos)
-      if pos >= s.length || s[pos] != "\""
-        return -1
-      end
-      pos += 1
-      while pos < s.length
-        c = s[pos]
-        if c == "\\"
-          # Skip the escape and the escaped character. \uXXXX spans 6
-          # chars total but skipping 2 still keeps us inside the string
-          # for the rest of the walk -- the remaining 4 hex digits look
-          # like ordinary string bytes and won't terminate the literal.
-          pos += 2
-        elsif c == "\""
-          return pos + 1
-        else
-          pos += 1
-        end
-      end
-      -1
-    end
-
-    # Walk a JSON value starting at `pos` (which must point at the first
-    # non-ws char of the value). Returns the position one past the value
-    # (or the input length on truncation).
-    def self.skip_value(s, pos)
-      pos = Json.skip_ws(s, pos)
-      if pos >= s.length
-        return pos
-      end
-      c = s[pos]
-      if c == "\""
-        return Json.skip_str(s, pos)
-      end
-      if c == "{" || c == "["
-        return Json.skip_container(s, pos)
-      end
-      # number / true / false / null -- read until the next structural /
-      # whitespace char.
-      while pos < s.length
-        c = s[pos]
-        if c == "," || c == "}" || c == "]" ||
-           c == " " || c == "\t" || c == "\n" || c == "\r"
-          return pos
-        end
-        pos += 1
-      end
-      pos
-    end
-
-    # Walk a balanced { ... } or [ ... ] starting at `pos`. Honours string
-    # literals so that `{` / `}` inside a value-string don't confuse the
-    # brace counter. Returns position one past the matching closer.
-    def self.skip_container(s, pos)
-      open_c = s[pos]
-      close_c = open_c == "{" ? "}" : "]"
-      depth = 1
-      pos += 1
-      while pos < s.length && depth > 0
-        c = s[pos]
-        if c == "\""
-          # whole nested string -- skip past it
-          npos = Json.skip_str(s, pos)
-          if npos < 0
-            return s.length
-          end
-          pos = npos
-        elsif c == open_c
-          depth += 1
-          pos += 1
-        elsif c == close_c
-          depth -= 1
-          pos += 1
-        else
-          pos += 1
-        end
-      end
-      pos
-    end
-
-    # Read a JSON-quoted string at `pos` and return its decoded contents
-    # (no surrounding quotes). Decodes the same escape sequences that
-    # `escape` produces. Returns "" on malformed input.
-    def self.parse_str_value(s, pos)
-      pos = Json.skip_ws(s, pos)
-      if pos >= s.length || s[pos] != "\""
-        return ""
-      end
-      pos += 1
-      out = ""
-      while pos < s.length
-        c = s[pos]
-        if c == "\""
-          return out
-        end
-        if c == "\\"
-          if pos + 1 >= s.length
-            return out
-          end
-          esc = s[pos + 1]
-          if esc == "\""
-            out = out + "\""
-          elsif esc == "\\"
-            out = out + "\\"
-          elsif esc == "/"
-            out = out + "/"
-          elsif esc == "n"
-            out = out + "\n"
-          elsif esc == "r"
-            out = out + "\r"
-          elsif esc == "t"
-            out = out + "\t"
-          elsif esc == "b"
-            out = out + "\b"
-          elsif esc == "f"
-            out = out + "\f"
-          elsif esc == "u"
-            # \u00XX -> map the two-digit hex back to a byte. Wider
-            # codepoints (U+0100+ or surrogate pairs) aren't decoded; the
-            # byte we emit is the low byte of the codepoint, which
-            # round-trips ASCII at minimum.
-            if pos + 5 < s.length
-              h1 = Json.hex_nibble(s[pos + 4])
-              h2 = Json.hex_nibble(s[pos + 5])
-              if h1 >= 0 && h2 >= 0
-                # rebuild the byte and push it -- spinel strings are
-                # byte-blobs, so this works for ASCII; for non-ASCII the
-                # original encoder would have used a passthrough byte
-                # anyway.
-                b = h1 * 16 + h2
-                out = out + Json.byte_to_chr(b)
-                pos += 6
-                next
-              end
-            end
-            out = out + "?"
-            pos += 2
-            next
-          else
-            out = out + esc
-          end
-          pos += 2
-        else
-          out = out + c
-          pos += 1
-        end
-      end
-      out
-    end
-
-    def self.hex_nibble(c)
-      if c >= "0" && c <= "9"
-        return c.getbyte(0) - "0".getbyte(0)
-      end
-      if c >= "a" && c <= "f"
-        return c.getbyte(0) - "a".getbyte(0) + 10
-      end
-      if c >= "A" && c <= "F"
-        return c.getbyte(0) - "A".getbyte(0) + 10
-      end
-      -1
-    end
-
-    # Build a single-byte string from an integer 0..255. Spinel doesn't
-    # expose `n.chr` for arbitrary bytes uniformly; the table covers the
-    # ASCII printable range and falls back to "?" for anything else (the
-    # JSON encoder side never produces non-ASCII via \u, so the fallback
-    # is reachable only for malformed input).
-    def self.byte_to_chr(n)
-      printable = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
-      if n >= 32 && n < 127
-        return printable[n - 32, 1]
-      end
-      if n == 9
-        return "\t"
-      end
-      if n == 10
-        return "\n"
-      end
-      if n == 13
-        return "\r"
-      end
-      "?"
-    end
-
-    # Read an integer at `pos`. Accepts an optional leading `-`. Returns 0
-    # on no-digit / non-numeric input (caller can use `has_key?` first if
-    # 0-vs-absent matters).
-    def self.parse_int_value(s, pos)
-      pos = Json.skip_ws(s, pos)
-      if pos >= s.length
-        return 0
-      end
-      neg = false
-      if s[pos] == "-"
-        neg = true
-        pos += 1
-      end
-      n = 0
-      saw_digit = false
-      while pos < s.length
-        c = s[pos]
-        if c >= "0" && c <= "9"
-          n = n * 10 + (c.getbyte(0) - "0".getbyte(0))
-          saw_digit = true
-          pos += 1
-        else
-          break
-        end
-      end
-      if !saw_digit
-        return 0
-      end
-      neg ? -n : n
-    end
-
-    # Walk the top-level object looking for the entry whose key matches
-    # `target_key`; return the position of the value's first non-ws
-    # character. Returns -1 if not found.
-    def self.find_value_start(s, target_key)
-      pos = Json.skip_ws(s, 0)
-      if pos >= s.length || s[pos] != "{"
-        return -1
-      end
-      pos += 1
-      while pos < s.length
-        pos = Json.skip_ws(s, pos)
-        if pos >= s.length
-          return -1
-        end
-        if s[pos] == "}"
-          return -1
-        end
-        # Read a key.
-        if s[pos] != "\""
-          return -1
-        end
-        key_start = pos
-        pos = Json.skip_str(s, pos)
-        if pos < 0
-          return -1
-        end
-        # Decode the key for comparison (handles \" inside keys).
-        key = Json.parse_str_value(s, key_start)
-        # Skip ws, ":".
-        pos = Json.skip_ws(s, pos)
-        if pos >= s.length || s[pos] != ":"
-          return -1
-        end
-        pos += 1
-        pos = Json.skip_ws(s, pos)
-        if key == target_key
-          return pos
-        end
-        # Skip the value, then the comma (if any).
-        pos = Json.skip_value(s, pos)
-        pos = Json.skip_ws(s, pos)
-        if pos < s.length && s[pos] == ","
-          pos += 1
-        elsif pos < s.length && s[pos] == "}"
-          return -1
-        end
-      end
-      -1
-    end
-  end
-end

data/lib/spinel_kit/version.rb

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

data/lib/spinel_kit.rb

@@ -1,45 +0,0 @@
-# SpinelKit -- 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
-# (the Ruby->native AOT compiler) cannot lower large chunks of CRuby stdlib
-# -- the `json` gem's C-ext fast path and metaprogrammed pure-Ruby fallback,
-# stdlib `Logger`, C-ext git bindings -- and the spinelgems compatibility
-# catalog confirms there is no verified gem to reuse for any of them. So this
-# gem consolidates the shims toy and tep each grew independently:
-#
-#   SpinelKit::Json          -- JSON encoders (json.rb) + flat-key decoders
-#                               (json_decoder.rb).
-#   SpinelKit::Json::Builder -- incremental ordered-object builder.
-#   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).
-#
-# 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/json"          # encoders
-#   require "spinel_kit/json_decoder"  # decoders (require alongside json if you decode)
-#   require "spinel_kit/json_builder"  # builder
-#   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/json"
-require_relative "spinel_kit/json_decoder"
-require_relative "spinel_kit/json_builder"
-require_relative "spinel_kit/hex"
-require_relative "spinel_kit/url"
-require_relative "spinel_kit/git"
-require_relative "spinel_kit/log"
-
-module SpinelKit
-end

data/sig/spinel_kit/json.rbs

@@ -1,15 +0,0 @@
-# Advisory RBS for SpinelKit::Json encoders (lib/spinel_kit/json.rb).
-# Decoders are in json_decoder.rbs; the builder in json_builder.rbs.
-module SpinelKit
-  class Json
-    def self.escape: (String s) -> String
-    def self.hex2: (Integer n) -> String
-    def self.quote: (String s) -> String
-    def self.encode_pair_str: (String k, String v) -> String
-    def self.encode_pair_int: (String k, Integer v) -> String
-    def self.from_str_hash: (Hash[String, String] h) -> String
-    def self.from_int_hash: (Hash[String, Integer] h) -> String
-    def self.from_str_array: (Array[String] a) -> String
-    def self.from_int_array: (Array[Integer] a) -> String
-  end
-end

data/sig/spinel_kit/json_builder.rbs

@@ -1,19 +0,0 @@
-module SpinelKit
-  class Json
-    class Builder
-      def initialize: () -> void
-      def add_str: (String key, String value) -> String
-      def add_num: (String key, untyped value) -> String
-      def add_bool: (String key, bool value) -> String
-      def add_raw: (String key, String raw) -> String
-      def add_obj: (String key, SpinelKit::Json::Builder child) -> String
-      def dump: () -> String
-      def comma: () -> void
-
-      # self-contained escapers (byte-identical to SpinelKit::Json.*)
-      def self.quote: (String s) -> String
-      def self.escape: (String s) -> String
-      def self.hex2: (Integer n) -> String
-    end
-  end
-end

data/sig/spinel_kit/json_decoder.rbs

@@ -1,21 +0,0 @@
-# Advisory RBS for SpinelKit::Json decoders (lib/spinel_kit/json_decoder.rb).
-module SpinelKit
-  class Json
-    def self.get_str: (String s, String key) -> String
-    def self.get_int: (String s, String key) -> Integer
-    def self.get_float: (String s, String key) -> Float
-    def self.get_int_array: (String s, String key) -> Array[Integer]
-    def self.has_key?: (String s, String key) -> bool
-
-    # internal walkers
-    def self.skip_ws: (String s, Integer pos) -> Integer
-    def self.skip_str: (String s, Integer pos) -> Integer
-    def self.skip_value: (String s, Integer pos) -> Integer
-    def self.skip_container: (String s, Integer pos) -> Integer
-    def self.parse_str_value: (String s, Integer pos) -> String
-    def self.hex_nibble: (String c) -> Integer
-    def self.byte_to_chr: (Integer n) -> String
-    def self.parse_int_value: (String s, Integer pos) -> Integer
-    def self.find_value_start: (String s, String target_key) -> Integer
-  end
-end