@misofm/platform 0.26.2 → 0.28.0

package/dist/client.js

@@ -1,781 +1,64 @@
 // Copyright (c) Miso Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
-import { miso as protocolMiso, } from "@misofm/musicos/client";
-import { PartyosClient } from "@misofm/partyos";
-import { PartyPlatformClient } from "./party/index.js";
-import * as recordContract from "./contracts/record/record.js";
-import * as pressingContract from "./contracts/record/pressing.js";
-import * as listingContract from "./contracts/record_shop/listing.js";
-import * as genreContract from "./contracts/genre/genre.js";
-import * as releaseDescriptionContract from "./contracts/release_description/release_description.js";
-import * as releaseDspLinkContract from "./contracts/release_dsp_link/release_dsp_link.js";
-import * as releaseGenreContract from "./contracts/release_genre/release_genre.js";
-import * as releaseKindContract from "./contracts/release_kind/release_kind.js";
-import * as releaseRevenueDistributorContract from "./contracts/release_revenue_distributor/release_revenue_distributor.js";
-import * as vaultContract from "./contracts/vault/vault.js";
-import * as compositionRoyaltyPoolContract from "./contracts/composition_royalty_pool/composition_royalty_pool.js";
-import * as recordingRoyaltyPoolContract from "./contracts/recording_royalty_pool/recording_royalty_pool.js";
-import * as partyWalletContract from "./contracts/party_wallet/party_wallet.js";
-import * as compositionRoutedStakeContract from "./contracts/composition_routed_stake/composition_routed_stake.js";
-import * as compositionRoyaltyPoolPluginContract from "./contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.js";
-import * as recordingRoyaltyPoolPluginContract from "./contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin.js";
-import * as releaseRevenueDistributorPluginContract from "./contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin.js";
-import * as routedStakeContract from "./contracts/routed_stake/routed_stake.js";
-import * as royaltyPoolContract from "./contracts/royalty_pool/pool.js";
-import * as recordingAdvisoryContract from "./contracts/recording_advisory/recording_advisory.js";
-import * as recordingLanguageContract from "./contracts/recording_language/recording_language.js";
-import * as recordingMasterReferenceContract from "./contracts/recording_master_reference/recording_master_reference.js";
-import * as recordingStreamingTranscodeContract from "./contracts/recording_streaming_transcode/recording_streaming_transcode.js";
-import * as recordingGenreContract from "./contracts/recording_genre/recording_genre.js";
-import * as vaultActions from "./vault.js";
-import * as coverArtContract from "./contracts/cover_art/cover_art.js";
-import * as releaseCoverArtContract from "./contracts/release_cover_art/release_cover_art.js";
-import * as releaseCreditsContract from "./contracts/release_credits/release_credits.js";
-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 { setReleaseDescription, setReleaseDspLinks, setReleaseKind, } from "./release-extensions.js";
-import { deriveGenreAddress, setReleaseGenres, setRecordingGenres, clearReleaseGenres, clearRecordingGenres, } from "./genre.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";
-import { Effect } from "effect";
-import { SuiClient, SuiRpcError, } from "@misofm/effect";
-import { MisoChainIdentifierMismatchError, MisoClientNotReadyError, MisoNetworkMismatchError, } from "./errors.js";
-export { MisoChainIdentifierMismatchError, MisoClientNotReadyError, MisoNetworkMismatchError, } from "./errors.js";
+import { Effect, Layer } from "effect";
+import { Sui, SuiGraphQL } from "@unconfirmed/sui-effect";
+import { SuiExtension } from "@unconfirmed/sui-effect/extension";
+import { getMisoPlatformDeployment } from "./deployments.js";
+import { Miso } from "./Miso.js";
+import { MisoPlatformDeploymentInvalidError } from "./errors.js";
+export { MisoChainIdentifierMismatchError, MisoNetworkMismatchError, MisoPlatformDeploymentInvalidError } from "./errors.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 MisoPlatformClient {
-    #client;
-    #config;
-    #protocol;
-    #party;
-    #chainIdentifier;
-    /** Bundled/custom deployment selected for the full facade, when available. */
-    deployment;
-    #readyState = "unvalidated";
-    /** Set once in the constructor via `Effect.cached`, so every caller of
-     * `ready()` shares the same in-flight/completed chain read. */
-    #readyEffect;
-    #layer;
-    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;
-        // The one place `PartyPlatformClient` is constructed: from this platform
-        // deployment's `partyos` (core) and `party` (extensions) sections, not
-        // from the object-model protocol client.
-        this.#party = deploymentSnapshot
-            ? new PartyPlatformClient(client, new PartyosClient(client, deploymentSnapshot.partyos), deploymentSnapshot.party)
-            : undefined;
-        this.#chainIdentifier =
-            deploymentSnapshot?.chainIdentifier ?? configSnapshot.chainIdentifier;
-        this.#layer = SuiClient.layer(client);
-        // Built once; `Effect.cached` shares the same in-flight/completed chain
-        // read across every caller of `ready()` — the outer `Effect.cached(...)`
-        // itself only sets up the memoization ref, so running it synchronously
-        // here does not perform the underlying Core API read.
-        this.#readyEffect = Effect.runSync(Effect.cached(Effect.suspend(() => {
-            this.#readyState = "validating";
-            if (!this.#chainIdentifier) {
-                return Effect.die(new Error("misoPlatform: chain readiness requires a complete deployment or an explicit `chainIdentifier`."));
-            }
-            const expected = this.#chainIdentifier;
-            return Effect.tryPromise({
-                try: (signal) => this.#client.core.getChainIdentifier({ signal }),
-                catch: (cause) => new SuiRpcError({ operation: "getChainIdentifier", cause }),
-            }).pipe(Effect.flatMap(({ chainIdentifier }) => chainIdentifier === expected
-                ? Effect.void
-                : new MisoChainIdentifierMismatchError({ actual: chainIdentifier, expected })), Effect.tap(() => Effect.sync(() => { this.#readyState = "ready"; })), Effect.tapError(() => Effect.sync(() => { this.#readyState = "failed"; })));
-        })));
-    }
-    /** 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() {
-        return this.#readyEffect;
-    }
-    /** Compatibility hook; prefer `client.miso.ready()`. */
-    validateChainIdentifier() {
-        return this.ready().pipe(Effect.map(() => 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 });
-        }
-    }
-    /**
-     * Runs the exact-ledger readiness gate, then provides `SuiClient` from this
-     * client's `ClientWithCoreApi`, so a read method's program has `R = never`.
-     */
-    #run(effect) {
-        return this.ready().pipe(Effect.flatMap(() => effect), Effect.provide(this.#layer));
-    }
-    /** Party identity and profile APIs, backed by the network SDK. */
-    get party() {
-        if (!this.#party) {
-            throw new Error("misoPlatform: Party APIs require the complete platform deployment. Use miso({ deployment }).");
-        }
-        this.#requireReady("party APIs");
-        return this.#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. */
-    getPressing(pressingId) {
-        return this.#run(getPressing(pressingId, this.recordPackageId));
-    }
-    /** One currency's offer, or `null` if the run does not sell in it. */
-    getListing(listingId) {
-        return this.#run(getListing(listingId, this.recordShopPackageId));
-    }
-    /** One concrete purchased Record, including immutable purchase provenance. */
-    getRecord(recordId) {
-        return this.#run(getRecord(recordId, this.recordPackageId));
-    }
-    /** Run + one currency's offer in a single round trip, by address math. */
-    getSale(p) {
-        return this.#run(getSale({
-            ...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"),
-        }),
-        clearReleaseGenres: (p) => clearReleaseGenres({
-            ...p,
-            releaseGenrePackageId: this.#requiredConfig("releaseGenrePackageId", "clearReleaseGenres"),
-        }),
-        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"),
-        }),
-        setRecordingGenres: (p) => setRecordingGenres({
-            ...p,
-            recordingGenrePackageId: this.#requiredConfig("recordingGenrePackageId", "setRecordingGenres"),
-        }),
-        clearRecordingGenres: (p) => clearRecordingGenres({
-            ...p,
-            recordingGenrePackageId: this.#requiredConfig("recordingGenrePackageId", "clearRecordingGenres"),
-        }),
-    }, (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). */
-    createShareCurrency(signer, params) {
-        return this.#run(share.createShareCurrency(signer, params));
-    }
-    /** Execute a composed platform PTB only after exact-ledger validation. */
-    executeViaExecutor(executor, ...thunks) {
-        return this.ready().pipe(Effect.flatMap(() => 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, ["addGenre", "removeGenre", "clearGenres"])
-                : 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,
-            recordingGenre: this.#config.recordingGenrePackageId
-                ? bindModulePackage(recordingGenreContract, this.#config.recordingGenrePackageId, ["addGenre", "removeGenre", "clearGenres"])
-                : 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`.
+ * The registration a Promise consumer passes to `client.$extend(...)`.
  *
- * 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({ clientNetwork: client.network, deploymentNetwork: deployment.network });
-            }
-            const protocol = protocolMiso({
-                deployment: deployment.protocol,
-                graphqlClient: options.graphqlClient,
-            }).register(client);
-            return new MisoPlatformClient(client, {
-                recordSales: deployment.recordSales,
-                misoPackageId: deployment.protocol.musicos,
-                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,
-                recordingGenrePackageId: deployment.packages.recordingGenre,
-                recordingMasterReferencePackageId: deployment.packages.recordingMasterReference,
-                recordingStreamingTranscodePackageId: deployment.packages.recordingStreamingTranscode,
-                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`.
+ * ```ts
+ * const client = new SuiGrpcClient({ network: "testnet" }).$extend(miso());
+ * const pressing = await client.miso.getPressing(pressingId);
+ * const recipe = client.miso.tx.purchaseRecord({ releaseId, edition, currencyType, paymentAmount, expectedPricing, recipient });
+ * await client.miso.dispose();
+ * ```
+ *
+ * `warm` is given because `tx`/`ids`/`call`/`bcs`/`vault`/`deployment` are
+ * synchronous members a consumer may read the moment it registers, and
+ * `Miso.layer` touches no network at build for a known chain id
+ * (`docs/extensions.md` §7, "Synchronous members, `$ready` and `warm`").
+ * `options.chainId` is forwarded to both `warm` (so `register` can build
+ * synchronously without reading the chain) and `sui` (so the same id is
+ * asserted against the node) — without it on a `devnet`, `localnet`, or
+ * custom network, `warm` throws for any network outside the built-in
+ * `mainnet`/`testnet` table.
+ *
+ * `ready` stays on the service, deprecated: `await client.miso.ready()`
+ * keeps compiling and working as a `$ready()`-style warm-up for a consumer
+ * migrating off the predecessor's own `ready()` idiom (`docs/CONVERSION.md`).
  */
-export function misoPlatform(config) {
-    return {
-        name: "misoPlatform",
-        register: (client) => {
-            const configSnapshot = immutableSnapshot(config);
-            if (configSnapshot.network && configSnapshot.network !== client.network) {
-                throw new MisoNetworkMismatchError({ clientNetwork: client.network, deploymentNetwork: configSnapshot.network });
-            }
-            const protocol = configSnapshot.misoPackageId
-                ? protocolMiso({
-                    deployment: { packageId: configSnapshot.misoPackageId },
-                }).register(client)
-                : undefined;
-            return new MisoPlatformClient(client, configSnapshot, protocol);
-        },
-    };
-}
+export const miso = (options = {}) => {
+    // `options.chainId` falls back to a custom deployment's own
+    // `chainIdentifier` (B5/B6, misofm/sdks#35 verification): a caller who
+    // names a custom network's deployment, with its own `chainIdentifier`, does
+    // not also have to repeat that id via `chainId` for `warm` to build
+    // synchronously — `docs/extensions.md` §7's "thread the chain id through
+    // your registration options" applies equally to an id the deployment
+    // already carries.
+    const chainId = options.chainId ?? options.deployment?.chainIdentifier;
+    return SuiExtension.fromService(Miso, {
+        name: (options.name ?? "miso"),
+        layer: Layer.unwrap(Effect.gen(function* () {
+            const sui = yield* Sui;
+            if (options.deployment)
+                return Miso.layer(options.deployment);
+            // `getMisoPlatformDeployment` throws a plain `Error` for a network
+            // with no bundled manifest; `Effect.try` turns that into a typed
+            // `MisoPlatformDeploymentInvalidError` instead of an unhandled defect
+            // out of `Layer.unwrap` (B5, misofm/sdks#35 verification) — the same
+            // mapping `Miso.layerConfig` already applies to the same function.
+            const deployment = yield* Effect.try({
+                try: () => getMisoPlatformDeployment(sui.network),
+                catch: (cause) => new MisoPlatformDeploymentInvalidError({ message: cause instanceof Error ? cause.message : String(cause) }),
+            });
+            return Miso.layer(deployment);
+        })).pipe(Layer.provide(options.graphqlClient ? SuiGraphQL.layer(options.graphqlClient) : SuiGraphQL.layerUnavailable)),
+        ...(chainId === undefined ? {} : { sui: { chainId } }),
+        warm: { chainId },
+    });
+};
 //# sourceMappingURL=client.js.map