@orpc/server 2.0.0-beta.48 → 2.0.0-beta.49

package/dist/router-client.js

@@ -0,0 +1,43 @@
+import { RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
+import { resolveMaybeOptionalOptions, toArray } from '@orpc/shared';
+import { Lazy } from './lazy.js';
+import { createProcedureClient } from './procedure-client.js';
+import { createGuardedProcedureLazy } from './procedure-utils.js';
+import { Procedure } from './procedure.js';
+import { getRouter } from './router-utils.js';
+/**
+ * Creates a server-side client that calls the router's procedures directly,
+ * within the same process, without any network layer.
+ *
+ * @see {@link https://orpc.dev/docs/client/server-side#router-clients | Server-Side Clients - Router Clients}
+ */
+export function createRouterClient(router, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    if (router instanceof Procedure) {
+        return createProcedureClient(router, options);
+    }
+    const procedureCaller = router instanceof Lazy ? createProcedureClient(createGuardedProcedureLazy(router), options) : {};
+    const cache = new Map();
+    const recursive = new Proxy(procedureCaller, {
+        get(target, key) {
+            if (typeof key !== 'string' ||
+                (router instanceof Lazy && RECURSIVE_CLIENT_UNWRAP_KEYS.has(key))) {
+                return Reflect.get(target, key);
+            }
+            let nextClient = cache.get(key);
+            if (nextClient === undefined) {
+                const next = getRouter(router, [key]);
+                if (!next) {
+                    return Reflect.get(target, key);
+                }
+                nextClient = createRouterClient(next, {
+                    ...options,
+                    path: [...toArray(options.path), key],
+                });
+                cache.set(key, nextClient);
+            }
+            return nextClient;
+        },
+    });
+    return recursive;
+}

package/dist/{router-hidden.d.mts → router-hidden.d.ts}

@@ -1,5 +1,5 @@
-import type { RouterContract } from "@orpc/contract";
-import type { Lazyable } from "./lazy.mjs";
-import type { AnyRouter } from "./router.mjs";
+import type { RouterContract } from '@orpc/contract';
+import type { Lazyable } from './lazy.ts';
+import type { AnyRouter } from './router.ts';
 export declare function withHiddenRouterContract<T extends Lazyable<AnyRouter>>(router: T, contract: RouterContract): T;
 export declare function getHiddenRouterContract(router: Lazyable<AnyRouter | RouterContract>): RouterContract | undefined;

package/dist/router-hidden.js

@@ -0,0 +1,14 @@
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = /* @__PURE__ */ Symbol.for('ORPC_HIDDEN_ROUTER_CONTRACT');
+export function withHiddenRouterContract(router, contract) {
+    return new Proxy(router, {
+        get(target, key) {
+            if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
+                return contract;
+            }
+            return Reflect.get(target, key);
+        },
+    });
+}
+export function getHiddenRouterContract(router) {
+    return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
+}

package/dist/router-utils.d.ts

