@derivation/rpc 0.3.5 → 0.5.0

package/dist/web-socket-transport.js

@@ -1,25 +1,27 @@
-/**
- * Transport implementation for browser WebSocket (client-side).
- */
-export class WebSocketTransport {
-    constructor(ws) {
-        this.ws = ws;
-    }
-    send(data) {
-        this.ws.send(data);
-    }
-    onMessage(handler) {
-        this.ws.onmessage = (event) => {
-            handler(event.data);
-        };
-    }
-    onClose(handler) {
-        this.ws.onclose = handler;
-    }
-    close() {
-        this.ws.close();
-    }
-    get bufferedAmount() {
-        return this.ws.bufferedAmount;
-    }
-}
+// src/web-socket-transport.ts
+var WebSocketTransport = class {
+  constructor(ws) {
+    this.ws = ws;
+  }
+  send(data) {
+    this.ws.send(data);
+  }
+  onMessage(handler) {
+    this.ws.onmessage = (event) => {
+      handler(event.data);
+    };
+  }
+  onClose(handler) {
+    this.ws.onclose = handler;
+  }
+  close() {
+    this.ws.close();
+  }
+  get bufferedAmount() {
+    return this.ws.bufferedAmount;
+  }
+};
+export {
+  WebSocketTransport
+};
+//# sourceMappingURL=web-socket-transport.js.map

package/dist/web-socket-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/web-socket-transport.ts"],"sourcesContent":["import { Transport } from \"./transport.js\";\n\n/**\n * Transport implementation for browser WebSocket (client-side).\n */\nexport class WebSocketTransport implements Transport {\n  constructor(private ws: globalThis.WebSocket) {}\n\n  send(data: string): void {\n    this.ws.send(data);\n  }\n\n  onMessage(handler: (data: string) => void): void {\n    this.ws.onmessage = (event: MessageEvent) => {\n      handler(event.data);\n    };\n  }\n\n  onClose(handler: () => void): void {\n    this.ws.onclose = handler;\n  }\n\n  close(): void {\n    this.ws.close();\n  }\n\n  get bufferedAmount(): number {\n    return this.ws.bufferedAmount;\n  }\n}\n"],"mappings":";AAKO,IAAM,qBAAN,MAA8C;AAAA,EACnD,YAAoB,IAA0B;AAA1B;AAAA,EAA2B;AAAA,EAE/C,KAAK,MAAoB;AACvB,SAAK,GAAG,KAAK,IAAI;AAAA,EACnB;AAAA,EAEA,UAAU,SAAuC;AAC/C,SAAK,GAAG,YAAY,CAAC,UAAwB;AAC3C,cAAQ,MAAM,IAAI;AAAA,IACpB;AAAA,EACF;AAAA,EAEA,QAAQ,SAA2B;AACjC,SAAK,GAAG,UAAU;AAAA,EACpB;AAAA,EAEA,QAAc;AACZ,SAAK,GAAG,MAAM;AAAA,EAChB;AAAA,EAEA,IAAI,iBAAyB;AAC3B,WAAO,KAAK,GAAG;AAAA,EACjB;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@derivation/rpc",
-  "version": "0.3.5",
+  "version": "0.5.0",
   "homepage": "https://github.com/derivationjs/rpc",
   "repository": {
     "type": "git",
@@ -9,63 +9,72 @@
   "description": "An RPC library for derivation.",
   "license": "MIT",
   "author": "Daniel Waterworth",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./iso": {
       "types": "./dist/iso.d.ts",
-      "import": "./dist/iso.js"
+      "import": "./dist/iso.js",
+      "require": "./dist/iso.cjs"
     },
     "./worker": {
       "types": "./dist/shared-worker-server.d.ts",
-      "import": "./dist/shared-worker-server.js"
+      "import": "./dist/shared-worker-server.js",
+      "require": "./dist/shared-worker-server.cjs"
     },
     "./client": {
       "types": "./dist/shared-worker-client.d.ts",
-      "import": "./dist/shared-worker-client.js"
+      "import": "./dist/shared-worker-client.js",
+      "require": "./dist/shared-worker-client.cjs"
     },
     "./transport": {
       "types": "./dist/transport.d.ts",
-      "import": "./dist/transport.js"
+      "import": "./dist/transport.js",
+      "require": "./dist/transport.cjs"
     },
     "./browser": {
       "types": "./dist/web-socket-transport.d.ts",
-      "import": "./dist/web-socket-transport.js"
+      "import": "./dist/web-socket-transport.js",
+      "require": "./dist/web-socket-transport.cjs"
     },
     "./server": {
       "types": "./dist/web-socket-server.d.ts",
-      "import": "./dist/web-socket-server.js"
+      "import": "./dist/web-socket-server.js",
+      "require": "./dist/web-socket-server.cjs"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "prepare": "tsc -p tsconfig.json",
-    "build": "tsc -p tsconfig.json",
+    "prepare": "tsup",
+    "build": "tsup",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "eslint src"
   },
   "dependencies": {
-    "@derivation/composable": "^0.3.5",
-    "@types/node": "^25.1.0",
+    "derivation": "^0.5.0",
+    "@derivation/composable": "^0.5.0",
+    "@types/node": "^25.2.3",
     "@types/ws": "^8.18.1",
-    "derivation": "^0.3.5",
     "immutable": "^5.1.4",
     "ws": "^8.19.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^8.54.0",
-    "@typescript-eslint/parser": "^8.54.0",
-    "eslint": "^9.39.2",
+    "@typescript-eslint/eslint-plugin": "^8.55.0",
+    "@typescript-eslint/parser": "^8.55.0",
+    "eslint": "^9.0.0",
     "eslint-plugin-import": "^2.32.0",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   }

