@orpc/server 1.14.11 → 1.14.13

package/dist/shared/server.B4BnEWWm.d.mts

@@ -1,67 +0,0 @@
-import { RPCSerializer, AnyORPCError } from '@orpc/client';
-import { Value, Promisable } from '@orpc/shared';
-import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { A as AnyProcedure, C as Context } from './server.CcR4kgje.mjs';
-import { A as AnyRouter } from './server.15O7oC1p.mjs';
-import { AnyProcedureContract } from '@orpc/contract';
-import { b as StandardHandlerHandleOptions, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure } from './server.DDFizwfU.mjs';
-
-interface RPCMatcherOptions {
-    /**
-     * Filter which procedures are exposed for matching. Return `false` to exclude.
-     *
-     * @default true
-     */
-    filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]>;
-}
-declare class RPCMatcher {
-    private readonly filter;
-    private readonly rootRouter;
-    private readonly tree;
-    private pendingLazyRouters;
-    constructor(router: AnyRouter, options?: RPCMatcherOptions);
-    private index;
-    match(_method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
-        path: string[];
-        procedure: AnyProcedure;
-    } | undefined>;
-    private matchPathname;
-    private resolvePendingLazyRouters;
-    private resolveProcedure;
-}
-
-interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
-    /**
-     * Override the default RPC serializer.
-     */
-    serializer?: Pick<RPCSerializer, keyof RPCSerializer>;
-    /**
-     * Resolve HTTP status for encoded successful outputs.
-     *
-     * Value should be in the `2xx` range and must be less than `400`.
-     * Return `undefined` or `null` to fallback to default
-     *
-     * @default DEFAULT_SUCCESS_STATUS (200)
-     */
-    outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>]>;
-    /**
-     * Mapping ORPCError Code -> HTTP Status Code
-     * The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
-     *
-     * @default COMMON_ERROR_STATUS_MAP
-     */
-    errorStatusMap?: Record<string, number> | undefined;
-}
-declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
-    private readonly matcher;
-    private readonly serializer;
-    private readonly errorStatusMap;
-    private readonly outputStatus;
-    constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-}
-
-export { RPCHandlerCodec as a, RPCMatcher as b };
-export type { RPCHandlerCodecOptions as R, RPCMatcherOptions as c };

package/dist/shared/server.BhsVw7m7.d.ts