@@ -0,0 +1,48 @@
+import type { AnyProcedureContract, AugmentContractRouterOptions, ErrorMap, MergedErrorMap, RouterContract } from '@orpc/contract';
+import type { Promisable } from '@orpc/shared';
+import type { Context, MergedInitialContext } from './context.ts';
+import type { Lazyable } from './lazy.ts';
+import { Lazy } from './lazy.ts';
+import type { AnyMiddleware } from './middleware.ts';
+import type { AnyProcedure, ProcedureConfig } from './procedure.ts';
+import { Procedure } from './procedure.ts';
+import type { AnyRouter } from './router.ts';
+export type AugmentedRouter<T extends AnyRouter, TErrorMap extends ErrorMap> = T extends Procedure<infer $InitialContext, infer $CurrentContext, infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<$InitialContext, $CurrentContext, $InputSchema, $OutputSchema, MergedErrorMap<TErrorMap, $ErrorMap>> : {
+    [K in keyof T]: T[K] extends Lazy<infer $ extends AnyRouter> ? Lazy<AugmentedRouter<$, TErrorMap>> : T[K] extends AnyRouter ? AugmentedRouter<T[K], TErrorMap> : never;
+};
+export type AugmentedRouterWithMiddlewares<T extends AnyRouter, TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> = T extends Procedure<infer $InitialContext, infer $CurrentContext, infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<MergedInitialContext<TInitialContext, TInjectedContext, $InitialContext>, $CurrentContext, $InputSchema, $OutputSchema, MergedErrorMap<TErrorMap, $ErrorMap>> : {
+    [K in keyof T]: T[K] extends Lazy<infer $ extends AnyRouter> ? Lazy<AugmentedRouterWithMiddlewares<$, TInitialContext, TInjectedContext, TErrorMap>> : T[K] extends AnyRouter ? AugmentedRouterWithMiddlewares<T[K], TInitialContext, TInjectedContext, TErrorMap> : never;
+};
+interface AugmentRouterOptions<TErrorMap extends ErrorMap> extends AugmentContractRouterOptions<TErrorMap>, ProcedureConfig {
+    middlewares: AnyMiddleware[];
+}
+export declare function augmentRouter<T extends AnyRouter, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: AugmentRouterOptions<TErrorMap>): AugmentedRouter<T, TErrorMap> | AugmentedRouterWithMiddlewares<T, TInitialContext, TCurrentContext, TErrorMap>;
+interface AugmentImplementedRouterOptions extends ProcedureConfig {
+    middlewares: AnyMiddleware[];
+}
+export declare function augmentImplementedRouter<T extends AnyRouter, TInitialContext extends Context, TCurrentContext extends Context>(router: T, options: AugmentImplementedRouterOptions): AugmentedRouter<T, object> | AugmentedRouterWithMiddlewares<T, TInitialContext, TCurrentContext, object>;
+/**
+ * Resolves the procedure of a contract walked from a router: the procedure itself,
+ * or the implementation of a contract-first procedure, looked up by its path.
+ *
+ * @throws {TypeError} If a contract-first procedure has no valid implementation.
+ */
+export declare function resolveContractProcedure(router: AnyRouter, contract: AnyProcedureContract, path: readonly string[]): Promise<AnyProcedure>;
+export declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+export interface WalkProcedureContractsLazyResult {
+    router: Lazy<AnyRouter>;
+    path: string[];
+}
+export declare function walkProcedureContractsSync(router: RouterContract | AnyRouter, callback: (contract: AnyProcedureContract | AnyProcedure, path: string[]) => void, path?: string[]): WalkProcedureContractsLazyResult[];
+export declare function walkProcedureContractsAsync(router: RouterContract | AnyRouter, callback: (contract: AnyProcedureContract | AnyProcedure, path: string[]) => Promisable<void>, path?: string[]): Promise<void>;
+export type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
+};
+/**
+ * Fully resolves all lazy routers inside a router, returning a plain router.
+ * Useful for making a router with lazy parts contract-compatible.
+ *
+ * @see {@link https://orpc.dev/docs/contract/router#router-to-contract | Router Contract - Router to Contract}
+ */
+export declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
+export {};

package/dist/router-utils.js