package/dist/client-handler.d.ts

@@ -1,27 +0,0 @@
-import { ClientMessage } from "./client-message.js";
-import { ServerMessage } from "./server-message.js";
-import { StreamEndpoints, MutationEndpoints, RPCDefinition } from "./stream-types.js";
-import { PresenceHandler } from "./presence-manager.js";
-import { Transport } from "./transport.js";
-export declare class ClientHandler<Defs extends RPCDefinition, Ctx = void> {
-    private readonly transport;
-    private readonly context;
-    private readonly streamEndpoints;
-    private readonly mutationEndpoints;
-    private readonly presenceHandler?;
-    private currentPresence?;
-    private closed;
-    private readonly streams;
-    private heartbeatTimeout;
-    private inactivityTimeout;
-    private readonly rateLimiter;
-    constructor(transport: Transport, context: Ctx, streamEndpoints: StreamEndpoints<Defs["streams"], Ctx>, mutationEndpoints: MutationEndpoints<Defs["mutations"], Ctx>, presenceHandler?: PresenceHandler);
-    private resetHeartbeat;
-    private resetInactivity;
-    handleMessage(message: string): void;
-    handleClientMessage(message: ClientMessage): Promise<void>;
-    handleStep(): void;
-    sendMessage(message: ServerMessage): void;
-    private handleDisconnect;
-    close(): void;
-}

package/dist/client-handler.js

