@misofm/api-client 0.1.1 → 0.2.0

package/README.md

@@ -3,9 +3,9 @@
 Typed client, schemas, and response contracts for the Miso API read layer.
 
 ```ts
-import { MisoApiClient } from "@misofm/api-client";
+import { createMisoApiClient } from "@misofm/api-client";
 
-const client = new MisoApiClient({ baseUrl: "https://api.testnet.miso.fm" });
+const client = createMisoApiClient({ baseUrl: "https://api.testnet.miso.fm" });
 ```
 
 The package is maintained in the [`misofm/api`](https://github.com/misofm/api)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misofm/api-client",
-  "version": "0.1.1",
+  "version": "0.2.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,7 +23,6 @@ import type {
   Balance,
   DiscoverShelf,
   DropPreview,
-  FeaturedRelease,
   OwnedParty,
   OwnedRecord,
   OwnedWork,
@@ -33,7 +32,6 @@ import type {
   PurchaseReceipt,
   RecordAlbum,
   ReleaseDetail,
-  ReleaseTrackCredits,
   WorkDetail,
 } from "./types.ts";
 
@@ -102,7 +100,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 +115,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 +125,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 +224,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
@@ -210,16 +253,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,11 +309,9 @@ 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",

package/src/index.ts

@@ -5,7 +5,7 @@
 // Miso read API.
 //
 // This package is what every Miso frontend reads through: the PWA, the CLI,
-// agents. It carries no chain code and no Sui dependency — a browser importing it
+// and third-party clients. It carries no chain code and no Sui dependency — a browser importing it
 // gets zod and a fetch wrapper, not a blockchain SDK.
 //
 //   import { createMisoApiClient } from "@misofm/api-client";
@@ -19,7 +19,3 @@ export type { CacheClass, CachePolicy } from "./cache.ts";
 
 export * as schemas from "./schemas.ts";
 export type * from "./types.ts";
-
-// Card checkout lives in miso-platform-service, not the read service, but it is
-// the same API to a caller — one package, one base URL, one error type.
-export * from "./checkout.ts";

package/src/schemas.ts

@@ -6,11 +6,11 @@
 //   · @misofm/api-client infers its types from it
 //   · miso-read-service generates its OpenAPI document from it
 //   · a contract test in that service parses every handler's real output through
-//     it, so a change in @misonetwork/sdk that these schemas don't describe fails CI
+//     it, so a change in @misofm/sdk/read that these schemas don't describe fails CI
 //     rather than reaching a client
 //
 // Schemas, not hand-written interfaces, precisely so that third clause is
-// possible. Agents, the CLI, and any future surface read the same OpenAPI.
+// possible. The CLI and any future client read the same OpenAPI.
 //
 // SCALARS: every u64/u128 is a DECIMAL STRING (`u64Schema`), never a number.
 // Prices, supply counts, and balances routinely exceed 2^53, and JSON has no
@@ -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,33 +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. */
-export const trackCreditsSchema = z.union([
-  z.object({
-    compositionCredits: z.array(creditSchema),
-    recordingCredits: recordingCreditsSchema,
-  }),
-  // Keep already-deployed recording-only responses usable while the read service
-  // rolls out the composition-credit projection.
-  recordingCreditsSchema.transform((recordingCredits) => ({
-    compositionCredits: [],
-    recordingCredits,
-  })),
-]);
-
-/** 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({
@@ -220,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"]),
@@ -237,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(),
@@ -345,6 +370,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>;

package/src/checkout.ts

@@ -1,146 +0,0 @@
-// Copyright (c) Miso Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-//
-// The card-checkout contract (Stripe on-ramp for records). Served by
-// miso-platform-service under `/platform/checkout`, not by the read service — it
-// is a WRITE surface with its own Durable Object payment gate — but it lives in
-// this package so an app has one API dependency rather than two.
-//
-// Lifted from miso-app's `lib/checkout-client.ts`, which was hand-written against
-// the backend and had no way to notice the backend changing.
-//
-//   quote → sign → session → redirect to Stripe → poll the receipt
-
-import { z } from "zod";
-import { MisoApiError } from "./client.ts";
-
-export const checkoutQuoteSchema = z.object({
-  /** The signed payload the buyer signs to prove intent. */
-  payload: z.string(),
-  nonce: z.string(),
-  /** What the card will actually be charged, in USD cents (price + card fee). */
-  cardAmountCents: z.number().int(),
-  expiresAt: z.string(),
-  priceDisplay: z.string(),
-});
-
-export const checkoutSessionSchema = z.object({
-  /** Stripe Checkout URL to redirect to. */
-  url: z.string().url(),
-  orderId: z.string(),
-});
-
-export const orderStateSchema = z.enum([
-  "awaiting_payment",
-  "paid",
-  "fulfilling",
-  "under_review",
-  "fulfilled",
-  "fulfill_failed",
-  "refund_pending",
-  "refunded",
-  "expired",
-]);
-
-export const receiptLineItemSchema = z.object({
-  description: z.string(),
-  amountCents: z.number().int(),
-  /** ISO-4217, lowercase (always "usd"). */
-  currency: z.string(),
-  quantity: z.number().int(),
-});
-
-export const orderReceiptSchema = z.object({
-  state: orderStateSchema,
-  /** The Sui address the record is/was delivered to. */
-  buyerAddress: z.string(),
-  lineItems: z.array(receiptLineItemSchema),
-  /** The minted record's object id once fulfilled — the target of "Mix it now". */
-  recordObjectId: z.string().optional(),
-  txDigest: z.string().optional(),
-  network: z.enum(["testnet", "mainnet"]),
-  failureReason: z.string().optional(),
-});
-
-export type CheckoutQuote = z.infer<typeof checkoutQuoteSchema>;
-export type CheckoutSession = z.infer<typeof checkoutSessionSchema>;
-export type OrderState = z.infer<typeof orderStateSchema>;
-export type ReceiptLineItem = z.infer<typeof receiptLineItemSchema>;
-export type OrderReceipt = z.infer<typeof orderReceiptSchema>;
-
-/**
- * Terminal "you can't see this": the order uuid + session_id capability pair did
- * not resolve — unknown order, wrong or expired session, or a malformed link. The
- * API returns an identical 404 for all of these so nothing leaks about whether
- * the order exists, which means the client can't tell them apart either.
- *
- * **Stop polling on this.** Any other non-2xx is transient and safe to retry.
- */
-export class CheckoutNotFoundError extends MisoApiError {
-  constructor(message: string) {
-    super(404, "not_found", message);
-    this.name = "CheckoutNotFoundError";
-  }
-}
-
-export interface CheckoutClientOptions {
-  baseUrl: string;
-  fetch?: typeof globalThis.fetch;
-  /** Where the platform service is mounted on `baseUrl`. */
-  prefix?: string;
-}
-
-export function createCheckoutClient(options: CheckoutClientOptions) {
-  const base = options.baseUrl.replace(/\/$/, "");
-  const prefix = options.prefix ?? "/platform/checkout";
-  const doFetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-
-  async function parseError(res: Response): Promise<MisoApiError> {
-    const body = (await res.json().catch(() => null)) as { error?: string | { message?: string } } | null;
-    const raw = body?.error;
-    const message = typeof raw === "string" ? raw : (raw?.message ?? `Request failed (${res.status})`);
-    return new MisoApiError(res.status, "checkout_error", message);
-  }
-
-  async function post<T>(schema: z.ZodType<T>, path: string, body: unknown): Promise<T> {
-    const res = await doFetch(`${base}${prefix}${path}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) throw await parseError(res);
-    return schema.parse(await res.json());
-  }
-
-  return {
-    /** Price + signed-payload quote for a drop, for a given recipient. */
-    getQuote: (dropId: string, recipient: string): Promise<CheckoutQuote> =>
-      post(checkoutQuoteSchema, "/quote", { dropId, recipient }),
-
-    /** Verify the signature + Enoki identity, then open a Stripe session. */
-    createSession: (params: {
-      payload: string;
-      signature: string;
-      address: string;
-      nonce: string;
-      jwt: string;
-      recordName?: string;
-    }): Promise<CheckoutSession> => post(checkoutSessionSchema, "/session", params),
-
-    /**
-     * The buyer-scoped receipt for the post-purchase page. Requires the order
-     * uuid AND the Stripe session id from the success redirect — a capability
-     * pair, not an id lookup. A 404/400 throws {@link CheckoutNotFoundError}.
-     */
-    getReceipt: async (orderId: string, sessionId: string): Promise<OrderReceipt> => {
-      const res = await doFetch(
-        `${base}${prefix}/orders/${orderId}/receipt?session_id=${encodeURIComponent(sessionId)}`,
-      );
-      if (res.status === 404 || res.status === 400) throw new CheckoutNotFoundError((await parseError(res)).message);
-      if (!res.ok) throw await parseError(res);
-      return orderReceiptSchema.parse(await res.json());
-    },
-  };
-}
-
-export type CheckoutClient = ReturnType<typeof createCheckoutClient>;