diff --git a/docs/index.html b/docs/index.html
index 8ff8f211..061f60d4 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -27,6 +27,7 @@ <h1>Planner.js</h1>
             </p>
             <section>
                 <h2 id="demo">Demo</h2>
+                <h3>Table</h3>
                 <p
                         data-height="398"
                         data-theme-id="light"
@@ -39,6 +40,19 @@ <h2 id="demo">Demo</h2>
                     See the Pen <a href="https://codepen.io/maximtmartin/pen/bQZMoj">Using the new JavaScript route
                     planner</a> on <a href="https://codepen.io">CodePen</a>.
                 </p>
+                <h3>Map</h3>
+                <p
+                        data-height="700"
+                        data-theme-id="light"
+                        data-slug-hash="yGMzLM"
+                        data-default-tab="result"
+                        data-user="maximtmartin"
+                        data-pen-title="Using the new JavaScript route planner (work in progress)"
+                        class="codepen"
+                >
+                    See the Pen <a href="https://codepen.io/maximtmartin/pen/yGMzLM">Using the new JavaScript route
+                    planner</a> on <a href="https://codepen.io">CodePen</a>.
+                </p>
             </section>
             <!--<section>
                 <h2 id="philosophy">Principles</h2>
diff --git a/src/Catalog.ts b/src/Catalog.ts
index 6bfebad8..c02fdd6b 100644
--- a/src/Catalog.ts
+++ b/src/Catalog.ts
@@ -1,11 +1,23 @@
 import TravelMode from "./TravelMode";
 
 export default class Catalog {
+
+  public static combine(...catalogs: Catalog[]): Catalog {
+    const combinedCatalog = new Catalog();
+
+    for (const sourceCatalog of catalogs) {
+      combinedCatalog.stopsFetcherConfigs.push(...sourceCatalog.stopsFetcherConfigs);
+      combinedCatalog.connectionsFetcherConfigs.push(...sourceCatalog.connectionsFetcherConfigs);
+    }
+
+    return combinedCatalog;
+  }
+
   public stopsFetcherConfigs = [];
   public connectionsFetcherConfigs = [];
 
-  public addStopsFetcher(prefix: string, accessUrl: string) {
-    this.stopsFetcherConfigs.push({prefix, accessUrl});
+  public addStopsFetcher(accessUrl: string) {
+    this.stopsFetcherConfigs.push({accessUrl});
   }
 
   public addConnectionsFetcher(accessUrl: string, travelMode: TravelMode) {
diff --git a/src/Context.ts b/src/Context.ts
index ad8f2992..00fb1d6e 100644
--- a/src/Context.ts
+++ b/src/Context.ts
@@ -1,9 +1,22 @@
+// @ts-ignore
+import { EventEmitter, Listener } from "events";
 import { Container, injectable } from "inversify";
 
+/**
+ * The Context serves as event pass through and holder of the inversify container object.
+ * Proxies an internal EventEmitter because ´decorate(injectable(), EventEmitter)´ causes
+ * errors when running tests in Jest
+ */
 @injectable()
-export default class Context {
+// @ts-ignore
+export default class Context implements EventEmitter {
+  private emitter: EventEmitter;
   private container: Container;
 
+  constructor() {
+    this.emitter = new EventEmitter();
+  }
+
   public setContainer(container: Container) {
     this.container = container;
   }
@@ -11,4 +24,52 @@ export default class Context {
   public getContainer() {
     return this.container;
   }
+
+  public addListener(type: string | symbol, listener: Listener): this {
+    this.emitter.addListener(type, listener);
+
+    return this;
+  }
+
+  public emit(type: string | symbol, ...args: any[]): boolean {
+    return this.emitter.emit(type, ...args);
+  }
+
+  public listenerCount(type: string | symbol): number {
+    return this.emitter.listenerCount(type);
+  }
+
+  public listeners(type: string | symbol): Listener[] {
+    return this.emitter.listeners(type);
+  }
+
+  public on(type: string | symbol, listener: Listener): this {
+    this.emitter.on(type, listener);
+
+    return this;
+  }
+
+  public once(type: string | symbol, listener: Listener): this {
+    this.emitter.once(type, listener);
+
+    return this;
+  }
+
+  public removeAllListeners(type?: string | symbol): this {
+    this.emitter.removeAllListeners(type);
+
+    return this;
+  }
+
+  public removeListener(type: string | symbol, listener: Listener): this {
+    this.emitter.removeListener(type, listener);
+
+    return this;
+  }
+
+  public setMaxListeners(n: number): this {
+    this.emitter.setMaxListeners(n);
+
+    return this;
+  }
 }
diff --git a/src/Defaults.ts b/src/Defaults.ts
index 0406b800..2be8ecc1 100644
--- a/src/Defaults.ts
+++ b/src/Defaults.ts
@@ -3,6 +3,8 @@ import Units from "./util/Units";
 export default class Defaults {
   public static readonly defaultMinimumWalkingSpeed = 3;
   public static readonly defaultMaximumWalkingSpeed = 6;
+  public static readonly defaultWalkingDuration = Units.fromSeconds(10 * 60);
+  public static readonly defaultMinimumTransferDuration = Units.fromSeconds(60);
   public static readonly defaultMaximumTransferDuration = Units.fromHours(.4);
-  public static readonly defaultMaximumTransfers = 8;
+  public static readonly defaultMaximumTransfers = 4;
 }
diff --git a/src/EventType.ts b/src/EventType.ts
new file mode 100644
index 00000000..d7cfe1a7
--- /dev/null
+++ b/src/EventType.ts
@@ -0,0 +1,12 @@
+enum EventType {
+  Query = "query",
+  QueryExponential = "query-exponential",
+  QueryAbort = "query-abort",
+  LDFetchGet = "ldfetch-get",
+  ConnectionScan = "connection-scan",
+  FinalReachableStops = "final-reachable-stops",
+  InitialReachableStops = "initial-reachable-stops",
+  AddedNewTransferProfile = "added-new-transfer-profile",
+}
+
+export default EventType;
diff --git a/src/Planner.ts b/src/Planner.ts
index d20bcc79..441fede4 100644
--- a/src/Planner.ts
+++ b/src/Planner.ts
@@ -1,5 +1,10 @@
 import { AsyncIterator } from "asynciterator";
+// @ts-ignore
+import { EventEmitter, Listener } from "events";
 import Context from "./Context";
+import EventType from "./EventType";
+import IStop from "./fetcher/stops/IStop";
+import IStopsProvider from "./fetcher/stops/IStopsProvider";
 import IPath from "./interfaces/IPath";
 import IQuery from "./interfaces/IQuery";
 import defaultContainer from "./inversify.config";
@@ -13,7 +18,8 @@ if (!Symbol.asyncIterator) {
 /**
  * Allows to ask route planning queries over our knowledge graphs
  */
-export default class Planner {
+// @ts-ignore
+export default class Planner implements EventEmitter {
   private context: Context;
   private queryRunner: IQueryRunner;
 
@@ -35,6 +41,72 @@ export default class Planner {
    * @returns An AsyncIterator of [[IPath]]s
    */
   public async query(query: IQuery): Promise<AsyncIterator<IPath>> {
-    return this.queryRunner.run(query);
+    this.emit(EventType.Query, query);
+
+    const iterator = await this.queryRunner.run(query);
+
+    this.once(EventType.QueryAbort, () => {
+      iterator.close();
+    });
+
+    return iterator;
+  }
+
+  public addListener(type: string | symbol, listener: Listener): this {
+    this.context.addListener(type, listener);
+
+    return this;
+  }
+
+  public emit(type: string | symbol, ...args: any[]): boolean {
+    return this.context.emit(type, ...args);
+  }
+
+  public listenerCount(type: string | symbol): number {
+    return this.context.listenerCount(type);
+  }
+
+  public listeners(type: string | symbol): Listener[] {
+    return this.context.listeners(type);
+  }
+
+  public on(type: string | symbol, listener: Listener): this {
+    this.context.on(type, listener);
+
+    return this;
+  }
+
+  public once(type: string | symbol, listener: Listener): this {
+    this.context.once(type, listener);
+
+    return this;
+  }
+
+  public removeAllListeners(type?: string | symbol): this {
+    this.context.removeAllListeners(type);
+
+    return this;
+  }
+
+  public removeListener(type: string | symbol, listener: Listener): this {
+    this.context.removeListener(type, listener);
+
+    return this;
+  }
+
+  public setMaxListeners(n: number): this {
+    this.context.setMaxListeners(n);
+
+    return this;
+  }
+
+  public getAllStops(): Promise<IStop[]> {
+    const provider = this.context.getContainer().get<IStopsProvider>(TYPES.StopsProvider);
+
+    if (provider) {
+      return provider.getAllStops();
+    }
+
+    return Promise.reject();
   }
 }
diff --git a/src/catalog.delijn.ts b/src/catalog.delijn.ts
new file mode 100644
index 00000000..95726afd
--- /dev/null
+++ b/src/catalog.delijn.ts
@@ -0,0 +1,18 @@
+import Catalog from "./Catalog";
+import TravelMode from "./TravelMode";
+
+const catalog = new Catalog();
+
+catalog.addStopsFetcher("http://openplanner.ilabt.imec.be/delijn/Antwerpen/stops");
+catalog.addStopsFetcher("http://openplanner.ilabt.imec.be/delijn/Limburg/stops");
+catalog.addStopsFetcher("http://openplanner.ilabt.imec.be/delijn/Oost-Vlaanderen/stops");
+catalog.addStopsFetcher("http://openplanner.ilabt.imec.be/delijn/Vlaams-Brabant/stops");
+catalog.addStopsFetcher("http://openplanner.ilabt.imec.be/delijn/West-Vlaanderen/stops");
+
+catalog.addConnectionsFetcher("http://openplanner.ilabt.imec.be/delijn/Antwerpen/connections", TravelMode.Bus);
+catalog.addConnectionsFetcher("http://openplanner.ilabt.imec.be/delijn/Limburg/connections", TravelMode.Bus);
+catalog.addConnectionsFetcher("http://openplanner.ilabt.imec.be/delijn/Oost-Vlaanderen/connections", TravelMode.Bus);
+catalog.addConnectionsFetcher("http://openplanner.ilabt.imec.be/delijn/Vlaams-Brabant/connections", TravelMode.Bus);
+catalog.addConnectionsFetcher("http://openplanner.ilabt.imec.be/delijn/West-Vlaanderen/connections", TravelMode.Bus);
+
+export default catalog;
diff --git a/src/catalog.nmbs.ts b/src/catalog.nmbs.ts
new file mode 100644
index 00000000..f9edf2e8
--- /dev/null
+++ b/src/catalog.nmbs.ts
@@ -0,0 +1,8 @@
+import Catalog from "./Catalog";
+import TravelMode from "./TravelMode";
+
+const catalog = new Catalog();
+catalog.addStopsFetcher("https://irail.be/stations/NMBS");
+catalog.addConnectionsFetcher("https://graph.irail.be/sncb/connections", TravelMode.Train);
+
+export default catalog;
diff --git a/src/demo.ts b/src/demo.ts
index 3d770876..240f8605 100644
--- a/src/demo.ts
+++ b/src/demo.ts
@@ -1,45 +1,69 @@
+import EventType from "./EventType";
 import Planner from "./index";
+import IPath from "./interfaces/IPath";
 import Units from "./util/Units";
 
 export default async (logResults) => {
 
   const planner = new Planner();
 
-  // const roadOnlyResult = await planner.query({
-  //  roadOnly: true,
-  //  from: "http://irail.be/stations/NMBS/008896008", // Kortrijk
-  //  to: "http://irail.be/stations/NMBS/008892007", // Ghent-Sint-Pieters
-  // });
-//
-  // roadOnlyResult.each((path) => {
-  //  if (logResults) {
-  //    console.log(path);
-  //  }
-  // });
+  if (logResults) {
+    let scannedPages = 0;
+    let scannedConnections = 0;
 
-  console.time("Public transport planner");
+    planner
+      .on(EventType.Query, (query) => {
+        console.log("Query", query);
+      })
+      .on(EventType.QueryExponential, (query) => {
+        const { minimumDepartureTime, maximumArrivalTime } = query;
+
+        console.log("Total scanned pages", scannedPages);
+        console.log("Total scanned connections", scannedConnections);
+        console.log("[Subquery]", minimumDepartureTime, maximumArrivalTime, maximumArrivalTime - minimumDepartureTime);
+      })
+      .on(EventType.LDFetchGet, (url, duration) => {
+        scannedPages++;
+        console.log(`[GET] ${url} (${duration}ms)`);
+      })
+      .on(EventType.ConnectionScan, (connection) => {
+        scannedConnections++;
+      });
+  }
 
   const publicTransportResult = await planner.query({
     publicTransportOnly: true,
+    // from: "https://data.delijn.be/stops/201657",
+    // to: "https://data.delijn.be/stops/205910",
+    // from: "https://data.delijn.be/stops/200455", // Deinze weg op Grammene +456
+    // to: "https://data.delijn.be/stops/502481", // Tielt Metaalconstructie Goossens
+    // from: "https://data.delijn.be/stops/509927", // Tield Rameplein perron 1
+    // to: "https://data.delijn.be/stops/200455", // Deinze weg op Grammene +456
     from: "http://irail.be/stations/NMBS/008896925", // Ingelmunster
     to: "http://irail.be/stations/NMBS/008892007", // Ghent-Sint-Pieters
     minimumDepartureTime: new Date(),
-    maximumTransferDuration: Units.fromHours(.5),
+    maximumTransferDuration: Units.fromHours(0.5),
   });
 
-  console.timeEnd("Public transport planner");
-
-  let i = 0;
+  return new Promise((resolve, reject) => {
+    let i = 0;
 
-  publicTransportResult.on("readable", () => {
-    let path = publicTransportResult.read();
+    publicTransportResult.take(3)
+      .on("data", (path: IPath) => {
+        ++i;
 
-    while (path && i < 5) {
-      console.log(i++, path);
+        if (logResults) {
+          console.log(i);
+          console.log(JSON.stringify(path, null, " "));
+          console.log("\n");
+        }
 
-      path = publicTransportResult.read();
-    }
+        if (i === 3) {
+          resolve(true);
+        }
+      })
+      .on("end", () => {
+        resolve(false);
+      });
   });
-
-  return true;
 };
diff --git a/src/fetcher/LDFetch.ts b/src/fetcher/LDFetch.ts
new file mode 100644
index 00000000..fa5492a7
--- /dev/null
+++ b/src/fetcher/LDFetch.ts
@@ -0,0 +1,48 @@
+import { inject, injectable } from "inversify";
+import LDFetchBase from "ldfetch";
+import { Triple } from "rdf-js";
+import Context from "../Context";
+import EventType from "../EventType";
+import TYPES from "../types";
+
+export interface ILDFetchResponse {
+  triples: Triple[];
+  prefixes: object;
+  statusCode: string;
+  url: string;
+}
+
+/**
+ * Proxies an ldfetch instance to transform its events
+ */
+@injectable()
+export default class LDFetch implements LDFetchBase {
+  private context: Context;
+  private ldFetchBase: LDFetchBase;
+  private httpStartTimes: { [url: string]: Date };
+
+  constructor(
+    @inject(TYPES.Context) context: Context,
+  ) {
+    this.ldFetchBase = new LDFetchBase({ headers: { Accept: "application/ld+json" } });
+    this.context = context;
+
+    this.setupEvents();
+  }
+
+  public get(url: string): Promise<ILDFetchResponse> {
+    return this.ldFetchBase.get(url);
+  }
+
+  private setupEvents(): void {
+    this.httpStartTimes = {};
+
+    this.ldFetchBase.on("request", (url) => this.httpStartTimes[url] = new Date());
+    this.ldFetchBase.on("redirect", (obj) => this.httpStartTimes[obj.to] = this.httpStartTimes[obj.from]);
+    this.ldFetchBase.on("response", (url) => {
+      const duration = (new Date()).getTime() - this.httpStartTimes[url].getTime();
+
+      this.context.emit(EventType.LDFetchGet, url, duration);
+    });
+  }
+}
diff --git a/src/fetcher/connections/ConnectionsProviderPassthrough.ts b/src/fetcher/connections/ConnectionsProviderPassthrough.ts
index 6c3e754b..e7c7c43c 100644
--- a/src/fetcher/connections/ConnectionsProviderPassthrough.ts
+++ b/src/fetcher/connections/ConnectionsProviderPassthrough.ts
@@ -9,6 +9,7 @@ import IConnectionsProvider from "./IConnectionsProvider";
 
 /**
  * Passes through one [[IConnectionsFetcher]], the first one if there are multiple
+ * This provider is most/only useful if there is only one fetcher
  */
 @injectable()
 export default class ConnectionsProviderPassthrough implements IConnectionsProvider {
diff --git a/src/fetcher/connections/ld-fetch/ConnectionsIteratorLazy.ts b/src/fetcher/connections/ld-fetch/ConnectionsIteratorLazy.ts
index d1760dd0..5308d950 100644
--- a/src/fetcher/connections/ld-fetch/ConnectionsIteratorLazy.ts
+++ b/src/fetcher/connections/ld-fetch/ConnectionsIteratorLazy.ts
@@ -85,22 +85,22 @@ export default class ConnectionsIteratorLazy extends BufferedIterator<IConnectio
   }
 
   private pushCurrentPage(): void {
-      const { connections } = this.currentPage;
+    const { connections } = this.currentPage;
 
-      if (this.config.backward) {
-        let c = connections.length - 1;
+    if (this.config.backward) {
+      let c = connections.length - 1;
 
-        while (c >= 0) {
-          this._push(connections[c]);
-          c--;
-        }
+      while (c >= 0) {
+        this._push(connections[c]);
+        c--;
+      }
 
-        // Forwards
-      } else {
-        for (const connection of connections) {
-          this._push(connection);
-        }
+      // Forwards
+    } else {
+      for (const connection of connections) {
+        this._push(connection);
       }
     }
+  }
 
 }
diff --git a/src/fetcher/connections/ld-fetch/HydraPageParser.ts b/src/fetcher/connections/ld-fetch/HydraPageParser.ts
index 7a0adcf0..e28779a3 100644
--- a/src/fetcher/connections/ld-fetch/HydraPageParser.ts
+++ b/src/fetcher/connections/ld-fetch/HydraPageParser.ts
@@ -63,7 +63,10 @@ export default class HydraPageParser {
   }
 
   private getDocumentIri(): string {
-    const typeTriple = this.triples.find(
+    // Type can be either http://www.w3.org/ns/hydra/core#PartialCollectionView
+    // or http://www.w3.org/ns/hydra/core#PagedCollection
+
+    let typeTriple = this.triples.find(
       Rdf.matchesTriple(
         null,
         "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
@@ -71,6 +74,16 @@ export default class HydraPageParser {
       ),
     );
 
+    if (!typeTriple) {
+      typeTriple = this.triples.find(
+        Rdf.matchesTriple(
+          null,
+          "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
+          "http://www.w3.org/ns/hydra/core#PagedCollection",
+        ),
+      );
+    }
+
     if (!typeTriple) {
       throw new Error("Hydra page doesn`t have type triple");
     }
diff --git a/src/fetcher/connections/merge/ConnectionsIteratorMerge.ts b/src/fetcher/connections/merge/ConnectionsIteratorMerge.ts
deleted file mode 100644
index 3eea26ab..00000000
--- a/src/fetcher/connections/merge/ConnectionsIteratorMerge.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import IConnection from "../IConnection";
-import IConnectionsFetcherConfig from "../IConnectionsFetcherConfig";
-
-export default class ConnectionsIteratorMerge implements AsyncIterator<IConnection> {
-
-  private iterators: Array<AsyncIterator<IConnection>>;
-  private config: IConnectionsFetcherConfig;
-
-  private nextConnections: IConnection[];
-
-  constructor(iterators: Array<AsyncIterator<IConnection>>, config: IConnectionsFetcherConfig) {
-    this.iterators = iterators;
-    this.config = config;
-
-    this.nextConnections = Array(iterators.length);
-  }
-
-  public async next(): Promise<IteratorResult<IConnection>> {
-    await this.replenishNextConnections();
-
-    // console.log("Next connections", this.nextConnections.map((c) => `${c.departureTime} ${c["@id"]}`));
-
-    if (!this.config.backward) {
-      // Get next connection with earliest departure time
-
-      const earliestConnection = this.findNextConnection(this.earliestPredicate);
-      return {value: earliestConnection, done: false};
-
-    } else {
-      // Get next connection with latest departure time
-
-      const latestConnection = this.findNextConnection(this.latestPredicate);
-      return {value: latestConnection, done: false};
-    }
-  }
-
-  public return(value?: any): Promise<IteratorResult<IConnection>> {
-    return undefined;
-  }
-
-  public throw(e?: any): Promise<IteratorResult<IConnection>> {
-    return undefined;
-  }
-
-  private findNextConnection(predicate: (matching: IConnection, current: IConnection) => boolean): IConnection {
-    let matchingConnectionIndex = 0;
-    let matchingConnection = this.nextConnections[matchingConnectionIndex];
-
-    for (let i = 1; i < this.nextConnections.length; i++) {
-      const currentConnection = this.nextConnections[i];
-
-      if (predicate(matchingConnection, currentConnection)) {
-        matchingConnectionIndex = i;
-        matchingConnection = currentConnection;
-      }
-    }
-
-    this.nextConnections[matchingConnectionIndex] = null;
-    return matchingConnection;
-  }
-
-  private earliestPredicate(matching: IConnection, current: IConnection): boolean {
-    return matching.departureTime.valueOf() > current.departureTime.valueOf();
-  }
-
-  private latestPredicate(matching: IConnection, current: IConnection): boolean {
-    return matching.departureTime.valueOf() < current.departureTime.valueOf();
-  }
-
-  private async replenishNextConnections() {
-    for (let i = 0; i < this.nextConnections.length; i++) {
-      if (!this.nextConnections[i]) {
-        const result = await this.iterators[i].next();
-        this.nextConnections[i] = result.value;
-      }
-    }
-  }
-
-}
diff --git a/src/fetcher/connections/merge/ConnectionsProviderMerge.ts b/src/fetcher/connections/merge/ConnectionsProviderMerge.ts
index ae8b53e1..9841fc99 100644
--- a/src/fetcher/connections/merge/ConnectionsProviderMerge.ts
+++ b/src/fetcher/connections/merge/ConnectionsProviderMerge.ts
@@ -1,23 +1,81 @@
 import { AsyncIterator } from "asynciterator";
-import { injectable, multiInject, tagged } from "inversify";
-import TYPES from "../../../types";
+import { inject, injectable } from "inversify";
+import Catalog from "../../../Catalog";
+import TYPES, { ConnectionsFetcherFactory } from "../../../types";
+import MergeIterator from "../../../util/iterators/MergeIterator";
 import IConnection from "../IConnection";
 import IConnectionsFetcher from "../IConnectionsFetcher";
 import IConnectionsFetcherConfig from "../IConnectionsFetcherConfig";
-import ConnectionsIteratorMerge from "./ConnectionsIteratorMerge";
 
+/**
+ * Instantiates and merge sorts all registered connection fetchers
+ */
 @injectable()
 export default class ConnectionsProviderMerge implements IConnectionsFetcher {
 
-  public createIterator: () => AsyncIterator<IConnection>;
+  private static forwardsConnectionSelector(connections: IConnection[]): number {
+    if (connections.length === 1) {
+      return 0;
+    }
+
+    let earliestIndex = 0;
+    const earliest = connections[earliestIndex];
+
+    for (let i = 1; i < connections.length; i++) {
+      const connection = connections[i];
+
+      if (connection.departureTime < earliest.departureTime) {
+        earliestIndex = i;
+      }
+    }
+
+    return earliestIndex;
+  }
+
+  private static backwardsConnectionsSelector(connections: IConnection[]): number {
+    if (connections.length === 1) {
+      return 0;
+    }
+
+    let latestIndex = 0;
+    const latest = connections[latestIndex];
+
+    for (let i = 1; i < connections.length; i++) {
+      const connection = connections[i];
+
+      if (connection.departureTime > latest.departureTime) {
+        latestIndex = i;
+      }
+    }
+
+    return latestIndex;
+  }
 
   private config: IConnectionsFetcherConfig;
   private connectionsFetchers: IConnectionsFetcher[];
 
   constructor(
-    @multiInject(TYPES.ConnectionsFetcher) @tagged("type", "source") connectionsFetchers: IConnectionsFetcher[],
+    @inject(TYPES.ConnectionsFetcherFactory) connectionsFetcherFactory: ConnectionsFetcherFactory,
+    @inject(TYPES.Catalog) catalog: Catalog,
   ) {
-    this.connectionsFetchers = connectionsFetchers;
+    this.connectionsFetchers = [];
+
+    for (const { accessUrl, travelMode } of catalog.connectionsFetcherConfigs) {
+      this.connectionsFetchers.push(connectionsFetcherFactory(accessUrl, travelMode));
+    }
+  }
+
+  public createIterator(): AsyncIterator<IConnection> {
+
+    const iterators = this.connectionsFetchers
+      .map((fetcher) => fetcher.createIterator());
+
+    const selector = this.config.backward ?
+      ConnectionsProviderMerge.backwardsConnectionsSelector
+      :
+      ConnectionsProviderMerge.forwardsConnectionSelector;
+
+    return new MergeIterator(iterators, selector, true);
   }
 
   public setConfig(config: IConnectionsFetcherConfig): void {
diff --git a/src/fetcher/stops/IStopsFetcher.ts b/src/fetcher/stops/IStopsFetcher.ts
index d2c9d3a1..098ac036 100644
--- a/src/fetcher/stops/IStopsFetcher.ts
+++ b/src/fetcher/stops/IStopsFetcher.ts
@@ -2,9 +2,7 @@ import IStopsProvider from "./IStopsProvider";
 
 /**
  * Represents one data source of stops, e.g. De Lijn or NMBS
- * Has a prefix for potential use by a [[IStopsProvider]]
  * Extends [[IStopsProvider]] because it should implement the same methods
  */
 export default interface IStopsFetcher extends IStopsProvider {
-  prefix: string;
 }
diff --git a/src/fetcher/stops/StopsProviderDefault.ts b/src/fetcher/stops/StopsProviderDefault.ts
index 4398c39d..ffe9b65a 100644
--- a/src/fetcher/stops/StopsProviderDefault.ts
+++ b/src/fetcher/stops/StopsProviderDefault.ts
@@ -16,17 +16,15 @@ export default class StopsProviderDefault implements IStopsProvider {
   ) {
     this.stopsFetchers = [];
 
-    for (const {prefix, accessUrl} of catalog.stopsFetcherConfigs) {
-      this.stopsFetchers.push(stopsFetcherFactory(prefix, accessUrl));
+    for (const { accessUrl } of catalog.stopsFetcherConfigs) {
+      this.stopsFetchers.push(stopsFetcherFactory(accessUrl));
     }
   }
 
   public async getStopById(stopId: string): Promise<IStop> {
-    const fetcher = this.determineStopFetcher(stopId);
-
-    if (fetcher) {
-      return fetcher.getStopById(stopId);
-    }
+    return Promise.all(this.stopsFetchers
+      .map((stopsFetcher: IStopsFetcher) => stopsFetcher.getStopById(stopId)),
+    ).then((results: IStop[]) => results.find((stop) => stop !== undefined));
   }
 
   public async getAllStops(): Promise<IStop[]> {
@@ -34,13 +32,4 @@ export default class StopsProviderDefault implements IStopsProvider {
       .map((stopsFetcher: IStopsFetcher) => stopsFetcher.getAllStops()),
     ).then((results: IStop[][]) => [].concat(...results));
   }
-
-  private determineStopFetcher(stopId: string): IStopsFetcher {
-    if (!this.stopsFetchers || !this.stopsFetchers.length) {
-      return null;
-    }
-
-    return this.stopsFetchers
-      .find((fetcher) => stopId.indexOf(fetcher.prefix) === 0);
-  }
 }
diff --git a/src/fetcher/stops/ld-fetch/StopsFetcherLDFetch.test.ts b/src/fetcher/stops/ld-fetch/StopsFetcherLDFetch.test.ts
index da6b6fda..14e10cf9 100644
--- a/src/fetcher/stops/ld-fetch/StopsFetcherLDFetch.test.ts
+++ b/src/fetcher/stops/ld-fetch/StopsFetcherLDFetch.test.ts
@@ -14,11 +14,9 @@ const DE_LIJN_STOPS_URLS = [
 const ldFetch = new LDFetch({ headers: { Accept: "application/ld+json" } });
 
 const deLijnFetcher = new StopsFetcherLDFetch(ldFetch);
-deLijnFetcher.setPrefix("https://data.delijn.be/stops/");
 deLijnFetcher.setAccessUrl(DE_LIJN_STOPS_URLS[2]);
 
 const nmbsFetcher = new StopsFetcherLDFetch(ldFetch);
-nmbsFetcher.setPrefix("http://irail.be/stations/NMBS/");
 nmbsFetcher.setAccessUrl("https://irail.be/stations/NMBS");
 
 test("[StopsFetcherLDFetch] De Lijn first stop", async () => {
diff --git a/src/fetcher/stops/ld-fetch/StopsFetcherLDFetch.ts b/src/fetcher/stops/ld-fetch/StopsFetcherLDFetch.ts
index d47fdb63..d7ef11b9 100644
--- a/src/fetcher/stops/ld-fetch/StopsFetcherLDFetch.ts
+++ b/src/fetcher/stops/ld-fetch/StopsFetcherLDFetch.ts
@@ -17,7 +17,6 @@ interface IStopMap {
 @injectable()
 export default class StopsFetcherLDFetch implements IStopsFetcher {
 
-  public prefix: string;
   private accessUrl: string;
 
   private ldFetch: LDFetch;
@@ -31,10 +30,6 @@ export default class StopsFetcherLDFetch implements IStopsFetcher {
     this.loadStops();
   }
 
-  public setPrefix(prefix: string) {
-    this.prefix = prefix;
-  }
-
   public setAccessUrl(accessUrl: string) {
     this.accessUrl = accessUrl;
   }
diff --git a/src/interfaces/IQuery.ts b/src/interfaces/IQuery.ts
index 3041e945..1142c149 100644
--- a/src/interfaces/IQuery.ts
+++ b/src/interfaces/IQuery.ts
@@ -1,5 +1,5 @@
 import ILocation from "./ILocation";
-import { DurationMs, SpeedkmH } from "./units";
+import { DistanceM, DurationMs, SpeedkmH } from "./units";
 
 export default interface IQuery {
   from?: string | string[] | ILocation | ILocation[];
@@ -11,6 +11,9 @@ export default interface IQuery {
   walkingSpeed?: SpeedkmH;
   minimumWalkingSpeed?: SpeedkmH;
   maximumWalkingSpeed?: SpeedkmH;
+  maximumWalkingDuration?: DurationMs;
+  maximumWalkingDistance?: DistanceM;
+  minimumTransferDuration?: DurationMs;
   maximumTransferDuration?: DurationMs;
   maximumTransfers?: number;
 }
diff --git a/src/inversify.config.ts b/src/inversify.config.ts
index ad05a770..7209beb3 100644
--- a/src/inversify.config.ts
+++ b/src/inversify.config.ts
@@ -1,11 +1,13 @@
 import { Container, interfaces } from "inversify";
-import LDFetch from "ldfetch";
 import Catalog from "./Catalog";
+import catalogDeLijn from "./catalog.delijn";
+import catalogNmbs from "./catalog.nmbs";
 import Context from "./Context";
-import ConnectionsProviderPassthrough from "./fetcher/connections/ConnectionsProviderPassthrough";
 import IConnectionsFetcher from "./fetcher/connections/IConnectionsFetcher";
 import IConnectionsProvider from "./fetcher/connections/IConnectionsProvider";
 import ConnectionsFetcherLazy from "./fetcher/connections/ld-fetch/ConnectionsFetcherLazy";
+import ConnectionsProviderMerge from "./fetcher/connections/merge/ConnectionsProviderMerge";
+import LDFetch from "./fetcher/LDFetch";
 import IStopsFetcher from "./fetcher/stops/IStopsFetcher";
 import IStopsProvider from "./fetcher/stops/IStopsProvider";
 import StopsFetcherLDFetch from "./fetcher/stops/ld-fetch/StopsFetcherLDFetch";
@@ -34,6 +36,8 @@ container.bind<ILocationResolver>(TYPES.LocationResolver).to(LocationResolverDef
 
 container.bind<IPublicTransportPlanner>(TYPES.PublicTransportPlanner)
   .to(PublicTransportPlannerCSAProfile);
+container.bind<interfaces.Factory<IPublicTransportPlanner>>(TYPES.PublicTransportPlannerFactory)
+  .toAutoFactory<IPublicTransportPlanner>(TYPES.PublicTransportPlanner);
 
 container.bind<IJourneyExtractor>(TYPES.JourneyExtractor)
   .to(JourneyExtractorDefault);
@@ -51,7 +55,7 @@ container.bind<IReachableStopsFinder>(TYPES.ReachableStopsFinder)
 container.bind<IReachableStopsFinder>(TYPES.ReachableStopsFinder)
   .to(ReachableStopsFinderBirdsEyeCached).whenTargetTagged("phase", ReachableStopsSearchPhase.Final);
 
-container.bind<IConnectionsProvider>(TYPES.ConnectionsProvider).to(ConnectionsProviderPassthrough).inSingletonScope();
+container.bind<IConnectionsProvider>(TYPES.ConnectionsProvider).to(ConnectionsProviderMerge).inSingletonScope();
 container.bind<IConnectionsFetcher>(TYPES.ConnectionsFetcher).to(ConnectionsFetcherLazy);
 container.bind<interfaces.Factory<IConnectionsFetcher>>(TYPES.ConnectionsFetcherFactory)
   .toFactory<IConnectionsFetcher>(
@@ -71,36 +75,20 @@ container.bind<IStopsFetcher>(TYPES.StopsFetcher).to(StopsFetcherLDFetch);
 container.bind<interfaces.Factory<IStopsFetcher>>(TYPES.StopsFetcherFactory)
   .toFactory<IStopsFetcher>(
     (context: interfaces.Context) =>
-      (prefix: string, accessUrl: string) => {
+      (accessUrl: string) => {
         const fetcher = context.container.get<StopsFetcherLDFetch>(TYPES.StopsFetcher);
-
-        fetcher.setPrefix(prefix);
         fetcher.setAccessUrl(accessUrl);
-
         return fetcher;
       },
   );
 
-// Init catalog
-const catalog = new Catalog();
-catalog.addStopsFetcher("http://irail.be/stations/NMBS/", "https://irail.be/stations/NMBS");
-catalog.addConnectionsFetcher("https://graph.irail.be/sncb/connections", TravelMode.Train);
+// Bind catalog
+container.bind<Catalog>(TYPES.Catalog).toConstantValue(catalogNmbs);
 
-container.bind<Catalog>(TYPES.Catalog).toConstantValue(catalog);
+// const combinedCatalog = Catalog.combine(catalogNmbs, catalogDeLijn);
+// container.bind<Catalog>(TYPES.Catalog).toConstantValue(combinedCatalog);
 
 // Init LDFetch
-const ldFetch = new LDFetch({ headers: { Accept: "application/ld+json" } });
-const httpStartTimes = {};
-
-ldFetch.on("request", (url) => httpStartTimes[url] = new Date());
-
-ldFetch.on("redirect", (obj) => httpStartTimes[obj.to] = httpStartTimes[obj.from]);
-
-ldFetch.on("response", (url) => {
-  const difference = (new Date()).getTime() - httpStartTimes[url].getTime();
-  console.log(`HTTP GET - ${url} (${difference}ms)`);
-});
-
-container.bind<LDFetch>(TYPES.LDFetch).toConstantValue(ldFetch);
+container.bind<LDFetch>(TYPES.LDFetch).to(LDFetch).inSingletonScope();
 
 export default container;
diff --git a/src/planner/public-transport/CSA/data-structure/stops/ITransferProfile.ts b/src/planner/public-transport/CSA/data-structure/stops/ITransferProfile.ts
index e2fa68f2..9d8b65f9 100644
--- a/src/planner/public-transport/CSA/data-structure/stops/ITransferProfile.ts
+++ b/src/planner/public-transport/CSA/data-structure/stops/ITransferProfile.ts
@@ -9,6 +9,7 @@ import IConnection from "../../../../../fetcher/connections/IConnection";
  * to arrive at the arrivalTime in the target [[IStop]].
  */
 export default interface ITransferProfile {
+  departureTime: number;
   arrivalTime: number;
   exitConnection: IConnection;
   enterConnection: IConnection;
diff --git a/src/planner/public-transport/CSA/util/ProfileUtil.ts b/src/planner/public-transport/CSA/util/ProfileUtil.ts
index 5ae0a827..f8317df9 100644
--- a/src/planner/public-transport/CSA/util/ProfileUtil.ts
+++ b/src/planner/public-transport/CSA/util/ProfileUtil.ts
@@ -1,4 +1,7 @@
+import DropOffType from "../../../../fetcher/connections/DropOffType";
 import IConnection from "../../../../fetcher/connections/IConnection";
+import { DurationMs } from "../../../../interfaces/units";
+import IArrivalTimeByTransfers from "../data-structure/IArrivalTimeByTransfers";
 import IProfilesByStop from "../data-structure/stops/IProfilesByStop";
 
 /**
@@ -19,16 +22,35 @@ export default class ProfileUtil {
     return result;
   }
 
-  public static getTransferTimes(profilesByStop: IProfilesByStop, connection: IConnection, maxLegs) {
+  public static getTransferTimes(
+    profilesByStop: IProfilesByStop,
+    connection: IConnection,
+    maxLegs: number,
+    minimumTransferDuration: DurationMs,
+    maximumTransferDuration: DurationMs,
+  ): IArrivalTimeByTransfers {
     const { arrivalStop, arrivalTime } = connection;
+    const trip = connection["gtfs:trip"];
 
-    let i = profilesByStop[arrivalStop].length - 1;
-    while (i >= 0) {
-      if (profilesByStop[arrivalStop][i].departureTime >= arrivalTime.getTime()) {
-        return profilesByStop[arrivalStop][i].getArrivalTimeByTransfers(connection["gtfs:trip"]).slice();
+    if (connection["gtfs:dropOffType"] !== DropOffType.NotAvailable) {
+
+      let profileIndex = profilesByStop[arrivalStop].length - 1;
+      while (profileIndex >= 0) {
+
+        const departure: number = profilesByStop[arrivalStop][profileIndex].departureTime;
+        const arrival: number = arrivalTime.getTime();
+
+        const transferDuration = departure - arrival;
+
+        if (transferDuration >= minimumTransferDuration && transferDuration <= maximumTransferDuration) {
+          const arrivalTimeByTransfers = profilesByStop[arrivalStop][profileIndex].getArrivalTimeByTransfers(trip);
+          return arrivalTimeByTransfers.slice() as IArrivalTimeByTransfers;
+        }
+        profileIndex--;
       }
-      i--;
+
     }
+
     return Array(maxLegs + 1).fill({
       "arrivalTime": Infinity,
       "gtfs:trip": connection["gtfs:trip"],
diff --git a/src/planner/public-transport/JourneyExtractorDefault.ts b/src/planner/public-transport/JourneyExtractorDefault.ts
index 24dde2e2..e987b17a 100644
--- a/src/planner/public-transport/JourneyExtractorDefault.ts
+++ b/src/planner/public-transport/JourneyExtractorDefault.ts
@@ -1,7 +1,6 @@
 import { ArrayIterator, AsyncIterator } from "asynciterator";
-import { inject, injectable, tagged } from "inversify";
+import { inject, injectable } from "inversify";
 import IConnection from "../../fetcher/connections/IConnection";
-import IStop from "../../fetcher/stops/IStop";
 import ILocation from "../../interfaces/ILocation";
 import IPath from "../../interfaces/IPath";
 import IStep from "../../interfaces/IStep";
@@ -9,19 +8,13 @@ import ILocationResolver from "../../query-runner/ILocationResolver";
 import IResolvedQuery from "../../query-runner/IResolvedQuery";
 import TravelMode from "../../TravelMode";
 import TYPES from "../../types";
-import Iterators from "../../util/Iterators";
 import Path from "../Path";
-import IRoadPlanner from "../road/IRoadPlanner";
 import Step from "../Step";
-import IReachableStopsFinder, { IReachableStop } from "../stops/IReachableStopsFinder";
-import ReachableStopsFinderMode from "../stops/ReachableStopsFinderMode";
-import ReachableStopsSearchPhase from "../stops/ReachableStopsSearchPhase";
+import IProfile from "./CSA/data-structure/stops/IProfile";
 import IProfilesByStop from "./CSA/data-structure/stops/IProfilesByStop";
 import ITransferProfile from "./CSA/data-structure/stops/ITransferProfile";
-import Profile from "./CSA/data-structure/stops/Profile";
 import ProfileUtil from "./CSA/util/ProfileUtil";
 import IJourneyExtractor from "./IJourneyExtractor";
-import JourneyExtractionPhase from "./JourneyExtractionPhase";
 
 /**
  * Creates journeys based on the profiles and query from [[PublicTransportPlannerCSAProfile]].
@@ -32,30 +25,12 @@ import JourneyExtractionPhase from "./JourneyExtractionPhase";
  */
 @injectable()
 export default class JourneyExtractorDefault implements IJourneyExtractor {
-  private readonly transferRoadPlanner: IRoadPlanner;
-  private readonly finalRoadPlanner: IRoadPlanner;
-  private readonly initialReachableStopsFinder: IReachableStopsFinder;
-
   private readonly locationResolver: ILocationResolver;
 
   private bestArrivalTime: number[][] = [];
 
-  constructor(
-    @inject(TYPES.RoadPlanner)
-    @tagged("phase", JourneyExtractionPhase.Transfer)
-      transferRoadPlanner: IRoadPlanner,
-    @inject(TYPES.RoadPlanner)
-    @tagged("phase", JourneyExtractionPhase.Final)
-      finalRoadPlanner: IRoadPlanner,
-    @inject(TYPES.ReachableStopsFinder)
-    @tagged("phase", ReachableStopsSearchPhase.Initial)
-      initialReachableStopsFinder: IReachableStopsFinder,
-    @inject(TYPES.LocationResolver) locationResolver: ILocationResolver,
-  ) {
-    this.transferRoadPlanner = transferRoadPlanner;
-    this.finalRoadPlanner = finalRoadPlanner;
+  constructor(@inject(TYPES.LocationResolver) locationResolver: ILocationResolver) {
     this.locationResolver = locationResolver;
-    this.initialReachableStopsFinder = initialReachableStopsFinder;
   }
 
   public async extractJourneys(
@@ -64,67 +39,52 @@ export default class JourneyExtractorDefault implements IJourneyExtractor {
   ): Promise<AsyncIterator<IPath>> {
     const filteredProfilesByStop: IProfilesByStop = ProfileUtil.filterInfinity(profilesByStop);
 
-    const departureLocation: IStop = query.from[0] as IStop;
-
-    const reachableStops = await this.initialReachableStopsFinder.findReachableStops(
-      departureLocation,
-      ReachableStopsFinderMode.Source,
-      query.maximumTransferDuration,
-      query.minimumWalkingSpeed,
-    );
+    const departureLocation: ILocation = query.from[0];
+    const arrivalLocation: ILocation = query.to[0];
 
     const paths: IPath[] = [];
 
-    for (const reachableStop of reachableStops) {
-      const departureStop: IStop = reachableStop.stop;
+    const departureLocationProfiles: IProfile[] = filteredProfilesByStop[departureLocation.id];
 
-      if (!filteredProfilesByStop[departureStop.id]) {
-        console.warn("Can't find departure stop: " + departureStop.id);
-        continue;
-      }
-
-      for (const profile of filteredProfilesByStop[departureStop.id]) {
-        if (profile.departureTime >= query.minimumDepartureTime.getTime()) {
-          const arrivalStop = query.to[0];
-
-          for (let amountOfTransfers = 0; amountOfTransfers < profile.transferProfiles.length; amountOfTransfers++) {
-            const transferProfile = profile.transferProfiles[amountOfTransfers];
-            const enterStop = transferProfile.enterConnection && transferProfile.enterConnection.departureStop;
-
-            if (enterStop !== departureStop.id) {
-              continue;
-            }
-
-            if (this.checkBestArrivalTime(transferProfile, departureStop, arrivalStop)) {
-              try {
-                paths.push(await this.extractJourney(
-                  arrivalStop,
-                  reachableStop,
-                  profile,
-                  amountOfTransfers,
-                  filteredProfilesByStop,
-                  query,
-                ));
-
-                this.setBestArrivalTime(departureStop, arrivalStop, transferProfile.arrivalTime);
-              } catch (e) {
-                console.warn(e);
-              }
-            }
+    // Can't find departure stop;
+    if (!departureLocationProfiles) {
+      return new ArrayIterator<IPath>(paths);
+    }
 
+    for (const profile of departureLocationProfiles) {
+
+      for (let amountOfTransfers = 0; amountOfTransfers < profile.transferProfiles.length; amountOfTransfers++) {
+        const transferProfile: ITransferProfile = profile.transferProfiles[amountOfTransfers];
+
+        if (this.checkBestArrivalTime(transferProfile, departureLocation, arrivalLocation)) {
+          try {
+            paths.push(await this.extractJourney(
+              departureLocation,
+              arrivalLocation,
+              transferProfile,
+              amountOfTransfers,
+              filteredProfilesByStop,
+            ));
+
+            this.setBestArrivalTime(
+              departureLocation,
+              arrivalLocation,
+              transferProfile.arrivalTime,
+            );
+          } catch (e) {
+            console.warn(e);
           }
-
         }
       }
-    }
 
+    }
     return new ArrayIterator<IPath>(paths.reverse());
   }
 
   private checkBestArrivalTime(
     transferProfile: ITransferProfile,
-    departureStop: ILocation,
-    arrivalStop: ILocation,
+    departureLocation: ILocation,
+    arrivalLocation: ILocation,
   ): boolean {
 
     const canArrive = transferProfile.arrivalTime < Infinity;
@@ -133,13 +93,13 @@ export default class JourneyExtractorDefault implements IJourneyExtractor {
       return false;
     }
 
-    const bestArrivalTimesOfDepartureStop = this.bestArrivalTime[departureStop.id];
+    const bestArrivalTimesOfDepartureStop = this.bestArrivalTime[departureLocation.id];
 
     if (!bestArrivalTimesOfDepartureStop) {
       return true;
     }
 
-    const bestArrivalTime = bestArrivalTimesOfDepartureStop[arrivalStop.id];
+    const bestArrivalTime = bestArrivalTimesOfDepartureStop[arrivalLocation.id];
 
     if (!bestArrivalTime) {
       return true;
@@ -148,151 +108,116 @@ export default class JourneyExtractorDefault implements IJourneyExtractor {
     return transferProfile.arrivalTime < bestArrivalTime;
   }
 
-  private setBestArrivalTime(departureStop: ILocation, arrivalStop: ILocation, arrivalTime: number): void {
-    if (!this.bestArrivalTime[departureStop.id]) {
-      this.bestArrivalTime[departureStop.id] = [];
+  private setBestArrivalTime(departureLocation: ILocation, arrivalLocation: ILocation, arrivalTime: number): void {
+    if (!this.bestArrivalTime[departureLocation.id]) {
+      this.bestArrivalTime[departureLocation.id] = [];
     }
-    this.bestArrivalTime[departureStop.id][arrivalStop.id] = arrivalTime;
+    this.bestArrivalTime[departureLocation.id][arrivalLocation.id] = arrivalTime;
   }
 
   private async extractJourney(
-    arrivalStop: ILocation,
-    reachableStop: IReachableStop,
-    profile: Profile,
+    departureLocation: ILocation,
+    arrivalLocation: ILocation,
+    transferProfile: ITransferProfile,
     transfers: number,
     profilesByStop: IProfilesByStop,
-    query: IResolvedQuery,
   ): Promise<IPath> {
-    let shouldReturn = true;
-
-    // Extract journey for amount of transfers
     const path: Path = Path.create();
 
-    let currentProfile = profile;
-    let remainingTransfers = transfers;
+    let currentTransferProfile: ITransferProfile = transferProfile;
+    let departureTime: Date = new Date(transferProfile.departureTime);
 
-    if (reachableStop.duration > 0) {
-      const currentTransferProfile = profile.transferProfiles[remainingTransfers];
+    let remainingTransfers: number = transfers;
 
-      this.addInitialFootpath(
-        path,
-        currentTransferProfile,
-        reachableStop,
-        query.from[0],
-      );
-    }
+    let currentLocation: ILocation = departureLocation;
 
     while (remainingTransfers >= 0) {
-      // Construct and push step
-      const currentTransferProfile = currentProfile.transferProfiles[remainingTransfers];
-
       const enterConnection: IConnection = currentTransferProfile.enterConnection;
       const exitConnection: IConnection = currentTransferProfile.exitConnection;
 
-      const step: IStep = Step.createFromConnections(enterConnection, exitConnection);
-
-      step.startLocation = await this.locationResolver.resolve(step.startLocation.id);
-      step.stopLocation = await this.locationResolver.resolve(step.stopLocation.id);
+      const enterLocation: ILocation = await this.locationResolver.resolve(enterConnection.departureStop);
+      const exitLocation: ILocation = await this.locationResolver.resolve(exitConnection.arrivalStop);
+
+      // Initial or transfer footpath.
+      const transferDepartureTime: Date = enterConnection.departureTime;
+
+      if (departureTime.getTime() !== transferDepartureTime.getTime()) {
+        const footpath: IStep = Step.create(
+          currentLocation,
+          enterLocation,
+          TravelMode.Walking,
+          {
+            minimum: transferDepartureTime.getTime() - departureTime.getTime(),
+          },
+          departureTime,
+          transferDepartureTime,
+        );
+
+        path.addStep(footpath);
+      }
 
+      // Public transport step.
+      const step: IStep = Step.createFromConnections(enterConnection, exitConnection);
+      step.startLocation = enterLocation;
+      step.stopLocation = exitLocation;
       path.addStep(step);
 
+      currentLocation = exitLocation;
       remainingTransfers--;
+
+      // Stop if we already arrived.
+      if (path.steps[path.steps.length - 1].stopLocation.id === arrivalLocation.id) {
+        break;
+      }
+
+      // Get next profile based on the arrival time at the current location.
       if (remainingTransfers >= 0) {
-        const nextProfile = profilesByStop[step.stopLocation.id];
-
-        let i = nextProfile.length - 1;
-        let found = false;
-
-        while (!found && i >= 0) {
-          const nextTransferProfile = nextProfile[i].transferProfiles[remainingTransfers];
-          const connection = nextTransferProfile.enterConnection;
-
-          if (connection) {
-            const from = await this.locationResolver.resolve(step.stopLocation.id);
-            const to = await this.locationResolver.resolve(connection.departureStop);
-
-            const walkingResult = await this.transferRoadPlanner.plan({
-              from: [from],
-              to: [to],
-              minimumWalkingSpeed: query.minimumWalkingSpeed,
-              maximumWalkingSpeed: query.maximumWalkingSpeed,
-            });
-
-            // Get first path
-            const walkingPath: IPath = await Iterators.getFirst(walkingResult);
-
-            if (walkingPath && walkingPath.steps[0] &&
-              connection.departureTime.getTime() >= step.stopTime.getTime() +
-              walkingPath.steps[0].duration.minimum
-            ) {
-              found = true;
-              path.addStep(walkingPath.steps[0]);
-              currentProfile = nextProfile[i];
-            }
-          }
+        const currentProfiles: IProfile[] = profilesByStop[currentLocation.id];
+        let i: number = currentProfiles.length - 1;
 
-          i--;
+        currentTransferProfile = currentProfiles[i].transferProfiles[remainingTransfers];
+        departureTime = new Date(currentTransferProfile.departureTime);
+
+        while (i >= 0 && departureTime < exitConnection.arrivalTime) {
+          currentTransferProfile = currentProfiles[--i].transferProfiles[remainingTransfers];
+          departureTime = new Date(currentTransferProfile.departureTime);
         }
 
-        if (!found) {
-          return Promise.reject("Can't reach arrival stop: " + arrivalStop.id + ", transfers: " + transfers);
+        if (i === -1) {
+          // This should never happen.
+          return Promise.reject("Can't find next connection");
         }
+
       }
-    }
 
-    if (path.steps[path.steps.length - 1].stopLocation.id !== arrivalStop.id) {
-      shouldReturn = await this.addFinalFootpath(path, arrivalStop, query);
+      // Final footpath.
+      if (remainingTransfers === -1) {
+        const transferArrivalTime: Date = exitConnection.arrivalTime;
+        const arrivalTime: Date = new Date(currentTransferProfile.arrivalTime);
+
+        if (arrivalTime.getTime() !== transferArrivalTime.getTime()) {
+          const footpath: IStep = Step.create(
+            currentLocation,
+            arrivalLocation,
+            TravelMode.Walking,
+            {
+              minimum: arrivalTime.getTime() - transferArrivalTime.getTime(),
+            },
+            transferArrivalTime,
+            arrivalTime,
+          );
+
+          path.addStep(footpath);
+        }
+      }
     }
 
-    if (!shouldReturn) {
-      return Promise.reject("Can't reach arrival stop: " + arrivalStop.id + ", transfers: " + transfers);
+    // Check if path ends in the arrival location.
+    if (path.steps[path.steps.length - 1].stopLocation.id !== arrivalLocation.id) {
+      // This should never happen.
+      return Promise.reject("Can't reach arrival stop:");
     }
 
     return path as IPath;
   }
-
-  private addInitialFootpath(
-    path: Path,
-    transferProfile: ITransferProfile,
-    reachableStop: IReachableStop,
-    startLocation: ILocation,
-  ): void {
-    const enterConnection: IConnection = transferProfile.enterConnection;
-    const stopTime = enterConnection.departureTime;
-    const startTime = new Date(stopTime.valueOf() - reachableStop.duration);
-
-    const step = Step.create(
-      startLocation,
-      reachableStop.stop as ILocation,
-      TravelMode.Walking,
-      { minimum: reachableStop.duration },
-      startTime,
-      enterConnection.departureTime,
-      undefined,
-    );
-
-    path.addStep(step);
-  }
-
-  private async addFinalFootpath(path: Path, arrivalStop: ILocation, query: IResolvedQuery): Promise<boolean> {
-    const lastStep = path.steps[path.steps.length - 1];
-
-    const fromLocation = await this.locationResolver.resolve(lastStep.stopLocation.id);
-    const toLocation = await this.locationResolver.resolve(arrivalStop);
-
-    const walkingResult = await this.finalRoadPlanner.plan({
-      from: [fromLocation],
-      to: [toLocation],
-      minimumWalkingSpeed: query.minimumWalkingSpeed,
-      maximumWalkingSpeed: query.maximumWalkingSpeed,
-    });
-
-    if (walkingResult && walkingResult[0] && walkingResult[0].steps[0] &&
-      query.maximumArrivalTime.getTime() >= lastStep.stopTime.getTime() +
-      walkingResult[0].steps[0].duration.minimum) {
-      path.addStep(walkingResult[0].steps[0]);
-      return true;
-    }
-    return false;
-  }
 }
diff --git a/src/planner/public-transport/PublicTransportPlannerCSAProfile.test.ts b/src/planner/public-transport/PublicTransportPlannerCSAProfile.test.ts
index 760564ad..85927f8b 100644
--- a/src/planner/public-transport/PublicTransportPlannerCSAProfile.test.ts
+++ b/src/planner/public-transport/PublicTransportPlannerCSAProfile.test.ts
@@ -1,5 +1,6 @@
 import "jest";
 import LDFetch from "ldfetch";
+import Defaults from "../../Defaults";
 import ConnectionsFetcherLazy from "../../fetcher/connections/ld-fetch/ConnectionsFetcherLazy";
 import ConnectionsFetcherNMBSTest from "../../fetcher/connections/tests/ConnectionsFetcherNMBSTest";
 import connectionsIngelmunsterGhent from "../../fetcher/connections/tests/data/ingelmunster-ghent";
@@ -9,14 +10,11 @@ import StopsFetcherLDFetch from "../../fetcher/stops/ld-fetch/StopsFetcherLDFetc
 import IPath from "../../interfaces/IPath";
 import IQuery from "../../interfaces/IQuery";
 import IStep from "../../interfaces/IStep";
-import Planner from "../../Planner";
 import IResolvedQuery from "../../query-runner/IResolvedQuery";
 import LocationResolverDefault from "../../query-runner/LocationResolverDefault";
 import QueryRunnerDefault from "../../query-runner/QueryRunnerDefault";
 import TravelMode from "../../TravelMode";
 import Iterators from "../../util/Iterators";
-import Units from "../../util/Units";
-import RoadPlannerBirdsEye from "../road/RoadPlannerBirdsEye";
 import ReachableStopsFinderBirdsEyeCached from "../stops/ReachableStopsFinderBirdsEyeCached";
 import JourneyExtractorDefault from "./JourneyExtractorDefault";
 import PublicTransportPlannerCSAProfile from "./PublicTransportPlannerCSAProfile";
@@ -32,16 +30,11 @@ describe("[PublicTransportPlannerCSAProfile]", () => {
       connectionFetcher.setConfig({ backward: true });
 
       const stopsFetcher = new StopsFetcherLDFetch(ldFetch);
-      stopsFetcher.setPrefix("http://irail.be/stations/NMBS/");
       stopsFetcher.setAccessUrl("https://irail.be/stations/NMBS");
 
       const locationResolver = new LocationResolverDefault(stopsFetcher);
       const reachableStopsFinder = new ReachableStopsFinderBirdsEyeCached(stopsFetcher);
-      const roadPlanner = new RoadPlannerBirdsEye();
       const journeyExtractor = new JourneyExtractorDefault(
-        roadPlanner,
-        roadPlanner,
-        reachableStopsFinder,
         locationResolver,
       );
 
@@ -50,6 +43,7 @@ describe("[PublicTransportPlannerCSAProfile]", () => {
         locationResolver,
         reachableStopsFinder,
         reachableStopsFinder,
+        reachableStopsFinder,
         journeyExtractor,
       );
     };
@@ -59,11 +53,14 @@ describe("[PublicTransportPlannerCSAProfile]", () => {
 
       const query: IResolvedQuery = {
         publicTransportOnly: true,
-        from: [{ id: "http://irail.be/stations/NMBS/008896925", latitude: 50.914326, longitude: 3.255416 }],
-        to: [{ id: "http://irail.be/stations/NMBS/008892007", latitude: 51.035896, longitude: 3.710675 }],
+        from: [{latitude: 50.914326, longitude: 3.255415 }],
+        to: [{ latitude: 51.035896, longitude: 3.710875 }],
         minimumDepartureTime: new Date("2018-11-06T09:00:00.000Z"),
         maximumArrivalTime: new Date("2018-11-06T19:00:00.000Z"),
         maximumTransfers: 8,
+        minimumWalkingSpeed: Defaults.defaultMinimumWalkingSpeed,
+        maximumWalkingSpeed: Defaults.defaultMaximumWalkingSpeed,
+        maximumTransferDuration: Defaults.defaultMaximumTransferDuration,
       };
 
       beforeAll(async () => {
@@ -89,11 +86,22 @@ describe("[PublicTransportPlannerCSAProfile]", () => {
 
       const query: IResolvedQuery = {
         publicTransportOnly: true,
-        from: [{ id: "http://irail.be/stations/NMBS/008821006" }],
-        to: [{ id: "http://irail.be/stations/NMBS/008812005" }],
+        from: [{
+          id: "http://irail.be/stations/NMBS/008821006",
+          latitude: 51.2172,
+          longitude: 4.421101,
+        }],
+        to: [{
+          id: "http://irail.be/stations/NMBS/008812005",
+          latitude: 50.859663,
+          longitude: 4.360846,
+        }],
         minimumDepartureTime: new Date("2017-12-19T15:50:00.000Z"),
         maximumArrivalTime: new Date("2017-12-19T16:50:00.000Z"),
         maximumTransfers: 1,
+        minimumWalkingSpeed: Defaults.defaultMinimumWalkingSpeed,
+        maximumWalkingSpeed: Defaults.defaultMaximumWalkingSpeed,
+        maximumTransferDuration: Defaults.defaultMaximumTransferDuration,
       };
 
       beforeAll(async () => {
@@ -123,11 +131,22 @@ describe("[PublicTransportPlannerCSAProfile]", () => {
 
       const query: IResolvedQuery = {
         publicTransportOnly: true,
-        from: [{ id: "http://irail.be/stations/NMBS/008812005" }],
-        to: [{ id: "http://irail.be/stations/NMBS/008821006" }],
+        from: [{
+          id: "http://irail.be/stations/NMBS/008812005",
+          latitude: 50.859663,
+          longitude: 4.360846,
+        }],
+        to: [{
+          id: "http://irail.be/stations/NMBS/008821006",
+          latitude: 51.2172,
+          longitude: 4.421101,
+        }],
         minimumDepartureTime: new Date("2017-12-19T16:20:00.000Z"),
         maximumArrivalTime: new Date("2017-12-19T16:50:00.000Z"),
         maximumTransfers: 1,
+        minimumWalkingSpeed: Defaults.defaultMinimumWalkingSpeed,
+        maximumWalkingSpeed: Defaults.defaultMaximumWalkingSpeed,
+        maximumTransferDuration: Defaults.defaultMaximumTransferDuration,
       };
 
       beforeAll(async () => {
@@ -162,16 +181,11 @@ describe("[PublicTransportPlannerCSAProfile]", () => {
       connectionFetcher.setAccessUrl("https://graph.irail.be/sncb/connections");
 
       const stopsFetcher = new StopsFetcherLDFetch(ldFetch);
-      stopsFetcher.setPrefix("http://irail.be/stations/NMBS/");
       stopsFetcher.setAccessUrl("https://irail.be/stations/NMBS");
 
       const locationResolver = new LocationResolverDefault(stopsFetcher);
       const reachableStopsFinder = new ReachableStopsFinderBirdsEyeCached(stopsFetcher);
-      const roadPlanner = new RoadPlannerBirdsEye();
       const journeyExtractor = new JourneyExtractorDefault(
-        roadPlanner,
-        roadPlanner,
-        reachableStopsFinder,
         locationResolver,
       );
 
@@ -180,6 +194,7 @@ describe("[PublicTransportPlannerCSAProfile]", () => {
         locationResolver,
         reachableStopsFinder,
         reachableStopsFinder,
+        reachableStopsFinder,
         journeyExtractor,
       );
 
@@ -330,49 +345,5 @@ describe("[PublicTransportPlannerCSAProfile]", () => {
       });
     });
 
-    describe("Exponential query runner", () => {
-      jest.setTimeout(100000);
-      let publicTransportResult;
-
-      const query = {
-        publicTransportOnly: true,
-        from: "http://irail.be/stations/NMBS/008896925", // Ingelmunster
-        to: "http://irail.be/stations/NMBS/008892007", // Ghent-Sint-Pieters
-        minimumDepartureTime: new Date(),
-        maximumTransferDuration: Units.fromHours(.5),
-      };
-
-      const result: IPath[] = [];
-
-      beforeAll(async (done) => {
-        const planner = new Planner();
-        publicTransportResult = await planner.query(query);
-
-        let i = 0;
-        publicTransportResult.on("readable", () => {
-          let path = publicTransportResult.read();
-          if (path) {
-            result.push(path);
-          }
-
-          while (path && i < 10) {
-            i++;
-            path = publicTransportResult.read();
-
-            if (path) {
-              result.push(path);
-            }
-          }
-
-          if (i === 10) {
-            done();
-          }
-        });
-      });
-
-      it("Correct departure and arrival stop", () => {
-          checkStops(result, query);
-      });
-    });
   });
 });
diff --git a/src/planner/public-transport/PublicTransportPlannerCSAProfile.ts b/src/planner/public-transport/PublicTransportPlannerCSAProfile.ts
index b2e696a5..e8c7db71 100644
--- a/src/planner/public-transport/PublicTransportPlannerCSAProfile.ts
+++ b/src/planner/public-transport/PublicTransportPlannerCSAProfile.ts
@@ -1,15 +1,20 @@
 import { AsyncIterator } from "asynciterator";
 import { inject, injectable, tagged } from "inversify";
+import Context from "../../Context";
+import EventType from "../../EventType";
+import DropOffType from "../../fetcher/connections/DropOffType";
 import IConnection from "../../fetcher/connections/IConnection";
 import IConnectionsProvider from "../../fetcher/connections/IConnectionsProvider";
+import PickupType from "../../fetcher/connections/PickupType";
 import IStop from "../../fetcher/stops/IStop";
+import ILocation from "../../interfaces/ILocation";
 import IPath from "../../interfaces/IPath";
 import { DurationMs } from "../../interfaces/units";
 import ILocationResolver from "../../query-runner/ILocationResolver";
 import IResolvedQuery from "../../query-runner/IResolvedQuery";
 import TYPES from "../../types";
 import Vectors from "../../util/Vectors";
-import IReachableStopsFinder from "../stops/IReachableStopsFinder";
+import IReachableStopsFinder, { IReachableStop } from "../stops/IReachableStopsFinder";
 import ReachableStopsFinderMode from "../stops/ReachableStopsFinderMode";
 import ReachableStopsSearchPhase from "../stops/ReachableStopsSearchPhase";
 import IArrivalTimeByTransfers from "./CSA/data-structure/IArrivalTimeByTransfers";
@@ -37,38 +42,64 @@ import IPublicTransportPlanner from "./IPublicTransportPlanner";
 export default class PublicTransportPlannerCSAProfile implements IPublicTransportPlanner {
   private readonly connectionsProvider: IConnectionsProvider;
   private readonly locationResolver: ILocationResolver;
+  private readonly initialReachableStopsFinder: IReachableStopsFinder;
   private readonly finalReachableStopsFinder: IReachableStopsFinder;
   private readonly transferReachableStopsFinder: IReachableStopsFinder;
   private readonly journeyExtractor: IJourneyExtractor;
+  private readonly context: Context;
 
   private profilesByStop: IProfilesByStop = {}; // S
   private earliestArrivalByTrip: IEarliestArrivalByTrip = {}; // T
   private durationToTargetByStop: DurationMs[] = [];
   private gtfsTripByConnection = {};
+  private initialReachableStops: IReachableStop[] = [];
 
   private query: IResolvedQuery;
   private connectionsIterator: AsyncIterator<IConnection>;
 
   constructor(
-    @inject(TYPES.ConnectionsProvider) connectionsProvider: IConnectionsProvider,
-    @inject(TYPES.LocationResolver) locationResolver: ILocationResolver,
+    @inject(TYPES.ConnectionsProvider)
+      connectionsProvider: IConnectionsProvider,
+    @inject(TYPES.LocationResolver)
+      locationResolver: ILocationResolver,
+    @inject(TYPES.ReachableStopsFinder)
+    @tagged("phase", ReachableStopsSearchPhase.Initial)
+      initialReachableStopsFinder: IReachableStopsFinder,
     @inject(TYPES.ReachableStopsFinder)
     @tagged("phase", ReachableStopsSearchPhase.Transfer)
       transferReachableStopsFinder: IReachableStopsFinder,
     @inject(TYPES.ReachableStopsFinder)
     @tagged("phase", ReachableStopsSearchPhase.Final)
       finalReachableStopsFinder: IReachableStopsFinder,
-    @inject(TYPES.JourneyExtractor) journeyExtractor: IJourneyExtractor,
+    @inject(TYPES.JourneyExtractor)
+      journeyExtractor: IJourneyExtractor,
+    @inject(TYPES.Context)
+      context?: Context,
   ) {
     this.connectionsProvider = connectionsProvider;
     this.locationResolver = locationResolver;
+    this.initialReachableStopsFinder = initialReachableStopsFinder;
     this.transferReachableStopsFinder = transferReachableStopsFinder;
     this.finalReachableStopsFinder = finalReachableStopsFinder;
     this.journeyExtractor = journeyExtractor;
+    this.context = context;
   }
 
   public async plan(query: IResolvedQuery): Promise<AsyncIterator<IPath>> {
     this.query = query;
+
+    const departureLocation = this.query.from[0];
+    if (!departureLocation.id) {
+      departureLocation.id = "geo:" + departureLocation.latitude + "," + departureLocation.longitude;
+      departureLocation.name = "Departure location";
+    }
+
+    const arrivalLocation = this.query.to[0];
+    if (!arrivalLocation.id) {
+      arrivalLocation.id = "geo:" + arrivalLocation.latitude + "," + arrivalLocation.longitude;
+      arrivalLocation.name = "Arrival location";
+    }
+
     this.setBounds();
 
     return this.calculateJourneys();
@@ -89,18 +120,24 @@ export default class PublicTransportPlannerCSAProfile implements IPublicTranspor
 
   private async calculateJourneys(): Promise<AsyncIterator<IPath>> {
     await this.initDurationToTargetByStop();
+    await this.initInitialReachableStops();
 
     this.connectionsIterator = this.connectionsProvider.createIterator();
 
     const self = this;
 
     return new Promise((resolve, reject) => {
-
+      let isDone = false;
       const done = () => {
-        self.journeyExtractor.extractJourneys(self.profilesByStop, self.query)
-          .then((resultIterator) => {
-            resolve(resultIterator);
-          });
+        if (!isDone) {
+          self.connectionsIterator.close();
+
+          self.journeyExtractor.extractJourneys(self.profilesByStop, self.query)
+            .then((resultIterator) => {
+              resolve(resultIterator);
+            });
+          isDone = true;
+        }
       };
 
       this.connectionsIterator.on("readable", () =>
@@ -127,6 +164,10 @@ export default class PublicTransportPlannerCSAProfile implements IPublicTranspor
         return;
       }
 
+      if (this.context) {
+        this.context.emit(EventType.ConnectionScan, connection);
+      }
+
       this.discoverConnection(connection);
 
       const earliestArrivalTime = this.calculateEarliestArrivalTime(connection);
@@ -193,26 +234,64 @@ export default class PublicTransportPlannerCSAProfile implements IPublicTranspor
     return Vectors.minVector((c) => c.arrivalTime, walkToTargetTime, remainSeatedTime, takeTransferTime);
   }
 
-  private async initDurationToTargetByStop(): Promise<void> {
+  private async initDurationToTargetByStop(): Promise<boolean> {
     const arrivalStop: IStop = this.query.to[0] as IStop;
 
     const reachableStops = await this.finalReachableStopsFinder
       .findReachableStops(
         arrivalStop,
         ReachableStopsFinderMode.Target,
-        this.query.maximumTransferDuration,
+        this.query.maximumWalkingDuration,
         this.query.minimumWalkingSpeed,
       );
 
+    if (reachableStops.length === 0 && this.context) {
+      this.context.emit(EventType.QueryAbort);
+
+      return false;
+    }
+
+    if (this.context) {
+      this.context.emit(EventType.FinalReachableStops, reachableStops);
+    }
+
     for (const reachableStop of reachableStops) {
       this.durationToTargetByStop[reachableStop.stop.id] = reachableStop.duration;
     }
+
+    return true;
+  }
+
+  private async initInitialReachableStops(): Promise<boolean> {
+    const fromLocation: IStop = this.query.from[0] as IStop;
+
+    this.initialReachableStops = await this.initialReachableStopsFinder.findReachableStops(
+      fromLocation,
+      ReachableStopsFinderMode.Source,
+      this.query.maximumWalkingDuration,
+      this.query.minimumWalkingSpeed,
+    );
+
+    if (this.initialReachableStops.length === 0 && this.context) {
+      this.context.emit(EventType.QueryAbort);
+
+      return false;
+    }
+
+    if (this.context) {
+      this.context.emit(EventType.InitialReachableStops, this.initialReachableStops);
+    }
+
+    return true;
   }
 
   private walkToTarget(connection: IConnection): IArrivalTimeByTransfers {
     const walkingTimeToTarget = this.durationToTargetByStop[connection.arrivalStop];
 
-    if (walkingTimeToTarget === undefined) {
+    if (
+      walkingTimeToTarget === undefined || connection["gtfs:dropOfType"] === "gtfs:NotAvailable" ||
+      connection.arrivalTime.getTime() + walkingTimeToTarget > this.query.maximumArrivalTime.getTime()
+    ) {
       return Array(this.query.maximumTransfers + 1).fill({
         "arrivalTime": Infinity,
         "gtfs:trip": connection["gtfs:trip"],
@@ -251,8 +330,17 @@ export default class PublicTransportPlannerCSAProfile implements IPublicTranspor
   }
 
   private takeTransfer(connection: IConnection): IArrivalTimeByTransfers {
+
+    const transferTimes: IArrivalTimeByTransfers = ProfileUtil.getTransferTimes(
+      this.profilesByStop,
+      connection,
+      this.query.maximumTransfers,
+      this.query.minimumTransferDuration,
+      this.query.maximumTransferDuration,
+    );
+
     return Vectors.shiftVector<IArrivalTimeByTransfers>(
-      ProfileUtil.getTransferTimes(this.profilesByStop, connection, this.query.maximumTransfers),
+      transferTimes,
       { "arrivalTime": Infinity, "gtfs:trip": connection["gtfs:trip"] },
     );
   }
@@ -290,26 +378,58 @@ export default class PublicTransportPlannerCSAProfile implements IPublicTranspor
     connection: IConnection,
     currentArrivalTimeByTransfers: IArrivalTimeByTransfers,
   ): Promise<void> {
+    const departureLocation: IStop = this.query.from[0] as IStop;
     const depProfile: Profile[] = this.profilesByStop[connection.departureStop];
-    const earliestProfileEntry = depProfile[depProfile.length - 1];
+    const earliestProfileEntry: Profile = depProfile[depProfile.length - 1];
 
-    const earliestArrivalTimeByTransfers = Vectors.minVector(
+    const earliestArrivalTimeByTransfers: IArrivalTimeByTransfers = Vectors.minVector(
       (c) => c.arrivalTime,
       currentArrivalTimeByTransfers,
       earliestProfileEntry.getArrivalTimeByTransfers(),
     );
 
-    const departureStop = await this.locationResolver.resolve(connection.departureStop);
-    const reachableStops = await this.transferReachableStopsFinder.findReachableStops(
+    const initialReachableStop: IReachableStop = this.initialReachableStops.find(
+      (reachable: IReachableStop) =>
+        reachable.stop.id === connection.departureStop,
+    );
+
+    if (initialReachableStop) {
+      this.incorporateInProfile(
+        connection,
+        initialReachableStop.duration,
+        departureLocation,
+        earliestArrivalTimeByTransfers,
+      );
+    }
+
+    const departureStop: ILocation = await this.locationResolver.resolve(connection.departureStop);
+    const reachableStops: IReachableStop[] = await this.transferReachableStopsFinder.findReachableStops(
       departureStop as IStop,
       ReachableStopsFinderMode.Source,
-      this.query.maximumTransferDuration,
+      this.query.maximumWalkingDuration,
       this.query.minimumWalkingSpeed,
     );
 
-    reachableStops.forEach((reachableStop) => {
-      // Incorporate (c_dep_time - f_dur, t_c) into profile of S[f_dep_stop]
-      this.incorporateInProfile(connection, reachableStop.duration, reachableStop.stop, earliestArrivalTimeByTransfers);
+    reachableStops.forEach((reachableStop: IReachableStop) => {
+      if (reachableStop.stop.id !== departureLocation.id) {
+        this.incorporateInProfile(
+          connection,
+          reachableStop.duration,
+          reachableStop.stop,
+          earliestArrivalTimeByTransfers,
+        );
+      }
+    });
+  }
+
+  private async emitTransferProfile(transferProfile: ITransferProfile, amountOfTransfers: number): Promise<void> {
+    const departureStop = await this.locationResolver.resolve(transferProfile.enterConnection.departureStop);
+    const arrivalStop = await this.locationResolver.resolve(transferProfile.exitConnection.arrivalStop);
+
+    this.context.emit(EventType.AddedNewTransferProfile, {
+      departureStop,
+      arrivalStop,
+      amountOfTransfers,
     });
   }
 
@@ -318,7 +438,13 @@ export default class PublicTransportPlannerCSAProfile implements IPublicTranspor
     duration: DurationMs,
     stop: IStop,
     arrivalTimeByTransfers: IArrivalTimeByTransfers,
-  ) {
+  ): void {
+    const departureTime = connection.departureTime.getTime() - duration;
+
+    if (departureTime < this.query.minimumDepartureTime.getTime()) {
+      return;
+    }
+
     let profilesByDepartureStop = this.profilesByStop[stop.id];
 
     if (!profilesByDepartureStop) {
@@ -340,6 +466,7 @@ export default class PublicTransportPlannerCSAProfile implements IPublicTranspor
           exitConnection: undefined,
           enterConnection: undefined,
           arrivalTime: Infinity,
+          departureTime: Infinity,
         };
 
         const possibleExitConnection = this.earliestArrivalByTrip[connection["gtfs:trip"]]
@@ -347,14 +474,21 @@ export default class PublicTransportPlannerCSAProfile implements IPublicTranspor
 
         if (
           arrivalTimeByTransfers[amountOfTransfers].arrivalTime < transferProfile.arrivalTime &&
-          connection["gtfs:pickupType"] !== "gtfs:NotAvailable" &&
-          possibleExitConnection["gtfs:dropOfType"] !== "gtfs:NotAvailable"
+          connection["gtfs:pickupType"] !== PickupType.NotAvailable &&
+          possibleExitConnection["gtfs:dropOfType"] !== DropOffType.NotAvailable
         ) {
           newTransferProfile.enterConnection = connection;
           newTransferProfile.exitConnection = possibleExitConnection;
+          newTransferProfile.departureTime = departureTime;
+
+          if (this.context && this.context.listenerCount(EventType.AddedNewTransferProfile) > 0) {
+            this.emitTransferProfile(newTransferProfile, amountOfTransfers);
+          }
+
         } else {
           newTransferProfile.enterConnection = transferProfile.enterConnection;
           newTransferProfile.exitConnection = transferProfile.exitConnection;
+          newTransferProfile.departureTime = transferProfile.departureTime;
         }
 
         if (newTransferProfile.exitConnection && newTransferProfile.enterConnection) {
@@ -364,7 +498,6 @@ export default class PublicTransportPlannerCSAProfile implements IPublicTranspor
         transferProfiles.push(newTransferProfile);
       }
 
-      const departureTime = connection.departureTime.getTime() - duration;
       const newProfile: Profile = Profile.createFromTransfers(departureTime, transferProfiles);
 
       let i = profilesByDepartureStop.length - 1;
diff --git a/src/planner/road/RoadPlannerBirdsEye.test.ts b/src/planner/road/RoadPlannerBirdsEye.test.ts
index 7f6201a2..b15577ca 100644
--- a/src/planner/road/RoadPlannerBirdsEye.test.ts
+++ b/src/planner/road/RoadPlannerBirdsEye.test.ts
@@ -11,7 +11,6 @@ const ldFetch = new LDFetch({ headers: { Accept: "application/ld+json" } });
 const planner: IRoadPlanner = new RoadPlannerBirdsEye();
 
 const stopsFetcher = new StopsFetcherLDFetch(ldFetch);
-stopsFetcher.setPrefix("http://irail.be/stations/NMBS/");
 stopsFetcher.setAccessUrl("https://irail.be/stations/NMBS");
 
 const locationResolver = new LocationResolverDefault(stopsFetcher);
diff --git a/src/planner/stops/ReachableStopsFinderBirdsEye.test.ts b/src/planner/stops/ReachableStopsFinderBirdsEye.test.ts
index c503f602..86523581 100644
--- a/src/planner/stops/ReachableStopsFinderBirdsEye.test.ts
+++ b/src/planner/stops/ReachableStopsFinderBirdsEye.test.ts
@@ -16,7 +16,6 @@ const DE_LIJN_STOPS_URLS = [
 const ldFetch = new LDFetch({ headers: { Accept: "application/ld+json" } });
 
 const stopsFetcher = new StopsFetcherLDFetch(ldFetch);
-stopsFetcher.setPrefix("https://data.delijn.be/stops/");
 stopsFetcher.setAccessUrl(DE_LIJN_STOPS_URLS[2]);
 
 const reachableStopsFinder = new ReachableStopsFinderBirdsEye(stopsFetcher);
diff --git a/src/planner/stops/ReachableStopsFinderRoadPlanner.test.ts b/src/planner/stops/ReachableStopsFinderRoadPlanner.test.ts
index 9013d2e5..e567b4a9 100644
--- a/src/planner/stops/ReachableStopsFinderRoadPlanner.test.ts
+++ b/src/planner/stops/ReachableStopsFinderRoadPlanner.test.ts
@@ -9,7 +9,6 @@ import ReachableStopsFinderRoadPlanner from "./ReachableStopsFinderRoadPlanner";
 const ldFetch = new LDFetch({ headers: { Accept: "application/ld+json" } });
 
 const stopsFetcher = new StopsFetcherLDFetch(ldFetch);
-stopsFetcher.setPrefix("http://irail.be/stations/NMBS/");
 stopsFetcher.setAccessUrl("https://irail.be/stations/NMBS");
 
 const roadPlanner = new RoadPlannerBirdsEye();
diff --git a/src/query-runner/IResolvedQuery.ts b/src/query-runner/IResolvedQuery.ts
index db2f1710..210fe29f 100644
--- a/src/query-runner/IResolvedQuery.ts
+++ b/src/query-runner/IResolvedQuery.ts
@@ -10,6 +10,8 @@ export default interface IResolvedQuery {
   publicTransportOnly?: boolean;
   minimumWalkingSpeed?: SpeedkmH;
   maximumWalkingSpeed?: SpeedkmH;
+  maximumWalkingDuration?: DurationMs;
+  minimumTransferDuration?: DurationMs;
   maximumTransferDuration?: DurationMs;
   maximumTransfers?: number;
 }
diff --git a/src/query-runner/LocationResolverDefault.test.ts b/src/query-runner/LocationResolverDefault.test.ts
index 5f3cd9a8..1ec1a03d 100644
--- a/src/query-runner/LocationResolverDefault.test.ts
+++ b/src/query-runner/LocationResolverDefault.test.ts
@@ -6,7 +6,6 @@ import LocationResolverDefault from "./LocationResolverDefault";
 const ldFetch = new LDFetch({ headers: { Accept: "application/ld+json" } });
 
 const stopsFetcher = new StopsFetcherLDFetch(ldFetch);
-stopsFetcher.setPrefix("http://irail.be/stations/NMBS/");
 stopsFetcher.setAccessUrl("https://irail.be/stations/NMBS");
 
 const locationResolver = new LocationResolverDefault(stopsFetcher);
diff --git a/src/query-runner/QueryRunnerDefault.ts b/src/query-runner/QueryRunnerDefault.ts
index dbd78739..d78e60cf 100644
--- a/src/query-runner/QueryRunnerDefault.ts
+++ b/src/query-runner/QueryRunnerDefault.ts
@@ -6,6 +6,7 @@ import IPath from "../interfaces/IPath";
 import IQuery from "../interfaces/IQuery";
 import IPublicTransportPlanner from "../planner/public-transport/IPublicTransportPlanner";
 import TYPES from "../types";
+import Units from "../util/Units";
 import ILocationResolver from "./ILocationResolver";
 import IQueryRunner from "./IQueryRunner";
 import IResolvedQuery from "./IResolvedQuery";
@@ -54,7 +55,8 @@ export default class QueryRunnerDefault implements IQueryRunner {
     const {
       from, to,
       minimumWalkingSpeed, maximumWalkingSpeed, walkingSpeed,
-      maximumTransferDuration, maximumTransfers,
+      maximumWalkingDuration, maximumWalkingDistance,
+      minimumTransferDuration, maximumTransferDuration, maximumTransfers,
       minimumDepartureTime, maximumArrivalTime,
       ...other
     } = query;
@@ -78,7 +80,10 @@ export default class QueryRunnerDefault implements IQueryRunner {
     resolvedQuery.to = await this.resolveEndpoint(to);
     resolvedQuery.minimumWalkingSpeed = minimumWalkingSpeed || walkingSpeed || Defaults.defaultMinimumWalkingSpeed;
     resolvedQuery.maximumWalkingSpeed = maximumWalkingSpeed || walkingSpeed || Defaults.defaultMaximumWalkingSpeed;
+    resolvedQuery.maximumWalkingDuration = maximumWalkingDuration ||
+      Units.toDuration(maximumWalkingDistance, resolvedQuery.minimumWalkingSpeed) || Defaults.defaultWalkingDuration;
 
+    resolvedQuery.minimumTransferDuration = minimumTransferDuration || Defaults.defaultMinimumTransferDuration;
     resolvedQuery.maximumTransferDuration = maximumTransferDuration || Defaults.defaultMaximumTransferDuration;
     resolvedQuery.maximumTransfers = maximumTransfers || Defaults.defaultMaximumTransfers;
 
diff --git a/src/query-runner/exponential/FilterUniqueIterator.ts b/src/query-runner/exponential/FilterUniquePathsIterator.ts
similarity index 73%
rename from src/query-runner/exponential/FilterUniqueIterator.ts
rename to src/query-runner/exponential/FilterUniquePathsIterator.ts
index d937d256..bec79048 100644
--- a/src/query-runner/exponential/FilterUniqueIterator.ts
+++ b/src/query-runner/exponential/FilterUniquePathsIterator.ts
@@ -2,12 +2,15 @@ import { AsyncIterator, SimpleTransformIterator } from "asynciterator";
 import IPath from "../../interfaces/IPath";
 import Path from "../../planner/Path";
 
-export default class FilterUniqueIterator extends SimpleTransformIterator<IPath, IPath> {
+export default class FilterUniquePathsIterator extends SimpleTransformIterator<IPath, IPath> {
 
   private store: Path[];
 
   constructor(source: AsyncIterator<IPath>) {
-    super(source);
+    super(source, {
+      maxBufferSize: 1,
+      autoStart: false,
+    });
 
     this.store = [];
   }
diff --git a/src/query-runner/exponential/QueryRunnerExponential.test.ts b/src/query-runner/exponential/QueryRunnerExponential.test.ts
new file mode 100644
index 00000000..06985aef
--- /dev/null
+++ b/src/query-runner/exponential/QueryRunnerExponential.test.ts
@@ -0,0 +1,104 @@
+import "jest";
+import LDFetch from "ldfetch";
+import Context from "../../Context";
+import ConnectionsFetcherLazy from "../../fetcher/connections/ld-fetch/ConnectionsFetcherLazy";
+import StopsFetcherLDFetch from "../../fetcher/stops/ld-fetch/StopsFetcherLDFetch";
+import IPath from "../../interfaces/IPath";
+import IStep from "../../interfaces/IStep";
+import JourneyExtractorDefault from "../../planner/public-transport/JourneyExtractorDefault";
+import PublicTransportPlannerCSAProfile from "../../planner/public-transport/PublicTransportPlannerCSAProfile";
+import ReachableStopsFinderBirdsEyeCached from "../../planner/stops/ReachableStopsFinderBirdsEyeCached";
+import TravelMode from "../../TravelMode";
+import Units from "../../util/Units";
+import LocationResolverDefault from "../LocationResolverDefault";
+import QueryRunnerExponential from "./QueryRunnerExponential";
+
+describe("[QueryRunnerExponential]", () => {
+  jest.setTimeout(100000);
+
+  let publicTransportResult;
+
+  const query = {
+    publicTransportOnly: true,
+    from: "http://irail.be/stations/NMBS/008896925", // Ingelmunster
+    to: "http://irail.be/stations/NMBS/008892007", // Ghent-Sint-Pieters
+    minimumDepartureTime: new Date(),
+    maximumTransferDuration: Units.fromHours(.5),
+  };
+
+  const createExponentialQueryRunner = () => {
+    const ldFetch = new LDFetch({ headers: { Accept: "application/ld+json" } });
+
+    const connectionFetcher = new ConnectionsFetcherLazy(ldFetch);
+    connectionFetcher.setTravelMode(TravelMode.Train);
+    connectionFetcher.setAccessUrl("https://graph.irail.be/sncb/connections");
+
+    const stopsFetcher = new StopsFetcherLDFetch(ldFetch);
+    stopsFetcher.setAccessUrl("https://irail.be/stations/NMBS");
+
+    const locationResolver = new LocationResolverDefault(stopsFetcher);
+    const reachableStopsFinder = new ReachableStopsFinderBirdsEyeCached(stopsFetcher);
+
+    const context = new Context();
+
+    const createJourneyExtractor = () => {
+      return new JourneyExtractorDefault(
+        locationResolver,
+      );
+    };
+
+    const createPlanner = () => {
+      return new PublicTransportPlannerCSAProfile(
+        connectionFetcher,
+        locationResolver,
+        reachableStopsFinder,
+        reachableStopsFinder,
+        reachableStopsFinder,
+        createJourneyExtractor(),
+      );
+    };
+
+    return new QueryRunnerExponential(context, locationResolver, createPlanner);
+  };
+
+  const result: IPath[] = [];
+
+  beforeAll(async (done) => {
+
+    const queryRunner = createExponentialQueryRunner();
+
+    publicTransportResult = await queryRunner.run(query);
+
+    await publicTransportResult.take(3)
+      .on("data", (path: IPath) => {
+        result.push(path);
+      })
+      .on("end", () => {
+        done();
+      });
+  });
+
+  it("Correct departure and arrival stop", () => {
+    checkStops(result, query);
+  });
+});
+
+const checkStops = (result, query) => {
+  expect(result).toBeDefined();
+  expect(result.length).toBeGreaterThanOrEqual(1);
+
+  for (const path of result) {
+    expect(path.steps).toBeDefined();
+
+    expect(path.steps.length).toBeGreaterThanOrEqual(1);
+
+    let currentLocation = query.from;
+    path.steps.forEach((step: IStep) => {
+      expect(step).toBeDefined();
+      expect(currentLocation).toEqual(step.startLocation.id);
+      currentLocation = step.stopLocation.id;
+    });
+
+    expect(query.to).toEqual(currentLocation);
+  }
+};
diff --git a/src/query-runner/exponential/QueryRunnerExponential.ts b/src/query-runner/exponential/QueryRunnerExponential.ts
index d5e2f3f2..cde5f40b 100644
--- a/src/query-runner/exponential/QueryRunnerExponential.ts
+++ b/src/query-runner/exponential/QueryRunnerExponential.ts
@@ -1,35 +1,39 @@
 import { AsyncIterator } from "asynciterator";
-import { inject, injectable } from "inversify";
+import { inject, injectable, interfaces } from "inversify";
 import Context from "../../Context";
 import Defaults from "../../Defaults";
+import EventType from "../../EventType";
 import ILocation from "../../interfaces/ILocation";
 import IPath from "../../interfaces/IPath";
 import IQuery from "../../interfaces/IQuery";
 import IPublicTransportPlanner from "../../planner/public-transport/IPublicTransportPlanner";
 import TYPES from "../../types";
+import Emiterator from "../../util/iterators/Emiterator";
+import Units from "../../util/Units";
 import ILocationResolver from "../ILocationResolver";
 import IQueryRunner from "../IQueryRunner";
 import IResolvedQuery from "../IResolvedQuery";
 import ExponentialQueryIterator from "./ExponentialQueryIterator";
-import FilterUniqueIterator from "./FilterUniqueIterator";
+import FilterUniquePathsIterator from "./FilterUniquePathsIterator";
 import SubqueryIterator from "./SubqueryIterator";
 
 @injectable()
 export default class QueryRunnerExponential implements IQueryRunner {
-  public private;
   private locationResolver: ILocationResolver;
-  private publicTransportPlanner: IPublicTransportPlanner;
-
+  private publicTransportPlannerFactory: interfaces.Factory<IPublicTransportPlanner>;
   private context: Context;
 
   constructor(
-    @inject(TYPES.Context) context: Context,
-    @inject(TYPES.LocationResolver) locationResolver: ILocationResolver,
-    @inject(TYPES.PublicTransportPlanner) publicTransportPlanner: IPublicTransportPlanner,
+    @inject(TYPES.Context)
+      context: Context,
+    @inject(TYPES.LocationResolver)
+      locationResolver: ILocationResolver,
+    @inject(TYPES.PublicTransportPlannerFactory)
+      publicTransportPlannerFactory: interfaces.Factory<IPublicTransportPlanner>,
   ) {
-    this.locationResolver = locationResolver;
-    this.publicTransportPlanner = publicTransportPlanner;
     this.context = context;
+    this.locationResolver = locationResolver;
+    this.publicTransportPlannerFactory = publicTransportPlannerFactory;
   }
 
   public async run(query: IQuery): Promise<AsyncIterator<IPath>> {
@@ -38,9 +42,18 @@ export default class QueryRunnerExponential implements IQueryRunner {
     if (baseQuery.publicTransportOnly) {
 
       const queryIterator = new ExponentialQueryIterator(baseQuery, 15 * 60 * 1000);
-      const subqueryIterator = new SubqueryIterator<IResolvedQuery, IPath>(queryIterator, this.runSubquery.bind(this));
+      // const emitQueryIterator = new Emiterator<IResolvedQuery>(
+      // queryIterator,
+      // this.context,
+      // EventType.QueryExponential,
+      // );
 
-      return new FilterUniqueIterator(subqueryIterator);
+      const subqueryIterator = new SubqueryIterator<IResolvedQuery, IPath>(
+        queryIterator,
+        this.runSubquery.bind(this),
+      );
+
+      return new FilterUniquePathsIterator(subqueryIterator);
 
     } else {
       return Promise.reject("Query not supported");
@@ -48,8 +61,10 @@ export default class QueryRunnerExponential implements IQueryRunner {
   }
 
   private async runSubquery(query: IResolvedQuery): Promise<AsyncIterator<IPath>> {
-    // TODO investigate publicTransportPlanner
-    const planner = this.context.getContainer().get<IPublicTransportPlanner>(TYPES.PublicTransportPlanner);
+    // TODO investigate if publicTransportPlanner can be reused or reuse some of its aggregated data
+    this.context.emit(EventType.QueryExponential, query);
+
+    const planner = this.publicTransportPlannerFactory() as IPublicTransportPlanner;
 
     return planner.plan(query);
   }
@@ -74,7 +89,8 @@ export default class QueryRunnerExponential implements IQueryRunner {
     const {
       from, to,
       minimumWalkingSpeed, maximumWalkingSpeed, walkingSpeed,
-      maximumTransferDuration, maximumTransfers,
+      maximumWalkingDuration, maximumWalkingDistance,
+      minimumTransferDuration, maximumTransferDuration, maximumTransfers,
       minimumDepartureTime,
       ...other
     } = query;
@@ -88,7 +104,10 @@ export default class QueryRunnerExponential implements IQueryRunner {
     resolvedQuery.to = await this.resolveEndpoint(to);
     resolvedQuery.minimumWalkingSpeed = minimumWalkingSpeed || walkingSpeed || Defaults.defaultMinimumWalkingSpeed;
     resolvedQuery.maximumWalkingSpeed = maximumWalkingSpeed || walkingSpeed || Defaults.defaultMaximumWalkingSpeed;
+    resolvedQuery.maximumWalkingDuration = maximumWalkingDuration ||
+      Units.toDuration(maximumWalkingDistance, resolvedQuery.minimumWalkingSpeed) || Defaults.defaultWalkingDuration;
 
+    resolvedQuery.minimumTransferDuration = minimumTransferDuration || Defaults.defaultMinimumTransferDuration;
     resolvedQuery.maximumTransferDuration = maximumTransferDuration || Defaults.defaultMaximumTransferDuration;
     resolvedQuery.maximumTransfers = maximumTransfers || Defaults.defaultMaximumTransfers;
 
diff --git a/src/query-runner/exponential/SubqueryIterator.ts b/src/query-runner/exponential/SubqueryIterator.ts
index 10485a6e..e749e5e3 100644
--- a/src/query-runner/exponential/SubqueryIterator.ts
+++ b/src/query-runner/exponential/SubqueryIterator.ts
@@ -53,7 +53,7 @@ export default class SubqueryIterator<Q, R> extends BufferedIterator<R> {
           }
 
           // Iterator was empty
-          if (self.currentResultPushed === 0) {
+          if (self.currentResultPushed === 0 && !this.closed) {
             self._read(null, done);
           }
         });
diff --git a/src/types.ts b/src/types.ts
index 1874889d..146cd498 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -16,7 +16,11 @@ const TYPES = {
   StopsFetcherFactory: Symbol("StopsFetcherFactory"),
 
   PublicTransportPlanner: Symbol("PublicTransportPlanner"),
+  PublicTransportPlannerFactory: Symbol("PublicTransportPlannerFactory"),
+
   RoadPlanner: Symbol("RoadPlanner"),
+  RoadPlannerFactory: Symbol("RoadPlannerFactory"),
+
   ReachableStopsFinder: Symbol("ReachableStopsFinder"),
   JourneyExtractor: Symbol("JourneyExtractor"),
   LDFetch: Symbol("LDFetch"),
@@ -25,5 +29,5 @@ const TYPES = {
 
 export default TYPES;
 
-export type StopsFetcherFactory = (prefix: string, accessUrl: string) => IStopsFetcher;
+export type StopsFetcherFactory = (accessUrl: string) => IStopsFetcher;
 export type ConnectionsFetcherFactory = (accessUrl: string, travelMode: TravelMode) => IConnectionsFetcher;
diff --git a/src/util/ReduceIterator.ts b/src/util/ReduceIterator.ts
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/util/iterators/Emiterator.ts b/src/util/iterators/Emiterator.ts
new file mode 100644
index 00000000..3b54f8a3
--- /dev/null
+++ b/src/util/iterators/Emiterator.ts
@@ -0,0 +1,27 @@
+import { AsyncIterator, SimpleTransformIterator, SimpleTransformIteratorOptions } from "asynciterator";
+import Context from "../../Context";
+import EventType from "../../EventType";
+
+/**
+ * Lazily emits an event of specified type for each item that passes through source iterator
+ * This doesn't put the source iterator in flow mode
+ */
+export default class Emiterator<T> extends SimpleTransformIterator<T, T> {
+  constructor(source: AsyncIterator<T>, context: Context, eventType: EventType) {
+    if (!context || !eventType) {
+      super(source);
+    }
+
+    const options: SimpleTransformIteratorOptions<T, T> = {
+      map: (item: T) => {
+        context.emit(eventType, item);
+
+        return item;
+      },
+      maxBufferSize: 1,
+      autoStart: false,
+    };
+
+    super(source, options);
+  }
+}
diff --git a/src/util/iterators/MergeIterator.test.ts b/src/util/iterators/MergeIterator.test.ts
new file mode 100644
index 00000000..6e84a808
--- /dev/null
+++ b/src/util/iterators/MergeIterator.test.ts
@@ -0,0 +1,70 @@
+import { ArrayIterator } from "asynciterator";
+import "jest";
+import MergeIterator from "./MergeIterator";
+
+const createSources = () => {
+  const firstIterator = new ArrayIterator<number>([1, 8, 10, 13]);
+  const secondIterator = new ArrayIterator<number>([4, 11]);
+  const thirdIterator = new ArrayIterator<number>([3, 5, 6, 12, 18]);
+
+  return [firstIterator, secondIterator, thirdIterator];
+};
+
+describe("[MergeIterator]", () => {
+
+  it("uncondensed", (done) => {
+
+    const mergeIterator = new MergeIterator<number>(createSources(), (numbers: number[]) => {
+
+      let smallestIndex = -1;
+
+      for (let i = 0; i < numbers.length; i++) {
+        if (smallestIndex < 0 && numbers[i] !== undefined) {
+          smallestIndex = i;
+          continue;
+        }
+
+        if (numbers[i] !== undefined && numbers[i] < numbers[smallestIndex]) {
+          smallestIndex = i;
+        }
+      }
+
+      return smallestIndex;
+    });
+
+    let current = 0;
+    const expected = [1, 3, 4, 5, 6, 8, 10, 11, 12, 13, 18];
+
+    mergeIterator.each((str) => {
+      expect(expected[current++]).toBe(str);
+    });
+
+    mergeIterator.on("end", () => done());
+  });
+
+  it("condensed", (done) => {
+
+    const mergeIterator = new MergeIterator<number>(createSources(), (numbers: number[]) => {
+
+      let smallestIndex = 0;
+
+      for (let i = 1; i < numbers.length; i++) {
+        if (numbers[i] !== undefined && numbers[i] < numbers[smallestIndex]) {
+          smallestIndex = i;
+        }
+      }
+
+      return smallestIndex;
+    }, true);
+
+    let current = 0;
+    const expected = [1, 3, 4, 5, 6, 8, 10, 11, 12, 13, 18];
+
+    mergeIterator.each((str) => {
+      expect(expected[current++]).toBe(str);
+    });
+
+    mergeIterator.on("end", () => done());
+  });
+
+});
diff --git a/src/util/iterators/MergeIterator.ts b/src/util/iterators/MergeIterator.ts
new file mode 100644
index 00000000..384ff3a7
--- /dev/null
+++ b/src/util/iterators/MergeIterator.ts
@@ -0,0 +1,138 @@
+import { AsyncIterator, BufferedIterator } from "asynciterator";
+
+/**
+ * Asynciterator that merges a number of source asynciterators based on the passed selector function.
+ * The selector function gets passed an array of values read from each of the asynciterators.
+ * Values can be undefined if their respective source iterator has ended.
+ * It should return the index in that array of the value to select.
+ * @param condensed When true, undefined values are filtered from the array passed to the selector function
+ */
+export default class MergeIterator<T> extends BufferedIterator<T> {
+  private readonly sourceIterators: Array<AsyncIterator<T>>;
+  private readonly selector: (values: T[]) => number;
+  private readonly condensed: boolean;
+
+  private values: T[];
+  private lastPushedIndex: number;
+  private endedSources: number;
+  private shouldClose: boolean;
+
+  constructor(sourceIterators: Array<AsyncIterator<T>>, selector: (values: T[]) => number, condensed?: boolean) {
+    super();
+
+    this.sourceIterators = sourceIterators;
+    this.selector = selector;
+    this.condensed = condensed;
+
+    this.endedSources = 0;
+
+    this.addListeners();
+  }
+
+  public _read(count: number, done: () => void): void {
+    if (!this.values) {
+      this.fillFirstValues(done);
+      return;
+    }
+
+    this.fillValue(this.lastPushedIndex, () => {
+      this.doPush(done);
+    });
+  }
+
+  public close() {
+    for (const iterator of this.sourceIterators) {
+      iterator.close();
+    }
+
+    super.close();
+  }
+
+  private fillFirstValues(done) {
+    this.values = Array(this.sourceIterators.length).fill(undefined);
+    let filledValues = 0;
+
+    const filled = () => {
+      filledValues++;
+
+      if (filledValues === this.sourceIterators.length) {
+        this.doPush(done);
+      }
+    };
+
+    for (let i = 0; i < this.sourceIterators.length; i++) {
+      this.fillValue(i, filled);
+    }
+  }
+
+  private fillValue(sourceIndex: number, filled: () => void) {
+    const iterator = this.sourceIterators[sourceIndex];
+
+    if (iterator.ended) {
+      filled();
+      return;
+    }
+
+    const value = iterator.read();
+
+    if (value) {
+      this.values[sourceIndex] = value;
+      filled();
+
+    } else {
+      iterator.once("readable", () => {
+        this.values[sourceIndex] = iterator.read();
+        filled();
+      });
+    }
+  }
+
+  private doPush(done: () => void) {
+    if (this.condensed) {
+      const { values, indexMap } = this.getCondensedValues();
+
+      this.lastPushedIndex = indexMap[this.selector(values)];
+
+    } else {
+      this.lastPushedIndex = this.selector(this.values);
+    }
+
+    this._push(this.values[this.lastPushedIndex]);
+    this.values[this.lastPushedIndex] = undefined;
+
+    done();
+
+    if (this.shouldClose) {
+      this.close();
+    }
+  }
+
+  private getCondensedValues() {
+    const values = [];
+    const indexMap = [];
+
+    this.values
+      .forEach((value: T, originalIndex: number) => {
+        if (value !== undefined) {
+          values.push(value);
+          indexMap.push(originalIndex);
+        }
+      }, {});
+
+    return { values, indexMap };
+  }
+
+  private addListeners() {
+    const self = this;
+
+    for (const iterator of this.sourceIterators) {
+      iterator.on("end", () => {
+        self.endedSources++;
+
+        if (self.endedSources === self.sourceIterators.length) {
+          self.shouldClose = true;
+        }
+      });
+    }
+  }
+}