@livestore/webmesh 0.0.0-snapshot-1d99fea7d2ce2c7a5d9ed0a3752f8a7bda6bc3db

package/src/node.ts

@@ -0,0 +1,408 @@
+import { LS_DEV, shouldNeverHappen } from '@livestore/utils'
+import type { Scope } from '@livestore/utils/effect'
+import {
+  Cause,
+  Duration,
+  Effect,
+  Fiber,
+  Option,
+  PubSub,
+  Queue,
+  Schema,
+  Stream,
+  WebChannel,
+} from '@livestore/utils/effect'
+
+import { makeMessageChannel } from './channel/message-channel.js'
+import { makeProxyChannel } from './channel/proxy-channel.js'
+import type { ChannelKey, MeshNodeName, MessageQueueItem, ProxyQueueItem } from './common.js'
+import { ConnectionAlreadyExistsError, packetAsOtelAttributes } from './common.js'
+import * as MeshSchema from './mesh-schema.js'
+import { TimeoutSet } from './utils.js'
+
+type ConnectionChannel = WebChannel.WebChannel<typeof MeshSchema.Packet.Type, typeof MeshSchema.Packet.Type>
+
+export interface MeshNode {
+  nodeName: MeshNodeName
+
+  connectionKeys: Effect.Effect<Set<MeshNodeName>>
+
+  debug: {
+    print: () => void
+  }
+
+  /**
+   * Manually adds a connection to get connected to the network of nodes with an existing WebChannel.
+   *
+   * Assumptions about the WebChannel connection:
+   * - 1:1 connection
+   * - Queues messages internally to never drop messages
+   * - Automatically reconnects
+   * - Ideally supports transferables
+   */
+  addConnection: {
+    (options: {
+      target: MeshNodeName
+      connectionChannel: ConnectionChannel
+      replaceIfExists: true
+    }): Effect.Effect<void, never, Scope.Scope>
+    (options: {
+      target: MeshNodeName
+      connectionChannel: ConnectionChannel
+      replaceIfExists?: boolean
+    }): Effect.Effect<void, ConnectionAlreadyExistsError, Scope.Scope>
+  }
+
+  removeConnection: (targetNodeName: MeshNodeName) => Effect.Effect<void, Cause.NoSuchElementException>
+
+  /**
+   * Tries to broker a MessageChannel connection between the nodes, otherwise will proxy messages via hop-nodes
+   *
+   * For a channel to successfully open, both sides need to have a connection and call `makeChannel`
+   */
+  makeChannel: <MsgListen, MsgSend>(args: {
+    target: MeshNodeName
+    /**
+     * A name for the channel (same from both sides).
+     * Needs to be unique in the context of the 2 connected nodes.
+     */
+    channelName: string
+    schema:
+      | Schema.Schema<MsgListen | MsgSend, any>
+      | {
+          listen: Schema.Schema<MsgListen, any>
+          send: Schema.Schema<MsgSend, any>
+        }
+    /**
+     * If possible, prefer using a MessageChannel with transferables (i.e. transferring memory instead of copying it).
+     */
+    mode: 'messagechannel' | 'proxy'
+    /**
+     * Amount of time before we consider a channel creation failed and retry when a new connection is available
+     *
+     * @default 1 second
+     */
+    timeout?: Duration.DurationInput
+  }) => Effect.Effect<WebChannel.WebChannel<MsgListen, MsgSend>, never, Scope.Scope>
+}
+
+export const makeMeshNode = (nodeName: MeshNodeName): Effect.Effect<MeshNode, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const connectionChannels = new Map<
+      MeshNodeName,
+      { channel: ConnectionChannel; listenFiber: Fiber.RuntimeFiber<void> }
+    >()
+
+    // To avoid unbounded memory growth, we automatically forget about packet ids after a while
+    const handledPacketIds = new TimeoutSet<string>({ timeout: Duration.minutes(1) })
+
+    const newConnectionAvailablePubSub = yield* PubSub.unbounded<MeshNodeName>().pipe(
+      Effect.acquireRelease(PubSub.shutdown),
+    )
+
+    // const proxyPacketsToProcess = yield* Queue.unbounded<ProxyQueueItem>().pipe(Effect.acquireRelease(Queue.shutdown))
+    // const messagePacketsToProcess = yield* Queue.unbounded<MessageQueueItem>().pipe(
+    //   Effect.acquireRelease(Queue.shutdown),
+    // )
+
+    const channelMap = new Map<
+      ChannelKey,
+      {
+        queue: Queue.Queue<MessageQueueItem | ProxyQueueItem>
+        /** This reference is only kept for debugging purposes */
+        debugInfo:
+          | {
+              channel: WebChannel.WebChannel<any, any>
+              target: MeshNodeName
+            }
+          | undefined
+      }
+    >()
+
+    const checkTransferableConnections = (packet: typeof MeshSchema.MessageChannelPacket.Type) => {
+      if (
+        (packet._tag === 'MessageChannelRequest' &&
+          (connectionChannels.size === 0 ||
+            // Either if direct connection does not support transferables ...
+            connectionChannels.get(packet.target)?.channel.supportsTransferables === false)) ||
+        // ... or if no forward-connections support transferables
+        ![...connectionChannels.values()].some((c) => c.channel.supportsTransferables === true)
+      ) {
+        return MeshSchema.MessageChannelResponseNoTransferables.make({
+          reqId: packet.id,
+          channelName: packet.channelName,
+          // NOTE for now we're "pretending" that the message is coming from the target node
+          // even though we're already handling it here.
+          // TODO we should clean this up at some point
+          source: packet.target,
+          // source: nodeName,
+          target: packet.source,
+          remainingHops: packet.hops,
+          hops: [],
+        })
+      }
+    }
+
+    const sendPacket = (packet: typeof MeshSchema.Packet.Type) =>
+      Effect.gen(function* () {
+        if (Schema.is(MeshSchema.NetworkConnectionAdded)(packet)) {
+          yield* Effect.spanEvent('NetworkConnectionAdded', { packet, nodeName })
+          yield* PubSub.publish(newConnectionAvailablePubSub, packet.target)
+
+          const connectionsToForwardTo = Array.from(connectionChannels)
+            .filter(([name]) => name !== packet.source)
+            .map(([_, con]) => con.channel)
+
+          yield* Effect.forEach(connectionsToForwardTo, (con) => con.send(packet), { concurrency: 'unbounded' })
+          return
+        }
+
+        // We have a direct connection to the target node
+        if (connectionChannels.has(packet.target)) {
+          const connectionChannel = connectionChannels.get(packet.target)!.channel
+          const hops = packet.source === nodeName ? [] : [...packet.hops, nodeName]
+          yield* connectionChannel.send({ ...packet, hops })
+        }
+        // In this case we have an expected route back we should follow
+        // eslint-disable-next-line unicorn/no-negated-condition
+        else if (packet.remainingHops !== undefined) {
+          const hopTarget =
+            packet.remainingHops[0] ?? shouldNeverHappen(`${nodeName}: Expected remaining hops for packet`, packet)
+          const connectionChannel = connectionChannels.get(hopTarget)?.channel
+
+          if (connectionChannel === undefined) {
+            yield* Effect.logWarning(
+              `${nodeName}: Expected to find hop target ${hopTarget} in connections. Dropping packet.`,
+              packet,
+            )
+            return
+          }
+
+          yield* connectionChannel.send({
+            ...packet,
+            remainingHops: packet.remainingHops.slice(1),
+            hops: [...packet.hops, nodeName],
+          })
+        }
+        // No route found, forward to all connections
+        else {
+          const hops = packet.source === nodeName ? [] : [...packet.hops, nodeName]
+
+          // Optimization: filter out connection where packet just came from
+          const connectionsToForwardTo = Array.from(connectionChannels)
+            .filter(([name]) => name !== packet.source)
+            .map(([_, con]) => con.channel)
+
+          // TODO if hops-depth=0, we should fail right away with no route found
+          if (hops.length === 0 && connectionsToForwardTo.length === 0 && LS_DEV) {
+            console.log(nodeName, 'no route found', packet._tag, 'TODO handle better')
+            // TODO return a expected failure
+          }
+
+          const packetToSend = { ...packet, hops }
+          // console.debug(nodeName, 'sendPacket:forwarding', packetToSend)
+
+          yield* Effect.forEach(connectionsToForwardTo, (con) => con.send(packetToSend), { concurrency: 'unbounded' })
+        }
+      }).pipe(
+        Effect.withSpan(`sendPacket:${packet._tag}:${packet.source}→${packet.target}`, {
+          attributes: packetAsOtelAttributes(packet),
+        }),
+        Effect.orDie,
+      )
+
+    const addConnection: MeshNode['addConnection'] = ({
+      target: targetNodeName,
+      connectionChannel,
+      replaceIfExists = false,
+    }) =>
+      Effect.gen(function* () {
+        if (connectionChannels.has(targetNodeName)) {
+          if (replaceIfExists) {
+            yield* removeConnection(targetNodeName).pipe(Effect.orDie)
+            // console.log('interrupting', targetNodeName)
+            // yield* Fiber.interrupt(connectionChannels.get(targetNodeName)!.listenFiber)
+          } else {
+            return yield* new ConnectionAlreadyExistsError({ target: targetNodeName })
+          }
+        }
+
+        // TODO use a priority queue instead to prioritize network-changes/connection-requests over payloads
+        const listenFiber = yield* connectionChannel.listen.pipe(
+          Stream.flatten(),
+          Stream.tap((message) =>
+            Effect.gen(function* () {
+              const packet = yield* Schema.decodeUnknown(MeshSchema.Packet)(message)
+
+              // console.debug(nodeName, 'received', packet._tag, packet.source, packet.target)
+
+              if (handledPacketIds.has(packet.id)) return
+              handledPacketIds.add(packet.id)
+
+              if (packet._tag === 'NetworkConnectionAdded') {
+                yield* sendPacket(packet)
+              } else if (packet.target === nodeName) {
+                const channelKey = `${packet.source}-${packet.channelName}` satisfies ChannelKey
+
+                if (!channelMap.has(channelKey)) {
+                  const queue = yield* Queue.unbounded<MessageQueueItem | ProxyQueueItem>().pipe(
+                    Effect.acquireRelease(Queue.shutdown),
+                  )
+                  channelMap.set(channelKey, { queue, debugInfo: undefined })
+                }
+
+                const queue = channelMap.get(channelKey)!.queue
+
+                const respondToSender = (outgoingPacket: typeof MeshSchema.Packet.Type) =>
+                  connectionChannel
+                    .send(outgoingPacket)
+                    .pipe(
+                      Effect.withSpan(
+                        `respondToSender:${outgoingPacket._tag}:${outgoingPacket.source}→${outgoingPacket.target}`,
+                        { attributes: packetAsOtelAttributes(outgoingPacket) },
+                      ),
+                      Effect.orDie,
+                    )
+
+                if (Schema.is(MeshSchema.ProxyChannelPacket)(packet)) {
+                  yield* Queue.offer(queue, { packet, respondToSender })
+                } else if (Schema.is(MeshSchema.MessageChannelPacket)(packet)) {
+                  yield* Queue.offer(queue, { packet, respondToSender })
+                }
+              } else {
+                if (Schema.is(MeshSchema.MessageChannelPacket)(packet)) {
+                  const noTransferableResponse = checkTransferableConnections(packet)
+                  if (noTransferableResponse !== undefined) {
+                    yield* Effect.spanEvent(`No transferable connections found for ${packet.source}→${packet.target}`)
+                    return yield* connectionChannel.send(noTransferableResponse).pipe(
+                      Effect.withSpan(`sendNoTransferableResponse:${packet.source}→${packet.target}`, {
+                        attributes: packetAsOtelAttributes(noTransferableResponse),
+                      }),
+                    )
+                  }
+                }
+
+                yield* sendPacket(packet)
+              }
+            }),
+          ),
+          Stream.runDrain,
+          Effect.orDie,
+          Effect.tapCauseLogPretty,
+          Effect.forkScoped,
+        )
+
+        connectionChannels.set(targetNodeName, { channel: connectionChannel, listenFiber })
+
+        const connectionAddedPacket = MeshSchema.NetworkConnectionAdded.make({
+          source: nodeName,
+          target: targetNodeName,
+        })
+        yield* sendPacket(connectionAddedPacket).pipe(Effect.ignoreLogged)
+      }).pipe(
+        Effect.withSpan(`addConnection:${nodeName}→${targetNodeName}`, {
+          attributes: { supportsTransferables: connectionChannel.supportsTransferables },
+        }),
+      ) as any // any-cast needed for error/never overload
+
+    const removeConnection: MeshNode['removeConnection'] = (targetNodeName) =>
+      Effect.gen(function* () {
+        if (!connectionChannels.has(targetNodeName)) {
+          yield* new Cause.NoSuchElementException(`No connection found for ${targetNodeName}`)
+        }
+
+        yield* Fiber.interrupt(connectionChannels.get(targetNodeName)!.listenFiber)
+
+        connectionChannels.delete(targetNodeName)
+      })
+
+    // TODO add heartbeat to detect dead connections (for both e2e and proxying)
+    // TODO when a channel is established in the same origin, we can use a weblock to detect disconnects
+    const makeChannel: MeshNode['makeChannel'] = ({
+      target,
+      channelName,
+      schema: inputSchema,
+      // TODO in the future we could have a mode that prefers messagechannels and then falls back to proxies if needed
+      mode,
+      timeout = Duration.seconds(1),
+    }) =>
+      Effect.gen(function* () {
+        const schema = WebChannel.mapSchema(inputSchema)
+        const channelKey = `${target}-${channelName}` satisfies ChannelKey
+
+        if (!channelMap.has(channelKey)) {
+          const queue = yield* Queue.unbounded<MessageQueueItem | ProxyQueueItem>().pipe(
+            Effect.acquireRelease(Queue.shutdown),
+          )
+          channelMap.set(channelKey, { queue, debugInfo: undefined })
+        }
+
+        const queue = channelMap.get(channelKey)!.queue as Queue.Queue<any>
+
+        yield* Effect.addFinalizer(() => Effect.sync(() => channelMap.delete(channelKey)))
+
+        if (mode === 'messagechannel') {
+          // console.debug(nodeName, 'message mode', modeRef.current)
+
+          // NOTE already retries internally when transferables are required
+          const channel = yield* makeMessageChannel({
+            nodeName,
+            queue,
+            newConnectionAvailablePubSub,
+            target,
+            channelName,
+            schema,
+            sendPacket,
+            checkTransferableConnections,
+          })
+
+          channelMap.set(channelKey, { queue, debugInfo: { channel, target } })
+
+          return channel
+        } else {
+          const channel = yield* makeProxyChannel({
+            nodeName,
+            newConnectionAvailablePubSub,
+            target,
+            channelName,
+            schema,
+            queue,
+            sendPacket,
+          })
+
+          channelMap.set(channelKey, { queue, debugInfo: { channel, target } })
+
+          return channel
+        }
+      }).pipe(
+        Effect.withSpanScoped(`makeChannel:${nodeName}→${target}(${channelName})`, {
+          attributes: { target, channelName, mode, timeout },
+        }),
+        Effect.annotateLogs({ nodeName }),
+      )
+
+    const connectionKeys: MeshNode['connectionKeys'] = Effect.sync(() => new Set(connectionChannels.keys()))
+
+    const debug: MeshNode['debug'] = {
+      print: () => {
+        console.log('Connections:', connectionChannels.size)
+        for (const [key, value] of connectionChannels) {
+          console.log(`  ${key}: supportsTransferables=${value.channel.supportsTransferables}`)
+        }
+
+        console.log('Channels:', channelMap.size)
+        for (const [key, value] of channelMap) {
+          console.log(
+            `  ${key}: \n`,
+            `    Queue: ${value.queue.unsafeSize().pipe(Option.getOrUndefined)}`,
+            value.queue,
+            '\n',
+            `    Channel: target=${value.debugInfo?.target} supportsTransferables=${value.debugInfo?.channel.supportsTransferables}`,
+            value.debugInfo?.channel,
+          )
+        }
+      },
+    }
+
+    return { nodeName, addConnection, removeConnection, makeChannel, connectionKeys, debug } satisfies MeshNode
+  }).pipe(Effect.withSpan(`makeMeshNode:${nodeName}`))

