@kernl-sdk/pg 0.1.24 → 0.1.26

package/dist/pgvector/__tests__/integration/lifecycle.integration.test.js

@@ -85,7 +85,7 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             const handle = pgvec.index(indexId);
             const hits = await handle.query({
                 query: [{ embedding: [1, 0, 0, 0] }],
-                topK: 10,
+                limit: 10,
             });
             expect(hits).toHaveLength(3);
             expect(hits[0].id).toBe("doc-1");
@@ -95,7 +95,7 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
                 filter: { published: true },
-                topK: 10,
+                limit: 10,
             });
             expect(hits).toHaveLength(2);
             for (const hit of hits) {
@@ -111,7 +111,7 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             });
             const hits = await handle.query({
                 filter: { id: "doc-1" },
-                topK: 1,
+                limit: 1,
             });
             expect(hits[0].document?.views).toBe(500);
             expect(hits[0].document?.title).toBe("Updated First Document");
@@ -121,7 +121,7 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             await handle.delete("doc-3");
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 10,
+                limit: 10,
             });
             expect(hits).toHaveLength(2);
             expect(hits.find((h) => h.id === "doc-3")).toBeUndefined();
@@ -199,7 +199,7 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             const handle = pgvec.index("custom_binding");
             const hits = await handle.query({
                 query: [{ embedding: [0.1, 0.2, 0.3, 0.4] }],
-                topK: 10,
+                limit: 10,
             });
             expect(hits).toHaveLength(2);
             expect(hits[0].id).toBe("existing-1");
@@ -253,7 +253,7 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             const handle = pgvec.index("custom_binding");
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 1,
+                limit: 1,
             });
             expect(hits).toHaveLength(1);
         });
@@ -290,11 +290,11 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             // Query each
             const hitsA = await handleA.query({
                 query: [{ embedding: [1, 0, 0, 0] }],
-                topK: 10,
+                limit: 10,
             });
             const hitsB = await handleB.query({
                 query: [{ embedding: [0, 1, 0, 0] }],
-                topK: 10,
+                limit: 10,
             });
             expect(hitsA).toHaveLength(1);
             expect(hitsA[0].document?.name).toBe("Index A Doc");
@@ -304,7 +304,7 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             await pgvec.deleteIndex("multi_index_a");
             const stillExists = await handleB.query({
                 query: [{ embedding: [0, 1, 0, 0] }],
-                topK: 10,
+                limit: 10,
             });
             expect(stillExists).toHaveLength(1);
             // Cleanup
@@ -384,7 +384,7 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             await handle.upsert({ id: "high-1", embedding: vec });
             const hits = await handle.query({
                 query: [{ embedding: vec }],
-                topK: 1,
+                limit: 1,
             });
             expect(hits).toHaveLength(1);
             expect(hits[0].document?.embedding).toHaveLength(1536);
@@ -409,7 +409,7 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             // Query on first vector field
             const hits = await handle.query({
                 query: [{ title_embedding: [1, 0, 0, 0] }],
-                topK: 1,
+                limit: 1,
             });
             expect(hits).toHaveLength(1);
             await pgvec.deleteIndex("multi_vec");
