@misofm/api-client 0.5.0 → 0.5.2

package/dist/schemas.js

@@ -0,0 +1,335 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+//
+// The response contract for every Miso read. This file is the SOURCE OF TRUTH:
+//
+//   · @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 missing, renamed, or mistyped fields fail CI rather than reaching a
+//     client. Additive fields remain forward-compatible and are stripped until
+//     the public schema adopts them.
+//
+// Schemas, not hand-written interfaces, precisely so that third clause is
+// 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
+// integer type that holds them. Millisecond timestamps stay numbers — they are
+// inside Number.MAX_SAFE_INTEGER and callers want to pass them to `new Date()`.
+import { z } from "zod";
+/** A u64/u128 in base units, as a decimal string. See the file header. */
+export const u64Schema = z
+    .string()
+    .regex(/^\d+$/, "expected a decimal integer string");
+/** A 0x-prefixed 32-byte Sui object id or address, in canonical form. */
+export const suiIdSchema = z
+    .string()
+    .regex(/^0x[0-9a-fA-F]{1,64}$/, "expected a Sui object id");
+/** A 32-byte Walrus blob id encoded as URL-safe, unpadded base64. */
+export const walrusBlobIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9_-]{43}$/, "expected a Walrus blob id");
+// ── Shared ───────────────────────────────────────────────────────────────────
+export const workStateSchema = z.union([
+    z.object({ type: z.literal("Initialized") }),
+    z.object({ type: z.literal("Published"), timestampMs: z.number().int() }),
+]);
+export const coverImageSchema = z.object({
+    kind: z.enum(["blob", "quiltPatch"]),
+    /** Aggregator URL — the only field a renderer needs. */
+    url: z.string().url(),
+});
+export const coverSchema = z.object({
+    still: coverImageSchema,
+    animated: coverImageSchema.nullable(),
+});
+export const creditSchema = z.object({
+    partyId: suiIdSchema,
+    displayName: z.string(),
+    roles: z.array(z.string()),
+});
+export const trackViewSchema = z.object({
+    /** Display number — "1", or "1.2" (disc.track) on a multi-disc set. */
+    no: z.string(),
+    title: z.string(),
+    recordingId: suiIdSchema,
+    /** The composition underlying this track's recording. */
+    compositionId: suiIdSchema,
+    /** This track's share of the release's revenue, in basis points. */
+    splitBps: z.number().int().min(0).max(10_000),
+    disc: z.number().int().min(1),
+    /** Streaming master attached through recording_master_reference, when present. */
+    masterBlobId: walrusBlobIdSchema.optional(),
+});
+/** 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 ──────────────────────────────────────────────────────────────────
+const releaseDetailBaseSchema = z.object({
+    id: suiIdSchema,
+    title: z.string(),
+    subtitle: z.string().nullable(),
+    /** Self-declared `release_kind`, or null when the extension is absent. */
+    kind: z.string().nullable(),
+    state: workStateSchema,
+    publishedAtMs: z.number().int().nullable(),
+    cover: coverSchema.nullable(),
+    credits: z.array(creditSchema),
+    /** The release's primary artists in chain order — its artist line. */
+    primaryArtists: z.array(z.string()),
+    discCount: z.number().int().min(0),
+    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"]),
+    amount: u64Schema,
+});
+export const currencySchema = z.object({
+    type: z.string().nullable(),
+    symbol: z.string(),
+    decimals: z.number().int().min(0).max(18),
+});
+export const pressingStateSchema = z.union([
+    z.object({
+        kind: z.literal("scheduled"),
+        startTimestampMs: z.number().int(),
+    }),
+    z.object({ kind: z.literal("active") }),
+    z.object({ kind: z.literal("paused") }),
+]);
+export const pressingViewSchema = z.object({
+    id: suiIdSchema,
+    releaseId: suiIdSchema,
+    state: pressingStateSchema,
+    /** Records pressed so far. The permanent run is intentionally uncapped. */
+    supply: u64Schema,
+});
+export const listingViewSchema = z.object({
+    id: suiIdSchema,
+    pressingId: suiIdSchema,
+    releaseId: suiIdSchema,
+    price: priceSchema,
+    currency: currencySchema,
+    state: z.enum(["enabled", "disabled"]),
+});
+export const pressingDetailSchema = z.object({
+    pressing: pressingViewSchema,
+    release: releaseDetailSchema,
+});
+export const pressingDetailWireSchema = z.object({
+    pressing: pressingViewSchema,
+    release: releaseDetailWireSchema,
+});
+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(),
+});
+// ── Artist ───────────────────────────────────────────────────────────────────
+export const partyMemberSchema = z.object({
+    id: suiIdSchema,
+    name: z.string(),
+});
+/**
+ * Every external platform the party link extensions know how to build a URL for,
+ * spanning social, music, and professional payloads. Enumerated rather than left
+ * as `string` so a renderer's icon/label switch is exhaustive at compile time —
+ * adding a platform on-chain should break the UI that has no icon for it.
+ */
+export const platformKeySchema = z.enum([
+    // Social (party_social)
+    "x",
+    "instagram",
+    "threads",
+    "tiktok",
+    "youtube",
+    "discord",
+    "telegram",
+    "reddit",
+    "twitch",
+    "facebook",
+    // Music (party_music)
+    "spotify",
+    "bandcamp",
+    "soundcloud",
+    "appleMusic",
+    "deezer",
+    "tidal",
+    "amazonMusic",
+    "audiomack",
+    // Professional / industry (party_pro_link)
+    "website",
+    "bookingPage",
+    "managementPage",
+    "publisherPage",
+    "labelPage",
+    "epk",
+    "patreon",
+    "substack",
+    "kofi",
+]);
+export const partyLinkSchema = z.object({
+    platform: platformKeySchema,
+    /** The platform-native identifier stored on-chain (handle / id / subdomain / URL). */
+    value: z.string(),
+    /** The public profile URL, rebuilt client-side from `value`. */
+    url: z.string(),
+});
+export const partyCtaSchema = z.object({ label: z.string(), url: z.string() });
+export const artistProfileSchema = z.object({
+    id: suiIdSchema,
+    kind: z.enum(["individual", "group"]),
+    name: z.string(),
+    createdAtMs: z.number().int(),
+    bioShort: z.string().nullable(),
+    bioLong: z.string().nullable(),
+    country: z.string().nullable(),
+    languages: z.array(z.string()),
+    /** Display names, already humanized from the on-chain HIP_HOP form. */
+    genres: z.array(z.string()),
+    links: z.array(partyLinkSchema),
+    ctas: z.array(partyCtaSchema),
+    members: z.array(partyMemberSchema),
+    /** Present only when requested via `include` — the owner-editor fields. */
+    roles: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional(),
+    avatarUrl: z.string().url(),
+});
+export const partySummarySchema = z.object({
+    id: suiIdSchema,
+    name: z.string(),
+    kind: z.enum(["individual", "group"]),
+});
+export const partySummariesSchema = z.array(partySummarySchema);
+// ── Wallet-scoped ────────────────────────────────────────────────────────────
+export const ownedRecordSchema = z.object({
+    id: suiIdSchema,
+    type: z.string(),
+    releaseId: suiIdSchema.nullable(),
+    /** This copy's number in its run. */
+    number: z.number().int().nullable(),
+});
+export const ownedRecordsSchema = z.array(ownedRecordSchema);
+export const ownedPartySchema = z.object({
+    partyId: suiIdSchema,
+    capId: suiIdSchema,
+    name: z.string(),
+    kind: z.enum(["individual", "group"]),
+});
+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({
+    /** The ADMIN CAP object id — the catalog's routing key. */
+    capId: suiIdSchema,
+    kind: workKindSchema,
+    workId: suiIdSchema,
+    title: z.string(),
+    state: z.string(),
+});
+export const ownedWorksSchema = z.array(ownedWorkSchema);
+export const workDetailSchema = ownedWorkSchema.extend({
+    subtitle: z.string().optional(),
+    royaltyRateBps: z.number().int().min(0).max(10_000).optional(),
+    shareType: z.string().optional(),
+    discCount: z.number().int().min(0).optional(),
+    trackCount: z.number().int().min(0).optional(),
+});
+export const balanceSchema = z.object({
+    address: suiIdSchema,
+    coinType: z.string(),
+    /** Base units. Totals coin objects AND the address balance. */
+    balance: u64Schema,
+    decimals: z.number().int().min(0).max(18),
+});
+export const ownershipSchema = z.object({
+    address: suiIdSchema,
+    objectId: suiIdSchema,
+    isOwner: z.boolean(),
+    /** Party checks only — the derived PartyAdminCap id owner-gated writes need. */
+    capId: suiIdSchema.optional(),
+});
+// ── Receipts ─────────────────────────────────────────────────────────────────
+export const recordSaleSchema = z.object({
+    listingId: suiIdSchema,
+    pressingId: suiIdSchema,
+    releaseId: suiIdSchema,
+    recordId: suiIdSchema,
+    number: u64Schema,
+    paid: u64Schema,
+    price: priceSchema,
+    currencyType: z.string(),
+    buyer: suiIdSchema,
+});
+export const trackRoyaltySchema = z.object({
+    no: z.string(),
+    title: z.string(),
+    recordingId: suiIdSchema,
+    splitBps: z.number().int().min(0).max(10_000),
+    amount: u64Schema,
+    /** Both null when the composition's royalty rate could not be resolved. */
+    composition: u64Schema.nullable(),
+    recording: u64Schema.nullable(),
+});
+export const purchaseReceiptSchema = z.object({
+    sale: recordSaleSchema,
+    detail: pressingDetailSchema,
+    /** The Listing price — differs from `sale.paid` on a floor-price overpay. */
+    price: u64Schema,
+    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`. */
+export const apiErrorSchema = z.object({
+    error: z.object({
+        code: z.string(),
+        message: z.string(),
+    }),
+});

package/{src/types.ts → dist/types.d.ts}

@@ -1,18 +1,10 @@
-// Copyright (c) Miso Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-//
-// Types inferred from ./schemas.ts. Nothing is hand-written here on purpose — a
-// type and its validator that can disagree will eventually disagree.
-
 import type { z } from "zod";
-import type * as s from "./schemas.ts";
-
+import type * as s from "./schemas.js";
 export type WorkState = z.infer<typeof s.workStateSchema>;
 export type CoverImage = z.infer<typeof s.coverImageSchema>;
 export type Cover = z.infer<typeof s.coverSchema>;
 export type Credit = z.infer<typeof s.creditSchema>;
 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 Price = z.infer<typeof s.priceSchema>;
@@ -22,14 +14,12 @@ export type PressingView = z.infer<typeof s.pressingViewSchema>;
 export type ListingView = z.infer<typeof s.listingViewSchema>;
 export type PressingDetail = z.infer<typeof s.pressingDetailSchema>;
 export type RecordAlbum = z.infer<typeof s.recordAlbumSchema>;
-
 export type PartyMember = z.infer<typeof s.partyMemberSchema>;
 export type PlatformKey = z.infer<typeof s.platformKeySchema>;
 export type PartyLink = z.infer<typeof s.partyLinkSchema>;
 export type PartyCta = z.infer<typeof s.partyCtaSchema>;
 export type ArtistProfile = z.infer<typeof s.artistProfileSchema>;
 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>;
@@ -38,9 +28,7 @@ export type OwnedWork = z.infer<typeof s.ownedWorkSchema>;
 export type WorkDetail = z.infer<typeof s.workDetailSchema>;
 export type Balance = z.infer<typeof s.balanceSchema>;
 export type Ownership = z.infer<typeof s.ownershipSchema>;
-
 export type RecordSale = z.infer<typeof s.recordSaleSchema>;
 export type TrackRoyalty = z.infer<typeof s.trackRoyaltySchema>;
 export type PurchaseReceipt = z.infer<typeof s.purchaseReceiptSchema>;
-
 export type ApiErrorBody = z.infer<typeof s.apiErrorSchema>;

package/dist/types.js

@@ -0,0 +1,6 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Types inferred from ./schemas.ts. Nothing is hand-written here on purpose — a
+// type and its validator that can disagree will eventually disagree.
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misofm/api-client",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "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": {
@@ -12,33 +12,47 @@
   "bugs": {
     "url": "https://github.com/misofm/api/issues"
   },
-  "module": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "type": "module",
   "sideEffects": false,
   "exports": {
-    ".": "./src/index.ts",
-    "./schemas": "./src/schemas.ts",
-    "./types": "./src/types.ts",
-    "./cache": "./src/cache.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas.d.ts",
+      "import": "./dist/schemas.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    },
+    "./cache": {
+      "types": "./dist/cache.d.ts",
+      "import": "./dist/cache.js"
+    }
   },
   "files": [
-    "src",
+    "dist",
+    "LICENSE",
     "README.md",
     "package.json"
   ],
   "scripts": {
+    "build": "node ./scripts/clean.mjs && tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "pack:check": "node ./scripts/verify-package.mjs",
     "test": "bun test",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "zod": "^4.3.6"
   },
-  "peerDependencies": {
-    "typescript": "^5"
-  },
   "devDependencies": {
-    "@types/bun": "latest",
+    "@types/bun": "1.3.14",
     "typescript": "^5"
   },
   "publishConfig": {

package/src/cache.test.ts

@@ -1,90 +0,0 @@
-// Copyright (c) Miso Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-//
-// The cache table is a policy document that happens to be executable, so it gets
-// tested as one: the exact header per class, and the invariants that make the
-// classes coherent with each other.
-
-import { describe, expect, test } from "bun:test";
-import { CACHE_POLICIES, cacheControl, workCacheClass, type CacheClass } from "./cache.ts";
-
-describe("cacheControl", () => {
-  const expected: Record<CacheClass, string> = {
-    immutable: "public, max-age=31536000, s-maxage=31536000, immutable",
-    published: "public, max-age=300, s-maxage=3600, stale-while-revalidate=86400",
-    draft: "public, max-age=0, s-maxage=60, stale-while-revalidate=300",
-    artist: "public, max-age=30, s-maxage=60, stale-while-revalidate=600",
-    sale: "public, max-age=0, s-maxage=60, stale-while-revalidate=300",
-    private: "private, no-store",
-  };
-
-  for (const [cls, header] of Object.entries(expected)) {
-    test(`${cls} → ${header}`, () => {
-      expect(cacheControl(cls as CacheClass)).toBe(header);
-    });
-  }
-
-  test("private never reaches a shared cache", () => {
-    const header = cacheControl("private");
-    expect(header).not.toContain("public");
-    expect(header).not.toContain("s-maxage");
-    expect(header).toContain("no-store");
-  });
-});
-
-describe("policy invariants", () => {
-  const publicClasses = (Object.keys(CACHE_POLICIES) as CacheClass[]).filter((c) => c !== "private");
-
-  test("the edge always holds a response at least as long as a browser does", () => {
-    // Otherwise the browser outlives the shared copy and the edge cache is
-    // pointless — every client revalidation would miss.
-    for (const cls of publicClasses) {
-      const p = CACHE_POLICIES[cls];
-      expect(p.sMaxAge!).toBeGreaterThanOrEqual(p.maxAge);
-    }
-  });
-
-  test("staleTime mirrors the browser lifetime, so the client never refetches what it already holds fresh", () => {
-    for (const cls of publicClasses) {
-      const p = CACHE_POLICIES[cls];
-      if (Number.isFinite(p.staleTimeMs)) expect(p.staleTimeMs).toBe(p.maxAge * 1000);
-    }
-    expect(CACHE_POLICIES.immutable.staleTimeMs).toBe(Number.POSITIVE_INFINITY);
-  });
-
-  test("live sale data is among the shortest public TTLs", () => {
-    // No longer strictly the shortest: a pressing is UNCAPPED, so its
-    // copies-sold counter gates nothing and a minute of staleness is cosmetic.
-    // `draft` now ties it, because an editor really must see their own change.
-    const others = publicClasses.filter((c) => c !== "sale");
-    for (const cls of others) {
-      expect(CACHE_POLICIES.sale.sMaxAge!).toBeLessThanOrEqual(CACHE_POLICIES[cls].sMaxAge!);
-    }
-  });
-
-  test("a draft is cached far more briefly than a published work", () => {
-    expect(CACHE_POLICIES.draft.sMaxAge!).toBeLessThan(CACHE_POLICIES.published.sMaxAge!);
-    // An editor must see their own change land.
-    expect(CACHE_POLICIES.draft.maxAge).toBe(0);
-  });
-
-  test("private carries no shared lifetime at all", () => {
-    expect(CACHE_POLICIES.private.sMaxAge).toBeNull();
-    expect(CACHE_POLICIES.private.staleWhileRevalidate).toBeNull();
-    expect(CACHE_POLICIES.private.staleTimeMs).toBe(0);
-  });
-});
-
-describe("workCacheClass", () => {
-  test("published work caches long, draft caches short", () => {
-    expect(workCacheClass({ type: "Published" })).toBe("published");
-    expect(workCacheClass({ type: "Initialized" })).toBe("draft");
-  });
-
-  test("an unknown or missing state is treated as a draft", () => {
-    // Fail toward freshness: over-caching a work that is still moving is the
-    // worse error, because the artist edits and nothing happens.
-    expect(workCacheClass(null)).toBe("draft");
-    expect(workCacheClass(undefined)).toBe("draft");
-  });
-});

package/src/cache.ts

@@ -1,91 +0,0 @@
-// Copyright (c) Miso Labs, Inc.
-// SPDX-License-Identifier: Apache-2.0
-//
-// How long each kind of read stays good. ONE table, shared by both ends:
-//
-//   miso-read-service  turns a class into `Cache-Control` and a Cache API entry
-//   this client        turns the same class into a TanStack Query `staleTime`
-//
-// They live together because a client that refetches every 30s in front of an
-// edge that caches for 60s is just serving itself the cached body twice. Reading
-// the same numbers keeps the browser's idea of "fresh" and the edge's identical.
-//
-// The classes are chosen by WHAT MOVES THE DATA, not by route:
-//
-//   immutable   nothing can change it, ever. A record's parent release is fixed
-//               at mint; a settled transaction is settled. Cache for a year.
-//   published   a published work. Its metadata only moves when an artist
-//               deliberately re-sets an extension — rare, and a minute of
-//               staleness costs nobody anything.
-//   draft       the same work before publication: actively being edited in
-//               studio, so the editor must see their own change land.
-//   artist      a profile page. Owner edits should surface within a minute.
-//   sale        a Pressing or Listing. Their state and the uncapped run's supply
-//               can move, so clients refresh them quickly. The chain remains the
-//               purchase gate when an edge response is briefly stale.
-//   private     address-scoped. Never enters a shared cache — the failure mode is
-//               serving one user's library to another.
-//
-// THERE IS NO INVALIDATION. These TTLs are the whole freshness story: the cache
-// is an optimization, never a source of truth, and the chain stays
-// authoritative. A writer who must see their OWN change immediately appends a
-// cache-buster param, which mints one throwaway entry instead of evicting the
-// one everybody else is reading.
-
-export type CacheClass = "immutable" | "published" | "draft" | "artist" | "sale" | "private";
-
-export interface CachePolicy {
-  /** Shared-cache lifetime in seconds (`s-maxage`). `null` for private. */
-  sMaxAge: number | null;
-  /**
-   * How long past `sMaxAge` the edge may serve the stale body while it
-   * revalidates behind the request. This is where the latency win lives: a
-   * visitor after expiry gets the old body instantly instead of waiting on a
-   * chain round-trip.
-   */
-  staleWhileRevalidate: number | null;
-  /** Browser lifetime (`max-age`). Deliberately shorter than the edge's. */
-  maxAge: number;
-  /** TanStack Query `staleTime`, in ms. Mirrors `maxAge`. */
-  staleTimeMs: number;
-}
-
-export const CACHE_POLICIES: Record<CacheClass, CachePolicy> = {
-  immutable: { sMaxAge: 31_536_000, staleWhileRevalidate: null, maxAge: 31_536_000, staleTimeMs: Number.POSITIVE_INFINITY },
-  published: { sMaxAge: 3_600, staleWhileRevalidate: 86_400, maxAge: 300, staleTimeMs: 300_000 },
-  draft: { sMaxAge: 60, staleWhileRevalidate: 300, maxAge: 0, staleTimeMs: 0 },
-  artist: { sMaxAge: 60, staleWhileRevalidate: 600, maxAge: 30, staleTimeMs: 30_000 },
-  sale: { sMaxAge: 60, staleWhileRevalidate: 300, maxAge: 0, staleTimeMs: 0 },
-  private: { sMaxAge: null, staleWhileRevalidate: null, maxAge: 0, staleTimeMs: 0 },
-};
-
-/**
- * The `Cache-Control` header for a class.
- *
- * `private, no-store` on the private class is doing real work: `private` alone
- * would still let a browser (or a misconfigured intermediary) retain the body,
- * and these responses describe one wallet's holdings.
- */
-export function cacheControl(cls: CacheClass): string {
-  const p = CACHE_POLICIES[cls];
-  if (p.sMaxAge === null) return "private, no-store";
-
-  const parts = ["public", `max-age=${p.maxAge}`, `s-maxage=${p.sMaxAge}`];
-  if (p.staleWhileRevalidate !== null) parts.push(`stale-while-revalidate=${p.staleWhileRevalidate}`);
-  if (cls === "immutable") parts.push("immutable");
-  return parts.join(", ");
-}
-
-/** TanStack Query options for a class — spread straight into `useQuery`. */
-export function queryPolicy(cls: CacheClass): { staleTime: number } {
-  return { staleTime: CACHE_POLICIES[cls].staleTimeMs };
-}
-
-/**
- * A work's class from its own state. This is why the middleware picks TTL from
- * the RESPONSE rather than the route: the same `/releases/:id` path is a
- * year-stable published record for one id and a live draft for another.
- */
-export function workCacheClass(state: { type: string } | null | undefined): CacheClass {
-  return state?.type === "Published" ? "published" : "draft";
-}