package/src/utils.ts

@@ -0,0 +1,47 @@
+/* eslint-disable prefer-arrow/prefer-arrow-functions */
+import { Duration } from '@livestore/utils/effect'
+
+/**
+ * A set of values that expire after a given timeout
+ * The timeout cleanup is performed in a batched way to avoid excessive setTimeout calls
+ */
+export class TimeoutSet<V> {
+  private values = new Map<V, number>()
+  private timeoutHandle: NodeJS.Timeout | undefined
+  private readonly timeoutMs: number
+
+  constructor({ timeout }: { timeout: Duration.DurationInput }) {
+    this.timeoutMs = Duration.toMillis(timeout)
+  }
+
+  add(value: V): void {
+    this.values.set(value, Date.now())
+    this.scheduleCleanup()
+  }
+
+  has(value: V): boolean {
+    return this.values.has(value)
+  }
+
+  delete(value: V): void {
+    this.values.delete(value)
+  }
+
+  private scheduleCleanup(): void {
+    if (this.timeoutHandle === undefined) {
+      this.timeoutHandle = setTimeout(() => {
+        this.cleanup()
+        this.timeoutHandle = undefined
+      }, this.timeoutMs)
+    }
+  }
+
+  private cleanup(): void {
+    const now = Date.now()
+    for (const [value, timestamp] of this.values.entries()) {
+      if (now - timestamp >= this.timeoutMs) {
+        this.values.delete(value)
+      }
+    }
+  }
+}

