@misofm/platform 0.0.0 → 0.18.0

package/dist/client.js

@@ -0,0 +1,788 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+import { miso as protocolMiso, } from "@misofm/protocol/client";
+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 recordingPreviewContract from "@misofm/protocol/contracts/recording_preview/recording_preview";
+import * as vaultActions from "./vault.js";
+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 { authorizeRecordShop, deriveListingId, derivePressingAdminCapId, derivePressingId, deriveRecordId, deriveSaleIds, getListing, getPressing, getRecord, getSale, openListing, openPressing, purchaseRecord, revokeRecordShop, setListingPrice, setListingState, } from "./pressing.js";
+import { publishShareCurrency, initializeShareCurrency, publishComposition, publishRecording, publishCompositionAndRecording, publishRelease, } from "./transactions.js";
+import * as share from "./share.js";
+import { publishReleaseGraph, } from "./release-graph.js";
+import { getMisoPlatformDeployment, requireOperationsDeployment, requireRecordSalesDeployment, } from "./deployments.js";
+import { immutableSnapshot } from "./internal.js";
+import { deriveGenreAddress, setReleaseDescription, setReleaseDspLinks, setReleaseGenres, setReleaseKind, } from "./release-extensions.js";
+import { setRecordingStreamingTranscode, unsetRecordingStreamingTranscode, } from "./recording-extensions.js";
+import { addReleaseCredit } from "./credits.js";
+import { setReleaseCover, setReleaseTrackCover, } from "./cover.js";
+import { executeViaExecutor as executePlatformViaExecutor, } from "./execute.js";
+/**
+ * Bind an explicit safe subset of a generated module to one immutable package.
+ * Callers cannot supply or override `package`; reference-returning, UID-only,
+ * and package-internal constructors never appear in this executable facade.
+ */
+function bindModulePackage(mod, pkg, available) {
+    const out = {};
+    for (const key of available) {
+        const value = mod[key];
+        out[String(key)] =
+            typeof value === "function"
+                ? (options) => value({ ...options, package: pkg })
+                : value;
+    }
+    return out;
+}
+/** Keep synchronous, client-bound surfaces unusable until the endpoint's exact
+ * ledger has been validated. The underlying standalone builders remain pure. */
+function requireReadyOnFunctions(surface, requireReady, namespace) {
+    return new Proxy(surface, {
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            if (typeof value !== "function")
+                return value;
+            return (...args) => {
+                requireReady(`${namespace}.${String(property)}`);
+                return Reflect.apply(value, target, args);
+            };
+        },
+    });
+}
+function requireReadyOnModuleFunctions(surface, requireReady, namespace) {
+    return new Proxy(surface, {
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            if (!value || typeof value !== "object")
+                return value;
+            return requireReadyOnFunctions(value, requireReady, `${namespace}.${String(property)}`);
+        },
+    });
+}
+export class MisoNetworkMismatchError extends Error {
+    clientNetwork;
+    deploymentNetwork;
+    name = "MisoNetworkMismatchError";
+    constructor(clientNetwork, deploymentNetwork) {
+        super(`@misofm/platform: client network "${clientNetwork}" does not match deployment network "${deploymentNetwork}"`);
+        this.clientNetwork = clientNetwork;
+        this.deploymentNetwork = deploymentNetwork;
+    }
+}
+export class MisoChainIdentifierMismatchError extends Error {
+    actual;
+    expected;
+    name = "MisoChainIdentifierMismatchError";
+    constructor(actual, expected) {
+        super(`@misofm/platform: endpoint chain identifier "${actual}" does not match deployment chain identifier "${expected}"`);
+        this.actual = actual;
+        this.expected = expected;
+    }
+}
+export class MisoClientNotReadyError extends Error {
+    operation;
+    name = "MisoClientNotReadyError";
+    constructor(operation) {
+        super(`@misofm/platform: ${operation} requires an exact-chain validation lifecycle; call and await client.miso.ready() first`);
+        this.operation = operation;
+    }
+}
+export class MisoPlatformClient {
+    #client;
+    #config;
+    #protocol;
+    #chainIdentifier;
+    /** Bundled/custom deployment selected for the full facade, when available. */
+    deployment;
+    #readyState = "unvalidated";
+    #readyPromise;
+    constructor(client, config, protocol, deployment) {
+        const configSnapshot = immutableSnapshot(config);
+        const deploymentSnapshot = deployment
+            ? immutableSnapshot(deployment)
+            : undefined;
+        this.#client = client;
+        this.#config = configSnapshot;
+        if (configSnapshot.operations?.status === "available") {
+            requireOperationsDeployment(configSnapshot.operations);
+        }
+        // A pressing-only facade must not implicitly register a fail-closed core
+        // extension. Supply a core deployment/misoPackageId when `protocol` is
+        // needed; otherwise this remains a safe, independent pressing client.
+        this.#protocol =
+            protocol ??
+                (configSnapshot.misoPackageId
+                    ? protocolMiso({
+                        deployment: { packageId: configSnapshot.misoPackageId },
+                    }).register(client)
+                    : undefined);
+        this.deployment = deploymentSnapshot;
+        this.#chainIdentifier =
+            deploymentSnapshot?.chainIdentifier ?? configSnapshot.chainIdentifier;
+    }
+    /** Permissionless protocol APIs bound to the same validated ledger. */
+    get protocol() {
+        if (!this.#protocol)
+            return undefined;
+        this.#requireReady("protocol APIs");
+        return this.#protocol;
+    }
+    /**
+     * Memoized exact-ledger readiness gate. Registration already rejects a
+     * synchronous network-label mismatch; this Core API read protects every
+     * client-bound write surface from a mislabeled or custom endpoint.
+     */
+    ready() {
+        if (!this.#readyPromise) {
+            this.#readyState = "validating";
+            this.#readyPromise = (async () => {
+                try {
+                    if (!this.#chainIdentifier) {
+                        throw new Error("misoPlatform: chain readiness requires a complete deployment or an explicit `chainIdentifier`.");
+                    }
+                    const { chainIdentifier } = await this.#client.core.getChainIdentifier();
+                    if (chainIdentifier !== this.#chainIdentifier) {
+                        throw new MisoChainIdentifierMismatchError(chainIdentifier, this.#chainIdentifier);
+                    }
+                    this.#readyState = "ready";
+                }
+                catch (error) {
+                    this.#readyState = "failed";
+                    throw error;
+                }
+            })();
+        }
+        return this.#readyPromise;
+    }
+    /** Compatibility hook; prefer `await client.miso.ready()`. */
+    async validateChainIdentifier() {
+        await this.ready();
+        return this.#chainIdentifier;
+    }
+    #requireReady(operation) {
+        // Capability availability remains the first fail-closed boundary. This
+        // keeps an unavailable deployment from masquerading as a mere lifecycle
+        // error while still preventing configured builders from running pre-ready.
+        if (operation === "ids.pressing" ||
+            operation === "ids.pressingAdminCap" ||
+            operation === "ids.record" ||
+            operation === "ids.listing" ||
+            operation === "ids.sale" ||
+            operation === "tx.purchaseRecord" ||
+            operation === "tx.openPressing" ||
+            operation === "tx.openListing" ||
+            operation === "tx.authorizeRecordShop" ||
+            operation === "tx.revokeRecordShop" ||
+            operation === "tx.setListingPrice" ||
+            operation === "tx.setListingState") {
+            this.#recordSales();
+        }
+        if (operation === "ids.vault" || operation === "ids.vaultAdminCap") {
+            this.#operations();
+        }
+        if (this.#readyState !== "ready") {
+            throw new MisoClientNotReadyError(operation);
+        }
+    }
+    /** Party identity and profile APIs, backed by the network SDK. */
+    get party() {
+        if (!this.#protocol) {
+            throw new Error("misoPlatform: Party APIs require the complete platform deployment. Use miso({ deployment }).");
+        }
+        this.#requireReady("party APIs");
+        return this.#protocol.party;
+    }
+    #recordSales() {
+        return requireRecordSalesDeployment(this.#config.recordSales ?? {
+            status: "unavailable",
+            reason: "this client was configured without Record and Record Shop package IDs",
+        });
+    }
+    #operations() {
+        return requireOperationsDeployment(this.#config.operations);
+    }
+    #availableOperations() {
+        return this.#config.operations?.status === "available"
+            ? requireOperationsDeployment(this.#config.operations)
+            : undefined;
+    }
+    get recordPackageId() {
+        return this.#recordSales().recordPackageId;
+    }
+    get recordShopPackageId() {
+        return this.#recordSales().recordShopPackageId;
+    }
+    #misoPackageId() {
+        const { misoPackageId } = this.#config;
+        if (!misoPackageId) {
+            throw new Error("misoPlatform: `misoPackageId` is required for the publish builders " +
+                "(publishComposition, publishRecording, publishCompositionAndRecording, publishRelease) — pass it to misoPlatform({ misoPackageId }).");
+        }
+        return misoPackageId;
+    }
+    #minatoPackageId() {
+        const { minatoPackageId } = this.#config;
+        if (!minatoPackageId) {
+            throw new Error("misoPlatform: `minatoPackageId` is required for the publish builders that disperse shares " +
+                "(publishComposition, publishRecording, publishCompositionAndRecording) — pass it to misoPlatform({ minatoPackageId }).");
+        }
+        return minatoPackageId;
+    }
+    #releaseRegistryId() {
+        const { releaseRegistryId: id } = this.#config;
+        if (!id) {
+            throw new Error("misoPlatform: `releaseRegistryId` is required to build a release.");
+        }
+        return id;
+    }
+    #requiredConfig(field, operation) {
+        const value = this.#config[field];
+        if (typeof value !== "string" || value.length === 0) {
+            throw new Error(`misoPlatform: \`${String(field)}\` is required for ${operation}.`);
+        }
+        return value;
+    }
+    // ── Reads ─────────────────────────────────────────────────────────────────
+    /** The run itself, or `null` if this release has never opened one. */
+    async getPressing(pressingId) {
+        await this.ready();
+        return getPressing(this.#client, pressingId, this.recordPackageId);
+    }
+    /** One currency's offer, or `null` if the run does not sell in it. */
+    async getListing(listingId) {
+        await this.ready();
+        return getListing(this.#client, listingId, this.recordShopPackageId);
+    }
+    /** One concrete purchased Record, including immutable purchase provenance. */
+    async getRecord(recordId) {
+        await this.ready();
+        return getRecord(this.#client, recordId, this.recordPackageId);
+    }
+    /** Run + one currency's offer in a single round trip, by address math. */
+    async getSale(p) {
+        await this.ready();
+        return getSale(this.#client, {
+            ...p,
+            recordPackageId: this.recordPackageId,
+            recordShopPackageId: this.recordShopPackageId,
+        });
+    }
+    // ── Address math ──────────────────────────────────────────────────────────
+    ids = requireReadyOnFunctions({
+        pressing: (releaseId, edition) => derivePressingId(releaseId, edition, this.recordPackageId),
+        pressingAdminCap: (pressingId) => derivePressingAdminCapId(pressingId, this.recordPackageId),
+        record: (pressingId, number) => deriveRecordId(pressingId, number, this.recordPackageId),
+        listing: (pressingId, currencyType) => deriveListingId(pressingId, currencyType, this.recordShopPackageId),
+        sale: (releaseId, edition, currencyType) => deriveSaleIds(releaseId, edition, currencyType, this.recordPackageId, this.recordShopPackageId),
+        vault: (capId, capType) => vaultActions.deriveVaultId({
+            vaultRegistryId: this.#operations().vault.registryId,
+            capId,
+            capType,
+            vaultPackageId: this.#operations().vault.packageId,
+        }),
+        vaultAdminCap: (vaultId) => vaultActions.deriveVaultAdminCapId(vaultId, this.#operations().vault.packageId),
+        genre: (canonicalName) => deriveGenreAddress(this.#requiredConfig("genreRegistryId", "genre id derivation"), this.#requiredConfig("genrePackageId", "genre id derivation"), canonicalName),
+    }, (operation) => this.#requireReady(operation), "ids");
+    // ── Transaction builders ──────────────────────────────────────────────────
+    /** Client-bound builders require a successful `await client.miso.ready()`.
+     * Standalone exports remain pure for explicitly managed offline workflows. */
+    tx = requireReadyOnFunctions({
+        purchaseRecord: (p) => purchaseRecord({
+            ...p,
+            recordPackageId: this.recordPackageId,
+            recordShopPackageId: this.recordShopPackageId,
+        }),
+        openPressing: (p) => openPressing({
+            ...p,
+            recordPackageId: this.recordPackageId,
+            recordShopPackageId: this.recordShopPackageId,
+        }),
+        openListing: (p) => openListing({ ...p, recordShopPackageId: this.recordShopPackageId }),
+        authorizeRecordShop: (p) => authorizeRecordShop({
+            ...p,
+            recordPackageId: this.recordPackageId,
+            recordShopPackageId: this.recordShopPackageId,
+        }),
+        revokeRecordShop: (p) => revokeRecordShop({
+            ...p,
+            recordPackageId: this.recordPackageId,
+            recordShopPackageId: this.recordShopPackageId,
+        }),
+        setListingPrice: (p) => setListingPrice({ ...p, recordShopPackageId: this.recordShopPackageId }),
+        setListingState: (p) => setListingState({ ...p, recordShopPackageId: this.recordShopPackageId }),
+        // Publishing (protocol works + minato share economics) — package-id-free
+        // builders pass through unchanged; the rest bind this client's
+        // `misoPackageId`/`minatoPackageId`, throwing at call time if either is
+        // missing (kept optional on the client so a sell-only client, e.g. a
+        // storefront that never mints new works, doesn't need to carry them).
+        publishShareCurrency,
+        initializeShareCurrency,
+        publishComposition: (p) => publishComposition({
+            ...p,
+            misoPackageId: this.#misoPackageId(),
+            minatoPackageId: this.#minatoPackageId(),
+        }),
+        publishRecording: (p) => publishRecording({
+            ...p,
+            misoPackageId: this.#misoPackageId(),
+            minatoPackageId: this.#minatoPackageId(),
+        }),
+        publishCompositionAndRecording: (p) => publishCompositionAndRecording({
+            ...p,
+            misoPackageId: this.#misoPackageId(),
+            minatoPackageId: this.#minatoPackageId(),
+        }),
+        publishRelease: (p) => {
+            return publishRelease({
+                ...p,
+                misoPackageId: this.#misoPackageId(),
+                releaseRegistryId: this.#releaseRegistryId(),
+            });
+        },
+        publishReleaseGraph: (p) => {
+            return publishReleaseGraph({
+                ...p,
+                misoPackageId: this.#misoPackageId(),
+                minatoPackageId: this.#minatoPackageId(),
+            });
+        },
+        setReleaseKind: (p) => setReleaseKind({
+            ...p,
+            releaseKindPackageId: this.#requiredConfig("releaseKindPackageId", "setReleaseKind"),
+        }),
+        setReleaseDescription: (p) => setReleaseDescription({
+            ...p,
+            releaseDescriptionPackageId: this.#requiredConfig("releaseDescriptionPackageId", "setReleaseDescription"),
+        }),
+        setReleaseGenres: (p) => setReleaseGenres({
+            ...p,
+            releaseGenrePackageId: this.#requiredConfig("releaseGenrePackageId", "setReleaseGenres"),
+        }),
+        setReleaseDspLinks: (p) => setReleaseDspLinks({
+            ...p,
+            releaseDspLinkPackageId: this.#requiredConfig("releaseDspLinkPackageId", "setReleaseDspLinks"),
+        }),
+        addReleaseCredit: (p) => addReleaseCredit({
+            ...p,
+            releaseCreditsPackageId: this.#requiredConfig("releaseCreditsPackageId", "addReleaseCredit"),
+            misoCreditPackageId: this.#requiredConfig("misoCreditPackageId", "addReleaseCredit"),
+        }),
+        setReleaseCover: (p) => setReleaseCover({
+            ...p,
+            coverArtPackageId: this.#requiredConfig("coverArtPackageId", "setReleaseCover"),
+            releaseCoverArtPackageId: this.#requiredConfig("releaseCoverArtPackageId", "setReleaseCover"),
+            oriPackageId: this.#requiredConfig("oriPackageId", "setReleaseCover"),
+        }),
+        setReleaseTrackCover: (p) => setReleaseTrackCover({
+            ...p,
+            coverArtPackageId: this.#requiredConfig("coverArtPackageId", "setReleaseTrackCover"),
+            releaseCoverArtPackageId: this.#requiredConfig("releaseCoverArtPackageId", "setReleaseTrackCover"),
+            oriPackageId: this.#requiredConfig("oriPackageId", "setReleaseTrackCover"),
+        }),
+        setRecordingStreamingTranscode: (p) => setRecordingStreamingTranscode({
+            ...p,
+            recordingStreamingTranscodePackageId: this.#requiredConfig("recordingStreamingTranscodePackageId", "setRecordingStreamingTranscode"),
+            oriPackageId: this.#requiredConfig("oriPackageId", "setRecordingStreamingTranscode"),
+        }),
+        unsetRecordingStreamingTranscode: (p) => unsetRecordingStreamingTranscode({
+            ...p,
+            recordingStreamingTranscodePackageId: this.#requiredConfig("recordingStreamingTranscodePackageId", "unsetRecordingStreamingTranscode"),
+        }),
+    }, (operation) => this.#requireReady(operation), "tx");
+    /**
+     * Vault-aware builders and parsers. These take explicit object ids because a
+     * VaultAdminCap is owner-held while the Vault is shared; package ids can come
+     * from the deployment config or be supplied for private deployments.
+     */
+    get vault() {
+        if (!this.#availableOperations())
+            return undefined;
+        this.#requireReady("vault builders");
+        return vaultActions;
+    }
+    // ── Share currency provisioning (executes; Signer pattern) ─────────────────
+    /** Publishes + initializes a fresh share currency (two txs). */
+    async createShareCurrency(signer, params) {
+        await this.ready();
+        return share.createShareCurrency(this.#client, signer, params);
+    }
+    /** Execute a composed platform PTB only after exact-ledger validation. */
+    async executeViaExecutor(executor, ...thunks) {
+        await this.ready();
+        return executePlatformViaExecutor(executor, ...thunks);
+    }
+    // ── Generated layer ───────────────────────────────────────────────────────
+    /** Generated Move-call bindings, for commands this facade doesn't wrap. */
+    get call() {
+        const sales = this.#config.recordSales?.status === "available"
+            ? this.#config.recordSales
+            : undefined;
+        const operations = this.#availableOperations();
+        return requireReadyOnModuleFunctions({
+            record: sales
+                ? bindModulePackage(recordContract, sales.recordPackageId, [
+                    "destroy",
+                    "releaseId",
+                    "pressingId",
+                    "edition",
+                    "number",
+                    "purchaseCurrency",
+                    "purchasePrice",
+                    "purchasedBy",
+                    "purchasedTimestampMs",
+                    "deriveAddress",
+                ])
+                : undefined,
+            listing: sales
+                ? bindModulePackage(listingContract, sales.recordShopPackageId, [
+                    "fixed",
+                    "floor",
+                    "enabled",
+                    "disabled",
+                    "setState",
+                    "setPrice",
+                    "purchase",
+                    "deriveAddress",
+                    "releaseId",
+                    "pressingId",
+                    "pricing",
+                    "price",
+                    "state",
+                    "isEnabled",
+                    "isDisabled",
+                    "isFixed",
+                    "isFloor",
+                ])
+                : undefined,
+            pressing: sales
+                ? bindModulePackage(pressingContract, sales.recordPackageId, [
+                    "authorizeDistributor",
+                    "revokeDistributor",
+                    "deriveAddress",
+                    "deriveAdminCapAddress",
+                    "releaseId",
+                    "edition",
+                    "supply",
+                    "maxSupply",
+                    "distributors",
+                    "isDistributorAuthorized",
+                    "pressingId",
+                ])
+                : undefined,
+            genre: this.#config.genrePackageId
+                ? bindModulePackage(genreContract, this.#config.genrePackageId, [
+                    "deriveAddress",
+                ])
+                : undefined,
+            releaseDescription: this.#config.releaseDescriptionPackageId
+                ? bindModulePackage(releaseDescriptionContract, this.#config.releaseDescriptionPackageId, ["setDescription", "clearDescription", "hasDescription"])
+                : undefined,
+            releaseDspLink: this.#config.releaseDspLinkPackageId
+                ? bindModulePackage(releaseDspLinkContract, this.#config.releaseDspLinkPackageId, [
+                    "platform",
+                    "platformSpotify",
+                    "platformAppleMusic",
+                    "platformAmazonMusic",
+                    "platformBandcamp",
+                    "platformDeezer",
+                    "platformSoundcloud",
+                    "platformTidal",
+                    "platformYoutubeMusic",
+                    "newSpotify",
+                    "newAppleMusicAlbum",
+                    "newAppleMusicTrack",
+                    "newAmazonMusicAlbum",
+                    "newAmazonMusicTrack",
+                    "newBandcamp",
+                    "newDeezer",
+                    "newSoundcloud",
+                    "newTidal",
+                    "newYoutubeMusic",
+                    "setReleaseLink",
+                    "clearReleaseLink",
+                    "setTrackLink",
+                    "clearTrackLink",
+                    "clearTrackLinks",
+                    "hasReleaseLink",
+                ])
+                : undefined,
+            releaseGenre: this.#config.releaseGenrePackageId
+                ? bindModulePackage(releaseGenreContract, this.#config.releaseGenrePackageId, [
+                    "setPrimaryGenre",
+                    "addSecondaryGenre",
+                    "removeSecondaryGenre",
+                    "setTrackPrimaryGenre",
+                    "unsetTrackPrimaryGenre",
+                    "hasGenre",
+                ])
+                : undefined,
+            releaseKind: this.#config.releaseKindPackageId
+                ? bindModulePackage(releaseKindContract, this.#config.releaseKindPackageId, ["setKind", "unsetKind", "hasKind"])
+                : undefined,
+            releaseRevenueDistributor: operations
+                ? bindModulePackage(releaseRevenueDistributorContract, operations.actions.releaseRevenueDistributor, [
+                    "redeemAndDistribute",
+                    "redeemAllAndDistribute",
+                    "receiveAndDistribute",
+                ])
+                : undefined,
+            releaseRevenueDistributorPlugin: operations
+                ? bindModulePackage(releaseRevenueDistributorPluginContract, operations.plugins.releaseRevenueDistributor, [
+                    "install",
+                    "uninstall",
+                    "redeemAllAndDistribute",
+                    "receiveAndDistribute",
+                    "isInstalled",
+                ])
+                : undefined,
+            vault: operations
+                ? bindModulePackage(vaultContract, operations.vault.packageId, [
+                    "share",
+                    "withdrawCap",
+                    "restoreCap",
+                    "derivedAddress",
+                    "capId",
+                    "isActive",
+                    "authorizedPlugins",
+                    "isPluginAuthorized",
+                ])
+                : undefined,
+            compositionRoyaltyPool: operations
+                ? bindModulePackage(compositionRoyaltyPoolContract, operations.actions.compositionRoyaltyPool, ["newPool", "receiveAndDeposit", "redeemAndDeposit", "poolAddress"])
+                : undefined,
+            compositionRoyaltyPoolPlugin: operations
+                ? bindModulePackage(compositionRoyaltyPoolPluginContract, operations.plugins.compositionRoyaltyPool, [
+                    "install",
+                    "uninstall",
+                    "receiveAndDeposit",
+                    "redeemAndDeposit",
+                    "isInstalled",
+                ])
+                : undefined,
+            recordingRoyaltyPool: operations
+                ? bindModulePackage(recordingRoyaltyPoolContract, operations.actions.recordingRoyaltyPool, ["newPool", "receiveAndDeposit", "redeemAndDeposit", "poolAddress"])
+                : undefined,
+            recordingRoyaltyPoolPlugin: operations
+                ? bindModulePackage(recordingRoyaltyPoolPluginContract, operations.plugins.recordingRoyaltyPool, [
+                    "install",
+                    "uninstall",
+                    "receiveAndDeposit",
+                    "redeemAndDeposit",
+                    "isInstalled",
+                ])
+                : undefined,
+            partyWallet: operations
+                ? bindModulePackage(partyWalletContract, operations.actions.partyWallet, ["receive", "receiveBalance", "redeemBalance", "inboxAddress"])
+                : undefined,
+            compositionRoutedStake: operations
+                ? bindModulePackage(compositionRoutedStakeContract, operations.actions.compositionRoutedStake, ["createStake", "register", "unregister", "unstake", "restake", "stakeAddress"])
+                : undefined,
+            routedStake: this.#config.routedStakePackageId
+                ? bindModulePackage(routedStakeContract, this.#config.routedStakePackageId, [
+                    "share",
+                    "register",
+                    "unregister",
+                    "sweep",
+                    "unstake",
+                    "restake",
+                    "derivedAddress",
+                ])
+                : undefined,
+            royaltyPool: this.#config.royaltyPoolPackageId
+                ? bindModulePackage(royaltyPoolContract, this.#config.royaltyPoolPackageId, [
+                    "share",
+                    "deposit",
+                    "sweepAndDeposit",
+                    "receiveAndDeposit",
+                    "registerStake",
+                    "unregisterStake",
+                    "claimRewards",
+                    "pendingRewards",
+                    "stakedShares",
+                    "cumulativeRewardPerShare",
+                    "cumulativeDeposits",
+                    "derivedAddress",
+                    "assertDerivedFrom",
+                ])
+                : undefined,
+            recordingAdvisory: this.#config.recordingAdvisoryPackageId
+                ? bindModulePackage(recordingAdvisoryContract, this.#config.recordingAdvisoryPackageId, [
+                    "explicit",
+                    "notExplicit",
+                    "cleaned",
+                    "setRating",
+                    "unsetRating",
+                    "hasRating",
+                    "isExplicit",
+                    "isNotExplicit",
+                    "isCleaned",
+                ])
+                : undefined,
+            recordingLanguage: this.#config.recordingLanguagePackageId
+                ? bindModulePackage(recordingLanguageContract, this.#config.recordingLanguagePackageId, [
+                    "setLanguages",
+                    "setInstrumental",
+                    "unsetLanguages",
+                    "hasLanguages",
+                    "isInstrumental",
+                ])
+                : undefined,
+            recordingMasterReference: this.#config.recordingMasterReferencePackageId
+                ? bindModulePackage(recordingMasterReferenceContract, this.#config.recordingMasterReferencePackageId, [
+                    "setMasterReference",
+                    "unsetMasterReference",
+                    "hasMasterReference",
+                ])
+                : undefined,
+            recordingStreamingTranscode: this.#config.recordingStreamingTranscodePackageId
+                ? bindModulePackage(recordingStreamingTranscodeContract, this.#config.recordingStreamingTranscodePackageId, [
+                    "setStreamingTranscode",
+                    "unsetStreamingTranscode",
+                    "hasStreamingTranscode",
+                ])
+                : undefined,
+            recordingPreview: this.#config.recordingPreviewPackageId
+                ? bindModulePackage(recordingPreviewContract, this.#config.recordingPreviewPackageId, ["setPreview", "unsetPreview", "hasPreview"])
+                : undefined,
+            coverArt: this.#config.coverArtPackageId
+                ? bindModulePackage(coverArtContract, this.#config.coverArtPackageId, [])
+                : undefined,
+            releaseCoverArt: this.#config.releaseCoverArtPackageId
+                ? bindModulePackage(releaseCoverArtContract, this.#config.releaseCoverArtPackageId, [
+                    "setCover",
+                    "unsetCover",
+                    "setTrackCover",
+                    "unsetTrackCover",
+                    "hasCoverArt",
+                ])
+                : undefined,
+            releaseCredits: this.#config.releaseCreditsPackageId
+                ? bindModulePackage(releaseCreditsContract, this.#config.releaseCreditsPackageId, ["addCredit", "removeCredit", "hasCredits"])
+                : undefined,
+        }, (operation) => this.#requireReady(operation), "call");
+    }
+    /** Generated BCS definitions, for parsing objects or events yourself. */
+    bcs = {
+        Record: recordContract.Record,
+        Pressing: pressingContract.Pressing,
+        PressingAdminCap: pressingContract.PressingAdminCap,
+        Listing: listingContract.Listing,
+        Pricing: listingContract.Pricing,
+        ListingState: listingContract.State,
+        RecordCreatedEvent: recordContract.RecordCreatedEvent,
+        RecordDestroyedEvent: recordContract.RecordDestroyedEvent,
+        PressingCreatedEvent: pressingContract.PressingCreatedEvent,
+        DistributorAuthorizedEvent: pressingContract.DistributorAuthorizedEvent,
+        DistributorRevokedEvent: pressingContract.DistributorRevokedEvent,
+        RecordPurchasedEvent: pressingContract.RecordPurchasedEvent,
+        ListingCreatedEvent: listingContract.ListingCreatedEvent,
+        ListingPriceChangedEvent: listingContract.ListingPriceChangedEvent,
+        ListingStateChangedEvent: listingContract.ListingStateChangedEvent,
+        RecordSoldEvent: listingContract.RecordSoldEvent,
+        VaultAdminCap: vaultContract.VaultAdminCap,
+        VaultRegistry: vaultContract.VaultRegistry,
+        VaultKey: vaultContract.VaultKey,
+        VaultAdminCapKey: vaultContract.VaultAdminCapKey,
+        VaultCreatedEvent: vaultContract.VaultCreatedEvent,
+        VaultCapabilityWithdrawnEvent: vaultContract.VaultCapabilityWithdrawnEvent,
+        VaultCapabilityRestoredEvent: vaultContract.VaultCapabilityRestoredEvent,
+        PartyObjectReceivedEvent: partyWalletContract.ObjectReceivedEvent,
+        PartyCoinsReceivedEvent: partyWalletContract.CoinsReceivedEvent,
+        PartyFundsRedeemedEvent: partyWalletContract.FundsRedeemedEvent,
+        ReleaseTrackRevenueDistributedEvent: releaseRevenueDistributorContract.ReleaseTrackRevenueDistributedEvent,
+        ReleaseRevenueDistributedEvent: releaseRevenueDistributorContract.ReleaseRevenueDistributedEvent,
+    };
+}
+/** The full Miso client exposed by `@misofm/platform`. */
+export { MisoPlatformClient as MisoClient };
+/**
+ * Registers the complete Miso facade at `client.miso`.
+ *
+ * Platform operations live directly on `client.miso`; the lower-level
+ * permissionless protocol SDK is available at `client.miso.protocol`.
+ */
+export function miso(options = {}) {
+    const name = (options.name ?? "miso");
+    return {
+        name,
+        register: (client) => {
+            const deployment = immutableSnapshot(options.deployment ?? getMisoPlatformDeployment(client.network));
+            if (deployment.network !== client.network) {
+                throw new MisoNetworkMismatchError(client.network, deployment.network);
+            }
+            const protocol = protocolMiso({
+                deployment: deployment.protocol,
+                graphqlClient: options.graphqlClient,
+            }).register(client);
+            return new MisoPlatformClient(client, {
+                recordSales: deployment.recordSales,
+                misoPackageId: deployment.protocol.miso,
+                minatoPackageId: deployment.packages.minato,
+                releaseRegistryId: deployment.objects.releaseRegistry,
+                releaseKindPackageId: deployment.packages.releaseKind,
+                releaseDescriptionPackageId: deployment.packages.releaseDescription,
+                releaseGenrePackageId: deployment.packages.releaseGenre,
+                releaseDspLinkPackageId: deployment.packages.releaseDspLink,
+                recordingAdvisoryPackageId: deployment.packages.recordingAdvisory,
+                recordingLanguagePackageId: deployment.packages.recordingLanguage,
+                recordingMasterReferencePackageId: deployment.packages.recordingMasterReference,
+                recordingStreamingTranscodePackageId: deployment.packages.recordingStreamingTranscode,
+                recordingPreviewPackageId: deployment.packages.recordingPreview,
+                operations: deployment.operations,
+                royaltyPoolPackageId: deployment.packages.royaltyPool,
+                routedStakePackageId: deployment.packages.routedStake,
+                releaseCreditsPackageId: deployment.packages.releaseCredits,
+                misoCreditPackageId: deployment.packages.credit,
+                coverArtPackageId: deployment.packages.coverArt,
+                releaseCoverArtPackageId: deployment.packages.releaseCoverArt,
+                genrePackageId: deployment.packages.genre,
+                genreRegistryId: deployment.objects.genreRegistry,
+                oriPackageId: deployment.packages.ori,
+            }, protocol, deployment);
+        },
+    };
+}
+/**
+ * @deprecated Prefer zero-config `miso()`, which registers the complete facade
+ * at `client.miso` and exposes the protocol layer at `client.miso.protocol`.
+ */
+export function misoPlatform(config) {
+    return {
+        name: "misoPlatform",
+        register: (client) => {
+            const configSnapshot = immutableSnapshot(config);
+            if (configSnapshot.network && configSnapshot.network !== client.network) {
+                throw new MisoNetworkMismatchError(client.network, configSnapshot.network);
+            }
+            const protocol = configSnapshot.misoPackageId
+                ? protocolMiso({
+                    deployment: { packageId: configSnapshot.misoPackageId },
+                }).register(client)
+                : undefined;
+            return new MisoPlatformClient(client, configSnapshot, protocol);
+        },
+    };
+}
+//# sourceMappingURL=client.js.map