@orpc/server 2.0.0-beta.5 → 2.0.0-beta.50

package/dist/helpers/base64url.js

@@ -0,0 +1,48 @@
+import { encodeBase64 } from "@orpc/shared";
+// src/helpers/base64url.ts
+/**
+* Encodes a Uint8Array to base64url format
+* Base64url is URL-safe and doesn't use padding
+*
+* @example
+* ```ts
+* const text = "Hello World"
+* const encoded = encodeBase64url(new TextEncoder().encode(text))
+* const decoded = decodeBase64url(encoded)
+* expect(new TextDecoder().decode(decoded)).toEqual(text)
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
+*/
+function encodeBase64url(data) {
+	return encodeBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+/**
+* Decodes a base64url string to Uint8Array
+* Only accepts canonical, unpadded base64url (the form produced by `encodeBase64url`),
+* returns undefined for anything else, including padded or standard base64 input
+*
+* @example
+* ```ts
+* const text = "Hello World"
+* const encoded = encodeBase64url(new TextEncoder().encode(text))
+* const decoded = decodeBase64url(encoded)
+* expect(new TextDecoder().decode(decoded)).toEqual(text)
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
+*/
+function decodeBase64url(base64url) {
+	try {
+		if (typeof base64url !== "string") return;
+		let base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+		while (base64.length % 4) base64 += "=";
+		const binaryString = atob(base64);
+		const bytes = new Uint8Array(binaryString.length);
+		for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+		return encodeBase64url(bytes) === base64url ? bytes : void 0;
+	} catch {
+		return;
+	}
+}
+export { decodeBase64url, encodeBase64url };

package/dist/helpers/cookie.d.ts

@@ -0,0 +1,50 @@
+import { ParseOptions, SetCookie, StringifyOptions } from "cookie";
+export interface SetCookieOptions extends Omit<SetCookie, "name" | "value">, StringifyOptions {
+  /**
+   * Specifies the value for the [`Path` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.4).
+   *
+   * @default '/'
+   */
+  path?: string;
+}
+/**
+ * Sets a cookie in the response headers.
+ *
+ * Does nothing if `headers` is `undefined`.
+ *
+ * @example
+ * ```ts
+ * const headers = new Headers()
+ *
+ * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
+ *
+ * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; Max-Age=3600; Path=/; HttpOnly')
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+ */
+export declare function setCookie(headers: Headers | undefined, name: string, value: string, options?: SetCookieOptions): void;
+export interface GetCookieOptions extends ParseOptions {}
+/**
+ * Gets a cookie value from request headers
+ *
+ * Returns `undefined` if the cookie is not found or headers are `undefined`.
+ *
+ * @example
+ * ```ts
+ * const headers = new Headers({ 'Cookie': 'sessionId=abc123; theme=dark' })
+ *
+ * const sessionId = getCookie(headers, 'sessionId')
+ *
+ * expect(sessionId).toEqual('abc123')
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+ */
+export declare function getCookie(headers: Headers | undefined, name: string, options?: GetCookieOptions): string | undefined;
+/**
+ * Deletes a cookie by marking it expired.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+ */
+export declare function deleteCookie(headers: Headers | undefined, name: string, options?: Omit<SetCookieOptions, "maxAge">): void;

package/dist/helpers/cookie.js

@@ -0,0 +1,62 @@
+import { parseCookie, stringifySetCookie } from "cookie";
+// src/helpers/cookie.ts
+/**
+* Sets a cookie in the response headers.
+*
+* Does nothing if `headers` is `undefined`.
+*
+* @example
+* ```ts
+* const headers = new Headers()
+*
+* setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
+*
+* expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; Max-Age=3600; Path=/; HttpOnly')
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+*/
+function setCookie(headers, name, value, options = {}) {
+	if (headers === void 0) return;
+	const cookieString = stringifySetCookie({
+		path: "/",
+		...options,
+		name,
+		value
+	}, options);
+	headers.append("Set-Cookie", cookieString);
+}
+/**
+* Gets a cookie value from request headers
+*
+* Returns `undefined` if the cookie is not found or headers are `undefined`.
+*
+* @example
+* ```ts
+* const headers = new Headers({ 'Cookie': 'sessionId=abc123; theme=dark' })
+*
+* const sessionId = getCookie(headers, 'sessionId')
+*
+* expect(sessionId).toEqual('abc123')
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+*/
+function getCookie(headers, name, options = {}) {
+	if (headers === void 0) return;
+	const cookieHeader = headers.get("cookie");
+	if (cookieHeader === null) return;
+	return parseCookie(cookieHeader, options)[name];
+}
+/**
+* Deletes a cookie by marking it expired.
+*
+* @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+*/
+function deleteCookie(headers, name, options = {}) {
+	return setCookie(headers, name, "", {
+		...options,
+		maxAge: 0
+	});
+}
+export { deleteCookie, getCookie, setCookie };

package/dist/helpers/encryption.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Encrypts a string using AES-GCM with a secret key.
+ * The output is base64url encoded to be URL-safe.
+ *
+ * @example
+ * ```ts
+ * const encrypted = await encrypt("Hello, World!", "test-secret-key")
+ * const decrypted = await decrypt(encrypted, "test-secret-key")
+ * expect(decrypted).toBe("Hello, World!")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
+ */
+export declare function encrypt(value: string, secret: string): Promise<string>;
+/**
+ * Decrypts a base64url encoded string using AES-GCM with a secret key.
+ * Returns the original string if decryption is successful, or undefined if it fails.
+ *
+ * @example
+ * ```ts
+ * const encrypted = await encrypt("Hello, World!", "test-secret-key")
+ * const decrypted = await decrypt(encrypted, "test-secret-key")
+ * expect(decrypted).toBe("Hello, World!")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
+ */
+export declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;

package/dist/helpers/encryption.js

@@ -0,0 +1,90 @@
+import { decodeBase64url, encodeBase64url } from "./base64url.js";
+// src/helpers/encryption.ts
+const PBKDF2_CONFIG = {
+	name: "PBKDF2",
+	/**
+	* Below the OWASP Password Storage Cheat Sheet recommendation of 600,000 iterations
+	* for PBKDF2-HMAC-SHA256. The output does not record the iteration count, so changing
+	* it would make existing ciphertexts undecryptable; raising it needs a versioned format.
+	*/
+	iterations: 6e4,
+	hash: "SHA-256"
+};
+const AES_GCM_CONFIG = {
+	name: "AES-GCM",
+	length: 256
+};
+const CRYPTO_CONSTANTS = {
+	SALT_LENGTH: 16,
+	IV_LENGTH: 12
+};
+/**
+* Encrypts a string using AES-GCM with a secret key.
+* The output is base64url encoded to be URL-safe.
+*
+* @example
+* ```ts
+* const encrypted = await encrypt("Hello, World!", "test-secret-key")
+* const decrypted = await decrypt(encrypted, "test-secret-key")
+* expect(decrypted).toBe("Hello, World!")
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
+*/
+async function encrypt(value, secret) {
+	const encoder = new TextEncoder();
+	const data = encoder.encode(value);
+	const salt = crypto.getRandomValues(new Uint8Array(CRYPTO_CONSTANTS.SALT_LENGTH));
+	const keyMaterial = await crypto.subtle.importKey("raw", encoder.encode(secret), PBKDF2_CONFIG.name, false, ["deriveKey"]);
+	const key = await crypto.subtle.deriveKey({
+		...PBKDF2_CONFIG,
+		salt
+	}, keyMaterial, AES_GCM_CONFIG, false, ["encrypt"]);
+	const iv = crypto.getRandomValues(new Uint8Array(CRYPTO_CONSTANTS.IV_LENGTH));
+	const encrypted = await crypto.subtle.encrypt({
+		name: AES_GCM_CONFIG.name,
+		iv
+	}, key, data);
+	const result = new Uint8Array(salt.length + iv.length + encrypted.byteLength);
+	result.set(salt, 0);
+	result.set(iv, salt.length);
+	result.set(new Uint8Array(encrypted), salt.length + iv.length);
+	return encodeBase64url(result);
+}
+/**
+* Decrypts a base64url encoded string using AES-GCM with a secret key.
+* Returns the original string if decryption is successful, or undefined if it fails.
+*
+* @example
+* ```ts
+* const encrypted = await encrypt("Hello, World!", "test-secret-key")
+* const decrypted = await decrypt(encrypted, "test-secret-key")
+* expect(decrypted).toBe("Hello, World!")
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
+*/
+async function decrypt(encrypted, secret) {
+	try {
+		const data = decodeBase64url(encrypted);
+		if (data === void 0) return;
+		const encoder = new TextEncoder();
+		const decoder = new TextDecoder();
+		const salt = data.slice(0, CRYPTO_CONSTANTS.SALT_LENGTH);
+		const iv = data.slice(CRYPTO_CONSTANTS.SALT_LENGTH, CRYPTO_CONSTANTS.SALT_LENGTH + CRYPTO_CONSTANTS.IV_LENGTH);
+		const encryptedData = data.slice(CRYPTO_CONSTANTS.SALT_LENGTH + CRYPTO_CONSTANTS.IV_LENGTH);
+		const keyMaterial = await crypto.subtle.importKey("raw", encoder.encode(secret), PBKDF2_CONFIG.name, false, ["deriveKey"]);
+		const key = await crypto.subtle.deriveKey({
+			...PBKDF2_CONFIG,
+			salt
+		}, keyMaterial, AES_GCM_CONFIG, false, ["decrypt"]);
+		const decrypted = await crypto.subtle.decrypt({
+			name: AES_GCM_CONFIG.name,
+			iv
+		}, key, encryptedData);
+		return decoder.decode(decrypted);
+	} catch {
+		return;
+	}
+}
+export { decrypt, encrypt };

package/dist/helpers/index.d.ts

@@ -1,149 +1,5 @@
-import { ParseOptions, SerializeOptions } from 'cookie';
-
-/**
- * Encodes a Uint8Array to base64url format
- * Base64url is URL-safe and doesn't use padding
- *
- * @example
- * ```ts
- * const text = "Hello World"
- * const encoded = encodeBase64url(new TextEncoder().encode(text))
- * const decoded = decodeBase64url(encoded)
- * expect(new TextDecoder().decode(decoded)).toEqual(text)
- * ```
- */
-declare function encodeBase64url(data: Uint8Array): string;
-/**
- * Decodes a base64url string to Uint8Array
- * Returns undefined if the input is invalid
- *
- * @example
- * ```ts
- * const text = "Hello World"
- * const encoded = encodeBase64url(new TextEncoder().encode(text))
- * const decoded = decodeBase64url(encoded)
- * expect(new TextDecoder().decode(decoded)).toEqual(text)
- * ```
- */
-declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
-
-interface SetCookieOptions extends SerializeOptions {
-    /**
-     * Specifies the value for the [`Path` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.4).
-     *
-     * @default '/'
-     */
-    path?: string;
-}
-/**
- * Sets a cookie in the response headers,
- *
- * Does nothing if `headers` is `undefined`.
- *
- * @example
- * ```ts
- * const headers = new Headers()
- *
- * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
- *
- * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; HttpOnly; Max-Age=3600')
- * ```
- *
- */
-declare function setCookie(headers: Headers | undefined, name: string, value: string, options?: SetCookieOptions): void;
-interface GetCookieOptions extends ParseOptions {
-}
-/**
- * Gets a cookie value from request headers
- *
- * Returns `undefined` if the cookie is not found or headers are `undefined`.
- *
- * @example
- * ```ts
- * const headers = new Headers({ 'Cookie': 'sessionId=abc123; theme=dark' })
- *
- * const sessionId = getCookie(headers, 'sessionId')
- *
- * expect(sessionId).toEqual('abc123')
- * ```
- */
-declare function getCookie(headers: Headers | undefined, name: string, options?: GetCookieOptions): string | undefined;
-/**
- * Deletes a cookie by marking it expired.
- */
-declare function deleteCookie(headers: Headers | undefined, name: string, options?: Omit<SetCookieOptions, 'maxAge'>): void;
-
-/**
- * Encrypts a string using AES-GCM with a secret key.
- * The output is base64url encoded to be URL-safe.
- *
- * @example
- * ```ts
- * const encrypted = await encrypt("Hello, World!", "test-secret-key")
- * const decrypted = await decrypt(encrypted, "test-secret-key")
- * expect(decrypted).toBe("Hello, World!")
- * ```
- */
-declare function encrypt(value: string, secret: string): Promise<string>;
-/**
- * Decrypts a base64url encoded string using AES-GCM with a secret key.
- * Returns the original string if decryption is successful, or undefined if it fails.
- *
- * @example
- * ```ts
- * const encrypted = await encrypt("Hello, World!", "test-secret-key")
- * const decrypted = await decrypt(encrypted, "test-secret-key")
- * expect(decrypted).toBe("Hello, World!")
- * ```
- */
-declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;
-
-/**
- * Signs a string value using HMAC-SHA256 with a secret key.
- *
- * This function creates a cryptographic signature that can be used to verify
- * the integrity and authenticity of the data. The signature is appended to
- * the original value, separated by a dot, using base64url encoding (no padding).
- *
- *
- * @example
- * ```ts
- * const signedValue = await sign("user123", "my-secret-key")
- * expect(signedValue).toEqual("user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA")
- * ```
- */
-declare function sign(value: string, secret: string): Promise<string>;
-/**
- * Verifies and extracts the original value from a signed string.
- *
- * This function validates the signature of a previously signed value using the same
- * secret key. If the signature is valid, it returns the original value. If the
- * signature is invalid or the format is incorrect, it returns undefined.
- *
- *
- * @example
- * ```ts
- * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
- * const originalValue = await unsign(signedValue, "my-secret-key")
- * expect(originalValue).toEqual("user123")
- * ```
- */
-declare function unsign(signedValue: string | undefined | null, secret: string): Promise<string | undefined>;
-/**
- * Extracts the value part from a signed string without verification.
- *
- * This function simply extracts the original value from a signed string
- * without performing any signature verification. It's useful when you need
- * to access the value quickly without the overhead of cryptographic verification.
- *
- * @example
- * ```ts
- * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
- * const value = getSignedValue(signedValue)
- * expect(value).toEqual("user123")
- * ```
- */
-declare function getSignedValue(signedValue: string | undefined | null): string | undefined;
-
-export { decodeBase64url, decrypt, deleteCookie, encodeBase64url, encrypt, getCookie, getSignedValue, setCookie, sign, unsign };
-export type { GetCookieOptions, SetCookieOptions };
+import { decodeBase64url, encodeBase64url } from "./base64url.js";
+import { GetCookieOptions, SetCookieOptions, deleteCookie, getCookie, setCookie } from "./cookie.js";
+import { decrypt, encrypt } from "./encryption.js";
+import { getSignedValue, sign, unsign } from "./signing.js";
+export { GetCookieOptions, SetCookieOptions, decodeBase64url, decrypt, deleteCookie, encodeBase64url, encrypt, getCookie, getSignedValue, setCookie, sign, unsign };

package/dist/helpers/index.js

@@ -0,0 +1,4 @@
+export { decodeBase64url, encodeBase64url } from "./base64url.js";
+export { deleteCookie, getCookie, setCookie } from "./cookie.js";
+export { decrypt, encrypt } from "./encryption.js";
+export { getSignedValue, sign, unsign } from "./signing.js";

package/dist/helpers/signing.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Signs a string value using HMAC-SHA256 with a secret key.
+ *
+ * This function creates a cryptographic signature that can be used to verify
+ * the integrity and authenticity of the data. The signature is appended to
+ * the original value, separated by a dot, using base64url encoding (no padding).
+ *
+ * @example
+ * ```ts
+ * const signedValue = await sign("user123", "my-secret-key")
+ * expect(signedValue).toEqual("user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+ */
+export declare function sign(value: string, secret: string): Promise<string>;
+/**
+ * Verifies and extracts the original value from a signed string.
+ *
+ * This function validates the signature of a previously signed value using the same
+ * secret key. If the signature is valid, it returns the original value. If the
+ * signature is invalid or the format is incorrect, it returns undefined.
+ *
+ * @example
+ * ```ts
+ * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
+ * const originalValue = await unsign(signedValue, "my-secret-key")
+ * expect(originalValue).toEqual("user123")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+ */
+export declare function unsign(signedValue: string | undefined | null, secret: string): Promise<string | undefined>;
+/**
+ * Extracts the value part from a signed string without verification.
+ *
+ * This function simply extracts the original value from a signed string
+ * without performing any signature verification. It's useful when you need
+ * to access the value quickly without the overhead of cryptographic verification.
+ *
+ * @example
+ * ```ts
+ * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
+ * const value = getSignedValue(signedValue)
+ * expect(value).toEqual("user123")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+ */
+export declare function getSignedValue(signedValue: string | undefined | null): string | undefined;

package/dist/helpers/signing.js

@@ -0,0 +1,78 @@
+import { decodeBase64url, encodeBase64url } from "./base64url.js";
+// src/helpers/signing.ts
+const ALGORITHM = {
+	name: "HMAC",
+	hash: "SHA-256"
+};
+/**
+* Signs a string value using HMAC-SHA256 with a secret key.
+*
+* This function creates a cryptographic signature that can be used to verify
+* the integrity and authenticity of the data. The signature is appended to
+* the original value, separated by a dot, using base64url encoding (no padding).
+*
+* @example
+* ```ts
+* const signedValue = await sign("user123", "my-secret-key")
+* expect(signedValue).toEqual("user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA")
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+*/
+async function sign(value, secret) {
+	const encoder = new TextEncoder();
+	const key = await crypto.subtle.importKey("raw", encoder.encode(secret), ALGORITHM, false, ["sign"]);
+	const signature = await crypto.subtle.sign(ALGORITHM, key, encoder.encode(value));
+	return `${value}.${encodeBase64url(new Uint8Array(signature))}`;
+}
+/**
+* Verifies and extracts the original value from a signed string.
+*
+* This function validates the signature of a previously signed value using the same
+* secret key. If the signature is valid, it returns the original value. If the
+* signature is invalid or the format is incorrect, it returns undefined.
+*
+* @example
+* ```ts
+* const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
+* const originalValue = await unsign(signedValue, "my-secret-key")
+* expect(originalValue).toEqual("user123")
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+*/
+async function unsign(signedValue, secret) {
+	if (typeof signedValue !== "string") return;
+	const lastDotIndex = signedValue.lastIndexOf(".");
+	if (lastDotIndex === -1) return;
+	const value = signedValue.slice(0, lastDotIndex);
+	const signatureBase64url = signedValue.slice(lastDotIndex + 1);
+	const signature = decodeBase64url(signatureBase64url);
+	if (signature === void 0) return;
+	const encoder = new TextEncoder();
+	const key = await crypto.subtle.importKey("raw", encoder.encode(secret), ALGORITHM, false, ["verify"]);
+	return await crypto.subtle.verify(ALGORITHM, key, signature, encoder.encode(value)) ? value : void 0;
+}
+/**
+* Extracts the value part from a signed string without verification.
+*
+* This function simply extracts the original value from a signed string
+* without performing any signature verification. It's useful when you need
+* to access the value quickly without the overhead of cryptographic verification.
+*
+* @example
+* ```ts
+* const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
+* const value = getSignedValue(signedValue)
+* expect(value).toEqual("user123")
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+*/
+function getSignedValue(signedValue) {
+	if (typeof signedValue !== "string") return;
+	const lastDotIndex = signedValue.lastIndexOf(".");
+	if (lastDotIndex === -1) return;
+	return signedValue.slice(0, lastDotIndex);
+}
+export { getSignedValue, sign, unsign };

package/dist/implementer-procedure.d.ts

@@ -0,0 +1,15 @@
+import { BuilderDefinition } from "./builder.js";
+import { Context, MergedContext, MergedInitialContext } from "./context.js";
+import { Middleware } from "./middleware.js";
+import { Procedure, ProcedureHandler } from "./procedure.js";
+import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorConstructorMap } from "@orpc/contract";
+import { IntersectPick } from "@orpc/shared";
+export declare class ProcedureImplementer<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+  "~orpc": BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>;
+  "constructor"(definition: BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>);
+  "use"<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): ProcedureImplementer<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, TErrorMap>;
+  "handler"(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>>): ImplementedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+}
+export declare class ImplementedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> {
+  use<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): ImplementedProcedure<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, TErrorMap>;
+}

