@wiscale/tauri-plugin-velesdb 1.15.0 → 1.18.0

package/LICENSE

@@ -0,0 +1,363 @@
+VelesDB Core License 1.0
+
+Based on the Elastic License 2.0 (ELv2) — Adapted for VelesDB Core
+
+Copyright (c) 2024-2026 Wiscale France. All rights reserved.
+
+VelesDB® is a registered trademark of Wiscale France.
+
+---
+
+## Acceptance
+
+By using the Software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The Licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license to use, copy, distribute, make available, and prepare derivative works of the Software, in each case subject to the limitations and conditions below.
+
+## Limitations
+
+### 1) No Hosted or Managed Service
+
+You may not provide the Software to third parties as a Hosted or Managed Service.
+
+A "Hosted or Managed Service" is any service where You (or a third party acting on Your behalf) host, operate, or make available the Software — directly or indirectly — to third parties who are provided access to a Substantial Set of the Software's features or functionality.
+
+This restriction includes, without limitation:
+
+- offering the Software as a cloud service, hosted service, managed service, or database-as-a-service (DBaaS),
+- operating the Software for third parties, including as a managed service provider (MSP), outsourcer, consultant, hosting provider, or service provider, even if provided to a single customer,
+- exposing the Software's query, administration, indexing, ingestion, storage, graph traversal, knowledge graph, columnar filtering, or management capabilities (or any substantially similar capabilities) to third parties through any interface, including but not limited to: APIs, SDKs, web interfaces, command lines, gateways, middleware, service layers, application wrappers, proxy layers, or any other programmatic or interactive mechanism.
+
+If third parties can store data in, query, manage collections or indexes, traverse or manage graph nodes and edges, filter structured data, administer schemas, or otherwise use the Software as a database, vector database, graph database, knowledge graph engine, columnar store, search engine, or query engine — whether directly or through any intermediary layer — this constitutes a Hosted or Managed Service and requires a separate commercial license from the Licensor.
+
+### 2) No Competitive Offering
+
+You may not use the Software to build, sell, offer, operate, or otherwise make commercially available any product or service that is Substantially Similar to the Software or that competes with the Software as:
+
+- a database,
+- a vector database,
+- a graph database or knowledge graph engine,
+- a columnar store or analytical engine,
+- a search engine,
+- a query engine, or
+- a hybrid search, retrieval, or multi-model data system.
+
+This restriction applies whether the product is offered as software, as a service, or as a component of a larger offering, and regardless of whether the Software's code is modified.
+
+This restriction does NOT prohibit:
+
+- internal use of the Software within your own organization,
+- integration of the Software as a backend component of your own product or service (provided end users receive only the results of your application and are not given access to the Software's core database capabilities),
+- use of the Software to power features such as search, retrieval, ranking, recommendations, or RAG within your own product.
+
+### 3) No Circumvention of Paid Features
+
+You may not move, change, disable, or circumvent any licensing mechanism or functionality that enforces paid features, and you may not remove or obscure any functionality in the Software that is protected by such licensing mechanism.
+
+### 4) No Removal of Notices; Trademarks
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices of the Licensor in the Software. Any use of the Licensor's trademarks is subject to applicable law.
+
+### 5) Benchmarking
+
+You may conduct and publish benchmarks of the Software, provided that any public disclosure of benchmark results includes all of the following:
+
+- the benchmarking methodology used,
+- the dataset(s) used (including size, type, and source),
+- the hardware configuration (CPU, RAM, storage, network),
+- the software version of VelesDB Core tested,
+- the full configuration of the Software as tested (including relevant parameters, tuning, and index settings),
+- any other software or tools used in the benchmark.
+
+The purpose of this requirement is transparency and reproducibility, not restriction. Benchmarks that omit this information may not be published or distributed publicly.
+
+## Redistribution
+
+### Attribution for Public-Facing Applications
+
+If You deploy or make publicly available an Application or Service that uses the Software as a component — including SaaS products, web applications, mobile applications, or browser-based applications — You must include a visible attribution notice containing a hyperlink to https://velesdb.com.
+
+**Placement:** The notice must appear in at least one location that is accessible to end users without requiring a separate action (e.g., not solely in source code or internal documentation). Acceptable placements include, but are not limited to:
+
+- a website footer or sidebar;
+- an application's About, Credits, or Settings page;
+- API documentation or developer portal;
+- a README or landing page for open-source projects that integrate the Software.
+
+**Format:** The notice may take any reasonable form, such as:
+
+- "Powered by [VelesDB](https://velesdb.com)"
+- "Built with [VelesDB](https://velesdb.com)"
+- The VelesDB logo (available at https://velesdb.com/brand) linking to https://velesdb.com
+
+The key requirement is a **clickable link to https://velesdb.com** that is visible to end users.
+
+**Exemptions:** This requirement does not apply to:
+- internal use within your organization;
+- development, testing, or staging environments;
+- holders of a VelesDB Enterprise or Premium license (which may include waived or alternative attribution terms — contact contact@wiscale.fr).
+
+Failure to comply with this attribution requirement constitutes a violation of this license.
+
+### Redistribution Terms
+
+You may redistribute the Software (in original or modified form), including through container images (e.g., Docker), installers, package managers (e.g., Homebrew, apt, cargo), infrastructure-as-code templates (e.g., Terraform, Helm), or any other distribution mechanism, provided that:
+
+1. a complete copy of this license is included with each distribution,
+2. all copyright and licensing notices in the Software are preserved and unmodified,
+3. the redistributed Software remains governed by this license (you may not relicense it under different terms),
+4. if modified, the distribution includes prominent notices stating that you have modified the Software, and
+5. redistribution does not grant recipients any right to provide the Software as a Hosted or Managed Service.
+
+For the avoidance of doubt, redistribution of the Software does not, by itself, constitute a Hosted or Managed Service, provided that the recipient operates the Software for its own internal use and not for the benefit of third parties.
+
+## Permitted Use (Clarification)
+
+You may use the Software in production, including for commercial purposes, and you may embed or integrate the Software into your own products and services, provided that:
+
+- the Software is used only as an internal component of your product or service, and
+- your end users are not provided access to a Substantial Set of the Software's features or functionality.
+
+For example, it is permitted to use the Software internally to power features such as:
+
+- search and retrieval,
+- retrieval-augmented generation (RAG),
+- ranking and recommendations,
+- document indexing and similarity matching,
+- knowledge graph traversal and relationship discovery,
+- structured data filtering and analytics,
+- any other feature where end users receive only the results produced by your application and do not receive access to the Software itself.
+
+**Embedded and local-first use.** The Software is designed to run as an embedded database (in-process, WASM, mobile, desktop, or server). Using the Software in embedded mode within your own application — including in browser-based (WASM), mobile (iOS/Android), desktop (Tauri), or server-side deployments — is expressly permitted under this license, provided the Software serves only as an internal component and end users do not receive direct access to the Software's database capabilities.
+
+## Business Model Clarification
+
+The Licensor offers the Software under a multi-tier model:
+
+- **VelesDB Core** — available under this license (source-available, free for permitted use).
+- **VelesDB Enterprise** — available under a separate commercial license for advanced features, support, and use cases not permitted under this license.
+- **VelesDB Cloud** — the Licensor's proprietary managed database service.
+
+Any use of the Software as a Hosted or Managed Service, as a Competitive Offering, or in any other manner not permitted by this license requires a separate **Enterprise** or **Premium** commercial license from the Licensor.
+
+## Examples (Non-Normative)
+
+### Allowed under this license
+
+- Your application uses VelesDB Core internally to power search, retrieval, or RAG, and customers cannot create or manage collections, indexes, or databases, nor run arbitrary queries against VelesDB Core.
+- You distribute VelesDB Core bundled with a desktop, mobile, or on-premise application for the customer's own internal use.
+- You use VelesDB Core as a backend for your SaaS product, where end users interact only with your application's interface and receive only processed results.
+- You publish benchmark results comparing VelesDB Core to other databases, with full methodology disclosure.
+- You redistribute VelesDB Core via Docker Hub, a package manager, or an infrastructure template, with this license included.
+
+### Requires a commercial (Enterprise/Premium) license
+
+- Offering VelesDB Core (or a derivative) as a hosted, managed, or cloud database service (DBaaS), regardless of whether it is branded as "VelesDB" or under a different name.
+- Operating VelesDB Core for a customer as a managed service provider, outsourcer, or consultant, where the customer has access to the Software's core capabilities.
+- Building and selling a product that competes with VelesDB as a vector database, search engine, or query engine.
+- A cloud provider offering VelesDB as a managed database, managed cluster, hosted indexing/query platform, or vector database as a service.
+- A multi-tenant service where tenants have access to the Software's database-like capabilities (collections, indexes, schemas, queries, ingestion).
+- Any service — regardless of the interface layer or branding — where third parties can effectively use the Software as a database.
+
+## Patents
+
+The Licensor grants you a license, under any patent claims the Licensor can license, or becomes able to license, to make, have made, use, sell, offer for sale, import and have imported the Software, in each case subject to the limitations and conditions in this license.
+
+This license does not cover any patent claims that you cause to be infringed by modifications or additions to the Software.
+
+If you or your company make any written claim that the Software infringes or contributes to infringement of any patent, your patent license for the Software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the Software from you also gets a copy of these terms.
+
+If you modify the Software, you must include in any modified copies of the Software prominent notices stating that you have modified the Software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in these terms.
+
+## Termination
+
+If you use the Software in violation of these terms, such use is not licensed, and your licenses will automatically terminate.
+
+If the Licensor provides you with a notice of your violation, and you cease all violation of this license no later than 30 days after you receive that notice, your licenses will be reinstated retroactively. However, if you violate these terms after such reinstatement, any additional violation of these terms will cause your licenses to terminate automatically and permanently.
+
+## No Liability
+
+As far as the law allows, the Software comes as is, without any warranty or condition, and the Licensor will not be liable to you for any damages arising out of these terms or the use or nature of the Software, under any kind of legal claim.
+
+## Definitions
+
+The **"Licensor"** is Wiscale France.
+
+The **"Software"** is the software the Licensor makes available under these terms, including VelesDB Core and all associated components, libraries, tools, and documentation.
+
+The **"Author"** is Julien Lange.
+
+**"You"** refers to the individual or entity agreeing to these terms.
+
+**"Your company"** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. "Control" means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect.
+
+**"Your licenses"** are all the licenses granted to you for the Software under these terms.
+
+**"Use"** means anything you do with the Software requiring one of your licenses.
+
+**"Hosted or Managed Service"** means any service, platform, or offering where You (or a third party acting on Your behalf) host, operate, or make available the Software for third parties, and those third parties are provided with access — directly or indirectly — to a Substantial Set of the Software's features or functionality. Access includes, without limitation, access through any of the following: APIs, SDKs, web interfaces, command lines, gateways, middleware, service layers, application wrappers, proxy layers, webhooks, message queues, or any other programmatic or interactive mechanism that enables third parties to create, manage, query, administer, index, ingest, store, traverse graphs, manage knowledge graph nodes or edges, filter structured data, or otherwise use the Software's core database, vector, graph, columnar, or hybrid capabilities.
+
+**"Substantial Set of features or functionality"** means access to features or functionality that, taken together, would reasonably allow a third party to use the Software as a general-purpose database, vector database, graph database, knowledge graph engine, columnar store, search engine, query engine, or hybrid/multi-model data system, or as a replacement for the Software, rather than merely receiving the results of your product's or application's features.
+
+**"Substantially Similar"** means a product or service that provides database, vector database, graph database, knowledge graph, columnar store, search engine, query engine, hybrid search, or multi-model data capabilities that overlap in purpose and function with the core capabilities of the Software to a degree that would reasonably be considered competitive. A product is not Substantially Similar merely because it uses the Software internally as a component.
+
+**"Competitive Offering"** means any product or service that is Substantially Similar to the Software and is made commercially available to third parties, whether as software, as a service, or as a component of a larger offering.
+
+**"Cloud Provider"** means any entity that provides cloud computing infrastructure, platform, or software services to third parties, including (without limitation) infrastructure-as-a-service (IaaS), platform-as-a-service (PaaS), and software-as-a-service (SaaS) providers.
+
+---
+
+## Licensing FAQ (VelesDB Core License 1.0)
+
+This FAQ is provided for convenience and developer guidance only. It does not replace, modify, or supplement the license terms above. In case of any conflict, the license terms prevail. If in doubt, contact the Licensor (Wiscale France — contact@wiscale.fr).
+
+### 1) Can I use VelesDB Core in production?
+
+**Yes.** Production use is permitted, including commercial production use, as long as you comply with the license limitations (no Hosted or Managed Service, no Competitive Offering).
+
+### 2) Can I use VelesDB Core inside my own SaaS product?
+
+**Yes.** If VelesDB Core is used only as an internal component of your SaaS and your customers interact only with your application's interface (not with VelesDB directly), this is permitted.
+
+In practice: your customers can use your app's features (search, RAG, recommendations, etc.), but they cannot create collections, manage indexes, run arbitrary queries, or otherwise use VelesDB as a database product.
+
+### 3) Can I use VelesDB Core as a backend for a RAG system?
+
+**Yes.** Using VelesDB Core to index documents, store embeddings, and retrieve results for a RAG pipeline is a typical permitted use case, as long as end users receive only the generated answers from your application and do not have direct database access.
+
+### 4) What is NOT allowed without a commercial license?
+
+- Offering VelesDB Core (or a derivative) as a hosted or managed database service (DBaaS, vector DB as a service, managed cluster, etc.).
+- Operating VelesDB Core for a customer as an MSP, outsourcer, or consultant where the customer has access to VelesDB's core capabilities.
+- Building and selling a competing database, vector database, search engine, or query engine based on VelesDB Core.
+- A cloud provider (e.g., AWS, GCP, Azure, or any other) offering VelesDB as a managed database service.
+
+If you want to do any of the above, you need an **Enterprise or Premium license**.
+
+### 5) Can I expose a public API endpoint that runs vector search against VelesDB Core?
+
+**It depends:**
+
+- **Allowed:** You expose an endpoint like `/search` or `/recommend` that returns results for your product, without giving customers the ability to create/manage collections, ingest vectors, manage indexes, run arbitrary queries, or administer the database.
+- **Not allowed without a commercial license:** You expose VelesDB-like capabilities (collections, ingestion, indexing, querying, admin) to third parties in a way that makes your service effectively "VelesDB as a service."
+
+### 6) Can I let my customers upload documents, and I index them in VelesDB Core for RAG?
+
+**Yes.** As long as customers are using your product's document upload feature and are not given direct access to VelesDB's database capabilities (no collection management, no arbitrary queries, no index administration).
+
+### 7) Can a cloud provider offer VelesDB as a managed service?
+
+**No, not under this license.** Cloud providers (or any third party) offering VelesDB as a managed database, DBaaS, managed cluster, hosted indexing/query platform, or vector database as a service must obtain a commercial license from Wiscale France.
+
+### 8) Can an agency, consultant, or MSP host VelesDB Core for a client?
+
+**Not under this license** if the arrangement constitutes a Hosted or Managed Service (including single-customer managed hosting where the client has access to VelesDB's core capabilities). That scenario requires a commercial license.
+
+### 9) Can I embed VelesDB Core in a desktop, mobile, or on-prem product I sell?
+
+**Yes.** Distributing VelesDB Core bundled with your product is permitted, provided you comply with the license (include the license text and notices), and you are not providing it as a Hosted or Managed Service.
+
+### 10) Can I modify VelesDB Core and keep my changes private?
+
+**Yes.** The license allows modification. If you distribute a modified version, you must include prominent notices stating that you modified it, and you must provide a copy of the license terms to recipients.
+
+### 11) Can I redistribute VelesDB Core?
+
+**Yes.** You may redistribute the Software (as-is or modified) through any mechanism (Docker, package managers, Helm charts, etc.), provided:
+
+- the license text is included,
+- copyright notices are preserved,
+- the software remains under this license,
+- if modified, modifications are prominently marked.
+
+Redistribution does not grant recipients any right to provide the Software as a Hosted or Managed Service.
+
+### 12) Can I publish benchmarks of VelesDB Core?
+
+**Yes.** You are encouraged to benchmark VelesDB Core. However, public benchmark results must include full disclosure of methodology, dataset, hardware, software version, and configuration. This ensures transparency and reproducibility.
+
+### 13) Can I build a competing database product using VelesDB Core?
+
+**No.** The No Competitive Offering clause prohibits using the Software to build, sell, or offer a product that competes with VelesDB as a database, vector database, graph database, columnar store, search engine, or query engine.
+
+However, using VelesDB Core as an internal component of a non-competing product (e.g., a CRM, an e-commerce platform, a content management system) is permitted.
+
+### 14) Can I remove license headers or copyright notices?
+
+**No.** You may not alter, remove, or obscure licensing, copyright, or other notices.
+
+### 15) Can I use the name "VelesDB" for my fork?
+
+**No.** VelesDB® is a registered trademark of Wiscale France. You may not brand your fork, derivative work, or product as "VelesDB" without written permission from Wiscale France. Use of the VelesDB name or logo is subject to applicable trademark law.
+
+### 16) What about a multi-tenant service where each tenant only has limited features?
+
+If tenants (third parties) get access to a Substantial Set of VelesDB's database, vector database, or query capabilities, it is a Hosted or Managed Service and requires a commercial license, regardless of the number of features exposed per tenant.
+
+### 17) What if my service wraps VelesDB behind an API gateway or middleware?
+
+The license explicitly covers indirect access through APIs, SDKs, gateways, middleware, service layers, and application wrappers. If the end result is that third parties can use the Software as a database — regardless of how many layers sit between them and VelesDB — a commercial license is required.
+
+### 18) What if I'm unsure whether my use case is permitted?
+
+**Ask.** Contact Wiscale France (contact@wiscale.fr) for clarification or to discuss a commercial license. We want developers to build great things with VelesDB — we're happy to help you find the right license for your use case.
+
+### 19) How do I get an Enterprise or Premium license?
+
+Contact Wiscale France (contact@wiscale.fr) to discuss licensing for hosted/managed services, Competitive Offerings, cloud provider partnerships, and other premium use cases.
+
+### 20) What is the difference between VelesDB Core, Enterprise, and Cloud?
+
+| Tier | License | Use Case |
+|------|---------|----------|
+| **VelesDB Core** | This license (source-available) | Internal use, embedding, SaaS backend, development, testing |
+| **VelesDB Enterprise** | Commercial license | Advanced features, support, hosted/managed services, competitive offerings |
+| **VelesDB Cloud** | Proprietary SaaS | Fully managed database service operated by Wiscale France |
+
+### 21) Can I use VelesDB's graph engine and knowledge graph features in my product?
+
+**Yes.** You can use the vector, graph, columnar, and hybrid search features internally within your product. The restriction applies only if you expose those capabilities directly to third parties as a database service, or if you build a competing graph/vector/search product.
+
+### 22) Can I embed VelesDB in a browser (WASM), mobile app, or Tauri desktop app?
+
+**Yes.** Embedded and local-first use is expressly permitted. VelesDB is designed to run in-process (WASM, iOS, Android, Tauri, server). As long as the Software serves as an internal component of your application, this is a permitted use.
+
+### 23) Does the license cover the premium features (Hybrid Search, RBAC, SSO, etc.)?
+
+The VelesDB Core license covers VelesDB Core. Premium features (such as RBAC, SSO, GPU Acceleration, Audit Logging, Multi-Tenancy, Encryption at Rest, and Snapshots) are available under VelesDB Enterprise with a separate commercial license. You may not circumvent the licensing mechanism that enforces premium features.
+
+### 24) Can I use VelesDB Core's VelesQL query language in my product?
+
+**Yes.** Using VelesQL to query data internally within your product is permitted. However, exposing a general-purpose VelesQL endpoint to third parties (allowing them to run arbitrary queries) would constitute providing access to a Substantial Set of the Software's capabilities and is not permitted without a commercial license.
+
+### 25) Do I need to display "Powered by VelesDB" on my website or app?
+
+**Yes, if your app is public.** Include a link to velesdb.com somewhere visible — footer, About page, credits, or docs. That's it. No specific size, color, or position required. Just a clickable link that users can find.
+
+Want to remove it? An Enterprise license waives the attribution requirement.
+
+### 26) What counts as a "public-facing application"?
+
+Anything accessible by people outside your organization: a SaaS product, a public website, a mobile app on app stores, a public API. Internal tools and staging environments don't count.
+
+### 27) Can I use the VelesDB logo instead of text?
+
+**Yes.** Logo or text, your choice — as long as it links to velesdb.com. Brand assets are at https://velesdb.com/brand.
+
+---
+
+## Trademark Notice
+
+VelesDB® is a registered trademark of Wiscale France. All rights reserved.
+
+Use of the VelesDB name, logo, or brand assets is subject to applicable trademark law. You may not use the VelesDB name or logo to imply endorsement, affiliation, or sponsorship by Wiscale France without prior written permission. Forks and derivative works must not be branded as "VelesDB" without explicit authorization from Wiscale France.

package/dist/index.d.mts

@@ -511,7 +511,7 @@ declare function deletePoints(request: DeletePointsRequest): Promise<void>;
  *   collection: 'documents',
  *   searches: [
  *     { vector: embedding1, topK: 5 },
- *     { vector: embedding2, topK: 10, filter: { category: 'tech' } }
+ *     { vector: embedding2, topK: 10, filter: { condition: { type: 'eq', field: 'category', value: 'tech' } } }
  *   ]
  * });
  * responses.forEach((resp, i) => {
@@ -873,5 +873,184 @@ declare function proceduralLearn(request: ProceduralLearnRequest): Promise<void>
  * @returns Array of matching procedures
  */
 declare function proceduralRecall(request: ProceduralRecallRequest): Promise<ProceduralMatchResult[]>;
+/** Request for sparse-only vector search. */
+interface SparseSearchRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Sparse vector as `{ "<dimIndex>": weight, ... }`. */
+    sparseVector: Record<string, number>;
+    /** Number of results to return. Default: 10. */
+    topK?: number;
+    /** Optional named sparse index to query. */
+    indexName?: string;
+}
+/** Request for hybrid dense + sparse search. */
+interface HybridSparseSearchRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Dense query vector. */
+    vector: number[];
+    /** Sparse vector as `{ "<dimIndex>": weight, ... }`. */
+    sparseVector: Record<string, number>;
+    /** Number of results to return. Default: 10. */
+    topK?: number;
+}
+/** A {@link PointInput} carrying an optional sparse vector. */
+interface SparsePointInput extends PointInput {
+    /** Optional sparse vector as `{ "<dimIndex>": weight, ... }`. */
+    sparseVector?: Record<string, number>;
+}
+/** Request to upsert points with optional sparse vectors. */
+interface SparseUpsertRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Points to insert or update. */
+    points: SparsePointInput[];
+}
+/**
+ * Searches a collection using a sparse vector (inverted-index retrieval).
+ *
+ * @param request - Sparse query parameters
+ * @returns Search results ordered by relevance
+ * @throws {CommandError} If the collection does not exist
+ *
+ * @example
+ * ```typescript
+ * const res = await sparseSearch({
+ *   collection: 'docs',
+ *   sparseVector: { '12': 0.8, '57': 0.6 },
+ *   topK: 10,
+ * });
+ * ```
+ */
+declare function sparseSearch(request: SparseSearchRequest): Promise<SearchResponse>;
+/**
+ * Searches a collection using both a dense and a sparse vector, fusing results.
+ *
+ * @param request - Hybrid dense + sparse query parameters
+ * @returns Fused search results ordered by relevance
+ * @throws {CommandError} If the collection does not exist
+ */
+declare function hybridSparseSearch(request: HybridSparseSearchRequest): Promise<SearchResponse>;
+/**
+ * Upserts points with optional sparse vectors for hybrid retrieval.
+ *
+ * @param request - Points to insert or update
+ * @returns Number of points written
+ * @throws {CommandError} On dimension mismatch or write failure
+ */
+declare function sparseUpsert(request: SparseUpsertRequest): Promise<number>;
+/** Request to train a Product Quantizer over a collection's vectors. */
+interface TrainPqRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Number of sub-quantizers. */
+    m?: number;
+    /** Number of centroids per sub-quantizer. */
+    k?: number;
+    /** Whether to use Optimized Product Quantization (OPQ). */
+    opq?: boolean;
+}
+/**
+ * Trains a Product Quantizer on the collection's existing vectors.
+ *
+ * @param request - PQ training parameters
+ * @returns A human-readable training summary
+ * @throws {CommandError} If the collection has too few vectors to train
+ */
+declare function trainPq(request: TrainPqRequest): Promise<string>;
+/** Request to stream-insert points (requires the `persistence` feature). */
+interface StreamInsertRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Points to stream-insert. */
+    points: PointInput[];
+}
+/**
+ * Streams a batch of points into a collection for high-throughput ingestion.
+ *
+ * Only available when the plugin is built with the `persistence` feature.
+ *
+ * @param request - Points to stream-insert
+ * @returns Number of points written
+ * @throws {CommandError} If persistence is disabled or the write fails
+ */
+declare function streamInsert(request: StreamInsertRequest): Promise<number>;
+/** Request to create a secondary index on a metadata field. */
+interface CreateIndexRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Metadata field name to index. */
+    fieldName: string;
+}
+/** Request to drop a secondary index on a metadata field. */
+interface DropIndexRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Metadata field name whose index to drop. */
+    fieldName: string;
+}
+/** Request to list secondary indexes on a collection. */
+interface ListIndexesRequest {
+    /** Target collection name. */
+    collection: string;
+}
+/** A single secondary index entry. */
+interface IndexInfoOutput {
+    /** Node label (or field name for secondary indexes). */
+    label: string;
+    /** Property name. */
+    property: string;
+    /** Index type (`hash`, `range`, or `secondary`). */
+    indexType: string;
+    /** Number of unique values indexed. */
+    cardinality: number;
+    /** Memory usage in bytes. */
+    memoryBytes: number;
+}
+/**
+ * Creates a secondary index on a metadata field for faster filtered search.
+ *
+ * @param request - Index target
+ * @throws {CommandError} If the collection does not exist
+ */
+declare function createIndex(request: CreateIndexRequest): Promise<void>;
+/**
+ * Drops a secondary index on a metadata field.
+ *
+ * @param request - Index target
+ * @returns `true` if an index was removed, `false` if none existed
+ * @throws {CommandError} If the collection does not exist
+ */
+declare function dropIndex(request: DropIndexRequest): Promise<boolean>;
+/**
+ * Lists all secondary indexes on a collection.
+ *
+ * @param request - Target collection
+ * @returns Array of index descriptors
+ * @throws {CommandError} If the collection does not exist
+ */
+declare function listIndexes(request: ListIndexesRequest): Promise<IndexInfoOutput[]>;
+/** Request for multi-source parallel BFS traversal. */
+interface TraverseGraphParallelRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Source node IDs to start traversal from. */
+    sources: number[];
+    /** Maximum traversal depth. Default: 3. */
+    maxDepth?: number;
+    /** Maximum results to return. Default: 100. */
+    limit?: number;
+    /** Optional relationship types to follow. */
+    relTypes?: string[];
+}
+/**
+ * Runs a multi-source parallel BFS traversal over a graph collection.
+ *
+ * @param request - Parallel traversal parameters
+ * @returns Array of traversal result nodes
+ * @throws {CommandError} If the collection is not a graph collection
+ */
+declare function traverseGraphParallel(request: TraverseGraphParallelRequest): Promise<TraversalOutput[]>;
 
