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

package/dist/helpers/encryption.js

@@ -0,0 +1,80 @@
+import { decodeBase64url, encodeBase64url } from './base64url.js';
+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',
+};
+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}
+ */
+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);
+}
+/**
+ * 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;
+    }
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base64url.ts';
+export * from './cookie.ts';
+export * from './encryption.ts';
+export * from './signing.ts';

package/dist/helpers/index.js

@@ -0,0 +1,4 @@
+export * from './base64url.js';
+export * from './cookie.js';
+export * from './encryption.js';
+export * 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,88 @@
+import { decodeBase64url, encodeBase64url } from './base64url.js';
+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))}`;
+}
+/**
+ * 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;
+}
+/**
+ * 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);
+}

package/dist/implementer-procedure.d.ts

@@ -0,0 +1,16 @@
+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';
+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,44 @@
+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,
+                },
+            ],
+        });
+    }
+}

package/dist/implementer-router.d.ts

@@ -0,0 +1,40 @@
+import type { ErrorMap, InferRouterContractErrorMap, RouterContract } from '@orpc/contract';
+import { ProcedureContract } from '@orpc/contract';
+import type { IntersectPick, Public } from '@orpc/shared';
+import type { Context, MergedContext, MergedInitialContext } from './context.ts';
+import { ProcedureImplementer } from './implementer-procedure.ts';
+import { Lazy } from './lazy.ts';
+import type { DecoratedMiddleware } from './middleware-decorated.ts';
+import type { AnyMiddleware, Middleware } from './middleware.ts';
+import type { ProcedureConfig } from './procedure.ts';
+import type { AugmentedRouterWithMiddlewares } from './router-utils.ts';
+import type { ContractedRouter } from './router.ts';
+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;
+};
+export declare function createRouterImplementer<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract, config: ProcedureConfig): RouterImplementer<TContract, TInitialContext>;

package/dist/implementer-router.js

@@ -0,0 +1,117 @@
+import { ProcedureContract } from '@orpc/contract';
+import { bindMethods, omit, setOwn } from '@orpc/shared';
+import { ProcedureImplementer } from './implementer-procedure.js';
+import { Lazy } from './lazy.js';
+import { decorateMiddleware } from './middleware-decorated.js';
+import { Procedure } from './procedure.js';
+import { withHiddenRouterContract } from './router-hidden.js';
+import { augmentImplementedRouter } from './router-utils.js';
+export class SharedRouterImplementer {
+    contract;
+    config;
+    middlewares;
+    constructor(contract, config, middlewares) {
+        this.contract = contract;
+        this.config = config;
+        this.middlewares = middlewares;
+    }
+    static create(contract, config, middlewares = []) {
+        return new SharedRouterImplementer(contract, config, middlewares);
+    }
+    use(middleware) {
+        return createRouterImplementerInternal(this.contract, this.config, [
+            ...this.middlewares,
+            middleware,
+        ]);
+    }
+    middleware(middleware) {
+        const allMiddlewares = [...this.middlewares, middleware];
+        let current = decorateMiddleware(allMiddlewares.shift());
+        for (const mid of allMiddlewares) {
+            current = current.use(mid);
+        }
+        return current;
+    }
+    router(router) {
+        if (this.middlewares.length) {
+            router = augmentImplementedRouter(router, {
+                ...this.config,
+                middlewares: this.middlewares,
+            });
+        }
+        return withHiddenRouterContract(router, this.contract);
+    }
+    lazy(loader) {
+        return new Lazy({
+            loader: async () => {
+                const { default: router } = await loader();
+                return { default: this.router(router) };
+            },
+            meta: {},
+        });
+    }
+}
+export function createRouterImplementer(contract, config) {
+    return createRouterImplementerInternal(toPlainRouterContract(contract), config, []);
+}
+/**
+ * A normal router can be used as a contract (e.g. for mocking), but its procedures carry a handler,
+ * middlewares and config. Kept as is, unimplemented procedures would pass as procedures, their config
+ * would override the config passed to `implement`, and handlers serving the hidden contract would run
+ * the contract's procedures instead of the actual implementation.
+ *
+ * Rebuilds the contract with every procedure turned into a plain {@link ProcedureContract}
+ * (without `handler`, `orderedMiddlewares` and procedure config), copying only the routers that contain one,
+ * so contract-first contracts are returned as is.
+ */
+function toPlainRouterContract(contract) {
+    if (contract instanceof ProcedureContract) {
+        if (!(contract instanceof Procedure)) {
+            return contract;
+        }
+        // handler & orderedMiddlewares are what make a definition a procedure (see Procedure[Symbol.hasInstance])
+        return new ProcedureContract(omit(contract['~orpc'], [
+            'handler',
+            'orderedMiddlewares',
+            'disableInputValidation',
+            'disableOutputValidation',
+        ]));
+    }
+    let copied;
+    for (const [key, child] of Object.entries(contract)) {
+        const plainChild = toPlainRouterContract(child);
+        if (plainChild !== child) {
+            copied ??= { ...contract };
+            copied[key] = plainChild;
+        }
+    }
+    return (copied ?? contract);
+}
+function createRouterImplementerInternal(contract, config, middlewares) {
+    if (contract instanceof ProcedureContract) {
+        return new ProcedureImplementer({
+            ...config,
+            ...contract['~orpc'],
+            orderedMiddlewares: middlewares.map((middleware) => ({ middleware })),
+        });
+    }
+    const implementer = {};
+    for (const [key, child] of Object.entries(contract)) {
+        setOwn(implementer, key, createRouterImplementerInternal(child, config, middlewares));
+    }
+    const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
+    for (const [key, method] of Object.entries(shared)) {
+        if (Object.hasOwn(implementer, key)) {
+            const child = implementer[key];
+            implementer[key] = new Proxy(method, {
+                get(_, p) {
+                    return Reflect.get(child, p);
+                },
+            });
+        }
+        else {
+            implementer[key] = method;
+        }
+    }
+    return implementer;
+}

