rocksky 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49ece2a26c96c4edb2110ec0ac28f0c5dcc46d4eb6e7a1b3526cf0f82b045599
-  data.tar.gz: 63a9342d472e413572ef7c5e9c756d930dd95c0571ccac56a16bb5f4e0a1a49b
+  metadata.gz: 56d65f24108dabf8d86f3b8cac9c501d29be2e6ef8cc829f0d3105a457988080
+  data.tar.gz: 8c781e0d976b90fe1691fc207802a5730d99911e1da99af75909b615282e2d8a
 SHA512:
-  metadata.gz: 59b15a62bef85d1beb4f281dfa24388b92a0887d0101f2a5f6d88693f947fc0d70affe522ee19191bbce09a101480953ce1f16abe6ac28530dea573ce4af4fec
-  data.tar.gz: 728673d1cf68236bacb64c155e086659a22bfd0a57bb1f81ffe1522cd593f40151e4c1d6cbf892afef7ecc3dee043fc2188d1e93f1de2a4e242ba3a38a39f552
+  metadata.gz: dbc13ce587f747ea82f7dd17f76d3883fbfc3eb5f08794f26b955414f633f2811d1669c84cce525a7c137485ed8b87be204df9e4622a6fe375548127a1911e85
+  data.tar.gz: b2e13963888d6fc54cdf183113f627261b41f089a15846e0561ff592b6dc0d50f193448ac2a5d6531cde2e38238ff056d54f9f4f769fb20c9b429b4eefec5ccf

data/README.md

@@ -1,229 +1,73 @@
 # rocksky (Ruby)
 