@@ -1,187 +0,0 @@
-import { parseClientMessage } from "./client-message.js";
-import { ServerMessage } from "./server-message.js";
-import { RateLimiter } from "./rate-limiter.js";
-export class ClientHandler {
-    constructor(transport, context, streamEndpoints, mutationEndpoints, presenceHandler) {
-        this.closed = false;
-        this.streams = new Map();
-        this.transport = transport;
-        this.context = context;
-        this.streamEndpoints = streamEndpoints;
-        this.mutationEndpoints = mutationEndpoints;
-        this.presenceHandler = presenceHandler;
-        this.rateLimiter = new RateLimiter(100, 300); // 100 messages over 5 minutes
-        console.log("new client connected");
-        // Set up transport handlers
-        this.transport.onMessage((data) => this.handleMessage(data));
-        this.transport.onClose(() => this.handleDisconnect());
-        this.resetHeartbeat();
-        this.resetInactivity();
-    }
-    resetHeartbeat() {
-        if (this.heartbeatTimeout) {
-            clearTimeout(this.heartbeatTimeout);
-        }
-        this.heartbeatTimeout = setTimeout(() => {
-            this.sendMessage(ServerMessage.heartbeat());
-        }, 10000);
-    }
-    resetInactivity() {
-        if (this.inactivityTimeout) {
-            clearTimeout(this.inactivityTimeout);
-        }
-        this.inactivityTimeout = setTimeout(() => {
-            this.close();
-        }, 30000);
-    }
-    handleMessage(message) {
-        this.resetInactivity();
-        // Check rate limit
-        if (this.rateLimiter.trigger()) {
-            console.log("Rate limit exceeded, closing connection");
-            this.close();
-            return;
-        }
-        let data;
-        try {
-            data = JSON.parse(message);
-        }
-        catch (_a) {
-            console.error("Invalid JSON received:", message);
-            return this.close();
-        }
-        let parsed;
-        try {
-            parsed = parseClientMessage(data);
-        }
-        catch (err) {
-            console.error("Invalid client message:", err);
-            return this.close();
-        }
-        this.handleClientMessage(parsed);
-    }
-    async handleClientMessage(message) {
-        switch (message.type) {
-            case "subscribe": {
-                const { id, name, args } = message;
-                if (!(name in this.streamEndpoints)) {
-                    console.error(`Unknown stream: ${name}`);
-                    this.close();
-                    return;
-                }
-                const endpoint = this.streamEndpoints[name];
-                try {
-                    const source = await endpoint(args, this.context);
-                    this.streams.set(id, source);
-                    this.sendMessage(ServerMessage.subscribed(id, source.Snapshot));
-                    console.log(`Client subscribed to \"${name}\" (${id})`);
-                }
-                catch (err) {
-                    console.error(`Error building stream ${name}:`, err);
-                    this.close();
-                }
-                break;
-            }
-            case "unsubscribe": {
-                const { id } = message;
-                this.streams.delete(id);
-                console.log(`Client unsubscribed from ${id}`);
-                break;
-            }
-            case "call": {
-                const { id, name, args } = message;
-                if (!(name in this.mutationEndpoints)) {
-                    console.error(`Unknown mutation: ${name}`);
-                    this.close();
-                    return;
-                }
-                const endpoint = this.mutationEndpoints[name];
-                endpoint(args, this.context)
-                    .then((result) => {
-                    if (result.success) {
-                        this.sendMessage(ServerMessage.resultSuccess(id, result.value));
-                        console.log(`Mutation \"${name}\" (${id}) completed successfully`);
-                    }
-                    else {
-                        this.sendMessage(ServerMessage.resultError(id, result.error));
-                        console.log(`Mutation \"${name}\" (${id}) returned error: ${result.error}`);
-                    }
-                })
-                    .catch((err) => {
-                    console.error(`Unhandled exception in mutation \"${name}\" (${id}):`, err);
-                    this.close();
-                });
-                break;
-            }
-            case "heartbeat":
-                break;
-            case "presence": {
-                if (!this.presenceHandler) {
-                    console.error("Presence not configured");
-                    this.close();
-                    return;
-                }
-                const { data } = message;
-                if (this.currentPresence !== undefined) {
-                    this.presenceHandler.update(this.currentPresence, data);
-                }
-                else {
-                    this.presenceHandler.add(data);
-                }
-                this.currentPresence = data;
-                break;
-            }
-        }
-    }
-    handleStep() {
-        if (this.closed)
-            return;
-        const changes = {};
-        for (const [id, source] of this.streams) {
-            const change = source.LastChange;
-            if (change === null)
-                continue;
-            changes[id] = change;
-        }
-        if (Object.keys(changes).length > 0) {
-            this.sendMessage(ServerMessage.delta(changes));
-        }
-    }
-    sendMessage(message) {
-        this.resetHeartbeat();
-        if (!this.closed) {
-            // Check buffer if available (WebSocket provides this, MessagePort doesn't)
-            if (this.transport.bufferedAmount !== undefined &&
-                this.transport.bufferedAmount > 100 * 1024) {
-                console.log("Send buffer exceeded 100KB, closing connection");
-                this.close();
-                return;
-            }
-            try {
-                this.transport.send(JSON.stringify(message));
-            }
-            catch (err) {
-                console.error("Failed to send message:", err);
-                this.close();
-            }
-        }
-    }
-    handleDisconnect() {
-        console.log("client disconnected");
-        this.close();
-    }
-    close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        clearTimeout(this.heartbeatTimeout);
-        clearTimeout(this.inactivityTimeout);
-        if (this.presenceHandler && this.currentPresence !== undefined) {
-            this.presenceHandler.remove(this.currentPresence);
-        }
-        try {
-            this.transport.close();
-        }
-        catch (_a) { }
-    }
-}

