langflower 0.1.0 → 0.1.2

package/vendor/tools/package.json

@@ -1,74 +0,0 @@
-{
-	"name": "@langflower/tools",
-	"version": "0.1.0",
-	"type": "module",
-	"exports": {
-		"./create-project-harness": {
-			"types": "./dist/create-project-harness.d.ts",
-			"import": "./dist/create-project-harness.js"
-		},
-		"./permission": {
-			"types": "./dist/permission.d.ts",
-			"import": "./dist/permission.js"
-		},
-		"./create-web-fetch": {
-			"types": "./dist/create-web-fetch.d.ts",
-			"import": "./dist/create-web-fetch.js"
-		},
-		"./create-crawl-context": {
-			"types": "./dist/create-crawl-context.d.ts",
-			"import": "./dist/create-crawl-context.js"
-		},
-		"./create-project-files-context": {
-			"types": "./dist/create-project-files-context.d.ts",
-			"import": "./dist/create-project-files-context.js"
-		},
-		"./domain-tool-configs": {
-			"types": "./dist/domain/domain-tool-configs.d.ts",
-			"import": "./dist/domain/domain-tool-configs.js"
-		},
-		"./create-memory-store": {
-			"types": "./dist/memory/create-memory-store.d.ts",
-			"import": "./dist/memory/create-memory-store.js"
-		},
-		"./html": {
-			"types": "./dist/domain/html.d.ts",
-			"import": "./dist/domain/html.js"
-		},
-		"./run-bfs-crawl": {
-			"types": "./dist/domain/run-bfs-crawl.d.ts",
-			"import": "./dist/domain/run-bfs-crawl.js"
-		},
-		"./mcp-stdio-client": {
-			"types": "./dist/mcp/mcp-stdio-client.d.ts",
-			"import": "./dist/mcp/mcp-stdio-client.js"
-		},
-		"./mcp-http-client": {
-			"types": "./dist/mcp/mcp-http-client.d.ts",
-			"import": "./dist/mcp/mcp-http-client.js"
-		},
-		"./mcp-tool-id": {
-			"types": "./dist/mcp/mcp-tool-id.d.ts",
-			"import": "./dist/mcp/mcp-tool-id.js"
-		},
-		"./build-mcp-handle": {
-			"types": "./dist/mcp/build-mcp-handle.d.ts",
-			"import": "./dist/mcp/build-mcp-handle.js"
-		},
-		"./format-mcp-connect-error": {
-			"types": "./dist/mcp/format-mcp-connect-error.d.ts",
-			"import": "./dist/mcp/format-mcp-connect-error.js"
-		},
-		"./create-system-mcp-handles": {
-			"types": "./dist/mcp/create-system-mcp-handles.d.ts",
-			"import": "./dist/mcp/create-system-mcp-handles.js"
-		}
-	},
-	"dependencies": {
-		"@langflower/node-sdk": "file:../node-sdk",
-		"undici": "^7.28.0"
-	},
-	"files": [
-		"dist"
-	]
-}

package/vendor/websocket-bridge/dist/bridge-codec.d.ts

@@ -1,3 +0,0 @@
-import type { WsBridgeCodec } from './bridge-types.js';
-export declare const encodeBridgeFrame: (transportDir: "in" | "out", busType: string, payload: unknown, ts?: string) => string;
-export declare const defaultWsBridgeCodec: WsBridgeCodec;

package/vendor/websocket-bridge/dist/bridge-codec.js

@@ -1,26 +0,0 @@
-const isBridgeFrame = (value) => Array.isArray(value) &&
-    value.length === 4 &&
-    typeof value[0] === 'string' &&
-    (value[1] === 'in' || value[1] === 'out') &&
-    typeof value[2] === 'string';
-export const encodeBridgeFrame = (transportDir, busType, payload, ts = new Date().toISOString()) => JSON.stringify([ts, transportDir, busType, payload]);
-export const defaultWsBridgeCodec = {
-    encode(event, transportDir) {
-        return encodeBridgeFrame(transportDir, event.type, event.payload);
-    },
-    decode(raw) {
-        try {
-            const parsed = JSON.parse(raw);
-            if (!isBridgeFrame(parsed)) {
-                return null;
-            }
-            return {
-                type: parsed[2],
-                payload: parsed[3],
-            };
-        }
-        catch {
-            return null;
-        }
-    },
-};