@@ -0,0 +1,202 @@
+import { mergeErrorMap, ProcedureContract, resolveMetaPlugins } from '@orpc/contract';
+import { getOwn, isNonPrimitive, omit, setOwn } from '@orpc/shared';
+import { Lazy, unlazy } from './lazy.js';
+import { createContractProcedure } from './procedure-utils.js';
+import { Procedure } from './procedure.js';
+import { getHiddenRouterContract } from './router-hidden.js';
+export function augmentRouter(router, options) {
+    if (router instanceof Lazy) {
+        const [meta, metaPlugins] = resolveMetaPlugins(options.meta, options.metaPlugins, router['~orpc'].metaPlugins);
+        const enhanced = new Lazy({
+            meta,
+            metaPlugins,
+            async loader() {
+                const { default: unlaziedRouter } = await unlazy(router);
+                const enhanced = augmentRouter(unlaziedRouter, options);
+                return unlazy(enhanced);
+            },
+        });
+        return enhanced;
+    }
+    if (router instanceof Procedure) {
+        const [meta, metaPlugins] = resolveMetaPlugins(options.meta, options.metaPlugins, router['~orpc'].metaPlugins);
+        const enhanced = 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 enhanced;
+    }
+    if (!isNonPrimitive(router)) {
+        return router;
+    }
+    const enhanced = {};
+    for (const [key, child] of Object.entries(router)) {
+        setOwn(enhanced, key, augmentRouter(child, options));
+    }
+    return enhanced;
+}
+export function augmentImplementedRouter(router, options) {
+    if (router instanceof Lazy) {
+        const enhanced = new Lazy({
+            ...router['~orpc'],
+            async loader() {
+                const { default: unlaziedRouter } = await unlazy(router);
+                const enhanced = augmentImplementedRouter(unlaziedRouter, options);
+                return unlazy(enhanced);
+            },
+        });
+        return enhanced;
+    }
+    if (router instanceof Procedure) {
+        const enhanced = new Procedure({
+            ...omit(options, ['middlewares']),
+            ...router['~orpc'],
+            orderedMiddlewares: [
+                ...options.middlewares.map((middleware) => ({
+                    middleware,
+                    inputSchemasLengthAtUse: 0,
+                    outputSchemasLengthAtUse: 0,
+                })),
+                ...router['~orpc'].orderedMiddlewares,
+            ],
+        });
+        return enhanced;
+    }
+    if (!isNonPrimitive(router)) {
+        return router;
+    }
+    const enhanced = {};
+    for (const [key, child] of Object.entries(router)) {
+        setOwn(enhanced, key, augmentImplementedRouter(child, options));
+    }
+    return enhanced;
+}
+/**
+ * Resolves the procedure of a contract walked from a router: the procedure itself,
+ * or the implementation of a contract-first procedure, looked up by its path.
+ *
+ * @throws {TypeError} If a contract-first procedure has no valid implementation.
+ */
+export async function resolveContractProcedure(router, contract, path) {
+    if (contract instanceof Procedure) {
+        return contract;
+    }
+    const { default: maybeProcedure } = await unlazy(getRouter(router, path));
+    if (!(maybeProcedure instanceof Procedure)) {
+        throw new TypeError(`[Contract-First] Missing or invalid implementation for procedure at path: "${path.join('.')}". ` +
+            `Ensure the procedure is correctly implemented and matches its contract.`);
+    }
+    return createContractProcedure(maybeProcedure, contract);
+}
+export function getRouter(router, path) {
+    let current = router;
+    for (let i = 0; i < path.length; i++) {
+        const segment = path[i];
+        if (!isNonPrimitive(current)) {
+            return undefined;
+        }
+        if (current instanceof Procedure) {
+            return undefined;
+        }
+        if (!(current instanceof Lazy)) {
+            current = getOwn(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 (!isNonPrimitive(current)) {
+        return undefined;
+    }
+    return current;
+}
+export function walkProcedureContractsSync(router, callback, path = []) {
+    const lazyResults = [];
+    walkProcedureContractsSyncInternal(router, callback, path.slice(), lazyResults);
+    return lazyResults;
+}
+function walkProcedureContractsSyncInternal(router, callback, path, lazyResults) {
+    const hiddenContract = getHiddenRouterContract(router);
+    if (hiddenContract !== undefined) {
+        router = hiddenContract;
+    }
+    if (router instanceof ProcedureContract) {
+        callback(router, path.slice());
+        return;
+    }
+    if (!isNonPrimitive(router)) {
+        return;
+    }
+    for (const [key, value] of Object.entries(router)) {
+        path.push(key);
+        if (value instanceof Lazy) {
+            lazyResults.push({ router: value, path: path.slice() });
+        }
+        else {
+            walkProcedureContractsSyncInternal(value, callback, path, lazyResults);
+        }
+        path.pop();
+    }
+}
+export async function walkProcedureContractsAsync(router, callback, path = []) {
+    const hiddenContract = getHiddenRouterContract(router);
+    if (hiddenContract !== undefined) {
+        router = hiddenContract;
+    }
+    if (router instanceof ProcedureContract) {
+        await callback(router, path);
+        return;
+    }
+    if (!isNonPrimitive(router)) {
+        return;
+    }
+    for (const [key, value] of Object.entries(router)) {
+        if (value instanceof Lazy) {
+            const { default: router } = await unlazy(value);
+            await walkProcedureContractsAsync(router, callback, [...path, key]);
+        }
+        else {
+            await walkProcedureContractsAsync(value, callback, [...path, key]);
+        }
+    }
+}
+/**
+ * Fully resolves all lazy routers inside a router, returning a plain router.
+ * Useful for making a router with lazy parts contract-compatible.
+ *
+ * @see {@link https://orpc.dev/docs/contract/router#router-to-contract | Router Contract - Router to Contract}
+ */
+export async function unlazyRouter(router) {
+    if (router instanceof Procedure) {
+        return router;
+    }
+    if (!isNonPrimitive(router)) {
+        return router;
+    }
+    const unlazied = {};
+    for (const key of Object.keys(router)) {
+        const item = router[key];
+        const { default: unlaziedRouter } = await unlazy(item);
+        setOwn(unlazied, key, await unlazyRouter(unlaziedRouter));
+    }
+    return unlazied;
+}

package/dist/router.d.ts

@@ -0,0 +1,72 @@
+import type { InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap, ProcedureContract, RouterContract, ThrowableError } from '@orpc/contract';
+import type { Context, MergedContext } from './context.ts';
+import type { Lazyable } from './lazy.ts';
+import type { Procedure } from './procedure.ts';
+export type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any> | {
+    [k: string]: Lazyable<Router<TInitialContext>>;
+};
+export type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap> : {
+    [K in keyof T]: T[K] extends RouterContract ? Lazyable<ContractedRouter<T[K], TInitialContext>> : never;
+};
+export type AnyRouter = Router<any>;
+export type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $> ? $ : never;
+/**
+ * Infer all initial context of the router.
+ *
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-initial-contexts | Router - Infer Router Initial Contexts}
+ */
+export type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
+};
+/**
+ * Infer all current context of the router.
+ *
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-final-contexts | Router - Infer Router Final Contexts}
+ */
+export type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never;
+};
+/**
+ * Infer all router inputs.
+ *
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-inputs | Router - Infer Router Inputs}
+ */
+export type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+/**
+ * Infer all router outputs.
+ *
+ * @remarks
+ * **Note**: A procedure is a router too.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-outputs | Router - Infer Router Outputs}
+ */
+export type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+/**
+ * Infer the union of throwable errors for entire router.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-error | Router - Infer Router Error}
+ */
+export type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never;
+}[keyof T];
+/**
+ * Infer throwable errors for each procedure, preserving the router shape.
+ *
+ * @see {@link https://orpc.dev/docs/router#infer-router-errors | Router - Infer Router Errors}
+ */
+export type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never;
+};