@@ -1,104 +0,0 @@
-import { AnyORPCError } from '@orpc/client';
-import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.CcR4kgje.js';
-import { Schema, ErrorMap } from '@orpc/contract';
-
-interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
-    /**
-     * Initializes the plugin and returns new handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform handler options
-     * such as interceptors, or configuration.
-     *
-     * @param options - The current handler options from previous plugins or base configuration
-     * @returns Transformed handler options with plugin's modifications applied
-     *
-     * @example
-     * ```ts
-     * init(options) {
-     *   return {
-     *     ...options,
-     *     interceptors: [...(options.interceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    init?(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-declare class CompositeStandardHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    readonly name = "~composite";
-    protected readonly plugins: StandardHandlerPlugin<T>[];
-    constructor(plugins?: StandardHandlerPlugin<T>[]);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-
-interface StandardHandlerHandleOptions<T extends Context> {
-    prefix?: `/${string}` | undefined;
-    context: T;
-}
-type StandardHandlerHandleResult = {
-    matched: true;
-    response: StandardResponse;
-} | {
-    matched: false;
-    response?: undefined;
-};
-interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, StandardHandlerHandleOptions<T> {
-    request: StandardLazyRequest;
-}
-type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
-interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: StandardLazyRequest;
-}
-type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
-interface StandardHandlerOptions<TContext extends Context> {
-    /**
-     * Fired on every request before routing, useful when you want
-     * to intercept all requests regardless of whether they match a procedure or not.
-     *
-     * @examples
-     * - batch plugins - separate one request into multiple and call multiple next
-     * - openapi spec plugin - to intercept a request and early response
-     */
-    routingInterceptors?: StandardHandlerRoutingInterceptor<TContext>[];
-    /**
-     * interceptor run after routing and before error handler,
-     * useful for error handling, logging, metrics, etc.
-     */
-    interceptors?: StandardHandlerInterceptor<TContext>[];
-    /**
-     *
-     * ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
-     * useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
-     */
-    clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap, any>[];
-    plugins?: StandardHandlerPlugin<TContext>[];
-}
-declare class StandardHandler<T extends Context> {
-    private readonly codec;
-    private readonly routingInterceptors;
-    private readonly interceptors;
-    private readonly clientInterceptors;
-    constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
-    handle(request: StandardLazyRequest, { context, prefix }: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
-}
-declare class OtelHandlerPlugin implements StandardHandlerPlugin<any> {
-    name: string;
-    init(options: StandardHandlerOptions<any>): StandardHandlerOptions<any>;
-}
-
-interface StandardHandlerCodecResolvedProcedure {
-    path: string[];
-    procedure: AnyProcedure;
-    decodeInput: () => Promise<unknown>;
-}
-interface StandardHandlerCodec<T extends Context> {
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-}
-
-export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, StandardHandler as S };
-export type { StandardHandlerOptions as a, StandardHandlerHandleOptions as b, StandardHandlerCodec as c, StandardHandlerCodecResolvedProcedure as d, StandardHandlerPlugin as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerInterceptorOptions as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/server.BoiFpNT7.mjs

@@ -1,224 +0,0 @@
-import { c as createProcedureClient, P as Procedure, L as Lazy, u as unlazy } from './server.DofEOwf-.mjs';
-import { resolveMetaPlugins, mergeErrorMap, ProcedureContract } from '@orpc/contract';
-import { getOrBind, omit, isTypescriptObject } from '@orpc/shared';
-
-const DEFAULT_SUCCESS_STATUS = 200;
-const DEFAULT_ERROR_STATUS = 500;
-
-function createGuardedProcedureLazy(lazy) {
-  const guarded = new Lazy({
-    ...lazy["~orpc"],
-    async loader() {
-      const { default: maybeProcedure } = await unlazy(lazy);
-      if (!(maybeProcedure instanceof Procedure)) {
-        throw new TypeError(`
-          Expected a lazy<procedure> but got lazy<unknown>.
-          This should be caught by TypeScript compilation.
-          Please report this issue if you think this is a bug.
-        `);
-      }
-      return { default: maybeProcedure };
-    }
-  });
-  return guarded;
-}
-function createContractProcedure(procedure, contract) {
-  return new Procedure({
-    ...procedure["~orpc"],
-    errorMap: contract["~orpc"].errorMap,
-    meta: contract["~orpc"].meta,
-    metaPlugins: contract["~orpc"].metaPlugins
-  });
-}
-function call(lazyableProcedure, ...[
-  input = void 0,
-  options = {}
-]) {
-  return createProcedureClient(lazyableProcedure, options)(input, options);
-}
-
-const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol.for("ORPC_HIDDEN_ROUTER_CONTRACT");
-function withHiddenRouterContract(router, contract) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
-        return contract;
-      }
-      return getOrBind(target, key);
-    }
-  });
-}
-function getHiddenRouterContract(router) {
-  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
-}
-
-function augmentRouter(router, options) {
-  if (router instanceof Lazy) {
-    const [meta, metaPlugins] = resolveMetaPlugins(
-      options.meta,
-      options.metaPlugins,
-      router["~orpc"].metaPlugins
-    );
-    const enhanced2 = new Lazy({
-      meta,
-      metaPlugins,
-      async loader() {
-        const { default: unlaziedRouter } = await unlazy(router);
-        const enhanced3 = augmentRouter(unlaziedRouter, options);
-        return unlazy(enhanced3);
-      }
-    });
-    return enhanced2;
-  }
-  if (router instanceof Procedure) {
-    const [meta, metaPlugins] = resolveMetaPlugins(
-      options.meta,
-      options.metaPlugins,
-      router["~orpc"].metaPlugins
-    );
-    const enhanced2 = new Procedure({
-      ...omit(options, ["middlewares", "errorMap", "meta", "metaPlugins"]),
-      ...router["~orpc"],
-      meta,
-      metaPlugins,
-      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
-      orderedMiddlewares: [
-        ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
-        ...router["~orpc"].orderedMiddlewares
-      ]
-    });
-    return enhanced2;
-  }
-  if (!isTypescriptObject(router)) {
-    return router;
-  }
-  const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentRouter(router[key], options);
-  }
-  return enhanced;
-}
-function augmentImplementedRouter(router, options) {
-  if (router instanceof Lazy) {
-    const enhanced2 = new Lazy({
-      ...router["~orpc"],
-      async loader() {
-        const { default: unlaziedRouter } = await unlazy(router);
-        const enhanced3 = augmentImplementedRouter(unlaziedRouter, options);
-        return unlazy(enhanced3);
-      }
-    });
-    return enhanced2;
-  }
-  if (router instanceof Procedure) {
-    const enhanced2 = new Procedure({
-      ...omit(options, ["middlewares"]),
-      ...router["~orpc"],
-      orderedMiddlewares: [
-        ...options.middlewares.map((middleware) => ({ middleware, inputSchemasLengthAtUse: 0, outputSchemasLengthAtUse: 0 })),
-        ...router["~orpc"].orderedMiddlewares
-      ]
-    });
-    return enhanced2;
-  }
-  if (!isTypescriptObject(router)) {
-    return router;
-  }
-  const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentImplementedRouter(router[key], options);
-  }
-  return enhanced;
-}
-function getRouter(router, path) {
-  let current = router;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (!isTypescriptObject(current)) {
-      return void 0;
-    }
-    if (current instanceof Procedure) {
-      return void 0;
-    }
-    if (!(current instanceof Lazy)) {
-      current = current[segment];
-      continue;
-    }
-    const lazied = current;
-    const rest = path.slice(i);
-    return new Lazy({
-      ...lazied["~orpc"],
-      async loader() {
-        const unwrapped = await unlazy(lazied);
-        const next = getRouter(unwrapped.default, rest);
-        return await unlazy(next);
-      }
-    });
-  }
-  if (!isTypescriptObject(current)) {
-    return void 0;
-  }
-  return current;
-}
-function walkProcedureContractsSync(router, callback, path = []) {
-  const hiddenContract = getHiddenRouterContract(router);
-  if (hiddenContract !== void 0) {
-    router = hiddenContract;
-  }
-  if (router instanceof ProcedureContract) {
-    callback(router, path);
-    return [];
-  }
-  if (!isTypescriptObject(router)) {
-    return [];
-  }
-  const lazyResults = [];
-  for (const key in router) {
-    const value = router[key];
-    if (value instanceof Lazy) {
-      lazyResults.push({ router: value, path: [...path, key] });
-    } else {
-      lazyResults.push(...walkProcedureContractsSync(value, callback, [...path, key]));
-    }
-  }
-  return lazyResults;
-}
-async function walkProcedureContractsAsync(router, callback, path = []) {
-  const hiddenContract = getHiddenRouterContract(router);
-  if (hiddenContract !== void 0) {
-    router = hiddenContract;
-  }
-  if (router instanceof ProcedureContract) {
-    await callback(router, path);
-    return;
-  }
-  if (!isTypescriptObject(router)) {
-    return;
-  }
-  for (const key in router) {
-    const value = router[key];
-    if (value instanceof Lazy) {
-      const { default: router2 } = await unlazy(value);
-      await walkProcedureContractsAsync(router2, callback, [...path, key]);
-    } else {
-      await walkProcedureContractsAsync(value, callback, [...path, key]);
-    }
-  }
-}
-async function unlazyRouter(router) {
-  if (router instanceof Procedure) {
-    return router;
-  }
-  if (!isTypescriptObject(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;
-}
-
-export { DEFAULT_SUCCESS_STATUS as D, DEFAULT_ERROR_STATUS as a, augmentRouter as b, createContractProcedure as c, augmentImplementedRouter as d, withHiddenRouterContract as e, createGuardedProcedureLazy as f, getRouter as g, call as h, getHiddenRouterContract as i, walkProcedureContractsAsync as j, unlazyRouter as u, walkProcedureContractsSync as w };

package/dist/shared/server.COPVXhDG.mjs

@@ -1,271 +0,0 @@
-import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
-import { sortPlugins, getOpenTelemetryConfig, runWithSpan, toArray, matchesHttpPathPrefix, intercept, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, recordSpanError, pathToHttpPath, normalizeHttpPath, value, parseEmptyableJSON } from '@orpc/shared';
-import { flattenStandardHeader, parseStandardUrl } from '@standardserver/core';
-import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.DofEOwf-.mjs';
-import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BoiFpNT7.mjs';
-
-class CompositeStandardHandlerPlugin {
-  name = "~composite";
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = sortPlugins(plugins);
-  }
-  init(options) {
-    for (const plugin of this.plugins) {
-      if (plugin.init) {
-        options = plugin.init(options);
-      }
-    }
-    return options;
-  }
-}
-
-class StandardHandler {
-  constructor(codec, options) {
-    this.codec = codec;
-    options = new CompositeStandardHandlerPlugin([
-      new OtelHandlerPlugin(),
-      ...toArray(options.plugins)
-    ]).init(options);
-    this.routingInterceptors = options.routingInterceptors;
-    this.interceptors = options.interceptors;
-    this.clientInterceptors = options.clientInterceptors;
-  }
-  routingInterceptors;
-  interceptors;
-  clientInterceptors;
-  async handle(request, { context, prefix }) {
-    if (prefix && !matchesHttpPathPrefix(request.url, prefix)) {
-      return { matched: false, response: void 0 };
-    }
-    return intercept(
-      this.routingInterceptors,
-      { context, prefix, request },
-      async ({ context: context2, prefix: prefix2, request: request2 }) => {
-        const span = getOpenTelemetryConfig()?.trace.getActiveSpan();
-        let step;
-        const matchedOrNot = await runWithSpan("find_procedure", () => this.codec.resolveProcedure(request2, { context: context2, prefix: prefix2 }));
-        if (!matchedOrNot) {
-          span?.updateName(`${ORPC_NAME}_no_match`);
-          span?.setAttribute("http.request.method", request2.method);
-          span?.setAttribute("url.path", request2.url);
-          return { matched: false };
-        }
-        const { path, procedure, decodeInput } = matchedOrNot;
-        span?.updateName(`${ORPC_NAME}.${path.join("/")}`);
-        span?.setAttribute("rpc.system", ORPC_NAME);
-        span?.setAttribute("rpc.method", path.join("."));
-        try {
-          const response = await intercept(
-            this.interceptors,
-            { context: context2, prefix: prefix2, request: request2, path, procedure, decodeInput },
-            async ({ context: context3, prefix: prefix3, request: request3, path: path2, procedure: procedure2, decodeInput: decodeInput2 }) => {
-              step = "decode_input";
-              let input = await runWithSpan("decode_input", decodeInput2);
-              step = void 0;
-              if (isAsyncIteratorObject(input)) {
-                input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
-              }
-              const client = createProcedureClient(procedure2, {
-                context: context3,
-                path: path2,
-                interceptors: this.clientInterceptors
-              });
-              step = "call_procedure";
-              const output = await client(input, {
-                signal: request3.signal,
-                lastEventId: flattenStandardHeader(request3.headers["last-event-id"])
-              });
-              step = void 0;
-              const response2 = await this.codec.encodeOutput(output, procedure2, path2, { context: context3, prefix: prefix3 });
-              return response2;
-            }
-          );
-          return { matched: true, response };
-        } catch (e) {
-          if (step !== "call_procedure") {
-            recordSpanError(span, e);
-          }
-          const error = step === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
-            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
-            cause: e
-          }) : toORPCError(e);
-          const response = await this.codec.encodeError(error, procedure, path, { context: context2, prefix: prefix2 });
-          return { matched: true, response };
-        }
-      }
-    );
-  }
-}
-class OtelHandlerPlugin {
-  name = "~opentelemetry";
-  init(options) {
-    return {
-      ...options,
-      routingInterceptors: [
-        // Should be placed before user-provided interceptors to help them access the current active context.
-        async ({ next, request }) => {
-          const otelConfig = getOpenTelemetryConfig();
-          let propagationContext;
-          if (otelConfig?.propagation) {
-            propagationContext = otelConfig.propagation.extract(otelConfig.context.active(), request.headers);
-          }
-          return runWithSpan(
-            { name: `${request.method} ${request.url}`, context: propagationContext },
-            () => next()
-          );
-        },
-        ...toArray(options.routingInterceptors)
-      ]
-    };
-  }
-}
-
-class RPCMatcher {
-  filter;
-  rootRouter;
-  tree = /* @__PURE__ */ new Map();
-  pendingLazyRouters = [];
-  constructor(router, options = {}) {
-    this.filter = options.filter ?? true;
-    this.rootRouter = router;
-    this.index(router);
-  }
-  index(router, path = []) {
-    const lazyResults = walkProcedureContractsSync(router, (procedure, procedurePath) => {
-      if (!value(this.filter, procedure, procedurePath)) {
-        return;
-      }
-      const httpPath = pathToHttpPath(procedurePath);
-      if (procedure instanceof Procedure) {
-        this.tree.set(httpPath, {
-          path: procedurePath,
-          contract: procedure,
-          procedure
-        });
-      } else {
-        this.tree.set(httpPath, {
-          path: procedurePath,
-          contract: procedure
-        });
-      }
-    }, path);
-    this.pendingLazyRouters.push(
-      ...lazyResults.map((result) => ({
-        ...result,
-        httpPathPrefix: pathToHttpPath(result.path)
-      }))
-    );
-  }
-  async match(_method, pathname, prefix) {
-    if (pathname.length > 1 && pathname.endsWith("/")) {
-      pathname = pathname.slice(0, -1);
-    }
-    if (prefix) {
-      if (!pathname.startsWith(prefix)) {
-        return void 0;
-      }
-      const charAfterPrefix = pathname[prefix.length];
-      if (charAfterPrefix === "/") {
-        pathname = pathname.slice(prefix.length);
-      } else if (charAfterPrefix === void 0) {
-        pathname = "/";
-      } else if (prefix[prefix.length - 1] === "/") {
-        pathname = pathname.slice(prefix.length - 1);
-      } else {
-        return void 0;
-      }
-    }
-    const result = await this.matchPathname(pathname);
-    if (!result && pathname.includes("%")) {
-      return this.matchPathname(normalizeHttpPath(pathname));
-    }
-    return result;
-  }
-  async matchPathname(pathname) {
-    await this.resolvePendingLazyRouters(pathname);
-    const entry = this.tree.get(pathname);
-    if (!entry) {
-      return void 0;
-    }
-    const procedure = await this.resolveProcedure(entry);
-    return { path: entry.path, procedure };
-  }
-  async resolvePendingLazyRouters(pathname) {
-    if (!this.pendingLazyRouters.length) {
-      return;
-    }
-    const stillPending = [];
-    for (const pending of this.pendingLazyRouters) {
-      if (pathname.startsWith(pending.httpPathPrefix)) {
-        const { default: router } = await unlazy(pending.router);
-        this.index(router, pending.path);
-      } else {
-        stillPending.push(pending);
-      }
-    }
-    this.pendingLazyRouters = stillPending;
-  }
-  async resolveProcedure(entry) {
-    if (entry.procedure) {
-      return entry.procedure;
-    }
-    const { default: maybeProcedure } = await unlazy(getRouter(this.rootRouter, entry.path));
-    if (!(maybeProcedure instanceof Procedure)) {
-      throw new TypeError(
-        `[Contract-First] Missing or invalid implementation for procedure at path: "${entry.path.join(".")}". Ensure the procedure is correctly implemented and matches its contract.`
-      );
-    }
-    entry.procedure = createContractProcedure(maybeProcedure, entry.contract);
-    return entry.procedure;
-  }
-}
-
-class RPCHandlerCodec {
-  matcher;
-  serializer;
-  errorStatusMap;
-  outputStatus;
-  constructor(router, options = {}) {
-    this.matcher = new RPCMatcher(router, options);
-    this.serializer = options.serializer ?? new RPCSerializer();
-    this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
-    this.outputStatus = options.outputStatus;
-  }
-  async resolveProcedure(request, options) {
-    const [pathname, query] = parseStandardUrl(request.url);
-    const matched = await this.matcher.match(request.method, pathname, options.prefix);
-    if (!matched) {
-      return void 0;
-    }
-    return {
-      procedure: matched.procedure,
-      path: matched.path,
-      decodeInput: async () => {
-        if (request.method === "GET") {
-          const dataString = new URLSearchParams(query).getAll("data").at(-1);
-          return this.serializer.deserialize(parseEmptyableJSON(dataString));
-        }
-        const body = await request.resolveBody();
-        return this.serializer.deserialize(body);
-      }
-    };
-  }
-  encodeOutput(output, procedure, path, options) {
-    return {
-      headers: {},
-      status: value(this.outputStatus, output, procedure, path, options) ?? DEFAULT_SUCCESS_STATUS,
-      body: this.serializer.serialize(output)
-    };
-  }
-  encodeError(error, _procedure, _path, _options) {
-    const status = this.errorStatusMap[error.code] ?? DEFAULT_ERROR_STATUS;
-    return {
-      headers: {},
-      status,
-      body: this.serializer.serialize(error.toJSON())
-    };
-  }
-}
-
-export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, RPCHandlerCodec as R, StandardHandler as S, RPCMatcher as a };

package/dist/shared/server.CX4vUnDk.mjs

@@ -1,11 +0,0 @@
-import { value } from '@orpc/shared';
-
-function createStandardPeerRequestHandler(handler, options) {
-  return async (request) => {
-    const context = await value(options.context ?? {}, request);
-    const { response } = await handler.handle(request, { ...options, context });
-    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
-  };
-}
-
-export { createStandardPeerRequestHandler as c };