@orpc/client 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/shared/{client.8ug8I-zu.d.ts → client.BoXZCzuS.d.ts}

@@ -1,4 +1,5 @@
 import { PromiseWithError, Registry, MaybeOptionalOptions } from '@orpc/shared';
+import { StandardResponse } from '@standard-server/core';
 
 interface ClientContext {
     [key: PropertyKey]: any;
@@ -21,6 +22,11 @@ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext,
     [k: string]: NestedClient<TClientContext>;
 };
 type AnyNestedClient = NestedClient<any>;
+/**
+ * Infers the **client context type** required by a client.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-context | Client-Side Clients - Infer Client Context}
+ */
 type InferClientContext<T extends AnyNestedClient> = T extends NestedClient<infer U> ? U : never;
 interface ClientLink<TClientContext extends ClientContext> {
     call: (path: string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
@@ -29,6 +35,8 @@ interface ClientLink<TClientContext extends ClientContext> {
  * Recursively infers the **input types** from a client.
  *
  * Produces a nested map where each endpoint's input type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-inputs | Client-Side Clients - Infer Client Inputs}
  */
 type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientInputs<T[K]> : never;
@@ -38,6 +46,8 @@ type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer
  *
  * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
  * Produces a nested map of body input types.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-body-inputs | Client-Side Clients - Infer Client Body Inputs}
  */
 type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U extends {
     body: infer UBody;
@@ -48,6 +58,8 @@ type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, in
  * Recursively infers the **output types** from a client.
  *
  * Produces a nested map where each endpoint's output type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-outputs | Client-Side Clients - Infer Client Outputs}
  */
 type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientOutputs<T[K]> : never;
@@ -57,6 +69,8 @@ type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any,
  *
  * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
  * Produces a nested map of body output types.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-body-outputs | Client-Side Clients - Infer Client Body Outputs}
  */
 type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U extends {
     body: infer UBody;
@@ -64,22 +78,33 @@ type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, a
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientBodyOutputs<T[K]> : never;
 };
 /**
- * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#typesafe-errors).
  *
  * Produces a nested map where each endpoint's error type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-errors | Client-Side Clients - Infer Client Errors}
  */
 type InferClientErrors<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientErrors<T[K]> : never;
 };
 /**
- * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#typesafe-errors).
  *
  * Useful when you want to handle all possible errors from any endpoint at once.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-error | Client-Side Clients - Infer Client Error}
  */
 type InferClientError<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientError<T[K]> : never;
 }[keyof T];
 
+/**
+ * Default mapping between common oRPC error codes and HTTP status codes.
+ * Handlers use it to determine response status codes; spread it to build a custom `errorStatusMap`.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/handler#custom-error-response | RPC Handler - Custom Error Response}
+ * @see {@link https://orpc.dev/docs/openapi/handler#custom-error-response | OpenAPI Handler - Custom Error Response}
+ */
 declare const COMMON_ERROR_STATUS_MAP: {
     BAD_REQUEST: number;
     UNAUTHORIZED: number;
@@ -114,24 +139,26 @@ type ORPCErrorOptions<TData> = ErrorOptions & {
 } : {
     data: TData;
 });
+/**
+ * Typed error carrying a `code`, a `message`, and optional `data`.
+ * Throw it from handlers or middleware to produce typed error responses on the client.
+ *
+ * @see {@link https://orpc.dev/docs/error-handling#orpcerror-class | Error Handling - ORPCError Class}
+ */
 declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     /**
-     * @info
-     * The `__branch` property is used for type branding, helping TypeScript distinguish
+     * @remarks
+     * **Note**: The `__branch` property is used for type branding, helping TypeScript distinguish
      * an `ORPCError` instance from plain objects with a similar structure.
      */
     readonly name: "ORPCError" & {
         __branch: "ORPCError";
     };
     /**
-     * Indicates whether the error matches a definition in the procedure's `.errors` map.
+     * Indicates whether the error matches a definition in the procedure's `.errors` map,
+     * which makes its type inferable on the client.
      */
     readonly defined: boolean;