package/package.json

@@ -1,109 +1,128 @@
 {
   "name": "@orpc/server",
-  "type": "module",
-  "version": "2.0.0-beta.48",
+  "version": "2.0.0-beta.49",
   "description": "Build typesafe APIs with oRPC: RPC and OpenAPI support, middleware, and adapters for Node.js, Bun, Deno, Fetch, Fastify, WebSocket, AWS Lambda, and more",
-  "license": "MIT",
-  "funding": [
-    "https://github.com/sponsors/dinwwwh",
-    "https://opencollective.com/middleapi"
+  "keywords": [
+    "api",
+    "aws-lambda",
+    "bun",
+    "deno",
+    "fastify",
+    "middleware",
+    "nodejs",
+    "openapi",
+    "orpc",
+    "rpc",
+    "server",
+    "typesafe",
+    "typescript",
+    "websocket"
   ],
   "homepage": "https://orpc.dev",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/middleapi/orpc.git",
     "directory": "packages/server"
   },
-  "keywords": [
-    "orpc",
-    "rpc",
-    "api",
-    "typescript",
-    "typesafe",
-    "server",
-    "openapi",
-    "middleware",
-    "nodejs",
-    "bun",
-    "deno",
-    "fastify",
-    "websocket",
-    "aws-lambda"
+  "funding": [
+    "https://github.com/sponsors/dinwwwh",
+    "https://opencollective.com/middleapi"
   ],
+  "files": [
+    "dist"
+  ],
+  "type": "module",
   "sideEffects": [
-    "./dist/extensions/callable.mjs"
+    "./dist/extensions/callable.js"
   ],
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs",
-      "default": "./dist/index.mjs"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./helpers": {
-      "types": "./dist/helpers/index.d.mts",
-      "import": "./dist/helpers/index.mjs",
-      "default": "./dist/helpers/index.mjs"
+      "types": "./dist/helpers/index.d.ts",
+      "import": "./dist/helpers/index.js",
+      "default": "./dist/helpers/index.js"
     },
     "./plugins": {
-      "types": "./dist/plugins/index.d.mts",
-      "import": "./dist/plugins/index.mjs",
-      "default": "./dist/plugins/index.mjs"
+      "types": "./dist/plugins/index.d.ts",
+      "import": "./dist/plugins/index.js",
+      "default": "./dist/plugins/index.js"
     },
     "./standard": {
-      "types": "./dist/adapters/standard/index.d.mts",
-      "import": "./dist/adapters/standard/index.mjs",
-      "default": "./dist/adapters/standard/index.mjs"
+      "types": "./dist/adapters/standard/index.d.ts",
+      "import": "./dist/adapters/standard/index.js",
+      "default": "./dist/adapters/standard/index.js"
     },
     "./standard-peer": {
-      "types": "./dist/adapters/standard-peer/index.d.mts",
-      "import": "./dist/adapters/standard-peer/index.mjs",
-      "default": "./dist/adapters/standard-peer/index.mjs"
+      "types": "./dist/adapters/standard-peer/index.d.ts",
+      "import": "./dist/adapters/standard-peer/index.js",
+      "default": "./dist/adapters/standard-peer/index.js"
     },
     "./fetch": {
-      "types": "./dist/adapters/fetch/index.d.mts",
-      "import": "./dist/adapters/fetch/index.mjs",
-      "default": "./dist/adapters/fetch/index.mjs"
+      "types": "./dist/adapters/fetch/index.d.ts",
+      "import": "./dist/adapters/fetch/index.js",
+      "default": "./dist/adapters/fetch/index.js"
     },
     "./node": {
-      "types": "./dist/adapters/node/index.d.mts",
-      "import": "./dist/adapters/node/index.mjs",
-      "default": "./dist/adapters/node/index.mjs"
+      "types": "./dist/adapters/node/index.d.ts",
+      "import": "./dist/adapters/node/index.js",
+      "default": "./dist/adapters/node/index.js"
     },
     "./aws-lambda": {
-      "types": "./dist/adapters/aws-lambda/index.d.mts",
-      "import": "./dist/adapters/aws-lambda/index.mjs",
-      "default": "./dist/adapters/aws-lambda/index.mjs"
+      "types": "./dist/adapters/aws-lambda/index.d.ts",
+      "import": "./dist/adapters/aws-lambda/index.js",
+      "default": "./dist/adapters/aws-lambda/index.js"
     },
     "./fastify": {
-      "types": "./dist/adapters/fastify/index.d.mts",
-      "import": "./dist/adapters/fastify/index.mjs",
-      "default": "./dist/adapters/fastify/index.mjs"
+      "types": "./dist/adapters/fastify/index.d.ts",
+      "import": "./dist/adapters/fastify/index.js",
+      "default": "./dist/adapters/fastify/index.js"
     },
     "./websocket": {
-      "types": "./dist/adapters/websocket/index.d.mts",
-      "import": "./dist/adapters/websocket/index.mjs",
-      "default": "./dist/adapters/websocket/index.mjs"
+      "types": "./dist/adapters/websocket/index.d.ts",
+      "import": "./dist/adapters/websocket/index.js",
+      "default": "./dist/adapters/websocket/index.js"
     },
     "./message-port": {
-      "types": "./dist/adapters/message-port/index.d.mts",
-      "import": "./dist/adapters/message-port/index.mjs",
-      "default": "./dist/adapters/message-port/index.mjs"
+      "types": "./dist/adapters/message-port/index.d.ts",
+      "import": "./dist/adapters/message-port/index.js",
+      "default": "./dist/adapters/message-port/index.js"
     },
     "./crossws": {
-      "types": "./dist/adapters/crossws/index.d.mts",
-      "import": "./dist/adapters/crossws/index.mjs",
-      "default": "./dist/adapters/crossws/index.mjs"
+      "types": "./dist/adapters/crossws/index.d.ts",
+      "import": "./dist/adapters/crossws/index.js",
+      "default": "./dist/adapters/crossws/index.js"
     },
     "./extensions/callable": {
-      "types": "./dist/extensions/callable.d.mts",
-      "import": "./dist/extensions/callable.mjs",
-      "default": "./dist/extensions/callable.mjs"
+      "types": "./dist/extensions/callable.d.ts",
+      "import": "./dist/extensions/callable.js",
+      "default": "./dist/extensions/callable.js"
     }
   },
