@misofm/platform 0.23.0 → 0.25.0

package/src/contracts/vault/vault.ts

@@ -0,0 +1,509 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Generic capability custody and plugin authorization.
+ *
+ * `Vault<Cap>` is a permanent, deterministically addressed shell that can hold one
+ * exact capability in a Sui `Referent`. An authorized plugin receives the whole
+ * capability temporarily, paired with a hot-potato `Borrow` receipt that forces
+ * the same capability back into the same vault before the transaction can finish.
+ * Plugin authorization is represented by a typed dynamic field in the vault's
+ * `Bag`.
+ */
+
+import { MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs, type BcsType } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as borrow from './deps/sui/borrow.ts';
+import * as bag from './deps/sui/bag.ts';
+const $moduleName = '@local-pkg/vault::vault';
+export const VaultRegistry = new MoveStruct({ name: `${$moduleName}::VaultRegistry`, fields: {
+        id: bcs.Address
+    } });
+/**
+ * Custodies one capability and the typed authorization records for plugins.
+ *
+ * `Vault` intentionally lacks `store`: only this module can share it, and no
+ * production API can delete it. `cap_id` permanently binds the shell to the exact
+ * capability from which its ID was derived. An empty Vault can only be restored
+ * with that same capability object.
+ */
+export function Vault<Cap extends BcsType<any>>(...typeParameters: [
+    Cap
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Vault<${typeParameters[0].name as Cap['name']}>`, fields: {
+            id: bcs.Address,
+            cap_id: bcs.Address,
+            cap: bcs.option(borrow.Referent(typeParameters[0])),
+            authorized_plugins: bag.Bag
+        } });
+}
+export const VaultAdminCap = new MoveStruct({ name: `${$moduleName}::VaultAdminCap<phantom Cap>`, fields: {
+        id: bcs.Address,
+        vault_id: bcs.Address
+    } });
+export const VaultKey = new MoveTuple({ name: `${$moduleName}::VaultKey<phantom Cap>`, fields: [bcs.Address] });
+export const VaultAdminCapKey = new MoveTuple({ name: `${$moduleName}::VaultAdminCapKey`, fields: [bcs.bool()] });
+export const AuthorizedPluginKey = new MoveTuple({ name: `${$moduleName}::AuthorizedPluginKey<phantom Witness>`, fields: [bcs.bool()] });
+export const VaultCreatedEvent = new MoveStruct({ name: `${$moduleName}::VaultCreatedEvent<phantom Cap>`, fields: {
+        vault_id: bcs.Address,
+        cap_id: bcs.Address
+    } });
+export const PluginAuthorizedEvent = new MoveStruct({ name: `${$moduleName}::PluginAuthorizedEvent<phantom Cap, phantom Witness>`, fields: {
+        vault_id: bcs.Address
+    } });
+export const PluginRevokedEvent = new MoveStruct({ name: `${$moduleName}::PluginRevokedEvent<phantom Cap, phantom Witness>`, fields: {
+        vault_id: bcs.Address
+    } });
+export const VaultCapabilityWithdrawnEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityWithdrawnEvent<phantom Cap>`, fields: {
+        vault_id: bcs.Address
+    } });
+export const VaultCapabilityRestoredEvent = new MoveStruct({ name: `${$moduleName}::VaultCapabilityRestoredEvent<phantom Cap>`, fields: {
+        vault_id: bcs.Address
+    } });
+export interface NewArguments<Cap extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<Cap>;
+}
+export interface NewOptions<Cap extends BcsType<any>> {
+    package?: string;
+    arguments: NewArguments<Cap> | [
+        registry: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<Cap>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Custody `cap` in its canonical permanent Vault and create the canonical
+ * vault-specific administrator capability.
+ */
+export function _new<Cap extends BcsType<any>>(options: NewOptions<Cap>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["registry", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ShareArguments {
+    vault: RawTransactionArgument<string>;
+}
+export interface ShareOptions {
+    package?: string;
+    arguments: ShareArguments | [
+        vault: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Share a newly-created vault. */
+export function share(options: ShareOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'share',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface WithdrawCapArguments {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+}
+export interface WithdrawCapOptions {
+    package?: string;
+    arguments: WithdrawCapArguments | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Withdraw the exact capability while leaving its canonical Vault and
+ * VaultAdminCap intact. Every plugin must be revoked first.
+ */
+export function withdrawCap(options: WithdrawCapOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'withdraw_cap',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RestoreCapArguments<Cap extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<Cap>;
+}
+export interface RestoreCapOptions<Cap extends BcsType<any>> {
+    package?: string;
+    arguments: RestoreCapArguments<Cap> | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<Cap>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Restore the exact capability used to derive this permanent Vault. Restoring
+ * always starts from a clean plugin-authorization slate.
+ */
+export function restoreCap<Cap extends BcsType<any>>(options: RestoreCapOptions<Cap>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[0]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'restore_cap',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AuthorizePluginArguments<Witness extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+    _: RawTransactionArgument<Witness>;
+}
+export interface AuthorizePluginOptions<Witness extends BcsType<any>> {
+    package?: string;
+    arguments: AuthorizePluginArguments<Witness> | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>,
+        _: RawTransactionArgument<Witness>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Authorize the plugin identified by this witness type. */
+export function authorizePlugin<Witness extends BcsType<any>>(options: AuthorizePluginOptions<Witness>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null,
+        `${options.typeArguments[1]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap", "_"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'authorize_plugin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RevokePluginArguments {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+}
+export interface RevokePluginOptions {
+    package?: string;
+    arguments: RevokePluginArguments | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Revoke a plugin authorization without requiring cooperation from the plugin. */
+export function revokePlugin(options: RevokePluginOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'revoke_plugin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface BorrowAsPluginArguments<Witness extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    _: RawTransactionArgument<Witness>;
+}
+export interface BorrowAsPluginOptions<Witness extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowAsPluginArguments<Witness> | [
+        self: RawTransactionArgument<string>,
+        _: RawTransactionArgument<Witness>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Temporarily lend the full custodied capability to an authorized plugin.
+ *
+ * `Borrow` has no abilities, so the exact capability must be returned through
+ * `put_back` in this transaction.
+ */
+export function borrowAsPlugin<Witness extends BcsType<any>>(options: BorrowAsPluginOptions<Witness>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[1]}`
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "_"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'borrow_as_plugin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface BorrowAsAdminArguments {
+    self: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+}
+export interface BorrowAsAdminOptions {
+    package?: string;
+    arguments: BorrowAsAdminArguments | [
+        self: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Temporarily lend the full custodied capability to the vault administrator. */
+export function borrowAsAdmin(options: BorrowAsAdminOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "adminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'borrow_as_admin',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PutBackArguments<Cap extends BcsType<any>> {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<Cap>;
+    receipt: TransactionArgument;
+}
+export interface PutBackOptions<Cap extends BcsType<any>> {
+    package?: string;
+    arguments: PutBackArguments<Cap> | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<Cap>,
+        receipt: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Return the exact capability borrowed from this vault.
+ *
+ * No additional authorization is required: `Borrow` proves the originating
+ * referent and capability object ID, and blocking return would harm liveness.
+ */
+export function putBack<Cap extends BcsType<any>>(options: PutBackOptions<Cap>) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "receipt"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'put_back',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface DerivedAddressArguments {
+    registry: RawTransactionArgument<string>;
+    capId: RawTransactionArgument<string>;
+}
+export interface DerivedAddressOptions {
+    package?: string;
+    arguments: DerivedAddressArguments | [
+        registry: RawTransactionArgument<string>,
+        capId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Derive the canonical Vault address for `cap_id` in this registry. */
+export function derivedAddress(options: DerivedAddressOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["registry", "capId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'derived_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface CapIdArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CapIdOptions {
+    package?: string;
+    arguments: CapIdArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** The exact capability object permanently assigned to this Vault. */
+export function capId(options: CapIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'cap_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsActiveArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IsActiveOptions {
+    package?: string;
+    arguments: IsActiveArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Whether this Vault is active.
+ *
+ * An active Vault has an outer Referent. It remains active during a
+ * transaction-local lease even though that Referent is temporarily empty.
+ */
+export function isActive(options: IsActiveOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'is_active',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AuthorizedPluginsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface AuthorizedPluginsOptions {
+    package?: string;
+    arguments: AuthorizedPluginsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** The immutable Bag containing typed plugin-authorization records. */
+export function authorizedPlugins(options: AuthorizedPluginsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'authorized_plugins',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsPluginAuthorizedArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface IsPluginAuthorizedOptions {
+    package?: string;
+    arguments: IsPluginAuthorizedArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns whether this witness type has an authorization record. */
+export function isPluginAuthorized(options: IsPluginAuthorizedOptions) {
+    const packageAddress = options.package ?? '@local-pkg/vault';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'vault',
+        function: 'is_plugin_authorized',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts.ts

@@ -4,51 +4,98 @@
 // Barrel for the codegen-generated, ABI-bound bindings (BCS structs + type-safe
 // Move calls). Re-exported from the package root as the `contracts` namespace.
 //
-// PLATFORM + EXTENSION packages. The protocol core (`miso`: Composition,
-// Recording, Release, Track) generates into `@misofm/protocol` and is
-// re-exported from ITS `contracts` namespace — import it from there rather than
-// mirroring it here.
+// The object-model core (`musicos`: Composition, Recording, Release, Track)
+// generates into `@misofm/musicos` and is re-exported from ITS `contracts`
+// namespace — import it from there rather than mirroring it here. Everything
+// else Miso offers on top of the object model — extensions, generic royalty
+// primitives, the Party extensions (the Party core is `@misofm/partyos`),
+// Record/Record Shop — lives in this barrel.
+
+// Every package here is generated from the current first-party Move source. The
+// generated default `@local-pkg/*` identities are source labels only: callers
+// must inject exact published addresses through a complete deployment before
+// building a transaction. Do not use a historic package ID as a substitute for
+// a fresh deployment.
+
+type PublicModule<M extends object, K extends readonly (keyof M)[]> = Omit<M, K[number]>;
+function withoutUnsafeCalls<M extends object, K extends readonly (keyof M)[]>(
+  module: M,
+  keys: K,
+): PublicModule<M, K> {
+  return Object.fromEntries(Object.entries(module).filter(([key]) => !keys.includes(key as keyof M))) as PublicModule<M, K>;
+}
+
+import * as rawCompositionCredits from "./contracts/composition_credits/composition_credits.ts";
+import * as rawRecordingCredits from "./contracts/recording_credits/recording_credits.ts";
+import * as rawRecordingMasterReference from "./contracts/recording_master_reference/recording_master_reference.ts";
+import * as rawReleaseCoverArt from "./contracts/release_cover_art/release_cover_art.ts";
+import * as rawReleaseCredits from "./contracts/release_credits/release_credits.ts";
+import * as rawReleaseDescription from "./contracts/release_description/release_description.ts";
+import * as rawRoyaltyPool from "./contracts/royalty_pool/pool.ts";
+import * as rawRoyaltyStake from "./contracts/royalty_pool/stake.ts";
+import * as rawRoutedStake from "./contracts/routed_stake/routed_stake.ts";
+import * as rawPartyProfile from "./contracts/party_profile/party_profile.ts";
 
 // Record identity/issuance and Record Shop primary-sale mechanics. The
 // package-restricted witness constructor is intentionally not exported here.
-export * as record from "@misofm/protocol/contracts/miso_record/record";
-export * as pressing from "@misofm/protocol/contracts/miso_record/pressing";
-export * as listing from "@misofm/protocol/contracts/miso_record_shop/listing";
-
-// Generic royalty-pool primitive, raw-cap Actions, and the three safe crank plugins.
-export * as royaltyPool from "@misofm/protocol/contracts/royalty_pool/pool";
-export * as royaltyPoolStake from "@misofm/protocol/contracts/royalty_pool/stake";
-export * as vault from "@misofm/protocol/contracts/vault/vault";
-export * as compositionRoyaltyPool from "@misofm/protocol/contracts/composition_royalty_pool/composition_royalty_pool";
-export * as recordingRoyaltyPool from "@misofm/protocol/contracts/recording_royalty_pool/recording_royalty_pool";
-export * as partyWallet from "@misofm/protocol/contracts/party_wallet/party_wallet";
-export * as routedStake from "@misofm/protocol/contracts/routed_stake/routed_stake";
-export * as compositionRoutedStake from "@misofm/protocol/contracts/composition_routed_stake/composition_routed_stake";
-export * as compositionRoyaltyPoolPlugin from "@misofm/protocol/contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin";
-export * as recordingRoyaltyPoolPlugin from "@misofm/protocol/contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin";
-export * as releaseRevenueDistributorPlugin from "@misofm/protocol/contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin";
+export * as record from "./contracts/record/record.ts";
+export * as pressing from "./contracts/record/pressing.ts";
+export * as listing from "./contracts/record_shop/listing.ts";
+
+// Generic royalty-pool primitive, raw-cap Actions, and the three safe crank
+// plugins (BCS codecs remain available; PTB-inaccessible references do not).
+export const royaltyPool = withoutUnsafeCalls(rawRoyaltyPool, ["balance", "_new"] as const);
+export const royaltyPoolStake = withoutUnsafeCalls(rawRoyaltyStake, ["balance", "getRegistration"] as const);
+/** The name the retired `@misofm/protocol` barrel used for {@link royaltyPoolStake}. */
+export { royaltyPoolStake as royaltyStake };
+export * as vault from "./contracts/vault/vault.ts";
+export * as compositionRoyaltyPool from "./contracts/composition_royalty_pool/composition_royalty_pool.ts";
+export * as recordingRoyaltyPool from "./contracts/recording_royalty_pool/recording_royalty_pool.ts";
+export * as partyWallet from "./contracts/party_wallet/party_wallet.ts";
+export const routedStake = withoutUnsafeCalls(
+  rawRoutedStake,
+  ["stake", "_new", "register", "unregister", "unstake", "restake"] as const,
+);
+export * as compositionRoutedStake from "./contracts/composition_routed_stake/composition_routed_stake.ts";
+export * as compositionRoyaltyPoolPlugin from "./contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.ts";
+export * as recordingRoyaltyPoolPlugin from "./contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin.ts";
+export * as releaseRevenueDistributorPlugin from "./contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin.ts";
 
 // Cover art (the CoverArt value type + the release attachment extension).
-export * as coverArt from "@misofm/protocol/contracts/cover_art/cover_art";
-export * as releaseCoverArt from "@misofm/protocol/contracts/release_cover_art/release_cover_art";
+export * as coverArt from "./contracts/cover_art/cover_art.ts";
+export const releaseCoverArt = withoutUnsafeCalls(rawReleaseCoverArt, ["cover"] as const);
 
 // Release presentation, discovery, buyer-content, and runtime economics.
-export * as genre from "@misofm/protocol/contracts/genre/genre";
-export * as releaseDescription from "@misofm/protocol/contracts/release_description/release_description";
-export * as releaseDspLink from "@misofm/protocol/contracts/release_dsp_link/release_dsp_link";
-export * as releaseGenre from "@misofm/protocol/contracts/release_genre/release_genre";
-export * as releaseKind from "@misofm/protocol/contracts/release_kind/release_kind";
-export * as releaseRevenueDistributor from "@misofm/protocol/contracts/release_revenue_distributor/release_revenue_distributor";
-export * as recordingAdvisory from "@misofm/protocol/contracts/recording_advisory/recording_advisory";
-export * as recordingLanguage from "@misofm/protocol/contracts/recording_language/recording_language";
-export * as recordingMasterReference from "@misofm/protocol/contracts/recording_master_reference/recording_master_reference";
-export * as recordingEngineSession from "@misofm/protocol/contracts/recording_engine_session/recording_engine_session";
-export * as recordingStreamingTranscode from "@misofm/protocol/contracts/recording_streaming_transcode/recording_streaming_transcode";
+export * as genre from "./contracts/genre/genre.ts";
+export const releaseDescription = withoutUnsafeCalls(rawReleaseDescription, ["description"] as const);
+export * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
+export * as releaseGenre from "./contracts/release_genre/release_genre.ts";
+export * as releaseKind from "./contracts/release_kind/release_kind.ts";
+export * as releaseRevenueDistributor from "./contracts/release_revenue_distributor/release_revenue_distributor.ts";
+export * as recordingAdvisory from "./contracts/recording_advisory/recording_advisory.ts";
+export * as recordingGenre from "./contracts/recording_genre/recording_genre.ts";
+export * as recordingLanguage from "./contracts/recording_language/recording_language.ts";
+export const recordingMasterReference = withoutUnsafeCalls(rawRecordingMasterReference, ["masterReference"] as const);
+export * as recordingEngineSession from "./contracts/recording_engine_session/recording_engine_session.ts";
+export * as recordingStreamingTranscode from "./contracts/recording_streaming_transcode/recording_streaming_transcode.ts";
 
 // Credits extensions (per-work credit stores + their role vocabularies).
-export * as compositionCredits from "@misofm/protocol/contracts/composition_credits/composition_credits";
-export * as compositionPartyRole from "@misofm/protocol/contracts/composition_credits/composition_party_role";
-export * as recordingCredits from "@misofm/protocol/contracts/recording_credits/recording_credits";
-export * as recordingPartyRole from "@misofm/protocol/contracts/recording_credits/recording_party_role";
-export * as releaseCredits from "@misofm/protocol/contracts/release_credits/release_credits";
-export * as releasePartyRole from "@misofm/protocol/contracts/release_credits/release_party_role";
+export const compositionCredits = withoutUnsafeCalls(rawCompositionCredits, ["credits"] as const);
+export * as compositionPartyRole from "./contracts/composition_credits/composition_party_role.ts";
+export const recordingCredits = withoutUnsafeCalls(rawRecordingCredits, ["credits", "primaryArtistIds", "featuredArtistIds"] as const);
+export * as recordingPartyRole from "./contracts/recording_credits/recording_party_role.ts";
+export const releaseCredits = withoutUnsafeCalls(rawReleaseCredits, ["credits"] as const);
+export * as releasePartyRole from "./contracts/release_credits/release_party_role.ts";
+
+// Party extensions. The Party core (`party`) is owned by `@misofm/partyos` —
+// import it from `@misofm/partyos/contracts` instead of mirroring it here.
+export * as partyCta from "./contracts/party_cta/party_cta.ts";
+export * as partyGenre from "./contracts/party_genre/party_genre.ts";
+export * as partyMedia from "./contracts/party_media/party_media.ts";
+export * as partyMusic from "./contracts/party_music/party_music.ts";
+export * as partyPlatformLink from "./contracts/party_platform_link/party_platform_link.ts";
+export * as partyProLink from "./contracts/party_pro_link/party_pro_link.ts";
+export const partyProfile = withoutUnsafeCalls(rawPartyProfile, ["profile"] as const);
+export * as partyRoles from "./contracts/party_roles/party_roles.ts";
+export * as partySocial from "./contracts/party_social/party_social.ts";
+export * as partyTags from "./contracts/party_tags/party_tags.ts";

package/src/cover.ts

@@ -21,8 +21,8 @@ import type { Transaction, TransactionObjectArgument } from "@mysten/sui/transac
 import type { TxThunk } from "./transactions.ts";
 import { asU64, directAdminCap, invokeWithAdminCap, type AdminCapAuthority, type ObjectInput, type U64Input } from "./vault.ts";
 import { OPTION_NONE, OPTION_SOME, unencryptedWalrusBlob } from "./internal.ts";
-import * as coverArt from "@misofm/protocol/contracts/cover_art/cover_art";
-import * as releaseCoverArt from "@misofm/protocol/contracts/release_cover_art/release_cover_art";
+import * as coverArt from "./contracts/cover_art/cover_art.ts";
+import * as releaseCoverArt from "./contracts/release_cover_art/release_cover_art.ts";
 
 type ReleaseAuthorityInput =
   | { readonly authority: AdminCapAuthority; readonly releaseAdminCapId?: never }