@livestore/webmesh 0.0.0-snapshot-f5ece014485b5ab43795c218f7ba7cfa32c81707 → 0.0.0-snapshot-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e

package/package.json

@@ -1,25 +1,27 @@
 {
   "name": "@livestore/webmesh",
-  "version": "0.0.0-snapshot-f5ece014485b5ab43795c218f7ba7cfa32c81707",
+  "version": "0.0.0-snapshot-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e",
   "type": "module",
   "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/mod.d.ts",
+      "bun": "./src/mod.ts",
       "default": "./dist/mod.js"
     },
     "./websocket-server": {
       "types": "./dist/websocket-server.d.ts",
+      "bun": "./src/websocket-server.ts",
       "default": "./dist/websocket-server.js"
     }
   },
   "types": "./dist/mod.d.ts",
   "dependencies": {
-    "@livestore/utils": "0.0.0-snapshot-f5ece014485b5ab43795c218f7ba7cfa32c81707"
+    "@livestore/utils": "0.0.0-snapshot-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e"
   },
   "devDependencies": {
-    "vitest": "^3.1.2",
-    "@livestore/utils-dev": "0.0.0-snapshot-f5ece014485b5ab43795c218f7ba7cfa32c81707"
+    "vitest": "3.2.4",
+    "@livestore/utils-dev": "0.0.0-snapshot-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e"
   },
   "files": [
     "package.json",

package/src/channel/proxy-channel.ts

@@ -21,8 +21,8 @@ import {
   type ChannelKey,
   type ChannelName,
   type MeshNodeName,
-  packetAsOtelAttributes,
   type ProxyQueueItem,
+  packetAsOtelAttributes,
 } from '../common.js'
 import * as MeshSchema from '../mesh-schema.js'
 
@@ -427,7 +427,7 @@ export const makeProxyChannel = ({
         debugInfo,
         ...({
           debug: {
-            ping: (message: string = 'ping') =>
+            ping: (message = 'ping') =>
               send(WebChannel.DebugPingMessage.make({ message })).pipe(
                 Effect.provide(runtime),
                 Effect.tapCauseLogPretty,

package/src/mod.ts

@@ -1,4 +1,4 @@
-export * from './websocket-edge.js'
-export * from './node.js'
-export * as WebmeshSchema from './mesh-schema.js'
 export { EdgeAlreadyExistsError } from './common.js'
+export * as WebmeshSchema from './mesh-schema.js'
+export * from './node.js'
+export * from './websocket-edge.js'

package/src/node.test.ts

@@ -216,90 +216,87 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
           ),
         // { fastCheck: { numRuns: 20 } },
       )
+      // const waitForOfflineDelay = undefined
+      // const sleepDelay = 0
+      // const channelType = 'direct'
+      // Vitest.scopedLive(
+      //   'b reconnects',
+      //   (test) =>
+      Vitest.scopedLive.prop(
+        'b reconnects',
+        [Delay, Delay, ChannelType],
+        ([waitForOfflineDelay, sleepDelay, channelType], test) =>
+          Effect.gen(function* () {
+            // console.log({ waitForOfflineDelay, sleepDelay, channelType })
 
-      {
-        // const waitForOfflineDelay = undefined
-        // const sleepDelay = 0
-        // const channelType = 'direct'
-        // Vitest.scopedLive(
-        //   'b reconnects',
-        //   (test) =>
-        Vitest.scopedLive.prop(
-          'b reconnects',
-          [Delay, Delay, ChannelType],
-          ([waitForOfflineDelay, sleepDelay, channelType], test) =>
-            Effect.gen(function* () {
-              // console.log({ waitForOfflineDelay, sleepDelay, channelType })
-
-              if (waitForOfflineDelay === undefined) {
-                // TODO we still need to fix this scenario but it shouldn't really be common in practice
-                return
-              }
+            if (waitForOfflineDelay === undefined) {
+              // TODO we still need to fix this scenario but it shouldn't really be common in practice
+              return
+            }
 
-              const nodeA = yield* makeMeshNode('A')
-              const nodeB = yield* makeMeshNode('B')
+            const nodeA = yield* makeMeshNode('A')
+            const nodeB = yield* makeMeshNode('B')
 
-              const { mode, connectNodes } = fromChannelType(channelType)
+            const { mode, connectNodes } = fromChannelType(channelType)
 
-              // TODO also optionally delay the edge
-              yield* connectNodes(nodeA, nodeB)
+            // TODO also optionally delay the edge
+            yield* connectNodes(nodeA, nodeB)
 
-              const waitForBToBeOffline =
-                waitForOfflineDelay === undefined ? undefined : yield* Deferred.make<void, never>()
+            const waitForBToBeOffline =
+              waitForOfflineDelay === undefined ? undefined : yield* Deferred.make<void, never>()
 
-              const nodeACode = Effect.gen(function* () {
-                const channelAToB = yield* createChannel(nodeA, 'B', { mode })
-                yield* channelAToB.send({ message: 'A1' })
-                expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B1' })
+            const nodeACode = Effect.gen(function* () {
+              const channelAToB = yield* createChannel(nodeA, 'B', { mode })
+              yield* channelAToB.send({ message: 'A1' })
+              expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B1' })
 
-                console.log('nodeACode:waiting for B to be offline')
-                if (waitForBToBeOffline !== undefined) {
-                  yield* waitForBToBeOffline
-                }
+              console.log('nodeACode:waiting for B to be offline')
+              if (waitForBToBeOffline !== undefined) {
+                yield* waitForBToBeOffline
+              }
 
-                yield* channelAToB.send({ message: 'A2' })
-                expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B2' })
-              })
+              yield* channelAToB.send({ message: 'A2' })
+              expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B2' })
+            })
 
-              // Simulating node b going offline and then coming back online
-              // This test also illustrates why we need a ack-message channel since otherwise
-              // sent messages might get lost
-              const nodeBCode = Effect.gen(function* () {
-                yield* Effect.gen(function* () {
-                  const channelBToA = yield* createChannel(nodeB, 'A', { mode })
+            // Simulating node b going offline and then coming back online
+            // This test also illustrates why we need a ack-message channel since otherwise
+            // sent messages might get lost
+            const nodeBCode = Effect.gen(function* () {
+              yield* Effect.gen(function* () {
+                const channelBToA = yield* createChannel(nodeB, 'A', { mode })
 
-                  yield* channelBToA.send({ message: 'B1' })
-                  expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' })
-                }).pipe(Effect.scoped, Effect.withSpan('nodeBCode:part1'))
+                yield* channelBToA.send({ message: 'B1' })
+                expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' })
+              }).pipe(Effect.scoped, Effect.withSpan('nodeBCode:part1'))
 
-                console.log('nodeBCode:B node going offline')
-                if (waitForBToBeOffline !== undefined) {
-                  yield* Deferred.succeed(waitForBToBeOffline, void 0)
-                }
+              console.log('nodeBCode:B node going offline')
+              if (waitForBToBeOffline !== undefined) {
+                yield* Deferred.succeed(waitForBToBeOffline, void 0)
+              }
 
-                if (sleepDelay !== undefined) {
-                  yield* Effect.sleep(sleepDelay).pipe(Effect.withSpan(`B:sleep(${sleepDelay})`))
-                }
+              if (sleepDelay !== undefined) {
+                yield* Effect.sleep(sleepDelay).pipe(Effect.withSpan(`B:sleep(${sleepDelay})`))
+              }
 
-                // Recreating the channel
-                yield* Effect.gen(function* () {
-                  const channelBToA = yield* createChannel(nodeB, 'A', { mode })
+              // Recreating the channel
+              yield* Effect.gen(function* () {
+                const channelBToA = yield* createChannel(nodeB, 'A', { mode })
 
-                  yield* channelBToA.send({ message: 'B2' })
-                  expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A2' })
-                }).pipe(Effect.scoped, Effect.withSpan('nodeBCode:part2'))
-              })
+                yield* channelBToA.send({ message: 'B2' })
+                expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A2' })
+              }).pipe(Effect.scoped, Effect.withSpan('nodeBCode:part2'))
+            })
 
-              yield* Effect.all([nodeACode, nodeBCode], { concurrency: 'unbounded' }).pipe(Effect.withSpan('test'))
-            }).pipe(
-              withCtx(test, {
-                skipOtel: true,
-                suffix: `waitForOfflineDelay=${waitForOfflineDelay} sleepDelay=${sleepDelay} channelType=${channelType}`,
-              }),
-            ),
-          { fastCheck: { numRuns: 20 } },
-        )
-      }
+            yield* Effect.all([nodeACode, nodeBCode], { concurrency: 'unbounded' }).pipe(Effect.withSpan('test'))
+          }).pipe(
+            withCtx(test, {
+              skipOtel: true,
+              suffix: `waitForOfflineDelay=${waitForOfflineDelay} sleepDelay=${sleepDelay} channelType=${channelType}`,
+            }),
+          ),
+        { fastCheck: { numRuns: 20 } },
+      )
 
       Vitest.scopedLive('reconnect with re-created node', (test) =>
         Effect.gen(function* () {

package/src/node.ts

@@ -298,7 +298,6 @@ export const makeMeshNode = <TName extends MeshNodeName>(
           yield* edgeChannel.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.at(-1) ?? shouldNeverHappen(`${nodeName}: Expected remaining hops for packet`, packet)

package/src/utils.ts

@@ -1,4 +1,3 @@
-/* eslint-disable prefer-arrow/prefer-arrow-functions */
 import { Duration, Effect } from '@livestore/utils/effect'
 
 /**