package/vendor/websocket-bridge/dist/bridge-frame.d.ts

@@ -1,11 +0,0 @@
-import type { WsBridgeCodec, WsBridgeError } from './bridge-types.js';
-import type { WsBridgeMessageSection } from './bridge-subjects.js';
-import type { WsBridgeConfig } from './bridge-types.js';
-export declare function decodeInboundFrame(config: WsBridgeConfig, codec: WsBridgeCodec, raw: string, section: WsBridgeMessageSection): {
-    event: {
-        type: string;
-        payload: unknown;
-    };
-} | {
-    error: WsBridgeError;
-};

package/vendor/websocket-bridge/dist/bridge-frame.js

@@ -1,24 +0,0 @@
-import { isWsBridgeEvent, parseWsBridgeEvent } from './bridge-guards.js';
-function createWsBridgeError(code, message, cause) {
-    return cause === undefined ? { code, message } : { code, message, cause };
-}
-export function decodeInboundFrame(config, codec, raw, section) {
-    const decoded = codec.decode(raw);
-    if (decoded === null) {
-        return {
-            error: createWsBridgeError('INVALID_FRAME', 'Frame is not valid bridge JSON envelope'),
-        };
-    }
-    const event = parseWsBridgeEvent(config, decoded, section);
-    if (event !== null) {
-        return { event };
-    }
-    if (isWsBridgeEvent(decoded)) {
-        return {
-            error: createWsBridgeError('UNKNOWN_EVENT_TYPE', `Unknown or disallowed event type: ${decoded.type}`),
-        };
-    }
-    return {
-        error: createWsBridgeError('INVALID_ENVELOPE', 'Frame must be a bridge tuple [ts, transportDir, busType, payload]'),
-    };
-}

package/vendor/websocket-bridge/dist/bridge-guards.d.ts

@@ -1,4 +0,0 @@
-import type { WsBridgeConfig, WsBridgeEvent } from './bridge-types.js';
-import type { WsBridgeMessageSection } from './bridge-subjects.js';
-export declare const isWsBridgeEvent: (value: unknown) => value is WsBridgeEvent;
-export declare const parseWsBridgeEvent: (config: WsBridgeConfig, value: unknown, section: WsBridgeMessageSection) => WsBridgeEvent | null;

package/vendor/websocket-bridge/dist/bridge-guards.js

@@ -1,17 +0,0 @@
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-export const isWsBridgeEvent = (value) => {
-    if (!isRecord(value)) {
-        return false;
-    }
-    return typeof value['type'] === 'string' && 'payload' in value;
-};
-const isKnownWsBridgeEventType = (config, type, section) => type in config[section];
-export const parseWsBridgeEvent = (config, value, section) => {
-    if (!isWsBridgeEvent(value)) {
-        return null;
-    }
-    if (!isKnownWsBridgeEventType(config, value.type, section)) {
-        return null;
-    }
-    return value;
-};

package/vendor/websocket-bridge/dist/bridge-subjects.d.ts

@@ -1,10 +0,0 @@
-import type { Subscription } from 'rxjs';
-import { Subject, type Observable } from 'rxjs';
-import type { WsBridgeConfig, WsBridgeEvent } from './bridge-types.js';
-export type WsBridgeMessageSection = keyof Pick<WsBridgeConfig, 'fromClientToServer' | 'fromServerToClient'>;
-export declare function readMessageKeys(config: WsBridgeConfig, section: WsBridgeMessageSection): readonly string[];
-export declare function createSubjectMap(keys: readonly string[]): Record<string, Subject<unknown>>;
-export declare function toObservables(subjects: Record<string, Subject<unknown>>): Record<string, Observable<unknown>>;
-export declare function wireOutgoingSubjects(subjects: Record<string, Subject<unknown>>, send: (event: WsBridgeEvent, transportDir: 'in' | 'out') => void, transportDir: 'in' | 'out'): Subscription[];
-export declare function routeInboundEvent(event: WsBridgeEvent, subjects: Record<string, Subject<unknown>>, clientId?: string): boolean;
-export declare function completeSubjects(subjects: Record<string, Subject<unknown>>): void;

package/vendor/websocket-bridge/dist/bridge-subjects.js

