@misofm/musicos 0.2.0 → 0.3.0

package/dist/queries.js

@@ -1,11 +1,27 @@
 // Copyright (c) Miso Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
+// Object reads. Single-object fetches use the Core API with `include: content`
+// and parse the BCS contents through the codegen-generated structs (so parsing
+// tracks the on-chain ABI). Generic-type discovery (by share type / by owner)
+// uses GraphQL to find object addresses, then reads them through the Core path.
+//
+// Every read requires the `SuiClient` service (and `SuiGraphQL` for the
+// type-discovery reads) instead of taking a client parameter — see
+// `@misofm/effect`. Not-found is a typed `ObjectNotFoundError`; a BCS decode
+// failure (including a wrong on-chain type, which fails to parse against the
+// expected ABI) is a typed `BcsDecodeError`. Extension dynamic-field readers
+// return `Option.none()` for "not attached" — extension data is optional by
+// design, and absence is a normal, expected state, not a failure.
+import { ConflictingWorkKindError } from "./errors.js";
+import { Effect, Option, Schema } from "effect";
 import { graphql } from "@mysten/sui/graphql/schema";
 import { deriveObjectID, normalizeSuiAddress } from "@mysten/sui/utils";
+import { BcsDecodeError, decodeBcs, getObjectContent, getObjectsContent, ObjectNotFoundError, SuiClient, SuiGraphQL, SuiRpcError, } from "@misofm/effect";
 import { Composition as CompositionBcs } from "./contracts/musicos/composition.js";
 import { Recording as RecordingBcs } from "./contracts/musicos/recording.js";
 import { Release as ReleaseBcs, ReleaseRegistry as ReleaseRegistryBcs, } from "./contracts/musicos/release.js";
-import { mapBps, mapComposition, mapRecording, mapRelease, } from "./internal.js";
+import { mapComposition, mapRecording, mapRelease, } from "./internal.js";
+import { Composition, CompositionAdminCap, Recording, RecordingAdminCap, Release, ReleaseAdminCap, ReleaseRegistry, } from "./types.js";
 // ============================================================================
 // Helpers
 // ============================================================================
@@ -35,33 +51,26 @@ export function extractTypeParams2(objectType) {
     }
     throw new Error(`Expected two type parameters in: ${objectType}`);
 }
+/** Key bytes for Move unit structs (single `0x00` for `dummy_field: bool = false`). */
+const UNIT_STRUCT_KEY_BYTES = new Uint8Array([0x00]);
 /**
- * True when `e` is a "this object does not exist" error from any of the Sui
- * client transports, so null-returning readers can distinguish absence from
- * transport failure. Matches, in order of preference:
+ * True when `e` is a "this object/dynamic field does not exist" error from any
+ * of the Sui client transports. This mirrors `@misofm/effect`'s internal
+ * classifier (not exported, since `getObjectContent` already covers the common
+ * case) — needed here for the reads that don't go through it: type-only object
+ * reads (no `content`) and dynamic-field reads. Matches, in order of
+ * preference:
  *
  *   1. Structured `ObjectError.code` values thrown by the JSON-RPC core client
  *      (`notExists`, `deleted`, `dynamicFieldNotFound`) and the GraphQL core
- *      client (`notFound`). The class itself is not exported by `@mysten/sui`,
- *      so we duck-type on `code`.
+ *      client (`notFound`).
  *   2. The message shapes those clients (and the gRPC core client, which wraps
- *      the server's per-object status message in a plain `Error`) produce:
- *      "Object 0x… does not exist" / "Object 0x… not found" / "Object 0x… has
- *      been deleted" / "Dynamic field not found for object 0x…" / "No object
- *      found for id 0x…".
- *
- * Transport/protocol errors must NOT match: every message pattern requires
- * object-ish context ("object" / "dynamic field"), so e.g. a JSON-RPC
- * "Method not found" or a gRPC "peer not found" is never treated as a missing
- * object and propagates to the caller.
+ *      the server's per-object status message in a plain `Error`) produce.
  */
