@misofm/api-client 0.1.2 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misofm/api-client",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Typed client and response contract for the Miso API read layer. The one definition of what a Miso read returns.",
   "license": "Apache-2.0",
   "repository": {

package/src/client.test.ts

@@ -2,17 +2,26 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { describe, expect, test } from "bun:test";
-import { cacheBuster, createMisoApiClient, MisoApiContractError, MisoApiError, READ_CACHE_CLASS } from "./client.ts";
+import {
+  cacheBuster,
+  createMisoApiClient,
+  MisoApiContractError,
+  MisoApiError,
+  READ_CACHE_CLASS,
+} from "./client.ts";
 
 /** A fetch that records the URL it was called with and replays a canned response. */
 function stubFetch(response: { status?: number; body?: unknown }) {
   const calls: string[] = [];
   const fetch = (async (input: string | URL) => {
     calls.push(String(input));
-    return new Response(response.body === undefined ? "" : JSON.stringify(response.body), {
-      status: response.status ?? 200,
-      headers: { "Content-Type": "application/json" },
-    });
+    return new Response(
+      response.body === undefined ? "" : JSON.stringify(response.body),
+      {
+        status: response.status ?? 200,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
   }) as unknown as typeof globalThis.fetch;
   return { fetch, calls };
 }
@@ -35,56 +44,98 @@ describe("URL construction", () => {
 
   test("tolerates a trailing slash on the base URL", async () => {
     const { fetch, calls } = stubFetch({ body: balance });
-    await createMisoApiClient({ baseUrl: `${BASE}/`, fetch }).getBalance("0xabc");
+    await createMisoApiClient({ baseUrl: `${BASE}/`, fetch }).getBalance(
+      "0xabc",
+    );
     expect(calls[0]).toBe(`${BASE}/read/v1/wallets/0xabc/balance`);
   });
 
   test("omits empty query params rather than sending them blank", async () => {
     const { fetch, calls } = stubFetch({ body: balance });
-    await createMisoApiClient({ baseUrl: BASE, fetch }).getBalance("0xabc", undefined);
+    await createMisoApiClient({ baseUrl: BASE, fetch }).getBalance(
+      "0xabc",
+      undefined,
+    );
     expect(calls[0]).not.toContain("coinType");
   });
 
   test("sends an explicit coin type when given one", async () => {
     const { fetch, calls } = stubFetch({ body: balance });
-    await createMisoApiClient({ baseUrl: BASE, fetch }).getBalance("0xabc", "0x2::sui::SUI");
+    await createMisoApiClient({ baseUrl: BASE, fetch }).getBalance(
+      "0xabc",
+      "0x2::sui::SUI",
+    );
     expect(calls[0]).toContain("coinType=0x2%3A%3Asui%3A%3ASUI");
   });
 
   test("joins the artist include list into one param", async () => {
     const { fetch, calls } = stubFetch({ status: 404 });
-    await createMisoApiClient({ baseUrl: BASE, fetch }).getArtist("0xp", { include: ["roles", "tags"] });
-    expect(calls[0]).toContain("include=roles%2Ctags");
+    await createMisoApiClient({ baseUrl: BASE, fetch }).getArtist("0xp", {
+      include: ["roles", "tags", "featured"],
+    });
+    expect(calls[0]).toContain("include=roles%2Ctags%2Cfeatured");
+  });
+
+  test("joins catalog relationship expansions into one param", async () => {
+    const { fetch, calls } = stubFetch({ status: 404 });
+    const client = createMisoApiClient({ baseUrl: BASE, fetch });
+    await client.getPressing("0xp", { include: ["trackCredits"] });
+    await client.getRelease("0xl", { include: ["trackCredits"] });
+    await client.getRecordAlbum("0xr", {
+      include: ["release", "trackCredits"],
+    });
+    expect(calls[0]).toContain("include=trackCredits");
+    expect(calls[1]).toContain("include=trackCredits");
+    expect(calls[2]).toContain("include=release%2CtrackCredits");
   });
 
   test("a custom prefix is honored (self-hosted / direct-to-service)", async () => {
     const { fetch, calls } = stubFetch({ body: balance });
-    await createMisoApiClient({ baseUrl: BASE, fetch, prefix: "/v1" }).getBalance("0xabc");
+    await createMisoApiClient({
+      baseUrl: BASE,
+      fetch,
+      prefix: "/v1",
+    }).getBalance("0xabc");
     expect(calls[0]).toBe(`${BASE}/v1/wallets/0xabc/balance`);
   });
 });
 
 describe("not-found handling", () => {
   test("a superseded pressing is null, not an error", async () => {
-    const { fetch } = stubFetch({ status: 404, body: { error: { code: "not_found", message: "gone" } } });
-    expect(await createMisoApiClient({ baseUrl: BASE, fetch }).getPressing("0xdead")).toBeNull();
+    const { fetch } = stubFetch({
+      status: 404,
+      body: { error: { code: "not_found", message: "gone" } },
+    });
+    expect(
+      await createMisoApiClient({ baseUrl: BASE, fetch }).getPressing("0xdead"),
+    ).toBeNull();
   });
 
   test("an unknown artist is null", async () => {
-    const { fetch } = stubFetch({ status: 404, body: { error: { code: "not_found", message: "gone" } } });
-    expect(await createMisoApiClient({ baseUrl: BASE, fetch }).getArtist("0xdead")).toBeNull();
+    const { fetch } = stubFetch({
+      status: 404,
+      body: { error: { code: "not_found", message: "gone" } },
+    });
+    expect(
+      await createMisoApiClient({ baseUrl: BASE, fetch }).getArtist("0xdead"),
+    ).toBeNull();
   });
 
   test("an empty id list short-circuits without a request", async () => {
     const { fetch, calls } = stubFetch({ body: [] });
-    expect(await createMisoApiClient({ baseUrl: BASE, fetch }).getArtists([])).toEqual([]);
+    expect(
+      await createMisoApiClient({ baseUrl: BASE, fetch }).getArtists([]),
+    ).toEqual([]);
     expect(calls).toHaveLength(0);
   });
 });
 
 describe("error handling", () => {
   test("surfaces the server's error code and message", async () => {
-    const { fetch } = stubFetch({ status: 429, body: { error: { code: "rate-limited", message: "Too many requests." } } });
+    const { fetch } = stubFetch({
+      status: 429,
+      body: { error: { code: "rate-limited", message: "Too many requests." } },
+    });
     const api = createMisoApiClient({ baseUrl: BASE, fetch });
     await expect(api.getDiscover()).rejects.toThrow(MisoApiError);
     try {
@@ -109,17 +160,24 @@ describe("error handling", () => {
   });
 
   test("a 404 on an endpoint that must return a body is an error, not null", async () => {
-    const { fetch } = stubFetch({ status: 404, body: { error: { code: "not_found", message: "gone" } } });
-    await expect(createMisoApiClient({ baseUrl: BASE, fetch }).getWalletRecords("0xabc")).rejects.toThrow(MisoApiError);
+    const { fetch } = stubFetch({
+      status: 404,
+      body: { error: { code: "not_found", message: "gone" } },
+    });
+    await expect(
+      createMisoApiClient({ baseUrl: BASE, fetch }).getWalletRecords("0xabc"),
+    ).rejects.toThrow(MisoApiError);
   });
 });
 
 describe("contract validation", () => {
   test("a response missing a required field fails loudly at the boundary", async () => {
-    const { fetch } = stubFetch({ body: { address: "0xabc", coinType: "0x2::sui::SUI" } }); // no balance
-    await expect(createMisoApiClient({ baseUrl: BASE, fetch }).getBalance("0xabc")).rejects.toThrow(
-      MisoApiContractError,
-    );
+    const { fetch } = stubFetch({
+      body: { address: "0xabc", coinType: "0x2::sui::SUI" },
+    }); // no balance
+    await expect(
+      createMisoApiClient({ baseUrl: BASE, fetch }).getBalance("0xabc"),
+    ).rejects.toThrow(MisoApiContractError);
   });
 
   test("a u64 sent as a NUMBER is rejected — the precision bug this contract exists to prevent", async () => {
@@ -131,7 +189,9 @@ describe("contract validation", () => {
   });
 
   test("the contract error names the field and points at version skew", async () => {
-    const { fetch } = stubFetch({ body: { ...balance, balance: "not-a-number" } });
+    const { fetch } = stubFetch({
+      body: { ...balance, balance: "not-a-number" },
+    });
     try {
       await createMisoApiClient({ baseUrl: BASE, fetch }).getBalance("0xabc");
       throw new Error("should have thrown");
@@ -143,7 +203,10 @@ describe("contract validation", () => {
 
   test("a valid response parses through to typed data", async () => {
     const { fetch } = stubFetch({ body: balance });
-    const result = await createMisoApiClient({ baseUrl: BASE, fetch }).getBalance("0xabc");
+    const result = await createMisoApiClient({
+      baseUrl: BASE,
+      fetch,
+    }).getBalance("0xabc");
     expect(result).toEqual(balance);
   });
 });
@@ -151,7 +214,12 @@ describe("contract validation", () => {
 describe("READ_CACHE_CLASS", () => {
   test("every wallet-scoped read is private", () => {
     for (const [method, cls] of Object.entries(READ_CACHE_CLASS)) {
-      if (method.startsWith("getWallet") || method.startsWith("owns") || method === "getBalance" || method === "getWork") {
+      if (
+        method.startsWith("getWallet") ||
+        method.startsWith("owns") ||
+        method === "getBalance" ||
+        method === "getWork"
+      ) {
         expect(cls).toBe("private");
       }
     }
@@ -177,7 +245,11 @@ describe("cache buster", () => {
 
   test("a supplied version rides on every read as ?v=", async () => {
     const { fetch, calls } = stubFetch({ body: balance });
-    const api = createMisoApiClient({ baseUrl: BASE, fetch, version: () => "1699999999" });
+    const api = createMisoApiClient({
+      baseUrl: BASE,
+      fetch,
+      version: () => "1699999999",
+    });
     await api.getBalance("0xabc");
     expect(calls[0]).toContain("v=1699999999");
   });
@@ -196,6 +268,8 @@ describe("cache buster", () => {
   test("cacheBuster is per-SECOND, so a burst after one write shares an entry", () => {
     // Millisecond granularity would mint a fresh cache entry per read.
     expect(cacheBuster(1_700_000_000_123)).toBe(cacheBuster(1_700_000_000_900));
-    expect(cacheBuster(1_700_000_000_000)).not.toBe(cacheBuster(1_700_000_001_000));
+    expect(cacheBuster(1_700_000_000_000)).not.toBe(
+      cacheBuster(1_700_000_001_000),
+    );
   });
 });

package/src/client.ts

@@ -23,8 +23,8 @@ import type {
   Balance,
   DiscoverShelf,
   DropPreview,
-  FeaturedRelease,
   OwnedParty,
+  PendingMembership,
   OwnedRecord,
   OwnedWork,
   Ownership,
@@ -33,7 +33,6 @@ import type {
   PurchaseReceipt,
   RecordAlbum,
   ReleaseDetail,
-  ReleaseTrackCredits,
   WorkDetail,
 } from "./types.ts";
 
@@ -102,7 +101,8 @@ export function createMisoApiClient(options: MisoApiClientOptions) {
   function url(path: string, query: Record<string, QueryValue> = {}): string {
     const u = new URL(`${base}${prefix}${path}`);
     for (const [k, v] of Object.entries(query)) {
-      if (v !== undefined && v !== null && v !== "") u.searchParams.set(k, String(v));
+      if (v !== undefined && v !== null && v !== "")
+        u.searchParams.set(k, String(v));
     }
     const v = options.version?.();
     if (v) u.searchParams.set("v", v);
@@ -116,7 +116,9 @@ export function createMisoApiClient(options: MisoApiClientOptions) {
     opts: { nullOn404?: boolean } = {},
   ): Promise<T | null> {
     const target = url(path, query);
-    const res = await doFetch(target, { headers: { Accept: "application/json" } });
+    const res = await doFetch(target, {
+      headers: { Accept: "application/json" },
+    });
 
     if (res.status === 404 && opts.nullOn404) return null;
 
@@ -124,52 +126,98 @@ export function createMisoApiClient(options: MisoApiClientOptions) {
       const body = await res.json().catch(() => null);
       const parsed = s.apiErrorSchema.safeParse(body);
       throw parsed.success
-        ? new MisoApiError(res.status, parsed.data.error.code, parsed.data.error.message)
-        : new MisoApiError(res.status, "unknown", `Request to ${path} failed (${res.status})`);
+        ? new MisoApiError(
+            res.status,
+            parsed.data.error.code,
+            parsed.data.error.message,
+          )
+        : new MisoApiError(
+            res.status,
+            "unknown",
+            `Request to ${path} failed (${res.status})`,
+          );
     }
 
     const json = await res.json().catch(() => {
-      throw new MisoApiError(res.status, "bad_response", `Response from ${path} was not JSON`);
+      throw new MisoApiError(
+        res.status,
+        "bad_response",
+        `Response from ${path} was not JSON`,
+      );
     });
 
     const parsed = schema.safeParse(json);
-    if (!parsed.success) throw new MisoApiContractError(path, parsed.error.issues);
+    if (!parsed.success)
+      throw new MisoApiContractError(path, parsed.error.issues);
     return parsed.data;
   }
 
   /** Same as `request`, for endpoints that always return a body. */
-  async function required<T>(schema: z.ZodType<T>, path: string, query?: Record<string, QueryValue>): Promise<T> {
+  async function required<T>(
+    schema: z.ZodType<T>,
+    path: string,
+    query?: Record<string, QueryValue>,
+  ): Promise<T> {
     return (await request(schema, path, query)) as T;
   }
 
   return {
     // ── Catalog ─────────────────────────────────────────────────────────────
     /** The records currently on sale. */
-    getDiscover: (): Promise<DiscoverShelf> => required(s.discoverShelfSchema, "/discover"),
+    getDiscover: (): Promise<DiscoverShelf> =>
+      required(s.discoverShelfSchema, "/discover"),
 
     /** A pressing and everything its buy page renders. `null` when there is no such pressing. */
-    getPressing: (pressingId: string): Promise<PressingDetail | null> =>
-      request(s.pressingDetailSchema, `/pressings/${pressingId}`, {}, { nullOn404: true }),
+    getPressing: (
+      pressingId: string,
+      opts: { include?: readonly "trackCredits"[] } = {},
+    ): Promise<PressingDetail | null> =>
+      request(
+        s.pressingDetailSchema,
+        `/pressings/${pressingId}`,
+        { include: opts.include?.join(",") },
+        { nullOn404: true },
+      ),
 
     /** A release with its cover, credits, and resolved tracklist. */
-    getRelease: (releaseId: string): Promise<ReleaseDetail | null> =>
-      request(s.releaseDetailSchema, `/releases/${releaseId}`, {}, { nullOn404: true }),
-
-    /** Per-track credits for a release, keyed by recording id. */
-    getReleaseTrackCredits: (releaseId: string): Promise<ReleaseTrackCredits> =>
-      required(s.releaseTrackCreditsSchema, `/releases/${releaseId}/credits`),
+    getRelease: (
+      releaseId: string,
+      opts: { include?: readonly "trackCredits"[] } = {},
+    ): Promise<ReleaseDetail | null> =>
+      request(
+        s.releaseDetailSchema,
+        `/releases/${releaseId}`,
+        { include: opts.include?.join(",") },
+        { nullOn404: true },
+      ),
 
     /** A record's parent release. Immutable for the life of the record. */
-    getRecordAlbum: (recordId: string): Promise<RecordAlbum | null> =>
-      request(s.recordAlbumSchema, `/records/${recordId}/album`, {}, { nullOn404: true }),
+    getRecordAlbum: (
+      recordId: string,
+      opts: { include?: readonly ("release" | "trackCredits")[] } = {},
+    ): Promise<RecordAlbum | null> =>
+      request(
+        s.recordAlbumSchema,
+        `/records/${recordId}/album`,
+        { include: opts.include?.join(",") },
+        { nullOn404: true },
+      ),
 
     /** Confirmation preview for a pasted pressing id. `null` when it isn't a pressing. */
     getDropPreview: (dropId: string): Promise<DropPreview | null> =>
-      request(s.dropPreviewSchema, `/drops/${dropId}/preview`, {}, { nullOn404: true }),
+      request(
+        s.dropPreviewSchema,
+        `/drops/${dropId}/preview`,
+        {},
+        { nullOn404: true },
+      ),
 
     // ── Artist ──────────────────────────────────────────────────────────────
-    /** An artist page. `include` adds the owner-editor fields (roles, tags). */
-    getArtist: (partyId: string, opts: { include?: readonly ("roles" | "tags")[] } = {}): Promise<ArtistProfile | null> =>
+    /** An artist plus optional relationship expansions. */
+    getArtist: (
+      partyId: string,
+      opts: { include?: readonly ("roles" | "tags" | "featured")[] } = {},
+    ): Promise<ArtistProfile | null> =>
       request(
         s.artistProfileSchema,
         `/artists/${partyId}`,
@@ -177,10 +225,6 @@ export function createMisoApiClient(options: MisoApiClientOptions) {
         { nullOn404: true },
       ),
 
-    /** The party's pinned pressing, resolved. `null` when nothing is pinned. */
-    getArtistFeatured: (partyId: string): Promise<FeaturedRelease | null> =>
-      request(s.featuredReleaseSchema.nullable(), `/artists/${partyId}/featured`) as Promise<FeaturedRelease | null>,
-
     /** Name + kind for many parties at once. */
     getArtists: (ids: readonly string[]): Promise<PartySummary[]> =>
       ids.length === 0
@@ -196,6 +240,10 @@ export function createMisoApiClient(options: MisoApiClientOptions) {
     getWalletParties: (address: string): Promise<OwnedParty[]> =>
       required(s.ownedPartiesSchema, `/wallets/${address}/parties`),
 
+    /** Group invitations awaiting acceptance by this wallet's controlled parties. */
+    getPendingMemberships: (address: string): Promise<PendingMembership[]> =>
+      required(s.pendingMembershipsSchema, `/wallets/${address}/pending-memberships`),
+
     /** The works this wallet administers, keyed by admin cap. */
     getWalletWorks: (address: string): Promise<OwnedWork[]> =>
       required(s.ownedWorksSchema, `/wallets/${address}/works`),
@@ -210,16 +258,28 @@ export function createMisoApiClient(options: MisoApiClientOptions) {
 
     /** Whether the wallet holds this party's admin cap. Carries the cap id. */
     ownsParty: (address: string, partyId: string): Promise<Ownership> =>
-      required(s.ownershipSchema, `/wallets/${address}/owns`, { party: partyId }),
+      required(s.ownershipSchema, `/wallets/${address}/owns`, {
+        party: partyId,
+      }),
 
     /** Whether the wallet owns this record. */
     ownsRecord: (address: string, recordId: string): Promise<Ownership> =>
-      required(s.ownershipSchema, `/wallets/${address}/owns`, { record: recordId }),
+      required(s.ownershipSchema, `/wallets/${address}/owns`, {
+        record: recordId,
+      }),
 
     // ── Receipts ────────────────────────────────────────────────────────────
     /** What one record sale was, re-derived from its transaction. */
-    getReceipt: (pressingId: string, txDigest: string): Promise<PurchaseReceipt | null> =>
-      request(s.purchaseReceiptSchema, `/receipts/${pressingId}/${txDigest}`, {}, { nullOn404: true }),
+    getReceipt: (
+      pressingId: string,
+      txDigest: string,
+    ): Promise<PurchaseReceipt | null> =>
+      request(
+        s.purchaseReceiptSchema,
+        `/receipts/${pressingId}/${txDigest}`,
+        {},
+        { nullOn404: true },
+      ),
   };
 }
 
@@ -254,14 +314,13 @@ export const READ_CACHE_CLASS = {
   getDiscover: "sale",
   getPressing: "sale",
   getDropPreview: "sale",
-  getReleaseTrackCredits: "published",
   getRecordAlbum: "immutable",
   getReceipt: "immutable",
   getArtist: "artist",
-  getArtistFeatured: "artist",
   getArtists: "artist",
   getWalletRecords: "private",
   getWalletParties: "private",
+  getPendingMemberships: "private",
   getWalletWorks: "private",
   getWork: "private",
   getBalance: "private",

package/src/schemas.ts

@@ -63,9 +63,36 @@ export const trackViewSchema = z.object({
   disc: z.number().int().min(1),
 });
 
+/** A recording's work-role credits and recording billing positions. */
+export const recordingCreditsSchema = z.object({
+  credits: z.array(creditSchema),
+  primaryArtistIds: z.array(suiIdSchema),
+  featuredArtistIds: z.array(suiIdSchema),
+});
+
+/** Per-track credits for a release. Composition writing and recording
+ * performance/production credits remain separate. */
+const completeTrackCreditsSchema = z.object({
+  compositionCredits: z.array(creditSchema),
+  recordingCredits: recordingCreditsSchema,
+});
+
+/** The HTTP wire accepts the complete shape and the deployed recording-only shape. */
+export const trackCreditsWireSchema = z.union([
+  completeTrackCreditsSchema,
+  recordingCreditsSchema,
+]);
+
+/** Clients always receive the complete shape, including during the rollout. */
+export const trackCreditsSchema = trackCreditsWireSchema.transform((credits) =>
+  "recordingCredits" in credits
+    ? credits
+    : { compositionCredits: [], recordingCredits: credits },
+);
+
 // ── Catalog ──────────────────────────────────────────────────────────────────
 
-export const releaseDetailSchema = z.object({
+const releaseDetailBaseSchema = z.object({
   id: suiIdSchema,
   title: z.string(),
   subtitle: z.string().nullable(),
@@ -79,6 +106,16 @@ export const releaseDetailSchema = z.object({
   tracks: z.array(trackViewSchema),
 });
 
+/** Transform-free wire form used by OpenAPI generation. */
+export const releaseDetailWireSchema = releaseDetailBaseSchema.extend({
+  trackCredits: z.record(suiIdSchema, trackCreditsWireSchema).optional(),
+});
+
+export const releaseDetailSchema = releaseDetailBaseSchema.extend({
+  /** Present only when requested via `include`. */
+  trackCredits: z.record(suiIdSchema, trackCreditsSchema).optional(),
+});
+
 export const priceSchema = z.object({
   /** `fixed` — pay exactly this. `floor` — pay at least this. */
   kind: z.enum(["fixed", "floor"]),
@@ -111,6 +148,11 @@ export const pressingDetailSchema = z.object({
   release: releaseDetailSchema,
 });
 
+export const pressingDetailWireSchema = z.object({
+  pressing: pressingViewSchema,
+  release: releaseDetailWireSchema,
+});
+
 export const discoverItemSchema = z.object({
   pressing: pressingViewSchema,
   releaseId: suiIdSchema,
@@ -125,6 +167,14 @@ export const discoverShelfSchema = z.array(discoverItemSchema);
 export const recordAlbumSchema = z.object({
   recordId: suiIdSchema,
   releaseId: suiIdSchema.nullable(),
+  /** Present only when requested via `include`. */
+  release: releaseDetailSchema.nullable().optional(),
+});
+
+export const recordAlbumWireSchema = z.object({
+  recordId: suiIdSchema,
+  releaseId: suiIdSchema.nullable(),
+  release: releaseDetailWireSchema.nullable().optional(),
 });
 
 export const dropPreviewSchema = z.object({
@@ -137,42 +187,6 @@ export const dropPreviewSchema = z.object({
   trackCount: z.number().int().min(0),
 });
 
-/** A recording's work-role credits and recording billing positions. */
-export const recordingCreditsSchema = z.object({
-  credits: z.array(creditSchema),
-  primaryArtistIds: z.array(suiIdSchema),
-  featuredArtistIds: z.array(suiIdSchema),
-});
-
-/** Per-track credits for a release. Composition writing and recording
- * performance/production credits remain separate. */
-const completeTrackCreditsSchema = z.object({
-  compositionCredits: z.array(creditSchema),
-  recordingCredits: recordingCreditsSchema,
-});
-
-/** The HTTP wire accepts the complete shape and the deployed recording-only shape. */
-export const trackCreditsWireSchema = z.union([
-  completeTrackCreditsSchema,
-  recordingCreditsSchema,
-]);
-
-/** Clients always receive the complete shape, including during the rollout. */
-export const trackCreditsSchema = trackCreditsWireSchema.transform((credits) =>
-  "recordingCredits" in credits
-    ? credits
-    : { compositionCredits: [], recordingCredits: credits },
-);
-
-/** Transform-free wire schema used when generating OpenAPI. */
-export const releaseTrackCreditsWireSchema = z.object({
-  tracks: z.record(suiIdSchema, trackCreditsWireSchema),
-});
-/** Per-track work credits for a release, keyed by recording id. */
-export const releaseTrackCreditsSchema = z.object({
-  tracks: z.record(suiIdSchema, trackCreditsSchema),
-});
-
 // ── Artist ───────────────────────────────────────────────────────────────────
 
 export const partyMemberSchema = z.object({
@@ -229,6 +243,14 @@ export const partyLinkSchema = z.object({
 
 export const partyCtaSchema = z.object({ label: z.string(), url: z.string() });
 
+export const featuredReleaseSchema = z.object({
+  pressingId: suiIdSchema,
+  releaseId: suiIdSchema,
+  title: z.string(),
+  artist: z.string(),
+  coverUrl: z.string().url().nullable(),
+});
+
 export const artistProfileSchema = z.object({
   id: suiIdSchema,
   kind: z.enum(["individual", "group"]),
@@ -246,17 +268,11 @@ export const artistProfileSchema = z.object({
   /** Present only when requested via `include` — the owner-editor fields. */
   roles: z.array(z.string()).optional(),
   tags: z.array(z.string()).optional(),
+  /** Present only when requested; null means the artist has no pinned release. */
+  featured: featuredReleaseSchema.nullable().optional(),
   avatarUrl: z.string().url(),
 });
 
-export const featuredReleaseSchema = z.object({
-  pressingId: suiIdSchema,
-  releaseId: suiIdSchema,
-  title: z.string(),
-  artist: z.string(),
-  coverUrl: z.string().url().nullable(),
-});
-
 export const partySummarySchema = z.object({
   id: suiIdSchema,
   name: z.string(),
@@ -286,6 +302,16 @@ export const ownedPartySchema = z.object({
 
 export const ownedPartiesSchema = z.array(ownedPartySchema);
 
+/** A group invitation awaiting action by a party the wallet administers. */
+export const pendingMembershipSchema = z.object({
+  memberPartyId: suiIdSchema,
+  memberCapId: suiIdSchema,
+  groupId: suiIdSchema,
+  groupName: z.string(),
+});
+
+export const pendingMembershipsSchema = z.array(pendingMembershipSchema);
+
 export const workKindSchema = z.enum(["composition", "recording", "release"]);
 
 export const ownedWorkSchema = z.object({
@@ -354,6 +380,13 @@ export const purchaseReceiptSchema = z.object({
   tracks: z.array(trackRoyaltySchema),
 });
 
+export const purchaseReceiptWireSchema = z.object({
+  sale: recordSaleSchema,
+  detail: pressingDetailWireSchema,
+  price: u64Schema,
+  tracks: z.array(trackRoyaltySchema),
+});
+
 // ── Errors ───────────────────────────────────────────────────────────────────
 
 /** The envelope every non-2xx carries, matching miso-api's `apiError`. */

package/src/types.ts

@@ -15,7 +15,6 @@ export type TrackView = z.infer<typeof s.trackViewSchema>;
 
 export type ReleaseDetail = z.infer<typeof s.releaseDetailSchema>;
 export type TrackCredits = z.infer<typeof s.trackCreditsSchema>;
-export type ReleaseTrackCredits = z.infer<typeof s.releaseTrackCreditsSchema>;
 export type Price = z.infer<typeof s.priceSchema>;
 export type Currency = z.infer<typeof s.currencySchema>;
 export type PressingView = z.infer<typeof s.pressingViewSchema>;
@@ -35,6 +34,7 @@ export type PartySummary = z.infer<typeof s.partySummarySchema>;
 
 export type OwnedRecord = z.infer<typeof s.ownedRecordSchema>;
 export type OwnedParty = z.infer<typeof s.ownedPartySchema>;
+export type PendingMembership = z.infer<typeof s.pendingMembershipSchema>;
 export type WorkKind = z.infer<typeof s.workKindSchema>;
 export type OwnedWork = z.infer<typeof s.ownedWorkSchema>;
 export type WorkDetail = z.infer<typeof s.workDetailSchema>;