hyperspace-sdk-ts 3.1.1 → 3.1.2

package/dist/client.js

@@ -224,7 +224,77 @@ class HyperspaceClient {
         });
         return out;
     }
+    toProtoFilter(f) {
+        const pf = new hyperspace_pb.Filter();
+        if (f.match) {
+            const m = new hyperspace_pb.Match();
+            m.setKey(f.match.key);
+            m.setValue(f.match.value);
+            pf.setMatch(m);
+        }
+        else if (f.prefix) {
+            const p = new hyperspace_pb.Prefix();
+            p.setKey(f.prefix.key);
+            p.setPrefix(f.prefix.prefix);
+            pf.setPrefix(p);
+        }
+        else if (f.range) {
+            const r = new hyperspace_pb.Range();
+            r.setKey(f.range.key);
+            if (f.range.gte !== undefined) {
+                if (Number.isInteger(f.range.gte))
+                    r.setGte(f.range.gte);
+                else
+                    r.setGteF64(f.range.gte);
+            }
+            if (f.range.lte !== undefined) {
+                if (Number.isInteger(f.range.lte))
+                    r.setLte(f.range.lte);
+                else
+                    r.setLteF64(f.range.lte);
+            }
+            pf.setRange(r);
+        }
+        else if (f.inCone) {
+            const c = new hyperspace_pb.InCone();
+            c.setAxesList(f.inCone.axes);
+            c.setAperturesList(f.inCone.apertures);
+            c.setCen(f.inCone.cen[0] || 0);
+            pf.setInCone(c);
+        }
+        else if (f.inBall) {
+            const b = new hyperspace_pb.InBall();
+            b.setCenterList(f.inBall.center);
+            b.setRadius(f.inBall.radius);
+            pf.setInBall(b);
+        }
+        else if (f.inBox) {
+            const b = new hyperspace_pb.InBox();
+            b.setMinBoundsList(f.inBox.minBounds);
+            b.setMaxBoundsList(f.inBox.maxBounds);
+            pf.setInBox(b);
+        }
+        else if (f.and) {
+            const andOp = new hyperspace_pb.FilterAnd();
+            andOp.setConditionsList(f.and.map(cond => this.toProtoFilter(cond)));
+            pf.setAndOp(andOp);
+        }
+        else if (f.or) {
+            const orOp = new hyperspace_pb.FilterOr();
+            orOp.setConditionsList(f.or.map(cond => this.toProtoFilter(cond)));
+            pf.setOrOp(orOp);
+        }
+        else if (f.not) {
+            const notOp = new hyperspace_pb.FilterNot();
+            notOp.setCondition(this.toProtoFilter(f.not));
+            pf.setNotOp(notOp);
+        }
+        return pf;
+    }
     constructor(host = 'localhost:50051', apiKey, userId) {
+        this.host = host;
+        this.apiKey = apiKey;
+        this.userId = userId;
         const options = {
             'grpc.max_send_message_length': 64 * 1024 * 1024,
             'grpc.max_receive_message_length': 64 * 1024 * 1024,
@@ -244,12 +314,30 @@ class HyperspaceClient {
         }
     }
     // ... (create/delete unchanged) ...
-    createCollection(name, dimension, metric) {
+    createCollection(name, schema) {
         return new Promise((resolve, reject) => {
             const req = new hyperspace_pb_1.CreateCollectionRequest();
             req.setName(name);
-            req.setDimension(dimension);
-            req.setMetric(metric);
+            const protoSchema = new hyperspace_pb.CollectionSchema();
+            const components = schema.components.map(c => {
+                const comp = new hyperspace_pb.VectorComponent();
+                comp.setName(c.name);
+                comp.setMetric(c.metric);
+                comp.setFullDimension(c.fullDimension);
+                comp.setWeight(c.weight);
+                return comp;
+            });
+            protoSchema.setComponentsList(components);
+            const pipeline = schema.cascadePipeline.map(l => {
+                const layer = new hyperspace_pb.MrlLayer();
+                layer.setComponentName(l.componentName);
+                layer.setCutoffDimension(l.cutoffDimension);
+                layer.setStoreInRam(l.storeInRam);
+                layer.setRerankTopK(l.rerankTopK);
+                return layer;
+            });
+            protoSchema.setCascadePipelineList(pipeline);
+            req.setSchema(protoSchema);
             this.client.createCollection(req, this.metadata, (err, resp) => {
                 if (err)
                     return reject(err);
@@ -268,22 +356,79 @@ class HyperspaceClient {
             });
         });
     }
+    freezeCollection(name) {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb.FreezeCollectionRequest();
+            req.setName(name);
+            this.client.freezeCollection(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp.getStatus());
+            });
+        });
+    }
+    unfreezeCollection(name) {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb.UnfreezeCollectionRequest();
+            req.setName(name);
+            this.client.unfreezeCollection(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp.getStatus());
+            });
+        });
+    }
     listCollections() {
         return new Promise((resolve, reject) => {
             const req = new hyperspace_pb_1.Empty();
             this.client.listCollections(req, this.metadata, (err, resp) => {
                 if (err)
                     return reject(err);
-                const list = resp.getCollectionsList().map(c => ({
-                    name: c.getName(),
-                    count: c.getCount(),
-                    dimension: c.getDimension(),
-                    metric: c.getMetric()
-                }));
+                const list = resp.getCollectionsList().map(c => {
+                    const info = {
+                        name: c.getName(),
+                        count: c.getCount()
+                    };
+                    const protoSchema = c.getSchema();
+                    if (protoSchema) {
+                        info.schema = {
+                            components: protoSchema.getComponentsList().map((comp) => ({
+                                name: comp.getName(),
+                                metric: comp.getMetric(),
+                                fullDimension: comp.getFullDimension(),
+                                weight: comp.getWeight()
+                            })),
+                            cascadePipeline: protoSchema.getCascadePipelineList().map((layer) => ({
+                                componentName: layer.getComponentName(),
+                                cutoffDimension: layer.getCutoffDimension(),
+                                storeInRam: layer.getStoreInRam(),
+                                rerankTopK: layer.getRerankTopK()
+                            }))
+                        };
+                    }
+                    return info;
+                });
                 resolve(list);
             });
         });
     }
