opencode-rag-plugin 1.18.2 → 1.19.1

package/dist/vectorstore/lancedb.js

@@ -384,26 +384,28 @@ export class LanceDbStore {
      * @returns An array of file summaries sorted by file path.
      */
     async listFiles() {
-        const table = await this.getTable();
-        const count = await table.countRows();
-        if (count === 0)
-            return [];
-        const rows = await table.query().select(["filePath", "language"]).limit(count).toArray();
-        const fileMap = new Map();
-        for (const row of rows) {
-            const filePath = row.filePath;
-            const language = row.language;
-            const existing = fileMap.get(filePath);
-            if (existing) {
-                existing.chunkCount++;
-            }
-            else {
-                fileMap.set(filePath, { language, chunkCount: 1 });
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            const count = await table.countRows();
+            if (count === 0)
+                return [];
+            const rows = await table.query().select(["filePath", "language"]).limit(count).toArray();
+            const fileMap = new Map();
+            for (const row of rows) {
+                const filePath = row.filePath;
+                const language = row.language;
+                const existing = fileMap.get(filePath);
+                if (existing) {
+                    existing.chunkCount++;
+                }
+                else {
+                    fileMap.set(filePath, { language, chunkCount: 1 });
+                }
             }
-        }
-        return Array.from(fileMap.entries())
-            .map(([filePath, info]) => ({ filePath, ...info }))
-            .sort((a, b) => a.filePath.localeCompare(b.filePath));
+            return Array.from(fileMap.entries())
+                .map(([filePath, info]) => ({ filePath, ...info }))
+                .sort((a, b) => a.filePath.localeCompare(b.filePath));
+        });
     }
     /**
      * Retrieve all chunks for a specific file path, sorted by start line.
@@ -411,39 +413,41 @@ export class LanceDbStore {
      * @returns An array of chunks for that file.
      */
     async getChunksByFilePath(filePath) {
-        const table = await this.getTable();
-        const normalizedPath = normalizeFilePath(filePath).replace(/'/g, "''");
-        const rows = await table.query()
-            .select(QUERY_COLUMNS)
-            .where(`filePath = '${normalizedPath}'`)
-            .toArray();
-        return rows
-            .map((row) => {
-            let tags;
-            try {
-                const raw = row.tags;
-                if (raw)
-                    tags = JSON.parse(raw);
-            }
-            catch {
-                tags = undefined;
-            }
-            return {
-                id: row.id,
-                content: row.content,
-                description: row.description ?? "",
-                metadata: {
-                    filePath: row.filePath,
-                    startLine: row.startLine,
-                    endLine: row.endLine,
-                    language: row.language,
-                    kind: row.kind || undefined,
-                    quirkType: row.quirkType || undefined,
-                    tags,
-                },
-            };
-        })
-            .sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            const normalizedPath = normalizeFilePath(filePath).replace(/'/g, "''");
+            const rows = await table.query()
+                .select(QUERY_COLUMNS)
+                .where(`filePath = '${normalizedPath}'`)
+                .toArray();
+            return rows
+                .map((row) => {
+                let tags;
+                try {
+                    const raw = row.tags;
+                    if (raw)
+                        tags = JSON.parse(raw);
+                }
+                catch {
+                    tags = undefined;
+                }
+                return {
+                    id: row.id,
+                    content: row.content,
+                    description: row.description ?? "",
+                    metadata: {
+                        filePath: row.filePath,
+                        startLine: row.startLine,
+                        endLine: row.endLine,
+                        language: row.language,
+                        kind: row.kind || undefined,
+                        quirkType: row.quirkType || undefined,
+                        tags,
+                    },
+                };
+            })
+                .sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+        });
     }
     /**
      * Retrieve a paginated list of all chunks without embeddings.
@@ -452,24 +456,51 @@ export class LanceDbStore {
      * @returns An array of chunk summaries.
      */
     async getChunks(offset, limit) {
-        const table = await this.getTable();
-        const rows = await table.query()
-            .select(QUERY_COLUMNS)
-            .offset(offset)
-            .limit(limit)
-            .toArray();
-        return rows.map((row) => ({
-            id: row.id,
-            filePath: row.filePath,
-            language: row.language,
-            startLine: row.startLine,
-            endLine: row.endLine,
-            content: row.content,
-            description: row.description ?? "",
-            kind: row.kind ?? "",
-            quirkType: row.quirkType ?? "",
-            tags: row.tags ?? "",
-        }));
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            const rows = await table.query()
+                .select(QUERY_COLUMNS)
+                .offset(offset)
+                .limit(limit)
+                .toArray();
+            return rows.map((row) => ({
+                id: row.id,
+                filePath: row.filePath,
+                language: row.language,
+                startLine: row.startLine,
+                endLine: row.endLine,
+                content: row.content,
+                description: row.description ?? "",
+                kind: row.kind ?? "",
+                quirkType: row.quirkType ?? "",
+                tags: row.tags ?? "",
+            }));
+        });
+    }
+    /**
+     * Fetch chunks with their embedding vectors included (for embedding projection).
+     * @param limit - Maximum number of rows to return.
+     * @returns Array of { id, filePath, language, startLine, endLine, description, embedding }.
+     */
+    async getChunksWithEmbeddings(limit) {
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            const rows = await table.query()
+                .select([...QUERY_COLUMNS, "embedding"])
+                .limit(limit)
+                .toArray();
+            return rows
+                .filter((r) => r.embedding && typeof r.embedding === "object")
+                .map((row) => ({
+                id: row.id,
+                filePath: row.filePath,
+                language: row.language,
+                startLine: row.startLine,
+                endLine: row.endLine,
+                description: row.description ?? "",
+                embedding: Array.from(row.embedding),
+            }));
+        });
     }
     /**
      * Perform ANN search internally, returning results scored as cosine similarity (0-1).
@@ -548,7 +579,13 @@ export class LanceDbStore {
     async optimize() {
         try {
             const table = await this.getTable();
-            await table.optimize({ cleanupOlderThan: new Date(), deleteUnverified: false });
+            // Clean up versions older than 1 hour — not "right now" — so in-flight
+            // queries (e.g. Web UI search, background auto-index) can finish before
+            // their data files are reclaimed.  Using new Date() here caused data-file
+            // race conditions where a reader got "Not found: … .lance" because the
+            // GC deleted fragments that the current version still referenced.
+            const threshold = new Date(Date.now() - 60 * 60 * 1000);
+            await table.optimize({ cleanupOlderThan: threshold, deleteUnverified: false });
         }
         catch {
             // Optimize is best-effort — must not break indexing.
@@ -564,15 +601,17 @@ export class LanceDbStore {
             const tableNames = await db.tableNames();
             if (!tableNames.includes(TABLE_NAME))
                 return [];
-            const table = await this.getTable();
-            const rows = await table.query().select(["filePath"]).toArray();
-            const paths = new Set();
-            for (const row of rows) {
-                const fp = row.filePath;
-                if (fp)
-                    paths.add(fp);
-            }
-            return Array.from(paths);
+            return this.withCorruptionRecovery(async () => {
+                const table = await this.getTable();
+                const rows = await table.query().select(["filePath"]).toArray();
+                const paths = new Set();
+                for (const row of rows) {
+                    const fp = row.filePath;
+                    if (fp)
+                        paths.add(fp);
+                }
+                return Array.from(paths);
+            });
         }
         catch {
             return [];
@@ -708,6 +747,56 @@ export class LanceDbStore {
         const normalizedPath = normalizeFilePath(filePath).replace(/'/g, "''");
         await table.delete(`filePath = '${normalizedPath}'`);
     }
+    /**
+     * Verify that data in the store is actually readable.
+     * Reads the `content` column (a large text field stored in data fragments,
+     * not in the version manifest) for the first few rows.  If any of the
+     * underlying `.lance` data files are missing from disk, LanceDB throws a
+     * corruption error ("Not found: ... .lance") and we return false.
+     *
+     * This catches silent corruption where countRows() returns metadata from
+     * the version manifest while the actual row data on disk is gone.
+     */
+    async checkIntegrity() {
+        try {
+            const db = await this.getDb();
+            const tableNames = await db.tableNames();
+            if (!tableNames.includes(TABLE_NAME))
+                return true;
+            const table = await this.getTable();
+            const count = await table.countRows();
+            if (count === 0)
+                return true;
+            // Read the `content` column (stored in data fragments, not in the
+            // version manifest) for the first few rows.  If a fragment is
+            // missing, LanceDB will fail with a "Not found" corruption error.
+            const rows = await table.query().select(["id", "content"]).limit(10).toArray();
+            return rows.length > 0;
+        }
+        catch (err) {
+            if (isCorruptionError(err))
+                return false;
+            return true;
+        }
+    }
+    /**
+     * Execute an async function with automatic corruption recovery.
+     * If the function throws a LanceDB corruption error, tryRepair() is run
+     * and the function is retried once.  If repair fails, the original error
+     * is re-thrown so callers/higher layers can handle it (e.g. return
+     * fallback data, clear the manifest, or trigger a rebuild).
+     */
+    async withCorruptionRecovery(fn) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (isCorruptionError(err) && await this.tryRepair()) {
+                return fn();
+            }
+            throw err;
+        }
+    }
     async tryRepair() {
         try {
             this.table = null;

package/dist/web/api.d.ts

@@ -5,6 +5,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { LanceDbStore } from "../vectorstore/lancedb.js";
 import { KeywordIndex } from "../retriever/keyword-index.js";
 import type { RagConfig } from "../core/config.js";
+import type { EmbeddingProvider } from "../core/interfaces.js";
 /** Internal shape for a JSON API response: an HTTP status code and a serialisable body. */
 interface ApiResponse {
     status: number;
@@ -27,7 +28,7 @@ interface ApiResponse {
  * @param cfg          - Active RAG configuration (used by quirk endpoints).
  * @returns An async handler that returns `true` when a route matched or `false` otherwise.
  */
-export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string, cfg?: RagConfig): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string, cfg?: RagConfig, getEmbedder?: () => Promise<EmbeddingProvider>): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
 /**
  * Perform token-usage analysis for a single evaluation session.
  *

package/dist/web/api.js

@@ -1,8 +1,10 @@
 import { readFileSync } from "node:fs";
-import { extname, resolve as resolvePathModule } from "node:path";
+import { extname, join, resolve as resolvePathModule } from "node:path";
+import { createHash } from "node:crypto";
 import { listSessions, getSession, deleteSession, compareSessions, validateSessionID } from "../eval/storage.js";
 import { analyzeTokenUsage, compareTokenAnalyses, projectTokenSavings } from "../eval/token-analysis.js";
 import { listQuirks, lintQuirks, removeQuirk } from "../quirks/quirk-store.js";
+import { retrieve } from "../retriever/retriever.js";
 const FILE_MIME_TYPES = {
     ".png": "image/png",
     ".jpg": "image/jpeg",
@@ -54,7 +56,7 @@ function sendJson(res, response) {
  * @param cfg          - Active RAG configuration (used by quirk endpoints).
  * @returns An async handler that returns `true` when a route matched or `false` otherwise.
  */
-export function createApiHandler(store, keywordIndex, storePath, cwd, cfg) {
+export function createApiHandler(store, keywordIndex, storePath, cwd, cfg, getEmbedder) {
     return async (req, res) => {
         const url = req.url ?? "/";
         const method = req.method ?? "GET";
@@ -71,7 +73,7 @@ export function createApiHandler(store, keywordIndex, storePath, cwd, cfg) {
         if (method === "OPTIONS") {
             res.writeHead(204, {
                 "Access-Control-Allow-Origin": "*",
-                "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+                "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
                 "Access-Control-Allow-Headers": "Content-Type",
             });
             res.end();
@@ -99,6 +101,21 @@ export function createApiHandler(store, keywordIndex, storePath, cwd, cfg) {
             else if (path === "/api/compare") {
                 response = await handleCompare(store, params);
             }
+            else if (path === "/api/retrieve") {
+                response = await handleRetrieve(store, keywordIndex, getEmbedder, cfg, params);
+            }
+            else if (path === "/api/indexing/status") {
+                response = await handleIndexingStatus(storePath, cwd);
+            }
+            else if (path === "/api/indexing/reindex" && method === "POST") {
+                response = await handleReindex(cwd, cfg, storePath, store, getEmbedder);
+            }
+            else if (path === "/api/config") {
+                response = await handleConfig(cfg);
+            }
+            else if (path === "/api/embeddings/projection") {
+                response = await handleEmbeddingProjection(store, params);
+            }
             // File content endpoint (for serving images)
             else if (path === "/api/file" && method === "GET") {
                 if (!cwd) {
@@ -290,6 +307,85 @@ async function handleSearch(keywordIndex, params) {
         },
     };
 }
+/**
+ * Perform a full vector+hybrid semantic search via the retrieve() pipeline.
+ * Accepts GET or POST with query parameters: q, topK, minScore, keywordWeight, hybrid, path, lang, explain.
+ * The embedder is lazily initialized on the first call; returns 202 if still initializing.
+ */
+async function handleRetrieve(store, keywordIndex, getEmbedder, cfg, params) {
+    if (!getEmbedder) {
+        return { status: 503, body: { error: "Embedder not configured for this server instance" } };
+    }
+    const q = params.get("q") ?? "";
+    if (!q.trim()) {
+        return { status: 400, body: { error: "Missing 'q' query parameter" } };
+    }
+    let embedder;
+    try {
+        embedder = await getEmbedder();
+    }
+    catch (err) {
+        return { status: 503, body: { error: `Embedding model unavailable: ${err.message}. Check that your embedding provider is running.` } };
+    }
+    const topK = parseInt(params.get("topK") ?? "10", 10);
+    const minScore = parseFloat(params.get("minScore") ?? "0.35");
+    const keywordWeight = parseFloat(params.get("keywordWeight") ?? "0.4");
+    const hybrid = params.get("hybrid") !== "false";
+    const explain = params.get("explain") !== "false";
+    const pathFilter = params.get("path") ?? undefined;
+    const langFilter = params.get("lang") ?? undefined;
+    try {
+        const results = await retrieve(q, embedder, store, {
+            topK,
+            minScore,
+            keywordIndex,
+            keywordWeight,
+            hybridEnabled: hybrid,
+            queryPrefix: cfg.embedding.queryPrefix,
+            explain,
+            filter: {
+                pathPatterns: pathFilter ? pathFilter.split(",").map((s) => s.trim()).filter(Boolean) : undefined,
+                languages: langFilter ? langFilter.split(",").map((s) => s.trim()).filter(Boolean) : undefined,
+            },
+        });
+        return {
+            status: 200,
+            body: {
+                query: q,
+                params: { topK, minScore, keywordWeight, hybrid, queryPrefix: cfg.embedding.queryPrefix },
+                results: results.map((r) => ({
+                    chunk: {
+                        id: r.chunk.id,
+                        filePath: r.chunk.metadata.filePath,
+                        startLine: r.chunk.metadata.startLine,
+                        endLine: r.chunk.metadata.endLine,
+                        language: r.chunk.metadata.language,
+                        content: r.chunk.content,
+                        description: r.chunk.description,
+                    },
+                    score: Math.round(r.score * 1000) / 1000,
+                    explanation: r.explanation
+                        ? {
+                            scoreBreakdown: {
+                                vectorScore: r.explanation.scoreBreakdown.vectorScore,
+                                keywordScore: r.explanation.scoreBreakdown.keywordScore,
+                                rawVectorScore: r.explanation.scoreBreakdown.rawVectorScore,
+                                rawKeywordScore: r.explanation.scoreBreakdown.rawKeywordScore,
+                                keywordWeight: r.explanation.scoreBreakdown.keywordWeight,
+                                vectorRank: r.explanation.scoreBreakdown.vectorRank,
+                                keywordRank: r.explanation.scoreBreakdown.keywordRank,
+                            },
+                            matchedTerms: r.explanation.matchedTerms,
+                        }
+                        : undefined,
+                })),
+            },
+        };
+    }
+    catch (err) {
+        return { status: 500, body: { error: `Retrieval failed: ${err.message}` } };
+    }
+}
 /** Fetch multiple chunks by their comma-separated IDs (`ids` query param) for side-by-side comparison. */
 async function handleCompare(store, params) {
     const idsParam = params.get("ids") ?? "";
@@ -301,6 +397,126 @@ async function handleCompare(store, params) {
     const chunks = allChunks.filter((c) => ids.includes(c.id ?? ""));
     return { status: 200, body: { chunks } };
 }
+/**
+ * Return indexing status — manifest stats, staleness, and a placeholder for watcher state.
+ */
+async function handleIndexingStatus(storePath, cwd) {
+    const manifestPath = join(storePath, "manifest.json");
+    let manifest = null;
+    try {
+        manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    }
+    catch { /* no manifest yet */ }
+    let staleFileCount = 0;
+    let totalChunks = 0;
+    let totalFiles = 0;
+    let lastIndexedAt = null;
+    let schemaVersion = manifest?.schemaVersion ?? 0;
+    if (manifest?.files) {
+        const storedFiles = manifest.files;
+        totalFiles = Object.keys(storedFiles).length;
+        totalChunks = Object.values(storedFiles).reduce((sum, f) => sum + (f.chunkCount ?? 0), 0);
+    }
+    if (manifest?.lastIndexedAt) {
+        lastIndexedAt = new Date(manifest.lastIndexedAt).toISOString();
+    }
+    // Count stale files by comparing manifest file list against current disk state
+    if (cwd && manifest?.files) {
+        const storedFiles = manifest.files;
+        for (const [filePath, fileMeta] of Object.entries(storedFiles)) {
+            try {
+                const fullPath = filePath;
+                const content = readFileSync(fullPath, "utf-8");
+                const hash = createHash("sha256").update(content).digest("hex");
+                if (hash !== fileMeta.hash)
+                    staleFileCount++;
+            }
+            catch {
+                staleFileCount++; // file was deleted or unreadable
+            }
+        }
+    }
+    return {
+        status: 200,
+        body: {
+            manifest: { totalChunks, totalFiles, schemaVersion, lastIndexedAt },
+            staleFileCount,
+            watcherActive: false,
+        },
+    };
+}
+/**
+ * Trigger a one-shot reindex pass in the background.
+ */
+async function handleReindex(cwd, cfg, storePath, store, getEmbedder) {
+    try {
+        const { runIndexPass } = await import("../indexer.js");
+        const embedder = getEmbedder ? await getEmbedder() : undefined;
+        if (!embedder) {
+            return { status: 503, body: { error: "Embedder not available" } };
+        }
+        runIndexPass({ cwd, storePath, config: cfg, store, embedder }).catch((err) => {
+            console.error("Background reindex failed:", err);
+        });
+        return { status: 200, body: { started: true } };
+    }
+    catch (err) {
+        return { status: 500, body: { error: `Failed to start reindex: ${err.message}` } };
+    }
+}
+/**
+ * Return the effective configuration with API keys redacted.
+ */
+function handleConfig(cfg) {
+    const redacted = JSON.parse(JSON.stringify(cfg));
+    redactKeys(redacted);
+    return { status: 200, body: { config: redacted } };
+}
+function redactKeys(obj) {
+    for (const key of Object.keys(obj)) {
+        if (key.toLowerCase().includes("apikey") || key === "apiKey") {
+            obj[key] = "***";
+        }
+        else if (typeof obj[key] === "object" && obj[key] !== null) {
+            redactKeys(obj[key]);
+        }
+    }
+}
+/**
+ * Project chunk embeddings to 2D via PCA for the Embedding Space Explorer.
+ */
+async function handleEmbeddingProjection(store, params) {
+    const maxChunks = parseInt(params.get("maxChunks") ?? "5000", 10);
+    try {
+        const chunks = await store.getChunksWithEmbeddings(maxChunks);
+        if (chunks.length === 0) {
+            return { status: 200, body: { points: [], totalChunks: 0 } };
+        }
+        if (chunks.length === 1) {
+            return { status: 200, body: { points: [{ id: chunks[0].id, x: 0.5, y: 0.5, filePath: chunks[0].filePath, startLine: chunks[0].startLine, endLine: chunks[0].endLine, language: chunks[0].language, description: chunks[0].description }], totalChunks: 1, displayedChunks: 1 } };
+        }
+        const { computePCA } = await import("./pca.js");
+        const vectors = chunks.map(c => c.embedding);
+        const projected = computePCA(vectors);
+        const points = chunks.map((c, i) => ({
+            id: c.id,
+            x: projected[i].x,
+            y: projected[i].y,
+            filePath: c.filePath,
+            startLine: c.startLine,
+            endLine: c.endLine,
+            language: c.language,
+            description: c.description,
+        }));
+        return {
+            status: 200,
+            body: { points, totalChunks: chunks.length, displayedChunks: points.length },
+        };
+    }
+    catch (err) {
+        return { status: 500, body: { error: `Projection failed: ${err.message}` } };
+    }
+}
 // ── File Content API ──────────────────────────────────────────────────
 /** Resolve a user-supplied file path against the workspace root, preventing directory traversal outside `cwd`. Returns `null` when the path escapes the workspace. */
 function resolvePath(cwd, filePath) {

package/dist/web/pca.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Self-contained, zero-dependency PCA implementation for 2D embedding projection.
+ */
+export declare function computePCA(vectors: number[][]): {
+    x: number;
+    y: number;
+}[];

package/dist/web/pca.js

@@ -0,0 +1,87 @@
+/**
+ * Self-contained, zero-dependency PCA implementation for 2D embedding projection.
+ */
+export function computePCA(vectors) {
+    const n = vectors.length;
+    if (n === 0)
+        return [];
+    const dim = vectors[0].length;
+    if (n === 1)
+        return [{ x: 0.5, y: 0.5 }];
+    // 1. Compute column means
+    const means = new Array(dim).fill(0);
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < dim; j++) {
+            means[j] += vectors[i][j];
+        }
+    }
+    for (let j = 0; j < dim; j++)
+        means[j] /= n;
+    // 2. Center data
+    const centered = vectors.map(v => v.map((val, j) => val - means[j]));
+    // 3. Compute covariance matrix (dim x dim), upper triangle
+    const cov = Array.from({ length: dim }, () => new Array(dim).fill(0));
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < dim; j++) {
+            for (let k = j; k < dim; k++) {
+                cov[j][k] += centered[i][j] * centered[i][k];
+            }
+        }
+    }
+    for (let j = 0; j < dim; j++) {
+        for (let k = j; k < dim; k++) {
+            cov[j][k] /= n - 1;
+        }
+    }
+    // 4. Power iteration to find top-2 eigenvectors
+    const pc1 = powerIteration(cov, dim, 50);
+    // Deflate: subtract PC1's contribution to find PC2
+    const deflated = cov.map((row, i) => {
+        const pc1DotRow = pc1.reduce((sum, v, idx) => sum + v * cov[i][idx], 0);
+        const pc1NormSq = pc1.reduce((sum, v) => sum + v * v, 0);
+        return row.map((val, j) => val - (pc1DotRow / pc1NormSq) * pc1[j]);
+    });
+    const pc2 = powerIteration(deflated, dim, 50);
+    // 5. Project centered data onto PCs
+    const projected = centered.map(v => ({
+        x: v.reduce((sum, val, j) => sum + val * pc1[j], 0),
+        y: v.reduce((sum, val, j) => sum + val * pc2[j], 0),
+    }));
+    // 6. Normalize to [0, 1]
+    const xs = projected.map(p => p.x);
+    const ys = projected.map(p => p.y);
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const minY = Math.min(...ys);
+    const maxY = Math.max(...ys);
+    const rangeX = maxX - minX || 1;
+    const rangeY = maxY - minY || 1;
+    return projected.map(p => ({
+        x: (p.x - minX) / rangeX,
+        y: (p.y - minY) / rangeY,
+    }));
+}
+/** Power iteration to find the dominant eigenvector of a symmetric matrix. */
+function powerIteration(matrix, dim, maxIter) {
+    let v = new Array(dim).fill(0).map(() => Math.random() * 2 - 1);
+    const normalize = (vec) => {
+        const len = Math.sqrt(vec.reduce((s, val) => s + val * val, 0));
+        return len > 1e-10 ? vec.map(val => val / len) : vec;
+    };
+    for (let iter = 0; iter < maxIter; iter++) {
+        const w = new Array(dim).fill(0);
+        for (let i = 0; i < dim; i++) {
+            for (let j = 0; j < dim; j++) {
+                w[i] += matrix[i][j] * v[j];
+            }
+        }
+        v = normalize(w);
+        if (iter > 5) {
+            const change = Math.sqrt(v.reduce((s, val, i) => s + (val - w[i]) * (val - w[i]), 0));
+            if (change < 1e-6)
+                break;
+        }
+    }
+    return v;
+}
+//# sourceMappingURL=pca.js.map