-  "files": [
-    "dist"
-  ],
+  "dependencies": {
+    "@orpc/client": "2.0.0-beta.49",
+    "@orpc/contract": "2.0.0-beta.49",
+    "@orpc/shared": "2.0.0-beta.49",
+    "@standard-server/aws-lambda": "~0.15.0",
+    "@standard-server/core": "~0.15.0",
+    "@standard-server/fastify": "~0.15.0",
+    "@standard-server/fetch": "~0.15.0",
+    "@standard-server/node": "~0.15.0",
+    "@standard-server/peer": "~0.15.0",
+    "cookie": "^2.0.1"
+  },
+  "devDependencies": {
+    "crossws": "^0.4.17",
+    "fastify": "^5.12.8",
+    "supertest": "^7.3.1",
+    "ws": "^8.22.1",
+    "zod": "^4.6.7"
+  },
   "peerDependencies": {
     "crossws": ">=0.3.4",
     "fastify": ">=5.6.1"
@@ -116,26 +135,5 @@
       "optional": true
     }
   },
-  "dependencies": {
-    "@orpc/client": "2.0.0-beta.48",
-    "@orpc/contract": "2.0.0-beta.48",
-    "@orpc/shared": "2.0.0-beta.48",
-    "@standard-server/aws-lambda": "~0.14.0",
-    "@standard-server/core": "~0.14.0",
-    "@standard-server/fastify": "~0.14.0",
-    "@standard-server/fetch": "~0.14.0",
-    "@standard-server/node": "~0.14.0",
-    "@standard-server/peer": "~0.14.0",
-    "cookie": "^2.0.1"
-  },
-  "devDependencies": {
-    "crossws": "^0.4.17",
-    "fastify": "^5.12.7",
-    "supertest": "^7.3.1",
-    "ws": "^8.22.0",
-    "zod": "^4.6.7"
-  },
-  "scripts": {
-    "type:check": "tsc -b"
-  }
+  "scripts": {}
 }