-Idiomatic Ruby client for the [Rocksky](https://rocksky.app) XRPC API.
-
-```ruby
-client = Rocksky.new(token: ENV["ROCKSKY_TOKEN"])
-
-client.actor.get_profile(did: "tsiry-sandratraina.com")
-client.charts.get_top_artists(limit: 10, start_date: "2025-01-01")
-client.scrobble.create_scrobble(title: "In Bloom", artist: "Nirvana")
-```
-
-Every XRPC NSID maps to a method on a resource object. `app.rocksky.actor.getProfile`
-becomes `client.actor.get_profile(...)`. `app.rocksky.scrobble.createScrobble`
-becomes `client.scrobble.create_scrobble(...)`. No magic — just kwargs in,
-parsed JSON out.
+Ruby bindings to the shared Rocksky Rust core (`rocksky-sdk`) through Ruby's
+stdlib `fiddle` (no `ffi` gem): AppView reads, AT Protocol PDS writes (scrobble
+fan-out, like, follow, shout) and the identity hashes — the same engine behind
+every Rocksky SDK.
 
 ## Installation
 
-Add it to your `Gemfile`:
-
-```ruby
-gem "rocksky"
+```sh
+gem install rocksky
 ```
 
-Or install directly:
+The gem is pure-Ruby; the native library is fetched from the GitHub release on
+first load and cached (checksum-verified). For a local checkout, build it once:
 
-```bash
-gem install rocksky
+```sh
+./build-core.sh
 ```
 
-Requires Ruby 3.0+. The SDK depends only on Ruby's stdlib (`net/http`, `json`, `uri`).
-
 ## Quick start
 
 ```ruby
 require "rocksky"
 
-# Reads ROCKSKY_BASE_URL and ROCKSKY_TOKEN from the env when omitted.
-client = Rocksky.new
-
-profile = client.actor.get_profile(did: "tsiry-sandratraina.com")
-puts profile["displayName"]
-```
-
-For authenticated calls, pass a Bluesky-issued Bearer token (see
-[lexicons documentation](https://github.com/rocksky/rocksky/blob/main/LEXICONS.md)):
-
-```ruby
-client = Rocksky.new(token: "eyJ...")
-client.scrobble.create_scrobble(title: "In Bloom", artist: "Nirvana")
-```
-
-`with_token` derives a new client without mutating the original — useful in
-web apps that share one base client across users:
-
-```ruby
-base = Rocksky.new
-def for_user(base, token) = base.with_token(token)
-```
-
-## Resources
-
-| Resource | Methods |
-|----------|---------|
-| `client.actor`    | `get_profile`, `get_actor_albums/artists/songs/scrobbles/playlists/loved_songs`, `get_actor_neighbours`, `get_actor_compatibility` |
-| `client.album`    | `get_album`, `get_albums`, `get_album_tracks` |
-| `client.apikey`   | `get_apikeys`, `create_apikey`, `update_apikey`, `remove_apikey` *(auth)* |
-| `client.artist`   | `get_artist`, `get_artists`, `get_artist_albums/tracks/listeners/recent_listeners` |
-| `client.charts`   | `get_scrobbles_chart`, `get_top_artists`, `get_top_tracks` |
-| `client.feed`     | `search`, `get_feed_generators/generator/feed`, `get_stories`, `get_recommendations`, `get_artist_recommendations`, `get_album_recommendations` |
-| `client.graph`    | `follow_account`, `unfollow_account`, `get_followers`, `get_follows`, `get_known_followers` *(auth)* |
-| `client.like`     | `like_song`, `dislike_song`, `like_shout`, `dislike_shout` *(auth)* |
-| `client.mirror`   | `get_mirror_sources`, `put_mirror_source` *(auth)* |
-| `client.player`   | `play`, `pause`, `next`, `previous`, `seek`, `play_file`, `play_directory`, `add_items_to_queue`, `get_currently_playing`, `get_playback_queue` |
-| `client.playlist` | `get_playlist`, `get_playlists`, `create_playlist`, `remove_playlist`, `start_playlist`, `insert_files`, `insert_directory` |
-| `client.scrobble` | `create_scrobble`, `get_scrobble`, `get_scrobbles` |
-| `client.shout`    | `create_shout`, `reply_shout`, `remove_shout`, `report_shout`, `get_*_shouts`, `get_shout_replies` |
-| `client.song`     | `get_song`, `get_songs`, `get_song_recent_listeners`, `match_song`, `create_song` |
-| `client.spotify`  | `play`, `pause`, `next`, `previous`, `seek`, `get_currently_playing` *(auth)* |
-| `client.stats`    | `get_stats`, `get_wrapped` |
-
-For anything not covered, drop down to the raw transport:
-
-```ruby
-client.query("app.rocksky.actor.getProfile", did: "did:plc:7vdlgi2bflelz7mmuxoqjfcr")
-client.procedure("app.rocksky.like.likeSong", body: { uri: "at://..." })
-```
-
-## Conventions
-
-- **Keyword args** for every parameter. Ruby `snake_case` names map to the
-  lexicon's `camelCase` (e.g. `start_date:` → `startDate`).
-- **`nil` is dropped.** Pass `nil` for any optional param and it won't be sent.
-- **Arrays are CSV-joined.** Lexicon list params like `names:` accept Ruby arrays:
-  `client.artist.get_artists(names: %w[Nirvana Pixies])`.
-- **Hashes in, Hashes out.** Responses come back as plain `Hash` (string keys) —
-  no DSL, no model classes. Match the shape of the lexicon JSON 1:1.
-
-## Error handling
-
-Every non-2xx response raises a subclass of `Rocksky::Error`:
-
-```ruby
-begin
-  client.song.get_song(uri: "at://does-not-exist")
-rescue Rocksky::NotFound => e
-  puts "missing: #{e.message} (status=#{e.status}, nsid=#{e.nsid})"
-rescue Rocksky::RateLimited
-  sleep 5; retry
-rescue Rocksky::Error => e
-  warn "rocksky failure: #{e.class}: #{e.message}"
-end
+# Reads — unauthenticated. base: overrides https://api.rocksky.app.
+stats = Rocksky.global_stats
+puts stats["scrobbles"]
+Rocksky.top_tracks(limit: 10).each { |t| puts "#{t["artist"]} — #{t["title"]}" }
+
+# Writes — log in once (session persisted at the given path).
+agent = Rocksky::Agent.login("session.json", "alice.bsky.social", "app-password")
+out = agent.scrobble(
+  "title" => "Chaser", "artist" => "Calibro 35",
+  "album" => "Jazzploitation", "albumArtist" => "Calibro 35", "durationMs" => 182_320
+)
+puts out["scrobbleUri"]
+agent.close
 ```
 
-| Class | Status |
-|-------|--------|
-| `Rocksky::BadRequest`     | 400 |
-| `Rocksky::Unauthorized`   | 401 |
-| `Rocksky::Forbidden`      | 403 |
-| `Rocksky::NotFound`       | 404 |
-| `Rocksky::RateLimited`    | 429 |
-| `Rocksky::ServerError`    | 5xx |
-| `Rocksky::HTTPError`      | any other non-2xx |
-| `Rocksky::TransportError` | DNS/TCP/timeouts |
-
-## IRB console
-
-The gem ships with a `rocksky-console` executable: an IRB session
-pre-loaded with a `client` bound to your environment.
-
-```bash
-$ gem install rocksky
-$ ROCKSKY_TOKEN=eyJ... rocksky-console
-Rocksky 0.2.0 — interactive console
-  base_url : https://api.rocksky.app
-  token    : present (set via ROCKSKY_TOKEN)
-
-A client is bound to `client`. Try:
-  client.actor.get_profile(did: "did:plc:7vdlgi2bflelz7mmuxoqjfcr")
-  client.charts.get_top_artists(limit: 10)
-
-irb> client.actor.get_profile(did: "did:plc:7vdlgi2bflelz7mmuxoqjfcr")
-=> {"did"=>"did:plc:...", "handle"=>"tsiry-sandratraina.com", ...}
-```
+## API
 
-### From a checkout (development)
+Reads/writes return plain Hashes/Strings (the wire shape); write verbs raise
+`Rocksky::Error` on an `{"error": …}` envelope. Records are Hashes with
+camelCase keys.
 
-If you've cloned the repo, use `bin/console` instead. It loads the local
-source tree, so edits to `lib/` are picked up on the next `reload!`-style
-restart:
+### Reads — `Rocksky`
 
-```bash
-$ cd sdk/ruby
-$ bundle install
-$ bin/console
-```
+`profile(actor, base:)`, `scrobbles(actor, limit:, offset:, base:)`,
+`top_tracks(limit:, offset:, base:)`, `global_stats(base:)`. Every read takes an
+optional `base:` to target a custom AppView.
 
-### Ad-hoc IRB (no script)
+### Writes — `Rocksky::Agent`
 
-You can always launch IRB yourself:
+`Agent.login(session_path, identifier, password, appview:)` → an agent. Then
+`scrobble(track)` (fans out to artist/album/song/scrobble), `like(uri, cid)`,
+`follow(did)`, `shout(subject_uri, subject_cid, message)`, `refresh_session`, and
+`close` (release the native handle).
 
-```bash
-$ irb -rrocksky
-irb> client = Rocksky.new(token: ENV["ROCKSKY_TOKEN"])
-irb> client.charts.get_top_tracks(limit: 5)
-```
-
-### Useful IRB recipes
-
-```ruby
-# Pretty-print responses
-require "json"
-puts JSON.pretty_generate(client.actor.get_profile(did: "did:plc:7vdlgi2bflelz7mmuxoqjfcr"))
+### Identity hashes
 
-# Inspect what the SDK is about to send
-client = Rocksky.new(headers: { "X-Debug" => "1" })
+`Rocksky.song_hash(title, artist, album)` — lowercase-hex SHA-256, identical
+to the server and every other Rocksky SDK.
 
-# Try things against staging without touching prod
-client = Rocksky.new(base_url: "https://api.staging.rocksky.app")
+## Example
 
-# Tighter timeouts in a script
-client = Rocksky.new(open_timeout: 2, read_timeout: 5)
+```sh
+ruby -Ilib examples/native_core.rb
 ```
 
-## Configuration
-
-| Option         | Default                       | Env var               |
-|----------------|-------------------------------|-----------------------|
-| `base_url`     | `https://api.rocksky.app`     | `ROCKSKY_BASE_URL`    |
-| `token`        | `nil`                         | `ROCKSKY_TOKEN`       |
-| `headers`      | `{}`                          | —                     |
-| `user_agent`   | `rocksky-ruby/<version>`      | —                     |
-| `open_timeout` | `10` seconds                  | —                     |
-| `read_timeout` | `30` seconds                  | —                     |
-
-## Types
-
-Lexicon-derived `Struct` types are available under `Rocksky::Generated::*`, mirroring every lex `*View*` / `*Record` / `*Input` / `*Output` / `*Params` shape from [the Rocksky lexicons](https://tangled.org/rocksky.app/rocksky/tree/main/apps/api/lexicons). Regenerate with `bun run lexgen:types` at the repo root.
-
-
-## Examples
-
-The `examples/` directory contains runnable scripts:
-
-```bash
-bundle exec ruby examples/01_profile.rb tsiry-sandratraina.com
-bundle exec ruby examples/03_charts.rb
-ROCKSKY_TOKEN=... bundle exec ruby examples/02_scrobble.rb
-```
-
-See [examples/README.md](examples/README.md) for the full list.
-
-## Development
-
-```bash
-$ bundle install
-$ bundle exec rake test    # run the suite
-$ bin/console              # IRB with the local source tree
-```
-
-Tests use Minitest + WebMock — no live network access needed. Add a new
-resource by dropping a file in `lib/rocksky/resources/`, wiring it into
-`lib/rocksky.rb` and `lib/rocksky/client.rb`, and adding tests under
-`test/resources/`.
-
 ## License
 
-[MIT](LICENSE) © Tsiry Sandratraina.
+MIT.

data/lib/rocksky/manifest.json

@@ -0,0 +1,5 @@
+{
+  "repo": "tsirysndr/rocksky",
+  "tag": "bindings-v0.1.0",
+  "checksums": {}
+}

data/lib/rocksky/native.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# Resolves the native rocksky-uniffi library, downloading a prebuilt from the
+# GitHub release on first use when it isn't already present locally.
+#
+# Order of preference:
+#   1. $ROCKSKY_NATIVE_LIB, if set.
+#   2. librocksky_uniffi.<ext> next to this file — a local ./build-core.sh build.
+#   3. A checksum-verified copy in the user cache, downloaded on first load (the
+#      published-gem path: the native lib is not bundled in the gem).
+#
+# The gem ships manifest.json (repo, release tag, one sha256 per target triple)
+# — filled from the release artifacts by sdk/scripts/gen-uniffi-manifest.sh.
+require "json"
+require "rbconfig"
+require "digest"
+require "fileutils"
+require "net/http"
+require "uri"
+
+module Rocksky
+  # Raised on native-lib resolution failure or an `{"error": …}` envelope.
+  class Error < StandardError; end
+
+  module Native
+    module_function
+
+    def ext
+      case RbConfig::CONFIG["host_os"]
+      when /darwin/ then "dylib"
+      when /mswin|mingw|cygwin/ then "dll"
+      else "so"
+      end
+    end
+
+    def arch
+      a = RbConfig::CONFIG["host_cpu"]
+      case a
+      when /x86_64|amd64/ then "x86_64"
+      when /arm64|aarch64/ then "aarch64"
+      else a
+      end
+    end
+
+    # Canonical target triple matching the release asset names.
+    def triple
+      case RbConfig::CONFIG["host_os"]
+      when /darwin/ then "#{arch}-apple-darwin"
+      when /linux/ then "#{arch}-linux-gnu"
+      when /freebsd/ then "#{arch}-unknown-freebsd"
+      when /netbsd/ then "#{arch}-unknown-netbsd"
+      when /openbsd/ then "#{arch}-unknown-openbsd"
+      else raise Error, "unsupported platform: #{RbConfig::CONFIG["host_os"]}"
+      end
+    end
+
+    def lib_dir
+      __dir__ # sdk/ruby/lib/rocksky
+    end
+
+    def cache_dir(tag)
+      base = ENV["XDG_CACHE_HOME"] || File.join(Dir.home, ".cache")
+      File.join(base, "rocksky", tag)
+    end
+
+    def manifest
+      JSON.parse(File.read(File.join(lib_dir, "manifest.json")))
+    end
+
+    # Absolute path to a loadable native library, fetching it if necessary.
+    def resolve
+      env = ENV["ROCKSKY_NATIVE_LIB"]
+      return env if env && File.exist?(env)
+
+      local = File.join(lib_dir, "librocksky_uniffi.#{ext}")
+      return local if File.exist?(local)
+
+      m = manifest
+      t = triple
+      sha = m.dig("checksums", t) or
+        raise Error, "no prebuilt native lib for #{t} (manifest has no checksum) — run ./build-core.sh"
+      tag = m["tag"]
+      dest = File.join(cache_dir(tag), "librocksky_uniffi-#{t}.#{ext}")
+      return dest if File.exist?(dest) && Digest::SHA256.file(dest).hexdigest == sha
+
+      download_verify(m["repo"], tag, t, sha, dest)
+      dest
+    end
+
+    def download_verify(repo, tag, triple, sha, dest)
+      url = "https://github.com/#{repo}/releases/download/#{tag}/librocksky_uniffi-#{triple}.#{ext}"
+      body = fetch(url)
+      got = Digest::SHA256.hexdigest(body)
+      raise Error, "checksum mismatch for #{triple}: want #{sha}, got #{got}" unless got == sha
+
+      FileUtils.mkdir_p(File.dirname(dest))
+      tmp = "#{dest}.download"
+      File.binwrite(tmp, body)
+      File.chmod(0o755, tmp)
+      File.rename(tmp, dest)
+    end
+
+    def fetch(url, limit = 5)
+      raise Error, "too many redirects" if limit.zero?
+
+      res = Net::HTTP.get_response(URI(url))
+      case res
+      when Net::HTTPSuccess then res.body
+      when Net::HTTPRedirection then fetch(res["location"], limit - 1)
+      else raise Error, "download failed (#{res.code}) for #{url}"
+      end
+    end
+  end
+end

data/lib/rocksky/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rocksky
-  VERSION = "0.3.0".freeze
+  VERSION = "0.4.0"
 end

data/lib/rocksky.rb

@@ -1,33 +1,135 @@
-require "rocksky/version"
-require "rocksky/error"
-require "rocksky/http"
-require "rocksky/resources/base"
-require "rocksky/resources/actor"
-require "rocksky/resources/album"
-require "rocksky/resources/apikey"
-require "rocksky/resources/artist"
-require "rocksky/resources/charts"
-require "rocksky/resources/feed"
-require "rocksky/resources/graph"
-require "rocksky/resources/like"
-require "rocksky/resources/mirror"
-require "rocksky/resources/player"
-require "rocksky/resources/playlist"
-require "rocksky/resources/scrobble"
-require "rocksky/resources/shout"
-require "rocksky/resources/song"
-require "rocksky/resources/spotify"
-require "rocksky/resources/stats"
-require "rocksky/client"
-require "rocksky/generated/types"
+# frozen_string_literal: true
+
+# Official Ruby SDK for Rocksky.
+#
+# A thin binding, via Ruby's stdlib `fiddle` (no `ffi` gem), to the plain C ABI
+# of the shared Rust core (`rocksky-uniffi` → `rocksky-sdk`): AppView reads, AT
+# Protocol PDS writes (scrobble fan-out, like, follow, shout) and the identity
+# hashes — the same engine behind every Rocksky SDK.
+#
+#     require "rocksky"
+#     Rocksky.global_stats
+#     agent = Rocksky::Agent.login("session.json", "alice.bsky.social", "app-pw")
+require "fiddle"
+require "fiddle/import"
+require "json"
+require_relative "rocksky/native"
 
 module Rocksky
-  # Build a new Rocksky client.
-  #
-  #   client = Rocksky.new(token: ENV["ROCKSKY_TOKEN"])
+  require_relative "rocksky/version"
+
+  module C
+    extend Fiddle::Importer
+    dlload Native.resolve
+    [
+      "char* rocksky_profile(const char*, const char*)",
+      "char* rocksky_scrobbles(const char*, const char*, unsigned int, unsigned int)",
+      "char* rocksky_top_tracks(const char*, unsigned int, unsigned int)",
+      "char* rocksky_global_stats(const char*)",
+      "char* rocksky_song_hash(const char*, const char*, const char*)",
+      "void rocksky_string_free(void*)",
+      "char* rocksky_last_error()",
+      "void* rocksky_agent_login(const char*, const char*, const char*, const char*)",
+      "void rocksky_agent_free(void*)",
+      "char* rocksky_agent_scrobble(void*, const char*)",
+      "char* rocksky_agent_like(void*, const char*, const char*)",
+      "char* rocksky_agent_follow(void*, const char*)",
+      "char* rocksky_agent_shout(void*, const char*, const char*, const char*)",
+      "char* rocksky_agent_refresh_session(void*)"
+    ].each { |sig| extern sig }
+  end
+  private_constant :C
+
+  # C strings the core returns aren't length-tagged; resolve length via strlen.
+  STRLEN = Fiddle::Function.new(
+    Fiddle::Handle::DEFAULT["strlen"], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_SIZE_T
+  )
+  private_constant :STRLEN
+
+  # Copy an owned C string into a Ruby string and free the original.
+  def self.take_string(ptr)
+    return nil if ptr.nil? || ptr.null?
+
+    len = STRLEN.call(ptr)
+    str = ptr[0, len].force_encoding("UTF-8")
+    C.rocksky_string_free(ptr)
+    str
+  end
+
+  # Parse a `{"ok"|"error"}` envelope, raising Error on failure.
+  def self.unwrap(ptr)
+    parsed = JSON.parse(take_string(ptr))
+    raise Error, parsed["error"] if parsed.key?("error")
+
+    parsed["ok"]
+  end
+
+  # ---- reads (unauthenticated; base: overrides the AppView URL) ----
+
+  def self.profile(actor, base: nil)
+    unwrap(C.rocksky_profile(base.to_s, actor))
+  end
+
+  def self.scrobbles(actor, limit: 50, offset: 0, base: nil)
+    unwrap(C.rocksky_scrobbles(base.to_s, actor, limit, offset))
+  end
+
+  def self.top_tracks(limit: 50, offset: 0, base: nil)
+    unwrap(C.rocksky_top_tracks(base.to_s, limit, offset))
+  end
+
+  def self.global_stats(base: nil)
+    unwrap(C.rocksky_global_stats(base.to_s))
+  end
+
+  # Identity hash — identical across every Rocksky SDK.
+  def self.song_hash(title, artist, album)
+    take_string(C.rocksky_song_hash(title, artist, album))
+  end
+
+  # ---- authenticated agent ----
   #
-  # See {Rocksky::Client#initialize} for all options.
-  def self.new(**opts)
-    Client.new(**opts)
+  # Records are passed as Hashes with camelCase keys (title, artist, album,
+  # albumArtist, durationMs, …), matching the wire record shape.
+  class Agent
+    def self.login(session_path, identifier, password, appview: nil)
+      ptr = C.rocksky_agent_login(session_path, identifier, password, appview.to_s)
+      raise Error, (Rocksky.take_string(C.rocksky_last_error()) || "login failed") if ptr.null?
+
+      new(ptr)
+    end
+
+    def initialize(ptr)
+      @ptr = ptr
+    end
+
+    # Scrobble a play; fans out to artist/album/song/scrobble. Returns the URIs.
+    def scrobble(track)
+      Rocksky.unwrap(C.rocksky_agent_scrobble(@ptr, JSON.generate(track)))
+    end
+
+    def like(uri, cid)
+      Rocksky.unwrap(C.rocksky_agent_like(@ptr, uri, cid))
+    end
+
+    def follow(did)
+      Rocksky.unwrap(C.rocksky_agent_follow(@ptr, did))
+    end
+
+    def shout(subject_uri, subject_cid, message)
+      Rocksky.unwrap(C.rocksky_agent_shout(@ptr, subject_uri, subject_cid, message))
+    end
+
+    def refresh_session
+      Rocksky.unwrap(C.rocksky_agent_refresh_session(@ptr))
+    end
+
+    # Release the native handle. The agent is unusable afterwards.
+    def close
+      return if @ptr.null?
+
+      C.rocksky_agent_free(@ptr)
+      @ptr = Fiddle::Pointer.new(0)
+    end
   end
 end

data/rocksky.gemspec

@@ -6,9 +6,10 @@ Gem::Specification.new do |spec|
   spec.authors     = ["Rocksky"]
   spec.email       = ["hi@rocksky.app"]
 
-  spec.summary     = "Ruby client for the Rocksky XRPC API."
-  spec.description = "Idiomatic Ruby SDK for Rocksky (rocksky.app) — scrobbles, " \
-                     "shouts, charts, playlists, and more."
+  spec.summary     = "Ruby SDK for Rocksky — native bindings to the shared Rust core."
+  spec.description = "Ruby SDK for Rocksky (rocksky.app): native bindings to the " \
+                     "shared Rust core — AppView reads, AT Protocol PDS writes " \
+                     "(scrobble, like, follow, shout), and identity hashes."
   spec.homepage    = "https://github.com/tsirysndr/rocksky"
   spec.license     = "MIT"
 
@@ -24,6 +25,9 @@ Gem::Specification.new do |spec|
 
   spec.files = Dir[
     "lib/**/*.rb",
+    # native-core download manifest (the lib itself is fetched on first load,
+    # never bundled — only *.rb + this json ship).
+    "lib/rocksky/manifest.json",
     "exe/*",
     "*.gemspec",
     "LICENSE",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rocksky
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Rocksky
@@ -65,8 +65,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.19'
-description: Idiomatic Ruby SDK for Rocksky (rocksky.app) — scrobbles, shouts, charts,
-  playlists, and more.
+description: 'Ruby SDK for Rocksky (rocksky.app): native bindings to the shared Rust
+  core — AppView reads, AT Protocol PDS writes (scrobble, like, follow, shout), and
+  identity hashes.'
 email:
 - hi@rocksky.app
 executables:
@@ -79,27 +80,8 @@ files:
 - README.md
 - exe/rocksky-console
 - lib/rocksky.rb
-- lib/rocksky/client.rb
-- lib/rocksky/error.rb
-- lib/rocksky/generated/types.rb
-- lib/rocksky/http.rb
-- lib/rocksky/resources/actor.rb
-- lib/rocksky/resources/album.rb
-- lib/rocksky/resources/apikey.rb
-- lib/rocksky/resources/artist.rb
-- lib/rocksky/resources/base.rb
-- lib/rocksky/resources/charts.rb
-- lib/rocksky/resources/feed.rb
-- lib/rocksky/resources/graph.rb
-- lib/rocksky/resources/like.rb
-- lib/rocksky/resources/mirror.rb
-- lib/rocksky/resources/player.rb
-- lib/rocksky/resources/playlist.rb
-- lib/rocksky/resources/scrobble.rb
-- lib/rocksky/resources/shout.rb
-- lib/rocksky/resources/song.rb
-- lib/rocksky/resources/spotify.rb
-- lib/rocksky/resources/stats.rb
+- lib/rocksky/manifest.json
+- lib/rocksky/native.rb
 - lib/rocksky/version.rb
 - rocksky.gemspec
 homepage: https://github.com/tsirysndr/rocksky
@@ -127,5 +109,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.10
 specification_version: 4
-summary: Ruby client for the Rocksky XRPC API.
+summary: Ruby SDK for Rocksky — native bindings to the shared Rust core.
 test_files: []