@atproto/lex-client 0.1.0-next.0 → 0.1.1

package/src/lexicons/com/atproto/repo/deleteRecord.defs.ts

@@ -9,32 +9,31 @@ const $nsid = 'com.atproto.repo.deleteRecord'
 
 export { $nsid }
 
+export const $lxm = $nsid
+export const $params = /*#__PURE__*/ l.params()
+export const $input = /*#__PURE__*/ l.jsonPayload({
+  repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
+  collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
+  rkey: /*#__PURE__*/ l.string({ format: 'record-key' }),
+  swapRecord: /*#__PURE__*/ l.optional(
+    /*#__PURE__*/ l.string({ format: 'cid' }),
+  ),
+  swapCommit: /*#__PURE__*/ l.optional(
+    /*#__PURE__*/ l.string({ format: 'cid' }),
+  ),
+})
+export const $output = /*#__PURE__*/ l.jsonPayload({
+  commit: /*#__PURE__*/ l.optional(
+    /*#__PURE__*/ l.ref<RepoDefs.CommitMeta>(
+      (() => RepoDefs.commitMeta) as any,
+    ),
+  ),
+})
 /** Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS. */
-const main =
-  /*#__PURE__*/
-  l.procedure(
-    $nsid,
-    /*#__PURE__*/ l.params(),
-    /*#__PURE__*/ l.jsonPayload({
-      repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
-      collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
-      rkey: /*#__PURE__*/ l.string({ format: 'record-key' }),
-      swapRecord: /*#__PURE__*/ l.optional(
-        /*#__PURE__*/ l.string({ format: 'cid' }),
-      ),
-      swapCommit: /*#__PURE__*/ l.optional(
-        /*#__PURE__*/ l.string({ format: 'cid' }),
-      ),
-    }),
-    /*#__PURE__*/ l.jsonPayload({
-      commit: /*#__PURE__*/ l.optional(
-        /*#__PURE__*/ l.ref<RepoDefs.CommitMeta>(
-          (() => RepoDefs.commitMeta) as any,
-        ),
-      ),
-    }),
-    ['InvalidSwap'],
-  )
+const main = /*#__PURE__*/ l.procedure($nsid, $params, $input, $output, [
+  'InvalidSwap',
+])
+
 export { main }
 
 export type $Params = l.InferMethodParams<typeof main>
@@ -48,8 +47,3 @@ export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<
   typeof main,
   B
 >
-
-export const $lxm = /*#__PURE__*/ main.nsid,
-  $params = /*#__PURE__*/ main.parameters,
-  $input = /*#__PURE__*/ main.input,
-  $output = /*#__PURE__*/ main.output

package/src/lexicons/com/atproto/repo/getRecord.defs.ts

@@ -8,24 +8,21 @@ const $nsid = 'com.atproto.repo.getRecord'
 
 export { $nsid }
 
+export const $lxm = $nsid
+export const $params = /*#__PURE__*/ l.params({
+  repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
+  collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
+  rkey: /*#__PURE__*/ l.string({ format: 'record-key' }),
+  cid: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string({ format: 'cid' })),
+})
+export const $output = /*#__PURE__*/ l.jsonPayload({
+  uri: /*#__PURE__*/ l.string({ format: 'at-uri' }),
+  cid: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string({ format: 'cid' })),
+  value: /*#__PURE__*/ l.lexMap(),
+})
 /** Get a single record from a repository. Does not require auth. */
-const main =
-  /*#__PURE__*/
-  l.query(
-    $nsid,
-    /*#__PURE__*/ l.params({
-      repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
-      collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
-      rkey: /*#__PURE__*/ l.string({ format: 'record-key' }),
-      cid: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string({ format: 'cid' })),
-    }),
-    /*#__PURE__*/ l.jsonPayload({
-      uri: /*#__PURE__*/ l.string({ format: 'at-uri' }),
-      cid: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string({ format: 'cid' })),
-      value: /*#__PURE__*/ l.lexMap(),
-    }),
-    ['RecordNotFound'],
-  )
+const main = /*#__PURE__*/ l.query($nsid, $params, $output, ['RecordNotFound'])
+
 export { main }
 
 export type $Params = l.InferMethodParams<typeof main>