@@ -440,7 +440,7 @@ describe.sequential("pgvector index lifecycle integration tests", () => {
             const handle2 = pgvec2.index("persist_test");
             const hits = await handle2.query({
                 query: [{ embedding: [1, 0, 0, 0] }],
-                topK: 1,
+                limit: 1,
             });
             expect(hits[0].document?.name).toBe("Persisted");
             await pgvec.deleteIndex("persist_test");

package/dist/pgvector/__tests__/integration/query.integration.test.d.ts

@@ -1,7 +1,7 @@
 /**
  * Query behavior integration tests for pgvector.
  *
- * Tests vector search, topK behavior, offset pagination, orderBy,
+ * Tests vector search, limit behavior, offset pagination, orderBy,
  * and result structure against real PostgreSQL.
  */
 export {};

package/dist/pgvector/__tests__/integration/query.integration.test.js

@@ -1,7 +1,7 @@
 /**
  * Query behavior integration tests for pgvector.
  *
- * Tests vector search, topK behavior, offset pagination, orderBy,
+ * Tests vector search, limit behavior, offset pagination, orderBy,
  * and result structure against real PostgreSQL.
  */
 import { describe, it, expect, beforeAll, afterAll } from "vitest";
@@ -107,7 +107,7 @@ describe.sequential("pgvector query integration tests", () => {
             // Query with basis vector 1 - should match vec-1 best
             const hits = await handle.query({
                 query: [{ embedding: [1.0, 0.0, 0.0, 0.0] }],
-                topK: 10,
+                limit: 10,
             });
             expect(hits.length).toBeGreaterThan(0);
             expect(hits[0].id).toBe("vec-1");
@@ -116,7 +116,7 @@ describe.sequential("pgvector query integration tests", () => {
             // Query with basis vector 2
             const hits = await handle.query({
                 query: [{ embedding: [0.0, 1.0, 0.0, 0.0] }],
-                topK: 10,
+                limit: 10,
             });
             expect(hits.length).toBeGreaterThan(0);
             expect(hits[0].id).toBe("vec-2");
@@ -129,7 +129,7 @@ describe.sequential("pgvector query integration tests", () => {
             // Query with mix of basis 1 and 2 - should prefer vec-5 which has [0.5, 0.5, 0, 0]
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.0, 0.0] }],
-                topK: 10,
+                limit: 10,
             });
             expect(hits.length).toBeGreaterThan(0);
             expect(hits[0].id).toBe("vec-5");
@@ -137,7 +137,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("returns high similarity score for exact match", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [1.0, 0.0, 0.0, 0.0] }],
-                topK: 1,
+                limit: 1,
             });
             // Cosine similarity of identical vectors should be very close to 1
             expect(hits[0].score).toBeGreaterThan(0.99);
@@ -145,7 +145,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("returns lower similarity for orthogonal vectors", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [1.0, 0.0, 0.0, 0.0] }],
-                topK: 10,
+                limit: 10,
             });
             // Find vec-4 which is orthogonal to query
             const orthogonal = hits.find((h) => h.id === "vec-4");
@@ -157,7 +157,7 @@ describe.sequential("pgvector query integration tests", () => {
             // Already normalized
             const hits = await handle.query({
                 query: [{ embedding: [0.707, 0.707, 0.0, 0.0] }],
-                topK: 3,
+                limit: 3,
             });
             // Should still find vec-5 as best match
             expect(hits[0].id).toBe("vec-5");
@@ -166,51 +166,51 @@ describe.sequential("pgvector query integration tests", () => {
             // Not normalized (should still work with cosine similarity)
             const hits = await handle.query({
                 query: [{ embedding: [2.0, 2.0, 0.0, 0.0] }],
-                topK: 3,
+                limit: 3,
             });
             // Should still find vec-5 as best match
             expect(hits[0].id).toBe("vec-5");
         });
     });
     // ============================================================
-    // TOPK BEHAVIOR
+    // LIMIT BEHAVIOR
     // ============================================================
-    describe("topK behavior", () => {
-        it("topK smaller than doc count returns exactly topK", async () => {
+    describe("limit behavior", () => {
+        it("limit smaller than doc count returns exactly limit", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 3,
+                limit: 3,
             });
             expect(hits.length).toBe(3);
         });
-        it("topK larger than doc count returns all docs", async () => {
+        it("limit larger than doc count returns all docs", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 100,
+                limit: 100,
             });
             expect(hits.length).toBe(6);
         });
-        it("topK of 1 returns single best match", async () => {
+        it("limit of 1 returns single best match", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [1.0, 0.0, 0.0, 0.0] }],
-                topK: 1,
+                limit: 1,
             });
             expect(hits.length).toBe(1);
             expect(hits[0].id).toBe("vec-1");
         });
-        it("topK with filter returns limited filtered results", async () => {
+        it("limit with filter returns limited filtered results", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 1,
+                limit: 1,
                 filter: { category: "db" },
             });
             expect(hits.length).toBe(1);
             expect(hits[0].document?.category).toBe("db");
         });
-        it("topK of 0 returns empty array", async () => {
+        it("limit of 0 returns empty array", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 0,
+                limit: 0,
             });
             expect(hits.length).toBe(0);
         });
@@ -223,21 +223,21 @@ describe.sequential("pgvector query integration tests", () => {
             // Get all results
             const allHits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 10,
+                limit: 10,
             });
             // Get results with offset
             const offsetHits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 10,
