@dikolab/kbdb 0.1.6 → 0.2.1

package/dist/worker.mjs

@@ -515,10 +515,13 @@ function encodeIdentifierList(ids) {
 
 // src/shared/wasm-codec/functions/encode-search-params.function.ts
 var encoder2 = new TextEncoder();
-function encodeSearchParams(query, mode = "and", limit = 20) {
-  return encoder2.encode(`${query}
+function encodeSearchParams(query, mode = "and", limit = 20, offset = 0) {
+  return encoder2.encode(
+    `${query}
 ${mode}
-${String(limit)}`);
+${String(limit)}
+${String(offset)}`
+  );
 }
 
 // src/shared/wasm-codec/functions/encode-type-filter-param.function.ts
@@ -581,40 +584,75 @@ function decodeU64(bytes, offset) {
 }
 
 // src/shared/wasm-codec/functions/decode-scored-results.function.ts
-function decodeScoredResults(bytes) {
+function decodeOptionString(bytes, offset) {
+  const tag = bytes[offset];
+  if (tag === 0) {
+    return { value: null, bytesRead: 1 };
+  }
+  const str = decodeString(bytes, offset + 1);
+  return { value: str.value, bytesRead: 1 + str.bytesRead };
+}
+function decodePagedSearchResult(bytes) {
   let offset = 0;
-  const count = decodeU32(bytes, offset);
-  offset += count.bytesRead;
-  const results = [];
-  for (let i = 0; i < count.value; i++) {
+  const total = decodeU32(bytes, offset);
+  offset += total.bytesRead;
+  const resultOffset = decodeU32(bytes, offset);
+  offset += resultOffset.bytesRead;
+  const limit = decodeU32(bytes, offset);
+  offset += limit.bytesRead;
+  const hasMore = bytes[offset] === 1;
+  offset += 1;
+  const itemCount = decodeU32(bytes, offset);
+  offset += itemCount.bytesRead;
+  const items = [];
+  for (let i = 0; i < itemCount.value; i++) {
     const kbid = decodeString(bytes, offset);
     offset += kbid.bytesRead;
+    const heading = decodeOptionString(bytes, offset);
+    offset += heading.bytesRead;
+    const sectionType = decodeString(bytes, offset);
+    offset += sectionType.bytesRead;
+    const docidCount = decodeU32(bytes, offset);
+    offset += docidCount.bytesRead;
+    const docids = [];
+    for (let j = 0; j < docidCount.value; j++) {
+      const docid = decodeString(bytes, offset);
+      offset += docid.bytesRead;
+      docids.push(docid.value);
+    }
     const score = decodeF32(bytes, offset);
     offset += score.bytesRead;
-    const matchCount = decodeU32(bytes, offset);
-    offset += matchCount.bytesRead;
-    const matches = [];
-    for (let j = 0; j < matchCount.value; j++) {
+    const snippet = decodeString(bytes, offset);
+    offset += snippet.bytesRead;
+    const termCount = decodeU32(bytes, offset);
+    offset += termCount.bytesRead;
+    const matched_terms = [];
+    for (let j = 0; j < termCount.value; j++) {
       const term = decodeString(bytes, offset);
       offset += term.bytesRead;
-      const freq = decodeF32(bytes, offset);
-      offset += freq.bytesRead;
-      matches.push({
-        term: term.value,
-        frequency: freq.value
-      });
+      matched_terms.push(term.value);
     }
-    results.push({
+    items.push({
       kbid: kbid.value,
+      heading: heading.value,
+      type: sectionType.value,
+      docids,
       score: score.value,
-      matches
+      snippet: snippet.value,
+      matched_terms
     });
   }
-  return results;
+  return {
+    items,
+    total: total.value,
+    offset: resultOffset.value,
+    limit: limit.value,
+    has_more: hasMore
+  };
 }
 
 // src/shared/wasm-codec/functions/decode-section-records.function.ts
-function decodeOptionString(bytes, offset) {
+function decodeOptionString2(bytes, offset) {
   const tag = bytes[offset];
   if (tag === 0) {
     return { value: null, bytesRead: 1 };
@@ -643,13 +681,13 @@ function decodeSectionRecords(bytes) {
   for (let i = 0; i < count.value; i++) {
     const kbid = decodeString(bytes, offset);
     offset += kbid.bytesRead;
-    const docid = decodeOptionString(bytes, offset);
+    const docid = decodeOptionString2(bytes, offset);
     offset += docid.bytesRead;
     const st = decodeSectionType(bytes, offset);
     offset += st.bytesRead;
-    const title = decodeOptionString(bytes, offset);
+    const title = decodeOptionString2(bytes, offset);
     offset += title.bytesRead;
-    const description = decodeOptionString(bytes, offset);
+    const description = decodeOptionString2(bytes, offset);
     offset += description.bytesRead;
     const content = decodeString(bytes, offset);
     offset += content.bytesRead;
@@ -800,6 +838,209 @@ function decodeRemoveFlag(bytes) {
   return bytes.length > 0 && bytes[0] === 1;
 }
 
+// src/shared/wasm-codec/functions/encode-recall-params.function.ts
+function encodeRecallParams(params) {
+  const depth = params.depth ?? 0;
+  const depthBytes = encodeU32(depth);
+  if (params.kbids !== void 0) {
+    const allKbids = params.kbid !== void 0 ? [...params.kbids, params.kbid] : [...params.kbids];
+    const countBytes = encodeU32(allKbids.length);
+    const encodedKbids = allKbids.map(encodeString);
+    const totalLen2 = 1 + // tag
+    countBytes.length + encodedKbids.reduce((sum, b) => sum + b.length, 0) + depthBytes.length;
+    const result2 = new Uint8Array(totalLen2);
+    let offset2 = 0;
+    result2[offset2++] = 1;
+    result2.set(countBytes, offset2);
+    offset2 += countBytes.length;
+    for (const kbidBytes2 of encodedKbids) {
+      result2.set(kbidBytes2, offset2);
+      offset2 += kbidBytes2.length;
+    }
+    result2.set(depthBytes, offset2);
+    return result2;
+  }
+  const kbid = params.kbid ?? "";
+  const kbidBytes = encodeString(kbid);
+  const totalLen = 1 + kbidBytes.length + depthBytes.length;
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  result[offset++] = 0;
+  result.set(kbidBytes, offset);
+  offset += kbidBytes.length;
+  result.set(depthBytes, offset);
+  return result;
+}
+
+// src/shared/wasm-codec/functions/decode-recall-result.function.ts
+function decodeRecallResult(bytes) {
+  const tag = bytes[0];
+  let offset = 1;
+  if (tag === 1) {
+    const countResult = decodeU32(bytes, offset);
+    offset += countResult.bytesRead;
+    const items = [];
+    for (let i = 0; i < countResult.value; i++) {
+      const { item: item2, bytesRead } = decodeOneResult(bytes, offset);
+      offset += bytesRead;
+      items.push(item2);
+    }
+    return items;
+  }
+  const { item } = decodeOneResult(bytes, offset);
+  return item;
+}
+function decodeOptionString3(bytes, offset) {
+  const tag = bytes[offset];
+  if (tag === 0) {
+    return { value: null, bytesRead: 1 };
+  }
+  const str = decodeString(bytes, offset + 1);
+  return { value: str.value, bytesRead: 1 + str.bytesRead };
+}
+function decodeReference(bytes, offset) {
+  let pos = offset;
+  const kbid = decodeString(bytes, pos);
+  pos += kbid.bytesRead;
+  const heading = decodeOptionString3(bytes, pos);
+  pos += heading.bytesRead;
+  const sectionType = decodeString(bytes, pos);
+  pos += sectionType.bytesRead;
+  const markerType = decodeString(bytes, pos);
+  pos += markerType.bytesRead;
+  const contextSnippet = decodeString(bytes, pos);
+  pos += contextSnippet.bytesRead;
+  const direction = decodeString(bytes, pos);
+  pos += direction.bytesRead;
+  return {
+    value: {
+      kbid: kbid.value,
+      heading: heading.value,
+      type: sectionType.value,
+      marker_type: markerType.value,
+      context_snippet: contextSnippet.value,
+      direction: direction.value
+    },
+    bytesRead: pos - offset
+  };
+}
+function decodeSibling(bytes, offset) {
+  let pos = offset;
+  const kbid = decodeString(bytes, pos);
+  pos += kbid.bytesRead;
+  const heading = decodeOptionString3(bytes, pos);
+  pos += heading.bytesRead;
+  const sectionType = decodeString(bytes, pos);
+  pos += sectionType.bytesRead;
+  const content = decodeString(bytes, pos);
+  pos += content.bytesRead;
+  return {
+    value: {
+      kbid: kbid.value,
+      heading: heading.value,
+      type: sectionType.value,
+      content: content.value
+    },
+    bytesRead: pos - offset
+  };
+}
+function decodeDocument(bytes, offset) {
+  let pos = offset;
+  const docid = decodeString(bytes, pos);
+  pos += docid.bytesRead;
+  const title = decodeString(bytes, pos);
+  pos += title.bytesRead;
+  const sectionCount = decodeU32(bytes, pos);
+  pos += sectionCount.bytesRead;
+  const sections = [];
+  for (let i = 0; i < sectionCount.value; i++) {
+    const secKbid = decodeString(bytes, pos);
+    pos += secKbid.bytesRead;
+    const secHeading = decodeOptionString3(bytes, pos);
+    pos += secHeading.bytesRead;
+    const secType = decodeString(bytes, pos);
+    pos += secType.bytesRead;
+    sections.push({
+      kbid: secKbid.value,
+      heading: secHeading.value,
+      type: secType.value
+    });
+  }
+  return {
+    value: {
+      docid: docid.value,
+      title: title.value,
+      sections
+    },
+    bytesRead: pos - offset
+  };
+}
+function decodeOneResult(bytes, startOffset) {
+  let pos = startOffset;
+  const kbid = decodeString(bytes, pos);
+  pos += kbid.bytesRead;
+  const heading = decodeOptionString3(bytes, pos);
+  pos += heading.bytesRead;
+  const sectionType = decodeString(bytes, pos);
+  pos += sectionType.bytesRead;
+  const content = decodeString(bytes, pos);
+  pos += content.bytesRead;
+  const docidCount = decodeU32(bytes, pos);
+  pos += docidCount.bytesRead;
+  const docids = [];
+  for (let i = 0; i < docidCount.value; i++) {
+    const docid = decodeString(bytes, pos);
+    pos += docid.bytesRead;
+    docids.push(docid.value);
+  }
+  const docCount = decodeU32(bytes, pos);
+  pos += docCount.bytesRead;
+  const documents = [];
+  for (let i = 0; i < docCount.value; i++) {
+    const doc = decodeDocument(bytes, pos);
+    pos += doc.bytesRead;
+    documents.push(doc.value);
+  }
+  const backRefCount = decodeU32(bytes, pos);
+  pos += backRefCount.bytesRead;
+  const back_references = [];
+  for (let i = 0; i < backRefCount.value; i++) {
+    const ref = decodeReference(bytes, pos);
+    pos += ref.bytesRead;
+    back_references.push(ref.value);
+  }
+  const sibCount = decodeU32(bytes, pos);
+  pos += sibCount.bytesRead;
+  const siblings = [];
+  for (let i = 0; i < sibCount.value; i++) {
+    const sib = decodeSibling(bytes, pos);
+    pos += sib.bytesRead;
+    siblings.push(sib.value);
+  }
+  const refCount = decodeU32(bytes, pos);
+  pos += refCount.bytesRead;
+  const references = [];
+  for (let i = 0; i < refCount.value; i++) {
+    const ref = decodeReference(bytes, pos);
+    pos += ref.bytesRead;
+    references.push(ref.value);
+  }
+  return {
+    item: {
+      kbid: kbid.value,
+      heading: heading.value,
+      type: sectionType.value,
+      content: content.value,
+      docids,
+      documents,
+      back_references,
+      siblings,
+      references
+    },
+    bytesRead: pos - startOffset
+  };
+}
+
 // src/shared/worker-daemon/classes/worker-daemon.class.ts
 var WASM_METHOD_MAP = {
   search: "worker_search",
@@ -838,7 +1079,8 @@ var WASM_METHOD_MAP = {
   listByType: "worker_list_by_type",
   list_by_type: "worker_list_by_type",
   listDocumentsByType: "worker_list_docs_by_type",
-  list_docs_by_type: "worker_list_docs_by_type"
+  list_docs_by_type: "worker_list_docs_by_type",
+  recall: "worker_recall"
 };
 var CONFIG_PREFIX = "config_";
 var CONFIG_KEY_MAP = {
@@ -1206,6 +1448,9 @@ var WorkerDaemon = class {
     if (method === "listDocumentsByType" || method === "list_docs_by_type") {
       return this.handleListDocsByType(params);
     }
+    if (method === "recall") {
+      return this.handleRecall(params);
+    }
     return this.invokeWasmRaw(wasmExport, new Uint8Array(0));
   }
   // -- Search/query (token-based async) --
@@ -1213,7 +1458,8 @@ var WorkerDaemon = class {
     const query = params["query"] ?? "";
     const mode = params["mode"] ?? "and";
     const limit = Number(params["limit"] ?? 20);
-    const encoded = encodeSearchParams(query, mode, limit);
+    const offset = Number(params["offset"] ?? 0);
+    const encoded = encodeSearchParams(query, mode, limit, offset);
     const searchFn = this.getExport("worker_search");
     const ptr = this.wasmAlloc(encoded.length);
     this.wasmWrite(ptr, encoded);
@@ -1235,7 +1481,7 @@ var WorkerDaemon = class {
       throw new IpcError(-32e3, new TextDecoder().decode(errBytes));
     }
     const resultBytes = this.readReturnSlot();
-    return decodeScoredResults(resultBytes);
+    return decodePagedSearchResult(resultBytes);
   }
   // -- Token status/result (u32 direct params) --
   handleResultStatus(params) {
@@ -1253,7 +1499,7 @@ var WorkerDaemon = class {
       throw new IpcError(-32e3, new TextDecoder().decode(errBytes));
     }
     const bytes = this.readReturnSlot();
-    return decodeScoredResults(bytes);
+    return decodePagedSearchResult(bytes);
   }
   // -- Binary-encoded input methods --
   handleAddSection(params) {
@@ -1364,6 +1610,14 @@ var WorkerDaemon = class {
     );
     return decodeDocumentManifestList(bytes);
   }
+  handleRecall(params) {
+    const kbid = typeof params["kbid"] === "string" ? params["kbid"] : void 0;
+    const kbids = Array.isArray(params["kbids"]) ? params["kbids"] : void 0;
+    const depth = Number(params["depth"] ?? 0);
+    const encoded = encodeRecallParams({ kbid, kbids, depth });
+    const bytes = this.callWasmSync("worker_recall", encoded);
+    return decodeRecallResult(bytes);
+  }
   // -- Zero-arg methods --
   handleInvalidateAll() {
     this.callWasmZeroArg("worker_invalidate_all");