indexer-cli 0.2.5 → 0.2.7

package/dist/storage/vectors.js

@@ -32,12 +32,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LanceDbVectorStore = exports.REQUIRED_COLUMNS = void 0;
+exports.LanceDbVectorStore = exports.SqliteVecVectorStore = exports.REQUIRED_COLUMNS = void 0;
 const node_fs_1 = require("node:fs");
-const lancedb = __importStar(require("@lancedb/lancedb"));
-const logger_js_1 = require("../core/logger.js");
-const logger = new logger_js_1.SystemLogger("vector-lancedb");
+const node_path_1 = __importDefault(require("node:path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const sqliteVec = __importStar(require("sqlite-vec"));
 exports.REQUIRED_COLUMNS = [
     "project_id",
     "chunk_id",
@@ -48,361 +51,271 @@ exports.REQUIRED_COLUMNS = [
     "content_hash",
     "chunk_type",
     "primary_symbol",
-    "vector",
+    "embedding",
 ];
-const COPY_VECTORS_QUERY_LIMIT = 1_000_000;
-class LanceDbVectorStore {
+const UPSERT_BATCH_SIZE = 200;
+class SqliteVecVectorStore {
     dbPath;
     vectorSize;
-    tableName;
-    cacheTTL;
     db;
-    table;
     initialized = false;
-    lastCacheRefresh = 0;
-    operationQueue = Promise.resolve();
     constructor(options) {
         this.dbPath = options.dbPath;
         this.vectorSize = options.vectorSize;
-        this.tableName = options.tableName ?? "vectors";
-        this.cacheTTL = options.cacheTTL ?? 5 * 60 * 1000;
+        this.db = this.openDatabase();
     }
     async initialize() {
         if (this.initialized) {
             return;
         }
-        this.db = await lancedb.connect(this.dbPath);
-        const tables = await this.db.tableNames();
-        if (!tables.includes(this.tableName)) {
-            await this.createTable();
-        }
-        else {
-            this.table = await this.db.openTable(this.tableName);
-            const schema = await this.table.getSchema();
-            if (!this.hasRequiredSchema(schema)) {
-                logger.warn(`[LanceDB] Schema mismatch for table "${this.tableName}", recreating.`);
-                await this.db.dropTable(this.tableName);
-                await this.createTable();
-            }
+        const db = this.getDb();
+        db.exec(`
+			CREATE TABLE IF NOT EXISTS vector_meta (
+				chunk_id TEXT PRIMARY KEY,
+				project_id TEXT NOT NULL,
+				snapshot_id TEXT NOT NULL,
+				file_path TEXT NOT NULL,
+				start_line INTEGER NOT NULL,
+				end_line INTEGER NOT NULL,
+				content_hash TEXT NOT NULL,
+				chunk_type TEXT NOT NULL DEFAULT '',
+				primary_symbol TEXT NOT NULL DEFAULT ''
+			);
+
+			CREATE INDEX IF NOT EXISTS idx_vector_meta_snapshot_id
+			ON vector_meta(snapshot_id);
+
+			CREATE INDEX IF NOT EXISTS idx_vector_meta_project_id
+			ON vector_meta(project_id);
+
+			CREATE INDEX IF NOT EXISTS idx_vector_meta_file_path
+			ON vector_meta(file_path);
+		`);
+        const vecChunksExists = db
+            .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'vec_chunks'")
+            .get();
+        if (!vecChunksExists) {
+            db.exec(`
+				CREATE VIRTUAL TABLE vec_chunks USING vec0(
+					chunk_id TEXT PRIMARY KEY,
+					embedding float[${this.vectorSize}]
+				)
+			`);
         }
         this.initialized = true;
     }
     async close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
         this.initialized = false;
-        this.db = null;
-        this.table = null;
     }
     async upsert(vectors) {
-        await this.runSerialized(async () => {
-            await this.withTransientIoRetry("upsert", async () => {
-                if (vectors.length === 0) {
-                    return;
-                }
-                if (!this.initialized) {
-                    await this.initialize();
-                }
-                const batchSize = 200;
-                for (let index = 0; index < vectors.length; index += batchSize) {
-                    const batch = vectors.slice(index, index + batchSize);
-                    const data = batch.map((vector) => ({
-                        project_id: vector.projectId,
-                        chunk_id: vector.chunkId,
-                        snapshot_id: vector.snapshotId,
-                        file_path: vector.filePath,
-                        start_line: vector.startLine,
-                        end_line: vector.endLine,
-                        content_hash: vector.contentHash,
-                        chunk_type: vector.chunkType ?? "",
-                        primary_symbol: vector.primarySymbol ?? "",
-                        vector: Array.from(vector.embedding),
-                    }));
-                    await this.table.add(data);
-                }
-            });
+        if (vectors.length === 0) {
+            return;
+        }
+        await this.initialize();
+        const db = this.getDb();
+        const deleteVectorStatement = db.prepare("DELETE FROM vec_chunks WHERE chunk_id = ?");
+        const deleteMetaStatement = db.prepare("DELETE FROM vector_meta WHERE chunk_id = ?");
+        const insertMetaStatement = db.prepare(`
+			INSERT INTO vector_meta (
+				chunk_id,
+				project_id,
+				snapshot_id,
+				file_path,
+				start_line,
+				end_line,
+				content_hash,
+				chunk_type,
+				primary_symbol
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+		`);
+        const insertVectorStatement = db.prepare("INSERT INTO vec_chunks (chunk_id, embedding) VALUES (?, vec_f32(?))");
+        const upsertBatch = db.transaction((batch) => {
+            for (const vector of batch) {
+                deleteVectorStatement.run(vector.chunkId);
+                deleteMetaStatement.run(vector.chunkId);
+                insertMetaStatement.run(vector.chunkId, vector.projectId, vector.snapshotId, vector.filePath, vector.startLine, vector.endLine, vector.contentHash, vector.chunkType ?? "", vector.primarySymbol ?? "");
+                insertVectorStatement.run(vector.chunkId, this.embeddingToBuffer(vector.embedding));
+            }
         });
+        for (let index = 0; index < vectors.length; index += UPSERT_BATCH_SIZE) {
+            const batch = vectors.slice(index, index + UPSERT_BATCH_SIZE);
+            upsertBatch(batch);
+        }
     }
     async search(queryEmbedding, topK, filters) {
-        return this.runSerialized(async () => {
-            return this.withTransientIoRetry("search", async () => {
-                if (!filters.projectId) {
-                    throw new Error("projectId is required in filters for search");
-                }
-                if (!this.initialized) {
-                    await this.initialize();
-                }
-                await this.refreshCacheIfNeeded();
-                await this.reopenTableIfNeeded();
-                const prefilter = await this.buildPrefilter(filters);
-                let results;
-                if (prefilter &&
-                    (typeof this.table.query === "function" ||
-                        typeof this.table.filter === "function")) {
-                    const rows = typeof this.table.query === "function"
-                        ? await this.table
-                            .query()
-                            .where(prefilter)
-                            .limit(COPY_VECTORS_QUERY_LIMIT)
-                            .select([
-                            "chunk_id",
-                            "snapshot_id",
-                            "file_path",
-                            "start_line",
-                            "end_line",
-                            "content_hash",
-                            "chunk_type",
-                            "primary_symbol",
-                            "vector",
-                        ])
-                            .toArray({ batchSize: 1024 })
-                        : await this.table
-                            .filter(prefilter)
-                            .limit(COPY_VECTORS_QUERY_LIMIT)
-                            .select([
-                            "chunk_id",
-                            "snapshot_id",
-                            "file_path",
-                            "start_line",
-                            "end_line",
-                            "content_hash",
-                            "chunk_type",
-                            "primary_symbol",
-                            "vector",
-                        ])
-                            .toArray();
-                    results = rows
-                        .map((row) => {
-                        const vector = Array.isArray(row.vector)
-                            ? row.vector
-                            : Array.from(row.vector ?? []);
-                        return {
-                            ...row,
-                            _distance: this.euclideanDistance(queryEmbedding, vector),
-                        };
-                    })
-                        .sort((left, right) => left._distance - right._distance)
-                        .slice(0, topK);
-                }
-                else {
-                    const searchQuery = this.table.search(queryEmbedding).limit(topK);
-                    results = prefilter
-                        ? await searchQuery.where(prefilter).toArray()
-                        : await searchQuery.toArray();
-                }
-                return results.map((result) => ({
-                    chunkId: result.chunk_id,
-                    snapshotId: result.snapshot_id,
-                    filePath: result.file_path,
-                    startLine: result.start_line,
-                    endLine: result.end_line,
-                    contentHash: result.content_hash,
-                    chunkType: typeof result.chunk_type === "string"
-                        ? result.chunk_type
-                        : undefined,
-                    primarySymbol: typeof result.primary_symbol === "string"
-                        ? result.primary_symbol
-                        : undefined,
-                    score: 1 /
-                        (1 + (typeof result._distance === "number" ? result._distance : 0)),
-                    distance: typeof result._distance === "number" ? result._distance : 0,
-                }));
-            });
-        });
+        if (!filters.projectId) {
+            throw new Error("projectId is required in filters for search");
+        }
+        await this.initialize();
+        const db = this.getDb();
+        const conditions = ["vm.project_id = ?"];
+        const values = [filters.projectId];
+        const prefilter = this.buildPrefilter(filters, "vm");
+        if (prefilter) {
+            conditions.push(prefilter);
+        }
+        const rows = db
+            .prepare(`
+				SELECT vm.*, vec_distance_L2(vc.embedding, vec_f32(?)) AS distance
+				FROM vec_chunks vc
+				JOIN vector_meta vm ON vc.chunk_id = vm.chunk_id
+				WHERE ${conditions.join(" AND ")}
+				ORDER BY distance
+				LIMIT ?
+			`)
+            .all(this.embeddingToBuffer(queryEmbedding), ...values, topK);
+        return rows.map((row) => ({
+            chunkId: row.chunk_id,
+            snapshotId: row.snapshot_id,
+            filePath: row.file_path,
+            startLine: row.start_line,
+            endLine: row.end_line,
+            contentHash: row.content_hash,
+            chunkType: row.chunk_type || undefined,
+            primarySymbol: row.primary_symbol || undefined,
+            score: 1 / (1 + row.distance),
+            distance: row.distance,
+        }));
     }
     async countVectors(filters) {
-        return this.runSerialized(async () => {
-            return this.withTransientIoRetry("countVectors", async () => {
-                if (!filters.projectId) {
-                    throw new Error("projectId is required in filters for countVectors");
-                }
-                if (!this.initialized) {
-                    await this.initialize();
-                }
-                await this.refreshCacheIfNeeded();
-                await this.reopenTableIfNeeded();
-                const prefilter = await this.buildPrefilter(filters);
-                if (typeof this.table.countRows === "function") {
-                    return prefilter
-                        ? await this.table.countRows(prefilter)
-                        : await this.table.countRows();
-                }
-                if (typeof this.table.filter === "function") {
-                    logger.warn("[LanceDB] countRows not available, falling back to filter-based count");
-                    const results = await this.table
-                        .filter(prefilter || "1 = 1")
-                        .limit(COPY_VECTORS_QUERY_LIMIT)
-                        .select(["chunk_id"])
-                        .toArray();
-                    return results.length;
-                }
-                if (typeof this.table.query === "function") {
-                    logger.warn("[LanceDB] countRows not available, falling back to query-based count");
-                    const query = this.table.query();
-                    const results = prefilter
-                        ? await query
-                            .where(prefilter)
-                            .limit(COPY_VECTORS_QUERY_LIMIT)
-                            .select(["chunk_id"])
-                            .toArray({ batchSize: 1024 })
-                        : await query
-                            .limit(COPY_VECTORS_QUERY_LIMIT)
-                            .select(["chunk_id"])
-                            .toArray({
-                            batchSize: 1024,
-                        });
-                    return results.length;
-                }
-                throw new Error("[LanceDB] countVectors requires countRows(), filter(), or query() support for exhaustive results");
-            });
-        });
+        if (!filters.projectId) {
+            throw new Error("projectId is required in filters for countVectors");
+        }
+        await this.initialize();
+        const db = this.getDb();
+        const conditions = ["project_id = ?"];
+        const values = [filters.projectId];
+        const prefilter = this.buildPrefilter(filters);
+        if (prefilter) {
+            conditions.push(prefilter);
+        }
+        const row = db
+            .prepare(`SELECT COUNT(*) AS count FROM vector_meta WHERE ${conditions.join(" AND ")}`)
+            .get(...values);
+        return row.count;
     }
     async deleteBySnapshot(projectId, snapshotId) {
-        await this.runSerialized(async () => {
-            await this.withTransientIoRetry("deleteBySnapshot", async () => {
-                void projectId;
-                if (!this.initialized) {
-                    await this.initialize();
-                }
-                await this.table.delete(`snapshot_id = '${this.escapeSqlLiteral(snapshotId.toString())}'`);
-            });
-        });
+        await this.initialize();
+        const db = this.getDb();
+        db.transaction(() => {
+            db.prepare(`
+				DELETE FROM vec_chunks
+				WHERE chunk_id IN (
+					SELECT chunk_id FROM vector_meta
+					WHERE project_id = ? AND snapshot_id = ?
+				)
+			`).run(projectId, snapshotId);
+            db.prepare("DELETE FROM vector_meta WHERE project_id = ? AND snapshot_id = ?").run(projectId, snapshotId);
+        })();
     }
     async copyVectors(projectId, fromSnapshotId, toSnapshotId, excludeFilePaths) {
-        await this.runSerialized(async () => {
-            await this.withTransientIoRetry("copyVectors", async () => {
-                if (!this.initialized) {
-                    await this.initialize();
-                }
-                await this.refreshCacheIfNeeded();
-                await this.reopenTableIfNeeded();
-                const filter = `snapshot_id = '${this.escapeSqlLiteral(fromSnapshotId.toString())}'`;
-                const results = typeof this.table.query === "function"
-                    ? await this.table
-                        .query()
-                        .where(filter)
-                        .limit(COPY_VECTORS_QUERY_LIMIT)
-                        .select([
-                        "project_id",
-                        "chunk_id",
-                        "snapshot_id",
-                        "file_path",
-                        "start_line",
-                        "end_line",
-                        "content_hash",
-                        "chunk_type",
-                        "primary_symbol",
-                        "vector",
-                    ])
-                        .toArray({ batchSize: 1024 })
-                    : typeof this.table.filter === "function"
-                        ? await this.table
-                            .filter(filter)
-                            .limit(COPY_VECTORS_QUERY_LIMIT)
-                            .select([
-                            "project_id",
-                            "chunk_id",
-                            "snapshot_id",
-                            "file_path",
-                            "start_line",
-                            "end_line",
-                            "content_hash",
-                            "chunk_type",
-                            "primary_symbol",
-                            "vector",
-                        ])
-                            .toArray()
-                        : await this.table
-                            .search(Array(this.vectorSize).fill(0))
-                            .limit(COPY_VECTORS_QUERY_LIMIT)
-                            .where(filter)
-                            .toArray();
-                const filtered = results.filter((row) => !excludeFilePaths.includes(String(row.file_path)));
-                if (filtered.length === 0) {
-                    return;
-                }
-                await this.table.add(filtered.map((row) => ({
-                    project_id: row.project_id ?? projectId.toString(),
-                    chunk_id: row.chunk_id,
-                    snapshot_id: toSnapshotId.toString(),
-                    file_path: row.file_path,
-                    start_line: row.start_line,
-                    end_line: row.end_line,
-                    content_hash: row.content_hash,
-                    chunk_type: row.chunk_type ?? "",
-                    primary_symbol: row.primary_symbol ?? "",
-                    vector: row.vector,
-                })));
-            });
+        await this.initialize();
+        const db = this.getDb();
+        const conditions = ["vm.project_id = ?", "vm.snapshot_id = ?"];
+        const values = [projectId, fromSnapshotId];
+        if (excludeFilePaths.length > 0) {
+            const placeholders = excludeFilePaths.map(() => "?").join(", ");
+            conditions.push(`vm.file_path NOT IN (${placeholders})`);
+            values.push(...excludeFilePaths);
+        }
+        const rows = db
+            .prepare(`
+				SELECT vm.*, vc.embedding
+				FROM vector_meta vm
+				JOIN vec_chunks vc ON vc.chunk_id = vm.chunk_id
+				WHERE ${conditions.join(" AND ")}
+			`)
+            .all(...values);
+        if (rows.length === 0) {
+            return;
+        }
+        const deleteVectorStatement = db.prepare("DELETE FROM vec_chunks WHERE chunk_id = ?");
+        const deleteMetaStatement = db.prepare("DELETE FROM vector_meta WHERE chunk_id = ?");
+        const insertMetaStatement = db.prepare(`
+			INSERT INTO vector_meta (
+				chunk_id,
+				project_id,
+				snapshot_id,
+				file_path,
+				start_line,
+				end_line,
+				content_hash,
+				chunk_type,
+				primary_symbol
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+		`);
+        const insertVectorStatement = db.prepare("INSERT INTO vec_chunks (chunk_id, embedding) VALUES (?, vec_f32(?))");
+        const copyBatch = db.transaction((batch) => {
+            for (const row of batch) {
+                deleteVectorStatement.run(row.chunk_id);
+                deleteMetaStatement.run(row.chunk_id);
+                insertMetaStatement.run(row.chunk_id, row.project_id, toSnapshotId, row.file_path, row.start_line, row.end_line, row.content_hash, row.chunk_type, row.primary_symbol);
+                insertVectorStatement.run(row.chunk_id, this.normalizeEmbeddingValue(row.embedding));
+            }
         });
+        for (let index = 0; index < rows.length; index += UPSERT_BATCH_SIZE) {
+            const batch = rows.slice(index, index + UPSERT_BATCH_SIZE);
+            copyBatch(batch);
+        }
     }
     async deleteByProject(projectId) {
-        await this.runSerialized(async () => {
-            await this.withTransientIoRetry("deleteByProject", async () => {
-                void projectId;
-                await this.close();
-                if (!(0, node_fs_1.existsSync)(this.dbPath)) {
-                    return;
-                }
-                (0, node_fs_1.rmSync)(this.dbPath, { recursive: true, force: true });
-            });
-        });
-    }
-    async runSerialized(operation) {
-        const run = this.operationQueue.then(operation, operation);
-        this.operationQueue = run.then(() => undefined, () => undefined);
-        return run;
+        await this.initialize();
+        const db = this.getDb();
+        db.transaction(() => {
+            db.prepare(`
+				DELETE FROM vec_chunks
+				WHERE chunk_id IN (
+					SELECT chunk_id FROM vector_meta WHERE project_id = ?
+				)
+			`).run(projectId);
+            db.prepare("DELETE FROM vector_meta WHERE project_id = ?").run(projectId);
+        })();
+        const legacyVectorsPath = node_path_1.default.join(node_path_1.default.dirname(this.dbPath), "vectors");
+        if ((0, node_fs_1.existsSync)(legacyVectorsPath)) {
+            (0, node_fs_1.rmSync)(legacyVectorsPath, { recursive: true, force: true });
+        }
     }
-    isTransientIoError(error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return (message.includes("LanceError(IO)") &&
-            (message.includes("Not found:") ||
-                message.includes("Did not find any data files") ||
-                message.includes("/vectors.lance/data/")));
+    openDatabase() {
+        const db = new better_sqlite3_1.default(this.dbPath);
+        sqliteVec.load(db);
+        return db;
     }
-    async withTransientIoRetry(operationName, operation) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            if (!this.isTransientIoError(error)) {
-                throw error;
-            }
-            const message = error instanceof Error ? error.message : String(error);
-            logger.warn(`[LanceDB] ${operationName} hit transient IO error, reopening and retrying once: ${message}`);
-            await this.close();
-            await this.initialize();
-            return operation();
+    getDb() {
+        if (!this.db) {
+            this.db = this.openDatabase();
         }
+        return this.db;
     }
-    async refreshCacheIfNeeded() {
-        const now = Date.now();
-        if (this.cacheTTL <= 0) {
-            if (this.table) {
-                this.table = null;
-            }
-            this.lastCacheRefresh = now;
-            return;
+    embeddingToBuffer(embedding) {
+        return Buffer.from(new Float32Array(embedding).buffer);
+    }
+    normalizeEmbeddingValue(embedding) {
+        if (Buffer.isBuffer(embedding)) {
+            return embedding;
         }
-        if (this.table && now - this.lastCacheRefresh > this.cacheTTL) {
-            this.table = null;
-            this.lastCacheRefresh = now;
-            logger.debug(`[LanceDB] Cache refreshed (TTL: ${this.cacheTTL}ms)`);
+        if (embedding instanceof Uint8Array) {
+            return Buffer.from(embedding);
         }
-    }
-    async reopenTableIfNeeded() {
-        if (!this.table) {
-            this.table = await this.db.openTable(this.tableName);
+        if (embedding instanceof ArrayBuffer) {
+            return Buffer.from(embedding);
         }
+        throw new Error("Unsupported sqlite-vec embedding value returned from database");
     }
-    async buildPrefilter(filters) {
+    buildPrefilter(filters, alias) {
         const conditions = [];
+        const prefix = alias ? `${alias}.` : "";
         if (filters.snapshotId) {
-            conditions.push(`snapshot_id = '${this.escapeSqlLiteral(filters.snapshotId)}'`);
+            conditions.push(`${prefix}snapshot_id = '${this.escapeSqlLiteral(filters.snapshotId)}'`);
         }
         if (filters.filePath) {
-            conditions.push(`file_path = '${this.escapeSqlLiteral(filters.filePath)}'`);
+            conditions.push(`${prefix}file_path = '${this.escapeSqlLiteral(filters.filePath)}'`);
         }
         else if (filters.pathPrefix) {
-            conditions.push(`file_path LIKE '${this.escapeSqlLike(filters.pathPrefix)}%'`);
+            conditions.push(`${prefix}file_path LIKE '${this.escapeSqlLike(filters.pathPrefix)}%'`);
         }
         if (filters.chunkTypes && filters.chunkTypes.length > 0) {
             const normalizedChunkTypes = filters.chunkTypes
@@ -410,48 +323,11 @@ class LanceDbVectorStore {
                 .filter((chunkType) => chunkType.length > 0)
                 .map((chunkType) => `'${this.escapeSqlLiteral(chunkType)}'`);
             if (normalizedChunkTypes.length > 0) {
-                conditions.push(`chunk_type IN (${normalizedChunkTypes.join(", ")})`);
+                conditions.push(`${prefix}chunk_type IN (${normalizedChunkTypes.join(", ")})`);
             }
         }
         return conditions.join(" AND ");
     }
-    euclideanDistance(a, b) {
-        const length = Math.min(a.length, b.length);
-        let sum = 0;
-        for (let index = 0; index < length; index += 1) {
-            const delta = a[index] - b[index];
-            sum += delta * delta;
-        }
-        return Math.sqrt(sum);
-    }
-    async createTable() {
-        this.table = await this.db.createTable(this.tableName, [
-            {
-                project_id: "",
-                chunk_id: "",
-                snapshot_id: "",
-                file_path: "",
-                start_line: 0,
-                end_line: 0,
-                content_hash: "",
-                chunk_type: "",
-                primary_symbol: "",
-                vector: Array(this.vectorSize).fill(0),
-            },
-        ]);
-    }
-    hasRequiredSchema(schema) {
-        if (!schema?.fields) {
-            return false;
-        }
-        const fields = new Set(schema.fields.map((field) => field.name));
-        for (const column of exports.REQUIRED_COLUMNS) {
-            if (!fields.has(column)) {
-                return false;
-            }
-        }
-        return true;
-    }
     escapeSqlLiteral(value) {
         return value.replace(/'/g, "''");
     }
@@ -459,5 +335,6 @@ class LanceDbVectorStore {
         return this.escapeSqlLiteral(value).replace(/[%_]/g, (char) => `\\${char}`);
     }
 }
-exports.LanceDbVectorStore = LanceDbVectorStore;
+exports.SqliteVecVectorStore = SqliteVecVectorStore;
+exports.LanceDbVectorStore = SqliteVecVectorStore;
 //# sourceMappingURL=vectors.js.map