+    getPoints(ids, collection = '') {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb_1.GetPointsRequest();
+            req.setCollection(collection);
+            req.setIdsList(ids);
+            this.client.getPoints(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                const points = resp.getPointsList().map((p) => ({
+                    id: p.getId(),
+                    vector: p.getVectorList(),
+                    metadata: p.getMetadataMap().toObject()
+                }));
+                resolve(points);
+            });
+        });
+    }
     delete(id, collection = '') {
         return new Promise((resolve, reject) => {
             const req = new hyperspace_pb.DeleteRequest();
@@ -296,7 +441,8 @@ class HyperspaceClient {
             });
         });
     }
-    insert(id, vector, meta, collection = '', durability = hyperspace_pb_1.DurabilityLevel.DEFAULT_LEVEL, typedMetadata) {
+    insert(id, vector, meta, collection = '', durability = hyperspace_pb_1.DurabilityLevel.DEFAULT_LEVEL, typedMetadata, payload // Sidecar Payload Storage (v3.2)
+    ) {
         return new Promise((resolve, reject) => {
             const req = new hyperspace_pb_1.InsertRequest();
             req.setVectorList(HyperspaceClient.toVectorList(vector));
@@ -315,6 +461,9 @@ class HyperspaceClient {
             req.setOriginNodeId('');
             req.setLogicalClock(0);
             req.setDurability(durability);
+            if (payload) {
+                req.setPayload(payload);
+            }
             this.client.insert(req, this.metadata, (err, resp) => {
                 if (err)
                     return reject(err);
@@ -388,43 +537,40 @@ class HyperspaceClient {
             req.setVectorList(HyperspaceClient.toVectorList(vector));
             req.setTopK(topK);
             req.setCollection(collection);
+            if (options === null || options === void 0 ? void 0 : options.filter) {
+                const map = req.getFilterMap();
+                for (const k in options.filter) {
+                    map.set(k, options.filter[k]);
+                }
+            }
+            if ((options === null || options === void 0 ? void 0 : options.restartFactor) !== undefined) {
+                const map = req.getFilterMap();
+                map.set('wave_restart_factor', options.restartFactor.toString());
+            }
+            if ((options === null || options === void 0 ? void 0 : options.useWave) !== undefined) {
+                req.setUseWave(options.useWave);
+            }
             if (options === null || options === void 0 ? void 0 : options.filters) {
-                const protoFilters = options.filters.map(f => {
-                    const pf = new hyperspace_pb.Filter();
-                    if (f.match) {
-                        const m = new hyperspace_pb.Match();
-                        m.setKey(f.match.key);
-                        m.setValue(f.match.value);
-                        pf.setMatch(m);
-                    }
-                    else if (f.range) {
-                        const r = new hyperspace_pb.Range();
-                        r.setKey(f.range.key);
-                        if (f.range.gte !== undefined) {
-                            if (Number.isInteger(f.range.gte))
-                                r.setGte(f.range.gte);
-                            else
-                                r.setGteF64(f.range.gte);
-                        }
-                        if (f.range.lte !== undefined) {
-                            if (Number.isInteger(f.range.lte))
-                                r.setLte(f.range.lte);
-                            else
-                                r.setLteF64(f.range.lte);
-                        }
-                        pf.setRange(r);
-                    }
-                    return pf;
-                });
-                req.setFiltersList(protoFilters);
+                req.setFiltersList(options.filters.map(f => this.toProtoFilter(f)));
             }
             if (options === null || options === void 0 ? void 0 : options.hybridQuery)
                 req.setHybridQuery(options.hybridQuery);
             if ((options === null || options === void 0 ? void 0 : options.hybridAlpha) !== undefined)
                 req.setHybridAlpha(options.hybridAlpha);
+            if ((options === null || options === void 0 ? void 0 : options.mrlDimension) !== undefined)
+                req.setMrlDimension(options.mrlDimension);
+            if ((options === null || options === void 0 ? void 0 : options.useWasserstein) !== undefined)
+                req.setUseWasserstein(options.useWasserstein);
+            if ((options === null || options === void 0 ? void 0 : options.includePayload) !== undefined)
+                req.setIncludePayload(options.includePayload);
+            if (options === null || options === void 0 ? void 0 : options.componentWeights) {
+                const map = req.getComponentWeightsMap();
+                for (const k in options.componentWeights) {
+                    map.set(k, options.componentWeights[k]);
+                }
+            }
             if (options === null || options === void 0 ? void 0 : options.bm25) {
-                // @ts-ignore: Bm25Options might not be in generated proto yet
-                const bm25Msg = new hyperspace_pb.Bm25Options();
+                const bm25Msg = new hyperspace_pb_1.Bm25Options();
                 if (options.bm25.method !== undefined)
                     bm25Msg.setMethod(options.bm25.method);
                 if (options.bm25.k1 !== undefined)
@@ -439,7 +585,6 @@ class HyperspaceClient {
                     bm25Msg.setNgrams(options.bm25.ngrams);
                 if (options.bm25.fusionMethod !== undefined)
                     bm25Msg.setFusionMethod(options.bm25.fusionMethod);
-                // @ts-ignore
                 req.setBm25Options(bm25Msg);
             }
             this.client.search(req, this.metadata, (err, resp) => {
@@ -457,7 +602,8 @@ class HyperspaceClient {
                         id: r.getId(),
                         distance: r.getDistance(),
                         metadata: meta,
-                        typedMetadata: HyperspaceClient.parseTypedMetadata(r.getTypedMetadataMap())
+                        typedMetadata: HyperspaceClient.parseTypedMetadata(r.getTypedMetadataMap()),
+                        payload: r.getPayload_asU8()
                     };
                 });
                 resolve(results);
@@ -471,38 +617,10 @@ class HyperspaceClient {
             req.setTopK(topK);
             req.setCollection(collection);
             if (options === null || options === void 0 ? void 0 : options.filters) {
-                const protoFilters = options.filters.map(f => {
-                    const pf = new hyperspace_pb.Filter();
-                    if (f.match) {
-                        const m = new hyperspace_pb.Match();
-                        m.setKey(f.match.key);
-                        m.setValue(f.match.value);
-                        pf.setMatch(m);
-                    }
-                    else if (f.range) {
-                        const r = new hyperspace_pb.Range();
-                        r.setKey(f.range.key);
-                        if (f.range.gte !== undefined) {
-                            if (Number.isInteger(f.range.gte))
-                                r.setGte(f.range.gte);
-                            else
-                                r.setGteF64(f.range.gte);
-                        }
-                        if (f.range.lte !== undefined) {
-                            if (Number.isInteger(f.range.lte))
-                                r.setLte(f.range.lte);
-                            else
-                                r.setLteF64(f.range.lte);
-                        }
-                        pf.setRange(r);
-                    }
-                    return pf;
-                });
-                req.setFiltersList(protoFilters);
+                req.setFiltersList(options.filters.map(f => this.toProtoFilter(f)));
             }
             if (options === null || options === void 0 ? void 0 : options.bm25) {
-                // @ts-ignore
-                const bm25Msg = new hyperspace_pb.Bm25Options();
+                const bm25Msg = new hyperspace_pb_1.Bm25Options();
                 if (options.bm25.method !== undefined)
                     bm25Msg.setMethod(options.bm25.method);
                 if (options.bm25.k1 !== undefined)
@@ -517,13 +635,14 @@ class HyperspaceClient {
                     bm25Msg.setNgrams(options.bm25.ngrams);
                 if (options.bm25.fusionMethod !== undefined)
                     bm25Msg.setFusionMethod(options.bm25.fusionMethod);
-                // @ts-ignore
                 req.setBm25Options(bm25Msg);
             }
             if ((options === null || options === void 0 ? void 0 : options.hybridAlpha) !== undefined) {
-                // @ts-ignore
                 req.setHybridAlpha(options.hybridAlpha);
             }
+            if ((options === null || options === void 0 ? void 0 : options.includePayload) !== undefined) {
+                req.setIncludePayload(options.includePayload);
+            }
             this.client.searchText(req, this.metadata, (err, resp) => {
                 if (err)
                     return reject(err);
@@ -539,7 +658,8 @@ class HyperspaceClient {
                         id: r.getId(),
                         distance: r.getDistance(),
                         metadata: meta,
-                        typedMetadata: HyperspaceClient.parseTypedMetadata(r.getTypedMetadataMap())
+                        typedMetadata: HyperspaceClient.parseTypedMetadata(r.getTypedMetadataMap()),
+                        payload: r.getPayload_asU8()
                     };
                 });
                 resolve(results);
@@ -571,7 +691,8 @@ class HyperspaceClient {
                         id: r.getId(),
                         distance: r.getDistance(),
                         metadata: meta,
-                        typedMetadata: HyperspaceClient.parseTypedMetadata(r.getTypedMetadataMap())
+                        typedMetadata: HyperspaceClient.parseTypedMetadata(r.getTypedMetadataMap()),
+                        payload: r.getPayload_asU8()
                     };
                 }));
                 resolve(batch);
@@ -722,34 +843,7 @@ class HyperspaceClient {
                 }
             }
             if (options === null || options === void 0 ? void 0 : options.filters) {
-                const protoFilters = options.filters.map(f => {
-                    const pf = new hyperspace_pb.Filter();
-                    if (f.match) {
-                        const m = new hyperspace_pb.Match();
-                        m.setKey(f.match.key);
-                        m.setValue(f.match.value);
-                        pf.setMatch(m);
-                    }
-                    else if (f.range) {
-                        const r = new hyperspace_pb.Range();
-                        r.setKey(f.range.key);
-                        if (f.range.gte !== undefined) {
-                            if (Number.isInteger(f.range.gte))
-                                r.setGte(f.range.gte);
-                            else
-                                r.setGteF64(f.range.gte);
-                        }
-                        if (f.range.lte !== undefined) {
-                            if (Number.isInteger(f.range.lte))
-                                r.setLte(f.range.lte);
-                            else
-                                r.setLteF64(f.range.lte);
-                        }
-                        pf.setRange(r);
-                    }
-                    return pf;
-                });
-                req.setFiltersList(protoFilters);
+                req.setFiltersList(options.filters.map(f => this.toProtoFilter(f)));
             }
             this.client.traverse(req, this.metadata, (err, resp) => {
                 if (err)
@@ -836,6 +930,251 @@ class HyperspaceClient {
         }
         return stream;
     }
+    getCollectionStats(name) {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb_1.CollectionStatsRequest();
+            req.setName(name);
+            this.client.getCollectionStats(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                const stats = {
+                    count: resp.getCount(),
+                    indexingQueue: resp.getIndexingQueue(),
+                    diskUsageBytes: resp.getDiskUsageBytes(),
+                    ramUsageBytes: resp.getRamUsageBytes(),
+                    activeTasks: resp.getActiveTasks()
+                };
+                const protoSchema = resp.getSchema();
+                if (protoSchema) {
+                    stats.schema = {
+                        components: protoSchema.getComponentsList().map((comp) => ({
+                            name: comp.getName(),
+                            metric: comp.getMetric(),
+                            fullDimension: comp.getFullDimension(),
+                            weight: comp.getWeight()
+                        })),
+                        cascadePipeline: protoSchema.getCascadePipelineList().map((layer) => ({
+                            componentName: layer.getComponentName(),
+                            cutoffDimension: layer.getCutoffDimension(),
+                            storeInRam: layer.getStoreInRam(),
+                            rerankTopK: layer.getRerankTopK()
+                        }))
+                    };
+                }
+                resolve(stats);
+            });
+        });
+    }
+    async exists(name) {
+        try {
+            await this.getCollectionStats(name);
+            return true;
+        }
+        catch (e) {
+            if (e.code === grpc.status.NOT_FOUND || (e.message && e.message.includes('not found'))) {
+                return false;
+            }
+            throw e;
+        }
+    }
+    async getCacheStats(name) {
+        const ip = this.host.split(':')[0];
+        const url = `http://${ip}:50050/api/collections/${name}/cache/stats`;
+        const headers = {};
+        if (this.apiKey)
+            headers['x-api-key'] = this.apiKey;
+        if (this.userId)
+            headers['x-hyperspace-user-id'] = this.userId;
+        const res = await fetch(url, { headers });
+        if (!res.ok) {
+            throw new Error(`Failed to get cache stats: ${res.statusText} (${await res.text()})`);
+        }
+        return res.json();
+    }
+    async clearCache(name) {
+        const ip = this.host.split(':')[0];
+        const url = `http://${ip}:50050/api/collections/${name}/cache/clear`;
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.apiKey)
+            headers['x-api-key'] = this.apiKey;
+        if (this.userId)
+            headers['x-hyperspace-user-id'] = this.userId;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({})
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to clear cache: ${res.statusText} (${await res.text()})`);
+        }
+        const data = await res.json();
+        return data.status === 'success';
+    }
+    async updateCacheConfig(name, policy, annThreshold) {
+        const ip = this.host.split(':')[0];
+        const url = `http://${ip}:50050/api/collections/${name}/cache/config`;
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.apiKey)
+            headers['x-api-key'] = this.apiKey;
+        if (this.userId)
+            headers['x-hyperspace-user-id'] = this.userId;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                policy,
+                ann_threshold: annThreshold
+            })
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to update cache config: ${res.statusText} (${await res.text()})`);
+        }
+        const data = await res.json();
+        return data.status === 'success';
+    }
+    updateCollection(name, config) {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb_1.ConfigUpdate();
+            req.setCollection(name);
+            if (config.efSearch !== undefined)
+                req.setEfSearch(config.efSearch);
+            if (config.efConstruction !== undefined)
+                req.setEfConstruction(config.efConstruction);
+            if (config.m !== undefined)
+                req.setM(config.m);
+            this.client.configure(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp.getStatus() === 'success' || (!!resp.getStatus() && resp.getStatus().includes('updated')));
+            });
+        });
+    }
+    createSnapshot() {
+        return new Promise((resolve, reject) => {
+            this.client.triggerSnapshot(new hyperspace_pb_1.Empty(), this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp.getStatus() === 'success');
+            });
+        });
+    }
+    vacuum() {
+        return new Promise((resolve, reject) => {
+            this.client.triggerVacuum(new hyperspace_pb_1.Empty(), this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp.getStatus() === 'success');
+            });
+        });
+    }
+    getMetrics(onData, onError) {
+        const req = new hyperspace_pb_1.MonitorRequest();
+        const stream = this.client.monitor(req, this.metadata);
+        stream.on('data', onData);
+        if (onError) {
+            stream.on('error', onError);
+        }
+        return stream;
+    }
+    searchMultiCollection(collections, query) {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb_1.SearchMultiCollectionRequest();
+            req.setCollectionsList(collections);
+            req.setVectorList(HyperspaceClient.toVectorList(query));
+            req.setTopK(10);
+            this.client.searchMultiCollection(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp.toObject());
+            });
+        });
+    }
+    triggerReconsolidation(collection, targetVector, learningRate = 0.01) {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb_1.ReconsolidationRequest();
+            req.setCollection(collection);
+            req.setTargetVectorList(targetVector);
+            req.setLearningRate(learningRate);
+            this.client.triggerReconsolidation(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp.getStatus() === 'success');
+            });
+        });
+    }
+    getSubsumptionTree(rootId, maxDepth = 3, collection = '') {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb.GetSubsumptionTreeRequest();
+            req.setRootId(rootId);
+            req.setMaxDepth(maxDepth);
+            req.setCollection(collection);
+            this.client.getSubsumptionTree(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                const nodes = resp.getNodesList().map((n) => ({
+                    id: n.getId(),
+                    metadata: n.getMetadataMap().toObject(),
+                    edgeTypes: n.getEdgeTypesList()
+                }));
+                resolve(nodes);
+            });
+        });
+    }
+    async exploreGraph(startId, maxDepth = 2, maxNodes = 256, collection = '') {
+        const req = new hyperspace_pb_1.TraverseRequest();
+        req.setStartId(startId);
+        req.setMaxDepth(maxDepth);
+        req.setMaxNodes(maxNodes);
+        req.setCollection(collection);
+        req.setTraversalMode(1); // DIFFUSIVE
+        req.setBreadthLimit(10);
+        return new Promise((resolve, reject) => {
+            this.client.traverse(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                const nodes = resp.getNodesList().map((n) => ({
+                    id: n.getId(),
+                    metadata: n.getMetadataMap().toObject(),
+                    edgeTypes: n.getEdgeTypesList(),
+                    neighbors: n.getNeighborsList()
+                }));
+                resolve({
+                    nodes,
+                    centerId: startId,
+                    count: nodes.length
+                });
+            });
+        });
+    }
+    async predictMomentum(trajectoryIds, steps = 1.0, collection = '', curvature = 1.0) {
+        if (trajectoryIds.length < 2)
+            return [];
+        const pts = await this.getPoints(trajectoryIds, collection);
+        const idToVec = new Map();
+        pts.forEach(p => idToVec.set(p.id, p.vector));
+        const vectors = trajectoryIds.map(id => idToVec.get(id)).filter(v => !!v);
+        if (vectors.length < 2)
+            return [];
+        const past = vectors[vectors.length - 2];
+        const current = vectors[vectors.length - 1];
+        const { koopmanExtrapolate } = require('./math');
+        return koopmanExtrapolate(past, current, steps, curvature);
+    }
+    async getTrustScore(trajectoryIds, collection = '', curvature = 1.0) {
+        const pts = await this.getPoints(trajectoryIds, collection);
+        const idToVec = new Map();
+        pts.forEach(p => idToVec.set(p.id, p.vector));
+        const vectors = trajectoryIds.map(id => idToVec.get(id)).filter(v => !!v);
+        if (vectors.length < 3)
+            return 0.0;
+        const { lyapunovConvergence } = require('./math');
+        try {
+            return lyapunovConvergence(vectors, curvature);
+        }
+        catch (e) {
+            return 1.0;
+        }
+    }
     close() {
         this.client.close();
     }