tep 0.11.3 → 0.11.5

data/lib/{tep/logger.rb → spinel_kit/log.rb}

@@ -1,28 +1,33 @@
-# Tep::Logger -- minimal levelled logger for spinel-AOT'd apps.
+# VENDORED from OriPekelman/spinelkit @ 09e8558 -- DO NOT EDIT HERE.
+# Edit upstream and re-sync with `make vendor-spinelkit`.
+# SpinelKit::Log -- minimal levelled logger for spinel-AOT'd apps.
 #
-# Why bundle one? CRuby's stdlib `Logger` is metaprogrammed (the
-# severity dispatch loop, the formatter API, the device-rotation
-# logic) and doesn't compile through spinel. Most app code that
-# wants logging really wants three things: a level guard, a
-# formatted line, and a destination.
+# WHY THIS EXISTS. CRuby's stdlib `Logger` is metaprogrammed (the severity
+# dispatch loop, the formatter API, the device-rotation logic) and the
+# spinelgems catalog rejects it (unresolved calls). Most app code that wants
+# logging really wants three things: a level guard, a formatted line, and a
+# destination. Ported verbatim from Tep::Logger; toy gains it for free.
 #
 # Surface
 # -------
-#
-#   logger = Tep::Logger.new
+#   logger = SpinelKit::Log.new
 #   logger.set_level("info")        # one of: debug / info / warn / error
 #   logger.info("server up on " + port.to_s)
 #   logger.error("db connect failed")
 #
 #   # File output: appends to the path. Leave unset for stderr.
-#   logger.to_file("/var/log/tep.log")
+#   logger.to_file("/var/log/app.log")
+#
+# Each line is `[<unix_seconds>] [<level>] <message>`. The integer-seconds
+# timestamp is what spinel exposes from `Time.now`; wider strftime support
+# would need a C-shim (defer until callers ask for it).
 #
-# Each line is `[<unix_seconds>] [<level>] <message>`. The
-# integer-seconds timestamp is what spinel exposes from `Time.now`;
-# wider strftime support would need a C-shim (defer until callers
-# ask for it).
-module Tep
-  class Logger
+# SPINEL NAMING DISCIPLINE: the method/param names below are the donor's
+# proven-green spellings; the class-side `level_value` keeps the comparison
+# a pure function so spinel pins its arg type to :str cleanly via a consumer
+# type-seed. See docs/spinel-discipline.md.
+module SpinelKit
+  class Log
     attr_accessor :min_level, :file_path
 
     def initialize
@@ -54,12 +59,11 @@ module Tep
     end
 
     def should_log?(level)
-      Logger.level_value(level) >= Logger.level_value(@min_level)
+      Log.level_value(level) >= Log.level_value(@min_level)
     end
 
-    # Class-side helper so the comparison stays a pure function and
-    # spinel pins its arg type to :str cleanly via the type-seed in
-    # tep.rb.
+    # Class-side helper so the comparison stays a pure function and spinel
+    # pins its arg type to :str cleanly via a consumer-side type-seed.
     def self.level_value(name)
       if name == "debug"
         return 0
@@ -73,8 +77,8 @@ module Tep
       if name == "error"
         return 3
       end
-      # Unknown level -- treat as info so misspelled labels don't
-      # vanish silently.
+      # Unknown level -- treat as info so misspelled labels don't vanish
+      # silently.
       1
     end
 

data/lib/spinel_kit/url.rb

