@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 505 lines 21.7 KB
Raw
1 import { SqliteClient } from "@effect/sql-sqlite-node"
2 import { assert, describe, it } from "@effect/vitest"
3 import { Effect, Layer, Queue, Redacted, Stream } from "effect"
4 import * as CompactionTest from "effect-test/eventlog/EventLogServerEncryptedCompactionTest"
5 import * as EncryptedTest from "effect-test/eventlog/EventLogServerEncryptedTest"
6 import * as SqlEventLogServerEncryptedStorageTest from "effect-test/eventlog/SqlEventLogServerEncryptedStorageTest"
7 import * as Digest from "effect/crypto/Digest"
8 import * as EventJournal from "effect/eventlog/EventJournal"
9 import * as EventLog from "effect/eventlog/EventLog"
10 import * as EventLogEncryption from "effect/eventlog/EventLogEncryption"
11 import * as EventLogMessage from "effect/eventlog/EventLogMessage"
12 import type { StoreId } from "effect/eventlog/EventLogMessage"
13 import * as EventLogServer from "effect/eventlog/EventLogServerEncrypted"
14 import * as EventLogSessionAuth from "effect/eventlog/EventLogSessionAuth"
15 import { makeGetIdentityRootSecretMaterial } from "effect/eventlog/internal/identityRootSecretDerivation"
16 import * as SqlEventLogServer from "effect/eventlog/SqlEventLogServerEncrypted"
17 import { Reactivity } from "effect/reactivity"
18 import * as RpcTest from "effect/rpc/RpcTest"
19 import * as SqlClient from "effect/sql/SqlClient"
20
21 EncryptedTest.suite(
22 "SQLite",
23 SqlEventLogServer.layerStorage().pipe(
24 Layer.provide(SqliteClient.layer({ filename: ":memory:" })),
25 Layer.provide(Reactivity.layer),
26 Layer.provide(EventLogEncryption.layerSubtle),
27 Layer.provide(Digest.layerWebCrypto)
28 )
29 )
30
31 CompactionTest.suite(
32 "SQLite",
33 (options) => SqlEventLogServer.layerStorage(options).pipe(Layer.provide(Digest.layerWebCrypto)),
34 SqliteClient.layer({ filename: ":memory:" })
35 )
36
37 SqlEventLogServerEncryptedStorageTest.compactionSuite("SQLite", SqliteClient.layer({ filename: ":memory:" }))
38
39 const storeIdA = "store-a" as StoreId
40 const storeIdB = "store-b" as StoreId
41
42 const makeEntry = (value: number) =>
43 new EventJournal.Entry({
44 id: EventJournal.makeEntryIdUnsafe(),
45 event: "UserCreated",
46 primaryKey: `user-${value}`,
47 payload: new Uint8Array([value])
48 }, { disableChecks: true })
49
50 const encodeWrite = Effect.fnUntraced(function*(
51 encryption: EventLogEncryption.EventLogEncryption["Service"],
52 identity: EventLog.Identity["Service"],
53 entry: EventJournal.Entry
54 ) {
55 const batches = yield* encryption.encrypt(identity, storeIdA, [entry])
56 return yield* new EventLogMessage.WriteEntries({
57 publicKey: identity.publicKey,
58 storeId: storeIdA,
59 batches
60 }).encoded
61 })
62
63 const makeBatch = (index: number, entryId = EventJournal.makeEntryIdUnsafe()): EventLogEncryption.EncryptedBatch => ({
64 entryIds: [entryId],
65 iv: new Uint8Array(12),
66 encryptedBatch: Uint8Array.of(index)
67 })
68
69 const getIdentityRootSecretMaterial = makeGetIdentityRootSecretMaterial(globalThis.crypto)
70
71 const makeAuthenticateRequest = Effect.fnUntraced(function*(options: {
72 readonly identity: EventLog.Identity["Service"]
73 readonly challenge: Uint8Array
74 readonly remoteId: EventJournal.RemoteId
75 }) {
76 const rootSecretMaterial = yield* getIdentityRootSecretMaterial(options.identity)
77 const signature = yield* EventLogSessionAuth.signSessionAuthPayload({
78 remoteId: options.remoteId,
79 challenge: options.challenge,
80 publicKey: options.identity.publicKey,
81 signingPublicKey: rootSecretMaterial.signingPublicKey,
82 signingPrivateKey: Redacted.value(rootSecretMaterial.signingPrivateKey)
83 })
84 return new EventLogMessage.Authenticate({
85 publicKey: options.identity.publicKey,
86 signingPublicKey: rootSecretMaterial.signingPublicKey,
87 signature,
88 algorithm: "Ed25519"
89 })
90 })
91
92 const makeAuthenticatedRpcClient = Effect.fnUntraced(function*(
93 storage: EventLogServer.Storage["Service"],
94 identities: ReadonlyArray<EventLog.Identity["Service"]>
95 ) {
96 const rpcClient = yield* RpcTest.makeClient(EventLogMessage.EventLogRemoteRpcs).pipe(
97 Effect.provide(
98 EventLogServer.layerRpcHandlers.pipe(
99 Layer.provide(Layer.succeed(EventLogServer.Storage, storage))
100 )
101 )
102 )
103 for (const identity of identities) {
104 const hello = yield* rpcClient["EventLog.Hello"]()
105 yield* rpcClient["EventLog.Authenticate"](
106 yield* makeAuthenticateRequest({
107 identity,
108 challenge: hello.challenge,
109 remoteId: hello.remoteId
110 })
111 )
112 }
113 return rpcClient
114 })
115
116 const assertForbidden = Effect.fnUntraced(function*<A>(
117 effect: Effect.Effect<A, EventLogMessage.EventLogProtocolError>
118 ) {
119 const error = yield* Effect.flip(effect)
120 assert.instanceOf(error, EventLogMessage.EventLogProtocolError)
121 assert.strictEqual(error.code, "Forbidden")
122 })
123
124 describe("SqlEventLogServer", () => {
125 it.effect("forbids reading another identity's changes", () =>
126 Effect.gen(function*() {
127 const sql = yield* SqliteClient.make({ filename: ":memory:" })
128 const storage = yield* SqlEventLogServer.makeStorage().pipe(
129 Effect.provideService(SqlClient.SqlClient, sql)
130 )
131 const encryption = yield* EventLogEncryption.EventLogEncryption
132 const identityA = yield* encryption.generateIdentity
133 const identityB = yield* encryption.generateIdentity
134 const rpcClient = yield* makeAuthenticatedRpcClient(storage, [identityA])
135
136 yield* storage.write(identityB.publicKey, storeIdA, [makeBatch(1)])
137 const error = yield* rpcClient["EventLog.Changes"]({
138 publicKey: identityB.publicKey,
139 storeId: storeIdA,
140 startSequence: 0
141 }).pipe(
142 Stream.take(1),
143 Stream.runCollect,
144 Effect.flip
145 )
146
147 assert.instanceOf(error, EventLogMessage.EventLogProtocolError)
148 assert.strictEqual(error.code, "Forbidden")
149 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
150
151 it.effect("forbids writing entries for another identity", () =>
152 Effect.gen(function*() {
153 const sql = yield* SqliteClient.make({ filename: ":memory:" })
154 const storage = yield* SqlEventLogServer.makeStorage().pipe(
155 Effect.provideService(SqlClient.SqlClient, sql)
156 )
157 const encryption = yield* EventLogEncryption.EventLogEncryption
158 const identityA = yield* encryption.generateIdentity
159 const identityB = yield* encryption.generateIdentity
160 const rpcClient = yield* makeAuthenticatedRpcClient(storage, [identityA])
161 const entry = makeEntry(1)
162 const data = yield* encodeWrite(encryption, identityB, entry)
163
164 const error = yield* rpcClient["EventLog.WriteSingle"]({ data }).pipe(Effect.flip)
165
166 assert.instanceOf(error, EventLogMessage.EventLogProtocolError)
167 assert.strictEqual(error.code, "Forbidden")
168 const written = yield* storage.write(identityB.publicKey, storeIdA, [makeBatch(2)])
169 assert.deepStrictEqual(written.map((entry) => entry.sequence), [1])
170 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
171
172 it.effect("forbids writing chunked entries for another identity", () =>
173 Effect.gen(function*() {
174 const sql = yield* SqliteClient.make({ filename: ":memory:" })
175 const storage = yield* SqlEventLogServer.makeStorage().pipe(
176 Effect.provideService(SqlClient.SqlClient, sql)
177 )
178 const encryption = yield* EventLogEncryption.EventLogEncryption
179 const identityA = yield* encryption.generateIdentity
180 const identityB = yield* encryption.generateIdentity
181 const rpcClient = yield* makeAuthenticatedRpcClient(storage, [identityA])
182 const entry = makeEntry(1)
183 const data = yield* encodeWrite(encryption, identityB, entry)
184 const midpoint = Math.ceil(data.byteLength / 2)
185 const parts = [
186 new EventLogMessage.ChunkedMessage({ id: 1, part: [0, 2], data: data.subarray(0, midpoint) }),
187 new EventLogMessage.ChunkedMessage({ id: 1, part: [1, 2], data: data.subarray(midpoint) })
188 ] as const
189
190 yield* rpcClient["EventLog.WriteChunked"](parts[0])
191 const error = yield* rpcClient["EventLog.WriteChunked"](parts[1]).pipe(Effect.flip)
192
193 assert.instanceOf(error, EventLogMessage.EventLogProtocolError)
194 assert.strictEqual(error.code, "Forbidden")
195 const written = yield* storage.write(identityB.publicKey, storeIdA, [makeBatch(2)])
196 assert.deepStrictEqual(written.map((entry) => entry.sequence), [1])
197 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
198
199 it.effect("isolates authenticated identities between connections", () =>
200 Effect.gen(function*() {
201 const sql = yield* SqliteClient.make({ filename: ":memory:" })
202 const storage = yield* SqlEventLogServer.makeStorage().pipe(
203 Effect.provideService(SqlClient.SqlClient, sql)
204 )
205 const encryption = yield* EventLogEncryption.EventLogEncryption
206 const identityA = yield* encryption.generateIdentity
207 const identityB = yield* encryption.generateIdentity
208 const handlers = yield* Layer.build(
209 EventLogServer.layerRpcHandlers.pipe(
210 Layer.provide(Layer.succeed(EventLogServer.Storage, storage))
211 )
212 )
213 const rpcClientA = yield* RpcTest.makeClient(EventLogMessage.EventLogRemoteRpcs).pipe(
214 Effect.provide(handlers)
215 )
216 const rpcClientB = yield* RpcTest.makeClient(EventLogMessage.EventLogRemoteRpcs).pipe(
217 Effect.provide(handlers)
218 )
219 const helloA = yield* rpcClientA["EventLog.Hello"]()
220 yield* rpcClientA["EventLog.Authenticate"](
221 yield* makeAuthenticateRequest({
222 identity: identityA,
223 challenge: helloA.challenge,
224 remoteId: helloA.remoteId
225 })
226 )
227 const helloB = yield* rpcClientB["EventLog.Hello"]()
228 yield* rpcClientB["EventLog.Authenticate"](
229 yield* makeAuthenticateRequest({
230 identity: identityB,
231 challenge: helloB.challenge,
232 remoteId: helloB.remoteId
233 })
234 )
235 const data = yield* encodeWrite(encryption, identityB, makeEntry(1))
236 const midpoint = Math.ceil(data.byteLength / 2)
237 const parts = [
238 new EventLogMessage.ChunkedMessage({ id: 1, part: [0, 2], data: data.subarray(0, midpoint) }),
239 new EventLogMessage.ChunkedMessage({ id: 1, part: [1, 2], data: data.subarray(midpoint) })
240 ] as const
241
242 yield* storage.write(identityB.publicKey, storeIdA, [makeBatch(1)])
243 yield* assertForbidden(
244 rpcClientA["EventLog.Changes"]({
245 publicKey: identityB.publicKey,
246 storeId: storeIdA,
247 startSequence: 0
248 }).pipe(Stream.take(1), Stream.runCollect)
249 )
250 yield* assertForbidden(rpcClientA["EventLog.WriteSingle"]({ data }))
251 yield* rpcClientA["EventLog.WriteChunked"](parts[0])
252 yield* assertForbidden(rpcClientA["EventLog.WriteChunked"](parts[1]))
253 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
254
255 it.effect("supports multiple authenticated identities on one connection", () =>
256 Effect.gen(function*() {
257 const sql = yield* SqliteClient.make({ filename: ":memory:" })
258 const storage = yield* SqlEventLogServer.makeStorage().pipe(
259 Effect.provideService(SqlClient.SqlClient, sql)
260 )
261 const encryption = yield* EventLogEncryption.EventLogEncryption
262 const identityA = yield* encryption.generateIdentity
263 const identityB = yield* encryption.generateIdentity
264 const rpcClient = yield* makeAuthenticatedRpcClient(storage, [identityA, identityB])
265 const entryA = makeEntry(1)
266 const entryB = makeEntry(2)
267 const dataA = yield* encodeWrite(encryption, identityA, entryA)
268 const dataB = yield* encodeWrite(encryption, identityB, entryB)
269
270 yield* rpcClient["EventLog.WriteSingle"]({ data: dataA })
271 yield* rpcClient["EventLog.WriteSingle"]({ data: dataB })
272 const changesA = yield* rpcClient["EventLog.Changes"]({
273 publicKey: identityA.publicKey,
274 storeId: storeIdA,
275 startSequence: 0
276 }).pipe(Stream.take(1), Stream.runCollect)
277 const changesB = yield* rpcClient["EventLog.Changes"]({
278 publicKey: identityB.publicKey,
279 storeId: storeIdA,
280 startSequence: 0
281 }).pipe(Stream.take(1), Stream.runCollect)
282
283 assert.strictEqual(changesA.length, 1)
284 assert.strictEqual(changesB.length, 1)
285 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
286
287 it.effect("persists remote id across storage instances", () =>
288 Effect.gen(function*() {
289 const sql = yield* SqliteClient.make({ filename: ":memory:" })
290 const storageA = yield* SqlEventLogServer.makeStorage().pipe(
291 Effect.provideService(SqlClient.SqlClient, sql)
292 )
293 const storageB = yield* SqlEventLogServer.makeStorage().pipe(
294 Effect.provideService(SqlClient.SqlClient, sql)
295 )
296 const idA = yield* storageA.getId
297 const idB = yield* storageB.getId
298 assert.deepStrictEqual(idA, idB)
299 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
300
301 it.effect("rejects session-auth rebinding for an existing publicKey", () =>
302 Effect.gen(function*() {
303 const sql = yield* SqliteClient.make({ filename: ":memory:" })
304 const storage = yield* SqlEventLogServer.makeStorage().pipe(
305 Effect.provideService(SqlClient.SqlClient, sql)
306 )
307 const rpcClient = yield* RpcTest.makeClient(EventLogMessage.EventLogRemoteRpcs).pipe(
308 Effect.provide(
309 EventLogServer.layerRpcHandlers.pipe(
310 Layer.provide(Layer.succeed(EventLogServer.Storage, storage))
311 )
312 )
313 )
314
315 const firstIdentity = yield* EventLog.makeIdentity
316 const secondIdentitySeed = yield* EventLog.makeIdentity
317 const secondIdentity: EventLog.Identity["Service"] = {
318 publicKey: firstIdentity.publicKey,
319 privateKey: secondIdentitySeed.privateKey
320 }
321
322 const firstMaterial = yield* getIdentityRootSecretMaterial(firstIdentity)
323 const secondMaterial = yield* getIdentityRootSecretMaterial(secondIdentity)
324 const sameSigningPublicKey =
325 firstMaterial.signingPublicKey.byteLength === secondMaterial.signingPublicKey.byteLength &&
326 firstMaterial.signingPublicKey.every((byte, index) => byte === secondMaterial.signingPublicKey[index])
327 assert.strictEqual(sameSigningPublicKey, false)
328
329 const firstHello = yield* rpcClient["EventLog.Hello"]()
330 yield* rpcClient["EventLog.Authenticate"](
331 yield* makeAuthenticateRequest({
332 identity: firstIdentity,
333 challenge: firstHello.challenge,
334 remoteId: firstHello.remoteId
335 })
336 )
337
338 const secondHello = yield* rpcClient["EventLog.Hello"]()
339 const error = yield* rpcClient["EventLog.Authenticate"](
340 yield* makeAuthenticateRequest({
341 identity: secondIdentity,
342 challenge: secondHello.challenge,
343 remoteId: secondHello.remoteId
344 })
345 ).pipe(Effect.flip)
346
347 assert.instanceOf(error, EventLogMessage.EventLogProtocolError)
348 assert.strictEqual(error.code, "Forbidden")
349 assert.strictEqual(error.message, "Session auth signature verification failed")
350 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
351
352 it.effect("writes entries and streams changes", () =>
353 Effect.gen(function*() {
354 const sql = yield* SqliteClient.make({ filename: ":memory:" })
355 const storage = yield* SqlEventLogServer.makeStorage().pipe(
356 Effect.provideService(SqlClient.SqlClient, sql)
357 )
358 const encryption = yield* EventLogEncryption.EventLogEncryption
359 const identity = yield* encryption.generateIdentity
360 const entries = [makeEntry(1), makeEntry(2)]
361 const persisted = yield* encryption.encrypt(identity, storeIdA, entries)
362 const written = yield* storage.write(identity.publicKey, storeIdA, persisted)
363 assert.deepStrictEqual(written.map((batch) => batch.sequence), [1])
364 assert.deepStrictEqual(
365 (yield* encryption.decrypt(identity, storeIdA, written)).map((entry) => entry.remoteSequence),
366 [1, 2]
367 )
368
369 const changes = yield* storage.changes(identity.publicKey, storeIdA, 0).pipe(
370 Stream.toQueue({ capacity: "unbounded" })
371 )
372 const taken = yield* Queue.takeAll(changes)
373 assert.deepStrictEqual(
374 (yield* encryption.decrypt(identity, storeIdA, taken)).map((entry) => entry.remoteSequence),
375 [1, 2]
376 )
377
378 const nextEntry = makeEntry(3)
379 const nextPersisted = yield* encryption.encrypt(identity, storeIdA, [nextEntry])
380 const updated = yield* storage.write(identity.publicKey, storeIdA, nextPersisted)
381 assert.deepStrictEqual(updated.map((entry) => entry.sequence), [3])
382
383 const next = yield* Queue.take(changes)
384 assert.strictEqual(next.sequence, 3)
385 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
386
387 it.effect("publishes each entry only once when the same batch is written twice", () =>
388 Effect.gen(function*() {
389 const sql = yield* SqliteClient.make({ filename: ":memory:" })
390 const storage = yield* SqlEventLogServer.makeStorage().pipe(
391 Effect.provideService(SqlClient.SqlClient, sql)
392 )
393 const entries = [makeBatch(1), makeBatch(2)]
394 const written = yield* storage.write("client-1", storeIdA, entries)
395 assert.deepStrictEqual(written.map((entry) => entry.sequence), [1, 2])
396
397 const changes = yield* storage.changes("client-1", storeIdA, 0).pipe(
398 Stream.toQueue({ capacity: "unbounded" })
399 )
400 assert.deepStrictEqual([yield* Queue.take(changes), yield* Queue.take(changes)], written)
401
402 yield* storage.write("client-1", storeIdA, entries)
403 assert.sameDeepMembers(
404 [...yield* storage.entrySequences("client-1", storeIdA, [entries[1].entryIds[0], entries[0].entryIds[0]])],
405 [
406 { entryId: entries[1].entryIds[0], sequence: 2 },
407 { entryId: entries[0].entryIds[0], sequence: 1 }
408 ]
409 )
410 const next = yield* storage.write("client-1", storeIdA, [makeBatch(3)])
411 // A fresh entry marks the end of the replay without a sleep or timeout.
412 const published = yield* Stream.fromQueue(changes).pipe(
413 Stream.takeUntil((entry) => entry.sequence === next[0].sequence),
414 Stream.runCollect
415 )
416 const backlog = yield* storage.changes("client-1", storeIdA, 0).pipe(
417 Stream.take(3),
418 Stream.runCollect
419 )
420 assert.deepStrictEqual(backlog, [...written, ...next])
421 assert.deepStrictEqual(published, next)
422 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
423
424 it.effect("isolates same publicKey across storeIds", () =>
425 Effect.gen(function*() {
426 const sql = yield* SqliteClient.make({ filename: ":memory:" })
427 const storage = yield* SqlEventLogServer.makeStorage().pipe(
428 Effect.provideService(SqlClient.SqlClient, sql)
429 )
430
431 yield* storage.write("client-1", storeIdA, [makeBatch(1)])
432 yield* storage.write("client-1", storeIdB, [makeBatch(2)])
433
434 const storeAEntries = yield* storage.changes("client-1", storeIdA, 0).pipe(
435 Stream.take(1),
436 Stream.runCollect
437 )
438 const storeBEntries = yield* storage.changes("client-1", storeIdB, 0).pipe(
439 Stream.take(1),
440 Stream.runCollect
441 )
442
443 assert.deepStrictEqual(storeAEntries.map((entry) => entry.sequence), [1])
444 assert.deepStrictEqual(storeBEntries.map((entry) => entry.sequence), [1])
445 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
446
447 it.effect("isolates same storeId across publicKeys", () =>
448 Effect.gen(function*() {
449 const sql = yield* SqliteClient.make({ filename: ":memory:" })
450 const storage = yield* SqlEventLogServer.makeStorage().pipe(
451 Effect.provideService(SqlClient.SqlClient, sql)
452 )
453
454 yield* storage.write("client-1", storeIdA, [makeBatch(1)])
455 yield* storage.write("client-2", storeIdA, [makeBatch(2)])
456
457 const clientOneEntries = yield* storage.changes("client-1", storeIdA, 0).pipe(
458 Stream.take(1),
459 Stream.runCollect
460 )
461 const clientTwoEntries = yield* storage.changes("client-2", storeIdA, 0).pipe(
462 Stream.take(1),
463 Stream.runCollect
464 )
465
466 assert.deepStrictEqual(clientOneEntries.map((entry) => entry.sequence), [1])
467 assert.deepStrictEqual(clientTwoEntries.map((entry) => entry.sequence), [1])
468 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
469
470 it.effect("keeps deduplication isolated per encrypted scope", () =>
471 Effect.gen(function*() {
472 const sql = yield* SqliteClient.make({ filename: ":memory:" })
473 const storage = yield* SqlEventLogServer.makeStorage().pipe(
474 Effect.provideService(SqlClient.SqlClient, sql)
475 )
476 const sharedEntryId = EventJournal.makeEntryIdUnsafe()
477
478 yield* storage.write("client-1", storeIdA, [makeBatch(1, sharedEntryId)])
479 yield* storage.write("client-1", storeIdA, [makeBatch(2, sharedEntryId)])
480 yield* storage.write("client-1", storeIdB, [makeBatch(3, sharedEntryId)])
481 yield* storage.write("client-2", storeIdA, [makeBatch(4, sharedEntryId)])
482
483 assert.deepStrictEqual(
484 (yield* storage.changes("client-1", storeIdA, 0).pipe(
485 Stream.take(1),
486 Stream.runCollect
487 )).map((entry) => entry.sequence),
488 [1]
489 )
490 assert.deepStrictEqual(
491 (yield* storage.changes("client-1", storeIdB, 0).pipe(
492 Stream.take(1),
493 Stream.runCollect
494 )).map((entry) => entry.sequence),
495 [1]
496 )
497 assert.deepStrictEqual(
498 (yield* storage.changes("client-2", storeIdA, 0).pipe(
499 Stream.take(1),
500 Stream.runCollect
501 )).map((entry) => entry.sequence),
502 [1]
503 )
504 }).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle, Digest.layerWebCrypto])))
505 })