-export { type AddEdgeRequest, type BatchSearchRequest, type CollectionInfo, type CommandError, type CreateCollectionRequest, type CreateGraphCollectionRequest, type CreateMetadataCollectionRequest, type DeletePointsRequest, type DistanceMetric, type EdgeOutput, type EpisodicRecentRequest, type EpisodicRecordRequest, type EpisodicResult, type FusionParams, type FusionStrategy, type GetEdgesRequest, type GetNodeDegreeRequest, type GetPointsRequest, type HybridResult, type HybridSearchRequest, type IndividualSearchRequest, type MetadataPointInput, type MultiQuerySearchRequest, type NodeDegreeOutput, type PointInput, type PointOutput, type ProceduralLearnRequest, type ProceduralMatchResult, type ProceduralRecallRequest, type QueryRequest, type QueryResponse, type ScrollRequest, type ScrollResponse, type SearchRequest, type SearchResponse, type SearchResult, type SemanticQueryRequest, type SemanticQueryResult, type SemanticStoreRequest, type StorageMode, type TextSearchRequest, type TraversalOutput, type TraverseGraphRequest, type UpsertMetadataRequest, type UpsertRequest, addEdge, batchSearch, createCollection, createGraphCollection, createMetadataCollection, deleteCollection, deletePoints, episodicRecent, episodicRecord, flush, getCollection, getEdges, getNodeDegree, getPoints, hybridSearch, isEmpty, listCollections, multiQuerySearch, proceduralLearn, proceduralRecall, query, scrollCollection, search, semanticQuery, semanticStore, textSearch, traverseGraph, upsert, upsertMetadata };
+export { type AddEdgeRequest, type BatchSearchRequest, type CollectionInfo, type CommandError, type CreateCollectionRequest, type CreateGraphCollectionRequest, type CreateIndexRequest, type CreateMetadataCollectionRequest, type DeletePointsRequest, type DistanceMetric, type DropIndexRequest, type EdgeOutput, type EpisodicRecentRequest, type EpisodicRecordRequest, type EpisodicResult, type FusionParams, type FusionStrategy, type GetEdgesRequest, type GetNodeDegreeRequest, type GetPointsRequest, type HybridResult, type HybridSearchRequest, type HybridSparseSearchRequest, type IndexInfoOutput, type IndividualSearchRequest, type ListIndexesRequest, type MetadataPointInput, type MultiQuerySearchRequest, type NodeDegreeOutput, type PointInput, type PointOutput, type ProceduralLearnRequest, type ProceduralMatchResult, type ProceduralRecallRequest, type QueryRequest, type QueryResponse, type ScrollRequest, type ScrollResponse, type SearchRequest, type SearchResponse, type SearchResult, type SemanticQueryRequest, type SemanticQueryResult, type SemanticStoreRequest, type SparsePointInput, type SparseSearchRequest, type SparseUpsertRequest, type StorageMode, type StreamInsertRequest, type TextSearchRequest, type TrainPqRequest, type TraversalOutput, type TraverseGraphParallelRequest, type TraverseGraphRequest, type UpsertMetadataRequest, type UpsertRequest, addEdge, batchSearch, createCollection, createGraphCollection, createIndex, createMetadataCollection, deleteCollection, deletePoints, dropIndex, episodicRecent, episodicRecord, flush, getCollection, getEdges, getNodeDegree, getPoints, hybridSearch, hybridSparseSearch, isEmpty, listCollections, listIndexes, multiQuerySearch, proceduralLearn, proceduralRecall, query, scrollCollection, search, semanticQuery, semanticStore, sparseSearch, sparseUpsert, streamInsert, textSearch, trainPq, traverseGraph, traverseGraphParallel, upsert, upsertMetadata };

