( currentState: TodoState, event: Readonly<TodoEvent> )

( currentState: TodoProjection, event: Readonly<TodoEvent> )

(filter: (message: Readonly<TransportMessage>) => boolean)

(filter: (message: ReadonlyDeep<TransportMessage>) => boolean)

(listId: string)

(todoId: TodoId)

( allEventsStream: EventStream<StreamEvent<V>>, streamEnd: EventStreamPosition, newEvents: Chunk.C

( changedFiles: readonly string[], packages: readonly PackageInternal[], rootDir: string )

(server: ReadonlyDeep<InMemoryServer>)

(actual: A, expected: A, message?: string, ..._: Array<never>)

(connections: ReadonlyArray<{ readonly clientId: string }>)

( either: Either.Either<R, L>, expected: L, ..._: Array<never> )

(expectedId: string, messages: ReadonlyArray<TransportMessage>)

( expectedType: string, messages: ReadonlyArray<TransportMessage> )

( option: Option.Option<A>, ..._: Array<never> )

( either: Either.Either<R, L>, expected: R, ..._: Array<never> )

(connections: ReadonlyArray<{ readonly clientId: string }>)

( option: Option.Option<A>, expected: A, ..._: Array<never> )

( exit: Exit.Exit<A, E>, expected: A, ..._: Array<never> )

(result: CommandResult)

(result: CommandResult)

(error: ReadonlyDeep<FailureError>)

(error: ReadonlyDeep<FailureError>)

(error: ReadonlyDeep<FailureError>)

( deferred: Deferred.Deferred<CommandResult>, commandId: string )

( connectedDeferred: Readonly<Deferred.Deferred<void, ConnectionError>>, url: Readonly<string> )

(streamId: EventStreamId)

( subscriptionManager: SubscriptionManagerService, streamId: EventStreamId, payload: NotificationPayload

(subscriptionManager: SubscriptionManagerService)

( subscriptionManager: SubscriptionManagerService, streamId: EventStreamId, payload: NotificationPayload

( server: ServerTransport, client1Messages: Stream.Stream<TransportMessage, never, never>,

( server: ReadonlyDeep<Server.Transport>, event: ReadonlyDeep<Event & { readonly streamId: EventStreamId }

( server: ReadonlyDeep<Server.Transport>, event: ReadonlyDeep<Event & { readonly streamId: EventStreamId }

( server: ServerTransport, filteredMessages: Stream.Stream<TransportMessage, never, never>

(serverState: ReadonlyDeep<InMemoryServerState>)

(message: ReadonlyDeep<TransportMessage>)

()

()

()

( server: ReadonlyDeep<Server.Transport>, event: ReadonlyDeep<Event & { readonly streamId: EventStreamId }

( server: ReadonlyDeep<Server.Transport>, commandId: string, result: ReadonlyDeep<CommandResult>, time

( clientId: Server.ClientId, connectedAt: ReadonlyDeep<Date>, ws: ReadonlyDeep<ServerWebSocket<Web

( serverState: ReadonlyDeep<InMemoryServerState>, connectionStatePubSub: ReadonlyDeep<PubSub.PubSub<Connec

( commands: ReadonlyDeep<T> )

(config: Readonly<ConnectionConfig>)

(clientState: ReadonlyDeep<InMemoryClientState>)

(changedPackages: ReadonlySet<string>, packageDependencyMap: Record<string, readonly string[]>)

(streamDir: string, path: Path.Path, filename: string)

(packagesDir: string)

(dir: string)

( layer: Layer.Layer<Protocol, TransportError | ConnectionError, Scope> )

( commands: ReadonlyDeep<T> )

(connectionsQueue: ReadonlyDeep<Queue.Queue<Server.ClientConnection>>)

()

(allEventsStream: EventStream<StreamEvent<V>>)

( subscriptions: HashMap.HashMap<EventStreamId, SubscriptionData<T>> )

(fs: FileSystem.FileSystem, path: Path.Path, changesetsDir: string)

(fs: FileSystem.FileSystem, packagePath: string)

(fs: FileSystem.FileSystem, packagePath: string)

( result: boolean, startTime: number, timeoutMs: number, pollIntervalMs: number, checkCondition: (st

( startTime: number, condition: () => Effect.Effect<boolean, E, never>, timeoutMs: number, pollInterva

( state: MockTransportState, message: TransportMessage, stateRef: Ref.Ref<MockTransportState> )

(changedPackages: ReadonlySet<string>, packageDependencyMap: Record<string, readonly string[]>)

(dir: string)

(fullPath: string)

(fullPath: string)

(changesets: readonly ChangesetInfoInternal[])

(tempDir: string)

( stateRef: Readonly<Ref.Ref<WebSocketInternalState>>, writerRef: Readonly<Ref.Ref<((data: string) => Effe

(stateRef: Ref.Ref<ProtocolState>, commandId: string)

( serverStateRef: ReadonlyDeep<Ref.Ref<ServerState>> )

(stateRef: Ref.Ref<ProtocolState>, streamId: string)

(tempDir: string)

( ref: SynchronizedRef.SynchronizedRef<HashMap.HashMap<EventStreamId, SubscriptionData<T>>> )

(statusPath: string)

()

( clientScope: Scope.CloseableScope, connection: ServerConnection )

(serverScope: Scope.CloseableScope, client: ClientTransport)

(packageDir: string)

(server: ServerTransport)

(eventStore: EventStore<TestEvent>)

()

(messageStream: Stream.Stream<TransportMessage>)

( stream: Stream.Stream<TransportMessage, never, never>, transport: ConnectedTransportTestInterface )

(firstBatch: readonly Event[])

( stateHistoryRef: Ref.Ref<Chunk.Chunk<ConnectionState>>, stateMonitoring: Fiber.Fiber<void, never> )

( config: FileSystemStoreConfig, fs: FileSystem.FileSystem, path: Path.Path, streamId: EventStreamId )

(server: InMemoryServer, testMessage: TransportMessage)

( timeoutMs: number, stream: Stream.Stream<A, E, never> )

( streamId: EventStreamId, state: SynchronizedRef.SynchronizedRef<FileSystemStoreState<V>>, historical:

( eventstoreTag: Readonly<Context.Tag<TTag, EventStore<EventRecord<TEvent, TOrigin>>>> )

(todoId: TodoId, eventNumber: number, title: string)

(eventNumber: number)

(id: TId, eventNumber: EventNumber, events: Chunk.Chunk<TEvent>)

( todoId: TodoId, eventNumber: number, events: Readonly<ReadonlyArray<TodoEvent>> )

( beforeContent: unknown, afterContent: unknown )

(todoId: TodoId)

(historical: Stream.Stream<V, never, never>)

(liveStream: Stream.Stream<string, EventStoreError, never>)

( predicate: (cmd: ReadonlyDeep<WireCommand>) => boolean, streamId: (cmd: ReadonlyDeep<WireCommand>) =