@dxos/feed 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (45) hide show
  1. package/README.md +6 -2
  2. package/dist/lib/neutral/chunk-PT6JZUME.mjs +734 -0
  3. package/dist/lib/neutral/chunk-PT6JZUME.mjs.map +7 -0
  4. package/dist/lib/neutral/index.mjs +13 -0
  5. package/dist/lib/neutral/meta.json +1 -0
  6. package/dist/lib/neutral/testing/index.mjs +180 -0
  7. package/dist/lib/neutral/testing/index.mjs.map +7 -0
  8. package/dist/types/src/errors.d.ts +39 -0
  9. package/dist/types/src/errors.d.ts.map +1 -0
  10. package/dist/types/src/feed-store.d.ts +103 -9
  11. package/dist/types/src/feed-store.d.ts.map +1 -1
  12. package/dist/types/src/index.d.ts +3 -1
  13. package/dist/types/src/index.d.ts.map +1 -1
  14. package/dist/types/src/sync-client.d.ts +54 -0
  15. package/dist/types/src/sync-client.d.ts.map +1 -0
  16. package/dist/types/src/sync-server.d.ts +28 -0
  17. package/dist/types/src/sync-server.d.ts.map +1 -0
  18. package/dist/types/src/testing/index.d.ts +1 -1
  19. package/dist/types/src/testing/index.d.ts.map +1 -1
  20. package/dist/types/src/testing/test-builder.d.ts +78 -0
  21. package/dist/types/src/testing/test-builder.d.ts.map +1 -0
  22. package/dist/types/tsconfig.tsbuildinfo +1 -1
  23. package/package.json +16 -13
  24. package/src/errors.ts +20 -0
  25. package/src/feed-store.test.ts +394 -39
  26. package/src/feed-store.ts +493 -140
  27. package/src/index.ts +3 -1
  28. package/src/sync-client.ts +195 -0
  29. package/src/sync-server.ts +96 -0
  30. package/src/sync.test.ts +151 -91
  31. package/src/testing/index.ts +1 -1
  32. package/src/testing/test-builder.ts +223 -0
  33. package/dist/lib/browser/index.mjs +0 -342
  34. package/dist/lib/browser/index.mjs.map +0 -7
  35. package/dist/lib/browser/meta.json +0 -1
  36. package/dist/lib/browser/testing/index.mjs +0 -1
  37. package/dist/lib/node-esm/index.mjs +0 -344
  38. package/dist/lib/node-esm/index.mjs.map +0 -7
  39. package/dist/lib/node-esm/meta.json +0 -1
  40. package/dist/lib/node-esm/testing/index.mjs +0 -2
  41. package/dist/lib/node-esm/testing/index.mjs.map +0 -7
  42. package/dist/types/src/protocol.d.ts +0 -120
  43. package/dist/types/src/protocol.d.ts.map +0 -1
  44. package/src/protocol.ts +0 -110
  45. /package/dist/lib/{browser/testing → neutral}/index.mjs.map +0 -0
package/src/index.ts CHANGED
@@ -3,4 +3,6 @@
3
3
  //
4
4
 
5
5
  export * from './feed-store';
