@misofm/platform 0.23.0 → 0.25.0

package/src/contracts/recording_engine_session/deps/ori/confidentiality.ts

@@ -0,0 +1,24 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveEnum, MoveStruct } from '../../../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+const $moduleName = 'ori::confidentiality';
+/**
+ * Confidentiality metadata for referenced data.
+ *
+ * Variants can only be constructed in this module, so encrypted values always
+ * carry a non-empty Seal-sealed data-encryption key.
+ */
+export const Confidentiality = new MoveEnum({ name: `${$moduleName}::Confidentiality`, fields: {
+        /** The referenced data is stored in the clear. */
+        Unencrypted: null,
+        /**
+         * The referenced data is encrypted. `sealed_dek` is its Seal-sealed
+         * data-encryption key, not the plaintext key.
+         */
+        Encrypted: new MoveStruct({ name: `Confidentiality.Encrypted`, fields: {
+                sealed_dek: bcs.vector(bcs.u8())
+            } })
+    } });

package/src/contracts/recording_engine_session/deps/ori/data.ts

@@ -0,0 +1,12 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../../../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import * as confidentiality from './confidentiality.ts';
+const $moduleName = 'ori::data';
+export const WalrusBlob = new MoveStruct({ name: `${$moduleName}::WalrusBlob`, fields: {
+        blob_id: bcs.u256(),
+        confidentiality: confidentiality.Confidentiality
+    } });

package/src/contracts/recording_engine_session/recording_engine_session.ts