@@ -34,7 +31,3 @@ export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<
   typeof main,
   B
 >
-
-export const $lxm = /*#__PURE__*/ main.nsid,
-  $params = main.parameters,
-  $output = main.output

package/src/lexicons/com/atproto/repo/listRecords.defs.ts

@@ -8,30 +8,28 @@ const $nsid = 'com.atproto.repo.listRecords'
 
 export { $nsid }
 
+export const $lxm = $nsid
+export const $params = /*#__PURE__*/ l.params({
+  repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
+  collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
+  limit: /*#__PURE__*/ l.optional(
+    /*#__PURE__*/ l.withDefault(
+      /*#__PURE__*/ l.integer({ minimum: 1, maximum: 100 }),
+      50,
+    ),
+  ),
+  cursor: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
+  reverse: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.boolean()),
+})
+export const $output = /*#__PURE__*/ l.jsonPayload({
+  cursor: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
+  records: /*#__PURE__*/ l.array(
+    /*#__PURE__*/ l.ref<Record$0>((() => record$0) as any),
+  ),
+})
 /** List a range of records in a repository, matching a specific collection. Does not require auth. */
-const main =
-  /*#__PURE__*/
-  l.query(
-    $nsid,
-    /*#__PURE__*/ l.params({
-      repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
-      collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
-      limit: /*#__PURE__*/ l.optional(
-        /*#__PURE__*/ l.withDefault(
-          /*#__PURE__*/ l.integer({ minimum: 1, maximum: 100 }),
-          50,
-        ),
-      ),
-      cursor: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
-      reverse: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.boolean()),
-    }),
-    /*#__PURE__*/ l.jsonPayload({
-      cursor: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
-      records: /*#__PURE__*/ l.array(
-        /*#__PURE__*/ l.ref<Record$0>((() => record$0) as any),
-      ),
-    }),
-  )
+const main = /*#__PURE__*/ l.query($nsid, $params, $output)
+
 export { main }
 
 export type $Params = l.InferMethodParams<typeof main>
@@ -40,11 +38,6 @@ export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<
   typeof main,
   B
 >
-
-export const $lxm = /*#__PURE__*/ main.nsid,
-  $params = main.parameters,
-  $output = main.output
-
 type Record$0 = {
   $type?: 'com.atproto.repo.listRecords#record'
   uri: l.AtUriString

package/src/lexicons/com/atproto/repo/putRecord.defs.ts

@@ -9,39 +9,38 @@ const $nsid = 'com.atproto.repo.putRecord'
 
 export { $nsid }
 
+export const $lxm = $nsid
+export const $params = /*#__PURE__*/ l.params()
+export const $input = /*#__PURE__*/ l.jsonPayload({
+  repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
+  collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
+  rkey: /*#__PURE__*/ l.string({ format: 'record-key', maxLength: 512 }),
+  validate: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.boolean()),
+  record: /*#__PURE__*/ l.lexMap(),
+  swapRecord: /*#__PURE__*/ l.optional(
+    /*#__PURE__*/ l.nullable(/*#__PURE__*/ l.string({ format: 'cid' })),
+  ),
+  swapCommit: /*#__PURE__*/ l.optional(
+    /*#__PURE__*/ l.string({ format: 'cid' }),
+  ),
+})
+export const $output = /*#__PURE__*/ l.jsonPayload({
+  uri: /*#__PURE__*/ l.string({ format: 'at-uri' }),
+  cid: /*#__PURE__*/ l.string({ format: 'cid' }),
+  commit: /*#__PURE__*/ l.optional(
+    /*#__PURE__*/ l.ref<RepoDefs.CommitMeta>(
+      (() => RepoDefs.commitMeta) as any,
+    ),
+  ),
+  validationStatus: /*#__PURE__*/ l.optional(
+    /*#__PURE__*/ l.string<{ knownValues: ['valid', 'unknown'] }>(),
+  ),
+})
 /** Write a repository record, creating or updating it as needed. Requires auth, implemented by PDS. */