6
- export * from './protocol';
6
+ export * from './errors';
7
+ export * from './sync-server';
8
+ export * from './sync-client';
@@ -0,0 +1,195 @@
1
+ //
2
+ // Copyright 2026 DXOS.org
3
+ //
4
+
5
+ import type * as SqlClient from '@effect/sql/SqlClient';
6
+ import * as Array from 'effect/Array';
7
+ import * as Deferred from 'effect/Deferred';
8
+ import * as Effect from 'effect/Effect';
9
+
10
+ import type { SpaceId } from '@dxos/keys';
11
+ import { type FeedProtocol } from '@dxos/protocols';
12
+ import type { SqlTransaction } from '@dxos/sql-sqlite';
13
+
14
+ import type { FeedStore } from './feed-store';
15
+ import { Context } from '@dxos/context';
16
+
17
+ type AppendResponse = FeedProtocol.AppendResponse;
18
+ type ProtocolMessage = FeedProtocol.ProtocolMessage;
19
+ type QueryResponse = FeedProtocol.QueryResponse;
20
+ type QueryRequestMessage = Extract<ProtocolMessage, { _tag: 'QueryRequest' }>;
21
+ type AppendRequestMessage = Extract<ProtocolMessage, { _tag: 'AppendRequest' }>;
22
+ type RequestMessage = QueryRequestMessage | AppendRequestMessage;
23
+ type RequestPayload =
24
+ | Omit<QueryRequestMessage, 'senderPeerId' | 'recipientPeerId'>
25
+ | Omit<AppendRequestMessage, 'senderPeerId' | 'recipientPeerId'>;
26
+
27
+ export type SyncClientOptions = {
28
+ /** This client's peer id. Set as senderPeerId on all requests. */
29
+ peerId: string;
30
+ /** The server's peer id. Set as recipientPeerId on all requests. */
31
+ serverPeerId?: string;
32
+ feedStore: FeedStore;
33
+ /** Send a protocol message to the server. Returns Effect. */
34
+ sendMessage: (ctx: Context, message: RequestMessage) => Effect.Effect<void, unknown, never>;
35
+ };
36
+
37
+ /**
38
+ * Client-side sync: pull/push by sending protocol messages and handling responses.
39
+ * Sets senderPeerId = peerId and recipientPeerId = serverPeerId on all requests.
40
+ * Uses a map of requestId -> Deferred to match responses to in-flight requests.
41
+ * handleMessage completes the Deferred for the requestId (if any) and removes the handler; no handler = noop.
42
+ */
43
+ export class SyncClient {
44
+ readonly #peerId: string;
45
+ readonly #serverPeerId: string | undefined;
46
+ readonly #feedStore: FeedStore;
47
+ readonly #sendMessage: SyncClientOptions['sendMessage'];
48
+ readonly #handlers = new Map<string, Deferred.Deferred<ProtocolMessage, Error>>();
49
+
50
+ constructor(options: SyncClientOptions) {
51
+ this.#peerId = options.peerId;
52
+ this.#serverPeerId = options.serverPeerId;
53
+ this.#feedStore = options.feedStore;
54
+ this.#sendMessage = options.sendMessage;
55
+ }
56
+
57
+ #withPeerIds(payload: RequestPayload): RequestMessage {
58
+ if (payload._tag === 'QueryRequest') {
59
+ return {
60
+ ...payload,
61
+ senderPeerId: this.#peerId,
62
+ recipientPeerId: this.#serverPeerId,
63
+ };
64
+ }
65
+ return {
66
+ ...payload,
67
+ senderPeerId: this.#peerId,
68
+ recipientPeerId: this.#serverPeerId,
69
+ };
70
+ }
71
+
72
+ /**
73
+ * Receive a message from the server. If a handler is registered for the message's requestId, complete it and remove; else noop.
74
+ */
75
+ handleMessage(message: ProtocolMessage): Effect.Effect<void, never, never> {
76
+ const requestId = 'requestId' in message && message.requestId != null ? String(message.requestId) : undefined;
77
+ if (requestId == null) return Effect.void;
78
+ const deferred = this.#handlers.get(requestId);
79
+ if (deferred == null) return Effect.void;
80
+ this.#handlers.delete(requestId);
81
+ if (message._tag === 'Error') {
82
+ return Effect.andThen(Deferred.fail(deferred, new Error(message.message)), () => Effect.void);
83
+ }
84
+ return Effect.andThen(Deferred.succeed(deferred, message), () => Effect.void);
85
+ }
86
+
87
+ pull(
88
+ ctx: Context,
89
+ opts: {
90
+ spaceId: SpaceId;
91
+ feedNamespace: string;
92
+ limit?: number;
93
+ },
94
+ ): Effect.Effect<{ done: boolean }, unknown, SqlClient.SqlClient | SqlTransaction.SqlTransaction> {
95
+ const self = this;
96
+ return Effect.gen(function* () {
97
+ const lastPulledPosition = yield* self.#feedStore.getSyncState({
98
+ spaceId: opts.spaceId,
99
+ feedNamespace: opts.feedNamespace,
100
+ });
101
+ const requestId = crypto.randomUUID();
102
+ const deferred = yield* Deferred.make<ProtocolMessage, Error>();
103
+ self.#handlers.set(requestId, deferred);
104
+ const request: RequestPayload = {
105
+ _tag: 'QueryRequest',
106
+ requestId,
107
+ spaceId: opts.spaceId,
108
+ feedNamespace: opts.feedNamespace,
109
+ position: lastPulledPosition,
110
+ limit: opts.limit,
111
+ };
112
+ yield* self.#sendMessage(ctx, self.#withPeerIds(request));
113
+ const message = yield* Deferred.await(deferred);
114
+ const response = yield* self.#expectResponse<QueryResponse>(requestId, message, 'QueryResponse');
115
+ if (response.blocks.length === 0) {
116
+ return { done: true };
117
+ }
118
+ yield* self.#feedStore.append({
119
+ spaceId: opts.spaceId,
120
+ feedNamespace: opts.feedNamespace,
121
+ blocks: response.blocks,
122
+ });
123
+
124
+ // Update sync state with the max position from the pulled batch.
125
+ const maxPulledPosition = response.blocks.reduce(
126
+ (max, block) => (block.position != null && block.position > max ? block.position : max),
127
+ lastPulledPosition,
128
+ );
129
+ yield* self.#feedStore.setSyncState({
130
+ spaceId: opts.spaceId,
131
+ feedNamespace: opts.feedNamespace,
132
+ lastPulledPosition: maxPulledPosition,
133
+ });
134
+
135
+ return { done: false };
136
+ });
137
+ }
138
+
139
+ push(
140
+ ctx: Context,
141
+ opts: {
142
+ spaceId: SpaceId;
143
+ feedNamespace: string;
144
+ limit?: number;
145
+ },
146
+ ): Effect.Effect<{ done: boolean }, unknown, SqlClient.SqlClient | SqlTransaction.SqlTransaction> {
147
+ const self = this;
148
+ return Effect.gen(function* () {
149
+ const unpositioned = yield* self.#feedStore.query({
150
+ spaceId: opts.spaceId,
151
+ feedNamespace: opts.feedNamespace,
152
+ unpositionedOnly: true,
153
+ limit: opts.limit,
154
+ });
155
+ if (unpositioned.blocks.length === 0) {
156
+ return { done: true };
157
+ }
158
+ const requestId = crypto.randomUUID();
159
+ const deferred = yield* Deferred.make<ProtocolMessage, Error>();
160
+ self.#handlers.set(requestId, deferred);
161
+ const request: RequestPayload = {
162
+ _tag: 'AppendRequest',
163
+ requestId,
164
+ spaceId: opts.spaceId,
165
+ feedNamespace: opts.feedNamespace,
166
+ blocks: unpositioned.blocks,
167
+ };
168
+ yield* self.#sendMessage(ctx, self.#withPeerIds(request));
169
+ const message = yield* Deferred.await(deferred);
170
+ const response = yield* self.#expectResponse<AppendResponse>(requestId, message, 'AppendResponse');
171
+ yield* self.#feedStore.setPosition({
172
+ spaceId: opts.spaceId,
173
+ blocks: Array.zipWith(response.positions, unpositioned.blocks, (position, block) => ({
174
+ feedId: block.feedId,
175
+ feedNamespace: opts.feedNamespace,
176
+ actorId: block.actorId,
177
+ sequence: block.sequence,
178
+ position,
179
+ })),
180
+ });
181
+ return { done: false };
182
+ });
183
+ }
184
+
185
+ #expectResponse<T>(requestId: string, message: ProtocolMessage, expectedTag: string): Effect.Effect<T, Error, never> {
186
+ if (message._tag === 'Error') {
187
+ return Effect.fail(new Error(message.message));
188
+ }
189
+ const requestIdMsg = 'requestId' in message ? String(message.requestId) : undefined;
190
+ if (message._tag !== expectedTag || requestIdMsg !== requestId) {
191
+ return Effect.fail(new Error(`Unexpected message: expected ${expectedTag} with requestId ${requestId}`));
192
+ }
193
+ return Effect.succeed(message as T);
194
+ }
195
+ }
@@ -0,0 +1,96 @@
1
+ //
2
+ // Copyright 2026 DXOS.org
3
+ //
4
+
5
+ import type * as SqlClient from '@effect/sql/SqlClient';
6
+ import * as Effect from 'effect/Effect';
7
+
8
+ import { type FeedProtocol } from '@dxos/protocols';
9
+ import type { SqlTransaction } from '@dxos/sql-sqlite';
10
+
11
+ import type { FeedStore } from './feed-store';
12
+ import { Context } from '@dxos/context';
13
+
14
+ type AppendRequest = FeedProtocol.AppendRequest;
15
+ type ProtocolMessage = FeedProtocol.ProtocolMessage;
16
+ type QueryRequest = FeedProtocol.QueryRequest;
17
+ type QueryResponse = FeedProtocol.QueryResponse;
18
+
19
+ export type SyncServerOptions = {
20
+ /** This server's peer id. Set as senderPeerId on all replies. */
21
+ peerId: string;
22
+ feedStore: FeedStore;
23
+ /** Send a protocol message to a client. Receives full message (recipient is set by server). Returns Effect. */
24
+ sendMessage: (ctx: Context, message: ProtocolMessage) => Effect.Effect<void, unknown, never>;
25
+ };
26
+
27
+ /**
28
+ * Server-side sync: receives protocol messages, runs query/append against the store, sends responses.
29
+ * Reusable for many peers: sets senderPeerId = peerId and recipientPeerId = incoming message's senderPeerId on replies.
30
+ */
31
+ export class SyncServer {
32
+ readonly #peerId: string;
33
+ readonly #feedStore: FeedStore;
34
+ readonly #sendMessage: SyncServerOptions['sendMessage'];
35
+
36
+ constructor(options: SyncServerOptions) {
37
+ this.#peerId = options.peerId;
38
+ this.#feedStore = options.feedStore;
39
+ this.#sendMessage = options.sendMessage;
40
+ }
41
+
42
+ /**
43
+ * Receive a message from a client. Handles QueryRequest and AppendRequest; sends response via sendMessage with correct peer ids.
44
+ */
45
+ handleMessage(
46
+ ctx: Context,
47
+ message: ProtocolMessage,
48
+ ): Effect.Effect<void, unknown, SqlClient.SqlClient | SqlTransaction.SqlTransaction> {
49
+ const self = this;
50
+ const recipientPeerId = message.senderPeerId;
51
+ const withPeerIds = (payload: Omit<ProtocolMessage, 'senderPeerId' | 'recipientPeerId'>): ProtocolMessage =>
52
+ ({
53
+ ...payload,
54
+ senderPeerId: self.#peerId,
55
+ recipientPeerId,
56
+ }) as ProtocolMessage;
57
+ switch (message._tag) {
58
+ case 'QueryRequest': {
59
+ const req = message as QueryRequest;
60
+ return Effect.gen(function* () {
61
+ const response: QueryResponse = yield* self.#feedStore.query(req);
62
+ yield* self.#sendMessage(ctx, withPeerIds({ _tag: 'QueryResponse', ...response }));
63
+ }).pipe(
64
+ Effect.catchAll((err: unknown) =>
65
+ self.#sendMessage(
66
+ ctx,
67
+ withPeerIds({
68
+ _tag: 'Error',
69
+ message: err instanceof Error ? err.message : String(err),
70
+ } as Omit<ProtocolMessage, 'senderPeerId' | 'recipientPeerId'>),
71
+ ),
72
+ ),
73
+ );
74
+ }
75
+ case 'AppendRequest': {
76
+ const req = message as AppendRequest;
77
+ return Effect.gen(function* () {
78
+ const response = yield* self.#feedStore.append(req);
79
+ yield* self.#sendMessage(ctx, withPeerIds({ _tag: 'AppendResponse', ...response }));
80
+ }).pipe(
81
+ Effect.catchAll((err: unknown) =>
82
+ self.#sendMessage(
83
+ ctx,
84
+ withPeerIds({
85
+ _tag: 'Error',
86
+ message: err instanceof Error ? err.message : String(err),
87
+ } as Omit<ProtocolMessage, 'senderPeerId' | 'recipientPeerId'>),
88
+ ),
89
+ ),
90
+ );
91
+ }
92
+ default:
93
+ return Effect.void;
94
+ }
95
+ }
96
+ }
package/src/sync.test.ts CHANGED
@@ -2,102 +2,162 @@
2
2
  // Copyright 2026 DXOS.org