package/dist/index.d.ts

@@ -511,7 +511,7 @@ declare function deletePoints(request: DeletePointsRequest): Promise<void>;
  *   collection: 'documents',
  *   searches: [
  *     { vector: embedding1, topK: 5 },
- *     { vector: embedding2, topK: 10, filter: { category: 'tech' } }
+ *     { vector: embedding2, topK: 10, filter: { condition: { type: 'eq', field: 'category', value: 'tech' } } }
  *   ]
  * });
  * responses.forEach((resp, i) => {
@@ -873,5 +873,184 @@ declare function proceduralLearn(request: ProceduralLearnRequest): Promise<void>
  * @returns Array of matching procedures
  */
 declare function proceduralRecall(request: ProceduralRecallRequest): Promise<ProceduralMatchResult[]>;
+/** Request for sparse-only vector search. */
+interface SparseSearchRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Sparse vector as `{ "<dimIndex>": weight, ... }`. */
+    sparseVector: Record<string, number>;
+    /** Number of results to return. Default: 10. */
+    topK?: number;
+    /** Optional named sparse index to query. */
+    indexName?: string;
+}
+/** Request for hybrid dense + sparse search. */
+interface HybridSparseSearchRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Dense query vector. */
+    vector: number[];
+    /** Sparse vector as `{ "<dimIndex>": weight, ... }`. */
+    sparseVector: Record<string, number>;
+    /** Number of results to return. Default: 10. */
+    topK?: number;
+}
+/** A {@link PointInput} carrying an optional sparse vector. */
+interface SparsePointInput extends PointInput {
+    /** Optional sparse vector as `{ "<dimIndex>": weight, ... }`. */
+    sparseVector?: Record<string, number>;
+}
+/** Request to upsert points with optional sparse vectors. */
+interface SparseUpsertRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Points to insert or update. */
+    points: SparsePointInput[];
+}
+/**
+ * Searches a collection using a sparse vector (inverted-index retrieval).
+ *
+ * @param request - Sparse query parameters
+ * @returns Search results ordered by relevance
+ * @throws {CommandError} If the collection does not exist
+ *
+ * @example
+ * ```typescript
+ * const res = await sparseSearch({
+ *   collection: 'docs',
+ *   sparseVector: { '12': 0.8, '57': 0.6 },
+ *   topK: 10,
+ * });
+ * ```
+ */
+declare function sparseSearch(request: SparseSearchRequest): Promise<SearchResponse>;
+/**
+ * Searches a collection using both a dense and a sparse vector, fusing results.
+ *
+ * @param request - Hybrid dense + sparse query parameters
+ * @returns Fused search results ordered by relevance
+ * @throws {CommandError} If the collection does not exist
+ */
+declare function hybridSparseSearch(request: HybridSparseSearchRequest): Promise<SearchResponse>;
+/**
+ * Upserts points with optional sparse vectors for hybrid retrieval.
+ *
+ * @param request - Points to insert or update
+ * @returns Number of points written
+ * @throws {CommandError} On dimension mismatch or write failure
+ */
+declare function sparseUpsert(request: SparseUpsertRequest): Promise<number>;
+/** Request to train a Product Quantizer over a collection's vectors. */
+interface TrainPqRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Number of sub-quantizers. */
+    m?: number;
+    /** Number of centroids per sub-quantizer. */
+    k?: number;
+    /** Whether to use Optimized Product Quantization (OPQ). */
+    opq?: boolean;
+}
+/**
+ * Trains a Product Quantizer on the collection's existing vectors.
+ *
+ * @param request - PQ training parameters
+ * @returns A human-readable training summary
+ * @throws {CommandError} If the collection has too few vectors to train
+ */
+declare function trainPq(request: TrainPqRequest): Promise<string>;
+/** Request to stream-insert points (requires the `persistence` feature). */
+interface StreamInsertRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Points to stream-insert. */
+    points: PointInput[];
+}
+/**
+ * Streams a batch of points into a collection for high-throughput ingestion.
+ *
+ * Only available when the plugin is built with the `persistence` feature.
+ *
+ * @param request - Points to stream-insert
+ * @returns Number of points written
+ * @throws {CommandError} If persistence is disabled or the write fails
+ */
+declare function streamInsert(request: StreamInsertRequest): Promise<number>;
+/** Request to create a secondary index on a metadata field. */
+interface CreateIndexRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Metadata field name to index. */
+    fieldName: string;
+}
+/** Request to drop a secondary index on a metadata field. */
+interface DropIndexRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Metadata field name whose index to drop. */
+    fieldName: string;
+}
+/** Request to list secondary indexes on a collection. */
+interface ListIndexesRequest {
+    /** Target collection name. */
+    collection: string;
+}
+/** A single secondary index entry. */
+interface IndexInfoOutput {
+    /** Node label (or field name for secondary indexes). */
+    label: string;
+    /** Property name. */
+    property: string;
+    /** Index type (`hash`, `range`, or `secondary`). */
+    indexType: string;
+    /** Number of unique values indexed. */
+    cardinality: number;
+    /** Memory usage in bytes. */
+    memoryBytes: number;
+}
+/**
+ * Creates a secondary index on a metadata field for faster filtered search.
+ *
+ * @param request - Index target
+ * @throws {CommandError} If the collection does not exist
+ */
+declare function createIndex(request: CreateIndexRequest): Promise<void>;
+/**
+ * Drops a secondary index on a metadata field.
+ *
+ * @param request - Index target
+ * @returns `true` if an index was removed, `false` if none existed
+ * @throws {CommandError} If the collection does not exist
+ */
+declare function dropIndex(request: DropIndexRequest): Promise<boolean>;
+/**
+ * Lists all secondary indexes on a collection.
+ *
+ * @param request - Target collection
+ * @returns Array of index descriptors
+ * @throws {CommandError} If the collection does not exist
+ */
+declare function listIndexes(request: ListIndexesRequest): Promise<IndexInfoOutput[]>;
+/** Request for multi-source parallel BFS traversal. */
+interface TraverseGraphParallelRequest {
+    /** Target collection name. */
+    collection: string;
+    /** Source node IDs to start traversal from. */
+    sources: number[];
+    /** Maximum traversal depth. Default: 3. */
+    maxDepth?: number;
+    /** Maximum results to return. Default: 100. */
+    limit?: number;
+    /** Optional relationship types to follow. */
+    relTypes?: string[];
+}
+/**
+ * Runs a multi-source parallel BFS traversal over a graph collection.
+ *
+ * @param request - Parallel traversal parameters
+ * @returns Array of traversal result nodes
+ * @throws {CommandError} If the collection is not a graph collection
+ */
+declare function traverseGraphParallel(request: TraverseGraphParallelRequest): Promise<TraversalOutput[]>;
 