-export function isNotFound(e) {
+function isMissingObjectError(e) {
     if (typeof e === "object" && e !== null && "code" in e) {
         const code = e.code;
-        if (code === "notExists" ||
-            code === "deleted" ||
-            code === "dynamicFieldNotFound" ||
-            code === "notFound") {
+        if (code === "notExists" || code === "deleted" || code === "dynamicFieldNotFound" || code === "notFound") {
             return true;
         }
     }
@@ -70,14 +79,38 @@ export function isNotFound(e) {
         /\bdynamic field\b[\s\S]*\bnot\s?found\b/i.test(msg) ||
         /\bno object\b/i.test(msg));
 }
-/** Key bytes for Move unit structs (single `0x00` for `dummy_field: bool = false`). */
-const UNIT_STRUCT_KEY_BYTES = new Uint8Array([0x00]);
+/** Classifies a Core API rejection against `objectId`: missing -> `ObjectNotFoundError`, else `SuiRpcError`. */
+function classifyMissing(objectId, operation, cause) {
+    return isMissingObjectError(cause) ? new ObjectNotFoundError({ objectId }) : new SuiRpcError({ operation, cause });
+}
+/** Fetches just an object's on-chain `type` (no content) through the Core API. */
+const getObjectType = Effect.fn("getObjectType")(function* (objectId) {
+    const client = yield* SuiClient;
+    const { object } = yield* Effect.tryPromise({
+        try: (signal) => client.core.getObject({ objectId, signal }),
+        catch: (cause) => classifyMissing(objectId, "getObject", cause),
+    });
+    return object.type;
+});
+/** Fetches one dynamic field's raw BCS value bytes; not-found becomes `ObjectNotFoundError`. */
+const getDynamicFieldValue = Effect.fn("getDynamicFieldValue")(function* (parentId, name) {
+    const client = yield* SuiClient;
+    const { dynamicField } = yield* Effect.tryPromise({
+        try: (signal) => client.core.getDynamicField({ parentId, name, signal }),
+        catch: (cause) => classifyMissing(parentId, "getDynamicField", cause),
+    });
+    return dynamicField.value.bcs;
+});
 /** Exhaust every Core owned-object page; cap discovery must not truncate. */
-async function listAllOwnedObjects(client, input) {
+const listAllOwnedObjects = Effect.fn("listAllOwnedObjects")(function* (input) {
+    const client = yield* SuiClient;
     const objects = [];
     let cursor;
     do {
-        const page = await client.core.listOwnedObjects(cursor ? { ...input, cursor } : input);
+        const page = yield* Effect.tryPromise({
+            try: (signal) => client.core.listOwnedObjects(cursor ? { ...input, cursor, signal } : { ...input, signal }),
+            catch: (cause) => new SuiRpcError({ operation: "listOwnedObjects", cause }),
+        });
         objects.push(...page.objects);
         cursor = page.pageInfo?.hasNextPage
             ? page.pageInfo.endCursor
@@ -86,81 +119,50 @@ async function listAllOwnedObjects(client, input) {
                 : null;
     } while (cursor);
     return objects;
-}
-/** Fetches one object's BCS content bytes (or null if absent). */
-async function getContent(client, objectId) {
-    const { object } = await client.core.getObject({
-        objectId,
-        include: { content: true },
-    });
-    return object.content ?? null;
-}
+});
 /**
- * Fetch and parse an object through the transport-neutral Core API. Object
- * content is BCS; never pass the full `objectBcs` envelope to a Move codec.
+ * Fetch and parse an object through the transport-neutral Core API, validating
+ * the parsed result against a domain `Schema`. Object content is BCS; never
+ * pass the full `objectBcs` envelope to a Move codec.
  */
-export async function getObjectByBcs(client, objectId, codec) {
-    const content = await getContent(client, objectId);
-    if (!content)
-        throw new Error(`Object not found: ${objectId}`);
-    return codec.parse(content);
-}
+export const getObjectByBcs = Effect.fn("getObjectByBcs")(function* (objectId, codec, schema, typeName) {
+    const { content } = yield* getObjectContent(objectId);
+    return yield* decodeBcs(codec, schema, content, { type: typeName, objectId });
+});
 /**
  * Read an optional first-party extension field from a core object's UID. Every
  * current extension uses a fieldless `ExtensionKey`, whose BCS is one false
- * boolean byte. Absence returns `null`; transport errors still propagate.
+ * boolean byte. Absence resolves to `Option.none()`; transport errors still fail.
  */
-export async function getExtensionField(client, parentId, params) {
-    try {
-        const { dynamicField } = await client.core.getDynamicField({
-            parentId,
-            name: {
-                type: `${params.packageId}::${params.module}::ExtensionKey`,
-                bcs: UNIT_STRUCT_KEY_BYTES,
-            },
-        });
-        return params.codec.parse(dynamicField.value.bcs);
-    }
-    catch (error) {
-        if (isNotFound(error))
-            return null;
-        throw error;
-    }
-}
-async function getReleaseDspField(client, releaseId, key, params) {
+export const getExtensionField = Effect.fn("getExtensionField")(function* (parentId, params) {
+    return yield* getDynamicFieldValue(parentId, {
+        type: `${params.packageId}::${params.module}::ExtensionKey`,
+        bcs: UNIT_STRUCT_KEY_BYTES,
+    }).pipe(Effect.map((bytes) => Option.some(params.codec.parse(bytes))), Effect.catchTag("ObjectNotFoundError", () => Effect.succeed(Option.none())));
+});
+const getReleaseDspField = Effect.fn("getReleaseDspField")(function* (releaseId, key, params) {
     if (!Number.isInteger(params.platform) || params.platform < 0 || params.platform > 255) {
         throw new Error("DSP platform must be a u8 discriminator");
     }
-    try {
-        const { dynamicField } = await client.core.getDynamicField({
-            parentId: releaseId,
-            name: {
-                type: `${params.packageId}::release_dsp_link::${key}`,
-                bcs: Uint8Array.of(params.platform),
-            },
-        });
-        return params.codec.parse(dynamicField.value.bcs);
-    }
-    catch (error) {
-        if (isNotFound(error))
-            return null;
-        throw error;
-    }
-}
+    return yield* getDynamicFieldValue(releaseId, {
+        type: `${params.packageId}::release_dsp_link::${key}`,
+        bcs: Uint8Array.of(params.platform),
+    }).pipe(Effect.map((bytes) => Option.some(params.codec.parse(bytes))), Effect.catchTag("ObjectNotFoundError", () => Effect.succeed(Option.none())));
+});
 /** Read a release-level DSP link stored under `ReleaseLinkKey(platform)`. */
-export function getReleaseDspLink(client, releaseId, params) {
-    return getReleaseDspField(client, releaseId, "ReleaseLinkKey", params);
+export function getReleaseDspLink(releaseId, params) {
+    return getReleaseDspField(releaseId, "ReleaseLinkKey", params);
 }
 /** Read the per-track DSP-link array stored under `TrackLinksKey(platform)`. */
-export function getTrackDspLinks(client, releaseId, params) {
-    return getReleaseDspField(client, releaseId, "TrackLinksKey", params);
+export function getTrackDspLinks(releaseId, params) {
+    return getReleaseDspField(releaseId, "TrackLinksKey", params);
 }
 // ============================================================================
 // Core registry and generic primitive reads
 // ============================================================================
 /** Parse the shared canonical core `miso::release::ReleaseRegistry` by ID. */
-export async function getReleaseRegistryById(client, registryId) {
-    return getObjectByBcs(client, registryId, ReleaseRegistryBcs);
+export function getReleaseRegistryById(registryId) {
+    return getObjectByBcs(registryId, ReleaseRegistryBcs, ReleaseRegistry, "ReleaseRegistry");
 }
 // ============================================================================
 // GraphQL discovery queries
@@ -208,12 +210,13 @@ const AddressesAndTypesByTypeQuery = graphql(`
  * exposes the first, so one bare Recording scan is shared by every requested
  * recording type and filtered client-side.
  */
-export async function getWorkAddressesByShareTypes(client, shareTypes, misoPackageId) {
+export const getWorkAddressesByShareTypes = Effect.fn("getWorkAddressesByShareTypes")(function* (shareTypes, misoPackageId) {
     const compositions = [...new Set(shareTypes.compositions)];
     const recordings = new Set(shareTypes.recordings);
     const out = { compositions: {}, recordings: {} };
     if (compositions.length === 0 && recordings.size === 0)
         return out;
+    const client = yield* SuiGraphQL;
     const declarations = [];
     const selections = [];
     const variables = {};
@@ -221,8 +224,7 @@ export async function getWorkAddressesByShareTypes(client, shareTypes, misoPacka
         const variable = `compositionType${index}`;
         declarations.push(`$${variable}: String!`);
         selections.push(`composition${index}: objects(first: 1, filter: { type: $${variable} }) { nodes { address } }`);
-        variables[variable] =
-            `${misoPackageId}::composition::Composition<${shareType}>`;
+        variables[variable] = `${misoPackageId}::composition::Composition<${shareType}>`;
     });
     if (recordings.size > 0) {
         declarations.push("$recordingType: String!");
@@ -232,14 +234,20 @@ export async function getWorkAddressesByShareTypes(client, shareTypes, misoPacka
     }`);
         variables.recordingType = `${misoPackageId}::recording::Recording`;
     }
-    const result = await client.query({
-        query: `query WorkAddressesByShareTypes(${declarations.join(", ")}) {
-      ${selections.join("\n")}
-    }`,
-        variables,
+    const result = yield* Effect.tryPromise({
+        try: () => client.query({
+            query: `query WorkAddressesByShareTypes(${declarations.join(", ")}) {
+          ${selections.join("\n")}
+        }`,
+            variables,
+        }),
+        catch: (cause) => new SuiRpcError({ operation: "workAddressesByShareTypes", cause }),
     });
     if (result.errors?.length) {
-        throw new AggregateError(result.errors.map((error) => new Error(error.message)), "Work type discovery failed");
+        return yield* new SuiRpcError({
+            operation: "workAddressesByShareTypes",
+            cause: new AggregateError(result.errors.map((error) => new Error(error.message)), "Work type discovery failed"),
+        });
     }
     compositions.forEach((shareType, index) => {
         const address = result.data?.[`composition${index}`]?.nodes[0]?.address;
@@ -267,35 +275,39 @@ export async function getWorkAddressesByShareTypes(client, shareTypes, misoPacka
     while (recordingPage?.pageInfo?.hasNextPage &&
         recordingPage.pageInfo.endCursor &&
         Object.keys(out.recordings).length < recordings.size) {
-        const next = await client.query({
-            query: `query RecordingWorkAddresses($recordingType: String!, $cursor: String!) {
-        recordings: objects(first: 50, after: $cursor, filter: { type: $recordingType }) {
-          pageInfo { hasNextPage endCursor }
-          nodes { address asMoveObject { contents { type { repr } } } }
-        }
-      }`,
-            variables: {
-                recordingType: variables.recordingType,
-                cursor: recordingPage.pageInfo.endCursor,
-            },
+        const cursor = recordingPage.pageInfo.endCursor;
+        const next = yield* Effect.tryPromise({
+            try: () => client.query({
+                query: `query RecordingWorkAddresses($recordingType: String!, $cursor: String!) {
+            recordings: objects(first: 50, after: $cursor, filter: { type: $recordingType }) {
+              pageInfo { hasNextPage endCursor }
+              nodes { address asMoveObject { contents { type { repr } } } }
+            }
+          }`,
+                variables: { recordingType: variables.recordingType, cursor },
+            }),
+            catch: (cause) => new SuiRpcError({ operation: "recordingWorkAddresses", cause }),
         });
         if (next.errors?.length) {
-            throw new AggregateError(next.errors.map((error) => new Error(error.message)), "Recording type discovery failed");
+            return yield* new SuiRpcError({
+                operation: "recordingWorkAddresses",
+                cause: new AggregateError(next.errors.map((error) => new Error(error.message)), "Recording type discovery failed"),
+            });
         }
         recordingPage = next.data?.recordings;
         readRecordingPage(recordingPage);
     }
     return out;
-}
+});
 /** Fetch and parse heterogeneous work objects through one Core bulk request. */
-export async function getWorksByIds(client, ids) {
+export const getWorksByIds = Effect.fn("getWorksByIds")(function* (ids) {
     const kinds = new Map();
     for (const [kind, objectIds] of Object.entries(ids)) {
         for (const objectId of objectIds) {
             const normalized = normalizeSuiAddress(objectId);
             const previous = kinds.get(normalized);
             if (previous && previous !== kind) {
-                throw new Error(`Work ${normalized} was requested as both ${previous} and ${kind}`);
+                return yield* new ConflictingWorkKindError({ objectId: normalized, kinds: [previous, kind] });
             }
             kinds.set(normalized, kind);
         }
@@ -303,64 +315,49 @@ export async function getWorksByIds(client, ids) {
     const out = { compositions: {}, recordings: {}, releases: {} };
     if (kinds.size === 0)
         return out;
-    const { objects } = await client.core.getObjects({
-        objectIds: [...kinds.keys()],
-        include: { content: true },
-    });
-    for (const obj of objects) {
-        if (obj instanceof Error || !obj.content)
-            continue;
-        const kind = kinds.get(normalizeSuiAddress(obj.objectId));
+    const contents = yield* getObjectsContent([...kinds.keys()]);
+    yield* Effect.forEach([...contents.entries()], ([objectId, { content }]) => Effect.gen(function* () {
+        const kind = kinds.get(normalizeSuiAddress(objectId));
         if (kind === "compositions") {
-            out.compositions[obj.objectId] = mapComposition(obj.objectId, CompositionBcs.parse(obj.content));
+            out.compositions[objectId] = yield* decodeBcs({ parse: (bytes) => mapComposition(objectId, CompositionBcs.parse(bytes)) }, Composition, content, { type: "Composition", objectId });
         }
         else if (kind === "recordings") {
-            out.recordings[obj.objectId] = mapRecording(obj.objectId, RecordingBcs.parse(obj.content));
+            out.recordings[objectId] = yield* decodeBcs({ parse: (bytes) => mapRecording(objectId, RecordingBcs.parse(bytes)) }, Recording, content, { type: "Recording", objectId });
         }
         else if (kind === "releases") {
-            out.releases[obj.objectId] = mapRelease(obj.objectId, ReleaseBcs.parse(obj.content));
+            out.releases[objectId] = yield* decodeBcs({ parse: (bytes) => mapRelease(objectId, ReleaseBcs.parse(bytes)) }, Release, content, { type: "Release", objectId });
         }
-    }
+    }), { concurrency: "unbounded" });
     return out;
-}
+});
 // ============================================================================
 // Composition
 // ============================================================================
 /** Fetches multiple compositions by ID in one Core request. */
-export async function getCompositionsByIds(client, compositionIds) {
+export const getCompositionsByIds = Effect.fn("getCompositionsByIds")(function* (compositionIds) {
     if (compositionIds.length === 0)
         return {};
-    const { objects } = await client.core.getObjects({
-        objectIds: compositionIds,
-        include: { content: true },
-    });
-    const out = {};
-    for (const obj of objects) {
-        if (obj instanceof Error || !obj.content)
-            continue;
-        out[obj.objectId] = mapComposition(obj.objectId, CompositionBcs.parse(obj.content));
-    }
-    return out;
-}
+    const contents = yield* getObjectsContent(compositionIds);
+    const decoded = yield* Effect.forEach([...contents.entries()], ([objectId, { content }]) => decodeBcs({ parse: (bytes) => mapComposition(objectId, CompositionBcs.parse(bytes)) }, Composition, content, { type: "Composition", objectId }).pipe(Effect.map((composition) => [objectId, composition])), { concurrency: "unbounded" });
+    return Object.fromEntries(decoded);
+});
 /** Fetches a composition by its object ID. */
-export async function getCompositionById(client, compositionId) {
-    const content = await getContent(client, compositionId);
-    if (!content)
-        throw new Error(`Composition not found: ${compositionId}`);
-    return mapComposition(compositionId, CompositionBcs.parse(content));
+export function getCompositionById(compositionId) {
+    return getObjectByBcs(compositionId, { parse: (bytes) => mapComposition(compositionId, CompositionBcs.parse(bytes)) }, Composition, "Composition");
 }
 /** Extracts the share type `T` from a `Composition<T>` object. */
-export async function getCompositionShareType(client, compositionId) {
-    const { object } = await client.core.getObject({ objectId: compositionId });
-    return extractTypeParam(object.type);
-}
+export const getCompositionShareType = Effect.fn("getCompositionShareType")(function* (compositionId) {
+    const type = yield* getObjectType(compositionId);
+    return extractTypeParam(type);
+});
 /** Fetches a composition by its share type (GraphQL discovery + Core read). */
-export async function getCompositionByShareType(client, graphqlClient, shareType, misoPackageId) {
-    const address = await getCompositionAddressByShareType(graphqlClient, shareType, misoPackageId);
-    if (!address)
-        throw new Error(`Composition not found for share type: ${shareType}`);
-    return getCompositionById(client, address);
-}
+export const getCompositionByShareType = Effect.fn("getCompositionByShareType")(function* (shareType, misoPackageId) {
+    const address = yield* getCompositionAddressByShareType(shareType, misoPackageId);
+    if (Option.isNone(address)) {
+        return yield* new ObjectNotFoundError({ objectId: `composition::Composition<${shareType}>` });
+    }
+    return yield* getCompositionById(address.value);
+});
 /**
  * Resolves a composition share type to its object address.
  *
@@ -368,14 +365,14 @@ export async function getCompositionByShareType(client, graphqlClient, shareType
  * composition's identity but will read extension fields rather than the core
  * Composition contents.
  */
-export async function getCompositionAddressByShareType(graphqlClient, shareType, misoPackageId) {
+export function getCompositionAddressByShareType(shareType, misoPackageId) {
     const type = `${misoPackageId}::composition::Composition<${shareType}>`;
-    return firstAddressOfType(graphqlClient, type);
-}
-export async function getCompositionAdminCapById(client, adminCapId) {
-    const { object } = await client.core.getObject({ objectId: adminCapId });
-    return { id: adminCapId, shareType: extractTypeParam(object.type) };
+    return firstAddressOfType(type);
 }
+export const getCompositionAdminCapById = Effect.fn("getCompositionAdminCapById")(function* (adminCapId) {
+    const type = yield* getObjectType(adminCapId);
+    return new CompositionAdminCap({ id: adminCapId, shareType: extractTypeParam(type) });
+});
 /**
  * Composition admin caps owned by `owner`.
  *
@@ -383,43 +380,32 @@ export async function getCompositionAdminCapById(client, adminCapId) {
  * object's instantiated `type`, so the share type is read straight off
  * `CompositionAdminCap<CompositionShare>` with no second round-trip.
  */
-export async function getOwnedCompositionAdminCaps(client, owner, misoPackageId) {
+export const getOwnedCompositionAdminCaps = Effect.fn("getOwnedCompositionAdminCaps")(function* (owner, misoPackageId) {
     const capType = `${misoPackageId}::composition::CompositionAdminCap`;
-    const objects = await listAllOwnedObjects(client, { owner, type: capType });
+    const objects = yield* listAllOwnedObjects({ owner, type: capType });
     const caps = [];
     for (const obj of objects) {
         const match = obj.type?.match(/<(.+)>$/);
         if (match?.[1])
-            caps.push({ id: obj.objectId, shareType: match[1] });
+            caps.push(new CompositionAdminCap({ id: obj.objectId, shareType: match[1] }));
     }
     return caps;
-}
+});
 export function deriveCompositionAdminCapId(compositionId, misoPackageId) {
     return deriveObjectID(compositionId, `${misoPackageId}::composition::CompositionAdminCapKey`, UNIT_STRUCT_KEY_BYTES);
 }
 // ============================================================================
 // Recording
 // ============================================================================
-export async function getRecordingsByIds(client, recordingIds) {
+export const getRecordingsByIds = Effect.fn("getRecordingsByIds")(function* (recordingIds) {
     if (recordingIds.length === 0)
         return {};
-    const { objects } = await client.core.getObjects({
-        objectIds: recordingIds,
-        include: { content: true },
-    });
-    const out = {};
-    for (const obj of objects) {
-        if (obj instanceof Error || !obj.content)
-            continue;
-        out[obj.objectId] = mapRecording(obj.objectId, RecordingBcs.parse(obj.content));
-    }
-    return out;
-}
-export async function getRecordingById(client, recordingId) {
-    const content = await getContent(client, recordingId);
-    if (!content)
-        throw new Error(`Recording not found: ${recordingId}`);
-    return mapRecording(recordingId, RecordingBcs.parse(content));
+    const contents = yield* getObjectsContent(recordingIds);
+    const decoded = yield* Effect.forEach([...contents.entries()], ([objectId, { content }]) => decodeBcs({ parse: (bytes) => mapRecording(objectId, RecordingBcs.parse(bytes)) }, Recording, content, { type: "Recording", objectId }).pipe(Effect.map((recording) => [objectId, recording])), { concurrency: "unbounded" });
+    return Object.fromEntries(decoded);
+});
+export function getRecordingById(recordingId) {
+    return getObjectByBcs(recordingId, { parse: (bytes) => mapRecording(recordingId, RecordingBcs.parse(bytes)) }, Recording, "Recording");
 }
 /**
  * The recording's OWN share type (`RecordingShare`). `Recording` is generic over
@@ -427,30 +413,31 @@ export async function getRecordingById(client, recordingId) {
  * them and returns the first; use {@link getRecordingShareTypes} when the
  * parent composition's share type is needed too.
  */
-export async function getRecordingShareType(client, recordingId) {
-    const [recordingShareType] = await getRecordingShareTypes(client, recordingId);
+export const getRecordingShareType = Effect.fn("getRecordingShareType")(function* (recordingId) {
+    const [recordingShareType] = yield* getRecordingShareTypes(recordingId);
     return recordingShareType;
-}
+});
 /**
  * Both of a recording's share types, as `[RecordingShare, CompositionShare]`.
  * Most builders need the pair — `track::new`, `recording::publish`
  * and the recording credit/pool extensions are all generic over both, in this
  * order.
  */
-export async function getRecordingShareTypes(client, recordingId) {
-    const { object } = await client.core.getObject({ objectId: recordingId });
-    return extractTypeParams2(object.type);
-}
-export async function getRecordingByShareType(client, graphqlClient, shareType, misoPackageId) {
-    const address = await addressOfRecordingWithShareType(graphqlClient, misoPackageId, shareType);
-    if (!address)
-        throw new Error(`Recording not found for share type: ${shareType}`);
-    return getRecordingById(client, address);
-}
-export async function getRecordingAdminCapById(client, adminCapId) {
-    const { object } = await client.core.getObject({ objectId: adminCapId });
-    return { id: adminCapId, shareType: extractTypeParam(object.type) };
-}
+export const getRecordingShareTypes = Effect.fn("getRecordingShareTypes")(function* (recordingId) {
+    const type = yield* getObjectType(recordingId);
+    return extractTypeParams2(type);
+});
+export const getRecordingByShareType = Effect.fn("getRecordingByShareType")(function* (shareType, misoPackageId) {
+    const address = yield* addressOfRecordingWithShareType(misoPackageId, shareType);
+    if (Option.isNone(address)) {
+        return yield* new ObjectNotFoundError({ objectId: `recording::Recording<${shareType}, ...>` });
+    }
+    return yield* getRecordingById(address.value);
+});
+export const getRecordingAdminCapById = Effect.fn("getRecordingAdminCapById")(function* (adminCapId) {
+    const type = yield* getObjectType(adminCapId);
+    return new RecordingAdminCap({ id: adminCapId, shareType: extractTypeParam(type) });
+});
 /**
  * Recording admin caps owned by `owner`.
  *
@@ -459,72 +446,56 @@ export async function getRecordingAdminCapById(client, adminCapId) {
  * so this yields only the recording's own share type — its parent composition's
  * share type is not recoverable from the cap alone.
  */
-export async function getOwnedRecordingAdminCaps(client, owner, misoPackageId) {
+export const getOwnedRecordingAdminCaps = Effect.fn("getOwnedRecordingAdminCaps")(function* (owner, misoPackageId) {
     const capType = `${misoPackageId}::recording::RecordingAdminCap`;
-    const objects = await listAllOwnedObjects(client, { owner, type: capType });
+    const objects = yield* listAllOwnedObjects({ owner, type: capType });
     const caps = [];
     for (const obj of objects) {
         const match = obj.type?.match(/<(.+)>$/);
         if (match?.[1])
-            caps.push({ id: obj.objectId, shareType: match[1] });
+            caps.push(new RecordingAdminCap({ id: obj.objectId, shareType: match[1] }));
     }
     return caps;
-}
+});
 export function deriveRecordingAdminCapId(recordingId, misoPackageId) {
     return deriveObjectID(recordingId, `${misoPackageId}::recording::RecordingAdminCapKey`, UNIT_STRUCT_KEY_BYTES);
 }
 // ============================================================================
 // Release
 // ============================================================================
-export async function getReleasesByIds(client, releaseIds) {
+export const getReleasesByIds = Effect.fn("getReleasesByIds")(function* (releaseIds) {
     if (releaseIds.length === 0)
         return {};
-    const { objects } = await client.core.getObjects({
-        objectIds: releaseIds,
-        include: { content: true },
-    });
-    const out = {};
-    for (const obj of objects) {
-        if (obj instanceof Error || !obj.content)
-            continue;
-        out[obj.objectId] = mapRelease(obj.objectId, ReleaseBcs.parse(obj.content));
-    }
-    return out;
-}
-export async function getReleaseById(client, releaseId) {
-    const { object } = await client.core.getObject({
-        objectId: releaseId,
-        include: { content: true },
-    });
-    if (!object.content)
-        throw new Error(`Release not found: ${releaseId}`);
-    return mapRelease(releaseId, ReleaseBcs.parse(object.content));
-}
-export async function getReleaseAdminCapById(client, adminCapId) {
-    const { object } = await client.core.getObject({
-        objectId: adminCapId,
-        include: { json: true },
+    const contents = yield* getObjectsContent(releaseIds);
+    const decoded = yield* Effect.forEach([...contents.entries()], ([objectId, { content }]) => decodeBcs({ parse: (bytes) => mapRelease(objectId, ReleaseBcs.parse(bytes)) }, Release, content, { type: "Release", objectId }).pipe(Effect.map((release) => [objectId, release])), { concurrency: "unbounded" });
+    return Object.fromEntries(decoded);
+});
+export function getReleaseById(releaseId) {
+    return getObjectByBcs(releaseId, { parse: (bytes) => mapRelease(releaseId, ReleaseBcs.parse(bytes)) }, Release, "Release");
+}
+export const getReleaseAdminCapById = Effect.fn("getReleaseAdminCapById")(function* (adminCapId) {
+    const client = yield* SuiClient;
+    const { object } = yield* Effect.tryPromise({
+        try: (signal) => client.core.getObject({ objectId: adminCapId, include: { json: true }, signal }),
+        catch: (cause) => classifyMissing(adminCapId, "getObject", cause),
     });
     const json = object.json;
-    if (!json?.release_id)
-        throw new Error(`ReleaseAdminCap not found: ${adminCapId}`);
-    return { id: adminCapId, releaseId: json.release_id };
-}
-export async function getOwnedReleaseAdminCaps(client, owner, misoPackageId) {
+    if (!json?.release_id) {
+        return yield* new ObjectNotFoundError({ objectId: adminCapId });
+    }
+    return new ReleaseAdminCap({ id: adminCapId, releaseId: json.release_id });
+});
+export const getOwnedReleaseAdminCaps = Effect.fn("getOwnedReleaseAdminCaps")(function* (owner, misoPackageId) {
     const capType = `${misoPackageId}::release::ReleaseAdminCap`;
-    const objects = await listAllOwnedObjects(client, {
-        owner,
-        type: capType,
-        include: { json: true },
-    });
+    const objects = yield* listAllOwnedObjects({ owner, type: capType, include: { json: true } });
     const caps = [];
     for (const obj of objects) {
         const json = obj.json;
         if (json?.release_id)
-            caps.push({ id: obj.objectId, releaseId: json.release_id });
+            caps.push(new ReleaseAdminCap({ id: obj.objectId, releaseId: json.release_id }));
     }
     return caps;
-}
+});
 export function deriveReleaseAdminCapId(releaseId, misoPackageId) {
     return deriveObjectID(releaseId, `${misoPackageId}::release::ReleaseAdminCapKey`, UNIT_STRUCT_KEY_BYTES);
 }
@@ -532,10 +503,10 @@ export function deriveReleaseAdminCapId(releaseId, misoPackageId) {
 // Share Currency
 // ============================================================================
 /** Extracts the share type `T` from a `Currency<T>` object. */
-export async function getShareCurrencyType(client, shareCurrencyId) {
-    const { object } = await client.core.getObject({ objectId: shareCurrencyId });
-    return extractTypeParam(object.type);
-}
+export const getShareCurrencyType = Effect.fn("getShareCurrencyType")(function* (shareCurrencyId) {
+    const type = yield* getObjectType(shareCurrencyId);
+    return extractTypeParam(type);
+});
 /**
  * Finds the `TreasuryCap<ShareType>` owned by `owner`. One Core API call.
  *
@@ -547,33 +518,32 @@ export async function getShareCurrencyType(client, shareCurrencyId) {
  * compose the two:
  *
  * ```ts
- * const shareType = await getShareCurrencyType(client, shareCurrencyId);
- * const capId = await getShareCurrencyTreasuryCap(client, shareType, owner);
+ * const shareType = yield* getShareCurrencyType(shareCurrencyId);
+ * const capId = yield* getShareCurrencyTreasuryCap(shareType, owner);
  * ```
  */
-export async function getShareCurrencyTreasuryCap(client, shareType, owner) {
-    const objects = await listAllOwnedObjects(client, {
-        owner,
-        type: `0x2::coin::TreasuryCap<${shareType}>`,
-    });
+export const getShareCurrencyTreasuryCap = Effect.fn("getShareCurrencyTreasuryCap")(function* (shareType, owner) {
+    const objects = yield* listAllOwnedObjects({ owner, type: `0x2::coin::TreasuryCap<${shareType}>` });
     if (objects.length === 0) {
         throw new Error(`No TreasuryCap found for ${shareType} owned by ${owner}`);
     }
     return objects[0].objectId;
-}
+});
 // ============================================================================
 // Private
 // ============================================================================
-/** Returns the first object address of a fully-qualified type, or null. */
-async function firstAddressOfType(client, type) {
-    const result = await client.query({
-        query: AddressesByTypeQuery,
-        variables: { type },
+/** Returns the first object address of a fully-qualified type, or `Option.none()`. */
+const firstAddressOfType = Effect.fn("firstAddressOfType")(function* (type) {
+    const client = yield* SuiGraphQL;
+    const result = yield* Effect.tryPromise({
+        try: () => client.query({ query: AddressesByTypeQuery, variables: { type } }),
+        catch: (cause) => new SuiRpcError({ operation: "addressesByType", cause }),
     });
-    return result.data?.objects?.nodes?.[0]?.address ?? null;
-}
+    return Option.fromNullishOr(result.data?.objects?.nodes?.[0]?.address);
+});
 /**
- * Address of the `Recording` whose FIRST type parameter is `shareType`, or null.
+ * Address of the `Recording` whose FIRST type parameter is `shareType`, or
+ * `Option.none()`.
  *
  * `Recording<RecordingShare, CompositionShare>` takes two parameters and a type
  * filter must supply all of them or none, so filtering by
@@ -583,17 +553,21 @@ async function firstAddressOfType(client, type) {
  * first parameter client-side. A recording's share currency is unique to it, so
  * the match is unambiguous.
  */
-async function addressOfRecordingWithShareType(client, misoPackageId, shareType) {
+const addressOfRecordingWithShareType = Effect.fn("addressOfRecordingWithShareType")(function* (misoPackageId, shareType) {
+    const client = yield* SuiGraphQL;
     let cursor;
     do {
-        const result = await client.query({
-            query: `query RecordingAddress($type: String!, $cursor: String) {
-        objects(first: 50, after: $cursor, filter: { type: $type }) {
-          pageInfo { hasNextPage endCursor }
-          nodes { address asMoveObject { contents { type { repr } } } }
-        }
-      }`,
-            variables: { type: `${misoPackageId}::recording::Recording`, cursor },
+        const result = yield* Effect.tryPromise({
+            try: () => client.query({
+                query: `query RecordingAddress($type: String!, $cursor: String) {
+            objects(first: 50, after: $cursor, filter: { type: $type }) {
+              pageInfo { hasNextPage endCursor }
+              nodes { address asMoveObject { contents { type { repr } } } }
+            }
+          }`,
+                variables: { type: `${misoPackageId}::recording::Recording`, cursor },
+            }),
+            catch: (cause) => new SuiRpcError({ operation: "recordingAddress", cause }),
         });
         const page = result.data?.objects;
         for (const node of page?.nodes ?? []) {
@@ -602,10 +576,10 @@ async function addressOfRecordingWithShareType(client, misoPackageId, shareType)
                 continue;
             const [recordingShareType] = extractTypeParams2(repr);
             if (recordingShareType === shareType)
-                return node.address;
+                return Option.some(node.address);
         }
         cursor = page?.pageInfo?.hasNextPage ? page.pageInfo.endCursor : null;
     } while (cursor);
-    return null;
-}
+    return Option.none();
+});
 //# sourceMappingURL=queries.js.map