-    /**
-     * Indicates whether the error's type is inferable at the TypeScript level.
-     * This is typically true when the error is explicitly defined or returned within a handler.
-     */
-    readonly inferable: boolean;
     code: TCode;
     data: TData;
     constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
@@ -155,13 +182,26 @@ interface ORPCErrorJSON<TCode extends string, TData> extends Pick<ORPCError<TCod
      * remove readonly
      */
     defined: boolean;
-    /**
-     * remove readonly
-     */
-    inferable: boolean;
 }
 type AnyORPCError = ORPCError<any, any>;
 type AnyORPCErrorJSON = ORPCErrorJSON<any, any>;
+interface MalformedResponseErrorOptions extends ErrorOptions {
+    message?: string;
+    response: StandardResponse;
+}
+/**
+ * Error indicating a response does not follow the expected oRPC format, carrying
+ * the resolved response. Found as the `cause` of a `MALFORMED_ORPC_RESPONSE`
+ * `ORPCError`.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/link#malformed-responses | RPC Link - Malformed Responses}
+ * @see {@link https://orpc.dev/docs/openapi/link#malformed-responses | OpenAPI Link - Malformed Responses}
+ */
+declare class MalformedResponseError extends Error {
+    readonly name = "MalformedResponseError";
+    response: StandardResponse;
+    constructor(options: MalformedResponseErrorOptions);
+}
 
-export { ORPCError as c, COMMON_ERROR_STATUS_MAP as j };
-export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, ORPCErrorJSON as d, AnyNestedClient as e, InferClientError as f, Client as g, ClientRest as h, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as p };
+export { ORPCError as h, COMMON_ERROR_STATUS_MAP as j, MalformedResponseError as p };
+export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, MalformedResponseErrorOptions as M, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, AnyNestedClient as c, InferClientError as d, Client as e, ClientRest as f, ORPCErrorJSON as g, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as q };

package/dist/shared/{client.Dnfj8jnT.mjs → client.Dtv1JPkU.mjs}

