@misofm/platform 0.27.0 → 0.28.0

package/src/read/catalog.ts

@@ -10,7 +10,7 @@
 // credits → recordings); the same work happens once here, inside one datacenter,
 // and every subsequent visitor is served from cache.
 
-import { Effect } from "effect";
+import { Effect, Result } from "effect";
 import {
   deriveListingId,
   getListing,
@@ -45,17 +45,19 @@ import {
   type RecordingEngineSessionView,
 } from "../recording-extensions.ts";
 import { getTrackCreditsByRecordingIds } from "../catalog.ts";
-import { getReleaseById, getReleasesByIds } from "@misofm/musicos";
+import { Musicos, type MusicosDeploymentInvalid, type MusicosService, type MusicosWorkNotFound, type ReadError } from "@misofm/musicos";
 import type { Release } from "@misofm/musicos";
 import {
-  getObjectsContent,
-  ObjectTypeMismatchError,
-  type BcsDecodeError,
-  type ObjectNotFoundError,
-  type SuiClient,
-  type SuiGraphQL,
-  type SuiRpcError,
-} from "@misofm/effect";
+  DecodeError,
+  ObjectId,
+  Sui,
+  SuiGraphQL,
+  type BatchItemError,
+  type GraphQLUnavailable,
+  type ObjectDeleted,
+  type ObjectUnavailable,
+  type TransportError,
+} from "@unconfirmed/sui-effect";
 import { ReleaseNotFoundError } from "../errors.ts";
 import type { MisoConfig } from "./config.ts";
 import { getRecordingTitles, parseReleaseObject } from "./works.ts";
@@ -85,6 +87,21 @@ import type {
   WorkState,
 } from "./types.ts";
 
+/**
+ * Builds `Musicos.layer({ deployment: { packageId } })`, provides it, and
+ * hands back the effect it wraps — see `../catalog.ts`'s `withMusicos` for
+ * the same idiom (kept file-local; see `docs/CONVERSION-STATUS.md`).
+ */
+function withMusicos<A, E>(
+  packageId: string,
+  effect: (musicos: MusicosService) => Effect.Effect<A, E, Sui>,
+): Effect.Effect<A, E | MusicosDeploymentInvalid, Sui> {
+  return Effect.gen(function* () {
+    const musicos = yield* Musicos;
+    return yield* effect(musicos);
+  }).pipe(Effect.provide(Musicos.layer({ deployment: { packageId } })));
+}
+
 // ── Walrus URLs ──────────────────────────────────────────────────────────────
 
 /** Aggregator URL for a cover image ref (a standalone Walrus blob). */