@@ -1,38 +0,0 @@
-import { Subject } from 'rxjs';
-export function readMessageKeys(config, section) {
-    return Object.keys(config[section]);
-}
-export function createSubjectMap(keys) {
-    const subjects = {};
-    for (const key of keys) {
-        subjects[key] = new Subject();
-    }
-    return subjects;
-}
-export function toObservables(subjects) {
-    const observables = {};
-    for (const [key, subject] of Object.entries(subjects)) {
-        observables[key] = subject.asObservable();
-    }
-    return observables;
-}
-export function wireOutgoingSubjects(subjects, send, transportDir) {
-    return Object.entries(subjects).map(([type, subject]) => subject.subscribe((payload) => {
-        send({ type, payload }, transportDir);
-    }));
-}
-export function routeInboundEvent(event, subjects, clientId) {
-    const subject = subjects[event.type];
-    if (subject === undefined) {
-        return false;
-    }
-    subject.next(clientId === undefined
-        ? event.payload
-        : { clientId, payload: event.payload });
-    return true;
-}
-export function completeSubjects(subjects) {
-    for (const subject of Object.values(subjects)) {
-        subject.complete();
-    }
-}

package/vendor/websocket-bridge/dist/bridge-types.d.ts

@@ -1,102 +0,0 @@
-import type { Observable, Subject } from 'rxjs';
-/** Message registry entry — payload type is carried by `message<T>()`. */
-export type WsBridgeMessageDefinition<Payload> = {
-    readonly payload?: Payload;
-};
-export type WsBridgeMessageConfig = Record<string, WsBridgeMessageDefinition<unknown>>;
-export type WsBridgeTransportConfig = {
-    readonly path?: string;
-    readonly port?: number;
-};
-export type WsBridgeEvent<Payload = unknown> = {
-    readonly type: string;
-    readonly payload: Payload;
-};
-/** Wire + log line: `[ts, transportDir, busType, payload]`. */
-export type BridgeFrame = readonly [
-    ts: string,
-    transportDir: 'in' | 'out',
-    busType: string,
-    payload: unknown
-];
-export type WsBridgeCodec = {
-    encode(event: WsBridgeEvent, transportDir: 'in' | 'out'): string;
-    decode(raw: string): WsBridgeEvent | null;
-};
-export type WsBridgeConfig<ClientToServer extends WsBridgeMessageConfig = WsBridgeMessageConfig, ServerToClient extends WsBridgeMessageConfig = WsBridgeMessageConfig> = {
-    readonly fromClientToServer: ClientToServer;
-    readonly fromServerToClient: ServerToClient;
-    readonly transport?: WsBridgeTransportConfig;
-    readonly codec?: WsBridgeCodec;
-};
-export type WsBridgeStatus = 'connecting' | 'connected' | 'disconnected';
-export type WsBridgeError = {
-    readonly code: string;
-    readonly message: string;
-    readonly cause?: unknown;
-};
-export type WsBridgeEventType<T extends WsBridgeMessageConfig> = Extract<keyof T, string>;
-export type WsBridgeAnyEventType<C extends WsBridgeConfig> = WsBridgeEventType<C['fromClientToServer']> | WsBridgeEventType<C['fromServerToClient']>;
-export type WsBridgePayload<T extends WsBridgeMessageConfig, K extends WsBridgeEventType<T>> = T[K] extends WsBridgeMessageDefinition<infer Payload> ? Payload : never;
-export type WsBridgeClientOutboundKey<C extends WsBridgeConfig> = WsBridgeEventType<C['fromClientToServer']>;
-export type WsBridgeClientInboundKey<C extends WsBridgeConfig> = WsBridgeEventType<C['fromServerToClient']>;
-export type WsBridgeServerOutboundKey<C extends WsBridgeConfig> = WsBridgeEventType<C['fromServerToClient']>;
-export type WsBridgeServerInboundKey<C extends WsBridgeConfig> = WsBridgeEventType<C['fromClientToServer']>;
-export type WsBridgeClientOutboundPayload<C extends WsBridgeConfig, K extends WsBridgeClientOutboundKey<C>> = WsBridgePayload<C['fromClientToServer'], K>;
-export type WsBridgeClientInboundPayload<C extends WsBridgeConfig, K extends WsBridgeClientInboundKey<C>> = WsBridgePayload<C['fromServerToClient'], K>;
-export type WsBridgeServerOutboundPayload<C extends WsBridgeConfig, K extends WsBridgeServerOutboundKey<C>> = WsBridgePayload<C['fromServerToClient'], K>;
-export type WsBridgeServerInboundPayload<C extends WsBridgeConfig, K extends WsBridgeServerInboundKey<C>> = WsBridgePayload<C['fromClientToServer'], K>;
-export type WsBridgeOutboundSubjects<T extends WsBridgeMessageConfig> = {
-    readonly [K in WsBridgeEventType<T>]: Subject<WsBridgePayload<T, K>>;
-};
-export type WsBridgeInboundObservables<T extends WsBridgeMessageConfig> = {
-    readonly [K in WsBridgeEventType<T>]: Observable<WsBridgePayload<T, K>>;
-};
-export type WsBridgeAnyPayload<C extends WsBridgeConfig, K extends WsBridgeAnyEventType<C>> = K extends WsBridgeEventType<C['fromClientToServer']> ? WsBridgePayload<C['fromClientToServer'], K> : K extends WsBridgeEventType<C['fromServerToClient']> ? WsBridgePayload<C['fromServerToClient'], K> : never;
-export type WsBridgeOutgoingChannel<Payload> = Subject<Payload>;
-export type WsBridgeIncomingChannel<Payload> = Observable<Payload>;
-/** Server-side inbound frame — includes originating client id for targeted replies. */
-export type WsBridgeServerInboundEvent<Payload> = {
-    readonly clientId: string;
-    readonly payload: Payload;
-};
-export type WsBridgeServerIncomingChannel<Payload> = Observable<WsBridgeServerInboundEvent<Payload>>;
-export type WsBridgeClientOutgoing<C extends WsBridgeConfig> = {
-    readonly [K in WsBridgeClientOutboundKey<C>]: WsBridgeOutgoingChannel<WsBridgeClientOutboundPayload<C, K>>;
-};
-export type WsBridgeClientIncoming<C extends WsBridgeConfig> = {
-    readonly [K in WsBridgeClientInboundKey<C>]: WsBridgeIncomingChannel<WsBridgeClientInboundPayload<C, K>>;
-};
-export type WsBridgeServerOutgoing<C extends WsBridgeConfig> = {
-    readonly [K in WsBridgeServerOutboundKey<C>]: WsBridgeOutgoingChannel<WsBridgeServerOutboundPayload<C, K>>;
-};
-export type WsBridgeServerIncoming<C extends WsBridgeConfig> = {
-    readonly [K in WsBridgeServerInboundKey<C>]: WsBridgeServerIncomingChannel<WsBridgeServerInboundPayload<C, K>>;
-};
-export type WsBridgeConnectedClient<C extends WsBridgeConfig> = {
-    readonly id: string;
-    readonly connected$: Observable<boolean>;
-    readonly disconnected$: Observable<void>;
-    close(): void;
-};
-export type WsBridgeConnectedClientApi<C extends WsBridgeConfig> = WsBridgeConnectedClient<C> & WsBridgeServerOutgoing<C>;
-export type WsBridgeClient<C extends WsBridgeConfig> = {
-    readonly errors$: Observable<WsBridgeError>;
-    readonly status$: Observable<WsBridgeStatus>;
-    close(): void;
-};
-export type WsBridgeClientApi<C extends WsBridgeConfig> = WsBridgeClient<C> & WsBridgeClientOutgoing<C> & WsBridgeClientIncoming<C>;
-export type WsBridgeServer<C extends WsBridgeConfig> = {
-    readonly connections$: Observable<WsBridgeConnectedClientApi<C>>;
-    readonly errors$: Observable<WsBridgeError>;
-    readonly status$: Observable<WsBridgeStatus>;
-    close(): void;
-    /**
-     * Push a client-to-server event as if a socket sent it (in-process
-     * hosts). Inbound channels stay Observables — not Subjects.
-     */
-    injectInbound<K extends WsBridgeServerInboundKey<C>>(type: K, payload: WsBridgeServerInboundPayload<C, K>, clientId?: string): void;
-};
-export type WsBridgeServerApi<C extends WsBridgeConfig> = WsBridgeServer<C> & WsBridgeServerIncoming<C> & WsBridgeServerOutgoing<C>;
-/** Type carrier for config entries — no casts in consumer config. */
-export declare const message: <Payload>() => WsBridgeMessageDefinition<Payload>;

