@misonetwork/sdk 0.7.0 → 0.9.0

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

@@ -0,0 +1,27 @@
+/**************************************************************
+ * 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 { MoveStruct } from '../../../utils/index.ts';
+const $moduleName = 'miso_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])
+        } });
+}

package/src/contracts/composition_credits/deps/sui/vec_map.ts

@@ -0,0 +1,33 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.ts';
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            key: typeParameters[0],
+            value: typeParameters[1]
+        } });
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+        } });
+}

package/src/contracts/miso/composition.ts

@@ -7,28 +7,28 @@
  * Represents a musical composition (song, instrumental work) in Miso. Compositions
  * are the underlying written works that recordings are based on. Each composition
  * has its own share token for ownership distribution.
- * 
+ *
  * ### Key Features:
- * 
+ *
  * - Share token initialization with fixed supply (10M tokens, 6 decimals)
  * - State machine: Initialized -> Published (embedded fields immutable after
  *   publish; dynamic fields remain extensible via `uid_mut`)
  * - Deterministic addresses via derived object pattern
- * 
+ *
  * Attribution (credits) is intentionally NOT part of core: it is display-oriented,
  * varies across platforms, and is never read by the economics. It lives in a
  * first-party credits extension attached via `uid_mut`, so core takes no
  * dependency on an identity package and core publish enforces no attribution.
- * 
+ *
  * ### Lifecycle and trust model
- * 
+ *
  * A composition is `key`-only with no `drop`: a fresh `Initialized` object cannot
  * be transferred, wrapped, publicly shared, or discarded, and its only by-value
  * consumer is `publish`. Create-and-publish is therefore atomic by construction —
  * an `Initialized` composition cannot outlive its creating transaction, and every
  * composition that exists on-chain is `Published` and shared. There is
  * deliberately no keep function; staged building must fit one transaction.
- * 
+ *
  * `uid_mut` works in any lifecycle state and is permanent root over ALL dynamic
  * fields on the object — including fields attached by other extensions. "Immutable
  * after publish" covers the embedded fields only; extension-layer data stays
@@ -37,10 +37,10 @@
  * holder as able to mutate or delete any extension data, forever.
  */
 