@@ -0,0 +1,166 @@
+# VENDORED from OriPekelman/spinelkit @ 09e8558 -- DO NOT EDIT HERE.
+# Edit upstream and re-sync with `make vendor-spinelkit`.
+require_relative "hex"
+
+# SpinelKit::Url -- percent-encode/decode (the CGI / URI-component surface
+# Spinel can't get from stdlib) plus a form-query parser and a small URL
+# splitter. Ported from Tep::Url; the hex digits now come from SpinelKit::Hex.
+#
+# Self-contained: the empty str=>str hashes are seeded inline (the
+# `{"" => ""}`-then-delete idiom that pins Spinel's value type), and substring
+# search is a private `find_idx` (the `< 0` callsites can't narrow against
+# String#index's int|nil under Spinel's current model). All pure string ops.
+module SpinelKit
+  class Url
+    # "%41+b" -> "A b" (form-decode: `+` is space, `%XX` is a byte).
+    def self.unescape(s)
+      out = ""
+      i = 0
+      n = s.length
+      while i < n
+        c = s[i]
+        if c == "+"
+          out = out + " "
+          i += 1
+        elsif c == "%" && i + 2 < n
+          hi = Hex.nibble(s[i + 1])
+          lo = Hex.nibble(s[i + 2])
+          if hi >= 0 && lo >= 0
+            out = out + ((hi * 16 + lo).chr)
+            i += 3
+          else
+            out = out + c
+            i += 1
+          end
+        else
+          out = out + c
+          i += 1
+        end
+      end
+      out
+    end
+
+    # Percent-encode everything outside the RFC 3986 unreserved set
+    # (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).
+    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
+        else
+          b = c.getbyte(0)
+          out = out + "%" + Hex.nibble_char(b / 16) + Hex.nibble_char(b % 16)
+        end
+        i += 1
+      end
+      out
+    end
+
+    # "a=1&b=2&c" -> {"a"=>"1","b"=>"2","c"=>""}. Keys + values are
+    # form-decoded (`unescape`).
+    def self.parse_query(s)
+      h = {"" => ""}
+      h.delete("")
+      if s.length == 0
+        return h
+      end
+      pairs = s.split("&")
+      pairs.each do |pair|
+        if pair.length > 0
+          eq = Url.find_idx(pair, "=", 0)
+          if eq < 0
+            h[Url.unescape(pair)] = ""
+          else
+            k = pair[0, eq]
+            v = pair[eq + 1, pair.length - eq - 1]
+            h[Url.unescape(k)] = Url.unescape(v)
+          end
+        end
+      end
+      h
+    end
+
+    # Split `http(s)://host[:port]/path?query` into a str=>str hash keyed
+    # scheme / host / port / path / query. Without a scheme the input is
+    # treated as a path (host stays empty). Default ports follow the scheme
+    # (80 / 443); `query` is the raw substring after `?` (not decoded).
+    #
+    # One body on purpose: Spinel widens a Hash-typed value when a helper
+    # mutates it and the caller keeps reading, so `out` stays StrStrHash only
+    # if nothing factors the mutation out (find_idx returns an int, no mutate).
+    def self.split_url(u)
+      out = {"" => ""}
+      out.delete("")
+      out["scheme"] = ""
+      out["host"]   = ""
+      out["port"]   = ""
+      out["path"]   = "/"
+      out["query"]  = ""
+
+      rest = u
+      if rest.length >= 7 && rest[0, 7] == "http://"
+        out["scheme"] = "http"
+        out["port"]   = "80"
+        rest = rest[7, rest.length - 7]
+      elsif rest.length >= 8 && rest[0, 8] == "https://"
+        out["scheme"] = "https"
+        out["port"]   = "443"
+        rest = rest[8, rest.length - 8]
+      end
+
+      if out["scheme"].length > 0
+        slash = Url.find_idx(rest, "/", 0)
+        hostport = rest
+        tail     = "/"
+        if slash >= 0
+          hostport = rest[0, slash]
+          tail     = rest[slash, rest.length - slash]
+        end
+        colon = Url.find_idx(hostport, ":", 0)
+        if colon >= 0
+          out["host"] = hostport[0, colon]
+          out["port"] = hostport[colon + 1, hostport.length - colon - 1]
+        else
+          out["host"] = hostport
+        end
+        rest = tail
+      end
+
+      qi = Url.find_idx(rest, "?", 0)
+      if qi >= 0
+        out["path"]  = rest[0, qi]
+        out["query"] = rest[qi + 1, rest.length - qi - 1]
+      else
+        out["path"] = rest
+      end
+      if out["path"].length == 0
+        out["path"] = "/"
+      end
+      out
+    end
+
+    # First index of `needle` in `s` at/after `start`, or -1. Internal
+    # (Spinel-safe substring search; see the module comment).
+    def self.find_idx(s, needle, start)
+      nlen = needle.length
+      slen = s.length
+      pos = start
+      while pos <= slen - nlen
+        if s[pos, nlen] == needle
+          return pos
+        end
+        pos += 1
+      end
+      -1
+    end
+  end
+end