package/vendor/websocket-bridge/dist/bridge-types.js

@@ -1,2 +0,0 @@
-/** Type carrier for config entries — no casts in consumer config. */
-export const message = () => ({});

package/vendor/websocket-bridge/dist/create-client.d.ts

@@ -1,5 +0,0 @@
-import type { WsBridgeClientApi, WsBridgeConfig } from './bridge-types.js';
-export type CreateClientOptions = {
-    readonly url?: string;
-};
-export declare function createClient<C extends WsBridgeConfig>(config: C, options?: CreateClientOptions): WsBridgeClientApi<C>;

package/vendor/websocket-bridge/dist/create-client.js

@@ -1,152 +0,0 @@
-import { BehaviorSubject, Subject } from 'rxjs';
-import NodeWebSocket from 'ws';
-import { defaultWsBridgeCodec } from './bridge-codec.js';
-import { decodeInboundFrame } from './bridge-frame.js';
-import { completeSubjects, createSubjectMap, readMessageKeys, routeInboundEvent, toObservables, wireOutgoingSubjects, } from './bridge-subjects.js';
-const OPEN = 1;
-function connectSocket(url) {
-    if (typeof globalThis.WebSocket !== 'undefined') {
-        const ws = new globalThis.WebSocket(url);
-        return {
-            get readyState() {
-                return ws.readyState;
-            },
-            send: (data) => {
-                ws.send(data);
-            },
-            close: () => {
-                ws.close();
-            },
-            onOpen: (callback) => {
-                ws.onopen = () => {
-                    callback();
-                };
-            },
-            onMessage: (callback) => {
-                ws.onmessage = (event) => {
-                    callback(String(event.data));
-                };
-            },
-            onClose: (callback) => {
-                ws.onclose = () => {
-                    callback();
-                };
-            },
-            onError: (callback) => {
-                ws.onerror = (event) => {
-                    callback(event);
-                };
-            },
-        };
-    }
-    const ws = new NodeWebSocket(url);
-    return {
-        get readyState() {
-            return ws.readyState;
-        },
-        send: (data) => {
-            ws.send(data);
-        },
-        close: () => {
-            ws.close();
-        },
-        onOpen: (callback) => {
-            ws.on('open', callback);
-        },
-        onMessage: (callback) => {
-            ws.on('message', (data) => {
-                callback(String(data));
-            });
-        },
-        onClose: (callback) => {
-            ws.on('close', callback);
-        },
-        onError: (callback) => {
-            ws.on('error', callback);
-        },
-    };
-}
-function resolveClientUrl(config, options) {
-    if (options.url !== undefined) {
-        return options.url;
-    }
-    const path = config.transport?.path ?? '/ws';
-    if (typeof globalThis.window !== 'undefined') {
-        const protocol = globalThis.window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-        return `${protocol}//${globalThis.window.location.host}${path}`;
-    }
-    const port = config.transport?.port ?? 4010;
-    return `ws://127.0.0.1:${port}${path}`;
-}
-export function createClient(config, options = {}) {
-    const codec = config.codec ?? defaultWsBridgeCodec;
-    const url = resolveClientUrl(config, options);
-    const clientToServerKeys = readMessageKeys(config, 'fromClientToServer');
-    const serverToClientKeys = readMessageKeys(config, 'fromServerToClient');
-    const outgoingSubjects = createSubjectMap(clientToServerKeys);
-    const inboundSubjects = createSubjectMap(serverToClientKeys);
-    const inboundObservables = toObservables(inboundSubjects);
-    const errorsSubject = new Subject();
-    const statusSubject = new BehaviorSubject('connecting');
-    const socket = connectSocket(url);
-    const sendEvent = (event, transportDir) => {
-        if (socket.readyState !== OPEN) {
-            errorsSubject.next({
-                code: 'TRANSPORT_NOT_OPEN',
-                message: 'Cannot send while WebSocket is not open',
-            });
-            return;
-        }
-        socket.send(codec.encode(event, transportDir));
-    };
-    // Wire at construction so early `.next` is not silently dropped; sendEvent
-    // still rejects until the socket is OPEN.
-    const wireSubscriptions = wireOutgoingSubjects(outgoingSubjects, sendEvent, 'in');
-    socket.onOpen(() => {
-        statusSubject.next('connected');
-    });
-    socket.onMessage((raw) => {
-        const frame = decodeInboundFrame(config, codec, raw, 'fromServerToClient');
-        if ('error' in frame) {
-            errorsSubject.next(frame.error);
-            return;
-        }
-        routeInboundEvent(frame.event, inboundSubjects);
-    });
-    let tornDown = false;
-    const tearDown = (closeSocket) => {
-        if (tornDown) {
-            return;
-        }
-        tornDown = true;
-        statusSubject.next('disconnected');
-        for (const subscription of wireSubscriptions) {
-            subscription.unsubscribe();
-        }
-        completeSubjects(outgoingSubjects);
-        completeSubjects(inboundSubjects);
-        errorsSubject.complete();
-        statusSubject.complete();
-        if (closeSocket) {
-            socket.close();
-        }
-    };
-    socket.onClose(() => {
-        tearDown(false);
-    });
-    socket.onError((cause) => {
-        errorsSubject.next({
-            code: 'TRANSPORT_ERROR',
-            message: 'WebSocket client error',
-            cause,
-        });
-    });
-    const core = {
-        errors$: errorsSubject.asObservable(),
-        status$: statusSubject.asObservable(),
-        close() {
-            tearDown(true);
-        },
-    };
-    return Object.assign(core, outgoingSubjects, inboundObservables);
-}

