@misofm/platform 0.27.0 → 0.28.0

package/src/party/client.ts

@@ -1,17 +1,27 @@
 // Copyright (c) Miso Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-// Party EXTENSIONS bound to one `PartyExtensionsDeployment`, wrapping a
-// `PartyosClient` for the Party core. Consumers reach this through
-// `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.
+// `MisoPartyService`: the party surface consumers reach through
+// `client.miso.party` (misofm/sdks#35, WP3 "party and protocol composition").
+// It is not a `Context.Service` of its own — it is a plain object `Miso`'s
+// `make` assembles from the converted `@misofm/partyos` `Partyos` service (7
+// core delegations) plus this package's own party EXTENSION reads
+// (`party/queries.ts`, already converted in stage 1) and 25 `tx` fragments
+// (9 from `Partyos.tx`, 16 first-party extension builders), bound to one
+// `PartyExtensionsDeployment`. Per sui-effect's `docs/extensions.md` §12
+// ("converting an existing facade", step 3): the service's members are thin —
+// they close over the `Sui` the caller already holds and call the standalone
+// `party/queries.ts` functions, which keeps those functions independently
+// exported and usable without a service.
+//
+// `PartyPlatformClient` — the predecessor hand-written class this replaces —
+// is deleted per the issue's target shape; nothing here holds a client or a
+// signer.
 
-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 { Effect } from "effect";
+import { Sui, type ObjectId, type Recipe, type DecodeError, type SuiService, type TransportError } from "@unconfirmed/sui-effect";
+import { contracts, derivePartyAdminCapId, type PartyosService } from "@misofm/partyos";
 import type { PartyExtensionsDeployment } from "../deployments.ts";
 import * as queries from "./queries.ts";
 import * as profileExt from "./extensions/profile.ts";
@@ -43,7 +53,7 @@ type BoundModule<M extends object, Removed extends PropertyKey> = {
 };
 
 /** Defaults generated calls to one package and removes reference-returning calls. */
