@oxyhq/core 4.0.1 → 5.1.0

package/src/mixins/OxyServices.assets.ts

@@ -1,6 +1,16 @@
-import type { AccountStorageUsageResponse, AssetUploadInput, AssetUrlResponse, AssetVariant, RNFileDescriptor } from '../models/interfaces';
+import type { AccountStorageUsageResponse, AssetUploadInput, AssetUrlResponse, AssetVariant, RNFileDescriptor, ServiceAssetMetadata } from '../models/interfaces';
 import type { OxyServicesBase } from '../OxyServices.base';
-import { isReactNative } from '../utils/platform';
+import { isReactNative } from '@oxyhq/protocol';
+import { logger } from '../utils/loggerUtils';
+import { extractErrorStatus } from '../utils/errorUtils';
+
+/**
+ * Maximum number of ids sent per `POST /assets/service/by-ids` request. Matches
+ * the server-side batch cap (the route rejects empty or > 100 id arrays with a
+ * 400); larger inputs are split into multiple chunked calls and merged. Mirrors
+ * `getUsersByIds`'s `USERS_BY_IDS_CHUNK_SIZE`.
+ */
+const SERVICE_ASSET_METADATA_CHUNK_SIZE = 100;
 
 export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T) {
   return class extends Base {
@@ -8,6 +18,22 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
       super(...(args as [any]));
     }
 
+    /**
+     * Service-token request, implemented by the auth mixin earlier in the
+     * composition pipeline (see `mixins/index.ts`). The assets mixin is typed
+     * against `OxyServicesBase`, which does not carry the auth mixin's methods,
+     * so this `declare` surfaces the inherited runtime method to TypeScript
+     * without re-implementing it. Used by
+     * {@link getServiceAssetMetadataByIds} to authenticate the server-to-server
+     * `/assets/service/by-ids` bulk fetch with a bearer service token.
+     */
+    declare makeServiceRequest: <R = unknown>(
+      method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
+      url: string,
+      data?: unknown,
+      userId?: string,
+    ) => Promise<R>;
+
     /**
      * Delete file
      */
@@ -167,6 +193,74 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
       return urls;
     }
 
