raffel 0.1.2

package/dist/rate-limit/drivers/redis.js

@@ -0,0 +1,46 @@
+export class RedisRateLimitDriver {
+    name = 'redis';
+    client;
+    prefix;
+    constructor(options) {
+        if (!options.client) {
+            throw new Error('[RedisRateLimitDriver] Redis client is required');
+        }
+        this.client = options.client;
+        this.prefix = options.prefix ?? 'raffel:rate-limit:';
+    }
+    async increment(key, windowMs) {
+        const fullKey = this.getFullKey(key);
+        const count = await this.client.incr(fullKey);
+        if (count === 1) {
+            if (this.client.pexpire) {
+                await this.client.pexpire(fullKey, windowMs);
+            }
+        }
+        let ttlMs = windowMs;
+        if (this.client.pttl) {
+            const ttl = await this.client.pttl(fullKey);
+            if (ttl > 0) {
+                ttlMs = ttl;
+            }
+        }
+        const resetAt = Date.now() + ttlMs;
+        return { count, resetAt };
+    }
+    async decrement(key) {
+        if (!this.client.decr)
+            return;
+        const fullKey = this.getFullKey(key);
+        await this.client.decr(fullKey);
+    }
+    async reset(key) {
+        if (!this.client.del)
+            return;
+        const fullKey = this.getFullKey(key);
+        await this.client.del(fullKey);
+    }
+    getFullKey(key) {
+        return `${this.prefix}${key}`;
+    }
+}
+//# sourceMappingURL=redis.js.map

package/dist/rate-limit/drivers/redis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.js","sourceRoot":"","sources":["../../../src/rate-limit/drivers/redis.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,oBAAoB;IACtB,IAAI,GAAG,OAAO,CAAA;IAEN,MAAM,CAAuC;IAC7C,MAAM,CAAQ;IAE/B,YAAY,OAAoC;QAC9C,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAA;QACpE,CAAC;QAED,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAA;QAC5B,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,oBAAoB,CAAA;IACtD,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,GAAW,EAAE,QAAgB;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;QACpC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QAE7C,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;YAChB,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBACxB,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;YAC9C,CAAC;QACH,CAAC;QAED,IAAI,KAAK,GAAG,QAAQ,CAAA;QACpB,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YACrB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;YAC3C,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC;gBACZ,KAAK,GAAG,GAAG,CAAA;YACb,CAAC;QACH,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAA;QAClC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA;IAC3B,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,GAAW;QACzB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI;YAAE,OAAM;QAC7B,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;QACpC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACjC,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,GAAW;QACrB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG;YAAE,OAAM;QAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;QACpC,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IAChC,CAAC;IAEO,UAAU,CAAC,GAAW;QAC5B,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,CAAA;IAC/B,CAAC;CACF"}

package/dist/rate-limit/factory.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Rate Limit Driver Factory
+ *
+ * Creates rate-limit drivers with a cache-like configuration.
+ */
+import type { RateLimitDriver, RateLimitDriverConfig, MemoryRateLimitDriverOptions, FilesystemRateLimitDriverOptions, RedisRateLimitDriverOptions } from './types.js';
+export declare function createDriver(type: 'memory', options?: MemoryRateLimitDriverOptions): RateLimitDriver;
+export declare function createDriver(type: 'filesystem', options?: FilesystemRateLimitDriverOptions): RateLimitDriver;
+export declare function createDriver(type: 'redis', options: RedisRateLimitDriverOptions): RateLimitDriver;
+export declare function createDriverFromConfig(config: RateLimitDriverConfig): RateLimitDriver;
+//# sourceMappingURL=factory.d.ts.map

package/dist/rate-limit/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/rate-limit/factory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,eAAe,EAEf,qBAAqB,EACrB,4BAA4B,EAC5B,gCAAgC,EAChC,2BAA2B,EAC5B,MAAM,YAAY,CAAA;AAKnB,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,4BAA4B,GAAG,eAAe,CAAA;AACrG,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,gCAAgC,GAAG,eAAe,CAAA;AAC7G,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,2BAA2B,GAAG,eAAe,CAAA;AAiBlG,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,qBAAqB,GAAG,eAAe,CAWrF"}

package/dist/rate-limit/factory.js

