@misofm/platform 0.0.0 → 0.18.0

package/dist/publication.js

@@ -0,0 +1,872 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Opinionated, atomic Miso catalog publication.
+ *
+ * Share packages and their registered Currency objects must already exist. This
+ * builder then creates every declared Party, Composition, Recording, Track,
+ * Release, extension, Vault plugin, Pressing, and Listing in one PTB. Share
+ * allocation is explicit: callers may preserve raw address balances or create
+ * holder Stakes, register them before a fresh pool is shared, and transfer the
+ * registered objects. Fresh raw protocol capabilities never leave the
+ * transaction: data extensions use them directly, Vault-only plugins are
+ * configured while each new Vault is still owned, and only the selected direct
+ * cap or VaultAdminCap is delivered.
+ */
+import { Transaction } from "@mysten/sui/transactions";
+import { contracts as protocolContracts, deriveCompositionAdminCapId, deriveRecordingAdminCapId, deriveReleaseAdminCapId, } from "@misofm/protocol";
+import { derivePartyAdminCapId } from "@misofm/protocol/party";
+import { requireOperationsDeployment, } from "./deployments.js";
+import { createShareStakes, disperseShares, registerShareStake, requiredCommandResult, shareRoyaltyPool, } from "./transactions.js";
+import { addRecordingPrimaryArtist, addReleaseCredit, attachCompositionCredit, attachRecordingCredit, } from "./credits.js";
+import { setRecordingAdvisory, setRecordingInstrumental, setRecordingLanguages, setRecordingMasterReference, setRecordingPreview, setRecordingStreamingTranscode, } from "./recording-extensions.js";
+import { setReleaseDescription, setReleaseDspLinks, setReleaseGenres, setReleaseKind, } from "./release-extensions.js";
+import { setReleaseCover, setReleaseTrackCover } from "./cover.js";
+import { custodyNewAdminCap, createCompositionRoutedStake, deriveVaultAdminCapId, directAdminCap, disposeNewAdminCap, installCompositionRoyaltyPoolPlugin, installRecordingRoyaltyPoolPlugin, installReleaseRevenueDistributorPlugin, invokeWithAdminCap, newCompositionRoyaltyPool, newRecordingRoyaltyPool, parseVaultCreatedEvent, registerCompositionRoutedStake, shareRoutedStake, } from "./vault.js";
+import { derivePressingAdminCapId, derivePressingId, } from "./pressing.js";
+import { requireRecordSalesDeployment } from "./deployments.js";
+import { allCreatedByType, createdByExactType } from "./execute.js";
+import * as pressingContract from "@misofm/protocol/contracts/miso_record/pressing";
+import * as listingContract from "@misofm/protocol/contracts/miso_record_shop/listing";
+const { composition, recording, release, track, party } = protocolContracts;
+export const MAX_ATOMIC_PUBLICATION_COMMANDS = 900;
+export const MAX_ATOMIC_PUBLICATION_INPUTS = 2048;
+/** Fixed protocol work-share supply: 10 million shares at six decimals. */
+const WORK_SHARE_SUPPLY = 10000000000000n;
+function requiredAt(items, index, description) {
+    const value = items[index];
+    if (value === undefined)
+        throw new Error(`${description} index ${index} is out of range`);
+    return value;
+}
+function partyCapType(p) {
+    return `${p.deployment.protocol.misoParty}::party::PartyAdminCap`;
+}
+function compositionCapType(p, shareType) {
+    return `${p.deployment.protocol.miso}::composition::CompositionAdminCap<${shareType}>`;
+}
+function recordingCapType(p, shareType) {
+    return `${p.deployment.protocol.miso}::recording::RecordingAdminCap<${shareType}>`;
+}
+function releaseCapType(p) {
+    return `${p.deployment.protocol.miso}::release::ReleaseAdminCap`;
+}
+function pressingCapType(p) {
+    return `${requireRecordSalesDeployment(p.deployment.recordSales).recordPackageId}::pressing::PressingAdminCap`;
+}
+function publicationUsesVault(p) {
+    return (p.parties.some((node) => "create" in node && node.custody.kind === "vault") ||
+        p.compositions.some((node) => node.custody.kind === "vault") ||
+        p.recordings.some((node) => node.custody.kind === "vault") ||
+        p.release?.custody.kind === "vault" ||
+        p.release?.tracks.some((node) => "authority" in node && node.authority.kind === "vault") === true ||
+        p.pressing?.custody.kind === "vault");
+}
+function operations(p) {
+    return requireOperationsDeployment(p.deployment.operations);
+}
+function custody(p, selected, capType, configure) {
+    if (selected.kind === "direct")
+        return { kind: "direct", owner: selected.owner };
+    const available = operations(p);
+    return {
+        kind: "vault",
+        owner: selected.owner,
+        vaultRegistry: available.vault.registryId,
+        capType,
+        vaultPackageId: available.vault.packageId,
+        configure,
+    };
+}
+function partyByRef(parties, ref) {
+    const value = parties.get(ref);
+    if (!value)
+        throw new Error(`Unknown publication party ref ${JSON.stringify(ref)}`);
+    return value;
+}
+function languageVector(tx, p, codes) {
+    const values = codes.map((code) => tx.moveCall({
+        target: `${p.deployment.protocol.languageCode}::language_code::new`,
+        arguments: [tx.pure.string(code)],
+    }));
+    return tx.makeMoveVec({
+        type: `${p.deployment.protocol.languageCode}::language_code::LanguageCode`,
+        elements: values,
+    });
+}
+function walrusBlob(tx, p, blobId) {
+    return tx.moveCall({
+        target: `${p.deployment.packages.ori}::walrus_data::new_blob`,
+        arguments: [tx.pure.u256(blobId)],
+    });
+}
+function listingPrice(tx, p, price) {
+    const pkg = requireRecordSalesDeployment(p.deployment.recordSales).recordShopPackageId;
+    const args = { package: pkg, arguments: [BigInt(price.amount)] };
+    return tx.add(price.kind === "fixed"
+        ? listingContract.fixed(args)
+        : listingContract.floor(args));
+}
+function publicationEdition(value) {
+    if (!Number.isInteger(value) || value <= 0 || value > 0xffff) {
+        throw new RangeError("pressing.edition must be an integer from 1 to 65535");
+    }
+    return value;
+}
+function publicationMaxSupply(value) {
+    if (value == null)
+        return null;
+    if (!Number.isInteger(value) || value <= 0 || value > 0xffff_ffff) {
+        throw new RangeError("pressing.maxSupply must be a positive u32 or null");
+    }
+    return value;
+}
+function compositionRoyaltyCut(royaltyRateBps) {
+    // Atomic publication always allocates a non-zero Recording creator remainder.
+    // Lower-level routed-stake builders remain available for Move's 100% case.
+    if (!Number.isInteger(royaltyRateBps) || royaltyRateBps <= 0 || royaltyRateBps >= 10_000) {
+        throw new RangeError("routed stake requires parent royaltyRateBps from 1 to 9999");
+    }
+    return (WORK_SHARE_SUPPLY * BigInt(royaltyRateBps)) / 10000n;
+}
+function allocatePublicationShares(tx, p, node, balance) {
+    if (node.shareDistribution !== "stake") {
+        disperseShares(tx, p.deployment.packages.minato, node.shareType, balance, node.shareRecipients);
+        return [];
+    }
+    return createShareStakes(tx, {
+        balance,
+        shareType: node.shareType,
+        recipients: node.shareRecipients,
+        royaltyPoolPackageId: p.deployment.packages.royaltyPool,
+    });
+}
+function registerPublicationStakes(tx, p, node, stakes, pool, currencyType) {
+    for (const stake of stakes) {
+        registerShareStake(tx, {
+            stake,
+            pool,
+            shareType: node.shareType,
+            currencyType,
+            royaltyPoolPackageId: p.deployment.packages.royaltyPool,
+        });
+    }
+}
+function transferPublicationStakes(tx, node, stakes) {
+    if (node.shareDistribution !== "stake") {
+        if (stakes.length !== 0)
+            throw new Error("balance distribution unexpectedly created stakes");
+        return;
+    }
+    if (stakes.length !== node.shareRecipients.length) {
+        throw new Error("publication stake count does not match share recipient count");
+    }
+    stakes.forEach((stake, index) => {
+        tx.transferObjects([stake], tx.pure.address(node.shareRecipients[index].address));
+    });
+}
+function publishComposition(tx, p, node, parts) {
+    const available = node.custody.kind === "vault" ? operations(p) : undefined;
+    const stakes = allocatePublicationShares(tx, p, node, parts.balance);
+    const typeArguments = [node.shareType];
+    if (node.custody.kind === "direct") {
+        tx.add(composition.publish({
+            package: p.deployment.protocol.miso,
+            typeArguments,
+            arguments: [parts.work, parts.adminCap],
+        }));
+        disposeNewAdminCap(tx, parts.adminCap, custody(p, node.custody, compositionCapType(p, node.shareType)));
+        transferPublicationStakes(tx, node, stakes);
+        return;
+    }
+    custodyNewAdminCap(tx, {
+        adminCap: parts.adminCap,
+        vaultRegistry: available.vault.registryId,
+        capType: compositionCapType(p, node.shareType),
+        vaultPackageId: available.vault.packageId,
+        owner: node.custody.owner,
+        configure: (vault, vaultAdminCap) => {
+            if (node.royaltyPool) {
+                installCompositionRoyaltyPoolPlugin(tx, {
+                    vault, vaultAdminCap, compositionShareType: node.shareType,
+                    pluginPackageId: available.plugins.compositionRoyaltyPool,
+                });
+                const authority = {
+                    kind: "vault", vault, vaultAdminCap,
+                    capType: compositionCapType(p, node.shareType),
+                    vaultPackageId: available.vault.packageId,
+                };
+                const poolParams = {
+                    authority, composition: parts.work,
+                    compositionShareType: node.shareType,
+                    currencyType: node.royaltyPool.currencyType,
+                    actionPackageId: available.actions.compositionRoyaltyPool,
+                };
+                const pool = newCompositionRoyaltyPool(tx, poolParams);
+                if (stakes.length > 0) {
+                    registerPublicationStakes(tx, p, node, stakes, pool, node.royaltyPool.currencyType);
+                }
+                shareRoyaltyPool(tx, {
+                    pool,
+                    shareType: node.shareType,
+                    currencyType: node.royaltyPool.currencyType,
+                    royaltyPoolPackageId: p.deployment.packages.royaltyPool,
+                });
+            }
+            invokeWithAdminCap(tx, {
+                kind: "vault", vault, vaultAdminCap,
+                capType: compositionCapType(p, node.shareType),
+                vaultPackageId: available.vault.packageId,
+            }, {
+                target: `${p.deployment.protocol.miso}::composition::publish`,
+                typeArguments,
+                arguments: [parts.work, tx.object.clock()],
+                adminCapIndex: 1,
+            });
+        },
+    });
+    transferPublicationStakes(tx, node, stakes);
+}
+function publishRecording(tx, p, node, parts, parentComposition) {
+    const available = node.custody.kind === "vault" ? operations(p) : undefined;
+    const typeArguments = [node.shareType, node.compositionShareType];
+    const stakes = allocatePublicationShares(tx, p, node, parts.balance);
+    if (node.custody.kind === "direct") {
+        tx.add(recording.publish({
+            package: p.deployment.protocol.miso,
+            typeArguments,
+            arguments: [parts.work, parts.adminCap],
+        }));
+        disposeNewAdminCap(tx, parts.adminCap, custody(p, node.custody, recordingCapType(p, node.shareType)));
+        transferPublicationStakes(tx, node, stakes);
+        return;
+    }
+    custodyNewAdminCap(tx, {
+        adminCap: parts.adminCap,
+        vaultRegistry: available.vault.registryId,
+        capType: recordingCapType(p, node.shareType),
+        vaultPackageId: available.vault.packageId,
+        owner: node.custody.owner,
+        configure: (vault, vaultAdminCap) => {
+            if (node.royaltyPool) {
+                installRecordingRoyaltyPoolPlugin(tx, {
+                    vault, vaultAdminCap,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    pluginPackageId: available.plugins.recordingRoyaltyPool,
+                });
+                const authority = {
+                    kind: "vault", vault, vaultAdminCap,
+                    capType: recordingCapType(p, node.shareType),
+                    vaultPackageId: available.vault.packageId,
+                };
+                const poolParams = {
+                    authority, recording: parts.work,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    currencyType: node.royaltyPool.currencyType,
+                    actionPackageId: available.actions.recordingRoyaltyPool,
+                };
+                const pool = newRecordingRoyaltyPool(tx, poolParams);
+                if (stakes.length > 0) {
+                    registerPublicationStakes(tx, p, node, stakes, pool, node.royaltyPool.currencyType);
+                }
+                if (node.routedStake) {
+                    if (!parentComposition)
+                        throw new Error(`${node.ref}: routed stake requires a fresh parent Composition`);
+                    const authority = directAdminCap(parentComposition.parts.adminCap);
+                    const routed = createCompositionRoutedStake(tx, {
+                        authority,
+                        composition: parentComposition.parts.work,
+                        recording: parts.work,
+                        recordingShareType: node.shareType,
+                        compositionShareType: node.compositionShareType,
+                        value: compositionRoyaltyCut(parentComposition.node.royaltyRateBps),
+                        actionPackageId: available.actions.compositionRoutedStake,
+                    });
+                    registerCompositionRoutedStake(tx, {
+                        authority,
+                        composition: parentComposition.parts.work,
+                        recording: parts.work,
+                        routedStake: routed,
+                        royaltyPool: pool,
+                        recordingShareType: node.shareType,
+                        compositionShareType: node.compositionShareType,
+                        currencyType: node.royaltyPool.currencyType,
+                        actionPackageId: available.actions.compositionRoutedStake,
+                    });
+                    shareRoutedStake(tx, {
+                        routedStake: routed,
+                        routedStakePackageId: p.deployment.packages.routedStake,
+                        stakeShareType: node.shareType,
+                        poolShareType: node.compositionShareType,
+                    });
+                }
+                shareRoyaltyPool(tx, {
+                    pool,
+                    shareType: node.shareType,
+                    currencyType: node.royaltyPool.currencyType,
+                    royaltyPoolPackageId: p.deployment.packages.royaltyPool,
+                });
+            }
+            invokeWithAdminCap(tx, {
+                kind: "vault", vault, vaultAdminCap,
+                capType: recordingCapType(p, node.shareType),
+                vaultPackageId: available.vault.packageId,
+            }, {
+                target: `${p.deployment.protocol.miso}::recording::publish`,
+                typeArguments,
+                arguments: [parts.work, tx.object.clock()],
+                adminCapIndex: 1,
+            });
+        },
+    });
+    transferPublicationStakes(tx, node, stakes);
+}
+function publishReleaseObject(tx, p, node, releaseObject, adminCap) {
+    const available = node.custody.kind === "vault" ? operations(p) : undefined;
+    if (node.custody.kind === "direct") {
+        tx.add(release.publish({
+            package: p.deployment.protocol.miso,
+            arguments: [releaseObject, adminCap],
+        }));
+        disposeNewAdminCap(tx, adminCap, custody(p, node.custody, releaseCapType(p)));
+        return;
+    }
+    custodyNewAdminCap(tx, {
+        adminCap,
+        vaultRegistry: available.vault.registryId,
+        capType: releaseCapType(p),
+        vaultPackageId: available.vault.packageId,
+        owner: node.custody.owner,
+        configure: (vault, vaultAdminCap) => {
+            if (node.revenueDistribution) {
+                installReleaseRevenueDistributorPlugin(tx, {
+                    vault, vaultAdminCap,
+                    pluginPackageId: available.plugins.releaseRevenueDistributor,
+                });
+            }
+            invokeWithAdminCap(tx, {
+                kind: "vault", vault, vaultAdminCap,
+                capType: releaseCapType(p),
+                vaultPackageId: available.vault.packageId,
+            }, {
+                target: `${p.deployment.protocol.miso}::release::publish`,
+                arguments: [releaseObject, tx.object.clock()],
+                adminCapIndex: 1,
+            });
+        },
+    });
+}
+/** Build the complete post-share catalog graph as one atomic PTB. */
+export function publishAtomicCatalog(p) {
+    if (p.recordings.some((node) => node.streamingTranscodeQuiltId !== undefined) &&
+        !p.deployment.packages.recordingStreamingTranscode) {
+        throw new Error("A recording streaming transcode requires deployment.packages.recordingStreamingTranscode");
+    }
+    if (publicationUsesVault(p)) {
+        requireOperationsDeployment(p.deployment.operations);
+    }
+    if (p.pressing) {
+        requireRecordSalesDeployment(p.deployment.recordSales);
+        if (!p.release)
+            throw new Error("A pressing requires a release");
+    }
+    for (const node of [...p.compositions, ...p.recordings]) {
+        if (node.royaltyPool && node.custody.kind !== "vault") {
+            throw new Error(`${node.ref}: permissionless royalty cranks require Vault custody`);
+        }
+    }
+    p.recordings.forEach((node) => {
+        if (!node.routedStake)
+            return;
+        if (node.parentCompositionIndex === undefined) {
+            throw new Error(`${node.ref}: routed stake requires a fresh parent Composition`);
+        }
+        if (!node.royaltyPool) {
+            throw new Error(`${node.ref}: routed stake requires a Recording royalty pool`);
+        }
+        if (node.shareDistribution !== "stake") {
+            throw new Error(`${node.ref}: routed stake requires Recording stake distribution`);
+        }
+        const parent = requiredAt(p.compositions, node.parentCompositionIndex, "parent composition");
+        if (!parent.royaltyPool) {
+            throw new Error(`${node.ref}: routed stake requires a parent Composition royalty pool`);
+        }
+        if (parent.shareDistribution !== "stake") {
+            throw new Error(`${node.ref}: routed stake requires parent Composition stake distribution`);
+        }
+        compositionRoyaltyCut(parent.royaltyRateBps);
+        if (parent.royaltyPool.currencyType !== node.royaltyPool.currencyType) {
+            throw new Error(`${node.ref}: routed stake pools must use the same currency type`);
+        }
+        if (parent.custody.kind !== "vault") {
+            throw new Error(`${node.ref}: routed stake requires parent Composition Vault custody`);
+        }
+    });
+    if (p.release?.revenueDistribution && p.release.custody.kind !== "vault") {
+        throw new Error("Release revenue distribution requires Vault custody");
+    }
+    return (tx) => {
+        const createdParties = new Map();
+        const parties = new Map();
+        for (const node of p.parties) {
+            if ("id" in node) {
+                parties.set(node.ref, tx.object(node.id));
+                continue;
+            }
+            const kind = tx.add(node.create === "group"
+                ? party.newGroupKind({ package: p.deployment.protocol.misoParty })
+                : party.newIndividualKind({ package: p.deployment.protocol.misoParty }));
+            const created = tx.add(party._new({
+                package: p.deployment.protocol.misoParty,
+                arguments: [kind, node.name],
+            }));
+            const parts = {
+                party: requiredCommandResult(created, 0, "party::new"),
+                adminCap: requiredCommandResult(created, 1, "party::new"),
+            };
+            createdParties.set(node.ref, parts);
+            parties.set(node.ref, parts.party);
+        }
+        const compositions = p.compositions.map((node) => {
+            const created = tx.add(composition._new({
+                package: p.deployment.protocol.miso,
+                typeArguments: [node.shareType],
+                arguments: [node.title, node.royaltyRateBps, node.shareCurrencyId, node.shareTreasuryCapId],
+            }));
+            return {
+                work: requiredCommandResult(created, 0, "composition::new"),
+                adminCap: requiredCommandResult(created, 1, "composition::new"),
+                balance: requiredCommandResult(created, 2, "composition::new"),
+            };
+        });
+        const recordings = p.recordings.map((node) => {
+            const parent = node.parentCompositionIndex !== undefined
+                ? requiredAt(compositions, node.parentCompositionIndex, "parent composition").work
+                : tx.object(node.parentCompositionId);
+            const created = tx.add(recording._new({
+                package: p.deployment.protocol.miso,
+                typeArguments: [node.shareType, node.compositionShareType],
+                arguments: [parent, node.shareCurrencyId, node.shareTreasuryCapId],
+            }));
+            return {
+                work: requiredCommandResult(created, 0, "recording::new"),
+                adminCap: requiredCommandResult(created, 1, "recording::new"),
+                balance: requiredCommandResult(created, 2, "recording::new"),
+            };
+        });
+        let releaseObject;
+        let releaseAdminCap;
+        if (p.release) {
+            const ids = p.release.tracks.map((node) => "recordingIndex" in node
+                ? tx.moveCall({
+                    target: "0x2::object::id",
+                    typeArguments: [`${p.deployment.protocol.miso}::recording::Recording<${p.recordings[node.recordingIndex].shareType},${p.recordings[node.recordingIndex].compositionShareType}>`],
+                    arguments: [requiredAt(recordings, node.recordingIndex, "fresh recording").work],
+                })
+                : tx.pure.id(node.recordingId));
+            const targetReleaseId = tx.moveCall({
+                target: `${p.deployment.protocol.miso}::release::derive_target_release_id`,
+                arguments: [
+                    tx.object(p.deployment.objects.releaseRegistry),
+                    tx.makeMoveVec({ type: "0x2::object::ID", elements: ids }),
+                    tx.makeMoveVec({ type: "u64", elements: p.release.tracks.map((node) => tx.pure.u64(node.splitBps)) }),
+                    tx.pure.u256(BigInt(p.release.nonce)),
+                ],
+            });
+            const tracks = p.release.tracks.map((node) => {
+                if ("recordingIndex" in node) {
+                    const recNode = requiredAt(p.recordings, node.recordingIndex, "fresh recording");
+                    const rec = requiredAt(recordings, node.recordingIndex, "fresh recording");
+                    return tx.add(track._new({
+                        package: p.deployment.protocol.miso,
+                        typeArguments: [recNode.shareType, recNode.compositionShareType],
+                        arguments: [rec.adminCap, rec.work, targetReleaseId, node.splitBps],
+                    }));
+                }
+                return invokeWithAdminCap(tx, node.authority, {
+                    target: `${p.deployment.protocol.miso}::track::new`,
+                    typeArguments: [node.recordingShareType, node.compositionShareType],
+                    arguments: [tx.object(node.recordingId), targetReleaseId, tx.pure.u16(node.splitBps)],
+                    adminCapIndex: 0,
+                });
+            });
+            const created = tx.moveCall({
+                target: `${p.deployment.protocol.miso}::release::new`,
+                arguments: [
+                    tx.object(p.deployment.objects.releaseRegistry),
+                    tx.pure.string(p.release.title),
+                    tx.makeMoveVec({ type: `${p.deployment.protocol.miso}::track::Track`, elements: tracks }),
+                    tx.pure.u256(BigInt(p.release.nonce)),
+                ],
+            });
+            releaseObject = requiredCommandResult(created, 0, "release::new");
+            releaseAdminCap = requiredCommandResult(created, 1, "release::new");
+        }
+        p.compositions.forEach((node, index) => {
+            const parts = requiredAt(compositions, index, "composition");
+            for (const credit of node.credits ?? []) {
+                attachCompositionCredit({
+                    compositionId: parts.work,
+                    authority: directAdminCap(parts.adminCap),
+                    partyId: partyByRef(parties, credit.party),
+                    displayName: credit.displayName,
+                    roles: credit.roles,
+                    compositionShareType: node.shareType,
+                    compositionCreditsPackageId: p.deployment.packages.compositionCredits,
+                    misoCreditPackageId: p.deployment.packages.credit,
+                })(tx);
+            }
+        });
+        p.recordings.forEach((node, index) => {
+            const parts = requiredAt(recordings, index, "recording");
+            const authority = directAdminCap(parts.adminCap);
+            for (const credit of node.credits ?? []) {
+                const target = partyByRef(parties, credit.party);
+                attachRecordingCredit({
+                    recordingId: parts.work, authority, partyId: target,
+                    displayName: credit.displayName, roles: credit.roles,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingCreditsPackageId: p.deployment.packages.recordingCredits,
+                    misoCreditPackageId: p.deployment.packages.credit,
+                })(tx);
+                if (credit.primaryArtist) {
+                    addRecordingPrimaryArtist({
+                        recordingId: parts.work, authority, partyId: target,
+                        recordingShareType: node.shareType,
+                        compositionShareType: node.compositionShareType,
+                        recordingCreditsPackageId: p.deployment.packages.recordingCredits,
+                    })(tx);
+                }
+            }
+            if (node.advisory)
+                setRecordingAdvisory({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingAdvisoryPackageId: p.deployment.packages.recordingAdvisory,
+                    rating: node.advisory,
+                })(tx);
+            if (node.languages?.kind === "instrumental")
+                setRecordingInstrumental({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingLanguagePackageId: p.deployment.packages.recordingLanguage,
+                })(tx);
+            if (node.languages?.kind === "languages")
+                setRecordingLanguages({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingLanguagePackageId: p.deployment.packages.recordingLanguage,
+                    languages: languageVector(tx, p, node.languages.codes),
+                })(tx);
+            if (node.masterReferenceBlobId !== undefined)
+                setRecordingMasterReference({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingMasterReferencePackageId: p.deployment.packages.recordingMasterReference,
+                    reference: walrusBlob(tx, p, node.masterReferenceBlobId),
+                })(tx);
+            if (node.streamingTranscodeQuiltId !== undefined)
+                setRecordingStreamingTranscode({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingStreamingTranscodePackageId: p.deployment.packages.recordingStreamingTranscode,
+                    oriPackageId: p.deployment.packages.ori,
+                    quiltId: node.streamingTranscodeQuiltId,
+                })(tx);
+            if (node.previewBlobId !== undefined)
+                setRecordingPreview({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingPreviewPackageId: p.deployment.packages.recordingPreview,
+                    reference: walrusBlob(tx, p, node.previewBlobId),
+                })(tx);
+        });
+        if (p.release && releaseObject && releaseAdminCap) {
+            const authority = directAdminCap(releaseAdminCap);
+            for (const credit of p.release.credits ?? [])
+                addReleaseCredit({
+                    releaseId: releaseObject, authority,
+                    partyId: partyByRef(parties, credit.party),
+                    displayName: credit.displayName, role: credit.role,
+                    releaseCreditsPackageId: p.deployment.packages.releaseCredits,
+                    misoCreditPackageId: p.deployment.packages.credit,
+                })(tx);
+            if (p.release.kind)
+                setReleaseKind({
+                    releaseId: releaseObject, authority, kind: p.release.kind,
+                    releaseKindPackageId: p.deployment.packages.releaseKind,
+                })(tx);
+            if (p.release.description)
+                setReleaseDescription({
+                    releaseId: releaseObject, authority, description: p.release.description,
+                    releaseDescriptionPackageId: p.deployment.packages.releaseDescription,
+                })(tx);
+            if (p.release.genres)
+                setReleaseGenres({
+                    releaseId: releaseObject, authority,
+                    primaryGenreId: p.release.genres.primaryGenreId,
+                    secondaryGenreIds: p.release.genres.secondaryGenreIds ?? [],
+                    trackPrimaryGenres: p.release.genres.tracks ?? [],
+                    releaseGenrePackageId: p.deployment.packages.releaseGenre,
+                })(tx);
+            if (p.release.dspLinks)
+                setReleaseDspLinks({
+                    releaseId: releaseObject, authority,
+                    releaseLinks: p.release.dspLinks.release ?? [],
+                    trackLinks: p.release.dspLinks.tracks ?? [],
+                    releaseDspLinkPackageId: p.deployment.packages.releaseDspLink,
+                })(tx);
+            if (p.release.cover?.stillBlobId !== undefined)
+                setReleaseCover({
+                    releaseId: releaseObject, authority,
+                    stillBlobId: p.release.cover.stillBlobId,
+                    animatedBlobId: p.release.cover.animatedBlobId,
+                    coverArtPackageId: p.deployment.packages.coverArt,
+                    releaseCoverArtPackageId: p.deployment.packages.releaseCoverArt,
+                    oriPackageId: p.deployment.packages.ori,
+                })(tx);
+            for (const cover of p.release.cover?.tracks ?? [])
+                setReleaseTrackCover({
+                    releaseId: releaseObject, authority,
+                    trackIndex: cover.trackIndex,
+                    stillBlobId: cover.stillBlobId,
+                    animatedBlobId: cover.animatedBlobId,
+                    coverArtPackageId: p.deployment.packages.coverArt,
+                    releaseCoverArtPackageId: p.deployment.packages.releaseCoverArt,
+                    oriPackageId: p.deployment.packages.ori,
+                })(tx);
+        }
+        let pressingParts;
+        if (p.pressing && releaseObject && releaseAdminCap) {
+            const sales = requireRecordSalesDeployment(p.deployment.recordSales);
+            const created = tx.add(pressingContract._new({
+                package: sales.recordPackageId,
+                arguments: [
+                    releaseObject,
+                    releaseAdminCap,
+                    publicationEdition(p.pressing.edition),
+                    publicationMaxSupply(p.pressing.maxSupply),
+                ],
+            }));
+            pressingParts = {
+                pressing: requiredCommandResult(created, 0, "pressing::new"),
+                adminCap: requiredCommandResult(created, 1, "pressing::new"),
+            };
+            tx.add(pressingContract.authorizeDistributor({
+                package: sales.recordPackageId,
+                typeArguments: [`${sales.recordShopPackageId}::witness::Witness`],
+                arguments: [pressingParts.pressing, pressingParts.adminCap],
+            }));
+            for (const listing of p.pressing.listings) {
+                const createdListing = tx.add(listingContract._new({
+                    package: sales.recordShopPackageId,
+                    typeArguments: [listing.currencyType],
+                    arguments: [
+                        pressingParts.pressing,
+                        pressingParts.adminCap,
+                        listingPrice(tx, p, listing.price),
+                    ],
+                }));
+                if (listing.enabled === false) {
+                    tx.add(listingContract.setState({
+                        package: sales.recordShopPackageId,
+                        typeArguments: [listing.currencyType],
+                        arguments: [
+                            createdListing,
+                            pressingParts.adminCap,
+                            tx.add(listingContract.disabled({ package: sales.recordShopPackageId })),
+                        ],
+                    }));
+                }
+                tx.add(listingContract.share({
+                    package: sales.recordShopPackageId,
+                    typeArguments: [listing.currencyType],
+                    arguments: [createdListing],
+                }));
+            }
+        }
+        p.recordings.forEach((node, index) => publishRecording(tx, p, node, requiredAt(recordings, index, "recording"), node.parentCompositionIndex === undefined
+            ? undefined
+            : {
+                node: requiredAt(p.compositions, node.parentCompositionIndex, "parent composition"),
+                parts: requiredAt(compositions, node.parentCompositionIndex, "parent composition"),
+            }));
+        p.compositions.forEach((node, index) => publishComposition(tx, p, node, requiredAt(compositions, index, "composition")));
+        if (p.release && releaseObject && releaseAdminCap) {
+            publishReleaseObject(tx, p, p.release, releaseObject, releaseAdminCap);
+        }
+        for (const node of p.parties) {
+            if ("id" in node)
+                continue;
+            const parts = createdParties.get(node.ref);
+            tx.add(party.share({
+                package: p.deployment.protocol.misoParty,
+                arguments: [parts.party, parts.adminCap],
+            }));
+            disposeNewAdminCap(tx, parts.adminCap, custody(p, node.custody, partyCapType(p)));
+        }
+        if (p.pressing && pressingParts) {
+            const sales = requireRecordSalesDeployment(p.deployment.recordSales);
+            tx.add(pressingContract.share({
+                package: sales.recordPackageId,
+                arguments: [pressingParts.pressing],
+            }));
+            disposeNewAdminCap(tx, pressingParts.adminCap, custody(p, p.pressing.custody, pressingCapType(p)));
+        }
+    };
+}
+/** Assemble without RPC access so callers can fail before publishing share packages. */
+export function inspectAtomicPublication(p) {
+    const tx = new Transaction();
+    publishAtomicCatalog(p)(tx);
+    const data = tx.getData();
+    return { commands: data.commands.length, inputs: data.inputs.length };
+}
+export function assertAtomicPublicationBounds(p) {
+    const inspection = inspectAtomicPublication(p);
+    if (inspection.commands > MAX_ATOMIC_PUBLICATION_COMMANDS) {
+        throw new Error(`Atomic publication requires ${inspection.commands} commands; the SDK safety cap is ` +
+            `${MAX_ATOMIC_PUBLICATION_COMMANDS} (Sui permits at most 1024).`);
+    }
+    if (inspection.inputs > MAX_ATOMIC_PUBLICATION_INPUTS) {
+        throw new Error(`Atomic publication requires ${inspection.inputs} inputs; Sui permits at most ` +
+            `${MAX_ATOMIC_PUBLICATION_INPUTS}.`);
+    }
+    return inspection;
+}
+function compactType(type) {
+    return type.replace(/\s+/g, "");
+}
+function findByShareType(created, shareType, description) {
+    const wanted = compactType(shareType);
+    const matches = created.filter((item) => compactType(item.objectType).includes(wanted));
+    if (matches.length !== 1)
+        throw new Error(`Expected one ${description} for ${shareType}; found ${matches.length}`);
+    return matches[0].objectId;
+}
+function vaultsByCap(result, vaultPackageId) {
+    const out = new Map();
+    for (const event of result.events) {
+        if (!event.eventType.includes("::vault::VaultCreatedEvent<"))
+            continue;
+        const parsed = parseVaultCreatedEvent(event.bcs);
+        out.set(parsed.cap_id, {
+            vaultId: parsed.vault_id,
+            vaultAdminCapId: deriveVaultAdminCapId(parsed.vault_id, vaultPackageId),
+        });
+    }
+    return out;
+}
+function authorityOut(result, vaults, selected, adminCapId, capType, vaultPackageId) {
+    if (selected.kind === "direct")
+        return { kind: "direct", adminCapId };
+    const found = vaults.get(adminCapId);
+    if (!found)
+        throw new Error(`No VaultCreatedEvent for admin cap ${adminCapId} in ${result.digest}`);
+    return { kind: "vault", ...found, capType, vaultPackageId };
+}
+/** Parse one atomic publication using type identity plus lifecycle event payloads. */
+export function parseAtomicPublicationResult(p, result) {
+    const available = publicationUsesVault(p) ? operations(p) : undefined;
+    const vaultPackageId = available?.vault.packageId ?? "";
+    const vaults = available
+        ? vaultsByCap(result, vaultPackageId)
+        : new Map();
+    const createdCompositions = allCreatedByType(result, "::composition::Composition<");
+    const createdRecordings = allCreatedByType(result, "::recording::Recording<");
+    const createdPools = allCreatedByType(result, "::pool::RoyaltyPool<");
+    const createdPartyNodes = p.parties.filter((node) => "create" in node);
+    const partyEvents = result.events.filter((event) => event.eventType.endsWith("::party::PartyCreatedEvent"));
+    if (partyEvents.length !== createdPartyNodes.length) {
+        throw new Error(`Expected ${createdPartyNodes.length} PartyCreatedEvent values; found ${partyEvents.length}`);
+    }
+    const parties = {};
+    for (const node of p.parties) {
+        if ("id" in node) {
+            parties[node.ref] = {
+                id: node.id,
+                adminCapId: derivePartyAdminCapId(node.id, p.deployment.protocol.misoParty),
+                created: false,
+            };
+        }
+    }
+    createdPartyNodes.forEach((node, index) => {
+        const event = partyEvents[index];
+        const parsed = protocolContracts.party.PartyCreatedEvent.parse(event.bcs);
+        const adminCapId = derivePartyAdminCapId(parsed.party_id, p.deployment.protocol.misoParty);
+        parties[node.ref] = {
+            id: parsed.party_id,
+            adminCapId,
+            created: true,
+            authority: authorityOut(result, vaults, node.custody, adminCapId, partyCapType(p), vaultPackageId),
+        };
+    });
+    const compositions = {};
+    p.compositions.forEach((node) => {
+        const id = findByShareType(createdCompositions, node.shareType, "Composition");
+        const adminCapId = deriveCompositionAdminCapId(id, p.deployment.protocol.miso);
+        compositions[node.ref] = {
+            id,
+            adminCapId,
+            shareType: node.shareType,
+            authority: authorityOut(result, vaults, node.custody, adminCapId, compositionCapType(p, node.shareType), vaultPackageId),
+            royaltyPoolId: node.royaltyPool ? findByShareType(createdPools, node.shareType, "Composition RoyaltyPool") : undefined,
+        };
+    });
+    const recordings = {};
+    p.recordings.forEach((node) => {
+        const id = findByShareType(createdRecordings, node.shareType, "Recording");
+        const adminCapId = deriveRecordingAdminCapId(id, p.deployment.protocol.miso);
+        recordings[node.ref] = {
+            id,
+            adminCapId,
+            shareType: node.shareType,
+            compositionShareType: node.compositionShareType,
+            authority: authorityOut(result, vaults, node.custody, adminCapId, recordingCapType(p, node.shareType), vaultPackageId),
+            royaltyPoolId: node.royaltyPool ? findByShareType(createdPools, node.shareType, "Recording RoyaltyPool") : undefined,
+            routedStakeId: node.routedStake
+                ? createdByExactType(result, `${p.deployment.packages.routedStake}::routed_stake::RoutedStake<${node.shareType},${node.compositionShareType}>`)
+                : undefined,
+        };
+    });
+    let releaseOut;
+    if (p.release) {
+        const id = createdByExactType(result, `${p.deployment.protocol.miso}::release::Release`);
+        const adminCapId = deriveReleaseAdminCapId(id, p.deployment.protocol.miso);
+        releaseOut = {
+            id,
+            adminCapId,
+            authority: authorityOut(result, vaults, p.release.custody, adminCapId, releaseCapType(p), vaultPackageId),
+        };
+    }
+    let pressingOut;
+    if (p.pressing && releaseOut) {
+        const sales = requireRecordSalesDeployment(p.deployment.recordSales);
+        const id = derivePressingId(releaseOut.id, p.pressing.edition, sales.recordPackageId);
+        const adminCapId = derivePressingAdminCapId(id, sales.recordPackageId);
+        pressingOut = {
+            id,
+            adminCapId,
+            authority: authorityOut(result, vaults, p.pressing.custody, adminCapId, pressingCapType(p), vaultPackageId),
+        };
+    }
+    return {
+        digest: result.digest,
+        gasUsed: result.gasUsed,
+        parties,
+        compositions,
+        recordings,
+        release: releaseOut,
+        pressing: pressingOut,
+    };
+}
+//# sourceMappingURL=publication.js.map