@misofm/sdk 0.16.0 → 0.17.1

package/src/contracts/party_wallet/party_wallet.ts

@@ -4,22 +4,20 @@
 
 
 /**
- * Vault-authorized withdrawals from a Party's object inbox and funds accumulator.
+ * Custody-agnostic wallet actions for a Party.
  *
- * Anyone may address objects or funds to a Party ID. This plugin is the bounded
- * withdrawal door: it temporarily leases the matching `PartyAdminCap`, uses it
- * only to reach that Party's UID, and returns it to the Vault. Object withdrawals
- * transfer to the recipient selected by the Vault administrator; monetary
- * withdrawals return a composable `Balance` for the caller's PTB to consume.
+ * A Party ID is both an object ID and an address. Anyone may send transferable
+ * objects or accumulator funds to that stable address, while only the matching
+ * `PartyAdminCap` can expose the Party UID needed to withdraw them. These raw-cap
+ * actions return every withdrawn asset to the caller so direct owners, Vault
+ * administrators, and other custody systems can compose the same immutable API.
  *
- * Installation alone never makes withdrawals permissionless. Every production
- * withdrawal is a `public fun` requiring the matching `VaultAdminCap`, and no
- * endpoint returns the leased capability, its borrow receipt, or a privileged
- * reference. The Party itself stores no plugin data.
+ * This package stores no Party data and defines no plugin or transfer policy.
  */
 
 import { MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
 import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 const $moduleName = '@local-pkg/party_wallet::party_wallet';
 export const ObjectReceivedEvent = new MoveStruct({ name: `${$moduleName}::ObjectReceivedEvent`, fields: {
@@ -35,161 +33,54 @@ export const FundsRedeemedEvent = new MoveStruct({ name: `${$moduleName}::FundsR
         party_id: bcs.Address,
         amount: bcs.u64()
     } });
-export interface InstallArguments {
-    vault: RawTransactionArgument<string>;
-    vaultAdminCap: RawTransactionArgument<string>;
-}
-export interface InstallOptions {
-    package?: string;
-    arguments: InstallArguments | [
-        vault: RawTransactionArgument<string>,
-        vaultAdminCap: RawTransactionArgument<string>
-    ];
-}
-/** Authorize this package on a Party capability Vault. */
-export function install(options: InstallOptions) {
-    const packageAddress = options.package ?? '@local-pkg/party_wallet';
-    const argumentsTypes = [
-        null,
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["vault", "vaultAdminCap"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'party_wallet',
-        function: 'install',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-export interface UninstallArguments {
-    vault: RawTransactionArgument<string>;
-    vaultAdminCap: RawTransactionArgument<string>;
-}
-export interface UninstallOptions {
-    package?: string;
-    arguments: UninstallArguments | [
-        vault: RawTransactionArgument<string>,
-        vaultAdminCap: RawTransactionArgument<string>
-    ];
-}
-/** Revoke this package from a Party capability Vault. */
-export function uninstall(options: UninstallOptions) {
-    const packageAddress = options.package ?? '@local-pkg/party_wallet';
-    const argumentsTypes = [
-        null,
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["vault", "vaultAdminCap"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'party_wallet',
-        function: 'uninstall',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-export interface ReceiveObjectArguments {
-    vault: RawTransactionArgument<string>;
+export interface ReceiveArguments {
     party: RawTransactionArgument<string>;
-    vaultAdminCap: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
     objectToReceive: TransactionArgument;
-    recipient: RawTransactionArgument<string>;
-}
-export interface ReceiveObjectOptions {
-    package?: string;
-    arguments: ReceiveObjectArguments | [
-        vault: RawTransactionArgument<string>,
-        party: RawTransactionArgument<string>,
-        vaultAdminCap: RawTransactionArgument<string>,
-        objectToReceive: TransactionArgument,
-        recipient: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string
-    ];
 }
-/**
- * Receive one `key + store` object addressed to the Party and transfer it to
- * `recipient`.
- *
- * Aborts if the Vault administrator is wrong, the plugin is not installed, the
- * Vault contains another Party's cap, or the receiving ticket is invalid for the
- * supplied Party.
- */
-export function receiveObject(options: ReceiveObjectOptions) {
-    const packageAddress = options.package ?? '@local-pkg/party_wallet';
-    const argumentsTypes = [
-        null,
-        null,
-        null,
-        null,
-        'address'
-    ] satisfies (string | null)[];
-    const parameterNames = ["vault", "party", "vaultAdminCap", "objectToReceive", "recipient"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'party_wallet',
-        function: 'receive_object',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
-export interface ReceiveObjectsArguments {
-    vault: RawTransactionArgument<string>;
-    party: RawTransactionArgument<string>;
-    vaultAdminCap: RawTransactionArgument<string>;
-    objectsToReceive: TransactionArgument;
-    recipient: RawTransactionArgument<string>;
-}
-export interface ReceiveObjectsOptions {
+export interface ReceiveOptions {
     package?: string;
-    arguments: ReceiveObjectsArguments | [
-        vault: RawTransactionArgument<string>,
+    arguments: ReceiveArguments | [
         party: RawTransactionArgument<string>,
-        vaultAdminCap: RawTransactionArgument<string>,
-        objectsToReceive: TransactionArgument,
-        recipient: RawTransactionArgument<string>
+        adminCap: RawTransactionArgument<string>,
+        objectToReceive: TransactionArgument
     ];
     typeArguments: [
         string
     ];
 }
 /**
- * Receive several `key + store` objects of one type and transfer each to
- * `recipient` in input order.
+ * Receive and return one `key + store` object addressed to `party`.
  *
- * Aborts with `ENothingToReceive` if `objects_to_receive` is empty. It also aborts
- * under the authorization and receiving conditions documented by `receive_object`.
+ * Aborts if `admin_cap` belongs to another Party or the receiving ticket does not
+ * identify an object addressed to this Party.
  */
-export function receiveObjects(options: ReceiveObjectsOptions) {
+export function receive(options: ReceiveOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_wallet';
     const argumentsTypes = [
         null,
         null,
-        null,
-        'vector<null>',
-        'address'
+        null
     ] satisfies (string | null)[];
-    const parameterNames = ["vault", "party", "vaultAdminCap", "objectsToReceive", "recipient"];
+    const parameterNames = ["party", "adminCap", "objectToReceive"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'party_wallet',
-        function: 'receive_objects',
+        function: 'receive',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });
 }
-export interface ReceiveCoinsArguments {
-    vault: RawTransactionArgument<string>;
+export interface ReceiveBalanceArguments {
     party: RawTransactionArgument<string>;
-    vaultAdminCap: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
     coins: TransactionArgument;
 }
-export interface ReceiveCoinsOptions {
+export interface ReceiveBalanceOptions {
     package?: string;
-    arguments: ReceiveCoinsArguments | [
-        vault: RawTransactionArgument<string>,
+    arguments: ReceiveBalanceArguments | [
         party: RawTransactionArgument<string>,
-        vaultAdminCap: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>,
         coins: TransactionArgument
     ];
     typeArguments: [
@@ -197,42 +88,38 @@ export interface ReceiveCoinsOptions {
     ];
 }
 /**
- * Receive coin objects of one currency, merge them, and return their combined
- * Balance for the caller's PTB to consume.
+ * Receive a non-empty set of coin objects addressed to `party`, merge them, and
+ * return their combined `Balance`.
  *
- * Aborts with `ENothingToReceive` if `coins` is empty. It also aborts if the Vault
- * administrator, plugin installation, Party capability, or a receiving ticket is
- * invalid.
+ * Aborts with `ENothingToReceive` when `coins` is empty, if `admin_cap` belongs to
+ * another Party, or if any ticket is invalid for this Party.
  */
-export function receiveCoins(options: ReceiveCoinsOptions) {
+export function receiveBalance(options: ReceiveBalanceOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_wallet';
     const argumentsTypes = [
-        null,
         null,
         null,
         'vector<null>'
     ] satisfies (string | null)[];
-    const parameterNames = ["vault", "party", "vaultAdminCap", "coins"];
+    const parameterNames = ["party", "adminCap", "coins"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'party_wallet',
-        function: 'receive_coins',
+        function: 'receive_balance',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });
 }
 export interface RedeemBalanceArguments {
-    vault: RawTransactionArgument<string>;
     party: RawTransactionArgument<string>;
-    vaultAdminCap: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
     value: RawTransactionArgument<number | bigint>;
 }
 export interface RedeemBalanceOptions {
     package?: string;
     arguments: RedeemBalanceArguments | [
-        vault: RawTransactionArgument<string>,
         party: RawTransactionArgument<string>,
-        vaultAdminCap: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>,
         value: RawTransactionArgument<number | bigint>
     ];
     typeArguments: [
@@ -240,22 +127,20 @@ export interface RedeemBalanceOptions {
     ];
 }
 /**
- * Redeem `value` from the Party's accumulator and return a Balance for the
- * caller's PTB to consume.
+ * Redeem `value` from `party`'s accumulator and return the resulting balance.
  *
- * Aborts if the Vault administrator is wrong, the plugin is not installed, the
- * Vault contains another Party's cap, `value` is zero, or the accumulator cannot
- * cover the requested amount.
+ * Aborts if `admin_cap` belongs to another Party. Accumulator semantics remain in
+ * `hikida`: zero values abort with code `1`, and unavailable funds abort in the
+ * Sui accumulator implementation.
  */
 export function redeemBalance(options: RedeemBalanceOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_wallet';
     const argumentsTypes = [
-        null,
         null,
         null,
         'u64'
     ] satisfies (string | null)[];
-    const parameterNames = ["vault", "party", "vaultAdminCap", "value"];
+    const parameterNames = ["party", "adminCap", "value"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'party_wallet',
@@ -264,73 +149,6 @@ export function redeemBalance(options: RedeemBalanceOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface SweepBalanceArguments {
-    vault: RawTransactionArgument<string>;
-    party: RawTransactionArgument<string>;
-    root: RawTransactionArgument<string>;
-    vaultAdminCap: RawTransactionArgument<string>;
-}
-export interface SweepBalanceOptions {
-    package?: string;
-    arguments: SweepBalanceArguments | [
-        vault: RawTransactionArgument<string>,
-        party: RawTransactionArgument<string>,
-        root: RawTransactionArgument<string>,
-        vaultAdminCap: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string
-    ];
-}
-/**
- * Redeem the settled `Currency` amount reported for the Party address and return a
- * Balance for the caller's PTB to consume.
- *
- * Funds sent during the current consensus commit are not yet settled and remain
- * available for a later sweep. Aborts with `ENoSettledFunds` when the settled
- * amount is zero. The framework caps the reported amount at `u64::MAX`; any excess
- * remains for a later sweep.
- */
-export function sweepBalance(options: SweepBalanceOptions) {
-    const packageAddress = options.package ?? '@local-pkg/party_wallet';
-    const argumentsTypes = [
-        null,
-        null,
-        null,
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["vault", "party", "root", "vaultAdminCap"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'party_wallet',
-        function: 'sweep_balance',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
-export interface IsInstalledArguments {
-    vault: RawTransactionArgument<string>;
-}
-export interface IsInstalledOptions {
-    package?: string;
-    arguments: IsInstalledArguments | [
-        vault: RawTransactionArgument<string>
-    ];
-}
-/** Return whether this plugin is installed on `vault`. */
-export function isInstalled(options: IsInstalledOptions) {
-    const packageAddress = options.package ?? '@local-pkg/party_wallet';
-    const argumentsTypes = [
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["vault"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'party_wallet',
-        function: 'is_installed',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
 export interface InboxAddressArguments {
     party: RawTransactionArgument<string>;
 }
@@ -340,7 +158,7 @@ export interface InboxAddressOptions {
         party: RawTransactionArgument<string>
     ];
 }
-/** Return the Party ID as the address to which objects or funds may be sent. */
+/** Return the Party ID as the address to which objects and funds may be sent. */
 export function inboxAddress(options: InboxAddressOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_wallet';
     const argumentsTypes = [
@@ -353,37 +171,4 @@ export function inboxAddress(options: InboxAddressOptions) {
         function: 'inbox_address',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
-}
-export interface SettledFundsArguments {
-    root: RawTransactionArgument<string>;
-    party: RawTransactionArgument<string>;
-}
-export interface SettledFundsOptions {
-    package?: string;
-    arguments: SettledFundsArguments | [
-        root: RawTransactionArgument<string>,
-        party: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string
-    ];
-}
-/**
- * Return the Party's accumulator balance settled at the start of the current
- * consensus commit.
- */
-export function settledFunds(options: SettledFundsOptions) {
-    const packageAddress = options.package ?? '@local-pkg/party_wallet';
-    const argumentsTypes = [
-        null,
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["root", "party"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'party_wallet',
-        function: 'settled_funds',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
 }

package/src/contracts/recording_advisory/recording_advisory.ts

@@ -7,7 +7,7 @@
  * The parental advisory rating for a recording — whether its lyrics are explicit —
  * stored as a dynamic field on the recording's UID and written through its
  * cap-gated `uid_mut`.
- * 
+ *
  * This is its own package on purpose. Advisory ratings are set by a different
  * person, at a different time, for entirely different reasons than the other facts
  * about a recording, and the standard that governs them moves on its own schedule.
@@ -15,13 +15,13 @@
  * the advisory standard drags every unrelated field through the migration. Kept
  * separate, a consumer implementing some future metadata profile selects this
  * extension or ignores it, and swapping it touches nothing else.
- * 
+ *
  * The rating is deliberately not a boolean. Every distributor and storefront
  * distinguishes a _cleaned_ edit — an explicit recording re-issued with the
  * offending content removed — from a recording that was never explicit at all.
  * They are merchandised differently and a boolean cannot express the difference,
  * so `Cleaned` is a first-class variant.
- * 
+ *
  * Attaching the extension IS the statement. There is no "attached but undeclared"
  * state: if a rating is present it has been asserted by the rights holder, and a
  * recording with nothing attached has simply said nothing.
@@ -29,6 +29,7 @@
 
 import { MoveTuple, MoveEnum, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
 import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 const $moduleName = '@local-pkg/recording_advisory::recording_advisory';
 export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });

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

@@ -9,6 +9,7 @@
  */
 
 import { type BcsType, bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { MoveStruct } from '../../../utils/index.js';
 const $moduleName = 'miso_credit::credit';
 /**

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

@@ -2,6 +2,7 @@
  * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
  **************************************************************/
 import { type BcsType, bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { MoveStruct } from '../../../utils/index.js';
 const $moduleName = '0x2::vec_map';
 /** An entry in the map */

package/src/contracts/recording_credits/deps/sui/vec_set.ts

@@ -2,6 +2,7 @@
  * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
  **************************************************************/
 import { type BcsType, bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { MoveStruct } from '../../../utils/index.js';
 const $moduleName = '0x2::vec_set';
 /**

package/src/contracts/recording_credits/recording_credits.ts

@@ -5,14 +5,14 @@
 
 /**
  * First-party credits extension for recordings.
- * 
+ *
  * Attribution (credits + primary/featured artists) is display-oriented and varies
  * across platforms, so it lives here as a dynamic field on the recording rather
  * than in immutable core. The data is attached under `ExtensionKey()` via the
  * recording's cap-gated `uid_mut`, so every mutation is authorized by the
  * recording's admin and credits survive into any lifecycle state (they may be
  * attached before or after the recording is published).
- * 
+ *
  * This is Miso's canonical credits standard; because it is an extension, other
  * parties may publish their own recording-credits standard against the same
  * `Recording`. Credits are NOT read by the economics — they are attribution.
@@ -20,6 +20,7 @@
 
 import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
 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.js';
 import * as credit from './deps/miso_credit/credit.js';

package/src/contracts/recording_credits/recording_party_role.ts

@@ -7,13 +7,13 @@
  * Defines the roles that parties can hold on a recording. Recordings are audio
  * performances of compositions, and these roles represent the various production
  * and performance contributions.
- * 
+ *
  * ### Design
- * 
+ *
  * `RecordingPartyRole` 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.
- * 
+ *
  * - **Seniority is a separate axis.** Most roles carry an optional
  *   `RecordingPartyRoleLevel` (Lead, Assistant, Additional, …). Industry variants
  *   like "Second Engineer" or "Additional Producer" are expressed as a base role
@@ -27,13 +27,14 @@
  *   the seed for off-chain display/localization. For `Custom`, `name()` returns
  *   the user-supplied string; for `Instrumentalist`, it returns
  *   `"Instrumentalist"` (the instrument itself is read off-chain).
- * 
+ *
  * These identifiers are Miso's own canonical vocabulary; any overlap with an
  * external standard (e.g. DDEX) is coincidental, not a reproduction of it.
  */
 
 import { MoveEnum, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
 import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 const $moduleName = '@local-pkg/recording_credits::recording_party_role';
 /** Indicates the seniority or prominence level of a party. */

package/src/contracts/recording_language/deps/language_code/language_code.ts

@@ -3,5 +3,6 @@
  **************************************************************/
 import { MoveTuple } from '../../../utils/index.js';
 import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 const $moduleName = 'language_code::language_code';
 export const LanguageCode = new MoveTuple({ name: `${$moduleName}::LanguageCode`, fields: [bcs.string()] });

package/src/contracts/recording_language/recording_language.ts

@@ -6,29 +6,30 @@
 /**
  * The languages sung or spoken on a recording, stored as a dynamic field on the
  * recording's UID and written through its cap-gated `uid_mut`.
- * 
+ *
  * Its own package, for the same reason the advisory rating is: language is set by
  * different people, at different times, and governed by a standard (ISO 639) that
  * has nothing to do with any other fact about the recording. A consumer
  * implementing a metadata profile picks this extension up or leaves it, and
  * replacing it never disturbs anything else attached to the work.
- * 
+ *
  * A `vector`, not a single code — bilingual and code-switching recordings are
  * ordinary, and forcing one language would mean choosing which of them to erase.
  * Order is the caller's: first is conventionally the predominant one.
- * 
+ *
  * **An empty vector means instrumental** — attached, and asserting there is no
  * sung or spoken content at all. That is a genuine claim about the recording and
  * is deliberately distinct from attaching nothing, which says only that nobody has
  * looked. `set_instrumental` exists so that claim reads as intent at the call site
  * rather than as an empty argument someone might mistake for an oversight.
- * 
+ *
  * `LanguageCode` is a valid ISO 639-1 code by construction, so this package checks
  * only what construction cannot: how many, and whether any repeat.
  */
 
 import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
 import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 import * as language_code from './deps/language_code/language_code.js';
 const $moduleName = '@local-pkg/recording_language::recording_language';

package/src/contracts/recording_master_reference/deps/ori/walrus_data.ts

@@ -3,6 +3,7 @@
  **************************************************************/
 import { MoveEnum, MoveStruct, MoveTuple } from '../../../utils/index.js';
 import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 const $moduleName = 'ori::walrus_data';
 /**
  * Confidentiality of a stored blob: cleartext, or encrypted with an access policy.

package/src/contracts/recording_master_reference/recording_master_reference.ts

@@ -5,34 +5,35 @@
 
 /**
  * A pointer to a recording's master audio — nothing more.
- * 
+ *
  * The value is a bare `ori::WalrusData` blob reference. This extension makes no
  * claim about what the blob contains: not its codec, not its sample rate, not its
  * duration, not that it is even audio. The only assertion is that the holder of
  * the recording's admin cap says this blob is the master. Everything else is
  * client-side convention.
- * 
+ *
  * That thinness is the point. Miso's attested path — the Nautilus-verified master
  * flow (`audio_ingester` producing a `miso_audio::Audio`), deferred — carries
  * channel count, bit depth, sample rate, sample count and a PCM digest, and every
  * one of those is backed by a Nautilus enclave signature over the measured audio.
  * Until that path is running, stating the same fields _unverified_ would dress an
  * assertion up as a measurement. A pointer cannot be mistaken for a measurement.
- * 
+ *
  * # This extension is a holdover
- * 
+ *
  * It exists to carry the catalogue until enclave ingestion is ready, and it is
  * meant to be removed rather than grown. When a recording's master is ingested for
  * real, attach the attested master via the ingester's master flow and call
  * `unset_master_reference` here. The two never need to coexist, and this package
  * deliberately holds nothing the attested path cannot restate.
- * 
+ *
  * Resist adding fields. Anything worth asserting about the audio is worth
  * attesting, and belongs in the ingested `Audio` rather than here.
  */
 
 import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
 import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 import * as walrus_data from './deps/ori/walrus_data.js';
 const $moduleName = '@local-pkg/recording_master_reference::recording_master_reference';

package/src/contracts/recording_preview/deps/ori/walrus_data.ts

@@ -3,6 +3,7 @@
  **************************************************************/
 import { MoveEnum, MoveStruct, MoveTuple } from '../../../utils/index.js';
 import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 const $moduleName = 'ori::walrus_data';
 /**
  * Confidentiality of a stored blob: cleartext, or encrypted with an access policy.

package/src/contracts/recording_preview/recording_preview.ts

@@ -7,7 +7,7 @@
  * Recording audio preview: a short, public teaser clip for a recording, stored as
  * a dynamic field on the recording's UID, set/cleared via the recording's
  * cap-gated `uid_mut`.
- * 
+ *
  * V1 is deliberately minimal: the value is a bare `ori::WalrusData` blob reference
  * — no ingestion or attestation ties the preview to the recording's master. What
  * the blob contains (codec, duration, clip offset) is client-side convention, not
@@ -17,6 +17,7 @@
 
 import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
 import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
 import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 import * as walrus_data from './deps/ori/walrus_data.js';
 const $moduleName = '@local-pkg/recording_preview::recording_preview';