@@ -165,7 +182,7 @@ function toSaleView(
 export const getPressingView = Effect.fn("getPressingView")(function* (
   pressingId: string,
   config: MisoConfig,
-): Effect.fn.Return<PressingView | null, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
+): Effect.fn.Return<PressingView | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
   const sales = requireRecordSalesDeployment(config.recordSales);
   const pressing = yield* getPressing(pressingId, sales.recordPackageId);
   return pressing ? toPressingView(pressing) : null;
@@ -176,7 +193,7 @@ export const getListingView = Effect.fn("getListingView")(function* (
   pressingId: string,
   currencyType: string,
   config: MisoConfig,
-): Effect.fn.Return<ListingView | null, ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
+): Effect.fn.Return<ListingView | null, DecodeError | ObjectUnavailable | TransportError, Sui> {
   const sales = requireRecordSalesDeployment(config.recordSales);
   const listingId = deriveListingId(pressingId, currencyType, sales.recordShopPackageId);
   const listing = yield* getListing(listingId, sales.recordShopPackageId);
@@ -262,7 +279,7 @@ function toTrackEngineSession(view: RecordingEngineSessionView): TrackEngineSess
 export const readReleaseCover = Effect.fn("readReleaseCover")(function* (
   releaseId: string,
   config: MisoConfig,
-): Effect.fn.Return<Cover | null, never, SuiClient> {
+): Effect.fn.Return<Cover | null, never, Sui> {
   const { releaseCoverArt } = config.protocol;
   const covers = yield* getReleaseCoversByIds([releaseId], releaseCoverArt).pipe(
     Effect.catch(() => Effect.succeed({} as Partial<Record<string, ReleaseCoverView>>)),
@@ -280,15 +297,15 @@ export interface ReleaseResources {
 }
 
 /**
- * A release plus selected derived resources in one heterogeneous Core batch.
- * Every extension id is deterministic, so separate object calls only add
- * network round trips without discovering anything new.
+ * A release plus selected derived resources in one heterogeneous chunked
+ * `sui.getObjects`. Every extension id is deterministic, so separate object
+ * calls only add network round trips without discovering anything new.
  */
 export const getReleaseResources = Effect.fn("getReleaseResources")(function* (
   releaseId: string,
   config: MisoConfig,
   include: readonly ReleaseResourceInclude[] = [],
-): Effect.fn.Return<ReleaseResources, ReleaseNotFoundError | BcsDecodeError | SuiRpcError, SuiClient> {
+): Effect.fn.Return<ReleaseResources, ReleaseNotFoundError | DecodeError | TransportError, Sui> {
   const wantsCover = include.includes("cover");
   const wantsCredits = include.includes("credits");
   const wantsKind = include.includes("kind");
@@ -301,7 +318,11 @@ export const getReleaseResources = Effect.fn("getReleaseResources")(function* (
     ...(creditsFieldId ? [creditsFieldId] : []),
     ...(kindFieldId ? [kindFieldId] : []),
   ];
-  const contentById = yield* getObjectsContent(objectIds);
+  const sui = yield* Sui;
+  const results = yield* sui.getObjects(objectIds.map((id) => ObjectId.make(id)));
+  const contentById = new Map(
+    results.flatMap((result, index) => (Result.isSuccess(result) ? [[objectIds[index]!, result.success] as const] : [])),
+  );
 
   const releaseFound = contentById.get(releaseId);
   if (!releaseFound) return yield* new ReleaseNotFoundError({ releaseId });
@@ -368,7 +389,7 @@ export const getReleaseDetail = Effect.fn("getReleaseDetail")(function* (
   releaseId: string,
   config: MisoConfig,
   options: GetReleaseOptions = {},
-): Effect.fn.Return<ReleaseDetail, ReleaseNotFoundError | BcsDecodeError | SuiRpcError, SuiClient | SuiGraphQL> {
+): Effect.fn.Return<ReleaseDetail, ReleaseNotFoundError | DecodeError | BatchItemError | GraphQLUnavailable | MusicosWorkNotFound | TransportError, Sui | SuiGraphQL> {
   const { release, cover, credits, kind } = yield* getReleaseResources(releaseId, config, [
     "cover",
     "credits",
@@ -429,7 +450,7 @@ export const getReleaseDetail = Effect.fn("getReleaseDetail")(function* (
 const getTrackCreditsForRecordingIds = Effect.fn("getTrackCreditsForRecordingIds")(function* (
   recordingIds: readonly string[],
   config: MisoConfig,
-): Effect.fn.Return<Record<string, TrackCredits>, SuiRpcError | BcsDecodeError, SuiClient | SuiGraphQL> {
+): Effect.fn.Return<Record<string, TrackCredits>, BatchItemError | GraphQLUnavailable | MusicosWorkNotFound | TransportError, Sui | SuiGraphQL> {
   const { compositionCredits, recordingCredits } = config.protocol;
   const tracks = yield* getTrackCreditsByRecordingIds(recordingIds, {
     misoPackageId: config.deployment.musicos,
@@ -459,8 +480,12 @@ const getTrackCreditsForRecordingIds = Effect.fn("getTrackCreditsForRecordingIds
 export const getTrackCredits = Effect.fn("getTrackCredits")(function* (
   releaseId: string,
   config: MisoConfig,
-): Effect.fn.Return<Record<string, TrackCredits>, ObjectNotFoundError | SuiRpcError | BcsDecodeError, SuiClient | SuiGraphQL> {
-  const release = yield* getReleaseById(releaseId);
+): Effect.fn.Return<
+  Record<string, TrackCredits>,
+  ReadError | MusicosDeploymentInvalid | MusicosWorkNotFound | BatchItemError | GraphQLUnavailable | TransportError,
+  Sui | SuiGraphQL
+> {
+  const release = yield* withMusicos(config.deployment.musicos, (musicos) => musicos.getReleaseById(ObjectId.make(releaseId)));
   const recordingIds = release.tracks.map((track) => track.recordingId);
   return yield* getTrackCreditsForRecordingIds(recordingIds, config);
 });
@@ -474,8 +499,8 @@ export const getPressingDetail = Effect.fn("getPressingDetail")(function* (
   options: GetReleaseOptions = {},
 ): Effect.fn.Return<
   PressingDetail | null,
-  ObjectTypeMismatchError | ReleaseNotFoundError | BcsDecodeError | SuiRpcError,
-  SuiClient | SuiGraphQL
+  DecodeError | ReleaseNotFoundError | MusicosWorkNotFound | BatchItemError | GraphQLUnavailable | TransportError,
+  Sui | SuiGraphQL
 > {
   const pressing = yield* getPressingView(pressingId, config);
   if (!pressing) return null;
@@ -495,8 +520,8 @@ export const getPressingSaleDetail = Effect.fn("getPressingSaleDetail")(function
   options: GetReleaseOptions = {},
 ): Effect.fn.Return<
   SaleDetail | null,
-  ObjectTypeMismatchError | ReleaseNotFoundError | BcsDecodeError | SuiRpcError,
-  SuiClient | SuiGraphQL
+  DecodeError | ReleaseNotFoundError | MusicosWorkNotFound | BatchItemError | GraphQLUnavailable | TransportError,
+  Sui | SuiGraphQL
 > {
   const pressing = yield* getPressingView(pressingId, config);
   if (!pressing) return null;
@@ -519,8 +544,8 @@ export const getPressingPreview = Effect.fn("getPressingPreview")(function* (
   config: MisoConfig,
 ): Effect.fn.Return<
   PressingPreview | null,
-  ObjectTypeMismatchError | ReleaseNotFoundError | BcsDecodeError | SuiRpcError,
-  SuiClient
+  DecodeError | ObjectUnavailable | ReleaseNotFoundError | TransportError,
+  Sui
 > {
   const pressing = yield* getPressingView(pressingId, config);
   if (!pressing) return null;
@@ -552,8 +577,8 @@ export const getSaleDetail = Effect.fn("getSaleDetail")(function* (
   options: GetReleaseOptions = {},
 ): Effect.fn.Return<
   SaleDetail | null,
-  ObjectTypeMismatchError | ReleaseNotFoundError | BcsDecodeError | SuiRpcError,
-  SuiClient | SuiGraphQL
+  DecodeError | ObjectDeleted | ObjectUnavailable | ReleaseNotFoundError | MusicosWorkNotFound | BatchItemError | GraphQLUnavailable | TransportError,
+  Sui | SuiGraphQL
 > {
   const sales = requireRecordSalesDeployment(config.recordSales);
   const sale = yield* getSale({
@@ -577,7 +602,11 @@ export const getSaleDetail = Effect.fn("getSaleDetail")(function* (
  */
 export const getDiscoverShelf = Effect.fn("getDiscoverShelf")(function* (
   config: MisoConfig,
-): Effect.fn.Return<DiscoverItem[], ObjectTypeMismatchError | BcsDecodeError | SuiRpcError, SuiClient> {
+): Effect.fn.Return<
+  DiscoverItem[],
+  DecodeError | ObjectDeleted | ObjectUnavailable | MusicosDeploymentInvalid | TransportError,
+  Sui
+> {
   const configuredSales = [...config.discoverSales];
   const sales = requireRecordSalesDeployment(config.recordSales);
   const settled = yield* Effect.forEach(
@@ -598,8 +627,8 @@ export const getDiscoverShelf = Effect.fn("getDiscoverShelf")(function* (
   const releaseIds = [...new Set(available.map((item) => item.result.pressing.releaseId))];
   if (releaseIds.length === 0) return [];
 
-  const [releases, coverViews, credits] = yield* Effect.all([
-    getReleasesByIds(releaseIds),
+  const [releaseResults, coverViews, credits] = yield* Effect.all([
+    withMusicos(config.deployment.musicos, (musicos) => musicos.getReleasesByIds(releaseIds.map((id) => ObjectId.make(id)))),
     getReleaseCoversByIds(releaseIds, config.protocol.releaseCoverArt).pipe(
       Effect.catch(() => Effect.succeed({} as Partial<Record<string, ReleaseCoverView>>)),
     ),
@@ -607,10 +636,13 @@ export const getDiscoverShelf = Effect.fn("getDiscoverShelf")(function* (
       Effect.catch(() => Effect.succeed({} as Partial<Record<string, CreditView[]>>)),
     ),
   ]);
+  const releases = new Map(
+    releaseResults.flatMap((result, index) => (Result.isSuccess(result) ? [[releaseIds[index]!, result.success] as const] : [])),
+  );
 
   return available.flatMap(({ result }) => {
     const releaseId = result.pressing.releaseId;
-    const release = releases[releaseId];
+    const release = releases.get(releaseId);
     if (!release) return [];
     const cover = toCover(config.walrusAggregatorUrl, coverViews[releaseId] ?? null);
     return [
@@ -645,8 +677,8 @@ export const getRecordAlbum = Effect.fn("getRecordAlbum")(function* (
   options: GetRecordAlbumOptions = {},
 ): Effect.fn.Return<
   RecordAlbum | null,
-  ObjectTypeMismatchError | ReleaseNotFoundError | BcsDecodeError | SuiRpcError,
-  SuiClient | SuiGraphQL
+  DecodeError | ObjectUnavailable | ReleaseNotFoundError | MusicosWorkNotFound | BatchItemError | GraphQLUnavailable | TransportError,
+  Sui | SuiGraphQL
 > {
   const sales = requireRecordSalesDeployment(config.recordSales);
   const record = yield* getRecord(recordId, sales.recordPackageId);

package/src/read/client.ts

@@ -12,45 +12,43 @@
 //
 // It also carries the resolved `MisoConfig`, so a read function takes ONE argument
 // and never has a package id threaded through its signature.
-//
-// Party now shares the same network SDK registration and deployment as protocol
-// core, so every read hangs off one `sui.miso` namespace.
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
 import { SuiGrpcClient } from "@mysten/sui/grpc";
 import { SuiGraphQLClient } from "@mysten/sui/graphql";
-import { miso, type MisoProtocolClient } from "@misofm/musicos/client";
-import { PartyosClient } from "@misofm/partyos";
-import { PartyPlatformClient } from "../party/index.ts";
+import { Layer } from "effect";
+import { Sui, SuiCore, SuiGraphQL, type NetworkMismatch, type TransportError } from "@unconfirmed/sui-effect";
+import { miso, type MisoClient as MisoExtensionClient } from "../client.ts";
+import { Miso, type MisoLayerError } from "../Miso.ts";
+import { getMisoPlatformDeployment, type MisoPlatformDeployment } from "../deployments.ts";
 import { misoConfig, networkFrom, type MisoConfig, type MisoConfigOverrides, type Network } from "./config.ts";
 
 function definedOverrides<T extends object>(value: T): Partial<T> {
   return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined)) as Partial<T>;
 }
 
-/**
- * The transport slice every `@misofm/platform/read` function needs to run its
- * `Effect`: `Effect.provide(SuiClient.layer(client.protocol))`. `sui` (below)
- * satisfies this structurally, since it is a real `ClientWithCoreApi`.
- */
-export type ProtocolClient = ClientWithCoreApi;
-
-/** A GraphQL client in the shape `@misofm/effect`'s `SuiGraphQL` service wants. */
-export type ProtocolGraphQLClient = SuiGraphQLClient;
-
 export interface MisoClient {
   config: MisoConfig;
-  /** gRPC data plane (object-model core only; Party is `client.party`). */
-  sui: SuiGrpcClient & { miso: MisoProtocolClient };
-  /** The same client, for `Effect.provide(SuiClient.layer(client.protocol))`. */
-  protocol: ProtocolClient;
+  /** gRPC data plane. */
+  sui: SuiGrpcClient;
   /** GraphQL RPC, for `Effect.provide(SuiGraphQL.layer(client.graphql))`. */
-  graphql: ProtocolGraphQLClient;
+  graphql: SuiGraphQLClient;
   /** The raw GraphQL client — identical to `graphql`; both names are kept for
    * source compatibility with callers migrating from the pre-Effect client. */
   graphqlRaw: SuiGraphQLClient;
-  /** Party identity and profile reads/builders, bound to `config.partyos`/`config.party`. */
-  party: PartyPlatformClient;
+  /**
+   * The `client.$extend(miso({ deployment, graphqlClient }))` face — the
+   * documented app-edge entry point for a Promise consumer: `client.miso.*`.
+   */
+  client: SuiGrpcClient & { readonly miso: MisoExtensionClient };
+  /**
+   * `Miso | Sui | SuiCore | SuiGraphQL`, ready to provide to an Effect
+   * consumer that wants `yield* Miso` directly (the read service) instead of
+   * going through the Promise face — or to any of this package's standalone
+   * `read/*` functions, which only ever need the narrower `Sui | SuiGraphQL`
+   * a superset layer still satisfies:
+   * `Effect.provide(getReleaseDetail(id, config), client.layer)`.
+   */
+  layer: Layer.Layer<Miso | Sui | SuiCore | SuiGraphQL, MisoLayerError | NetworkMismatch | TransportError>;
 }
 
 export interface CreateMisoClientOptions extends MisoConfigOverrides {
@@ -58,13 +56,30 @@ export interface CreateMisoClientOptions extends MisoConfigOverrides {
   network?: Network | string;
   /** Complete verified configuration for a custom or unbundled deployment. */
   config?: MisoConfig;
+  /**
+   * The complete deployment `Miso`/`client.miso` build from. Defaults to the
+   * bundled manifest for `network` — required alongside a custom `config` on
+   * a network with no bundled entry, since `MisoConfig` alone (a package-id
+   * subset) cannot reconstruct the `operations`/`packages` sections
+   * `Miso.layer` needs.
+   */
+  deployment?: MisoPlatformDeployment;
+  /**
+   * The chain identifier the node must report — forwarded to both the
+   * standalone `layer` (`Sui.layerNoDepsWith({ chainId })`) and `client.miso`
+   * (`miso({ chainId })`), so the two transports this client builds (and the
+   * warm registration on `devnet`/`localnet`/a custom network) agree on the
+   * same pinned id rather than each asserting independently. Omit on
+   * `mainnet`/`testnet`, where both already have a built-in default.
+   */
+  chainId?: string;
 }
 
 /**
  * Build the client from a bundled network or a complete verified custom config.
  */
 export function createMisoClient(options: CreateMisoClientOptions = {}): MisoClient {
-  const { network, config: providedConfig, ...overrides } = options;
+  const { network, config: providedConfig, deployment: providedDeployment, chainId, ...overrides } = options;
   const requestedNetwork = networkFrom(network);
   // A caller-supplied verified deployment may still override transport URLs or
   // the discover shelf; undefined fields never erase verified config values.
@@ -76,19 +91,29 @@ export function createMisoClient(options: CreateMisoClientOptions = {}): MisoCli
       `@misofm/platform/read: provided config is for ${config.network}, not ${requestedNetwork}.`,
     );
   }
+  const deployment = providedDeployment ?? getMisoPlatformDeployment(requestedNetwork);
 
-  const grpc = new SuiGrpcClient({ baseUrl: config.grpcUrl, network: config.network });
+  const sui = new SuiGrpcClient({ baseUrl: config.grpcUrl, network: config.network });
   const graphqlRaw = new SuiGraphQLClient({ url: config.graphqlUrl, network: config.network });
 
-  const sui = grpc.$extend(miso({ deployment: config.deployment }));
-  const party = new PartyPlatformClient(sui, new PartyosClient(sui, config.partyos), config.party);
+  // Reuse the one gRPC client instance `client` itself extends below —
+  // `SuiCore.layerFromClient(sui)`, not a second `SuiCore.layerGrpc(...)`
+  // transport pointed at the same endpoint (C item, misofm/sdks#35
+  // verification): an Effect consumer using `layer` and a Promise consumer
+  // using `client` then share one connection, not two.
+  const suiLayer = chainId !== undefined ? Sui.layerNoDepsWith({ chainId }) : Sui.layerNoDeps;
+  const suiPlusCore = suiLayer.pipe(Layer.provideMerge(SuiCore.layerFromClient(sui)));
+  const base = Layer.merge(suiPlusCore, SuiGraphQL.layer(graphqlRaw));
+  const layer = Miso.layer(deployment).pipe(Layer.provideMerge(base));
+
+  const client = sui.$extend(miso({ deployment, graphqlClient: graphqlRaw, chainId }));
 
   return {
     config,
     sui,
-    protocol: sui,
     graphql: graphqlRaw,
     graphqlRaw,
-    party,
+    client,
+    layer,
   };
 }

package/src/read/config.ts

@@ -13,7 +13,7 @@
 
 import type { MisoDeployment } from "@misofm/musicos/deployments";
 import type { PartyDeployment } from "@misofm/partyos/deployments";
-import { getMisoPlatformDeployment, type PartyExtensionsDeployment, type RecordSalesDeployment } from "../deployments.ts";
+import { getMisoPlatformDeployment, type MisoPlatformDeployment, type PartyExtensionsDeployment, type RecordSalesDeployment } from "../deployments.ts";
 import { walrusAggregatorUrl } from "../walrus.ts";
 
 export type Network = "testnet" | "mainnet";
@@ -27,8 +27,17 @@ export function networkFrom(value: string | undefined): Network {
 
 /** Package ids for the miso protocol core and the extensions the read layer touches. */
 export interface ProtocolIds {
-  /** `vault` — shared custody for protocol admin capabilities. */
-  vault: string;
+  /**
+   * `vault` — shared custody for protocol admin capabilities, or `null` when
+   * this deployment's `operations` is unavailable AND carries no
+   * `legacy.vaultPackageId` fallback (misofm/sdks#35 verification, B1). A
+   * `MisoConfig` in that shape is still fully constructible; only the two
+   * `read/wallet.ts` members that classify a vaulted work admin cap
+   * (`getOwnedWorks`, `getWorkByCap`) fail typed `OperationsUnavailableError`
+   * when they actually need this field and find it `null` — every other
+   * `read.*` member is unaffected.
+   */
+  vault: string | null;
   /** `release_cover_art` — the release cover extension. */
   releaseCoverArt: string;
   /** `release_kind` — the Release's optional self-declared kind. */
@@ -100,38 +109,49 @@ export type MisoConfigOverrides = Partial<
   Pick<MisoConfig, "grpcUrl" | "graphqlUrl" | "walrusAggregatorUrl" | "apiBaseUrl" | "discoverSales">
 >;
 
-/** The config for `network`, derived from this SDK's verified deployment map. */
-export function misoConfig(network: Network, overrides: MisoConfigOverrides = {}): MisoConfig {
-  const platform = getMisoPlatformDeployment(network);
+/**
+ * The config for a complete `MisoPlatformDeployment` — the same manifest
+ * `Miso.layer(deployment)` builds the service from — so `Miso`'s bound
+ * `read.*` namespace (misofm/sdks#35, WP6) and `misoConfig` share one
+ * derivation instead of two.
+ *
+ * TODO: `money`/`grpcUrl`/`graphqlUrl`/`apiBaseUrl` are still the fixed
+ * Testnet-shaped defaults the predecessor `misoConfig` hard-coded regardless
+ * of `deployment.network` (a pre-existing gap this stage's facade-derivation
+ * scope does not extend to fixing — see `docs/CONVERSION.md`); pass
+ * `overrides` for a Mainnet or custom deployment's real endpoints today.
+ */
+export function configFromDeployment(deployment: MisoPlatformDeployment, overrides: MisoConfigOverrides = {}): MisoConfig {
+  // No current-or-legacy Vault package id is a real, expected deployment
+  // shape (an `operations: { status: "unavailable" }` deployment with no
+  // `legacy.vaultPackageId` fallback) — `vault: null` here, not a thrown
+  // error, so this function (and therefore `Miso.layer`, which calls it
+  // unconditionally to bind `read.*`) always succeeds for a structurally
+  // valid deployment. B1, misofm/sdks#35 verification: see `ProtocolIds.vault`.
   const vaultPackageId =
-    platform.operations.status === "available"
-      ? platform.operations.vault.packageId
-      : platform.operations.legacy?.vaultPackageId;
-  if (!vaultPackageId) {
-    throw new Error(
-      `@misofm/platform/read: no current or legacy Vault type metadata for "${network}".`,
-    );
-  }
+    (deployment.operations.status === "available"
+      ? deployment.operations.vault.packageId
+      : deployment.operations.legacy?.vaultPackageId) ?? null;
   const config: MisoConfig = {
-    network,
-    deployment: platform.protocol,
-    partyos: platform.partyos,
-    party: platform.party,
-    recordSales: platform.recordSales,
+    network: deployment.network,
+    deployment: deployment.protocol,
+    partyos: deployment.partyos,
+    party: deployment.party,
+    recordSales: deployment.recordSales,
     protocol: {
       // Read-only legacy type discovery does not make this package an
       // executable operations ABI; client call surfaces remain fail closed.
       vault: vaultPackageId,
-      releaseCoverArt: platform.packages.releaseCoverArt,
-      releaseKind: platform.packages.releaseKind,
-      recordingMasterReference: platform.packages.recordingMasterReference,
-      recordingStreamingTranscode: platform.packages.recordingStreamingTranscode ?? null,
-      recordingEngineSession: platform.packages.recordingEngineSession ?? null,
-      compositionCredits: platform.packages.compositionCredits,
-      recordingCredits: platform.packages.recordingCredits,
-      releaseCredits: platform.packages.releaseCredits,
-      credit: platform.packages.credit,
-      royaltyPool: platform.packages.royaltyPool,
+      releaseCoverArt: deployment.packages.releaseCoverArt,
+      releaseKind: deployment.packages.releaseKind,
+      recordingMasterReference: deployment.packages.recordingMasterReference,
+      recordingStreamingTranscode: deployment.packages.recordingStreamingTranscode ?? null,
+      recordingEngineSession: deployment.packages.recordingEngineSession ?? null,
+      compositionCredits: deployment.packages.compositionCredits,
+      recordingCredits: deployment.packages.recordingCredits,
+      releaseCredits: deployment.packages.releaseCredits,
+      credit: deployment.packages.credit,
+      royaltyPool: deployment.packages.royaltyPool,
     },
     money: {
       usdCoinType:
@@ -140,13 +160,18 @@ export function misoConfig(network: Network, overrides: MisoConfigOverrides = {}
     },
     grpcUrl: "https://fullnode.testnet.sui.io",
     graphqlUrl: "https://graphql.testnet.sui.io/graphql",
-    walrusAggregatorUrl: walrusAggregatorUrl(network),
+    walrusAggregatorUrl: walrusAggregatorUrl(deployment.network),
     apiBaseUrl: "https://api.testnet.miso.fm",
     discoverSales: [],
   };
   return { ...config, ...stripUndefined(overrides) };
 }
 
+/** The config for `network`, derived from this SDK's verified deployment map. */
+export function misoConfig(network: Network, overrides: MisoConfigOverrides = {}): MisoConfig {
+  return configFromDeployment(getMisoPlatformDeployment(network), overrides);
+}
+
 /** `{ a: undefined }` must not clobber a real default when spread. */
 function stripUndefined<T extends object>(o: T): Partial<T> {
   return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined)) as Partial<T>;

package/src/read/genres.ts

@@ -5,8 +5,8 @@
 // object carries a screaming-snake name ("HIP_HOP"). There is no id→name table
 // anywhere off-chain, so the names are read from the objects and humanized.
 
-import { Effect } from "effect";
-import { getObjectsContent, type SuiClient } from "@misofm/effect";
+import { Effect, Result } from "effect";
+import { ObjectId, Sui, SuiSchema } from "@unconfirmed/sui-effect";
 import { Genre as GenreBcs } from "../contracts/genre/genre.ts";
 
 /** "HIP_HOP" → "Hip Hop". */
@@ -21,25 +21,29 @@ function humanize(name: string): string {
 /**
  * Resolve `Genre` object ids to display names. Best-effort: an id that fails to
  * read, or whose content does not parse as a `Genre`, is dropped rather than
- * failing the artist page around it.
+ * failing the artist page around it — the WP2 behaviour change named in
+ * misofm/sdks#35 ("`resolveGenreNames` on the same batch skips it") now comes
+ * for free from `sui.getObjects`' per-item `Result` instead of a hand-rolled
+ * `try`/`catch` around a `Map`.
+ *
+ * Never fails.
  */
 export const resolveGenreNames = Effect.fn("resolveGenreNames")(function* (
-  ids: string[],
-): Effect.fn.Return<string[], never, SuiClient> {
+  ids: ReadonlyArray<string>,
+): Effect.fn.Return<string[], never, Sui> {
   if (ids.length === 0) return [];
-  return yield* getObjectsContent(ids).pipe(
-    Effect.map((contentById) => {
-      const out: string[] = [];
-      for (const { content } of contentById.values()) {
-        try {
-          const name = GenreBcs.parse(content).name;
-          if (name) out.push(humanize(name));
-        } catch {
-          // Malformed content — drop this genre rather than fail the page.
-        }
-      }
-      return out;
-    }),
+  const sui = yield* Sui;
+  const results = yield* sui.getObjects(ids.map((id) => ObjectId.make(id)), { schema: SuiSchema.bcs(GenreBcs) }).pipe(
+    // A transport failure across the whole batch is soft here too — a genre
+    // list that could not be read at all still must not fail the page it
+    // decorates.
     Effect.catch(() => Effect.succeed([])),
   );
+  const out: string[] = [];
+  for (const result of results) {
+    if (!Result.isSuccess(result)) continue;
+    const name = result.success.content.name;
+    if (name) out.push(humanize(name));
+  }
+  return out;
 });

package/src/read/index.ts

@@ -10,20 +10,22 @@
 //
 // Browser- and server-compatible. The HTTP API is a thin cached transport over
 // this same surface; direct clients can use it without going through the API.
-// Every read returns `Effect<A, E, SuiClient | SuiGraphQL>`; `createMisoClient`
-// bundles the transport, config, and Party client — provide its `sui`/`graphqlRaw`
-// as the Effect services once, at your program's boundary:
+// Every read returns `Effect<A, E, Sui | SuiGraphQL>`; `createMisoClient`
+// (misofm/sdks#35) already builds that layer for you as `miso.layer` — provide
+// it once, at your program's boundary:
 //
 //   const miso = createMisoClient({ network: "testnet" })
-//   const layer = Layer.mergeAll(SuiClient.layer(miso.sui), SuiGraphQL.layer(miso.graphqlRaw))
 //   const pressing = await Effect.runPromise(
-//     getPressingDetail(pressingId, miso.config).pipe(Effect.provide(layer)),
+//     getPressingDetail(pressingId, miso.config).pipe(Effect.provide(miso.layer)),
 //   )
+//
+// Prefer the Promise face for one-off reads instead:
+// `await miso.client.miso.read.getPressingDetail(pressingId)`.
 
 export { createMisoClient } from "./client.ts";
 export type { MisoClient, CreateMisoClientOptions } from "./client.ts";
 
-export { misoConfig, networkFrom } from "./config.ts";
+export { configFromDeployment, misoConfig, networkFrom } from "./config.ts";
 export type {
   MisoConfig,
   MisoConfigOverrides,