@@ -0,0 +1,33 @@
+/**
+ * Rate Limit Driver Factory
+ *
+ * Creates rate-limit drivers with a cache-like configuration.
+ */
+import { MemoryRateLimitDriver } from './drivers/memory.js';
+import { FilesystemRateLimitDriver } from './drivers/filesystem.js';
+import { RedisRateLimitDriver } from './drivers/redis.js';
+export function createDriver(type, options) {
+    switch (type) {
+        case 'memory':
+            return new MemoryRateLimitDriver(options);
+        case 'filesystem':
+            return new FilesystemRateLimitDriver(options);
+        case 'redis':
+            return new RedisRateLimitDriver(options);
+        default:
+            throw new Error(`Unknown rate limit driver type: ${type}`);
+    }
+}
+export function createDriverFromConfig(config) {
+    switch (config.driver) {
+        case 'memory':
+            return createDriver('memory', config.options);
+        case 'filesystem':
+            return createDriver('filesystem', config.options);
+        case 'redis':
+            return createDriver('redis', config.options);
+        default:
+            throw new Error(`Unknown rate limit driver: ${config.driver}`);
+    }
+}
+//# sourceMappingURL=factory.js.map

package/dist/rate-limit/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../src/rate-limit/factory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAKzD,MAAM,UAAU,YAAY,CAC1B,IAAyB,EACzB,OAAuG;IAEvG,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,IAAI,qBAAqB,CAAC,OAAuC,CAAC,CAAA;QAC3E,KAAK,YAAY;YACf,OAAO,IAAI,yBAAyB,CAAC,OAA2C,CAAC,CAAA;QACnF,KAAK,OAAO;YACV,OAAO,IAAI,oBAAoB,CAAC,OAAsC,CAAC,CAAA;QACzE;YACE,MAAM,IAAI,KAAK,CAAC,mCAAmC,IAAI,EAAE,CAAC,CAAA;IAC9D,CAAC;AACH,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,MAA6B;IAClE,QAAQ,MAAM,CAAC,MAAM,EAAE,CAAC;QACtB,KAAK,QAAQ;YACX,OAAO,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,CAAA;QAC/C,KAAK,YAAY;YACf,OAAO,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,CAAA;QACnD,KAAK,OAAO;YACV,OAAO,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,CAAA;QAC9C;YACE,MAAM,IAAI,KAAK,CAAC,8BAA+B,MAA6B,CAAC,MAAM,EAAE,CAAC,CAAA;IAC1F,CAAC;AACH,CAAC"}

package/dist/rate-limit/index.d.ts

@@ -0,0 +1,6 @@
+export type { RateLimitDriver, RateLimitRecord, RateLimitDriverType, RateLimitDriverConfig, MemoryRateLimitDriverOptions, FilesystemRateLimitDriverOptions, RedisRateLimitDriverOptions, RedisLikeClient, } from './types.js';
+export { createDriver, createDriverFromConfig, } from './factory.js';
+export { MemoryRateLimitDriver } from './drivers/memory.js';
+export { FilesystemRateLimitDriver } from './drivers/filesystem.js';
+export { RedisRateLimitDriver } from './drivers/redis.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/rate-limit/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rate-limit/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,qBAAqB,EACrB,4BAA4B,EAC5B,gCAAgC,EAChC,2BAA2B,EAC3B,eAAe,GAChB,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,YAAY,EACZ,sBAAsB,GACvB,MAAM,cAAc,CAAA;AAErB,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/rate-limit/index.js

@@ -0,0 +1,5 @@
+export { createDriver, createDriverFromConfig, } from './factory.js';
+export { MemoryRateLimitDriver } from './drivers/memory.js';
+export { FilesystemRateLimitDriver } from './drivers/filesystem.js';
+export { RedisRateLimitDriver } from './drivers/redis.js';
+//# sourceMappingURL=index.js.map

