diff --git a/engine/functions/PhaseFunctions.ts b/engine/functions/PhaseFunctions.ts
index ab2ccb5..18200e2 100644
--- a/engine/functions/PhaseFunctions.ts
+++ b/engine/functions/PhaseFunctions.ts
@@ -56,11 +56,13 @@ Object.freeze(defaultPhases)
 Object.freeze(phasesNoNavigation)
 
 export async function getPhases(options: { exclude?: FeatureId[] } = {}): Promise<readonly IPhase<any, any>[]> {
+  console.log('GETPHASES-PHASES-CALLED--->')
   const exclude = options.exclude || []
   return Promise.all(exclude.includes('navigation') ? phasesNoNavigation : defaultPhases)
 }
 
 export function resetPhases(state: MapStateUnwrapped, phases: readonly IPhase<any, any>[]) {
+  console.log('RESET-PHASES-CALLED--->')
   for (const phase of phases) {
     phase.reset(state)
   }
@@ -68,6 +70,7 @@ export function resetPhases(state: MapStateUnwrapped, phases: readonly IPhase<an
 
 export async function startPhases(state: MapStateUnwrapped, phases: readonly IPhase<any, any>[]) {
   // TODO remove
+  console.log('START-PHASES-CALLED--->')
   const results = [] as any[]
   let result: any
   const newState = { ...state }
diff --git a/engine/functions/checkKey.ts b/engine/functions/checkKey.ts
index 7a86a4f..9822889 100644
--- a/engine/functions/checkKey.ts
+++ b/engine/functions/checkKey.ts
@@ -1,6 +1,7 @@
 import matches from 'ts-matches'
 import { FeatureKey, TileKey } from '../types'
 export default function checkKey(key: FeatureKey | TileKey) {
+  console.log("CHECKKEY__FN")
   matches(key)
     .when(matches.tuple(matches.number, matches.number), () => {})
     .when(matches.tuple(matches.string, matches.number, matches.number, matches.string), () => {})
diff --git a/engine/functions/computePolygonDifference.ts b/engine/functions/computePolygonDifference.ts
index c12d29d..39dee1c 100644
--- a/engine/functions/computePolygonDifference.ts
+++ b/engine/functions/computePolygonDifference.ts
@@ -14,6 +14,7 @@ function roundEach(array: any[]) {
 }
 
 export default function computePolygonDifference(subjectGeometry: Polygon, ...clippingGeometries: Polygon[]) {
+  console.log("COMPUTEPOLYGONDIFF__FN")
   // Quick and dirty fix for polygon-clipping's floating point woes
   roundEach(clippingGeometries)
   return pc.difference([subjectGeometry], ...clippingGeometries)
diff --git a/engine/functions/computeSquaredDistanceFromCircle.ts b/engine/functions/computeSquaredDistanceFromCircle.ts
index 525fef1..be37132 100644
--- a/engine/functions/computeSquaredDistanceFromCircle.ts
+++ b/engine/functions/computeSquaredDistanceFromCircle.ts
@@ -1,7 +1,9 @@
 export default function computeDistanceFromCircle(
+
   point: [number, number],
   circleCenter: [number, number],
   circleRadius: number
 ) {
+  console.log("COMPUTEPSQUAREDIST__FN");
   return Math.hypot(point[0] - circleCenter[0], point[1] - circleCenter[1]) - circleRadius
 }
diff --git a/engine/functions/computeTileBoundingBox.ts b/engine/functions/computeTileBoundingBox.ts
index 2e8a698..9f8e0e1 100644
--- a/engine/functions/computeTileBoundingBox.ts
+++ b/engine/functions/computeTileBoundingBox.ts
@@ -10,6 +10,7 @@ export default function computeTileBoundingBox(
   center: LongLat,
   target: BBox = Array(4) as any
 ): BBox {
+  console.log("COMPUTETILEBOUNDING__FN");
   toMetersFromCenter([tileXToLong(x, TILE_ZOOM), tileYToLat(y, TILE_ZOOM)], center, $array2)
 
   const [x1, y1] = $array2
diff --git a/engine/functions/createCompleteObject.ts b/engine/functions/createCompleteObject.ts
index 168f0b2..3a43b38 100644
--- a/engine/functions/createCompleteObject.ts
+++ b/engine/functions/createCompleteObject.ts
@@ -8,6 +8,7 @@ export default function createCompleteObject(
   geometryPhaseResult: MapDerivedFeatureGeometry,
   feature: SupportedFeature
 ): MapDerivedFeatureComplete {
+  console.log("CREATECOMPLETEOBJECT__FN");
   const { color, extrude, zIndex = 0 } = getFeatureStyles(DEFAULT_FEATURE_STYLES, layerName, feature.properties.class)
 
   const materialParams = {
diff --git a/engine/functions/createFeatureLabel.ts b/engine/functions/createFeatureLabel.ts
index 807ae3b..5aa2a3f 100644
--- a/engine/functions/createFeatureLabel.ts
+++ b/engine/functions/createFeatureLabel.ts
@@ -64,6 +64,7 @@ export default function createFeatureLabel(
   lineString: Feature<LineString>,
   mapCenterPoint: LongLat
 ): MapFeatureLabel {
+  console.log("CREATEFEATURELABEL__FN");
   const lineLen = turf.length(lineString)
   const middleSlice = turf.lineSliceAlong(lineString, lineLen * 0.48, lineLen * 0.52).geometry.coordinates
 
diff --git a/engine/functions/createGeometry.ts b/engine/functions/createGeometry.ts
index 2e11df4..f1c5721 100644
--- a/engine/functions/createGeometry.ts
+++ b/engine/functions/createGeometry.ts
@@ -43,6 +43,7 @@ function colorVertices(geometry: BufferGeometry, baseColor: Color, light: Color,
 }
 
 export default function createGeometry(feature: SupportedFeature, style: IStyles): BufferGeometry {
+  console.log("CREATEGEOMETRY__FN");
   const shape = new Shape()
 
   let coords: LongLat[]
diff --git a/engine/functions/createIntersectionTestTileCircle.ts b/engine/functions/createIntersectionTestTileCircle.ts
index cc83038..88699a1 100644
--- a/engine/functions/createIntersectionTestTileCircle.ts
+++ b/engine/functions/createIntersectionTestTileCircle.ts
@@ -1,5 +1,7 @@
 export default function createIntersectTestTileCircle(centerX: number, centerY: number, radius: number) {
+  console.log("CREATEINTERESECT__FN");
   return function isIntersectTileCircle(cellX: number, cellY: number): boolean {
+    
     const testEdgeX = centerX < cellX ? cellX : centerX > cellX + 1 ? cellX + 1 : centerX
     const testEdgeY = centerY < cellY ? cellY : centerY > cellY + 1 ? cellY + 1 : centerY
     const distanceFromCenter = Math.hypot(testEdgeX - centerX, testEdgeY - centerY)
diff --git a/engine/functions/createSurroundingTileIterator.ts b/engine/functions/createSurroundingTileIterator.ts
index 4b87465..5e2693b 100644
--- a/engine/functions/createSurroundingTileIterator.ts
+++ b/engine/functions/createSurroundingTileIterator.ts
@@ -12,6 +12,7 @@ export default function* createSurroundingTileIterator(
   minimumSceneRadius: number,
   zoomLevel: number
 ): Generator<TileKey> {
+  console.log("CREATESURROUNDING__FN");
   const [startLong, startLat] = fromMetersFromCenter([-minimumSceneRadius, -minimumSceneRadius], center)
   const [endLong, endLat] = fromMetersFromCenter([minimumSceneRadius, minimumSceneRadius], center)
 
diff --git a/engine/functions/createUsingCache.ts b/engine/functions/createUsingCache.ts
index 59c0ed2..2967b72 100644
--- a/engine/functions/createUsingCache.ts
+++ b/engine/functions/createUsingCache.ts
@@ -4,6 +4,7 @@ import createUsingGetSet from './createUsingGetSet'
 export default function createUsingCache<CacheKey extends ITuple, Value>(
   create: (state: MapStateUnwrapped, key: CacheKey, ...extraArgs: any[]) => Value
 ) {
+  console.log("CREATEUSINGCACHE__FN");
   const _createUsingCache = createUsingGetSet(create)
   return (cache: IParametricMap<CacheKey, Value>, state: MapStateUnwrapped, key: CacheKey, ...extraArgs: any[]) => {
     return _createUsingCache(cache.get.bind(cache), cache.set.bind(cache), state, key, ...extraArgs)
diff --git a/engine/functions/createUsingGetSet.ts b/engine/functions/createUsingGetSet.ts
index 7f4fd28..9087420 100644
--- a/engine/functions/createUsingGetSet.ts
+++ b/engine/functions/createUsingGetSet.ts
@@ -3,6 +3,7 @@ import { ITuple, MapStateUnwrapped } from '../types'
 export default function createUsingGetSet<CacheKey extends ITuple, Value>(
   create: (state: MapStateUnwrapped, key: CacheKey, ...args: any[]) => Value
 ) {
+  console.log("CREATEUSINGGETSET__FN");
   return (
     get: (key: CacheKey) => Value,
     set: (key: CacheKey, value: Value) => any,
diff --git a/engine/functions/createWorkerFunction.ts b/engine/functions/createWorkerFunction.ts
index f5cf6fb..8cdf1d4 100644
--- a/engine/functions/createWorkerFunction.ts
+++ b/engine/functions/createWorkerFunction.ts
@@ -8,7 +8,7 @@ export default function createWorkerFunction<
   worker: Worker
 ): (...args: { [I in keyof HandlerArgs]: Comlink.UnproxyOrClone<HandlerArgs[I]> }) => Promise<HandlerResult> {
   const api = Comlink.wrap<WorkerApi>(worker)
-
+  console.log("CREATEWORKER__FN");
   return async function workerFunction(...args: { [I in keyof HandlerArgs]: Comlink.UnproxyOrClone<HandlerArgs[I]> }) {
     return (await api.handle(...args)) as Promise<HandlerResult>
   }
diff --git a/engine/functions/fetchUsingCache.ts b/engine/functions/fetchUsingCache.ts
index 8120d35..ca33424 100644
--- a/engine/functions/fetchUsingCache.ts
+++ b/engine/functions/fetchUsingCache.ts
@@ -5,6 +5,7 @@ import createUsingGetSet from './createUsingGetSet'
 export default function fetchUsingCache<CacheKey extends ITuple, Value>(
   fetch: (state: MapStateUnwrapped, key: CacheKey, ...args: any[]) => Value
 ) {
+  console.log("FETCHCACHE__FN");
   const _fetchUsingCache = createUsingGetSet(fetch)
   return async (
     cache: ParametricCache<CacheKey, Value>,
diff --git a/engine/functions/fetchVectorTile.ts b/engine/functions/fetchVectorTile.ts
index 587b0e8..2813512 100644
--- a/engine/functions/fetchVectorTile.ts
+++ b/engine/functions/fetchVectorTile.ts
@@ -4,7 +4,7 @@ import { VectorTile } from '../types'
 import { vectors } from '../vectors'
 import getMapboxUrl from './getMapboxUrl'
 
-export default async function fetchVectorTile(_: any, key: TileKey): Promise<VectorTile> {
+export default async function fetchVectorTile(_: any, key: TileKey): Promise<VectorTile> {  console.log("GETCHVECTOR__FN");
   const [x, y] = key
   const url = getMapboxUrl(
     'mapbox.mapbox-streets-v8',
diff --git a/engine/functions/findSplitFeatures.ts b/engine/functions/findSplitFeatures.ts
index eb8ba48..a94d56f 100644
--- a/engine/functions/findSplitFeatures.ts
+++ b/engine/functions/findSplitFeatures.ts
@@ -7,7 +7,9 @@ type GroupKey = Feature['id']
 type Group = [FeatureKey, Feature][]
 
 /** Useful for when a feature is split across multiple vector tiles */
+
 export default function* findSplitFeatures(keys: Iterator<FeatureKey>, features: Iterator<Feature>): Generator<Group> {
+  console.log("FINDSPLIT__FN");
   const zipped = zipIterators<[FeatureKey, Feature]>(keys, features)
   const groups = new Map<GroupKey, Group>()
   const groupSetFunction = (groupKey: GroupKey, groupValue: Group) => {
diff --git a/engine/functions/getCachedMaterial.ts b/engine/functions/getCachedMaterial.ts
index b9942f0..4f04f9e 100644
--- a/engine/functions/getCachedMaterial.ts
+++ b/engine/functions/getCachedMaterial.ts
@@ -6,6 +6,7 @@ const cache = new Map<string, MeshLambertMaterial>()
 // TODO re-implement using createUsingGetSet
 // TODO generalize this so it'll work even if params contain Textures
 export default function getCachedMaterial(Material: any, params: MeshLambertMaterialParameters): MeshLambertMaterial {
+  console.log("GETCACHED__FN");
   const key = JSON.stringify(params)
   let material = cache.get(key)
 
diff --git a/engine/functions/getFeaturesFromVectorTileLayer.ts b/engine/functions/getFeaturesFromVectorTileLayer.ts
index 14272bf..1e89bcb 100644
--- a/engine/functions/getFeaturesFromVectorTileLayer.ts
+++ b/engine/functions/getFeaturesFromVectorTileLayer.ts
@@ -8,6 +8,7 @@ export default function* getFeaturesFromVectorTileLayer(
   y: number,
   zoom: number
 ): Generator<FeatureWithTileIndex> {
+  console.log("GETFEATURES__FN");
   const layer = tile.layers[layerName]
   for (let tileIndex = 0; tileIndex < layer.length; tileIndex++) {
     const feature = layer.feature(tileIndex).toGeoJSON(x, y, zoom)
diff --git a/engine/functions/getMapboxUrl.ts b/engine/functions/getMapboxUrl.ts
index c8209a4..191e1f3 100644
--- a/engine/functions/getMapboxUrl.ts
+++ b/engine/functions/getMapboxUrl.ts
@@ -7,9 +7,10 @@ export default function getMapboxUrl(
   tileY: number,
   tileZoom: number,
   format: string,
-  apiKey: string,
+  apiKey: "",
   highDpi = false
 ) {
+  console.log("GETMAPBOX__FN");
   return `https://api.mapbox.com/v4/${layerId}/${tileZoom}/${tileX}/${tileY}${
     highDpi ? '@2x' : ''
   }.${format}?access_token=${apiKey}`
diff --git a/engine/functions/isIntersectCircleCircle.ts b/engine/functions/isIntersectCircleCircle.ts
index d2d5523..d250104 100644
--- a/engine/functions/isIntersectCircleCircle.ts
+++ b/engine/functions/isIntersectCircleCircle.ts
@@ -6,6 +6,7 @@ export default function isIntersectCircleCircle(
   centerPointB: [number, number],
   radiusB: number
 ): boolean {
+  console.log("ISINTERSECT__FN");
   const distanceSquared = computeSquared(centerPointA, centerPointB, radiusB)
   return distanceSquared < radiusA * radiusA
 }
diff --git a/engine/functions/tesselatePolygon.ts b/engine/functions/tesselatePolygon.ts
index 3d3bb94..2a031ea 100644
--- a/engine/functions/tesselatePolygon.ts
+++ b/engine/functions/tesselatePolygon.ts
@@ -19,6 +19,7 @@ export function indexedVerticesToGeoJSONTriangles(indexes: number[], vertices: n
 }
 
 export default function tesselatePolygon(polygon: Polygon) {
+  console.log("tesselatePolygon__FN");
   const { vertices, holes } = earcut.flatten(polygon)
   const indexes = earcut(vertices, holes, 2)
   return indexedVerticesToGeoJSONTriangles(indexes, vertices)
diff --git a/engine/functions/transformFeature.ts b/engine/functions/transformFeature.ts
index d9f87af..ea0bc87 100644
--- a/engine/functions/transformFeature.ts
+++ b/engine/functions/transformFeature.ts
@@ -34,6 +34,7 @@ export default function transformFeature<FeatureType extends SupportedFeature>(
   feature: FeatureType,
   center: LongLat
 ): MapTransformedFeature {
+  console.log("transformFeature__FN");
   const centerPointLongLat = turf.center(feature).geometry.coordinates
   const centerPoint = toMetersFromCenter(centerPointLongLat, center) as [number, number]
   let transformedFeature = feature
diff --git a/engine/functions/transformGeometry.ts b/engine/functions/transformGeometry.ts
index ad7ec34..e62d5f0 100644
--- a/engine/functions/transformGeometry.ts
+++ b/engine/functions/transformGeometry.ts
@@ -18,6 +18,7 @@ export default function transformGeometry<Coordinates extends Position[] | Posit
   coordTarget = coordSource
 ) {
   // TODO use ts-matches
+  console.log("transformGeometry__FN");
   switch (type) {
     case 'LineString':
       transformRing(coordSource as Position[], transformer)
diff --git a/engine/functions/unifyCachedFeatures.ts b/engine/functions/unifyCachedFeatures.ts
index e0eee6d..72785cc 100644
--- a/engine/functions/unifyCachedFeatures.ts
+++ b/engine/functions/unifyCachedFeatures.ts
@@ -7,6 +7,7 @@ import unifyFeatures from './unifyFeatures'
 const allowedGeometryTypes: Feature['geometry']['type'][] = ['Polygon', 'MultiPolygon']
 
 export default function unifyCachedFeatures(cache: FeatureCache<Feature>) {
+  console.log("unifyCACHE__FN");
   for (const splitFeature of findSplitFeatures(cache.keys(), cache.values())) {
     const firstKey = splitFeature[0][0]
     const features = splitFeature.map(([_, feature]) => feature)
diff --git a/engine/functions/unifyFeatures.ts b/engine/functions/unifyFeatures.ts
index a8184ef..28edddf 100644
--- a/engine/functions/unifyFeatures.ts
+++ b/engine/functions/unifyFeatures.ts
@@ -4,6 +4,7 @@ import { multiPolygon, polygon } from '@turf/turf'
 
 /** Useful for when a feature is split across multiple vector tiles */
 export default function unifyFeatures(features: Feature[]): Feature {
+  console.log("unifyFeature__FN");
   if (features.length > 1) {
     const allCoords = features.map(getCoords)
 
diff --git a/engine/phases/CreateCompleteNavMeshPhase.ts b/engine/phases/CreateCompleteNavMeshPhase.ts
index 83e9d0c..ea70a00 100644
--- a/engine/phases/CreateCompleteNavMeshPhase.ts
+++ b/engine/phases/CreateCompleteNavMeshPhase.ts
@@ -8,10 +8,12 @@ export const isCachingPhase = false
 const builder = new NavMeshBuilder()
 
 export function getTaskKeys(_: MapStateUnwrapped) {
+  console.log('CreateCompleteNavMesh-PHASE-CALLED--->')
   return [null]
 }
 
 export function execTask(state: MapStateUnwrapped, _: TileKey) {
+  console.log('CreateCompleteNavMesh-PHASE-CALLED_2--->')
   for (const value of state.tileNavMeshCache.values()) {
     builder.addGeometry({ type: 'MultiPolygon', coordinates: value })
   }
diff --git a/engine/phases/CreateCompleteObjectPhase.ts b/engine/phases/CreateCompleteObjectPhase.ts
index e5708d1..8ecfa9c 100644
--- a/engine/phases/CreateCompleteObjectPhase.ts
+++ b/engine/phases/CreateCompleteObjectPhase.ts
@@ -7,6 +7,7 @@ export const isAsyncPhase = false
 export const isCachingPhase = true
 
 const createCompleteObjectUsingCache = createUsingCache((state: MapStateUnwrapped, key: FeatureKey) => {
+  console.log('CreateCompleteObjectPhase--->')
   const [layerName] = key
 
   const feature = state.featureCache.get(key)
@@ -16,6 +17,7 @@ const createCompleteObjectUsingCache = createUsingCache((state: MapStateUnwrappe
 })
 
 export function* getTaskKeys(state: MapStateUnwrapped) {
+  console.log('CreateCompleteObjectPhase_2--->')
   for (const key of state.featureCache.keys()) {
     const geometry = state.geometryCache.get(key)
     if (geometry) {
@@ -25,6 +27,7 @@ export function* getTaskKeys(state: MapStateUnwrapped) {
 }
 
 export function getTaskStatus(state: MapStateUnwrapped, key: FeatureKey) {
+    console.log('CreateCompleteObjectPhase_3--->')
   return state.completeObjectsTasks.get(key)
 }
 export function setTaskStatus(state: MapStateUnwrapped, key: FeatureKey, status: TaskStatus) {
@@ -32,6 +35,7 @@ export function setTaskStatus(state: MapStateUnwrapped, key: FeatureKey, status:
 }
 
 export function execTask(state: MapStateUnwrapped, key: FeatureKey) {
+  console.log('CreateCompleteObjectPhase--->')
   return createCompleteObjectUsingCache(state.completeObjects, state, key)
 }
 
diff --git a/engine/phases/CreateFallbackLanduseMeshPhase.ts b/engine/phases/CreateFallbackLanduseMeshPhase.ts
index 2a0c25d..a8da103 100644
--- a/engine/phases/CreateFallbackLanduseMeshPhase.ts
+++ b/engine/phases/CreateFallbackLanduseMeshPhase.ts
@@ -10,12 +10,14 @@ export const isAsyncPhase = false
 export const isCachingPhase = false
 
 export function getTaskKeys(state: MapStateUnwrapped) {
+  console.log('CreateFallbackLand--->')
   return state.tileCache.keys()
 }
 
 const $tileBBox = Array(4)
 
 export function execTask(state: MapStateUnwrapped, key: TileKey) {
+  console.log('CreateFallbackLand_1--->')
   const [x, y] = key
 
   const [tileLeft, tileTop, tileRight, tileBottom] = computeTileBoundingBox(
diff --git a/engine/phases/CreateGeometryPhase.ts b/engine/phases/CreateGeometryPhase.ts
index b4f468a..ab09f78 100644
--- a/engine/phases/CreateGeometryPhase.ts
+++ b/engine/phases/CreateGeometryPhase.ts
@@ -17,6 +17,7 @@ const geometryLoader = new BufferGeometryLoader()
 
 /** using fetchUsingCache since createGeometry returns a promise */
 const createGeometryUsingCache = fetchUsingCache(async (state: MapStateUnwrapped, key: FeatureKey) => {
+  console.log('CreateGeometryPhase--->')
   const { feature, centerPoint, boundingCircleRadius } = state.transformedFeatureCache.get(key)
   const [layerName] = key
   const styles = getFeatureStyles(DEFAULT_FEATURE_STYLES, layerName, feature.properties.class)
@@ -44,6 +45,7 @@ export const isAsyncPhase = true
 export const isCachingPhase = true
 
 export function* getTaskKeys(state: MapStateUnwrapped) {
+  console.log('CreateGeometryPhase_2--->')
   const viewerPositionScaled = multiplyArray(state.viewerPosition, 1 / state.scale, $array2) as [number, number]
   for (const key of state.transformedFeatureCache.keys()) {
     const { centerPoint, boundingCircleRadius } = state.transformedFeatureCache.get(key)
@@ -62,6 +64,7 @@ export function setTaskStatus(state: MapStateUnwrapped, key: FeatureKey, status:
 }
 
 export function startTask(state: MapStateUnwrapped, key: FeatureKey) {
+  console.log('CreateGeometryPhase_3--->')
   return createGeometryUsingCache(state.geometryCache as any, state, key)
 }
 
diff --git a/engine/phases/CreateHelpersPhase.ts b/engine/phases/CreateHelpersPhase.ts
index 6d34d24..742225b 100644
--- a/engine/phases/CreateHelpersPhase.ts
+++ b/engine/phases/CreateHelpersPhase.ts
@@ -7,6 +7,7 @@ export const isAsyncPhase = false
 export const isCachingPhase = true
 
 const createHelpersUsingCache = createUsingCache((state: MapStateUnwrapped, key: TileKey) => {
+  console.log('CreateHelpersUsingCache--->')
   const polygons = state.tileNavMeshCache.get(key)
   // const tileNavMesh = createPolygonHelper(polygons[0])
   const tileNavMesh = createConvexMultiPolygonHelper(polygons)
@@ -17,6 +18,7 @@ const createHelpersUsingCache = createUsingCache((state: MapStateUnwrapped, key:
 })
 
 export function getTaskKeys(state: MapStateUnwrapped) {
+  console.log('CreateHelpersUsingCache_2--->')
   return state.tileNavMeshCache.keys()
 }
 
@@ -28,6 +30,7 @@ export function setTaskStatus(state: MapStateUnwrapped, key: TileKey, status: Ta
 }
 
 export function execTask(state: MapStateUnwrapped, key: TileKey) {
+  console.log('CreateHelpersUsingCache_3--->')
   return createHelpersUsingCache(state.helpersCache, state, key)
 }
 
diff --git a/engine/phases/CreateLabelPhase.ts b/engine/phases/CreateLabelPhase.ts
index 8efc1b3..8715a0c 100644
--- a/engine/phases/CreateLabelPhase.ts
+++ b/engine/phases/CreateLabelPhase.ts
@@ -8,6 +8,7 @@ export const isAsyncPhase = false
 export const isCachingPhase = true
 
 export function* getTaskKeys(state: MapStateUnwrapped) {
+  console.log('CreateLabelPhase--->')
   for (const key of state.completeObjects.keys()) {
     const feature = state.featureCache.get(key)
     const transformed = state.transformedFeatureCache.get(key)
@@ -38,6 +39,7 @@ const createLabelUsingCache = createUsingCache((state: MapStateUnwrapped, key: F
 })
 
 export function execTask(state: MapStateUnwrapped, key: FeatureKey) {
+  console.log('CreateLabelPhase_2--->')
   return createLabelUsingCache(state.labelCache, state, key)
 }
 
diff --git a/engine/phases/CreateTileNavMeshPhase.ts b/engine/phases/CreateTileNavMeshPhase.ts
index 0217d62..9a08356 100644
--- a/engine/phases/CreateTileNavMeshPhase.ts
+++ b/engine/phases/CreateTileNavMeshPhase.ts
@@ -82,6 +82,7 @@ const createNavMeshUsingCache = createUsingCache((state: MapStateUnwrapped, key:
 })
 
 export function getTaskKeys(state: MapStateUnwrapped) {
+  console.log('CreateNavMeshPhase--->')
   return createSurroundingTileIterator(state.center, state.navMeshRadius, TILE_ZOOM)
 }
 
@@ -93,6 +94,7 @@ export function setTaskStatus(state: MapStateUnwrapped, key: TileKey, status: Ta
 }
 
 export function execTask(state: MapStateUnwrapped, key: TileKey) {
+  console.log('CreateNavMeshPhase_2--->')
   return createNavMeshUsingCache(state.tileNavMeshCache, state, key)
 }
 
diff --git a/engine/phases/ExtractTileFeaturesPhase.ts b/engine/phases/ExtractTileFeaturesPhase.ts
index c1aec5a..9d3f591 100644
--- a/engine/phases/ExtractTileFeaturesPhase.ts
+++ b/engine/phases/ExtractTileFeaturesPhase.ts
@@ -9,6 +9,7 @@ export const isAsyncPhase = false
 export const isCachingPhase = true
 
 export function getTaskKeys(state: MapStateUnwrapped) {
+  console.log('ExtractTileFeaturesPhase--->')
   console.log('tileCache size', state.tileCache.size)
   return state.tileCache.keys()
 }
@@ -21,6 +22,7 @@ export function setTaskStatus(state: MapStateUnwrapped, key: TileKey, status: Ta
 }
 
 export function execTask(state: MapStateUnwrapped, tileKey: TileKey) {
+  console.log('ExtractTileFeaturesPhase_2--->')
   const vectorTile = state.tileCache.get(tileKey)
   const [x, y] = tileKey
   if (vectorTile) {
diff --git a/engine/phases/FetchTilesPhase.ts b/engine/phases/FetchTilesPhase.ts
index 50c9f7f..412b484 100644
--- a/engine/phases/FetchTilesPhase.ts
+++ b/engine/phases/FetchTilesPhase.ts
@@ -12,6 +12,7 @@ export const isAsyncPhase = true
 export const isCachingPhase = true
 
 export function getTaskKeys(state: MapStateUnwrapped) {
+  console.log('FetchVector--->')
   return createSurroundingTileIterator(state.center, state.minimumSceneRadius, TILE_ZOOM)
 }
 
@@ -23,6 +24,7 @@ export function setTaskStatus(state: MapStateUnwrapped, key: TileKey, status: Ta
 }
 
 export function startTask(state: MapStateUnwrapped, key: TileKey) {
+  console.log('FetchVector_2--->')
   return fetchVectorTileUsingCache(state.tileCache, state, key)
 }
 
diff --git a/engine/phases/TransformFeaturePhase.ts b/engine/phases/TransformFeaturePhase.ts
index 80b8253..491d248 100644
--- a/engine/phases/TransformFeaturePhase.ts
+++ b/engine/phases/TransformFeaturePhase.ts
@@ -22,6 +22,7 @@ const transformFeatureUsingCache = fetchUsingCache((state: MapStateUnwrapped, ke
 })
 
 export function getTaskKeys(state: MapStateUnwrapped) {
+  console.log('TransformPhase--->')
   return state.featureCache.keys()
 }
 
@@ -33,6 +34,7 @@ export function setTaskStatus(state: MapStateUnwrapped, key: FeatureKey, status:
 }
 
 export function startTask(state: MapStateUnwrapped, key: FeatureKey) {
+  console.log('TransformPhase_2--->')
   return transformFeatureUsingCache(state.transformedFeatureCache as any, state, key)
 }
 
diff --git a/engine/phases/UnifyFeaturesPhase.ts b/engine/phases/UnifyFeaturesPhase.ts
index 4e7b008..882fa06 100644
--- a/engine/phases/UnifyFeaturesPhase.ts
+++ b/engine/phases/UnifyFeaturesPhase.ts
@@ -6,10 +6,12 @@ export const isAsyncPhase = false
 export const isCachingPhase = false
 
 export function* getTaskKeys() {
+  console.log('UnifyFeatures--->')
   yield null
 }
 
 export function execTask(state: MapStateUnwrapped) {
+  console.log('UnifyFeatures_2--->')
   unifyCachedFeatures(state.featureCache)
 }