data/lib/tep/auth_bearer_token.rb

@@ -9,7 +9,7 @@
 #   Tep::AuthBearerToken.set_secret(ENV["JWT_SECRET"])
 #
 # Token payload schema (flat JSON, single level -- matches
-# Tep::Json's flat-object extraction surface):
+# SpinelKit::Json's flat-object extraction surface):
 #
 #   {
 #     "sub":      "user:42",                    # principal_id (required)
@@ -22,7 +22,7 @@
 #                                               # agent_id|issued_at|expires_at|origin
 #   }
 #
-# Why flat (not nested `acting_via: { ... }`): Tep::Json today
+# Why flat (not nested `acting_via: { ... }`): SpinelKit::Json today
 # extracts flat keys only. A nested-object getter is a separate
 # tiny battery; for v1 of Auth the flat pipe-encoded delegate
 # string is the smallest thing that ships and round-trips
@@ -64,20 +64,20 @@ module Tep
 
       # Check expiry first -- a token whose exp passed gets rejected
       # even if the signature still verifies. exp is unix epoch sec.
-      exp = Tep::Json.get_int(payload, "exp")
+      exp = SpinelKit::Json.get_int(payload, "exp")
       if exp > 0 && Time.now.to_i >= exp
         return nil
       end
 
-      sub = Tep::Json.get_str(payload, "sub")
+      sub = SpinelKit::Json.get_str(payload, "sub")
       if sub.length == 0
         return nil
       end
 
-      caps_str = Tep::Json.get_str(payload, "caps")
+      caps_str = SpinelKit::Json.get_str(payload, "caps")
       caps = Tep::AuthBearerToken.parse_caps(caps_str)
 
-      delegate_str = Tep::Json.get_str(payload, "delegate")
+      delegate_str = SpinelKit::Json.get_str(payload, "delegate")
       delegation = Tep::AuthBearerToken.parse_delegate(delegate_str)
 
       Tep::Identity.new(sub, delegation, caps)

data/lib/tep/auth_oauth2.rb

@@ -161,10 +161,10 @@ module Tep
       delegate_str = rec.client_id + "|" + now_ts.to_s + "|" +
                      exp_ts.to_s + "|oauth_grant"
       payload = "{" +
-        Tep::Json.encode_pair_str("sub", rec.principal_id) + "," +
-        Tep::Json.encode_pair_int("exp", exp_ts) + "," +
-        Tep::Json.encode_pair_str("caps", rec.caps_str) + "," +
-        Tep::Json.encode_pair_str("delegate", delegate_str) +
+        SpinelKit::Json.encode_pair_str("sub", rec.principal_id) + "," +
+        SpinelKit::Json.encode_pair_int("exp", exp_ts) + "," +
+        SpinelKit::Json.encode_pair_str("caps", rec.caps_str) + "," +
+        SpinelKit::Json.encode_pair_str("delegate", delegate_str) +
       "}"
       Tep::Jwt.encode_hs256(payload, secret)
     end

data/lib/tep/broadcast.rb

@@ -114,14 +114,21 @@ module Tep
     # remote deliveries are best-effort and not counted here.
     def self.publish(topic, payload)
       matched = Tep::Broadcast.publish_local_only(topic, payload)
-      if Tep::APP.broadcast_pg_enabled != 0
-        wire = Tep::Broadcast.encode_wire(topic, payload)
-        Tep::APP.broadcast_pg_conn.notify(
-          Tep::APP.broadcast_pg_channel, wire)
-      end
+      # Cross-worker fan-out is an OPT-IN hook (#216): the core build
+      # has no PG reference, so a non-PG app DCEs the entire libpq
+      # closure. `require "tep/pg"` redefines cross_worker_notify with
+      # the real broadcast_pg_conn.notify (last-definition-wins).
+      Tep::Broadcast.cross_worker_notify(topic, payload)
       matched
     end
 