package/dist/rate-limit/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/rate-limit/index.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,YAAY,EACZ,sBAAsB,GACvB,MAAM,cAAc,CAAA;AAErB,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/rate-limit/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Rate Limit Driver Types
+ *
+ * Driver abstraction for pluggable rate limiting backends.
+ */
+export interface RateLimitRecord {
+    count: number;
+    resetAt: number;
+}
+export interface RateLimitDriver {
+    readonly name: string;
+    increment(key: string, windowMs: number): Promise<RateLimitRecord>;
+    decrement?(key: string): Promise<void>;
+    reset?(key: string): Promise<void>;
+    shutdown?(): Promise<void>;
+}
+export interface MemoryRateLimitDriverOptions {
+    /** Maximum number of keys to keep (default: 10000) */
+    maxKeys?: number;
+    /** Cleanup interval in ms (default: 60000) */
+    cleanupInterval?: number;
+}
+export interface FilesystemRateLimitDriverOptions {
+    /** Directory for storing rate limit state (default: '.rate-limit') */
+    directory?: string;
+    /** Cleanup interval in ms (default: 300000) */
+    cleanupInterval?: number;
+}
+export interface RedisRateLimitDriverOptions {
+    client: RedisLikeClient;
+    prefix?: string;
+}
+export interface RedisLikeClient {
+    incr(key: string): Promise<number>;
+    decr?(key: string): Promise<number>;
+    pexpire?(key: string, ttlMs: number): Promise<number>;
+    pttl?(key: string): Promise<number>;
+    del?(key: string): Promise<number>;
+}
+export type RateLimitDriverType = 'memory' | 'filesystem' | 'redis';
+export type RateLimitDriverConfig = {
+    driver: 'memory';
+    options?: MemoryRateLimitDriverOptions;
+} | {
+    driver: 'filesystem';
+    options?: FilesystemRateLimitDriverOptions;
+} | {
+    driver: 'redis';
+    options: RedisRateLimitDriverOptions;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/rate-limit/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/rate-limit/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IAClE,SAAS,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACtC,KAAK,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClC,QAAQ,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B;AAED,MAAM,WAAW,4BAA4B;IAC3C,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,8CAA8C;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,gCAAgC;IAC/C,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,+CAA+C;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAClC,IAAI,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACnC,OAAO,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACrD,IAAI,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACnC,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACnC;AAED,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,YAAY,GAAG,OAAO,CAAA;AAEnE,MAAM,MAAM,qBAAqB,GAC7B;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,OAAO,CAAC,EAAE,4BAA4B,CAAA;CAAE,GAC5D;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,OAAO,CAAC,EAAE,gCAAgC,CAAA;CAAE,GACpE;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,2BAA2B,CAAA;CAAE,CAAA"}

package/dist/rate-limit/types.js

@@ -0,0 +1,7 @@
+/**
+ * Rate Limit Driver Types
+ *
+ * Driver abstraction for pluggable rate limiting backends.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/rate-limit/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/rate-limit/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/server/builder.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Server Builder Implementation
+ *
+ * Unified server builder with fluent API for multi-protocol support.
+ */
+import type { ServerOptions, RaffelServer } from './types.js';
+/**
+ * Create a unified Raffel server
+ */
+export declare function createServer(options: ServerOptions): RaffelServer;
+//# sourceMappingURL=builder.d.ts.map

package/dist/server/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/server/builder.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,OAAO,KAAK,EACV,aAAa,EAMb,YAAY,EAUb,MAAM,YAAY,CAAA;AAwDnB;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CAg5DjE"}

package/dist/server/builder.int.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Server Builder Tests
+ *
+ * Tests for the unified server API.
+ */
+export {};
+//# sourceMappingURL=builder.int.test.d.ts.map

package/dist/server/builder.int.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.int.test.d.ts","sourceRoot":"","sources":["../../src/server/builder.int.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/server/builder.int.test.js

@@ -0,0 +1,414 @@
+/**
+ * Server Builder Tests
+ *
+ * Tests for the unified server API.
+ */
+import { describe, it, expect, afterEach, beforeEach } from 'vitest';
+import { createServer as createHttpServer } from 'node:http';
+import { mkdtemp, writeFile, rm, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { z } from 'zod';
+import { createServer } from './builder.js';
+import { createRouterModule } from './router-module.js';
+import { createContext } from '../types/index.js';
+import { registerValidator, resetValidation, createZodAdapter } from '../validation/index.js';
+import { loadDiscovery } from './fs-routes/loader.js';
+// Helper to create test envelope with context
+function createTestEnvelope(procedure, payload = {}, type = 'request') {
+    return {
+        id: `test-${Date.now()}`,
+        procedure,
+        type,
+        payload,
+        metadata: {},
+        context: createContext('test-id'),
+    };
+}
+async function getFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = createHttpServer();
+        server.on('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                server.close(() => reject(new Error('Failed to acquire free port')));
+                return;
+            }
+            const { port } = address;
+            server.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(port);
+                }
+            });
+        });
+    });
+}
+async function createTempDir() {
+    return mkdtemp(path.join(os.tmpdir(), 'raffel-channels-'));
+}
+async function writeFixture(root, relativePath, content) {
+    const filePath = path.join(root, relativePath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, 'utf-8');
+}
+const TEST_PORT = 24000;
+describe('createServer', () => {
+    let server = null;
+    beforeEach(() => {
+        // Register Zod adapter for validation tests
+        resetValidation();
+        registerValidator(createZodAdapter(z));
+    });
+    afterEach(async () => {
+        if (server?.isRunning) {
+            await server.stop();
+        }
+        server = null;
+    });
+    describe('basic lifecycle', () => {
+        it('should create a server with default options', () => {
+            server = createServer({ port: TEST_PORT });
+            expect(server).toBeDefined();
+            expect(server.isRunning).toBe(false);
+        });
+        it('should start and stop the server', async () => {
+            server = createServer({ port: TEST_PORT });
+            expect(server.isRunning).toBe(false);
+            await server.start();
+            expect(server.isRunning).toBe(true);
+            expect(server.addresses).toBeDefined();
+            expect(server.addresses?.http.port).toBe(TEST_PORT);
+            await server.stop();
+            expect(server.isRunning).toBe(false);
+        });
+        it('should restart the server', async () => {
+            server = createServer({ port: TEST_PORT });
+            await server.start();
+            expect(server.isRunning).toBe(true);
+            await server.restart();
+            expect(server.isRunning).toBe(true);
+        });
+        it('should throw error when starting already running server', async () => {
+            server = createServer({ port: TEST_PORT });
+            await server.start();
+            await expect(server.start()).rejects.toThrow('Server is already running');
+        });
+    });
+    describe('fluent procedure registration', () => {
+        it('should register a procedure with fluent API', async () => {
+            server = createServer({ port: TEST_PORT });
+            server
+                .procedure('users.create')
+                .input(z.object({ name: z.string() }))
+                .output(z.object({ id: z.string() }))
+                .description('Create a new user')
+                .handler(async (input) => {
+                return { id: `user-${input.name}` };
+            });
+            expect(server.registry.getProcedure('users.create')).toBeDefined();
+        });
+        it('should register a procedure with interceptor', async () => {
+            server = createServer({ port: TEST_PORT });
+            const calls = [];
+            const interceptor = async (_envelope, _ctx, next) => {
+                calls.push('before');
+                const result = await next();
+                calls.push('after');
+                return result;
+            };
+            server
+                .procedure('test')
+                .use(interceptor)
+                .handler(async () => {
+                calls.push('handler');
+                return 'done';
+            });
+            // Call the procedure directly via router
+            const result = (await server.router.handle(createTestEnvelope('test')));
+            expect(result.type).toBe('response');
+            expect(result.payload).toBe('done');
+            expect(calls).toEqual(['before', 'handler', 'after']);
+        });
+        it('should validate input with schema', async () => {
+            server = createServer({ port: TEST_PORT });
+            server
+                .procedure('validate')
+                .input(z.object({ age: z.number().min(0) }))
+                .handler(async (input) => {
+                return { age: input.age };
+            });
+            // Valid input
+            const validResult = (await server.router.handle(createTestEnvelope('validate', { age: 25 })));
+            expect(validResult.type).toBe('response');
+            expect(validResult.payload).toEqual({ age: 25 });
+            // Invalid input
+            const invalidResult = (await server.router.handle(createTestEnvelope('validate', { age: -5 })));
+            expect(invalidResult.type).toBe('error');
+        });
+    });
+    describe('handler groups', () => {
+        it('should create grouped procedures', async () => {
+            server = createServer({ port: TEST_PORT });
+            const users = server.group('users');
+            users.procedure('create').handler(async () => ({ id: '1' }));
+            users.procedure('get').handler(async () => ({ name: 'John' }));
+            users.procedure('list').handler(async () => []);
+            expect(server.registry.getProcedure('users.create')).toBeDefined();
+            expect(server.registry.getProcedure('users.get')).toBeDefined();
+            expect(server.registry.getProcedure('users.list')).toBeDefined();
+        });
+        it('should inherit middleware from group', async () => {
+            server = createServer({ port: TEST_PORT });
+            const calls = [];
+            const groupMiddleware = async (_envelope, _ctx, next) => {
+                calls.push('group-middleware');
+                return next();
+            };
+            const users = server.group('users').use(groupMiddleware);
+            users.procedure('test').handler(async () => {
+                calls.push('handler');
+                return 'done';
+            });
+            await server.router.handle(createTestEnvelope('users.test'));
+            expect(calls).toEqual(['group-middleware', 'handler']);
+        });
+        it('should support nested groups', async () => {
+            server = createServer({ port: TEST_PORT });
+            const users = server.group('users');
+            const admin = users.group('admin');
+            admin.procedure('ban').handler(async () => ({ banned: true }));
+            admin.procedure('unban').handler(async () => ({ banned: false }));
+            expect(server.registry.getProcedure('users.admin.ban')).toBeDefined();
+            expect(server.registry.getProcedure('users.admin.unban')).toBeDefined();
+        });
+        it('should inherit middleware through nested groups', async () => {
+            server = createServer({ port: TEST_PORT });
+            const calls = [];
+            const users = server.group('users').use(async (_env, _ctx, next) => {
+                calls.push('users-mw');
+                return next();
+            });
+            const admin = users.group('admin').use(async (_env, _ctx, next) => {
+                calls.push('admin-mw');
+                return next();
+            });
+            admin.procedure('action').handler(async () => {
+                calls.push('handler');
+                return 'done';
+            });
+            await server.router.handle(createTestEnvelope('users.admin.action'));
+            expect(calls).toEqual(['users-mw', 'admin-mw', 'handler']);
+        });
+    });
+    describe('router modules', () => {
+        it('should mount a module with prefix', async () => {
+            server = createServer({ port: TEST_PORT });
+            const users = createRouterModule('users');
+            users.procedure('create').handler(async () => ({ id: '1' }));
+            server.mount('admin', users);
+            expect(server.registry.getProcedure('admin.users.create')).toBeDefined();
+        });
+        it('should compose prefixes across nested module groups', async () => {
+            server = createServer({ port: TEST_PORT });
+            const users = createRouterModule('users');
+            const admin = users.group('admin');
+            admin.procedure('ban').handler(async () => ({ banned: true }));
+            server.mount('api', users);
+            expect(server.registry.getProcedure('api.users.admin.ban')).toBeDefined();
+        });
+        it('should apply interceptors in deterministic order', async () => {
+            server = createServer({ port: TEST_PORT });
+            const calls = [];
+            const record = (label) => async (_env, _ctx, next) => {
+                calls.push(label);
+                return next();
+            };
+            server.use(record('global'));
+            const module = createRouterModule('users').use(record('module'));
+            module
+                .procedure('action')
+                .use(record('handler'))
+                .handler(async () => {
+                calls.push('handler-fn');
+                return 'ok';
+            });
+            server.mount('admin', module, { interceptors: [record('mount')] });
+            await server.router.handle(createTestEnvelope('admin.users.action'));
+            expect(calls).toEqual(['global', 'mount', 'module', 'handler', 'handler-fn']);
+        });
+    });
+    describe('global middleware', () => {
+        it('should apply global middleware to all procedures', async () => {
+            server = createServer({ port: TEST_PORT });
+            const calls = [];
+            server.use(async (_env, _ctx, next) => {
+                calls.push('global');
+                return next();
+            });
+            server.procedure('test1').handler(async () => {
+                calls.push('handler1');
+                return 'done1';
+            });
+            server.procedure('test2').handler(async () => {
+                calls.push('handler2');
+                return 'done2';
+            });
+            await server.router.handle(createTestEnvelope('test1'));
+            calls.length = 0;
+            await server.router.handle(createTestEnvelope('test2'));
+            expect(calls).toEqual(['global', 'handler2']);
+        });
+    });
+    describe('direct registration (backwards compatible)', () => {
+        it('should support direct procedure registration', async () => {
+            server = createServer({ port: TEST_PORT });
+            server.procedure('legacy', async () => 'legacy-result');
+            const result = (await server.router.handle(createTestEnvelope('legacy')));
+            expect(result.type).toBe('response');
+            expect(result.payload).toBe('legacy-result');
+        });
+    });
+    describe('protocol configuration', () => {
+        it('should enable WebSocket', () => {
+            server = createServer({ port: TEST_PORT });
+            server.enableWebSocket('/ws');
+            // Can't test actual WebSocket without starting, but we can verify it's configured
+            expect(server).toBeDefined();
+        });
+        it('should enable JSON-RPC', () => {
+            server = createServer({ port: TEST_PORT });
+            server.enableJsonRpc('/rpc');
+            expect(server).toBeDefined();
+        });
+        it('should configure TCP', () => {
+            server = createServer({ port: TEST_PORT });
+            server.tcp({ port: TEST_PORT + 10 });
+            expect(server).toBeDefined();
+        });
+        it('should chain protocol configurations', () => {
+            server = createServer({ port: TEST_PORT })
+                .enableWebSocket()
+                .enableJsonRpc()
+                .tcp({ port: TEST_PORT + 10 });
+            expect(server).toBeDefined();
+        });
+    });
+    describe('shared protocol ports', () => {
+        it('should serve JSON-RPC and GraphQL over the HTTP port with basePath', async () => {
+            const port = await getFreePort();
+            server = createServer({
+                port,
+                basePath: '/api',
+                jsonrpc: { path: '/rpc' },
+                graphql: { path: '/graphql' },
+            });
+            server
+                .procedure('getHello')
+                .output(z.string())
+                .handler(async () => 'world');
+            await server.start();
+            expect(server.addresses?.jsonrpc?.port).toBe(port);
+            expect(server.addresses?.jsonrpc?.shared).toBe(true);
+            expect(server.addresses?.jsonrpc?.path).toBe('/api/rpc');
+            expect(server.addresses?.graphql?.port).toBe(port);
+            expect(server.addresses?.graphql?.shared).toBe(true);
+            expect(server.addresses?.graphql?.path).toBe('/api/graphql');
+            const rpcResponse = await fetch(`http://localhost:${port}/api/rpc`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: 1,
+                    method: 'getHello',
+                    params: {},
+                }),
+            });
+            expect(rpcResponse.status).toBe(200);
+            const rpcBody = (await rpcResponse.json());
+            expect(rpcBody.result).toBe('world');
+            const gqlResponse = await fetch(`http://localhost:${port}/api/graphql`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ query: '{ getHello }' }),
+            });
+            expect(gqlResponse.status).toBe(200);
+            const gqlBody = (await gqlResponse.json());
+            expect(gqlBody.data).toEqual({ getHello: 'world' });
+        });
+    });
+    describe('channel auth discovery', () => {
+        let tempDir = null;
+        afterEach(async () => {
+            if (tempDir) {
+                await rm(tempDir, { recursive: true, force: true });
+                tempDir = null;
+            }
+        });
+        it('should apply the closest _auth config for optional channels', async () => {
+            tempDir = await createTempDir();
+            await writeFixture(tempDir, 'src/channels/_auth.js', `export default { anonymous: { principal: 'root-guest' } }\n`);
+            await writeFixture(tempDir, 'src/channels/private/_auth.js', `export default { anonymous: { principal: 'private-guest' } }\n`);
+            await writeFixture(tempDir, 'src/channels/private/room.js', `export const auth = 'optional'\n`);
+            const discovery = await loadDiscovery({
+                baseDir: tempDir,
+                discovery: { channels: true },
+                extensions: ['.js'],
+            });
+            const port = await getFreePort();
+            let observedAuth;
+            server = createServer({
+                port,
+                websocket: {
+                    channels: {
+                        authorize: async (_socketId, _channel, ctx) => {
+                            observedAuth = ctx.auth;
+                            return true;
+                        },
+                    },
+                },
+            });
+            server.addDiscovery(discovery);
+            await server.start();
+            const ctx = createContext('socket-test');
+            const result = await server.channels.subscribe('socket-1', 'private/room', ctx);
+            expect(result.success).toBe(true);
+            expect(observedAuth?.principal).toBe('private-guest');
+        });
+        it('should enforce auth for required channels with _auth config', async () => {
+            tempDir = await createTempDir();
+            await writeFixture(tempDir, 'src/channels/_auth.js', `export default { anonymous: { principal: 'guest' } }\n`);
+            await writeFixture(tempDir, 'src/channels/secure.js', `export const auth = 'required'\n`);
+            const discovery = await loadDiscovery({
+                baseDir: tempDir,
+                discovery: { channels: true },
+                extensions: ['.js'],
+            });
+            const port = await getFreePort();
+            server = createServer({
+                port,
+                websocket: { channels: {} },
+            });
+            server.addDiscovery(discovery);
+            await server.start();
+            const ctx = createContext('socket-test');
+            const result = await server.channels.subscribe('socket-1', 'secure', ctx);
+            expect(result.success).toBe(false);
+            expect(result.error?.code).toBe('PERMISSION_DENIED');
+        });
+    });
+    describe('accessors', () => {
+        it('should provide access to registry', () => {
+            server = createServer({ port: TEST_PORT });
+            expect(server.registry).toBeDefined();
+        });
+        it('should provide access to router', () => {
+            server = createServer({ port: TEST_PORT });
+            expect(server.router).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=builder.int.test.js.map