@rocksky/sdk 0.12.0 → 0.14.0

package/src/client.ts

@@ -1,6 +1,7 @@
 import { Client, simpleFetchHandler } from "@atcute/client";
 
 import { RockskyError } from "./errors.js";
+import type { Filter } from "./filter.js";
 import { RockskyLibrary } from "./library.js";
 import type {
   ActorProfileViewBasic,
@@ -10,6 +11,8 @@ import type {
   ArtistViewBasic,
   ArtistViewDetailed,
   ChartsView,
+  CreateScrobbleInput,
+  FollowAccountOutput,
   FeedGeneratorsView,
   FeedRecommendationsView,
   FeedRecommendedAlbumsView,
@@ -36,10 +39,13 @@ import type {
   GetTrackShoutsOutput,
   GetUnreadCountOutput,
   ListNotificationsOutput,
+  MirrorSourceView,
   PlayerCurrentlyPlayingViewDetailed,
   PlayerPlaybackQueueViewDetailed,
   PlaylistGetPlaylistsOutput,
   PlaylistViewDetailed,
+  PutAudioSettingsInput,
+  PutMirrorSourceInput,
   RockboxSettingsView,
   ScrobbleViewBasic,
   SongViewBasic,
@@ -47,6 +53,7 @@ import type {
   StatsGlobalStatsView,
   StatsView,
   StatsWrappedView,
+  UnfollowAccountOutput,
   UpdateSeenOutput,
 } from "./generated/types.js";
 
@@ -135,7 +142,7 @@ export class RockskyClient {
       if (v !== undefined && v !== "") clean[k] = v;
     }
     const res = await this.rpc.get(nsid as never, { params: clean } as never);
-    if (!res.ok) throw new RockskyError(res.data);
+    if (!res.ok) throw new RockskyError(res.data, res.status);
     return res.data as T;
   }
 
@@ -160,6 +167,24 @@ export class RockskyClient {
     return this.query(nsid, params);
   }
 
+  /** Call any AppView procedure by nsid. `params` ride the query string (some
+   * procedures take their arguments there), `body` is the JSON input — omitted
+   * entirely when `undefined`. Escape hatch for procedures without a wrapper. */
+  async post<T = unknown>(
+    nsid: string,
+    opts: { params?: Record<string, unknown>; body?: unknown } = {},
+  ): Promise<T> {
+    const clean: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(opts.params ?? {})) {
+      if (v !== undefined && v !== "") clean[k] = v;
+    }
+    const call: Record<string, unknown> = { params: clean };
+    if (opts.body !== undefined) call.input = opts.body;
+    const res = await this.rpc.post(nsid as never, call as never);
+    if (!res.ok) throw new RockskyError(res.data, res.status);
+    return res.data as T;
+  }
+
   /** An actor's most-played songs. */
   async songs(actor: string, limit = 50, offset = 0): Promise<SongViewBasic[]> {
     const out = await this.query<{ tracks?: SongViewBasic[] }>("app.rocksky.actor.getActorSongs", {
@@ -229,32 +254,53 @@ export class RockskyClient {
     return out.artists ?? [];
   }
 
-  /** The album catalog, optionally filtered by `genre`. */
-  async catalogAlbums(limit = 50, offset = 0, genre?: string): Promise<AlbumViewBasic[]> {
+  /** The album catalog, optionally filtered by `genre` and/or an RSQL
+   * {@link Filter} expression (see {@link AlbumFields}). */
+  async catalogAlbums(
+    limit = 50,
+    offset = 0,
+    genre?: string,
+    filter?: string | Filter,
+  ): Promise<AlbumViewBasic[]> {
     const out = await this.query<{ albums?: AlbumViewBasic[] }>("app.rocksky.album.getAlbums", {
       limit,
       offset,
       genre,
+      filter: filter?.toString(),
     });
     return out.albums ?? [];
   }
 
-  /** The artist catalog, optionally filtered by `genre`. */
-  async catalogArtists(limit = 50, offset = 0, genre?: string): Promise<ArtistViewBasic[]> {
+  /** The artist catalog, optionally filtered by `genre` and/or an RSQL
+   * {@link Filter} expression (see {@link ArtistFields}). */
+  async catalogArtists(
+    limit = 50,
+    offset = 0,
+    genre?: string,
+    filter?: string | Filter,
+  ): Promise<ArtistViewBasic[]> {
     const out = await this.query<{ artists?: ArtistViewBasic[] }>("app.rocksky.artist.getArtists", {
       limit,
       offset,
       genre,
+      filter: filter?.toString(),
     });
     return out.artists ?? [];
   }
 
-  /** The song catalog, optionally filtered by `genre`. */
-  async catalogSongs(limit = 50, offset = 0, genre?: string): Promise<SongViewBasic[]> {
+  /** The song catalog, optionally filtered by `genre` and/or an RSQL
+   * {@link Filter} expression (see {@link SongFields}). */
+  async catalogSongs(
+    limit = 50,
+    offset = 0,
+    genre?: string,
+    filter?: string | Filter,
+  ): Promise<SongViewBasic[]> {
     const out = await this.query<{ tracks?: SongViewBasic[] }>("app.rocksky.song.getSongs", {
       limit,
       offset,
       genre,
+      filter: filter?.toString(),
     });
     return out.tracks ?? [];
   }
@@ -282,13 +328,21 @@ export class RockskyClient {
   }
 
   /** A social/global scrobbles feed. Pass `did` to scope to an actor and
-   * `following = true` for their follow graph. */
-  async scrobbleFeed(did?: string, following = false, limit = 50, offset = 0): Promise<ScrobbleViewBasic[]> {
+   * `following = true` for their follow graph. `filter` takes an RSQL
+   * {@link Filter} expression (see {@link ScrobbleFields}). */
+  async scrobbleFeed(
+    did?: string,
+    following = false,
+    limit = 50,
+    offset = 0,
+    filter?: string | Filter,
+  ): Promise<ScrobbleViewBasic[]> {
     const out = await this.query<{ scrobbles?: ScrobbleViewBasic[] }>("app.rocksky.scrobble.getScrobbles", {
       did,
       following,
       limit,
       offset,
+      filter: filter?.toString(),
     });
     return out.scrobbles ?? [];
   }
@@ -509,7 +563,34 @@ export class RockskyClient {
     const res = await this.rpc.post("app.rocksky.notification.updateSeen" as never, {
       input: (ids && ids.length ? { ids } : {}) as never,
     } as never);
-    if (!res.ok) throw new RockskyError(res.data);
+    if (!res.ok) throw new RockskyError(res.data, res.status);
     return res.data as UpdateSeenOutput;
   }
+
+  /** Follow an account by DID or handle (`app.rocksky.graph.followAccount`). Auth required. */
+  followAccount(account: string): Promise<FollowAccountOutput> {
+    return this.post("app.rocksky.graph.followAccount", { params: { account } });
+  }
+
+  /** Unfollow an account by DID or handle (`app.rocksky.graph.unfollowAccount`). Auth required. */
+  unfollowAccount(account: string): Promise<UnfollowAccountOutput> {
+    return this.post("app.rocksky.graph.unfollowAccount", { params: { account } });
+  }
+
+  /** Submit a scrobble through the AppView (`app.rocksky.scrobble.createScrobble`).
+   * Auth required. For direct-to-PDS scrobbling use {@link Agent} instead. */
+  createScrobble(input: CreateScrobbleInput): Promise<ScrobbleViewBasic> {
+    return this.post("app.rocksky.scrobble.createScrobble", { body: input });
+  }
+
+  /** Create or update a mirror source (`app.rocksky.mirror.putMirrorSource`). Auth required. */
+  putMirrorSource(input: PutMirrorSourceInput): Promise<MirrorSourceView> {
+    return this.post("app.rocksky.mirror.putMirrorSource", { body: input });
+  }
+
+  /** Patch the viewer's Rockbox audio settings (`app.rocksky.rockbox.putAudioSettings`).
+   * Auth required. */
+  putAudioSettings(input: PutAudioSettingsInput): Promise<RockboxSettingsView> {
+    return this.post("app.rocksky.rockbox.putAudioSettings", { body: input });
+  }
 }

package/src/errors.ts

@@ -1,10 +1,15 @@
-/** Error thrown when a Rocksky XRPC call returns a non-2xx `{ error, message }`. */
 export class RockskyError extends Error {
+  /** The XRPC error code (e.g. "InvalidRequest", "AuthMissing"), when the
+   * server sent one. */
   readonly kind?: string;
-  constructor(payload: unknown) {
+  /** The HTTP status of the failed response, when known. */
+  readonly status?: number;
+
+  constructor(payload: unknown, status?: number) {
     const p = payload as { error?: string; message?: string } | undefined;
     super(p?.message || p?.error || "rocksky request failed");
     this.name = "RockskyError";
     this.kind = p?.error;
+    this.status = status;
   }
 }

package/src/filter.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from "bun:test";
+import { AlbumFields, ArtistFields, Filter, ScrobbleFields, SongFields } from "./filter.js";
+
+describe("Filter", () => {
+  test("eq renders a bare value when safe", () => {
+    expect(Filter.eq("artist", "Radiohead").build()).toBe("artist==Radiohead");
+  });
+
+  test("eq quotes values with spaces", () => {
+    expect(Filter.eq("artist", "Daft Punk").build()).toBe('artist=="Daft Punk"');
+  });
+
+  test("eq escapes embedded quotes and backslashes", () => {
+    expect(Filter.eq("title", 'He said "hi"').build()).toBe('title=="He said \\"hi\\""');
+    expect(Filter.eq("title", "back\\slash").build()).toBe('title=="back\\\\slash"');
+  });
+
+  test("wildcards pass through unquoted", () => {
+    expect(Filter.eq("artist", "Daft*").build()).toBe("artist==Daft*");
+  });
+
+  test("ne", () => {
+    expect(Filter.ne("artist", "Eminem").build()).toBe("artist!=Eminem");
+  });
+
+  test("ordered comparisons render verbose operators", () => {
+    expect(Filter.gt("duration", 200000).build()).toBe("duration=gt=200000");
+    expect(Filter.ge("year", 2000).build()).toBe("year=ge=2000");
+    expect(Filter.lt("trackNumber", 5).build()).toBe("trackNumber=lt=5");
+    expect(Filter.le("year", 1999).build()).toBe("year=le=1999");
+  });
+
+  test("in and out lists", () => {
+    expect(Filter.in("genre", ["house", "electro"]).build()).toBe("genre=in=(house,electro)");
+    expect(Filter.out("genre", ["hip hop"]).build()).toBe('genre=out=("hip hop")');
+  });
+
+  test("in/out reject empty lists", () => {
+    expect(() => Filter.in("genre", [])).toThrow();
+    expect(() => Filter.out("genre", [])).toThrow();
+  });
+
+  test("null checks", () => {
+    expect(Filter.isNull("uri").build()).toBe("uri==null");
+    expect(Filter.isNotNull("uri").build()).toBe("uri!=null");
+  });
+
+  test("and joins with ;", () => {
+    const f = Filter.eq("artist", "Radiohead").and(Filter.gt("duration", 200000));
+    expect(f.build()).toBe("artist==Radiohead;duration=gt=200000");
+  });
+
+  test("or joins with ,", () => {
+    const f = Filter.eq("artist", "Radiohead").or(Filter.eq("artist", "Muse"));
+    expect(f.build()).toBe("artist==Radiohead,artist==Muse");
+  });
+
+  test("or nested in and is parenthesized", () => {
+    const left = Filter.eq("artist", "Radiohead").or(Filter.eq("artist", "Muse"));
+    expect(left.and(Filter.gt("duration", 200000)).build()).toBe(
+      "(artist==Radiohead,artist==Muse);duration=gt=200000",
+    );
+    const right = Filter.eq("genre", "house").or(Filter.eq("genre", "electro"));
+    expect(Filter.eq("artist", "Radiohead").and(right).build()).toBe(
+      "artist==Radiohead;(genre==house,genre==electro)",
+    );
+  });
+
+  test("and nested in or needs no parentheses", () => {
+    const f = Filter.eq("artist", "Radiohead")
+      .and(Filter.gt("duration", 200000))
+      .or(Filter.eq("genre", "house"));
+    expect(f.build()).toBe("artist==Radiohead;duration=gt=200000,genre==house");
+  });
+
+  test("booleans and dotted fields", () => {
+    expect(Filter.eq("user.handle", "tsiry.dev").build()).toBe("user.handle==tsiry.dev");
+    expect(Filter.eq("liked", true).build()).toBe("liked==true");
+  });
+
+  test("toString matches build so filters interpolate", () => {
+    const f = Filter.eq("artist", "Radiohead");
+    expect(`${f}`).toBe(f.build());
+  });
+
+  test("field constants map to server selectors", () => {
+    expect(SongFields.albumArtist).toBe("albumArtist");
+    expect(AlbumFields.releaseDate).toBe("releaseDate");
+    expect(ArtistFields.genres).toBe("genres");
+    expect(ScrobbleFields.trackArtist).toBe("track.artist");
+    expect(ScrobbleFields.userHandle).toBe("user.handle");
+    expect(Filter.eq(ScrobbleFields.artistGenres, "house").build()).toBe("artist.genres==house");
+  });
+});

package/src/filter.ts

@@ -0,0 +1,192 @@
+/**
+ * Fluent builder for RSQL filter expressions, accepted by the `filter`
+ * parameter of the catalog and scrobble-feed queries
+ * (app.rocksky.song.getSongs, app.rocksky.artist.getArtists,
+ * app.rocksky.album.getAlbums, app.rocksky.scrobble.getScrobbles).
+ *
+ * ```ts
+ * import { Filter } from "@rocksky/sdk";
+ *
+ * const filter = Filter.eq("artist", "Daft Punk")
+ *   .and(Filter.gt("duration", 200_000))
+ *   .or(Filter.in("genre", ["house", "electro"]));
+ *
+ * await client.catalogSongs(50, 0, undefined, filter);
+ * // artist=="Daft Punk";duration=gt=200000,genre=in=(house,electro)
+ * ```
+ *
+ * String values are quoted and escaped automatically when they contain
+ * characters RSQL reserves; `*` wildcards pass through unquoted so
+ * `Filter.eq("artist", "Daft*")` performs a case-insensitive match.
+ */
+export type FilterValue = string | number | boolean;
+
+/** Characters that never need quoting in an RSQL value (`*` kept bare so wildcards work). */
+const SAFE_VALUE = /^[A-Za-z0-9_.:@*+-]+$/;
+
+const renderValue = (value: FilterValue): string => {
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value.length > 0 && SAFE_VALUE.test(value)) return value;
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+};
+
+type NodeKind = "comparison" | "and" | "or";
+
+export class Filter {
+  private constructor(
+    private readonly expr: string,
+    private readonly kind: NodeKind,
+  ) {}
+
+  private static comparison(field: string, op: string, value: FilterValue): Filter {
+    return new Filter(`${field}${op}${renderValue(value)}`, "comparison");
+  }
+
+  private static list(field: string, op: string, values: FilterValue[]): Filter {
+    if (values.length === 0) {
+      throw new Error(`Filter.${op === "=in=" ? "in" : "out"}("${field}", ...) needs at least one value`);
+    }
+    return new Filter(`${field}${op}(${values.map(renderValue).join(",")})`, "comparison");
+  }
+
+  /** `field==value` — equals; `*` in string values is a wildcard. */
+  static eq(field: string, value: FilterValue): Filter {
+    return Filter.comparison(field, "==", value);
+  }
+
+  /** `field!=value` — not equals. */
+  static ne(field: string, value: FilterValue): Filter {
+    return Filter.comparison(field, "!=", value);
+  }
+
+  /** `field=gt=value` — greater than. */
+  static gt(field: string, value: FilterValue): Filter {
+    return Filter.comparison(field, "=gt=", value);
+  }
+
+  /** `field=ge=value` — greater than or equal. */
+  static ge(field: string, value: FilterValue): Filter {
+    return Filter.comparison(field, "=ge=", value);
+  }
+
+  /** `field=lt=value` — less than. */
+  static lt(field: string, value: FilterValue): Filter {
+    return Filter.comparison(field, "=lt=", value);
+  }
+
+  /** `field=le=value` — less than or equal. */
+  static le(field: string, value: FilterValue): Filter {
+    return Filter.comparison(field, "=le=", value);
+  }
+
+  /** `field=in=(a,b)` — matches any of the values. */
+  static in(field: string, values: FilterValue[]): Filter {
+    return Filter.list(field, "=in=", values);
+  }
+
+  /** `field=out=(a,b)` — matches none of the values. */
+  static out(field: string, values: FilterValue[]): Filter {
+    return Filter.list(field, "=out=", values);
+  }
+
+  /** `field==null` — the field is NULL. */
+  static isNull(field: string): Filter {
+    return new Filter(`${field}==null`, "comparison");
+  }
+
+  /** `field!=null` — the field is not NULL. */
+  static isNotNull(field: string): Filter {
+    return new Filter(`${field}!=null`, "comparison");
+  }
+
+  /** Both sides must match (`;`). An `or` operand is parenthesized to keep RSQL precedence. */
+  and(other: Filter): Filter {
+    return new Filter(`${this.renderIn("and")};${other.renderIn("and")}`, "and");
+  }
+
+  /** Either side may match (`,`). */
+  or(other: Filter): Filter {
+    return new Filter(`${this.expr},${other.expr}`, "or");
+  }
+
+  private renderIn(parent: "and"): string {
+    return this.kind === "or" ? `(${this.expr})` : this.expr;
+  }
+
+  /** The RSQL expression string to send as the `filter` query param. */
+  build(): string {
+    return this.expr;
+  }
+
+  toString(): string {
+    return this.expr;
+  }
+}
+
+/** Filterable fields of app.rocksky.song.getSongs. */
+export const SongFields = {
+  title: "title",
+  artist: "artist",
+  album: "album",
+  albumArtist: "albumArtist",
+  genre: "genre",
+  composer: "composer",
+  label: "label",
+  duration: "duration",
+  trackNumber: "trackNumber",
+  discNumber: "discNumber",
+  mbId: "mbId",
+  isrc: "isrc",
+  sha256: "sha256",
+  uri: "uri",
+  albumUri: "albumUri",
+  artistUri: "artistUri",
+  createdAt: "createdAt",
+} as const;
+
+/** Filterable fields of app.rocksky.album.getAlbums. */
+export const AlbumFields = {
+  title: "title",
+  artist: "artist",
+  year: "year",
+  releaseDate: "releaseDate",
+  sha256: "sha256",
+  uri: "uri",
+  artistUri: "artistUri",
+  createdAt: "createdAt",
+} as const;
+
+/** Filterable fields of app.rocksky.artist.getArtists. */
+export const ArtistFields = {
+  name: "name",
+  genres: "genres",
+  bornIn: "bornIn",
+  born: "born",
+  died: "died",
+  sha256: "sha256",
+  uri: "uri",
+  createdAt: "createdAt",
+} as const;
+
+/** Filterable fields of app.rocksky.scrobble.getScrobbles (dotted selectors reach the joined track/user/artist). */
+export const ScrobbleFields = {
+  uri: "uri",
+  date: "date",
+  timestamp: "timestamp",
+  title: "title",
+  artist: "artist",
+  album: "album",
+  trackTitle: "track.title",
+  trackArtist: "track.artist",
+  trackAlbum: "track.album",
+  trackAlbumArtist: "track.albumArtist",
+  trackGenre: "track.genre",
+  trackDuration: "track.duration",
+  trackIsrc: "track.isrc",
+  trackMbId: "track.mbId",
+  userDid: "user.did",
+  userHandle: "user.handle",
+  userDisplayName: "user.displayName",
+  artistName: "artist.name",
+  artistGenres: "artist.genres",
+} as const;

package/src/generated/types.ts

@@ -243,6 +243,8 @@ export interface ArtistGetArtistsParams {
   names?: string;
   /** The genre to filter artists by */
   genre?: string;
+  /** RSQL filter expression, e.g. `name==Daft*;genres=in=(house,electro)`. Supports ==, !=, <, <=, >, >=, =in=, =out=, and `;`/`and`, `,`/`or` combinators, `*` wildcards in string values. Filterable fields: name, genres, bornIn, born, died, sha256, uri, createdAt */
+  filter?: string;
 }
 
 export interface ArtistListenerViewBasic {
@@ -847,6 +849,8 @@ export interface GetAlbumsParams {
   offset?: number;
   /** The genre to filter artists by */
   genre?: string;
+  /** RSQL filter expression, e.g. `artist=="Daft Punk";year=ge=2000`. Supports ==, !=, <, <=, >, >=, =in=, =out=, and `;`/`and`, `,`/`or` combinators, `*` wildcards in string values. Filterable fields: title, artist, year, releaseDate, sha256, uri, artistUri, createdAt */
+  filter?: string;
 }
 
 export interface GetAlbumTracksOutput {
@@ -1243,6 +1247,8 @@ export interface GetScrobblesParams {
   limit?: number;
   /** The offset for pagination */
   offset?: number;
+  /** RSQL filter expression, e.g. `track.artist=="Daft Punk";date=ge=2025-01-01`. Supports ==, !=, <, <=, >, >=, =in=, =out=, and `;`/`and`, `,`/`or` combinators, `*` wildcards in string values. Filterable fields: uri, date, timestamp, title, artist, album, track.title, track.artist, track.album, track.albumArtist, track.genre, track.duration, track.isrc, track.mbId, user.did, user.handle, user.displayName, artist.name, artist.genres */
+  filter?: string;
 }
 
 export interface GetShoutRepliesOutput {
@@ -1312,6 +1318,8 @@ export interface GetSongsParams {
   isrc?: string;
   /** Filter songs by Spotify track ID (resolved internally to the Spotify track URL) */
   spotifyId?: string;
+  /** RSQL filter expression, e.g. `artist=="Daft Punk";duration=gt=200000`. Supports ==, !=, <, <=, >, >=, =in=, =out=, and `;`/`and`, `,`/`or` combinators, `*` wildcards in string values. Filterable fields: title, artist, album, albumArtist, genre, composer, label, duration, trackNumber, discNumber, mbId, isrc, sha256, uri, albumUri, artistUri, createdAt */
+  filter?: string;
 }
 
 export interface GetStarredOutput {
@@ -1626,6 +1634,18 @@ export interface NotificationActor {
   avatar?: Uri;
 }
 
+/** The song, album, or scrobble a notification relates to, for rich display. */
+export interface NotificationSubjectView {
+  /** The at-uri of the subject. */
+  uri: string;
+  /** The title of the track or album. */
+  title?: string;
+  /** The artist of the track or album. */
+  artist?: string;
+  /** The album art image URL. */
+  albumArt?: Uri;
+}
+
 export interface NotificationView {
   /** The unique identifier of the notification. */
   id: string;
@@ -1642,6 +1662,7 @@ export interface NotificationView {
   /** The content of the related shout, if any. */
   shoutContent?: string;
   actor?: NotificationActor;
+  subject?: NotificationSubjectView;
 }
 
 export interface PingOutput {

package/src/hash.ts

@@ -1,9 +1,11 @@
-import { createHash } from "node:crypto";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
 
 // Lowercase-hex SHA-256 of s.toLowerCase() — the lowercasing is applied to the
 // whole string (not per field), matching Rocksky's server and every other SDK.
+// Pure-JS digest (@noble/hashes) so this module stays browser-safe.
 function sha256Lower(s: string): string {
-  return createHash("sha256").update(s.toLowerCase()).digest("hex");
+  return bytesToHex(sha256(new TextEncoder().encode(s.toLowerCase())));
 }
 
 /** Identity hash of a song: sha256(lower("{title} - {artist} - {album}")). */

package/src/index.ts

@@ -23,7 +23,9 @@ export {
   type RateLimitOptions,
   type RateLimitState,
 } from "./agent.js";
-export { RockskyIndex, totalIndexed, type IndexStats } from "./dedup.js";
+// The dedup index (classic-level, Node-only) lives on the `@rocksky/sdk/dedup`
+// subpath so this root entry stays browser-safe.
+export type { IndexStats, RockskyIndex } from "./dedup.js";
 export { runJetstream, DEFAULT_JETSTREAM_SERVERS, type JetstreamOptions } from "./jetstream.js";
 export {
   RemotePlayer,
@@ -41,6 +43,14 @@ export {
   type RemoteDevice,
   type RemoteStatus,
 } from "./remote-controller.js";
+export {
+  Filter,
+  SongFields,
+  AlbumFields,
+  ArtistFields,
+  ScrobbleFields,
+  type FilterValue,
+} from "./filter.js";
 export { songHash, albumHash, artistHash } from "./hash.js";
 export { RockskyError } from "./errors.js";
 export type * from "./generated/types.js";

package/src/library.ts

@@ -20,7 +20,7 @@ export class RockskyLibrary {
       if (v !== undefined && v !== "") clean[k] = v;
     }
     const res = await this.rpc.get(nsid as never, { params: clean } as never);
-    if (!res.ok) throw new RockskyError(res.data);
+    if (!res.ok) throw new RockskyError(res.data, res.status);
     return res.data as T;
   }
 
@@ -30,7 +30,7 @@ export class RockskyLibrary {
       if (v !== undefined && v !== "") clean[k] = v;
     }
     const res = await this.rpc.post(nsid as never, { input: clean } as never);
-    if (!res.ok) throw new RockskyError(res.data);
+    if (!res.ok) throw new RockskyError(res.data, res.status);
     return res.data as T;
   }
 

package/src/remote.ts

@@ -1,9 +1,8 @@
-// Browser-safe entry: the remote-control player + controller only.
+// Lightweight entry: the remote-control player + controller only.
 //
-// The main entry (`@rocksky/sdk`) bundles the dedup index (classic-level) and
-// the identity hashes (node:crypto), which are Node-only. The remote player /
-// controller are pure WebSocket + JSON with zero Node dependencies, so this
-// subpath (`@rocksky/sdk/remote`) is safe to import from a browser bundle.
+// Since 0.14.0 the main entry (`@rocksky/sdk`) is browser-safe too — the
+// dedup index (classic-level, Node-only) moved to `@rocksky/sdk/dedup`. This
+// subpath remains for consumers that only need the remote player/controller.
 
 export {
   RemotePlayer,