@misofm/platform 0.25.0 → 0.26.1

package/src/genre.ts

@@ -40,12 +40,14 @@
  * `genres()[0]`, computed client-side the same way Move computes them.
  */
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
 import { bcs } from "@mysten/sui/bcs";
 import { deriveDynamicFieldID, deriveObjectID, normalizeSuiObjectId } from "@mysten/sui/utils";
 import type { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+import { Effect, Schema } from "effect";
+import { getOptionalObjectContent, type SuiClient, type SuiRpcError } from "@misofm/effect";
 import type { TxThunk } from "./transactions.ts";
 import { directAdminCap, invokeWithAdminCap, type AdminCapAuthority, type ObjectInput } from "./vault.ts";
+import { PlatformDeployment } from "./deployments.ts";
 import type { ReleaseExtensionTarget } from "./release-extensions.ts";
 import type { RecordingExtensionTarget } from "./recording-extensions.ts";
 import * as genre from "./contracts/genre/genre.ts";
@@ -82,6 +84,31 @@ export function deriveGenreAddress(
   );
 }
 
+/**
+ * A vocabulary entry from the shared `genre` registry, identified by its
+ * canonical name (e.g. `"HIP_HOP"`). Constructing one needs the deployment's
+ * genre registry object id and genre package id — see {@link Genre.derive}.
+ */
+export class Genre extends Schema.Class<Genre>("@misofm/platform/Genre")({
+  id: Schema.String,
+  name: Schema.String,
+}) {
+  /**
+   * Derives a `Genre`'s immutable object address from the platform
+   * deployment's genre registry + package id. This is a pure derivation (no
+   * chain read) but is the pilot for a value object whose construction
+   * genuinely needs deployment context, so it reaches that context through
+   * the `PlatformDeployment` service rather than an explicit parameter.
+   */
+  static readonly derive = Effect.fn("Genre.derive")(function* (
+    canonicalName: string,
+  ): Effect.fn.Return<Genre, never, PlatformDeployment> {
+    const deployment = yield* PlatformDeployment;
+    const id = deriveGenreAddress(deployment.objects.genreRegistry, deployment.packages.genre, canonicalName);
+    return new Genre({ id, name: canonicalName });
+  });
+}
+
 // ── Shared validation ────────────────────────────────────────────────────────
 
 /** The maximum number of genres `release_genre` / `recording_genre` will accept. */