@@ -1,4 +1,4 @@
-import { resolveMaybeOptionalOptions, getConstructor } from '@orpc/shared';
+import { resolveMaybeOptionalOptions, getConstructors } from '@orpc/shared';
 
 const COMMON_ERROR_STATUS_MAP = {
   BAD_REQUEST: 400,
@@ -33,20 +33,16 @@ class ORPCError extends Error {
     ORPCErrorConstructors.add(ORPCError);
   }
   /**
-   * @info
-   * The `__branch` property is used for type branding, helping TypeScript distinguish
+   * @remarks
+   * **Note**: The `__branch` property is used for type branding, helping TypeScript distinguish
    * an `ORPCError` instance from plain objects with a similar structure.
    */
   name = "ORPCError";
   /**
-   * Indicates whether the error matches a definition in the procedure's `.errors` map.
+   * Indicates whether the error matches a definition in the procedure's `.errors` map,
+   * which makes its type inferable on the client.
    */
   defined = false;
-  /**
-   * Indicates whether the error's type is inferable at the TypeScript level.
-   * This is typically true when the error is explicitly defined or returned within a handler.
-   */
-  inferable = false;
   code;
   data;
   constructor(code, ...rest) {
@@ -59,7 +55,6 @@ class ORPCError extends Error {
   toJSON() {
     return {
       defined: this.defined,
-      inferable: this.inferable,
       code: this.code,
       message: this.message,
       data: this.data
@@ -81,12 +76,21 @@ class ORPCError extends Error {
     if (!ORPCErrorConstructors.has(this)) {
       return super[Symbol.hasInstance](instance);
     }
-    const constructor = getConstructor(instance);
-    if (constructor && ORPCErrorConstructors.has(constructor)) {
-      return true;
+    for (const constructor of getConstructors(instance)) {
+      if (ORPCErrorConstructors.has(constructor)) {
+        return true;
+      }
     }
-    return super[Symbol.hasInstance](instance);
+    return false;
+  }
+}
+class MalformedResponseError extends Error {
+  name = "MalformedResponseError";
+  response;
+  constructor(options) {
+    super(options.message, options);
+    this.response = options.response;
   }
 }
 
-export { COMMON_ERROR_STATUS_MAP as C, ORPCError as O };
+export { COMMON_ERROR_STATUS_MAP as C, MalformedResponseError as M, ORPCError as O };

package/dist/shared/{client.DXhchJ84.mjs → client.VXsLhJtT.mjs}

@@ -1,8 +1,7 @@
-import { sortPlugins, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, intercept, getOpenTelemetryConfig, value, pathToHttpPath, stringifyJSON } from '@orpc/shared';
-import { mergeStandardHeaders, parseStandardUrl } from '@standardserver/core';
-import { toStandardHeaders } from '@standardserver/fetch';
-import { O as ORPCError } from './client.Dnfj8jnT.mjs';
-import { R as RPCSerializer, i as isORPCErrorJson, c as createORPCErrorFromJson } from './client.DMXKFDyV.mjs';
+import { sortPlugins, runWithSpan, ORPC_NAME, getTracer, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, intercept, value, pathToHttpPath, stringifyJSON } from '@orpc/shared';
+import { mergeStandardHeaders, parseStandardUrl } from '@standard-server/core';
+import { toStandardHeaders } from '@standard-server/fetch';
+import { R as RPCSerializer, c as createORPCErrorFromMalformedResponse, i as isORPCErrorJson, a as createORPCErrorFromJson } from './client.BYHnU_Z3.mjs';
 
 class CompositeStandardLinkPlugin {
   name = "~composite";
@@ -37,50 +36,46 @@ class StandardLink {
     return runWithSpan(`${ORPC_NAME}.${path.join("/")}`, (span) => {
       span?.setAttribute("rpc.system", ORPC_NAME);
       span?.setAttribute("rpc.method", path.join("."));
-      if (isAsyncIteratorObject(input)) {
-        input = override(input, traceAsyncIterator("consume_event_iterator_input", input));
+      if (getTracer() && isAsyncIteratorObject(input)) {
+        input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
+      } else if (getTracer() && input instanceof ReadableStream) {
+        input = override(input, traceReadableStream("consume_octet_stream_input", input));
       }
       return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
-        const otel = getOpenTelemetryConfig();
-        let activeContext;
-        const activeSpan = otel?.trace.getActiveSpan() ?? span;
-        if (activeSpan && otel) {
-          activeContext = otel.trace.setSpan(otel.context.active(), activeSpan);
-        }
+        const tracer = getTracer();
+        const activeSpan = tracer?.getActiveSpan() ?? span;
         let request = await runWithSpan(
-          { name: "encode_input", context: activeContext },
+          { name: "encode_input", parent: activeSpan },
           () => this.codec.encodeInput(input2, path2, options2)
         );
-        if (activeContext && otel?.propagation) {
+        if (activeSpan && tracer?.inject) {
           const headers = { ...request.headers };
-          otel.propagation.inject(activeContext, headers);
+          tracer.inject(activeSpan, headers);
           request = { ...request, headers };
         }
         const response = await intercept(
           this.transportInterceptors,
           { ...options2, path: path2, request },
           ({ path: path3, request: request2, ...options3 }) => {
-            let activeTransportContext;
-            const activeTransportSpan = otel?.trace.getActiveSpan() ?? activeSpan;
-            if (activeTransportSpan && otel) {
-              activeTransportContext = otel.trace.setSpan(otel.context.active(), activeTransportSpan);
-            }
+            const activeTransportSpan = tracer?.getActiveSpan() ?? activeSpan;
             return runWithSpan(
-              { name: "send_request", context: activeTransportContext },
+              { name: "send_request", parent: activeTransportSpan },
               () => this.transport.send(request2, path3, options3)
             );
           }
         );
         const decodedResult = await runWithSpan(
-          { name: "decode_response", context: activeContext },
+          { name: "decode_response", parent: activeSpan },
           () => this.codec.decodeResponse(response, path2, options2)
         );
         if (decodedResult.kind === "error") {
           throw decodedResult.error;
         }
         const output = decodedResult.output;
-        if (isAsyncIteratorObject(output)) {
-          return override(output, traceAsyncIterator("consume_event_iterator_output", output));
+        if (getTracer() && isAsyncIteratorObject(output)) {
+          return override(output, traceAsyncIterator("consume_async_iterator_object_output", output));
+        } else if (getTracer() && output instanceof ReadableStream) {
+          return override(output, traceReadableStream("consume_octet_stream_output", output));
         }
         return output;
       });
@@ -139,13 +134,15 @@ class RPCLinkCodec {
     };
   }
   async decodeResponse(response) {
-    const isOk = response.status >= 200 && response.status < 400;
+    const isOk = response.status < 400;
     const body = await response.resolveBody();
     const deserialized = await (async () => {
       try {
         return this.serializer.deserialize(body);
       } catch (cause) {
-        throw new Error("Invalid RPC response format.", {
+        throw createORPCErrorFromMalformedResponse({
+          message: "Invalid RPC response format.",
+          response: { status: response.status, headers: response.headers, body },
           cause
         });
       }
@@ -156,9 +153,7 @@ class RPCLinkCodec {
       }
       return {
         kind: "error",
-        error: new ORPCError("MALFORMED_ORPC_ERROR_RESPONSE", {
-          data: { headers: response.headers, status: response.status, body: deserialized }
-        })
+        error: createORPCErrorFromMalformedResponse({ response: { headers: response.headers, status: response.status, body } })
       };
     }
     return { kind: "output", output: deserialized };

package/dist/shared/{client.BdItY5DT.d.mts → client.n8K9dFhY.d.mts}

@@ -1,4 +1,4 @@
-import { StandardBody } from '@standardserver/core';
+import { StandardBody } from '@standard-server/core';
 import { Segment } from '@orpc/shared';
 
 type RPCJsonSerializationMeta = [type: string, ...path: Segment[]];
@@ -16,7 +16,10 @@ type RPCJsonSerialization = {
 interface RPCJsonSerializerHandler {
     condition(value: unknown): boolean;
     serialize(value: any): unknown;
-    deserialize(serialized: any): unknown;
+    /**
+     * `serialized` comes from the wire, so validate its type and throw on mismatch.
+     */
+    deserialize(serialized: unknown): unknown;
     /**
      * If false, the result of this serializer will not be further processed by other serializers,
      * even if it matches their conditions and treat it as final serialized value.
@@ -60,10 +63,10 @@ interface RPCJsonSerializerOptions {
      *
      * **Disabling:** Set a key to `undefined` to remove a built-in handler:
      * ```ts
-     * handlers: { regexp: undefined }
+     * handlers: { url: undefined }
      * ```
      *
-     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `regexp`, `set`, `map`.
+     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `set`, `map`.
      */
     handlers?: Record<string, undefined | RPCJsonSerializerHandler> | undefined;
     /**
@@ -73,11 +76,23 @@ interface RPCJsonSerializerOptions {
      */
     omitUndefinedProperties?: boolean | undefined;
 }
+/**
+ * Serializes and deserializes native types like Date, BigInt, Set, and Map
+ * into a JSON value plus separate metadata describing how to restore them.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/serializer#rpc-json-serializer | RPC Serializer - RPC JSON Serializer}
+ */
 declare class RPCJsonSerializer {
     private readonly handlers;
+    private readonly inlineBuiltInHandlers;
+    private readonly handlerEntries;
     private readonly omitUndefinedProperties;
     constructor(options?: RPCJsonSerializerOptions);
     serialize(data: unknown): RPCJsonSerialization;
+    /**
+     * `segments` is a shared mutable stack (push/pop while walking),
+     * so it must be copied before being stored in `meta` or `maps`.
+     */
     private serializeValue;
     deserialize(serialized: RPCJsonSerialization): unknown;
 }
@@ -97,6 +112,12 @@ interface RPCSerializerOptions extends RPCJsonSerializerOptions {
      */
     serialize?: RPCSerializerSerializeOptions | undefined;
 }
+/**
+ * Serializes and deserializes data for the RPC protocol,
+ * preserving native types like Date, BigInt, Set, and Map that plain JSON cannot represent.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/serializer | RPC Serializer}
+ */
 declare class RPCSerializer {
     private readonly jsonSerializer;
     private readonly defaultSerializeOptions;

package/dist/shared/{client.BdItY5DT.d.ts → client.n8K9dFhY.d.ts}

@@ -1,4 +1,4 @@
-import { StandardBody } from '@standardserver/core';
+import { StandardBody } from '@standard-server/core';
 import { Segment } from '@orpc/shared';
 
 type RPCJsonSerializationMeta = [type: string, ...path: Segment[]];
@@ -16,7 +16,10 @@ type RPCJsonSerialization = {
 interface RPCJsonSerializerHandler {
     condition(value: unknown): boolean;
     serialize(value: any): unknown;
-    deserialize(serialized: any): unknown;
+    /**
+     * `serialized` comes from the wire, so validate its type and throw on mismatch.
+     */
+    deserialize(serialized: unknown): unknown;
     /**
      * If false, the result of this serializer will not be further processed by other serializers,
      * even if it matches their conditions and treat it as final serialized value.
@@ -60,10 +63,10 @@ interface RPCJsonSerializerOptions {
      *
      * **Disabling:** Set a key to `undefined` to remove a built-in handler:
      * ```ts
-     * handlers: { regexp: undefined }
+     * handlers: { url: undefined }
      * ```
      *
-     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `regexp`, `set`, `map`.
+     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `set`, `map`.
      */
     handlers?: Record<string, undefined | RPCJsonSerializerHandler> | undefined;
     /**
@@ -73,11 +76,23 @@ interface RPCJsonSerializerOptions {
      */
     omitUndefinedProperties?: boolean | undefined;
 }
+/**
+ * Serializes and deserializes native types like Date, BigInt, Set, and Map
+ * into a JSON value plus separate metadata describing how to restore them.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/serializer#rpc-json-serializer | RPC Serializer - RPC JSON Serializer}
+ */
 declare class RPCJsonSerializer {
     private readonly handlers;
+    private readonly inlineBuiltInHandlers;
+    private readonly handlerEntries;
     private readonly omitUndefinedProperties;
     constructor(options?: RPCJsonSerializerOptions);
     serialize(data: unknown): RPCJsonSerialization;
+    /**
+     * `segments` is a shared mutable stack (push/pop while walking),
+     * so it must be copied before being stored in `meta` or `maps`.
+     */
     private serializeValue;
     deserialize(serialized: RPCJsonSerialization): unknown;
 }
@@ -97,6 +112,12 @@ interface RPCSerializerOptions extends RPCJsonSerializerOptions {
      */
     serialize?: RPCSerializerSerializeOptions | undefined;
 }
+/**
+ * Serializes and deserializes data for the RPC protocol,
+ * preserving native types like Date, BigInt, Set, and Map that plain JSON cannot represent.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/serializer | RPC Serializer}
+ */
 declare class RPCSerializer {
     private readonly jsonSerializer;
     private readonly defaultSerializeOptions;

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.40",
+  "description": "Consume oRPC and OpenAPI APIs with end-to-end type safety over HTTP, WebSocket, or message ports",
   "license": "MIT",
+  "funding": [
+    "https://github.com/sponsors/dinwwwh",
+    "https://opencollective.com/middleapi"
+  ],
   "homepage": "https://orpc.dev",
   "repository": {
     "type": "git",
@@ -10,7 +15,15 @@
     "directory": "packages/client"
   },
   "keywords": [
-    "orpc"
+    "orpc",
+    "rpc",
+    "api",
+    "typescript",
+    "typesafe",
+    "client",
+    "fetch",
+    "websocket",
+    "openapi"
   ],
   "sideEffects": false,
   "exports": {
@@ -50,16 +63,15 @@
     "dist"
   ],
   "dependencies": {
-    "@standardserver/core": "^0.0.25",
-    "@standardserver/fetch": "^0.0.25",
-    "@standardserver/peer": "^0.0.25",
-    "@orpc/shared": "2.0.0-beta.4"
+    "@orpc/shared": "2.0.0-beta.40",
+    "@standard-server/core": "~0.9.2",
+    "@standard-server/fetch": "~0.9.2",
+    "@standard-server/peer": "~0.9.2"
   },
   "devDependencies": {
-    "zod": "^4.4.3"
+    "zod": "^4.5.4"
   },
   "scripts": {
-    "build": "unbuild",
     "type:check": "tsc -b"
   }
 }