@derivation/rpc 0.1.2 → 0.1.5

package/dist/client-handler.d.ts

@@ -1,15 +1,22 @@
 import { RawData, WebSocket } from "ws";
 import { ClientMessage } from "./client-message";
 import { ServerMessage } from "./server-message";
-import { StreamEndpoints, StreamDefinitions } from "./stream-types";
-export declare class ClientHandler<Defs extends StreamDefinitions> {
+import { StreamEndpoints, MutationEndpoints, RPCDefinition } from "./stream-types";
+import { PresenceHandler } from "./presence-manager";
+export declare class ClientHandler<Defs extends RPCDefinition> {
     private readonly ws;
-    private readonly endpoints;
+    private readonly streamEndpoints;
+    private readonly mutationEndpoints;
+    private readonly presenceHandler?;
+    private currentPresence?;
     private closed;
     private readonly streams;
-    private interval;
-    constructor(ws: WebSocket, endpoints: StreamEndpoints<Defs>);
+    private heartbeatTimeout;
+    private inactivityTimeout;
+    private readonly rateLimiter;
+    constructor(ws: WebSocket, streamEndpoints: StreamEndpoints<Defs["streams"]>, mutationEndpoints: MutationEndpoints<Defs["mutations"]>, presenceHandler?: PresenceHandler);
     private resetHeartbeat;
+    private resetInactivity;
     handleMessage(message: RawData): void;
     handleClientMessage(message: ClientMessage): void;
     handleStep(): void;

package/dist/client-handler.js

@@ -1,23 +1,43 @@
 import { parseClientMessage } from "./client-message";
 import { ServerMessage } from "./server-message";
+import { RateLimiter } from "./rate-limiter";
 export class ClientHandler {
-    constructor(ws, endpoints) {
+    constructor(ws, streamEndpoints, mutationEndpoints, presenceHandler) {
         this.closed = false;
         this.streams = new Map();
         this.ws = ws;
-        this.endpoints = endpoints;
+        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");
         this.resetHeartbeat();
+        this.resetInactivity();
     }
     resetHeartbeat() {
-        if (this.interval) {
-            clearInterval(this.interval);
+        if (this.heartbeatTimeout) {
+            clearTimeout(this.heartbeatTimeout);
         }
-        this.interval = setInterval(() => {
+        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.toString());
@@ -40,12 +60,12 @@ export class ClientHandler {
         switch (message.type) {
             case "subscribe": {
                 const { id, name, args } = message;
-                if (!(name in this.endpoints)) {
+                if (!(name in this.streamEndpoints)) {
                     console.error(`Unknown stream: ${name}`);
                     this.close();
                     return;
                 }
-                const endpoint = this.endpoints[name];
+                const endpoint = this.streamEndpoints[name];
                 try {
                     const source = endpoint(args);
                     this.streams.set(id, source);
@@ -64,8 +84,49 @@ export class ClientHandler {
                 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)
+                    .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() {
@@ -73,7 +134,10 @@ export class ClientHandler {
             return;
         const changes = {};
         for (const [id, source] of this.streams) {
-            changes[id] = source.LastChange;
+            const change = source.LastChange;
+            if (change === null)
+                continue;
+            changes[id] = change;
         }
         if (Object.keys(changes).length > 0) {
             this.sendMessage(ServerMessage.delta(changes));
@@ -82,6 +146,11 @@ export class ClientHandler {
     sendMessage(message) {
         this.resetHeartbeat();
         if (!this.closed) {
+            if (this.ws.bufferedAmount > 100 * 1024) {
+                console.log("Send buffer exceeded 100KB, closing connection");
+                this.close();
+                return;
+            }
             try {
                 this.ws.send(JSON.stringify(message));
             }
@@ -99,7 +168,11 @@ export class ClientHandler {
         if (this.closed)
             return;
         this.closed = true;
-        clearInterval(this.interval);
+        clearTimeout(this.heartbeatTimeout);
+        clearTimeout(this.inactivityTimeout);
+        if (this.presenceHandler && this.currentPresence !== undefined) {
+            this.presenceHandler.remove(this.currentPresence);
+        }
         try {
             this.ws.close();
         }

package/dist/client-message.d.ts

@@ -15,6 +15,18 @@ 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;
@@ -25,11 +37,21 @@ export declare const ClientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     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: Record<string, unknown>) => SubscribeMessage;
     unsubscribe: (id: number) => UnsubscribeMessage;
+    call: (id: number, name: string, args: Record<string, unknown>) => CallMessage;
     heartbeat: () => HeartbeatMessage;
+    presence: (data: Record<string, unknown>) => PresenceMessage;
 };

package/dist/client-message.js

@@ -12,10 +12,22 @@ export const UnsubscribeMessageSchema = z.object({
 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);
@@ -31,7 +43,17 @@ export const ClientMessage = {
         type: "unsubscribe",
         id,
     }),
+    call: (id, name, args) => ({
+        type: "call",
+        id,
+        name,
+        args,
+    }),
     heartbeat: () => ({
         type: "heartbeat",
     }),
+    presence: (data) => ({
+        type: "presence",
+        data,
+    }),
 };

package/dist/client.d.ts

@@ -1,15 +1,23 @@
 import type { Graph } from "derivation";
-import type { StreamDefinitions, StreamSinks } from "./stream-types";
-export declare class Client<Defs extends StreamDefinitions> {
+import type { StreamSinks, RPCDefinition, MutationResult } from "./stream-types";
+export declare class Client<Defs extends RPCDefinition> {
     private ws;
     private sinks;
     private graph;
     private nextId;
-    private pending;
+    private pendingStreams;
+    private pendingMutations;
     private activeStreams;
+    private heartbeatTimeout;
+    private inactivityTimeout;
     private registry;
-    constructor(ws: WebSocket, sinks: StreamSinks<Defs>, graph: Graph);
+    private resetHeartbeat;
+    private resetInactivity;
+    constructor(ws: WebSocket, sinks: StreamSinks<Defs["streams"]>, graph: Graph);
     private handleMessage;
-    private send;
-    run<Key extends keyof Defs>(key: Key, args: Defs[Key]["args"]): Promise<Defs[Key]["returnType"]>;
+    private sendMessage;
+    run<Key extends keyof Defs["streams"]>(key: Key, args: Defs["streams"][Key]["args"]): Promise<Defs["streams"][Key]["returnType"]>;
+    call<Key extends keyof Defs["mutations"]>(key: Key, args: Defs["mutations"][Key]["args"]): Promise<MutationResult<Defs["mutations"][Key]["result"]>>;
+    close(): void;
+    setPresence(value: Record<string, unknown>): void;
 }

package/dist/client.js

@@ -1,37 +1,57 @@
 import { ClientMessage } from "./client-message";
-function changer(sink, stream) {
+function changer(sink, input) {
     return (change) => {
-        const s = stream.deref();
-        if (s) {
-            sink.apply(change, s);
+        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(ws, sinks, graph) {
         this.ws = ws;
         this.sinks = sinks;
         this.graph = graph;
         this.nextId = 1;
-        this.pending = new Map();
+        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.send(ClientMessage.unsubscribe(id));
+            this.sendMessage(ClientMessage.unsubscribe(id));
             this.activeStreams.delete(id);
         });
         this.ws.onmessage = (event) => {
             const message = JSON.parse(event.data);
-            this.handleMessage(message);
+            this.ws.send(JSON.stringify(message));
         };
+        this.resetHeartbeat();
+        this.resetInactivity();
     }
     handleMessage(message) {
+        this.resetInactivity();
         switch (message.type) {
             case "snapshot": {
-                const resolve = this.pending.get(message.id);
+                const resolve = this.pendingStreams.get(message.id);
                 if (resolve) {
                     resolve(message.snapshot);
-                    this.pending.delete(message.id);
+                    this.pendingStreams.delete(message.id);
                 }
                 break;
             }
@@ -43,34 +63,71 @@ export class Client {
                         sink(change);
                     }
                     else if (!sink) {
-                        console.log(`🧹 Sink ${id} GC’d — auto-unsubscribing`);
-                        this.send(ClientMessage.unsubscribe(id));
+                        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;
         }
     }
-    send(message) {
+    sendMessage(message) {
+        this.resetHeartbeat();
         this.ws.send(JSON.stringify(message));
     }
     async run(key, args) {
         console.log(`Running stream ${String(key)} with args ${JSON.stringify(args)}`);
         const id = this.nextId++;
-        this.send(ClientMessage.subscribe(id, String(key), args));
+        this.sendMessage(ClientMessage.subscribe(id, String(key), args));
         const snapshot = await new Promise((resolve) => {
-            this.pending.set(id, resolve);
+            this.pendingStreams.set(id, resolve);
         });
         const endpoint = this.sinks[key];
-        const sink = endpoint(snapshot);
-        const stream = sink.build();
-        const ref = new WeakRef(stream);
-        this.activeStreams.set(id, changer(sink, ref));
-        this.registry.register(stream, [id, String(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.ws.close();
+        }
+        catch (_a) { }
+    }
+    setPresence(value) {
+        this.sendMessage(ClientMessage.presence(value));
+    }
 }

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export { ReactiveSetSourceAdapter, ReactiveSetSinkAdapter, sink as setSink } fro
 export { ReactiveMapSourceAdapter, ReactiveMapSinkAdapter, sink as mapSink } from "./reactive-map-adapter";
 export { StreamSourceAdapter, StreamSinkAdapter, sink as streamSink } from "./stream-adapter";
 export { setupWebSocketServer } from "./websocket-server";
+export type { PresenceHandler } from "./presence-manager";

package/dist/presence-manager.d.ts

@@ -0,0 +1,5 @@
+export interface PresenceHandler {
+    add(value: Record<string, unknown>): void;
+    remove(value: Record<string, unknown>): void;
+    update(oldValue: Record<string, unknown>, newValue: Record<string, unknown>): void;
+}

package/dist/presence-manager.js

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

package/dist/rate-limiter.d.ts

@@ -0,0 +1,7 @@
+export declare class RateLimiter {
+    private timestamps;
+    private readonly maxOccurrences;
+    private readonly windowNanos;
+    constructor(maxOccurrences: number, windowSeconds: number);
+    trigger(): boolean;
+}

package/dist/rate-limiter.js

@@ -0,0 +1,19 @@
+export class RateLimiter {
+    constructor(maxOccurrences, windowSeconds) {
+        this.timestamps = [];
+        this.maxOccurrences = maxOccurrences;
+        this.windowNanos = BigInt(windowSeconds) * BigInt(1000000000);
+    }
+    trigger() {
+        const now = process.hrtime.bigint();
+        // Add current timestamp
+        this.timestamps.push(now);
+        // Remove expired timestamps from front
+        const cutoff = now - this.windowNanos;
+        while (this.timestamps.length > 0 && this.timestamps[0] < cutoff) {
+            this.timestamps.shift();
+        }
+        // Return true if we've exceeded the limit
+        return this.timestamps.length > this.maxOccurrences;
+    }
+}

package/dist/reactive-map-adapter.d.ts

@@ -1,4 +1,4 @@
-import { Graph, ReactiveMap, ReactiveMapSource } from "derivation";
+import { Graph, ReactiveMap, ReactiveMapSource, ZMapChangeInput } from "derivation";
 import { Source, Sink } from "./stream-types";
 import { Iso } from "./iso";
 export declare class ReactiveMapSourceAdapter<K, V> implements Source<ReactiveMap<K, V>> {
@@ -6,14 +6,18 @@ export declare class ReactiveMapSourceAdapter<K, V> implements Source<ReactiveMa
     private readonly iso;
     constructor(map: ReactiveMap<K, V>, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>);
     get Snapshot(): object;
-    get LastChange(): object;
+    get LastChange(): object | null;
     get Stream(): ReactiveMap<K, V>;
 }
-export declare class ReactiveMapSinkAdapter<K, V> implements Sink<ReactiveMapSource<K, V>> {
+export declare class ReactiveMapSinkAdapter<K, V> implements Sink<ReactiveMapSource<K, V>, ZMapChangeInput<K, V>> {
     private readonly graph;
     private readonly iso;
-    constructor(graph: Graph, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>);
-    apply(change: object, stream: ReactiveMapSource<K, V>): void;
-    build(): ReactiveMapSource<K, V>;
+    private readonly initialMap;
+    constructor(graph: Graph, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>, snapshot: object);
+    apply(change: object, input: ZMapChangeInput<K, V>): void;
+    build(): {
+        stream: ReactiveMapSource<K, V>;
+        input: ZMapChangeInput<K, V>;
+    };
 }
-export declare function sink<K, V>(graph: Graph, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>): (snapshot: object) => Sink<ReactiveMapSource<K, V>>;
+export declare function sink<K, V>(graph: Graph, keyIso: Iso<K, unknown>, valueIso: Iso<V, unknown>): (snapshot: object) => Sink<ReactiveMapSource<K, V>, ZMapChangeInput<K, V>>;

package/dist/reactive-map-adapter.js

@@ -1,4 +1,3 @@
-import { ZMap } from "derivation";
 import { zmap } from "./iso";
 export class ReactiveMapSourceAdapter {
     constructor(map, keyIso, valueIso) {
@@ -9,37 +8,34 @@ export class ReactiveMapSourceAdapter {
         return this.iso.to(this.map.snapshot);
     }
     get LastChange() {
-        return this.iso.to(this.map.changes.value);
+        const change = this.iso.to(this.map.changes.value);
+        if (change.length === 0)
+            return null;
+        return change;
     }
     get Stream() {
         return this.map;
     }
 }
 export class ReactiveMapSinkAdapter {
-    constructor(graph, keyIso, valueIso) {
+    constructor(graph, keyIso, valueIso, snapshot) {
         this.graph = graph;
         this.iso = zmap(keyIso, valueIso);
+        this.initialMap = this.iso.from(snapshot);
     }
-    apply(change, stream) {
+    apply(change, input) {
         const zmapChange = this.iso.from(change);
         for (const [key, value, weight] of zmapChange.getEntries()) {
-            stream.add(key, value, weight);
+            input.add(key, value, weight);
         }
     }
     build() {
-        return this.graph.inputMap(new ZMap());
+        const stream = this.graph.inputMap(this.initialMap);
+        return { stream, input: stream.changes };
     }
 }
 export function sink(graph, keyIso, valueIso) {
-    const wholeIso = zmap(keyIso, valueIso);
     return (snapshot) => {
-        const initial = wholeIso.from(snapshot);
-        const g = graph;
-        const adapter = new ReactiveMapSinkAdapter(g, keyIso, valueIso);
-        const stream = g.inputMap(initial);
-        return {
-            apply: adapter.apply.bind(adapter),
-            build: () => stream,
-        };
+        return new ReactiveMapSinkAdapter(graph, keyIso, valueIso, snapshot);
     };
 }

package/dist/reactive-set-adapter.d.ts

@@ -1,4 +1,4 @@
-import { ZSet, Graph, ReactiveSet, ReactiveSetSource } from "derivation";
+import { ZSet, Graph, ReactiveSet, ReactiveSetSource, ZSetChangeInput } from "derivation";
 import { Source, Sink } from "./stream-types";
 import { Iso } from "./iso";
 export declare class ReactiveSetSourceAdapter<T> implements Source<ReactiveSet<T>> {
@@ -6,14 +6,18 @@ export declare class ReactiveSetSourceAdapter<T> implements Source<ReactiveSet<T
     private readonly iso;
     constructor(set: ReactiveSet<T>, iso: Iso<T, unknown>);
     get Snapshot(): object;
-    get LastChange(): object;
+    get LastChange(): object | null;
     get Stream(): ReactiveSet<T>;
 }
-export declare class ReactiveSetSinkAdapter<T> implements Sink<ReactiveSetSource<T>> {
+export declare class ReactiveSetSinkAdapter<T> implements Sink<ReactiveSetSource<T>, ZSetChangeInput<T>> {
     private readonly graph;
     private readonly iso;
-    constructor(graph: Graph, iso: Iso<ZSet<T>, unknown>);
-    apply(change: object, stream: ReactiveSetSource<T>): void;
-    build(): ReactiveSetSource<T>;
+    private readonly initialSet;
+    constructor(graph: Graph, iso: Iso<ZSet<T>, unknown>, snapshot: object);
+    apply(change: object, input: ZSetChangeInput<T>): void;
+    build(): {
+        stream: ReactiveSetSource<T>;
+        input: ZSetChangeInput<T>;
+    };
 }
-export declare function sink<T>(graph: Graph, iso: Iso<T, unknown>): (snapshot: object) => Sink<ReactiveSetSource<T>>;
+export declare function sink<T>(graph: Graph, iso: Iso<T, unknown>): (snapshot: object) => Sink<ReactiveSetSource<T>, ZSetChangeInput<T>>;

package/dist/reactive-set-adapter.js

@@ -1,4 +1,3 @@
-import { ZSet } from "derivation";
 import { zset, zsetToArray, compose } from "./iso";
 export class ReactiveSetSourceAdapter {
     constructor(set, iso) {
@@ -9,34 +8,32 @@ export class ReactiveSetSourceAdapter {
         return this.iso.to(this.set.snapshot);
     }
     get LastChange() {
-        return this.iso.to(this.set.changes.value);
+        const change = this.iso.to(this.set.changes.value);
+        if (change.length === 0)
+            return null;
+        return change;
     }
     get Stream() {
         return this.set;
     }
 }
 export class ReactiveSetSinkAdapter {
-    constructor(graph, iso) {
+    constructor(graph, iso, snapshot) {
         this.graph = graph;
         this.iso = iso;
+        this.initialSet = iso.from(snapshot);
     }
-    apply(change, stream) {
-        stream.push(this.iso.from(change));
+    apply(change, input) {
+        input.push(this.iso.from(change));
     }
     build() {
-        return this.graph.inputSet(new ZSet([]));
+        const stream = this.graph.inputSet(this.initialSet);
+        return { stream, input: stream.changes };
     }
 }
 export function sink(graph, iso) {
     const wholeIso = compose(zset(iso), zsetToArray());
     return (snapshot) => {
-        const set = wholeIso.from(snapshot);
-        const g = graph;
-        const adapter = new ReactiveSetSinkAdapter(g, wholeIso);
-        const stream = g.inputSet(set);
-        return {
-            apply: adapter.apply.bind(adapter),
-            build: () => stream,
-        };
+        return new ReactiveSetSinkAdapter(graph, wholeIso, snapshot);
     };
 }