-export { type AddEdgeRequest, type BatchSearchRequest, type CollectionInfo, type CommandError, type CreateCollectionRequest, type CreateGraphCollectionRequest, type CreateMetadataCollectionRequest, type DeletePointsRequest, type DistanceMetric, type EdgeOutput, type EpisodicRecentRequest, type EpisodicRecordRequest, type EpisodicResult, type FusionParams, type FusionStrategy, type GetEdgesRequest, type GetNodeDegreeRequest, type GetPointsRequest, type HybridResult, type HybridSearchRequest, type IndividualSearchRequest, type MetadataPointInput, type MultiQuerySearchRequest, type NodeDegreeOutput, type PointInput, type PointOutput, type ProceduralLearnRequest, type ProceduralMatchResult, type ProceduralRecallRequest, type QueryRequest, type QueryResponse, type ScrollRequest, type ScrollResponse, type SearchRequest, type SearchResponse, type SearchResult, type SemanticQueryRequest, type SemanticQueryResult, type SemanticStoreRequest, type StorageMode, type TextSearchRequest, type TraversalOutput, type TraverseGraphRequest, type UpsertMetadataRequest, type UpsertRequest, addEdge, batchSearch, createCollection, createGraphCollection, createMetadataCollection, deleteCollection, deletePoints, episodicRecent, episodicRecord, flush, getCollection, getEdges, getNodeDegree, getPoints, hybridSearch, isEmpty, listCollections, multiQuerySearch, proceduralLearn, proceduralRecall, query, scrollCollection, search, semanticQuery, semanticStore, textSearch, traverseGraph, upsert, upsertMetadata };
+export { type AddEdgeRequest, type BatchSearchRequest, type CollectionInfo, type CommandError, type CreateCollectionRequest, type CreateGraphCollectionRequest, type CreateIndexRequest, type CreateMetadataCollectionRequest, type DeletePointsRequest, type DistanceMetric, type DropIndexRequest, type EdgeOutput, type EpisodicRecentRequest, type EpisodicRecordRequest, type EpisodicResult, type FusionParams, type FusionStrategy, type GetEdgesRequest, type GetNodeDegreeRequest, type GetPointsRequest, type HybridResult, type HybridSearchRequest, type HybridSparseSearchRequest, type IndexInfoOutput, type IndividualSearchRequest, type ListIndexesRequest, type MetadataPointInput, type MultiQuerySearchRequest, type NodeDegreeOutput, type PointInput, type PointOutput, type ProceduralLearnRequest, type ProceduralMatchResult, type ProceduralRecallRequest, type QueryRequest, type QueryResponse, type ScrollRequest, type ScrollResponse, type SearchRequest, type SearchResponse, type SearchResult, type SemanticQueryRequest, type SemanticQueryResult, type SemanticStoreRequest, type SparsePointInput, type SparseSearchRequest, type SparseUpsertRequest, type StorageMode, type StreamInsertRequest, type TextSearchRequest, type TrainPqRequest, type TraversalOutput, type TraverseGraphParallelRequest, type TraverseGraphRequest, type UpsertMetadataRequest, type UpsertRequest, addEdge, batchSearch, createCollection, createGraphCollection, createIndex, createMetadataCollection, deleteCollection, deletePoints, dropIndex, episodicRecent, episodicRecord, flush, getCollection, getEdges, getNodeDegree, getPoints, hybridSearch, hybridSparseSearch, isEmpty, listCollections, listIndexes, multiQuerySearch, proceduralLearn, proceduralRecall, query, scrollCollection, search, semanticQuery, semanticStore, sparseSearch, sparseUpsert, streamInsert, textSearch, trainPq, traverseGraph, traverseGraphParallel, upsert, upsertMetadata };

