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

package/dist/helpers/cookie.js

@@ -1,69 +1,62 @@
-import { parseCookie, stringifySetCookie } from 'cookie';
+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}
- */
-export function setCookie(headers, name, value, options = {}) {
-    if (headers === undefined) {
-        return;
-    }
-    const cookieString = stringifySetCookie({
-        // Force path to '/' by default so the cookie is available across the
-        // entire app, not just under the directory of the request that set it
-        // (which is what browsers do per RFC 6265 §5.1.4 when Path is omitted).
-        path: '/',
-        ...options,
-        name, // prioritize
-        value, // prioritize
-    }, options);
-    headers.append('Set-Cookie', cookieString);
+* 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}
- */
-export function getCookie(headers, name, options = {}) {
-    if (headers === undefined) {
-        return undefined;
-    }
-    const cookieHeader = headers.get('cookie');
-    if (cookieHeader === null) {
-        return undefined;
-    }
-    return parseCookie(cookieHeader, options)[name];
+* 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}
- */
-export function deleteCookie(headers, name, options = {}) {
-    return setCookie(headers, name, '', {
-        ...options,
-        maxAge: 0, // prioritize
-    });
+* 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

@@ -25,4 +25,4 @@ export declare function encrypt(value: string, secret: string): Promise<string>;
  *
  * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
  */
-export declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;
+export declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;

package/dist/helpers/encryption.js

@@ -1,80 +1,90 @@
-import { decodeBase64url, encodeBase64url } from './base64url.js';
+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: 60_000,
-    hash: 'SHA-256',
+	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,
+	name: "AES-GCM",
+	length: 256
 };
 const CRYPTO_CONSTANTS = {
-    SALT_LENGTH: 16,
-    IV_LENGTH: 12,
+	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}
- */
-export 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);
+* 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}
- */
-export async function decrypt(encrypted, secret) {
-    try {
-        const data = decodeBase64url(encrypted);
-        if (data === undefined) {
-            return undefined;
-        }
-        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 undefined if decryption fails (invalid key, corrupted data, etc.)
-        return undefined;
-    }
+* 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,4 +1,5 @@
-export * from './base64url.ts';
-export * from './cookie.ts';
-export * from './encryption.ts';
-export * from './signing.ts';
+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

@@ -1,4 +1,4 @@
-export * from './base64url.js';
-export * from './cookie.js';
-export * from './encryption.js';
-export * from './signing.js';
+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

@@ -47,4 +47,4 @@ export declare function unsign(signedValue: string | undefined | null, secret: s
  *
  * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
  */
-export declare function getSignedValue(signedValue: string | undefined | null): string | undefined;
+export declare function getSignedValue(signedValue: string | undefined | null): string | undefined;

package/dist/helpers/signing.js

@@ -1,88 +1,78 @@
-import { decodeBase64url, encodeBase64url } from './base64url.js';
-const ALGORITHM = { name: 'HMAC', hash: 'SHA-256' };
+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}
- */
-export 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))}`;
+* 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}
- */
-export async function unsign(signedValue, secret) {
-    if (typeof signedValue !== 'string') {
-        return undefined;
-    }
-    const lastDotIndex = signedValue.lastIndexOf('.');
-    if (lastDotIndex === -1) {
-        return undefined;
-    }
-    const value = signedValue.slice(0, lastDotIndex);
-    const signatureBase64url = signedValue.slice(lastDotIndex + 1);
-    const signature = decodeBase64url(signatureBase64url);
-    if (signature === undefined) {
-        return undefined;
-    }
-    const encoder = new TextEncoder();
-    const key = await crypto.subtle.importKey('raw', encoder.encode(secret), ALGORITHM, false, [
-        'verify',
-    ]);
-    const isValid = await crypto.subtle.verify(ALGORITHM, key, signature, encoder.encode(value));
-    return isValid ? value : undefined;
+* 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}
- */
-export function getSignedValue(signedValue) {
-    if (typeof signedValue !== 'string') {
-        return undefined;
-    }
-    const lastDotIndex = signedValue.lastIndexOf('.');
-    if (lastDotIndex === -1) {
-        return undefined;
-    }
-    return signedValue.slice(0, lastDotIndex);
+* 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

@@ -1,16 +1,15 @@
-import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorConstructorMap } from '@orpc/contract';
-import type { IntersectPick } from '@orpc/shared';
-import type { BuilderDefinition } from './builder.ts';
-import type { Context, MergedContext, MergedInitialContext } from './context.ts';
-import type { Middleware } from './middleware.ts';
-import type { ProcedureHandler } from './procedure.ts';
-import { Procedure } from './procedure.ts';
+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>;
+  "~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>;
-}
+  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

@@ -1,44 +1,37 @@
-import { Procedure } from './procedure.js';
-export 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,
-        });
-    }
-}
-export class ImplementedProcedure extends Procedure {
-    use(middleware) {
-        // Since middleware executes before the handler, we use `IntersectPick` to ensure
-        // that the middleware's output context ($OutContext) is compatible with the
-        // context requirements of the handler, which may have already been defined.
-        return new ImplementedProcedure({
-            ...this['~orpc'],
-            orderedMiddlewares: [
-                ...this['~orpc'].orderedMiddlewares,
-                {
-                    middleware,
-                    inputSchemasLengthAtUse: this['~orpc'].inputSchemas?.length,
-                    outputSchemasLengthAtUse: this['~orpc'].outputSchemas?.length,
-                },
-            ],
-        });
-    }
-}
+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 };