@misofm/platform 0.24.0 → 0.26.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

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Shared read plumbing for the platform reads.
-
-// `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";
+//
+// Not-found is a typed `ObjectNotFoundError` (see `@misofm/effect/errors`),
+// matched with `Effect.catchTag("ObjectNotFoundError", ...)` — there is no
+// `isNotFound` predicate to re-export anymore.
+export {};

package/src/read/artist.ts

@@ -10,8 +10,12 @@
 //
 // `roles` and `tags` are opt-in via `include`.
 
+import { Effect, Option } from "effect";
+import { getPartiesByIds, getPartyById } from "@misofm/partyos";
+import type { BcsDecodeError, ObjectNotFoundError, ObjectTypeMismatchError, SuiClient, SuiRpcError } from "@misofm/effect";
+import { getCtas, getGenres, getLinks, getProfile, getRoles, getTags } from "../party/queries.ts";
 import { resolveGenreNames } from "./genres.ts";
-import type { MisoClient } from "./client.ts";
+import type { MisoConfig } from "./config.ts";
 import type {
   ArtistProfile,
   PartyMember,
@@ -31,39 +35,40 @@ export function partyAvatarUrl(apiBaseUrl: string, partyId: string): string {
 }
 
 /**
- * An artist page, fully resolved. Throws only if the PARTY itself can't be read —
+ * An artist page, fully resolved. Fails only if the PARTY itself can't be read —
  * every extension is optional by design (a party with no profile set is a new
  * party, not a broken one), so each decoration read falls back to its empty value.
  */
-export async function getArtistProfile(
-  client: MisoClient,
+export const getArtistProfile = Effect.fn("getArtistProfile")(function* (
   partyId: string,
+  config: MisoConfig,
   options: GetArtistOptions = {},
-): Promise<ArtistProfile> {
+): Effect.fn.Return<
+  ArtistProfile,
+  ObjectNotFoundError | ObjectTypeMismatchError | BcsDecodeError | SuiRpcError,
+  SuiClient
+> {
   const include = new Set(options.include ?? []);
-  const { party } = client.sui.miso;
+  const party = config.party;
 
-  const [profile, ctas, genreIds, links, roles, tags, entity] =
-    await Promise.all([
-      party.getProfile(partyId).catch(() => null),
-      party.getCtas(partyId).catch(() => []),
-      party.getGenres(partyId).catch(() => [] as string[]),
-      party.getLinks(partyId).catch(() => []),
-      include.has("roles")
-        ? party.getRoles(partyId).catch(() => [] as string[])
-        : Promise.resolve(undefined),
-      include.has("tags")
-        ? party.getTags(partyId).catch(() => [] as string[])
-        : Promise.resolve(undefined),
-      party.getPartyById(partyId),
-    ]);
+  const [profileOpt, ctas, genreIds, links, roles, tags, entity] = yield* Effect.all([
+    getProfile(partyId, party.partyProfile).pipe(Effect.catch(() => Effect.succeed(Option.none()))),
+    getCtas(partyId, party.partyCta).pipe(Effect.catch(() => Effect.succeed([] as { label: string; url: string }[]))),
+    getGenres(partyId, party.partyGenre).pipe(Effect.catch(() => Effect.succeed([] as string[]))),
+    getLinks(partyId).pipe(Effect.catch(() => Effect.succeed([] as { platform: string; value: string; url: string }[]))),
+    include.has("roles")
+      ? getRoles(partyId, party.partyRoles).pipe(Effect.catch(() => Effect.succeed([] as string[])))
+      : Effect.succeed(undefined),
+    include.has("tags")
+      ? getTags(partyId, party.partyTags).pipe(Effect.catch(() => Effect.succeed([] as string[])))
+      : Effect.succeed(undefined),
+    getPartyById(partyId, config.partyos.partyos),
+  ]);
+  const profile = Option.getOrNull(profileOpt);
 
-  const [genres, members] = await Promise.all([
-    resolveGenreNames(client, genreIds),
-    resolveMembers(
-      client,
-      entity.kind === "group" ? (entity.members ?? []) : [],
-    ),
+  const [genres, members] = yield* Effect.all([
+    resolveGenreNames(genreIds),
+    resolveMembers(entity.kind === "group" ? (entity.members ?? []) : [], config),
   ]);
 
   return {
@@ -74,45 +79,45 @@ export async function getArtistProfile(
     bioShort: profile?.bioShort ?? null,
     bioLong: profile?.bioLong ?? null,
     country: profile?.country ?? null,
-    languages: profile?.languages ?? [],
+    languages: profile?.languages ? [...profile.languages] : [],
     genres,
     links: links.map((l) => ({
       platform: l.platform,
       value: l.value,
       url: l.url,
-    })),
+    })) as ArtistProfile["links"],
     ctas: ctas.map((c) => ({ label: c.label, url: c.url })),
     members,
     ...(roles !== undefined ? { roles } : {}),
     ...(tags !== undefined ? { tags } : {}),
-    avatarUrl: partyAvatarUrl(client.config.apiBaseUrl, entity.id),
+    avatarUrl: partyAvatarUrl(config.apiBaseUrl, entity.id),
   };
-}
+});
 
 /** Group members with names resolved. A member that fails to read is dropped. */
-async function resolveMembers(
-  client: MisoClient,
+const resolveMembers = Effect.fn("resolveMembers")(function* (
   memberIds: readonly string[],
-): Promise<PartyMember[]> {
+  config: MisoConfig,
+): Effect.fn.Return<PartyMember[], never, SuiClient> {
   if (memberIds.length === 0) return [];
-  const parties = await client.sui.miso.party
-    .getPartiesByIds([...memberIds])
-    .catch(() => ({}) as Record<string, undefined>);
+  const parties = yield* getPartiesByIds([...memberIds], config.partyos.partyos).pipe(
+    Effect.catch(() => Effect.succeed({} as Record<string, undefined>)),
+  );
   return memberIds.flatMap((id) => {
     const p = parties[id];
     return p ? [{ id, name: p.name }] : [];
   });
-}
+});
 
 /** Name + kind for many parties at once. Ids that don't resolve are omitted. */
-export async function getPartySummaries(
-  client: MisoClient,
+export const getPartySummaries = Effect.fn("getPartySummaries")(function* (
   ids: readonly string[],
-): Promise<PartySummary[]> {
+  config: MisoConfig,
+): Effect.fn.Return<PartySummary[], ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
   if (ids.length === 0) return [];
-  const parties = await client.sui.miso.party.getPartiesByIds([...ids]);
+  const parties = yield* getPartiesByIds([...ids], config.partyos.partyos);
   return ids.flatMap((id) => {
     const p = parties[id];
     return p ? [{ id, name: p.name, kind: p.kind }] : [];
   });
-}
+});