@misofm/platform 0.24.0 → 0.25.0

package/src/publication.ts

@@ -21,8 +21,9 @@ import {
   deriveCompositionAdminCapId,
   deriveRecordingAdminCapId,
   deriveReleaseAdminCapId,
-} from "@misofm/protocol";
-import { derivePartyAdminCapId } from "@misofm/protocol/party";
+} from "@misofm/musicos";
+import { party } from "@misofm/partyos/contracts";
+import { derivePartyAdminCapId } from "@misofm/partyos";
 import {
   requireOperationsDeployment,
   type AvailableOperationsDeployment,
@@ -58,10 +59,10 @@ import { unencryptedWalrusBlob } from "./internal.ts";
 import {
   setReleaseDescription,
   setReleaseDspLinks,
-  setReleaseGenres,
   setReleaseKind,
   type DspLink,
 } from "./release-extensions.ts";
+import { setReleaseGenres, setRecordingGenres } from "./genre.ts";
 import { setReleaseCover, setReleaseTrackCover } from "./cover.ts";
 import {
   custodyNewAdminCap,
@@ -88,10 +89,10 @@ import {
 } from "./pressing.ts";
 import { requireRecordSalesDeployment } from "./deployments.ts";
 import { allCreatedByType, createdByExactType, type PlatformExecResult } from "./execute.ts";
-import * as pressingContract from "@misofm/protocol/contracts/miso_record/pressing";
-import * as listingContract from "@misofm/protocol/contracts/miso_record_shop/listing";
+import * as pressingContract from "./contracts/record/pressing.ts";
+import * as listingContract from "./contracts/record_shop/listing.ts";
 
-const { composition, recording, release, track, party } = protocolContracts;
+const { composition, recording, release, track } = protocolContracts;
 
 export const MAX_ATOMIC_PUBLICATION_COMMANDS = 900;
 export const MAX_ATOMIC_PUBLICATION_INPUTS = 2048;
@@ -183,6 +184,8 @@ export type PublicationRecording = PublicationRecordingParent & {
   /** Route the exact parent Composition royalty cut through this Recording's pool. */
   readonly routedStake?: true;
   readonly advisory?: "Explicit" | "NotExplicit" | "Cleaned";
+  /** Ordered genre object ids, primary first (1-6). */
+  readonly genres?: string[];
   readonly languages?: PublicationRecordingLanguages;
   readonly masterReferenceBlobId?: bigint | string;
   /** Complete Walrus Quilt ID containing this Recording's streaming transcodes. */
@@ -214,11 +217,8 @@ export interface PublicationRelease {
   readonly credits?: PublicationReleaseCredit[];
   readonly kind?: string;
   readonly description?: string;
-  readonly genres?: {
-    readonly primaryGenreId: string;
-    readonly secondaryGenreIds?: string[];
-    readonly tracks?: { readonly trackIndex: number; readonly genreId: string }[];
-  };
+  /** Ordered genre object ids, primary first (1-6). */
+  readonly genres?: string[];
   readonly dspLinks?: {
     readonly release?: DspLink[];
     readonly tracks?: { readonly trackIndex: number; readonly link: DspLink }[];
@@ -275,19 +275,19 @@ function requiredAt<T>(items: readonly T[], index: number, description: string):
 }
 
 function partyCapType(p: AtomicPublicationParams): string {
-  return `${p.deployment.protocol.misoParty}::party::PartyAdminCap`;
+  return `${p.deployment.partyos.partyos}::party::PartyAdminCap`;
 }
 
 function compositionCapType(p: AtomicPublicationParams, shareType: string): string {
-  return `${p.deployment.protocol.miso}::composition::CompositionAdminCap<${shareType}>`;
+  return `${p.deployment.protocol.musicos}::composition::CompositionAdminCap<${shareType}>`;
 }
 
 function recordingCapType(p: AtomicPublicationParams, shareType: string): string {
-  return `${p.deployment.protocol.miso}::recording::RecordingAdminCap<${shareType}>`;
+  return `${p.deployment.protocol.musicos}::recording::RecordingAdminCap<${shareType}>`;
 }
 
 function releaseCapType(p: AtomicPublicationParams): string {
-  return `${p.deployment.protocol.miso}::release::ReleaseAdminCap`;
+  return `${p.deployment.protocol.musicos}::release::ReleaseAdminCap`;
 }
 
 function pressingCapType(p: AtomicPublicationParams): string {
@@ -340,11 +340,11 @@ function partyByRef(
 
 function languageVector(tx: Transaction, p: AtomicPublicationParams, codes: string[]) {
   const values = codes.map((code) => tx.moveCall({
-    target: `${p.deployment.protocol.languageCode}::language_code::new`,
+    target: `${p.deployment.packages.languageCode}::language_code::new`,
     arguments: [tx.pure.string(code)],
   }));
   return tx.makeMoveVec({
-    type: `${p.deployment.protocol.languageCode}::language_code::LanguageCode`,
+    type: `${p.deployment.packages.languageCode}::language_code::LanguageCode`,
     elements: values,
   });
 }
@@ -456,7 +456,7 @@ function publishComposition(
   const typeArguments: [string] = [node.shareType];
   if (node.custody.kind === "direct") {
     tx.add(composition.publish({
-      package: p.deployment.protocol.miso,
+      package: p.deployment.protocol.musicos,
       typeArguments,
       arguments: [parts.work, parts.adminCap],
     }));
@@ -503,7 +503,7 @@ function publishComposition(
         capType: compositionCapType(p, node.shareType),
         vaultPackageId: available!.vault.packageId,
       }, {
-        target: `${p.deployment.protocol.miso}::composition::publish`,
+        target: `${p.deployment.protocol.musicos}::composition::publish`,
         typeArguments,
         arguments: [parts.work, tx.object.clock()],
         adminCapIndex: 1,
@@ -525,7 +525,7 @@ function publishRecording(
   const stakes = allocatePublicationShares(tx, p, node, parts.balance);
   if (node.custody.kind === "direct") {
     tx.add(recording.publish({
-      package: p.deployment.protocol.miso,
+      package: p.deployment.protocol.musicos,
       typeArguments,
       arguments: [parts.work, parts.adminCap],
     }));
@@ -605,7 +605,7 @@ function publishRecording(
         capType: recordingCapType(p, node.shareType),
         vaultPackageId: available!.vault.packageId,
       }, {
-        target: `${p.deployment.protocol.miso}::recording::publish`,
+        target: `${p.deployment.protocol.musicos}::recording::publish`,
         typeArguments,
         arguments: [parts.work, tx.object.clock()],
         adminCapIndex: 1,
@@ -625,7 +625,7 @@ function publishReleaseObject(
   const available = node.custody.kind === "vault" ? operations(p) : undefined;
   if (node.custody.kind === "direct") {
     tx.add(release.publish({
-      package: p.deployment.protocol.miso,
+      package: p.deployment.protocol.musicos,
       arguments: [releaseObject, adminCap],
     }));
     disposeNewAdminCap(tx, adminCap, custody(p, node.custody, releaseCapType(p)));
@@ -649,7 +649,7 @@ function publishReleaseObject(
         capType: releaseCapType(p),
         vaultPackageId: available!.vault.packageId,
       }, {
-        target: `${p.deployment.protocol.miso}::release::publish`,
+        target: `${p.deployment.protocol.musicos}::release::publish`,
         arguments: [releaseObject, tx.object.clock()],
         adminCapIndex: 1,
       });
@@ -726,10 +726,10 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
         continue;
       }
       const kind = tx.add(node.create === "group"
-        ? party.newGroupKind({ package: p.deployment.protocol.misoParty })
-        : party.newIndividualKind({ package: p.deployment.protocol.misoParty }));
+        ? party.newGroupKind({ package: p.deployment.partyos.partyos })
+        : party.newIndividualKind({ package: p.deployment.partyos.partyos }));
       const created = tx.add(party._new({
-        package: p.deployment.protocol.misoParty,
+        package: p.deployment.partyos.partyos,
         arguments: [kind, node.name],
       }));
       const parts = {
@@ -742,7 +742,7 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
 
     const compositions: WorkParts[] = p.compositions.map((node) => {
       const created = tx.add(composition._new({
-        package: p.deployment.protocol.miso,
+        package: p.deployment.protocol.musicos,
         typeArguments: [node.shareType],
         arguments: [node.title, node.royaltyRateBps, node.shareCurrencyId, node.shareTreasuryCapId],
       }));
@@ -758,7 +758,7 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
         ? requiredAt(compositions, node.parentCompositionIndex, "parent composition").work
         : tx.object(node.parentCompositionId);
       const created = tx.add(recording._new({
-        package: p.deployment.protocol.miso,
+        package: p.deployment.protocol.musicos,
         typeArguments: [node.shareType, node.compositionShareType],
         arguments: [parent, node.shareCurrencyId, node.shareTreasuryCapId],
       }));
@@ -775,12 +775,12 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
       const ids = p.release.tracks.map((node) => "recordingIndex" in node
         ? tx.moveCall({
             target: "0x2::object::id",
-            typeArguments: [`${p.deployment.protocol.miso}::recording::Recording<${p.recordings[node.recordingIndex]!.shareType},${p.recordings[node.recordingIndex]!.compositionShareType}>`],
+            typeArguments: [`${p.deployment.protocol.musicos}::recording::Recording<${p.recordings[node.recordingIndex]!.shareType},${p.recordings[node.recordingIndex]!.compositionShareType}>`],
             arguments: [requiredAt(recordings, node.recordingIndex, "fresh recording").work],
           })
         : tx.pure.id(node.recordingId));
       const targetReleaseId = tx.moveCall({
-        target: `${p.deployment.protocol.miso}::release::derive_target_release_id`,
+        target: `${p.deployment.protocol.musicos}::release::derive_target_release_id`,
         arguments: [
           tx.object(p.deployment.objects.releaseRegistry),
           tx.makeMoveVec({ type: "0x2::object::ID", elements: ids }),
@@ -793,24 +793,24 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
           const recNode = requiredAt(p.recordings, node.recordingIndex, "fresh recording");
           const rec = requiredAt(recordings, node.recordingIndex, "fresh recording");
           return tx.add(track._new({
-            package: p.deployment.protocol.miso,
+            package: p.deployment.protocol.musicos,
             typeArguments: [recNode.shareType, recNode.compositionShareType],
             arguments: [rec.adminCap, rec.work, targetReleaseId, node.splitBps],
           }));
         }
         return invokeWithAdminCap(tx, node.authority, {
-          target: `${p.deployment.protocol.miso}::track::new`,
+          target: `${p.deployment.protocol.musicos}::track::new`,
           typeArguments: [node.recordingShareType, node.compositionShareType],
           arguments: [tx.object(node.recordingId), targetReleaseId, tx.pure.u16(node.splitBps)],
           adminCapIndex: 0,
         });
       });
       const created = tx.moveCall({
-        target: `${p.deployment.protocol.miso}::release::new`,
+        target: `${p.deployment.protocol.musicos}::release::new`,
         arguments: [
           tx.object(p.deployment.objects.releaseRegistry),
           tx.pure.string(p.release.title),
-          tx.makeMoveVec({ type: `${p.deployment.protocol.miso}::track::Track`, elements: tracks }),
+          tx.makeMoveVec({ type: `${p.deployment.protocol.musicos}::track::Track`, elements: tracks }),
           tx.pure.u256(BigInt(p.release.nonce)),
         ],
       });
@@ -863,6 +863,21 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
         recordingAdvisoryPackageId: p.deployment.packages.recordingAdvisory,
         rating: node.advisory,
       })(tx);
+      if (node.genres) {
+        const recordingGenrePackageId = p.deployment.packages.recordingGenre;
+        if (!recordingGenrePackageId) {
+          throw new Error(
+            "publishAtomicCatalog: recording genres require deployment.packages.recordingGenre",
+          );
+        }
+        setRecordingGenres({
+          recordingId: parts.work, authority,
+          recordingShareType: node.shareType,
+          compositionShareType: node.compositionShareType,
+          recordingGenrePackageId,
+          genreIds: node.genres,
+        })(tx);
+      }
       if (node.languages?.kind === "instrumental") setRecordingInstrumental({
         recordingId: parts.work, authority,
         recordingShareType: node.shareType,
@@ -922,9 +937,7 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
       })(tx);
       if (p.release.genres) setReleaseGenres({
         releaseId: releaseObject, authority,
-        primaryGenreId: p.release.genres.primaryGenreId,
-        secondaryGenreIds: p.release.genres.secondaryGenreIds ?? [],
-        trackPrimaryGenres: p.release.genres.tracks ?? [],
+        genreIds: p.release.genres,
         releaseGenrePackageId: p.deployment.packages.releaseGenre,
       })(tx);
       if (p.release.dspLinks) setReleaseDspLinks({
@@ -1023,7 +1036,7 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
       if ("id" in node) continue;
       const parts = createdParties.get(node.ref)!;
       tx.add(party.share({
-        package: p.deployment.protocol.misoParty,
+        package: p.deployment.partyos.partyos,
         arguments: [parts.party, parts.adminCap],
       }));
       disposeNewAdminCap(tx, parts.adminCap, custody(p, node.custody, partyCapType(p)));
@@ -1152,15 +1165,15 @@ export function parseAtomicPublicationResult(
     if ("id" in node) {
       parties[node.ref] = {
         id: node.id,
-        adminCapId: derivePartyAdminCapId(node.id, p.deployment.protocol.misoParty),
+        adminCapId: derivePartyAdminCapId(node.id, p.deployment.partyos.partyos),
         created: false,
       };
     }
   }
   createdPartyNodes.forEach((node, index) => {
     const event = partyEvents[index]!;
-    const parsed = protocolContracts.party.PartyCreatedEvent.parse(event.bcs);
-    const adminCapId = derivePartyAdminCapId(parsed.party_id, p.deployment.protocol.misoParty);
+    const parsed = party.PartyCreatedEvent.parse(event.bcs);
+    const adminCapId = derivePartyAdminCapId(parsed.party_id, p.deployment.partyos.partyos);
     parties[node.ref] = {
       id: parsed.party_id,
       adminCapId,
@@ -1172,7 +1185,7 @@ export function parseAtomicPublicationResult(
   const compositions: AtomicPublicationResult["compositions"] = {};
   p.compositions.forEach((node) => {
     const id = findByShareType(createdCompositions, node.shareType, "Composition");
-    const adminCapId = deriveCompositionAdminCapId(id, p.deployment.protocol.miso);
+    const adminCapId = deriveCompositionAdminCapId(id, p.deployment.protocol.musicos);
     compositions[node.ref] = {
       id,
       adminCapId,
@@ -1185,7 +1198,7 @@ export function parseAtomicPublicationResult(
   const recordings: AtomicPublicationResult["recordings"] = {};
   p.recordings.forEach((node) => {
     const id = findByShareType(createdRecordings, node.shareType, "Recording");
-    const adminCapId = deriveRecordingAdminCapId(id, p.deployment.protocol.miso);
+    const adminCapId = deriveRecordingAdminCapId(id, p.deployment.protocol.musicos);
     recordings[node.ref] = {
       id,
       adminCapId,
@@ -1204,8 +1217,8 @@ export function parseAtomicPublicationResult(
 
   let releaseOut: AtomicPublicationResult["release"];
   if (p.release) {
-    const id = createdByExactType(result, `${p.deployment.protocol.miso}::release::Release`);
-    const adminCapId = deriveReleaseAdminCapId(id, p.deployment.protocol.miso);
+    const id = createdByExactType(result, `${p.deployment.protocol.musicos}::release::Release`);
+    const adminCapId = deriveReleaseAdminCapId(id, p.deployment.protocol.musicos);
     releaseOut = {
       id,
       adminCapId,

package/src/queries.ts

@@ -5,5 +5,5 @@
 
 // `isNotFound` is the protocol SDK's — the not-found taxonomy is a property of
 // the Sui transports, not of any one package's objects, so it is defined once in
-// `@misofm/protocol` and re-exported here for the platform readers.
-export { isNotFound } from "@misofm/protocol";
+// `@misofm/musicos` and re-exported here for the platform readers.
+export { isNotFound } from "@misofm/musicos";

package/src/read/artist.ts

@@ -41,7 +41,7 @@ export async function getArtistProfile(
   options: GetArtistOptions = {},
 ): Promise<ArtistProfile> {
   const include = new Set(options.include ?? []);
-  const { party } = client.sui.miso;
+  const { party } = client;
 
   const [profile, ctas, genreIds, links, roles, tags, entity] =
     await Promise.all([
@@ -95,7 +95,7 @@ async function resolveMembers(
   memberIds: readonly string[],
 ): Promise<PartyMember[]> {
   if (memberIds.length === 0) return [];
-  const parties = await client.sui.miso.party
+  const parties = await client.party
     .getPartiesByIds([...memberIds])
     .catch(() => ({}) as Record<string, undefined>);
   return memberIds.flatMap((id) => {
@@ -110,7 +110,7 @@ export async function getPartySummaries(
   ids: readonly string[],
 ): Promise<PartySummary[]> {
   if (ids.length === 0) return [];
-  const parties = await client.sui.miso.party.getPartiesByIds([...ids]);
+  const parties = await client.party.getPartiesByIds([...ids]);
   return ids.flatMap((id) => {
     const p = parties[id];
     return p ? [{ id, name: p.name, kind: p.kind }] : [];

package/src/read/catalog.ts

@@ -44,8 +44,8 @@ import {
   type RecordingEngineSessionView,
 } from "../recording-extensions.ts";
 import { getTrackCreditsByRecordingIds } from "../catalog.ts";
-import { getReleaseById, getReleasesByIds, isNotFound } from "@misofm/protocol";
-import type { Release } from "@misofm/protocol";
+import { getReleaseById, getReleasesByIds, isNotFound } from "@misofm/musicos";
+import type { Release } from "@misofm/musicos";
 import type { MisoClient } from "./client.ts";
 import { getRecordingTitles, parseReleaseObject } from "./works.ts";
 import { int } from "./internal/scalars.ts";
@@ -398,7 +398,7 @@ export async function getReleaseDetail(
       client.protocol,
       client.graphql,
       recordingIds,
-      client.config.deployment.miso,
+      client.config.deployment.musicos,
     ),
     getRecordingMasterReferencesByIds(
       client.protocol,
@@ -455,7 +455,7 @@ async function getTrackCreditsForRecordingIds(
     client.graphql,
     recordingIds,
     {
-      misoPackageId: client.config.deployment.miso,
+      misoPackageId: client.config.deployment.musicos,
       compositionCreditsPackageId: compositionCredits,
       recordingCreditsPackageId: recordingCredits,
     },

package/src/read/client.ts

@@ -18,7 +18,9 @@
 
 import { SuiGrpcClient } from "@mysten/sui/grpc";
 import { SuiGraphQLClient } from "@mysten/sui/graphql";
-import { miso, type MisoProtocolClient } from "@misofm/protocol/client";
+import { miso, type MisoProtocolClient } from "@misofm/musicos/client";
+import { PartyosClient } from "@misofm/partyos";
+import { PartyPlatformClient } from "../party/index.ts";
 import { misoConfig, networkFrom, type MisoConfig, type MisoConfigOverrides, type Network } from "./config.ts";
 
 function definedOverrides<T extends object>(value: T): Partial<T> {
@@ -31,14 +33,14 @@ function definedOverrides<T extends object>(value: T): Partial<T> {
  * same shape from our side so the one cast in `createMisoClient` is explicit
  * rather than an `any` smeared across the codebase.
  */
-export type ProtocolClient = Parameters<typeof import("@misofm/protocol").getReleaseById>[0];
+export type ProtocolClient = Parameters<typeof import("@misofm/musicos").getReleaseById>[0];
 
 /** A GraphQL client in the shape the protocol SDK's type-discovery queries want. */
 export type ProtocolGraphQLClient = SuiGraphQLClient;
 
 export interface MisoClient {
   config: MisoConfig;
-  /** gRPC data plane, including Party at `sui.miso.party`. */
+  /** gRPC data plane (object-model core only; Party is `client.party`). */
   sui: SuiGrpcClient & { miso: MisoProtocolClient };
   /** The same client, typed for the protocol SDK's read helpers. */
   protocol: ProtocolClient;
@@ -46,6 +48,8 @@ export interface MisoClient {
   graphql: ProtocolGraphQLClient;
   /** The raw GraphQL client, for this SDK's own queries (the pruned-transaction read). */
   graphqlRaw: SuiGraphQLClient;
+  /** Party identity and profile reads/builders, bound to `config.partyos`/`config.party`. */
+  party: PartyPlatformClient;
 }
 
 export interface CreateMisoClientOptions extends MisoConfigOverrides {
@@ -76,6 +80,7 @@ export function createMisoClient(options: CreateMisoClientOptions = {}): MisoCli
   const graphqlRaw = new SuiGraphQLClient({ url: config.graphqlUrl, network: config.network });
 
   const sui = grpc.$extend(miso({ deployment: config.deployment }));
+  const party = new PartyPlatformClient(sui, new PartyosClient(sui, config.partyos), config.party);
 
   return {
     config,
@@ -83,5 +88,6 @@ export function createMisoClient(options: CreateMisoClientOptions = {}): MisoCli
     protocol: sui as unknown as ProtocolClient,
     graphql: graphqlRaw as unknown as ProtocolGraphQLClient,
     graphqlRaw,
+    party,
   };
 }

package/src/read/config.ts

@@ -11,8 +11,9 @@
 // by the platform SDK. Mainnet remains deliberately unavailable until a complete
 // deployment is bundled for it.
 
-import type { MisoDeployment } from "@misofm/protocol/deployments";
-import { getMisoPlatformDeployment, type RecordSalesDeployment } from "../deployments.ts";
+import type { MisoDeployment } from "@misofm/musicos/deployments";
+import type { PartyDeployment } from "@misofm/partyos/deployments";
+import { getMisoPlatformDeployment, type PartyExtensionsDeployment, type RecordSalesDeployment } from "../deployments.ts";
 import { walrusAggregatorUrl } from "../walrus.ts";
 
 export type Network = "testnet" | "mainnet";
@@ -58,6 +59,10 @@ export interface MisoConfig {
   /** Complete package set used by the integrated `client.miso` SDK. */
   deployment: MisoDeployment;
   protocol: ProtocolIds;
+  /** The Party object model deployment (`@misofm/partyos`). */
+  partyos: PartyDeployment;
+  /** First-party Party extension package ids. */
+  party: PartyExtensionsDeployment;
   /** Final Record/Record Shop deployment, or an explicit unavailable legacy state. */
   recordSales: RecordSalesDeployment;
   money: MoneyIds;
@@ -108,6 +113,8 @@ export function misoConfig(network: Network, overrides: MisoConfigOverrides = {}
   const config: MisoConfig = {
     network,
     deployment: platform.protocol,
+    partyos: platform.partyos,
+    party: platform.party,
     recordSales: platform.recordSales,
     protocol: {
       // Read-only legacy type discovery does not make this package an

package/src/read/index.ts

@@ -5,7 +5,7 @@
 //
 // One place that knows how to turn Sui objects into the things Miso talks about:
 // a pressing, a release, an artist, a library, a receipt. It composes
-// @misofm/protocol, owns the per-network id manifest, and returns view types that
+// @misofm/musicos, owns the per-network id manifest, and returns view types that
 // survive JSON.
 //
 // Browser- and server-compatible. The HTTP API is a thin cached transport over

package/src/read/receipts.ts

@@ -20,11 +20,11 @@
 // read walks. We show the buyer that arithmetic, in the same truncating integer
 // math the chain does.
 
-import * as listingContract from "@misofm/protocol/contracts/miso_record_shop/listing";
+import * as listingContract from "../contracts/record_shop/listing.ts";
 import {
   extractTypeParams2,
   getCompositionsByIds,
-} from "@misofm/protocol";
+} from "@misofm/musicos";
 import { normalizeStructTag, normalizeSuiAddress } from "@mysten/sui/utils";
 import { getPressingDetail } from "./catalog.ts";
 import type { MisoClient } from "./client.ts";
@@ -36,7 +36,7 @@ import { getWorkAddressesByShareTypes } from "./works.ts";
 const BPS = 10_000n;
 const U64_MAX = (1n << 64n) - 1n;
 
-/** `miso_record_shop::listing::RecordSoldEvent<Currency>`. */
+/** `record_shop::listing::RecordSoldEvent<Currency>`. */
 const RECORD_SOLD_EVENT_NAME = "listing::RecordSoldEvent";
 
 /**
@@ -378,7 +378,7 @@ async function compositionRatesByRecording(client: MisoClient, recordingIds: str
   const addresses = await getWorkAddressesByShareTypes(
     client.graphql,
     { compositions: shareTypes, recordings: [] },
-    client.config.deployment.miso,
+    client.config.deployment.musicos,
   );
   const compositionIds = Object.values(addresses.compositions).filter((id): id is string => !!id);
   const compositions = await getCompositionsByIds(client.protocol, compositionIds);

package/src/read/types.ts

@@ -294,7 +294,7 @@ export interface PartySummary {
 export interface OwnedRecord {
   /** Canonical object id — the `recordId` route param. */
   id: string;
-  /** Full on-chain type, e.g. `<miso_record>::record::Record`. */
+  /** Full on-chain type, e.g. `<record>::record::Record`. */
   type: string;
   releaseId: string;
   pressingId: string;

package/src/read/wallet.ts

@@ -18,11 +18,12 @@ import {
   getRecordingByShareType,
   getReleaseById,
   isNotFound,
-} from "@misofm/protocol";
+} from "@misofm/musicos";
+import { party as partyContracts } from "@misofm/partyos/contracts";
 import type { MisoClient } from "./client.ts";
 import { int, u64 } from "./internal/scalars.ts";
-import * as vaultContract from "@misofm/protocol/contracts/vault/vault";
-import * as recordContract from "@misofm/protocol/contracts/miso_record/record";
+import * as vaultContract from "../contracts/vault/vault.ts";
+import * as recordContract from "../contracts/record/record.ts";
 import { deriveRecordId } from "../pressing.ts";
 import { requireRecordSalesDeployment } from "../deployments.ts";
 import type {
@@ -157,7 +158,7 @@ function isCanonicalRecordType(
 
 /**
  * The records `owner` holds. Ownership is DIRECT — a record is an address-owned
- * `<miso_record>::record::Record` with no pressing/license/receipt intermediary.
+ * `<record>::record::Record` with no pressing/license/receipt intermediary.
  * The server-side type filter and exact local check deliberately exclude records
  * from any retired package namespace.
  */
@@ -220,7 +221,7 @@ export async function getOwnedRecords(client: MisoClient, owner: string): Promis
  * authoritative in a way that remembering created parties client-side is not.
  */
 export async function getOwnedParties(client: MisoClient, owner: string): Promise<OwnedParty[]> {
-  const capType = `${client.config.deployment.misoParty}::party::PartyAdminCap`;
+  const capType = `${client.config.partyos.partyos}::party::PartyAdminCap`;
 
   // One page of 50 caps is plenty for launch-scale artists; paginate if labels
   // ever start hitting the cap.
@@ -233,7 +234,7 @@ export async function getOwnedParties(client: MisoClient, owner: string): Promis
 
   const caps = objects.flatMap((obj) => {
     try {
-      const cap = networkContracts.party.PartyAdminCap.parse(obj.content);
+      const cap = partyContracts.PartyAdminCap.parse(obj.content);
       return [{ capId: obj.objectId, partyId: cap.party_id }];
     } catch {
       return [];
@@ -241,7 +242,7 @@ export async function getOwnedParties(client: MisoClient, owner: string): Promis
   });
   if (caps.length === 0) return [];
 
-  const parties = await client.sui.miso.party.getPartiesByIds(caps.map((c) => c.partyId));
+  const parties = await client.party.getPartiesByIds(caps.map((c) => c.partyId));
   return caps.flatMap(({ capId, partyId }) => {
     const p = parties[partyId];
     return p ? [{ partyId, capId, name: p.name, kind: p.kind }] : [];
@@ -267,13 +268,13 @@ export async function getPendingMemberships(
   const invitations = await Promise.all(
     individuals.map(async (member) => ({
       member,
-      groupIds: await client.sui.miso.party.getPendingMemberships(member.partyId),
+      groupIds: await client.party.getPendingMemberships(member.partyId),
     })),
   );
   const groupIds = [...new Set(invitations.flatMap(({ groupIds }) => groupIds))];
   if (groupIds.length === 0) return [];
 
-  const groups = await client.sui.miso.party.getPartiesByIds(groupIds);
+  const groups = await client.party.getPartiesByIds(groupIds);
   return invitations.flatMap(({ member, groupIds }) =>
     groupIds.flatMap((groupId): PendingMembership[] => {
       const group = groups[groupId];
@@ -321,7 +322,7 @@ async function ownedVaultedWorkCaps(client: MisoClient, owner: string) {
     releases: VaultedReleaseCap[];
   } = { compositions: [], recordings: [], releases: [] };
   const vaultPackageId = client.config.protocol.vault;
-  const misoPackageId = client.config.deployment.miso;
+  const misoPackageId = client.config.deployment.musicos;
   const capType = `${vaultPackageId}::vault::VaultAdminCap`;
   let cursor: string | null = null;
 
@@ -369,7 +370,7 @@ async function resolveVaultedReleaseCaps(
   caps: readonly VaultedReleaseCap[],
 ): Promise<{ id: string; releaseId: string }[]> {
   if (caps.length === 0) return [];
-  const releaseCapType = `${client.config.deployment.miso}::release::ReleaseAdminCap`;
+  const releaseCapType = `${client.config.deployment.musicos}::release::ReleaseAdminCap`;
   const vaultType = normalizeStructTag(
     `${client.config.protocol.vault}::vault::Vault<${releaseCapType}>`,
   );
@@ -409,7 +410,7 @@ async function resolveVaultedReleaseCaps(
  * `release_id` directly.
  */
 export async function getOwnedWorks(client: MisoClient, owner: string): Promise<OwnedWork[]> {
-  const miso = client.config.deployment.miso;
+  const miso = client.config.deployment.musicos;
 
   const [directCompCaps, directRecCaps, directRelCaps, vaulted] = await Promise.all([
     ownedGenericCaps(client, owner, `${miso}::composition::CompositionAdminCap`),
@@ -468,7 +469,7 @@ export async function getOwnedWorks(client: MisoClient, owner: string): Promise<
 
 /** Classify a direct or vaulted cap by its on-chain type, then resolve its work. */
 export async function getWorkByCap(client: MisoClient, capId: string): Promise<WorkDetail | null> {
-  const miso = client.config.deployment.miso;
+  const miso = client.config.deployment.musicos;
 
   let type: string;
   let json: Record<string, unknown> | null;
@@ -664,7 +665,7 @@ function isAddressOwner(owner: unknown, address: string): boolean {
  * stays hidden rather than being offered and then rejected on submit.
  */
 export async function ownsParty(client: MisoClient, address: string, partyId: string): Promise<Ownership> {
-  const capId = client.sui.miso.party.derivePartyAdminCapId(partyId);
+  const capId = client.party.derivePartyAdminCapId(partyId);
   const isOwner = await client.protocol.core
     .getObject({ objectId: capId })
     .then(({ object }) => isAddressOwner(object?.owner, address))

package/src/read/works.ts

@@ -12,7 +12,7 @@ import {
   type Recording,
   type Release,
   type TrackState,
-} from "@misofm/protocol";
+} from "@misofm/musicos";
 
 export interface WorkShareTypes {
   compositions: readonly string[];

package/src/recording-extensions.ts

@@ -7,15 +7,15 @@ import { bcs } from "@mysten/sui/bcs";
 import type { ClientWithCoreApi } from "@mysten/sui/client";
 import type { Transaction, TransactionArgument, TransactionObjectArgument } from "@mysten/sui/transactions";
 import { deriveDynamicFieldID, fromHex, toHex } from "@mysten/sui/utils";
-import { isNotFound } from "@misofm/protocol";
+import { isNotFound } from "@misofm/musicos";
 import type { TxThunk } from "./transactions.ts";
 import { invokeWithAdminCap, type AdminCapAuthority, type ObjectInput } from "./vault.ts";
-import * as advisory from "@misofm/protocol/contracts/recording_advisory/recording_advisory";
-import * as language from "@misofm/protocol/contracts/recording_language/recording_language";
-import * as walrusData from "@misofm/protocol/contracts/recording_master_reference/deps/ori/data";
-import * as masterReference from "@misofm/protocol/contracts/recording_master_reference/recording_master_reference";
-import * as engineSession from "@misofm/protocol/contracts/recording_engine_session/recording_engine_session";
-import * as streamingTranscode from "@misofm/protocol/contracts/recording_streaming_transcode/recording_streaming_transcode";
+import * as advisory from "./contracts/recording_advisory/recording_advisory.ts";
+import * as language from "./contracts/recording_language/recording_language.ts";
+import * as walrusData from "./contracts/recording_master_reference/deps/ori/data.ts";
+import * as masterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
+import * as engineSession from "./contracts/recording_engine_session/recording_engine_session.ts";
+import * as streamingTranscode from "./contracts/recording_streaming_transcode/recording_streaming_transcode.ts";
 import { unencryptedWalrusBlob } from "./internal.ts";
 
 export interface RecordingExtensionTarget {