package/dist/client-message.d.ts

@@ -1,57 +0,0 @@
-import { z } from "zod";
-export declare const SubscribeMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"subscribe">;
-    id: z.ZodNumber;
-    name: z.ZodString;
-    args: z.ZodObject<{}, z.core.$loose>;
-}, z.core.$strip>;
-export type SubscribeMessage = z.infer<typeof SubscribeMessageSchema>;
-export declare const UnsubscribeMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"unsubscribe">;
-    id: z.ZodNumber;
-}, z.core.$strip>;
-export type UnsubscribeMessage = z.infer<typeof UnsubscribeMessageSchema>;
-export declare const HeartbeatMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"heartbeat">;
-}, z.core.$strip>;
-export type HeartbeatMessage = z.infer<typeof HeartbeatMessageSchema>;
-export declare const CallMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"call">;
-    id: z.ZodNumber;
-    name: z.ZodString;
-    args: z.ZodObject<{}, z.core.$loose>;
-}, z.core.$strip>;
-export type CallMessage = z.infer<typeof CallMessageSchema>;
-export declare const PresenceMessageSchema: z.ZodObject<{
-    type: z.ZodLiteral<"presence">;
-    data: z.ZodObject<{}, z.core.$loose>;
-}, z.core.$strip>;
-export type PresenceMessage = z.infer<typeof PresenceMessageSchema>;
-export declare const ClientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"subscribe">;
-    id: z.ZodNumber;
-    name: z.ZodString;
-    args: z.ZodObject<{}, z.core.$loose>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"unsubscribe">;
-    id: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"heartbeat">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"call">;
-    id: z.ZodNumber;
-    name: z.ZodString;
-    args: z.ZodObject<{}, z.core.$loose>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"presence">;
-    data: z.ZodObject<{}, z.core.$loose>;
-}, z.core.$strip>], "type">;
-export type ClientMessage = z.infer<typeof ClientMessageSchema>;
-export declare function parseClientMessage(data: unknown): ClientMessage;
-export declare const ClientMessage: {
-    subscribe: (id: number, name: string, args: object) => SubscribeMessage;
-    unsubscribe: (id: number) => UnsubscribeMessage;
-    call: (id: number, name: string, args: object) => CallMessage;
-    heartbeat: () => HeartbeatMessage;
-    presence: (data: object) => PresenceMessage;
-};

package/dist/client-message.js

