effect 4.0.0-beta.50 → 4.0.0-beta.52

package/src/unstable/eventlog/SqlEventJournal.ts

@@ -71,7 +71,7 @@ export const make = (options?: {
             payload BLOB NOT NULL,
             timestamp INTEGER NOT NULL
           )`
-    })
+    }).pipe(withTracerDisabled)
 
     yield* sql.onDialectOrElse({
       pg: () =>
@@ -106,7 +106,7 @@ export const make = (options?: {
             sequence INT NOT NULL,
             PRIMARY KEY (remote_id, entry_id)
           )`
-    })
+    }).pipe(withTracerDisabled)
 
     const decodeEntryRows = Schema.decodeUnknownEffect(EntryRowArray)
     const toEntries = (rows: ReadonlyArray<EntryRow>): ReadonlyArray<EventJournal.Entry> => rows.map(toEntry)
@@ -193,6 +193,7 @@ export const make = (options?: {
 
     return EventJournal.EventJournal.of({
       entries: sql`SELECT * FROM ${entryTableSql} ORDER BY timestamp ASC`.pipe(
+        withTracerDisabled,
         Effect.flatMap(decodeEntryRows),
         Effect.map(toEntries),
         Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "entries" }))
@@ -210,10 +211,12 @@ export const make = (options?: {
           yield* PubSub.publish(pubsub, entry)
           return value
         },
+        withTracerDisabled,
         Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "write" }))
       ),
       writeFromRemote: (options) =>
         writeFromRemote(options).pipe(
+          withTracerDisabled,
           Effect.catchIf(
             (e) => e._tag !== "EventJournalError",
             (cause) => Effect.fail(new EventJournal.EventJournalError({ cause, method: "writeFromRemote" }))
@@ -232,6 +235,7 @@ export const make = (options?: {
           )
           return yield* f(entries)
         },
+        withTracerDisabled,
         Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "withRemoteUncommited" }))
       ),
       nextRemoteSequence: (remoteId) =>
@@ -242,6 +246,7 @@ export const make = (options?: {
               if (value === null || value === undefined) return 0
               return Number(value) + 1
             }),
+            withTracerDisabled,
             Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "nextRemoteSequence" }))
           ),
       changes: PubSub.subscribe(pubsub),
@@ -249,6 +254,7 @@ export const make = (options?: {
         yield* sql`DROP TABLE ${entryTableSql}`
         yield* sql`DROP TABLE ${remotesTableSql}`
       }).pipe(
+        withTracerDisabled,
         Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "destroy" }))
       ),
       withLock(_storeId) {
@@ -305,3 +311,5 @@ const RemoteRow = Schema.Struct({
 })
 
 const RemoteRowArray = Schema.Array(RemoteRow)
+
+const withTracerDisabled = Effect.withTracerEnabled(false)

package/src/unstable/eventlog/SqlEventLogServerEncrypted.ts

@@ -148,7 +148,7 @@ export const makeStorage = (options?: {
           PubSub.shutdown
         )
         return { pubsub, table } as const
-      }),
+      }, withTracerDisabled),
       idleTimeToLive: "5 minutes"
     })
 
@@ -182,6 +182,7 @@ export const makeStorage = (options?: {
           )
         },
         sql.withTransaction,