+                limit: 10,
                 offset: 2,
             });
             expect(offsetHits.length).toBe(4); // 6 total - 2 skipped
             expect(offsetHits[0].id).toBe(allHits[2].id);
         });
-        it("offset with topK limits correctly", async () => {
+        it("offset with limit limits correctly", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 2,
+                limit: 2,
                 offset: 2,
             });
             expect(hits.length).toBe(2);
@@ -245,7 +245,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("offset beyond result count returns empty", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 10,
+                limit: 10,
                 offset: 100,
             });
             expect(hits.length).toBe(0);
@@ -254,19 +254,19 @@ describe.sequential("pgvector query integration tests", () => {
             // Page 1
             const page1 = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 2,
+                limit: 2,
                 offset: 0,
             });
             // Page 2
             const page2 = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 2,
+                limit: 2,
                 offset: 2,
             });
             // Page 3
             const page3 = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 2,
+                limit: 2,
                 offset: 4,
             });
             expect(page1.length).toBe(2);
@@ -281,12 +281,12 @@ describe.sequential("pgvector query integration tests", () => {
             // 2 docs in "ml" category
             const allMl = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 10,
+                limit: 10,
                 filter: { category: "ml" },
             });
             const offsetMl = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 10,
+                limit: 10,
                 offset: 1,
                 filter: { category: "ml" },
             });
