Teardown not happening when observables are changed / refCount not working as I expect

[wheelere]

Hi, I'm trying to use extended Subjects with custom teardown logic and use refCount() to close them when they are no longer in use.
These subjects are chain subscribed like

private fromQuery(
  query: QueryObject[],
  options: Options,
): RxJs.Observable<SubscribedData<Result>> {
  ...
  const subject = new BufferSubject(1);
  const observer = this.createGetAndSubscribeObservable(query, options, token);
  const multicasted = observer.pipe(multicast(subject), refCount());

  SOURCE_CACHE.set(token, multicasted);
  return multicasted;
}

private fromDataPath(
  dataPath: DataPath,
  params: Inputs,
  options: Options,
): RxJs.Observable<SubscribedData<ConvertedNotification[]>> {
  ...
  return this.fromQuery(query, options).pipe(
    map((rawData: SubscribedData<Result>) => {
      const { data, errorMessage } = rawData;
      return (data as notifs).notifications === undefined || _.isEmpty(data)
        ? { data: [], errorMessage }
        : { data: (data as Notifs).notifications, errorMessage };
    }),
  );
}

private subscriberFromDataPath(
  dataPath: DataPath,
  name: string,
  mapInputs?: MapInputsFunction,
): Subscriber<unknown> {
  return (dataObj, rawInputs, options): RxJs.Observable<SubscribedData<unknown>> => {
    const inputs = unwrapDataAndMapInputs(dataObj, rawInputs, mapInputs);
    if (inputs === null) {
      return RxJs.of([]).pipe(map(() => Object.assign(dataObj, { [name]: { data: [] } })));
    }
    if (Array.isArray(inputs)) {
      let errorMessage: string | undefined;
      const batchedDataPaths = inputs.map((input) => {
        return this.fromDataPath(dataPath, input, options).pipe(
          map((data) => {
            if (data.errorMessage) {
              errorMessage = data.errorMessage;
            }
            return { [dataPathParamsToString(input, true)]: data.data };
          }),
        );
      });
      return RxJs.combineLatest(batchedDataPaths).pipe(
        map((data) => {
          return Object.assign(dataObj, { [name]: { data, errorMessage } });
        }),
      );
    }
    return this.fromDataPath(dataPath, inputs, options).pipe(
      map((data) => Object.assign(dataObj, { [name]: data })),
    );
  };
}

The problem I'm seeing is that if inputs change and recalculate the DataPaths needed, the DataPath observables that are no longer being used by the pipeline are not torn down. Is this an issue with the way my pipelines are designed? Do I need to include logic to explicitly close the old dataPath requests? Do I need to move the refCount further up the tree?