-const main =
-  /*#__PURE__*/
-  l.procedure(
-    $nsid,
-    /*#__PURE__*/ l.params(),
-    /*#__PURE__*/ l.jsonPayload({
-      repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
-      collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
-      rkey: /*#__PURE__*/ l.string({ format: 'record-key', maxLength: 512 }),
-      validate: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.boolean()),
-      record: /*#__PURE__*/ l.lexMap(),
-      swapRecord: /*#__PURE__*/ l.optional(
-        /*#__PURE__*/ l.nullable(/*#__PURE__*/ l.string({ format: 'cid' })),
-      ),
-      swapCommit: /*#__PURE__*/ l.optional(
-        /*#__PURE__*/ l.string({ format: 'cid' }),
-      ),
-    }),
-    /*#__PURE__*/ l.jsonPayload({
-      uri: /*#__PURE__*/ l.string({ format: 'at-uri' }),
-      cid: /*#__PURE__*/ l.string({ format: 'cid' }),
-      commit: /*#__PURE__*/ l.optional(
-        /*#__PURE__*/ l.ref<RepoDefs.CommitMeta>(
-          (() => RepoDefs.commitMeta) as any,
-        ),
-      ),
-      validationStatus: /*#__PURE__*/ l.optional(
-        /*#__PURE__*/ l.string<{ knownValues: ['valid', 'unknown'] }>(),
-      ),
-    }),
-    ['InvalidSwap'],
-  )
+const main = /*#__PURE__*/ l.procedure($nsid, $params, $input, $output, [
+  'InvalidSwap',
+])
+
 export { main }
 
 export type $Params = l.InferMethodParams<typeof main>
@@ -55,8 +54,3 @@ export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<
   typeof main,
   B
 >
-
-export const $lxm = /*#__PURE__*/ main.nsid,
-  $params = /*#__PURE__*/ main.parameters,
-  $input = /*#__PURE__*/ main.input,
-  $output = /*#__PURE__*/ main.output

package/src/lexicons/com/atproto/repo/uploadBlob.defs.ts

@@ -8,15 +8,15 @@ const $nsid = 'com.atproto.repo.uploadBlob'
 
 export { $nsid }
 
+export const $lxm = $nsid
+export const $params = /*#__PURE__*/ l.params()
+export const $input = /*#__PURE__*/ l.payload('*/*')
+export const $output = /*#__PURE__*/ l.jsonPayload({
+  blob: /*#__PURE__*/ l.blob(),
+})
 /** Upload a new blob, to be referenced from a repository record. The blob will be deleted if it is not referenced within a time window (eg, minutes). Blob restrictions (mimetype, size, etc) are enforced when the reference is created. Requires auth, implemented by PDS. */
-const main =
-  /*#__PURE__*/
-  l.procedure(
-    $nsid,
-    /*#__PURE__*/ l.params(),
-    /*#__PURE__*/ l.payload('*/*'),
-    /*#__PURE__*/ l.jsonPayload({ blob: /*#__PURE__*/ l.blob() }),
-  )
+const main = /*#__PURE__*/ l.procedure($nsid, $params, $input, $output)
+
 export { main }
 
 export type $Params = l.InferMethodParams<typeof main>
@@ -30,8 +30,3 @@ export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<
   typeof main,
   B
 >
-
-export const $lxm = /*#__PURE__*/ main.nsid,
-  $params = /*#__PURE__*/ main.parameters,
-  $input = /*#__PURE__*/ main.input,
-  $output = /*#__PURE__*/ main.output

package/src/lexicons/com/atproto/repo.ts

@@ -2,10 +2,11 @@
  * THIS FILE WAS GENERATED BY "@atproto/lex". DO NOT EDIT.
  */
 
-export * as createRecord from './repo/createRecord.js'
+export * as applyWrites from './repo/applyWrites.js'
 export * as deleteRecord from './repo/deleteRecord.js'
 export * as getRecord from './repo/getRecord.js'
 export * as listRecords from './repo/listRecords.js'
 export * as putRecord from './repo/putRecord.js'
 export * as uploadBlob from './repo/uploadBlob.js'