package/dist/adapters/aws-lambda/handler.d.mts

@@ -1,25 +0,0 @@
-import type { MaybeOptionalOptions } from "@orpc/shared";
-import type { AnyAPIGatewayProxyEvent, HttpResponseStream, SendStandardResponseOptions } from "@standard-server/aws-lambda";
-import type { Context } from "../../context.mjs";
-import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from "../standard/index.mjs";
-export type AwsLambdaHandlerHandleResult = {
-	matched: true;
-} | {
-	matched: false;
-};
-export interface AwsLambdaHandlerOptions<_T extends Context> {
-	/**
-	* Custom options for `sendStandardResponse`, used to send a `Standard Response`
-	*/
-	sendStandardResponse?: SendStandardResponseOptions | undefined;
-}
-/**
-* Requires the AWS Lambda Node.js runtime with response streaming enabled,
-* handlers should be wrapped with `awslambda.streamifyResponse`.
-*/
-export declare class AwsLambdaHandler<T extends Context> {
-	private readonly standardHandler;
-	private readonly sendStandardResponseOptions;
-	constructor(standardHandler: StandardHandler<T>, options?: NoInfer<AwsLambdaHandlerOptions<T>>);
-	handle(event: AnyAPIGatewayProxyEvent, responseStream: HttpResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<AwsLambdaHandlerHandleResult>;
-}

package/dist/adapters/aws-lambda/handler.mjs

@@ -1,21 +0,0 @@
-import { resolveMaybeOptionalOptions } from "@orpc/shared";
-import { sendStandardResponse, toStandardLazyRequest } from "@standard-server/aws-lambda";
-import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/index.mjs";
-
-export class AwsLambdaHandler {
-	standardHandler;
-	sendStandardResponseOptions;
-	constructor(standardHandler, options = {}) {
-		this.standardHandler = standardHandler;
-		this.sendStandardResponseOptions = options.sendStandardResponse;
-	}
-	async handle(event, responseStream, ...rest) {
-		const standardRequest = toStandardLazyRequest(event, responseStream);
-		const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
-		if (!result.matched) {
-			return result;
-		}
-		await sendStandardResponse(responseStream, result.response, this.sendStandardResponseOptions);
-		return result;
-	}
-}