@orpc/server 0.0.0-next.c3068b4 → 0.0.0-next.c40d0c9

package/dist/shared/server.Prfzu_zf.mjs

@@ -0,0 +1,98 @@
+import { ORPCError } from '@orpc/client';
+import { StandardRPCJsonSerializer, StandardRPCSerializer } from '@orpc/client/standard';
+import { S as StandardHandler, b as StandardRPCMatcher, a as StandardRPCCodec } from './server.DCCkTG29.mjs';
+import { toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, toFetchResponse } from '@orpc/standard-server-fetch';
+import { r as resolveFriendlyStandardHandleOptions } from './server.BVwwTHyO.mjs';
+
+class BodyLimitPlugin {
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.push(async (options2) => {
+      if (!options2.request.body) {
+        return options2.next();
+      }
+      let currentBodySize = 0;
+      const rawReader = options2.request.body.getReader();
+      const reader = new ReadableStream({
+        start: async (controller) => {
+          try {
+            if (Number(options2.request.headers.get("content-length")) > this.maxBodySize) {
+              controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+              return;
+            }
+            while (true) {
+              const { done, value } = await rawReader.read();
+              if (done) {
+                break;
+              }
+              currentBodySize += value.length;
+              if (currentBodySize > this.maxBodySize) {
+                controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+                break;
+              }
+              controller.enqueue(value);
+            }
+          } finally {
+            controller.close();
+          }
+        }
+      });
+      const requestInit = { body: reader, duplex: "half" };
+      return options2.next({
+        ...options2,
+        request: new Request(options2.request, requestInit)
+      });
+    });
+  }
+}
+
+class FetchHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    for (const plugin of toArray(options.plugins)) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+    this.toFetchResponseOptions = options;
+  }
+  toFetchResponseOptions;
+  adapterInterceptors;
+  async handle(request, ...rest) {
+    return intercept(
+      this.adapterInterceptors,
+      {
+        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        request,
+        toFetchResponseOptions: this.toFetchResponseOptions
+      },
+      async ({ request: request2, toFetchResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(request2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return result;
+        }
+        return {
+          matched: true,
+          response: toFetchResponse(result.response, toFetchResponseOptions)
+        };
+      }
+    );
+  }
+}
+
+class RPCHandler extends FetchHandler {
+  constructor(router, options = {}) {
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
+    const matcher = new StandardRPCMatcher();
+    const codec = new StandardRPCCodec(serializer);
+    super(new StandardHandler(router, matcher, codec, options), options);
+  }
+}
+
+export { BodyLimitPlugin as B, FetchHandler as F, RPCHandler as R };

package/dist/shared/server.e3W6AG3-.mjs

