ultracode 5.4.0 → 5.6.0

package/dist/chunks/chunk-2Z6OQPYC.js

@@ -0,0 +1,656 @@
+import { getGpuClient } from './chunk-FPELPFER.js';
+import { simdL2Normalize } from './chunk-QN237S7C.js';
+import { detectBaseBranch, loadBaseMetadata, createInitialBaseMetadata, updateBaseMetadata } from './chunk-G6J42I55.js';
+import { init_storage_paths, normalizeBranchName, getProjectDir } from './chunk-TVOTA7EE.js';
+import { tryGarbageCollect } from './chunk-IMQ6WSJV.js';
+import { init_logging, log, logMemory } from './chunk-VCCBEJQ5.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+// src/semantic/faiss/layered-faiss-provider.ts
+init_logging();
+init_storage_paths();
+var DEFAULT_CONFIG = {
+  dimensions: 384,
+  indexType: "hnsw",
+  hnswM: 32,
+  hnswEfConstruction: 200,
+  hnswEfSearch: 64,
+  autoSaveThreshold: 5e4
+  // Increased to reduce blocking during indexing
+};
+function getLayeredPaths(projectDir, branchName, baseBranch) {
+  const safeBranch = normalizeBranchName(branchName);
+  const safeBase = baseBranch ? normalizeBranchName(baseBranch) : safeBranch;
+  return {
+    // Base layer - uses base branch name (e.g., faiss-dev.bin for base branch "dev")
+    baseIndex: join(projectDir, `faiss-${safeBase}.bin`),
+    baseIds: join(projectDir, `faiss-${safeBase}.bin.ids.json`),
+    baseMeta: join(projectDir, "faiss-base.meta.json"),
+    // Delta layer (per feature branch)
+    deltaIndex: join(projectDir, `faiss-${safeBranch}.delta.bin`),
+    deltaIds: join(projectDir, `faiss-${safeBranch}.delta.ids.json`),
+    deltaMeta: join(projectDir, `faiss-${safeBranch}.delta.meta.json`),
+    tombstones: join(projectDir, `faiss-${safeBranch}.tombstones.json`)
+  };
+}
+var LayeredFaissProvider = class _LayeredFaissProvider {
+  config;
+  client = null;
+  isInitialized = false;
+  // Project context
+  projectPath = "";
+  projectHash = "";
+  currentBranch = null;
+  baseBranch = null;
+  // Layer state
+  isOnBaseBranch = false;
+  baseIdSet = /* @__PURE__ */ new Set();
+  deltaIdSet = /* @__PURE__ */ new Set();
+  tombstones = /* @__PURE__ */ new Set();
+  // Change tracking
+  baseUnsavedCount = 0;
+  deltaUnsavedCount = 0;
+  /** Maximum delta size before auto-merge to prevent memory leaks */
+  static MAX_DELTA_SIZE = 5e3;
+  // Initialization mutex
+  initializePromise = null;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  // ===========================================================================
+  // Public API
+  // ===========================================================================
+  /**
+   * Check if the provider is initialized
+   */
+  get initialized() {
+    return this.isInitialized;
+  }
+  /**
+   * Get current configured dimensions
+   */
+  getDimensions() {
+    return this.config.dimensions;
+  }
+  /**
+   * Update dimensions (e.g. when embedding model changes)
+   * Only effective before initialize() creates the FAISS index.
+   */
+  setDimensions(dimensions) {
+    if (this.config.dimensions !== dimensions) {
+      log.i("LAYERED_FAISS", "dimensions_updated", { from: this.config.dimensions, to: dimensions });
+      this.config.dimensions = dimensions;
+    }
+  }
+  // ===========================================================================
+  // Lifecycle
+  // ===========================================================================
+  /**
+   * Initialize the provider for a specific project and branch
+   * v6: CRITICAL FIX - Check if projectHash changed and reinitialize if needed!
+   * Without this, switching projects would continue using the first project's index.
+   */
+  async initialize(projectPath, projectHash, branchName) {
+    if (this.initializePromise && this.projectHash === projectHash) {
+      return this.initializePromise;
+    }
+    if (this.projectHash && this.projectHash !== projectHash) {
+      log.i("LAYERED_FAISS", "project_switch", {
+        from: this.projectHash,
+        to: projectHash
+      });
+      if (this.isInitialized) {
+        log.i("LAYERED_FAISS", "saving_before_switch", {
+          project: this.projectHash,
+          baseUnsaved: this.baseUnsavedCount,
+          deltaUnsaved: this.deltaUnsavedCount
+        });
+        await this.save();
+      }
+      this.isInitialized = false;
+      this.initializePromise = null;
+    }
+    this.initializePromise = this.initializeInternal(projectPath, projectHash, branchName);
+    return this.initializePromise;
+  }
+  async initializeInternal(projectPath, projectHash, branchName) {
+    try {
+      this.projectPath = projectPath;
+      this.projectHash = projectHash;
+      this.currentBranch = normalizeBranchName(branchName);
+      this.baseIdSet.clear();
+      this.deltaIdSet.clear();
+      this.tombstones.clear();
+      this.baseUnsavedCount = 0;
+      this.deltaUnsavedCount = 0;
+      const projectDir = getProjectDir(projectPath);
+      if (!existsSync(projectDir)) {
+        mkdirSync(projectDir, { recursive: true });
+      }
+      this.client = getGpuClient();
+      const started = await this.client.start();
+      if (!started) {
+        log.e("LAYERED_FAISS", "client_start_fail");
+        return false;
+      }
+      this.baseBranch = detectBaseBranch(projectPath);
+      this.isOnBaseBranch = this.baseBranch === this.currentBranch;
+      log.i("LAYERED_FAISS", "init", {
+        project: projectHash,
+        current: this.currentBranch,
+        base: this.baseBranch,
+        isOnBase: this.isOnBaseBranch
+      });
+      await this.loadLayers();
+      this.isInitialized = true;
+      return true;
+    } catch (error) {
+      log.e("LAYERED_FAISS", "init_fail", { err: String(error) });
+      this.initializePromise = null;
+      return false;
+    }
+  }
+  /**
+   * Load the appropriate layers based on current branch
+   */
+  async loadLayers() {
+    const projectDir = getProjectDir(this.projectPath);
+    const paths = getLayeredPaths(projectDir, this.currentBranch, this.baseBranch);
+    log.d("LAYERED_FAISS", "load_layers", {
+      projectDir,
+      projectPath: this.projectPath,
+      currentBranch: this.currentBranch,
+      baseBranch: this.baseBranch,
+      baseIndexPath: paths.baseIndex,
+      baseIndexExists: existsSync(paths.baseIndex),
+      baseIdsPath: paths.baseIds,
+      baseIdsExists: existsSync(paths.baseIds)
+    });
+    await this.loadBaseLayer(paths);
+    if (!this.isOnBaseBranch) {
+      await this.loadDeltaLayer(paths);
+    }
+  }
+  /**
+   * Load base layer index
+   */
+  async loadBaseLayer(paths) {
+    const indexConfig = {
+      dimensions: this.config.dimensions,
+      indexType: this.config.indexType,
+      metric: "l2",
+      hnswM: this.config.hnswM,
+      hnswEfConstruction: this.config.hnswEfConstruction,
+      hnswEfSearch: this.config.hnswEfSearch
+    };
+    const baseIndexExists = existsSync(paths.baseIndex);
+    const loadPath = baseIndexExists ? paths.baseIndex : void 0;
+    await this.client.faissInitialize(indexConfig, loadPath);
+    if (baseIndexExists && existsSync(paths.baseIds)) {
+      try {
+        const data = readFileSync(paths.baseIds, "utf-8");
+        const ids = JSON.parse(data);
+        this.baseIdSet = new Set(ids);
+        log.d("LAYERED_FAISS", "base_ids_loaded", { count: this.baseIdSet.size });
+      } catch (error) {
+        log.w("LAYERED_FAISS", "base_ids_load_fail", { err: String(error) });
+      }
+    }
+    const stats = await this.client.faissGetStats();
+    log.i("LAYERED_FAISS", "base_loaded", {
+      vectors: stats.totalVectors,
+      ids: this.baseIdSet.size,
+      fromFile: baseIndexExists
+    });
+  }
+  /**
+   * Load delta layer for feature branch
+   */
+  async loadDeltaLayer(paths) {
+    if (existsSync(paths.tombstones)) {
+      try {
+        const data = readFileSync(paths.tombstones, "utf-8");
+        const tombstoneList = JSON.parse(data);
+        this.tombstones = new Set(tombstoneList);
+        log.d("LAYERED_FAISS", "tombstones_loaded", { count: this.tombstones.size });
+      } catch (error) {
+        log.w("LAYERED_FAISS", "tombstones_load_fail", { err: String(error) });
+      }
+    }
+    if (existsSync(paths.deltaIds)) {
+      try {
+        const data = readFileSync(paths.deltaIds, "utf-8");
+        const ids = JSON.parse(data);
+        this.deltaIdSet = new Set(ids);
+        log.d("LAYERED_FAISS", "delta_ids_loaded", { count: this.deltaIdSet.size });
+      } catch (error) {
+        log.w("LAYERED_FAISS", "delta_ids_load_fail", { err: String(error) });
+      }
+    }
+  }
+  // ===========================================================================
+  // Branch switching
+  // ===========================================================================
+  /**
+   * Switch to a different branch
+   */
+  async switchBranch(branchName) {
+    const normalizedBranch = normalizeBranchName(branchName);
+    if (this.currentBranch === normalizedBranch) {
+      return;
+    }
+    log.i("LAYERED_FAISS", "branch_switch", {
+      from: this.currentBranch,
+      to: normalizedBranch
+    });
+    await this.save();
+    this.currentBranch = normalizedBranch;
+    this.isOnBaseBranch = this.baseBranch === normalizedBranch;
+    this.deltaIdSet.clear();
+    this.tombstones.clear();
+    this.deltaUnsavedCount = 0;
+    if (!this.isOnBaseBranch) {
+      const projectDir = getProjectDir(this.projectPath);
+      const paths = getLayeredPaths(projectDir, normalizedBranch, this.baseBranch);
+      await this.loadDeltaLayer(paths);
+    }
+    log.i("LAYERED_FAISS", "branch_switched", {
+      branch: normalizedBranch,
+      isOnBase: this.isOnBaseBranch,
+      deltaIds: this.deltaIdSet.size,
+      tombstones: this.tombstones.size
+    });
+  }
+  // ===========================================================================
+  // Search
+  // ===========================================================================
+  /**
+   * Search across all layers
+   *
+   * Algorithm:
+   * 1. Search base index for top K*2 results
+   * 2. Filter out tombstones
+   * 3. If on feature branch, search delta for top K*2
+   * 4. Merge and deduplicate (delta takes precedence)
+   * 5. Sort by similarity and return top K
+   */
+  async search(queryVector, limit) {
+    if (!this.isInitialized || !this.client) {
+      log.w("LAYERED_FAISS", "search called but not initialized", {
+        isInit: this.isInitialized,
+        hasClient: !!this.client
+      });
+      return [];
+    }
+    const normalizedQuery = simdL2Normalize(queryVector);
+    log.d("LAYERED_FAISS", "search", {
+      inputLen: queryVector.length,
+      normalizedLen: normalizedQuery.length,
+      limit,
+      normalizedSample: Array.from(normalizedQuery.slice(0, 3))
+    });
+    const searchLimit = Math.min(limit * 2, 200);
+    const results = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    if (!this.isOnBaseBranch && this.deltaIdSet.size > 0) ;
+    log.d("LAYERED_FAISS", "calling faissSearch", {
+      vectorLen: normalizedQuery.length,
+      vectorType: normalizedQuery.constructor.name,
+      searchLimit
+    });
+    const baseResults = await this.client.faissSearch(normalizedQuery, searchLimit);
+    for (const result of baseResults) {
+      if (seenIds.has(result.id)) continue;
+      if (this.tombstones.has(result.id)) continue;
+      if (this.deltaIdSet.has(result.id)) {
+        continue;
+      }
+      results.push({
+        id: result.id,
+        similarity: 1 - result.distance,
+        // Convert L2 distance to similarity
+        source: "base"
+      });
+      seenIds.add(result.id);
+    }
+    for (const id of this.deltaIdSet) {
+      if (!seenIds.has(id) && results.length < limit) {
+        const baseResult = baseResults.find((r) => r.id === id);
+        if (baseResult) {
+          results.push({
+            id: baseResult.id,
+            similarity: 1 - baseResult.distance,
+            source: "delta"
+          });
+          seenIds.add(id);
+        }
+      }
+    }
+    return results.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+  }
+  /**
+   * Search and return in VectorStore-compatible format
+   */
+  async searchForVectorStore(queryVector, limit) {
+    const results = await this.search(queryVector, limit);
+    return results.map((r) => ({
+      id: r.id,
+      content: "",
+      // Content is not stored in FAISS, retrieved separately
+      similarity: r.similarity,
+      metadata: { source: r.source }
+    }));
+  }
+  // ===========================================================================
+  // Add / Remove
+  // ===========================================================================
+  /**
+   * Add a vector embedding
+   */
+  async add(embedding) {
+    if (!this.isInitialized || !this.client) {
+      return { success: false, target: "base", error: "Not initialized" };
+    }
+    const normalizedVector = simdL2Normalize(embedding.vector);
+    if (this.isOnBaseBranch) {
+      await this.client.faissAdd([embedding.id], normalizedVector);
+      this.baseIdSet.add(embedding.id);
+      this.baseUnsavedCount++;
+      if (this.baseUnsavedCount >= this.config.autoSaveThreshold) {
+        await this.saveBase();
+      }
+      return { success: true, target: "base" };
+    } else {
+      this.tombstones.delete(embedding.id);
+      this.deltaIdSet.add(embedding.id);
+      this.deltaUnsavedCount++;
+      log.i("LAYERED_FAISS", "add_to_delta", {
+        id: embedding.id.slice(0, 50),
+        branch: this.currentBranch,
+        deltaUnsaved: this.deltaUnsavedCount
+      });
+      await this.client.faissAdd([embedding.id], normalizedVector);
+      if (this.deltaUnsavedCount >= this.config.autoSaveThreshold) {
+        await this.saveDelta();
+      }
+      return { success: true, target: "delta" };
+    }
+  }
+  /**
+   * Add multiple embeddings in batch (optimized - single Named Pipe call)
+   */
+  async addBatch(embeddings) {
+    if (embeddings.length === 0) {
+      return [];
+    }
+    if (!this.isInitialized || !this.client) {
+      return embeddings.map(() => ({ success: false, target: "base", error: "Not initialized" }));
+    }
+    log.d("LAYERED_FAISS", "addBatch_called", {
+      count: embeddings.length,
+      branch: this.currentBranch,
+      isOnBase: this.isOnBaseBranch
+    });
+    const startTime = performance.now();
+    const allIds = [];
+    const dimensions = this.config.dimensions;
+    const allVectors = new Float32Array(embeddings.length * dimensions);
+    for (let i = 0; i < embeddings.length; i++) {
+      const embedding = embeddings[i];
+      const normalized = simdL2Normalize(embedding.vector);
+      allIds.push(embedding.id);
+      allVectors.set(normalized, i * dimensions);
+      if (this.isOnBaseBranch) {
+        this.baseIdSet.add(embedding.id);
+      } else {
+        this.tombstones.delete(embedding.id);
+        this.deltaIdSet.add(embedding.id);
+      }
+    }
+    await this.client.faissAdd(allIds, allVectors);
+    if (this.isOnBaseBranch) {
+      this.baseUnsavedCount += embeddings.length;
+      if (this.baseUnsavedCount >= this.config.autoSaveThreshold) {
+        await this.saveBase();
+      }
+    } else {
+      this.deltaUnsavedCount += embeddings.length;
+      if (this.deltaUnsavedCount >= this.config.autoSaveThreshold) {
+        await this.saveDelta();
+      }
+    }
+    const elapsed = performance.now() - startTime;
+    log.i("LAYERED_FAISS", "addBatch_complete", {
+      count: embeddings.length,
+      elapsed: `${elapsed.toFixed(1)}ms`,
+      speed: `${Math.round(embeddings.length / (elapsed / 1e3))}/s`,
+      target: this.isOnBaseBranch ? "base" : "delta",
+      deltaIdSetSize: this.deltaIdSet.size,
+      tombstonesSize: this.tombstones.size
+    });
+    if (!this.isOnBaseBranch && this.deltaIdSet.size > _LayeredFaissProvider.MAX_DELTA_SIZE) {
+      log.i("LAYERED_FAISS", "auto_merge_delta", {
+        deltaSize: this.deltaIdSet.size,
+        tombstones: this.tombstones.size,
+        threshold: _LayeredFaissProvider.MAX_DELTA_SIZE
+      });
+      logMemory("LAYERED_FAISS", { deltaSize: this.deltaIdSet.size, tombstones: this.tombstones.size });
+      await this.saveBase();
+      if (tryGarbageCollect(true)) {
+        log.d("LAYERED_FAISS", "gc_after_merge");
+      }
+    }
+    const target = this.isOnBaseBranch ? "base" : "delta";
+    return embeddings.map(() => ({ success: true, target }));
+  }
+  /**
+   * Remove vectors by IDs (IVectorProvider interface)
+   */
+  async remove(ids) {
+    for (const id of ids) {
+      await this.removeOne(id);
+    }
+  }
+  /**
+   * Remove a single vector by ID
+   */
+  async removeOne(id) {
+    if (!this.isInitialized || !this.client) {
+      return { success: false, action: "not_found" };
+    }
+    if (this.isOnBaseBranch) {
+      const existed = this.baseIdSet.has(id);
+      if (existed) {
+        await this.client.faissRemove([id]);
+        this.baseIdSet.delete(id);
+        this.baseUnsavedCount++;
+        return { success: true, action: "removed_from_base" };
+      }
+      return { success: false, action: "not_found" };
+    } else {
+      if (this.deltaIdSet.has(id)) {
+        this.deltaIdSet.delete(id);
+        this.deltaUnsavedCount++;
+        return { success: true, action: "removed_from_delta" };
+      } else if (this.baseIdSet.has(id)) {
+        this.tombstones.add(id);
+        this.deltaUnsavedCount++;
+        return { success: true, action: "added_tombstone" };
+      }
+      return { success: false, action: "not_found" };
+    }
+  }
+  /**
+   * Check if ID exists (considering tombstones)
+   */
+  has(id) {
+    if (this.tombstones.has(id)) {
+      return false;
+    }
+    return this.deltaIdSet.has(id) || this.baseIdSet.has(id);
+  }
+  /**
+   * Get existing IDs from a list (considering tombstones)
+   * Required by IVectorProvider interface
+   */
+  getExistingIds(ids) {
+    const existing = /* @__PURE__ */ new Set();
+    for (const id of ids) {
+      if (this.has(id)) {
+        existing.add(id);
+      }
+    }
+    return existing;
+  }
+  // ===========================================================================
+  // Persistence
+  // ===========================================================================
+  /**
+   * Save all layers
+   */
+  async save() {
+    log.i("LAYERED_FAISS", "save_called", {
+      branch: this.currentBranch,
+      isOnBase: this.isOnBaseBranch,
+      baseUnsaved: this.baseUnsavedCount,
+      deltaUnsaved: this.deltaUnsavedCount
+    });
+    if (this.baseUnsavedCount > 0) {
+      await this.saveBase();
+    }
+    if (this.deltaUnsavedCount > 0) {
+      await this.saveDelta();
+    } else if (!this.isOnBaseBranch) {
+      log.w("LAYERED_FAISS", "delta_not_saved_zero_unsaved", {
+        branch: this.currentBranch,
+        deltaIdSetSize: this.deltaIdSet.size
+      });
+    }
+  }
+  /**
+   * Save base layer
+   */
+  async saveBase() {
+    if (!this.client || !this.isInitialized) return;
+    const projectDir = getProjectDir(this.projectPath);
+    const paths = getLayeredPaths(projectDir, this.currentBranch, this.baseBranch);
+    try {
+      const dir = dirname(paths.baseIndex);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      await this.client.faissSave(paths.baseIndex);
+      writeFileSync(paths.baseIds, JSON.stringify([...this.baseIdSet]), "utf-8");
+      const existingMeta = loadBaseMetadata(this.projectPath);
+      if (!existingMeta) {
+        createInitialBaseMetadata(this.projectPath, this.currentBranch, this.config.dimensions, this.baseIdSet.size);
+        this.baseBranch = this.currentBranch;
+        log.i("LAYERED_FAISS", "base_meta_created", { branch: this.currentBranch });
+      } else {
+        updateBaseMetadata(this.projectPath, this.baseIdSet.size);
+      }
+      this.baseUnsavedCount = 0;
+      log.i("LAYERED_FAISS", "base_saved", { vectors: this.baseIdSet.size });
+    } catch (error) {
+      log.e("LAYERED_FAISS", "base_save_fail", { err: String(error) });
+    }
+  }
+  /**
+   * Save delta layer
+   */
+  async saveDelta() {
+    if (!this.isInitialized || this.isOnBaseBranch || !this.client) return;
+    const projectDir = getProjectDir(this.projectPath);
+    const paths = getLayeredPaths(projectDir, this.currentBranch, this.baseBranch);
+    try {
+      const dir = dirname(paths.deltaIds);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      await this.client.faissSave(paths.deltaIndex || paths.baseIndex);
+      writeFileSync(paths.deltaIds, JSON.stringify([...this.deltaIdSet]), "utf-8");
+      writeFileSync(paths.tombstones, JSON.stringify([...this.tombstones]), "utf-8");
+      const deltaMeta = {
+        branchName: this.currentBranch,
+        baseBranch: this.baseBranch,
+        deltaVectorCount: this.deltaIdSet.size,
+        tombstoneCount: this.tombstones.size,
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      writeFileSync(paths.deltaMeta, JSON.stringify(deltaMeta, null, 2), "utf-8");
+      this.deltaUnsavedCount = 0;
+      log.i("LAYERED_FAISS", "delta_saved", {
+        branch: this.currentBranch,
+        deltaIds: this.deltaIdSet.size,
+        tombstones: this.tombstones.size
+      });
+    } catch (error) {
+      log.e("LAYERED_FAISS", "delta_save_fail", { err: String(error) });
+    }
+  }
+  // ===========================================================================
+  // Statistics
+  // ===========================================================================
+  /**
+   * Get statistics about the layered index
+   */
+  async getStats() {
+    const baseVectors = this.baseIdSet.size;
+    const deltaVectors = this.deltaIdSet.size;
+    const tombstoneCount = this.tombstones.size;
+    const totalVectors = baseVectors + deltaVectors - tombstoneCount;
+    return {
+      totalVectors: Math.max(0, totalVectors),
+      baseVectors,
+      deltaVectors,
+      tombstones: tombstoneCount,
+      currentBranch: this.currentBranch,
+      baseBranch: this.baseBranch,
+      isOnBaseBranch: this.isOnBaseBranch
+    };
+  }
+  /**
+   * Get count of searchable vectors
+   */
+  async count() {
+    const stats = await this.getStats();
+    return stats.totalVectors;
+  }
+  // ===========================================================================
+  // Cleanup
+  // ===========================================================================
+  /**
+   * Close and save all state
+   */
+  async close() {
+    if (!this.isInitialized) return;
+    await this.save();
+    this.isInitialized = false;
+    this.initializePromise = null;
+    log.i("LAYERED_FAISS", "closed", {
+      project: this.projectHash,
+      branch: this.currentBranch
+    });
+  }
+};
+var layeredProviderInstance = null;
+function getLayeredFaissProvider(config) {
+  if (!layeredProviderInstance) {
+    layeredProviderInstance = new LayeredFaissProvider(config);
+  } else if (config?.dimensions && config.dimensions !== layeredProviderInstance.getDimensions()) {
+    layeredProviderInstance.setDimensions(config.dimensions);
+  }
+  return layeredProviderInstance;
+}
+async function shutdownLayeredFaissProvider() {
+  if (layeredProviderInstance) {
+    await layeredProviderInstance.close();
+    layeredProviderInstance = null;
+  }
+}
+
+export { LayeredFaissProvider, getLayeredFaissProvider, shutdownLayeredFaissProvider };
+//# sourceMappingURL=chunk-2Z6OQPYC.js.map
+//# sourceMappingURL=chunk-2Z6OQPYC.js.map