-function bindModulePackage<M extends object, K extends readonly (keyof M)[]>(
+export function bindModulePackage<M extends object, K extends readonly (keyof M)[] = readonly []>(
   mod: M,
   pkg: string,
   unavailable: K = [] as unknown as K,
@@ -53,228 +63,227 @@ function bindModulePackage<M extends object, K extends readonly (keyof M)[]>(
     if ((unavailable as readonly string[]).includes(key)) continue;
     out[key] =
       typeof value === "function"
-        ? (options: { package?: string }) => (value as (o: unknown) => unknown)({ package: pkg, ...options })
+        // `pkg` always wins — matches `Miso.ts`'s own `bindModulePackage`
+        // (C item, misofm/sdks#35 verification): the bound package is fixed,
+        // not a default a caller can quietly override via an unsafe cast
+        // past `BoundModule`'s `Omit<Options, "package">`.
+        ? (options: { package?: string }) => (value as (o: unknown) => unknown)({ ...options, package: pkg })
         : value;
   }
   return out as BoundModule<M, K[number]>;
 }
 
+/** The 25 `tx` fragments `MisoPartyService.tx` exposes: 9 delegated from `Partyos.tx`, 16 first-party extensions. */
+export type PartyTxBuilders = PartyosService["tx"] & {
+  readonly setProfile: (p: Omit<profileExt.SetProfileParams, "partyProfilePackageId" | "countryCodePackageId" | "languageCodePackageId">) => Recipe;
+  readonly clearProfile: (p: Omit<profileExt.ClearProfileParams, "partyProfilePackageId">) => Recipe;
+  readonly setMedia: (p: Omit<mediaExt.SetMediaParams, "partyMediaPackageId">) => Recipe;
+  readonly clearMedia: (p: Omit<mediaExt.ClearMediaParams, "partyMediaPackageId">) => Recipe;
+  readonly addRole: (p: Omit<rolesExt.AddRoleParams, "partyRolesPackageId">) => Recipe;
+  readonly removeRole: (p: Omit<rolesExt.RemoveRoleParams, "partyRolesPackageId">) => Recipe;
+  readonly clearRoles: (p: Omit<rolesExt.ClearRolesParams, "partyRolesPackageId">) => Recipe;
+  readonly addTag: (p: Omit<tagsExt.AddTagParams, "partyTagsPackageId">) => Recipe;
+  readonly removeTag: (p: Omit<tagsExt.RemoveTagParams, "partyTagsPackageId">) => Recipe;
+  readonly clearTags: (p: Omit<tagsExt.ClearTagsParams, "partyTagsPackageId">) => Recipe;
+  readonly addGenre: (p: Omit<genresExt.AddGenreParams, "partyGenrePackageId">) => Recipe;
+  readonly removeGenre: (p: Omit<genresExt.RemoveGenreParams, "partyGenrePackageId">) => Recipe;
+  readonly clearGenres: (p: Omit<genresExt.ClearGenresParams, "partyGenrePackageId">) => Recipe;
+  readonly setCtas: (p: Omit<ctasExt.SetCtasParams, "partyCtaPackageId">) => Recipe;
+  readonly clearCtas: (p: Omit<ctasExt.ClearCtasParams, "partyCtaPackageId">) => Recipe;
+  readonly setLink: (platform: PlatformKey, p: linksExt.BoundSetLinkParams) => Recipe;
+  readonly clearLink: (platform: PlatformKey, p: linksExt.BoundClearLinkParams) => Recipe;
+} & linksExt.LinkTxBuilders;
+
 /**
- * Package-bound Party client exposed at `client.miso.party`. Wraps a
- * `PartyosClient` for the Party core (identity, admin caps, group membership)
- * and adds the first-party extensions (profile, media, roles, tags, genres,
- * CTAs, platform links) this package owns.
+ * The party surface at `client.miso.party`: the converted `@misofm/partyos`
+ * core (delegated, unchanged) plus this package's own party EXTENSION reads
+ * and transaction fragments, bound to one `PartyExtensionsDeployment`.
+ *
+ * Declared as an object type alias, not an `interface` — sui-effect 0.1.0's
+ * `PromiseFace<S>` recurses only into members assignable to
+ * `Record<string, unknown>`, and an `interface` (unlike a type alias's object
+ * literal) is not, so `client.miso.party` would keep typing every member here
+ * as `Effect`-returning while the derived Promise face maps them to
+ * Promise-returning methods at runtime (misofm/sdks#35 verification, A1). See
+ * `docs/CONVERSION.md` "Stage 5".
  */
-export class PartyPlatformClient {
-  #core: PartyosClient;
-  #layer: ReturnType<typeof SuiClient.layer>;
-  #profilePkg: string;
-  #countryCodePkg: string;
-  #languageCodePkg: string;
-  #mediaPkg: string;
-  #rolesPkg: string;
-  #tagsPkg: string;
-  #partyGenrePkg: string;
-  #ctaPkg: string;
-  #platformLinkPkg: string;
-  #socialPkg: string;
-  #musicPkg: string;
-  #proLinkPkg: string;
-
-  constructor(client: ClientWithCoreApi, core: PartyosClient, extensions: PartyExtensionsDeployment) {
-    this.#core = core;
-    this.#layer = SuiClient.layer(client);
-    this.#profilePkg = extensions.partyProfile;
-    this.#countryCodePkg = extensions.countryCode;
-    this.#languageCodePkg = extensions.languageCode;
-    this.#mediaPkg = extensions.partyMedia;
-    this.#rolesPkg = extensions.partyRoles;
-    this.#tagsPkg = extensions.partyTags;
-    this.#partyGenrePkg = extensions.partyGenre;
-    this.#ctaPkg = extensions.partyCta;
-    this.#platformLinkPkg = extensions.partyPlatformLink;
-    this.#socialPkg = extensions.partySocial;
-    this.#musicPkg = extensions.partyMusic;
-    this.#proLinkPkg = extensions.partyProLink;
-  }
-
-  /** The wrapped Party-core client (identity, admin caps, group membership). */
-  get core(): PartyosClient {
-    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`) ===
-
-  getPartyById(partyId: string): Effect.Effect<Party, ObjectNotFoundError | ObjectTypeMismatchError | BcsDecodeError | SuiRpcError> {
-    return this.#core.getPartyById(partyId);
-  }
-  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). */
-  getMemberships(partyId: string): Effect.Effect<string[], SuiRpcError> {
-    return this.#core.getMemberships(partyId);
-  }
-  /** Member ids invited to a group but not yet accepted. */
-  getPendingInvites(groupId: string): Effect.Effect<string[], SuiRpcError> {
-    return this.#core.getPendingInvites(groupId);
-  }
-  /** Group ids that have invited this party but are awaiting its response. */
-  getPendingMemberships(partyId: string): Effect.Effect<string[], SuiRpcError> {
-    return this.#core.getPendingMemberships(partyId);
-  }
-  /** Whether a party is a member of a group. */
-  isMember(memberId: string, groupId: string): Effect.Effect<boolean, SuiRpcError> {
-    return this.#core.isMember(memberId, groupId);
-  }
+export type MisoPartyService = {
+  // === Core (delegated to `Partyos`) ===
+  readonly getPartyById: PartyosService["getPartyById"];
+  readonly getPartiesByIds: PartyosService["getPartiesByIds"];
+  /** Derives a party's `PartyAdminCap` id (it is a `derived_object` off the party UID). Never fails. */
+  readonly derivePartyAdminCapId: (partyId: string) => ObjectId;
+  readonly getMemberships: PartyosService["getMemberships"];
+  readonly getPendingInvites: PartyosService["getPendingInvites"];
+  readonly getPendingMemberships: PartyosService["getPendingMemberships"];
+  readonly isMember: PartyosService["isMember"];
 
-  // === Extension queries ===
+  // === Extension queries (this package's own) ===
+  /** Fails with: `DecodeError`, `TransportError`. */
+  readonly getProfile: (partyId: string) => Effect.Effect<Option.Option<Profile>, DecodeError | TransportError>;
+  /** Fails with: `DecodeError`, `TransportError`. */
+  readonly getMedia: (partyId: string) => Effect.Effect<Option.Option<Media>, DecodeError | TransportError>;
+  /** The party's artist-type roles (display names), or `[]`. Fails with: `DecodeError`, `TransportError`. */
+  readonly getRoles: (partyId: string) => Effect.Effect<string[], DecodeError | TransportError>;
+  /** The party's free-form tags, or `[]`. Fails with: `DecodeError`, `TransportError`. */
+  readonly getTags: (partyId: string) => Effect.Effect<string[], DecodeError | TransportError>;
+  /** The party's genre object ids, or `[]`. Fails with: `DecodeError`, `TransportError`. */
+  readonly getGenres: (partyId: string) => Effect.Effect<string[], DecodeError | TransportError>;
+  /** The party's ordered CTA list (position is priority), or `[]`. Fails with: `DecodeError`, `TransportError`. */
+  readonly getCtas: (partyId: string) => Effect.Effect<Cta[], DecodeError | TransportError>;
+  /** All external-platform links attached to the party. Fails with: `DecodeError`, `TransportError`. */
+  readonly getLinks: (partyId: string) => Effect.Effect<PlatformLink[], DecodeError | TransportError>;
 
-  getProfile(partyId: string): Effect.Effect<Option.Option<Profile>, BcsDecodeError | SuiRpcError> {
-    return this.#provide(queries.getProfile(partyId, this.#profilePkg));
-  }
-  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). */
-  getRoles(partyId: string): Effect.Effect<string[], SuiRpcError> {
-    return this.#provide(queries.getRoles(partyId, this.#rolesPkg));
-  }
-  /** The party's free-form tags. */
-  getTags(partyId: string): Effect.Effect<string[], SuiRpcError> {
-    return this.#provide(queries.getTags(partyId, this.#tagsPkg));
-  }
-  /** The party's genre object ids. */
-  getGenres(partyId: string): Effect.Effect<string[], SuiRpcError> {
-    return this.#provide(queries.getGenres(partyId, this.#partyGenrePkg));
-  }
-  /** The party's ordered CTA list (position is priority). */
-  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). */
-  getLinks(partyId: string): Effect.Effect<PlatformLink[], SuiRpcError> {
-    return this.#provide(queries.getLinks(partyId));
-  }
+  /**
+   * The 25 `tx` fragments (9 delegated from `Partyos.tx`, 16 first-party
+   * extension builders) with every package id bound to this deployment.
+   * Never fails; a recipe is synchronous and `Tx.build` reports one that
+   * throws as a `BuildError`.
+   */
+  readonly tx: PartyTxBuilders;
+  /** Generated type-safe Move calls (for `tx.add`), package-bound. */
+  readonly call: {
+    readonly party: ReturnType<typeof bindModulePackage<typeof contracts.party>>;
+    readonly profile: ReturnType<typeof bindModulePackage<typeof profileMod, readonly ["profile"]>>;
+    readonly media: ReturnType<typeof bindModulePackage<typeof mediaMod>>;
+    readonly roles: ReturnType<typeof bindModulePackage<typeof rolesMod>>;
+    readonly tags: ReturnType<typeof bindModulePackage<typeof tagsMod>>;
+    readonly cta: ReturnType<typeof bindModulePackage<typeof ctaMod>>;
+    readonly genre: ReturnType<typeof bindModulePackage<typeof genreMod>>;
+    readonly platformLink: ReturnType<typeof bindModulePackage<typeof platformLinkMod>>;
+    readonly social: ReturnType<typeof bindModulePackage<typeof socialMod>>;
+    readonly music: ReturnType<typeof bindModulePackage<typeof musicMod>>;
+    readonly proLink: ReturnType<typeof bindModulePackage<typeof proLinkMod>>;
+  };
+  /** Generated BCS structs (for parsing object/event content). */
+  readonly bcs: {
+    readonly Profile: typeof profileMod.Profile;
+    readonly ProfileSetEvent: typeof profileMod.PartyProfileSetEvent;
+    readonly PartyProfileSetEvent: typeof profileMod.PartyProfileSetEvent;
+    readonly PartyProfileClearedEvent: typeof profileMod.PartyProfileClearedEvent;
+    readonly Media: typeof mediaMod.Media;
+    readonly MediaSetEvent: typeof mediaMod.MediaSetEvent;
+    readonly MediaClearedEvent: typeof mediaMod.MediaClearedEvent;
+    readonly ArtistRole: typeof rolesMod.ArtistRole;
+    readonly RoleAddedEvent: typeof rolesMod.RoleAddedEvent;
+    readonly RoleRemovedEvent: typeof rolesMod.RoleRemovedEvent;
+    readonly RolesClearedEvent: typeof rolesMod.RolesClearedEvent;
+    readonly TagAddedEvent: typeof tagsMod.TagAddedEvent;
+    readonly TagRemovedEvent: typeof tagsMod.TagRemovedEvent;
+    readonly TagsClearedEvent: typeof tagsMod.TagsClearedEvent;
+    readonly Cta: typeof ctaMod.Cta;
+    readonly CtasSetEvent: typeof ctaMod.CtasSetEvent;
+    readonly CtasClearedEvent: typeof ctaMod.CtasClearedEvent;
+    readonly GenreAddedEvent: typeof genreMod.GenreAddedEvent;
+    readonly GenreRemovedEvent: typeof genreMod.GenreRemovedEvent;
+    readonly GenresClearedEvent: typeof genreMod.GenresClearedEvent;
+    readonly LinkSetEvent: typeof platformLinkMod.LinkSetEvent;
+    readonly LinkClearedEvent: typeof platformLinkMod.LinkClearedEvent;
+  };
+};
 
-  // === Transaction builders (thunks; package ids bound from the client) ===
+/**
+ * Assembles {@link MisoPartyService} from the converted `Partyos` service and
+ * `Sui`, bound to `deployment` — called from `Miso`'s own `make` (which
+ * already holds both), per `docs/extensions.md` §12 step 3: a thin service
+ * layer over standalone functions, closing over the `Sui` the caller already
+ * has rather than adding a requirement of its own.
+ */
+export function makeMisoParty(sui: SuiService, partyos: PartyosService, deployment: PartyExtensionsDeployment): MisoPartyService {
+  const withSui = <A, E>(effect: Effect.Effect<A, E, Sui>): Effect.Effect<A, E> =>
+    effect.pipe(Effect.provideService(Sui, sui));
 
-  get tx() {
-    const profilePkg = this.#profilePkg;
-    const cc = this.#countryCodePkg;
-    const lc = this.#languageCodePkg;
-    const mediaPkg = this.#mediaPkg;
-    const rolesPkg = this.#rolesPkg;
-    const tagsPkg = this.#tagsPkg;
-    const ctaPkg = this.#ctaPkg;
-    const partyGenrePkg = this.#partyGenrePkg;
-    const linkIds: linksExt.LinkPackageIds = {
-      partyPlatformLinkPackageId: this.#platformLinkPkg,
-      partySocialPackageId: this.#socialPkg,
-      partyMusicPackageId: this.#musicPkg,
-      partyProLinkPackageId: this.#proLinkPkg,
-    };
-    return {
-      // Party core builders — delegated straight from `PartyosClient`.
-      ...this.#core.tx,
-      setProfile: (
-        p: Omit<profileExt.SetProfileParams, "partyProfilePackageId" | "countryCodePackageId" | "languageCodePackageId">,
-      ) =>
-        profileExt.setProfile({
-          ...p,
-          partyProfilePackageId: profilePkg,
-          countryCodePackageId: cc,
-          languageCodePackageId: lc,
-        }),
-      clearProfile: (p: Omit<profileExt.ClearProfileParams, "partyProfilePackageId">) =>
-        profileExt.clearProfile({ ...p, partyProfilePackageId: profilePkg }),
-      setMedia: (p: Omit<mediaExt.SetMediaParams, "partyMediaPackageId">) =>
-        mediaExt.setMedia({ ...p, partyMediaPackageId: mediaPkg }),
-      clearMedia: (p: Omit<mediaExt.ClearMediaParams, "partyMediaPackageId">) =>
-        mediaExt.clearMedia({ ...p, partyMediaPackageId: mediaPkg }),
-      // Roles
-      addRole: (p: Omit<rolesExt.AddRoleParams, "partyRolesPackageId">) =>
-        rolesExt.addRole({ ...p, partyRolesPackageId: rolesPkg }),
-      removeRole: (p: Omit<rolesExt.RemoveRoleParams, "partyRolesPackageId">) =>
-        rolesExt.removeRole({ ...p, partyRolesPackageId: rolesPkg }),
-      clearRoles: (p: Omit<rolesExt.ClearRolesParams, "partyRolesPackageId">) =>
-        rolesExt.clearRoles({ ...p, partyRolesPackageId: rolesPkg }),
-      // Tags
-      addTag: (p: Omit<tagsExt.AddTagParams, "partyTagsPackageId">) =>
-        tagsExt.addTag({ ...p, partyTagsPackageId: tagsPkg }),
-      removeTag: (p: Omit<tagsExt.RemoveTagParams, "partyTagsPackageId">) =>
-        tagsExt.removeTag({ ...p, partyTagsPackageId: tagsPkg }),
-      clearTags: (p: Omit<tagsExt.ClearTagsParams, "partyTagsPackageId">) =>
-        tagsExt.clearTags({ ...p, partyTagsPackageId: tagsPkg }),
-      // Genres
-      addGenre: (p: Omit<genresExt.AddGenreParams, "partyGenrePackageId">) =>
-        genresExt.addGenre({ ...p, partyGenrePackageId: partyGenrePkg }),
-      removeGenre: (p: Omit<genresExt.RemoveGenreParams, "partyGenrePackageId">) =>
-        genresExt.removeGenre({ ...p, partyGenrePackageId: partyGenrePkg }),
-      clearGenres: (p: Omit<genresExt.ClearGenresParams, "partyGenrePackageId">) =>
-        genresExt.clearGenres({ ...p, partyGenrePackageId: partyGenrePkg }),
-      // CTAs
-      setCtas: (p: Omit<ctasExt.SetCtasParams, "partyCtaPackageId">) =>
-        ctasExt.setCtas({ ...p, partyCtaPackageId: ctaPkg }),
-      clearCtas: (p: Omit<ctasExt.ClearCtasParams, "partyCtaPackageId">) =>
-        ctasExt.clearCtas({ ...p, partyCtaPackageId: ctaPkg }),
-      // Platform links — generic (any platform) plus per-platform `set…`/`clear…`.
-      setLink: (platform: PlatformKey, p: linksExt.BoundSetLinkParams) =>
-        linksExt.setLink(platform, { ...p, ...linkIds }),
-      clearLink: (platform: PlatformKey, p: linksExt.BoundClearLinkParams) =>
-        linksExt.clearLink(platform, { ...p, ...linkIds }),
-      ...linksExt.linkTxBuilders(linkIds),
-    };
-  }
+  const profilePkg = deployment.partyProfile;
+  const cc = deployment.countryCode;
+  const lc = deployment.languageCode;
+  const mediaPkg = deployment.partyMedia;
+  const rolesPkg = deployment.partyRoles;
+  const tagsPkg = deployment.partyTags;
+  const ctaPkg = deployment.partyCta;
+  const partyGenrePkg = deployment.partyGenre;
+  const linkIds: linksExt.LinkPackageIds = {
+    partyPlatformLinkPackageId: deployment.partyPlatformLink,
+    partySocialPackageId: deployment.partySocial,
+    partyMusicPackageId: deployment.partyMusic,
+    partyProLinkPackageId: deployment.partyProLink,
+  };
 
-  // === Generated type-safe Move calls (for tx.add) ===
+  const tx: PartyTxBuilders = {
+    ...partyos.tx,
+    setProfile: (p) => profileExt.setProfile({ ...p, partyProfilePackageId: profilePkg, countryCodePackageId: cc, languageCodePackageId: lc }),
+    clearProfile: (p) => profileExt.clearProfile({ ...p, partyProfilePackageId: profilePkg }),
+    setMedia: (p) => mediaExt.setMedia({ ...p, partyMediaPackageId: mediaPkg }),
+    clearMedia: (p) => mediaExt.clearMedia({ ...p, partyMediaPackageId: mediaPkg }),
+    addRole: (p) => rolesExt.addRole({ ...p, partyRolesPackageId: rolesPkg }),
+    removeRole: (p) => rolesExt.removeRole({ ...p, partyRolesPackageId: rolesPkg }),
+    clearRoles: (p) => rolesExt.clearRoles({ ...p, partyRolesPackageId: rolesPkg }),
+    addTag: (p) => tagsExt.addTag({ ...p, partyTagsPackageId: tagsPkg }),
+    removeTag: (p) => tagsExt.removeTag({ ...p, partyTagsPackageId: tagsPkg }),
+    clearTags: (p) => tagsExt.clearTags({ ...p, partyTagsPackageId: tagsPkg }),
+    addGenre: (p) => genresExt.addGenre({ ...p, partyGenrePackageId: partyGenrePkg }),
+    removeGenre: (p) => genresExt.removeGenre({ ...p, partyGenrePackageId: partyGenrePkg }),
+    clearGenres: (p) => genresExt.clearGenres({ ...p, partyGenrePackageId: partyGenrePkg }),
+    setCtas: (p) => ctasExt.setCtas({ ...p, partyCtaPackageId: ctaPkg }),
+    clearCtas: (p) => ctasExt.clearCtas({ ...p, partyCtaPackageId: ctaPkg }),
+    setLink: (platform, p) => linksExt.setLink(platform, { ...p, ...linkIds }),
+    clearLink: (platform, p) => linksExt.clearLink(platform, { ...p, ...linkIds }),
+    ...linksExt.linkTxBuilders(linkIds),
+  };
 
-  get call() {
-    return {
-      party: this.#core.call.party,
-      profile: bindModulePackage(profileMod, this.#profilePkg, ["profile"] as const),
-      media: bindModulePackage(mediaMod, this.#mediaPkg),
-      roles: bindModulePackage(rolesMod, this.#rolesPkg),
-      tags: bindModulePackage(tagsMod, this.#tagsPkg),
-      cta: bindModulePackage(ctaMod, this.#ctaPkg),
-      genre: bindModulePackage(genreMod, this.#partyGenrePkg),
-      platformLink: bindModulePackage(platformLinkMod, this.#platformLinkPkg),
-      social: bindModulePackage(socialMod, this.#socialPkg),
-      music: bindModulePackage(musicMod, this.#musicPkg),
-      proLink: bindModulePackage(proLinkMod, this.#proLinkPkg),
-    };
-  }
+  return {
+    getPartyById: partyos.getPartyById,
+    getPartiesByIds: partyos.getPartiesByIds,
+    derivePartyAdminCapId: (partyId) => derivePartyAdminCapId(partyId, partyos.deployment.partyos),
+    getMemberships: partyos.getMemberships,
+    getPendingInvites: partyos.getPendingInvites,
+    getPendingMemberships: partyos.getPendingMemberships,
+    isMember: partyos.isMember,
 
-  // === Generated BCS structs (for parsing object/event content) ===
+    getProfile: (partyId) => withSui(queries.getProfile(partyId, profilePkg)),
+    getMedia: (partyId) => withSui(queries.getMedia(partyId, mediaPkg)),
+    getRoles: (partyId) => withSui(queries.getRoles(partyId, rolesPkg)),
+    getTags: (partyId) => withSui(queries.getTags(partyId, tagsPkg)),
+    getGenres: (partyId) => withSui(queries.getGenres(partyId, partyGenrePkg)),
+    getCtas: (partyId) => withSui(queries.getCtas(partyId, ctaPkg)),
+    getLinks: (partyId) => withSui(queries.getLinks(partyId)),
 
-  get bcs() {
-    return {
-      ...this.#core.bcs,
+    tx,
+    call: {
+      party: bindModulePackage(contracts.party, partyos.deployment.partyos),
+      profile: bindModulePackage(profileMod, profilePkg, ["profile"] as const),
+      media: bindModulePackage(mediaMod, mediaPkg),
+      roles: bindModulePackage(rolesMod, rolesPkg),
+      tags: bindModulePackage(tagsMod, tagsPkg),
+      cta: bindModulePackage(ctaMod, ctaPkg),
+      genre: bindModulePackage(genreMod, partyGenrePkg),
+      platformLink: bindModulePackage(platformLinkMod, linkIds.partyPlatformLinkPackageId),
+      social: bindModulePackage(socialMod, linkIds.partySocialPackageId),
+      music: bindModulePackage(musicMod, linkIds.partyMusicPackageId),
+      proLink: bindModulePackage(proLinkMod, linkIds.partyProLinkPackageId),
+    },
+    bcs: {
       Profile: profileMod.Profile,
-      ProfileSetEvent: profileMod.ProfileSetEvent,
+      ProfileSetEvent: profileMod.PartyProfileSetEvent,
+      PartyProfileSetEvent: profileMod.PartyProfileSetEvent,
+      PartyProfileClearedEvent: profileMod.PartyProfileClearedEvent,
       Media: mediaMod.Media,
       MediaSetEvent: mediaMod.MediaSetEvent,
+      MediaClearedEvent: mediaMod.MediaClearedEvent,
       ArtistRole: rolesMod.ArtistRole,
       RoleAddedEvent: rolesMod.RoleAddedEvent,
+      RoleRemovedEvent: rolesMod.RoleRemovedEvent,
+      RolesClearedEvent: rolesMod.RolesClearedEvent,
       TagAddedEvent: tagsMod.TagAddedEvent,
+      TagRemovedEvent: tagsMod.TagRemovedEvent,
+      TagsClearedEvent: tagsMod.TagsClearedEvent,
       Cta: ctaMod.Cta,
       CtasSetEvent: ctaMod.CtasSetEvent,
+      CtasClearedEvent: ctaMod.CtasClearedEvent,
       GenreAddedEvent: genreMod.GenreAddedEvent,
+      GenreRemovedEvent: genreMod.GenreRemovedEvent,
+      GenresClearedEvent: genreMod.GenresClearedEvent,
       LinkSetEvent: platformLinkMod.LinkSetEvent,
       LinkClearedEvent: platformLinkMod.LinkClearedEvent,
-    };
-  }
+    },
+  };
 }
-
-/** @deprecated Use `PartyPlatformClient`. Retained for callers migrating from the pre-split class. */
-export { PartyPlatformClient as PartyProtocolClient };

package/src/party/extensions/ctas.ts

@@ -7,7 +7,7 @@
 // and passes the vector to `set_ctas`.
 
 import * as ctaMod from "../../contracts/party_cta/party_cta.ts";
-import type { TxThunk } from "@misofm/partyos";
+import type { Recipe } from "@unconfirmed/sui-effect";
 import type { Cta } from "../types.ts";
 
 export interface SetCtasParams {
@@ -19,7 +19,7 @@ export interface SetCtasParams {
 }
 
 /** Sets (or replaces) the party's ordered CTA list. */
-export function setCtas(params: SetCtasParams): TxThunk {
+export function setCtas(params: SetCtasParams): Recipe {
   return (tx) => {
     const ctaType = `${params.partyCtaPackageId}::party_cta::Cta`;
     const ctas = tx.makeMoveVec({
@@ -39,7 +39,7 @@ export interface ClearCtasParams {
 }
 
 /** Removes the party's CTA list. No-op on-chain if none is set. */
-export function clearCtas(params: ClearCtasParams): TxThunk {
+export function clearCtas(params: ClearCtasParams): Recipe {
   return (tx) => {
     tx.add(ctaMod.clearCtas({ package: params.partyCtaPackageId, arguments: [params.partyId, params.capId] }));
   };

package/src/party/extensions/genres.ts

@@ -6,7 +6,7 @@
 // entry), so the builder passes `tx.object(genreId)`; removal is by id.
 
 import * as genreMod from "../../contracts/party_genre/party_genre.ts";
-import type { TxThunk } from "@misofm/partyos";
+import type { Recipe } from "@unconfirmed/sui-effect";
 
 export interface AddGenreParams {
   partyId: string;
@@ -17,7 +17,7 @@ export interface AddGenreParams {
 }
 
 /** Tags a genre on the party. Aborts on-chain if already present or the max is reached. */
-export function addGenre(params: AddGenreParams): TxThunk {
+export function addGenre(params: AddGenreParams): Recipe {
   return (tx) => {
     tx.add(
       genreMod.addGenre({
@@ -37,7 +37,7 @@ export interface RemoveGenreParams {
 }
 
 /** Untags a genre from the party. Aborts on-chain if not present. */
-export function removeGenre(params: RemoveGenreParams): TxThunk {
+export function removeGenre(params: RemoveGenreParams): Recipe {
   return (tx) => {
     tx.add(
       genreMod.removeGenre({
@@ -55,7 +55,7 @@ export interface ClearGenresParams {
 }
 
 /** Removes the party's entire genre set. No-op on-chain if none is set. */
-export function clearGenres(params: ClearGenresParams): TxThunk {
+export function clearGenres(params: ClearGenresParams): Recipe {
   return (tx) => {
     tx.add(genreMod.clearGenres({ package: params.partyGenrePackageId, arguments: [params.partyId, params.capId] }));
   };

package/src/party/extensions/links.ts

@@ -11,7 +11,7 @@
 // Only the native identifier is stored on-chain; the public URL is rebuilt from it.
 
 import * as platformLinkMod from "../../contracts/party_platform_link/party_platform_link.ts";
-import type { TxThunk } from "@misofm/partyos";
+import type { Recipe } from "@unconfirmed/sui-effect";
 import { PlatformLink } from "../types.ts";
 import type { PlatformKey } from "../types.ts";
 
@@ -105,7 +105,7 @@ export interface SetLinkParams extends LinkPackageIds {
 }
 
 /** Sets (or replaces) a platform's link on the party. */
-export function setLink(platform: PlatformKey, params: SetLinkParams): TxThunk {
+export function setLink(platform: PlatformKey, params: SetLinkParams): Recipe {
   return (tx) => {
     const spec = PLATFORMS[platform];
     const pkg = payloadPackageId(spec, params);
@@ -129,7 +129,7 @@ export interface ClearLinkParams extends LinkPackageIds {
 }
 
 /** Clears a platform's link from the party. No-op on-chain if unset. */
-export function clearLink(platform: PlatformKey, params: ClearLinkParams): TxThunk {
+export function clearLink(platform: PlatformKey, params: ClearLinkParams): Recipe {
   return (tx) => {
     const spec = PLATFORMS[platform];
     tx.add(
@@ -171,16 +171,16 @@ export type BoundClearLinkParams = Omit<ClearLinkParams, keyof LinkPackageIds>;
 
 /** Per-platform `setX` / `clearX` builders, keyed off the table so all ~27 are covered. */
 export type LinkTxBuilders =
-  & { [K in PlatformKey as `set${Capitalize<K>}`]: (p: BoundSetLinkParams) => TxThunk }
-  & { [K in PlatformKey as `clear${Capitalize<K>}`]: (p: BoundClearLinkParams) => TxThunk };
+  & { [K in PlatformKey as `set${Capitalize<K>}`]: (p: BoundSetLinkParams) => Recipe }
+  & { [K in PlatformKey as `clear${Capitalize<K>}`]: (p: BoundClearLinkParams) => Recipe };
 
 /** Builds the per-platform link tx builders with `ids` pre-bound. */
 export function linkTxBuilders(ids: LinkPackageIds): LinkTxBuilders {
   const out: Record<string, unknown> = {};
   for (const key of PLATFORM_KEYS) {
     const cap = key.charAt(0).toUpperCase() + key.slice(1);
-    out[`set${cap}`] = (p: BoundSetLinkParams): TxThunk => setLink(key, { ...p, ...ids });
-    out[`clear${cap}`] = (p: BoundClearLinkParams): TxThunk => clearLink(key, { ...p, ...ids });
+    out[`set${cap}`] = (p: BoundSetLinkParams): Recipe => setLink(key, { ...p, ...ids });
+    out[`clear${cap}`] = (p: BoundClearLinkParams): Recipe => clearLink(key, { ...p, ...ids });
   }
   return out as LinkTxBuilders;
 }

package/src/party/extensions/media.ts

@@ -10,7 +10,7 @@
 
 import { b64UrlToU256 } from "../internal.ts";
 import * as mediaMod from "../../contracts/party_media/party_media.ts";
-import type { TxThunk } from "@misofm/partyos";
+import type { Recipe } from "@unconfirmed/sui-effect";
 import type { Media } from "../types.ts";
 
 /**
@@ -30,7 +30,7 @@ export interface SetMediaParams {
 }
 
 /** Sets (or replaces) the party's media quilt. */
-export function setMedia(params: SetMediaParams): TxThunk {
+export function setMedia(params: SetMediaParams): Recipe {
   return (tx) => {
     tx.add(
       mediaMod.setMedia({
@@ -48,7 +48,7 @@ export interface ClearMediaParams {
 }
 
 /** Removes the party's media entirely. No-op on-chain if none is set. */
-export function clearMedia(params: ClearMediaParams): TxThunk {
+export function clearMedia(params: ClearMediaParams): Recipe {
   return (tx) => {
     tx.add(mediaMod.clearMedia({ package: params.partyMediaPackageId, arguments: [params.partyId, params.capId] }));
   };

package/src/party/extensions/profile.ts

@@ -6,7 +6,7 @@
 // `CountryCode` / `LanguageCode` values from raw ISO codes.
 
 import * as profileMod from "../../contracts/party_profile/party_profile.ts";
-import type { TxThunk } from "@misofm/partyos";
+import type { Recipe } from "@unconfirmed/sui-effect";
 
 const OPTION_NONE = "0x1::option::none";
 const OPTION_SOME = "0x1::option::some";
@@ -26,7 +26,7 @@ export interface SetProfileParams {
 }
 
 /** Sets (creates or replaces) a party's whole profile. */
-export function setProfile(params: SetProfileParams): TxThunk {
+export function setProfile(params: SetProfileParams): Recipe {
   return (tx) => {
     const ccType = `${params.countryCodePackageId}::country_code::CountryCode`;
     const country = params.country
@@ -69,7 +69,7 @@ export interface ClearProfileParams {
 }
 
 /** Removes a party's profile. No-op on-chain if none is set. */
-export function clearProfile(params: ClearProfileParams): TxThunk {
+export function clearProfile(params: ClearProfileParams): Recipe {
   return (tx) => {
     tx.add(
       profileMod.clearProfile({