@replit/river 0.9.3 → 0.10.1

package/dist/router/context.d.ts

@@ -1,30 +0,0 @@
-/**
- * The context for services/procedures. This is used only on
- * the server.
- *
- * An important detail is that the state prop is always on
- * this interface and it shouldn't be changed, removed, or
- * extended. This prop is for the state of a service.
- *
- * You should use declaration merging to extend this interface
- * with whatever you need. For example, if you need to access
- * a database, you could do:
- *
- * ```ts
- * declare module '@replit/river' {
- *   interface ServiceContext {
- *     db: Database;
- *   }
- * }
- * ```
- */
-export interface ServiceContext {
-    state: object | unknown;
-}
-/**
- * The {@link ServiceContext} with state. This is what is passed to procedures.
- */
-export type ServiceContextWithState<State extends object | unknown> = ServiceContext & {
-    state: State;
-};
-//# sourceMappingURL=context.d.ts.map

package/dist/router/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../router/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,CAAC,KAAK,SAAS,MAAM,GAAG,OAAO,IAChE,cAAc,GAAG;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC"}

package/dist/router/context.js

@@ -1 +0,0 @@
-export {};

package/dist/router/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../router/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC7D,YAAY,EACV,aAAa,EACb,WAAW,EACX,OAAO,EACP,WAAW,EACX,SAAS,EACT,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,GACZ,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,YAAY,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,YAAY,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACzE,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACxE,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC"}

package/dist/router/result.d.ts

@@ -1,25 +0,0 @@
-import { TLiteralString, TNever, TObject, TSchema, TString, TUnion } from '@sinclair/typebox';
-export type RiverErrorSchema = TObject<{
-    code: TLiteralString;
-    message: TLiteralString | TString;
-}> | TObject<{
-    code: TLiteralString;
-    message: TLiteralString | TString;
-    extras: TSchema;
-}>;
-export type RiverError = TUnion<RiverErrorSchema[]> | RiverErrorSchema | TNever;
-export declare const UNCAUGHT_ERROR = "UNCAUGHT_ERROR";
-export declare const RiverUncaughtSchema: TObject<{
-    code: import("@sinclair/typebox").TLiteral<"UNCAUGHT_ERROR">;
-    message: TString;
-}>;
-export type Result<T, E> = {
-    ok: true;
-    payload: T;
-} | {
-    ok: false;
-    payload: E;
-};
-export declare function Ok<T, E>(payload: T): Result<T, E>;
-export declare function Err<T, E>(error: E): Result<T, E>;
-//# sourceMappingURL=result.d.ts.map

package/dist/router/result.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../router/result.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,MAAM,EACN,OAAO,EACP,OAAO,EACP,OAAO,EACP,MAAM,EAEP,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,gBAAgB,GACxB,OAAO,CAAC;IACN,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC;CACnC,CAAC,GACF,OAAO,CAAC;IACN,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC;IAClC,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC,CAAC;AACP,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,gBAAgB,EAAE,CAAC,GAAG,gBAAgB,GAAG,MAAM,CAAC;AAEhF,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAC/C,eAAO,MAAM,mBAAmB;;;EAG9B,CAAC;AAEH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IACnB;IACE,EAAE,EAAE,IAAI,CAAC;IACT,OAAO,EAAE,CAAC,CAAC;CACZ,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,CAAC,CAAC;CACZ,CAAC;AAEN,wBAAgB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAKjD;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAKhD"}

package/dist/router/result.js

@@ -1,18 +0,0 @@
-import { Type, } from '@sinclair/typebox';
-export const UNCAUGHT_ERROR = 'UNCAUGHT_ERROR';
-export const RiverUncaughtSchema = Type.Object({
-    code: Type.Literal(UNCAUGHT_ERROR),
-    message: Type.String(),
-});
-export function Ok(payload) {
-    return {
-        ok: true,
-        payload,
-    };
-}
-export function Err(error) {
-    return {
-        ok: false,
-        payload: error,
-    };
-}

package/dist/router/server.d.ts

