tep 0.11.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 01e96933540bed51cfb5ef9b6edd91154c63d60bf2469eece6e1fbfff42815d5
+  data.tar.gz: 47005866b1f57933b4724c19eb1e387b2d3f0d9e52003cc0d155795ed522977a
+SHA512:
+  metadata.gz: 58cbe7986525f4eedd43a6b2e603dca7545a8b7d46d0b241a175e451bbcb9ee8d29e1de0e7b8d323f8cee75d93f4ce24a1f8344593affad0534c71f182f7f442
+  data.tar.gz: 0f31fe5463c71bef2ee00a1507ff2b9a4c45c49023810e3e2a206e10737b6f794bf89c2b09d1eebf3c23b05321f143bc652b117cf4493e4bf259c2f14bf3861e

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ori Pekelman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Makefile

@@ -0,0 +1,134 @@
+TEP_ROOT  := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+LIB_DIR   := $(TEP_ROOT)/lib/tep
+SPINEL    ?= spinel
+TEP       := $(TEP_ROOT)/bin/tep
+
+# Exported so bin/tep injects the right path into the @TEP_SPHTTP_O@
+# / @TEP_SQLITE_O@ / @TEP_PG_O@ placeholders inside net.rb / sqlite.rb /
+# pg.rb. Override either env var to point at a pre-built .o (useful
+# when the source tree isn't writable). Crypto symbols (sp_crypto_*)
+# live in spinel's libspinel_rt.a since matz/spinel#514, no separate
+# .o needed.
+export TEP_SPHTTP_O := $(LIB_DIR)/sphttp.o
+export TEP_SQLITE_O := $(LIB_DIR)/tep_sqlite.o
+export TEP_PG_O     := $(LIB_DIR)/tep_pg.o
+export SPINEL
+
+# libpq cflags / libs. pkg-config is the preferred path (libpq ships
+# a .pc file on Linux + Homebrew); pg_config is the fallback for
+# stripped-down hosts.
+#
+# NB: `pg_config --cflags` returns the cflags PostgreSQL itself was
+# built with (warning flags, -O2, ...), NOT the cflags a libpq
+# CONSUMER needs. We want -I<includedir>; the consumer cflags are
+# constructed from `pg_config --includedir`. Same for -L from
+# `--libdir`. If neither lookup finds libpq, both vars stay empty
+# and the compile fails at link time with "cannot find -lpq" --
+# the right loud failure for "you wanted Tep::PG but didn't install
+# libpq".
+TEP_PG_CFLAGS ?= $(shell \
+    pkg-config --cflags libpq 2>/dev/null || \
+    pg_config --includedir 2>/dev/null | sed -e 's|^|-I|')
+TEP_PG_LIBS   ?= $(shell \
+    pkg-config --libs libpq 2>/dev/null || \
+    (pg_config --libdir 2>/dev/null | sed -e 's|^|-L|' ; echo "-lpq") | tr '\n' ' ')
+export TEP_PG_CFLAGS TEP_PG_LIBS
+
+.PHONY: all clean helper hello sinatra_style bench bench-tep bench-sinatra demo test test-parallel spinel-fresh test-pg vendor-examples
+
+# Vendor each gem example's Gemfile-declared dependencies via
+# bundler-spinel (spinel-compat vendor, from $(SPINELGEMS)) into
+# examples/<x>/vendor/spinel -- where bin/tep follows the generated
+# deps.rb. This is how a tep app uses a real published gem: declare it in
+# a Gemfile, let spinelgems resolve + place it, require_relative the
+# deps. Run inside the dev container (mounts /spinelgems, sets SPINELGEMS)
+# or point SPINELGEMS at a spinelgems checkout. Regenerated from the
+# committed Gemfile.lock; the output is gitignored.
+SPINELGEMS ?= ../spinelgems
+vendor-examples:
+	@for d in examples/*/; do \
+	  [ -f "$$d/Gemfile.lock" ] || continue; \
+	  echo "vendor: $$d"; \
+	  ( cd "$$d" && ruby -I "$(SPINELGEMS)/lib" "$(SPINELGEMS)/exe/spinel-compat" vendor ) || exit 1; \
+	done
+
+# Always check that the local spinel checkout is on tip-of-master
+# before we build / test against it -- spinel moves quickly and a
+# stale binary is a fast way to chase ghost regressions. Skip with
+# `TEP_SKIP_SPINEL_FRESH=1`; override the spinel location with
+# `TEP_SPINEL_DIR`.
+spinel-fresh:
+	@$(TEP_ROOT)/tools/spinel-fresh.sh
+
+all: spinel-fresh helper hello sinatra_style bench
+
+helper: spinel-fresh $(LIB_DIR)/sphttp.o $(LIB_DIR)/tep_sqlite.o $(LIB_DIR)/tep_pg.o
+
+$(LIB_DIR)/sphttp.o: $(LIB_DIR)/sphttp.c
+	cc -O2 -c $< -o $@
+
+$(LIB_DIR)/tep_sqlite.o: $(LIB_DIR)/tep_sqlite.c
+	cc -O2 -c $< -o $@
+
+$(LIB_DIR)/tep_pg.o: $(LIB_DIR)/tep_pg.c
+	cc -O2 -c $(TEP_PG_CFLAGS) $< -o $@
+
+hello: helper
+	$(TEP) build examples/hello.rb
+
+sinatra_style: helper
+	$(TEP) build examples/sinatra_style.rb
+
+bench: bench-tep
+
+bench-tep: helper
+	$(TEP) build bench/hello_bench.rb
+	$(TEP) build bench/api_bench.rb
+	$(TEP) build bench/pg_bench.rb
+
+bench-sinatra:
+	cd bench && bundle _2.7.2_ install --quiet
+
+demo: hello
+	./examples/hello
+
+test: helper
+	@pkill -f tep-test 2>/dev/null; true
+	ruby test/run_all.rb
+
+# `make test-parallel` -- dev fast loop. Runs each test/test_*.rb in
+# its own process in parallel (sidestepping the harness's "one thread
+# per class" constraint), with per-process port-base allocation. Cuts
+# wall time roughly by core count on the gx10 (~13min serial ->
+# ~1-2min). `make test` stays serial -- the canonical / CI path with
+# clean output ordering. Cap with TEP_TEST_PROCS=N.
+test-parallel: helper
+	@pkill -f tep-test 2>/dev/null; true
+	ruby test/run_parallel.rb
+
+# `make test-pg` -- runs test/test_pg.rb against a real PostgreSQL.
+# Reads PG_TEST_URL from the environment if set; otherwise expects
+# the caller to have a PG reachable at the default libpq path.
+# Without PG_TEST_URL the test class skips cleanly (so `make test`
+# is unaffected by Postgres availability).
+#
+# Recipe to spin up a throwaway PG via docker:
+#
+#   docker run -d --rm --name tep_test_pg -p 54329:5432 \
+#     -e POSTGRES_PASSWORD=postgres postgres:16
+#   until docker exec tep_test_pg pg_isready -U postgres | grep -q accepting; do sleep 1; done
+#   PG_TEST_URL='postgresql://postgres:postgres@127.0.0.1:54329/postgres' make test-pg
+#   docker stop tep_test_pg
+test-pg: helper
+	@pkill -f tep-test 2>/dev/null; true
+	ruby test/test_pg.rb
+
+clean:
+	rm -f $(LIB_DIR)/*.o
+	rm -f examples/hello examples/sinatra_style examples/diag
+	rm -f examples/.*.tep.rb
+	rm -f bench/hello_bench bench/api_bench bench/.*.tep.rb
+	rm -f test/real_world/.*.tep.rb
+	# Compiled binaries in test/real_world/ have no extension; sources
+	# are .rb. Find executables and remove only those.
+	@find test/real_world -maxdepth 1 -type f -perm -u+x ! -name '*.rb' -delete 2>/dev/null || true

data/README.md

@@ -0,0 +1,247 @@
+<p align="center">
+  <img src="logo/tep.png" alt="Tep — Spinal Tap of web frameworks" width="240">
+</p>
+
+# Tep
+
+A Sinatra-flavoured web framework that compiles to a native binary
+via [Spinel][spinel].
+
+> **Current release:** [v0.10.0](https://github.com/OriPekelman/tep/releases/tag/v0.10.0)
+> — the Proxy + OpenAI-server + Events batteries on top of the agentic
+> surface (Auth, Broadcast, Presence, LiveView, MCP).
+> Pre-alpha; API still in motion.
+
+> **Why Tep exists.** Two complementary goals:
+>
+> 1. **Exercise Spinel against real-world Ruby code.** Tep is the
+>    largest pure-Ruby application Spinel compiles end-to-end. Every
+>    Sinatra idiom, every battery, every demo doubles as a torture
+>    test for the AOT compiler's codegen + analyzer. Bugs surface
+>    here, get reduced to minimal repros, and land upstream as PRs
+>    or issues against [matz/spinel](https://github.com/matz/spinel).
+>    If something doesn't work in Tep, the bug is usually in Spinel,
+>    and that's the point.
+>
+> 2. **Be the harness for [toy][toy].** Toy is Tep's sibling
+>    project: a machine-learning framework written in pure Ruby and
+>    compiled by Spinel. Toy needs an HTTP/MCP layer for serving
+>    models, exposing training tools to agents (Claude Code et al.),
+>    streaming inference results, and wiring presence into
+>    collaborative training sessions. Tep is that layer. Every
+>    battery in Tep is shaped by what Toy actually needs to ship.
+>
+> Tep happens to be useful as a general web framework too — fast,
+> single-binary, Sinatra-shaped — but the design choices are made
+> through these two lenses.
+
+[toy]: https://github.com/OriPekelman/toy
+
+## Quick start
+
+```sh
+# 1. install Spinel
+git clone https://github.com/matz/spinel
+cd spinel && make all
+export PATH="$PWD:$PATH"
+
+# 2. install Tep
+git clone https://github.com/OriPekelman/tep
+cd tep && make all
+./examples/hello -p 4567
+```
+
+Your own app:
+
+```ruby
+# hello.rb
+require 'sinatra'
+
+get '/' do
+  "hello from Tep"
+end
+
+get '/hi/:name' do
+  "hi, " + params[:name] + "!"
+end
+```
+
+```sh
+tep build hello.rb       # -> ./hello (~80 KB binary, no Ruby runtime)
+./hello -p 4567
+```
+
+The translator (`bin/tep`) needs CRuby >= 3.2 with the `prism` gem
+installed (a development-only dependency — `bundle install` brings it
+in). Prism ships with the stdlib from 3.4 onward; on 3.2/3.3 it's a
+gem install. Recommended Ruby manager:
+[`rv`](https://github.com/spinel-coop/rv) — fast version+gem
+manager from the Spinel Cooperative (separate project from the
+matz/spinel AOT compiler Tep compiles through; same Ruby
+neighbourhood). `.ruby-version` in this repo pins 3.4.0; `rv
+shell` makes `rv run rake test` just work. Build deps on Linux:
+`build-essential`, `libsqlite3-dev`. macOS: Xcode CLI tools.
+
+For a full walkthrough — auth, persistence, deploy — see the
+[Getting started](https://github.com/OriPekelman/tep/wiki/Getting-Started)
+wiki page.
+
+## Is it fast?
+
+Yes. ~150k req/s on a small Linux server with the request path doing
+actual work (SQLite SELECT + JSON), microsecond median latency. The
+hot path is C from end to end (epoll, request parsing, dispatch,
+response writer); the Ruby you wrote is compiled, not interpreted.
+HTTP/1.1 keep-alive and prefork with `SO_REUSEPORT` are the usual
+wins applied.
+
+Two scenarios, both `wrk -t8 -c256 -d10s` on Linux 6.x / aarch64,
+8 workers a side (Sinatra: 8 workers × 4 threads):
+
+| Scenario                | Server         | Req/sec | p50    | p99    |
+|-------------------------|----------------|--------:|-------:|-------:|
+| **hello** (raw plumbing)| Tep            | 167,150 |  40 µs | <1 ms  |
+| hello                   | Sinatra + Puma |  31,184 |  40 ms | 171 ms |
+| **api** (SQLite + JSON) | Tep            | 145,290 |  43 µs | 243 µs |
+| api                     | Sinatra + Puma |  24,926 | 1.8 ms | 171 ms |
+
+Numbers are conservative floors; a clean re-run on a quiet host is
+expected to come in higher. Reproduce with `bench/run_all.sh`.
+
+> **macOS note.** Linux is Tep's primary deployment target. Builds
+> and runs on macOS too, but Darwin's `SO_REUSEPORT` doesn't load-
+> balance new connections across prefork workers — a single long-
+> running response on the busy worker blocks every other request on
+> the same listener. On Linux 3.9+ the kernel distributes accepts
+> correctly, so prefork scales as the table above. The path forward
+> for tep apps that need real concurrency on macOS is
+> `Tep::Server::Scheduled` (one worker, fibers per connection) + a
+> cooperative `Tep::Http` — design + phases in
+> [`docs/MACOS-CONCURRENCY.md`](docs/MACOS-CONCURRENCY.md).
+
+## What's in the box
+
+Sinatra-shaped routing, filters, responses, templates, sessions,
+plus a collection of "batteries" — pure-Tep modules that cover the
+gem ecosystem's most common needs in a way that lowers cleanly
+through Spinel.
+
+| Battery          | What it covers |
+|------------------|---|
+| `Tep::SQLite`    | libsqlite3 wrapper via a small C shim — exec / prepare / bind / step / col / first_str / first_int. |
+| `Tep::Json`      | encode primitives + flat-key decoder for JSON-over-HTTP. |
+| `Tep::Logger`    | levelled logger (debug/info/warn/error), stderr or file. |
+| `Tep::Jwt`       | HS256 JWT encode / verify / decode. |
+| `Tep::Password`  | PBKDF2-SHA256, 200k iters, self-describing storage. |
+| `Tep::Security`  | `Cors` (before-filter) + `Headers` (HSTS, nosniff, ...). |
+| `Tep::Assets`    | compile-time bundling for `<app>/assets/*`. |
+| `Tep::Scheduler` | cooperative fiber scheduler with timer + I/O parking. |
+| `Tep::Shell`     | popen-based shell-out + small-file reader (`/proc`, `/sys`, `/etc`). |
+| `Tep::Http`      | Faraday-shaped outbound HTTP/1.0 client. |
+| `Tep::Llm`       | ruby-openai-shaped chat-completions client; backends interchangeable via base_url (Ollama / OpenAI / [toy](https://github.com/OriPekelman/toy)). Sync `chat()` + SSE `chat_stream()`. |
+| `Tep::Llm::OpenAI::Server` | The other side of the OpenAI fence — serve OpenAI-compatible HTTP from local compute. Subclass `Tep::Llm::OpenAI::Backend`, wire `Server.use(MyBackend.new)` + `Server.serve!(events_jsonl)`, get `/v1/models` + `/v1/completions` (non-streaming + SSE with `"stream": true`) + toy/v1 events out of the box. `/v1/embeddings` lives app-side (the lib stays float-free); see [`docs/OPENAI-SERVER-BATTERY.md`](docs/OPENAI-SERVER-BATTERY.md). |
+| `Tep::Proxy`     | Sinatra-flavored reverse proxy. Subclass `Tep::Proxy`, override `rewrite_path` / `before_forward` / `after_forward` (non-streaming), or `stream_request?` / `on_stream_chunk` / `on_stream_end` (SSE / chunked pass-through). Block-form DSL — `proxy.before_forward do \|req, res, ureq\| ... end` — lowers to a synthesized subclass; see [`docs/PROXY-BATTERY.md`](docs/PROXY-BATTERY.md). |
+| `Tep::Events`    | toy/v1 JSONL emitter (`run_start` / `inference` / `run_end`). Float-free by design — caller hands in integer `wall_us`, schema-side floats live in caller-built `extra_json`. The OpenAI-server battery wires it automatically; standalone for any per-request telemetry stream. |
+| `Tep::WebSocket` | RFC 6455 server-side WebSocket. `websocket '/chat' do \|ws\| ... end` DSL lowers to Frame + Handshake + Driver + Connection. Requires `set :scheduler, :scheduled`. |
+| `Tep::Parallel`  | grosser/parallel-shaped fork fan-out. |
+| `Tep::Job`       | sidekiq-shaped queue over SQLite. |
+| `PG`             | ruby-pg-shape libpq client: `PG::Connection`, `PG::Result`, `PG::Error`; surface mirrors the `pg` gem (`exec` / `exec_params` / `escape_*` / `fields` / `values` / `getvalue` / `sql_state`). Designed so an eventual ActiveRecord-on-spinel port reuses the existing AR adapter with minimal divergence — see `docs/PG-BATTERY.md`. |
+| `Tep::Auth`      | Principal+delegate identity (`Tep::Identity` / `Tep::AgentDelegation`) + provider chain. Three providers shipped: `Tep::AuthBearerToken` (JWT-HS256), `Tep::AuthSessionCookie` (signed cookie), `Tep::AuthOAuth2` (authorization-code grant issuance for bots/agents). Same `req.identity` surface regardless of provider; agents are first-class (`identity.agent?`, `identity.acting_via.agent_id`, capability subsetting). |
+| `Tep::Broadcast` | In-process pub-sub + cross-worker via PG LISTEN/NOTIFY. Subscribe an fd to a topic (`subscribe` raw, `subscribe_ws` WS-frame-wrapped); publish writes to every matching subscriber. The seam Presence and LiveView build on. |
+| `Tep::Presence`  | Topic-keyed who's-here registry, agent-aware. `Tep::Presence.track(req, topic, fd)` records a (principal, session, topic) tuple with a 3-state structured status (`:available | :busy | :blocked` + free-text note + expiry). Diffs broadcast on join/leave/status; PG-mirror for cross-worker `list_global` snapshots. |
+| `Tep::LiveView`  | Phoenix.LiveView-shape server-rendered stateful UI over WebSocket. Subclass `Tep::LiveView`, override `render` + `handle_event` + (optionally) `handle_presence_diff`; `broadcast_render` fans the new HTML out to every subscribed viewer. Bootstrap client (~10 lines of inline JS) ships in `Tep::LiveView.render_page`. |
+| `Tep::MCP`       | Tool catalog for the agent-as-driver role. `mcp_tool 'name', "desc" do; param :foo, Type, "..."; on_call do; ...; end; end` registers a tool both at `POST /tools/<name>` (HTTP-direct) and through a JSON-RPC 2.0 dispatcher at `POST /mcp` (MCP-native — Claude Code / OpenCode / Gravity CLI). `GET /llms.txt` auto-publishes the catalog. See [`docs/MCP-BATTERY.md`](docs/MCP-BATTERY.md). Chunk 5.1; `mcp_resource` + streaming + OpenAPI in 5.2–5.4. |
+
+Per-battery API docs and cookbooks live on the
+[wiki](https://github.com/OriPekelman/tep/wiki). The full
+Sinatra-compatibility matrix is in
+[SINATRA_COMPAT.md](SINATRA_COMPAT.md).
+
+The last four batteries (`Tep::Auth`, `Tep::Broadcast`,
+`Tep::Presence`, `Tep::LiveView`) ship a small framework for
+"web apps in a live agentic age" — `req.identity` is always a
+principal+delegate pair so agents acting on behalf of humans
+are first-class through every battery. The end-to-end design
++ a realistic chat-room scenario walked through every seam
+lives in [`docs/BATTERIES-DESIGN.md`](docs/BATTERIES-DESIGN.md).
+
+430 tests pass `make test` (serial, ~13 min on the gx10) or `make test-parallel` (subprocess fan-out, ~4 min — see [`test/run_parallel.rb`](test/run_parallel.rb)). End-to-end demos that build and run:
+
+- **[`examples/counter/`](examples/counter/app.rb)** — the
+  smallest `Tep.live` demo. Shared integer counter; click in one
+  tab, every other tab updates in <100ms. ~80 lines of Ruby + CSS,
+  no JS to write (the bootstrap shell wires `data-event` clicks
+  through the WS).
+- **[`examples/experiments/`](examples/experiments/app.rb)** —
+  the `Tep::MCP` battery demo. Mock training-run manager driven
+  by an MCP client (Claude Code / OpenCode / Gravity): 4 tools,
+  2 resources, capability gating, auto-published `/llms.txt` +
+  `/openapi.json` + `/mcp` JSON-RPC. ~200 lines of Ruby plus an
+  `AGENTS.md` worked example.
+- **[`examples/agentic_chat/`](examples/agentic_chat/app.rb)** —
+  the four-battery agentic demo. Sub-second WS push, multi-user
+  chat, agent-spawn with OAuth2-style delegation. ~270 lines.
+- **[`examples/chatbot/`](examples/chatbot/app.rb)** — minimalistic
+  OpenWebUI-style client backed by any OpenAI-compatible endpoint
+  (Ollama / OpenAI / [toy](https://github.com/OriPekelman/toy)'s `toy serve`)
+  exercising the full pre-agentic battery surface
+  (`Tep::Server::Scheduled` + `Tep::Llm` + `Tep::SQLite` +
+  `Tep::Streamer` + `Tep::Session` + `Tep::Password` + `Tep::Jwt` +
+  `Tep::Security::{Cors,Headers}` + `Tep::Assets` + `Tep::Json` +
+  `Tep::Job` + `Tep::Logger`) in ~1500 lines of Ruby + HTML + CSS + JS.
+- **[`examples/llm_gateway/`](examples/llm_gateway/app.rb)** — the
+  `Tep::Proxy` streaming demo. Block-form DSL gateway in front of an
+  OpenAI-compatible upstream; pumps SSE token deltas straight through
+  to the client and emits one `Tep::Events` `inference` event per
+  completed stream.
+- **[`examples/api_gateway/`](examples/api_gateway/app.rb)** — the
+  buffered-proxy demo. Capability-gated forwarding with `before_forward`
+  + `after_forward` observability hooks; same DSL, non-streaming.
+- **[`examples/websocket_echo.rb`](examples/websocket_echo.rb)** —
+  `Tep::WebSocket` in isolation; `test/test_websocket_echo.rb`
+  performs a real RFC 6455 handshake over a raw socket and
+  round-trips a masked TEXT frame.
+
+### Type signatures (RBS)
+
+`sig/` ships [RBS](https://github.com/ruby/rbs) signatures for tep's
+public surface, mirroring `lib/tep/`. They're for IDE tooling today
+(Solargraph, RubyMine) and for forward compatibility with
+spinel-side RBS consumption (discussion at [#6](https://github.com/OriPekelman/tep/issues/6)) —
+the goal is to let library authors carry the type-correctness burden
+in `.rbs` files so app developers can write idiomatic Ruby without
+the inference-warming seed dance that currently lives at the top
+of `lib/tep.rb`. `rake rbs:validate` syntax-checks the tree.
+
+## Spinel-direct
+
+`tep build` accepts either the Sinatra DSL or a lower-level
+Tep-class style without the translator:
+
+```ruby
+require_relative '../lib/tep'
+
+class Hi < Tep::Handler
+  def handle(req, res)
+    "<p>hi, " + req.params["name"] + "!</p>"
+  end
+end
+
+Tep.get "/hi/:name", Hi.new
+Tep.run!(4567, 1, false)
+```
+
+Useful for tracing where the translator's textual rewrites go.
+
+## Reporting bugs
+
+Tep deliberately exists to find Spinel's edges. If you hit a
+Sinatra idiom that doesn't translate, a Spinel-emitted miscompile,
+a runtime hang — please file an issue with a minimal reproduction.
+"Your app doesn't build" is a useful data point.
+
+## License
+
+MIT, see [LICENSE](LICENSE).
+
+[spinel]: https://github.com/matz/spinel