+        withTracerDisabled,
         Effect.orDie
       ),
       write: Effect.fnUntraced(
@@ -228,7 +229,8 @@ export const makeStorage = (options?: {
           return allEntries
         },
         Effect.orDie,
-        Effect.scoped
+        Effect.scoped,
+        withTracerDisabled
       ),
       changes: Effect.fnUntraced(
         function*(publicKey, storeId, startSequence) {
@@ -243,10 +245,11 @@ export const makeStorage = (options?: {
           return Stream.fromArray(initial).pipe(Stream.concat(Stream.fromSubscription(subscription)))
         },
         Effect.orDie,
+        withTracerDisabled,
         Stream.unwrap
       )
     })
-  })
+  }).pipe(withTracerDisabled)
 
 const EncryptedRemoteEntrySql = Schema.Struct({
   sequence: Schema.Number,
@@ -314,3 +317,5 @@ const makeEncryptedScopeKey = (
   publicKey: string,
   storeId: string
 ): string => `${publicKey}/${storeId}`
+
+const withTracerDisabled = Effect.withTracerEnabled(false)

package/src/unstable/eventlog/SqlEventLogServerUnencrypted.ts

@@ -322,7 +322,8 @@ export const makeStorage = (options?: {
           )
         },
         sql.withTransaction,
-        Effect.orDie
+        Effect.orDie,
+        withTracerDisabled
       ),
       entriesAfter: (storeId, entry) =>
         sql`
@@ -333,7 +334,8 @@ export const makeStorage = (options?: {
         `.pipe(
           Effect.flatMap(decodeRemoteEntries),
           Effect.map(Arr.map((r) => r.entry)),
-          Effect.orDie
+          Effect.orDie,
+          withTracerDisabled
         ),
       write: Effect.fnUntraced(
         function*(storeId, entries) {
@@ -389,6 +391,7 @@ export const makeStorage = (options?: {
         },
         Effect.scoped,
         sql.withTransaction,
+        withTracerDisabled,
         Effect.orDie
       ),
       changes: Effect.fnUntraced(
@@ -410,6 +413,7 @@ export const makeStorage = (options?: {
           )
         },
         Effect.orDie,
+        withTracerDisabled,
         Stream.unwrap
       ),
       withTransaction: (effect) =>
@@ -417,7 +421,7 @@ export const makeStorage = (options?: {
           Effect.catchIf(SqlError.isSqlError, Effect.die)
         )
     })
-  })
+  }).pipe(withTracerDisabled)
 
 /**
  * @since 4.0.0
@@ -498,3 +502,5 @@ const decodeStoreSequence = (rows: unknown): Effect.Effect<number, Schema.Schema
 const decodeSessionAuthBindings = (
   rows: unknown
 ): Effect.Effect<ReadonlyArray<SessionAuthBindingSql>, Schema.SchemaError> => decodeSessionAuthBindingRows(rows)
+
+const withTracerDisabled = Effect.withTracerEnabled(false)

package/src/unstable/httpapi/HttpApi.ts

@@ -255,7 +255,7 @@ export const reflect = <Id extends string, Groups extends HttpApiGroup.Any>(
 // -------------------------------------------------------------------------------------
 
 const extractResponseContent = (
-  schemas: readonly [Schema.Top, ...Array<Schema.Top>],
+  schemas: Array<Schema.Top>,
   getStatus: (ast: AST.AST) => number
 ): ReadonlyMap<number, [Schema.Top, ...Array<Schema.Top>]> => {
   const map = new Map<number, [Schema.Top, ...Array<Schema.Top>]>()

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -36,6 +36,7 @@ import * as Multipart from "../http/Multipart.ts"
 import * as UrlParams from "../http/UrlParams.ts"
 import type * as HttpApi from "./HttpApi.ts"
 import * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
+import { HttpApiSchemaError } from "./HttpApiError.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import * as HttpApiMiddleware from "./HttpApiMiddleware.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
@@ -589,13 +590,13 @@ function handlerToHttpEffect(
         group
       }
       if (decodeParams) {
-        request.params = yield* decodeParams(routeContext.params)
+        request.params = yield* HttpApiSchemaError.wrap("Params", decodeParams(routeContext.params))
       }
       if (decodeHeaders) {
-        request.headers = yield* decodeHeaders(httpRequest.headers)
+        request.headers = yield* HttpApiSchemaError.wrap("Headers", decodeHeaders(httpRequest.headers))
       }
       if (decodeQuery) {
-        request.query = yield* decodeQuery(query)
+        request.query = yield* HttpApiSchemaError.wrap("Query", decodeQuery(query))
       }
       if (payloadBy) {
         const result = decodePayload(payloadBy, httpRequest, query)
@@ -603,15 +604,20 @@ function handlerToHttpEffect(
           return result
         }
         if (result !== undefined) {
-          request.payload = yield* result
+          request.payload = yield* HttpApiSchemaError.wrap("Payload", result)
         }
       }
       const response = yield* handler(request)
-      return Response.isHttpServerResponse(response) ? response : yield* encodeSuccess(response)
+      return Response.isHttpServerResponse(response)
+        ? response
+        : yield* HttpApiSchemaError.wrap("Body", encodeSuccess(response))
     })
   ).pipe(
     Effect.withErrorReporting,
-    Effect.catch((error) => Effect.orDie(encodeError(error))),
+    Effect.catch((error) => {
+      if (HttpApiSchemaError.is(error)) return Effect.die(error)
+      return Effect.orDie(encodeError(error))
+    }),
     Effect.provideContext(context)
   )
 }
@@ -719,6 +725,7 @@ function makeSuccessSchema(endpoint: HttpApiEndpoint.AnyWithProps): Schema.Encod
 
 function makeErrorSchema(endpoint: HttpApiEndpoint.AnyWithProps): Schema.Encoder<HttpServerResponse, unknown> {
   const schemas = HttpApiEndpoint.getErrorSchemas(endpoint).map(toResponseErrorSchema)
+  if (schemas.length === 0) return Schema.Never
   return schemas.length === 1 ? schemas[0] : Schema.Union(schemas)
 }
 

package/src/unstable/httpapi/HttpApiClient.ts

@@ -23,7 +23,6 @@ import * as HttpMethod from "../http/HttpMethod.ts"
 import * as UrlParams from "../http/UrlParams.ts"
 import * as HttpApi from "./HttpApi.ts"
 import * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
-import type { BadRequest } from "./HttpApiError.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import type * as HttpApiMiddleware from "./HttpApiMiddleware.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
@@ -32,7 +31,7 @@ import * as HttpApiSchema from "./HttpApiSchema.ts"
  * @since 4.0.0
  * @category models
  */
