@derivation/rpc 0.3.5 → 0.5.0

package/dist/shared-worker-client.js

@@ -1,25 +1,244 @@
-import { Client } from "./client.js";
-import { MessagePortTransport } from "./messageport-transport.js";
-/**
- * Create a client connected to a SharedWorker.
- *
- * @example
- * ```typescript
- * // main.ts
- * const graph = new Graph();
- * const worker = new SharedWorker('/worker.js');
- *
- * const client = createSharedWorkerClient(worker.port, {
- *   streams: {
- *     todos: setSink(graph, todoIso),
- *   },
- * }, graph);
- *
- * const todos = await client.run('todos', { filter: 'active' });
- * ```
- */
-export function createSharedWorkerClient(port, sinks, graph) {
-    const transport = new MessagePortTransport(port);
-    port.start();
-    return new Client(transport, sinks, graph);
+// src/client-message.ts
+import { z } from "zod";
+var SubscribeMessageSchema = z.object({
+  type: z.literal("subscribe"),
+  id: z.number(),
+  name: z.string(),
+  args: z.looseObject({})
+});
+var UnsubscribeMessageSchema = z.object({
+  type: z.literal("unsubscribe"),
+  id: z.number()
+});
+var HeartbeatMessageSchema = z.object({
+  type: z.literal("heartbeat")
+});
+var CallMessageSchema = z.object({
+  type: z.literal("call"),
+  id: z.number(),
+  name: z.string(),
+  args: z.looseObject({})
+});
+var PresenceMessageSchema = z.object({
+  type: z.literal("presence"),
+  data: z.looseObject({})
+});
+var ClientMessageSchema = z.discriminatedUnion("type", [
+  SubscribeMessageSchema,
+  UnsubscribeMessageSchema,
+  HeartbeatMessageSchema,
+  CallMessageSchema,
+  PresenceMessageSchema
+]);
+var ClientMessage = {
+  subscribe: (id, name, args) => ({
+    type: "subscribe",
+    id,
+    name,
+    args
+  }),
+  unsubscribe: (id) => ({
+    type: "unsubscribe",
+    id
+  }),
+  call: (id, name, args) => ({
+    type: "call",
+    id,
+    name,
+    args
+  }),
+  heartbeat: () => ({
+    type: "heartbeat"
+  }),
+  presence: (data) => ({
+    type: "presence",
+    data
+  })
+};
+
+// src/client.ts
+function changer(sink, input) {
+  return (change) => {
+    const i = input.deref();
+    if (i) {
+      sink.apply(change, i);
+    }
+  };
 }
+var Client = class {
+  constructor(transport, sinks, graph) {
+    this.transport = transport;
+    this.sinks = sinks;
+    this.graph = graph;
+    this.nextId = 1;
+    this.pendingStreams = /* @__PURE__ */ new Map();
+    this.pendingMutations = /* @__PURE__ */ new Map();
+    this.activeStreams = /* @__PURE__ */ new Map();
+    this.registry = new FinalizationRegistry(
+      ([id, name]) => {
+        console.log(`\u{1F9F9} Stream ${id} (${name}) collected \u2014 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();
+  }
+  resetHeartbeat() {
+    if (this.heartbeatTimeout) {
+      clearTimeout(this.heartbeatTimeout);
+    }
+    this.heartbeatTimeout = setTimeout(() => {
+      this.sendMessage(ClientMessage.heartbeat());
+    }, 1e4);
+  }
+  resetInactivity() {
+    if (this.inactivityTimeout) {
+      clearTimeout(this.inactivityTimeout);
+    }
+    this.inactivityTimeout = setTimeout(() => {
+      this.close();
+    }, 3e4);
+  }
+  handleMessage(message) {
+    this.resetInactivity();
+    switch (message.type) {
+      case "snapshot": {
+        console.log(`[Client] Received snapshot for stream ${message.id}`);
+        const resolve = this.pendingStreams.get(message.id);
+        if (resolve) {
+          resolve(message.snapshot);
+          this.pendingStreams.delete(message.id);
+        }
+        break;
+      }
+      case "delta": {
+        const changeCount = Object.keys(message.changes).length;
+        console.log(`[Client] Received delta with ${changeCount} changes for streams: ${Object.keys(message.changes).join(", ")}`);
+        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(`\u{1F9F9} Sink ${id} GC'd \u2014 auto-unsubscribing`);
+            this.sendMessage(ClientMessage.unsubscribe(id));
+            this.activeStreams.delete(id);
+          }
+        }
+        console.log("[Client] Stepping graph");
+        this.graph.step();
+        break;
+      }
+      case "result": {
+        console.log(`[Client] Received mutation result for call ${message.id}:`, message.success ? "success" : "error");
+        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":
+        console.log("[Client] Received 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 (e) {
+    }
+  }
+  setPresence(value) {
+    this.sendMessage(ClientMessage.presence(value));
+  }
+};
+
+// src/messageport-transport.ts
+var MessagePortTransport = class {
+  constructor(port) {
+    this.port = port;
+  }
+  send(data) {
+    console.log("[MessagePortTransport] Sending:", data.substring(0, 100) + (data.length > 100 ? "..." : ""));
+    this.port.postMessage(data);
+  }
+  onMessage(handler) {
+    this.port.onmessage = (event) => {
+      console.log("[MessagePortTransport] Received:", event.data.substring(0, 100) + (event.data.length > 100 ? "..." : ""));
+      handler(event.data);
+    };
+  }
+  onClose(handler) {
+    this.port.onmessageerror = handler;
+  }
+  close() {
+    this.port.close();
+  }
+  // MessagePort doesn't provide bufferedAmount
+  get bufferedAmount() {
+    return void 0;
+  }
+};
+
+// src/shared-worker-client.ts
+function createSharedWorkerClient(port, sinks, graph) {
+  const transport = new MessagePortTransport(port);
+  port.start();
+  return new Client(transport, sinks, graph);
+}
+export {
+  createSharedWorkerClient
+};
+//# sourceMappingURL=shared-worker-client.js.map

package/dist/shared-worker-client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client-message.ts","../src/client.ts","../src/messageport-transport.ts","../src/shared-worker-client.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const SubscribeMessageSchema = z.object({\n  type: z.literal(\"subscribe\"),\n  id: z.number(),\n  name: z.string(),\n  args: z.looseObject({}),\n});\nexport type SubscribeMessage = z.infer<typeof SubscribeMessageSchema>;\n\nexport const UnsubscribeMessageSchema = z.object({\n  type: z.literal(\"unsubscribe\"),\n  id: z.number(),\n});\nexport type UnsubscribeMessage = z.infer<typeof UnsubscribeMessageSchema>;\n\nexport const HeartbeatMessageSchema = z.object({\n  type: z.literal(\"heartbeat\"),\n});\nexport type HeartbeatMessage = z.infer<typeof HeartbeatMessageSchema>;\n\nexport const CallMessageSchema = z.object({\n  type: z.literal(\"call\"),\n  id: z.number(),\n  name: z.string(),\n  args: z.looseObject({}),\n});\nexport type CallMessage = z.infer<typeof CallMessageSchema>;\n\nexport const PresenceMessageSchema = z.object({\n  type: z.literal(\"presence\"),\n  data: z.looseObject({}),\n});\nexport type PresenceMessage = z.infer<typeof PresenceMessageSchema>;\n\nexport const ClientMessageSchema = z.discriminatedUnion(\"type\", [\n  SubscribeMessageSchema,\n  UnsubscribeMessageSchema,\n  HeartbeatMessageSchema,\n  CallMessageSchema,\n  PresenceMessageSchema,\n]);\nexport type ClientMessage = z.infer<typeof ClientMessageSchema>;\n\nexport function parseClientMessage(data: unknown): ClientMessage {\n  return ClientMessageSchema.parse(data);\n}\n\nexport const ClientMessage = {\n  subscribe: (\n    id: number,\n    name: string,\n    args: object,\n  ): SubscribeMessage => ({\n    type: \"subscribe\",\n    id,\n    name,\n    args: args as Record<string, unknown>,\n  }),\n  unsubscribe: (id: number): UnsubscribeMessage => ({\n    type: \"unsubscribe\",\n    id,\n  }),\n  call: (\n    id: number,\n    name: string,\n    args: object,\n  ): CallMessage => ({\n    type: \"call\",\n    id,\n    name,\n    args: args as Record<string, unknown>,\n  }),\n  heartbeat: (): HeartbeatMessage => ({\n    type: \"heartbeat\",\n  }),\n  presence: (data: object): PresenceMessage => ({\n    type: \"presence\",\n    data: data as Record<string, unknown>,\n  }),\n};\n","import { ClientMessage } from \"./client-message.js\";\nimport { ServerMessage } from \"./server-message.js\";\nimport type { Graph } from \"derivation\";\nimport type {\n  Sink,\n  StreamSinks,\n  RPCDefinition,\n  MutationResult,\n} from \"./stream-types.js\";\nimport { Transport } from \"./transport.js\";\n\nfunction changer<T extends object, I extends object>(\n  sink: Sink<T, I>,\n  input: WeakRef<I>,\n): (change: object) => void {\n  return (change) => {\n    const i = input.deref();\n    if (i) {\n      sink.apply(change, i);\n    }\n  };\n}\n\nexport class Client<Defs extends RPCDefinition> {\n  private nextId = 1;\n  private pendingStreams = new Map<number, (snapshot: object) => void>();\n  private pendingMutations = new Map<\n    number,\n    (result: MutationResult<unknown>) => void\n  >();\n  private activeStreams = new Map<number, (change: object) => void>();\n  private heartbeatTimeout: NodeJS.Timeout | undefined;\n  private inactivityTimeout: NodeJS.Timeout | undefined;\n\n  private registry = new FinalizationRegistry<[number, string]>(\n    ([id, name]) => {\n      console.log(`🧹 Stream ${id} (${name}) collected — unsubscribing`);\n      this.sendMessage(ClientMessage.unsubscribe(id));\n      this.activeStreams.delete(id);\n    },\n  );\n\n  private resetHeartbeat() {\n    if (this.heartbeatTimeout) {\n      clearTimeout(this.heartbeatTimeout);\n    }\n\n    this.heartbeatTimeout = setTimeout(() => {\n      this.sendMessage(ClientMessage.heartbeat());\n    }, 10_000);\n  }\n\n  private resetInactivity() {\n    if (this.inactivityTimeout) {\n      clearTimeout(this.inactivityTimeout);\n    }\n\n    this.inactivityTimeout = setTimeout(() => {\n      this.close();\n    }, 30_000);\n  }\n\n  constructor(\n    private transport: Transport,\n    private sinks: StreamSinks<Defs[\"streams\"]>,\n    private graph: Graph,\n  ) {\n    this.transport.onMessage((data: string) => {\n      const message = JSON.parse(data) as ServerMessage;\n      this.handleMessage(message);\n    });\n    this.resetHeartbeat();\n    this.resetInactivity();\n  }\n\n  private handleMessage(message: ServerMessage) {\n    this.resetInactivity();\n\n    switch (message.type) {\n      case \"snapshot\": {\n        console.log(`[Client] Received snapshot for stream ${message.id}`);\n        const resolve = this.pendingStreams.get(message.id);\n        if (resolve) {\n          resolve(message.snapshot as object);\n          this.pendingStreams.delete(message.id);\n        }\n        break;\n      }\n      case \"delta\": {\n        const changeCount = Object.keys(message.changes).length;\n        console.log(`[Client] Received delta with ${changeCount} changes for streams: ${Object.keys(message.changes).join(\", \")}`);\n        for (const [idStr, change] of Object.entries(message.changes)) {\n          const id = Number(idStr);\n          const sink = this.activeStreams.get(id);\n\n          if (sink && change && typeof change === \"object\") {\n            sink(change);\n          } else if (!sink) {\n            console.log(`🧹 Sink ${id} GC'd — auto-unsubscribing`);\n            this.sendMessage(ClientMessage.unsubscribe(id));\n            this.activeStreams.delete(id);\n          }\n        }\n        console.log(\"[Client] Stepping graph\");\n        this.graph.step();\n        break;\n      }\n      case \"result\": {\n        console.log(`[Client] Received mutation result for call ${message.id}:`, message.success ? \"success\" : \"error\");\n        const resolve = this.pendingMutations.get(message.id);\n        if (resolve) {\n          if (message.success) {\n            resolve({ success: true, value: message.value });\n          } else {\n            resolve({\n              success: false,\n              error: message.error || \"Unknown error\",\n            });\n          }\n          this.pendingMutations.delete(message.id);\n        }\n        break;\n      }\n      case \"heartbeat\":\n        console.log(\"[Client] Received heartbeat\");\n        break;\n    }\n  }\n\n  private sendMessage(message: ClientMessage) {\n    this.resetHeartbeat();\n    this.transport.send(JSON.stringify(message));\n  }\n\n  async run<Key extends keyof Defs[\"streams\"]>(\n    key: Key,\n    args: Defs[\"streams\"][Key][\"args\"],\n  ): Promise<Defs[\"streams\"][Key][\"returnType\"]> {\n    console.log(\n      `Running stream ${String(key)} with args ${JSON.stringify(args)}`,\n    );\n    const id = this.nextId++;\n\n    this.sendMessage(ClientMessage.subscribe(id, String(key), args));\n\n    const snapshot = await new Promise<object>((resolve) => {\n      this.pendingStreams.set(id, resolve);\n    });\n\n    const endpoint = this.sinks[key];\n    const sinkAdapter = endpoint(snapshot);\n    const { stream, input } = sinkAdapter.build();\n    const inputRef = new WeakRef(input);\n    this.activeStreams.set(id, changer(sinkAdapter, inputRef));\n    this.registry.register(input, [id, String(key)]);\n\n    return stream;\n  }\n\n  async call<Key extends keyof Defs[\"mutations\"]>(\n    key: Key,\n    args: Defs[\"mutations\"][Key][\"args\"],\n  ): Promise<MutationResult<Defs[\"mutations\"][Key][\"result\"]>> {\n    console.log(\n      `Calling mutation ${String(key)} with args ${JSON.stringify(args)}`,\n    );\n    const id = this.nextId++;\n\n    this.sendMessage(\n      ClientMessage.call(id, String(key), args as Record<string, unknown>),\n    );\n\n    const result = await new Promise<\n      MutationResult<Defs[\"mutations\"][Key][\"result\"]>\n    >((resolve) => {\n      this.pendingMutations.set(\n        id,\n        resolve as (result: MutationResult<unknown>) => void,\n      );\n    });\n\n    return result;\n  }\n\n  close() {\n    clearTimeout(this.heartbeatTimeout);\n    clearTimeout(this.inactivityTimeout);\n    try {\n      this.transport.close();\n    } catch {}\n  }\n\n  setPresence(value: Record<string, unknown>): void {\n    this.sendMessage(ClientMessage.presence(value));\n  }\n}\n","import { Transport } from \"./transport.js\";\n\n/**\n * Transport implementation for MessagePort (SharedWorker communication).\n */\nexport class MessagePortTransport implements Transport {\n  constructor(private port: MessagePort) {}\n\n  send(data: string): void {\n    console.log(\"[MessagePortTransport] Sending:\", data.substring(0, 100) + (data.length > 100 ? \"...\" : \"\"));\n    this.port.postMessage(data);\n  }\n\n  onMessage(handler: (data: string) => void): void {\n    this.port.onmessage = (event: MessageEvent) => {\n      console.log(\"[MessagePortTransport] Received:\", event.data.substring(0, 100) + (event.data.length > 100 ? \"...\" : \"\"));\n      handler(event.data);\n    };\n  }\n\n  onClose(handler: () => void): void {\n    // MessagePort doesn't have a reliable close event\n    // We'll use messageerror as a signal, though it's not perfect\n    this.port.onmessageerror = handler;\n  }\n\n  close(): void {\n    this.port.close();\n  }\n\n  // MessagePort doesn't provide bufferedAmount\n  get bufferedAmount(): undefined {\n    return undefined;\n  }\n}\n","import { Graph } from \"derivation\";\nimport { Client } from \"./client.js\";\nimport { MessagePortTransport } from \"./messageport-transport.js\";\nimport { StreamSinks, RPCDefinition } from \"./stream-types.js\";\n\n/**\n * Create a client connected to a SharedWorker.\n *\n * @example\n * ```typescript\n * // main.ts\n * const graph = new Graph();\n * const worker = new SharedWorker('/worker.js');\n *\n * const client = createSharedWorkerClient(worker.port, {\n *   streams: {\n *     todos: setSink(graph, todoIso),\n *   },\n * }, graph);\n *\n * const todos = await client.run('todos', { filter: 'active' });\n * ```\n */\nexport function createSharedWorkerClient<Defs extends RPCDefinition>(\n  port: MessagePort,\n  sinks: StreamSinks<Defs[\"streams\"]>,\n  graph: Graph,\n): Client<Defs> {\n  const transport = new MessagePortTransport(port);\n  port.start();\n  return new Client<Defs>(transport, sinks, graph);\n}\n"],"mappings":"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","names":[]}

package/dist/shared-worker-server.cjs

@@ -0,0 +1,363 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/shared-worker-server.ts
+var shared_worker_server_exports = {};
+__export(shared_worker_server_exports, {
+  setupSharedWorker: () => setupSharedWorker
+});
+module.exports = __toCommonJS(shared_worker_server_exports);
+
+// src/client-message.ts
+var import_zod = require("zod");
+var SubscribeMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("subscribe"),
+  id: import_zod.z.number(),
+  name: import_zod.z.string(),
+  args: import_zod.z.looseObject({})
+});
+var UnsubscribeMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("unsubscribe"),
+  id: import_zod.z.number()
+});
+var HeartbeatMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("heartbeat")
+});
+var CallMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("call"),
+  id: import_zod.z.number(),
+  name: import_zod.z.string(),
+  args: import_zod.z.looseObject({})
+});
+var PresenceMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("presence"),
+  data: import_zod.z.looseObject({})
+});
+var ClientMessageSchema = import_zod.z.discriminatedUnion("type", [
+  SubscribeMessageSchema,
+  UnsubscribeMessageSchema,
+  HeartbeatMessageSchema,
+  CallMessageSchema,
+  PresenceMessageSchema
+]);
+function parseClientMessage(data) {
+  return ClientMessageSchema.parse(data);
+}
+
+// src/server-message.ts
+var import_zod2 = require("zod");
+var HeartbeatMessageSchema2 = import_zod2.z.object({
+  type: import_zod2.z.literal("heartbeat")
+});
+var SubscribedSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("snapshot"),
+  id: import_zod2.z.number(),
+  snapshot: import_zod2.z.unknown()
+});
+var DeltaMessageSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("delta"),
+  changes: import_zod2.z.record(import_zod2.z.number(), import_zod2.z.unknown())
+});
+var ResultMessageSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("result"),
+  id: import_zod2.z.number(),
+  success: import_zod2.z.boolean(),
+  value: import_zod2.z.unknown().optional(),
+  error: import_zod2.z.string().optional()
+});
+var ServerMessageSchema = import_zod2.z.discriminatedUnion("type", [
+  HeartbeatMessageSchema2,
+  SubscribedSchema,
+  DeltaMessageSchema,
+  ResultMessageSchema
+]);
+var ServerMessage = {
+  heartbeat: () => ({
+    type: "heartbeat"
+  }),
+  subscribed: (id, snapshot) => ({
+    type: "snapshot",
+    id,
+    snapshot
+  }),
+  delta: (changes) => ({
+    type: "delta",
+    changes
+  }),
+  resultSuccess: (id, value) => ({
+    type: "result",
+    id,
+    success: true,
+    value
+  }),
+  resultError: (id, error) => ({
+    type: "result",
+    id,
+    success: false,
+    error
+  })
+};
+
+// src/shared-worker-client-handler.ts
+var SharedWorkerClientHandler = class {
+  constructor(transport, context, streamEndpoints, mutationEndpoints, presenceHandler) {
+    this.closed = false;
+    this.streams = /* @__PURE__ */ new Map();
+    this.transport = transport;
+    this.context = context;
+    this.streamEndpoints = streamEndpoints;
+    this.mutationEndpoints = mutationEndpoints;
+    this.presenceHandler = presenceHandler;
+    console.log("new client connected");
+    this.transport.onMessage((data) => this.handleMessage(data));
+    this.transport.onClose(() => this.handleDisconnect());
+  }
+  handleMessage(message) {
+    let data;
+    try {
+      data = JSON.parse(message);
+    } catch (e) {
+      console.error("Invalid JSON received:", message);
+      return this.close();
+    }
+    let parsed;
+    try {
+      parsed = parseClientMessage(data);
+    } catch (error) {
+      console.error("Invalid client message:", error);
+      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 !== void 0) {
+          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) {
+      console.log(`[ClientHandler] Sending delta with ${Object.keys(changes).length} changes for streams: ${Object.keys(changes).join(", ")}`);
+      this.sendMessage(ServerMessage.delta(changes));
+    }
+  }
+  sendMessage(message) {
+    if (this.closed) return;
+    this.transport.send(JSON.stringify(message));
+  }
+  handleDisconnect() {
+    this.close();
+  }
+  close() {
+    if (this.closed) return;
+    console.log("[ClientHandler] Closing client connection");
+    this.closed = true;
+    if (this.presenceHandler && this.currentPresence) {
+      this.presenceHandler.remove(this.currentPresence);
+    }
+    console.log(`[ClientHandler] Cleaning up ${this.streams.size} active streams`);
+    this.streams.clear();
+    try {
+      this.transport.close();
+    } catch (e) {
+    }
+  }
+};
+
+// src/weak-list.ts
+var WeakList = class {
+  constructor() {
+    this.items = [];
+  }
+  add(value) {
+    this.items.push(new WeakRef(value));
+  }
+  *[Symbol.iterator]() {
+    const newItems = [];
+    for (const ref of this.items) {
+      const value = ref.deref();
+      if (value !== void 0) {
+        yield value;
+        newItems.push(ref);
+      }
+    }
+    this.items = newItems;
+  }
+};
+
+// src/messageport-transport.ts
+var MessagePortTransport = class {
+  constructor(port) {
+    this.port = port;
+  }
+  send(data) {
+    console.log("[MessagePortTransport] Sending:", data.substring(0, 100) + (data.length > 100 ? "..." : ""));
+    this.port.postMessage(data);
+  }
+  onMessage(handler) {
+    this.port.onmessage = (event) => {
+      console.log("[MessagePortTransport] Received:", event.data.substring(0, 100) + (event.data.length > 100 ? "..." : ""));
+      handler(event.data);
+    };
+  }
+  onClose(handler) {
+    this.port.onmessageerror = handler;
+  }
+  close() {
+    this.port.close();
+  }
+  // MessagePort doesn't provide bufferedAmount
+  get bufferedAmount() {
+    return void 0;
+  }
+};
+
+// src/shared-worker-server.ts
+function setupSharedWorker(options, graph) {
+  const { streams, mutations, createContext, presenceHandler } = options;
+  const clients = new WeakList();
+  graph.afterStep(() => {
+    console.log("[SharedWorker] Broadcasting deltas to clients");
+    for (const client of clients) {
+      client.handleStep();
+    }
+  });
+  const globalScope = self;
+  globalScope.onconnect = (event) => {
+    console.log("[SharedWorker] New client connecting...");
+    const port = event.ports[0];
+    const messageBuffer = [];
+    let client = null;
+    const tempMessageHandler = (e) => {
+      console.log("[SharedWorker] Buffering message during setup:", e.data);
+      messageBuffer.push(e.data);
+    };
+    port.onmessage = tempMessageHandler;
+    Promise.resolve(createContext(port)).then((context) => {
+      console.log("[SharedWorker] Context created, setting up client handler");
+      const transport = new MessagePortTransport(port);
+      client = new SharedWorkerClientHandler(
+        transport,
+        context,
+        streams,
+        mutations,
+        presenceHandler
+      );
+      clients.add(client);
+      console.log("[SharedWorker] Client handler registered");
+      console.log(`[SharedWorker] Processing ${messageBuffer.length} buffered messages`);
+      for (const msg of messageBuffer) {
+        client.handleMessage(msg);
+      }
+      messageBuffer.length = 0;
+      port.start();
+      console.log("[SharedWorker] Client connection ready");
+    }).catch((err) => {
+      console.error("[SharedWorker] Error creating context:", err);
+      port.close();
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupSharedWorker
+});
+//# sourceMappingURL=shared-worker-server.cjs.map