@tstdl/base 0.93.182 → 0.93.183

package/rpc/tests/rpc.integration.test.js

@@ -1,615 +0,0 @@
-import { CustomError } from '../../errors/custom.error.js';
-import { NotFoundError } from '../../errors/not-found.error.js';
-import { NotImplementedError } from '../../errors/not-implemented.error.js';
-import { NotSupportedError } from '../../errors/not-supported.error.js';
-import { internal } from '../../internal.js';
-import { registerSerializer, serialize } from '../../serializer/index.js';
-import { afterEach, beforeAll, describe, expect, it } from 'vitest';
-import { defaultReadableStreamRpcAdapter } from '../adapters/readable-stream.adapter.js';
-import { MessagePortRpcEndpoint } from '../endpoints/message-port.rpc-endpoint.js';
-import { RpcConnectionClosedError, RpcRemoteError } from '../rpc.error.js';
-import { Rpc } from '../rpc.js';
-class CustomData {
-    foo;
-    constructor(foo) {
-        this.foo = foo;
-    }
-}
-class MyAppError extends CustomError {
-    static errorName = 'MyAppError';
-    code;
-    constructor(message, code) {
-        super({ message });
-        this.code = code;
-    }
-}
-describe('Rpc Integration', () => {
-    afterEach(() => {
-        Rpc.reset();
-    });
-    beforeAll(async () => {
-        try {
-            Rpc.registerAdapter(defaultReadableStreamRpcAdapter);
-        }
-        catch {
-            // ignore
-        }
-        try {
-            registerSerializer(CustomData, 'CustomData', (instance) => ({ foo: instance.foo }), (data) => new CustomData(data.foo));
-            registerSerializer(MyAppError, 'MyAppError', (instance) => ({ message: instance.message, code: instance.code, stack: instance.stack }), (data) => {
-                const error = new MyAppError(data.message, data.code);
-                error.stack = data.stack;
-                return error;
-            });
-            registerSerializer(NotSupportedError, 'NotSupportedError', (instance) => ({ message: instance.message, stack: instance.stack }), (data) => {
-                const error = new NotSupportedError(data.message);
-                error.stack = data.stack;
-                return error;
-            });
-            registerSerializer(NotImplementedError, 'NotImplementedError', (instance) => ({ message: instance.message, stack: instance.stack }), (data) => {
-                const error = new NotImplementedError(data.message);
-                error.stack = data.stack;
-                return error;
-            });
-            registerSerializer(NotFoundError, 'NotFoundError', (instance) => ({ message: instance.message, stack: instance.stack }), (data) => {
-                const error = new NotFoundError(data.message);
-                error.stack = data.stack;
-                return error;
-            });
-        }
-        catch {
-            // ignore
-        }
-    });
-    it('should expose and connect to an object', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const target = {
-            add(a, b) {
-                return a + b;
-            },
-            greet(name) {
-                return `Hello, ${name}!`;
-            },
-        };
-        Rpc.expose(target, 'test-service-1');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-service-1');
-        const sum = await proxy.add(5, 3);
-        expect(sum).toBe(8);
-        const greeting = await proxy.greet('World');
-        expect(greeting).toBe('Hello, World!');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support property access', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const target = {
-            version: '1.0.0',
-            config: {
-                enabled: true,
-            },
-        };
-        Rpc.expose(target, 'test-service-2');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-service-2');
-        expect(await proxy.version).toBe('1.0.0');
-        expect(await proxy.config.enabled).toBe(true);
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support setting properties via helper', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const target = {
-            value: 0,
-        };
-        Rpc.expose(target, 'test-service-3');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-service-3');
-        await Rpc.set(proxy, 'value', 42);
-        expect(await proxy.value).toBe(42);
-        expect(target.value).toBe(42);
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should handle errors and preserve custom properties', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const target = {
-            fail() {
-                throw new MyAppError('Operation failed', 500);
-            },
-        };
-        Rpc.expose(target, 'test-service-4');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-service-4');
-        try {
-            await proxy.fail();
-            expect.fail('Should have thrown');
-        }
-        catch (error) {
-            expect(error.message).toContain('Received error from remote: Operation failed');
-            expect(error.cause).toBeInstanceOf(RpcRemoteError);
-            expect(error.code).toBe(500);
-        }
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support isAlive and release', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        Rpc.expose({ foo: 'bar' }, 'test-service-5');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-service-5');
-        expect(Rpc.isAlive(proxy)).toBe(true);
-        Rpc.release(proxy);
-        expect(Rpc.isAlive(proxy)).toBe(false);
-        await expect(proxy.foo).rejects.toThrow(RpcConnectionClosedError);
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support deleteProperty, defineProperty and has traps', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const target = {
-            foo: 'bar',
-        };
-        Rpc.expose(target, 'test-service-6');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-service-6');
-        expect(await Reflect.has(proxy, 'foo')).toBe(true);
-        await Reflect.deleteProperty(proxy, 'foo');
-        expect(await proxy.foo).toBeUndefined();
-        expect(target.foo).toBeUndefined();
-        await Reflect.defineProperty(proxy, 'newProp', { value: 123, enumerable: true, configurable: true, writable: true });
-        expect(await proxy.newProp).toBe(123);
-        expect(target.newProp).toBe(123);
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support Rpc.delete and Rpc.has helpers', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const target = {
-            foo: 'bar',
-        };
-        Rpc.expose(target, 'test-service-helpers');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-service-helpers');
-        expect(await Rpc.has(proxy, 'foo')).toBe(true);
-        expect(await Rpc.has(proxy, 'nonExistent')).toBe(false);
-        // Standard Reflect.has on a proxy with async traps will always be true (truthy promise)
-        expect(Reflect.has(proxy, 'nonExistent')).toBe(true);
-        const deleteResult = await Rpc.delete(proxy, 'foo');
-        expect(deleteResult).toBe(true);
-        expect(await Rpc.has(proxy, 'foo')).toBe(false);
-        expect(target.foo).toBeUndefined();
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support automatic proxying of nested objects via root', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const nested = {
-            id: 'nested-1',
-            async getValue() { return 'val'; },
-        };
-        const target = {
-            getNested() {
-                return Rpc.proxy(nested, target);
-            },
-        };
-        Rpc.expose(target, 'test-nested-root');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-nested-root');
-        const nestedProxy = await proxy.getNested();
-        expect(await nestedProxy.id).toBe('nested-1');
-        expect(await nestedProxy.getValue()).toBe('val');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support transfers', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const target = {
-            async sum(buffer) {
-                const view = new Uint8Array(buffer);
-                return view.reduce((a, b) => a + b, 0);
-            },
-        };
-        Rpc.expose(target, 'test-transfer');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-transfer');
-        const buffer = new Uint8Array([1, 2, 3, 4, 5]).buffer;
-        const sum = await proxy.sum(Rpc.transfer(buffer, [buffer]));
-        expect(sum).toBe(15);
-        expect(buffer.byteLength).toBe(0); // Should be detached
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support ReadableStream adapter', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const target = {
-            async getStream() {
-                const stream = new ReadableStream({
-                    start(controller) {
-                        controller.enqueue(1);
-                        controller.enqueue(2);
-                        controller.enqueue(3);
-                        controller.close();
-                    },
-                });
-                return Rpc.adapt(stream, defaultReadableStreamRpcAdapter);
-            },
-        };
-        Rpc.expose(target, 'test-stream');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-stream');
-        const stream = await proxy.getStream();
-        const reader = stream.getReader();
-        const results = [];
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
-            }
-            results.push(value);
-        }
-        expect(results).toEqual([1, 2, 3]);
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support direct function exposure', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const target = (name) => `Hello, ${name}!`;
-        Rpc.expose(target, 'test-function');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-function');
-        const result = await proxy('World');
-        expect(result).toBe('Hello, World!');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support constructor exposure and construct trap', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        class Target {
-            name;
-            constructor(name) {
-                this.name = name;
-            }
-            greet() {
-                return `Hello, ${this.name}!`;
-            }
-        }
-        Rpc.expose(Target, 'test-constructor');
-        Rpc.listen(serverEndpoint);
-        const ProxyClass = await Rpc.connect(clientEndpoint, 'test-constructor');
-        const instance = await new ProxyClass('World');
-        expect(await instance.name).toBe('World');
-        expect(await instance.greet()).toBe('Hello, World!');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should return null for getPrototypeOf', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        Rpc.expose({ foo: 'bar' }, 'test-proto');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-proto');
-        expect(Object.getPrototypeOf(proxy)).toBeNull();
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support isProxied helper', () => {
-        const obj = { foo: 'bar' };
-        expect(Rpc.isProxied(obj)).toBe(false);
-        Rpc.proxy(obj);
-        expect(Rpc.isProxied(obj)).toBe(true);
-    });
-    it('should throw error when connecting to non-existent service', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        Rpc.listen(serverEndpoint);
-        await expect(Rpc.connect(clientEndpoint, 'non-existent')).rejects.toThrow('Could not connect to "non-existent" as nothing with that name is exposed.');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should reset exposed services', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        Rpc.expose({ foo: 'bar' }, 'test-reset');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-reset');
-        expect(await proxy.foo).toBe('bar');
-        Rpc.reset();
-        await expect(Rpc.connect(clientEndpoint, 'test-reset')).rejects.toThrow('Could not connect to "test-reset" as nothing with that name is exposed.');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support complex serialization with nested proxies', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const nested = {
-            id: 'nested',
-            async getValue() { return 'val'; },
-        };
-        const target = {
-            getData() {
-                return Rpc.serialize({
-                    info: 'some info',
-                    item: Rpc.proxy(nested),
-                });
-            },
-        };
-        Rpc.expose(target, 'test-complex-serialization');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-complex-serialization');
-        const result = await proxy.getData();
-        expect(result.info).toBe('some info');
-        expect(await result.item.id).toBe('nested');
-        expect(await result.item.getValue()).toBe('val');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should handle non-object errors', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const target = {
-            fail() {
-                throw 'String error';
-            },
-        };
-        Rpc.expose(target, 'test-string-error');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-string-error');
-        try {
-            await proxy.fail();
-            expect.fail('Should have thrown');
-        }
-        catch (error) {
-            expect(error.message).toContain('Received error from remote:');
-            expect(error.message).toContain('String error');
-        }
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support ReadableStream cancellation', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        let cancelled = false;
-        let cancelReason;
-        const target = {
-            getStream() {
-                const stream = new ReadableStream({
-                    cancel(reason) {
-                        cancelled = true;
-                        cancelReason = reason;
-                    },
-                });
-                return Rpc.adapt(stream, defaultReadableStreamRpcAdapter);
-            },
-        };
-        Rpc.expose(target, 'test-stream-cancel');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-stream-cancel');
-        const stream = await proxy.getStream();
-        await stream.cancel('my reason');
-        expect(cancelled).toBe(true);
-        expect(cancelReason).toBe('my reason');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should throw when adapter is not registered on receiver side', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const fakeAdapter = {
-            name: 'Fake',
-            adaptSource: () => ({ data: undefined }),
-            adaptTarget: () => ({}),
-        };
-        const target2 = {
-            getFake() {
-                return Rpc.adapt({}, fakeAdapter);
-            },
-        };
-        Rpc.expose(target2, 'test-fake-adapter');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-fake-adapter');
-        await expect(proxy.getFake()).rejects.toThrow('No adapter registration for "RpcAdapter:Fake" found.');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support MessagePortRpcEndpoint.from', () => {
-        const { port1 } = new MessageChannel();
-        const endpoint = MessagePortRpcEndpoint.from(port1);
-        expect(endpoint).toBeInstanceOf(MessagePortRpcEndpoint);
-        endpoint.close();
-    });
-    it('should handle SharedWorker in browser-like environment', async () => {
-        const originalSharedWorker = globalThis.SharedWorker;
-        const originalWindow = globalThis.window;
-        // Mock SharedWorker and browser environment
-        const mockPort = {
-            addEventListener: () => { },
-            removeEventListener: () => { },
-            start: () => { },
-            close: () => { },
-            postMessage: () => { },
-        };
-        const MockSharedWorker = class {
-            port = mockPort;
-            addEventListener = () => { };
-            removeEventListener = () => { };
-        };
-        globalThis.SharedWorker = MockSharedWorker;
-        globalThis.window = { document: {} };
-        // Re-importing or relying on the fact that isBrowser check happens at runtime in constructor
-        // Actually, it uses isBrowser which is imported.
-        // Let's just mock the transport property check.
-        const worker = new MockSharedWorker();
-        const endpoint = new MessagePortRpcEndpoint(worker);
-        // If isBrowser was false, it would use source (worker) instead of source.port (mockPort)
-        // To ensure it hits the branch, we can try to force isBrowser to true if we were using a proxy or something,
-        // but here we just want to see if we can trigger the logic.
-        // Since isBrowser is already evaluated, we might need to mock it earlier or use a different approach.
-        // But let's see what happens.
-        // expect((endpoint as any).transport).toBe(mockPort);
-        globalThis.SharedWorker = originalSharedWorker;
-        globalThis.window = originalWindow;
-    });
-    it('should throw for unsupported message types in listen', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        Rpc.listen(serverEndpoint);
-        const controlChannel = clientEndpoint.getOrOpenChannel('control');
-        const response = await controlChannel.request({ type: 'unsupported' });
-        expect(() => Rpc[internal].parseRpcMessageValue(response, clientEndpoint)).toThrow('Message type unsupported not supported in listen.');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should throw for unsupported message types in exposeObject', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        Rpc.expose({ foo: 'bar' }, 'test-unsupported-proxy');
-        Rpc.listen(serverEndpoint);
-        const controlChannel = clientEndpoint.getOrOpenChannel('control');
-        const response = await controlChannel.request({ type: 'connect', name: 'test-unsupported-proxy' });
-        const proxyChannel = clientEndpoint.getChannel(response.channel);
-        const response2 = await proxyChannel.request({ type: 'unsupported', path: ['foo'] });
-        expect(() => Rpc[internal].parseRpcMessageValue(response2, clientEndpoint)).toThrow('Unsupported message type unsupported.');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support adapt with root object', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const stream = new ReadableStream();
-        const root = { stream: Rpc.adapt(stream, defaultReadableStreamRpcAdapter, stream) };
-        Rpc.expose(root, 'test-adapt-root');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-adapt-root');
-        expect(await proxy.stream).toBeInstanceOf(ReadableStream);
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should throw when serializing a marked rpc proxy directly', async () => {
-        const proxyInstance = new Rpc[internal].RpcProxy();
-        expect(() => serialize(proxyInstance)).toThrow(NotSupportedError);
-    });
-    it('should support serializing an object marked with Rpc.adapt', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const adapter = {
-            name: 'test-serialize-adapt',
-            adaptSource: () => ({ data: 'some-data', transfer: [] }),
-            adaptTarget: (data) => ({ deserializedData: data }),
-        };
-        Rpc.registerAdapter(adapter);
-        const target = {
-            getAdapted() {
-                const obj = {};
-                Rpc.adapt(obj, adapter);
-                return Rpc.serialize(obj);
-            },
-        };
-        Rpc.expose(target, 'test-serialize-adapt-service');
-        Rpc.listen(serverEndpoint);
-        const proxy = await Rpc.connect(clientEndpoint, 'test-serialize-adapt-service');
-        const result = await proxy.getAdapted();
-        expect(result.deserializedData).toBe('some-data');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should throw for unsupported message types in ReadableStreamRpcAdapter', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const stream = new ReadableStream();
-        const channel = serverEndpoint.openChannel();
-        defaultReadableStreamRpcAdapter.adaptSource(stream, channel);
-        // Wait for channel to be established on both sides
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        const clientChannel = clientEndpoint.getChannel(channel.id);
-        const response = await clientChannel.request({ type: 'unsupported' });
-        expect(() => Rpc[internal].parseRpcMessageValue(response, clientEndpoint)).toThrow('Type unsupported is not supported.');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should support MessagePortRpcEndpoint.close', () => {
-        const { port1 } = new MessageChannel();
-        const endpoint = new MessagePortRpcEndpoint(port1);
-        endpoint.close(); // Should not throw
-    });
-    it('should throw for unsupported response types in ReadableStreamRpcAdapter target', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const channel = serverEndpoint.openChannel();
-        const stream = defaultReadableStreamRpcAdapter.adaptTarget(undefined, channel);
-        const clientChannel = clientEndpoint.getChannel(channel.id);
-        clientChannel.request$.subscribe(({ id }) => {
-            clientChannel.respond(id, { type: 'unsupported' });
-        });
-        const reader = stream.getReader();
-        await expect(reader.read()).rejects.toThrow('Type unsupported is not supported.');
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should throw RpcConnectionClosedError when channel is closed during request', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const serverEndpoint = new MessagePortRpcEndpoint(port1);
-        const clientEndpoint = new MessagePortRpcEndpoint(port2);
-        const channel = clientEndpoint.openChannel();
-        const requestPromise = channel.request({ type: 'get', path: ['foo'] });
-        channel.close();
-        await expect(requestPromise).rejects.toThrow(RpcConnectionClosedError);
-        serverEndpoint.close();
-        clientEndpoint.close();
-    });
-    it('should throw for unsupported rpc value types', () => {
-        expect(() => Rpc[internal].parseRpcMessageValue({ type: 'unsupported' }, {})).toThrow('Type unsupported not supported');
-    });
-    it('should handle open-channel message for existing channel', async () => {
-        const { port1, port2 } = new MessageChannel();
-        const sourceEndpoint = new MessagePortRpcEndpoint(port1);
-        const targetEndpoint = new MessagePortRpcEndpoint(port2);
-        const channelId = 'existing-channel';
-        const channel = sourceEndpoint.openChannel(channelId);
-        const { port2: p2 } = new MessageChannel();
-        // Manually trigger handleOpenChannelMessage on the target side
-        targetEndpoint.handleOpenChannelMessage({ seq: 1, type: 'open-channel', id: channelId, port: p2 });
-        // It should just update the transport
-        expect(targetEndpoint[internal].channels.has(channelId)).toBe(true);
-        channel.close();
-        sourceEndpoint.close();
-        targetEndpoint.close();
-    });
-});

package/signals/implementation/errors.d.ts

@@ -1,2 +0,0 @@
-export declare function throwInvalidWriteToSignalError(): void;
-export declare function setThrowInvalidWriteToSignalError(fn: () => never): void;