package/dist/implementer.d.ts

@@ -0,0 +1,16 @@
+import type { RouterContract } from '@orpc/contract';
+import type { DefaultInitialContext } from './builder.ts';
+import type { Context } from './context.ts';
+import type { RouterImplementer } from './implementer-router.ts';
+import type { ProcedureConfig } from './procedure.ts';
+export type Implementer<TContract extends RouterContract, TInitialContext extends Context> = {
+    $context<T extends Context = DefaultInitialContext>(): Implementer<TContract, T & object>;
+    $config(config: ProcedureConfig): Implementer<TContract, TInitialContext>;
+} & RouterImplementer<TContract, TInitialContext>;
+/**
+ * Turns a contract into an implementer, used to implement the contract's
+ * procedures, routers, and middleware with full type safety.
+ *
+ * @see {@link https://orpc.dev/docs/contract/implementation#implementer | Contract Implementation - Implementer}
+ */
+export declare function implement<TContract extends RouterContract, TInitialContext extends Context = DefaultInitialContext>(contract: TContract, config?: ProcedureConfig): Implementer<TContract, TInitialContext & object>;

package/dist/implementer.js

@@ -0,0 +1,37 @@
+import { isNonPrimitive } from '@orpc/shared';
+import { createRouterImplementer } from './implementer-router.js';
+/**
+ * Turns a contract into an implementer, used to implement the contract's
+ * procedures, routers, and middleware with full type safety.
+ *
+ * @see {@link https://orpc.dev/docs/contract/implementation#implementer | Contract Implementation - Implementer}
+ */
+export function implement(contract, config = {}) {
+    // Using `& object` avoids "has no properties in common with type" errors
+    // when combining procedures or routers with compatible but non-overlapping contexts.
+    const routerImplementer = createRouterImplementer(contract, config);
+    const implementer = new Proxy(routerImplementer, {
+        get(_, p) {
+            let method;
+            if (p === '$context') {
+                method = () => implementer;
+            }
+            else if (p === '$config') {
+                method = (incoming) => implement(contract, { ...config, ...incoming });
+            }
+            const value = Reflect.get(routerImplementer, p);
+            if (method) {
+                if (!isNonPrimitive(value)) {
+                    return method;
+                }
+                return new Proxy(method, {
+                    get(_, p) {
+                        return Reflect.get(value, p);
+                    },
+                });
+            }
+            return value;
+        },
+    });
+    return implementer;
+}

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+export * from './builder.ts';
+export * from './builder-variants.ts';
+export * from './constants.ts';
+export * from './context.ts';
+export * from './implementer.ts';
+export * from './implementer-procedure.ts';
+export { SharedRouterImplementer } from './implementer-router.ts';
+export type { RouterImplementer, RouterImplementerWithMiddlewares, SharedRouterImplementerWithMiddlewares, } from './implementer-router.ts';
+export * from './lazy.ts';
+export * from './middleware.ts';
+export type { DecoratedMiddleware } from './middleware-decorated.ts';
+export * from './procedure.ts';
+export * from './procedure-client.ts';
+export * from './procedure-decorated.ts';
+export { call } from './procedure-utils.ts';
+export type { CallOptions, CallRest } from './procedure-utils.ts';
+export * from './router.ts';
+export type { 
+/**
+ * @deprecated Use `InferRouterFinalContexts` instead.
+ */
+InferRouterFinalContexts as InferRouterCurrentContexts, } from './router.ts';
+export * from './router-client.ts';
+export { getRouter, resolveContractProcedure, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync, } from './router-utils.ts';
+export type { AugmentedRouter, AugmentedRouterWithMiddlewares, UnlaziedRouter, WalkProcedureContractsLazyResult, } from './router-utils.ts';
+export type { AnyORPCError, AnyORPCErrorJSON, Client, ClientContext, ClientOptions, ClientRest, FriendlyClientOptions, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, RPCJsonSerialization, RPCJsonSerializationMeta, RPCJsonSerializerHandler, RPCJsonSerializerOptions, RPCSerializerOptions, RPCSerializerSerializeOptions, SafeResult, } from '@orpc/client';
+export { COMMON_ERROR_STATUS_MAP, isDefinedError, ORPCError, RPCJsonSerializer, RPCSerializer, safe, toORPCError, } from '@orpc/client';
+export type { AnyMetaPlugin, AnySchema, ErrorMap, ErrorMapItem, InferSchemaInput, InferSchemaOutput, InitialInputSchema, InitialOutputSchema, MergedErrorMap, MergedSchema, Meta, MetaPlugin, MetaPluginDefinition, ORPCErrorConstructorMap, ORPCErrorConstructorMapItem, ORPCErrorConstructorMapItemOptions, ORPCErrorFactory, ORPCErrorFactoryOptions, ORPCErrorFromErrorMap, ProcedureContract, ProcedureContractDefinition, RouterContract, Schema, } from '@orpc/contract';
+export { asyncIteratorObject, defineMeta, error, eventIterator, type, ValidationError, } from '@orpc/contract';
+export type { AsyncCleanupFn, AsyncIteratorClassNextFn, DistributiveOmit, IntersectPick, MaybeOptionalOptions, PromiseWithError, Public, Registry, ThrowableError, } from '@orpc/shared';
+export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, 
+/**
+ * @deprecated Use `asyncIteratorToStream` instead.
+ */
+asyncIteratorToStream as eventIteratorToStream, 
+/**
+ * @deprecated Use `asyncIteratorToUnproxiedDataStream` instead.
+ */
+asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, 
+/**
+ * @deprecated Use `streamToAsyncIteratorObject` instead.
+ */
+streamToAsyncIteratorObject as streamToEventIterator, } from '@orpc/shared';
+export type { EventMeta, StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl, } from '@standard-server/core';
+export { 
+/**
+ * @deprecated Use `EventStreamErrorEvent` instead.
+ */
+EventStreamErrorEvent as ErrorEvent, EventStreamErrorEvent, 
+/**
+ * Retrieves metadata attached to a single iterator event value.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/publisher | Publisher Helpers}
+ */
+getEventMeta, unwrapEvent, 
+/**
+ * Returns a new iterator event value with attached, validated metadata.
+ *
+ * @see {@link https://orpc.dev/docs/async-iterator-object#last-event-id--event-metadata | AsyncIteratorObject (SSE) - Last Event ID & Event Metadata}
+ */
+withEventMeta, } from '@standard-server/core';