package/dist/index.js

@@ -24,9 +24,11 @@ __export(index_exports, {
   batchSearch: () => batchSearch,
   createCollection: () => createCollection,
   createGraphCollection: () => createGraphCollection,
+  createIndex: () => createIndex,
   createMetadataCollection: () => createMetadataCollection,
   deleteCollection: () => deleteCollection,
   deletePoints: () => deletePoints,
+  dropIndex: () => dropIndex,
   episodicRecent: () => episodicRecent,
   episodicRecord: () => episodicRecord,
   flush: () => flush,
@@ -35,8 +37,10 @@ __export(index_exports, {
   getNodeDegree: () => getNodeDegree,
   getPoints: () => getPoints,
   hybridSearch: () => hybridSearch,
+  hybridSparseSearch: () => hybridSparseSearch,
   isEmpty: () => isEmpty,
   listCollections: () => listCollections,
+  listIndexes: () => listIndexes,
   multiQuerySearch: () => multiQuerySearch,
   proceduralLearn: () => proceduralLearn,
   proceduralRecall: () => proceduralRecall,
@@ -45,109 +49,143 @@ __export(index_exports, {
   search: () => search,
   semanticQuery: () => semanticQuery,
   semanticStore: () => semanticStore,
+  sparseSearch: () => sparseSearch,
+  sparseUpsert: () => sparseUpsert,
+  streamInsert: () => streamInsert,
   textSearch: () => textSearch,
+  trainPq: () => trainPq,
   traverseGraph: () => traverseGraph,
+  traverseGraphParallel: () => traverseGraphParallel,
   upsert: () => upsert,
   upsertMetadata: () => upsertMetadata
 });
 module.exports = __toCommonJS(index_exports);
 var import_core = require("@tauri-apps/api/core");
-async function createCollection(request) {
+function createCollection(request) {
   return (0, import_core.invoke)("plugin:velesdb|create_collection", { request });
 }
-async function createMetadataCollection(request) {
+function createMetadataCollection(request) {
   return (0, import_core.invoke)("plugin:velesdb|create_metadata_collection", { request });
 }
 async function deleteCollection(name) {
-  return (0, import_core.invoke)("plugin:velesdb|delete_collection", { name });
+  await (0, import_core.invoke)("plugin:velesdb|delete_collection", { name });
 }
-async function listCollections() {
+function listCollections() {
   return (0, import_core.invoke)("plugin:velesdb|list_collections");
 }
-async function getCollection(name) {
+function getCollection(name) {
   return (0, import_core.invoke)("plugin:velesdb|get_collection", { name });
 }
-async function upsert(request) {
+function upsert(request) {
   return (0, import_core.invoke)("plugin:velesdb|upsert", { request });
 }
-async function upsertMetadata(request) {
+function upsertMetadata(request) {
   return (0, import_core.invoke)("plugin:velesdb|upsert_metadata", { request });
 }
-async function search(request) {
+function search(request) {
   return (0, import_core.invoke)("plugin:velesdb|search", { request });
 }
-async function textSearch(request) {
+function textSearch(request) {
   return (0, import_core.invoke)("plugin:velesdb|text_search", { request });
 }
-async function hybridSearch(request) {
+function hybridSearch(request) {
   return (0, import_core.invoke)("plugin:velesdb|hybrid_search", { request });
 }
-async function query(request) {
+function query(request) {
   return (0, import_core.invoke)("plugin:velesdb|query", { request });
 }
-async function getPoints(request) {
+function getPoints(request) {
   return (0, import_core.invoke)("plugin:velesdb|get_points", { request });
 }
 async function deletePoints(request) {
-  return (0, import_core.invoke)("plugin:velesdb|delete_points", { request });
+  await (0, import_core.invoke)("plugin:velesdb|delete_points", { request });
 }
-async function batchSearch(request) {
+function batchSearch(request) {
   return (0, import_core.invoke)("plugin:velesdb|batch_search", { request });
 }
-async function multiQuerySearch(request) {
+function multiQuerySearch(request) {
   return (0, import_core.invoke)("plugin:velesdb|multi_query_search", { request });
 }
-async function isEmpty(name) {
+function isEmpty(name) {
   return (0, import_core.invoke)("plugin:velesdb|is_empty", { name });
 }
 async function flush(name) {
-  return (0, import_core.invoke)("plugin:velesdb|flush", { name });
+  await (0, import_core.invoke)("plugin:velesdb|flush", { name });
 }
 async function addEdge(request) {
-  return (0, import_core.invoke)("plugin:velesdb|add_edge", { request });
+  await (0, import_core.invoke)("plugin:velesdb|add_edge", { request });
 }
-async function getEdges(request) {
+function getEdges(request) {
   return (0, import_core.invoke)("plugin:velesdb|get_edges", { request });
 }
-async function traverseGraph(request) {
+function traverseGraph(request) {
   return (0, import_core.invoke)("plugin:velesdb|traverse_graph", { request });
 }
-async function getNodeDegree(request) {
+function getNodeDegree(request) {
   return (0, import_core.invoke)("plugin:velesdb|get_node_degree", { request });
 }
-async function createGraphCollection(request) {
+function createGraphCollection(request) {
   return (0, import_core.invoke)("plugin:velesdb|create_graph_collection", { request });
 }
-async function scrollCollection(request) {
+function scrollCollection(request) {
   return (0, import_core.invoke)("plugin:velesdb|scroll_collection", { request });
 }
 async function semanticStore(request) {
-  return (0, import_core.invoke)("plugin:velesdb|semantic_store", { request });
+  await (0, import_core.invoke)("plugin:velesdb|semantic_store", { request });
 }
-async function semanticQuery(request) {
+function semanticQuery(request) {
   return (0, import_core.invoke)("plugin:velesdb|semantic_query", { request });
 }
 async function episodicRecord(request) {
-  return (0, import_core.invoke)("plugin:velesdb|episodic_record", { request });
+  await (0, import_core.invoke)("plugin:velesdb|episodic_record", { request });
 }
-async function episodicRecent(request) {
+function episodicRecent(request) {
   return (0, import_core.invoke)("plugin:velesdb|episodic_recent", { request });
 }
 async function proceduralLearn(request) {
-  return (0, import_core.invoke)("plugin:velesdb|procedural_learn", { request });
+  await (0, import_core.invoke)("plugin:velesdb|procedural_learn", { request });
 }
-async function proceduralRecall(request) {
+function proceduralRecall(request) {
   return (0, import_core.invoke)("plugin:velesdb|procedural_recall", { request });
 }
+function sparseSearch(request) {
+  return (0, import_core.invoke)("plugin:velesdb|sparse_search", { request });
+}
+function hybridSparseSearch(request) {
+  return (0, import_core.invoke)("plugin:velesdb|hybrid_sparse_search", { request });
+}
+function sparseUpsert(request) {
+  return (0, import_core.invoke)("plugin:velesdb|sparse_upsert", { request });
+}
+function trainPq(request) {
+  return (0, import_core.invoke)("plugin:velesdb|train_pq", { request });
+}
+function streamInsert(request) {
+  return (0, import_core.invoke)("plugin:velesdb|stream_insert", { request });
+}
+async function createIndex(request) {
+  await (0, import_core.invoke)("plugin:velesdb|create_index", { request });
+}
+function dropIndex(request) {
+  return (0, import_core.invoke)("plugin:velesdb|drop_index", { request });
+}
+function listIndexes(request) {
+  return (0, import_core.invoke)("plugin:velesdb|list_indexes", { request });
+}
+function traverseGraphParallel(request) {
+  return (0, import_core.invoke)("plugin:velesdb|traverse_graph_parallel", { request });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addEdge,
   batchSearch,
   createCollection,
   createGraphCollection,
+  createIndex,
   createMetadataCollection,
   deleteCollection,
   deletePoints,
+  dropIndex,
   episodicRecent,
   episodicRecord,
   flush,
@@ -156,8 +194,10 @@ async function proceduralRecall(request) {
   getNodeDegree,
   getPoints,
   hybridSearch,
+  hybridSparseSearch,
   isEmpty,
   listCollections,
+  listIndexes,
   multiQuerySearch,
   proceduralLearn,
   proceduralRecall,
@@ -166,8 +206,13 @@ async function proceduralRecall(request) {
   search,
   semanticQuery,
   semanticStore,
+  sparseSearch,
+  sparseUpsert,
+  streamInsert,
   textSearch,
+  trainPq,
   traverseGraph,
+  traverseGraphParallel,
   upsert,
   upsertMetadata
 });

package/dist/index.mjs

@@ -1,100 +1,129 @@
 // index.ts
 import { invoke } from "@tauri-apps/api/core";
-async function createCollection(request) {
+function createCollection(request) {
   return invoke("plugin:velesdb|create_collection", { request });
 }
-async function createMetadataCollection(request) {
+function createMetadataCollection(request) {
   return invoke("plugin:velesdb|create_metadata_collection", { request });
 }
 async function deleteCollection(name) {
-  return invoke("plugin:velesdb|delete_collection", { name });
+  await invoke("plugin:velesdb|delete_collection", { name });
 }
-async function listCollections() {
+function listCollections() {
   return invoke("plugin:velesdb|list_collections");
 }
-async function getCollection(name) {
+function getCollection(name) {
   return invoke("plugin:velesdb|get_collection", { name });
 }
-async function upsert(request) {
+function upsert(request) {
   return invoke("plugin:velesdb|upsert", { request });
 }
-async function upsertMetadata(request) {
+function upsertMetadata(request) {
   return invoke("plugin:velesdb|upsert_metadata", { request });
 }
-async function search(request) {
+function search(request) {
   return invoke("plugin:velesdb|search", { request });
 }
-async function textSearch(request) {
+function textSearch(request) {
   return invoke("plugin:velesdb|text_search", { request });
 }
-async function hybridSearch(request) {
+function hybridSearch(request) {
   return invoke("plugin:velesdb|hybrid_search", { request });
 }
-async function query(request) {
+function query(request) {
   return invoke("plugin:velesdb|query", { request });
 }
-async function getPoints(request) {
+function getPoints(request) {
   return invoke("plugin:velesdb|get_points", { request });
 }
 async function deletePoints(request) {
-  return invoke("plugin:velesdb|delete_points", { request });
+  await invoke("plugin:velesdb|delete_points", { request });
 }
-async function batchSearch(request) {
+function batchSearch(request) {
   return invoke("plugin:velesdb|batch_search", { request });
 }
-async function multiQuerySearch(request) {
+function multiQuerySearch(request) {
   return invoke("plugin:velesdb|multi_query_search", { request });
 }
-async function isEmpty(name) {
+function isEmpty(name) {
   return invoke("plugin:velesdb|is_empty", { name });
 }
 async function flush(name) {
-  return invoke("plugin:velesdb|flush", { name });
+  await invoke("plugin:velesdb|flush", { name });
 }
 async function addEdge(request) {
-  return invoke("plugin:velesdb|add_edge", { request });
+  await invoke("plugin:velesdb|add_edge", { request });
 }
-async function getEdges(request) {
+function getEdges(request) {
   return invoke("plugin:velesdb|get_edges", { request });
 }
-async function traverseGraph(request) {
+function traverseGraph(request) {
   return invoke("plugin:velesdb|traverse_graph", { request });
 }
-async function getNodeDegree(request) {
+function getNodeDegree(request) {
   return invoke("plugin:velesdb|get_node_degree", { request });
 }
-async function createGraphCollection(request) {
+function createGraphCollection(request) {
   return invoke("plugin:velesdb|create_graph_collection", { request });
 }
-async function scrollCollection(request) {
+function scrollCollection(request) {
   return invoke("plugin:velesdb|scroll_collection", { request });
 }
 async function semanticStore(request) {
-  return invoke("plugin:velesdb|semantic_store", { request });
+  await invoke("plugin:velesdb|semantic_store", { request });
 }
-async function semanticQuery(request) {
+function semanticQuery(request) {
   return invoke("plugin:velesdb|semantic_query", { request });
 }
 async function episodicRecord(request) {
-  return invoke("plugin:velesdb|episodic_record", { request });
+  await invoke("plugin:velesdb|episodic_record", { request });
 }
-async function episodicRecent(request) {
+function episodicRecent(request) {
   return invoke("plugin:velesdb|episodic_recent", { request });
 }
 async function proceduralLearn(request) {
-  return invoke("plugin:velesdb|procedural_learn", { request });
+  await invoke("plugin:velesdb|procedural_learn", { request });
 }
-async function proceduralRecall(request) {
+function proceduralRecall(request) {
   return invoke("plugin:velesdb|procedural_recall", { request });
 }
+function sparseSearch(request) {
+  return invoke("plugin:velesdb|sparse_search", { request });
+}
+function hybridSparseSearch(request) {
+  return invoke("plugin:velesdb|hybrid_sparse_search", { request });
+}
+function sparseUpsert(request) {
+  return invoke("plugin:velesdb|sparse_upsert", { request });
+}
+function trainPq(request) {
+  return invoke("plugin:velesdb|train_pq", { request });
+}
+function streamInsert(request) {
+  return invoke("plugin:velesdb|stream_insert", { request });
+}
+async function createIndex(request) {
+  await invoke("plugin:velesdb|create_index", { request });
+}
+function dropIndex(request) {
+  return invoke("plugin:velesdb|drop_index", { request });
+}
+function listIndexes(request) {
+  return invoke("plugin:velesdb|list_indexes", { request });
+}
+function traverseGraphParallel(request) {
+  return invoke("plugin:velesdb|traverse_graph_parallel", { request });
+}
 export {
   addEdge,
   batchSearch,
   createCollection,
   createGraphCollection,
+  createIndex,
   createMetadataCollection,
   deleteCollection,
   deletePoints,
+  dropIndex,
   episodicRecent,
   episodicRecord,
   flush,
@@ -103,8 +132,10 @@ export {
   getNodeDegree,
   getPoints,
   hybridSearch,
+  hybridSparseSearch,
   isEmpty,
   listCollections,
+  listIndexes,
   multiQuerySearch,
   proceduralLearn,
   proceduralRecall,
@@ -113,8 +144,13 @@ export {
   search,
   semanticQuery,
   semanticStore,
+  sparseSearch,
+  sparseUpsert,
+  streamInsert,
   textSearch,
+  trainPq,
   traverseGraph,
+  traverseGraphParallel,
   upsert,
   upsertMetadata
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wiscale/tauri-plugin-velesdb",
-  "version": "1.15.0",
+  "version": "1.18.0",
   "description": "TypeScript bindings for the VelesDB Tauri plugin - Vector search in desktop apps",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -14,7 +14,8 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsup index.ts --format cjs,esm --dts",
@@ -33,7 +34,7 @@
     "desktop"
   ],
   "author": "Cyberlife Coder",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
     "url": "https://github.com/cyberlife-coder/VelesDB.git",