+    # No-op cross-worker hook. Overridden by lib/tep/pg.rb when the PG
+    # backend is loaded. Keeping the PG NOTIFY out of core is what lets
+    # `Tep::Broadcast.publish` compile without pulling tep_pg_*/libpq.
+    def self.cross_worker_notify(topic, payload)
+      0
+    end
+
     # Total subscription count across all topics. Useful for
     # diagnostics and the v1 test surface.
     def self.subscriber_count
@@ -157,81 +164,12 @@ module Tep
 
     # ---- PG backend (cross-worker pub/sub) ----
     #
-    # Opens a dedicated PG connection and issues `LISTEN <channel>`.
-    # Subsequent publishes NOTIFY this channel too -- other workers
-    # subscribed to the same channel can receive the message via
-    # poll_pg_once.
-    #
-    # `conninfo` is the libpq connect string. `channel` must be a
-    # safe SQL identifier (e.g. "tep_broadcast") since it lands
-    # inside a LISTEN / NOTIFY command unescaped.
-    #
-    # Returns 0 on success, -1 on connection or LISTEN failure.
-    def self.enable_pg_backend(conninfo, channel)
-      conn = PG::Connection.new(conninfo)
-      if conn.pgh < 0
-        return -1
-      end
-      if conn.listen(channel) < 0
-        return -1
-      end
-      Tep::APP.set_broadcast_pg_conn(conn)
-      Tep::APP.set_broadcast_pg_channel(channel)
-      Tep::APP.set_broadcast_pg_enabled(1)
-      0
-    end
-
-    def self.disable_pg_backend
-      if Tep::APP.broadcast_pg_enabled == 0
-        return 0
-      end
-      Tep::APP.broadcast_pg_conn.unlisten(Tep::APP.broadcast_pg_channel)
-      Tep::APP.broadcast_pg_conn.finish
-      Tep::APP.set_broadcast_pg_enabled(0)
-      0
-    end
-
-    # Process one notification from the PG channel: parse the wire
-    # format, dispatch to local subscribers as if `publish` had
-    # been called locally (but WITHOUT re-NOTIFYing -- that would
-    # loop). Returns 1 if a notification was processed, 0 on
-    # timeout, -1 on connection error or unenabled backend.
-    def self.poll_pg_once(timeout_ms)
-      if Tep::APP.broadcast_pg_enabled == 0
-        return -1
-      end
-      r = Tep::APP.broadcast_pg_conn.poll_notification(timeout_ms)
-      if r != 1
-        return r
-      end
-      wire = Tep::APP.broadcast_pg_conn.last_notify_payload
-      Tep::Broadcast.deliver_wire_local(wire)
-      1
-    end
-
-    # Wire format: "<topic_byte_length>:<topic><payload>".
-    # Length-prefixed so topics and payloads with arbitrary chars
-    # (commas, colons, embedded quotes, newlines) round-trip
-    # unambiguously. Encoded by `publish` when the PG backend is
-    # enabled; decoded by `deliver_wire_local`.
-    def self.encode_wire(topic, payload)
-      topic.length.to_s + ":" + topic + payload
-    end
-
-    def self.deliver_wire_local(wire)
-      colon = Tep.str_find(wire, ":", 0)
-      if colon <= 0
-        return -1
-      end
-      len_str = wire[0, colon]
-      tlen    = len_str.to_i
-      if tlen < 0 || colon + 1 + tlen > wire.length
-        return -1
-      end
-      topic   = wire[colon + 1, tlen]
-      payload = wire[colon + 1 + tlen, wire.length - colon - 1 - tlen]
-      Tep::Broadcast.publish_local_only(topic, payload)
-    end
+    # The PG LISTEN/NOTIFY backend is OPT-IN (#216). enable_pg_backend /
+    # disable_pg_backend / poll_pg_once, plus the wire encode/decode
+    # helpers (encode_wire / deliver_wire_local) and the
+    # cross_worker_notify override, live in lib/tep/pg.rb and only
+    # compile into apps that `require "tep/pg"`. Core Broadcast carries
+    # no PG reference so a non-PG app DCEs the libpq closure entirely.
 
     # Same fan-out as #publish but skips the PG NOTIFY step. Used
     # internally by poll_pg_once when delivering a cross-worker