package/src/websocket-connection.ts

@@ -0,0 +1,158 @@
+import type { Scope } from '@livestore/utils/effect'
+import {
+  Deferred,
+  Effect,
+  Either,
+  FiberHandle,
+  Queue,
+  Schedule,
+  Schema,
+  Stream,
+  WebChannel,
+  WebSocket,
+} from '@livestore/utils/effect'
+import type NodeWebSocket from 'ws'
+
+import * as MeshSchema from './mesh-schema.js'
+import type { MeshNode } from './node.js'
+
+export class WSConnectionInit extends Schema.TaggedStruct('WSConnectionInit', {
+  from: Schema.String,
+}) {}
+
+export class WSConnectionPayload extends Schema.TaggedStruct('WSConnectionPayload', {
+  from: Schema.String,
+  payload: Schema.Any,
+}) {}
+
+export class WSConnectionMessage extends Schema.Union(WSConnectionInit, WSConnectionPayload) {}
+
+export const MessageMsgPack = Schema.MsgPack(WSConnectionMessage)
+
+export type SocketType =
+  | {
+      _tag: 'leaf'
+      from: string
+    }
+  | {
+      _tag: 'relay'
+    }
+
+export const connectViaWebSocket = ({
+  node,
+  url,
+  reconnect = Schedule.exponential(100),
+}: {
+  node: MeshNode
+  url: string
+  reconnect?: Schedule.Schedule<unknown> | false
+}): Effect.Effect<void, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const fiberHandle = yield* FiberHandle.make()
+
+    const connect = Effect.gen(function* () {
+      const socket = yield* WebSocket.makeWebSocket({ url, reconnect })
+
+      // NOTE we want to use `runFork` here so this Effect is not part of the fiber that will be interrupted
+      socket.addEventListener('close', () => FiberHandle.run(fiberHandle, connect).pipe(Effect.runFork))
+
+      const connection = yield* makeWebSocketConnection(socket, { _tag: 'leaf', from: node.nodeName })
+
+      yield* node.addConnection({ target: 'ws', connectionChannel: connection.webChannel, replaceIfExists: true })
+
+      yield* Effect.never
+    }).pipe(Effect.scoped, Effect.withSpan('@livestore/webmesh:websocket-connection:connect'))
+
+    yield* FiberHandle.run(fiberHandle, connect)
+  })
+
+export const makeWebSocketConnection = (
+  socket: globalThis.WebSocket | NodeWebSocket.WebSocket,
+  socketType: SocketType,
+): Effect.Effect<
+  {
+    webChannel: WebChannel.WebChannel<typeof MeshSchema.Packet.Type, typeof MeshSchema.Packet.Type>
+    from: string
+  },
+  never,
+  Scope.Scope
+> =>
+  Effect.gen(function* () {
+    socket.binaryType = 'arraybuffer'
+
+    const fromDeferred = yield* Deferred.make<string>()
+
+    yield* Stream.fromEventListener<MessageEvent>(socket as any, 'message').pipe(
+      Stream.map((msg) => Schema.decodeUnknownEither(MessageMsgPack)(new Uint8Array(msg.data))),
+      Stream.flatten(),
+      Stream.tap((msg) =>
+        Effect.gen(function* () {
+          if (msg._tag === 'WSConnectionInit') {
+            yield* Deferred.succeed(fromDeferred, msg.from)
+          } else {
+            const decodedPayload = yield* Schema.decode(MeshSchema.Packet)(msg.payload)
+            yield* Queue.offer(listenQueue, decodedPayload)
+          }
+        }),
+      ),
+      Stream.runDrain,
+      Effect.tapCauseLogPretty,
+      Effect.forkScoped,
+    )
+
+    const listenQueue = yield* Queue.unbounded<typeof MeshSchema.Packet.Type>().pipe(
+      Effect.acquireRelease(Queue.shutdown),
+    )
+
+    const initHandshake = (from: string) =>
+      socket.send(Schema.encodeSync(MessageMsgPack)({ _tag: 'WSConnectionInit', from }))
+
+    if (socketType._tag === 'leaf') {
+      initHandshake(socketType.from)
+    }
+
+    const deferredResult = yield* fromDeferred
+    const from = socketType._tag === 'leaf' ? socketType.from : deferredResult
+
+    if (socketType._tag === 'relay') {
+      initHandshake(from)
+    }
+
+    const isConnectedLatch = yield* Effect.makeLatch(true)
+
+    const closedDeferred = yield* Deferred.make<void>()
+
+    yield* Effect.eventListener<any>(
+      socket,
+      'close',
+      () =>
+        Effect.gen(function* () {
+          yield* isConnectedLatch.close
+          yield* Deferred.succeed(closedDeferred, undefined)
+        }),
+      { once: true },
+    )
+
+    const send = (message: typeof MeshSchema.Packet.Type) =>
+      Effect.gen(function* () {
+        yield* isConnectedLatch.await
+        const payload = yield* Schema.encode(MeshSchema.Packet)(message)
+        socket.send(Schema.encodeSync(MessageMsgPack)({ _tag: 'WSConnectionPayload', payload, from }))
+      })
+
+    const listen = Stream.fromQueue(listenQueue).pipe(Stream.map(Either.right))
+
+    const webChannel = {
+      [WebChannel.WebChannelSymbol]: WebChannel.WebChannelSymbol,
+      send,
+      listen,
+      closedDeferred,
+      schema: { listen: MeshSchema.Packet, send: MeshSchema.Packet },
+      supportsTransferables: false,
+    } satisfies WebChannel.WebChannel<typeof MeshSchema.Packet.Type, typeof MeshSchema.Packet.Type>
+
+    return {
+      webChannel: webChannel as WebChannel.WebChannel<typeof MeshSchema.Packet.Type, typeof MeshSchema.Packet.Type>,
+      from,
+    }
+  })