@@ -1,59 +0,0 @@
-import { z } from "zod";
-export const SubscribeMessageSchema = z.object({
-    type: z.literal("subscribe"),
-    id: z.number(),
-    name: z.string(),
-    args: z.looseObject({}),
-});
-export const UnsubscribeMessageSchema = z.object({
-    type: z.literal("unsubscribe"),
-    id: z.number(),
-});
-export const HeartbeatMessageSchema = z.object({
-    type: z.literal("heartbeat"),
-});
-export const CallMessageSchema = z.object({
-    type: z.literal("call"),
-    id: z.number(),
-    name: z.string(),
-    args: z.looseObject({}),
-});
-export const PresenceMessageSchema = z.object({
-    type: z.literal("presence"),
-    data: z.looseObject({}),
-});
-export const ClientMessageSchema = z.discriminatedUnion("type", [
-    SubscribeMessageSchema,
-    UnsubscribeMessageSchema,
-    HeartbeatMessageSchema,
-    CallMessageSchema,
-    PresenceMessageSchema,
-]);
-export function parseClientMessage(data) {
-    return ClientMessageSchema.parse(data);
-}
-export const ClientMessage = {
-    subscribe: (id, name, args) => ({
-        type: "subscribe",
-        id,
-        name,
-        args: args,
-    }),
-    unsubscribe: (id) => ({
-        type: "unsubscribe",
-        id,
-    }),
-    call: (id, name, args) => ({
-        type: "call",
-        id,
-        name,
-        args: args,
-    }),
-    heartbeat: () => ({
-        type: "heartbeat",
-    }),
-    presence: (data) => ({
-        type: "presence",
-        data: data,
-    }),
-};

package/dist/client.js

@@ -1,133 +0,0 @@
-import { ClientMessage } from "./client-message.js";
-function changer(sink, input) {
-    return (change) => {
-        const i = input.deref();
-        if (i) {
-            sink.apply(change, i);
-        }
-    };
-}
-export class Client {
-    resetHeartbeat() {
-        if (this.heartbeatTimeout) {
-            clearTimeout(this.heartbeatTimeout);
-        }
-        this.heartbeatTimeout = setTimeout(() => {
-            this.sendMessage(ClientMessage.heartbeat());
-        }, 10000);
-    }
-    resetInactivity() {
-        if (this.inactivityTimeout) {
-            clearTimeout(this.inactivityTimeout);
-        }
-        this.inactivityTimeout = setTimeout(() => {
-            this.close();
-        }, 30000);
-    }
-    constructor(transport, sinks, graph) {
-        this.transport = transport;
-        this.sinks = sinks;
-        this.graph = graph;
-        this.nextId = 1;
-        this.pendingStreams = new Map();
-        this.pendingMutations = new Map();
-        this.activeStreams = new Map();
-        this.registry = new FinalizationRegistry(([id, name]) => {
-            console.log(`🧹 Stream ${id} (${name}) collected — unsubscribing`);
-            this.sendMessage(ClientMessage.unsubscribe(id));
-            this.activeStreams.delete(id);
-        });
-        this.transport.onMessage((data) => {
-            const message = JSON.parse(data);
-            this.handleMessage(message);
-        });
-        this.resetHeartbeat();
-        this.resetInactivity();
-    }
-    handleMessage(message) {
-        this.resetInactivity();
-        switch (message.type) {
-            case "snapshot": {
-                const resolve = this.pendingStreams.get(message.id);
-                if (resolve) {
-                    resolve(message.snapshot);
-                    this.pendingStreams.delete(message.id);
-                }
-                break;
-            }
-            case "delta": {
-                for (const [idStr, change] of Object.entries(message.changes)) {
-                    const id = Number(idStr);
-                    const sink = this.activeStreams.get(id);
-                    if (sink && change && typeof change === "object") {
-                        sink(change);
-                    }
-                    else if (!sink) {
-                        console.log(`🧹 Sink ${id} GC'd — auto-unsubscribing`);
-                        this.sendMessage(ClientMessage.unsubscribe(id));
-                        this.activeStreams.delete(id);
-                    }
-                }
-                this.graph.step();
-                break;
-            }
-            case "result": {
-                const resolve = this.pendingMutations.get(message.id);
-                if (resolve) {
-                    if (message.success) {
-                        resolve({ success: true, value: message.value });
-                    }
-                    else {
-                        resolve({
-                            success: false,
-                            error: message.error || "Unknown error",
-                        });
-                    }
-                    this.pendingMutations.delete(message.id);
-                }
-                break;
-            }
-            case "heartbeat":
-                break;
-        }
-    }
-    sendMessage(message) {
-        this.resetHeartbeat();
-        this.transport.send(JSON.stringify(message));
-    }
-    async run(key, args) {
-        console.log(`Running stream ${String(key)} with args ${JSON.stringify(args)}`);
-        const id = this.nextId++;
-        this.sendMessage(ClientMessage.subscribe(id, String(key), args));
-        const snapshot = await new Promise((resolve) => {
-            this.pendingStreams.set(id, resolve);
-        });
-        const endpoint = this.sinks[key];
-        const sinkAdapter = endpoint(snapshot);
-        const { stream, input } = sinkAdapter.build();
-        const inputRef = new WeakRef(input);
-        this.activeStreams.set(id, changer(sinkAdapter, inputRef));
-        this.registry.register(input, [id, String(key)]);
-        return stream;
-    }
-    async call(key, args) {
-        console.log(`Calling mutation ${String(key)} with args ${JSON.stringify(args)}`);
-        const id = this.nextId++;
-        this.sendMessage(ClientMessage.call(id, String(key), args));
-        const result = await new Promise((resolve) => {
-            this.pendingMutations.set(id, resolve);
-        });
-        return result;
-    }
-    close() {
-        clearTimeout(this.heartbeatTimeout);
-        clearTimeout(this.inactivityTimeout);
-        try {
-            this.transport.close();
-        }
-        catch (_a) { }
-    }
-    setPresence(value) {
-        this.sendMessage(ClientMessage.presence(value));
-    }
-}

