@misofm/platform 0.24.0 → 0.25.0

package/src/catalog.ts

@@ -3,7 +3,7 @@
 
 // Composed catalog reads.
 //
-// `@misofm/protocol` exposes one-question reads: fetch an object by id, list the
+// `@misofm/musicos` exposes one-question reads: fetch an object by id, list the
 // caps an address owns, resolve a share type to its work. Stitching several of
 // those together to answer a PRODUCT question — "show me everything this artist
 // administers" — is orchestration, and it lives here for the same reason the
@@ -19,7 +19,7 @@ import {
   getRecordingsByIds,
   getReleaseById,
   type Recording,
-} from "@misofm/protocol";
+} from "@misofm/musicos";
 import { getWorkAddressesByShareTypes } from "./read/works.ts";
 import {
   getCompositionCreditsByIds,

package/src/client.ts

@@ -38,36 +38,38 @@ import type { ParallelTransactionExecutor } from "@mysten/sui/transactions";
 import {
   miso as protocolMiso,
   type MisoProtocolClient,
-} from "@misofm/protocol/client";
-import type { PartyProtocolClient } from "@misofm/protocol/party";
+} from "@misofm/musicos/client";
+import { PartyosClient } from "@misofm/partyos";
+import { PartyPlatformClient } from "./party/index.ts";
 
-import * as recordContract from "@misofm/protocol/contracts/miso_record/record";
-import * as pressingContract from "@misofm/protocol/contracts/miso_record/pressing";
-import * as listingContract from "@misofm/protocol/contracts/miso_record_shop/listing";
-import * as genreContract from "@misofm/protocol/contracts/genre/genre";
-import * as releaseDescriptionContract from "@misofm/protocol/contracts/release_description/release_description";
-import * as releaseDspLinkContract from "@misofm/protocol/contracts/release_dsp_link/release_dsp_link";
-import * as releaseGenreContract from "@misofm/protocol/contracts/release_genre/release_genre";
-import * as releaseKindContract from "@misofm/protocol/contracts/release_kind/release_kind";
-import * as releaseRevenueDistributorContract from "@misofm/protocol/contracts/release_revenue_distributor/release_revenue_distributor";
-import * as vaultContract from "@misofm/protocol/contracts/vault/vault";
-import * as compositionRoyaltyPoolContract from "@misofm/protocol/contracts/composition_royalty_pool/composition_royalty_pool";
-import * as recordingRoyaltyPoolContract from "@misofm/protocol/contracts/recording_royalty_pool/recording_royalty_pool";
-import * as partyWalletContract from "@misofm/protocol/contracts/party_wallet/party_wallet";
-import * as compositionRoutedStakeContract from "@misofm/protocol/contracts/composition_routed_stake/composition_routed_stake";
-import * as compositionRoyaltyPoolPluginContract from "@misofm/protocol/contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin";
-import * as recordingRoyaltyPoolPluginContract from "@misofm/protocol/contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin";
-import * as releaseRevenueDistributorPluginContract from "@misofm/protocol/contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin";
-import * as routedStakeContract from "@misofm/protocol/contracts/routed_stake/routed_stake";
-import * as royaltyPoolContract from "@misofm/protocol/contracts/royalty_pool/pool";
-import * as recordingAdvisoryContract from "@misofm/protocol/contracts/recording_advisory/recording_advisory";
-import * as recordingLanguageContract from "@misofm/protocol/contracts/recording_language/recording_language";
-import * as recordingMasterReferenceContract from "@misofm/protocol/contracts/recording_master_reference/recording_master_reference";
-import * as recordingStreamingTranscodeContract from "@misofm/protocol/contracts/recording_streaming_transcode/recording_streaming_transcode";
+import * as recordContract from "./contracts/record/record.ts";
+import * as pressingContract from "./contracts/record/pressing.ts";
+import * as listingContract from "./contracts/record_shop/listing.ts";
+import * as genreContract from "./contracts/genre/genre.ts";
+import * as releaseDescriptionContract from "./contracts/release_description/release_description.ts";
+import * as releaseDspLinkContract from "./contracts/release_dsp_link/release_dsp_link.ts";
+import * as releaseGenreContract from "./contracts/release_genre/release_genre.ts";
+import * as releaseKindContract from "./contracts/release_kind/release_kind.ts";
+import * as releaseRevenueDistributorContract from "./contracts/release_revenue_distributor/release_revenue_distributor.ts";
+import * as vaultContract from "./contracts/vault/vault.ts";
+import * as compositionRoyaltyPoolContract from "./contracts/composition_royalty_pool/composition_royalty_pool.ts";
+import * as recordingRoyaltyPoolContract from "./contracts/recording_royalty_pool/recording_royalty_pool.ts";
+import * as partyWalletContract from "./contracts/party_wallet/party_wallet.ts";
+import * as compositionRoutedStakeContract from "./contracts/composition_routed_stake/composition_routed_stake.ts";
+import * as compositionRoyaltyPoolPluginContract from "./contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.ts";
+import * as recordingRoyaltyPoolPluginContract from "./contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin.ts";
+import * as releaseRevenueDistributorPluginContract from "./contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin.ts";
+import * as routedStakeContract from "./contracts/routed_stake/routed_stake.ts";
+import * as royaltyPoolContract from "./contracts/royalty_pool/pool.ts";
+import * as recordingAdvisoryContract from "./contracts/recording_advisory/recording_advisory.ts";
+import * as recordingLanguageContract from "./contracts/recording_language/recording_language.ts";
+import * as recordingMasterReferenceContract from "./contracts/recording_master_reference/recording_master_reference.ts";
+import * as recordingStreamingTranscodeContract from "./contracts/recording_streaming_transcode/recording_streaming_transcode.ts";
+import * as recordingGenreContract from "./contracts/recording_genre/recording_genre.ts";
 import * as vaultActions from "./vault.ts";