data/lib/tep/events.rb

@@ -80,19 +80,19 @@ module Tep
       # was a bare string before #115. os + arch come from uname() via
       # Sock.sphttp_os_kind / sphttp_arch_kind.
       line = "{" +
-        Json.encode_pair_str("kind", "run_start") + "," +
-        Json.encode_pair_str("schema", "toy/v1") + "," +
-        Json.encode_pair_int("t", 0) + "," +
-        Json.encode_pair_str("started_at", started) + "," +
+        SpinelKit::Json.encode_pair_str("kind", "run_start") + "," +
+        SpinelKit::Json.encode_pair_str("schema", "toy/v1") + "," +
+        SpinelKit::Json.encode_pair_int("t", 0) + "," +
+        SpinelKit::Json.encode_pair_str("started_at", started) + "," +
         "\"host\":{" +
-          Json.encode_pair_str("name", host) + "," +
-          Json.encode_pair_str("os",   Sock.sphttp_os_kind) + "," +
-          Json.encode_pair_str("arch", Sock.sphttp_arch_kind) +
+          SpinelKit::Json.encode_pair_str("name", host) + "," +
+          SpinelKit::Json.encode_pair_str("os",   Sock.sphttp_os_kind) + "," +
+          SpinelKit::Json.encode_pair_str("arch", Sock.sphttp_arch_kind) +
         "}," +
-        "\"backend\":{" + Json.encode_pair_str("kind", backend_kind) + "}," +
+        "\"backend\":{" + SpinelKit::Json.encode_pair_str("kind", backend_kind) + "}," +
         "\"model\":{" +
-          Json.encode_pair_str("name", model_name) + "," +
-          Json.encode_pair_str("path", model_path) +
+          SpinelKit::Json.encode_pair_str("name", model_name) + "," +
+          SpinelKit::Json.encode_pair_str("path", model_path) +
         "}," +
         "\"config\":" + config_json +
       "}"
@@ -120,10 +120,10 @@ module Tep
       # Build the merged extra: spec fields first, then caller's
       # fields appended (if non-empty).
       extra = "{" +
-        Json.encode_pair_str("model", model) + "," +
-        Json.encode_pair_int("prompt_tokens", prompt_tokens) + "," +
-        Json.encode_pair_int("completion_tokens", completion_tokens) + "," +
-        Json.encode_pair_int("latency_us", wall_us)
+        SpinelKit::Json.encode_pair_str("model", model) + "," +
+        SpinelKit::Json.encode_pair_int("prompt_tokens", prompt_tokens) + "," +
+        SpinelKit::Json.encode_pair_int("completion_tokens", completion_tokens) + "," +
+        SpinelKit::Json.encode_pair_int("latency_us", wall_us)
       caller_inner = ""
       if extra_json.length > 2
         # Strip the outer braces -- "{...}" -> "...".
@@ -134,10 +134,10 @@ module Tep
       end
       extra = extra + "}"
       line = "{" +
-        Json.encode_pair_str("kind", "eval") + "," +
-        Json.encode_pair_str("phase", "serve") + "," +
-        Json.encode_pair_int("t", rel_t) + "," +
-        Json.encode_pair_str("name", "request") + "," +
+        SpinelKit::Json.encode_pair_str("kind", "eval") + "," +
+        SpinelKit::Json.encode_pair_str("phase", "serve") + "," +
+        SpinelKit::Json.encode_pair_int("t", rel_t) + "," +
+        SpinelKit::Json.encode_pair_str("name", "request") + "," +
         "\"extra\":" + extra +
       "}"
       append_line(line)
@@ -163,14 +163,14 @@ module Tep
       end
       ended = Sock.sphttp_iso8601_utc(Time.now.to_i)
       line = "{" +
