@baukit/data-contracts 0.7.2 → 0.7.4

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.
@@ -0,0 +1,684 @@
1
+ import { describe, expect, it } from 'vitest';
2
+
3
+ import {
4
+ type RevisionedWriteQueue,
5
+ type RevisionedWriteQueueOptions,
6
+ type RevisionedWriteRequest,
7
+ type RevisionedWriteResult,
8
+ createRevisionedWriteQueue,
9
+ } from './revisioned-writes.js';
10
+
11
+ interface Deferred<T> {
12
+ readonly promise: Promise<T>;
13
+ resolve(value: T): void;
14
+ reject(error: unknown): void;
15
+ }
16
+
17
+ function deferred<T>(): Deferred<T> {
18
+ let resolve!: (value: T) => void;
19
+ let reject!: (error: unknown) => void;
20
+ const promise = new Promise<T>((onResolve, onReject) => {
21
+ resolve = onResolve;
22
+ reject = onReject;
23
+ });
24
+ return { promise, resolve, reject };
25
+ }
26
+
27
+ type Request<TValue = string> = RevisionedWriteRequest<string, string, TValue, number>;
28
+ type Result = RevisionedWriteResult<number, { readonly serverValue: string }>;
29
+
30
+ interface PendingWrite<TValue> {
31
+ readonly request: Request<TValue>;
32
+ readonly result: Deferred<Result>;
33
+ }
34
+
35
+ class FakeServer<TValue = string> {
36
+ readonly writes: PendingWrite<TValue>[] = [];
37
+
38
+ readonly write = (request: Request<TValue>): Promise<Result> => {
39
+ const result = deferred<Result>();
40
+ this.writes.push({ request, result });
41
+ return result.promise;
42
+ };
43
+
44
+ at(index: number): PendingWrite<TValue> {
45
+ const write = this.writes[index];
46
+ if (write === undefined) {
47
+ throw new Error(`No write at index ${String(index)}.`);
48
+ }
49
+ return write;
50
+ }
51
+
52
+ accept(index: number, revision: number): void {
53
+ this.at(index).result.resolve({ kind: 'accepted', revision });
54
+ }
55
+ }
56
+
57
+ type Options<TValue> = Partial<
58
+ RevisionedWriteQueueOptions<string, string, TValue, number, { readonly serverValue: string }>
59
+ >;
60
+
61
+ function createQueue<TValue = string>(
62
+ server: FakeServer<TValue>,
63
+ options: Options<TValue> = {},
64
+ ): RevisionedWriteQueue<string, string, TValue, number, { readonly serverValue: string }> {
65
+ return createRevisionedWriteQueue<
66
+ string,
67
+ string,
68
+ TValue,
69
+ number,
70
+ { readonly serverValue: string }
71
+ >({
72
+ initial: { scope: 'account-a', document: 'doc-1', acknowledgedRevision: 1 },
73
+ write: server.write,
74
+ ...options,
75
+ });
76
+ }
77
+
78
+ async function settle(): Promise<void> {
79
+ for (let turn = 0; turn < 5; turn += 1) {
80
+ await Promise.resolve();
81
+ }
82
+ }
83
+
84
+ describe('revisioned write queue', () => {
85
+ it('starts idle with the acknowledged revision and no unsent value', () => {
86
+ const queue = createQueue(new FakeServer());
87
+
88
+ expect(queue.getSnapshot()).toMatchObject({
89
+ status: 'idle',
90
+ scope: 'account-a',
91
+ document: 'doc-1',
92
+ acknowledgedRevision: 1,
93
+ unsent: null,
94
+ uncertain: null,
95
+ conflict: null,
96
+ error: null,
97
+ });
98
+ });
99
+
100
+ it('keeps an enqueued value unsent until the product flushes', async () => {
101
+ const server = new FakeServer();
102
+ const queue = createQueue(server);
103
+
104
+ queue.enqueue('draft');
105
+ await settle();
106
+
107
+ expect(server.writes).toHaveLength(0);
108
+ expect(queue.getSnapshot()).toMatchObject({
109
+ status: 'dirty',
110
+ acknowledgedRevision: 1,
111
+ unsent: { value: 'draft' },
112
+ });
113
+ });
114
+
115
+ describe('edits during save', () => {
116
+ it('keeps a newer edit dirty while the older write is in flight', async () => {
117
+ const server = new FakeServer();
118
+ const queue = createQueue(server);
119
+ const statuses: string[] = [];
120
+ queue.subscribe(() => statuses.push(queue.getSnapshot().status));
121
+
122
+ queue.enqueue('first');
123
+ const flushed = queue.flush();
124
+ queue.enqueue('second');
125
+
126
+ expect(queue.getSnapshot()).toMatchObject({
127
+ status: 'writing',
128
+ acknowledgedRevision: 1,
129
+ unsent: { value: 'second' },
130
+ });
131
+
132
+ server.accept(0, 2);
133
+ await settle();
134
+
135
+ expect(server.writes).toHaveLength(2);
136
+ expect(server.at(1).request).toMatchObject({ value: 'second', expectedRevision: 2 });
137
+ expect(queue.getSnapshot()).toMatchObject({
138
+ status: 'writing',
139
+ acknowledgedRevision: 2,
140
+ unsent: null,
141
+ });
142
+
143
+ server.accept(1, 3);
144
+ const snapshot = await flushed;
145
+
146
+ expect(snapshot).toMatchObject({ status: 'idle', acknowledgedRevision: 3, unsent: null });
147
+ expect(statuses.slice(0, -1)).not.toContain('idle');
148
+ });
149
+
150
+ it('never lets an older acknowledgement mark a newer value saved', async () => {
151
+ const server = new FakeServer();
152
+ const queue = createQueue(server);
153
+
154
+ queue.enqueue('first');
155
+ void queue.flush();
156
+ queue.enqueue('second');
157
+ server.at(0).result.resolve({ kind: 'rejected', error: new Error('offline') });
158
+ await settle();
159
+
160
+ expect(queue.getSnapshot()).toMatchObject({
161
+ status: 'failed',
162
+ acknowledgedRevision: 1,
163
+ unsent: { value: 'second' },
164
+ });
165
+ });
166
+ });
167
+
168
+ describe('several queued writes', () => {
169
+ it('coalesces three queued values to the newest by default', async () => {
170
+ const server = new FakeServer();
171
+ const queue = createQueue(server);
172
+
173
+ queue.enqueue('a');
174
+ const flushed = queue.flush();
175
+ queue.enqueue('b');
176
+ queue.enqueue('c');
177
+ queue.enqueue('d');
178
+ server.accept(0, 2);
179
+ await settle();
180
+ server.accept(1, 3);
181
+ await flushed;
182
+
183
+ expect(server.writes.map((write) => write.request.value)).toEqual(['a', 'd']);
184
+ expect(server.writes.map((write) => write.request.expectedRevision)).toEqual([1, 2]);
185
+ expect(queue.getSnapshot()).toMatchObject({ status: 'idle', acknowledgedRevision: 3 });
186
+ });
187
+
188
+ it('lets a custom coalescer keep every operation', async () => {
189
+ const server = new FakeServer<readonly string[]>();
190
+ const queue = createQueue(server, {
191
+ coalesce: (older, newer) => [...older, ...newer],
192
+ });
193
+
194
+ queue.enqueue(['a']);
195
+ const flushed = queue.flush();
196
+ queue.enqueue(['b']);
197
+ queue.enqueue(['c']);
198
+ queue.enqueue(['d']);
199
+ server.accept(0, 2);
200
+ await settle();
201
+ server.accept(1, 3);
202
+ await flushed;
203
+
204
+ expect(server.writes.map((write) => write.request.value)).toEqual([['a'], ['b', 'c', 'd']]);
205
+ });
206
+
207
+ it('sends values that arrive between writes in order with successive revisions', async () => {
208
+ const server = new FakeServer();
209
+ const queue = createQueue(server);
210
+
211
+ queue.enqueue('a');
212
+ const flushed = queue.flush();
213
+ queue.enqueue('b');
214
+ server.accept(0, 2);
215
+ await settle();
216
+ queue.enqueue('c');
217
+ server.accept(1, 3);
218
+ await settle();
219
+ server.accept(2, 4);
220
+ await flushed;
221
+
222
+ expect(
223
+ server.writes.map((write) => [write.request.value, write.request.expectedRevision]),
224
+ ).toEqual([
225
+ ['a', 1],
226
+ ['b', 2],
227
+ ['c', 3],
228
+ ]);
229
+ expect(queue.getSnapshot().acknowledgedRevision).toBe(4);
230
+ });
231
+ });
232
+
233
+ describe('concurrent flushes', () => {
234
+ it('shares one drain between concurrent callers', async () => {
235
+ const server = new FakeServer();
236
+ const queue = createQueue(server);
237
+
238
+ queue.enqueue('value');
239
+ const first = queue.flush();
240
+ const second = queue.flush();
241
+ queue.enqueue('later');
242
+ const third = queue.flush();
243
+
244
+ expect(second).toBe(first);
245
+ expect(third).toBe(first);
246
+ expect(server.writes).toHaveLength(1);
247
+
248
+ server.accept(0, 2);
249
+ await settle();
250
+ server.accept(1, 3);
251
+ const snapshots = await Promise.all([first, second, third]);
252
+
253
+ expect(server.writes).toHaveLength(2);
254
+ expect(snapshots.every((snapshot) => snapshot.status === 'idle')).toBe(true);
255
+ });
256
+
257
+ it('starts a new drain for a value enqueued after the previous drain finished', async () => {
258
+ const server = new FakeServer();
259
+ const queue = createQueue(server);
260
+
261
+ queue.enqueue('a');
262
+ const first = queue.flush();
263
+ server.accept(0, 2);
264
+ await first;
265
+ queue.enqueue('b');
266
+ const second = queue.flush();
267
+
268
+ expect(second).not.toBe(first);
269
+ expect(server.at(1).request).toMatchObject({ value: 'b', expectedRevision: 2 });
270
+ });
271
+
272
+ it('resolves immediately when nothing is unsent', async () => {
273
+ const server = new FakeServer();
274
+ const queue = createQueue(server);
275
+
276
+ await expect(queue.flush()).resolves.toMatchObject({ status: 'idle' });
277
+ expect(server.writes).toHaveLength(0);
278
+ });
279
+ });
280
+
281
+ describe('retry after a definite failure', () => {
282
+ it('keeps the acknowledged revision and resends the merged unsent value', async () => {
283
+ const server = new FakeServer();
284
+ const queue = createQueue(server);
285
+ const failure = new Error('validation');
286
+
287
+ queue.enqueue('a');
288
+ void queue.flush();
289
+ server.at(0).result.resolve({ kind: 'rejected', error: failure });
290
+ await settle();
291
+
292
+ expect(queue.getSnapshot()).toMatchObject({
293
+ status: 'failed',
294
+ acknowledgedRevision: 1,
295
+ unsent: { value: 'a' },
296
+ error: failure,
297
+ });
298
+
299
+ queue.enqueue('b');
300
+ const retried = queue.retry();
301
+
302
+ expect(server.at(1).request).toMatchObject({
303
+ value: 'b',
304
+ expectedRevision: 1,
305
+ afterUnknownOutcome: false,
306
+ });
307
+ server.accept(1, 2);
308
+
309
+ await expect(retried).resolves.toMatchObject({
310
+ status: 'idle',
311
+ acknowledgedRevision: 2,
312
+ error: null,
313
+ });
314
+ });
315
+
316
+ it('lets a later flush resume after a definite failure', async () => {
317
+ const server = new FakeServer();
318
+ const queue = createQueue(server);
319
+
320
+ queue.enqueue('a');
321
+ void queue.flush();
322
+ server.at(0).result.resolve({ kind: 'rejected', error: new Error('offline') });
323
+ await settle();
324
+ void queue.flush();
325
+
326
+ expect(server.at(1).request).toMatchObject({ value: 'a', expectedRevision: 1 });
327
+ });
328
+
329
+ it('merges the failed value with newer edits through the coalescer', async () => {
330
+ const server = new FakeServer<readonly string[]>();
331
+ const queue = createQueue(server, { coalesce: (older, newer) => [...older, ...newer] });
332
+
333
+ queue.enqueue(['a']);
334
+ void queue.flush();
335
+ queue.enqueue(['b']);
336
+ server.at(0).result.resolve({ kind: 'rejected', error: new Error('offline') });
337
+ await settle();
338
+
339
+ expect(queue.getSnapshot().unsent).toEqual({ value: ['a', 'b'] });
340
+ });
341
+ });
342
+
343
+ describe('ambiguous completion', () => {
344
+ it('pauses on an unknown outcome and never folds it into newer edits', async () => {
345
+ const server = new FakeServer();
346
+ const queue = createQueue(server);
347
+ const failure = new Error('connection reset');
348
+
349
+ queue.enqueue('a');
350
+ void queue.flush();
351
+ queue.enqueue('b');
352
+ server.at(0).result.reject(failure);
353
+ await settle();
354
+
355
+ expect(queue.getSnapshot()).toMatchObject({
356
+ status: 'unknown-outcome',
357
+ acknowledgedRevision: 1,
358
+ uncertain: { value: 'a', expectedRevision: 1 },
359
+ unsent: { value: 'b' },
360
+ error: failure,
361
+ });
362
+
363
+ await queue.flush();
364
+ expect(server.writes).toHaveLength(1);
365
+ });
366
+
367
+ it('replays the identical write with a flag when the product retries', async () => {
368
+ const server = new FakeServer();
369
+ const queue = createQueue(server);
370
+
371
+ queue.enqueue('a');
372
+ void queue.flush();
373
+ queue.enqueue('b');
374
+ server.at(0).result.reject(new Error('timeout'));
375
+ await settle();
376
+
377
+ const retried = queue.retry();
378
+ expect(server.at(1).request).toMatchObject({
379
+ value: 'a',
380
+ expectedRevision: 1,
381
+ afterUnknownOutcome: true,
382
+ });
383
+ expect(queue.getSnapshot()).toMatchObject({ status: 'writing', uncertain: null });
384
+
385
+ server.accept(1, 2);
386
+ await settle();
387
+ expect(server.at(2).request).toMatchObject({
388
+ value: 'b',
389
+ expectedRevision: 2,
390
+ afterUnknownOutcome: false,
391
+ });
392
+ server.accept(2, 3);
393
+
394
+ await expect(retried).resolves.toMatchObject({ status: 'idle', acknowledgedRevision: 3 });
395
+ });
396
+
397
+ it('treats a synchronous throw from the write callback as an unknown outcome', async () => {
398
+ const queue = createRevisionedWriteQueue<string, string, string, number, never>({
399
+ initial: { scope: 'account-a', document: 'doc-1', acknowledgedRevision: 1 },
400
+ write: () => {
401
+ throw new Error('boom');
402
+ },
403
+ });
404
+
405
+ queue.enqueue('a');
406
+ await expect(queue.flush()).resolves.toMatchObject({
407
+ status: 'unknown-outcome',
408
+ uncertain: { value: 'a', expectedRevision: 1 },
409
+ });
410
+ });
411
+
412
+ it('lets the product reseed after checking the server instead of replaying', async () => {
413
+ const server = new FakeServer();
414
+ const queue = createQueue(server);
415
+
416
+ queue.enqueue('a');
417
+ void queue.flush();
418
+ server.at(0).result.reject(new Error('timeout'));
419
+ await settle();
420
+ queue.reset({ scope: 'account-a', document: 'doc-1', acknowledgedRevision: 2 });
421
+
422
+ expect(queue.getSnapshot()).toMatchObject({
423
+ status: 'idle',
424
+ acknowledgedRevision: 2,
425
+ uncertain: null,
426
+ error: null,
427
+ });
428
+ });
429
+ });
430
+
431
+ describe('conflict', () => {
432
+ it('stops queued writes and keeps the conflicting value unsent', async () => {
433
+ const server = new FakeServer();
434
+ const queue = createQueue(server);
435
+
436
+ queue.enqueue('a');
437
+ void queue.flush();
438
+ queue.enqueue('b');
439
+ server.at(0).result.resolve({
440
+ kind: 'conflict',
441
+ currentRevision: 5,
442
+ conflict: { serverValue: 'theirs' },
443
+ });
444
+ await settle();
445
+
446
+ expect(server.writes).toHaveLength(1);
447
+ expect(queue.getSnapshot()).toMatchObject({
448
+ status: 'conflict',
449
+ acknowledgedRevision: 1,
450
+ unsent: { value: 'b' },
451
+ conflict: { currentRevision: 5, conflict: { serverValue: 'theirs' } },
452
+ });
453
+
454
+ queue.enqueue('c');
455
+ await queue.flush();
456
+ await queue.retry();
457
+ expect(server.writes).toHaveLength(1);
458
+ expect(queue.getSnapshot()).toMatchObject({ status: 'conflict', unsent: { value: 'c' } });
459
+ });
460
+
461
+ it('resumes only after the product resets to the current revision', async () => {
462
+ const server = new FakeServer();
463
+ const queue = createQueue(server);
464
+
465
+ queue.enqueue('mine');
466
+ void queue.flush();
467
+ server.at(0).result.resolve({
468
+ kind: 'conflict',
469
+ currentRevision: 5,
470
+ conflict: { serverValue: 'theirs' },
471
+ });
472
+ await settle();
473
+
474
+ queue.reset({ scope: 'account-a', document: 'doc-1', acknowledgedRevision: 5 });
475
+ queue.enqueue('mine');
476
+ const flushed = queue.flush();
477
+ expect(server.at(1).request).toMatchObject({ value: 'mine', expectedRevision: 5 });
478
+ server.accept(1, 6);
479
+
480
+ await expect(flushed).resolves.toMatchObject({
481
+ status: 'idle',
482
+ acknowledgedRevision: 6,
483
+ conflict: null,
484
+ });
485
+ });
486
+ });
487
+
488
+ describe('cancellation', () => {
489
+ it('aborts the active write, drops unsent values, and ignores the late result', async () => {
490
+ const server = new FakeServer();
491
+ const queue = createQueue(server);
492
+
493
+ queue.enqueue('a');
494
+ const flushed = queue.flush();
495
+ queue.enqueue('b');
496
+ queue.cancel();
497
+
498
+ expect(server.at(0).request.signal.aborted).toBe(true);
499
+ expect(queue.getSnapshot()).toMatchObject({
500
+ status: 'cancelled',
501
+ acknowledgedRevision: 1,
502
+ unsent: null,
503
+ });
504
+
505
+ server.accept(0, 2);
506
+ await expect(flushed).resolves.toMatchObject({ status: 'cancelled' });
507
+ await settle();
508
+ expect(server.writes).toHaveLength(1);
509
+ expect(queue.getSnapshot().acknowledgedRevision).toBe(1);
510
+ });
511
+
512
+ it('ignores enqueue, flush, and retry after cancellation', async () => {
513
+ const server = new FakeServer();
514
+ const queue = createQueue(server);
515
+
516
+ queue.cancel();
517
+ queue.enqueue('a');
518
+ await queue.flush();
519
+ await queue.retry();
520
+
521
+ expect(server.writes).toHaveLength(0);
522
+ expect(queue.getSnapshot()).toMatchObject({ status: 'cancelled', unsent: null });
523
+ });
524
+
525
+ it('cancels when the injected signal aborts', async () => {
526
+ const server = new FakeServer();
527
+ const host = new AbortController();
528
+ const queue = createQueue(server, { signal: host.signal });
529
+
530
+ queue.enqueue('a');
531
+ void queue.flush();
532
+ host.abort();
533
+ server.accept(0, 2);
534
+ await settle();
535
+
536
+ expect(server.at(0).request.signal.aborted).toBe(true);
537
+ expect(queue.getSnapshot()).toMatchObject({ status: 'cancelled', acknowledgedRevision: 1 });
538
+ });
539
+
540
+ it('starts cancelled when the injected signal already aborted', () => {
541
+ const host = new AbortController();
542
+ host.abort();
543
+ const queue = createQueue(new FakeServer(), { signal: host.signal });
544
+
545
+ queue.reset({ scope: 'account-b', document: 'doc-2', acknowledgedRevision: 1 });
546
+ expect(queue.getSnapshot().status).toBe('cancelled');
547
+ });
548
+
549
+ it('can be reused after a product reset', () => {
550
+ const server = new FakeServer();
551
+ const queue = createQueue(server);
552
+
553
+ queue.cancel();
554
+ queue.reset({ scope: 'account-a', document: 'doc-1', acknowledgedRevision: 7 });
555
+ queue.enqueue('a');
556
+ void queue.flush();
557
+
558
+ expect(server.at(0).request).toMatchObject({ value: 'a', expectedRevision: 7 });
559
+ });
560
+ });
561
+
562
+ describe('scope changes', () => {
563
+ it('fences a late completion after an account switch', async () => {
564
+ const server = new FakeServer();
565
+ const queue = createQueue(server);
566
+
567
+ queue.enqueue('a-value');
568
+ const oldFlush = queue.flush();
569
+ queue.enqueue('a-later');
570
+ queue.reset({ scope: 'account-b', document: 'doc-9', acknowledgedRevision: 40 });
571
+
572
+ expect(server.at(0).request.signal.aborted).toBe(true);
573
+ expect(queue.getSnapshot()).toMatchObject({
574
+ status: 'idle',
575
+ scope: 'account-b',
576
+ document: 'doc-9',
577
+ acknowledgedRevision: 40,
578
+ unsent: null,
579
+ });
580
+
581
+ server.accept(0, 2);
582
+ await oldFlush;
583
+ await settle();
584
+
585
+ expect(server.writes).toHaveLength(1);
586
+ expect(queue.getSnapshot()).toMatchObject({ scope: 'account-b', acknowledgedRevision: 40 });
587
+ });
588
+
589
+ it('fences late failures and conflicts after a document switch', async () => {
590
+ const server = new FakeServer();
591
+ const queue = createQueue(server);
592
+
593
+ queue.enqueue('a');
594
+ void queue.flush();
595
+ queue.reset({ scope: 'account-a', document: 'doc-2', acknowledgedRevision: 10 });
596
+ queue.enqueue('b');
597
+ void queue.flush();
598
+
599
+ server.at(0).result.resolve({
600
+ kind: 'conflict',
601
+ currentRevision: 3,
602
+ conflict: { serverValue: 'x' },
603
+ });
604
+ await settle();
605
+
606
+ expect(queue.getSnapshot()).toMatchObject({
607
+ status: 'writing',
608
+ document: 'doc-2',
609
+ conflict: null,
610
+ });
611
+ expect(server.at(1).request).toMatchObject({
612
+ document: 'doc-2',
613
+ value: 'b',
614
+ expectedRevision: 10,
615
+ });
616
+
617
+ server.accept(1, 11);
618
+ await settle();
619
+ expect(queue.getSnapshot()).toMatchObject({ status: 'idle', acknowledgedRevision: 11 });
620
+ });
621
+
622
+ it('ignores a late A write after switching A to B and back to A', async () => {
623
+ const server = new FakeServer();
624
+ const queue = createQueue(server);
625
+
626
+ queue.enqueue('first-a');
627
+ void queue.flush();
628
+ queue.reset({ scope: 'account-b', document: 'doc-1', acknowledgedRevision: 1 });
629
+ queue.reset({ scope: 'account-a', document: 'doc-1', acknowledgedRevision: 3 });
630
+ queue.enqueue('second-a');
631
+ const flushed = queue.flush();
632
+
633
+ server.at(0).result.reject(new Error('aborted'));
634
+ await settle();
635
+ expect(queue.getSnapshot()).toMatchObject({ status: 'writing', uncertain: null });
636
+
637
+ server.accept(1, 4);
638
+ await expect(flushed).resolves.toMatchObject({
639
+ status: 'idle',
640
+ scope: 'account-a',
641
+ acknowledgedRevision: 4,
642
+ });
643
+ });
644
+
645
+ it('passes the scope and document of the generation that started the write', () => {
646
+ const server = new FakeServer();
647
+ const queue = createQueue(server);
648
+
649
+ queue.enqueue('a');
650
+ void queue.flush();
651
+
652
+ expect(server.at(0).request).toMatchObject({ scope: 'account-a', document: 'doc-1' });
653
+ });
654
+ });
655
+
656
+ describe('observable snapshot', () => {
657
+ it('notifies subscribers and keeps the snapshot stable between changes', () => {
658
+ const queue = createQueue(new FakeServer());
659
+ let notifications = 0;
660
+ const unsubscribe = queue.subscribe(() => {
661
+ notifications += 1;
662
+ });
663
+
664
+ const before = queue.getSnapshot();
665
+ expect(queue.getSnapshot()).toBe(before);
666
+ queue.enqueue('a');
667
+ expect(notifications).toBe(1);
668
+ expect(queue.getSnapshot()).not.toBe(before);
669
+
670
+ unsubscribe();
671
+ queue.enqueue('b');
672
+ expect(notifications).toBe(1);
673
+ });
674
+ });
675
+ });
676
+
677
+ it('exports the queue from its own entry point only', async () => {
678
+ const [root, entry] = await Promise.all([
679
+ import('@baukit/data-contracts'),
680
+ import('@baukit/data-contracts/revisioned-writes'),
681
+ ]);
682
+ expect(entry.createRevisionedWriteQueue).toBeTypeOf('function');
683
+ expect(Object.keys(root)).not.toContain('createRevisionedWriteQueue');
684
+ });