@livestore/webmesh 0.0.0-snapshot-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e → 0.0.0-snapshot-8fd59846e2580d37bdd37ae607e9db2a458a8b63

package/package.json

@@ -1,27 +1,25 @@
 {
   "name": "@livestore/webmesh",
-  "version": "0.0.0-snapshot-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e",
+  "version": "0.0.0-snapshot-8fd59846e2580d37bdd37ae607e9db2a458a8b63",
   "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-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e"
+    "@livestore/utils": "0.0.0-snapshot-8fd59846e2580d37bdd37ae607e9db2a458a8b63"
   },
   "devDependencies": {
-    "vitest": "3.2.4",
-    "@livestore/utils-dev": "0.0.0-snapshot-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e"
+    "vitest": "^3.1.2",
+    "@livestore/utils-dev": "0.0.0-snapshot-8fd59846e2580d37bdd37ae607e9db2a458a8b63"
   },
   "files": [
     "package.json",

package/src/channel/proxy-channel.ts

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

package/src/mod.ts

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

package/src/node.test.ts

@@ -216,87 +216,90 @@ 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 })
 
-            if (waitForOfflineDelay === undefined) {
-              // TODO we still need to fix this scenario but it shouldn't really be common in practice
-              return
-            }
+      {
+        // 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 nodeA = yield* makeMeshNode('A')
-            const nodeB = yield* makeMeshNode('B')
+              if (waitForOfflineDelay === undefined) {
+                // TODO we still need to fix this scenario but it shouldn't really be common in practice
+                return
+              }
 
-            const { mode, connectNodes } = fromChannelType(channelType)
+              const nodeA = yield* makeMeshNode('A')
+              const nodeB = yield* makeMeshNode('B')
 
-            // TODO also optionally delay the edge
-            yield* connectNodes(nodeA, nodeB)
+              const { mode, connectNodes } = fromChannelType(channelType)
 
-            const waitForBToBeOffline =
-              waitForOfflineDelay === undefined ? undefined : yield* Deferred.make<void, never>()
+              // TODO also optionally delay the edge
+              yield* connectNodes(nodeA, nodeB)
 
-            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 waitForBToBeOffline =
+                waitForOfflineDelay === undefined ? undefined : yield* Deferred.make<void, never>()
 
-              console.log('nodeACode:waiting for B to be offline')
-              if (waitForBToBeOffline !== undefined) {
-                yield* waitForBToBeOffline
-              }
+              const nodeACode = Effect.gen(function* () {
+                const channelAToB = yield* createChannel(nodeA, 'B', { mode })
+                yield* channelAToB.send({ message: 'A1' })
+                expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B1' })
 
-              yield* channelAToB.send({ message: 'A2' })
-              expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B2' })
-            })
+                console.log('nodeACode:waiting for B to be offline')
+                if (waitForBToBeOffline !== undefined) {
+                  yield* waitForBToBeOffline
+                }
 
-            // 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* channelAToB.send({ message: 'A2' })
+                expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B2' })
+              })
 
-                yield* channelBToA.send({ message: 'B1' })
-                expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' })
-              }).pipe(Effect.scoped, Effect.withSpan('nodeBCode:part1'))
+              // 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 })
 
-              console.log('nodeBCode:B node going offline')
-              if (waitForBToBeOffline !== undefined) {
-                yield* Deferred.succeed(waitForBToBeOffline, void 0)
-              }
+                  yield* channelBToA.send({ message: 'B1' })
+                  expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' })
+                }).pipe(Effect.scoped, Effect.withSpan('nodeBCode:part1'))
 
-              if (sleepDelay !== undefined) {
-                yield* Effect.sleep(sleepDelay).pipe(Effect.withSpan(`B:sleep(${sleepDelay})`))
-              }
+                console.log('nodeBCode:B node going offline')
+                if (waitForBToBeOffline !== undefined) {
+                  yield* Deferred.succeed(waitForBToBeOffline, void 0)
+                }
 
-              // Recreating the channel
-              yield* Effect.gen(function* () {
-                const channelBToA = yield* createChannel(nodeB, 'A', { mode })
+                if (sleepDelay !== undefined) {
+                  yield* Effect.sleep(sleepDelay).pipe(Effect.withSpan(`B:sleep(${sleepDelay})`))
+                }
 
-                yield* channelBToA.send({ message: 'B2' })
-                expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A2' })
-              }).pipe(Effect.scoped, Effect.withSpan('nodeBCode:part2'))
-            })
+                // Recreating the channel
+                yield* Effect.gen(function* () {
+                  const channelBToA = yield* createChannel(nodeB, 'A', { mode })
 
-            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* 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 } },
+        )
+      }
 
       Vitest.scopedLive('reconnect with re-created node', (test) =>
         Effect.gen(function* () {

package/src/node.ts

@@ -298,6 +298,7 @@ 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,3 +1,4 @@
+/* eslint-disable prefer-arrow/prefer-arrow-functions */
 import { Duration, Effect } from '@livestore/utils/effect'
 
 /**