+    /**
+     * Resolve many Oxy asset ids to their content-addressed metadata in one
+     * round-trip per chunk via `POST /assets/service/by-ids` (body `{ ids }`).
+     *
+     * Returns each asset's `sha256`, `mime`, byte `size`, and `status` — built
+     * for server-to-server callers (e.g. Mention's MTN Protocol blob-ref
+     * resolution) that need the content hash for an asset id. Ids are
+     * deduplicated and validated (empty/blank ids dropped) before being split
+     * into chunks of {@link SERVICE_ASSET_METADATA_CHUNK_SIZE} (the server-side
+     * cap). The server omits unknown/deleted ids from each chunk's `data`, so
+     * the merged result may be shorter than the requested id list and the caller
+     * is expected to map by `id`.
+     *
+     * **Service-token auth (required).** `/assets/service/by-ids` is guarded by
+     * `serviceAuthMiddleware` + the `files:read` scope and is called via
+     * `makeServiceRequest`, which attaches `Authorization: Bearer <serviceToken>`
+     * (the same client that calls `POST /assets/service/cache`). The calling
+     * client MUST be service-configured (`configureServiceAuth(apiKey,
+     * apiSecret)`) before invoking this method; otherwise `getServiceToken()`
+     * throws because no credentials are available. A plain user-session request
+     * is rejected by the route's service-auth guard.
+     *
+     * Resilience: chunks are independent. A failed chunk is logged and skipped —
+     * the method returns every entry that resolved successfully rather than
+     * discarding the whole call on one chunk's failure. An empty/whitespace-only
+     * input resolves immediately with `[]` and performs no network call.
+     *
+     * Not cached at the SDK layer: it's a POST keyed on a multi-id body (low hit
+     * rate), mirroring the sibling service/POST methods which never cache.
+     */
+    async getServiceAssetMetadataByIds(ids: string[]): Promise<ServiceAssetMetadata[]> {
+      const uniqueIds = Array.from(
+        new Set(ids.filter((id): id is string => typeof id === 'string' && id.trim().length > 0)),
+      );
+      if (uniqueIds.length === 0) {
+        return [];
+      }
+
+      const chunks: string[][] = [];
+      for (let i = 0; i < uniqueIds.length; i += SERVICE_ASSET_METADATA_CHUNK_SIZE) {
+        chunks.push(uniqueIds.slice(i, i + SERVICE_ASSET_METADATA_CHUNK_SIZE));
+      }
+
+      // Run chunks concurrently; a single chunk failure must not sink the rest.
+      const settled = await Promise.all(
+        chunks.map(async (chunk): Promise<ServiceAssetMetadata[]> => {
+          try {
+            const entries = await this.makeServiceRequest<ServiceAssetMetadata[]>(
+              'POST',
+              '/assets/service/by-ids',
+              { ids: chunk },
+            );
+            return Array.isArray(entries) ? entries : [];
+          } catch (error: unknown) {
+            logger.warn('getServiceAssetMetadataByIds: chunk failed, continuing with remaining chunks', {
+              method: 'getServiceAssetMetadataByIds',
+              chunkSize: chunk.length,
+              status: extractErrorStatus(error),
+              error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+          }
+        }),
+      );
+
+      return settled.flat();
+    }
+
     /**
      * Upload raw file data
      */

package/src/mixins/OxyServices.auth.ts

@@ -16,7 +16,7 @@ import type { PublicApplication } from './OxyServices.connectedApps';
 import { OxyAuthenticationError } from '../OxyServices.errors';
 import { KeyManager } from '../crypto/keyManager';
 import { SignatureService } from '../crypto/signatureService';
-import { loadNodeCrypto } from '../utils/platformCrypto';
+import { loadNodeCrypto } from '@oxyhq/protocol';
 import { logger } from '../utils/loggerUtils';
 import { normalizeUserIdentity, normalizeUserIdentityOrNull } from '../utils/userIdentity';
 

package/src/mixins/OxyServices.civic.ts

@@ -49,17 +49,18 @@
  * session.
  */
 import type {
+  ChainHeadResponse,
   CredentialIssueResult,
   CredentialListResult,
   CredentialStatus,
   CredentialVerifyResult,
   ExportAttestation,
+  OxySignedRecordType,
   PersonhoodStatusResult,
   PublicCard,
   RealLifeAttestationResult,
   SignedPublicCard,
   SignedRecordEnvelope,
-  SignedRecordType,
   ValidationRequestSummary,
   ValidationVerdict,
   ValidationVoteResult,
@@ -67,7 +68,7 @@ import type {
   VouchResult,
 } from '@oxyhq/contracts';
 import type { OxyServicesBase } from '../OxyServices.base';
-import { canonicalize } from '../crypto/canonicalJson';
+import { canonicalize, verifySignature } from '@oxyhq/protocol';
 import { SignatureService } from '../crypto/signatureService';
 import { buildUserDid } from './OxyServices.identity';
 import { CACHE_TIMES } from './mixinHelpers';
@@ -290,7 +291,7 @@ export function parseAttestPayload(raw: string): ParsedAttestPayload | null {
  * key, matching the server which omits absent keys entirely) and checks the
  * `ES256K-DER-SHA256` signature against `attestation.publicKey`.
  *
- * NEVER throws: `SignatureService.verify` already swallows malformed-input
+ * NEVER throws: `verifySignature` already swallows malformed-input
  * errors and returns `false`, and an absent attestation short-circuits to
  * `false`. A pure, reusable helper (Commons can call it on a cached card).
  *
@@ -308,7 +309,7 @@ export async function verifyPublicCardAttestation(
   if (!signature || !publicKey) {
     return false;
   }
-  return SignatureService.verify(canonicalize(card), signature, publicKey);
+  return verifySignature(canonicalize(card), signature, publicKey);
 }
 
 /**
@@ -390,18 +391,6 @@ export interface RevokeCredentialResult {
   credential: VerifiableCredentialResponse;
 }
 
-/**
- * The current chain head as returned by `GET /identity/records/:userId/chain/head`.
- * `headRecordId` is `null` and `seq` is `-1` when the subject has no chain yet,
- * so the next record's coordinates are always `seq: head.seq + 1` (genesis = 0)
- * and `prev: head.headRecordId` (genesis = null).
- */
-interface ChainHeadResponse {
-  headRecordId: string | null;
-  seq: number;
-  recordCount: number;
-}
-
 export function OxyServicesCivicMixin<T extends typeof OxyServicesBase>(Base: T) {
   return class extends Base {
     constructor(...args: any[]) {
@@ -929,7 +918,7 @@ export function OxyServicesCivicMixin<T extends typeof OxyServicesBase>(Base: T)
      * @param rkey - The AtProto-style record key within the collection.
      */
     async _signMyCivicRecordV2(
-      type: SignedRecordType,
+      type: OxySignedRecordType,
       record: Record<string, unknown>,
       collection: string,
       rkey: string,

package/src/mixins/OxyServices.identity.ts

@@ -28,6 +28,7 @@ import type {
   DidDocument,
   DomainVerificationInstructions,
   ExportBundle,
+  OxySignedRecordType,
   SignedRecordEnvelope,
   VerifiedDomain,
 } from '@oxyhq/contracts';
@@ -43,8 +44,13 @@ import { CACHE_TIMES } from './mixinHelpers';
  */
 const OXY_IDENTITY_APEX = 'oxy.so';
 
-/** Record categories a client may sign and publish. */
-export type IdentityRecordType = SignedRecordEnvelope['type'];
+/**
+ * Record categories a client may sign and publish to the Oxy store. The base
+ * envelope `type` is now an open string (any app may define its own records on
+ * the shared grammar); the Oxy identity store re-narrows it to the closed Oxy
+ * record set.
+ */
+export type IdentityRecordType = OxySignedRecordType;
 
 /** Auth-method types that can be unlinked via {@link OxyServicesIdentityMixin}. */
 export type UnlinkableAuthMethodType = 'identity' | 'password' | 'google' | 'apple' | 'github';

package/src/mixins/OxyServices.language.ts

@@ -4,7 +4,7 @@
 import { normalizeLanguageCode, getLanguageMetadata, getLanguageName, getNativeLanguageName } from '../utils/languageUtils';
 import type { LanguageMetadata } from '../utils/languageUtils';
 import type { OxyServicesBase } from '../OxyServices.base';
-import { loadAsyncStorage } from '../utils/platformCrypto';
+import { loadAsyncStorage } from '@oxyhq/protocol';
 import { isDev } from '../shared/utils/debugUtils';
 
 export function OxyServicesLanguageMixin<T extends typeof OxyServicesBase>(Base: T) {

package/src/mixins/OxyServices.nodes.ts

@@ -40,6 +40,7 @@
  * server's `serializeNode` projection exactly. Dates cross the wire as ISO
  * strings.
  */
+import type { ChainHeadResponse } from '@oxyhq/contracts';
 import type { OxyServicesBase } from '../OxyServices.base';
 import { SignatureService } from '../crypto/signatureService';
 import { buildUserDid } from './OxyServices.identity';
@@ -157,18 +158,6 @@ export interface RemoveNodeResult {
   revoked: boolean;
 }
 
-/**
- * The current chain head as returned by `GET /identity/records/:userId/chain/head`.
- * `headRecordId` is `null` and `seq` is `-1` when the subject has no chain yet,
- * so the next record's coordinates are always `seq: head.seq + 1` (genesis = 0)
- * and `prev: head.headRecordId` (genesis = null).
- */
-interface ChainHeadResponse {
-  headRecordId: string | null;
-  seq: number;
-  recordCount: number;
-}
-
 export function OxyServicesNodesMixin<T extends typeof OxyServicesBase>(Base: T) {
   return class extends Base {
     constructor(...args: any[]) {

package/src/mixins/OxyServices.utility.ts

@@ -7,7 +7,7 @@
 import { jwtDecode } from 'jwt-decode';
 import type { ApiError, User } from '../models/interfaces';
 import type { OxyServicesBase } from '../OxyServices.base';
-import { loadNodeCrypto } from '../utils/platformCrypto';
+import { loadNodeCrypto } from '@oxyhq/protocol';
 import { logger } from '../utils/loggerUtils';
 import { CACHE_TIMES } from './mixinHelpers';
 
@@ -26,17 +26,6 @@ interface JwtPayload {
   [key: string]: unknown;
 }
 
-/**
- * Result from the account acting-as verification endpoint
- * (`GET /accounts/verify-acting-as`). Indicates whether a user is authorized to
- * act as a given account. The `account:act_as` capability is granted only to the
- * `owner`, `admin`, and `editor` account roles.
- */
-interface ActingAsVerification {
-  authorized: boolean;
-  role: 'owner' | 'admin' | 'editor';
-}
-
 /**
  * Result from the service-acting-as verification endpoint.
  * Confirms that a given service app holds an active delegation grant for
@@ -141,9 +130,6 @@ interface AuthMiddlewareOptions {
 
 export function OxyServicesUtilityMixin<T extends typeof OxyServicesBase>(Base: T) {
   return class extends Base {
-    /** @internal In-memory cache for acting-as verification results (TTL: 5 min) */
-    _actingAsCache = new Map<string, { result: ActingAsVerification | null; expiresAt: number }>();
-
     /**
      * In-memory cache for service-acting-as verification.
      * Negative results are cached for 1min to avoid hammering the verify
@@ -161,55 +147,6 @@ export function OxyServicesUtilityMixin<T extends typeof OxyServicesBase>(Base:
       super(...(args as [any]));
     }
 
-    /**
-     * Verify that a user is authorized to act as an account (direct membership
-     * or inherited via an ancestor). Backed by `GET /accounts/verify-acting-as`.
-     * Results are cached in-memory for 5 minutes to avoid repeated API calls.
-     *
-     * @internal Used by the auth() middleware — not part of the public API
-     */
-    async verifyActingAs(userId: string, accountId: string): Promise<ActingAsVerification | null> {
-      const cacheKey = `${userId}:${accountId}`;
-      const now = Date.now();
-
-      // Check cache
-      const cached = this._actingAsCache.get(cacheKey);
-      if (cached && cached.expiresAt > now) {
-        return cached.result;
-      }
-
-      // Query the API
-      try {
-        const result = await this.makeRequest<ActingAsVerification>(
-          'GET',
-          '/accounts/verify-acting-as',
-          { accountId, userId },
-          { cache: false, retry: false, timeout: 5000 }
-        );
-
-        // Cache successful result for 5 minutes
-        this._actingAsCache.set(cacheKey, {
-          result: result && result.authorized ? result : null,
-          expiresAt: now + 5 * 60 * 1000,
-        });
-
-        return result && result.authorized ? result : null;
-      } catch (error) {
-        logger.warn('[oxy.auth] verifyActingAs lookup failed — caching negative result', {
-          component: 'auth',
-          method: 'verifyActingAs',
-          userId,
-          accountId,
-        }, error);
-        // Cache negative result for 1 minute to avoid hammering on transient errors
-        this._actingAsCache.set(cacheKey, {
-          result: null,
-          expiresAt: now + 1 * 60 * 1000,
-        });
-        return null;
-      }
-    }
-
     /**
      * Verify that a service app holds an active delegation grant authorising
      * it to act on behalf of `userId`. Returns the grant (with allowed scopes)
@@ -362,50 +299,6 @@ export function OxyServicesUtilityMixin<T extends typeof OxyServicesBase>(Base:
 
       // Return an async middleware function
       return async (req: AuthReq, res: AuthRes, next: AuthNext) => {
-        // Process X-Acting-As header for managed account identity delegation.
-        // Called after successful authentication, before next(). If the header
-        // is present, verifies authorization and swaps the request identity to
-        // the managed account, preserving the original user for audit trails.
-        const processActingAs = async (): Promise<boolean> => {
-          const actingAsUserId = req.headers['x-acting-as'];
-          if (!actingAsUserId || typeof actingAsUserId !== 'string') return true; // No header, proceed normally
-          const currentUserId = req.userId;
-          if (!currentUserId) return true; // No authenticated user yet — nothing to swap
-
-          const verification = await oxyInstance.verifyActingAs(currentUserId, actingAsUserId);
-          if (!verification) {
-            const error = {
-              error: 'ACTING_AS_UNAUTHORIZED',
-              message: 'Not authorized to act as this account',
-              code: 'ACTING_AS_UNAUTHORIZED',
-              status: 403,
-            };
-            if (onError) {
-              onError(error);
-            } else {
-              res.status(403).json(error);
-            }
-            return false;
-          }
-
-          // Preserve original user for audit trails
-          req.originalUser = { id: currentUserId, ...(req.user ?? {}) };
-          req.actingAs = { userId: actingAsUserId, role: verification.role };
-
-          // Swap user identity to the managed account
-          req.userId = actingAsUserId;
-          req.user = { id: actingAsUserId, _id: actingAsUserId } as unknown as User;
-
-          if (debug) {
-            logger.debug(`[oxy.auth] Acting as ${actingAsUserId} (role=${verification.role}) original=${currentUserId}`, {
-              component: 'auth',
-              method: 'auth.processActingAs',
-            });
-          }
-
-          return true;
-        };
-
         try {
           // Extract token from Authorization header.
           // Node/Express normalizes `Authorization` to a string; we guard
@@ -490,9 +383,9 @@ export function OxyServicesUtilityMixin<T extends typeof OxyServicesBase>(Base:
             // Signature verification uses a manual HMAC-SHA256 compare because
             // this file ships into RN/web bundles where `jsonwebtoken` is
             // unavailable. The middleware only ever runs on Node hosts (see
-            // platformCrypto's doc-comment), and `loadNodeCrypto` is per-
-            // platform: the RN variant throws so Metro never bundles a Node
-            // built-in reference.
+            // `@oxyhq/protocol`'s `platform/crypto` doc-comment), and
+            // `loadNodeCrypto` is per-platform: the RN variant throws so Metro
+            // never bundles a Node built-in reference.
             try {
               await verifyServiceTokenSignature(token, jwtSecret);
               verifyServiceTokenClaims(decoded, {
@@ -712,9 +605,7 @@ export function OxyServicesUtilityMixin<T extends typeof OxyServicesBase>(Base:
                 });
               }
 
-              // Process X-Acting-As header before proceeding
-              if (await processActingAs()) return next();
-              return;
+              return next();
             } catch (validationError) {
               if (debug) {
                 logger.debug('[oxy.auth] Session validation failed', {
@@ -781,8 +672,7 @@ export function OxyServicesUtilityMixin<T extends typeof OxyServicesBase>(Base:
             });
           }
 
-          // Process X-Acting-As header before proceeding
-          if (await processActingAs()) next();
+          next();
         } catch (error) {
           const handled = oxyInstance.handleError(error) as Error & {
             code?: string;
@@ -1128,8 +1018,6 @@ interface AuthReq {
   sessionId?: string | null;
   serviceApp?: ServiceApp;
   serviceActingAs?: { userId: string; scopes: string[] };
-  actingAs?: { userId: string; role: string };
-  originalUser?: { id: string } & Partial<User>;
 }
 
 interface AuthRes {
@@ -1146,7 +1034,6 @@ interface SocketLike {
 }
 
 interface OxyAuthInstance {
-  verifyActingAs(userId: string, accountId: string): Promise<ActingAsVerification | null>;
   verifyServiceActingAs(appId: string, userId: string): Promise<ServiceActingAsVerification | null>;
   validateSession(
     sessionId: string,

package/src/mixins/__tests__/OxyServices.civic.test.ts

@@ -37,7 +37,7 @@ import type {
   VerifiableCredentialResponse,
 } from '@oxyhq/contracts';
 import { OxyServices } from '../../OxyServices';
-import { canonicalize } from '../../crypto/canonicalJson';
+import { canonicalize, signMessage } from '@oxyhq/protocol';
 import { SignatureService } from '../../crypto/signatureService';
 import { parseAttestPayload, parseIdPayload, verifyPublicCardAttestation } from '../OxyServices.civic';
 
@@ -61,7 +61,7 @@ async function signCard(card: PublicCard): Promise<{ attestation: ExportAttestat
   const keyPair = ec.genKeyPair();
   const privateKey = keyPair.getPrivate('hex');
   const publicKey = keyPair.getPublic('hex');
-  const signature = await SignatureService.signWithKey(canonicalize(card), privateKey);
+  const signature = await signMessage(canonicalize(card), privateKey);
   return {
     attestation: {
       issuer: 'did:web:api.oxy.so',

package/src/mixins/__tests__/OxyServices.serviceAssetMetadata.test.ts

@@ -0,0 +1,116 @@
+/**
+ * `getServiceAssetMetadataByIds` mixin tests.
+ *
+ * Stubs `makeServiceRequest` (the service-token transport used by the route's
+ * `serviceAuthMiddleware` + `files:read` scope) so the tests run with no network
+ * and no `getServiceToken()` round-trip, then asserts:
+ *  - empty / whitespace-only input no-ops to `[]` with no network call;
+ *  - input is de-duplicated and a single chunk is sent for <= 100 unique ids,
+ *    POSTed to `/assets/service/by-ids` as `{ ids }`;
+ *  - the `{ data }` envelope is unwrapped to a bare `ServiceAssetMetadata[]`
+ *    (mirroring how `makeServiceRequest<T[]>` returns the inner array);
+ *  - inputs > 100 ids are chunked at 100/request and merged;
+ *  - a failed chunk is logged and skipped — successful chunks still return.
+ */
+
+import type { ServiceAssetMetadata } from '../../models/interfaces';
+import { OxyServices } from '../../OxyServices';
+
+const sampleEntry: ServiceAssetMetadata = {
+  id: 'asset-1',
+  sha256: 'a'.repeat(64),
+  mime: 'image/jpeg',
+  size: 12345,
+  status: 'active',
+};
+
+describe('OxyServices.assets — getServiceAssetMetadataByIds', () => {
+  let oxy: OxyServices;
+  let makeServiceRequestSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    oxy = new OxyServices({ baseURL: 'http://test.invalid' });
+    makeServiceRequestSpy = jest.spyOn(oxy, 'makeServiceRequest');
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('returns [] and performs no network call for empty / whitespace input', async () => {
+    await expect(oxy.getServiceAssetMetadataByIds([])).resolves.toEqual([]);
+    await expect(oxy.getServiceAssetMetadataByIds(['', '   '])).resolves.toEqual([]);
+    expect(makeServiceRequestSpy).not.toHaveBeenCalled();
+  });
+
+  it('de-duplicates and sends a single chunk for <= 100 unique ids', async () => {
+    // makeServiceRequest unwraps the API's `{ data }` envelope, so the resolved
+    // value is the bare array (NOT `{ data: [...] }`) — mirror that real shape.
+    makeServiceRequestSpy.mockResolvedValueOnce([sampleEntry]);
+
+    const result = await oxy.getServiceAssetMetadataByIds([
+      'asset-1',
+      'asset-1', // duplicate
+      '   ', // dropped
+    ]);
+
+    expect(result).toEqual([sampleEntry]);
+    expect(makeServiceRequestSpy).toHaveBeenCalledTimes(1);
+    expect(makeServiceRequestSpy).toHaveBeenCalledWith(
+      'POST',
+      '/assets/service/by-ids',
+      { ids: ['asset-1'] },
+    );
+  });
+
+  it('chunks at 100 ids per request and merges each chunk', async () => {
+    const ids = Array.from({ length: 250 }, (_, i) => `asset-${i}`);
+
+    makeServiceRequestSpy.mockImplementation(
+      async (
+        _method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
+        _url: string,
+        data?: { ids: string[] },
+      ): Promise<ServiceAssetMetadata[]> =>
+        (data?.ids ?? []).map((id) => ({
+          id,
+          sha256: 'b'.repeat(64),
+          mime: 'application/octet-stream',
+          size: 1,
+          status: 'active' as const,
+        })),
+    );
+
+    const result = await oxy.getServiceAssetMetadataByIds(ids);
+
+    // 250 unique ids => 100 + 100 + 50 across three POSTs.
+    expect(makeServiceRequestSpy).toHaveBeenCalledTimes(3);
+    const chunkSizes = makeServiceRequestSpy.mock.calls.map(
+      (call) => (call[2] as { ids: string[] }).ids.length,
+    );
+    expect(chunkSizes).toEqual([100, 100, 50]);
+
+    expect(result).toHaveLength(250);
+    expect(result[0]).toEqual({
+      id: 'asset-0',
+      sha256: 'b'.repeat(64),
+      mime: 'application/octet-stream',
+      size: 1,
+      status: 'active',
+    });
+    expect(result[249]?.id).toBe('asset-249');
+  });
+
+  it('skips a failed chunk and returns the entries that resolved', async () => {
+    const ids = Array.from({ length: 150 }, (_, i) => `asset-${i}`);
+
+    makeServiceRequestSpy
+      .mockResolvedValueOnce([sampleEntry]) // first chunk (100 ids) succeeds
+      .mockRejectedValueOnce(new Error('chunk failed')); // second chunk (50 ids) fails
+
+    const result = await oxy.getServiceAssetMetadataByIds(ids);
+
+    expect(makeServiceRequestSpy).toHaveBeenCalledTimes(2);
+    expect(result).toEqual([sampleEntry]);
+  });
+});