-import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction } from '@mysten/sui/transactions';
-import * as bps from './deps/bps/bps.js';
+import * as bps from './deps/bps/bps.ts';
 const $moduleName = '@local-pkg/miso::composition';
 /** Lifecycle state of a composition. */
 export const CompositionState = new MoveEnum({ name: `${$moduleName}::CompositionState`, fields: {
@@ -156,33 +156,6 @@ export function publish(options: PublishOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface IdArguments {
-    self: RawTransactionArgument<string>;
-}
-export interface IdOptions {
-    package?: string;
-    arguments: IdArguments | [
-        self: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string
-    ];
-}
-/** Returns the composition's object ID. */
-export function id(options: IdOptions) {
-    const packageAddress = options.package ?? '@local-pkg/miso';
-    const argumentsTypes = [
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["self"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'composition',
-        function: 'id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
 export interface TitleArguments {
     self: RawTransactionArgument<string>;
 }

package/src/contracts/miso/deps/bps/bps.ts

@@ -5,9 +5,9 @@
 
 /**
  * Basis-points arithmetic with a newtype wrapper.
- * 
+ *
  * 1 bps = 0.01%. 10_000 bps = 100%.
- * 
+ *
  * Storage-optimal: `BPS` stores a `u16` (2 bytes), the tightest width that fits
  * the `[0, 10_000]` range. Apply functions cover every standard integer width
  * (`u8` through `u256`); overflow safety on `u8`–`u128` is delegated to
@@ -17,7 +17,7 @@
  * (~1.16e73).
  */
 
-import { MoveTuple } from '../../../utils/index.js';
+import { MoveTuple } from '../../../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 const $moduleName = 'bps::bps';
 export const BPS = new MoveTuple({ name: `${$moduleName}::BPS`, fields: [bcs.u16()] });

package/src/contracts/miso/recording.ts

@@ -7,44 +7,44 @@
  * Represents an audio recording of a composition in Miso. Recordings are the audio
  * performances that are distributed and played. Each recording has its own share
  * token for ownership distribution.
- * 
+ *
  * ### Key Features:
- * 
+ *
  * - Share token initialization with fixed supply (10M tokens, 6 decimals)
  * - State machine: Initialized -> Published (embedded fields immutable after
  *   publish; dynamic fields remain extensible via `uid_mut`, e.g. masters, and
  *   credits/attribution attached by the credits extension)
  * - Deterministic addresses via derived object pattern
- * 
+ *
  * Attribution (credits, primary/featured artists) is intentionally NOT part of
  * core: it is display-oriented, varies across platforms, and is never read by the
  * economics. It lives in a first-party credits extension attached via `uid_mut`,
  * so core takes no dependency on an identity package and core publish enforces no
  * attribution.
- * 
+ *
  * A recording carries no name of its own. Its display title is its composition's
  * title, read by reference — composition titles are immutable, so an embedded copy
  * would carry no information. Anything that names this particular take — "(Live)",
  * "Radio Edit", a translated title — has more than one correct rendering, which
  * makes it presentation, and presentation lives in the metadata extension, never
  * in the frozen core. Core stores what a recording _is_; extensions describe it.
- * 
+ *
  * ### Lifecycle and trust model
- * 
+ *
  * A recording is `key`-only with no `drop`: a fresh `Initialized` object cannot be
  * transferred, wrapped, publicly shared, or discarded, and its only by-value
  * consumer is `publish`. Create-and-publish is therefore atomic by construction —
  * an `Initialized` recording cannot outlive its creating transaction, and every
  * recording that exists on-chain is `Published` and shared. There is deliberately
  * no keep function; staged building must fit one transaction.
- * 
+ *
  * `uid_mut` works in any lifecycle state and is permanent root over ALL dynamic
  * fields on the object — including fields attached by other extensions. "Immutable
  * after publish" covers the embedded fields only; extension-layer data stays
  * admin-mutable in perpetuity. This is the designed extension surface, and it is
  * the one trust assumption that never expires: integrators should model the cap
  * holder as able to mutate or delete any extension data, forever.
- * 
+ *
  * The recording carries its parent composition's identity two ways. The
  * `CompositionShare` phantom type parameter is the durable identity (a share
  * currency is published independently of miso and survives a fresh republish,
@@ -54,7 +54,7 @@
  * on-chain consumers holding only `&Recording` — or a bare `Track` — could not
  * otherwise reach the composition at all. Both are set at creation and immutable,
  * so they cannot diverge.
- * 
+ *
  * A recording is its own freshly-created object (`object::new`), not a derived
  * child of its composition: `recording::new` takes a read-only `&Composition`
  * (only to read its royalty rate and id), so publishing recordings under a
@@ -62,7 +62,7 @@
  * collides on a per-composition index.
  */
 
-import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction } from '@mysten/sui/transactions';
 const $moduleName = '@local-pkg/miso::recording';
@@ -240,34 +240,6 @@ export function compositionId(options: CompositionIdOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface IdArguments {
-    self: RawTransactionArgument<string>;
-}
-export interface IdOptions {
-    package?: string;
-    arguments: IdArguments | [
-        self: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string,
-        string
-    ];
-}
-/** Returns the recording's object ID. */
-export function id(options: IdOptions) {
-    const packageAddress = options.package ?? '@local-pkg/miso';
-    const argumentsTypes = [
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["self"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'recording',
-        function: 'id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
 export interface UidArguments {
     self: RawTransactionArgument<string>;
 }

package/src/contracts/miso/release.ts

@@ -7,7 +7,7 @@
  * Represents a music release in Miso. A release is an ordered tracklist with
  * per-track revenue distribution configuration. Cover art lives in the `cover_art`
  * extension, not in core.
- * 
+ *
  * The tracklist is deliberately FLAT — a `vector<Track>` with no disc structure.
  * Grouping a sequence into discs, vinyl sides, acts, or movements is a property of
  * a distribution medium, not of the release: it has more than one correct
@@ -15,19 +15,19 @@
  * extension. A consequence worth stating: the stored tracklist and the digest
  * pre-image have the same shape, so what signers consented to is exactly what is
  * stored — nothing structural is chosen after consent except the title.
- * 
+ *
  * ### Key Features:
- * 
+ *
  * - Ordered flat tracklist (grouping is presentation, in the metadata extension)
  * - Configurable per-track revenue splits
  * - State machine: Initialized -> Published
- * 
+ *
  * Attribution (credits, primary/featured artists) is intentionally NOT part of
  * core: it is display-oriented, varies across platforms, and is never read by the
  * economics. It lives in a first-party credits extension attached via `uid_mut`,
  * so core takes no dependency on an identity package and core publish enforces no
  * attribution.
- * 
+ *
  * The same rule governs naming. Core stores what a thing _is_ — identity and
  * everything the economics read; extensions describe it. The release's `title` is
  * the one embedded name: it is constitutive (naming the package is part of
@@ -35,9 +35,9 @@
  * naming ("Deluxe Edition"), disc titles, localized titles, and DSP-shaped slots
  * all have more than one correct rendering — presentation — and live in the
  * metadata extension.
- * 
+ *
  * ### Consent scope
- * 
+ *
  * The release digest — and therefore the derived release id every `Track` commits
  * to at creation — binds the economics and membership of the release: the ordered
  * list of `(recording, split)` pairs and the creator's nonce. It deliberately
@@ -46,17 +46,18 @@
  * chosen by the release creator, before or after tracks are created, and are
  * trusted and publicly attributable rather than cryptographically committed. See
  * `track::new` for the signer-side statement of this boundary.
- * 
- * The derived id commits to a `(parent, digest)` pair, not the digest alone — so
- * targeting an id also consents to that namespace's liveness. If the parent object
- * is deleted, or its `&mut UID` becomes permanently unreachable, the release can
- * never exist and every track or offer targeting it is stranded — the same
- * blast-radius class as a release that simply never publishes. A coordinator meant
- * to serve as the default parent namespace should therefore be shared and
- * undeletable.
- * 
+ *
+ * The derived id commits to the canonical registry's UID and the digest, not the
+ * digest alone — so targeting an id also consents to that namespace's liveness. If
+ * that parent were deleted, or its `&mut UID` became permanently unreachable, the
+ * release could never exist and every track or offer targeting it would be
+ * stranded — the same blast-radius class as a release that simply never publishes.
+ * `ReleaseRegistry` is therefore created and shared exactly once at package
+ * initialization, and exposes neither a constructor, deletion path, nor mutable
+ * UID accessor.
+ *
  * ### Lifecycle and trust model
- * 
+ *
  * A release is `key`-only with no `drop`: a fresh `Initialized` object cannot be
  * transferred, wrapped, publicly shared, or discarded, and its only by-value
  * consumer is `publish`. Create-and-publish is therefore atomic by construction —
@@ -64,7 +65,7 @@
  * release that exists on-chain is `Published` and shared. There is deliberately no
  * keep function; assembling tracks, discs, and the release must fit one
  * transaction.
- * 
+ *
  * `uid_mut` works in any lifecycle state and is permanent root over ALL dynamic
  * fields on the object — including fields attached by other extensions. "Immutable
  * after publish" covers the embedded fields only; extension-layer data stays
@@ -73,10 +74,10 @@
  * holder as able to mutate or delete any extension data, forever.
  */
 
-import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
-import * as track from './track.js';
+import * as track from './track.ts';
 const $moduleName = '@local-pkg/miso::release';
 /** Lifecycle state of a release. */
 export const ReleaseState = new MoveEnum({ name: `${$moduleName}::ReleaseState`, fields: {
@@ -98,6 +99,9 @@ export const Release = new MoveStruct({ name: `${$moduleName}::Release`, fields:
          */
         tracks: bcs.vector(track.Track)
     } });
+export const ReleaseRegistry = new MoveStruct({ name: `${$moduleName}::ReleaseRegistry`, fields: {
+        id: bcs.Address
+    } });
 export const ReleaseKey = new MoveTuple({ name: `${$moduleName}::ReleaseKey`, fields: [bcs.vector(bcs.u8())] });
 export const ReleaseAdminCap = new MoveStruct({ name: `${$moduleName}::ReleaseAdminCap`, fields: {
         /** Unique identifier for this capability. */
@@ -109,37 +113,41 @@ export const ReleaseAdminCapKey = new MoveTuple({ name: `${$moduleName}::Release
 export const ReleasePublishedEvent = new MoveStruct({ name: `${$moduleName}::ReleasePublishedEvent`, fields: {
         release_id: bcs.Address
     } });
+export const ReleaseRegistryCreatedEvent = new MoveStruct({ name: `${$moduleName}::ReleaseRegistryCreatedEvent`, fields: {
+        registry_id: bcs.Address,
+        created_by: bcs.Address
+    } });
 export interface NewArguments {
+    self: RawTransactionArgument<string>;
     title: RawTransactionArgument<string>;
     tracks: TransactionArgument;
     nonce: RawTransactionArgument<number | bigint>;
-    parent: RawTransactionArgument<string>;
 }
 export interface NewOptions {
     package?: string;
     arguments: NewArguments | [
+        self: RawTransactionArgument<string>,
         title: RawTransactionArgument<string>,
         tracks: TransactionArgument,
-        nonce: RawTransactionArgument<number | bigint>,
-        parent: RawTransactionArgument<string>
+        nonce: RawTransactionArgument<number | bigint>
     ];
 }
 /**
- * Creates a new release with the given configuration. Claims the release's UID as
- * a derived child of `parent`, keyed by the release digest (see the module doc's
- * "Consent scope" section) — so contention is per-parent, and which object serves
- * as parent is entirely the caller's choice. Returns the release and admin
- * capability.
+ * Assembles a release under the canonical registry namespace. This is
+ * permissionless: consent is carried by the supplied tracks, each of which was
+ * created for the exact derived release id. Returns the release and admin
+ * capability by value so the caller can compose `publish` and custody in the same
+ * PTB.
  */
 export function _new(options: NewOptions) {
     const packageAddress = options.package ?? '@local-pkg/miso';
     const argumentsTypes = [
+        null,
         '0x1::string::String',
         'vector<null>',
-        'u256',
-        '0x2::object::ID'
+        'u256'
     ] satisfies (string | null)[];
-    const parameterNames = ["title", "tracks", "nonce", "parent"];
+    const parameterNames = ["self", "title", "tracks", "nonce"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'release',
@@ -147,121 +155,126 @@ export function _new(options: NewOptions) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
-export interface PublishArguments {
+export interface DeriveTargetReleaseIdArguments {
     self: RawTransactionArgument<string>;
-    cap: RawTransactionArgument<string>;
+    recordingIds: RawTransactionArgument<Array<string>>;
+    trackSplitValues: RawTransactionArgument<Array<number | bigint>>;
+    nonce: RawTransactionArgument<number | bigint>;
 }
-export interface PublishOptions {
+export interface DeriveTargetReleaseIdOptions {
     package?: string;
-    arguments: PublishArguments | [
+    arguments: DeriveTargetReleaseIdArguments | [
         self: RawTransactionArgument<string>,
-        cap: RawTransactionArgument<string>
+        recordingIds: RawTransactionArgument<Array<string>>,
+        trackSplitValues: RawTransactionArgument<Array<number | bigint>>,
+        nonce: RawTransactionArgument<number | bigint>
     ];
 }
 /**
- * Publishes the release, making it immutable. Track splits must be set and sum to
- * 100% before publishing. Required State: Initialized
- *
- * Note: core enforces no attribution requirement — credits live in the credits
- * extension and may be attached before or after publish via `uid_mut`.
+ * Derives the release id that `new` would claim under this registry, without
+ * creating a release. This immutable shared-object access remains parallelizable
+ * for clients preparing tracks.
  */
-export function publish(options: PublishOptions) {
+export function deriveTargetReleaseId(options: DeriveTargetReleaseIdOptions) {
     const packageAddress = options.package ?? '@local-pkg/miso';
     const argumentsTypes = [
         null,
-        null,
-        '0x2::clock::Clock'
+        'vector<0x2::object::ID>',
+        'vector<u64>',
+        'u256'
     ] satisfies (string | null)[];
-    const parameterNames = ["self", "cap"];
+    const parameterNames = ["self", "recordingIds", "trackSplitValues", "nonce"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'release',
-        function: 'publish',
+        function: 'derive_target_release_id',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
-export interface AuthorizeArguments {
+export interface ReleaseRegistryIdArguments {
     self: RawTransactionArgument<string>;
-    cap: RawTransactionArgument<string>;
 }
-export interface AuthorizeOptions {
+export interface ReleaseRegistryIdOptions {
     package?: string;
-    arguments: AuthorizeArguments | [
-        self: RawTransactionArgument<string>,
-        cap: RawTransactionArgument<string>
+    arguments: ReleaseRegistryIdArguments | [
+        self: RawTransactionArgument<string>
     ];
 }
-/** Verifies that the admin capability matches this release. */
-export function authorize(options: AuthorizeOptions) {
+/**
+ * Returns the canonical registry's object ID, which is the derivation parent
+ * committed to by `new` and `derive_target_release_id`. Exported as the
+ * `ReleaseRegistry.id()` method to avoid colliding with the existing
+ * `release::id(&Release)` ABI function.
+ */
+export function releaseRegistryId(options: ReleaseRegistryIdOptions) {
     const packageAddress = options.package ?? '@local-pkg/miso';
     const argumentsTypes = [
-        null,
         null
     ] satisfies (string | null)[];
-    const parameterNames = ["self", "cap"];
+    const parameterNames = ["self"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'release',
-        function: 'authorize',
+        function: 'release_registry_id',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
-export interface DeriveTargetReleaseIdArguments {
-    recordingIds: RawTransactionArgument<Array<string>>;
-    trackSplitValues: RawTransactionArgument<Array<number | bigint>>;
-    nonce: RawTransactionArgument<number | bigint>;
-    parent: RawTransactionArgument<string>;
+export interface PublishArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
 }
-export interface DeriveTargetReleaseIdOptions {
+export interface PublishOptions {
     package?: string;
-    arguments: DeriveTargetReleaseIdArguments | [
-        recordingIds: RawTransactionArgument<Array<string>>,
-        trackSplitValues: RawTransactionArgument<Array<number | bigint>>,
-        nonce: RawTransactionArgument<number | bigint>,
-        parent: RawTransactionArgument<string>
+    arguments: PublishArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
     ];
 }
 /**
- * Derives the target release ID that `new()` would produce for the given inputs
- * and parent, without creating the object. This is the on-chain equivalent of the
- * client-side `deriveReleaseId()` function.
+ * Publishes the release, making it immutable. Track splits must be set and sum to
+ * 100% before publishing. Required State: Initialized
+ *
+ * Note: core enforces no attribution requirement — credits live in the credits
+ * extension and may be attached before or after publish via `uid_mut`.
  */
-export function deriveTargetReleaseId(options: DeriveTargetReleaseIdOptions) {
+export function publish(options: PublishOptions) {
     const packageAddress = options.package ?? '@local-pkg/miso';
     const argumentsTypes = [
-        'vector<0x2::object::ID>',
-        'vector<u64>',
-        'u256',
-        '0x2::object::ID'
+        null,
+        null,
+        '0x2::clock::Clock'
     ] satisfies (string | null)[];
-    const parameterNames = ["recordingIds", "trackSplitValues", "nonce", "parent"];
+    const parameterNames = ["self", "cap"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'release',
-        function: 'derive_target_release_id',
+        function: 'publish',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
-export interface IdArguments {
+export interface AuthorizeArguments {
     self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
 }
-export interface IdOptions {
+export interface AuthorizeOptions {
     package?: string;
-    arguments: IdArguments | [
-        self: RawTransactionArgument<string>
+    arguments: AuthorizeArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
     ];
 }
-/** Returns the release's object ID. */
-export function id(options: IdOptions) {
+/** Verifies that the admin capability matches this release. */
+export function authorize(options: AuthorizeOptions) {
     const packageAddress = options.package ?? '@local-pkg/miso';
     const argumentsTypes = [
+        null,
         null
     ] satisfies (string | null)[];
-    const parameterNames = ["self"];
+    const parameterNames = ["self", "cap"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'release',
-        function: 'id',
+        function: 'authorize',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }

package/src/contracts/miso/track.ts

@@ -6,9 +6,9 @@
 /**
  * Represents a track on a release, linking a recording to its position in the
  * tracklist.
- * 
+ *
  * A `Track` is the minimal positioned (recording, revenue-share) pair:
- * 
+ *
  * - `recording_id` — the routing target for the track's revenue, and the handle
  *   through which all other metadata (title, cover art, and the
  *   recording/composition share-type identities) is reached.
@@ -20,7 +20,7 @@
  *   release-specific and not derivable from the recording.
  * - `state` — the assign-once lifecycle that carries (then sheds) the recording
  *   admin's target release commitment, made at creation; see `TrackState`.
- * 
+ *
  * `Track` is intentionally monomorphic: a `Release` holds a `vector<Track>` of
  * tracks from many different recordings/compositions, so it cannot be generic over
  * their share types. It stores no title, cover art, or share-type — those are
@@ -28,10 +28,10 @@
  * embeds exactly the facts on-chain consumers cannot reach any other way.
  */
 
-import { MoveEnum, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { MoveEnum, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
 import { bcs } from '@mysten/sui/bcs';
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
-import * as bps from './deps/bps/bps.js';
+import * as bps from './deps/bps/bps.ts';
 const $moduleName = '@local-pkg/miso::track';
 /**
  * Lifecycle state of a track within a release. A track is born `Unassigned`,