package/dist/implementer-procedure.js

@@ -0,0 +1,37 @@
+import { Procedure } from "./procedure.js";
+// src/implementer-procedure.ts
+var ProcedureImplementer = class ProcedureImplementer {
+	"~orpc";
+	"constructor"(definition) {
+		this["~orpc"] = definition;
+	}
+	"use"(middleware) {
+		return new ProcedureImplementer({
+			...this["~orpc"],
+			orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+				middleware,
+				inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+				outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+			}]
+		});
+	}
+	"handler"(handler) {
+		return new ImplementedProcedure({
+			...this["~orpc"],
+			handler
+		});
+	}
+};
+var ImplementedProcedure = class ImplementedProcedure extends Procedure {
+	use(middleware) {
+		return new ImplementedProcedure({
+			...this["~orpc"],
+			orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+				middleware,
+				inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+				outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+			}]
+		});
+	}
+};
+export { ImplementedProcedure, ProcedureImplementer };

package/dist/implementer-router.d.ts

@@ -0,0 +1,34 @@
+import { Context, MergedContext, MergedInitialContext } from "./context.js";
+import { ProcedureImplementer } from "./implementer-procedure.js";
+import { Lazy } from "./lazy.js";
+import { AnyMiddleware, Middleware } from "./middleware.js";
+import { DecoratedMiddleware } from "./middleware-decorated.js";
+import { ProcedureConfig } from "./procedure.js";
+import { ContractedRouter } from "./router.js";
+import { AugmentedRouterWithMiddlewares } from "./router-utils.js";
+import { ErrorMap, InferRouterContractErrorMap, ProcedureContract, RouterContract } from "@orpc/contract";
+import { IntersectPick, Public } from "@orpc/shared";
+export declare class SharedRouterImplementer<TContract extends RouterContract, TInitialContext extends Context> {
+  private readonly contract;
+  private readonly config;
+  private readonly middlewares;
+  private constructor();
+  static create<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract, config: ProcedureConfig): SharedRouterImplementer<TContract, TInitialContext>;
+  static create<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context>(contract: TContract, config: ProcedureConfig, middlewares: AnyMiddleware[]): SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext>;
+  use<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $InContext extends Context = TInitialContext, $ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>>(middleware: Middleware<$InContext | TInitialContext, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, object, $InContext>, $OutContext>;
+  middleware<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $Input, $InContext extends Context = TInitialContext, $Output = any>(middleware: Middleware<$InContext | TInitialContext, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, object, $InContext>, $OutContext, $Input, $Output, object>;
+  router<T extends ContractedRouter<TContract, any>>(router: T): T;
+  lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
+    default: T;
+  }>): Lazy<T>;
+}
+export interface SharedRouterImplementerWithMiddlewares<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context> {
+  use<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>>;
+  middleware<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $Input, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $Output = any>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, $Input, $Output, object>;
+  router<T extends ContractedRouter<TContract, MergedContext<TInitialContext, TInjectedContext>>>(router: T): AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>;
+  lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
+    default: T;
+  }>): Lazy<AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>>;
+}
+export type RouterImplementer<TContract extends RouterContract, TInitialContext extends Context> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, object, $InputSchema, $OutputSchema, $ErrorMap> : Public<SharedRouterImplementer<TContract, TInitialContext>> & { [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementer<TContract[K], TInitialContext> : never; };
+export type RouterImplementerWithMiddlewares<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, TInjectedContext, $InputSchema, $OutputSchema, $ErrorMap> : SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext> & { [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementerWithMiddlewares<TContract[K], TInitialContext, TInjectedContext> : never; };