package/dist/messageport-transport.d.ts

@@ -1,13 +0,0 @@
-import { Transport } from "./transport.js";
-/**
- * Transport implementation for MessagePort (SharedWorker communication).
- */
-export declare class MessagePortTransport implements Transport {
-    private port;
-    constructor(port: MessagePort);
-    send(data: string): void;
-    onMessage(handler: (data: string) => void): void;
-    onClose(handler: () => void): void;
-    close(): void;
-    get bufferedAmount(): undefined;
-}

package/dist/messageport-transport.js

@@ -1,28 +0,0 @@
-/**
- * Transport implementation for MessagePort (SharedWorker communication).
- */
-export class MessagePortTransport {
-    constructor(port) {
-        this.port = port;
-    }
-    send(data) {
-        this.port.postMessage(data);
-    }
-    onMessage(handler) {
-        this.port.onmessage = (event) => {
-            handler(event.data);
-        };
-    }
-    onClose(handler) {
-        // MessagePort doesn't have a reliable close event
-        // We'll use messageerror as a signal, though it's not perfect
-        this.port.onmessageerror = handler;
-    }
-    close() {
-        this.port.close();
-    }
-    // MessagePort doesn't provide bufferedAmount
-    get bufferedAmount() {
-        return undefined;
-    }
-}

package/dist/node-web-socket-transport.d.ts

@@ -1,16 +0,0 @@
-import { WebSocket } from "ws";
-import { Transport } from "./transport.js";
-/**
- * Transport implementation for Node.js WebSocket (server-side using 'ws' library).
- */
-export declare class NodeWebSocketTransport implements Transport {
-    private ws;
-    private messageHandlerSet;
-    private closeHandlerSet;
-    constructor(ws: WebSocket);
-    send(data: string): void;
-    onMessage(handler: (data: string) => void): void;
-    onClose(handler: () => void): void;
-    close(): void;
-    get bufferedAmount(): number;
-}