@misofm/platform 0.25.0 → 0.26.1

package/src/credits.ts

@@ -28,9 +28,10 @@
 // about any of it — it only provides the cap-gated `uid_mut` hook these attach
 // through.
 
-import type { ClientWithCoreApi } from "@mysten/sui/client";
+import { Effect, Option } from "effect";
 import { bcs } from "@mysten/sui/bcs";
 import { deriveDynamicFieldID } from "@mysten/sui/utils";
+import { getObjectsContent, SuiClient, type SuiRpcError } from "@misofm/effect";
 import type {
   Transaction,
   TransactionArgument,
@@ -632,23 +633,18 @@ interface CreditFieldTarget {
 }
 
 /** Fetch many derived credit fields through one Core bulk request. */
-async function fetchCreditFields(
-  client: ClientWithCoreApi,
+const fetchCreditFields = Effect.fn("fetchCreditFields")(function* (
   targets: readonly CreditFieldTarget[],
-): Promise<Map<string, Uint8Array>> {
+): Effect.fn.Return<Map<string, Uint8Array>, SuiRpcError, SuiClient> {
   if (targets.length === 0) return new Map();
-  const { objects } = await client.core.getObjects({
-    objectIds: targets.map((target) => target.fieldId),
-    include: { content: true },
-  });
+  const objects = yield* getObjectsContent(targets.map((target) => target.fieldId));
   const contents = new Map<string, Uint8Array>();
-  objects.forEach((object, index) => {
-    if (object instanceof Error || !object.content) return;
-    const target = targets[index];
-    if (target) contents.set(target.fieldId, object.content);
-  });
+  for (const target of targets) {
+    const object = objects.get(target.fieldId);
+    if (object) contents.set(target.fieldId, object.content);
+  }
   return contents;
-}
+});
 
 function compositionCreditTargets(
   compositionIds: readonly string[],
@@ -783,34 +779,23 @@ function recordingRoleLabel(role: ParsedEnum): string {
  * Reads a composition's writing credits (the `composition_credits` extension), or
  * `null` if no credits field is attached.
  */
-export async function getCompositionCredits(
-  client: ClientWithCoreApi,
+/** Reads a composition's writing credits (the `composition_credits` extension). */
+export const getCompositionCredits = Effect.fn("getCompositionCredits")(function* (
   compositionId: string,
   compositionCreditsPackageId: string,
-): Promise<CreditView[] | null> {
-  return (
-    (
-      await getCompositionCreditsByIds(
-        client,
-        [compositionId],
-        compositionCreditsPackageId,
-      )
-    )[compositionId] ?? null
-  );
-}
+): Effect.fn.Return<Option.Option<CreditView[]>, SuiRpcError, SuiClient> {
+  const byId = yield* getCompositionCreditsByIds([compositionId], compositionCreditsPackageId);
+  return Option.fromNullishOr(byId[compositionId]);
+});
 
 /** Composition credits for many works in one Core bulk request. */
-export async function getCompositionCreditsByIds(
-  client: ClientWithCoreApi,
+export const getCompositionCreditsByIds = Effect.fn("getCompositionCreditsByIds")(function* (
   compositionIdsInput: readonly string[],
   compositionCreditsPackageId: string,
-): Promise<Partial<Record<string, CreditView[]>>> {
+): Effect.fn.Return<Partial<Record<string, CreditView[]>>, SuiRpcError, SuiClient> {
   const compositionIds = [...new Set(compositionIdsInput)];
-  const targets = compositionCreditTargets(
-    compositionIds,
-    compositionCreditsPackageId,
-  );
-  const contents = await fetchCreditFields(client, targets);
+  const targets = compositionCreditTargets(compositionIds, compositionCreditsPackageId);
+  const contents = yield* fetchCreditFields(targets);
   const out: Partial<Record<string, CreditView[]>> = {};
   for (const target of targets) {
     const content = contents.get(target.fieldId);
@@ -822,40 +807,28 @@ export async function getCompositionCreditsByIds(
     }
   }
   return out;
-}
+});
 
 /**
  * Reads a recording's credits plus its primary/featured artist party ids (the
- * `recording_credits` extension), or `null` if no credits field is attached.
+ * `recording_credits` extension).
  */
-export async function getRecordingCredits(
-  client: ClientWithCoreApi,
+export const getRecordingCredits = Effect.fn("getRecordingCredits")(function* (
   recordingId: string,
   recordingCreditsPackageId: string,
-): Promise<RecordingCreditsView | null> {
-  return (
-    (
-      await getRecordingCreditsByIds(
-        client,
-        [recordingId],
-        recordingCreditsPackageId,
-      )
-    )[recordingId] ?? null
-  );
-}
+): Effect.fn.Return<Option.Option<RecordingCreditsView>, SuiRpcError, SuiClient> {
+  const byId = yield* getRecordingCreditsByIds([recordingId], recordingCreditsPackageId);
+  return Option.fromNullishOr(byId[recordingId]);
+});
 
 /** Recording credits for many works in one Core bulk request. */
-export async function getRecordingCreditsByIds(
-  client: ClientWithCoreApi,
+export const getRecordingCreditsByIds = Effect.fn("getRecordingCreditsByIds")(function* (
   recordingIdsInput: readonly string[],
   recordingCreditsPackageId: string,
-): Promise<Partial<Record<string, RecordingCreditsView>>> {
+): Effect.fn.Return<Partial<Record<string, RecordingCreditsView>>, SuiRpcError, SuiClient> {
   const recordingIds = [...new Set(recordingIdsInput)];
-  const targets = recordingCreditTargets(
-    recordingIds,
-    recordingCreditsPackageId,
-  );
-  const contents = await fetchCreditFields(client, targets);
+  const targets = recordingCreditTargets(recordingIds, recordingCreditsPackageId);
+  const contents = yield* fetchCreditFields(targets);
   const out: Partial<Record<string, RecordingCreditsView>> = {};
   for (const target of targets) {
     const content = contents.get(target.fieldId);
@@ -868,33 +841,28 @@ export async function getRecordingCreditsByIds(
     };
   }
   return out;
-}
+});
 
 /**
- * Reads a release's top-line billing credits (the `release_credits` extension), or
- * `null` if no credits field is attached. Each credit has exactly one role.
+ * Reads a release's top-line billing credits (the `release_credits` extension).
+ * Each credit has exactly one role.
  */
-export async function getReleaseCredits(
-  client: ClientWithCoreApi,
+export const getReleaseCredits = Effect.fn("getReleaseCredits")(function* (
   releaseId: string,
   releaseCreditsPackageId: string,
-): Promise<CreditView[] | null> {
-  return (
-    (
-      await getReleaseCreditsByIds(client, [releaseId], releaseCreditsPackageId)
-    )[releaseId] ?? null
-  );
-}
+): Effect.fn.Return<Option.Option<CreditView[]>, SuiRpcError, SuiClient> {
+  const byId = yield* getReleaseCreditsByIds([releaseId], releaseCreditsPackageId);
+  return Option.fromNullishOr(byId[releaseId]);
+});
 
 /** Release billing credits for many releases in one Core bulk request. */
-export async function getReleaseCreditsByIds(
-  client: ClientWithCoreApi,
+export const getReleaseCreditsByIds = Effect.fn("getReleaseCreditsByIds")(function* (
   releaseIdsInput: readonly string[],
   releaseCreditsPackageId: string,
-): Promise<Partial<Record<string, CreditView[]>>> {
+): Effect.fn.Return<Partial<Record<string, CreditView[]>>, SuiRpcError, SuiClient> {
   const releaseIds = [...new Set(releaseIdsInput)];
   const targets = releaseCreditTargets(releaseIds, releaseCreditsPackageId);
-  const contents = await fetchCreditFields(client, targets);
+  const contents = yield* fetchCreditFields(targets);
   const out: Partial<Record<string, CreditView[]>> = {};
   for (const target of targets) {
     const content = contents.get(target.fieldId);
@@ -903,4 +871,4 @@ export async function getReleaseCreditsByIds(
     }
   }
   return out;
-}
+});

package/src/deployments.ts

@@ -6,7 +6,20 @@ import { MISO_DEPLOYMENTS } from "@misofm/musicos/deployments";
 import type { PartyDeployment } from "@misofm/partyos/deployments";
 import { PARTYOS_DEPLOYMENTS } from "@misofm/partyos/deployments";
 import { normalizeSuiAddress, normalizeSuiObjectId } from "@mysten/sui/utils";
+import { Context, Effect, Layer } from "effect";
+import { DeploymentError } from "@misofm/effect/errors";
 import { immutableSnapshot } from "./internal.ts";
+import {
+  MisoPlatformDeploymentInvalidError,
+  OperationsUnavailableError,
+  RecordSalesUnavailableError,
+} from "./errors.ts";
+
+export {
+  MisoPlatformDeploymentInvalidError,
+  OperationsUnavailableError,
+  RecordSalesUnavailableError,
+} from "./errors.ts";
 
 /** Every package address a platform deployment must supply, for canonical-id
  * and pairwise-distinctness validation in {@link assertMisoPlatformDeployment}. */
@@ -66,20 +79,13 @@ export type RecordSalesDeployment =
       readonly recordShopPackageId: string;
     };
 
-export class RecordSalesUnavailableError extends Error {
-  override readonly name = "RecordSalesUnavailableError";
-  constructor(readonly reason: string) {
-    super(`@misofm/platform: Record sales are unavailable: ${reason}`);
-  }
-}
-
 export function requireRecordSalesDeployment(
   deployment: RecordSalesDeployment | undefined,
 ): Extract<RecordSalesDeployment, { status: "available" }> {
   if (!deployment || deployment.status === "unavailable") {
-    throw new RecordSalesUnavailableError(
-      deployment?.reason ?? "no Record sales deployment was configured",
-    );
+    throw new RecordSalesUnavailableError({
+      reason: deployment?.reason ?? "no Record sales deployment was configured",
+    });
   }
   const canonicalPackageId = (value: string): boolean => {
     if (!/^0x[0-9a-f]{64}$/.test(value)) return false;
@@ -93,14 +99,14 @@ export function requireRecordSalesDeployment(
     !canonicalPackageId(deployment.recordPackageId) ||
     !canonicalPackageId(deployment.recordShopPackageId)
   ) {
-    throw new RecordSalesUnavailableError(
-      "Record and Record Shop package IDs must be canonical 32-byte Sui object IDs",
-    );
+    throw new RecordSalesUnavailableError({
+      reason: "Record and Record Shop package IDs must be canonical 32-byte Sui object IDs",
+    });
   }
   if (deployment.recordPackageId === deployment.recordShopPackageId) {
-    throw new RecordSalesUnavailableError(
-      "Record and Record Shop package IDs must be distinct",
-    );
+    throw new RecordSalesUnavailableError({
+      reason: "Record and Record Shop package IDs must be distinct",
+    });
   }
   return deployment;
 }
@@ -137,13 +143,6 @@ export type OperationsDeployment =
       };
     };
 
-export class OperationsUnavailableError extends Error {
-  override readonly name = "OperationsUnavailableError";
-  constructor(readonly reason: string) {
-    super(`@misofm/platform: Vault operations are unavailable: ${reason}`);
-  }
-}
-
 export type AvailableOperationsDeployment = Extract<
   OperationsDeployment,
   { status: "available" }
@@ -172,9 +171,9 @@ export function requireOperationsDeployment(
   deployment: OperationsDeployment | undefined,
 ): AvailableOperationsDeployment {
   if (!deployment || deployment.status !== "available") {
-    throw new OperationsUnavailableError(
-      deployment?.reason ?? "no Vault operations deployment was configured",
-    );
+    throw new OperationsUnavailableError({
+      reason: deployment?.reason ?? "no Vault operations deployment was configured",
+    });
   }
 
   const candidate = deployment as Partial<AvailableOperationsDeployment>;
@@ -201,15 +200,15 @@ export function requireOperationsDeployment(
 
   for (const [field, id] of packageEntries) {
     if (!canonicalObjectId(id)) {
-      throw new OperationsUnavailableError(
-        `${field} must be a canonical 32-byte Sui package ID`,
-      );
+      throw new OperationsUnavailableError({
+        reason: `${field} must be a canonical 32-byte Sui package ID`,
+      });
     }
   }
   if (!canonicalObjectId(vault?.registryId)) {
-    throw new OperationsUnavailableError(
-      "vault.registryId must be a canonical 32-byte Sui object ID",
-    );
+    throw new OperationsUnavailableError({
+      reason: "vault.registryId must be a canonical 32-byte Sui object ID",
+    });
   }
 
   const identities = [
@@ -217,9 +216,9 @@ export function requireOperationsDeployment(
     vault.registryId,
   ];
   if (new Set(identities).size !== identities.length) {
-    throw new OperationsUnavailableError(
-      `the Vault registry object and all ${packageEntries.length} package IDs must be distinct`,
-    );
+    throw new OperationsUnavailableError({
+      reason: `the Vault registry object and all ${packageEntries.length} package IDs must be distinct`,
+    });
   }
   return deployment;
 }
@@ -316,10 +315,6 @@ export interface MisoPlatformDeployment {
   };
 }
 
-export class MisoPlatformDeploymentInvalidError extends Error {
-  override readonly name = "MisoPlatformDeploymentInvalidError";
-}
-
 /**
  * Validates the `packages` and `party` package-id sets before any Move target
  * is constructed from them: every required id must be a canonical 32-byte Sui
@@ -331,28 +326,28 @@ export function assertMisoPlatformDeployment(
   deployment: unknown,
 ): asserts deployment is MisoPlatformDeployment {
   if (!deployment || typeof deployment !== "object" || Array.isArray(deployment)) {
-    throw new MisoPlatformDeploymentInvalidError(
-      "@misofm/platform: deployment must be a complete MisoPlatformDeployment object.",
-    );
+    throw new MisoPlatformDeploymentInvalidError({
+      message: "@misofm/platform: deployment must be a complete MisoPlatformDeployment object.",
+    });
   }
   const candidate = deployment as Partial<MisoPlatformDeployment>;
   const packages = candidate.packages as Partial<MisoPlatformDeployment["packages"]> | undefined;
   const party = candidate.party as Partial<PartyExtensionsDeployment> | undefined;
   const partyos = candidate.partyos as Partial<PartyDeployment> | undefined;
   if (!packages || typeof packages !== "object") {
-    throw new MisoPlatformDeploymentInvalidError(
-      "@misofm/platform: deployment is missing its `packages` section.",
-    );
+    throw new MisoPlatformDeploymentInvalidError({
+      message: "@misofm/platform: deployment is missing its `packages` section.",
+    });
   }
   if (!party || typeof party !== "object") {
-    throw new MisoPlatformDeploymentInvalidError(
-      "@misofm/platform: deployment is missing its `party` section.",
-    );
+    throw new MisoPlatformDeploymentInvalidError({
+      message: "@misofm/platform: deployment is missing its `party` section.",
+    });
   }
   if (!partyos || typeof partyos !== "object") {
-    throw new MisoPlatformDeploymentInvalidError(
-      "@misofm/platform: deployment is missing its `partyos` section.",
-    );
+    throw new MisoPlatformDeploymentInvalidError({
+      message: "@misofm/platform: deployment is missing its `partyos` section.",
+    });
   }
 
   const seenPackageIds = new Set<string>();
@@ -363,29 +358,30 @@ export function assertMisoPlatformDeployment(
    * manifest. */
   const checkCanonical = (field: string, packageId: unknown, dedupeOk = false) => {
     if (typeof packageId !== "string") {
-      throw new MisoPlatformDeploymentInvalidError(
-        `@misofm/platform: deployment is missing package ID for "${field}".`,
-      );
+      throw new MisoPlatformDeploymentInvalidError({
+        message: `@misofm/platform: deployment is missing package ID for "${field}".`,
+      });
     }
     let normalized: string;
     try {
       normalized = normalizeSuiAddress(packageId);
     } catch {
-      throw new MisoPlatformDeploymentInvalidError(
-        `@misofm/platform: deployment package ID for "${field}" is not a valid Sui address.`,
-      );
+      throw new MisoPlatformDeploymentInvalidError({
+        message: `@misofm/platform: deployment package ID for "${field}" is not a valid Sui address.`,
+      });
     }
     if (packageId !== normalized) {
-      throw new MisoPlatformDeploymentInvalidError(
-        `@misofm/platform: deployment package ID for "${field}" must be normalized (${normalized}).`,
-      );
+      throw new MisoPlatformDeploymentInvalidError({
+        message: `@misofm/platform: deployment package ID for "${field}" must be normalized (${normalized}).`,
+      });
     }
     if (!dedupeOk) {
       if (seenPackageIds.has(packageId)) {
-        throw new MisoPlatformDeploymentInvalidError(
-          `@misofm/platform: deployment package ID for "${field}" duplicates another package. ` +
+        throw new MisoPlatformDeploymentInvalidError({
+          message:
+            `@misofm/platform: deployment package ID for "${field}" duplicates another package. ` +
             "Every package in a deployment manifest must have its own address.",
-        );
+        });
       }
       seenPackageIds.add(packageId);
     }
@@ -401,14 +397,16 @@ export function assertMisoPlatformDeployment(
     checkCanonical(`party.${key}`, party[key], key === "countryCode" || key === "languageCode");
   }
   if (party.countryCode !== packages.countryCode) {
-    throw new MisoPlatformDeploymentInvalidError(
-      "@misofm/platform: party.countryCode must match packages.countryCode (the same shared dependency package).",
-    );
+    throw new MisoPlatformDeploymentInvalidError({
+      message:
+        "@misofm/platform: party.countryCode must match packages.countryCode (the same shared dependency package).",
+    });
   }
   if (party.languageCode !== packages.languageCode) {
-    throw new MisoPlatformDeploymentInvalidError(
-      "@misofm/platform: party.languageCode must match packages.languageCode (the same shared dependency package).",
-    );
+    throw new MisoPlatformDeploymentInvalidError({
+      message:
+        "@misofm/platform: party.languageCode must match packages.languageCode (the same shared dependency package).",
+    });
   }
 }
 
@@ -572,3 +570,39 @@ export function getMisoPlatformDeployment(
   }
   return deployment;
 }
+
+/** Effect-returning `assertMisoPlatformDeployment`: validation failure becomes a typed `DeploymentError`. */
+export function validateMisoPlatformDeployment(
+  deployment: unknown,
+): Effect.Effect<MisoPlatformDeployment, DeploymentError> {
+  return Effect.try({
+    try: () => normalizeMisoPlatformDeployment(deployment),
+    catch: (cause) =>
+      new DeploymentError({
+        message: cause instanceof Error ? cause.message : String(cause),
+      }),
+  });
+}
+
+/**
+ * The platform deployment manifest as a service, so the deployment-aware
+ * platform reads and PTB builders (notably {@link Genre.derive}, which needs
+ * the genre registry + package ids) can declare it in `R` instead of taking it
+ * as an explicit parameter. `MisoPlatformClient`/`misoPlatform()` provide this
+ * layer internally; a bare read composed from `queries.ts` functions must
+ * provide it explicitly, e.g.
+ * `program.pipe(Effect.provide(PlatformDeployment.layer(deployment)))`.
+ */
+export class PlatformDeployment extends Context.Service<PlatformDeployment, MisoPlatformDeployment>()(
+  "@misofm/platform/PlatformDeployment",
+) {
+  /** Provides a concrete, already-validated `MisoPlatformDeployment` as the service. */
+  static layer(deployment: MisoPlatformDeployment): Layer.Layer<PlatformDeployment> {
+    return Layer.succeed(PlatformDeployment, deployment);
+  }
+
+  /** Resolves a bundled deployment for `network` and provides it as the service; fails closed for unknown networks. */
+  static fromNetwork(network: string): Layer.Layer<PlatformDeployment> {
+    return PlatformDeployment.layer(getMisoPlatformDeployment(network));
+  }
+}

package/src/errors.ts

@@ -0,0 +1,156 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// The platform-specific error vocabulary, built on the shared foundation
+// (`@misofm/effect/errors`). Every failure a caller might need to act on is a
+// `Schema.TaggedError` carrying the fields needed to act; `isNotFound`-style
+// message sniffing is replaced by `Effect.catchTag` against these tags.
+
+import { Schema } from "effect";
+
+// Re-export the foundation vocabulary so a platform consumer never needs a
+// second import for the errors platform reads/executes surface directly.
+export {
+  BcsDecodeError,
+  DeploymentError,
+  GraphQLUnavailableError,
+  ObjectNotFoundError,
+  ObjectTypeMismatchError,
+  SuiRpcError,
+  TransactionFailedError,
+  type SuiReadError,
+} from "@misofm/effect/errors";
+
+/** Record sales (Record + Record Shop) are unavailable on this deployment. */
+export class RecordSalesUnavailableError extends Schema.TaggedError<RecordSalesUnavailableError>()(
+  "RecordSalesUnavailableError",
+  {
+    reason: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `@misofm/platform: Record sales are unavailable: ${this.reason}`;
+  }
+}
+
+/** Vault/Action/plugin operations are unavailable on this deployment. */
+export class OperationsUnavailableError extends Schema.TaggedError<OperationsUnavailableError>()(
+  "OperationsUnavailableError",
+  {
+    reason: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `@misofm/platform: Vault operations are unavailable: ${this.reason}`;
+  }
+}
+
+/** A caller-supplied `MisoPlatformDeployment` manifest failed structural validation. */
+export class MisoPlatformDeploymentInvalidError extends Schema.TaggedError<MisoPlatformDeploymentInvalidError>()(
+  "MisoPlatformDeploymentInvalidError",
+  {
+    message: Schema.String,
+  },
+) {}
+
+/** The connected client's network does not match the configured deployment's network. */
+export class MisoNetworkMismatchError extends Schema.TaggedError<MisoNetworkMismatchError>()(
+  "MisoNetworkMismatchError",
+  {
+    clientNetwork: Schema.String,
+    deploymentNetwork: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `@misofm/platform: client network "${this.clientNetwork}" does not match deployment network "${this.deploymentNetwork}"`;
+  }
+}
+
+/** The connected endpoint's chain identifier does not match the configured deployment's. */
+export class MisoChainIdentifierMismatchError extends Schema.TaggedError<MisoChainIdentifierMismatchError>()(
+  "MisoChainIdentifierMismatchError",
+  {
+    actual: Schema.String,
+    expected: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `@misofm/platform: endpoint chain identifier "${this.actual}" does not match deployment chain identifier "${this.expected}"`;
+  }
+}
+
+/** A method that requires the exact-chain validation lifecycle was called before `ready()`. */
+export class MisoClientNotReadyError extends Schema.TaggedError<MisoClientNotReadyError>()(
+  "MisoClientNotReadyError",
+  {
+    operation: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `@misofm/platform: ${this.operation} requires an exact-chain validation lifecycle; call and await client.miso.ready() first`;
+  }
+}
+
+/** An on-chain `RecordSoldEvent` could not be decoded into a `RecordSale`. */
+export class MalformedRecordSoldEventError extends Schema.TaggedError<MalformedRecordSoldEventError>()(
+  "MalformedRecordSoldEventError",
+  {
+    digest: Schema.optional(Schema.String),
+    reason: Schema.optional(Schema.String),
+  },
+) {}
+
+/** Authenticated-fetch / API-authorization signing or verification failure. */
+export const MisoAuthErrorCode = Schema.Literals([
+  "invalid_target",
+  "challenge_rejected",
+  "invalid_challenge",
+  "signing_failed",
+]);
+export type MisoAuthErrorCode = typeof MisoAuthErrorCode.Type;
+
+export class MisoAuthError extends Schema.TaggedError<MisoAuthError>()("MisoAuthError", {
+  code: MisoAuthErrorCode,
+  reason: Schema.String,
+  status: Schema.optional(Schema.Number),
+  cause: Schema.optional(Schema.Defect()),
+}) {
+  override get message(): string {
+    return this.reason;
+  }
+}
+
+// ── Domain not-found wrappers ───────────────────────────────────────────────
+//
+// Added where a caller benefits from a typed tag instead of message-sniffing —
+// concretely, `misofm/api`'s read service hand-rolls exactly this bridge today
+// (`services/miso-read-service/src/routes.ts`: `isMissingRelease`,
+// `isMissingReceipt`). These let that bridge use `Effect.catchTag` instead.
+
+/** No Release exists at the requested id (or it is not a Release from the configured deployment). */
+export class ReleaseNotFoundError extends Schema.TaggedError<ReleaseNotFoundError>()("ReleaseNotFoundError", {
+  releaseId: Schema.String,
+}) {}
+
+/** The fullnode and the indexer both have no record of this transaction digest. */
+export class ReceiptNotFoundError extends Schema.TaggedError<ReceiptNotFoundError>()("ReceiptNotFoundError", {
+  digest: Schema.String,
+}) {}
+
+/** The transaction exists, but its effects contain no `record_shop::listing::RecordSoldEvent`. */
+export class RecordPurchaseNotFoundError extends Schema.TaggedError<RecordPurchaseNotFoundError>()(
+  "RecordPurchaseNotFoundError",
+  {
+    digest: Schema.String,
+  },
+) {}
+
+/** An object exists at the requested Pressing id, but is not a Pressing from the configured Record package. */
+export class ForeignPressingError extends Schema.TaggedError<ForeignPressingError>()("ForeignPressingError", {
+  pressingId: Schema.String,
+  actualType: Schema.optional(Schema.String),
+}) {
+  override get message(): string {
+    return `@misofm/platform: object ${this.pressingId} is not a Pressing from the configured Record package.`;
+  }
+}

package/src/execute.ts

@@ -10,7 +10,9 @@
 
 import type { ParallelTransactionExecutor } from "@mysten/sui/transactions";
 import type { SuiClientTypes } from "@mysten/sui/client";
+import { Effect } from "effect";
 import { buildTx, toExecResult, FULL_INCLUDE, type ExecResult } from "@misofm/musicos";
+import { SuiRpcError } from "@misofm/effect/errors";
 import type { TxThunk } from "./transactions.ts";
 
 // Consumers of the platform SDK should not need a second direct dependency on
@@ -39,14 +41,16 @@ export interface PlatformExecResult extends ExecResult {
  * job (e.g. a resumable checkpoint that reconciles against on-chain state). A Move
  * abort RESOLVES as a `FailedTransaction`, so `toExecResult` surfaces it too.
  */
-export async function executeViaExecutor(
+export const executeViaExecutor = Effect.fn("executeViaExecutor")(function* (
   executor: ParallelTransactionExecutor,
   ...thunks: TxThunk[]
-): Promise<PlatformExecResult> {
-  const tx = await buildTx(...thunks);
-  const res: SuiClientTypes.TransactionResult<PlatformFullInclude> =
-    await executor.executeTransaction(tx, PLATFORM_FULL_INCLUDE);
+): Effect.fn.Return<PlatformExecResult, SuiRpcError> {
+  const tx = yield* buildTx(...thunks);
+  const res: SuiClientTypes.TransactionResult<PlatformFullInclude> = yield* Effect.tryPromise({
+    try: () => executor.executeTransaction(tx, PLATFORM_FULL_INCLUDE),
+    catch: (cause) => new SuiRpcError({ operation: "executeTransaction", cause }),
+  });
   const base = toExecResult(res);
   if (res.$kind !== "Transaction") throw new Error("unreachable: toExecResult accepted a failed transaction");
   return { ...base, events: res.Transaction.events ?? [] };
-}
+});