3
3
  //
4
4
 
5
- import type * as SqlClient from '@effect/sql/SqlClient';
6
- import * as SqliteClient from '@effect/sql-sqlite-node/SqliteClient';
7
- import { describe, expect, it } from '@effect/vitest';
8
- import * as Effect from 'effect/Effect';
9
- import * as ManagedRuntime from 'effect/ManagedRuntime';
10
-
11
- import { SpaceId } from '@dxos/keys';
12
-
13
- import { FeedStore } from './feed-store';
14
- import { type Block } from './protocol';
15
-
16
- describe.skip('Feed Sync V2 (RPC)', () => {
17
- const makePeer = () => {
18
- const layer = SqliteClient.layer({ filename: ':memory:' });
19
- const runtime = ManagedRuntime.make(layer);
20
- const run = <A, E>(effect: Effect.Effect<A, E, SqlClient.SqlClient>) => runtime.runPromise(effect);
21
- return { run };
22
- };
23
-
24
- it('should sync blocks from server to client via RPC', async () => {
25
- const server = makePeer();
26
- const client = makePeer();
27
-
28
- const spaceId = SpaceId.random();
29
- const feedId = '01H1V1X1X1X1X1X1X1X1X1X1X3';
30
-
31
- // Server setup: Append blocks
32
- await server.run(
33
- Effect.gen(function* () {
34
- const feed = new FeedStore({ localActorId: 'server', assignPositions: true });
35
- const blocks: Block[] = [
36
- {
37
- feedId: undefined,
38
- actorId: feedId,
39
- sequence: 1,
40
- predActorId: null,
41
- predSequence: null,
42
- position: null,
43
- timestamp: 100,
44
- data: new Uint8Array([1]),
45
- },
46
- {
47
- feedId: undefined,
48
- actorId: feedId,
49
- sequence: 2,
50
- predActorId: feedId,
51
- predSequence: 1,
52
- position: null,
53
- timestamp: 200,
54
- data: new Uint8Array([2]),
55
- },
56
- ];
57
- yield* feed.append({ requestId: 'req-0', blocks, spaceId, namespace: 'data', feedId });
58
- }),
59
- );
5
+ import { describe, expect, test } from '@effect/vitest';
60
6
 
61
- // Sync Simulation: Client polls Server
62
- // 1. Client subscribes
63
- const subId = await server.run(
64
- Effect.gen(function* () {
65
- // Wait, we flattened it. Tests need to update to NOT use SqlFeedStore!
66
- // I will fix the class instantiation in a moment.
67
- const feed = new FeedStore({ localActorId: 'server', assignPositions: true });
68
- const res = yield* feed.subscribe({ requestId: 'req-sub', feedIds: [feedId], spaceId });
69
- return res.subscriptionId;
70
- }),
71
- );
7
+ import { RuntimeProvider } from '@dxos/effect';
8
+ import { ObjectId, SpaceId } from '@dxos/keys';
9
+ import { FeedProtocol } from '@dxos/protocols';
10
+ import { range } from '@dxos/util';
11
+
12
+ import { TestBuilder } from './testing';
13
+
14
+ const WellKnownNamespaces = FeedProtocol.WellKnownNamespaces;
15
+
16
+ describe('Sync', () => {
17
+ const LOG_SQL = false;
18
+
19
+ const spaceId = SpaceId.random();
20
+ const feedId = ObjectId.random();
21
+
22
+ test('pull blocks from server', async () => {
23
+ await using builder = await new TestBuilder({ numPeers: 2, spaceId, logSql: LOG_SQL }).open();
24
+ const [server, client] = builder.peers;
25
+
26
+ const testBlocks = generateTestBlocks(0, 5);
27
+
28
+ await server.feedStore
29
+ .appendLocal(
30
+ testBlocks.map((block) => ({
31
+ spaceId,
32
+ feedId,
33
+ feedNamespace: WellKnownNamespaces.data,
34
+ data: block,
35
+ })),
36
+ )
37
+ .pipe(RuntimeProvider.runPromise(server.runtime.runtimeEffect));
38
+
39
+ await builder.pull(client);
40
+
41
+ const { blocks } = await client.feedStore
42
+ .query({
43
+ spaceId,
44
+ feedNamespace: WellKnownNamespaces.data,
45
+ })
46
+ .pipe(RuntimeProvider.runPromise(client.runtime.runtimeEffect));
47
+ expect(blocks.map((block) => block.data)).toEqual(testBlocks);
48
+ });
49
+
50
+ test('push blocks from client to server', async () => {
51
+ await using builder = await new TestBuilder({ numPeers: 2, spaceId, logSql: LOG_SQL }).open();
52
+ const [server, client] = builder.peers;
53
+
54
+ const testBlocks = generateTestBlocks(0, 5);
55
+
56
+ await client.feedStore
57
+ .appendLocal(
58
+ testBlocks.map((block) => ({
59
+ spaceId,
60
+ feedId,
61
+ feedNamespace: WellKnownNamespaces.data,
62
+ data: block,
63
+ })),
64
+ )
65
+ .pipe(RuntimeProvider.runPromise(client.runtime.runtimeEffect));
66
+
67
+ await builder.push(client);
72
68
 
73
- // 2. Client queries using subscription
74
- const blocks = await server.run(
75
- Effect.gen(function* () {
76
- const feed = new FeedStore({ localActorId: 'server', assignPositions: true }); // Updated class usage
77
- const res = yield* feed.query({ requestId: 'req-query', query: { subscriptionId: subId }, position: 0 });
78
- return res.blocks;
79
- }),
69
+ const serverBlocks = await server.feedStore
70
+ .query({
71
+ spaceId,
72
+ feedNamespace: WellKnownNamespaces.data,
73
+ })
74
+ .pipe(RuntimeProvider.runPromise(server.runtime.runtimeEffect));
75
+ expect(serverBlocks.blocks.map((block) => block.data)).toEqual(testBlocks);
76
+ expect(serverBlocks.blocks.every((block) => block.position != null)).toBe(true);
77
+
78
+ const clientBlocks = await client.feedStore
79
+ .query({
80
+ spaceId,
81
+ feedNamespace: WellKnownNamespaces.data,
82
+ })
83
+ .pipe(RuntimeProvider.runPromise(client.runtime.runtimeEffect));
84
+ expect(clientBlocks.blocks.map((block) => block.position)).toEqual(
85
+ serverBlocks.blocks.map((block) => block.position),
80
86
  );
87
+ });
81
88
 
82
- expect(blocks.length).toBe(2);
83
- expect(blocks[0].sequence).toBe(1);
84
-
85
- // 3. Client stores them (Verify client persistence)
86
- await client.run(
87
- Effect.gen(function* () {
88
- const feed = new FeedStore({ localActorId: 'client', assignPositions: true }); // Updated class usage
89
- // Client appends them.
90
- yield* feed.append({ requestId: 'req-push', blocks, spaceId, namespace: 'data', feedId });
91
-
92
- // Verify
93
- const myBlocks = yield* feed.query({
94
- requestId: 'req-verify',
95
- query: { feedIds: [feedId] },
96
- position: 0,
89
+ test('push blocks incrementally in batches', async () => {
90
+ await using builder = await new TestBuilder({ numPeers: 2, spaceId, logSql: LOG_SQL }).open();
91
+ const [server, client] = builder.peers;
92
+
93
+ const testBlocks = generateTestBlocks(0, 5);
94
+
95
+ await client.feedStore
96
+ .appendLocal(
97
+ testBlocks.map((block) => ({
97
98
  spaceId,
98
- });
99
- expect(myBlocks.blocks.length).toBe(2);
100
- }),
99
+ feedId,
100
+ feedNamespace: WellKnownNamespaces.data,
101
+ data: block,
102
+ })),
103
+ )
104
+ .pipe(RuntimeProvider.runPromise(client.runtime.runtimeEffect));
105
+
106
+ let done = false,
107
+ numBatches = 0;
108
+ while (!done) {
109
+ numBatches++;
110
+ const result = await builder.push(client, { limit: 2 });
111
+ done = result.done;
112
+ }
113
+ await builder.push(client);
114
+ expect(numBatches).toBeGreaterThan(2);
115
+ expect(numBatches).toBeLessThan(10);
116
+
117
+ const serverBlocks = await server.feedStore
118
+ .query({
119
+ spaceId,
120
+ feedNamespace: WellKnownNamespaces.data,
121
+ })
122
+ .pipe(RuntimeProvider.runPromise(server.runtime.runtimeEffect));
123
+ expect(serverBlocks.blocks.map((block) => block.data)).toEqual(testBlocks);
124
+ expect(serverBlocks.blocks.every((block) => block.position != null)).toBe(true);
125
+
126
+ const clientBlocks = await client.feedStore
127
+ .query({
128
+ spaceId,
129
+ feedNamespace: WellKnownNamespaces.data,
130
+ })
131
+ .pipe(RuntimeProvider.runPromise(client.runtime.runtimeEffect));
132
+ expect(clientBlocks.blocks.map((block) => block.position)).toEqual(
133
+ serverBlocks.blocks.map((block) => block.position),
101
134
  );
102
135
  });
136
+
137
+ test('3-way sync', async () => {
138
+ await using builder = await new TestBuilder({ numPeers: 3, spaceId, logSql: LOG_SQL }).open();
139
+ const [, client1, client2] = builder.peers;
140
+
141
+ const testBlocks = generateTestBlocks(0, 5);
142
+
143
+ await client1.feedStore
144
+ .appendLocal(
145
+ testBlocks.map((block) => ({ spaceId, feedId, feedNamespace: WellKnownNamespaces.data, data: block })),
146
+ )
147
+ .pipe(RuntimeProvider.runPromise(client1.runtime.runtimeEffect));
148
+ await builder.push(client1);
149
+
150
+ await builder.pull(client2);
151
+
152
+ const { blocks: client1Blocks } = await client1.feedStore
153
+ .query({ spaceId, feedNamespace: WellKnownNamespaces.data })
154
+ .pipe(RuntimeProvider.runPromise(client1.runtime.runtimeEffect));
155
+ const { blocks: client2Blocks } = await client2.feedStore
156
+ .query({ spaceId, feedNamespace: WellKnownNamespaces.data })
157
+ .pipe(RuntimeProvider.runPromise(client2.runtime.runtimeEffect));
158
+ expect(client1Blocks).toEqual(client2Blocks);
159
+ expect(client1Blocks.every((block) => block.position != null)).toBe(true);
160
+ });
103
161
  });
162
+
163
+ const generateTestBlocks = (start: number, count: number) => range(count, (i) => new Uint8Array([start + i]));
@@ -2,4 +2,4 @@
2
2
  // Copyright 2025 DXOS.org
3
3
  //
4
4
 
5
- export {};
5
+ export * from './test-builder';