-        Json.encode_pair_str("kind", "run_end") + "," +
-        Json.encode_pair_int("t", rel_t) + "," +
-        Json.encode_pair_str("ended_at", ended) + "," +
-        Json.encode_pair_str("reason", reason) + "," +
+        SpinelKit::Json.encode_pair_str("kind", "run_end") + "," +
+        SpinelKit::Json.encode_pair_int("t", rel_t) + "," +
+        SpinelKit::Json.encode_pair_str("ended_at", ended) + "," +
+        SpinelKit::Json.encode_pair_str("reason", reason) + "," +
         "\"stats\":{" +
-          Json.encode_pair_int("requests", @req_count) + "," +
-          Json.encode_pair_int("errors", @err_count) + "," +
-          Json.encode_pair_int("tokens_out", @tok_out) +
+          SpinelKit::Json.encode_pair_int("requests", @req_count) + "," +
+          SpinelKit::Json.encode_pair_int("errors", @err_count) + "," +
+          SpinelKit::Json.encode_pair_int("tokens_out", @tok_out) +
         "}" +
       "}"
       append_line(line)
@@ -205,28 +205,28 @@ module Tep
            Tep.str_find(line_s, "\"name\":\"request\"", 0) >= 0
           reqs += 1
           # completion_tokens now lives nested inside the `extra`
-          # object. Tep::Json.find_value_start walks only the
+          # object. SpinelKit::Json.find_value_start walks only the
           # top-level keys (it skips over nested objects), so we
           # have to extract extra first, then get_int within it.
-          extra_pos = Json.find_value_start(line_s, "extra")
+          extra_pos = SpinelKit::Json.find_value_start(line_s, "extra")
           if extra_pos >= 0
-            obj_end = Json.skip_container(line_s, extra_pos)
+            obj_end = SpinelKit::Json.skip_container(line_s, extra_pos)
             extra_obj = line_s[extra_pos, obj_end - extra_pos]
-            toks += Json.get_int(extra_obj, "completion_tokens")
+            toks += SpinelKit::Json.get_int(extra_obj, "completion_tokens")
           end
         end
         i += 1
       end
       ended = Sock.sphttp_iso8601_utc(Time.now.to_i)
       out = "{" +
-        Json.encode_pair_str("kind", "run_end") + "," +
-        Json.encode_pair_int("t", rel_t) + "," +
-        Json.encode_pair_str("ended_at", ended) + "," +
-        Json.encode_pair_str("reason", reason) + "," +
+        SpinelKit::Json.encode_pair_str("kind", "run_end") + "," +
+        SpinelKit::Json.encode_pair_int("t", rel_t) + "," +
+        SpinelKit::Json.encode_pair_str("ended_at", ended) + "," +
+        SpinelKit::Json.encode_pair_str("reason", reason) + "," +
         "\"stats\":{" +
-          Json.encode_pair_int("requests", reqs) + "," +
-          Json.encode_pair_int("errors", errs) + "," +
-          Json.encode_pair_int("tokens_out", toks) +
+          SpinelKit::Json.encode_pair_int("requests", reqs) + "," +
+          SpinelKit::Json.encode_pair_int("errors", errs) + "," +
+          SpinelKit::Json.encode_pair_int("tokens_out", toks) +
         "}" +
       "}"
       append_line(out)
@@ -243,7 +243,7 @@ module Tep
     end
 
     # Append one JSON line. Best-effort, append mode -- mirrors
-    # Tep::Logger's file sink. Telemetry must never fail a request, so
+    # SpinelKit::Log's file sink. Telemetry must never fail a request, so
     # a malformed/unwritable path degrades to a dropped line rather
     # than a raised error reaching the handler. Callers gate on a
     # non-empty @path before reaching here.

data/lib/tep/http.rb

@@ -151,7 +151,7 @@ module Tep
 
     def self.send_req_blocking(verb, url, body, headers)
       out = Tep::Http::Response.new
-      parts = Tep::Url.split_url(url)
+      parts = SpinelKit::Url.split_url(url)
       scheme = parts["scheme"]
       if scheme != "http" && scheme != "https"
         # Unknown scheme.