package/vendor/websocket-bridge/dist/create-server.d.ts

@@ -1,8 +0,0 @@
-import type { WsBridgeConfig, WsBridgeServerApi } from './bridge-types.js';
-export type CreateServerOptions = {
-    readonly host?: string;
-    readonly port?: number;
-    readonly path?: string;
-    readonly httpServer?: import('node:http').Server;
-};
-export declare function createServer<C extends WsBridgeConfig>(config: C, options?: CreateServerOptions): WsBridgeServerApi<C>;

package/vendor/websocket-bridge/dist/create-server.js

@@ -1,134 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { BehaviorSubject, Subject } from 'rxjs';
-import { WebSocketServer } from 'ws';
-import { defaultWsBridgeCodec } from './bridge-codec.js';
-import { decodeInboundFrame } from './bridge-frame.js';
-import { completeSubjects, createSubjectMap, readMessageKeys, routeInboundEvent, toObservables, wireOutgoingSubjects, } from './bridge-subjects.js';
-export function createServer(config, options = {}) {
-    const codec = config.codec ?? defaultWsBridgeCodec;
-    const path = options.path ?? config.transport?.path ?? '/ws';
-    const host = options.host ?? '127.0.0.1';
-    const port = options.port ?? config.transport?.port ?? 0;
-    const clientToServerKeys = readMessageKeys(config, 'fromClientToServer');
-    const serverToClientKeys = readMessageKeys(config, 'fromServerToClient');
-    const inboundSubjects = createSubjectMap(clientToServerKeys);
-    const broadcastSubjects = createSubjectMap(serverToClientKeys);
-    const inboundObservables = toObservables(inboundSubjects);
-    const connectionsSubject = new Subject();
-    const errorsSubject = new Subject();
-    const statusSubject = new BehaviorSubject('connecting');
-    const clients = new Set();
-    const wireSubscriptions = wireOutgoingSubjects(broadcastSubjects, (event, transportDir) => {
-        const raw = codec.encode(event, transportDir);
-        for (const client of clients) {
-            if (client.ws.readyState === client.ws.OPEN) {
-                client.ws.send(raw);
-            }
-        }
-    }, 'out');
-    const wss = options.httpServer !== undefined
-        ? new WebSocketServer({ server: options.httpServer, path })
-        : new WebSocketServer({ host, port, path });
-    if (options.httpServer !== undefined) {
-        if (options.httpServer.listening) {
-            statusSubject.next('connected');
-        }
-        else {
-            options.httpServer.once('listening', () => {
-                statusSubject.next('connected');
-            });
-        }
-    }
-    wss.on('listening', () => {
-        if (options.httpServer === undefined) {
-            statusSubject.next('connected');
-        }
-    });
-    wss.on('error', (cause) => {
-        errorsSubject.next({
-            code: 'TRANSPORT_ERROR',
-            message: 'WebSocket server error',
-            cause,
-        });
-        statusSubject.next('disconnected');
-    });
-    wss.on('connection', (ws) => {
-        const id = randomUUID();
-        const outgoingSubjects = createSubjectMap(serverToClientKeys);
-        const disconnectedSubject = new Subject();
-        const connectedSubject = new BehaviorSubject(true);
-        const subscriptions = wireOutgoingSubjects(outgoingSubjects, (event, transportDir) => {
-            if (ws.readyState !== ws.OPEN) {
-                return;
-            }
-            ws.send(codec.encode(event, transportDir));
-        }, 'out');
-        const closeClient = () => {
-            if (ws.readyState === ws.OPEN || ws.readyState === ws.CONNECTING) {
-                ws.close();
-            }
-        };
-        const api = Object.assign({
-            id,
-            connected$: connectedSubject.asObservable(),
-            disconnected$: disconnectedSubject.asObservable(),
-            close: closeClient,
-        }, outgoingSubjects);
-        const record = {
-            id,
-            ws,
-            api,
-            outgoingSubjects,
-            subscriptions,
-            disconnectedSubject,
-        };
-        clients.add(record);
-        connectionsSubject.next(api);
-        ws.on('message', (raw) => {
-            const frame = decodeInboundFrame(config, codec, String(raw), 'fromClientToServer');
-            if ('error' in frame) {
-                errorsSubject.next(frame.error);
-                return;
-            }
-            routeInboundEvent(frame.event, inboundSubjects, id);
-        });
-        ws.on('close', () => {
-            connectedSubject.next(false);
-            connectedSubject.complete();
-            disconnectedSubject.next();
-            disconnectedSubject.complete();
-            clients.delete(record);
-            for (const subscription of subscriptions) {
-                subscription.unsubscribe();
-            }
-            completeSubjects(outgoingSubjects);
-        });
-    });
-    const core = {
-        connections$: connectionsSubject.asObservable(),
-        errors$: errorsSubject.asObservable(),
-        status$: statusSubject.asObservable(),
-        injectInbound(type, payload, clientId = 'in-process') {
-            const routed = routeInboundEvent({ type, payload }, inboundSubjects, clientId);
-            if (!routed) {
-                throw new Error(`Unknown inbound event: ${String(type)}`);
-            }
-        },
-        close() {
-            statusSubject.next('disconnected');
-            for (const client of [...clients]) {
-                client.ws.close();
-            }
-            for (const subscription of wireSubscriptions) {
-                subscription.unsubscribe();
-            }
-            completeSubjects(broadcastSubjects);
-            completeSubjects(inboundSubjects);
-            connectionsSubject.complete();
-            errorsSubject.complete();
-            statusSubject.complete();
-            wss.close();
-        },
-    };
-    return Object.assign(core, inboundObservables, broadcastSubjects);
-}