-export type Client<Groups extends HttpApiGroup.Any, E = BadRequest, R = never> = Simplify<
+export type Client<Groups extends HttpApiGroup.Any, E = never, R = never> = Simplify<
   & {
     readonly [Group in Extract<Groups, { readonly topLevel: false }> as HttpApiGroup.Name<Group>]: Client.Group<
       Group,
@@ -50,7 +49,7 @@ export type Client<Groups extends HttpApiGroup.Any, E = BadRequest, R = never> =
  * @since 4.0.0
  * @category models
  */
-export type ForApi<Api extends HttpApi.Any, E = BadRequest, R = never> = Api extends
+export type ForApi<Api extends HttpApi.Any, E = never, R = never> = Api extends
   HttpApi.HttpApi<infer _Id, infer Groups> ? Client<Groups, E, R> :
   never
 
@@ -405,7 +404,7 @@ export const makeWith = <ApiId extends string, Groups extends HttpApiGroup.Any,
       | undefined
     readonly baseUrl?: URL | string | undefined
   }
-): Effect.Effect<Client<Groups, BadRequest | E, R>, never, HttpApiGroup.MiddlewareClient<Groups>> => {
+): Effect.Effect<Client<Groups, E, R>, never, HttpApiGroup.MiddlewareClient<Groups>> => {
   const client: Record<string, Record<string, any>> = {}
   return makeClient(api, {
     ...options,
@@ -440,7 +439,7 @@ export const group = <
     readonly baseUrl?: URL | string | undefined
   }
 ): Effect.Effect<
-  Client.Group<Groups, GroupName, BadRequest | E, R>,
+  Client.Group<Groups, GroupName, E, R>,
   never,
   HttpApiGroup.MiddlewareClient<HttpApiGroup.WithName<Groups, GroupName>>
 > => {
@@ -480,7 +479,7 @@ export const endpoint = <
 ): Effect.Effect<
   Client.Method<
     HttpApiEndpoint.WithName<HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>, EndpointName>,
-    BadRequest | E,
+    E,
     R
   >,
   never,

package/src/unstable/httpapi/HttpApiEndpoint.ts

@@ -16,7 +16,6 @@ import * as HttpRouter from "../http/HttpRouter.ts"
 import type { HttpServerRequest } from "../http/HttpServerRequest.ts"
 import type { HttpServerResponse } from "../http/HttpServerResponse.ts"
 import type * as Multipart from "../http/Multipart.ts"
-import { BadRequestFromSchemaError, type BadRequestNoContent } from "./HttpApiError.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import type * as HttpApiMiddleware from "./HttpApiMiddleware.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
@@ -54,7 +53,7 @@ export interface HttpApiEndpoint<
   out Payload extends Schema.Top = never,
   out Headers extends Schema.Top = never,
   out Success extends Schema.Top = typeof HttpApiSchema.NoContent,
-  out Error extends Schema.Top = typeof BadRequestNoContent,
+  out Error extends Schema.Top = never,
   in out Middleware = never,
   out MiddlewareR = never
 > extends Pipeable {
@@ -172,7 +171,7 @@ export function getSuccessSchemas(endpoint: AnyWithProps): [Schema.Top, ...Array
 }
 
 /** @internal */
-export function getErrorSchemas(endpoint: AnyWithProps): [Schema.Top, ...Array<Schema.Top>] {
+export function getErrorSchemas(endpoint: AnyWithProps): Array<Schema.Top> {
   const schemas = new Set<Schema.Top>(endpoint.error)
   for (const middleware of endpoint.middlewares) {
     const key = middleware as any as HttpApiMiddleware.AnyService
@@ -180,7 +179,7 @@ export function getErrorSchemas(endpoint: AnyWithProps): [Schema.Top, ...Array<S
       schemas.add(schema)
     }
   }
-  return Arr.append(Array.from(schemas), BadRequestFromSchemaError)
+  return Array.from(schemas)
 }
 
 /**
@@ -951,7 +950,7 @@ export const make = <Method extends HttpMethod>(method: Method): {
       : StringTree<ExtractSchemaOrArray<Payload>>,
     StringTree<Headers extends Schema.Struct.Fields ? Schema.Struct<Headers> : Headers>,
     Json<Success extends ReadonlyArray<Schema.Top> ? Success[number] : Success>,
-    Json<(Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error) | typeof BadRequestNoContent>
+    Json<Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error>
   >
   <
     const Name extends string,
@@ -983,7 +982,7 @@ export const make = <Method extends HttpMethod>(method: Method): {
     ExtractSchemaOrArray<Payload>,
     ExtractSchemaOrArray<Headers>,
     Success extends ReadonlyArray<Schema.Top> ? Success[number] : Success,
-    (Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error) | typeof BadRequestNoContent
+    Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error
   >
 } =>
 <
@@ -1018,7 +1017,7 @@ export const make = <Method extends HttpMethod>(method: Method): {
     : Payload,
   Headers extends Schema.Struct.Fields ? Schema.Struct<Headers> : Headers,
   Success extends ReadonlyArray<Schema.Top> ? Success[number] : Success,
-  (Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error) | typeof BadRequestNoContent
+  Error extends ReadonlyArray<Schema.Top> ? Error[number] : Error
 > => {
   const disableCodecs = options?.disableCodecs ?? false
   const transformStringTree = disableCodecs ? identity : Schema.toCodecStringTree

package/src/unstable/httpapi/HttpApiError.ts

@@ -1,11 +1,11 @@
 /**
  * @since 4.0.0
  */
+import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as ErrorReporter from "../../ErrorReporter.ts"
-import { identity } from "../../Function.ts"
+import { hasProperty } from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
-import * as Transformation from "../../SchemaTransformation.ts"
 import * as HttpServerRespondable from "../http/HttpServerRespondable.ts"
 import * as HttpServerResponse from "../http/HttpServerResponse.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
@@ -48,26 +48,6 @@ export const BadRequestNoContent = BadRequest.pipe(HttpApiSchema.asNoContent({
   decode: () => new BadRequest({})
 }))
 
-/**
- * @category Built-in errors
- * @since 4.0.0
- */
-export const BadRequestFromSchemaError = BadRequest.pipe(
-  Schema.decodeTo(
-    Schema.Union([Schema.declare(Schema.isSchemaError), BadRequest]),
-    Transformation.transform({
-      encode: (_) => BadRequest.singleton,
-      decode: identity
-    })
-  ),
-  HttpApiSchema.asNoContent({
-    decode: () => new BadRequest({})
-  })
-).annotate({
-  httpApiStatus: 400,
-  description: "BadRequest"
-})
-
 /**
  * @category Built-in errors
  * @since 4.0.0
@@ -332,3 +312,44 @@ export class ServiceUnavailable
 export const ServiceUnavailableNoContent = ServiceUnavailable.pipe(HttpApiSchema.asNoContent({
   decode: () => new ServiceUnavailable({})
 }))
+
+/**
+ * @category Parsing errors
+ * @since 4.0.0
+ */
+export type HttpApiSchemaErrorTypeId = "~effect/httpapi/HttpApiError/HttpApiSchemaError"
+
+/**
+ * @category Parsing errors
+ * @since 4.0.0
+ */
+export const HttpApiSchemaErrorTypeId: HttpApiSchemaErrorTypeId = "~effect/httpapi/HttpApiError/HttpApiSchemaError"
+
+/**
+ * @category Parsing errors
+ * @since 4.0.0
+ */
+export class HttpApiSchemaError extends Data.TaggedClass("HttpApiSchemaError")<{
+  readonly kind: "Params" | "Headers" | "Query" | "Body" | "Payload"
+  readonly cause: Schema.SchemaError
+}> {
+  readonly [HttpApiSchemaErrorTypeId]: HttpApiSchemaErrorTypeId = HttpApiSchemaErrorTypeId
+
+  static is(u: unknown): u is HttpApiSchemaError {
+    return hasProperty(u, HttpApiSchemaErrorTypeId)
+  }
+
+  static wrap<A, R>(
+    kind: HttpApiSchemaError["kind"],
+    effect: Effect.Effect<A, Schema.SchemaError, R>
+  ): Effect.Effect<A, HttpApiSchemaError, R> {
+    return Effect.mapError(effect, (error) => new HttpApiSchemaError({ kind, cause: error }))
+  }
+
+  readonly name = "HttpApiSchemaError"
+  readonly message = this.kind;
+
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(badRequestResponse)
+  }
+}

package/src/unstable/httpapi/HttpApiMiddleware.ts

@@ -5,7 +5,7 @@ import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import { hasProperty } from "../../Predicate.ts"
-import * as Schema from "../../Schema.ts"
+import type * as Schema from "../../Schema.ts"
 import { Scope } from "../../Scope.ts"
 import type { unhandled } from "../../Types.ts"
 import type * as HttpClientError from "../http/HttpClientError.ts"
@@ -14,6 +14,7 @@ import type * as HttpClientResponse from "../http/HttpClientResponse.ts"
 import type * as HttpRouter from "../http/HttpRouter.ts"
 import type { HttpServerResponse } from "../http/HttpServerResponse.ts"
 import type * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
+import { HttpApiSchemaError } from "./HttpApiError.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import type * as HttpApiSecurity from "./HttpApiSecurity.ts"
 
@@ -333,11 +334,11 @@ function getError(error: ErrorConstraint | undefined): ReadonlySet<Schema.Top> {
 export const layerSchemaErrorTransform = <Id, E extends ErrorConstraint, Requires>(
   service: Context.Service<Id, HttpApiMiddleware<never, E, Requires>>,
   transform: (
-    error: Schema.SchemaError,
+    error: HttpApiSchemaError,
     context: { readonly endpoint: HttpApiEndpoint.AnyWithProps; readonly group: HttpApiGroup.AnyWithProps }
   ) => Effect.Effect<
     HttpServerResponse,
-    ErrorSchemaFromConstraint<E>["Type"] | Schema.SchemaError,
+    ErrorSchemaFromConstraint<E>["Type"] | HttpApiSchemaError,
     Requires | HttpRouter.Provided
   >
 ): Layer.Layer<Id> =>
@@ -348,9 +349,9 @@ export const layerSchemaErrorTransform = <Id, E extends ErrorConstraint, Require
         httpEffect,
         (e): Effect.Effect<
           HttpServerResponse,
-          unhandled | Schema.SchemaError | ErrorSchemaFromConstraint<E>["Type"],
+          unhandled | HttpApiSchemaError | ErrorSchemaFromConstraint<E>["Type"],
           Requires | HttpRouter.Provided
-        > => Schema.isSchemaError(e) ? transform(e, options) : Effect.fail(e)
+        > => HttpApiSchemaError.is(e) ? transform(e, options) : Effect.fail(e)
       )
   )
 

package/src/unstable/httpapi/OpenApi.ts

@@ -199,21 +199,11 @@ function processAnnotation<Services, S, I>(
  * and overrides. Cached results are used for better performance when the same
  * `HttpApi` instance is processed multiple times.
  *
- * **Options**
- *
- * - `additionalProperties`: Controls how additional properties are handled while resolving the JSON schema. Possible values include:
- *   - `false`: Disallow additional properties (default)
- *   - `true`: Allow additional properties
- *   - `JsonSchema`: Use the provided JSON Schema for additional properties
- *
  * @category constructors
  * @since 4.0.0
  */
 export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
-  api: HttpApi.HttpApi<Id, Groups>,
-  options?: {
-    readonly additionalProperties?: boolean | JsonSchema.JsonSchema | undefined
-  } | undefined
+  api: HttpApi.HttpApi<Id, Groups>
 ): OpenAPISpec {
   const cached = apiCache.get(api)
   if (cached !== undefined) {
@@ -484,9 +474,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
       Arr.map(pathOps, (op) => op.ast)
     )
     const jsonSchemaMultiDocument = JsonSchema.toMultiDocumentOpenApi3_1(
-      SchemaRepresentation.toJsonSchemaMultiDocument(multiDocument, {
-        additionalProperties: options?.additionalProperties
-      })
+      SchemaRepresentation.toJsonSchemaMultiDocument(multiDocument)
     )
     const patchOps: Array<JsonPatch.JsonPatchOperation> = pathOps.map((op, i) => {
       const oppath = escapePath(op.path)
@@ -536,7 +524,7 @@ type ResponseBodies = Map<
 >
 
 function extractResponseBodies(
-  schemas: readonly [Schema.Top, ...Array<Schema.Top>],
+  schemas: Array<Schema.Top>,
   getStatus: (ast: AST.AST) => number,
   getDescription: (ast: AST.AST) => string | undefined
 ): ResponseBodies {

package/src/unstable/observability/OtlpMetrics.ts

@@ -124,7 +124,7 @@ export const make: (options: {
               if (typeof currentCount === "bigint" && typeof previousCount === "bigint") {
                 reportValue = currentCount - previousCount
                 // Handle reset: if current < previous, report current value
-                if (reportValue < 0n) {
+                if (reportValue < BigInt(0)) {
                   reportValue = currentCount
                 }
               } else {

package/src/unstable/observability/internal/protobuf.ts

@@ -29,9 +29,9 @@ const encodeTag = (fieldNumber: number, wireType: WireType): number => (fieldNum
 export const encodeVarint = (value: number | bigint): Uint8Array => {
   const bytes: Array<number> = []
   let n = typeof value === "bigint" ? value : BigInt(value)
-  while (n > 0x7fn) {
-    bytes.push(Number(n & 0x7fn) | 0x80)
-    n >>= 7n
+  while (n > BigInt(127)) {
+    bytes.push(Number(n & BigInt(127)) | 0x80)
+    n >>= BigInt(7)
   }
   bytes.push(Number(n))
   return new Uint8Array(bytes)
@@ -44,7 +44,7 @@ export const encodeVarint = (value: number | bigint): Uint8Array => {
  */
 export const encodeSint = (value: number | bigint): Uint8Array => {
   const n = typeof value === "bigint" ? value : BigInt(value)
-  const zigzag = (n << 1n) ^ (n >> 63n)
+  const zigzag = (n << BigInt(1)) ^ (n >> BigInt(63))
   return encodeVarint(zigzag)
 }
 

package/src/unstable/rpc/RpcSerialization.ts

@@ -400,47 +400,52 @@ interface JsonRpcResponse {
 type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse
 
 /**
+ * Create a MessagePack serialization with custom msgpackr options.
+ *
  * @since 4.0.0
  * @category serialization
  */
-export const msgPack: RpcSerialization["Service"] = RpcSerialization.of({
-  contentType: "application/msgpack",
-  includesFraming: true,
-  makeUnsafe: () => {
-    const unpackr = new Msgpackr.Unpackr({
-      useRecords: true
-    })
-    const packr = new Msgpackr.Packr({
-      useRecords: true
-    })
-    const encoder = new TextEncoder()
-    let incomplete: Uint8Array | undefined = undefined
-    return {
-      decode: (bytes) => {
-        let buf = typeof bytes === "string" ? encoder.encode(bytes) : bytes
-        if (incomplete !== undefined) {
-          const prev = buf
-          bytes = new Uint8Array(incomplete.length + buf.length)
-          bytes.set(incomplete)
-          bytes.set(prev, incomplete.length)
-          buf = bytes
-          incomplete = undefined
-        }
-        try {
-          return unpackr.unpackMultiple(buf)
-        } catch (error_) {
-          const error = error_ as any
-          if (error.incomplete) {
-            incomplete = buf.subarray(error.lastPosition)
-            return error.values ?? []
+export const makeMsgPack = (options?: Msgpackr.Options | undefined): RpcSerialization["Service"] =>
+  RpcSerialization.of({
+    contentType: "application/msgpack",
+    includesFraming: true,
+    makeUnsafe: () => {
+      const unpackr = new Msgpackr.Unpackr(options)
+      const packr = new Msgpackr.Packr(options)
+      const encoder = new TextEncoder()
+      let incomplete: Uint8Array | undefined = undefined
+      return {
+        decode(bytes) {
+          let buf = typeof bytes === "string" ? encoder.encode(bytes) : bytes
+          if (incomplete !== undefined) {
+            const prev = buf
+            bytes = new Uint8Array(incomplete.length + buf.length)
+            bytes.set(incomplete)
+            bytes.set(prev, incomplete.length)
+            buf = bytes
+            incomplete = undefined
           }
-          return []
-        }
-      },
-      encode: (response) => packr.pack(response)
+          try {
+            return unpackr.unpackMultiple(buf)
+          } catch (error_) {
+            const error = error_ as any
+            if (error.incomplete) {
+              incomplete = buf.subarray(error.lastPosition)
+              return error.values ?? []
+            }
+            throw error_
+          }
+        },
+        encode: (response) => packr.pack(response)
+      }
     }
-  }
-})
+  })
+
+/**
+ * @since 4.0.0
+ * @category serialization
+ */
+export const msgPack: RpcSerialization["Service"] = makeMsgPack({ useRecords: true })
 
 /**
  * A rpc serialization layer that uses JSON for serialization.

package/dist/internal/schema/to-codec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=to-codec.d.ts.map

package/dist/internal/schema/to-codec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"to-codec.d.ts","sourceRoot":"","sources":["../../../src/internal/schema/to-codec.ts"],"names":[],"mappings":""}