package/dist/index.js

@@ -0,0 +1,48 @@
+export * from './builder.js';
+export * from './builder-variants.js';
+export * from './constants.js';
+export * from './context.js';
+export * from './implementer.js';
+export * from './implementer-procedure.js';
+export { SharedRouterImplementer } from './implementer-router.js';
+export * from './lazy.js';
+export * from './middleware.js';
+export * from './procedure.js';
+export * from './procedure-client.js';
+export * from './procedure-decorated.js';
+export { call } from './procedure-utils.js';
+export * from './router.js';
+export * from './router-client.js';
+export { getRouter, resolveContractProcedure, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync, } from './router-utils.js';
+export { COMMON_ERROR_STATUS_MAP, isDefinedError, ORPCError, RPCJsonSerializer, RPCSerializer, safe, toORPCError, } from '@orpc/client';
+export { asyncIteratorObject, defineMeta, error, eventIterator, type, ValidationError, } from '@orpc/contract';
+export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, 
+/**
+ * @deprecated Use `asyncIteratorToStream` instead.
+ */
+asyncIteratorToStream as eventIteratorToStream, 
+/**
+ * @deprecated Use `asyncIteratorToUnproxiedDataStream` instead.
+ */
+asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, 
+/**
+ * @deprecated Use `streamToAsyncIteratorObject` instead.
+ */
+streamToAsyncIteratorObject as streamToEventIterator, } from '@orpc/shared';
+export { 
+/**
+ * @deprecated Use `EventStreamErrorEvent` instead.
+ */
+EventStreamErrorEvent as ErrorEvent, EventStreamErrorEvent, 
+/**
+ * Retrieves metadata attached to a single iterator event value.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/publisher | Publisher Helpers}
+ */
+getEventMeta, unwrapEvent, 
+/**
+ * Returns a new iterator event value with attached, validated metadata.
+ *
+ * @see {@link https://orpc.dev/docs/async-iterator-object#last-event-id--event-metadata | AsyncIteratorObject (SSE) - Last Event ID & Event Metadata}
+ */
+withEventMeta, } from '@standard-server/core';

package/dist/lazy.d.ts

@@ -0,0 +1,20 @@
+import type { AnyMetaPlugin, Meta } from '@orpc/contract';
+export interface LazyDefinition<T> {
+    meta: Meta;
+    metaPlugins?: AnyMetaPlugin[] | undefined;
+    loader: () => Promise<{
+        default: T;
+    }>;
+}
+export declare class Lazy<T> {
+    '~orpc': LazyDefinition<T>;
+    constructor(def: LazyDefinition<T>);
+    /**
+     * Checks if the given instance satisfies the {@link Lazy} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+export type Lazyable<T> = T | Lazy<T>;
+export declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;