@@ -302,7 +302,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("orders by integer field ascending", async () => {
             const hits = await handle.query({
                 orderBy: { field: "priority", direction: "asc" },
-                topK: 10,
+                limit: 10,
             });
             expect(hits.length).toBe(6);
             expect(hits[0].document?.priority).toBe(1);
@@ -315,7 +315,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("orders by integer field descending", async () => {
             const hits = await handle.query({
                 orderBy: { field: "priority", direction: "desc" },
-                topK: 10,
+                limit: 10,
             });
             expect(hits[0].document?.priority).toBe(6);
             expect(hits[5].document?.priority).toBe(1);
@@ -324,7 +324,7 @@ describe.sequential("pgvector query integration tests", () => {
             // Note: We can still order by the "score" field even though it's excluded from the result
             const hits = await handle.query({
                 orderBy: { field: "priority", direction: "desc" },
-                topK: 10,
+                limit: 10,
             });
             // Verify descending order by priority
             for (let i = 1; i < hits.length; i++) {
@@ -334,7 +334,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("orders by string field", async () => {
             const hits = await handle.query({
                 orderBy: { field: "title", direction: "asc" },
-                topK: 10,
+                limit: 10,
             });
             // Verify alphabetical order
             for (let i = 1; i < hits.length; i++) {
@@ -347,16 +347,16 @@ describe.sequential("pgvector query integration tests", () => {
             const hits = await handle.query({
                 filter: { category: "ml" },
                 orderBy: { field: "priority", direction: "desc" },
-                topK: 10,
+                limit: 10,
             });
             expect(hits.length).toBe(2);
             expect(hits[0].document?.priority).toBe(2);
             expect(hits[1].document?.priority).toBe(1);
         });
-        it("orderBy with topK limits after ordering", async () => {
+        it("orderBy with limit limits after ordering", async () => {
             const hits = await handle.query({
                 orderBy: { field: "priority", direction: "asc" },
-                topK: 3,
+                limit: 3,
             });
             expect(hits.length).toBe(3);
             expect(hits[0].document?.priority).toBe(1);
@@ -366,7 +366,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("orderBy with offset", async () => {
             const hits = await handle.query({
                 orderBy: { field: "priority", direction: "asc" },
-                topK: 2,
+                limit: 2,
                 offset: 2,
             });
             expect(hits.length).toBe(2);
@@ -381,7 +381,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("filter-only query returns all matching docs", async () => {
             const hits = await handle.query({
                 filter: { category: "db" },
-                topK: 10,
+                limit: 10,
             });
             expect(hits.length).toBe(2);
             for (const hit of hits) {
@@ -391,7 +391,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("empty query with orderBy returns ordered docs", async () => {
             const hits = await handle.query({
                 orderBy: { field: "priority", direction: "asc" },
-                topK: 10,
+                limit: 10,
             });
             expect(hits.length).toBe(6);
             expect(hits[0].document?.priority).toBe(1);
@@ -400,7 +400,7 @@ describe.sequential("pgvector query integration tests", () => {
             const hits = await handle.query({
                 filter: { category: "search" },
                 orderBy: { field: "priority", direction: "desc" },
-                topK: 10,
+                limit: 10,
             });
             expect(hits.length).toBe(2);
             // Ordered by priority desc: vec-6 (priority 6), vec-5 (priority 5)
@@ -415,7 +415,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("results have required fields", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [1.0, 0.0, 0.0, 0.0] }],
-                topK: 1,
+                limit: 1,
             });
             expect(hits.length).toBe(1);
             expect(hits[0]).toHaveProperty("id");
@@ -427,7 +427,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("score is a valid number", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [1.0, 0.0, 0.0, 0.0] }],
-                topK: 5,
+                limit: 5,
             });
             for (const hit of hits) {
                 expect(typeof hit.score).toBe("number");
@@ -437,7 +437,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("document fields are included by default", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [1.0, 0.0, 0.0, 0.0] }],
-                topK: 1,
+                limit: 1,
             });
             expect(hits[0].document).toBeDefined();
             expect(hits[0].document).toHaveProperty("title");
@@ -452,7 +452,7 @@ describe.sequential("pgvector query integration tests", () => {
         it("index field matches query index", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [1.0, 0.0, 0.0, 0.0] }],
-                topK: 5,
+                limit: 5,
             });
             for (const hit of hits) {
                 expect(hit.index).toBe(testIndexId);
@@ -467,22 +467,22 @@ describe.sequential("pgvector query integration tests", () => {
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
                 filter: { category: "nonexistent" },
-                topK: 10,
+                limit: 10,
             });
             expect(hits).toEqual([]);
         });
         it("offset beyond result count returns empty array", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 10,
+                limit: 10,
                 offset: 1000,
             });
             expect(hits).toEqual([]);
         });
-        it("topK 0 returns empty array", async () => {
+        it("limit 0 returns empty array", async () => {
             const hits = await handle.query({
                 query: [{ embedding: [0.5, 0.5, 0.5, 0.5] }],
-                topK: 0,
+                limit: 0,
             });
             expect(hits).toEqual([]);
         });
@@ -508,7 +508,7 @@ describe.sequential("pgvector query integration tests", () => {
             ]);
             const hits = await eucHandle.query({
                 query: [{ embedding: [1, 0, 0, 0] }],
-                topK: 3,
+                limit: 3,
             });
             expect(hits[0].id).toBe("e1"); // Exact match
             expect(hits[1].id).toBe("e3"); // Closest
@@ -534,7 +534,7 @@ describe.sequential("pgvector query integration tests", () => {
             ]);
             const hits = await dotHandle.query({
                 query: [{ embedding: [1, 1, 0, 0] }],
-                topK: 3,
+                limit: 3,
             });
             // Dot product: d1=1, d2=1, d3=1
             // With equal dot products, order may vary, but d3 should be competitive

package/dist/pgvector/__tests__/search.test.js

@@ -157,7 +157,7 @@ describe.sequential("PGSearchIndex", () => {
             });
             const results = await handle.query({
                 query: [{ embedding: [0.1, 0.2, 0.3] }],
-                topK: 1,
+                limit: 1,
             });
             expect(results).toHaveLength(1);
             expect(results[0].id).toBe("test-1");

package/dist/pgvector/sql/__tests__/limit.test.js

@@ -4,7 +4,7 @@ describe("SQL_LIMIT", () => {
     describe("encode", () => {
         it("builds LIMIT clause", () => {
             const result = SQL_LIMIT.encode({
-                topK: 10,
+                limit: 10,
                 offset: 0,
                 startIdx: 1,
             });
@@ -13,7 +13,7 @@ describe("SQL_LIMIT", () => {
         });
         it("respects startIdx for parameter numbering", () => {
             const result = SQL_LIMIT.encode({
-                topK: 10,
+                limit: 10,
                 offset: 0,
                 startIdx: 5,
             });
@@ -22,7 +22,7 @@ describe("SQL_LIMIT", () => {
         });
         it("includes OFFSET when offset > 0", () => {
             const result = SQL_LIMIT.encode({
-                topK: 10,
+                limit: 10,
                 offset: 20,
                 startIdx: 1,
             });
@@ -31,7 +31,7 @@ describe("SQL_LIMIT", () => {
         });
         it("skips OFFSET when offset is 0", () => {
             const result = SQL_LIMIT.encode({
-                topK: 25,
+                limit: 25,
                 offset: 0,
                 startIdx: 3,
             });
@@ -41,7 +41,7 @@ describe("SQL_LIMIT", () => {
         it("handles pagination correctly", () => {
             // Page 1: offset 0
             const page1 = SQL_LIMIT.encode({
-                topK: 20,
+                limit: 20,
                 offset: 0,
                 startIdx: 1,
             });
@@ -49,7 +49,7 @@ describe("SQL_LIMIT", () => {
             expect(page1.params).toEqual([20]);
             // Page 2: offset 20
             const page2 = SQL_LIMIT.encode({
-                topK: 20,
+                limit: 20,
                 offset: 20,
                 startIdx: 1,
             });
@@ -57,7 +57,7 @@ describe("SQL_LIMIT", () => {
             expect(page2.params).toEqual([20, 20]);
             // Page 3: offset 40
             const page3 = SQL_LIMIT.encode({
-                topK: 20,
+                limit: 20,
                 offset: 40,
                 startIdx: 1,
             });
@@ -68,7 +68,7 @@ describe("SQL_LIMIT", () => {
             // Simulating: SELECT uses $1, WHERE uses $2-$4
             // LIMIT should start at $5
             const result = SQL_LIMIT.encode({
-                topK: 10,
+                limit: 10,
                 offset: 50,
                 startIdx: 5,
             });
@@ -76,9 +76,9 @@ describe("SQL_LIMIT", () => {
             expect(result.params).toEqual([10, 50]);
         });
         describe("edge values", () => {
-            it("handles topK: 0", () => {
+            it("handles limit: 0", () => {
                 const result = SQL_LIMIT.encode({
-                    topK: 0,
+                    limit: 0,
                     offset: 0,
                     startIdx: 1,
                 });
@@ -86,18 +86,18 @@ describe("SQL_LIMIT", () => {
                 expect(result.sql).toBe("LIMIT $1");
                 expect(result.params).toEqual([0]);
             });
-            it("handles topK: 1", () => {
+            it("handles limit: 1", () => {
                 const result = SQL_LIMIT.encode({
-                    topK: 1,
+                    limit: 1,
                     offset: 0,
                     startIdx: 1,
                 });
                 expect(result.sql).toBe("LIMIT $1");
                 expect(result.params).toEqual([1]);
             });
-            it("handles very large topK", () => {
+            it("handles very large limit", () => {
                 const result = SQL_LIMIT.encode({
-                    topK: 1000000,
+                    limit: 1000000,
                     offset: 0,
                     startIdx: 1,
                 });
@@ -106,7 +106,7 @@ describe("SQL_LIMIT", () => {
             });
             it("handles very large offset", () => {
                 const result = SQL_LIMIT.encode({
-                    topK: 10,
+                    limit: 10,
                     offset: 999999,
                     startIdx: 1,
                 });
@@ -115,16 +115,16 @@ describe("SQL_LIMIT", () => {
             });
             it("handles very large startIdx", () => {
                 const result = SQL_LIMIT.encode({
-                    topK: 10,
+                    limit: 10,
                     offset: 20,
                     startIdx: 50,
                 });
                 expect(result.sql).toBe("LIMIT $50 OFFSET $51");
                 expect(result.params).toEqual([10, 20]);
             });
-            it("handles startIdx: 1 with both topK and offset", () => {
+            it("handles startIdx: 1 with both limit and offset", () => {
                 const result = SQL_LIMIT.encode({
-                    topK: 25,
+                    limit: 25,
                     offset: 100,
                     startIdx: 1,
                 });
@@ -135,7 +135,7 @@ describe("SQL_LIMIT", () => {
         describe("offset boundary", () => {
             it("includes OFFSET when offset is exactly 1", () => {
                 const result = SQL_LIMIT.encode({
-                    topK: 10,
+                    limit: 10,
                     offset: 1,
                     startIdx: 1,
                 });
@@ -144,7 +144,7 @@ describe("SQL_LIMIT", () => {
             });
             it("does not include OFFSET when offset is exactly 0", () => {
                 const result = SQL_LIMIT.encode({
-                    topK: 10,
+                    limit: 10,
                     offset: 0,
                     startIdx: 1,
                 });