@rocksky/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1492 @@
+// src/errors.ts
+class RockskyError extends Error {
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "RockskyError";
+    this.cause = options?.cause;
+  }
+}
+
+class RockskyHttpError extends RockskyError {
+  status;
+  statusText;
+  url;
+  body;
+  constructor(args) {
+    const message = args.message ?? `Rocksky API ${args.status} ${args.statusText} at ${args.url}`;
+    super(message);
+    this.name = "RockskyHttpError";
+    this.status = args.status;
+    this.statusText = args.statusText;
+    this.url = args.url;
+    this.body = args.body;
+  }
+}
+
+class RockskyTimeoutError extends RockskyError {
+  constructor(ms) {
+    super(`Rocksky request timed out after ${ms}ms`);
+    this.name = "RockskyTimeoutError";
+  }
+}
+
+class RockskyAuthError extends RockskyError {
+  constructor(message = "Authentication required") {
+    super(message);
+    this.name = "RockskyAuthError";
+  }
+}
+
+// src/types.ts
+var DEFAULT_BASE_URL = "https://api.rocksky.app";
+
+// src/http.ts
+function buildConfig(opts) {
+  const headers = {
+    accept: "application/json",
+    ...opts.userAgent ? { "user-agent": opts.userAgent } : {},
+    ...opts.headers ?? {}
+  };
+  return {
+    baseUrl: stripTrailingSlash(opts.baseUrl ?? DEFAULT_BASE_URL),
+    auth: opts.auth,
+    fetch: opts.fetch ?? globalThis.fetch.bind(globalThis),
+    headers,
+    timeoutMs: opts.timeoutMs ?? 30000,
+    retries: opts.retries ?? 0,
+    retryDelayMs: opts.retryDelayMs ?? 300
+  };
+}
+function stripTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+async function resolveAuth(provider) {
+  if (provider == null)
+    return;
+  if (typeof provider === "string")
+    return provider;
+  return await provider();
+}
+function serializeParams(params) {
+  if (!params)
+    return "";
+  const usp = new URLSearchParams;
+  for (const [k, v] of Object.entries(params)) {
+    if (v == null)
+      continue;
+    if (Array.isArray(v)) {
+      for (const item of v) {
+        if (item == null)
+          continue;
+        usp.append(k, String(item));
+      }
+    } else if (typeof v === "boolean") {
+      usp.append(k, v ? "true" : "false");
+    } else {
+      usp.append(k, String(v));
+    }
+  }
+  const s = usp.toString();
+  return s ? `?${s}` : "";
+}
+async function xrpcCall(config, nsid, method, opts = {}) {
+  const url = `${config.baseUrl}/xrpc/${nsid}` + serializeParams(opts.params);
+  const timeoutMs = opts.timeoutMs ?? config.timeoutMs;
+  const retries = opts.retries ?? config.retries;
+  const headers = {
+    ...config.headers,
+    ...opts.headers ?? {}
+  };
+  const authProvider = opts.auth === undefined ? config.auth : opts.auth;
+  const token = await resolveAuth(authProvider);
+  if (token) {
+    headers.authorization = `Bearer ${token}`;
+  } else if (opts.requireAuth) {
+    throw new RockskyAuthError(`${nsid} requires authentication — provide an "auth" token`);
+  }
+  const init = {
+    method,
+    headers,
+    signal: opts.signal
+  };
+  if (method === "POST" && opts.body !== undefined) {
+    headers["content-type"] = "application/json";
+    init.body = JSON.stringify(opts.body);
+  }
+  let lastErr;
+  for (let attempt = 0;attempt <= retries; attempt++) {
+    try {
+      return await runOnce(config.fetch, url, init, timeoutMs);
+    } catch (err) {
+      lastErr = err;
+      if (!isRetryable(err) || attempt === retries)
+        throw err;
+      await sleep(config.retryDelayMs * Math.pow(2, attempt));
+    }
+  }
+  throw lastErr;
+}
+async function runOnce(fetchImpl, url, init, timeoutMs) {
+  const controller = new AbortController;
+  const upstream = init.signal;
+  const onAbort = () => controller.abort(upstream?.reason);
+  upstream?.addEventListener("abort", onAbort, { once: true });
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, { ...init, signal: controller.signal });
+    const text = await res.text();
+    const body = parseMaybeJson(text);
+    if (!res.ok) {
+      throw new RockskyHttpError({
+        status: res.status,
+        statusText: res.statusText,
+        url,
+        body
+      });
+    }
+    return body;
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "AbortError") {
+      if (upstream?.aborted)
+        throw err;
+      throw new RockskyTimeoutError(timeoutMs);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+    upstream?.removeEventListener("abort", onAbort);
+  }
+}
+function parseMaybeJson(text) {
+  if (!text)
+    return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function isRetryable(err) {
+  if (err instanceof RockskyTimeoutError)
+    return true;
+  if (err instanceof RockskyHttpError) {
+    return err.status >= 500 || err.status === 429;
+  }
+  return false;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/paginate.ts
+function paginate(args) {
+  const pageSize = args.pageSize ?? 50;
+  const maxItems = args.maxItems ?? Number.POSITIVE_INFINITY;
+  async function* iter() {
+    let offset = 0;
+    let cursor;
+    let yielded = 0;
+    while (yielded < maxItems) {
+      checkAbort(args.signal);
+      const result = await args.fetch({ limit: pageSize, offset, cursor });
+      checkAbort(args.signal);
+      const { items, nextCursor } = normalize(result);
+      if (items.length === 0)
+        return;
+      for (const item of items) {
+        if (yielded >= maxItems)
+          return;
+        yield item;
+        yielded++;
+      }
+      offset += items.length;
+      if (nextCursor !== undefined) {
+        if (nextCursor === cursor || nextCursor === null)
+          return;
+        cursor = nextCursor ?? undefined;
+      } else if (items.length < pageSize) {
+        return;
+      }
+    }
+  }
+  const iterable = { [Symbol.asyncIterator]: iter };
+  return Object.assign(iterable, {
+    async toArray() {
+      const out = [];
+      for await (const item of iter())
+        out.push(item);
+      return out;
+    }
+  });
+}
+function normalize(result) {
+  if (Array.isArray(result))
+    return { items: result };
+  return { items: result.items, nextCursor: result.cursor ?? null };
+}
+function checkAbort(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("aborted", "AbortError");
+  }
+}
+
+// src/realtime.ts
+var RECONNECT_DEFAULTS = {
+  backoffMs: 500,
+  maxBackoffMs: 30000,
+  maxAttempts: Number.POSITIVE_INFINITY,
+  factor: 2
+};
+
+class RealtimeClient {
+  options;
+  ws;
+  listeners = new Map;
+  reconnectAttempts = 0;
+  pingTimer;
+  closed = false;
+  deviceId;
+  url;
+  reconnectOpts;
+  WsCtor;
+  constructor(options) {
+    this.options = options;
+    this.url = options.url ?? deriveWsUrl(options.baseUrl ?? DEFAULT_BASE_URL);
+    this.reconnectOpts = options.reconnect === false ? null : {
+      ...RECONNECT_DEFAULTS,
+      ...typeof options.reconnect === "object" ? options.reconnect : {}
+    };
+    const ctor = options.webSocket ?? globalThis.WebSocket;
+    if (!ctor) {
+      throw new RockskyError("No WebSocket implementation available — pass `webSocket` in options");
+    }
+    this.WsCtor = ctor;
+  }
+  get currentDeviceId() {
+    return this.deviceId;
+  }
+  get isOpen() {
+    return this.ws?.readyState === 1;
+  }
+  on(event, listener) {
+    const set = this.listeners.get(event) ?? new Set;
+    set.add(listener);
+    this.listeners.set(event, set);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set)
+      return;
+    for (const fn of set) {
+      try {
+        fn(payload);
+      } catch (err) {
+        const errSet = this.listeners.get("error");
+        errSet?.forEach((f) => f(err));
+      }
+    }
+  }
+  async connect() {
+    this.closed = false;
+    const ws = new this.WsCtor(this.url);
+    this.ws = ws;
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        resolve();
+      };
+      const onError = (err) => {
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        reject(err);
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+    });
+    this.attachHandlers(ws);
+    this.reconnectAttempts = 0;
+    this.emit("open", undefined);
+    if (this.options.autoRegister !== false) {
+      await this.register();
+    }
+    this.startPing();
+  }
+  async register() {
+    const token = await resolveToken(this.options.token);
+    this.sendRaw({
+      type: "register",
+      clientName: this.options.clientName ?? "rocksky-sdk",
+      token
+    });
+  }
+  async sendMessage(data) {
+    if (!this.deviceId) {
+      throw new RockskyError("Cannot send message — device not registered yet (await connect() first)");
+    }
+    const token = await resolveToken(this.options.token);
+    this.sendRaw({
+      type: "message",
+      data,
+      device_id: this.deviceId,
+      token
+    });
+  }
+  async sendControl(args) {
+    const token = await resolveToken(this.options.token);
+    this.sendRaw({
+      type: args.type ?? "control",
+      target: args.target,
+      action: args.action,
+      args: args.args,
+      token
+    });
+  }
+  ping() {
+    if (this.ws?.readyState === 1)
+      this.ws.send("ping");
+  }
+  sendRaw(payload) {
+    if (this.ws?.readyState !== 1) {
+      throw new RockskyError("WebSocket is not open");
+    }
+    this.ws.send(typeof payload === "string" ? payload : JSON.stringify(payload));
+  }
+  async close(code = 1000, reason = "client closing") {
+    this.closed = true;
+    this.stopPing();
+    this.ws?.close(code, reason);
+  }
+  attachHandlers(ws) {
+    ws.addEventListener("message", (event) => {
+      const raw = event.data;
+      if (raw === "pong")
+        return;
+      let parsed;
+      try {
+        parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+      } catch {
+        this.emit("raw", raw);
+        return;
+      }
+      this.emit("raw", parsed);
+      this.dispatch(parsed);
+    });
+    ws.addEventListener("close", (event) => {
+      this.stopPing();
+      this.emit("close", event);
+      if (!this.closed && this.reconnectOpts)
+        this.scheduleReconnect();
+    });
+    ws.addEventListener("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+  dispatch(msg) {
+    if (!msg || typeof msg !== "object")
+      return;
+    const m = msg;
+    if (m.status === "registered" && typeof m.deviceId === "string") {
+      this.deviceId = m.deviceId;
+      this.emit("registered", { deviceId: m.deviceId });
+      return;
+    }
+    if (m.type === "device_registered" && typeof m.deviceId === "string") {
+      this.emit("deviceRegistered", {
+        deviceId: m.deviceId,
+        clientName: String(m.clientName ?? "")
+      });
+      return;
+    }
+    if (m.type === "message" && typeof m.device_id === "string") {
+      this.emit("message", {
+        data: m.data,
+        device_id: m.device_id
+      });
+      return;
+    }
+    if (typeof m.action === "string") {
+      this.emit("control", {
+        type: String(m.type ?? "control"),
+        action: m.action,
+        args: m.args
+      });
+    }
+  }
+  scheduleReconnect() {
+    if (!this.reconnectOpts)
+      return;
+    if (this.reconnectAttempts >= this.reconnectOpts.maxAttempts)
+      return;
+    const delay = Math.min(this.reconnectOpts.backoffMs * Math.pow(this.reconnectOpts.factor, this.reconnectAttempts), this.reconnectOpts.maxBackoffMs);
+    this.reconnectAttempts++;
+    setTimeout(() => {
+      if (this.closed)
+        return;
+      this.connect().catch((err) => this.emit("error", err));
+    }, delay);
+  }
+  startPing() {
+    const ms = this.options.pingIntervalMs ?? 25000;
+    if (ms <= 0)
+      return;
+    this.pingTimer = setInterval(() => this.ping(), ms);
+  }
+  stopPing() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = undefined;
+    }
+  }
+}
+function createRealtimeClient(opts) {
+  return new RealtimeClient(opts);
+}
+
+class RealtimeClientBuilder {
+  opts = {};
+  url(u) {
+    this.opts.url = u;
+    return this;
+  }
+  baseUrl(u) {
+    this.opts.baseUrl = u;
+    return this;
+  }
+  token(t) {
+    this.opts.token = t;
+    return this;
+  }
+  clientName(name) {
+    this.opts.clientName = name;
+    return this;
+  }
+  autoRegister(value) {
+    this.opts.autoRegister = value;
+    return this;
+  }
+  reconnect(value) {
+    this.opts.reconnect = value;
+    return this;
+  }
+  pingInterval(ms) {
+    this.opts.pingIntervalMs = ms;
+    return this;
+  }
+  webSocket(ctor) {
+    this.opts.webSocket = ctor;
+    return this;
+  }
+  build() {
+    if (!this.opts.token) {
+      throw new RockskyError("RealtimeClientBuilder: token() is required before build()");
+    }
+    return new RealtimeClient(this.opts);
+  }
+}
+((RealtimeClient) => {
+  function builder() {
+    return new RealtimeClientBuilder;
+  }
+  RealtimeClient.builder = builder;
+})(RealtimeClient ||= {});
+function deriveWsUrl(httpBase) {
+  const u = new URL(httpBase);
+  u.protocol = u.protocol === "https:" ? "wss:" : "ws:";
+  u.pathname = u.pathname.replace(/\/$/, "") + "/ws";
+  return u.toString();
+}
+async function resolveToken(source) {
+  return typeof source === "function" ? await source() : source;
+}
+
+// src/namespaces/actor.ts
+class ActorNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getProfile(params = {}, opts) {
+    return this.call("app.rocksky.actor.getProfile", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getActorAlbums(params, opts) {
+    return this.call("app.rocksky.actor.getActorAlbums", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getActorArtists(params, opts) {
+    return this.call("app.rocksky.actor.getActorArtists", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getActorSongs(params, opts) {
+    return this.call("app.rocksky.actor.getActorSongs", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getActorScrobbles(params, opts) {
+    return this.call("app.rocksky.actor.getActorScrobbles", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getActorLovedSongs(params, opts) {
+    return this.call("app.rocksky.actor.getActorLovedSongs", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getActorPlaylists(params, opts) {
+    return this.call("app.rocksky.actor.getActorPlaylists", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getActorNeighbours(params, opts) {
+    return this.call("app.rocksky.actor.getActorNeighbours", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getActorCompatibility(params, opts) {
+    return this.call("app.rocksky.actor.getActorCompatibility", "GET", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/album.ts
+class AlbumNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getAlbum(params, opts) {
+    return this.call("app.rocksky.album.getAlbum", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getAlbums(params = {}, opts) {
+    return this.call("app.rocksky.album.getAlbums", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getAlbumTracks(params, opts) {
+    return this.call("app.rocksky.album.getAlbumTracks", "GET", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/apikey.ts
+class ApikeyNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getApikeys(params = {}, opts) {
+    return this.call("app.rocksky.apikey.getApikeys", "GET", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  createApikey(input, opts) {
+    return this.call("app.rocksky.apikey.createApikey", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  updateApikey(input, opts) {
+    return this.call("app.rocksky.apikey.updateApikey", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  removeApikey(params, opts) {
+    return this.call("app.rocksky.apikey.removeApikey", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/artist.ts
+class ArtistNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getArtist(params, opts) {
+    return this.call("app.rocksky.artist.getArtist", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getArtists(params = {}, opts) {
+    return this.call("app.rocksky.artist.getArtists", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getArtistAlbums(params, opts) {
+    return this.call("app.rocksky.artist.getArtistAlbums", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getArtistTracks(params = {}, opts) {
+    return this.call("app.rocksky.artist.getArtistTracks", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getArtistListeners(params, opts) {
+    return this.call("app.rocksky.artist.getArtistListeners", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getArtistRecentListeners(params, opts) {
+    return this.call("app.rocksky.artist.getArtistRecentListeners", "GET", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/charts.ts
+class ChartsNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getScrobblesChart(params = {}, opts) {
+    return this.call("app.rocksky.charts.getScrobblesChart", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getTopArtists(params = {}, opts) {
+    return this.call("app.rocksky.charts.getTopArtists", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getTopTracks(params = {}, opts) {
+    return this.call("app.rocksky.charts.getTopTracks", "GET", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/dropbox.ts
+class DropboxNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getFiles(params = {}, opts) {
+    return this.call("app.rocksky.dropbox.getFiles", "GET", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  getMetadata(params, opts) {
+    return this.call("app.rocksky.dropbox.getMetadata", "GET", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  getTemporaryLink(params, opts) {
+    return this.call("app.rocksky.dropbox.getTemporaryLink", "GET", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  downloadFile(params, opts) {
+    return this.call("app.rocksky.dropbox.downloadFile", "GET", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/feed.ts
+class FeedNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  search(params, opts) {
+    return this.call("app.rocksky.feed.search", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getFeed(params, opts) {
+    return this.call("app.rocksky.feed.getFeed", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getFeedGenerators(params = {}, opts) {
+    return this.call("app.rocksky.feed.getFeedGenerators", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getFeedGenerator(params, opts) {
+    return this.call("app.rocksky.feed.getFeedGenerator", "GET", {
+      params,
+      ...opts
+    });
+  }
+  describeFeedGenerator(opts) {
+    return this.call("app.rocksky.feed.describeFeedGenerator", "GET", {
+      ...opts
+    });
+  }
+  getFeedSkeleton(params, opts) {
+    return this.call("app.rocksky.feed.getFeedSkeleton", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getRecommendations(params, opts) {
+    return this.call("app.rocksky.feed.getRecommendations", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getArtistRecommendations(params, opts) {
+    return this.call("app.rocksky.feed.getArtistRecommendations", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getAlbumRecommendations(params, opts) {
+    return this.call("app.rocksky.feed.getAlbumRecommendations", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getStories(params = {}, opts) {
+    return this.call("app.rocksky.feed.getStories", "GET", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/googledrive.ts
+class GoogleDriveNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getFile(params, opts) {
+    return this.call("app.rocksky.googledrive.getFile", "GET", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  getFiles(params = {}, opts) {
+    return this.call("app.rocksky.googledrive.getFiles", "GET", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  downloadFile(params, opts) {
+    return this.call("app.rocksky.googledrive.downloadFile", "GET", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/graph.ts
+class GraphNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  followAccount(params, opts) {
+    return this.call("app.rocksky.graph.followAccount", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  unfollowAccount(params, opts) {
+    return this.call("app.rocksky.graph.unfollowAccount", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  getFollowers(params, opts) {
+    return this.call("app.rocksky.graph.getFollowers", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getFollows(params, opts) {
+    return this.call("app.rocksky.graph.getFollows", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getKnownFollowers(params, opts) {
+    return this.call("app.rocksky.graph.getKnownFollowers", "GET", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/like.ts
+class LikeNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  likeSong(input = {}, opts) {
+    return this.call("app.rocksky.like.likeSong", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  dislikeSong(input = {}, opts) {
+    return this.call("app.rocksky.like.dislikeSong", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  likeShout(input = {}, opts) {
+    return this.call("app.rocksky.like.likeShout", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  dislikeShout(input = {}, opts) {
+    return this.call("app.rocksky.like.dislikeShout", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/mirror.ts
+class MirrorNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getMirrorSources(opts) {
+    return this.call("app.rocksky.mirror.getMirrorSources", "GET", {
+      requireAuth: true,
+      ...opts
+    });
+  }
+  putMirrorSource(input, opts) {
+    return this.call("app.rocksky.mirror.putMirrorSource", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/player.ts
+class PlayerNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getCurrentlyPlaying(params = {}, opts) {
+    return this.call("app.rocksky.player.getCurrentlyPlaying", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getPlaybackQueue(params = {}, opts) {
+    return this.call("app.rocksky.player.getPlaybackQueue", "GET", {
+      params,
+      ...opts
+    });
+  }
+  play(params = {}, opts) {
+    return this.call("app.rocksky.player.play", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  pause(params = {}, opts) {
+    return this.call("app.rocksky.player.pause", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  next(params = {}, opts) {
+    return this.call("app.rocksky.player.next", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  previous(params = {}, opts) {
+    return this.call("app.rocksky.player.previous", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  seek(params, opts) {
+    return this.call("app.rocksky.player.seek", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  playFile(params, opts) {
+    return this.call("app.rocksky.player.playFile", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  playDirectory(params, opts) {
+    return this.call("app.rocksky.player.playDirectory", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  addItemsToQueue(params, opts) {
+    return this.call("app.rocksky.player.addItemsToQueue", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  addDirectoryToQueue(params, opts) {
+    return this.call("app.rocksky.player.addDirectoryToQueue", "POST", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/playlist.ts
+class PlaylistNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getPlaylists(params = {}, opts) {
+    return this.call("app.rocksky.playlist.getPlaylists", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getPlaylist(params, opts) {
+    return this.call("app.rocksky.playlist.getPlaylist", "GET", {
+      params,
+      ...opts
+    });
+  }
+  createPlaylist(params, opts) {
+    return this.call("app.rocksky.playlist.createPlaylist", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  removePlaylist(params, opts) {
+    return this.call("app.rocksky.playlist.removePlaylist", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  startPlaylist(params, opts) {
+    return this.call("app.rocksky.playlist.startPlaylist", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  insertDirectory(params, opts) {
+    return this.call("app.rocksky.playlist.insertDirectory", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  insertFiles(params, opts) {
+    return this.call("app.rocksky.playlist.insertFiles", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  removeTrack(params, opts) {
+    return this.call("app.rocksky.playlist.removeTrack", "POST", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/scrobble.ts
+class ScrobbleNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  createScrobble(input, opts) {
+    return this.call("app.rocksky.scrobble.createScrobble", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  getScrobble(params, opts) {
+    return this.call("app.rocksky.scrobble.getScrobble", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getScrobbles(params = {}, opts) {
+    return this.call("app.rocksky.scrobble.getScrobbles", "GET", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/shout.ts
+class ShoutNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  createShout(input = {}, opts) {
+    return this.call("app.rocksky.shout.createShout", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  replyShout(input, opts) {
+    return this.call("app.rocksky.shout.replyShout", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  reportShout(input, opts) {
+    return this.call("app.rocksky.shout.reportShout", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  removeShout(params, opts) {
+    return this.call("app.rocksky.shout.removeShout", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+  getShoutReplies(params, opts) {
+    return this.call("app.rocksky.shout.getShoutReplies", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getProfileShouts(params, opts) {
+    return this.call("app.rocksky.shout.getProfileShouts", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getTrackShouts(params, opts) {
+    return this.call("app.rocksky.shout.getTrackShouts", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getArtistShouts(params, opts) {
+    return this.call("app.rocksky.shout.getArtistShouts", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getAlbumShouts(params, opts) {
+    return this.call("app.rocksky.shout.getAlbumShouts", "GET", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/song.ts
+class SongNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getSong(params, opts) {
+    return this.call("app.rocksky.song.getSong", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getSongs(params = {}, opts) {
+    return this.call("app.rocksky.song.getSongs", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getSongRecentListeners(params, opts) {
+    return this.call("app.rocksky.song.getSongRecentListeners", "GET", {
+      params,
+      ...opts
+    });
+  }
+  matchSong(params, opts) {
+    return this.call("app.rocksky.song.matchSong", "GET", {
+      params,
+      ...opts
+    });
+  }
+  createSong(input, opts) {
+    return this.call("app.rocksky.song.createSong", "POST", {
+      body: input,
+      requireAuth: true,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/spotify.ts
+class SpotifyNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getCurrentlyPlaying(params = {}, opts) {
+    return this.call("app.rocksky.spotify.getCurrentlyPlaying", "GET", {
+      params,
+      ...opts
+    });
+  }
+  play(opts) {
+    return this.call("app.rocksky.spotify.play", "POST", {
+      requireAuth: true,
+      ...opts
+    });
+  }
+  pause(opts) {
+    return this.call("app.rocksky.spotify.pause", "POST", {
+      requireAuth: true,
+      ...opts
+    });
+  }
+  next(opts) {
+    return this.call("app.rocksky.spotify.next", "POST", {
+      requireAuth: true,
+      ...opts
+    });
+  }
+  previous(opts) {
+    return this.call("app.rocksky.spotify.previous", "POST", {
+      requireAuth: true,
+      ...opts
+    });
+  }
+  seek(params, opts) {
+    return this.call("app.rocksky.spotify.seek", "POST", {
+      params,
+      requireAuth: true,
+      ...opts
+    });
+  }
+}
+
+// src/namespaces/stats.ts
+class StatsNamespace {
+  call;
+  constructor(call) {
+    this.call = call;
+  }
+  getStats(params, opts) {
+    return this.call("app.rocksky.stats.getStats", "GET", {
+      params,
+      ...opts
+    });
+  }
+  getWrapped(params, opts) {
+    return this.call("app.rocksky.stats.getWrapped", "GET", {
+      params,
+      ...opts
+    });
+  }
+}
+
+// src/client.ts
+class RockskyClient {
+  config;
+  actor;
+  album;
+  apikey;
+  artist;
+  charts;
+  dropbox;
+  feed;
+  googledrive;
+  graph;
+  like;
+  mirror;
+  player;
+  playlist;
+  scrobble;
+  shout;
+  song;
+  spotify;
+  stats;
+  constructor(options = {}) {
+    this.config = buildConfig(options);
+    const call = (nsid, method, opts) => xrpcCall(this.config, nsid, method, opts ?? {});
+    this.actor = new ActorNamespace(call);
+    this.album = new AlbumNamespace(call);
+    this.apikey = new ApikeyNamespace(call);
+    this.artist = new ArtistNamespace(call);
+    this.charts = new ChartsNamespace(call);
+    this.dropbox = new DropboxNamespace(call);
+    this.feed = new FeedNamespace(call);
+    this.googledrive = new GoogleDriveNamespace(call);
+    this.graph = new GraphNamespace(call);
+    this.like = new LikeNamespace(call);
+    this.mirror = new MirrorNamespace(call);
+    this.player = new PlayerNamespace(call);
+    this.playlist = new PlaylistNamespace(call);
+    this.scrobble = new ScrobbleNamespace(call);
+    this.shout = new ShoutNamespace(call);
+    this.song = new SongNamespace(call);
+    this.spotify = new SpotifyNamespace(call);
+    this.stats = new StatsNamespace(call);
+  }
+  withAuth(auth) {
+    return new RockskyClient({
+      ...this.optionsSnapshot(),
+      auth
+    });
+  }
+  withBaseUrl(baseUrl) {
+    return new RockskyClient({
+      ...this.optionsSnapshot(),
+      baseUrl
+    });
+  }
+  realtime(options) {
+    return createRealtimeClient({
+      baseUrl: this.config.baseUrl,
+      ...options
+    });
+  }
+  paginate(args) {
+    return paginate(args);
+  }
+  xrpc(nsid, method = "GET", opts = {}) {
+    return xrpcCall(this.config, nsid, method, opts);
+  }
+  static builder() {
+    return new RockskyClientBuilder;
+  }
+  optionsSnapshot() {
+    return {
+      baseUrl: this.config.baseUrl,
+      auth: this.config.auth,
+      fetch: this.config.fetch,
+      headers: this.config.headers,
+      timeoutMs: this.config.timeoutMs,
+      retries: this.config.retries,
+      retryDelayMs: this.config.retryDelayMs
+    };
+  }
+}
+
+class RockskyClientBuilder {
+  opts = {};
+  baseUrl(url) {
+    this.opts.baseUrl = url;
+    return this;
+  }
+  auth(auth) {
+    this.opts.auth = auth;
+    return this;
+  }
+  bearer(token) {
+    this.opts.auth = token;
+    return this;
+  }
+  fetch(impl) {
+    this.opts.fetch = impl;
+    return this;
+  }
+  header(key, value) {
+    this.opts.headers = { ...this.opts.headers, [key]: value };
+    return this;
+  }
+  headers(headers) {
+    this.opts.headers = { ...this.opts.headers, ...headers };
+    return this;
+  }
+  userAgent(ua) {
+    this.opts.userAgent = ua;
+    return this;
+  }
+  timeout(ms) {
+    this.opts.timeoutMs = ms;
+    return this;
+  }
+  retries(n) {
+    this.opts.retries = n;
+    return this;
+  }
+  retryDelay(ms) {
+    this.opts.retryDelayMs = ms;
+    return this;
+  }
+  build() {
+    return new RockskyClient(this.opts);
+  }
+}
+function createClient(options = {}) {
+  return new RockskyClient(options);
+}
+// src/pipe.ts
+function pipe(value, ...ops) {
+  let factory = typeof value === "function" ? value : () => value;
+  for (const op of ops)
+    factory = op(factory);
+  return factory();
+}
+function map(fn) {
+  return (factory) => async () => fn(await factory());
+}
+function tap(fn) {
+  return (factory) => async () => {
+    const a = await factory();
+    await fn(a);
+    return a;
+  };
+}
+function withRetry(times, options = {}) {
+  const delayMs = options.delayMs ?? 200;
+  const factor = options.factor ?? 2;
+  const shouldRetry = options.shouldRetry ?? (() => true);
+  return (factory) => async () => {
+    let lastErr;
+    for (let attempt = 0;attempt <= times; attempt++) {
+      try {
+        return await factory();
+      } catch (err) {
+        lastErr = err;
+        if (attempt === times || !shouldRetry(err, attempt))
+          throw err;
+        await sleep2(delayMs * Math.pow(factor, attempt));
+      }
+    }
+    throw lastErr;
+  };
+}
+function withTimeout(ms) {
+  return (factory) => () => new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new RockskyTimeoutError(ms)), ms);
+    factory().then((v) => {
+      clearTimeout(timer);
+      resolve(v);
+    }, (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+function withFallback(fallback) {
+  return (factory) => async () => {
+    try {
+      return await factory();
+    } catch (err) {
+      return typeof fallback === "function" ? await fallback(err) : fallback;
+    }
+  };
+}
+function catchError(handler) {
+  return (factory) => async () => {
+    try {
+      return await factory();
+    } catch (err) {
+      return await handler(err);
+    }
+  };
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+export {
+  withTimeout,
+  withRetry,
+  withFallback,
+  tap,
+  pipe,
+  paginate,
+  map,
+  createRealtimeClient,
+  createClient,
+  catchError,
+  RockskyTimeoutError,
+  RockskyHttpError,
+  RockskyError,
+  RockskyClientBuilder,
+  RockskyClient,
+  RockskyAuthError,
+  RealtimeClientBuilder,
+  RealtimeClient,
+  DEFAULT_BASE_URL
+};