raffel 1.0.6 → 1.0.7

package/dist/inspect/playground-invokers.js

@@ -0,0 +1,950 @@
+/**
+ * Inspect — Playground protocol invokers and session management
+ *
+ * Handles HTTP, JSON-RPC, GraphQL, gRPC invocations and
+ * WebSocket/SSE session lifecycle for the playground server.
+ */
+import { randomUUID } from 'node:crypto';
+import { createConnection } from 'node:net';
+import { createSocket } from 'node:dgram';
+import * as grpc from '@grpc/grpc-js';
+import * as protoLoader from '@grpc/proto-loader';
+import { WebSocket } from 'ws';
+const TCP_LENGTH_HEADER_SIZE = 4;
+export function normalizeConnectHost(host) {
+    if (!host || host === '0.0.0.0' || host === '::') {
+        return '127.0.0.1';
+    }
+    return host;
+}
+export function toStringRecord(input) {
+    if (!input) {
+        return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (value === undefined || value === null)
+            continue;
+        result[key] = String(value);
+    }
+    return result;
+}
+function sanitizeQueryRecord(input) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(input)) {
+        if (value === undefined || value === null || value === '')
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                params.append(key, String(item));
+            }
+            continue;
+        }
+        params.set(key, String(value));
+    }
+    const rendered = params.toString();
+    return rendered ? `?${rendered}` : '';
+}
+function interpolatePath(pathname, params) {
+    let rendered = pathname;
+    for (const [key, value] of Object.entries(params)) {
+        rendered = rendered.replaceAll(`:${key}`, encodeURIComponent(String(value)));
+        rendered = rendered.replaceAll(`:${key}?`, encodeURIComponent(String(value)));
+    }
+    return rendered.replace(/\/:\w+\?/g, '');
+}
+function buildTargetUrl(entry, payload, options = {}) {
+    const protocol = options.protocol ?? (entry.protocol === 'websocket' ? 'ws' : 'http');
+    const host = normalizeConnectHost(entry.target.host);
+    const port = entry.target.port;
+    const pathname = interpolatePath(options.path ?? entry.target.path ?? '/', payload.params ?? {});
+    const query = sanitizeQueryRecord(toStringRecord(payload.query));
+    return `${protocol}://${host}:${port}${pathname}${query}`;
+}
+function buildHttpUrl(entry, payload) {
+    return buildTargetUrl(entry, payload);
+}
+function buildWebSocketCandidates(entry, payload) {
+    const candidates = [buildTargetUrl(entry, payload, { protocol: 'ws' })];
+    const path = entry.target.path;
+    if (path) {
+        const segments = path.split('/').filter(Boolean);
+        if (segments.length > 1) {
+            const fallbackPath = `/${segments[segments.length - 1]}`;
+            const fallbackUrl = buildTargetUrl(entry, payload, { protocol: 'ws', path: fallbackPath });
+            if (!candidates.includes(fallbackUrl)) {
+                candidates.push(fallbackUrl);
+            }
+        }
+    }
+    return candidates;
+}
+export function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => {
+            try {
+                const text = Buffer.concat(chunks).toString('utf8');
+                resolve((text ? JSON.parse(text) : {}));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+async function parseFetchResponse(response) {
+    const contentType = response.headers.get('content-type') ?? '';
+    if (contentType.includes('application/json')) {
+        return response.json();
+    }
+    return response.text();
+}
+function encodeDatagramPayload(payload) {
+    if (payload === undefined || payload === null) {
+        return Buffer.alloc(0);
+    }
+    if (typeof payload === 'string') {
+        return Buffer.from(payload, 'utf8');
+    }
+    return Buffer.from(JSON.stringify(payload), 'utf8');
+}
+function decodeDatagramPayload(payload) {
+    const raw = payload.toString('utf8');
+    if (!raw) {
+        return '';
+    }
+    return parseMaybeJson(raw);
+}
+function encodeTcpRawPayload(payload) {
+    if (payload === undefined || payload === null) {
+        return Buffer.alloc(0);
+    }
+    if (typeof payload === 'string') {
+        return Buffer.from(payload, 'utf8');
+    }
+    return Buffer.from(JSON.stringify(payload), 'utf8');
+}
+function frameTcpMessage(message) {
+    const data = Buffer.from(JSON.stringify(message), 'utf8');
+    const frame = Buffer.allocUnsafe(TCP_LENGTH_HEADER_SIZE + data.length);
+    frame.writeUInt32BE(data.length, 0);
+    data.copy(frame, TCP_LENGTH_HEADER_SIZE);
+    return frame;
+}
+function connectTcpSocket(entry) {
+    const port = entry.target.port;
+    if (port === undefined) {
+        throw new Error(`Missing TCP target port for playground entry "${entry.key}"`);
+    }
+    return new Promise((resolve, reject) => {
+        const socket = createConnection({
+            host: normalizeConnectHost(entry.target.host),
+            port,
+        }, () => resolve(socket));
+        socket.once('error', reject);
+    });
+}
+function waitForTcpEnvelope(socket, timeoutMs = 5000) {
+    return new Promise((resolve, reject) => {
+        let buffer = Buffer.alloc(0);
+        const timeout = setTimeout(() => {
+            cleanup();
+            reject(new Error(`Timed out waiting for TCP response after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timeout);
+            socket.off('data', onData);
+            socket.off('error', onError);
+            socket.off('close', onClose);
+        };
+        const onError = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const onClose = () => {
+            cleanup();
+            reject(new Error('TCP socket closed before a response was received'));
+        };
+        const onData = (chunk) => {
+            buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+            while (buffer.length >= TCP_LENGTH_HEADER_SIZE) {
+                const messageLength = buffer.readUInt32BE(0);
+                const totalLength = TCP_LENGTH_HEADER_SIZE + messageLength;
+                if (buffer.length < totalLength) {
+                    return;
+                }
+                const messageData = buffer.subarray(TCP_LENGTH_HEADER_SIZE, totalLength);
+                buffer = buffer.subarray(totalLength);
+                try {
+                    cleanup();
+                    resolve(JSON.parse(messageData.toString('utf8')));
+                }
+                catch (error) {
+                    cleanup();
+                    reject(error);
+                }
+                return;
+            }
+        };
+        socket.on('data', onData);
+        socket.once('error', onError);
+        socket.once('close', onClose);
+    });
+}
+function attachTcpEnvelopeStream(socket, handlers) {
+    let buffer = Buffer.alloc(0);
+    socket.on('data', (chunk) => {
+        buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+        while (buffer.length >= TCP_LENGTH_HEADER_SIZE) {
+            const messageLength = buffer.readUInt32BE(0);
+            const totalLength = TCP_LENGTH_HEADER_SIZE + messageLength;
+            if (buffer.length < totalLength) {
+                return;
+            }
+            const messageData = buffer.subarray(TCP_LENGTH_HEADER_SIZE, totalLength);
+            buffer = buffer.subarray(totalLength);
+            try {
+                handlers.onEnvelope(JSON.parse(messageData.toString('utf8')));
+            }
+            catch (error) {
+                handlers.onError(error);
+            }
+        }
+    });
+    socket.on('error', handlers.onError);
+    if (handlers.onClose) {
+        socket.on('close', handlers.onClose);
+    }
+}
+function attachRawTcpMessageStream(socket, framing, handlers) {
+    if (!framing || framing.type === 'none') {
+        socket.on('data', (chunk) => {
+            handlers.onMessage(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+    }
+    else if (framing.type === 'delimiter' && framing.delimiter) {
+        let buffer = Buffer.alloc(0);
+        const delimiter = Buffer.from(framing.delimiter, 'utf8');
+        socket.on('data', (chunk) => {
+            buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+            let index = -1;
+            while ((index = buffer.indexOf(delimiter)) !== -1) {
+                const message = buffer.subarray(0, index);
+                buffer = buffer.subarray(index + delimiter.length);
+                handlers.onMessage(message);
+            }
+        });
+    }
+    else if (framing.type === 'length-prefixed') {
+        const lengthBytes = framing.lengthBytes ?? 4;
+        const lengthEncoding = framing.lengthEncoding ?? 'BE';
+        let buffer = Buffer.alloc(0);
+        socket.on('data', (chunk) => {
+            buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+            while (buffer.length >= lengthBytes) {
+                const length = lengthBytes === 1
+                    ? buffer.readUInt8(0)
+                    : lengthBytes === 2
+                        ? (lengthEncoding === 'BE' ? buffer.readUInt16BE(0) : buffer.readUInt16LE(0))
+                        : (lengthEncoding === 'BE' ? buffer.readUInt32BE(0) : buffer.readUInt32LE(0));
+                const totalLength = lengthBytes + length;
+                if (buffer.length < totalLength) {
+                    return;
+                }
+                const message = buffer.subarray(lengthBytes, totalLength);
+                buffer = buffer.subarray(totalLength);
+                handlers.onMessage(message);
+            }
+        });
+    }
+    socket.on('error', handlers.onError);
+    if (handlers.onClose) {
+        socket.on('close', handlers.onClose);
+    }
+}
+function frameRawTcpMessage(payload, framing) {
+    if (!framing || framing.type === 'none') {
+        return payload;
+    }
+    if (framing.type === 'delimiter' && framing.delimiter) {
+        return Buffer.concat([payload, Buffer.from(framing.delimiter, 'utf8')]);
+    }
+    const lengthBytes = framing.lengthBytes ?? 4;
+    const lengthEncoding = framing.lengthEncoding ?? 'BE';
+    const header = Buffer.alloc(lengthBytes);
+    if (lengthBytes === 1) {
+        header.writeUInt8(payload.length, 0);
+    }
+    else if (lengthBytes === 2) {
+        if (lengthEncoding === 'BE') {
+            header.writeUInt16BE(payload.length, 0);
+        }
+        else {
+            header.writeUInt16LE(payload.length, 0);
+        }
+    }
+    else if (lengthEncoding === 'BE') {
+        header.writeUInt32BE(payload.length, 0);
+    }
+    else {
+        header.writeUInt32LE(payload.length, 0);
+    }
+    return Buffer.concat([header, payload]);
+}
+export async function invokeHttp(entry, payload) {
+    if (entry.mode === 'stream') {
+        throw new Error('Use a session for HTTP stream bindings');
+    }
+    const url = buildHttpUrl(entry, payload);
+    const headers = {
+        ...toStringRecord(payload.headers),
+        ...toStringRecord(payload.metadata),
+    };
+    const method = entry.label.split(' ')[0] || 'POST';
+    const requestInit = {
+        method,
+        headers,
+    };
+    if (method !== 'GET' && payload.body !== undefined) {
+        requestInit.body = JSON.stringify(payload.body);
+        if (!headers['content-type']) {
+            headers['content-type'] = 'application/json';
+        }
+    }
+    const response = await fetch(url, requestInit);
+    return {
+        ok: response.ok,
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: await parseFetchResponse(response),
+    };
+}
+export async function invokeJsonRpc(entry, payload) {
+    const url = buildHttpUrl(entry, payload);
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            ...toStringRecord(payload.headers),
+            ...toStringRecord(payload.metadata),
+        },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            method: entry.label,
+            params: payload.body ?? {},
+            id: 'playground-call',
+        }),
+    });
+    return {
+        ok: response.ok,
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: await parseFetchResponse(response),
+    };
+}
+export async function invokeGraphQL(entry, payload) {
+    const url = buildHttpUrl(entry, payload);
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            ...toStringRecord(payload.headers),
+            ...toStringRecord(payload.metadata),
+        },
+        body: JSON.stringify({
+            query: payload.document,
+        }),
+    });
+    return {
+        ok: response.ok,
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: await parseFetchResponse(response),
+    };
+}
+function resolveGrpcClient(root, fullName) {
+    const parts = fullName.split('.').filter(Boolean);
+    let current = root;
+    for (const part of parts) {
+        if (!current || typeof current !== 'object' || !(part in current)) {
+            throw new Error(`gRPC service "${fullName}" not found in loaded proto definition`);
+        }
+        current = current[part];
+    }
+    return current;
+}
+function createGrpcClient(entry, graph) {
+    const transport = graph.transports.find((candidate) => candidate.id === entry.transportId);
+    if (!transport?.grpc) {
+        throw new Error('Missing gRPC transport metadata for playground invocation');
+    }
+    const definition = protoLoader.loadSync(transport.grpc.protoPath, {
+        keepCase: true,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true,
+    });
+    const proto = grpc.loadPackageDefinition(definition);
+    const Client = resolveGrpcClient(proto, entry.target.service ?? '');
+    return new Client(`${normalizeConnectHost(entry.target.host)}:${entry.target.port}`, grpc.credentials.createInsecure());
+}
+function buildGrpcMetadata(payload) {
+    const metadata = new grpc.Metadata();
+    for (const [key, value] of Object.entries(toStringRecord(payload.metadata))) {
+        metadata.set(key, value);
+    }
+    return metadata;
+}
+export async function invokeGrpc(entry, payload, graph) {
+    if (entry.mode !== 'unary') {
+        throw new Error(`Use a session for gRPC ${entry.mode} methods`);
+    }
+    const client = createGrpcClient(entry, graph);
+    const metadata = buildGrpcMetadata(payload);
+    try {
+        const response = await new Promise((resolve, reject) => {
+            client[entry.target.method ?? ''](payload.body ?? {}, metadata, (error, result) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+        return {
+            ok: true,
+            body: response,
+        };
+    }
+    finally {
+        client.close();
+    }
+}
+export async function invokeTcp(entry, payload) {
+    if (entry.mode === 'stream') {
+        throw new Error('Use a session for TCP stream bindings');
+    }
+    const socket = await connectTcpSocket(entry);
+    const requestId = randomUUID();
+    const metadata = {
+        ...toStringRecord(payload.headers),
+        ...toStringRecord(payload.metadata),
+    };
+    const message = {
+        id: requestId,
+        procedure: entry.target.procedure ?? entry.label,
+        type: entry.mode === 'event' ? 'event' : 'request',
+        payload: payload.body ?? {},
+        metadata,
+    };
+    try {
+        const responsePromise = waitForTcpEnvelope(socket);
+        socket.write(frameTcpMessage(message));
+        const response = await responsePromise;
+        return {
+            ok: response.type !== 'error',
+            body: response.payload,
+            envelope: response,
+        };
+    }
+    finally {
+        socket.destroy();
+    }
+}
+export async function invokeUdp(entry, payload) {
+    const port = entry.target.port;
+    if (port === undefined) {
+        throw new Error(`Missing UDP target port for playground entry "${entry.key}"`);
+    }
+    const socketType = entry.target.socketType ?? 'udp4';
+    const socket = createSocket(socketType);
+    const body = encodeDatagramPayload(payload.body);
+    try {
+        await new Promise((resolve, reject) => {
+            socket.once('error', reject);
+            socket.bind(() => resolve());
+        });
+        const response = await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                cleanup();
+                resolve({
+                    ok: true,
+                    body: null,
+                    note: 'No UDP response received before timeout; the handler may be fire-and-forget.',
+                });
+            }, 1500);
+            const cleanup = () => {
+                clearTimeout(timeout);
+                socket.off('message', onMessage);
+                socket.off('error', onError);
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const onMessage = (message) => {
+                cleanup();
+                resolve({
+                    ok: true,
+                    body: decodeDatagramPayload(message),
+                });
+            };
+            socket.once('error', onError);
+            socket.once('message', onMessage);
+            socket.send(body, port, normalizeConnectHost(entry.target.host), (error) => {
+                if (error) {
+                    cleanup();
+                    reject(error);
+                }
+            });
+        });
+        return response;
+    }
+    finally {
+        socket.close();
+    }
+}
+export function toSessionView(session) {
+    return {
+        id: session.id,
+        entry: session.entry.key,
+        state: session.state,
+        protocol: session.protocol,
+        mode: session.mode,
+        target: session.target,
+        sent: [...session.sent],
+        received: [...session.received],
+        errors: [...session.errors],
+    };
+}
+function parseMaybeJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+export async function createGrpcSession(entry, payload, graph) {
+    const client = createGrpcClient(entry, graph);
+    const metadata = buildGrpcMetadata(payload);
+    const sent = [];
+    const received = [];
+    const errors = [];
+    const target = `${normalizeConnectHost(entry.target.host)}:${entry.target.port}/${entry.target.service}.${entry.target.method}`;
+    const methodName = entry.target.method ?? '';
+    let closing = false;
+    let resolveSettled = null;
+    let rejectSettled = null;
+    const settled = new Promise((resolve, reject) => {
+        resolveSettled = resolve;
+        rejectSettled = reject;
+    });
+    const session = {
+        id: randomUUID(),
+        entry,
+        state: 'connecting',
+        protocol: entry.protocol,
+        mode: entry.mode,
+        target,
+        sent,
+        received,
+        errors,
+        async close() {
+            closing = true;
+            if (entry.mode === 'server-streaming') {
+                readableCall?.cancel();
+                client.close();
+                session.state = 'closed';
+                resolveSettled?.();
+                return;
+            }
+            if (entry.mode === 'client-streaming') {
+                writableCall?.end();
+            }
+            else if (entry.mode === 'bidirectional') {
+                duplexCall?.end();
+            }
+            try {
+                await settled;
+            }
+            finally {
+                client.close();
+            }
+        },
+    };
+    let readableCall = null;
+    let writableCall = null;
+    let duplexCall = null;
+    const pushReceived = (message) => {
+        received.push({ at: new Date().toISOString(), payload: message });
+    };
+    const handleError = (error) => {
+        const isCancellation = error.code === grpc.status.CANCELLED;
+        if (closing && isCancellation) {
+            session.state = 'closed';
+            resolveSettled?.();
+            return;
+        }
+        session.state = 'error';
+        errors.push(error.message);
+        rejectSettled?.(error);
+    };
+    if (entry.mode === 'server-streaming') {
+        readableCall = client[methodName](payload.body ?? {}, metadata);
+        readableCall.on('data', (chunk) => {
+            pushReceived({ type: 'data', payload: chunk });
+        });
+        readableCall.on('end', () => {
+            session.state = 'closed';
+            resolveSettled?.();
+            client.close();
+        });
+        readableCall.on('error', handleError);
+        session.state = 'open';
+        return session;
+    }
+    if (entry.mode === 'client-streaming') {
+        writableCall = client[methodName](metadata, (error, result) => {
+            if (error) {
+                handleError(error);
+                return;
+            }
+            pushReceived({ type: 'response', payload: result });
+            session.state = 'closed';
+            resolveSettled?.();
+        });
+        session.send = (message) => {
+            writableCall?.write(message);
+            sent.push({ at: new Date().toISOString(), payload: message });
+        };
+        writableCall.on('error', handleError);
+        session.state = 'open';
+        return session;
+    }
+    if (entry.mode !== 'bidirectional') {
+        client.close();
+        throw new Error(`Sessions are not supported for gRPC ${entry.mode}`);
+    }
+    duplexCall = client[methodName](metadata);
+    duplexCall.on('data', (chunk) => {
+        pushReceived({ type: 'data', payload: chunk });
+    });
+    duplexCall.on('end', () => {
+        session.state = 'closed';
+        resolveSettled?.();
+        client.close();
+    });
+    duplexCall.on('error', handleError);
+    session.send = (message) => {
+        duplexCall?.write(message);
+        sent.push({ at: new Date().toISOString(), payload: message });
+    };
+    session.state = 'open';
+    return session;
+}
+export async function createTcpStreamSession(entry, payload) {
+    if (entry.mode !== 'stream') {
+        throw new Error(`TCP sessions are only supported for stream bindings; received ${entry.mode}`);
+    }
+    const socket = await connectTcpSocket(entry);
+    const requestId = randomUUID();
+    const target = `${normalizeConnectHost(entry.target.host)}:${entry.target.port}/${entry.target.procedure ?? entry.label}`;
+    const sent = [];
+    const received = [];
+    const errors = [];
+    let closing = false;
+    const session = {
+        id: randomUUID(),
+        entry,
+        state: 'connecting',
+        protocol: entry.protocol,
+        mode: entry.mode,
+        target,
+        sent,
+        received,
+        errors,
+        async close() {
+            closing = true;
+            if (!socket.destroyed) {
+                socket.write(frameTcpMessage({
+                    id: requestId,
+                    type: 'cancel',
+                }));
+                socket.end();
+            }
+            session.state = 'closed';
+        },
+    };
+    attachTcpEnvelopeStream(socket, {
+        onEnvelope(envelope) {
+            received.push({ at: new Date().toISOString(), payload: envelope });
+            if (envelope.type === 'stream:end') {
+                session.state = 'closed';
+            }
+            else if (envelope.type === 'stream:error' || envelope.type === 'error') {
+                session.state = closing ? 'closed' : 'error';
+            }
+            else if (session.state === 'connecting') {
+                session.state = 'open';
+            }
+        },
+        onError(error) {
+            if (closing) {
+                session.state = 'closed';
+                return;
+            }
+            session.state = 'error';
+            errors.push(error.message);
+        },
+        onClose() {
+            if (session.state !== 'error') {
+                session.state = 'closed';
+            }
+        },
+    });
+    socket.write(frameTcpMessage({
+        id: requestId,
+        procedure: entry.target.procedure ?? entry.label,
+        type: 'stream:start',
+        payload: payload.body ?? {},
+        metadata: {
+            ...toStringRecord(payload.headers),
+            ...toStringRecord(payload.metadata),
+        },
+    }));
+    session.state = 'open';
+    return session;
+}
+export async function createRawTcpSession(entry) {
+    const socket = await connectTcpSocket(entry);
+    const sent = [];
+    const received = [];
+    const errors = [];
+    const target = `${normalizeConnectHost(entry.target.host)}:${entry.target.port}/${entry.target.procedure ?? entry.label}`;
+    const framing = entry.target.framing;
+    const session = {
+        id: randomUUID(),
+        entry,
+        state: 'connecting',
+        protocol: entry.protocol,
+        mode: entry.mode,
+        target,
+        sent,
+        received,
+        errors,
+        send(message) {
+            const payload = encodeTcpRawPayload(message);
+            socket.write(frameRawTcpMessage(payload, framing));
+            sent.push({ at: new Date().toISOString(), payload: parseMaybeJson(payload.toString('utf8')) });
+        },
+        async close() {
+            socket.end();
+            session.state = 'closed';
+        },
+    };
+    attachRawTcpMessageStream(socket, framing, {
+        onMessage(message) {
+            received.push({
+                at: new Date().toISOString(),
+                payload: parseMaybeJson(message.toString('utf8')),
+            });
+            if (session.state === 'connecting') {
+                session.state = 'open';
+            }
+        },
+        onError(error) {
+            session.state = 'error';
+            errors.push(error.message);
+        },
+        onClose() {
+            if (session.state !== 'error') {
+                session.state = 'closed';
+            }
+        },
+    });
+    session.state = 'open';
+    return session;
+}
+export async function createWebSocketSession(entry, payload) {
+    const sent = [];
+    const received = [];
+    const errors = [];
+    const headers = {
+        ...toStringRecord(payload.headers),
+        ...toStringRecord(payload.metadata),
+    };
+    const candidates = buildWebSocketCandidates(entry, payload);
+    let socket = null;
+    let target = candidates[0];
+    const session = {
+        id: randomUUID(),
+        entry,
+        state: 'connecting',
+        protocol: entry.protocol,
+        mode: entry.mode,
+        target,
+        sent,
+        received,
+        errors,
+        send(message) {
+            const normalized = typeof message === 'string' ? message : JSON.stringify(message);
+            socket?.send(normalized);
+            sent.push({ at: new Date().toISOString(), payload: parseMaybeJson(normalized) });
+        },
+        async close() {
+            socket?.close();
+        },
+    };
+    async function connect(candidate) {
+        return await new Promise((resolve, reject) => {
+            const current = new WebSocket(candidate, { headers });
+            const timeout = setTimeout(() => {
+                current.close();
+                reject(new Error(`Timed out opening WebSocket session to ${candidate}`));
+            }, 2000);
+            current.once('open', () => {
+                clearTimeout(timeout);
+                resolve(current);
+            });
+            current.once('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    let lastError = null;
+    for (const candidate of candidates) {
+        try {
+            socket = await connect(candidate);
+            target = candidate;
+            session.target = candidate;
+            break;
+        }
+        catch (error) {
+            lastError = error;
+            errors.push(lastError.message);
+        }
+    }
+    if (!socket) {
+        session.state = 'error';
+        throw lastError ?? new Error('Failed to open WebSocket session');
+    }
+    socket.on('message', (message) => {
+        const raw = typeof message === 'string' ? message : message.toString('utf8');
+        received.push({ at: new Date().toISOString(), payload: parseMaybeJson(raw) });
+    });
+    socket.on('close', () => {
+        session.state = 'closed';
+    });
+    socket.on('error', (error) => {
+        session.state = 'error';
+        errors.push(error.message);
+    });
+    session.state = 'open';
+    return session;
+}
+function parseSseBlock(block) {
+    const event = {};
+    for (const line of block.split('\n')) {
+        const separator = line.indexOf(':');
+        if (separator === -1)
+            continue;
+        const key = line.slice(0, separator).trim();
+        const value = line.slice(separator + 1).trim();
+        if (key === 'event') {
+            event.event = value;
+        }
+        else if (key === 'data') {
+            event.data = value;
+        }
+    }
+    if (event.data) {
+        return {
+            ...event,
+            parsed: parseMaybeJson(event.data),
+        };
+    }
+    return event;
+}
+export async function createHttpStreamSession(entry, payload) {
+    const target = buildHttpUrl(entry, payload);
+    const controller = new AbortController();
+    const sent = [];
+    const received = [];
+    const errors = [];
+    const session = {
+        id: randomUUID(),
+        entry,
+        state: 'connecting',
+        protocol: entry.protocol,
+        mode: entry.mode,
+        target,
+        sent,
+        received,
+        errors,
+        async close() {
+            controller.abort('playground-session-closed');
+            session.state = 'closed';
+        },
+    };
+    void (async () => {
+        try {
+            const response = await fetch(target, {
+                method: 'GET',
+                headers: {
+                    accept: 'text/event-stream',
+                    ...toStringRecord(payload.headers),
+                    ...toStringRecord(payload.metadata),
+                },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                session.state = 'error';
+                errors.push(`HTTP ${response.status}`);
+                received.push({
+                    at: new Date().toISOString(),
+                    payload: await parseFetchResponse(response),
+                });
+                return;
+            }
+            session.state = 'open';
+            const reader = response.body?.getReader();
+            if (!reader) {
+                session.state = 'closed';
+                return;
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const blocks = buffer.split('\n\n');
+                buffer = blocks.pop() ?? '';
+                for (const block of blocks) {
+                    if (!block.trim())
+                        continue;
+                    received.push({
+                        at: new Date().toISOString(),
+                        payload: parseSseBlock(block),
+                    });
+                }
+            }
+            session.state = 'closed';
+        }
+        catch (error) {
+            if (!controller.signal.aborted) {
+                session.state = 'error';
+                errors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+    })();
+    return session;
+}
+//# sourceMappingURL=playground-invokers.js.map