@@ -0,0 +1,370 @@
+import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
+import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
+import { value, intercept } from '@orpc/shared';
+
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazy(loader, meta = {}) {
+  return {
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
+  };
+}
+function isLazy(item) {
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
+}
+function unlazy(lazied) {
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+
+function isStartWithMiddlewares(middlewares, compare) {
+  if (compare.length > middlewares.length) {
+    return false;
+  }
+  for (let i = 0; i < middlewares.length; i++) {
+    if (compare[i] === void 0) {
+      return true;
+    }
+    if (middlewares[i] !== compare[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function mergeMiddlewares(first, second, options) {
+  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
+    return second;
+  }
+  return [...first, ...second];
+}
+function addMiddleware(middlewares, addition) {
+  return [...middlewares, addition];
+}
+
+class Procedure {
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+}
+function isProcedure(item) {
+  if (item instanceof Procedure) {
+    return true;
+  }
+  return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
+}
+
+function mergeCurrentContext(context, other) {
+  return { ...context, ...other };
+}
+
+function createORPCErrorConstructorMap(errors) {
+  const proxy = new Proxy(errors, {
+    get(target, code) {
+      if (typeof code !== "string") {
+        return Reflect.get(target, code);
+      }
+      const item = (...[options]) => {
+        const config = errors[code];
+        return new ORPCError(code, {
+          defined: Boolean(config),
+          status: config?.status,
+          message: options?.message ?? config?.message,
+          data: options?.data,
+          cause: options?.cause
+        });
+      };
+      return item;
+    }
+  });
+  return proxy;
+}
+async function validateORPCError(map, error) {
+  const { code, status, message, data, cause, defined } = error;
+  const config = map?.[error.code];
+  if (!config || fallbackORPCErrorStatus(error.code, config.status) !== error.status) {
+    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
+  }
+  if (!config.data) {
+    return defined ? error : new ORPCError(code, { defined: true, status, message, data, cause });
+  }
+  const validated = await config.data["~standard"].validate(error.data);
+  if (validated.issues) {
+    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
+  }
+  return new ORPCError(code, { defined: true, status, message, data: validated.value, cause });
+}
+
+function middlewareOutputFn(output) {
+  return { output, context: {} };
+}
+
+function createProcedureClient(lazyableProcedure, ...[options]) {
+  return async (...[input, callerOptions]) => {
+    const path = options?.path ?? [];
+    const { default: procedure } = await unlazy(lazyableProcedure);
+    const clientContext = callerOptions?.context ?? {};
+    const context = await value(options?.context ?? {}, clientContext);
+    const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
+    try {
+      return await intercept(
+        options?.interceptors ?? [],
+        {
+          context,
+          input,
+          // input only optional when it undefinable so we can safely cast it
+          errors,
+          path,
+          procedure,
+          signal: callerOptions?.signal,
+          lastEventId: callerOptions?.lastEventId
+        },
+        (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+      );
+    } catch (e) {
+      if (!(e instanceof ORPCError)) {
+        throw e;
+      }
+      const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
+      throw validated;
+    }
+  };
+}
+async function validateInput(procedure, input) {
+  const schema = procedure["~orpc"].inputSchema;
+  if (!schema) {
+    return input;
+  }
+  const result = await schema["~standard"].validate(input);
+  if (result.issues) {
+    throw new ORPCError("BAD_REQUEST", {
+      message: "Input validation failed",
+      data: {
+        issues: result.issues
+      },
+      cause: new ValidationError({ message: "Input validation failed", issues: result.issues })
+    });
+  }
+  return result.value;
+}
+async function validateOutput(procedure, output) {
+  const schema = procedure["~orpc"].outputSchema;
+  if (!schema) {
+    return output;
+  }
+  const result = await schema["~standard"].validate(output);
+  if (result.issues) {
+    throw new ORPCError("INTERNAL_SERVER_ERROR", {
+      message: "Output validation failed",
+      cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
+    });
+  }
+  return result.value;
+}
+async function executeProcedureInternal(procedure, options) {
+  const middlewares = procedure["~orpc"].middlewares;
+  const inputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].inputValidationIndex), middlewares.length);
+  const outputValidationIndex = Math.min(Math.max(0, procedure["~orpc"].outputValidationIndex), middlewares.length);
+  let currentIndex = 0;
+  let currentContext = options.context;
+  let currentInput = options.input;
+  const next = async (...[nextOptions]) => {
+    const index = currentIndex;
+    const midContext = nextOptions?.context ?? {};
+    currentIndex += 1;
+    currentContext = mergeCurrentContext(currentContext, midContext);
+    if (index === inputValidationIndex) {
+      currentInput = await validateInput(procedure, currentInput);
+    }
+    const mid = middlewares[index];
+    const result = mid ? {
+      context: midContext,
+      output: (await mid({ ...options, context: currentContext, next }, currentInput, middlewareOutputFn)).output
+    } : {
+      context: midContext,
+      output: await procedure["~orpc"].handler({ ...options, context: currentContext, input: currentInput })
+    };
+    if (index === outputValidationIndex) {
+      const validatedOutput = await validateOutput(procedure, result.output);
+      return {
+        context: result.context,
+        output: validatedOutput
+      };
+    }
+    return result;
+  };
+  return (await next()).output;
+}
+
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
+function setHiddenRouterContract(router, contract) {
+  return new Proxy(router, {
+    get(target, key) {
+      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
+        return contract;
+      }
+      return Reflect.get(target, key);
+    }
+  });
+}
+function getHiddenRouterContract(router) {
+  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+}
+
+function getRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!current) {
+      return void 0;
+    }
+    if (isProcedure(current)) {
+      return void 0;
+    }
+    if (!isLazy(current)) {
+      current = current[segment];
+      continue;
+    }
+    const lazied = current;
+    const rest = path.slice(i);
+    return lazy(async () => {
+      const unwrapped = await unlazy(lazied);
+      const next = getRouter(unwrapped.default, rest);
+      return unlazy(next);
+    }, getLazyMeta(lazied));
+  }
+  return current;
+}
+function createAccessibleLazyRouter(lazied) {
+  const recursive = new Proxy(lazied, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouter(lazied, [key]);
+      return createAccessibleLazyRouter(next);
+    }
+  });
+  return recursive;
+}
+function enhanceRouter(router, options) {
+  if (isLazy(router)) {
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhanced2 = lazy(async () => {
+      const { default: unlaziedRouter } = await unlazy(router);
+      const enhanced3 = enhanceRouter(unlaziedRouter, options);
+      return unlazy(enhanced3);
+    }, {
+      ...laziedMeta,
+      prefix: enhancedPrefix
+    });
+    const accessible = createAccessibleLazyRouter(enhanced2);
+    return accessible;
+  }
+  if (isProcedure(router)) {
+    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, { dedupeLeading: options.dedupeLeadingMiddlewares });
+    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      route: enhanceRoute(router["~orpc"].route, options),
+      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+      middlewares: newMiddlewares,
+      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
+      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
+    });
+    return enhanced2;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceRouter(router[key], options);
+  }
+  return enhanced;
+}
+function traverseContractProcedures(options, callback, lazyOptions = []) {
+  let currentRouter = options.router;
+  const hiddenContract = getHiddenRouterContract(options.router);
+  if (hiddenContract !== void 0) {
+    currentRouter = hiddenContract;
+  }
+  if (isLazy(currentRouter)) {
+    lazyOptions.push({
+      router: currentRouter,
+      path: options.path
+    });
+  } else if (isContractProcedure(currentRouter)) {
+    callback({
+      contract: currentRouter,
+      path: options.path
+    });
+  } else {
+    for (const key in currentRouter) {
+      traverseContractProcedures(
+        {
+          router: currentRouter[key],
+          path: [...options.path, key]
+        },
+        callback,
+        lazyOptions
+      );
+    }
+  }
+  return lazyOptions;
+}
+async function resolveContractProcedures(options, callback) {
+  const pending = [options];
+  for (const options2 of pending) {
+    const lazyOptions = traverseContractProcedures(options2, callback);
+    for (const options3 of lazyOptions) {
+      const { default: router } = await unlazy(options3.router);
+      pending.push({
+        router,
+        path: options3.path
+      });
+    }
+  }
+}
+async function unlazyRouter(router) {
+  if (isProcedure(router)) {
+    return router;
+  }
+  const unlazied = {};
+  for (const key in router) {
+    const item = router[key];
+    const { default: unlaziedRouter } = await unlazy(item);
+    unlazied[key] = await unlazyRouter(unlaziedRouter);
+  }
+  return unlazied;
+}
+
+function createAssertedLazyProcedure(lazied) {
+  const lazyProcedure = lazy(async () => {
+    const { default: maybeProcedure } = await unlazy(lazied);
+    if (!isProcedure(maybeProcedure)) {
+      throw new Error(`
+            Expected a lazy<procedure> but got lazy<unknown>.
+            This should be caught by TypeScript compilation.
+            Please report this issue if this makes you feel uncomfortable.
+        `);
+    }
+    return { default: maybeProcedure };
+  }, getLazyMeta(lazied));
+  return lazyProcedure;
+}
+function createContractedProcedure(procedure, contract) {
+  return new Procedure({
+    ...procedure["~orpc"],
+    errorMap: contract["~orpc"].errorMap,
+    route: contract["~orpc"].route,
+    meta: contract["~orpc"].meta
+  });
+}
+function call(procedure, input, ...rest) {
+  return createProcedureClient(procedure, ...rest)(input);
+}
+
+export { LAZY_SYMBOL as L, Procedure as P, createContractedProcedure as a, addMiddleware as b, createProcedureClient as c, isLazy as d, enhanceRouter as e, createAssertedLazyProcedure as f, getRouter as g, createORPCErrorConstructorMap as h, isProcedure as i, getLazyMeta as j, middlewareOutputFn as k, lazy as l, mergeCurrentContext as m, isStartWithMiddlewares as n, mergeMiddlewares as o, call as p, getHiddenRouterContract as q, createAccessibleLazyRouter as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u, validateORPCError as v, resolveContractProcedures as w, unlazyRouter as x };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.c3068b4",
+  "version": "0.0.0-next.c40d0c9",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,42 +15,42 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
     },
     "./standard": {
-      "types": "./dist/src/adapters/standard/index.d.ts",
-      "import": "./dist/standard.js",
-      "default": "./dist/standard.js"
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     },
     "./hono": {
-      "types": "./dist/src/adapters/hono/index.d.ts",
-      "import": "./dist/hono.js",
-      "default": "./dist/hono.js"
+      "types": "./dist/adapters/hono/index.d.mts",
+      "import": "./dist/adapters/hono/index.mjs",
+      "default": "./dist/adapters/hono/index.mjs"
     },
     "./next": {
-      "types": "./dist/src/adapters/next/index.d.ts",
-      "import": "./dist/next.js",
-      "default": "./dist/next.js"
+      "types": "./dist/adapters/next/index.d.mts",
+      "import": "./dist/adapters/next/index.mjs",
+      "default": "./dist/adapters/next/index.mjs"
     },
     "./node": {
-      "types": "./dist/src/adapters/node/index.d.ts",
-      "import": "./dist/node.js",
-      "default": "./dist/node.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/adapters/node/index.d.mts",
+      "import": "./dist/adapters/node/index.mjs",
+      "default": "./dist/adapters/node/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
@@ -58,15 +58,18 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "content-disposition": "^0.5.4",
-    "@orpc/contract": "0.0.0-next.c3068b4",
-    "@orpc/shared": "0.0.0-next.c3068b4"
+    "@orpc/client": "0.0.0-next.c40d0c9",
+    "@orpc/standard-server": "0.0.0-next.c40d0c9",
+    "@orpc/shared": "0.0.0-next.c40d0c9",
+    "@orpc/standard-server-fetch": "0.0.0-next.c40d0c9",
+    "@orpc/standard-server-node": "0.0.0-next.c40d0c9",
+    "@orpc/contract": "0.0.0-next.c40d0c9"
   },
   "devDependencies": {
-    "light-my-request": "^6.5.1"
+    "supertest": "^7.0.0"
   },
   "scripts": {
-    "build": "tsup --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-6RSW63UJ.js

@@ -1,136 +0,0 @@
-import {
-  RPCCodec,
-  RPCMatcher,
-  StandardHandler
-} from "./chunk-JHLUGXCM.js";
-
-// src/adapters/fetch/utils.ts
-import { once } from "@orpc/shared";
-import cd from "content-disposition";
-function fetchHeadersToStandardHeaders(headers) {
-  const standardHeaders = {};
-  for (const [key, value] of headers) {
-    if (Array.isArray(standardHeaders[key])) {
-      standardHeaders[key].push(value);
-    } else if (standardHeaders[key] !== void 0) {
-      standardHeaders[key] = [standardHeaders[key], value];
-    } else {
-      standardHeaders[key] = value;
-    }
-  }
-  return standardHeaders;
-}
-async function fetchReToStandardBody(re) {
-  if (!re.body) {
-    return void 0;
-  }
-  const contentDisposition = re.headers.get("content-disposition");
-  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
-  if (fileName) {
-    const blob2 = await re.blob();
-    return new File([blob2], fileName, {
-      type: blob2.type
-    });
-  }
-  const contentType = re.headers.get("content-type");
-  if (!contentType || contentType.startsWith("application/json")) {
-    const text = await re.text();
-    if (!text) {
-      return void 0;
-    }
-    return JSON.parse(text);
-  }
-  if (contentType.startsWith("multipart/form-data")) {
-    return await re.formData();
-  }
-  if (contentType.startsWith("application/x-www-form-urlencoded")) {
-    return new URLSearchParams(await re.text());
-  }
-  if (contentType.startsWith("text/")) {
-    return await re.text();
-  }
-  const blob = await re.blob();
-  return new File([blob], "blob", {
-    type: blob.type
-  });
-}
-function fetchRequestToStandardRequest(request) {
-  const url = new URL(request.url);
-  return {
-    raw: { request },
-    url,
-    signal: request.signal,
-    method: request.method,
-    body: once(() => {
-      return fetchReToStandardBody(request);
-    }),
-    get headers() {
-      const headers = fetchHeadersToStandardHeaders(request.headers);
-      Object.defineProperty(this, "headers", { value: headers, writable: true });
-      return headers;
-    },
-    set headers(value) {
-      Object.defineProperty(this, "headers", { value, writable: true });
-    }
-  };
-}
-function standardResponseToFetchHeaders(response) {
-  const fetchHeaders = new Headers();
-  for (const [key, value] of Object.entries(response.headers)) {
-    if (Array.isArray(value)) {
-      for (const v of value) {
-        fetchHeaders.append(key, v);
-      }
-    } else if (value !== void 0) {
-      fetchHeaders.append(key, value);
-    }
-  }
-  if (response.body instanceof Blob && !fetchHeaders.has("content-disposition")) {
-    fetchHeaders.set("content-disposition", cd(response.body instanceof File ? response.body.name : "blob"));
-  } else if (!(response.body instanceof Blob) && !(response.body instanceof URLSearchParams) && !(response.body instanceof FormData) && response.body !== void 0 && !fetchHeaders.has("content-type")) {
-    fetchHeaders.set("content-type", "application/json");
-  }
-  return fetchHeaders;
-}
-function standardBodyToFetchBody(body) {
-  if (body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams) {
-    return body;
-  }
-  return JSON.stringify(body);
-}
-function standardResponseToFetchResponse(response) {
-  return new Response(standardBodyToFetchBody(response.body), {
-    headers: standardResponseToFetchHeaders(response),
-    status: response.status
-  });
-}
-
-// src/adapters/fetch/rpc-handler.ts
-var RPCHandler = class {
-  standardHandler;
-  constructor(router, options) {
-    const matcher = options?.matcher ?? new RPCMatcher();
-    const codec = options?.codec ?? new RPCCodec();
-    this.standardHandler = new StandardHandler(router, matcher, codec, options);
-  }
-  async handle(request, ...rest) {
-    const standardRequest = fetchRequestToStandardRequest(request);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
-      return result;
-    }
-    return {
-      matched: true,
-      response: standardResponseToFetchResponse(result.response)
-    };
-  }
-};
-
-export {
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse,
-  RPCHandler
-};
-//# sourceMappingURL=chunk-6RSW63UJ.js.map