-import * as coverArtContract from "@misofm/protocol/contracts/cover_art/cover_art";
-import * as releaseCoverArtContract from "@misofm/protocol/contracts/release_cover_art/release_cover_art";
-import * as releaseCreditsContract from "@misofm/protocol/contracts/release_credits/release_credits";
+import * as coverArtContract from "./contracts/cover_art/cover_art.ts";
+import * as releaseCoverArtContract from "./contracts/release_cover_art/release_cover_art.ts";
+import * as releaseCreditsContract from "./contracts/release_credits/release_credits.ts";
 import {
   authorizeRecordShop,
   deriveListingId,
@@ -128,16 +130,24 @@ import {
 } from "./deployments.ts";
 import { immutableSnapshot } from "./internal.ts";
 import {
-  deriveGenreAddress,
   setReleaseDescription,
   setReleaseDspLinks,
-  setReleaseGenres,
   setReleaseKind,
   type SetReleaseDescriptionParams,
   type SetReleaseDspLinksParams,
-  type SetReleaseGenresParams,
   type SetReleaseKindParams,
 } from "./release-extensions.ts";
+import {
+  deriveGenreAddress,
+  setReleaseGenres,
+  setRecordingGenres,
+  clearReleaseGenres,
+  clearRecordingGenres,
+  type SetReleaseGenresParams,
+  type SetRecordingGenresParams,
+  type ClearReleaseGenresParams,
+  type ClearRecordingGenresParams,
+} from "./genre.ts";
 import {
   setRecordingStreamingTranscode,
   unsetRecordingStreamingTranscode,
@@ -275,7 +285,7 @@ export interface MisoPlatformConfig {
    * unavailable legacy state that makes every sales API fail closed. */
   recordSales?: RecordSalesDeployment;
   /**
-   * The `@misofm/protocol` protocol package (miso core). Required for the
+   * The `@misofm/musicos` protocol package (miso core). Required for the
    * publish builders (`publishComposition`, `publishRecording`,
    * `publishCompositionAndRecording`) — optional if this client only ever
    * sells pressed records.
@@ -296,6 +306,7 @@ export interface MisoPlatformConfig {
   releaseDspLinkPackageId?: string;
   recordingAdvisoryPackageId?: string;
   recordingLanguagePackageId?: string;
+  recordingGenrePackageId?: string;
   recordingMasterReferencePackageId?: string;
   recordingStreamingTranscodePackageId?: string;
   /** Structurally complete Vault/Action/plugin identity set. */
@@ -347,6 +358,18 @@ type ConfiguredReleaseGenres = DistributiveOmit<
   SetReleaseGenresParams,
   "releaseGenrePackageId"
 >;
+type ConfiguredRecordingGenres = DistributiveOmit<
+  SetRecordingGenresParams,
+  "recordingGenrePackageId"
+>;
+type ConfiguredClearReleaseGenres = DistributiveOmit<
+  ClearReleaseGenresParams,
+  "releaseGenrePackageId"
+>;
+type ConfiguredClearRecordingGenres = DistributiveOmit<
+  ClearRecordingGenresParams,
+  "recordingGenrePackageId"
+>;
 type ConfiguredReleaseDspLinks = DistributiveOmit<
   SetReleaseDspLinksParams,
   "releaseDspLinkPackageId"
@@ -382,6 +405,7 @@ export class MisoPlatformClient {
   readonly #client: ClientWithCoreApi;
   readonly #config: MisoPlatformConfig;
   readonly #protocol?: MisoProtocolClient;
+  readonly #party?: PartyPlatformClient;
   readonly #chainIdentifier?: string;
   /** Bundled/custom deployment selected for the full facade, when available. */
   readonly deployment?: MisoPlatformDeployment;
@@ -415,6 +439,16 @@ export class MisoPlatformClient {
           }).register(client)
         : undefined);
     this.deployment = deploymentSnapshot;
+    // The one place `PartyPlatformClient` is constructed: from this platform
+    // deployment's `partyos` (core) and `party` (extensions) sections, not
+    // from the object-model protocol client.
+    this.#party = deploymentSnapshot
+      ? new PartyPlatformClient(
+          client,
+          new PartyosClient(client, deploymentSnapshot.partyos),
+          deploymentSnapshot.party,
+        )
+      : undefined;
     this.#chainIdentifier =
       deploymentSnapshot?.chainIdentifier ?? configSnapshot.chainIdentifier;
   }
@@ -494,14 +528,14 @@ export class MisoPlatformClient {
   }
 
   /** Party identity and profile APIs, backed by the network SDK. */
-  get party(): PartyProtocolClient {
-    if (!this.#protocol) {
+  get party(): PartyPlatformClient {
+    if (!this.#party) {
       throw new Error(
         "misoPlatform: Party APIs require the complete platform deployment. Use miso({ deployment }).",
       );
     }
     this.#requireReady("party APIs");
-    return this.#protocol.party;
+    return this.#party;
   }
 
   #recordSales() {
@@ -751,6 +785,14 @@ export class MisoPlatformClient {
           "setReleaseGenres",
         ),
       }),
+    clearReleaseGenres: (p: ConfiguredClearReleaseGenres): TxThunk =>
+      clearReleaseGenres({
+        ...p,
+        releaseGenrePackageId: this.#requiredConfig(
+          "releaseGenrePackageId",
+          "clearReleaseGenres",
+        ),
+      }),
     setReleaseDspLinks: (p: ConfiguredReleaseDspLinks): TxThunk =>
       setReleaseDspLinks({
         ...p,
@@ -824,6 +866,22 @@ export class MisoPlatformClient {
           "unsetRecordingStreamingTranscode",
         ),
       }),