@@ -0,0 +1,335 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * A recording administrator's pointer to the Miso Engine session for a recording:
+ * the canonical Session V1 document plus every stem it plays.
+ *
+ * The Session V1 document references each source by the SHA-256 digest of its
+ * canonical PCM (engine `STEM_IDENTITY_V1`) and carries no locator. Walrus serves
+ * blobs by blob ID. `EngineSession` therefore records, next to the session blob,
+ * one `Stem` per source pairing that digest with the standalone Walrus blob
+ * holding its FLAC delivery object. A client reads one value and can resolve every
+ * source the session names.
+ *
+ * Session and stems are one value and are replaced together: adding a source
+ * changes the document, so a new document and a new stem set land in a single
+ * `set_engine_session`. Stems are sorted by digest and unique, so the value has
+ * exactly one canonical form for a given session.
+ *
+ * Every referenced blob is unencrypted; the constructors reject encrypted
+ * confidentiality. This extension asserts only which blobs the recording
+ * administrator chose. It does not prove storage availability, document validity,
+ * that a stem decodes to its digest, or that the digests match the document's
+ * sources. Publication tooling must perform those checks before attachment.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as data_1 from './deps/ori/data.ts';
+const $moduleName = '@local-pkg/recording_engine_session::recording_engine_session';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const Stem = new MoveStruct({ name: `${$moduleName}::Stem`, fields: {
+        /**
+           * SHA-256 digest of the stem's canonical PCM serialization (engine
+           * `STEM_IDENTITY_V1`), 32 raw bytes in natural order. Equals the source's
+           * `content` identity in the Session V1 document without its `sha256:` prefix.
+           */
+        digest: bcs.vector(bcs.u8()),
+        /**
+         * Unencrypted standalone Walrus blob holding the stem's FLAC delivery object,
+         * which decodes to the PCM the digest commits to.
+         */
+        data: data_1.WalrusBlob
+    } });
+export const EngineSession = new MoveStruct({ name: `${$moduleName}::EngineSession`, fields: {
+        /**
+           * Unencrypted standalone Walrus blob holding the canonical Session V1 JSON
+           * document, byte for byte as the engine emitted it.
+           */
+        data: data_1.WalrusBlob,
+        /** Every stem the document's sources reference, sorted by digest, unique. */
+        stems: bcs.vector(Stem)
+    } });
+export const EngineSessionSetEvent = new MoveStruct({ name: `${$moduleName}::EngineSessionSetEvent`, fields: {
+        recording_id: bcs.Address,
+        session: EngineSession
+    } });
+export const EngineSessionUnsetEvent = new MoveStruct({ name: `${$moduleName}::EngineSessionUnsetEvent`, fields: {
+        recording_id: bcs.Address
+    } });
+export interface NewStemArguments {
+    digest: RawTransactionArgument<Array<number>>;
+    data: TransactionArgument;
+}
+export interface NewStemOptions {
+    package?: string;
+    arguments: NewStemArguments | [
+        digest: RawTransactionArgument<Array<number>>,
+        data: TransactionArgument
+    ];
+}
+/** Creates a stem reference from a 32-byte PCM digest and an unencrypted blob. */
+export function newStem(options: NewStemOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_engine_session';
+    const argumentsTypes = [
+        'vector<u8>',
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["digest", "data"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_engine_session',
+        function: 'new_stem',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface NewArguments {
+    data: TransactionArgument;
+    stems: TransactionArgument;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        data: TransactionArgument,
+        stems: TransactionArgument
+    ];
+}
+/**
+ * Creates an engine session from an unencrypted session blob and its stems.
+ *
+ * `stems` must be in strictly increasing digest order, which also forbids
+ * duplicates. An empty vector is valid: a Session V1 document may declare no
+ * sources.
+ */
+export function _new(options: NewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_engine_session';
+    const argumentsTypes = [
+        null,
+        'vector<null>'
+    ] satisfies (string | null)[];
+    const parameterNames = ["data", "stems"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_engine_session',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface DataArguments {
+    self: TransactionArgument;
+}
+export interface DataOptions {
+    package?: string;
+    arguments: DataArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns the unencrypted Walrus blob containing the Session V1 document. */
+export function data(options: DataOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_engine_session';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_engine_session',
+        function: 'data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface StemsArguments {
+    self: TransactionArgument;
+}
+export interface StemsOptions {
+    package?: string;
+    arguments: StemsArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns the session's stems, sorted by digest. */
+export function stems(options: StemsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_engine_session';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_engine_session',
+        function: 'stems',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface StemDigestArguments {
+    self: TransactionArgument;
+}
+export interface StemDigestOptions {
+    package?: string;
+    arguments: StemDigestArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns a stem's 32-byte canonical PCM digest. */
+export function stemDigest(options: StemDigestOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_engine_session';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_engine_session',
+        function: 'stem_digest',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface StemDataArguments {
+    self: TransactionArgument;
+}
+export interface StemDataOptions {
+    package?: string;
+    arguments: StemDataArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns the unencrypted Walrus blob holding a stem's FLAC delivery object. */
+export function stemData(options: StemDataOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_engine_session';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_engine_session',
+        function: 'stem_data',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface SetEngineSessionArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    session: TransactionArgument;
+}
+export interface SetEngineSessionOptions {
+    package?: string;
+    arguments: SetEngineSessionArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        session: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Sets or replaces the recording's Miso Engine session. */
+export function setEngineSession(options: SetEngineSessionOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_engine_session';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "session"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_engine_session',
+        function: 'set_engine_session',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface UnsetEngineSessionArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface UnsetEngineSessionOptions {
+    package?: string;
+    arguments: UnsetEngineSessionArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Removes the recording's Miso Engine session, if present. Idempotent. */
+export function unsetEngineSession(options: UnsetEngineSessionOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_engine_session';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_engine_session',
+        function: 'unset_engine_session',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasEngineSessionArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasEngineSessionOptions {
+    package?: string;
+    arguments: HasEngineSessionArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Whether a Miso Engine session is attached to the recording. */
+export function hasEngineSession(options: HasEngineSessionOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_engine_session';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_engine_session',
+        function: 'has_engine_session',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface EngineSessionArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface EngineSessionOptions {
+    package?: string;
+    arguments: EngineSessionArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** The recording's Miso Engine session. Aborts when none is attached. */
+export function engineSession(options: EngineSessionOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_engine_session';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_engine_session',
+        function: 'engine_session',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/recording_genre/recording_genre.ts

@@ -0,0 +1,235 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * The genres that classify a recording, in order with the primary first, stored as
+ * a dynamic field on the recording's UID and written through its cap-gated
+ * `uid_mut`.
+ *
+ * This is its own package on purpose. Genre is classified by different people, at
+ * different times, against a vocabulary that evolves on its own schedule — exactly
+ * the split behind `recording_advisory` and `recording_language`. A consumer
+ * implementing some future classification profile picks this extension up or
+ * ignores it, and replacing it never disturbs anything else attached to the
+ * recording.
+ *
+ * **Why the recording, and not the release.** `musicos::track`'s module doc is
+ * explicit that a `Track` embeds only facts "genuinely release-specific and not
+ * derivable from the recording" — title and cover art were excluded for exactly
+ * this reason. Genre is not release-specific: it is a fact about the audio itself,
+ * and `track::new` can be called repeatedly against one published `Recording` with
+ * different target releases, so one master can be a track on many releases at
+ * once. `Recording` holds no back-reference to any release. A per-track genre
+ * override written from the release side is therefore N independent
+ * classifications of one master, made by whichever compilation curator happens to
+ * hold that release's cap — someone who does not own the master and has no
+ * standing to assert what genre it is. The recording's own admin is the party
+ * entitled to classify it, and does so once, here.
+ *
+ * **Division of labour with `release_genre`.** Release-level genre is a separate,
+ * legitimate claim: a compilation is "Jazz" _as a product_ even when the
+ * recordings inside it are not, individually, jazz. `release_genre` keeps that
+ * product-level classification. A client resolving a track's genre should read
+ * this package first — the recording's own classification — and fall back to the
+ * release's primary genre only when the recording has none.
+ *
+ * **Shape.** One ordered `vector<ID>` of `genre::Genre` object ids, index 0 the
+ * primary, capped at `MAX_GENRES` — the house precedent is `recording_language`:
+ * "Order is the caller's: first is conventionally the predominant one." The old
+ * release-side design split a single ordered concept into `primary: ID` plus
+ * `secondary: vector<ID>`, and three of its six error codes existed only to police
+ * the boundary between the two halves — states that cannot exist in a single list.
+ * Reordering — including promoting an existing entry to primary — is
+ * `clear_genres` followed by `add_genre` in the desired order, atomically within
+ * one programmable transaction block: one fewer function to keep in lockstep with
+ * `release_genre`, no conditional-capacity branch (insert-new-at-front vs.
+ * move-existing-to-front), and the client states its intended final order directly
+ * instead of encoding it as a sequence of promotions.
+ *
+ * The stored value is a bare `vector<ID>` under the package's own key, no wrapper
+ * struct — the same choice `party_genre` makes for its `VecSet<ID>` and
+ * `recording_language` makes for its `vector<LanguageCode>`. `vector<ID>` has
+ * `drop`, so removing the field is `let _: vector<ID> = df::remove(...)` with no
+ * destructuring required.
+ *
+ * Non-empty by construction: removing the last genre drops the field, so "the
+ * field is attached" always implies "there is a primary" — there is no
+ * attached-but-empty state to special-case.
+ *
+ * Every write takes `&Genre` — a real, name-derived object from the shared
+ * vocabulary — so only ids that resolve to a genuine vocabulary entry can ever
+ * enter the list. Removal takes a bare `ID`, since the object itself is not needed
+ * to drop a reference to it.
+ *
+ * This module exposes no function derivable by composing the others. This package
+ * is never upgraded — every publish is a fresh identity at a fresh address — so
+ * every public function is permanent surface: once live, it must be carried,
+ * re-published, and re-audited for as long as the package is in use. A predicate
+ * or accessor a caller can compute from `genres()` earns nothing by also living
+ * on-chain. Concretely: emptiness is `genres(recording).is_empty()`, and the
+ * primary is `genres(recording)[0]` (valid whenever the vector is non-empty, by
+ * the non-empty-by-construction invariant above).
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/recording_genre::recording_genre';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const GenreAddedEvent = new MoveStruct({ name: `${$moduleName}::GenreAddedEvent`, fields: {
+        recording_id: bcs.Address,
+        genre_id: bcs.Address
+    } });
+export const GenreRemovedEvent = new MoveStruct({ name: `${$moduleName}::GenreRemovedEvent`, fields: {
+        recording_id: bcs.Address,
+        genre_id: bcs.Address
+    } });
+export const GenresClearedEvent = new MoveStruct({ name: `${$moduleName}::GenresClearedEvent`, fields: {
+        recording_id: bcs.Address
+    } });
+export interface AddGenreArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    genre: RawTransactionArgument<string>;
+}
+export interface AddGenreOptions {
+    package?: string;
+    arguments: AddGenreArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        genre: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Appends a genre to the recording's list. Creates the field on first use, in
+ * which case the appended genre becomes the primary. Aborts `EDuplicateGenre` if
+ * the genre is already present, `EMaxGenres` if the recording is already at
+ * capacity.
+ */
+export function addGenre(options: AddGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "genre"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_genre',
+        function: 'add_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RemoveGenreArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    genreId: RawTransactionArgument<string>;
+}
+export interface RemoveGenreOptions {
+    package?: string;
+    arguments: RemoveGenreArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        genreId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Removes a genre by id. If it was the primary, the next genre in the list becomes
+ * primary. Removing the last remaining genre drops the field entirely and
+ * additionally emits `GenresClearedEvent`. Aborts `EGenreNotPresent` if the genre
+ * is not assigned — including when nothing is attached at all.
+ */
+export function removeGenre(options: RemoveGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "genreId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_genre',
+        function: 'remove_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ClearGenresArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface ClearGenresOptions {
+    package?: string;
+    arguments: ClearGenresArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Removes the recording's entire genre list. A no-op when nothing is attached.
+ * Emits `GenresClearedEvent` only when a list was actually removed.
+ */
+export function clearGenres(options: ClearGenresOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_genre';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_genre',
+        function: 'clear_genres',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface GenresArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface GenresOptions {
+    package?: string;
+    arguments: GenresArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * The recording's genre ids in order, primary first. Empty when nothing is
+ * attached.
+ */
+export function genres(options: GenresOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_genre';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_genre',
+        function: 'genres',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

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

@@ -0,0 +1,8 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveTuple } from '../../../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+const $moduleName = 'language_code::language_code';
+export const LanguageCode = new MoveTuple({ name: `${$moduleName}::LanguageCode`, fields: [bcs.string()] });