+export * as createRecord from './repo/createRecord.js'
 export * as defs from './repo/defs.js'

package/src/lexicons/com/atproto/sync/getBlob.defs.ts

@@ -8,24 +8,21 @@ const $nsid = 'com.atproto.sync.getBlob'
 
 export { $nsid }
 
+export const $lxm = $nsid
+export const $params = /*#__PURE__*/ l.params({
+  did: /*#__PURE__*/ l.string({ format: 'did' }),
+  cid: /*#__PURE__*/ l.string({ format: 'cid' }),
+})
+export const $output = /*#__PURE__*/ l.payload('*/*')
 /** Get a blob associated with a given account. Returns the full blob as originally uploaded. Does not require auth; implemented by PDS. */
-const main =
-  /*#__PURE__*/
-  l.query(
-    $nsid,
-    /*#__PURE__*/ l.params({
-      did: /*#__PURE__*/ l.string({ format: 'did' }),
-      cid: /*#__PURE__*/ l.string({ format: 'cid' }),
-    }),
-    /*#__PURE__*/ l.payload('*/*'),
-    [
-      'BlobNotFound',
-      'RepoNotFound',
-      'RepoTakendown',
-      'RepoSuspended',
-      'RepoDeactivated',
-    ],
-  )
+const main = /*#__PURE__*/ l.query($nsid, $params, $output, [
+  'BlobNotFound',
+  'RepoNotFound',
+  'RepoTakendown',
+  'RepoSuspended',
+  'RepoDeactivated',
+])
+
 export { main }
 
 export type $Params = l.InferMethodParams<typeof main>
@@ -34,7 +31,3 @@ export type $OutputBody<B = l.BinaryData> = l.InferMethodOutputBody<
   typeof main,
   B
 >
-
-export const $lxm = /*#__PURE__*/ main.nsid,
-  $params = main.parameters,
-  $output = main.output

package/src/types.ts