package/vendor/websocket-bridge/dist/testing/expect-type.d.ts

@@ -1,3 +0,0 @@
-/** Compile-time equality — resolves to `true` or `never`. */
-export type ExpectEqual<A, B> = (<T>() => T extends A ? 1 : 2) extends <U>() => U extends B ? 1 : 2 ? true : never;
-export declare function assertTypeEqual<_T extends true>(): void;

package/vendor/websocket-bridge/dist/testing/expect-type.js

@@ -1,3 +0,0 @@
-export function assertTypeEqual() {
-    // compile-time assertion helper
-}

package/vendor/websocket-bridge/dist/testing/sample-diagram-ws-config.d.ts

@@ -1,27 +0,0 @@
-export type EdgeConnectionPayload = {
-    readonly fromNodeId: string;
-    readonly fromPortId: string;
-    readonly toNodeId: string;
-    readonly toPortId: string;
-};
-export type EdgeCreateCommandPayload = {
-    readonly edgeId: string;
-};
-export type SessionReadyPayload = {
-    readonly version: number;
-};
-/** Sample config from plan — edge create request + command. */
-export declare const diagramWsConfig: {
-    readonly transport: {
-        readonly path: "/ws";
-        readonly port: 4010;
-    };
-    readonly fromClientToServer: {
-        readonly 'edge.create.requested': import("../bridge-types.js").WsBridgeMessageDefinition<EdgeConnectionPayload>;
-    };
-    readonly fromServerToClient: {
-        readonly 'edge.create.command': import("../bridge-types.js").WsBridgeMessageDefinition<EdgeCreateCommandPayload>;
-        readonly 'session.ready': import("../bridge-types.js").WsBridgeMessageDefinition<SessionReadyPayload>;
-    };
-};
-export type DiagramWsConfig = typeof diagramWsConfig;