@@ -334,19 +361,13 @@ export function recordingGenresFieldId(
  * are attached. The primary is `list[0]`; there is no separate primary reader
  * because the Move `genres` view already returns `[]` for the absent case.
  */
-export async function getReleaseGenres(
-  client: ClientWithCoreApi,
+export const getReleaseGenres = Effect.fn("getReleaseGenres")(function* (
   releaseId: string,
   releaseGenrePackageId: string,
-): Promise<string[]> {
-  const { objects } = await client.core.getObjects({
-    objectIds: [releaseGenresFieldId(releaseId, releaseGenrePackageId)],
-    include: { content: true },
-  });
-  const object = objects[0];
-  if (!object || object instanceof Error || !object.content) return [];
-  return parseReleaseGenresContent(object.content);
-}
+): Effect.fn.Return<string[], SuiRpcError, SuiClient> {
+  const found = yield* getOptionalObjectContent(releaseGenresFieldId(releaseId, releaseGenrePackageId));
+  return found._tag === "None" ? [] : parseReleaseGenresContent(found.value.content);
+});
 
 /**
  * Read a Recording's genre ids in order (primary first), or `[]` when no
@@ -354,16 +375,10 @@ export async function getReleaseGenres(
  * reader because the Move `genres` view already returns `[]` for the absent
  * case.
  */
-export async function getRecordingGenres(
-  client: ClientWithCoreApi,
+export const getRecordingGenres = Effect.fn("getRecordingGenres")(function* (
   recordingId: string,
   recordingGenrePackageId: string,
-): Promise<string[]> {
-  const { objects } = await client.core.getObjects({
-    objectIds: [recordingGenresFieldId(recordingId, recordingGenrePackageId)],
-    include: { content: true },
-  });
-  const object = objects[0];
-  if (!object || object instanceof Error || !object.content) return [];
-  return parseRecordingGenresContent(object.content);
-}
+): Effect.fn.Return<string[], SuiRpcError, SuiClient> {
+  const found = yield* getOptionalObjectContent(recordingGenresFieldId(recordingId, recordingGenrePackageId));
+  return found._tag === "None" ? [] : parseRecordingGenresContent(found.value.content);
+});

package/src/party/client.ts

@@ -3,9 +3,14 @@
 
 // Party EXTENSIONS bound to one `PartyExtensionsDeployment`, wrapping a
 // `PartyosClient` for the Party core. Consumers reach this through
-// `client.miso.party`.
+// `client.miso.party`. Every read returns `Effect<A, E>` (`R = never`) — the
+// `SuiClient` service is provided once by `PartyosClient`/`MisoPlatformClient`
+// and threaded through here, never re-provided per method.
 
+import { Effect } from "effect";
+import type { Option } from "effect";
 import type { ClientWithCoreApi } from "@mysten/sui/client";
+import { SuiClient, type BcsDecodeError, type ObjectNotFoundError, type ObjectTypeMismatchError, type SuiRpcError } from "@misofm/effect";
 import type { Party, PartyosClient } from "@misofm/partyos";
 import type { PartyExtensionsDeployment } from "../deployments.ts";
 import * as queries from "./queries.ts";
@@ -61,8 +66,8 @@ function bindModulePackage<M extends object, K extends readonly (keyof M)[]>(
  * CTAs, platform links) this package owns.
  */
 export class PartyPlatformClient {
-  #client: ClientWithCoreApi;
   #core: PartyosClient;
+  #layer: ReturnType<typeof SuiClient.layer>;
   #profilePkg: string;
   #countryCodePkg: string;
   #languageCodePkg: string;
@@ -77,8 +82,8 @@ export class PartyPlatformClient {
   #proLinkPkg: string;
 
   constructor(client: ClientWithCoreApi, core: PartyosClient, extensions: PartyExtensionsDeployment) {
-    this.#client = client;
     this.#core = core;
+    this.#layer = SuiClient.layer(client);
     this.#profilePkg = extensions.partyProfile;
     this.#countryCodePkg = extensions.countryCode;
     this.#languageCodePkg = extensions.languageCode;
@@ -98,61 +103,68 @@ export class PartyPlatformClient {
     return this.#core;
   }
 
+  /** Provides the bound `SuiClient` layer, dropping `R` to `never`. */
+  #provide<A, E>(effect: Effect.Effect<A, E, SuiClient>): Effect.Effect<A, E> {
+    return effect.pipe(Effect.provide(this.#layer));
+  }
+
   // === Core (delegated to `PartyosClient`) ===
 
-  async getPartyById(partyId: string): Promise<Party> {
+  getPartyById(partyId: string): Effect.Effect<Party, ObjectNotFoundError | ObjectTypeMismatchError | BcsDecodeError | SuiRpcError> {
     return this.#core.getPartyById(partyId);
   }
-  async getPartiesByIds(partyIds: readonly string[]): Promise<Partial<Record<string, Party>>> {
+  getPartiesByIds(
+    partyIds: readonly string[],
+  ): Effect.Effect<Partial<Record<string, Party>>, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError> {
     return this.#core.getPartiesByIds(partyIds);
   }
   derivePartyAdminCapId(partyId: string): string {
     return this.#core.derivePartyAdminCapId(partyId);
   }
   /** Group ids a party belongs to (member-side membership records). */
-  async getMemberships(partyId: string): Promise<string[]> {
+  getMemberships(partyId: string): Effect.Effect<string[], SuiRpcError> {
     return this.#core.getMemberships(partyId);
   }
   /** Member ids invited to a group but not yet accepted. */
-  async getPendingInvites(groupId: string): Promise<string[]> {
+  getPendingInvites(groupId: string): Effect.Effect<string[], SuiRpcError> {
     return this.#core.getPendingInvites(groupId);
   }
   /** Group ids that have invited this party but are awaiting its response. */
-  async getPendingMemberships(partyId: string): Promise<string[]> {
+  getPendingMemberships(partyId: string): Effect.Effect<string[], SuiRpcError> {
     return this.#core.getPendingMemberships(partyId);
   }
   /** Whether a party is a member of a group. */
-  async isMember(memberId: string, groupId: string): Promise<boolean> {
+  isMember(memberId: string, groupId: string): Effect.Effect<boolean, SuiRpcError> {
     return this.#core.isMember(memberId, groupId);
   }
 
   // === Extension queries ===
 
-  async getProfile(partyId: string): Promise<Profile | null> {
-    return queries.getProfile(this.#client, partyId, this.#profilePkg);
+  getProfile(partyId: string): Effect.Effect<Option.Option<Profile>, BcsDecodeError | SuiRpcError> {
+    return this.#provide(queries.getProfile(partyId, this.#profilePkg));
   }
-  async getMedia(partyId: string): Promise<Media | null> {
-    return queries.getMedia(this.#client, partyId, this.#mediaPkg);
+  getMedia(partyId: string): Effect.Effect<Option.Option<Media>, BcsDecodeError | SuiRpcError> {
+    return this.#provide(queries.getMedia(partyId, this.#mediaPkg));
   }
   /** The party's artist-type roles (display names). */
-  async getRoles(partyId: string): Promise<string[]> {
-    return queries.getRoles(this.#client, partyId, this.#rolesPkg);
+  getRoles(partyId: string): Effect.Effect<string[], SuiRpcError> {
+    return this.#provide(queries.getRoles(partyId, this.#rolesPkg));
   }
   /** The party's free-form tags. */
-  async getTags(partyId: string): Promise<string[]> {
-    return queries.getTags(this.#client, partyId, this.#tagsPkg);
+  getTags(partyId: string): Effect.Effect<string[], SuiRpcError> {
+    return this.#provide(queries.getTags(partyId, this.#tagsPkg));
   }
   /** The party's genre object ids. */
-  async getGenres(partyId: string): Promise<string[]> {
-    return queries.getGenres(this.#client, partyId, this.#partyGenrePkg);
+  getGenres(partyId: string): Effect.Effect<string[], SuiRpcError> {
+    return this.#provide(queries.getGenres(partyId, this.#partyGenrePkg));
   }
   /** The party's ordered CTA list (position is priority). */
-  async getCtas(partyId: string): Promise<Cta[]> {
-    return queries.getCtas(this.#client, partyId, this.#ctaPkg);
+  getCtas(partyId: string): Effect.Effect<Cta[], SuiRpcError> {
+    return this.#provide(queries.getCtas(partyId, this.#ctaPkg));
   }
   /** All external-platform links attached to the party (social, music, professional). */
-  async getLinks(partyId: string): Promise<PlatformLink[]> {
-    return queries.getLinks(this.#client, partyId);
+  getLinks(partyId: string): Effect.Effect<PlatformLink[], SuiRpcError> {
+    return this.#provide(queries.getLinks(partyId));
   }
 
   // === Transaction builders (thunks; package ids bound from the client) ===

package/src/party/extensions/links.ts

@@ -12,7 +12,8 @@
 
 import * as platformLinkMod from "../../contracts/party_platform_link/party_platform_link.ts";
 import type { TxThunk } from "@misofm/partyos";
-import type { PlatformKey, PlatformLink } from "../types.ts";
+import { PlatformLink } from "../types.ts";
+import type { PlatformKey } from "../types.ts";
 
 /** Which payload package a platform's `Data` type + constructor live in. */
 type PayloadPkgKind = "social" | "music" | "pro";
@@ -160,7 +161,7 @@ export function platformForDataType(dataType: string): PlatformKey | null {
 
 /** Builds a public `PlatformLink` from a platform key and its stored native identifier. */
 export function buildLink(platform: PlatformKey, value: string): PlatformLink {
-  return { platform, value, url: PLATFORMS[platform].url(value) };
+  return new PlatformLink({ platform, value, url: PLATFORMS[platform].url(value) });
 }
 
 // === Bound builders (the client binds package ids, then exposes per-platform methods) ===

package/src/party/queries.ts

@@ -7,10 +7,17 @@
 // in `@misofm/partyos` — this file only covers profile/media/roles/tags/genres/
 // ctas/links.
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
+import { Effect, Option, Stream } from "effect";
 import { deriveDynamicFieldID } from "@mysten/sui/utils";
 import { bcs } from "@mysten/sui/bcs";
-import { getObjectContent } from "@misofm/partyos";
+import {
+  decodeBcs,
+  getOptionalObjectContent,
+  listDynamicFields,
+  SuiClient,
+  type BcsDecodeError,
+  type SuiRpcError,
+} from "@misofm/effect";
 import { Profile as ProfileBcs, ProfileKey as ProfileKeyBcs } from "../contracts/party_profile/party_profile.ts";
 import { Media as MediaBcs, MediaKey as MediaKeyBcs } from "../contracts/party_media/party_media.ts";
 import { ArtistRole as ArtistRoleBcs, RolesKey as RolesKeyBcs } from "../contracts/party_roles/party_roles.ts";
@@ -19,115 +26,122 @@ import { GenresKey as GenresKeyBcs } from "../contracts/party_genre/party_genre.
 import { Cta as CtaBcs, CtasKey as CtasKeyBcs } from "../contracts/party_cta/party_cta.ts";
 import { mapCtas, mapGenres, mapMedia, mapProfile, mapRoles, mapTags } from "./internal.ts";
 import { buildLink, platformForDataType } from "./extensions/links.ts";
-import type { Cta, Media, PlatformLink, Profile } from "./types.ts";
+import { Cta, Media, PlatformLink, Profile } from "./types.ts";
 
 // The profile is a dynamic field on the party UID under an empty `ProfileKey()`
 // (Move's implicit `dummy_field: bool` → one zero byte).
 const ProfileField = bcs.struct("Field", { id: bcs.Address, name: ProfileKeyBcs, value: ProfileBcs });
 const PROFILE_KEY_BYTES = ProfileKeyBcs.serialize([false]).toBytes();
 
-/** Fetches a party's profile, or null if none is set. */
-export async function getProfile(
-  client: ClientWithCoreApi,
+/** Fetches a party's profile; `Option.none()` if none is set. */
+export const getProfile = Effect.fn("getProfile")(function* (
   partyId: string,
   partyProfilePackageId: string,
-): Promise<Profile | null> {
+): Effect.fn.Return<Option.Option<Profile>, BcsDecodeError | SuiRpcError, SuiClient> {
   const fieldId = deriveDynamicFieldID(
     partyId,
     `${partyProfilePackageId}::party_profile::ProfileKey`,
     PROFILE_KEY_BYTES,
   );
-  const content = await getObjectContent(client, fieldId);
-  if (!content) return null;
-  return mapProfile(partyId, ProfileField.parse(content).value);
-}
+  const contentOpt = yield* getOptionalObjectContent(fieldId);
+  if (Option.isNone(contentOpt)) return Option.none();
+  const profile = yield* decodeBcs(
+    { parse: (bytes: Uint8Array) => mapProfile(partyId, ProfileField.parse(bytes).value) },
+    Profile,
+    contentOpt.value.content,
+    { type: "Profile", objectId: fieldId },
+  );
+  return Option.some(profile);
+});
 
 // Media is a dynamic field on the party UID under an empty `MediaKey()` (same
 // implicit `dummy_field: bool` → one zero byte as the profile key).
 const MediaField = bcs.struct("Field", { id: bcs.Address, name: MediaKeyBcs, value: MediaBcs });
 const MEDIA_KEY_BYTES = MediaKeyBcs.serialize([false]).toBytes();
 
-/** Fetches a party's media (avatar + header), or null if none is set. */
-export async function getMedia(
-  client: ClientWithCoreApi,
+/** Fetches a party's media (avatar + header); `Option.none()` if none is set. */
+export const getMedia = Effect.fn("getMedia")(function* (
   partyId: string,
   partyMediaPackageId: string,
-): Promise<Media | null> {
+): Effect.fn.Return<Option.Option<Media>, BcsDecodeError | SuiRpcError, SuiClient> {
   const fieldId = deriveDynamicFieldID(
     partyId,
     `${partyMediaPackageId}::party_media::MediaKey`,
     MEDIA_KEY_BYTES,
   );
-  const content = await getObjectContent(client, fieldId);
-  if (!content) return null;
-  return mapMedia(partyId, MediaField.parse(content).value);
-}
+  const contentOpt = yield* getOptionalObjectContent(fieldId);
+  if (Option.isNone(contentOpt)) return Option.none();
+  const media = yield* decodeBcs(
+    { parse: (bytes: Uint8Array) => mapMedia(partyId, MediaField.parse(bytes).value) },
+    Media,
+    contentOpt.value.content,
+    { type: "Media", objectId: fieldId },
+  );
+  return Option.some(media);
+});
 
 // === Collection extension reads (roles / tags / genres / ctas) ===
 //
 // Each is a single dynamic field on the party UID under an empty positional key
 // (Move's implicit `dummy_field: bool` → one zero byte, same as the profile key).
+// Absence keeps the pre-migration policy: an empty collection, not a failure.
 
 const ROLES_KEY_BYTES = RolesKeyBcs.serialize([false]).toBytes();
 const RolesField = bcs.struct("Field", { id: bcs.Address, name: RolesKeyBcs, value: bcs.vector(ArtistRoleBcs) });
 
 /** The party's artist-type roles (display names), or `[]` if none are set. */
-export async function getRoles(
-  client: ClientWithCoreApi,
+export const getRoles = Effect.fn("getRoles")(function* (
   partyId: string,
   partyRolesPackageId: string,
-): Promise<string[]> {
+): Effect.fn.Return<string[], SuiRpcError, SuiClient> {
   const fieldId = deriveDynamicFieldID(partyId, `${partyRolesPackageId}::party_roles::RolesKey`, ROLES_KEY_BYTES);
-  const content = await getObjectContent(client, fieldId);
-  if (!content) return [];
-  return mapRoles(RolesField.parse(content).value);
-}
+  const contentOpt = yield* getOptionalObjectContent(fieldId);
+  if (Option.isNone(contentOpt)) return [];
+  return mapRoles(RolesField.parse(contentOpt.value.content).value);
+});
 
 const TAGS_KEY_BYTES = TagsKeyBcs.serialize([false]).toBytes();
 const TagsField = bcs.struct("Field", { id: bcs.Address, name: TagsKeyBcs, value: bcs.vector(bcs.string()) });
 
 /** The party's free-form tags, or `[]` if none are set. */
-export async function getTags(
-  client: ClientWithCoreApi,
+export const getTags = Effect.fn("getTags")(function* (
   partyId: string,
   partyTagsPackageId: string,
-): Promise<string[]> {
+): Effect.fn.Return<string[], SuiRpcError, SuiClient> {
   const fieldId = deriveDynamicFieldID(partyId, `${partyTagsPackageId}::party_tags::TagsKey`, TAGS_KEY_BYTES);
-  const content = await getObjectContent(client, fieldId);
-  if (!content) return [];
-  return mapTags(TagsField.parse(content).value);
-}
+  const contentOpt = yield* getOptionalObjectContent(fieldId);
+  if (Option.isNone(contentOpt)) return [];
+  return mapTags(TagsField.parse(contentOpt.value.content).value);
+});
 
 const GENRES_KEY_BYTES = GenresKeyBcs.serialize([false]).toBytes();
 const GenresField = bcs.struct("Field", { id: bcs.Address, name: GenresKeyBcs, value: bcs.vector(bcs.Address) });
 
 /** The party's genre object ids, or `[]` if none are set. */
-export async function getGenres(
-  client: ClientWithCoreApi,
+export const getGenres = Effect.fn("getGenres")(function* (
   partyId: string,
   partyGenrePackageId: string,
-): Promise<string[]> {
+): Effect.fn.Return<string[], SuiRpcError, SuiClient> {
   const fieldId = deriveDynamicFieldID(partyId, `${partyGenrePackageId}::party_genre::GenresKey`, GENRES_KEY_BYTES);
-  const content = await getObjectContent(client, fieldId);
-  if (!content) return [];
-  return mapGenres(GenresField.parse(content).value);
-}
+  const contentOpt = yield* getOptionalObjectContent(fieldId);
+  if (Option.isNone(contentOpt)) return [];
+  return mapGenres(GenresField.parse(contentOpt.value.content).value);
+});
 
 const CTAS_KEY_BYTES = CtasKeyBcs.serialize([false]).toBytes();
 // The CTA field's value is a bare `vector<Cta>` (not a wrapper struct).
 const CtasField = bcs.struct("Field", { id: bcs.Address, name: CtasKeyBcs, value: bcs.vector(CtaBcs) });
 
 /** The party's ordered CTA list (position is priority), or `[]` if none is set. */
-export async function getCtas(
-  client: ClientWithCoreApi,
+export const getCtas = Effect.fn("getCtas")(function* (
   partyId: string,
   partyCtaPackageId: string,
-): Promise<Cta[]> {
+): Effect.fn.Return<Cta[], SuiRpcError, SuiClient> {
   const fieldId = deriveDynamicFieldID(partyId, `${partyCtaPackageId}::party_cta::CtasKey`, CTAS_KEY_BYTES);
-  const content = await getObjectContent(client, fieldId);
-  if (!content) return [];
-  return mapCtas(CtasField.parse(content).value);
-}
+  const contentOpt = yield* getOptionalObjectContent(fieldId);
+  if (Option.isNone(contentOpt)) return [];
+  return mapCtas(CtasField.parse(contentOpt.value.content).value).map((c) => new Cta(c));
+});
 
 // === Platform-link reads ===
 //
@@ -141,23 +155,21 @@ const PlatformLinkField = bcs.struct("Field", { id: bcs.Address, name: bcs.bool(
 const PLATFORM_LINK_KEY_RE = /::platform_link::PlatformLinkKey<(.+)>$/;
 
 /** All external-platform links attached to a party (social, music, professional). */
-export async function getLinks(client: ClientWithCoreApi, partyId: string): Promise<PlatformLink[]> {
+export const getLinks = Effect.fn("getLinks")(function* (
+  partyId: string,
+): Effect.fn.Return<PlatformLink[], SuiRpcError, SuiClient> {
+  const fields = Array.from(yield* Stream.runCollect(listDynamicFields(partyId)));
   const links: PlatformLink[] = [];
-  let cursor: string | null | undefined;
-  do {
-    const page = await client.core.listDynamicFields({ parentId: partyId, cursor: cursor ?? undefined });
-    for (const f of page.dynamicFields) {
-      if (typeof f.name?.type !== "string") continue;
-      const match = f.name.type.match(PLATFORM_LINK_KEY_RE);
-      const dataType = match?.[1];
-      if (!dataType) continue;
-      const platform = platformForDataType(dataType);
-      if (!platform) continue;
-      const content = await getObjectContent(client, f.fieldId);
-      if (!content) continue;
-      links.push(buildLink(platform, PlatformLinkField.parse(content).value));
-    }
-    cursor = page.hasNextPage ? page.cursor : null;
-  } while (cursor);
+  for (const f of fields) {
+    if (typeof f.name?.type !== "string") continue;
+    const match = f.name.type.match(PLATFORM_LINK_KEY_RE);
+    const dataType = match?.[1];
+    if (!dataType) continue;
+    const platform = platformForDataType(dataType);
+    if (!platform) continue;
+    const contentOpt = yield* getOptionalObjectContent(f.fieldId);
+    if (Option.isNone(contentOpt)) continue;
+    links.push(buildLink(platform, PlatformLinkField.parse(contentOpt.value.content).value));
+  }
   return links;
-}
+});

package/src/party/types.ts

@@ -6,79 +6,83 @@
 // these. The Party object model itself (`Party`, `PartyKind`) is owned by
 // `@misofm/partyos` — import it from there.
 
-export interface Profile {
-  partyId: string;
-  bioShort: string;
-  bioLong?: string;
+import { Schema } from "effect";
+
+export class Profile extends Schema.Class<Profile>("@misofm/platform/Profile")({
+  partyId: Schema.String,
+  bioShort: Schema.String,
+  bioLong: Schema.optional(Schema.String),
   /** ISO 3166-1 alpha-2 country code, e.g. "GB". */
-  country?: string;
+  country: Schema.optional(Schema.String),
   /** ISO 639-1 language codes, e.g. ["en"]. */
-  languages: string[];
-}
+  languages: Schema.Array(Schema.String),
+}) {}
 
 /**
  * A party's imagery, stored on-chain as a single Walrus quilt. Individual images
  * (avatar, header, …) are quilt patches addressed by identifier off-chain — see
  * `mediaUrls` / `MEDIA_IDENTIFIERS` in `extensions/media`.
  */
-export interface Media {
-  partyId: string;
+export class Media extends Schema.Class<Media>("@misofm/platform/Media")({
+  partyId: Schema.String,
   /** Walrus quilt blob id (base64url) holding the party's images. */
-  quiltId: string;
-}
+  quiltId: Schema.String,
+}) {}
 
 /** A single call-to-action on a party: a labeled external link. Position is priority. */
-export interface Cta {
-  label: string;
-  url: string;
-}
+export class Cta extends Schema.Class<Cta>("@misofm/platform/Cta")({
+  label: Schema.String,
+  url: Schema.String,
+}) {}
 
 /**
  * A platform this SDK knows how to build a link for. One key per external
  * platform, spanning social (`x`, `instagram`, …), music (`spotify`, `bandcamp`,
  * …), and professional/industry (`website`, `patreon`, …) payloads.
  */
-export type PlatformKey =
+export const PlatformKey = Schema.Literals([
   // Social (party_social)
-  | "x"
-  | "instagram"
-  | "threads"
-  | "tiktok"
-  | "youtube"
-  | "discord"
-  | "telegram"
-  | "reddit"
-  | "twitch"
-  | "facebook"
+  "x",
+  "instagram",
+  "threads",
+  "tiktok",
+  "youtube",
+  "discord",
+  "telegram",
+  "reddit",
+  "twitch",
+  "facebook",
   // Music (party_music)
-  | "spotify"
-  | "bandcamp"
-  | "soundcloud"
-  | "appleMusic"
-  | "deezer"
-  | "tidal"
-  | "amazonMusic"
-  | "audiomack"
+  "spotify",
+  "bandcamp",
+  "soundcloud",
+  "appleMusic",
+  "deezer",
+  "tidal",
+  "amazonMusic",
+  "audiomack",
   // Professional / industry (party_pro_link)
-  | "website"
-  | "bookingPage"
-  | "managementPage"
-  | "publisherPage"
-  | "labelPage"
-  | "epk"
-  | "patreon"
-  | "substack"
-  | "kofi";
+  "website",
+  "bookingPage",
+  "managementPage",
+  "publisherPage",
+  "labelPage",
+  "epk",
+  "patreon",
+  "substack",
+  "kofi",
+]);
+export type PlatformKey = typeof PlatformKey.Type;
 
 /**
  * One external-platform link attached to a party. Only the native identifier
  * (`value` — a handle, artist id, subdomain, or full URL) is stored on-chain; the
  * public `url` is rebuilt client-side from it.
  */
-export interface PlatformLink {
-  platform: PlatformKey;
+export class PlatformLink extends Schema.Class<PlatformLink>("@misofm/platform/PlatformLink")({
+  platform: PlatformKey,
   /** The platform-native identifier stored on-chain (handle / id / subdomain / URL). */
-  value: string;
+  value: Schema.String,
   /** The public profile URL, rebuilt from `value`. */
-  url: string;
-}
+  url: Schema.String,
+}) {}