@@ -46,18 +46,14 @@ export type Service = `${DidString}#${DidServiceIdentifier}`
  * const file: BinaryBodyInit = fileInput.files[0]
  * await client.xrpc(uploadMethod, { body: file })
  * ```
- *
- * @note Uint8Array is parameterized with ArrayBuffer (not ArrayBufferLike)
- * because fetch's BodyInit requires ArrayBuffer-backed views —
- * SharedArrayBuffer is not supported for network I/O.
  */
 export type BinaryBodyInit =
-  | Uint8Array<ArrayBuffer>
-  | ArrayBuffer
-  | Blob
-  | ReadableStream<Uint8Array<ArrayBuffer>>
-  | AsyncIterable<Uint8Array<ArrayBuffer>>
   | string
+  | Blob
+  | Uint8Array
+  | ArrayBuffer
+  | ReadableStream<Uint8Array>
+  | AsyncIterable<Uint8Array>
 
 export type EncodingString = `${string}/${string}`
 
@@ -68,7 +64,7 @@ export function isEncodingString(
 }
 
 export type XrpcUnknownResponsePayload<
-  TBinary extends BinaryBodyInit = Uint8Array<ArrayBuffer>,
+  TBinary extends BinaryBodyInit = Uint8Array,
 > = {
   encoding: EncodingString
   body: LexValue | TBinary

package/src/util.ts

@@ -1,3 +1,8 @@
+import {
+  InferRecordKey,
+  LexiconRecordKey,
+  RecordSchema,
+} from '@atproto/lex-schema'
 import type { DidString, Service } from './types.js'
 
 export function applyDefaults<
@@ -55,6 +60,19 @@ export function isAsyncIterable<T>(
   )
 }
 
+export function asUint8ArrayArrayBuffer(
+  bytes: Uint8Array,
+): Uint8Array<ArrayBuffer> {
+  // If the Uint8Array is already backed by a non-shared ArrayBuffer, we can use
+  // it directly.
+  if (bytes.buffer instanceof ArrayBuffer) {
+    return bytes as Uint8Array<ArrayBuffer>
+  }
+
+  // Otherwise, we need to create a new ArrayBuffer and copy the data.
+  return new Uint8Array(bytes)
+}
+
 export type XrpcRequestHeadersOptions = {
   /** Additional HTTP headers to include in the request. */
   headers?: HeadersInit
@@ -115,7 +133,7 @@ export function toReadableStreamPonyfill(
   data: AsyncIterable<Uint8Array>,
 ): ReadableStream<Uint8Array> {
   let iterator: AsyncIterator<Uint8Array> | undefined
-  return new ReadableStream({
+  return new ReadableStream<Uint8Array>({
     async pull(controller) {
       try {
         iterator ??= data[Symbol.asyncIterator]()
@@ -133,3 +151,32 @@ export function toReadableStreamPonyfill(
     },
   })
 }
+
+export type RecordKeyOptions<
+  T extends RecordSchema,
+  AlsoOptionalWhenRecordKeyIs extends LexiconRecordKey = never,
+> = T['key'] extends `literal:${string}` | AlsoOptionalWhenRecordKeyIs
+  ? { rkey?: InferRecordKey<T> }
+  : { rkey: InferRecordKey<T> }
+
+export function getDefaultRecordKey<const T extends RecordSchema>(
+  schema: T,
+): undefined | InferRecordKey<T> {
+  // Let the server generate the TID
+  if (schema.key === 'tid') return undefined
+  if (schema.key === 'any') return undefined
+
+  return getLiteralRecordKey(schema)
+}
+
+export function getLiteralRecordKey<const T extends RecordSchema>(
+  schema: T,
+): InferRecordKey<T> {
+  if (schema.key.startsWith('literal:')) {
+    return schema.key.slice(8) as InferRecordKey<T>
+  }
+
+  throw new TypeError(
+    `An "rkey" must be provided for record key type "${schema.key}" (${schema.$type})`,
+  )
+}

package/src/write-operation-builder.ts

@@ -0,0 +1,110 @@
+import {
+  $Typed,
+  InferInput,
+  Main,
+  RecordSchema,
+  Restricted,
+  getMain,
+} from '@atproto/lex-schema'
+import { com } from './lexicons/index.js'
+import {
+  RecordKeyOptions,
+  getDefaultRecordKey,
+  getLiteralRecordKey,
+} from './util.js'
+
+export type WriteOperation =
+  | $Typed<com.atproto.repo.applyWrites.Create>
+  | $Typed<com.atproto.repo.applyWrites.Update>
+  | $Typed<com.atproto.repo.applyWrites.Delete>
+
+export type WriteOperationCreateOptions<T extends RecordSchema> =
+  RecordKeyOptions<T, 'tid' | 'any'>
+
+export type WriteOperationUpdateOptions<T extends RecordSchema> =
+  RecordKeyOptions<T>
+
+export type WriteOperationDeleteOptions<T extends RecordSchema> =
+  RecordKeyOptions<T>
+
+export type WriteOperationsFactory = (
+  helper: WriteOperationHelper,
+) => Iterable<WriteOperation>
+
+export class WriteOperationHelper {
+  private constructor() {}
+
+  create<const T extends RecordSchema>(
+    ns: NonNullable<unknown> extends WriteOperationCreateOptions<T>
+      ? Main<T>
+      : Restricted<'This record type requires an "options" argument'>,
+    input: Omit<InferInput<T>, '$type'>,
+  ): $Typed<com.atproto.repo.applyWrites.Create>
+  create<const T extends RecordSchema>(
+    ns: Main<T>,
+    input: Omit<InferInput<T>, '$type'>,
+    options: WriteOperationCreateOptions<T>,
+  ): $Typed<com.atproto.repo.applyWrites.Create>
+  create<const T extends RecordSchema>(
+    ns: Main<T>,
+    input: Omit<InferInput<T>, '$type'>,
+    options: WriteOperationCreateOptions<T> = {} as WriteOperationCreateOptions<T>,
+  ): $Typed<com.atproto.repo.applyWrites.Create> {
+    const schema: T = getMain(ns)
+    const value = schema.build(input)
+    return com.atproto.repo.applyWrites.create.$build({
+      collection: schema.$type,
+      value,
+      rkey: options?.rkey ?? getDefaultRecordKey(schema),
+    })
+  }
+
+  update<const T extends RecordSchema>(
+    ns: NonNullable<unknown> extends WriteOperationUpdateOptions<T>
+      ? Main<T>
+      : Restricted<'This record type requires an "options" argument'>,
+    input: Omit<InferInput<T>, '$type'>,
+  ): $Typed<com.atproto.repo.applyWrites.Update>
+  update<const T extends RecordSchema>(
+    ns: Main<T>,
+    input: Omit<InferInput<T>, '$type'>,
+    options: WriteOperationUpdateOptions<T>,
+  ): $Typed<com.atproto.repo.applyWrites.Update>
+  update<const T extends RecordSchema>(
+    ns: Main<T>,
+    input: Omit<InferInput<T>, '$type'>,
+    options: WriteOperationUpdateOptions<T> = {} as WriteOperationUpdateOptions<T>,
+  ): $Typed<com.atproto.repo.applyWrites.Update> {
+    const schema: T = getMain(ns)
+    const value = schema.build(input)
+    return com.atproto.repo.applyWrites.update.$build({
+      collection: schema.$type,
+      value,
+      rkey: options?.rkey ?? getLiteralRecordKey(schema),
+    })
+  }
+
+  delete<const T extends RecordSchema>(
+    ns: NonNullable<unknown> extends WriteOperationDeleteOptions<T>
+      ? Main<T>
+      : Restricted<'This record type requires an "options" argument'>,
+  ): $Typed<com.atproto.repo.applyWrites.Delete>
+  delete<const T extends RecordSchema>(
+    ns: Main<T>,
+    options: WriteOperationDeleteOptions<T>,
+  ): $Typed<com.atproto.repo.applyWrites.Delete>
+  delete<const T extends RecordSchema>(
+    ns: Main<T>,
+    options: WriteOperationDeleteOptions<T> = {} as WriteOperationDeleteOptions<T>,
+  ): $Typed<com.atproto.repo.applyWrites.Delete> {
+    const schema: T = getMain(ns)
+    return com.atproto.repo.applyWrites.delete.$build({
+      collection: schema.$type,
+      rkey: options?.rkey ?? getLiteralRecordKey(schema),
+    })
+  }
+
+  static build(factory: WriteOperationsFactory): WriteOperation[] {
+    return Array.from(factory(new WriteOperationHelper()))
+  }
+}

package/src/xrpc.ts

@@ -19,6 +19,7 @@ import { XrpcResponse, XrpcResponseOptions } from './response.js'
 import { BinaryBodyInit } from './types.js'
 import {
   XrpcRequestHeadersOptions,
+  asUint8ArrayArrayBuffer,
   buildXrpcRequestHeaders,
   isAsyncIterable,
   isBlobLike,
@@ -336,17 +337,16 @@ function xrpcProcedureInput(
     case 'object': {
       if (body === null) break
       if (ArrayBuffer.isView(body)) {
-        return buildPayload(
-          input,
-          body as Uint8Array<ArrayBuffer>,
-          encodingHint,
-        )
+        return buildPayload(input, asUint8ArrayArrayBuffer(body), encodingHint)
       } else if (
         body instanceof ArrayBuffer ||
         body instanceof ReadableStream
       ) {
         return buildPayload(input, body, encodingHint)
       } else if (isAsyncIterable(body)) {
+        // @NOTE While fetch() does not allow SharedArrayBuffer-backed
+        // Uint8Arrays as "body", it **does** allow using ReadableStreams made
+        // of Uint8Arrays<SharedArrayBuffer> (tested on NodeJS 22) as "body".
         return buildPayload(input, toReadableStream(body), encodingHint)
       } else if (isBlobLike(body)) {
         return buildPayload(input, body, encodingHint || body.type)