@@ -1,39 +0,0 @@
-import { Static } from '@sinclair/typebox';
-import { Connection, Transport } from '../transport/transport';
-import { AnyProcedure, AnyService, PayloadType } from './builder';
-import type { Pushable } from 'it-pushable';
-import { TransportMessage } from '../transport/message';
-import { ServiceContext } from './context';
-import { Result, RiverError } from './result';
-/**
- * Represents a server with a set of services. Use {@link createServer} to create it.
- * @template Services - The type of services provided by the server.
- */
-export interface Server<Services> {
-    services: Services;
-    streams: Map<string, ProcStream>;
-    close(): Promise<void>;
-}
-interface ProcStream {
-    id: string;
-    serviceName: string;
-    procedureName: string;
-    procedure: AnyProcedure;
-    incoming: Pushable<TransportMessage>;
-    outgoing: Pushable<TransportMessage<Result<Static<PayloadType>, Static<RiverError>>>>;
-    promises: {
-        outputHandler: Promise<unknown>;
-        inputHandler: Promise<unknown>;
-    };
-}
-/**
- * Creates a server instance that listens for incoming messages from a transport and routes them to the appropriate service and procedure.
- * The server tracks the state of each service along with open streams and the extended context object.
- * @param transport - The transport to listen to.
- * @param services - An object containing all the services to be registered on the server.
- * @param extendedContext - An optional object containing additional context to be passed to all services.
- * @returns A promise that resolves to a server instance with the registered services.
- */
-export declare function createServer<Services extends Record<string, AnyService>>(transport: Transport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Promise<Server<Services>>;
-export {};
-//# sourceMappingURL=server.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../router/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAElE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAGL,gBAAgB,EAKjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,cAAc,EAA2B,MAAM,WAAW,CAAC;AAGpE,OAAO,EAEL,MAAM,EACN,UAAU,EAGX,MAAM,UAAU,CAAC;AAElB;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,QAAQ;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,UAAU,UAAU;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,YAAY,CAAC;IACxB,QAAQ,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IACrC,QAAQ,EAAE,QAAQ,CAChB,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAClE,CAAC;IACF,QAAQ,EAAE;QACR,aAAa,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAChC,YAAY,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;KAChC,CAAC;CACH;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EAC5E,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,EAChC,QAAQ,EAAE,QAAQ,EAClB,eAAe,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GAC9C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAqQ3B"}

package/dist/router/server.js

@@ -1,217 +0,0 @@
-import { pushable } from 'it-pushable';
-import { ControlMessagePayloadSchema, isStreamClose, isStreamOpen, reply, closeStream, } from '../transport/message';
-import { log } from '../logging';
-import { Value } from '@sinclair/typebox/value';
-import { Err, UNCAUGHT_ERROR, } from './result';
-/**
- * Creates a server instance that listens for incoming messages from a transport and routes them to the appropriate service and procedure.
- * The server tracks the state of each service along with open streams and the extended context object.
- * @param transport - The transport to listen to.
- * @param services - An object containing all the services to be registered on the server.
- * @param extendedContext - An optional object containing additional context to be passed to all services.
- * @returns A promise that resolves to a server instance with the registered services.
- */
-export async function createServer(transport, services, extendedContext) {
-    const contextMap = new Map();
-    // map of streamId to ProcStream
-    const streamMap = new Map();
-    async function cleanupStream(id) {
-        const stream = streamMap.get(id);
-        if (!stream) {
-            return;
-        }
-        stream.incoming.end();
-        await stream.promises.inputHandler;
-        stream.outgoing.end();
-        await stream.promises.outputHandler;
-        streamMap.delete(id);
-    }
-    function getContext(service) {
-        const context = contextMap.get(service);
-        if (!context) {
-            const err = `${transport.clientId} -- no context found for ${service.name}`;
-            log?.error(err);
-            throw new Error(err);
-        }
-        return context;
-    }
-    // populate the context map
-    for (const service of Object.values(services)) {
-        contextMap.set(service, { ...extendedContext, state: service.state });
-    }
-    const handler = async (message) => {
-        if (message.to !== transport.clientId) {
-            log?.info(`${transport.clientId} -- got msg with destination that isn't the server, ignoring`);
-            return;
-        }
-        const streamIdx = message.streamId;
-        const procStream = streamMap.get(streamIdx);
-        if (procStream) {
-            // If the stream is a continuation, we do not admit the init messages.
-            if (Value.Check(procStream.procedure.input, message.payload)) {
-                procStream.incoming.push(message);
-            }
-            else if (!Value.Check(ControlMessagePayloadSchema, message.payload)) {
-                log?.error(`${transport.clientId} -- procedure ${procStream.serviceName}.${procStream.procedureName} received invalid payload: ${JSON.stringify(message.payload)}`);
-            }
-            if (isStreamClose(message.controlFlags)) {
-                await cleanupStream(streamIdx);
-            }
-            return;
-        }
-        if (!isStreamOpen(message.controlFlags)) {
-            log?.warn(`${transport.clientId} -- couldn't find a matching procedure stream for ${message.serviceName}.${message.procedureName}:${message.streamId}`);
-            return;
-        }
-        if (!message.serviceName || !(message.serviceName in services)) {
-            log?.warn(`${transport.clientId} -- couldn't find service ${message.serviceName}`);
-            return;
-        }
-        const service = services[message.serviceName];
-        const serviceContext = getContext(service);
-        if (!message.procedureName ||
-            !(message.procedureName in service.procedures)) {
-            log?.warn(`${transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`);
-            return;
-        }
-        const procedure = service.procedures[message.procedureName];
-        const procHasInitMessage = 'init' in procedure;
-        const incoming = pushable({ objectMode: true });
-        const outgoing = pushable({ objectMode: true });
-        const outputHandler = 
-        // sending outgoing messages back to client
-        (async () => {
-            for await (const response of outgoing) {
-                transport.send(response);
-            }
-            // we ended, send a close bit back to the client
-            // only subscriptions and streams have streams the
-            // handler can close
-            if (procedure.type === 'subscription' || procedure.type === 'stream') {
-                transport.send(closeStream(transport.clientId, message.from, message.streamId));
-            }
-        })();
-        function errorHandler(err) {
-            const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
-            log?.error(`${transport.clientId} -- procedure ${message.serviceName}.${message.procedureName}:${message.streamId} threw an error: ${errorMsg}`);
-            outgoing.push(reply(message, Err({
-                code: UNCAUGHT_ERROR,
-                message: errorMsg,
-            })));
-        }
-        // pump incoming message stream -> handler -> outgoing message stream
-        let inputHandler;
-        if (procedure.type === 'stream') {
-            if (procHasInitMessage) {
-                inputHandler = (async () => {
-                    const initMessage = await incoming.next();
-                    if (initMessage.done) {
-                        return;
-                    }
-                    return procedure
-                        .handler(serviceContext, initMessage.value, incoming, outgoing)
-                        .catch(errorHandler);
-                })();
-            }
-            else {
-                inputHandler = procedure
-                    .handler(serviceContext, incoming, outgoing)
-                    .catch(errorHandler);
-            }
-        }
-        else if (procedure.type === 'rpc') {
-            inputHandler = (async () => {
-                const inputMessage = await incoming.next();
-                if (inputMessage.done) {
-                    return;
-                }
-                try {
-                    const outputMessage = await procedure.handler(serviceContext, inputMessage.value);
-                    outgoing.push(outputMessage);
-                }
-                catch (err) {
-                    errorHandler(err);
-                }
-            })();
-        }
-        else if (procedure.type === 'subscription') {
-            inputHandler = (async () => {
-                const inputMessage = await incoming.next();
-                if (inputMessage.done) {
-                    return;
-                }
-                try {
-                    await procedure.handler(serviceContext, inputMessage.value, outgoing);
-                }
-                catch (err) {
-                    errorHandler(err);
-                }
-            })();
-        }
-        else if (procedure.type === 'upload') {
-            if (procHasInitMessage) {
-                inputHandler = (async () => {
-                    const initMessage = await incoming.next();
-                    if (initMessage.done) {
-                        return;
-                    }
-                    try {
-                        const outputMessage = await procedure.handler(serviceContext, initMessage.value, incoming);
-                        outgoing.push(outputMessage);
-                    }
-                    catch (err) {
-                        errorHandler(err);
-                    }
-                })();
-            }
-            else {
-                inputHandler = (async () => {
-                    try {
-                        const outputMessage = await procedure.handler(serviceContext, incoming);
-                        outgoing.push(outputMessage);
-                    }
-                    catch (err) {
-                        errorHandler(err);
-                    }
-                })();
-            }
-        }
-        else {
-            // procedure is inferred to be never here as this is not a valid procedure type
-            // we cast just to log
-            log?.warn(`${transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`);
-            return;
-        }
-        streamMap.set(streamIdx, {
-            id: message.streamId,
-            incoming,
-            outgoing,
-            serviceName: message.serviceName,
-            procedureName: message.procedureName,
-            procedure,
-            promises: { inputHandler, outputHandler },
-        });
-        // This is the first message, so we parse is as the initialization message, if supplied.
-        if ((!procHasInitMessage && Value.Check(procedure.input, message.payload)) ||
-            (procHasInitMessage && Value.Check(procedure.init, message.payload))) {
-            incoming.push(message);
-        }
-        else if (!Value.Check(ControlMessagePayloadSchema, message.payload)) {
-            log?.error(`${transport.clientId} -- procedure ${message.serviceName}.${message.procedureName} received invalid payload: ${JSON.stringify(message.payload)}`);
-        }
-        if (isStreamClose(message.controlFlags)) {
-            await cleanupStream(streamIdx);
-        }
-    };
-    transport.addEventListener('message', handler);
-    return {
-        services,
-        streams: streamMap,
-        async close() {
-            transport.removeEventListener('message', handler);
-            for (const streamIdx of streamMap.keys()) {
-                await cleanupStream(streamIdx);
-            }
-        },
-    };
-}

package/dist/transport/events.d.ts

@@ -1,19 +0,0 @@
-import { OpaqueTransportMessage } from './message';
-import { Connection } from './transport';
-export interface EventMap {
-    message: OpaqueTransportMessage;
-    connectionStatus: {
-        status: 'connect' | 'disconnect';
-        conn: Connection;
-    };
-}
-export type EventTypes = keyof EventMap;
-export type EventHandler<K extends EventTypes> = (event: EventMap[K]) => void;
-export declare class EventDispatcher<T extends EventTypes> {
-    private eventListeners;
-    numberOfListeners<K extends T>(eventType: K): number;
-    addEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
-    removeEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
-    dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
-}
-//# sourceMappingURL=events.d.ts.map

package/dist/transport/events.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../transport/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,sBAAsB,CAAC;IAChC,gBAAgB,EAAE;QAChB,MAAM,EAAE,SAAS,GAAG,YAAY,CAAC;QACjC,IAAI,EAAE,UAAU,CAAC;KAClB,CAAC;CACH;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,QAAQ,CAAC;AACxC,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,UAAU,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAE9E,qBAAa,eAAe,CAAC,CAAC,SAAS,UAAU;IAC/C,OAAO,CAAC,cAAc,CAA2C;IAEjE,iBAAiB,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IAI3C,gBAAgB,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;IAQpE,mBAAmB,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;IAOvE,aAAa,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;CAQ5D"}

package/dist/transport/events.js

@@ -1,26 +0,0 @@
-export class EventDispatcher {
-    eventListeners = {};
-    numberOfListeners(eventType) {
-        return this.eventListeners[eventType]?.size ?? 0;
-    }
-    addEventListener(eventType, handler) {
-        if (!this.eventListeners[eventType]) {
-            this.eventListeners[eventType] = new Set();
-        }
-        this.eventListeners[eventType]?.add(handler);
-    }
-    removeEventListener(eventType, handler) {
-        const handlers = this.eventListeners[eventType];
-        if (handlers) {
-            this.eventListeners[eventType]?.delete(handler);
-        }
-    }
-    dispatchEvent(eventType, event) {
-        const handlers = this.eventListeners[eventType];
-        if (handlers) {
-            for (const handler of handlers) {
-                handler(event);
-            }
-        }
-    }
-}

package/dist/transport/impls/stdio/stdio.d.ts

@@ -1,33 +0,0 @@
-/// <reference types="node" />
-import { Codec } from '../../../codec';
-import { TransportClientId } from '../../message';
-import { Connection, Transport } from '../../transport';
-export declare class StdioConnection extends Connection {
-    output: NodeJS.WritableStream;
-    constructor(transport: Transport<StdioConnection>, connectedTo: TransportClientId, output: NodeJS.WritableStream);
-    send(payload: Uint8Array): boolean;
-    close(): Promise<void>;
-}
-interface Options {
-    codec: Codec;
-}
-/**
- * A transport implementation that uses standard input and output streams.
- * @extends Transport
- */
-export declare class StdioTransport extends Transport<StdioConnection> {
-    clientId: TransportClientId;
-    input: NodeJS.ReadableStream;
-    output: NodeJS.WritableStream;
-    /**
-     * Constructs a new StdioTransport instance.
-     * @param clientId - The ID of the client associated with this transport.
-     * @param input - The readable stream to use as input. Defaults to process.stdin.
-     * @param output - The writable stream to use as output. Defaults to process.stdout.
-     */
-    constructor(clientId: TransportClientId, input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream, providedOptions?: Partial<Options>);
-    setupConnectionStatusListeners(): void;
-    createNewConnection(to: TransportClientId): Promise<void>;
-}
-export {};
-//# sourceMappingURL=stdio.d.ts.map

package/dist/transport/impls/stdio/stdio.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../../../transport/impls/stdio/stdio.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKxD,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;gBAG5B,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,EACrC,WAAW,EAAE,iBAAiB,EAC9B,MAAM,EAAE,MAAM,CAAC,cAAc;IAM/B,IAAI,CAAC,OAAO,EAAE,UAAU;IAOlB,KAAK;CAGZ;AAED,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAMD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,SAAS,CAAC,eAAe,CAAC;IAC5D,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC,cAAc,CAAiB;IAC7C,MAAM,EAAE,MAAM,CAAC,cAAc,CAAkB;IAE/C;;;;;OAKG;gBAED,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,GAAE,MAAM,CAAC,cAA8B,EAC5C,MAAM,GAAE,MAAM,CAAC,cAA+B,EAC9C,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAUpC,8BAA8B,IAAI,IAAI;IAwBhC,mBAAmB,CAAC,EAAE,EAAE,iBAAiB;CAShD"}

package/dist/transport/impls/stdio/stdio.js

@@ -1,75 +0,0 @@
-import { NaiveJsonCodec } from '../../../codec/json';
-import { log } from '../../../logging';
-import { Connection, Transport } from '../../transport';
-import readline from 'readline';
-const newlineBuff = new TextEncoder().encode('\n');
-export class StdioConnection extends Connection {
-    output;
-    constructor(transport, connectedTo, output) {
-        super(transport, connectedTo);
-        this.output = output;
-    }
-    send(payload) {
-        const out = new Uint8Array(payload.length + newlineBuff.length);
-        out.set(payload, 0);
-        out.set(newlineBuff, payload.length);
-        return this.output.write(out);
-    }
-    async close() {
-        this.output.end();
-    }
-}
-const defaultOptions = {
-    codec: NaiveJsonCodec,
-};
-/**
- * A transport implementation that uses standard input and output streams.
- * @extends Transport
- */
-export class StdioTransport extends Transport {
-    clientId;
-    input = process.stdin;
-    output = process.stdout;
-    /**
-     * Constructs a new StdioTransport instance.
-     * @param clientId - The ID of the client associated with this transport.
-     * @param input - The readable stream to use as input. Defaults to process.stdin.
-     * @param output - The writable stream to use as output. Defaults to process.stdout.
-     */
-    constructor(clientId, input = process.stdin, output = process.stdout, providedOptions) {
-        const options = { ...defaultOptions, ...providedOptions };
-        super(options.codec, clientId);
-        this.clientId = clientId;
-        this.input = input;
-        this.output = output;
-        this.setupConnectionStatusListeners();
-    }
-    setupConnectionStatusListeners() {
-        let conn = undefined;
-        const rl = readline.createInterface({
-            input: this.input,
-        });
-        const encoder = new TextEncoder();
-        rl.on('line', (msg) => {
-            const parsedMsg = this.parseMsg(encoder.encode(msg));
-            if (parsedMsg && !this.connections.has(parsedMsg.from)) {
-                conn = new StdioConnection(this, parsedMsg.from, this.output);
-                this.onConnect(conn);
-            }
-            this.handleMsg(parsedMsg);
-        });
-        rl.on('close', () => {
-            if (conn) {
-                this.onDisconnect(conn);
-            }
-        });
-    }
-    async createNewConnection(to) {
-        if (this.state === 'destroyed') {
-            throw new Error('cant reopen a destroyed connection');
-        }
-        log?.info(`${this.clientId} -- establishing a new stream to ${to}`);
-        const conn = new StdioConnection(this, to, this.output);
-        this.onConnect(conn);
-    }
-}

package/dist/transport/impls/stdio/stdio.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=stdio.test.d.ts.map

package/dist/transport/impls/stdio/stdio.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stdio.test.d.ts","sourceRoot":"","sources":["../../../../transport/impls/stdio/stdio.test.ts"],"names":[],"mappings":""}

package/dist/transport/impls/stdio/stdio.test.js

@@ -1,25 +0,0 @@
-import { describe, test, expect } from 'vitest';
-import stream from 'node:stream';
-import { StdioTransport } from './stdio';
-import { waitForMessage } from '../..';
-import { payloadToTransportMessage } from '../../../util/testHelpers';
-import { ensureTransportIsClean } from '../../../__tests__/fixtures/cleanup';
-describe('sending and receiving across node streams works', () => {
-    test('basic send/receive', async () => {
-        const clientToServer = new stream.PassThrough();
-        const serverToClient = new stream.PassThrough();
-        const serverTransport = new StdioTransport('abc', clientToServer, serverToClient);
-        const clientTransport = new StdioTransport('def', serverToClient, clientToServer);
-        const msg = {
-            msg: 'cool',
-            test: 123,
-        };
-        const p = waitForMessage(serverTransport);
-        clientTransport.send(payloadToTransportMessage(msg, 'stream', clientTransport.clientId, serverTransport.clientId));
-        await expect(p).resolves.toStrictEqual(msg);
-        await clientTransport.close();
-        await serverTransport.close();
-        await ensureTransportIsClean(clientTransport);
-        await ensureTransportIsClean(serverTransport);
-    });
-});

package/dist/transport/impls/ws/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/client.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnD,UAAU,OAAO;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,KAAK,CAAC;CACd;AAQD,KAAK,eAAe,GAAG;IAAE,EAAE,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,SAAS,CAAC,mBAAmB,CAAC;IAC1E;;OAEG;IACH,QAAQ,EAAE,CAAC,EAAE,EAAE,iBAAiB,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,iBAAiB,CAAC;IAE5B,iBAAiB,EAAE,GAAG,CAAC,iBAAiB,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC;IAEpE;;;;;OAKG;gBAED,QAAQ,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,EAClC,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAWpC,8BAA8B,IAAI,IAAI;IAIhC,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,SAAI;IAuEjD;;OAEG;IACG,IAAI;CAGX"}

package/dist/transport/impls/ws/connection.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="ws" />
-import { TransportClientId } from '../../message';
-import { Connection, Transport } from '../../transport';
-import WebSocket from 'isomorphic-ws';
-export declare class WebSocketConnection extends Connection {
-    ws: WebSocket;
-    constructor(transport: Transport<WebSocketConnection>, connectedTo: TransportClientId, ws: WebSocket);
-    send(payload: Uint8Array): boolean;
-    close(): Promise<void>;
-}
-//# sourceMappingURL=connection.d.ts.map

package/dist/transport/impls/ws/connection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/connection.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,SAAS,MAAM,eAAe,CAAC;AAEtC,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,EAAE,EAAE,SAAS,CAAC;gBAGZ,SAAS,EAAE,SAAS,CAAC,mBAAmB,CAAC,EACzC,WAAW,EAAE,iBAAiB,EAC9B,EAAE,EAAE,SAAS;IAUf,IAAI,CAAC,OAAO,EAAE,UAAU;IASlB,KAAK;CAGZ"}

package/dist/transport/impls/ws/connection.js

@@ -1,23 +0,0 @@
-import { Connection } from '../../transport';
-export class WebSocketConnection extends Connection {
-    ws;
-    constructor(transport, connectedTo, ws) {
-        super(transport, connectedTo);
-        this.ws = ws;
-        ws.binaryType = 'arraybuffer';
-        // take over the onmessage for this websocket
-        this.ws.onmessage = (msg) => transport.onMessage(msg.data);
-    }
-    send(payload) {
-        if (this.ws.readyState === this.ws.OPEN) {
-            this.ws.send(payload);
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    async close() {
-        this.ws.close();
-    }
-}

package/dist/transport/impls/ws/server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkB,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAC5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEnD,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAMD,qBAAa,wBAAyB,SAAQ,SAAS,CAAC,mBAAmB,CAAC;IAC1E,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,iBAAiB,CAAC;gBAG1B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IASpC,8BAA8B,IAAI,IAAI;IAiChC,mBAAmB,CAAC,EAAE,EAAE,MAAM;CAKrC"}

package/dist/transport/impls/ws/ws.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ws.test.d.ts.map

package/dist/transport/impls/ws/ws.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ws.test.d.ts","sourceRoot":"","sources":["../../../../transport/impls/ws/ws.test.ts"],"names":[],"mappings":""}