@@ -168,7 +168,7 @@ module Tep
       # pooling TLS sockets is out of scope for 6.7b (#126). HTTP/1.0 +
       # Connection: close + recv-until-EOF over a fresh verified socket.
       if scheme == "https"
-        fd = Sock.sphttp_connect_tls(host, port)   # port 443 via Tep::Url
+        fd = Sock.sphttp_connect_tls(host, port)   # port 443 via SpinelKit::Url
         if fd < 0
           return out
         end
@@ -275,7 +275,7 @@ module Tep
     # docs/MACOS-CONCURRENCY.md for the why.
     def self.send_req_coop(verb, url, body, headers)
       out = Tep::Http::Response.new
-      parts = Tep::Url.split_url(url)
+      parts = SpinelKit::Url.split_url(url)
       scheme = parts["scheme"]
       if scheme != "http" && scheme != "https"
         return out

data/lib/tep/job.rb

@@ -24,7 +24,7 @@
 #   )
 #
 # The single-arg payload is intentional: structured data goes
-# through JSON (Tep::Json) which we already ship. Sidekiq's
+# through JSON (SpinelKit::Json) which we already ship. Sidekiq's
 # multi-arg `perform_async(a, b, c)` translates to encoding the
 # tuple as a JSON string and decoding it in `perform`.
 #
@@ -34,7 +34,7 @@
 #
 #     class HelloJob < Tep::Job
 #       def perform(arg)
-#         Tep::Logger.new.info("hello " + arg)
+#         SpinelKit::Log.new.info("hello " + arg)
 #         "done"
 #       end
 #     end

data/lib/tep/jwt.rb

@@ -13,14 +13,14 @@
 # Surface
 # -------
 #
-#   payload_json = "{" + Tep::Json.encode_pair_str("sub", user_id) + "," +
-#                        Tep::Json.encode_pair_int("exp", exp_unix) + "}"
+#   payload_json = "{" + SpinelKit::Json.encode_pair_str("sub", user_id) + "," +
+#                        SpinelKit::Json.encode_pair_int("exp", exp_unix) + "}"
 #   token = Tep::Jwt.encode_hs256(payload_json, secret)
 #
 #   # On the receiving side:
 #   if Tep::Jwt.verify_hs256(token, secret)
 #     payload = Tep::Jwt.decode_payload(token)   # the JSON string
-#     sub = Tep::Json.get_str(payload, "sub")
+#     sub = SpinelKit::Json.get_str(payload, "sub")
 #   end
 #
 # Scope
@@ -32,7 +32,7 @@
 #
 # **Claims validation:** the `verify_hs256` only checks the
 # signature. `exp` / `nbf` / `iss` / `aud` claim checks are left
-# to caller code -- pull them with `Tep::Json.get_int(payload, "exp")`
+# to caller code -- pull them with `SpinelKit::Json.get_int(payload, "exp")`
 # and compare against `Time.now.to_i`. This keeps the surface
 # small and lets the app's policy decide what's required (some
 # apps want skew tolerance, some want strict expiry).

data/lib/tep/live_view.rb

@@ -132,8 +132,8 @@ module Tep
     #     "note":      <free text>,
     #     "until_ts":  <unix ts or 0> }
     #
-    # Subclasses typically pull a few keys via Tep::Json.get_str /
-    # Tep::Json.get_int + update an @presence ivar; then either
+    # Subclasses typically pull a few keys via SpinelKit::Json.get_str /
+    # SpinelKit::Json.get_int + update an @presence ivar; then either
     # call broadcast_render (to fan out the new HTML to every
     # subscriber) or just mutate (if the LiveView is the only
     # observer).
@@ -176,8 +176,8 @@ module Tep
     # imeth on the base class dispatches through the typed slot
     # of the subclass instance and avoids the box.
     def dispatch_event_json(json_msg, req)
-      event   = Tep::Json.get_str(json_msg, "event")
-      payload = Tep::Json.get_str(json_msg, "payload")
+      event   = SpinelKit::Json.get_str(json_msg, "event")
+      payload = SpinelKit::Json.get_str(json_msg, "payload")
       handle_event(event, payload, req)
       0
     end