package/src/websocket-server.ts

@@ -0,0 +1,40 @@
+import type { Scope } from '@livestore/utils/effect'
+import { Effect } from '@livestore/utils/effect'
+import * as WebSocket from 'ws'
+
+import { makeMeshNode } from './node.js'
+import { makeWebSocketConnection } from './websocket-connection.js'
+
+export const makeWebSocketServer = ({
+  relayNodeName,
+}: {
+  relayNodeName: string
+}): Effect.Effect<WebSocket.WebSocketServer, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const server = new WebSocket.WebSocketServer({ noServer: true })
+
+    const node = yield* makeMeshNode(relayNodeName)
+
+    const runtime = yield* Effect.runtime<never>()
+
+    // TODO handle node disconnects (i.e. remove respective connection)
+    server.on('connection', (socket) => {
+      Effect.gen(function* () {
+        const { webChannel, from } = yield* makeWebSocketConnection(socket, { _tag: 'relay' })
+
+        yield* node.addConnection({ target: from, connectionChannel: webChannel, replaceIfExists: true })
+        yield* Effect.log(`WS Relay ${relayNodeName}: added connection from '${from}'`)
+
+        socket.addEventListener('close', () =>
+          Effect.gen(function* () {
+            yield* node.removeConnection(from)
+            yield* Effect.log(`WS Relay ${relayNodeName}: removed connection from '${from}'`)
+          }).pipe(Effect.provide(runtime), Effect.runFork),
+        )
+
+        yield* Effect.never
+      }).pipe(Effect.scoped, Effect.tapCauseLogPretty, Effect.provide(runtime), Effect.runFork)
+    })
+
+    return server
+  })

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "resolveJsonModule": true,
+    "tsBuildInfoFile": "./dist/.tsbuildinfo"
+  },
+  "include": ["./src"],
+  "references": [{ "path": "../common" }, { "path": "../utils" }]
+}