+    setRecordingGenres: (p: ConfiguredRecordingGenres): TxThunk =>
+      setRecordingGenres({
+        ...p,
+        recordingGenrePackageId: this.#requiredConfig(
+          "recordingGenrePackageId",
+          "setRecordingGenres",
+        ),
+      }),
+    clearRecordingGenres: (p: ConfiguredClearRecordingGenres): TxThunk =>
+      clearRecordingGenres({
+        ...p,
+        recordingGenrePackageId: this.#requiredConfig(
+          "recordingGenrePackageId",
+          "clearRecordingGenres",
+        ),
+      }),
   }, (operation) => this.#requireReady(operation), "tx");
 
   /**
@@ -966,14 +1024,7 @@ export class MisoPlatformClient {
         ? bindModulePackage(
             releaseGenreContract,
             this.#config.releaseGenrePackageId,
-            [
-              "setPrimaryGenre",
-              "addSecondaryGenre",
-              "removeSecondaryGenre",
-              "setTrackPrimaryGenre",
-              "unsetTrackPrimaryGenre",
-              "hasGenre",
-            ] as const,
+            ["addGenre", "removeGenre", "clearGenres"] as const,
           )
         : undefined,
       releaseKind: this.#config.releaseKindPackageId
@@ -1161,6 +1212,13 @@ export class MisoPlatformClient {
             ] as const,
           )
         : undefined,
+      recordingGenre: this.#config.recordingGenrePackageId
+        ? bindModulePackage(
+            recordingGenreContract,
+            this.#config.recordingGenrePackageId,
+            ["addGenre", "removeGenre", "clearGenres"] as const,
+          )
+        : undefined,
       coverArt: this.#config.coverArtPackageId
         ? bindModulePackage(
             coverArtContract,
@@ -1256,7 +1314,7 @@ export function miso<const Name extends string = "miso">(
         client,
         {
           recordSales: deployment.recordSales,
-          misoPackageId: deployment.protocol.miso,
+          misoPackageId: deployment.protocol.musicos,
           minatoPackageId: deployment.packages.minato,
           releaseRegistryId: deployment.objects.releaseRegistry,
           releaseKindPackageId: deployment.packages.releaseKind,
@@ -1265,6 +1323,7 @@ export function miso<const Name extends string = "miso">(
           releaseDspLinkPackageId: deployment.packages.releaseDspLink,
           recordingAdvisoryPackageId: deployment.packages.recordingAdvisory,
           recordingLanguagePackageId: deployment.packages.recordingLanguage,
+          recordingGenrePackageId: deployment.packages.recordingGenre,
           recordingMasterReferencePackageId:
             deployment.packages.recordingMasterReference,
           recordingStreamingTranscodePackageId:

package/src/contracts/composition_credits/composition_credits.ts

@@ -0,0 +1,170 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * First-party credits extension for compositions.
+ *
+ * Attribution (writing credits) is display-oriented and varies across platforms,
+ * so it lives here as a dynamic field on the composition rather than in immutable
+ * core. The data is attached under `ExtensionKey()` via the composition's
+ * cap-gated `uid_mut`, so every mutation is authorized by the composition's admin
+ * and credits survive into any lifecycle state (they may be attached before or
+ * after the composition is published).
+ *
+ * This is musicos's canonical credits standard; because it is an extension, other
+ * parties may publish their own composition-credits standard against the same
+ * `Composition`. Credits are NOT read by the economics — they are attribution.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as vec_map from './deps/sui/vec_map.ts';
+import * as credit from './deps/credit/credit.ts';
+import * as composition_party_role from './composition_party_role.ts';
+const $moduleName = '@local-pkg/composition_credits::composition_credits';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const CompositionCredits = new MoveStruct({ name: `${$moduleName}::CompositionCredits`, fields: {
+        /** Map of party IDs to their credit (display name + roles). */
+        credits: vec_map.VecMap(bcs.Address, credit.Credit(composition_party_role.CompositionPartyRole))
+    } });
+export const CreditAddedEvent = new MoveStruct({ name: `${$moduleName}::CreditAddedEvent`, fields: {
+        composition_id: bcs.Address,
+        party_id: bcs.Address,
+        credit: credit.Credit(composition_party_role.CompositionPartyRole)
+    } });
+export const CreditRemovedEvent = new MoveStruct({ name: `${$moduleName}::CreditRemovedEvent`, fields: {
+        composition_id: bcs.Address,
+        party_id: bcs.Address,
+        credit: credit.Credit(composition_party_role.CompositionPartyRole)
+    } });
+export interface AddCreditArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+    credit: TransactionArgument;
+}
+export interface AddCreditOptions {
+    package?: string;
+    arguments: AddCreditArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>,
+        credit: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Adds a credit for a party on the composition, lazily creating the credits record
+ * on first use. Each credit must have 1-5 roles, and a party may hold at most one
+ * credit. Requires the composition's admin capability.
+ */
+export function addCredit(options: AddCreditOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "party", "credit"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'add_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RemoveCreditArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    partyId: RawTransactionArgument<string>;
+}
+export interface RemoveCreditOptions {
+    package?: string;
+    arguments: RemoveCreditArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        partyId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Removes a party's credit. Requires the composition's admin capability. */
+export function removeCredit(options: RemoveCreditOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "partyId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'remove_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasCreditsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasCreditsOptions {
+    package?: string;
+    arguments: HasCreditsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Returns whether a credits record has been attached to this composition yet. */
+export function hasCredits(options: HasCreditsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'has_credits',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface CreditsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CreditsOptions {
+    package?: string;
+    arguments: CreditsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Returns the party-to-credit map. Aborts if no credits are attached. */
+export function credits(options: CreditsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_credits',
+        function: 'credits',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/composition_credits/composition_party_role.ts

@@ -0,0 +1,190 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Defines the roles that parties can hold on a composition. Compositions are the
+ * underlying musical works (melody + lyrics), and these roles represent the
+ * writing and adaptation contributions to them.
+ *
+ * ### Design
+ *
+ * `CompositionPartyRole` is a closed enum: variants can only be constructed and
+ * matched inside this module, so the `new_*_role` constructors are the external
+ * write-API and `name()` is the external read-API.
+ *
+ * - **No seniority axis.** Unlike recording roles, composition roles carry no
+ *   level — a writer either contributed in a given capacity or did not.
+ * - **`Custom` is the escape hatch.** The canonical variants cover the common
+ *   writing vocabulary; anything outside it is a `Custom(name)` whose name is
+ *   validated. Prefer a canonical variant when one fits.
+ * - **`name()` is the canonical identifier**, returned as a stable PascalCase
+ *   token (e.g. `"Songwriter"`). For `Custom`, `name()` returns the user-supplied
+ *   string.
+ *
+ * These identifiers are musicos's own canonical vocabulary; any overlap with an
+ * external standard (e.g. DDEX) is coincidental, not a reproduction of it.
+ */
+
+import { MoveEnum, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/composition_credits::composition_party_role';
+/** Represents a party's role on a composition. */
+export const CompositionPartyRole = new MoveEnum({ name: `${$moduleName}::CompositionPartyRole`, fields: {
+        /** Adapted an existing work into this composition. */
+        Adapter: null,
+        /** Arranged the musical parts of the composition. */
+        Arranger: null,
+        /** Composed the music of the composition. */
+        Composer: null,
+        /** Wrote the lyrics of the composition. */
+        Lyricist: null,
+        /** Wrote both music and lyrics of the composition. */
+        Songwriter: null,
+        /** Translated the lyrics of the composition. */
+        Translator: null,
+        /**
+         * A user-defined role not covered by a canonical variant. Carries the role name
+         * (validated). An escape hatch — prefer a canonical variant when one fits.
+         */
+        Custom: bcs.string()
+    } });
+export interface NewAdapterRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Adapter role. */
+export function newAdapterRole(options: NewAdapterRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_adapter_role',
+    });
+}
+export interface NewArrangerRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Arranger role. */
+export function newArrangerRole(options: NewArrangerRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_arranger_role',
+    });
+}
+export interface NewComposerRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Composer role. */
+export function newComposerRole(options: NewComposerRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_composer_role',
+    });
+}
+export interface NewLyricistRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Lyricist role. */
+export function newLyricistRole(options: NewLyricistRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_lyricist_role',
+    });
+}
+export interface NewSongwriterRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Songwriter role. */
+export function newSongwriterRole(options: NewSongwriterRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_songwriter_role',
+    });
+}
+export interface NewTranslatorRoleOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+/** Creates a new Translator role. */
+export function newTranslatorRole(options: NewTranslatorRoleOptions = {}) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_translator_role',
+    });
+}
+export interface NewCustomRoleArguments {
+    roleName: RawTransactionArgument<string>;
+}
+export interface NewCustomRoleOptions {
+    package?: string;
+    arguments: NewCustomRoleArguments | [
+        roleName: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Creates a new Custom role with a user-defined name. The name freezes into
+ * credits, so it is validated here. Prefer a canonical variant when one fits.
+ */
+export function newCustomRole(options: NewCustomRoleOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        '0x1::string::String'
+    ] satisfies (string | null)[];
+    const parameterNames = ["roleName"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'new_custom_role',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface NameArguments {
+    self: TransactionArgument;
+}
+export interface NameOptions {
+    package?: string;
+    arguments: NameArguments | [
+        self: TransactionArgument
+    ];
+}
+/**
+ * Returns the canonical identifier of the role as a stable PascalCase token. For
+ * `Custom`, returns the user-supplied name.
+ */
+export function name(options: NameOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_party_role',
+        function: 'name',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/composition_credits/deps/credit/credit.ts

@@ -0,0 +1,28 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Represents a party's credit on a work or activity. A credit pairs a display name
+ * with one or more roles, identifying how a party contributed to the work.
+ */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { MoveStruct } from '../../../utils/index.ts';
+const $moduleName = 'credit::credit';
+/**
+ * A credit attributing roles to a party on a work. Generic over the role type to
+ * support domain-specific roles.
+ */
+export function Credit<Role extends BcsType<any>>(...typeParameters: [
+    Role
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Credit<${typeParameters[0].name as Role['name']}>`, fields: {
+            /** Human-readable name to display for this credit. */
+            display_name: bcs.string(),
+            /** Roles assigned to the credited party. */
+            roles: bcs.vector(typeParameters[0])
+        } });
+}