@delali/narsil 0.3.1-next.131 → 0.3.1-next.141
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/adapters/filesystem.mjs +1 -1
- package/dist/adapters/indexeddb.mjs +1 -1
- package/dist/analysis-change-HQUT2Z3I.mjs +43 -0
- package/dist/analysis-change-entry-TZTG4AZB.mjs +1 -0
- package/dist/browser/analysis-change-JPV775LR.mjs +900 -0
- package/dist/browser/analysis-change-entry-7HR4LWL3.mjs +1 -0
- package/dist/browser/{chunk-UDGB2MWT.mjs → chunk-35B42UFM.mjs} +4 -0
- package/dist/browser/chunk-3ZBJYAS4.mjs +19 -0
- package/dist/browser/{chunk-2Y3CO4EQ.mjs → chunk-5DB2VDGI.mjs} +1149 -1853
- package/dist/browser/chunk-6RHTAVZX.mjs +656 -0
- package/dist/browser/chunk-CCOAOO73.mjs +86 -0
- package/dist/browser/{chunk-AIIJDWMG.mjs → chunk-D33A5VMU.mjs} +16 -16
- package/dist/browser/{chunk-VBBLTD7O.mjs → chunk-HKX2G6WH.mjs} +1520 -2159
- package/dist/browser/{chunk-NSCSR6MA.mjs → chunk-KTOK275N.mjs} +606 -830
- package/dist/browser/{chunk-D7WQF6DV.mjs → chunk-LVY2LI35.mjs} +2 -2
- package/dist/browser/chunk-MVM33ZUL.mjs +993 -0
- package/dist/browser/chunk-MWUK3DA5.mjs +2634 -0
- package/dist/browser/{chunk-VEGHFP2P.mjs → chunk-MZI3TEOW.mjs} +4 -2
- package/dist/browser/chunk-OIZS5KIX.mjs +6 -0
- package/dist/browser/chunk-R4WUDZQV.mjs +176 -0
- package/dist/browser/{chunk-M5UAAXGU.mjs → chunk-TCLEOZ4P.mjs} +3 -3
- package/dist/browser/chunk-VFYMPCOV.mjs +212 -0
- package/dist/browser/chunk-WCFCHIBB.mjs +177 -0
- package/dist/browser/chunk-XNWPP5NS.mjs +21 -0
- package/dist/browser/chunk-ZEV26AQ6.mjs +270 -0
- package/dist/browser/cold-module-MJMKNUYJ.mjs +745 -0
- package/dist/browser/{durability-wiring-FNZSRH4N.mjs → durability-wiring-SNOWIT6Z.mjs} +370 -95
- package/dist/browser/import-TLB2A5LJ.mjs +9 -0
- package/dist/browser/module-BUFNZMEU.mjs +12 -0
- package/dist/browser/{module-4HIMOQM5.mjs → module-BVP4TKZU.mjs} +397 -109
- package/dist/browser/{phrase-module-WESYVU7K.mjs → phrase-module-HGVBO24W.mjs} +1 -1
- package/dist/{restore-queue-JAMNRC6T.mjs → browser/restore-queue-ONYNYUDE.mjs} +8 -2
- package/dist/browser/{runtime-3X7ZJ5T3.mjs → runtime-VEUH674B.mjs} +2 -2
- package/dist/browser/{snapshot-V7VF6BN6.mjs → snapshot-QXBKHJAG.mjs} +135 -183
- package/dist/browser/{write-YIC2MKRY.mjs → write-WHFBDWQS.mjs} +64 -90
- package/dist/{capabilities-B6WxrWxt.d.ts → capabilities-BCdUwK_L.d.ts} +10 -3
- package/dist/chunk-46NZOPHS.mjs +21 -0
- package/dist/{chunk-JT3YZGCE.mjs → chunk-5WYVUPGD.mjs} +3 -188
- package/dist/chunk-6SNBQESJ.mjs +214 -0
- package/dist/{chunk-2C3WXBQS.mjs → chunk-74XB2SXI.mjs} +1 -1
- package/dist/chunk-7AUASRE7.mjs +653 -0
- package/dist/{chunk-NMXRXFGZ.mjs → chunk-AST3SHFA.mjs} +27 -25
- package/dist/chunk-BOJZGUS6.mjs +177 -0
- package/dist/{chunk-T4OFG4IQ.mjs → chunk-BRUUBXCB.mjs} +92 -17
- package/dist/{chunk-5LX6MOIB.mjs → chunk-C3YDYX6C.mjs} +1 -1
- package/dist/chunk-CZQ33DLW.mjs +78 -0
- package/dist/{chunk-4GDLFDPZ.mjs → chunk-DD2673TX.mjs} +3 -2
- package/dist/{chunk-EUCX5K74.mjs → chunk-DQNKVOJ2.mjs} +65 -65
- package/dist/{chunk-RNSC4NFI.mjs → chunk-EEBCDP36.mjs} +3 -1
- package/dist/chunk-FOCV4CBZ.mjs +87 -0
- package/dist/{chunk-HCGJKDZV.mjs → chunk-GLZHNSGB.mjs} +1 -1
- package/dist/chunk-GWOS5DYC.mjs +2637 -0
- package/dist/{chunk-PATMDIMN.mjs → chunk-HJJWY6PT.mjs} +1 -1
- package/dist/{chunk-CZ7ISLXA.mjs → chunk-HNHCNTVG.mjs} +4 -0
- package/dist/{chunk-Y2U5VVWX.mjs → chunk-ICW45TTU.mjs} +1 -1
- package/dist/{chunk-TGHNXN7W.mjs → chunk-IO5F7ZBE.mjs} +261 -948
- package/dist/{chunk-P36MUFEJ.mjs → chunk-JDDXV6UF.mjs} +2 -1
- package/dist/{chunk-7OIQ2SIO.mjs → chunk-KEIYVZUX.mjs} +5 -5
- package/dist/{chunk-PU6SKH7O.mjs → chunk-KGOXHLLZ.mjs} +7 -3
- package/dist/{chunk-WVRDRLIC.mjs → chunk-KZL72VTC.mjs} +70 -18
- package/dist/chunk-L76W3IZJ.mjs +193 -0
- package/dist/{chunk-2JWNJSNE.mjs → chunk-LA4WNDHL.mjs} +88 -801
- package/dist/{chunk-ZR4VM4A6.mjs → chunk-N37VMC62.mjs} +1 -18
- package/dist/{chunk-JJ6EUMXB.mjs → chunk-NJJCPFXN.mjs} +2 -2
- package/dist/chunk-NN33CZRE.mjs +86 -0
- package/dist/{chunk-2WBY4Y4M.mjs → chunk-NOT5QOHU.mjs} +1 -1
- package/dist/{chunk-D5TFRB5G.mjs → chunk-NPNK57CA.mjs} +1 -1
- package/dist/chunk-NRUXBYPH.mjs +121 -0
- package/dist/{chunk-6SSVIW7Y.mjs → chunk-O4LJQI4G.mjs} +31 -5
- package/dist/{chunk-UJWGQIXU.mjs → chunk-QHPYS427.mjs} +1 -0
- package/dist/{chunk-F6AAXI7T.mjs → chunk-RHKRTYGO.mjs} +13 -4
- package/dist/{chunk-2SEL6SBS.mjs → chunk-RKAVHNRW.mjs} +2 -2
- package/dist/{chunk-RCMNL7RI.mjs → chunk-SBMAWTRG.mjs} +41 -4
- package/dist/chunk-SRJBFG2T.mjs +881 -0
- package/dist/{chunk-X5CNUKD5.mjs → chunk-TNBIK2LQ.mjs} +1663 -1652
- package/dist/{chunk-NNO7CO3A.mjs → chunk-UIKN2OTQ.mjs} +1 -1
- package/dist/chunk-UUZCQQG2.mjs +209 -0
- package/dist/{chunk-6M6SDH3S.mjs → chunk-VEFN6X6Q.mjs} +8 -8
- package/dist/chunk-VJEGOELZ.mjs +177 -0
- package/dist/chunk-W2COJ5AH.mjs +148 -0
- package/dist/{chunk-RWESFSJI.mjs → chunk-WJGO5PGV.mjs} +317 -174
- package/dist/{chunk-7X5JST5L.mjs → chunk-WNBRW4Q2.mjs} +16 -2
- package/dist/{chunk-SZGRYEIC.mjs → chunk-XS2VM7UE.mjs} +3 -3
- package/dist/{chunk-Y4BVTQ53.mjs → chunk-XZ3SRNDJ.mjs} +25 -64
- package/dist/{chunk-K77FJXKS.mjs → chunk-YHUTF6EA.mjs} +474 -93
- package/dist/{chunk-OGLV4I3L.mjs → chunk-YLNSJQLX.mjs} +12 -7
- package/dist/{chunk-SOHMMNCH.mjs → chunk-Z4HFMYNX.mjs} +32 -27
- package/dist/{chunk-5W7AEVTH.mjs → chunk-ZMBFWQXN.mjs} +2 -2
- package/dist/{chunk-2MKX2SCO.mjs → chunk-ZPWS2SKJ.mjs} +297 -274
- package/dist/{chunk-7XY6VD7B.mjs → chunk-ZSWHPKGM.mjs} +1 -1
- package/dist/{client-gNAfaHcE.d.ts → client-B12YFALP.d.ts} +18 -3
- package/dist/client.d.ts +7 -7
- package/dist/client.mjs +11 -1
- package/dist/cold-module-4X7WJCFM.mjs +783 -0
- package/dist/{config-D1cDv3sE.d.ts → config-BhZxIeb1.d.ts} +10 -1
- package/dist/{config-CmYJO34X.d.ts → config-CIG5yDyg.d.ts} +2 -2
- package/dist/{direct-executor-HQ4QVDX7.mjs → direct-executor-7XOQ7VQP.mjs} +14 -14
- package/dist/distribution/coordinator/etcd.d.ts +2 -2
- package/dist/distribution/coordinator/etcd.mjs +1 -1
- package/dist/distribution/coordinator/in-memory.d.ts +2 -2
- package/dist/distribution/transport/grpc.mjs +1 -1
- package/dist/distribution.d.ts +24 -8
- package/dist/distribution.mjs +982 -211
- package/dist/{durability-wiring-S7OX2MAI.mjs → durability-wiring-324D2DDD.mjs} +362 -94
- package/dist/embeddings/openai.mjs +2 -2
- package/dist/{engine-m_Ddr1bz.d.ts → engine-CtzbHOmG.d.ts} +64 -7
- package/dist/import-OOBUW3RR.mjs +44 -0
- package/dist/{index-HYnqS1SE.d.ts → index-DsEurhSl.d.ts} +1 -1
- package/dist/index.browser.mjs +5 -5
- package/dist/index.d.ts +6 -6
- package/dist/index.mjs +22 -22
- package/dist/{long-query-thread-BSL25PD6.mjs → long-query-thread-4SW7RWDE.mjs} +15 -15
- package/dist/{module-2E4XYSGT.mjs → module-DXSJ5LT2.mjs} +378 -87
- package/dist/module-IYPLWHGC.mjs +48 -0
- package/dist/paged-partition-archive-HFP45PLU.mjs +269 -0
- package/dist/partial-words.mjs +5 -5
- package/dist/pattern.mjs +3 -3
- package/dist/persistence/durability/checkpoint-worker.d.ts +16 -1
- package/dist/persistence/durability/checkpoint-worker.mjs +28 -26
- package/dist/{phrase-module-JERF2IDG.mjs → phrase-module-5QHBD2VJ.mjs} +1 -1
- package/dist/react.d.ts +9 -9
- package/dist/react.mjs +4 -0
- package/dist/{rerank-DMMT4FZA.mjs → rerank-KTLC3E6N.mjs} +5 -5
- package/dist/rerankers/http.mjs +2 -2
- package/dist/{browser/restore-queue-GEZ54CA5.mjs → restore-queue-FEYAC4SB.mjs} +8 -2
- package/dist/{runtime-7MLQ7J64.mjs → runtime-DYV75DCB.mjs} +6 -6
- package/dist/{schema-BTXbHCqA.d.ts → schema-B-Runv0n.d.ts} +7 -0
- package/dist/server.d.ts +12 -10
- package/dist/server.mjs +54 -21
- package/dist/{snapshot-DOQLGGEX.mjs → snapshot-CGM65VCD.mjs} +101 -197
- package/dist/synonyms.mjs +6 -4
- package/dist/{tasks-Co8HfRD7.d.ts → tasks-CjRJRGTb.d.ts} +26 -8
- package/dist/{thread-SKO7CN3R.mjs → thread-KGNAIKPD.mjs} +14 -14
- package/dist/vector/search-worker.d.ts +1 -1
- package/dist/vector/search-worker.mjs +6 -5
- package/dist/workers/entry.mjs +8 -8
- package/dist/{write-ZKR7SNRT.mjs → write-2DZPEQL2.mjs} +82 -107
- package/openapi.json +114 -6
- package/package.json +12 -8
|
@@ -1,12 +1,12 @@
|
|
|
1
|
+
import { osqCodeBytes, osqStagedQueryBytes, osqRecordBytes, unpackLevels, readTrailer, stageQueryLevels, writeRecord } from './chunk-37CD3OKS.mjs';
|
|
1
2
|
import { stopUsingTheNativeSearchCore, noteFallback, nativeSearchCoreIsEnabled } from './chunk-DJHHF2L5.mjs';
|
|
2
|
-
import { unpackLevels, readTrailer, stageQueryLevels, osqCodeBytes, osqStagedQueryBytes, osqRecordBytes, writeRecord } from './chunk-37CD3OKS.mjs';
|
|
3
3
|
import { markSimdUnavailable } from './chunk-KOKM4PQN.mjs';
|
|
4
|
-
import { MAX_WASM_PAGES, WASM_PAGE_BYTES, VECTOR_SCRATCH_SLOTS,
|
|
5
|
-
import { loadNativeCore } from './chunk-
|
|
6
|
-
import { COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, PLACEMENT_ROOM_REQUESTS, MAX_LAYER_CAP, INITIAL_LIST_CAPACITY, INITIAL_UPPER_SLOTS,
|
|
4
|
+
import { MAX_WASM_PAGES, WASM_PAGE_BYTES, VECTOR_SCRATCH_SLOTS, OSQ_STEPS, UNPLACED_FLAG_CHUNK_ORDINALS, OSQ_GRID, VECTOR_BLOCK_INITIAL_SLOTS, OSQ_QUERY_BITS, MAX_VECTOR_ORDINALS, VECTOR_STORE_INITIAL_CAPACITY, LOCK_SPIN_ITERATIONS, LOCK_WAIT_SLICE_MS, OSQ_REFINE_ROUNDS, OSQ_REFINE_TOLERANCE, OSQ_PLACEMENT_QUERY_BITS, GRAPH_LOCK_WAIT_SLICE_MS, NATIVE_ATTACH_RETRY_MS, GRAPH_LOCK_WAIT_DEADLINE_MS, OSQ_LAMBDA, MAX_DOC_ID_TABLE_BYTES } from './chunk-QSK35UC2.mjs';
|
|
5
|
+
import { loadNativeCore } from './chunk-74XB2SXI.mjs';
|
|
6
|
+
import { DEFAULT_EF_SEARCH, COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, PLACEMENT_ROOM_REQUESTS, MAX_LAYER_CAP, INITIAL_LIST_CAPACITY, INITIAL_UPPER_SLOTS, NEAREST_LINK_FALLBACK_HOSTS, FARTHEST_REJECTED_LINKS_KEPT } from './chunk-VJS4JFBQ.mjs';
|
|
7
7
|
import { compareCodePoints } from './chunk-YTJCGKM4.mjs';
|
|
8
8
|
import { threadSlotGone } from './chunk-RFBLQLLZ.mjs';
|
|
9
|
-
import { NarsilError, ErrorCodes } from './chunk-
|
|
9
|
+
import { NarsilError, ErrorCodes } from './chunk-HNHCNTVG.mjs';
|
|
10
10
|
|
|
11
11
|
// src/vector/shared-buffers/growable.ts
|
|
12
12
|
function sharedMemoryAvailable() {
|
|
@@ -372,235 +372,6 @@ function releaseSlot(header, held, words, threadSlot) {
|
|
|
372
372
|
}
|
|
373
373
|
}
|
|
374
374
|
|
|
375
|
-
// src/vector/ordinal-filter.ts
|
|
376
|
-
function createOrdinalFilter(slots) {
|
|
377
|
-
return { bits: new Uint8Array(slots + 7 >>> 3), count: 0 };
|
|
378
|
-
}
|
|
379
|
-
function addToOrdinalFilter(filter, ordinal) {
|
|
380
|
-
const index = ordinal >>> 3;
|
|
381
|
-
if (index >= filter.bits.length) return;
|
|
382
|
-
const bit = 1 << (ordinal & 7);
|
|
383
|
-
if ((filter.bits[index] & bit) !== 0) return;
|
|
384
|
-
filter.bits[index] |= bit;
|
|
385
|
-
filter.count += 1;
|
|
386
|
-
}
|
|
387
|
-
function ordinalFilterHas(filter, ordinal) {
|
|
388
|
-
const index = ordinal >>> 3;
|
|
389
|
-
if (index >= filter.bits.length) return false;
|
|
390
|
-
return (filter.bits[index] & 1 << (ordinal & 7)) !== 0;
|
|
391
|
-
}
|
|
392
|
-
function removeFromOrdinalFilter(filter, ordinal) {
|
|
393
|
-
const index = ordinal >>> 3;
|
|
394
|
-
if (index >= filter.bits.length) return;
|
|
395
|
-
const bit = 1 << (ordinal & 7);
|
|
396
|
-
if ((filter.bits[index] & bit) === 0) return;
|
|
397
|
-
filter.bits[index] &= ~bit;
|
|
398
|
-
filter.count -= 1;
|
|
399
|
-
}
|
|
400
|
-
function* ordinalFilterValues(filter) {
|
|
401
|
-
const bits = filter.bits;
|
|
402
|
-
for (let index = 0; index < bits.length; index++) {
|
|
403
|
-
const byte = bits[index];
|
|
404
|
-
if (byte === 0) continue;
|
|
405
|
-
for (let offset = 0; offset < 8; offset++) {
|
|
406
|
-
if ((byte & 1 << offset) !== 0) yield index << 3 | offset;
|
|
407
|
-
}
|
|
408
|
-
}
|
|
409
|
-
}
|
|
410
|
-
|
|
411
|
-
// src/vector/simd-wasm-binary.ts
|
|
412
|
-
var SIMD_DISTANCE_WASM_BASE64 = "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";
|
|
413
|
-
var SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64 = "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";
|
|
414
|
-
|
|
415
|
-
// src/vector/simd.ts
|
|
416
|
-
var wasmExports = null;
|
|
417
|
-
var f32View = null;
|
|
418
|
-
function decodeBase64(base64) {
|
|
419
|
-
if (typeof Buffer !== "undefined") {
|
|
420
|
-
return new Uint8Array(Buffer.from(base64, "base64"));
|
|
421
|
-
}
|
|
422
|
-
const binary = atob(base64);
|
|
423
|
-
const bytes = new Uint8Array(binary.length);
|
|
424
|
-
for (let i = 0; i < binary.length; i++) {
|
|
425
|
-
bytes[i] = binary.charCodeAt(i);
|
|
426
|
-
}
|
|
427
|
-
return bytes;
|
|
428
|
-
}
|
|
429
|
-
try {
|
|
430
|
-
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
431
|
-
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
432
|
-
if (typeof WebAssembly !== "undefined" && typeof WebAssembly.validate === "function" && WebAssembly.validate(wasmBuffer)) {
|
|
433
|
-
const module = new WebAssembly.Module(wasmBuffer);
|
|
434
|
-
const instance = new WebAssembly.Instance(module);
|
|
435
|
-
wasmExports = instance.exports;
|
|
436
|
-
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
437
|
-
}
|
|
438
|
-
} catch {
|
|
439
|
-
wasmExports = null;
|
|
440
|
-
f32View = null;
|
|
441
|
-
}
|
|
442
|
-
if (wasmExports === null) markSimdUnavailable();
|
|
443
|
-
var OFFSET_B_BYTES = 16384;
|
|
444
|
-
function ensureMemory(dim) {
|
|
445
|
-
if (!wasmExports || !f32View) return;
|
|
446
|
-
const needed = OFFSET_B_BYTES + dim * 4;
|
|
447
|
-
const currentSize = wasmExports.memory.buffer.byteLength;
|
|
448
|
-
if (needed > currentSize) {
|
|
449
|
-
const pagesNeeded = Math.ceil(needed / 65536);
|
|
450
|
-
const currentPages = currentSize / 65536;
|
|
451
|
-
wasmExports.memory.grow(pagesNeeded - currentPages);
|
|
452
|
-
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
453
|
-
}
|
|
454
|
-
}
|
|
455
|
-
function getF32View() {
|
|
456
|
-
if (!f32View) {
|
|
457
|
-
throw new Error("SIMD memory is not initialized");
|
|
458
|
-
}
|
|
459
|
-
return f32View;
|
|
460
|
-
}
|
|
461
|
-
function copyOneVector(a) {
|
|
462
|
-
getF32View().set(a, 0);
|
|
463
|
-
}
|
|
464
|
-
function copyTwoVectors(a, b) {
|
|
465
|
-
const view = getF32View();
|
|
466
|
-
view.set(a, 0);
|
|
467
|
-
view.set(b, OFFSET_B_BYTES / 4);
|
|
468
|
-
}
|
|
469
|
-
function simdDotProduct(a, b) {
|
|
470
|
-
if (!wasmExports || !f32View) return null;
|
|
471
|
-
ensureMemory(a.length);
|
|
472
|
-
copyTwoVectors(a, b);
|
|
473
|
-
return wasmExports.dot_product(0, OFFSET_B_BYTES, a.length);
|
|
474
|
-
}
|
|
475
|
-
function simdMagnitude(a) {
|
|
476
|
-
if (!wasmExports || !f32View) return null;
|
|
477
|
-
ensureMemory(a.length);
|
|
478
|
-
copyOneVector(a);
|
|
479
|
-
return wasmExports.magnitude(0, a.length);
|
|
480
|
-
}
|
|
481
|
-
function simdSquaredEuclideanDistance(a, b) {
|
|
482
|
-
if (!wasmExports || !f32View) return null;
|
|
483
|
-
ensureMemory(a.length);
|
|
484
|
-
copyTwoVectors(a, b);
|
|
485
|
-
return wasmExports.squared_euclidean_distance(0, OFFSET_B_BYTES, a.length);
|
|
486
|
-
}
|
|
487
|
-
var arenaModule;
|
|
488
|
-
function getArenaModule() {
|
|
489
|
-
if (arenaModule !== void 0) return arenaModule;
|
|
490
|
-
try {
|
|
491
|
-
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
492
|
-
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
493
|
-
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
494
|
-
arenaModule = null;
|
|
495
|
-
return null;
|
|
496
|
-
}
|
|
497
|
-
arenaModule = new WebAssembly.Module(wasmBuffer);
|
|
498
|
-
} catch {
|
|
499
|
-
arenaModule = null;
|
|
500
|
-
}
|
|
501
|
-
return arenaModule;
|
|
502
|
-
}
|
|
503
|
-
function createArenaSimd() {
|
|
504
|
-
try {
|
|
505
|
-
const module = getArenaModule();
|
|
506
|
-
if (module === null) return null;
|
|
507
|
-
const instance = new WebAssembly.Instance(module);
|
|
508
|
-
const exports$1 = instance.exports;
|
|
509
|
-
if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.osq_dot_nibbles_4x4 !== "function" || typeof exports$1.osq_dot_bits !== "function" || typeof exports$1.osq_dot_bits_pair !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function" || !(exports$1.memory instanceof WebAssembly.Memory)) {
|
|
510
|
-
return null;
|
|
511
|
-
}
|
|
512
|
-
return exports$1;
|
|
513
|
-
} catch {
|
|
514
|
-
return null;
|
|
515
|
-
}
|
|
516
|
-
}
|
|
517
|
-
var sharedMemoryModule;
|
|
518
|
-
function getSharedMemoryModule() {
|
|
519
|
-
if (sharedMemoryModule !== void 0) return sharedMemoryModule;
|
|
520
|
-
try {
|
|
521
|
-
const bytes = decodeBase64(SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64);
|
|
522
|
-
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
523
|
-
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
524
|
-
sharedMemoryModule = null;
|
|
525
|
-
return null;
|
|
526
|
-
}
|
|
527
|
-
sharedMemoryModule = new WebAssembly.Module(wasmBuffer);
|
|
528
|
-
} catch {
|
|
529
|
-
sharedMemoryModule = null;
|
|
530
|
-
}
|
|
531
|
-
return sharedMemoryModule;
|
|
532
|
-
}
|
|
533
|
-
function createSharedArenaSimd(memory) {
|
|
534
|
-
try {
|
|
535
|
-
const module = getSharedMemoryModule();
|
|
536
|
-
if (module === null) return null;
|
|
537
|
-
const instance = new WebAssembly.Instance(module, { env: { memory } });
|
|
538
|
-
const exports$1 = instance.exports;
|
|
539
|
-
if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.osq_dot_nibbles_4x4 !== "function" || typeof exports$1.osq_dot_bits !== "function" || typeof exports$1.osq_dot_bits_pair !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function") {
|
|
540
|
-
return null;
|
|
541
|
-
}
|
|
542
|
-
return {
|
|
543
|
-
memory,
|
|
544
|
-
dot_product: exports$1.dot_product,
|
|
545
|
-
magnitude: exports$1.magnitude,
|
|
546
|
-
squared_euclidean_distance: exports$1.squared_euclidean_distance,
|
|
547
|
-
dot_u8: exports$1.dot_u8,
|
|
548
|
-
sqdist_u8: exports$1.sqdist_u8,
|
|
549
|
-
osq_dot_nibbles_4x4: exports$1.osq_dot_nibbles_4x4,
|
|
550
|
-
osq_dot_bits: exports$1.osq_dot_bits,
|
|
551
|
-
osq_dot_bits_pair: exports$1.osq_dot_bits_pair
|
|
552
|
-
};
|
|
553
|
-
} catch {
|
|
554
|
-
return null;
|
|
555
|
-
}
|
|
556
|
-
}
|
|
557
|
-
function arenaFloat32Distance(simd, byteA, byteB, dimension, metric, magnitudeA, magnitudeB) {
|
|
558
|
-
if (metric === "euclidean") {
|
|
559
|
-
return Math.sqrt(simd.squared_euclidean_distance(byteA, byteB, dimension));
|
|
560
|
-
}
|
|
561
|
-
const dot = simd.dot_product(byteA, byteB, dimension);
|
|
562
|
-
if (metric === "dotProduct") return -dot;
|
|
563
|
-
if (magnitudeA === 0 || magnitudeB === 0) return 1;
|
|
564
|
-
return 1 - dot / (magnitudeA * magnitudeB);
|
|
565
|
-
}
|
|
566
|
-
|
|
567
|
-
// src/vector/similarity.ts
|
|
568
|
-
function magnitude(v) {
|
|
569
|
-
const result = simdMagnitude(v);
|
|
570
|
-
if (result !== null) return result;
|
|
571
|
-
let sum = 0;
|
|
572
|
-
for (let i = 0; i < v.length; i++) {
|
|
573
|
-
sum += v[i] * v[i];
|
|
574
|
-
}
|
|
575
|
-
return Math.sqrt(sum);
|
|
576
|
-
}
|
|
577
|
-
function cosineSimilarityWithMagnitudes(a, b, magA, magB) {
|
|
578
|
-
if (magA === 0 || magB === 0) return 0;
|
|
579
|
-
return dotProduct(a, b) / (magA * magB);
|
|
580
|
-
}
|
|
581
|
-
function dotProduct(a, b) {
|
|
582
|
-
const result = simdDotProduct(a, b);
|
|
583
|
-
if (result !== null) return result;
|
|
584
|
-
let sum = 0;
|
|
585
|
-
for (let i = 0; i < a.length; i++) {
|
|
586
|
-
sum += a[i] * b[i];
|
|
587
|
-
}
|
|
588
|
-
return sum;
|
|
589
|
-
}
|
|
590
|
-
function euclideanDistance(a, b) {
|
|
591
|
-
return Math.sqrt(squaredEuclideanDistance(a, b));
|
|
592
|
-
}
|
|
593
|
-
function squaredEuclideanDistance(a, b) {
|
|
594
|
-
const result = simdSquaredEuclideanDistance(a, b);
|
|
595
|
-
if (result !== null) return result;
|
|
596
|
-
let sum = 0;
|
|
597
|
-
for (let i = 0; i < a.length; i++) {
|
|
598
|
-
const diff = a[i] - b[i];
|
|
599
|
-
sum += diff * diff;
|
|
600
|
-
}
|
|
601
|
-
return sum;
|
|
602
|
-
}
|
|
603
|
-
|
|
604
375
|
// src/vector/hnsw/adjacency/views.ts
|
|
605
376
|
var ABSENT = -1;
|
|
606
377
|
function openAdjacency(handles, m, mMax0) {
|
|
@@ -876,113 +647,160 @@ function replaceNeighbors(adj, ord, layer, neighbors, count) {
|
|
|
876
647
|
writeNeighbors(adj, ord, 0, neighbors, count);
|
|
877
648
|
}
|
|
878
649
|
|
|
879
|
-
// src/vector/
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
function
|
|
887
|
-
|
|
650
|
+
// src/vector/simd-wasm-binary.ts
|
|
651
|
+
var SIMD_DISTANCE_WASM_BASE64 = "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";
|
|
652
|
+
var SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64 = "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";
|
|
653
|
+
|
|
654
|
+
// src/vector/simd.ts
|
|
655
|
+
var wasmExports = null;
|
|
656
|
+
var f32View = null;
|
|
657
|
+
function decodeBase64(base64) {
|
|
658
|
+
if (typeof Buffer !== "undefined") {
|
|
659
|
+
return new Uint8Array(Buffer.from(base64, "base64"));
|
|
660
|
+
}
|
|
661
|
+
const binary = atob(base64);
|
|
662
|
+
const bytes = new Uint8Array(binary.length);
|
|
663
|
+
for (let i = 0; i < binary.length; i++) {
|
|
664
|
+
bytes[i] = binary.charCodeAt(i);
|
|
665
|
+
}
|
|
666
|
+
return bytes;
|
|
888
667
|
}
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
function
|
|
893
|
-
|
|
894
|
-
|
|
668
|
+
try {
|
|
669
|
+
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
670
|
+
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
671
|
+
if (typeof WebAssembly !== "undefined" && typeof WebAssembly.validate === "function" && WebAssembly.validate(wasmBuffer)) {
|
|
672
|
+
const module = new WebAssembly.Module(wasmBuffer);
|
|
673
|
+
const instance = new WebAssembly.Instance(module);
|
|
674
|
+
wasmExports = instance.exports;
|
|
675
|
+
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
676
|
+
}
|
|
677
|
+
} catch {
|
|
678
|
+
wasmExports = null;
|
|
679
|
+
f32View = null;
|
|
895
680
|
}
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
|
|
900
|
-
const
|
|
901
|
-
|
|
902
|
-
|
|
681
|
+
if (wasmExports === null) markSimdUnavailable();
|
|
682
|
+
var OFFSET_B_BYTES = 16384;
|
|
683
|
+
function ensureMemory(dim) {
|
|
684
|
+
if (!wasmExports || !f32View) return;
|
|
685
|
+
const needed = OFFSET_B_BYTES + dim * 4;
|
|
686
|
+
const currentSize = wasmExports.memory.buffer.byteLength;
|
|
687
|
+
if (needed > currentSize) {
|
|
688
|
+
const pagesNeeded = Math.ceil(needed / 65536);
|
|
689
|
+
const currentPages = currentSize / 65536;
|
|
690
|
+
wasmExports.memory.grow(pagesNeeded - currentPages);
|
|
691
|
+
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
692
|
+
}
|
|
903
693
|
}
|
|
904
|
-
function
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
state.visited.fill(0);
|
|
908
|
-
state.visitStamp = 1;
|
|
694
|
+
function getF32View() {
|
|
695
|
+
if (!f32View) {
|
|
696
|
+
throw new Error("SIMD memory is not initialized");
|
|
909
697
|
}
|
|
910
|
-
return
|
|
698
|
+
return f32View;
|
|
911
699
|
}
|
|
912
|
-
function
|
|
913
|
-
|
|
914
|
-
if (ord >= state.adjacency.handles.tombstones.byteLength) return false;
|
|
915
|
-
state.tombstones = fixedView(state.adjacency.handles.tombstones, Uint8Array);
|
|
916
|
-
return ord < state.tombstones.length;
|
|
700
|
+
function copyOneVector(a) {
|
|
701
|
+
getF32View().set(a, 0);
|
|
917
702
|
}
|
|
918
|
-
function
|
|
919
|
-
|
|
703
|
+
function copyTwoVectors(a, b) {
|
|
704
|
+
const view = getF32View();
|
|
705
|
+
view.set(a, 0);
|
|
706
|
+
view.set(b, OFFSET_B_BYTES / 4);
|
|
920
707
|
}
|
|
921
|
-
function
|
|
922
|
-
|
|
708
|
+
function simdDotProduct(a, b) {
|
|
709
|
+
if (!wasmExports || !f32View) return null;
|
|
710
|
+
ensureMemory(a.length);
|
|
711
|
+
copyTwoVectors(a, b);
|
|
712
|
+
return wasmExports.dot_product(0, OFFSET_B_BYTES, a.length);
|
|
923
713
|
}
|
|
924
|
-
function
|
|
925
|
-
|
|
714
|
+
function simdMagnitude(a) {
|
|
715
|
+
if (!wasmExports || !f32View) return null;
|
|
716
|
+
ensureMemory(a.length);
|
|
717
|
+
copyOneVector(a);
|
|
718
|
+
return wasmExports.magnitude(0, a.length);
|
|
926
719
|
}
|
|
927
|
-
function
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
|
|
932
|
-
return -dotProduct(a, b);
|
|
933
|
-
case "euclidean":
|
|
934
|
-
return euclideanDistance(a, b);
|
|
935
|
-
}
|
|
720
|
+
function simdSquaredEuclideanDistance(a, b) {
|
|
721
|
+
if (!wasmExports || !f32View) return null;
|
|
722
|
+
ensureMemory(a.length);
|
|
723
|
+
copyTwoVectors(a, b);
|
|
724
|
+
return wasmExports.squared_euclidean_distance(0, OFFSET_B_BYTES, a.length);
|
|
936
725
|
}
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
|
|
942
|
-
|
|
943
|
-
|
|
944
|
-
|
|
726
|
+
var arenaModule;
|
|
727
|
+
function getArenaModule() {
|
|
728
|
+
if (arenaModule !== void 0) return arenaModule;
|
|
729
|
+
try {
|
|
730
|
+
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
731
|
+
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
732
|
+
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
733
|
+
arenaModule = null;
|
|
734
|
+
return null;
|
|
735
|
+
}
|
|
736
|
+
arenaModule = new WebAssembly.Module(wasmBuffer);
|
|
737
|
+
} catch {
|
|
738
|
+
arenaModule = null;
|
|
945
739
|
}
|
|
740
|
+
return arenaModule;
|
|
946
741
|
}
|
|
947
|
-
function
|
|
948
|
-
|
|
949
|
-
|
|
950
|
-
|
|
951
|
-
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
|
|
957
|
-
}
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
if (quantizer === void 0 || !quantizer.isCalibrated()) return void 0;
|
|
961
|
-
return quantizer;
|
|
962
|
-
}
|
|
963
|
-
function nodeDistanceFunction(state, metric) {
|
|
964
|
-
const storeDistance = state.store.pairDistance(metric);
|
|
965
|
-
const quantizer = state.quantizer;
|
|
966
|
-
if (quantizer === void 0 || !buildsFromCodes(state)) return storeDistance;
|
|
967
|
-
const codeDistance = quantizer.pairDistance();
|
|
968
|
-
return (aOrd, bOrd) => {
|
|
969
|
-
const estimated = codeDistance(aOrd, bOrd);
|
|
970
|
-
return estimated === Number.POSITIVE_INFINITY ? storeDistance(aOrd, bOrd) : estimated;
|
|
971
|
-
};
|
|
742
|
+
function createArenaSimd() {
|
|
743
|
+
try {
|
|
744
|
+
const module = getArenaModule();
|
|
745
|
+
if (module === null) return null;
|
|
746
|
+
const instance = new WebAssembly.Instance(module);
|
|
747
|
+
const exports$1 = instance.exports;
|
|
748
|
+
if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.osq_dot_nibbles_4x4 !== "function" || typeof exports$1.osq_dot_bits !== "function" || typeof exports$1.osq_dot_bits_pair !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function" || !(exports$1.memory instanceof WebAssembly.Memory)) {
|
|
749
|
+
return null;
|
|
750
|
+
}
|
|
751
|
+
return exports$1;
|
|
752
|
+
} catch {
|
|
753
|
+
return null;
|
|
754
|
+
}
|
|
972
755
|
}
|
|
973
|
-
|
|
974
|
-
|
|
975
|
-
if (
|
|
976
|
-
|
|
756
|
+
var sharedMemoryModule;
|
|
757
|
+
function getSharedMemoryModule() {
|
|
758
|
+
if (sharedMemoryModule !== void 0) return sharedMemoryModule;
|
|
759
|
+
try {
|
|
760
|
+
const bytes = decodeBase64(SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64);
|
|
761
|
+
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
762
|
+
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
763
|
+
sharedMemoryModule = null;
|
|
764
|
+
return null;
|
|
765
|
+
}
|
|
766
|
+
sharedMemoryModule = new WebAssembly.Module(wasmBuffer);
|
|
767
|
+
} catch {
|
|
768
|
+
sharedMemoryModule = null;
|
|
769
|
+
}
|
|
770
|
+
return sharedMemoryModule;
|
|
977
771
|
}
|
|
978
|
-
function
|
|
979
|
-
|
|
772
|
+
function createSharedArenaSimd(memory) {
|
|
773
|
+
try {
|
|
774
|
+
const module = getSharedMemoryModule();
|
|
775
|
+
if (module === null) return null;
|
|
776
|
+
const instance = new WebAssembly.Instance(module, { env: { memory } });
|
|
777
|
+
const exports$1 = instance.exports;
|
|
778
|
+
if (typeof exports$1.dot_u8 !== "function" || typeof exports$1.sqdist_u8 !== "function" || typeof exports$1.osq_dot_nibbles_4x4 !== "function" || typeof exports$1.osq_dot_bits !== "function" || typeof exports$1.osq_dot_bits_pair !== "function" || typeof exports$1.dot_product !== "function" || typeof exports$1.magnitude !== "function" || typeof exports$1.squared_euclidean_distance !== "function") {
|
|
779
|
+
return null;
|
|
780
|
+
}
|
|
781
|
+
return {
|
|
782
|
+
memory,
|
|
783
|
+
dot_product: exports$1.dot_product,
|
|
784
|
+
magnitude: exports$1.magnitude,
|
|
785
|
+
squared_euclidean_distance: exports$1.squared_euclidean_distance,
|
|
786
|
+
dot_u8: exports$1.dot_u8,
|
|
787
|
+
sqdist_u8: exports$1.sqdist_u8,
|
|
788
|
+
osq_dot_nibbles_4x4: exports$1.osq_dot_nibbles_4x4,
|
|
789
|
+
osq_dot_bits: exports$1.osq_dot_bits,
|
|
790
|
+
osq_dot_bits_pair: exports$1.osq_dot_bits_pair
|
|
791
|
+
};
|
|
792
|
+
} catch {
|
|
793
|
+
return null;
|
|
794
|
+
}
|
|
980
795
|
}
|
|
981
|
-
function
|
|
982
|
-
|
|
983
|
-
|
|
796
|
+
function arenaFloat32Distance(simd, byteA, byteB, dimension, metric, magnitudeA, magnitudeB) {
|
|
797
|
+
if (metric === "euclidean") {
|
|
798
|
+
return Math.sqrt(simd.squared_euclidean_distance(byteA, byteB, dimension));
|
|
984
799
|
}
|
|
985
|
-
|
|
800
|
+
const dot = simd.dot_product(byteA, byteB, dimension);
|
|
801
|
+
if (metric === "dotProduct") return -dot;
|
|
802
|
+
if (magnitudeA === 0 || magnitudeB === 0) return 1;
|
|
803
|
+
return 1 - dot / (magnitudeA * magnitudeB);
|
|
986
804
|
}
|
|
987
805
|
|
|
988
806
|
// src/vector/vector-store/blocks.ts
|
|
@@ -1637,50 +1455,219 @@ function nativeConnect(state, field, metric, nearby) {
|
|
|
1637
1455
|
return writeToTheGraph(state, field, connect) === NATIVE_OK;
|
|
1638
1456
|
}
|
|
1639
1457
|
|
|
1640
|
-
// src/vector/
|
|
1641
|
-
function
|
|
1642
|
-
|
|
1643
|
-
|
|
1644
|
-
|
|
1645
|
-
|
|
1458
|
+
// src/vector/similarity.ts
|
|
1459
|
+
function magnitude(v) {
|
|
1460
|
+
const result = simdMagnitude(v);
|
|
1461
|
+
if (result !== null) return result;
|
|
1462
|
+
let sum = 0;
|
|
1463
|
+
for (let i = 0; i < v.length; i++) {
|
|
1464
|
+
sum += v[i] * v[i];
|
|
1465
|
+
}
|
|
1466
|
+
return Math.sqrt(sum);
|
|
1646
1467
|
}
|
|
1647
|
-
function
|
|
1648
|
-
return
|
|
1649
|
-
|
|
1650
|
-
found: createHeap(true),
|
|
1651
|
-
entryPoints: new Int32Array(INITIAL_LIST_CAPACITY),
|
|
1652
|
-
entryPointCount: 0,
|
|
1653
|
-
traversal: createList(INITIAL_LIST_CAPACITY),
|
|
1654
|
-
working: createList(INITIAL_LIST_CAPACITY),
|
|
1655
|
-
linkSelections: [],
|
|
1656
|
-
pruneCandidates: createList(INITIAL_LIST_CAPACITY),
|
|
1657
|
-
pruneSelection: createList(INITIAL_LIST_CAPACITY),
|
|
1658
|
-
repairCandidates: createList(INITIAL_LIST_CAPACITY),
|
|
1659
|
-
repairSelection: createList(INITIAL_LIST_CAPACITY),
|
|
1660
|
-
droppedLinks: createList(INITIAL_LIST_CAPACITY)
|
|
1661
|
-
};
|
|
1468
|
+
function cosineSimilarityWithMagnitudes(a, b, magA, magB) {
|
|
1469
|
+
if (magA === 0 || magB === 0) return 0;
|
|
1470
|
+
return dotProduct(a, b) / (magA * magB);
|
|
1662
1471
|
}
|
|
1663
|
-
function
|
|
1664
|
-
const
|
|
1665
|
-
|
|
1666
|
-
|
|
1472
|
+
function dotProduct(a, b) {
|
|
1473
|
+
const result = simdDotProduct(a, b);
|
|
1474
|
+
if (result !== null) return result;
|
|
1475
|
+
let sum = 0;
|
|
1476
|
+
for (let i = 0; i < a.length; i++) {
|
|
1477
|
+
sum += a[i] * b[i];
|
|
1478
|
+
}
|
|
1479
|
+
return sum;
|
|
1667
1480
|
}
|
|
1668
|
-
function
|
|
1669
|
-
|
|
1670
|
-
let capacity = list.ords.length === 0 ? INITIAL_LIST_CAPACITY : list.ords.length;
|
|
1671
|
-
while (capacity < needed) capacity *= 2;
|
|
1672
|
-
const ords = new Int32Array(capacity);
|
|
1673
|
-
ords.set(list.ords);
|
|
1674
|
-
list.ords = ords;
|
|
1675
|
-
const distances = new Float64Array(capacity);
|
|
1676
|
-
distances.set(list.distances);
|
|
1677
|
-
list.distances = distances;
|
|
1481
|
+
function euclideanDistance(a, b) {
|
|
1482
|
+
return Math.sqrt(squaredEuclideanDistance(a, b));
|
|
1678
1483
|
}
|
|
1679
|
-
function
|
|
1680
|
-
|
|
1681
|
-
|
|
1682
|
-
|
|
1683
|
-
|
|
1484
|
+
function squaredEuclideanDistance(a, b) {
|
|
1485
|
+
const result = simdSquaredEuclideanDistance(a, b);
|
|
1486
|
+
if (result !== null) return result;
|
|
1487
|
+
let sum = 0;
|
|
1488
|
+
for (let i = 0; i < a.length; i++) {
|
|
1489
|
+
const diff = a[i] - b[i];
|
|
1490
|
+
sum += diff * diff;
|
|
1491
|
+
}
|
|
1492
|
+
return sum;
|
|
1493
|
+
}
|
|
1494
|
+
|
|
1495
|
+
// src/vector/hnsw/insertion-order.ts
|
|
1496
|
+
var GOLDEN_GAMMA = 2654435769;
|
|
1497
|
+
var FIRST_MIX_MULTIPLIER = 569420461;
|
|
1498
|
+
var SECOND_MIX_MULTIPLIER = 1935289751;
|
|
1499
|
+
var TWO_TO_THE_32 = 4294967296;
|
|
1500
|
+
var HALF_A_STEP = 0.5;
|
|
1501
|
+
function mixedUint32(value) {
|
|
1502
|
+
let mixed = value + GOLDEN_GAMMA | 0;
|
|
1503
|
+
mixed ^= mixed >>> 16;
|
|
1504
|
+
mixed = Math.imul(mixed, FIRST_MIX_MULTIPLIER);
|
|
1505
|
+
mixed ^= mixed >>> 15;
|
|
1506
|
+
mixed = Math.imul(mixed, SECOND_MIX_MULTIPLIER);
|
|
1507
|
+
mixed ^= mixed >>> 15;
|
|
1508
|
+
return mixed >>> 0;
|
|
1509
|
+
}
|
|
1510
|
+
function unitDrawOf(value) {
|
|
1511
|
+
return (mixedUint32(value) + HALF_A_STEP) / TWO_TO_THE_32;
|
|
1512
|
+
}
|
|
1513
|
+
function shuffleInPlace(items) {
|
|
1514
|
+
let stream = items.length;
|
|
1515
|
+
for (let i = items.length - 1; i > 0; i--) {
|
|
1516
|
+
stream = mixedUint32(stream);
|
|
1517
|
+
const j = Math.floor(stream / TWO_TO_THE_32 * (i + 1));
|
|
1518
|
+
const held = items[i];
|
|
1519
|
+
items[i] = items[j];
|
|
1520
|
+
items[j] = held;
|
|
1521
|
+
}
|
|
1522
|
+
return items;
|
|
1523
|
+
}
|
|
1524
|
+
|
|
1525
|
+
// src/vector/hnsw/shared.ts
|
|
1526
|
+
function entryPointOf(state) {
|
|
1527
|
+
return Atomics.load(state.header, GRAPH_ENTRY_POINT);
|
|
1528
|
+
}
|
|
1529
|
+
function topLayerOf(state) {
|
|
1530
|
+
return Atomics.load(state.header, GRAPH_TOP_LAYER);
|
|
1531
|
+
}
|
|
1532
|
+
function nodeCountOf(state) {
|
|
1533
|
+
return Atomics.load(state.header, GRAPH_NODE_COUNT);
|
|
1534
|
+
}
|
|
1535
|
+
function tombstoneCountOf(state) {
|
|
1536
|
+
return Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT);
|
|
1537
|
+
}
|
|
1538
|
+
function ensureCapacity(state, needed) {
|
|
1539
|
+
ensureAdjacencyCapacity(state.adjacency, needed);
|
|
1540
|
+
ensureVisited(state, needed);
|
|
1541
|
+
}
|
|
1542
|
+
function ensureVisited(state, needed) {
|
|
1543
|
+
if (needed <= state.visited.length) return;
|
|
1544
|
+
let capacity = state.visited.length === 0 ? 16 : state.visited.length;
|
|
1545
|
+
while (capacity < needed) capacity *= 2;
|
|
1546
|
+
const next = new Uint32Array(capacity);
|
|
1547
|
+
next.set(state.visited);
|
|
1548
|
+
state.visited = next;
|
|
1549
|
+
}
|
|
1550
|
+
function nextVisitStamp(state) {
|
|
1551
|
+
state.visitStamp++;
|
|
1552
|
+
if (state.visitStamp === 4294967295) {
|
|
1553
|
+
state.visited.fill(0);
|
|
1554
|
+
state.visitStamp = 1;
|
|
1555
|
+
}
|
|
1556
|
+
return state.visitStamp;
|
|
1557
|
+
}
|
|
1558
|
+
function reachTombstone(state, ord) {
|
|
1559
|
+
if (ord < state.tombstones.length) return true;
|
|
1560
|
+
if (ord >= state.adjacency.handles.tombstones.byteLength) return false;
|
|
1561
|
+
state.tombstones = fixedView(state.adjacency.handles.tombstones, Uint8Array);
|
|
1562
|
+
return ord < state.tombstones.length;
|
|
1563
|
+
}
|
|
1564
|
+
function isTombstoned(state, ord) {
|
|
1565
|
+
return ord >= 0 && reachTombstone(state, ord) && state.tombstones[ord] === 1;
|
|
1566
|
+
}
|
|
1567
|
+
function nodeExists(state, ord) {
|
|
1568
|
+
return hasNode(state.adjacency, ord);
|
|
1569
|
+
}
|
|
1570
|
+
function nodeMaxLayer(state, ord) {
|
|
1571
|
+
return nodeLevel(state.adjacency, ord);
|
|
1572
|
+
}
|
|
1573
|
+
function toDistance(a, b, magA, magB, metric) {
|
|
1574
|
+
switch (metric) {
|
|
1575
|
+
case "cosine":
|
|
1576
|
+
return 1 - cosineSimilarityWithMagnitudes(a, b, magA, magB);
|
|
1577
|
+
case "dotProduct":
|
|
1578
|
+
return -dotProduct(a, b);
|
|
1579
|
+
case "euclidean":
|
|
1580
|
+
return euclideanDistance(a, b);
|
|
1581
|
+
}
|
|
1582
|
+
}
|
|
1583
|
+
function toScore(distance, metric) {
|
|
1584
|
+
switch (metric) {
|
|
1585
|
+
case "cosine":
|
|
1586
|
+
return 1 - distance;
|
|
1587
|
+
case "dotProduct":
|
|
1588
|
+
return -distance;
|
|
1589
|
+
case "euclidean":
|
|
1590
|
+
return 1 / (1 + distance);
|
|
1591
|
+
}
|
|
1592
|
+
}
|
|
1593
|
+
function levelOfOrdinal(ord, mL) {
|
|
1594
|
+
return Math.min(Math.floor(-Math.log(unitDrawOf(ord)) * mL), MAX_LAYER_CAP);
|
|
1595
|
+
}
|
|
1596
|
+
function buildsFromCodes(state) {
|
|
1597
|
+
return activeQuantizer(state) !== void 0;
|
|
1598
|
+
}
|
|
1599
|
+
function activeQuantizer(state) {
|
|
1600
|
+
const quantizer = state.quantizer;
|
|
1601
|
+
if (quantizer === void 0 || !quantizer.isCalibrated()) return void 0;
|
|
1602
|
+
return quantizer;
|
|
1603
|
+
}
|
|
1604
|
+
function nodeDistanceFunction(state, metric) {
|
|
1605
|
+
const storeDistance = state.store.pairDistance(metric);
|
|
1606
|
+
const quantizer = state.quantizer;
|
|
1607
|
+
if (quantizer === void 0 || !buildsFromCodes(state)) return storeDistance;
|
|
1608
|
+
const codeDistance = quantizer.pairDistance();
|
|
1609
|
+
return (aOrd, bOrd) => {
|
|
1610
|
+
const estimated = codeDistance(aOrd, bOrd);
|
|
1611
|
+
return estimated === Number.POSITIVE_INFINITY ? storeDistance(aOrd, bOrd) : estimated;
|
|
1612
|
+
};
|
|
1613
|
+
}
|
|
1614
|
+
function queryDistanceByOrd(state, qVec, qMag, ord, metric) {
|
|
1615
|
+
return state.store.distanceFromQuery(qVec, qMag, ord, metric);
|
|
1616
|
+
}
|
|
1617
|
+
function maxConns(state, layer) {
|
|
1618
|
+
return layer === 0 ? state.Mmax0 : state.M;
|
|
1619
|
+
}
|
|
1620
|
+
function addConnection(connections, ord) {
|
|
1621
|
+
for (let i = 0; i < connections.length; i++) {
|
|
1622
|
+
if (connections[i] === ord) return;
|
|
1623
|
+
}
|
|
1624
|
+
connections.push(ord);
|
|
1625
|
+
}
|
|
1626
|
+
|
|
1627
|
+
// src/vector/hnsw/workspace.ts
|
|
1628
|
+
function createList(capacity) {
|
|
1629
|
+
return { ords: new Int32Array(capacity), distances: new Float64Array(capacity), size: 0 };
|
|
1630
|
+
}
|
|
1631
|
+
function createHeap(greatestFirst) {
|
|
1632
|
+
return { ...createList(INITIAL_LIST_CAPACITY), greatestFirst, topOrd: -1, topDistance: 0 };
|
|
1633
|
+
}
|
|
1634
|
+
function createHNSWWorkspace() {
|
|
1635
|
+
return {
|
|
1636
|
+
frontier: createHeap(false),
|
|
1637
|
+
found: createHeap(true),
|
|
1638
|
+
entryPoints: new Int32Array(INITIAL_LIST_CAPACITY),
|
|
1639
|
+
entryPointCount: 0,
|
|
1640
|
+
traversal: createList(INITIAL_LIST_CAPACITY),
|
|
1641
|
+
working: createList(INITIAL_LIST_CAPACITY),
|
|
1642
|
+
linkSelections: [],
|
|
1643
|
+
pruneCandidates: createList(INITIAL_LIST_CAPACITY),
|
|
1644
|
+
pruneSelection: createList(INITIAL_LIST_CAPACITY),
|
|
1645
|
+
repairCandidates: createList(INITIAL_LIST_CAPACITY),
|
|
1646
|
+
repairSelection: createList(INITIAL_LIST_CAPACITY),
|
|
1647
|
+
droppedLinks: createList(INITIAL_LIST_CAPACITY)
|
|
1648
|
+
};
|
|
1649
|
+
}
|
|
1650
|
+
function linkSelectionsFor(workspace, layers) {
|
|
1651
|
+
const selections = workspace.linkSelections;
|
|
1652
|
+
while (selections.length < layers) selections.push(createList(INITIAL_LIST_CAPACITY));
|
|
1653
|
+
return selections;
|
|
1654
|
+
}
|
|
1655
|
+
function ensureListCapacity(list, needed) {
|
|
1656
|
+
if (needed <= list.ords.length) return;
|
|
1657
|
+
let capacity = list.ords.length === 0 ? INITIAL_LIST_CAPACITY : list.ords.length;
|
|
1658
|
+
while (capacity < needed) capacity *= 2;
|
|
1659
|
+
const ords = new Int32Array(capacity);
|
|
1660
|
+
ords.set(list.ords);
|
|
1661
|
+
list.ords = ords;
|
|
1662
|
+
const distances = new Float64Array(capacity);
|
|
1663
|
+
distances.set(list.distances);
|
|
1664
|
+
list.distances = distances;
|
|
1665
|
+
}
|
|
1666
|
+
function appendToList(list, ord, distance) {
|
|
1667
|
+
ensureListCapacity(list, list.size + 1);
|
|
1668
|
+
list.ords[list.size] = ord;
|
|
1669
|
+
list.distances[list.size] = distance;
|
|
1670
|
+
list.size += 1;
|
|
1684
1671
|
}
|
|
1685
1672
|
function copyList(source, target) {
|
|
1686
1673
|
ensureListCapacity(target, source.size);
|
|
@@ -2164,6 +2151,42 @@ function countIncomingBeforeWriting(state, holdsGraphLock) {
|
|
|
2164
2151
|
}
|
|
2165
2152
|
}
|
|
2166
2153
|
|
|
2154
|
+
// src/vector/ordinal-filter.ts
|
|
2155
|
+
function createOrdinalFilter(slots) {
|
|
2156
|
+
return { bits: new Uint8Array(slots + 7 >>> 3), count: 0 };
|
|
2157
|
+
}
|
|
2158
|
+
function addToOrdinalFilter(filter, ordinal) {
|
|
2159
|
+
const index = ordinal >>> 3;
|
|
2160
|
+
if (index >= filter.bits.length) return;
|
|
2161
|
+
const bit = 1 << (ordinal & 7);
|
|
2162
|
+
if ((filter.bits[index] & bit) !== 0) return;
|
|
2163
|
+
filter.bits[index] |= bit;
|
|
2164
|
+
filter.count += 1;
|
|
2165
|
+
}
|
|
2166
|
+
function ordinalFilterHas(filter, ordinal) {
|
|
2167
|
+
const index = ordinal >>> 3;
|
|
2168
|
+
if (index >= filter.bits.length) return false;
|
|
2169
|
+
return (filter.bits[index] & 1 << (ordinal & 7)) !== 0;
|
|
2170
|
+
}
|
|
2171
|
+
function removeFromOrdinalFilter(filter, ordinal) {
|
|
2172
|
+
const index = ordinal >>> 3;
|
|
2173
|
+
if (index >= filter.bits.length) return;
|
|
2174
|
+
const bit = 1 << (ordinal & 7);
|
|
2175
|
+
if ((filter.bits[index] & bit) === 0) return;
|
|
2176
|
+
filter.bits[index] &= ~bit;
|
|
2177
|
+
filter.count -= 1;
|
|
2178
|
+
}
|
|
2179
|
+
function* ordinalFilterValues(filter) {
|
|
2180
|
+
const bits = filter.bits;
|
|
2181
|
+
for (let index = 0; index < bits.length; index++) {
|
|
2182
|
+
const byte = bits[index];
|
|
2183
|
+
if (byte === 0) continue;
|
|
2184
|
+
for (let offset = 0; offset < 8; offset++) {
|
|
2185
|
+
if ((byte & 1 << offset) !== 0) yield index << 3 | offset;
|
|
2186
|
+
}
|
|
2187
|
+
}
|
|
2188
|
+
}
|
|
2189
|
+
|
|
2167
2190
|
// src/vector/hnsw/graph-ops.ts
|
|
2168
2191
|
function readNeighborsLocked(state, ord, layer) {
|
|
2169
2192
|
for (; ; ) {
|
|
@@ -2300,17 +2323,6 @@ function everyCandidateWasHeld() {
|
|
|
2300
2323
|
return true;
|
|
2301
2324
|
}
|
|
2302
2325
|
|
|
2303
|
-
// src/vector/hnsw/insertion-order.ts
|
|
2304
|
-
function shuffleInPlace(items) {
|
|
2305
|
-
for (let i = items.length - 1; i > 0; i--) {
|
|
2306
|
-
const j = Math.floor(Math.random() * (i + 1));
|
|
2307
|
-
const held = items[i];
|
|
2308
|
-
items[i] = items[j];
|
|
2309
|
-
items[j] = held;
|
|
2310
|
-
}
|
|
2311
|
-
return items;
|
|
2312
|
-
}
|
|
2313
|
-
|
|
2314
2326
|
// src/vector/hnsw/mutation.ts
|
|
2315
2327
|
function clearTombstone(state, ord) {
|
|
2316
2328
|
if (!reachTombstone(state, ord) || Atomics.load(state.tombstones, ord) !== 1) return;
|
|
@@ -2438,7 +2450,7 @@ function writeRecordBeforePlacement(state, ord) {
|
|
|
2438
2450
|
function placeThroughTheCore(state, ord, holdsGraphLock) {
|
|
2439
2451
|
let field = nativeFieldFor(state);
|
|
2440
2452
|
if (field === null) return false;
|
|
2441
|
-
const level2 =
|
|
2453
|
+
const level2 = levelOfOrdinal(ord, state.mL);
|
|
2442
2454
|
for (let request = 0; request < PLACEMENT_ROOM_REQUESTS && field !== null; request++) {
|
|
2443
2455
|
ensureUpperRoom(state.adjacency, level2);
|
|
2444
2456
|
const placement = nativePlace(state, field, state.buildMetric, ord, level2, holdsGraphLock);
|
|
@@ -2465,7 +2477,7 @@ function insertNode(state, ord, holdsGraphLock = false) {
|
|
|
2465
2477
|
if (!holdsGraphLock) lockGraphShared(state.locks);
|
|
2466
2478
|
try {
|
|
2467
2479
|
clearTombstone(state, ord);
|
|
2468
|
-
const level2 =
|
|
2480
|
+
const level2 = levelOfOrdinal(ord, state.mL);
|
|
2469
2481
|
createNode(state.adjacency, ord, level2);
|
|
2470
2482
|
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
2471
2483
|
if (!claimEntryIfEmpty(state, ord, level2)) linkNode(state, ord, level2);
|
|
@@ -2596,1425 +2608,1424 @@ function rebuild(state) {
|
|
|
2596
2608
|
connectAfterBuild(state);
|
|
2597
2609
|
}
|
|
2598
2610
|
|
|
2599
|
-
// src/vector/
|
|
2600
|
-
|
|
2601
|
-
|
|
2602
|
-
|
|
2603
|
-
|
|
2604
|
-
|
|
2605
|
-
|
|
2606
|
-
|
|
2607
|
-
|
|
2608
|
-
|
|
2609
|
-
|
|
2610
|
-
|
|
2611
|
-
|
|
2612
|
-
|
|
2613
|
-
store.handle,
|
|
2614
|
-
query,
|
|
2615
|
-
nativeMetricCode(metric),
|
|
2616
|
-
candidateCount,
|
|
2617
|
-
state.locks.threadSlot,
|
|
2618
|
-
store.ordinals,
|
|
2619
|
-
store.distances,
|
|
2620
|
-
filter === void 0 ? null : filter.bits
|
|
2621
|
-
);
|
|
2622
|
-
} catch (error) {
|
|
2623
|
-
stopUsingTheNativeSearchCore(error);
|
|
2624
|
-
return false;
|
|
2611
|
+
// src/vector/hnsw/numbered-graph.ts
|
|
2612
|
+
var NO_NUMBER = -1;
|
|
2613
|
+
var NO_ORDINAL = -1;
|
|
2614
|
+
var NO_LAYER = -1;
|
|
2615
|
+
var BYTES_PER_VALUE = 4;
|
|
2616
|
+
var LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
|
|
2617
|
+
function swapEveryValue(bytes) {
|
|
2618
|
+
for (let i = 0; i + 3 < bytes.length; i += BYTES_PER_VALUE) {
|
|
2619
|
+
const first = bytes[i];
|
|
2620
|
+
const second = bytes[i + 1];
|
|
2621
|
+
bytes[i] = bytes[i + 3];
|
|
2622
|
+
bytes[i + 1] = bytes[i + 2];
|
|
2623
|
+
bytes[i + 2] = second;
|
|
2624
|
+
bytes[i + 3] = first;
|
|
2625
2625
|
}
|
|
2626
|
-
if (count < 0) return false;
|
|
2627
|
-
copyCandidates(store, count, candidates);
|
|
2628
|
-
return true;
|
|
2629
2626
|
}
|
|
2630
|
-
function
|
|
2631
|
-
const
|
|
2632
|
-
|
|
2633
|
-
|
|
2634
|
-
let kept = 0;
|
|
2635
|
-
for (let i = 0; i < candidates.size && kept < nearest; i++) {
|
|
2636
|
-
const ord = candidates.ords[i];
|
|
2637
|
-
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2638
|
-
ordinals[kept++] = ord;
|
|
2639
|
-
}
|
|
2640
|
-
const distances = nativeScores(store, query, metric, kept);
|
|
2641
|
-
if (distances === null) return null;
|
|
2642
|
-
const hits = [];
|
|
2643
|
-
for (let i = 0; i < kept; i++) {
|
|
2644
|
-
if (distances[i] === Number.POSITIVE_INFINITY) continue;
|
|
2645
|
-
const score = toScore(distances[i], metric);
|
|
2646
|
-
if (score < minSimilarity) continue;
|
|
2647
|
-
hits.push({ ord: ordinals[i], score });
|
|
2648
|
-
}
|
|
2649
|
-
return hits;
|
|
2627
|
+
function littleEndianBytesOf(values) {
|
|
2628
|
+
const bytes = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
|
|
2629
|
+
if (!LITTLE_ENDIAN) swapEveryValue(bytes);
|
|
2630
|
+
return bytes;
|
|
2650
2631
|
}
|
|
2651
|
-
|
|
2652
|
-
|
|
2653
|
-
|
|
2654
|
-
var WIDE_DIMENSION_LIMIT = 1024;
|
|
2655
|
-
var DEFAULT_EF_SEARCH_MARGIN_BY_BAND = {
|
|
2656
|
-
narrow: 50,
|
|
2657
|
-
middle: 75,
|
|
2658
|
-
wide: 0
|
|
2659
|
-
};
|
|
2660
|
-
var DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT = 18;
|
|
2661
|
-
var DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS = {
|
|
2662
|
-
1: 3,
|
|
2663
|
-
2: 3,
|
|
2664
|
-
4: 1,
|
|
2665
|
-
8: 1
|
|
2666
|
-
};
|
|
2667
|
-
var DEFAULT_RESCORE_DEPTH_BY_BITS = {
|
|
2668
|
-
1: {
|
|
2669
|
-
narrow: { perLimit: 3.23, perSquareRootOfLimit: 55.9 },
|
|
2670
|
-
middle: { perLimit: 2.2, perSquareRootOfLimit: 27 },
|
|
2671
|
-
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2672
|
-
},
|
|
2673
|
-
2: {
|
|
2674
|
-
narrow: { perLimit: 2.6, perSquareRootOfLimit: 22.5 },
|
|
2675
|
-
middle: { perLimit: 1, perSquareRootOfLimit: 16 },
|
|
2676
|
-
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2677
|
-
},
|
|
2678
|
-
4: {
|
|
2679
|
-
narrow: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2680
|
-
middle: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2681
|
-
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
2682
|
-
},
|
|
2683
|
-
8: {
|
|
2684
|
-
narrow: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2685
|
-
middle: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2686
|
-
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
2632
|
+
function valuesOf(bytes) {
|
|
2633
|
+
if (LITTLE_ENDIAN && bytes.byteOffset % BYTES_PER_VALUE === 0) {
|
|
2634
|
+
return new Uint32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / BYTES_PER_VALUE));
|
|
2687
2635
|
}
|
|
2688
|
-
|
|
2689
|
-
|
|
2690
|
-
|
|
2691
|
-
function dimensionBand(dimension) {
|
|
2692
|
-
if (dimension < NARROW_DIMENSION_LIMIT) return "narrow";
|
|
2693
|
-
return dimension < WIDE_DIMENSION_LIMIT ? "middle" : "wide";
|
|
2694
|
-
}
|
|
2695
|
-
function defaultRescoreDepth(bits, dimension, k) {
|
|
2696
|
-
const band = dimensionBand(dimension);
|
|
2697
|
-
const { perLimit, perSquareRootOfLimit } = DEFAULT_RESCORE_DEPTH_BY_BITS[bits][band];
|
|
2698
|
-
const floor = DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS[bits] * k;
|
|
2699
|
-
const depth = Math.max(floor, Math.ceil(perLimit * k + perSquareRootOfLimit * Math.sqrt(k)));
|
|
2700
|
-
if (bits !== 2 || band !== "middle") return depth;
|
|
2701
|
-
const withinDefaultWalk = Math.min(
|
|
2702
|
-
k + DEFAULT_EF_SEARCH_MARGIN_BY_BAND.middle,
|
|
2703
|
-
Math.ceil(k + DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT * Math.sqrt(k))
|
|
2704
|
-
);
|
|
2705
|
-
return Math.max(depth, withinDefaultWalk);
|
|
2636
|
+
const copy = bytes.slice(0, bytes.byteLength - bytes.byteLength % BYTES_PER_VALUE);
|
|
2637
|
+
if (!LITTLE_ENDIAN) swapEveryValue(copy);
|
|
2638
|
+
return new Uint32Array(copy.buffer, 0, copy.byteLength / BYTES_PER_VALUE);
|
|
2706
2639
|
}
|
|
2707
|
-
function
|
|
2708
|
-
|
|
2640
|
+
function savedTopLayer(state, ordinal) {
|
|
2641
|
+
if (ordinal === NO_ORDINAL) return NO_LAYER;
|
|
2642
|
+
return Math.min(nodeMaxLayer(state, ordinal), MAX_LAYER_CAP);
|
|
2709
2643
|
}
|
|
2710
|
-
|
|
2711
|
-
|
|
2712
|
-
|
|
2713
|
-
|
|
2714
|
-
|
|
2715
|
-
|
|
2716
|
-
const window = options.rescoreWindow ?? k;
|
|
2717
|
-
let depth = window;
|
|
2718
|
-
if (quantizer !== void 0) {
|
|
2719
|
-
depth = options.oversample === void 0 ? defaultRescoreDepth(quantizer.bits, state.dimension, window) : Math.ceil(window * options.oversample);
|
|
2644
|
+
function neighbourValueCount(state, topLayers, start, end) {
|
|
2645
|
+
let values = 0;
|
|
2646
|
+
for (let number = start; number < end; number++) {
|
|
2647
|
+
const top = topLayers[number];
|
|
2648
|
+
if (top < 0) continue;
|
|
2649
|
+
values += state.adjacency.level0Stride + top * state.adjacency.upperStride;
|
|
2720
2650
|
}
|
|
2721
|
-
|
|
2722
|
-
|
|
2723
|
-
|
|
2724
|
-
const
|
|
2725
|
-
const
|
|
2726
|
-
|
|
2727
|
-
|
|
2728
|
-
|
|
2729
|
-
|
|
2651
|
+
return values;
|
|
2652
|
+
}
|
|
2653
|
+
function serializePart(state, numbers, start, end) {
|
|
2654
|
+
const { numberOfOrdinal, ordinalOfNumber, topLayers } = numbers;
|
|
2655
|
+
const adjacency = state.adjacency;
|
|
2656
|
+
const levels = new Uint8Array(end - start);
|
|
2657
|
+
const values = new Uint32Array(neighbourValueCount(state, topLayers, start, end));
|
|
2658
|
+
let cursor = 0;
|
|
2659
|
+
for (let number = start; number < end; number++) {
|
|
2660
|
+
const top = topLayers[number];
|
|
2661
|
+
levels[number - start] = top + 1;
|
|
2662
|
+
for (let layer = 0; layer <= top; layer++) {
|
|
2663
|
+
const base = layerBase(adjacency, ordinalOfNumber[number], layer);
|
|
2664
|
+
const array = layerArray(adjacency, layer);
|
|
2665
|
+
const held = base === -1 ? 0 : Math.min(array[base], maxConns(state, layer));
|
|
2666
|
+
const countAt = cursor;
|
|
2667
|
+
cursor += 1;
|
|
2668
|
+
for (let i = 1; i <= held; i++) {
|
|
2669
|
+
const neighbourOrdinal = array[base + i];
|
|
2670
|
+
if (neighbourOrdinal < 0 || neighbourOrdinal >= numberOfOrdinal.length) continue;
|
|
2671
|
+
const neighbour = numberOfOrdinal[neighbourOrdinal];
|
|
2672
|
+
if (neighbour === NO_NUMBER || neighbour === number || topLayers[neighbour] < layer) continue;
|
|
2673
|
+
values[cursor] = neighbour;
|
|
2674
|
+
cursor += 1;
|
|
2675
|
+
}
|
|
2676
|
+
values[countAt] = cursor - countAt - 1;
|
|
2730
2677
|
}
|
|
2731
2678
|
}
|
|
2732
|
-
|
|
2733
|
-
|
|
2734
|
-
|
|
2735
|
-
const
|
|
2736
|
-
|
|
2737
|
-
|
|
2738
|
-
const
|
|
2739
|
-
if (
|
|
2679
|
+
return { levels, neighbours: littleEndianBytesOf(values.subarray(0, cursor)) };
|
|
2680
|
+
}
|
|
2681
|
+
function serializeNumberedGraphParts(state, numberOfOrdinal, ordinalOfNumber, partSize) {
|
|
2682
|
+
const slots = adjacencySlots(state.adjacency);
|
|
2683
|
+
const topLayers = new Int8Array(ordinalOfNumber.length).fill(-1);
|
|
2684
|
+
for (let number = 0; number < ordinalOfNumber.length; number++) {
|
|
2685
|
+
const ordinal = ordinalOfNumber[number];
|
|
2686
|
+
if (ordinal >= slots) continue;
|
|
2687
|
+
topLayers[number] = savedTopLayer(state, ordinal);
|
|
2740
2688
|
}
|
|
2741
|
-
|
|
2742
|
-
|
|
2689
|
+
const entryOrdinal = entryPointOf(state);
|
|
2690
|
+
const entryNumber = entryOrdinal >= 0 && entryOrdinal < numberOfOrdinal.length ? numberOfOrdinal[entryOrdinal] : NO_NUMBER;
|
|
2691
|
+
const entryHoldsNode = entryNumber !== NO_NUMBER && topLayers[entryNumber] >= 0;
|
|
2692
|
+
const header = {
|
|
2693
|
+
entryPoint: entryHoldsNode ? entryNumber : null,
|
|
2694
|
+
maxLayer: Math.max(0, Math.min(topLayerOf(state), MAX_LAYER_CAP)),
|
|
2695
|
+
m: state.M,
|
|
2696
|
+
efConstruction: state.efCons,
|
|
2697
|
+
metric: state.buildMetric
|
|
2698
|
+
};
|
|
2699
|
+
const numbers = { numberOfOrdinal, ordinalOfNumber, topLayers };
|
|
2700
|
+
const parts = [];
|
|
2701
|
+
for (let start = 0; start < ordinalOfNumber.length; start += partSize) {
|
|
2702
|
+
const end = Math.min(start + partSize, ordinalOfNumber.length);
|
|
2703
|
+
parts.push({ ...header, ...serializePart(state, numbers, start, end) });
|
|
2743
2704
|
}
|
|
2744
|
-
|
|
2745
|
-
|
|
2746
|
-
|
|
2747
|
-
|
|
2748
|
-
|
|
2749
|
-
|
|
2750
|
-
|
|
2751
|
-
|
|
2752
|
-
|
|
2753
|
-
|
|
2754
|
-
|
|
2705
|
+
return parts;
|
|
2706
|
+
}
|
|
2707
|
+
function graphWithoutNodes(part, firstNumber, numbers) {
|
|
2708
|
+
const values = valuesOf(part.neighbours);
|
|
2709
|
+
const levels = part.levels.slice();
|
|
2710
|
+
const kept = new Uint32Array(values.length);
|
|
2711
|
+
let cursor = 0;
|
|
2712
|
+
let length = 0;
|
|
2713
|
+
for (let at = 0; at < part.levels.length; at++) {
|
|
2714
|
+
const start = cursor;
|
|
2715
|
+
for (let layer = 0; layer < part.levels[at]; layer++) cursor += values[cursor] + 1;
|
|
2716
|
+
if (numbers.has(firstNumber + at)) {
|
|
2717
|
+
levels[at] = 0;
|
|
2718
|
+
continue;
|
|
2755
2719
|
}
|
|
2756
|
-
|
|
2757
|
-
|
|
2758
|
-
unlockGraphShared(state.locks);
|
|
2720
|
+
kept.set(values.subarray(start, cursor), length);
|
|
2721
|
+
length += cursor - start;
|
|
2759
2722
|
}
|
|
2760
|
-
|
|
2723
|
+
const entryPoint = part.entryPoint !== null && numbers.has(part.entryPoint) ? null : part.entryPoint;
|
|
2724
|
+
return { ...part, entryPoint, levels, neighbours: littleEndianBytesOf(kept.subarray(0, length)) };
|
|
2761
2725
|
}
|
|
2762
|
-
function
|
|
2763
|
-
|
|
2726
|
+
function endsInsideAList() {
|
|
2727
|
+
throw new NarsilError(
|
|
2728
|
+
ErrorCodes.PERSISTENCE_LOAD_FAILED,
|
|
2729
|
+
"Invalid vector graph payload: neighbours ends inside a list"
|
|
2730
|
+
);
|
|
2764
2731
|
}
|
|
2765
|
-
function
|
|
2766
|
-
const
|
|
2767
|
-
|
|
2768
|
-
|
|
2769
|
-
|
|
2732
|
+
function requireWholeNeighbourLists(graph) {
|
|
2733
|
+
const values = valuesOf(graph.neighbours);
|
|
2734
|
+
if (values.length * BYTES_PER_VALUE !== graph.neighbours.byteLength) endsInsideAList();
|
|
2735
|
+
let cursor = 0;
|
|
2736
|
+
for (let number = 0; number < graph.levels.length; number++) {
|
|
2737
|
+
for (let layer = 0; layer < graph.levels[number]; layer++) {
|
|
2738
|
+
if (cursor >= values.length) endsInsideAList();
|
|
2739
|
+
const count = values[cursor];
|
|
2740
|
+
if (count > values.length - cursor - 1) endsInsideAList();
|
|
2741
|
+
cursor += count + 1;
|
|
2742
|
+
}
|
|
2770
2743
|
}
|
|
2771
|
-
return resolved;
|
|
2772
2744
|
}
|
|
2773
|
-
function
|
|
2774
|
-
|
|
2775
|
-
|
|
2776
|
-
|
|
2777
|
-
return
|
|
2745
|
+
function topLayerInParts(graph, number) {
|
|
2746
|
+
const part = graph.parts[Math.floor(number / graph.partSize)];
|
|
2747
|
+
if (part === void 0) return -1;
|
|
2748
|
+
const at = number % graph.partSize;
|
|
2749
|
+
return at < part.levels.length ? part.levels[at] - 1 : -1;
|
|
2778
2750
|
}
|
|
2779
|
-
function
|
|
2780
|
-
|
|
2781
|
-
|
|
2782
|
-
|
|
2783
|
-
|
|
2784
|
-
|
|
2785
|
-
|
|
2786
|
-
|
|
2751
|
+
function highestNodeOrdinal(graph, ordinalAt) {
|
|
2752
|
+
let highest = -1;
|
|
2753
|
+
for (let p = 0; p < graph.parts.length; p++) {
|
|
2754
|
+
const levels = graph.parts[p].levels;
|
|
2755
|
+
for (let at = 0; at < levels.length; at++) {
|
|
2756
|
+
const ordinal = ordinalAt(p * graph.partSize + at);
|
|
2757
|
+
if (levels[at] > 0 && ordinal > highest) highest = ordinal;
|
|
2758
|
+
}
|
|
2787
2759
|
}
|
|
2788
|
-
|
|
2789
|
-
for (const hit of ordered) {
|
|
2790
|
-
if (taken.length >= k && hit.score < taken[k - 1].score) break;
|
|
2791
|
-
const docId = docIdOf(hit.ord);
|
|
2792
|
-
if (docId !== void 0) taken.push({ ord: hit.ord, score: hit.score, docId });
|
|
2793
|
-
}
|
|
2794
|
-
return taken.sort(bestFirst).slice(0, k);
|
|
2760
|
+
return highest;
|
|
2795
2761
|
}
|
|
2796
|
-
function
|
|
2797
|
-
|
|
2798
|
-
|
|
2799
|
-
|
|
2800
|
-
|
|
2801
|
-
|
|
2802
|
-
|
|
2803
|
-
|
|
2804
|
-
|
|
2805
|
-
|
|
2806
|
-
|
|
2762
|
+
function deserializeNumberedGraph(state, graph, ordinalOfNumber) {
|
|
2763
|
+
for (const part of graph.parts) requireWholeNeighbourLists(part);
|
|
2764
|
+
resetGraph(state);
|
|
2765
|
+
const ordinalAt = (number) => number < ordinalOfNumber.length ? ordinalOfNumber[number] : NO_ORDINAL;
|
|
2766
|
+
const highestOrdinal = highestNodeOrdinal(graph, ordinalAt);
|
|
2767
|
+
if (highestOrdinal >= 0) ensureCapacity(state, highestOrdinal + 1);
|
|
2768
|
+
const kept = [];
|
|
2769
|
+
let highestLayer = -1;
|
|
2770
|
+
let nodeOnHighestLayer = NO_ORDINAL;
|
|
2771
|
+
for (let p = 0; p < graph.parts.length; p++) {
|
|
2772
|
+
const part = graph.parts[p];
|
|
2773
|
+
const values = valuesOf(part.neighbours);
|
|
2774
|
+
let cursor = 0;
|
|
2775
|
+
for (let at = 0; at < part.levels.length; at++) {
|
|
2776
|
+
const number = p * graph.partSize + at;
|
|
2777
|
+
const top = part.levels[at] - 1;
|
|
2778
|
+
if (top < 0) continue;
|
|
2779
|
+
const ordinal = ordinalAt(number);
|
|
2780
|
+
const keptTop = Math.min(top, MAX_LAYER_CAP);
|
|
2781
|
+
if (ordinal !== NO_ORDINAL) {
|
|
2782
|
+
createNode(state.adjacency, ordinal, keptTop);
|
|
2783
|
+
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
2784
|
+
if (keptTop > highestLayer) {
|
|
2785
|
+
highestLayer = keptTop;
|
|
2786
|
+
nodeOnHighestLayer = ordinal;
|
|
2787
|
+
}
|
|
2788
|
+
}
|
|
2789
|
+
for (let layer = 0; layer <= top; layer++) {
|
|
2790
|
+
const count = values[cursor];
|
|
2791
|
+
kept.length = 0;
|
|
2792
|
+
const limit = maxConns(state, layer);
|
|
2793
|
+
for (let i = 1; i <= count && kept.length < limit; i++) {
|
|
2794
|
+
const neighbour = values[cursor + i];
|
|
2795
|
+
const neighbourOrdinal = ordinalAt(neighbour);
|
|
2796
|
+
if (neighbourOrdinal === NO_ORDINAL || neighbour === number) continue;
|
|
2797
|
+
if (topLayerInParts(graph, neighbour) < layer) continue;
|
|
2798
|
+
if (!kept.includes(neighbourOrdinal)) kept.push(neighbourOrdinal);
|
|
2799
|
+
}
|
|
2800
|
+
cursor += count + 1;
|
|
2801
|
+
if (ordinal !== NO_ORDINAL && layer <= keptTop) {
|
|
2802
|
+
writeNeighbors(state.adjacency, ordinal, layer, kept, kept.length);
|
|
2803
|
+
}
|
|
2804
|
+
}
|
|
2805
|
+
}
|
|
2807
2806
|
}
|
|
2808
|
-
const
|
|
2809
|
-
const
|
|
2810
|
-
const
|
|
2811
|
-
|
|
2812
|
-
const
|
|
2813
|
-
|
|
2814
|
-
|
|
2815
|
-
|
|
2807
|
+
const first = graph.parts[0];
|
|
2808
|
+
const entryPoint = first === void 0 ? null : first.entryPoint;
|
|
2809
|
+
const entryOrdinal = entryPoint === null ? NO_ORDINAL : ordinalAt(entryPoint);
|
|
2810
|
+
const entryTop = entryPoint === null ? -1 : Math.min(topLayerInParts(graph, entryPoint), MAX_LAYER_CAP);
|
|
2811
|
+
const entryIsUsable = entryOrdinal !== NO_ORDINAL && entryTop >= 0;
|
|
2812
|
+
Atomics.store(state.header, GRAPH_ENTRY_POINT, entryIsUsable ? entryOrdinal : nodeOnHighestLayer);
|
|
2813
|
+
Atomics.store(state.header, GRAPH_TOP_LAYER, entryIsUsable ? entryTop : highestLayer);
|
|
2814
|
+
leaveIncomingUncounted(state);
|
|
2816
2815
|
}
|
|
2817
|
-
|
|
2818
|
-
|
|
2819
|
-
|
|
2820
|
-
|
|
2821
|
-
|
|
2822
|
-
|
|
2823
|
-
|
|
2816
|
+
|
|
2817
|
+
// src/vector/hnsw/persistence.ts
|
|
2818
|
+
function resolveNodes(state, store, data) {
|
|
2819
|
+
const nodes = [];
|
|
2820
|
+
let maxOrd = -1;
|
|
2821
|
+
for (const [docId, maxLayer, layerConns] of data.nodes) {
|
|
2822
|
+
const ord = store.getOrdinal(docId);
|
|
2823
|
+
if (ord === void 0 || !store.holdsOrdinal(ord)) continue;
|
|
2824
|
+
const clampedMaxLayer = Math.min(Math.max(maxLayer, 0), MAX_LAYER_CAP);
|
|
2825
|
+
const layers = [];
|
|
2826
|
+
for (const [layer, neighbors] of layerConns) {
|
|
2827
|
+
if (layer < 0 || layer > clampedMaxLayer) continue;
|
|
2828
|
+
const limit = maxConns(state, layer);
|
|
2829
|
+
const resolved = [];
|
|
2830
|
+
for (const neighborDoc of neighbors) {
|
|
2831
|
+
if (resolved.length >= limit) break;
|
|
2832
|
+
const neighborOrd = store.getOrdinal(neighborDoc);
|
|
2833
|
+
if (neighborOrd === void 0) continue;
|
|
2834
|
+
addConnection(resolved, neighborOrd);
|
|
2835
|
+
if (neighborOrd > maxOrd) maxOrd = neighborOrd;
|
|
2836
|
+
}
|
|
2837
|
+
layers.push([layer, resolved]);
|
|
2838
|
+
}
|
|
2839
|
+
if (ord > maxOrd) maxOrd = ord;
|
|
2840
|
+
nodes.push({ ord, maxLayer: clampedMaxLayer, layers });
|
|
2824
2841
|
}
|
|
2825
|
-
return
|
|
2842
|
+
return { nodes, maxOrd };
|
|
2826
2843
|
}
|
|
2827
|
-
function
|
|
2828
|
-
|
|
2829
|
-
|
|
2830
|
-
|
|
2831
|
-
|
|
2832
|
-
const score = toScore(candidates.distances[i], metric);
|
|
2833
|
-
if (score < minSimilarity) continue;
|
|
2834
|
-
hits.push({ ord, score });
|
|
2844
|
+
function deserializeGraph(state, store, data) {
|
|
2845
|
+
resetGraph(state);
|
|
2846
|
+
const { nodes, maxOrd } = resolveNodes(state, store, data);
|
|
2847
|
+
if (maxOrd >= 0) {
|
|
2848
|
+
ensureCapacity(state, maxOrd + 1);
|
|
2835
2849
|
}
|
|
2836
|
-
|
|
2837
|
-
|
|
2838
|
-
|
|
2839
|
-
|
|
2840
|
-
|
|
2841
|
-
|
|
2842
|
-
if (rescored !== null) return rescored;
|
|
2843
|
-
const arena = state.store.prepareQueryArena(query);
|
|
2844
|
-
const qMag2 = arena ? arena.magnitude : magnitude(query);
|
|
2845
|
-
return rescoreWithFullPrecision(state, candidates, query, qMag2, arena, depth, metric, minSimilarity, filter);
|
|
2850
|
+
for (const node of nodes) {
|
|
2851
|
+
createNode(state.adjacency, node.ord, node.maxLayer);
|
|
2852
|
+
for (const [layer, neighbors] of node.layers) {
|
|
2853
|
+
writeNeighbors(state.adjacency, node.ord, layer, neighbors, neighbors.length);
|
|
2854
|
+
}
|
|
2855
|
+
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
2846
2856
|
}
|
|
2847
|
-
|
|
2848
|
-
|
|
2849
|
-
|
|
2850
|
-
|
|
2851
|
-
|
|
2852
|
-
const rescored = [];
|
|
2853
|
-
let taken = 0;
|
|
2854
|
-
for (let i = 0; i < candidates.size && taken < depth; i++) {
|
|
2855
|
-
const ord = candidates.ords[i];
|
|
2856
|
-
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2857
|
-
taken += 1;
|
|
2858
|
-
let fullDistance;
|
|
2859
|
-
if (arenaQuery) {
|
|
2860
|
-
fullDistance = state.store.distanceFromArena(arenaQuery, ord, metric);
|
|
2861
|
-
if (fullDistance === Number.POSITIVE_INFINITY) continue;
|
|
2862
|
-
} else {
|
|
2863
|
-
const entry = entryForOrd(state, ord);
|
|
2864
|
-
if (!entry) continue;
|
|
2865
|
-
fullDistance = toDistance(query, entry.vector, qMag, entry.magnitude, metric);
|
|
2857
|
+
if (data.entryPoint != null && data.entryPoint !== "") {
|
|
2858
|
+
const epOrd = store.getOrdinal(data.entryPoint);
|
|
2859
|
+
if (epOrd !== void 0 && nodeExists(state, epOrd)) {
|
|
2860
|
+
Atomics.store(state.header, GRAPH_ENTRY_POINT, epOrd);
|
|
2861
|
+
Atomics.store(state.header, GRAPH_TOP_LAYER, Math.min(Math.max(data.maxLayer, 0), MAX_LAYER_CAP));
|
|
2866
2862
|
}
|
|
2867
|
-
const score = toScore(fullDistance, metric);
|
|
2868
|
-
if (score < minSimilarity) continue;
|
|
2869
|
-
rescored.push({ ord, score });
|
|
2870
2863
|
}
|
|
2871
|
-
|
|
2864
|
+
if (entryPointOf(state) === -1 && Atomics.load(state.header, GRAPH_NODE_COUNT) > 0) {
|
|
2865
|
+
let bestOrd = -1;
|
|
2866
|
+
let bestLayer = -1;
|
|
2867
|
+
const slots = adjacencySlots(state.adjacency);
|
|
2868
|
+
for (let ord = 0; ord < slots; ord++) {
|
|
2869
|
+
const level2 = nodeMaxLayer(state, ord);
|
|
2870
|
+
if (level2 === -1) continue;
|
|
2871
|
+
if (level2 > bestLayer) {
|
|
2872
|
+
bestLayer = level2;
|
|
2873
|
+
bestOrd = ord;
|
|
2874
|
+
}
|
|
2875
|
+
}
|
|
2876
|
+
Atomics.store(state.header, GRAPH_ENTRY_POINT, bestOrd);
|
|
2877
|
+
Atomics.store(state.header, GRAPH_TOP_LAYER, bestLayer);
|
|
2878
|
+
}
|
|
2879
|
+
leaveIncomingUncounted(state);
|
|
2872
2880
|
}
|
|
2873
|
-
|
|
2874
|
-
|
|
2875
|
-
|
|
2876
|
-
|
|
2877
|
-
score: hit.score,
|
|
2878
|
-
termFrequencies: {},
|
|
2879
|
-
fieldLengths: {},
|
|
2880
|
-
idf: {}
|
|
2881
|
-
}));
|
|
2881
|
+
|
|
2882
|
+
// src/vector/hnsw/scratch-bytes.ts
|
|
2883
|
+
function listBytes(list) {
|
|
2884
|
+
return list.ords.byteLength + list.distances.byteLength;
|
|
2882
2885
|
}
|
|
2883
|
-
function
|
|
2884
|
-
|
|
2885
|
-
|
|
2886
|
+
function workspaceBytes(workspace) {
|
|
2887
|
+
let bytes = listBytes(workspace.frontier) + listBytes(workspace.found) + listBytes(workspace.traversal) + listBytes(workspace.working) + listBytes(workspace.pruneCandidates) + listBytes(workspace.pruneSelection) + listBytes(workspace.repairCandidates) + listBytes(workspace.repairSelection) + workspace.entryPoints.byteLength;
|
|
2888
|
+
for (const list of workspace.linkSelections) bytes += listBytes(list);
|
|
2889
|
+
return bytes;
|
|
2886
2890
|
}
|
|
2887
|
-
|
|
2888
|
-
|
|
2889
|
-
|
|
2890
|
-
|
|
2891
|
-
const adjacency = openAdjacency(handles, shape.m, shape.mMax0);
|
|
2892
|
-
return {
|
|
2893
|
-
dimension,
|
|
2894
|
-
store,
|
|
2895
|
-
quantizer,
|
|
2896
|
-
adjacency,
|
|
2897
|
-
locks: openGraphLocks(handles, threadSlot),
|
|
2898
|
-
header: handles.header,
|
|
2899
|
-
tombstones: fixedView(handles.tombstones, Uint8Array),
|
|
2900
|
-
visited: new Uint32Array(0),
|
|
2901
|
-
visitStamp: 0,
|
|
2902
|
-
workspace: createHNSWWorkspace(),
|
|
2903
|
-
neighborScratch: new Int32Array(adjacency.level0Stride),
|
|
2904
|
-
M: shape.m,
|
|
2905
|
-
Mmax0: shape.mMax0,
|
|
2906
|
-
efCons: shape.efConstruction,
|
|
2907
|
-
buildMetric: shape.metric,
|
|
2908
|
-
mL: 1 / Math.log(shape.m)
|
|
2909
|
-
};
|
|
2891
|
+
function searchScratchBytes(state) {
|
|
2892
|
+
const held = workspaceBytes(state.workspace) + state.neighborScratch.byteLength + state.visited.byteLength;
|
|
2893
|
+
const native = attachedNativeField(state);
|
|
2894
|
+
return native === null ? held : held + nativeScratchBytes(state, native);
|
|
2910
2895
|
}
|
|
2911
2896
|
|
|
2912
|
-
// src/vector/
|
|
2913
|
-
function
|
|
2914
|
-
|
|
2915
|
-
|
|
2916
|
-
|
|
2917
|
-
|
|
2918
|
-
return 4;
|
|
2919
|
-
case "osq2":
|
|
2920
|
-
return 2;
|
|
2921
|
-
case "osq1":
|
|
2922
|
-
return 1;
|
|
2923
|
-
default:
|
|
2924
|
-
return null;
|
|
2925
|
-
}
|
|
2926
|
-
}
|
|
2927
|
-
function clamp(value, low, high) {
|
|
2928
|
-
return Math.min(Math.max(value, low), high);
|
|
2897
|
+
// src/vector/native/walk.ts
|
|
2898
|
+
function copyCandidates(store, count, target) {
|
|
2899
|
+
ensureListCapacity(target, count);
|
|
2900
|
+
target.ords.set(store.ordinals.subarray(0, count));
|
|
2901
|
+
target.distances.set(store.distances.subarray(0, count));
|
|
2902
|
+
target.size = count;
|
|
2929
2903
|
}
|
|
2930
|
-
function
|
|
2931
|
-
|
|
2932
|
-
|
|
2933
|
-
|
|
2934
|
-
|
|
2935
|
-
|
|
2936
|
-
|
|
2904
|
+
function nativeTraverse(state, field, query, candidateCount, metric, filter, candidates) {
|
|
2905
|
+
const store = field.store;
|
|
2906
|
+
reserveOrdinals(store, candidateCount);
|
|
2907
|
+
let count;
|
|
2908
|
+
try {
|
|
2909
|
+
count = field.core.search(
|
|
2910
|
+
field.graph,
|
|
2911
|
+
store.handle,
|
|
2912
|
+
query,
|
|
2913
|
+
nativeMetricCode(metric),
|
|
2914
|
+
candidateCount,
|
|
2915
|
+
state.locks.threadSlot,
|
|
2916
|
+
store.ordinals,
|
|
2917
|
+
store.distances,
|
|
2918
|
+
filter === void 0 ? null : filter.bits
|
|
2919
|
+
);
|
|
2920
|
+
} catch (error) {
|
|
2921
|
+
stopUsingTheNativeSearchCore(error);
|
|
2922
|
+
return false;
|
|
2937
2923
|
}
|
|
2938
|
-
|
|
2924
|
+
if (count < 0) return false;
|
|
2925
|
+
copyCandidates(store, count, candidates);
|
|
2926
|
+
return true;
|
|
2939
2927
|
}
|
|
2940
|
-
|
|
2941
|
-
|
|
2942
|
-
|
|
2943
|
-
|
|
2944
|
-
|
|
2945
|
-
|
|
2946
|
-
|
|
2947
|
-
|
|
2928
|
+
function nativeRescoredHits(store, candidates, query, depth, metric, minSimilarity, filter) {
|
|
2929
|
+
const nearest = Math.min(candidates.size, depth);
|
|
2930
|
+
reserveOrdinals(store, nearest);
|
|
2931
|
+
const ordinals = store.ordinals;
|
|
2932
|
+
let kept = 0;
|
|
2933
|
+
for (let i = 0; i < candidates.size && kept < nearest; i++) {
|
|
2934
|
+
const ord = candidates.ords[i];
|
|
2935
|
+
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2936
|
+
ordinals[kept++] = ord;
|
|
2937
|
+
}
|
|
2938
|
+
const distances = nativeScores(store, query, metric, kept);
|
|
2939
|
+
if (distances === null) return null;
|
|
2940
|
+
const hits = [];
|
|
2941
|
+
for (let i = 0; i < kept; i++) {
|
|
2942
|
+
if (distances[i] === Number.POSITIVE_INFINITY) continue;
|
|
2943
|
+
const score = toScore(distances[i], metric);
|
|
2944
|
+
if (score < minSimilarity) continue;
|
|
2945
|
+
hits.push({ ord: ordinals[i], score });
|
|
2946
|
+
}
|
|
2947
|
+
return hits;
|
|
2948
2948
|
}
|
|
2949
|
-
|
|
2950
|
-
|
|
2949
|
+
|
|
2950
|
+
// src/vector/search-depth/constants.ts
|
|
2951
|
+
var NARROW_DIMENSION_LIMIT = 768;
|
|
2952
|
+
var WIDE_DIMENSION_LIMIT = 1024;
|
|
2953
|
+
var DEFAULT_EF_SEARCH_MARGIN_BY_BAND = {
|
|
2954
|
+
narrow: 50,
|
|
2955
|
+
middle: 75,
|
|
2956
|
+
wide: 0
|
|
2957
|
+
};
|
|
2958
|
+
var DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT = 18;
|
|
2959
|
+
var DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS = {
|
|
2960
|
+
1: 3,
|
|
2961
|
+
2: 3,
|
|
2962
|
+
4: 1,
|
|
2963
|
+
8: 1
|
|
2964
|
+
};
|
|
2965
|
+
var DEFAULT_RESCORE_DEPTH_BY_BITS = {
|
|
2966
|
+
1: {
|
|
2967
|
+
narrow: { perLimit: 3.23, perSquareRootOfLimit: 55.9 },
|
|
2968
|
+
middle: { perLimit: 2.2, perSquareRootOfLimit: 27 },
|
|
2969
|
+
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2970
|
+
},
|
|
2971
|
+
2: {
|
|
2972
|
+
narrow: { perLimit: 2.6, perSquareRootOfLimit: 22.5 },
|
|
2973
|
+
middle: { perLimit: 1, perSquareRootOfLimit: 16 },
|
|
2974
|
+
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2975
|
+
},
|
|
2976
|
+
4: {
|
|
2977
|
+
narrow: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2978
|
+
middle: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2979
|
+
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
2980
|
+
},
|
|
2981
|
+
8: {
|
|
2982
|
+
narrow: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2983
|
+
middle: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2984
|
+
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
2985
|
+
}
|
|
2986
|
+
};
|
|
2987
|
+
|
|
2988
|
+
// src/vector/search-depth/index.ts
|
|
2989
|
+
function dimensionBand(dimension) {
|
|
2990
|
+
if (dimension < NARROW_DIMENSION_LIMIT) return "narrow";
|
|
2991
|
+
return dimension < WIDE_DIMENSION_LIMIT ? "middle" : "wide";
|
|
2951
2992
|
}
|
|
2952
|
-
function
|
|
2953
|
-
|
|
2993
|
+
function defaultRescoreDepth(bits, dimension, k) {
|
|
2994
|
+
const band = dimensionBand(dimension);
|
|
2995
|
+
const { perLimit, perSquareRootOfLimit } = DEFAULT_RESCORE_DEPTH_BY_BITS[bits][band];
|
|
2996
|
+
const floor = DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS[bits] * k;
|
|
2997
|
+
const depth = Math.max(floor, Math.ceil(perLimit * k + perSquareRootOfLimit * Math.sqrt(k)));
|
|
2998
|
+
if (bits !== 2 || band !== "middle") return depth;
|
|
2999
|
+
const withinDefaultWalk = Math.min(
|
|
3000
|
+
k + DEFAULT_EF_SEARCH_MARGIN_BY_BAND.middle,
|
|
3001
|
+
Math.ceil(k + DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT * Math.sqrt(k))
|
|
3002
|
+
);
|
|
3003
|
+
return Math.max(depth, withinDefaultWalk);
|
|
2954
3004
|
}
|
|
2955
|
-
function
|
|
2956
|
-
|
|
2957
|
-
|
|
2958
|
-
|
|
2959
|
-
|
|
2960
|
-
|
|
2961
|
-
|
|
2962
|
-
|
|
3005
|
+
function defaultEfSearch(dimension, k) {
|
|
3006
|
+
return Math.max(DEFAULT_EF_SEARCH, k + DEFAULT_EF_SEARCH_MARGIN_BY_BAND[dimensionBand(dimension)]);
|
|
3007
|
+
}
|
|
3008
|
+
|
|
3009
|
+
// src/vector/hnsw/search.ts
|
|
3010
|
+
function traverse(state, query, k, searchMetric, options) {
|
|
3011
|
+
const calibrated = activeQuantizer(state);
|
|
3012
|
+
const quantizer = calibrated === void 0 || calibrated.size === 0 ? void 0 : calibrated;
|
|
3013
|
+
const useQuantized = quantizer !== void 0;
|
|
3014
|
+
const window = options.rescoreWindow ?? k;
|
|
3015
|
+
let depth = window;
|
|
3016
|
+
if (quantizer !== void 0) {
|
|
3017
|
+
depth = options.oversample === void 0 ? defaultRescoreDepth(quantizer.bits, state.dimension, window) : Math.ceil(window * options.oversample);
|
|
3018
|
+
}
|
|
3019
|
+
const ef = Math.max(options.efSearch ?? defaultEfSearch(state.dimension, window), depth);
|
|
3020
|
+
const filter = options.filter;
|
|
3021
|
+
const workspace = state.workspace;
|
|
3022
|
+
const candidates = workspace.traversal;
|
|
3023
|
+
const native = nativeFieldFor(state);
|
|
3024
|
+
if (native !== null) {
|
|
3025
|
+
candidates.size = 0;
|
|
3026
|
+
if (nativeTraverse(state, native, query, ef, searchMetric, filter, candidates)) {
|
|
3027
|
+
return { candidates, depth: useQuantized ? depth : 0, arenaQuery: null, qMag: 0, native };
|
|
2963
3028
|
}
|
|
2964
|
-
}
|
|
2965
|
-
|
|
2966
|
-
|
|
2967
|
-
|
|
3029
|
+
}
|
|
3030
|
+
noteFallback("search");
|
|
3031
|
+
const store = state.store;
|
|
3032
|
+
const arenaQuery = store.prepareQueryArena(query);
|
|
3033
|
+
const qMag = arenaQuery ? arenaQuery.magnitude : magnitude(query);
|
|
3034
|
+
let distFn;
|
|
3035
|
+
if (quantizer !== void 0) {
|
|
3036
|
+
const prepared = quantizer.prepareQuery(query);
|
|
3037
|
+
if (prepared) distFn = quantizer.preparedDistance(prepared);
|
|
3038
|
+
}
|
|
3039
|
+
if (!distFn && arenaQuery) {
|
|
3040
|
+
distFn = store.queryDistance(arenaQuery, searchMetric);
|
|
3041
|
+
}
|
|
3042
|
+
candidates.size = 0;
|
|
3043
|
+
lockGraphShared(state.locks);
|
|
3044
|
+
try {
|
|
3045
|
+
const entryPoint = entryPointOf(state);
|
|
3046
|
+
if (entryPoint === -1) return { candidates, depth: useQuantized ? depth : 0, arenaQuery, qMag, native: null };
|
|
3047
|
+
setSingleEntryPoint(workspace, entryPoint);
|
|
3048
|
+
for (let layer = topLayerOf(state); layer >= 1; layer--) {
|
|
3049
|
+
searchLayer(state, query, qMag, 1, layer, searchMetric, false, distFn, candidates, void 0, options.clock);
|
|
3050
|
+
if (candidates.size > 0) {
|
|
3051
|
+
setSingleEntryPoint(workspace, candidates.ords[0]);
|
|
3052
|
+
}
|
|
2968
3053
|
}
|
|
3054
|
+
searchLayer(state, query, qMag, ef, 0, searchMetric, true, distFn, candidates, filter, options.clock);
|
|
3055
|
+
} finally {
|
|
3056
|
+
unlockGraphShared(state.locks);
|
|
2969
3057
|
}
|
|
2970
|
-
|
|
2971
|
-
totals[dimension + 1] += 1;
|
|
3058
|
+
return { candidates, depth: useQuantized ? depth : 0, arenaQuery, qMag, native: null };
|
|
2972
3059
|
}
|
|
2973
|
-
function
|
|
2974
|
-
|
|
2975
|
-
const mean = new Float64Array(target.dimension);
|
|
2976
|
-
for (let i = 0; i < mean.length; i++) mean[i] = target.totals[i] / count;
|
|
2977
|
-
return mean;
|
|
3060
|
+
function bestFirst(a, b) {
|
|
3061
|
+
return b.score - a.score || compareCodePoints(a.docId, b.docId);
|
|
2978
3062
|
}
|
|
2979
|
-
function
|
|
2980
|
-
|
|
2981
|
-
const
|
|
2982
|
-
|
|
2983
|
-
|
|
2984
|
-
if (target.metric === "cosine") {
|
|
2985
|
-
let squares = 0;
|
|
2986
|
-
for (let i = 0; i < dimension; i++) squares += mean[i] * mean[i];
|
|
2987
|
-
const length = Math.sqrt(squares);
|
|
2988
|
-
for (let i = 0; i < dimension; i++) centroid[i] = length === 0 ? mean[i] : mean[i] / length;
|
|
2989
|
-
return centroid;
|
|
3063
|
+
function resolveEvery(hits, docIdOf) {
|
|
3064
|
+
const resolved = [];
|
|
3065
|
+
for (const hit of hits) {
|
|
3066
|
+
const docId = docIdOf(hit.ord);
|
|
3067
|
+
if (docId !== void 0) resolved.push({ ord: hit.ord, score: hit.score, docId });
|
|
2990
3068
|
}
|
|
2991
|
-
|
|
2992
|
-
return centroid;
|
|
3069
|
+
return resolved;
|
|
2993
3070
|
}
|
|
2994
|
-
function
|
|
2995
|
-
|
|
2996
|
-
|
|
3071
|
+
function scoresDescend(hits) {
|
|
3072
|
+
for (let i = 1; i < hits.length; i++) {
|
|
3073
|
+
if (!(hits[i].score <= hits[i - 1].score)) return false;
|
|
3074
|
+
}
|
|
3075
|
+
return hits.length === 0 || !Number.isNaN(hits[0].score);
|
|
2997
3076
|
}
|
|
2998
|
-
function
|
|
2999
|
-
|
|
3000
|
-
|
|
3001
|
-
const width = (upper - lower) / steps;
|
|
3002
|
-
for (let i = 0; i < x.length; i++) {
|
|
3003
|
-
const q = lower + width * level(x[i], lower, upper, steps);
|
|
3004
|
-
xe += x[i] * (x[i] - q);
|
|
3005
|
-
e += (x[i] - q) * (x[i] - q);
|
|
3077
|
+
function bestResolvedHits(hits, k, docIdOf) {
|
|
3078
|
+
if (!Number.isInteger(k) || k <= 0) {
|
|
3079
|
+
return resolveEvery(hits, docIdOf).sort(bestFirst).slice(0, k);
|
|
3006
3080
|
}
|
|
3007
|
-
|
|
3081
|
+
let ordered = hits;
|
|
3082
|
+
if (!scoresDescend(ordered)) {
|
|
3083
|
+
if (hits.some((hit) => Number.isNaN(hit.score))) return resolveEvery(hits, docIdOf).sort(bestFirst).slice(0, k);
|
|
3084
|
+
ordered = hits.slice().sort((a, b) => b.score - a.score);
|
|
3085
|
+
}
|
|
3086
|
+
const taken = [];
|
|
3087
|
+
for (const hit of ordered) {
|
|
3088
|
+
if (taken.length >= k && hit.score < taken[k - 1].score) break;
|
|
3089
|
+
const docId = docIdOf(hit.ord);
|
|
3090
|
+
if (docId !== void 0) taken.push({ ord: hit.ord, score: hit.score, docId });
|
|
3091
|
+
}
|
|
3092
|
+
return taken.sort(bestFirst).slice(0, k);
|
|
3008
3093
|
}
|
|
3009
|
-
function
|
|
3010
|
-
|
|
3011
|
-
|
|
3012
|
-
|
|
3013
|
-
|
|
3014
|
-
|
|
3015
|
-
|
|
3016
|
-
for (let round = 0; round < OSQ_REFINE_ROUNDS; round++) {
|
|
3017
|
-
let daa = 0;
|
|
3018
|
-
let dab = 0;
|
|
3019
|
-
let dbb = 0;
|
|
3020
|
-
let dax = 0;
|
|
3021
|
-
let dbx = 0;
|
|
3022
|
-
for (let i = 0; i < x.length; i++) {
|
|
3023
|
-
const s = level(x[i], lower, upper, steps) / steps;
|
|
3024
|
-
daa += (1 - s) * (1 - s);
|
|
3025
|
-
dab += (1 - s) * s;
|
|
3026
|
-
dbb += s * s;
|
|
3027
|
-
dax += x[i] * (1 - s);
|
|
3028
|
-
dbx += x[i] * s;
|
|
3029
|
-
}
|
|
3030
|
-
const m0 = (1 - OSQ_LAMBDA) * dax * dax / norm + OSQ_LAMBDA * daa;
|
|
3031
|
-
const m1 = (1 - OSQ_LAMBDA) * dax * dbx / norm + OSQ_LAMBDA * dab;
|
|
3032
|
-
const m2 = (1 - OSQ_LAMBDA) * dbx * dbx / norm + OSQ_LAMBDA * dbb;
|
|
3033
|
-
const det = m0 * m2 - m1 * m1;
|
|
3034
|
-
if (det === 0) return [lower, upper];
|
|
3035
|
-
const a = (m2 * dax - m1 * dbx) / det;
|
|
3036
|
-
const b = (m0 * dbx - m1 * dax) / det;
|
|
3037
|
-
if (Math.abs(a - lower) < OSQ_REFINE_TOLERANCE && Math.abs(b - upper) < OSQ_REFINE_TOLERANCE) return [lower, upper];
|
|
3038
|
-
const candidate = loss(x, a, b, steps, norm);
|
|
3039
|
-
if (candidate > best) return [lower, upper];
|
|
3040
|
-
lower = a;
|
|
3041
|
-
upper = b;
|
|
3042
|
-
best = candidate;
|
|
3094
|
+
function collectHits(state, query, k, searchMetric, minSimilarity, options) {
|
|
3095
|
+
if (query.length !== state.dimension) {
|
|
3096
|
+
throw new NarsilError(
|
|
3097
|
+
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
3098
|
+
`Vector dimension mismatch: expected ${state.dimension}, got ${query.length}`,
|
|
3099
|
+
{ expected: state.dimension, received: query.length }
|
|
3100
|
+
);
|
|
3043
3101
|
}
|
|
3044
|
-
|
|
3045
|
-
|
|
3046
|
-
|
|
3047
|
-
|
|
3102
|
+
const liveSize = nodeCountOf(state) - tombstoneCountOf(state);
|
|
3103
|
+
if (entryPointOf(state) === -1 || liveSize === 0) {
|
|
3104
|
+
return [];
|
|
3105
|
+
}
|
|
3106
|
+
const traversal = traverse(state, query, k, searchMetric, options);
|
|
3107
|
+
const { candidates } = traversal;
|
|
3108
|
+
const filter = options.filter;
|
|
3109
|
+
if (traversal.depth === 0) return estimatedHits(candidates, 0, searchMetric, minSimilarity, filter);
|
|
3110
|
+
const rescored = rescoredHits(state, traversal, query, traversal.depth, searchMetric, minSimilarity, filter);
|
|
3111
|
+
if (options.rescoreWindow === void 0 || minSimilarity !== Number.NEGATIVE_INFINITY) return rescored;
|
|
3112
|
+
const rest = endOfRescored(candidates, traversal.depth, filter);
|
|
3113
|
+
return rescored.concat(estimatedHits(candidates, rest, searchMetric, minSimilarity, filter));
|
|
3048
3114
|
}
|
|
3049
|
-
function
|
|
3050
|
-
|
|
3051
|
-
|
|
3052
|
-
|
|
3053
|
-
|
|
3054
|
-
|
|
3055
|
-
|
|
3056
|
-
let total = 0;
|
|
3057
|
-
let minimum = Number.POSITIVE_INFINITY;
|
|
3058
|
-
let maximum = Number.NEGATIVE_INFINITY;
|
|
3059
|
-
for (let i = 0; i < dimension; i++) {
|
|
3060
|
-
x[i] = v[i] - centroid[i];
|
|
3061
|
-
correction += metric === "euclidean" ? x[i] * x[i] : v[i] * centroid[i];
|
|
3062
|
-
total += x[i];
|
|
3063
|
-
if (x[i] < minimum) minimum = x[i];
|
|
3064
|
-
if (x[i] > maximum) maximum = x[i];
|
|
3115
|
+
function endOfRescored(candidates, depth, filter) {
|
|
3116
|
+
if (filter === void 0) return Math.min(depth, candidates.size);
|
|
3117
|
+
let taken = 0;
|
|
3118
|
+
for (let i = 0; i < candidates.size; i++) {
|
|
3119
|
+
if (!ordinalFilterHas(filter, candidates.ords[i])) continue;
|
|
3120
|
+
taken += 1;
|
|
3121
|
+
if (taken === depth) return i + 1;
|
|
3065
3122
|
}
|
|
3066
|
-
|
|
3067
|
-
|
|
3068
|
-
|
|
3069
|
-
const
|
|
3070
|
-
|
|
3071
|
-
|
|
3072
|
-
|
|
3073
|
-
|
|
3074
|
-
|
|
3075
|
-
|
|
3076
|
-
);
|
|
3077
|
-
const levels = new Uint8Array(dimension);
|
|
3078
|
-
let sum = 0;
|
|
3079
|
-
for (let i = 0; i < dimension; i++) {
|
|
3080
|
-
levels[i] = level(x[i], lower, upper, steps);
|
|
3081
|
-
sum += levels[i];
|
|
3123
|
+
return candidates.size;
|
|
3124
|
+
}
|
|
3125
|
+
function estimatedHits(candidates, from, metric, minSimilarity, filter) {
|
|
3126
|
+
const hits = [];
|
|
3127
|
+
for (let i = from; i < candidates.size; i++) {
|
|
3128
|
+
const ord = candidates.ords[i];
|
|
3129
|
+
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
3130
|
+
const score = toScore(candidates.distances[i], metric);
|
|
3131
|
+
if (score < minSimilarity) continue;
|
|
3132
|
+
hits.push({ ord, score });
|
|
3082
3133
|
}
|
|
3083
|
-
return
|
|
3134
|
+
return hits;
|
|
3084
3135
|
}
|
|
3085
|
-
|
|
3086
|
-
|
|
3087
|
-
|
|
3088
|
-
|
|
3089
|
-
|
|
3090
|
-
|
|
3091
|
-
|
|
3136
|
+
function rescoredHits(state, traversal, query, depth, metric, minSimilarity, filter) {
|
|
3137
|
+
const { candidates, native } = traversal;
|
|
3138
|
+
if (native !== null) {
|
|
3139
|
+
const rescored = nativeRescoredHits(native.store, candidates, query, depth, metric, minSimilarity, filter);
|
|
3140
|
+
if (rescored !== null) return rescored;
|
|
3141
|
+
const arena = state.store.prepareQueryArena(query);
|
|
3142
|
+
const qMag2 = arena ? arena.magnitude : magnitude(query);
|
|
3143
|
+
return rescoreWithFullPrecision(state, candidates, query, qMag2, arena, depth, metric, minSimilarity, filter);
|
|
3144
|
+
}
|
|
3145
|
+
const { qMag, arenaQuery } = traversal;
|
|
3146
|
+
return rescoreWithFullPrecision(state, candidates, query, qMag, arenaQuery, depth, metric, minSimilarity, filter);
|
|
3092
3147
|
}
|
|
3093
|
-
function
|
|
3094
|
-
|
|
3095
|
-
|
|
3096
|
-
|
|
3097
|
-
|
|
3148
|
+
function rescoreWithFullPrecision(state, candidates, query, qMag, arenaQuery, depth, metric, minSimilarity, filter) {
|
|
3149
|
+
noteFallback("score");
|
|
3150
|
+
const rescored = [];
|
|
3151
|
+
let taken = 0;
|
|
3152
|
+
for (let i = 0; i < candidates.size && taken < depth; i++) {
|
|
3153
|
+
const ord = candidates.ords[i];
|
|
3154
|
+
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
3155
|
+
taken += 1;
|
|
3156
|
+
let fullDistance;
|
|
3157
|
+
if (arenaQuery) {
|
|
3158
|
+
fullDistance = state.store.distanceFromArena(arenaQuery, ord, metric);
|
|
3159
|
+
if (fullDistance === Number.POSITIVE_INFINITY) continue;
|
|
3160
|
+
} else {
|
|
3161
|
+
fullDistance = state.store.distanceFromQuery(query, qMag, ord, metric);
|
|
3162
|
+
if (fullDistance === Number.POSITIVE_INFINITY) continue;
|
|
3163
|
+
}
|
|
3164
|
+
const score = toScore(fullDistance, metric);
|
|
3165
|
+
if (score < minSimilarity) continue;
|
|
3166
|
+
rescored.push({ ord, score });
|
|
3167
|
+
}
|
|
3168
|
+
return rescored;
|
|
3098
3169
|
}
|
|
3099
|
-
function
|
|
3100
|
-
const
|
|
3101
|
-
|
|
3102
|
-
|
|
3103
|
-
|
|
3170
|
+
function search(state, docIdOf, query, k, searchMetric, minSimilarity, options = {}) {
|
|
3171
|
+
const hits = collectHits(state, query, k, searchMetric, minSimilarity, options);
|
|
3172
|
+
return bestResolvedHits(hits, k, docIdOf).map((hit) => ({
|
|
3173
|
+
docId: hit.docId,
|
|
3174
|
+
score: hit.score,
|
|
3175
|
+
termFrequencies: {},
|
|
3176
|
+
fieldLengths: {},
|
|
3177
|
+
idf: {}
|
|
3178
|
+
}));
|
|
3104
3179
|
}
|
|
3105
|
-
function
|
|
3106
|
-
const
|
|
3107
|
-
|
|
3108
|
-
if (bits === 4) return osqNibbleProducts(bytesA, offsetA, bytesB, offsetB, codeBytes);
|
|
3109
|
-
return osqNarrowPairProducts(bytesA, offsetA, bytesB, offsetB, bits, codeBytes);
|
|
3180
|
+
function searchOrdinals(state, docIdOf, query, k, searchMetric, minSimilarity, options = {}) {
|
|
3181
|
+
const hits = collectHits(state, query, k, searchMetric, minSimilarity, options);
|
|
3182
|
+
return bestResolvedHits(hits, k, docIdOf);
|
|
3110
3183
|
}
|
|
3111
3184
|
|
|
3112
|
-
// src/vector/
|
|
3113
|
-
function
|
|
3114
|
-
const
|
|
3115
|
-
const
|
|
3116
|
-
const
|
|
3117
|
-
const
|
|
3118
|
-
|
|
3119
|
-
|
|
3120
|
-
|
|
3121
|
-
|
|
3122
|
-
|
|
3123
|
-
|
|
3124
|
-
|
|
3125
|
-
|
|
3126
|
-
|
|
3127
|
-
|
|
3128
|
-
|
|
3129
|
-
|
|
3130
|
-
|
|
3131
|
-
|
|
3132
|
-
|
|
3133
|
-
|
|
3134
|
-
|
|
3135
|
-
|
|
3136
|
-
}
|
|
3137
|
-
|
|
3138
|
-
|
|
3139
|
-
|
|
3140
|
-
|
|
3141
|
-
|
|
3142
|
-
|
|
3143
|
-
|
|
3144
|
-
|
|
3145
|
-
|
|
3146
|
-
|
|
3147
|
-
|
|
3148
|
-
|
|
3149
|
-
|
|
3150
|
-
|
|
3151
|
-
|
|
3152
|
-
|
|
3153
|
-
|
|
3154
|
-
|
|
3155
|
-
|
|
3156
|
-
const target = store.codeBlockOf(blockIndex * capacity).bytes(start + block.usedBytes);
|
|
3157
|
-
target.set(block.bytes.subarray(0, block.usedBytes), start);
|
|
3158
|
-
}
|
|
3159
|
-
}
|
|
3160
|
-
return { centroid, recode, copyIntoStore };
|
|
3185
|
+
// src/vector/hnsw/snapshot.ts
|
|
3186
|
+
function exportSnapshot(state) {
|
|
3187
|
+
const adj = state.adjacency;
|
|
3188
|
+
const slots = adjacencySlots(adj);
|
|
3189
|
+
const used = upperUsed(adj);
|
|
3190
|
+
const stride = adj.level0Stride;
|
|
3191
|
+
rebindNodes(adj);
|
|
3192
|
+
reachTombstone(state, slots);
|
|
3193
|
+
return {
|
|
3194
|
+
dimension: state.dimension,
|
|
3195
|
+
m: state.M,
|
|
3196
|
+
efConstruction: state.efCons,
|
|
3197
|
+
metric: state.buildMetric,
|
|
3198
|
+
slots,
|
|
3199
|
+
upperUsed: used,
|
|
3200
|
+
nodeLevels: adj.nodeLevels.slice(0, slots),
|
|
3201
|
+
level0: adj.level0.slice(0, slots * stride),
|
|
3202
|
+
upperBase: adj.upperBase.slice(0, slots),
|
|
3203
|
+
upper: adj.upper.slice(0, used),
|
|
3204
|
+
tombstones: state.tombstones.slice(0, slots),
|
|
3205
|
+
tombstoneCount: Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT),
|
|
3206
|
+
nodeCount: Atomics.load(state.header, GRAPH_NODE_COUNT),
|
|
3207
|
+
entryPointOrd: Atomics.load(state.header, GRAPH_ENTRY_POINT),
|
|
3208
|
+
topLayer: Atomics.load(state.header, GRAPH_TOP_LAYER)
|
|
3209
|
+
};
|
|
3210
|
+
}
|
|
3211
|
+
function restoreSnapshot(state, snapshot) {
|
|
3212
|
+
resetGraph(state);
|
|
3213
|
+
const adj = state.adjacency;
|
|
3214
|
+
ensureAdjacencyCapacity(adj, snapshot.slots);
|
|
3215
|
+
adj.nodeLevels.set(snapshot.nodeLevels);
|
|
3216
|
+
adj.level0.set(snapshot.level0);
|
|
3217
|
+
adj.upperBase.set(snapshot.upperBase);
|
|
3218
|
+
ensureUpperCapacity(adj, snapshot.upper.length);
|
|
3219
|
+
adj.upper.set(snapshot.upper);
|
|
3220
|
+
Atomics.store(state.header, GRAPH_UPPER_USED, snapshot.upperUsed);
|
|
3221
|
+
Atomics.store(state.header, GRAPH_SLOTS, snapshot.slots);
|
|
3222
|
+
state.tombstones = fixedView(adj.handles.tombstones, Uint8Array);
|
|
3223
|
+
state.tombstones.set(snapshot.tombstones);
|
|
3224
|
+
Atomics.store(state.header, GRAPH_TOMBSTONE_COUNT, snapshot.tombstoneCount);
|
|
3225
|
+
Atomics.store(state.header, GRAPH_NODE_COUNT, snapshot.nodeCount);
|
|
3226
|
+
Atomics.store(state.header, GRAPH_ENTRY_POINT, snapshot.entryPointOrd);
|
|
3227
|
+
Atomics.store(state.header, GRAPH_TOP_LAYER, snapshot.topLayer);
|
|
3228
|
+
leaveIncomingUncounted(state);
|
|
3161
3229
|
}
|
|
3162
3230
|
|
|
3163
|
-
// src/vector/
|
|
3164
|
-
function
|
|
3165
|
-
const
|
|
3166
|
-
const
|
|
3167
|
-
|
|
3168
|
-
|
|
3169
|
-
|
|
3170
|
-
|
|
3171
|
-
|
|
3172
|
-
|
|
3173
|
-
|
|
3174
|
-
|
|
3175
|
-
|
|
3176
|
-
|
|
3177
|
-
|
|
3178
|
-
|
|
3179
|
-
|
|
3180
|
-
|
|
3181
|
-
|
|
3182
|
-
|
|
3183
|
-
|
|
3184
|
-
}
|
|
3185
|
-
|
|
3186
|
-
|
|
3187
|
-
|
|
3188
|
-
|
|
3189
|
-
|
|
3190
|
-
|
|
3191
|
-
|
|
3192
|
-
|
|
3193
|
-
|
|
3194
|
-
|
|
3195
|
-
|
|
3196
|
-
|
|
3197
|
-
|
|
3198
|
-
|
|
3199
|
-
|
|
3200
|
-
|
|
3201
|
-
|
|
3202
|
-
|
|
3203
|
-
|
|
3204
|
-
if (Atomics.load(codePresent, ordinal) !== 0) return;
|
|
3205
|
-
Atomics.add(store.handles.header, STORE_CODE_COUNT, 1);
|
|
3206
|
-
Atomics.store(codePresent, ordinal, 1);
|
|
3207
|
-
}
|
|
3208
|
-
function writeCentroid(centroid) {
|
|
3209
|
-
store.handles.centroid.set(centroid);
|
|
3210
|
-
Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
3211
|
-
Atomics.store(store.handles.header, STORE_CALIBRATED, 1);
|
|
3212
|
-
}
|
|
3213
|
-
function measureInto(ordinals, sums) {
|
|
3214
|
-
if (nativeMeasure(store.handles, metric, ordinals, sums.totals)) return;
|
|
3215
|
-
noteFallback("measure");
|
|
3216
|
-
for (const vector of storedVectors(ordinals)) addToCentroidSums(sums, vector);
|
|
3217
|
-
}
|
|
3218
|
-
function* storedVectors(ordinals) {
|
|
3219
|
-
for (const ordinal of ordinals) {
|
|
3220
|
-
if (store.holdsOrdinal(ordinal)) yield store.vectorAt(ordinal);
|
|
3231
|
+
// src/vector/hnsw/state.ts
|
|
3232
|
+
function openGraphState(handles, dimension, store, quantizer, threadSlot) {
|
|
3233
|
+
const shape = graphShapeOf(handles.header);
|
|
3234
|
+
const adjacency = openAdjacency(handles, shape.m, shape.mMax0);
|
|
3235
|
+
return {
|
|
3236
|
+
dimension,
|
|
3237
|
+
store,
|
|
3238
|
+
quantizer,
|
|
3239
|
+
adjacency,
|
|
3240
|
+
locks: openGraphLocks(handles, threadSlot),
|
|
3241
|
+
header: handles.header,
|
|
3242
|
+
tombstones: fixedView(handles.tombstones, Uint8Array),
|
|
3243
|
+
visited: new Uint32Array(0),
|
|
3244
|
+
visitStamp: 0,
|
|
3245
|
+
workspace: createHNSWWorkspace(),
|
|
3246
|
+
neighborScratch: new Int32Array(adjacency.level0Stride),
|
|
3247
|
+
M: shape.m,
|
|
3248
|
+
Mmax0: shape.mMax0,
|
|
3249
|
+
efCons: shape.efConstruction,
|
|
3250
|
+
buildMetric: shape.metric,
|
|
3251
|
+
mL: 1 / Math.log(shape.m)
|
|
3252
|
+
};
|
|
3253
|
+
}
|
|
3254
|
+
|
|
3255
|
+
// src/vector/hnsw/index.ts
|
|
3256
|
+
function createHNSWIndex(dimension, store, config, quantizer, handles) {
|
|
3257
|
+
const M = config?.m ?? 16;
|
|
3258
|
+
const shared = handles ?? createSharedGraphHandles({
|
|
3259
|
+
m: M,
|
|
3260
|
+
mMax0: M * 2,
|
|
3261
|
+
efConstruction: config?.efConstruction ?? 200,
|
|
3262
|
+
metric: config?.metric ?? "cosine"
|
|
3263
|
+
});
|
|
3264
|
+
const state = openGraphState(shared, dimension, store, quantizer, 0);
|
|
3265
|
+
const docIdOf = (ord) => store.docIdForOrdinal(ord);
|
|
3266
|
+
function exclusively(operation) {
|
|
3267
|
+
lockGraphExclusive(state.locks);
|
|
3268
|
+
try {
|
|
3269
|
+
return operation();
|
|
3270
|
+
} finally {
|
|
3271
|
+
unlockGraphExclusive(state.locks);
|
|
3221
3272
|
}
|
|
3222
3273
|
}
|
|
3223
|
-
function
|
|
3224
|
-
|
|
3225
|
-
|
|
3226
|
-
|
|
3227
|
-
const offset = recordOffset(ordinal);
|
|
3228
|
-
writeRecord(block.bytes(offset + layout.slotStride), offset, code, bits, block.data(offset + layout.slotStride));
|
|
3229
|
-
markPresent(ordinal);
|
|
3230
|
-
recoding?.recode(ordinal);
|
|
3231
|
-
}
|
|
3232
|
-
function writeCodesOf(ordinals) {
|
|
3233
|
-
if (!isCalibrated() || ordinals.length === 0) return;
|
|
3234
|
-
if (nativeQuantise(store.handles, metric, ordinals)) {
|
|
3235
|
-
if (recoding !== null) for (const ordinal of ordinals) recoding.recode(ordinal);
|
|
3236
|
-
return;
|
|
3274
|
+
function insertNode2(docId) {
|
|
3275
|
+
const ord = store.getOrdinal(docId);
|
|
3276
|
+
if (ord === void 0) {
|
|
3277
|
+
throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
|
|
3237
3278
|
}
|
|
3238
|
-
|
|
3239
|
-
|
|
3240
|
-
|
|
3241
|
-
function clearCodes(ordinal) {
|
|
3242
|
-
if (ordinal < 0 || !reach2(ordinal)) return;
|
|
3243
|
-
if (Atomics.exchange(codePresent, ordinal, 0) === 1) Atomics.sub(store.handles.header, STORE_CODE_COUNT, 1);
|
|
3244
|
-
}
|
|
3245
|
-
function stageQuery(block, query) {
|
|
3246
|
-
if (block.simd === null || !block.hasScratch) return false;
|
|
3247
|
-
if (block.stagedOrdinal !== QUERY_STAGED) {
|
|
3248
|
-
block.bytes(block.scratchByteOffset + query.packed.length).set(query.packed, block.scratchByteOffset);
|
|
3249
|
-
block.stagedOrdinal = QUERY_STAGED;
|
|
3279
|
+
const entry = store.entryForOrdinal(ord);
|
|
3280
|
+
if (!entry) {
|
|
3281
|
+
throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
|
|
3250
3282
|
}
|
|
3251
|
-
|
|
3252
|
-
|
|
3253
|
-
|
|
3254
|
-
|
|
3255
|
-
|
|
3283
|
+
if (entry.vector.length !== dimension) {
|
|
3284
|
+
throw new NarsilError(
|
|
3285
|
+
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
3286
|
+
`Vector dimension mismatch: expected ${dimension}, got ${entry.vector.length}`,
|
|
3287
|
+
{ docId, expected: dimension, received: entry.vector.length }
|
|
3288
|
+
);
|
|
3256
3289
|
}
|
|
3257
|
-
|
|
3258
|
-
}
|
|
3259
|
-
function distanceFrom(products, query, levelBits) {
|
|
3260
|
-
const estimate = osqEstimate(products, documentTrailer, bits, query, levelBits, dimension, centroidDotNow(), metric);
|
|
3261
|
-
return osqDistance(estimate, metric);
|
|
3262
|
-
}
|
|
3263
|
-
function estimateDistance(ordinal, query) {
|
|
3264
|
-
const block = store.codeBlockOf(ordinal);
|
|
3265
|
-
const offset = recordOffset(ordinal);
|
|
3266
|
-
const products = productsAgainstQuery(block, offset, query);
|
|
3267
|
-
readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
|
|
3268
|
-
return distanceFrom(products, query, queryBits);
|
|
3269
|
-
}
|
|
3270
|
-
function prepareQuery(query) {
|
|
3271
|
-
if (!isCalibrated() || query.length !== dimension) return null;
|
|
3272
|
-
const code = osqQuantize(query, store.handles.centroid, queryBits, metric, scratch);
|
|
3273
|
-
const packed = new Uint8Array(layout.queryBytes);
|
|
3274
|
-
stageQueryLevels(code.levels, bits, packed);
|
|
3275
|
-
for (const block of store.openCodeBlocks()) block.stagedOrdinal = NOTHING_STAGED;
|
|
3276
|
-
currentQuery = {
|
|
3277
|
-
packed,
|
|
3278
|
-
lower: code.lower,
|
|
3279
|
-
upper: code.upper,
|
|
3280
|
-
correction: code.correction,
|
|
3281
|
-
sum: code.sum
|
|
3282
|
-
};
|
|
3283
|
-
return currentQuery;
|
|
3284
|
-
}
|
|
3285
|
-
function preparedDistance(prepared) {
|
|
3286
|
-
const generic = (ordinal) => holds2(ordinal) ? estimateDistance(ordinal, prepared) : Number.POSITIVE_INFINITY;
|
|
3287
|
-
if (store.handles.codeBlocks.length === 0) return generic;
|
|
3288
|
-
const block = store.codeBlockOf(0);
|
|
3289
|
-
const simd = block.simd;
|
|
3290
|
-
if (simd === null || !block.hasScratch) return generic;
|
|
3291
|
-
const presentView = codePresent;
|
|
3292
|
-
const limit = Math.min(presentView.length, capacity);
|
|
3293
|
-
const { slotsOffset, slotStride } = layout;
|
|
3294
|
-
const data = block.data(slotsOffset + slotStride);
|
|
3295
|
-
const dataLength = data.byteLength;
|
|
3296
|
-
const queryOffset = block.scratchByteOffset;
|
|
3297
|
-
return (ordinal) => {
|
|
3298
|
-
if (ordinal < 0 || ordinal >= limit || block.stagedOrdinal !== QUERY_STAGED) return generic(ordinal);
|
|
3299
|
-
if (presentView[ordinal] !== 1) return Number.POSITIVE_INFINITY;
|
|
3300
|
-
const offset = slotsOffset + ordinal * slotStride;
|
|
3301
|
-
if (offset + slotStride > dataLength) return generic(ordinal);
|
|
3302
|
-
const products = simdQueryProducts(simd, layout, offset, queryOffset);
|
|
3303
|
-
readTrailer(data, offset, codeBytes, documentTrailer);
|
|
3304
|
-
return distanceFrom(products, prepared, queryBits);
|
|
3305
|
-
};
|
|
3290
|
+
insertNode(state, ord);
|
|
3306
3291
|
}
|
|
3307
|
-
function
|
|
3308
|
-
|
|
3309
|
-
|
|
3310
|
-
|
|
3292
|
+
function* entriesIterator() {
|
|
3293
|
+
const slots = adjacencySlots(state.adjacency);
|
|
3294
|
+
for (let ord = 0; ord < slots; ord++) {
|
|
3295
|
+
if (!hasNode(state.adjacency, ord)) continue;
|
|
3296
|
+
if (isTombstoned(state, ord)) continue;
|
|
3297
|
+
const docId = store.docIdForOrdinal(ord);
|
|
3298
|
+
if (docId === void 0) continue;
|
|
3299
|
+
const entry = store.entryForOrdinal(ord);
|
|
3300
|
+
if (!entry) continue;
|
|
3301
|
+
yield [docId, { docId, vector: entry.vector, magnitude: entry.magnitude }];
|
|
3311
3302
|
}
|
|
3312
|
-
if (!isCalibrated() || vector.length !== dimension) return null;
|
|
3313
|
-
const code = osqQuantize(vector, store.handles.centroid, placementQueryBits, metric, scratch);
|
|
3314
|
-
const levels = new Uint8Array(2 * codeBytes);
|
|
3315
|
-
levels.set(code.levels);
|
|
3316
|
-
return (ordinal) => {
|
|
3317
|
-
if (!holds2(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3318
|
-
const block = store.codeBlockOf(ordinal);
|
|
3319
|
-
const offset = recordOffset(ordinal);
|
|
3320
|
-
const products = osqNibblesByByteLevels(block.bytes(offset + codeBytes), offset, levels, codeBytes);
|
|
3321
|
-
readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
|
|
3322
|
-
return distanceFrom(products, code, placementQueryBits);
|
|
3323
|
-
};
|
|
3324
3303
|
}
|
|
3325
|
-
function
|
|
3326
|
-
|
|
3327
|
-
|
|
3328
|
-
const
|
|
3329
|
-
|
|
3330
|
-
const offsetB = recordOffset(ordB);
|
|
3331
|
-
const products = blockA === blockB && blockA.simd !== null ? simdPairProducts(blockA.simd, layout, offsetA, offsetB) : scalarPairProducts(
|
|
3332
|
-
layout,
|
|
3333
|
-
blockA.bytes(offsetA + codeBytes),
|
|
3334
|
-
offsetA,
|
|
3335
|
-
blockB.bytes(offsetB + codeBytes),
|
|
3336
|
-
offsetB
|
|
3337
|
-
);
|
|
3338
|
-
readTrailer(blockA.data(offsetA + layout.slotStride), offsetA, codeBytes, documentTrailer);
|
|
3339
|
-
readTrailer(blockB.data(offsetB + layout.slotStride), offsetB, codeBytes, otherTrailer);
|
|
3340
|
-
return distanceFrom(products, otherTrailer, bits);
|
|
3341
|
-
}
|
|
3342
|
-
function pairDistance() {
|
|
3343
|
-
if (store.handles.codeBlocks.length === 0) return distanceBetween;
|
|
3344
|
-
const block = store.codeBlockOf(0);
|
|
3345
|
-
const simd = block.simd;
|
|
3346
|
-
if (simd === null) return distanceBetween;
|
|
3347
|
-
const presentView = codePresent;
|
|
3348
|
-
const limit = Math.min(presentView.length, capacity);
|
|
3349
|
-
const { slotsOffset, slotStride } = layout;
|
|
3350
|
-
const data = block.data(slotsOffset + slotStride);
|
|
3351
|
-
const dataLength = data.byteLength;
|
|
3352
|
-
return (ordA, ordB) => {
|
|
3353
|
-
if (ordA < 0 || ordB < 0 || ordA >= limit || ordB >= limit) return distanceBetween(ordA, ordB);
|
|
3354
|
-
if (presentView[ordA] !== 1 || presentView[ordB] !== 1) return Number.POSITIVE_INFINITY;
|
|
3355
|
-
const offsetA = slotsOffset + ordA * slotStride;
|
|
3356
|
-
const offsetB = slotsOffset + ordB * slotStride;
|
|
3357
|
-
if (Math.max(offsetA, offsetB) + slotStride > dataLength) return distanceBetween(ordA, ordB);
|
|
3358
|
-
const products = simdPairProducts(simd, layout, offsetA, offsetB);
|
|
3359
|
-
readTrailer(data, offsetA, codeBytes, documentTrailer);
|
|
3360
|
-
readTrailer(data, offsetB, codeBytes, otherTrailer);
|
|
3361
|
-
return distanceFrom(products, otherTrailer, bits);
|
|
3362
|
-
};
|
|
3304
|
+
function compactionNeeded() {
|
|
3305
|
+
const nodeCount = nodeCountOf(state);
|
|
3306
|
+
if (nodeCount === 0) return false;
|
|
3307
|
+
const tombstones = tombstoneCountOf(state);
|
|
3308
|
+
return tombstones / nodeCount > COMPACTION_TOMBSTONE_RATIO || tombstones > COMPACTION_ABSOLUTE_THRESHOLD;
|
|
3363
3309
|
}
|
|
3364
3310
|
return {
|
|
3365
|
-
|
|
3366
|
-
|
|
3367
|
-
get size() {
|
|
3368
|
-
return Atomics.load(store.handles.header, STORE_CODE_COUNT);
|
|
3369
|
-
},
|
|
3370
|
-
get centroid() {
|
|
3371
|
-
return isCalibrated() ? store.handles.centroid : null;
|
|
3372
|
-
},
|
|
3373
|
-
isCalibrated,
|
|
3374
|
-
holdsOrdinal: holds2,
|
|
3375
|
-
writeCodes(ordinal) {
|
|
3376
|
-
singleOrdinal[0] = ordinal;
|
|
3377
|
-
writeCodesOf(singleOrdinal);
|
|
3378
|
-
},
|
|
3379
|
-
writeCodesOf,
|
|
3380
|
-
measureInto,
|
|
3381
|
-
calibrateFrom(ordinals) {
|
|
3382
|
-
const sums = createCentroidSums(dimension, metric);
|
|
3383
|
-
measureInto(ordinals, sums);
|
|
3384
|
-
const centroid = centroidOfCentroidSums(sums);
|
|
3385
|
-
if (centroid === null) return false;
|
|
3386
|
-
writeCentroid(centroid);
|
|
3387
|
-
return true;
|
|
3388
|
-
},
|
|
3389
|
-
restoreRecord(ordinal, record) {
|
|
3390
|
-
if (!reach2(ordinal) || record.length !== layout.slotStride) return;
|
|
3391
|
-
const block = store.codeBlockOf(ordinal);
|
|
3392
|
-
const offset = recordOffset(ordinal);
|
|
3393
|
-
block.bytes(offset + layout.slotStride).set(record, offset);
|
|
3394
|
-
markPresent(ordinal);
|
|
3395
|
-
recoding?.recode(ordinal);
|
|
3396
|
-
},
|
|
3397
|
-
recordAt(ordinal) {
|
|
3398
|
-
const block = store.codeBlockOf(ordinal);
|
|
3399
|
-
const offset = recordOffset(ordinal);
|
|
3400
|
-
return block.bytes(offset + layout.slotStride).subarray(offset, offset + layout.slotStride);
|
|
3401
|
-
},
|
|
3402
|
-
clearCodes,
|
|
3403
|
-
writeCentroid,
|
|
3404
|
-
resetCalibration() {
|
|
3405
|
-
recoding = null;
|
|
3406
|
-
Atomics.store(store.handles.header, STORE_CALIBRATED, 0);
|
|
3407
|
-
store.handles.centroid.fill(0);
|
|
3408
|
-
Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
3409
|
-
},
|
|
3410
|
-
resetCodes() {
|
|
3411
|
-
recoding = null;
|
|
3412
|
-
codePresent = fixedView(store.handles.codePresent, Uint8Array);
|
|
3413
|
-
codePresent.fill(0);
|
|
3414
|
-
Atomics.store(store.handles.header, STORE_CODE_COUNT, 0);
|
|
3415
|
-
},
|
|
3416
|
-
beginRecoding(centroid) {
|
|
3417
|
-
recoding = createCodeRecoding({ store, layout, metric, holds: holds2, clearCodes }, Float32Array.from(centroid));
|
|
3418
|
-
},
|
|
3419
|
-
recode(ordinal) {
|
|
3420
|
-
recoding?.recode(ordinal);
|
|
3421
|
-
},
|
|
3422
|
-
finishRecoding() {
|
|
3423
|
-
if (recoding === null) return false;
|
|
3424
|
-
const finished = recoding;
|
|
3425
|
-
recoding = null;
|
|
3426
|
-
finished.copyIntoStore(store.slots);
|
|
3427
|
-
writeCentroid(finished.centroid);
|
|
3428
|
-
return true;
|
|
3429
|
-
},
|
|
3430
|
-
abandonRecoding() {
|
|
3431
|
-
recoding = null;
|
|
3432
|
-
},
|
|
3433
|
-
prepareQuery,
|
|
3434
|
-
distanceFromPreparedByOrdinal(prepared, ordinal) {
|
|
3435
|
-
if (!holds2(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3436
|
-
return estimateDistance(ordinal, prepared);
|
|
3311
|
+
get dimension() {
|
|
3312
|
+
return dimension;
|
|
3437
3313
|
},
|
|
3438
|
-
preparedDistance,
|
|
3439
|
-
pairDistance,
|
|
3440
|
-
placementDistance: placementDistance2
|
|
3441
|
-
};
|
|
3442
|
-
}
|
|
3443
|
-
|
|
3444
|
-
// src/vector/osq/index.ts
|
|
3445
|
-
function createOsqQuantizer(dimension, bits, metric, store) {
|
|
3446
|
-
let opened = null;
|
|
3447
|
-
function shared() {
|
|
3448
|
-
if (opened === null && store.dimension === dimension && store.handles.codeLayout !== null) {
|
|
3449
|
-
opened = openSharedQuantizer(store.view, store.handles.codeLayout, metric);
|
|
3450
|
-
}
|
|
3451
|
-
return opened;
|
|
3452
|
-
}
|
|
3453
|
-
function requireShared() {
|
|
3454
|
-
const view = shared();
|
|
3455
|
-
if (view === null) throw new Error("The vector store holds no vector for the quantizer to work on");
|
|
3456
|
-
return view;
|
|
3457
|
-
}
|
|
3458
|
-
function ordinalOf(docId) {
|
|
3459
|
-
const ordinal = store.getOrdinal(docId);
|
|
3460
|
-
if (ordinal === void 0) {
|
|
3461
|
-
throw new Error(`Cannot quantize "${docId}": the vector store holds no vector for it`);
|
|
3462
|
-
}
|
|
3463
|
-
return ordinal;
|
|
3464
|
-
}
|
|
3465
|
-
return {
|
|
3466
|
-
dimension,
|
|
3467
|
-
bits,
|
|
3468
|
-
metric,
|
|
3469
3314
|
get size() {
|
|
3470
|
-
return
|
|
3471
|
-
},
|
|
3472
|
-
get centroid() {
|
|
3473
|
-
return shared()?.centroid ?? null;
|
|
3474
|
-
},
|
|
3475
|
-
isCalibrated: () => shared()?.isCalibrated() ?? false,
|
|
3476
|
-
calibrate(ordinals) {
|
|
3477
|
-
if (ordinals.length > 0) requireShared().calibrateFrom(ordinals);
|
|
3478
|
-
},
|
|
3479
|
-
measure(ordinals, sums) {
|
|
3480
|
-
if (ordinals.length > 0) requireShared().measureInto(ordinals, sums);
|
|
3481
|
-
},
|
|
3482
|
-
quantize(docId) {
|
|
3483
|
-
const ordinal = ordinalOf(docId);
|
|
3484
|
-
const view = requireShared();
|
|
3485
|
-
if (!view.isCalibrated()) view.calibrateFrom(Int32Array.of(ordinal));
|
|
3486
|
-
view.writeCodes(ordinal);
|
|
3487
|
-
},
|
|
3488
|
-
writeCodes(ordinal) {
|
|
3489
|
-
shared()?.writeCodes(ordinal);
|
|
3490
|
-
},
|
|
3491
|
-
remove(docId) {
|
|
3492
|
-
const ordinal = store.getOrdinal(docId);
|
|
3493
|
-
if (ordinal !== void 0) shared()?.clearCodes(ordinal);
|
|
3494
|
-
},
|
|
3495
|
-
removeOrdinal(ordinal) {
|
|
3496
|
-
shared()?.clearCodes(ordinal);
|
|
3315
|
+
return nodeCountOf(state) - tombstoneCountOf(state);
|
|
3497
3316
|
},
|
|
3498
|
-
|
|
3499
|
-
|
|
3500
|
-
const view = shared();
|
|
3501
|
-
const ordinal = store.getOrdinal(docId);
|
|
3502
|
-
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3503
|
-
return unpackLevels(view.recordAt(ordinal), 0, dimension, bits);
|
|
3317
|
+
get tombstoneCount() {
|
|
3318
|
+
return tombstoneCountOf(state);
|
|
3504
3319
|
},
|
|
3505
|
-
|
|
3506
|
-
const
|
|
3507
|
-
|
|
3508
|
-
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3509
|
-
return view.recordAt(ordinal);
|
|
3320
|
+
get entryPointId() {
|
|
3321
|
+
const entryPoint = entryPointOf(state);
|
|
3322
|
+
return entryPoint === -1 ? null : store.docIdForOrdinal(entryPoint) ?? null;
|
|
3510
3323
|
},
|
|
3511
|
-
|
|
3512
|
-
|
|
3513
|
-
if (view === null || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3514
|
-
return view.recordAt(ordinal);
|
|
3324
|
+
get topLayer() {
|
|
3325
|
+
return topLayerOf(state);
|
|
3515
3326
|
},
|
|
3516
|
-
|
|
3517
|
-
|
|
3327
|
+
get m() {
|
|
3328
|
+
return state.M;
|
|
3518
3329
|
},
|
|
3519
|
-
|
|
3520
|
-
|
|
3330
|
+
get efConstruction() {
|
|
3331
|
+
return state.efCons;
|
|
3521
3332
|
},
|
|
3522
|
-
|
|
3523
|
-
|
|
3333
|
+
get metric() {
|
|
3334
|
+
return state.buildMetric;
|
|
3524
3335
|
},
|
|
3525
|
-
|
|
3526
|
-
|
|
3527
|
-
const view = requireShared();
|
|
3528
|
-
view.resetCodes();
|
|
3529
|
-
view.calibrateFrom(ordinals);
|
|
3530
|
-
view.writeCodesOf(ordinals);
|
|
3336
|
+
get graphBytes() {
|
|
3337
|
+
return graphBytes(state.adjacency);
|
|
3531
3338
|
},
|
|
3532
|
-
|
|
3533
|
-
|
|
3339
|
+
get searchScratchBytes() {
|
|
3340
|
+
return searchScratchBytes(state);
|
|
3534
3341
|
},
|
|
3535
|
-
|
|
3536
|
-
shared
|
|
3342
|
+
get handles() {
|
|
3343
|
+
return shared;
|
|
3537
3344
|
},
|
|
3538
|
-
|
|
3539
|
-
|
|
3540
|
-
|
|
3345
|
+
insertNode: insertNode2,
|
|
3346
|
+
insertOrdinal: (ordinal) => insertNode(state, ordinal),
|
|
3347
|
+
markTombstone: (docId) => {
|
|
3348
|
+
const ord = store.getOrdinal(docId);
|
|
3349
|
+
if (ord !== void 0) markTombstone(state, ord);
|
|
3541
3350
|
},
|
|
3542
|
-
|
|
3543
|
-
|
|
3544
|
-
|
|
3545
|
-
|
|
3546
|
-
|
|
3547
|
-
return
|
|
3351
|
+
markTombstoneOrdinal: (ordinal) => markTombstone(state, ordinal),
|
|
3352
|
+
holdsNode: (ordinal) => hasNode(state.adjacency, ordinal),
|
|
3353
|
+
holdsTombstone: (ordinal) => hasNode(state.adjacency, ordinal) && isTombstoned(state, ordinal),
|
|
3354
|
+
has: (docId) => {
|
|
3355
|
+
const ord = store.getOrdinal(docId);
|
|
3356
|
+
return ord !== void 0 && hasNode(state.adjacency, ord) && !isTombstoned(state, ord);
|
|
3548
3357
|
},
|
|
3549
|
-
|
|
3550
|
-
const
|
|
3551
|
-
|
|
3552
|
-
return view.pairDistance();
|
|
3358
|
+
isTombstoned: (docId) => {
|
|
3359
|
+
const ord = store.getOrdinal(docId);
|
|
3360
|
+
return ord !== void 0 && isTombstoned(state, ord);
|
|
3553
3361
|
},
|
|
3554
|
-
|
|
3555
|
-
clear()
|
|
3556
|
-
|
|
3557
|
-
|
|
3558
|
-
|
|
3559
|
-
|
|
3560
|
-
|
|
3362
|
+
search: (query, k, searchMetric, minSimilarity, options) => search(state, docIdOf, query, k, searchMetric, minSimilarity, options),
|
|
3363
|
+
clear: () => exclusively(() => resetGraph(state)),
|
|
3364
|
+
retire: () => Atomics.store(shared.header, GRAPH_RETIRED, 1),
|
|
3365
|
+
entries: entriesIterator,
|
|
3366
|
+
compactionNeeded,
|
|
3367
|
+
compactTombstones: () => exclusively(() => compactTombstones(state)),
|
|
3368
|
+
connectUnreached: () => exclusively(() => connectAfterBuild(state)),
|
|
3369
|
+
rebuild: () => exclusively(() => rebuild(state)),
|
|
3370
|
+
exclusively,
|
|
3371
|
+
deserialize: (data) => exclusively(() => deserializeGraph(state, store, data)),
|
|
3372
|
+
serializeNumbered: (numberOfOrdinal, ordinalOfNumber, partSize) => serializeNumberedGraphParts(state, numberOfOrdinal, ordinalOfNumber, partSize),
|
|
3373
|
+
deserializeNumbered: (graph, ordinalOfNumber) => exclusively(() => deserializeNumberedGraph(state, graph, ordinalOfNumber)),
|
|
3374
|
+
exportSnapshot: () => exportSnapshot(state),
|
|
3375
|
+
restoreSnapshot: (snapshot) => exclusively(() => restoreSnapshot(state, snapshot))
|
|
3561
3376
|
};
|
|
3562
3377
|
}
|
|
3563
3378
|
|
|
3564
|
-
// src/vector/
|
|
3565
|
-
|
|
3566
|
-
|
|
3567
|
-
|
|
3568
|
-
|
|
3569
|
-
|
|
3570
|
-
|
|
3571
|
-
|
|
3572
|
-
|
|
3573
|
-
|
|
3574
|
-
|
|
3575
|
-
|
|
3576
|
-
|
|
3577
|
-
bytes[i + 3] = first;
|
|
3379
|
+
// src/vector/osq/quantize.ts
|
|
3380
|
+
function osqBitsOf(mode) {
|
|
3381
|
+
switch (mode) {
|
|
3382
|
+
case "osq8":
|
|
3383
|
+
return 8;
|
|
3384
|
+
case "osq4":
|
|
3385
|
+
return 4;
|
|
3386
|
+
case "osq2":
|
|
3387
|
+
return 2;
|
|
3388
|
+
case "osq1":
|
|
3389
|
+
return 1;
|
|
3390
|
+
default:
|
|
3391
|
+
return null;
|
|
3578
3392
|
}
|
|
3579
3393
|
}
|
|
3580
|
-
function
|
|
3581
|
-
|
|
3582
|
-
if (!LITTLE_ENDIAN) swapEveryValue(bytes);
|
|
3583
|
-
return bytes;
|
|
3394
|
+
function clamp(value, low, high) {
|
|
3395
|
+
return Math.min(Math.max(value, low), high);
|
|
3584
3396
|
}
|
|
3585
|
-
function
|
|
3586
|
-
|
|
3587
|
-
|
|
3397
|
+
function unitNormaliseInto(target, vector) {
|
|
3398
|
+
let squares = 0;
|
|
3399
|
+
for (let i = 0; i < vector.length; i++) squares += vector[i] * vector[i];
|
|
3400
|
+
const length = Math.sqrt(squares);
|
|
3401
|
+
if (length === 0) {
|
|
3402
|
+
for (let i = 0; i < vector.length; i++) target[i] = vector[i];
|
|
3403
|
+
return;
|
|
3588
3404
|
}
|
|
3589
|
-
|
|
3590
|
-
if (!LITTLE_ENDIAN) swapEveryValue(copy);
|
|
3591
|
-
return new Uint32Array(copy.buffer, 0, copy.byteLength / BYTES_PER_VALUE);
|
|
3405
|
+
for (let i = 0; i < vector.length; i++) target[i] = vector[i] / length;
|
|
3592
3406
|
}
|
|
3593
|
-
|
|
3594
|
-
|
|
3595
|
-
return
|
|
3407
|
+
var CENTROID_TOTALS_PAST_DIMENSION = 2;
|
|
3408
|
+
function createCentroidSums(dimension, metric) {
|
|
3409
|
+
return {
|
|
3410
|
+
metric,
|
|
3411
|
+
dimension,
|
|
3412
|
+
totals: new Float64Array(dimension + CENTROID_TOTALS_PAST_DIMENSION),
|
|
3413
|
+
scratch: new Float64Array(dimension)
|
|
3414
|
+
};
|
|
3596
3415
|
}
|
|
3597
|
-
function
|
|
3598
|
-
|
|
3599
|
-
for (let number = start; number < end; number++) {
|
|
3600
|
-
const top = topLayers[number];
|
|
3601
|
-
if (top < 0) continue;
|
|
3602
|
-
values += state.adjacency.level0Stride + top * state.adjacency.upperStride;
|
|
3603
|
-
}
|
|
3604
|
-
return values;
|
|
3416
|
+
function countOfCentroidSums(target) {
|
|
3417
|
+
return target.totals[target.dimension + 1];
|
|
3605
3418
|
}
|
|
3606
|
-
function
|
|
3607
|
-
|
|
3608
|
-
|
|
3609
|
-
|
|
3610
|
-
const
|
|
3611
|
-
let
|
|
3612
|
-
|
|
3613
|
-
|
|
3614
|
-
|
|
3615
|
-
|
|
3616
|
-
|
|
3617
|
-
|
|
3618
|
-
|
|
3619
|
-
|
|
3620
|
-
|
|
3621
|
-
|
|
3622
|
-
const neighbourOrdinal = array[base + i];
|
|
3623
|
-
if (neighbourOrdinal < 0 || neighbourOrdinal >= numberOfOrdinal.length) continue;
|
|
3624
|
-
const neighbour = numberOfOrdinal[neighbourOrdinal];
|
|
3625
|
-
if (neighbour === NO_NUMBER || neighbour === number || topLayers[neighbour] < layer) continue;
|
|
3626
|
-
values[cursor] = neighbour;
|
|
3627
|
-
cursor += 1;
|
|
3628
|
-
}
|
|
3629
|
-
values[countAt] = cursor - countAt - 1;
|
|
3419
|
+
function squaredLengthsOfCentroidSums(target) {
|
|
3420
|
+
return target.totals[target.dimension];
|
|
3421
|
+
}
|
|
3422
|
+
function addToCentroidSums(target, vector) {
|
|
3423
|
+
const { totals, scratch, dimension } = target;
|
|
3424
|
+
let squares = totals[dimension];
|
|
3425
|
+
if (target.metric === "cosine") {
|
|
3426
|
+
unitNormaliseInto(scratch, vector);
|
|
3427
|
+
for (let i = 0; i < dimension; i++) {
|
|
3428
|
+
totals[i] += scratch[i];
|
|
3429
|
+
squares += scratch[i] * scratch[i];
|
|
3430
|
+
}
|
|
3431
|
+
} else {
|
|
3432
|
+
for (let i = 0; i < dimension; i++) {
|
|
3433
|
+
totals[i] += vector[i];
|
|
3434
|
+
squares += vector[i] * vector[i];
|
|
3630
3435
|
}
|
|
3631
3436
|
}
|
|
3632
|
-
|
|
3437
|
+
totals[dimension] = squares;
|
|
3438
|
+
totals[dimension + 1] += 1;
|
|
3633
3439
|
}
|
|
3634
|
-
function
|
|
3635
|
-
const
|
|
3636
|
-
const
|
|
3637
|
-
for (let
|
|
3638
|
-
|
|
3639
|
-
|
|
3640
|
-
|
|
3440
|
+
function meanOfCentroidSums(target) {
|
|
3441
|
+
const count = countOfCentroidSums(target);
|
|
3442
|
+
const mean = new Float64Array(target.dimension);
|
|
3443
|
+
for (let i = 0; i < mean.length; i++) mean[i] = target.totals[i] / count;
|
|
3444
|
+
return mean;
|
|
3445
|
+
}
|
|
3446
|
+
function centroidOfCentroidSums(target) {
|
|
3447
|
+
if (countOfCentroidSums(target) === 0) return null;
|
|
3448
|
+
const dimension = target.dimension;
|
|
3449
|
+
const mean = meanOfCentroidSums(target);
|
|
3450
|
+
const centroid = new Float32Array(dimension);
|
|
3451
|
+
if (target.metric === "cosine") {
|
|
3452
|
+
let squares = 0;
|
|
3453
|
+
for (let i = 0; i < dimension; i++) squares += mean[i] * mean[i];
|
|
3454
|
+
const length = Math.sqrt(squares);
|
|
3455
|
+
for (let i = 0; i < dimension; i++) centroid[i] = length === 0 ? mean[i] : mean[i] / length;
|
|
3456
|
+
return centroid;
|
|
3641
3457
|
}
|
|
3642
|
-
|
|
3643
|
-
|
|
3644
|
-
|
|
3645
|
-
|
|
3646
|
-
|
|
3647
|
-
|
|
3648
|
-
|
|
3649
|
-
|
|
3650
|
-
|
|
3651
|
-
|
|
3652
|
-
const
|
|
3653
|
-
|
|
3654
|
-
|
|
3655
|
-
|
|
3656
|
-
|
|
3458
|
+
for (let i = 0; i < dimension; i++) centroid[i] = mean[i];
|
|
3459
|
+
return centroid;
|
|
3460
|
+
}
|
|
3461
|
+
function level(value, lower, upper, steps) {
|
|
3462
|
+
if (upper === lower) return 0;
|
|
3463
|
+
return Math.floor((clamp(value, lower, upper) - lower) * steps / (upper - lower) + 0.5);
|
|
3464
|
+
}
|
|
3465
|
+
function loss(x, lower, upper, steps, norm) {
|
|
3466
|
+
let xe = 0;
|
|
3467
|
+
let e = 0;
|
|
3468
|
+
const width = (upper - lower) / steps;
|
|
3469
|
+
for (let i = 0; i < x.length; i++) {
|
|
3470
|
+
const q = lower + width * level(x[i], lower, upper, steps);
|
|
3471
|
+
xe += x[i] * (x[i] - q);
|
|
3472
|
+
e += (x[i] - q) * (x[i] - q);
|
|
3473
|
+
}
|
|
3474
|
+
return (1 - OSQ_LAMBDA) * xe * xe / norm + OSQ_LAMBDA * e;
|
|
3475
|
+
}
|
|
3476
|
+
function refine(x, lowerStart, upperStart, steps) {
|
|
3477
|
+
let lower = lowerStart;
|
|
3478
|
+
let upper = upperStart;
|
|
3479
|
+
let norm = 0;
|
|
3480
|
+
for (let i = 0; i < x.length; i++) norm += x[i] * x[i];
|
|
3481
|
+
if (norm === 0 || upper === lower) return [lower, upper];
|
|
3482
|
+
let best = loss(x, lower, upper, steps, norm);
|
|
3483
|
+
for (let round = 0; round < OSQ_REFINE_ROUNDS; round++) {
|
|
3484
|
+
let daa = 0;
|
|
3485
|
+
let dab = 0;
|
|
3486
|
+
let dbb = 0;
|
|
3487
|
+
let dax = 0;
|
|
3488
|
+
let dbx = 0;
|
|
3489
|
+
for (let i = 0; i < x.length; i++) {
|
|
3490
|
+
const s = level(x[i], lower, upper, steps) / steps;
|
|
3491
|
+
daa += (1 - s) * (1 - s);
|
|
3492
|
+
dab += (1 - s) * s;
|
|
3493
|
+
dbb += s * s;
|
|
3494
|
+
dax += x[i] * (1 - s);
|
|
3495
|
+
dbx += x[i] * s;
|
|
3496
|
+
}
|
|
3497
|
+
const m0 = (1 - OSQ_LAMBDA) * dax * dax / norm + OSQ_LAMBDA * daa;
|
|
3498
|
+
const m1 = (1 - OSQ_LAMBDA) * dax * dbx / norm + OSQ_LAMBDA * dab;
|
|
3499
|
+
const m2 = (1 - OSQ_LAMBDA) * dbx * dbx / norm + OSQ_LAMBDA * dbb;
|
|
3500
|
+
const det = m0 * m2 - m1 * m1;
|
|
3501
|
+
if (det === 0) return [lower, upper];
|
|
3502
|
+
const a = (m2 * dax - m1 * dbx) / det;
|
|
3503
|
+
const b = (m0 * dbx - m1 * dax) / det;
|
|
3504
|
+
if (Math.abs(a - lower) < OSQ_REFINE_TOLERANCE && Math.abs(b - upper) < OSQ_REFINE_TOLERANCE) return [lower, upper];
|
|
3505
|
+
const candidate = loss(x, a, b, steps, norm);
|
|
3506
|
+
if (candidate > best) return [lower, upper];
|
|
3507
|
+
lower = a;
|
|
3508
|
+
upper = b;
|
|
3509
|
+
best = candidate;
|
|
3510
|
+
}
|
|
3511
|
+
return [lower, upper];
|
|
3512
|
+
}
|
|
3513
|
+
function createOsqScratch(dimension) {
|
|
3514
|
+
return { normalised: new Float64Array(dimension), centred: new Float64Array(dimension) };
|
|
3515
|
+
}
|
|
3516
|
+
function osqQuantize(vector, centroid, bits, metric, scratch) {
|
|
3517
|
+
const dimension = vector.length;
|
|
3518
|
+
const v = scratch.normalised;
|
|
3519
|
+
if (metric === "cosine") unitNormaliseInto(v, vector);
|
|
3520
|
+
else for (let i = 0; i < dimension; i++) v[i] = vector[i];
|
|
3521
|
+
const x = scratch.centred;
|
|
3522
|
+
let correction = 0;
|
|
3523
|
+
let total = 0;
|
|
3524
|
+
let minimum = Number.POSITIVE_INFINITY;
|
|
3525
|
+
let maximum = Number.NEGATIVE_INFINITY;
|
|
3526
|
+
for (let i = 0; i < dimension; i++) {
|
|
3527
|
+
x[i] = v[i] - centroid[i];
|
|
3528
|
+
correction += metric === "euclidean" ? x[i] * x[i] : v[i] * centroid[i];
|
|
3529
|
+
total += x[i];
|
|
3530
|
+
if (x[i] < minimum) minimum = x[i];
|
|
3531
|
+
if (x[i] > maximum) maximum = x[i];
|
|
3657
3532
|
}
|
|
3658
|
-
|
|
3659
|
-
|
|
3660
|
-
|
|
3661
|
-
const
|
|
3662
|
-
const
|
|
3663
|
-
const
|
|
3664
|
-
|
|
3665
|
-
|
|
3666
|
-
|
|
3667
|
-
|
|
3668
|
-
|
|
3669
|
-
|
|
3670
|
-
|
|
3671
|
-
|
|
3672
|
-
|
|
3673
|
-
|
|
3674
|
-
length += cursor - start;
|
|
3533
|
+
const mean = total / dimension;
|
|
3534
|
+
let spread = 0;
|
|
3535
|
+
for (let i = 0; i < dimension; i++) spread += (x[i] - mean) * (x[i] - mean);
|
|
3536
|
+
const std = Math.sqrt(spread / dimension);
|
|
3537
|
+
const steps = OSQ_STEPS[bits];
|
|
3538
|
+
const [lower, upper] = refine(
|
|
3539
|
+
x,
|
|
3540
|
+
clamp(mean - OSQ_GRID[bits] * std, minimum, maximum),
|
|
3541
|
+
clamp(mean + OSQ_GRID[bits] * std, minimum, maximum),
|
|
3542
|
+
steps
|
|
3543
|
+
);
|
|
3544
|
+
const levels = new Uint8Array(dimension);
|
|
3545
|
+
let sum = 0;
|
|
3546
|
+
for (let i = 0; i < dimension; i++) {
|
|
3547
|
+
levels[i] = level(x[i], lower, upper, steps);
|
|
3548
|
+
sum += levels[i];
|
|
3675
3549
|
}
|
|
3676
|
-
|
|
3677
|
-
return { ...part, entryPoint, levels, neighbours: littleEndianBytesOf(kept.subarray(0, length)) };
|
|
3550
|
+
return { levels, lower, upper, correction, sum };
|
|
3678
3551
|
}
|
|
3679
|
-
|
|
3680
|
-
|
|
3681
|
-
|
|
3682
|
-
|
|
3683
|
-
);
|
|
3552
|
+
|
|
3553
|
+
// src/vector/osq/products.ts
|
|
3554
|
+
function simdQueryProducts(simd, layout, documentOffset, queryOffset) {
|
|
3555
|
+
const { bits, dimension, codeBytes } = layout;
|
|
3556
|
+
if (bits === 8) return simd.dot_u8(documentOffset, queryOffset, dimension);
|
|
3557
|
+
if (bits === 4) return simd.osq_dot_nibbles_4x4(documentOffset, queryOffset, codeBytes);
|
|
3558
|
+
return simd.osq_dot_bits(documentOffset, queryOffset, codeBytes, bits);
|
|
3684
3559
|
}
|
|
3685
|
-
function
|
|
3686
|
-
const
|
|
3687
|
-
if (
|
|
3688
|
-
|
|
3689
|
-
|
|
3690
|
-
for (let layer = 0; layer < graph.levels[number]; layer++) {
|
|
3691
|
-
if (cursor >= values.length) endsInsideAList();
|
|
3692
|
-
const count = values[cursor];
|
|
3693
|
-
if (count > values.length - cursor - 1) endsInsideAList();
|
|
3694
|
-
cursor += count + 1;
|
|
3695
|
-
}
|
|
3696
|
-
}
|
|
3560
|
+
function scalarQueryProducts(layout, document2, documentOffset, packed) {
|
|
3561
|
+
const { bits, dimension, codeBytes } = layout;
|
|
3562
|
+
if (bits === 8) return osqByteLevelProducts(document2, documentOffset, packed, 0, dimension);
|
|
3563
|
+
if (bits === 4) return osqNibbleProducts(document2, documentOffset, packed, 0, codeBytes);
|
|
3564
|
+
return osqStagedQueryProducts(document2, documentOffset, bits, packed, 0, codeBytes);
|
|
3697
3565
|
}
|
|
3698
|
-
function
|
|
3699
|
-
const
|
|
3700
|
-
if (
|
|
3701
|
-
|
|
3702
|
-
return
|
|
3566
|
+
function simdPairProducts(simd, layout, offsetA, offsetB) {
|
|
3567
|
+
const { bits, dimension, codeBytes } = layout;
|
|
3568
|
+
if (bits === 8) return simd.dot_u8(offsetA, offsetB, dimension);
|
|
3569
|
+
if (bits === 4) return simd.osq_dot_nibbles_4x4(offsetA, offsetB, codeBytes);
|
|
3570
|
+
return simd.osq_dot_bits_pair(offsetA, offsetB, codeBytes, bits);
|
|
3703
3571
|
}
|
|
3704
|
-
function
|
|
3705
|
-
|
|
3706
|
-
|
|
3707
|
-
|
|
3708
|
-
|
|
3709
|
-
|
|
3710
|
-
|
|
3572
|
+
function scalarPairProducts(layout, bytesA, offsetA, bytesB, offsetB) {
|
|
3573
|
+
const { bits, dimension, codeBytes } = layout;
|
|
3574
|
+
if (bits === 8) return osqByteLevelProducts(bytesA, offsetA, bytesB, offsetB, dimension);
|
|
3575
|
+
if (bits === 4) return osqNibbleProducts(bytesA, offsetA, bytesB, offsetB, codeBytes);
|
|
3576
|
+
return osqNarrowPairProducts(bytesA, offsetA, bytesB, offsetB, bits, codeBytes);
|
|
3577
|
+
}
|
|
3578
|
+
|
|
3579
|
+
// src/vector/osq/recoding.ts
|
|
3580
|
+
function createCodeRecoding(source, centroid) {
|
|
3581
|
+
const { store, layout, metric } = source;
|
|
3582
|
+
const { capacity, slotStride, bits } = layout;
|
|
3583
|
+
const scratch = createOsqScratch(layout.dimension);
|
|
3584
|
+
const blocks = [];
|
|
3585
|
+
let recoded = new Uint8Array(0);
|
|
3586
|
+
function blockReaching(blockIndex, end) {
|
|
3587
|
+
const held = blocks[blockIndex];
|
|
3588
|
+
if (held !== void 0 && held.bytes.length >= end) return held;
|
|
3589
|
+
const length = Math.min(capacity * slotStride, Math.max(end, (held?.bytes.length ?? 0) * 2));
|
|
3590
|
+
const bytes = new Uint8Array(length);
|
|
3591
|
+
if (held !== void 0) bytes.set(held.bytes);
|
|
3592
|
+
const block = { bytes, data: new DataView(bytes.buffer), usedBytes: held?.usedBytes ?? 0 };
|
|
3593
|
+
blocks[blockIndex] = block;
|
|
3594
|
+
return block;
|
|
3595
|
+
}
|
|
3596
|
+
function markRecoded(ordinal) {
|
|
3597
|
+
if (ordinal >= recoded.length) {
|
|
3598
|
+
const grown = new Uint8Array(Math.max(ordinal + 1, recoded.length * 2));
|
|
3599
|
+
grown.set(recoded);
|
|
3600
|
+
recoded = grown;
|
|
3711
3601
|
}
|
|
3602
|
+
recoded[ordinal] = 1;
|
|
3712
3603
|
}
|
|
3713
|
-
|
|
3714
|
-
|
|
3715
|
-
|
|
3716
|
-
|
|
3717
|
-
|
|
3718
|
-
|
|
3719
|
-
|
|
3720
|
-
|
|
3721
|
-
|
|
3722
|
-
|
|
3723
|
-
|
|
3724
|
-
|
|
3725
|
-
|
|
3726
|
-
|
|
3727
|
-
|
|
3728
|
-
|
|
3729
|
-
|
|
3730
|
-
const
|
|
3731
|
-
if (
|
|
3732
|
-
const
|
|
3733
|
-
|
|
3734
|
-
if (ordinal !== NO_ORDINAL) {
|
|
3735
|
-
createNode(state.adjacency, ordinal, keptTop);
|
|
3736
|
-
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
3737
|
-
if (keptTop > highestLayer) {
|
|
3738
|
-
highestLayer = keptTop;
|
|
3739
|
-
nodeOnHighestLayer = ordinal;
|
|
3740
|
-
}
|
|
3741
|
-
}
|
|
3742
|
-
for (let layer = 0; layer <= top; layer++) {
|
|
3743
|
-
const count = values[cursor];
|
|
3744
|
-
kept.length = 0;
|
|
3745
|
-
const limit = maxConns(state, layer);
|
|
3746
|
-
for (let i = 1; i <= count && kept.length < limit; i++) {
|
|
3747
|
-
const neighbour = values[cursor + i];
|
|
3748
|
-
const neighbourOrdinal = ordinalAt(neighbour);
|
|
3749
|
-
if (neighbourOrdinal === NO_ORDINAL || neighbour === number) continue;
|
|
3750
|
-
if (topLayerInParts(graph, neighbour) < layer) continue;
|
|
3751
|
-
if (!kept.includes(neighbourOrdinal)) kept.push(neighbourOrdinal);
|
|
3752
|
-
}
|
|
3753
|
-
cursor += count + 1;
|
|
3754
|
-
if (ordinal !== NO_ORDINAL && layer <= keptTop) {
|
|
3755
|
-
writeNeighbors(state.adjacency, ordinal, layer, kept, kept.length);
|
|
3756
|
-
}
|
|
3757
|
-
}
|
|
3604
|
+
function recode(ordinal) {
|
|
3605
|
+
if (!source.holds(ordinal) || !store.holdsOrdinal(ordinal)) return;
|
|
3606
|
+
const offset = ordinal % capacity * slotStride;
|
|
3607
|
+
const block = blockReaching(Math.floor(ordinal / capacity), offset + slotStride);
|
|
3608
|
+
const code = osqQuantize(store.vectorAt(ordinal), centroid, bits, metric, scratch);
|
|
3609
|
+
writeRecord(block.bytes, offset, code, bits, block.data);
|
|
3610
|
+
block.usedBytes = Math.max(block.usedBytes, offset + slotStride);
|
|
3611
|
+
markRecoded(ordinal);
|
|
3612
|
+
}
|
|
3613
|
+
function copyIntoStore(slots) {
|
|
3614
|
+
for (let ordinal = 0; ordinal < slots; ordinal++) {
|
|
3615
|
+
if (!source.holds(ordinal) || ordinal < recoded.length && recoded[ordinal] === 1) continue;
|
|
3616
|
+
recode(ordinal);
|
|
3617
|
+
if (ordinal >= recoded.length || recoded[ordinal] !== 1) source.clearCodes(ordinal);
|
|
3618
|
+
}
|
|
3619
|
+
const start = slotByteOffset(layout, 0);
|
|
3620
|
+
for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
|
|
3621
|
+
const block = blocks[blockIndex];
|
|
3622
|
+
if (block === void 0 || block.usedBytes === 0) continue;
|
|
3623
|
+
const target = store.codeBlockOf(blockIndex * capacity).bytes(start + block.usedBytes);
|
|
3624
|
+
target.set(block.bytes.subarray(0, block.usedBytes), start);
|
|
3758
3625
|
}
|
|
3759
3626
|
}
|
|
3760
|
-
|
|
3761
|
-
const entryPoint = first === void 0 ? null : first.entryPoint;
|
|
3762
|
-
const entryOrdinal = entryPoint === null ? NO_ORDINAL : ordinalAt(entryPoint);
|
|
3763
|
-
const entryTop = entryPoint === null ? -1 : Math.min(topLayerInParts(graph, entryPoint), MAX_LAYER_CAP);
|
|
3764
|
-
const entryIsUsable = entryOrdinal !== NO_ORDINAL && entryTop >= 0;
|
|
3765
|
-
Atomics.store(state.header, GRAPH_ENTRY_POINT, entryIsUsable ? entryOrdinal : nodeOnHighestLayer);
|
|
3766
|
-
Atomics.store(state.header, GRAPH_TOP_LAYER, entryIsUsable ? entryTop : highestLayer);
|
|
3767
|
-
leaveIncomingUncounted(state);
|
|
3627
|
+
return { centroid, recode, copyIntoStore };
|
|
3768
3628
|
}
|
|
3769
3629
|
|
|
3770
|
-
// src/vector/
|
|
3771
|
-
function
|
|
3772
|
-
const
|
|
3773
|
-
|
|
3774
|
-
|
|
3775
|
-
|
|
3776
|
-
|
|
3777
|
-
|
|
3778
|
-
|
|
3779
|
-
|
|
3780
|
-
|
|
3781
|
-
|
|
3782
|
-
|
|
3783
|
-
|
|
3784
|
-
|
|
3785
|
-
|
|
3786
|
-
|
|
3787
|
-
|
|
3788
|
-
|
|
3789
|
-
|
|
3790
|
-
|
|
3630
|
+
// src/vector/osq/view.ts
|
|
3631
|
+
function openSharedQuantizer(store, layout, metric) {
|
|
3632
|
+
const { dimension, bits, queryBits, codeBytes, capacity } = layout;
|
|
3633
|
+
const scratch = createOsqScratch(dimension);
|
|
3634
|
+
const placementQueryBits = osqPlacementQueryBits(bits);
|
|
3635
|
+
const documentTrailer = { lower: 0, upper: 0, correction: 0, sum: 0 };
|
|
3636
|
+
const otherTrailer = { lower: 0, upper: 0, correction: 0, sum: 0 };
|
|
3637
|
+
let codePresent = fixedView(store.handles.codePresent, Uint8Array);
|
|
3638
|
+
let centroidDot = 0;
|
|
3639
|
+
let centroidGeneration = -1;
|
|
3640
|
+
let currentQuery = null;
|
|
3641
|
+
let recoding = null;
|
|
3642
|
+
const singleOrdinal = new Int32Array(1);
|
|
3643
|
+
function reach2(ordinal) {
|
|
3644
|
+
if (ordinal < codePresent.length) return true;
|
|
3645
|
+
if (ordinal >= store.handles.codePresent.byteLength) return false;
|
|
3646
|
+
codePresent = fixedView(store.handles.codePresent, Uint8Array);
|
|
3647
|
+
return ordinal < codePresent.length;
|
|
3648
|
+
}
|
|
3649
|
+
function isCalibrated() {
|
|
3650
|
+
return Atomics.load(store.handles.header, STORE_CALIBRATED) === 1;
|
|
3651
|
+
}
|
|
3652
|
+
function recomputeCentroidDot(generation) {
|
|
3653
|
+
const centroid = store.handles.centroid;
|
|
3654
|
+
let total = 0;
|
|
3655
|
+
for (let i = 0; i < dimension; i++) total += centroid[i] * centroid[i];
|
|
3656
|
+
centroidDot = total;
|
|
3657
|
+
centroidGeneration = generation;
|
|
3658
|
+
}
|
|
3659
|
+
function centroidDotNow() {
|
|
3660
|
+
const generation = Atomics.load(store.handles.header, STORE_CALIBRATION_GENERATION);
|
|
3661
|
+
if (generation !== centroidGeneration) recomputeCentroidDot(generation);
|
|
3662
|
+
return centroidDot;
|
|
3663
|
+
}
|
|
3664
|
+
function holds2(ordinal) {
|
|
3665
|
+
return ordinal >= 0 && reach2(ordinal) && codePresent[ordinal] === 1;
|
|
3666
|
+
}
|
|
3667
|
+
function recordOffset(ordinal) {
|
|
3668
|
+
return slotByteOffset(layout, ordinal % capacity);
|
|
3669
|
+
}
|
|
3670
|
+
function markPresent(ordinal) {
|
|
3671
|
+
if (Atomics.load(codePresent, ordinal) !== 0) return;
|
|
3672
|
+
Atomics.add(store.handles.header, STORE_CODE_COUNT, 1);
|
|
3673
|
+
Atomics.store(codePresent, ordinal, 1);
|
|
3674
|
+
}
|
|
3675
|
+
function writeCentroid(centroid) {
|
|
3676
|
+
store.handles.centroid.set(centroid);
|
|
3677
|
+
Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
3678
|
+
Atomics.store(store.handles.header, STORE_CALIBRATED, 1);
|
|
3679
|
+
}
|
|
3680
|
+
function measureInto(ordinals, sums) {
|
|
3681
|
+
if (nativeMeasure(store.handles, metric, ordinals, sums.totals)) return;
|
|
3682
|
+
noteFallback("measure");
|
|
3683
|
+
for (const vector of storedVectors(ordinals)) addToCentroidSums(sums, vector);
|
|
3684
|
+
}
|
|
3685
|
+
function* storedVectors(ordinals) {
|
|
3686
|
+
for (const ordinal of ordinals) {
|
|
3687
|
+
if (store.holdsOrdinal(ordinal)) yield store.vectorAt(ordinal);
|
|
3791
3688
|
}
|
|
3792
|
-
if (ord > maxOrd) maxOrd = ord;
|
|
3793
|
-
nodes.push({ ord, maxLayer: clampedMaxLayer, layers });
|
|
3794
3689
|
}
|
|
3795
|
-
|
|
3796
|
-
|
|
3797
|
-
|
|
3798
|
-
|
|
3799
|
-
|
|
3800
|
-
|
|
3801
|
-
|
|
3690
|
+
function writeRecordOf(ordinal) {
|
|
3691
|
+
if (!reach2(ordinal) || !store.holdsOrdinal(ordinal)) return;
|
|
3692
|
+
const code = osqQuantize(store.vectorAt(ordinal), store.handles.centroid, bits, metric, scratch);
|
|
3693
|
+
const block = store.codeBlockOf(ordinal);
|
|
3694
|
+
const offset = recordOffset(ordinal);
|
|
3695
|
+
writeRecord(block.bytes(offset + layout.slotStride), offset, code, bits, block.data(offset + layout.slotStride));
|
|
3696
|
+
markPresent(ordinal);
|
|
3697
|
+
recoding?.recode(ordinal);
|
|
3802
3698
|
}
|
|
3803
|
-
|
|
3804
|
-
|
|
3805
|
-
|
|
3806
|
-
|
|
3699
|
+
function writeCodesOf(ordinals) {
|
|
3700
|
+
if (!isCalibrated() || ordinals.length === 0) return;
|
|
3701
|
+
if (nativeQuantise(store.handles, metric, ordinals)) {
|
|
3702
|
+
if (recoding !== null) for (const ordinal of ordinals) recoding.recode(ordinal);
|
|
3703
|
+
return;
|
|
3807
3704
|
}
|
|
3808
|
-
|
|
3705
|
+
noteFallback("quantise");
|
|
3706
|
+
for (const ordinal of ordinals) writeRecordOf(ordinal);
|
|
3809
3707
|
}
|
|
3810
|
-
|
|
3811
|
-
|
|
3812
|
-
if (
|
|
3813
|
-
|
|
3814
|
-
|
|
3708
|
+
function clearCodes(ordinal) {
|
|
3709
|
+
if (ordinal < 0 || !reach2(ordinal)) return;
|
|
3710
|
+
if (Atomics.exchange(codePresent, ordinal, 0) === 1) Atomics.sub(store.handles.header, STORE_CODE_COUNT, 1);
|
|
3711
|
+
}
|
|
3712
|
+
function stageQuery(block, query) {
|
|
3713
|
+
if (block.simd === null || !block.hasScratch) return false;
|
|
3714
|
+
if (block.stagedOrdinal !== QUERY_STAGED) {
|
|
3715
|
+
block.bytes(block.scratchByteOffset + query.packed.length).set(query.packed, block.scratchByteOffset);
|
|
3716
|
+
block.stagedOrdinal = QUERY_STAGED;
|
|
3815
3717
|
}
|
|
3718
|
+
return true;
|
|
3816
3719
|
}
|
|
3817
|
-
|
|
3818
|
-
|
|
3819
|
-
|
|
3820
|
-
const slots = adjacencySlots(state.adjacency);
|
|
3821
|
-
for (let ord = 0; ord < slots; ord++) {
|
|
3822
|
-
const level2 = nodeMaxLayer(state, ord);
|
|
3823
|
-
if (level2 === -1) continue;
|
|
3824
|
-
if (level2 > bestLayer) {
|
|
3825
|
-
bestLayer = level2;
|
|
3826
|
-
bestOrd = ord;
|
|
3827
|
-
}
|
|
3720
|
+
function productsAgainstQuery(block, documentOffset, query) {
|
|
3721
|
+
if (block.simd !== null && stageQuery(block, query)) {
|
|
3722
|
+
return simdQueryProducts(block.simd, layout, documentOffset, block.scratchByteOffset);
|
|
3828
3723
|
}
|
|
3829
|
-
|
|
3830
|
-
|
|
3724
|
+
return scalarQueryProducts(layout, block.bytes(documentOffset + codeBytes), documentOffset, query.packed);
|
|
3725
|
+
}
|
|
3726
|
+
function distanceFrom(products, query, levelBits) {
|
|
3727
|
+
const estimate = osqEstimate(products, documentTrailer, bits, query, levelBits, dimension, centroidDotNow(), metric);
|
|
3728
|
+
return osqDistance(estimate, metric);
|
|
3729
|
+
}
|
|
3730
|
+
function estimateDistance(ordinal, query) {
|
|
3731
|
+
const block = store.codeBlockOf(ordinal);
|
|
3732
|
+
const offset = recordOffset(ordinal);
|
|
3733
|
+
const products = productsAgainstQuery(block, offset, query);
|
|
3734
|
+
readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
|
|
3735
|
+
return distanceFrom(products, query, queryBits);
|
|
3736
|
+
}
|
|
3737
|
+
function prepareQuery(query) {
|
|
3738
|
+
if (!isCalibrated() || query.length !== dimension) return null;
|
|
3739
|
+
const code = osqQuantize(query, store.handles.centroid, queryBits, metric, scratch);
|
|
3740
|
+
const packed = new Uint8Array(layout.queryBytes);
|
|
3741
|
+
stageQueryLevels(code.levels, bits, packed);
|
|
3742
|
+
for (const block of store.openCodeBlocks()) block.stagedOrdinal = NOTHING_STAGED;
|
|
3743
|
+
currentQuery = {
|
|
3744
|
+
packed,
|
|
3745
|
+
lower: code.lower,
|
|
3746
|
+
upper: code.upper,
|
|
3747
|
+
correction: code.correction,
|
|
3748
|
+
sum: code.sum
|
|
3749
|
+
};
|
|
3750
|
+
return currentQuery;
|
|
3751
|
+
}
|
|
3752
|
+
function preparedDistance(prepared) {
|
|
3753
|
+
const generic = (ordinal) => holds2(ordinal) ? estimateDistance(ordinal, prepared) : Number.POSITIVE_INFINITY;
|
|
3754
|
+
if (store.handles.codeBlocks.length === 0) return generic;
|
|
3755
|
+
const block = store.codeBlockOf(0);
|
|
3756
|
+
const simd = block.simd;
|
|
3757
|
+
if (simd === null || !block.hasScratch) return generic;
|
|
3758
|
+
const presentView = codePresent;
|
|
3759
|
+
const limit = Math.min(presentView.length, capacity);
|
|
3760
|
+
const { slotsOffset, slotStride } = layout;
|
|
3761
|
+
const data = block.data(slotsOffset + slotStride);
|
|
3762
|
+
const dataLength = data.byteLength;
|
|
3763
|
+
const queryOffset = block.scratchByteOffset;
|
|
3764
|
+
return (ordinal) => {
|
|
3765
|
+
if (ordinal < 0 || ordinal >= limit || block.stagedOrdinal !== QUERY_STAGED) return generic(ordinal);
|
|
3766
|
+
if (presentView[ordinal] !== 1) return Number.POSITIVE_INFINITY;
|
|
3767
|
+
const offset = slotsOffset + ordinal * slotStride;
|
|
3768
|
+
if (offset + slotStride > dataLength) return generic(ordinal);
|
|
3769
|
+
const products = simdQueryProducts(simd, layout, offset, queryOffset);
|
|
3770
|
+
readTrailer(data, offset, codeBytes, documentTrailer);
|
|
3771
|
+
return distanceFrom(products, prepared, queryBits);
|
|
3772
|
+
};
|
|
3773
|
+
}
|
|
3774
|
+
function placementDistance2(vector) {
|
|
3775
|
+
if (placementQueryBits === queryBits) {
|
|
3776
|
+
const prepared = prepareQuery(vector);
|
|
3777
|
+
return prepared === null ? null : preparedDistance(prepared);
|
|
3778
|
+
}
|
|
3779
|
+
if (!isCalibrated() || vector.length !== dimension) return null;
|
|
3780
|
+
const code = osqQuantize(vector, store.handles.centroid, placementQueryBits, metric, scratch);
|
|
3781
|
+
const levels = new Uint8Array(2 * codeBytes);
|
|
3782
|
+
levels.set(code.levels);
|
|
3783
|
+
return (ordinal) => {
|
|
3784
|
+
if (!holds2(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3785
|
+
const block = store.codeBlockOf(ordinal);
|
|
3786
|
+
const offset = recordOffset(ordinal);
|
|
3787
|
+
const products = osqNibblesByByteLevels(block.bytes(offset + codeBytes), offset, levels, codeBytes);
|
|
3788
|
+
readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
|
|
3789
|
+
return distanceFrom(products, code, placementQueryBits);
|
|
3790
|
+
};
|
|
3791
|
+
}
|
|
3792
|
+
function distanceBetween(ordA, ordB) {
|
|
3793
|
+
if (!holds2(ordA) || !holds2(ordB)) return Number.POSITIVE_INFINITY;
|
|
3794
|
+
const blockA = store.codeBlockOf(ordA);
|
|
3795
|
+
const blockB = store.codeBlockOf(ordB);
|
|
3796
|
+
const offsetA = recordOffset(ordA);
|
|
3797
|
+
const offsetB = recordOffset(ordB);
|
|
3798
|
+
const products = blockA === blockB && blockA.simd !== null ? simdPairProducts(blockA.simd, layout, offsetA, offsetB) : scalarPairProducts(
|
|
3799
|
+
layout,
|
|
3800
|
+
blockA.bytes(offsetA + codeBytes),
|
|
3801
|
+
offsetA,
|
|
3802
|
+
blockB.bytes(offsetB + codeBytes),
|
|
3803
|
+
offsetB
|
|
3804
|
+
);
|
|
3805
|
+
readTrailer(blockA.data(offsetA + layout.slotStride), offsetA, codeBytes, documentTrailer);
|
|
3806
|
+
readTrailer(blockB.data(offsetB + layout.slotStride), offsetB, codeBytes, otherTrailer);
|
|
3807
|
+
return distanceFrom(products, otherTrailer, bits);
|
|
3808
|
+
}
|
|
3809
|
+
function pairDistance() {
|
|
3810
|
+
if (store.handles.codeBlocks.length === 0) return distanceBetween;
|
|
3811
|
+
const block = store.codeBlockOf(0);
|
|
3812
|
+
const simd = block.simd;
|
|
3813
|
+
if (simd === null) return distanceBetween;
|
|
3814
|
+
const presentView = codePresent;
|
|
3815
|
+
const limit = Math.min(presentView.length, capacity);
|
|
3816
|
+
const { slotsOffset, slotStride } = layout;
|
|
3817
|
+
const data = block.data(slotsOffset + slotStride);
|
|
3818
|
+
const dataLength = data.byteLength;
|
|
3819
|
+
return (ordA, ordB) => {
|
|
3820
|
+
if (ordA < 0 || ordB < 0 || ordA >= limit || ordB >= limit) return distanceBetween(ordA, ordB);
|
|
3821
|
+
if (presentView[ordA] !== 1 || presentView[ordB] !== 1) return Number.POSITIVE_INFINITY;
|
|
3822
|
+
const offsetA = slotsOffset + ordA * slotStride;
|
|
3823
|
+
const offsetB = slotsOffset + ordB * slotStride;
|
|
3824
|
+
if (Math.max(offsetA, offsetB) + slotStride > dataLength) return distanceBetween(ordA, ordB);
|
|
3825
|
+
const products = simdPairProducts(simd, layout, offsetA, offsetB);
|
|
3826
|
+
readTrailer(data, offsetA, codeBytes, documentTrailer);
|
|
3827
|
+
readTrailer(data, offsetB, codeBytes, otherTrailer);
|
|
3828
|
+
return distanceFrom(products, otherTrailer, bits);
|
|
3829
|
+
};
|
|
3831
3830
|
}
|
|
3832
|
-
leaveIncomingUncounted(state);
|
|
3833
|
-
}
|
|
3834
|
-
|
|
3835
|
-
// src/vector/hnsw/scratch-bytes.ts
|
|
3836
|
-
function listBytes(list) {
|
|
3837
|
-
return list.ords.byteLength + list.distances.byteLength;
|
|
3838
|
-
}
|
|
3839
|
-
function workspaceBytes(workspace) {
|
|
3840
|
-
let bytes = listBytes(workspace.frontier) + listBytes(workspace.found) + listBytes(workspace.traversal) + listBytes(workspace.working) + listBytes(workspace.pruneCandidates) + listBytes(workspace.pruneSelection) + listBytes(workspace.repairCandidates) + listBytes(workspace.repairSelection) + workspace.entryPoints.byteLength;
|
|
3841
|
-
for (const list of workspace.linkSelections) bytes += listBytes(list);
|
|
3842
|
-
return bytes;
|
|
3843
|
-
}
|
|
3844
|
-
function searchScratchBytes(state) {
|
|
3845
|
-
const held = workspaceBytes(state.workspace) + state.neighborScratch.byteLength + state.visited.byteLength;
|
|
3846
|
-
const native = attachedNativeField(state);
|
|
3847
|
-
return native === null ? held : held + nativeScratchBytes(state, native);
|
|
3848
|
-
}
|
|
3849
|
-
|
|
3850
|
-
// src/vector/hnsw/snapshot.ts
|
|
3851
|
-
function exportSnapshot(state) {
|
|
3852
|
-
const adj = state.adjacency;
|
|
3853
|
-
const slots = adjacencySlots(adj);
|
|
3854
|
-
const used = upperUsed(adj);
|
|
3855
|
-
const stride = adj.level0Stride;
|
|
3856
|
-
rebindNodes(adj);
|
|
3857
|
-
reachTombstone(state, slots);
|
|
3858
3831
|
return {
|
|
3859
|
-
|
|
3860
|
-
|
|
3861
|
-
|
|
3862
|
-
|
|
3863
|
-
|
|
3864
|
-
|
|
3865
|
-
|
|
3866
|
-
|
|
3867
|
-
|
|
3868
|
-
|
|
3869
|
-
|
|
3870
|
-
|
|
3871
|
-
|
|
3872
|
-
|
|
3873
|
-
|
|
3832
|
+
bits,
|
|
3833
|
+
metric,
|
|
3834
|
+
get size() {
|
|
3835
|
+
return Atomics.load(store.handles.header, STORE_CODE_COUNT);
|
|
3836
|
+
},
|
|
3837
|
+
get centroid() {
|
|
3838
|
+
return isCalibrated() ? store.handles.centroid : null;
|
|
3839
|
+
},
|
|
3840
|
+
isCalibrated,
|
|
3841
|
+
holdsOrdinal: holds2,
|
|
3842
|
+
writeCodes(ordinal) {
|
|
3843
|
+
singleOrdinal[0] = ordinal;
|
|
3844
|
+
writeCodesOf(singleOrdinal);
|
|
3845
|
+
},
|
|
3846
|
+
writeCodesOf,
|
|
3847
|
+
measureInto,
|
|
3848
|
+
calibrateFrom(ordinals) {
|
|
3849
|
+
const sums = createCentroidSums(dimension, metric);
|
|
3850
|
+
measureInto(ordinals, sums);
|
|
3851
|
+
const centroid = centroidOfCentroidSums(sums);
|
|
3852
|
+
if (centroid === null) return false;
|
|
3853
|
+
writeCentroid(centroid);
|
|
3854
|
+
return true;
|
|
3855
|
+
},
|
|
3856
|
+
restoreRecord(ordinal, record) {
|
|
3857
|
+
if (!reach2(ordinal) || record.length !== layout.slotStride) return;
|
|
3858
|
+
const block = store.codeBlockOf(ordinal);
|
|
3859
|
+
const offset = recordOffset(ordinal);
|
|
3860
|
+
block.bytes(offset + layout.slotStride).set(record, offset);
|
|
3861
|
+
markPresent(ordinal);
|
|
3862
|
+
recoding?.recode(ordinal);
|
|
3863
|
+
},
|
|
3864
|
+
recordAt(ordinal) {
|
|
3865
|
+
const block = store.codeBlockOf(ordinal);
|
|
3866
|
+
const offset = recordOffset(ordinal);
|
|
3867
|
+
return block.bytes(offset + layout.slotStride).subarray(offset, offset + layout.slotStride);
|
|
3868
|
+
},
|
|
3869
|
+
clearCodes,
|
|
3870
|
+
writeCentroid,
|
|
3871
|
+
resetCalibration() {
|
|
3872
|
+
recoding = null;
|
|
3873
|
+
Atomics.store(store.handles.header, STORE_CALIBRATED, 0);
|
|
3874
|
+
store.handles.centroid.fill(0);
|
|
3875
|
+
Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
3876
|
+
},
|
|
3877
|
+
resetCodes() {
|
|
3878
|
+
recoding = null;
|
|
3879
|
+
codePresent = fixedView(store.handles.codePresent, Uint8Array);
|
|
3880
|
+
codePresent.fill(0);
|
|
3881
|
+
Atomics.store(store.handles.header, STORE_CODE_COUNT, 0);
|
|
3882
|
+
},
|
|
3883
|
+
beginRecoding(centroid) {
|
|
3884
|
+
recoding = createCodeRecoding({ store, layout, metric, holds: holds2, clearCodes }, Float32Array.from(centroid));
|
|
3885
|
+
},
|
|
3886
|
+
recode(ordinal) {
|
|
3887
|
+
recoding?.recode(ordinal);
|
|
3888
|
+
},
|
|
3889
|
+
finishRecoding() {
|
|
3890
|
+
if (recoding === null) return false;
|
|
3891
|
+
const finished = recoding;
|
|
3892
|
+
recoding = null;
|
|
3893
|
+
finished.copyIntoStore(store.slots);
|
|
3894
|
+
writeCentroid(finished.centroid);
|
|
3895
|
+
return true;
|
|
3896
|
+
},
|
|
3897
|
+
abandonRecoding() {
|
|
3898
|
+
recoding = null;
|
|
3899
|
+
},
|
|
3900
|
+
prepareQuery,
|
|
3901
|
+
distanceFromPreparedByOrdinal(prepared, ordinal) {
|
|
3902
|
+
if (!holds2(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3903
|
+
return estimateDistance(ordinal, prepared);
|
|
3904
|
+
},
|
|
3905
|
+
preparedDistance,
|
|
3906
|
+
pairDistance,
|
|
3907
|
+
placementDistance: placementDistance2
|
|
3874
3908
|
};
|
|
3875
3909
|
}
|
|
3876
|
-
function restoreSnapshot(state, snapshot) {
|
|
3877
|
-
resetGraph(state);
|
|
3878
|
-
const adj = state.adjacency;
|
|
3879
|
-
ensureAdjacencyCapacity(adj, snapshot.slots);
|
|
3880
|
-
adj.nodeLevels.set(snapshot.nodeLevels);
|
|
3881
|
-
adj.level0.set(snapshot.level0);
|
|
3882
|
-
adj.upperBase.set(snapshot.upperBase);
|
|
3883
|
-
ensureUpperCapacity(adj, snapshot.upper.length);
|
|
3884
|
-
adj.upper.set(snapshot.upper);
|
|
3885
|
-
Atomics.store(state.header, GRAPH_UPPER_USED, snapshot.upperUsed);
|
|
3886
|
-
Atomics.store(state.header, GRAPH_SLOTS, snapshot.slots);
|
|
3887
|
-
state.tombstones = fixedView(adj.handles.tombstones, Uint8Array);
|
|
3888
|
-
state.tombstones.set(snapshot.tombstones);
|
|
3889
|
-
Atomics.store(state.header, GRAPH_TOMBSTONE_COUNT, snapshot.tombstoneCount);
|
|
3890
|
-
Atomics.store(state.header, GRAPH_NODE_COUNT, snapshot.nodeCount);
|
|
3891
|
-
Atomics.store(state.header, GRAPH_ENTRY_POINT, snapshot.entryPointOrd);
|
|
3892
|
-
Atomics.store(state.header, GRAPH_TOP_LAYER, snapshot.topLayer);
|
|
3893
|
-
leaveIncomingUncounted(state);
|
|
3894
|
-
}
|
|
3895
3910
|
|
|
3896
|
-
// src/vector/
|
|
3897
|
-
function
|
|
3898
|
-
|
|
3899
|
-
|
|
3900
|
-
|
|
3901
|
-
|
|
3902
|
-
efConstruction: config?.efConstruction ?? 200,
|
|
3903
|
-
metric: config?.metric ?? "cosine"
|
|
3904
|
-
});
|
|
3905
|
-
const state = openGraphState(shared, dimension, store, quantizer, 0);
|
|
3906
|
-
const docIdOf = (ord) => store.docIdForOrdinal(ord);
|
|
3907
|
-
function exclusively(operation) {
|
|
3908
|
-
lockGraphExclusive(state.locks);
|
|
3909
|
-
try {
|
|
3910
|
-
return operation();
|
|
3911
|
-
} finally {
|
|
3912
|
-
unlockGraphExclusive(state.locks);
|
|
3911
|
+
// src/vector/osq/index.ts
|
|
3912
|
+
function createOsqQuantizer(dimension, bits, metric, store) {
|
|
3913
|
+
let opened = null;
|
|
3914
|
+
function shared() {
|
|
3915
|
+
if (opened === null && store.dimension === dimension && store.handles.codeLayout !== null) {
|
|
3916
|
+
opened = openSharedQuantizer(store.view, store.handles.codeLayout, metric);
|
|
3913
3917
|
}
|
|
3918
|
+
return opened;
|
|
3914
3919
|
}
|
|
3915
|
-
function
|
|
3916
|
-
const
|
|
3917
|
-
if (
|
|
3918
|
-
|
|
3919
|
-
}
|
|
3920
|
-
const entry = store.entryForOrdinal(ord);
|
|
3921
|
-
if (!entry) {
|
|
3922
|
-
throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
|
|
3923
|
-
}
|
|
3924
|
-
if (entry.vector.length !== dimension) {
|
|
3925
|
-
throw new NarsilError(
|
|
3926
|
-
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
3927
|
-
`Vector dimension mismatch: expected ${dimension}, got ${entry.vector.length}`,
|
|
3928
|
-
{ docId, expected: dimension, received: entry.vector.length }
|
|
3929
|
-
);
|
|
3930
|
-
}
|
|
3931
|
-
insertNode(state, ord);
|
|
3920
|
+
function requireShared() {
|
|
3921
|
+
const view = shared();
|
|
3922
|
+
if (view === null) throw new Error("The vector store holds no vector for the quantizer to work on");
|
|
3923
|
+
return view;
|
|
3932
3924
|
}
|
|
3933
|
-
function
|
|
3934
|
-
const
|
|
3935
|
-
|
|
3936
|
-
|
|
3937
|
-
if (isTombstoned(state, ord)) continue;
|
|
3938
|
-
const docId = store.docIdForOrdinal(ord);
|
|
3939
|
-
if (docId === void 0) continue;
|
|
3940
|
-
const entry = store.entryForOrdinal(ord);
|
|
3941
|
-
if (!entry) continue;
|
|
3942
|
-
yield [docId, { docId, vector: entry.vector, magnitude: entry.magnitude }];
|
|
3925
|
+
function ordinalOf(docId) {
|
|
3926
|
+
const ordinal = store.getOrdinal(docId);
|
|
3927
|
+
if (ordinal === void 0) {
|
|
3928
|
+
throw new Error(`Cannot quantize "${docId}": the vector store holds no vector for it`);
|
|
3943
3929
|
}
|
|
3944
|
-
|
|
3945
|
-
function compactionNeeded() {
|
|
3946
|
-
const nodeCount = nodeCountOf(state);
|
|
3947
|
-
if (nodeCount === 0) return false;
|
|
3948
|
-
const tombstones = tombstoneCountOf(state);
|
|
3949
|
-
return tombstones / nodeCount > COMPACTION_TOMBSTONE_RATIO || tombstones > COMPACTION_ABSOLUTE_THRESHOLD;
|
|
3930
|
+
return ordinal;
|
|
3950
3931
|
}
|
|
3951
3932
|
return {
|
|
3952
|
-
|
|
3953
|
-
|
|
3954
|
-
|
|
3933
|
+
dimension,
|
|
3934
|
+
bits,
|
|
3935
|
+
metric,
|
|
3955
3936
|
get size() {
|
|
3956
|
-
return
|
|
3937
|
+
return shared()?.size ?? 0;
|
|
3957
3938
|
},
|
|
3958
|
-
get
|
|
3959
|
-
return
|
|
3939
|
+
get centroid() {
|
|
3940
|
+
return shared()?.centroid ?? null;
|
|
3960
3941
|
},
|
|
3961
|
-
|
|
3962
|
-
|
|
3963
|
-
|
|
3942
|
+
isCalibrated: () => shared()?.isCalibrated() ?? false,
|
|
3943
|
+
calibrate(ordinals) {
|
|
3944
|
+
if (ordinals.length > 0) requireShared().calibrateFrom(ordinals);
|
|
3964
3945
|
},
|
|
3965
|
-
|
|
3966
|
-
|
|
3946
|
+
measure(ordinals, sums) {
|
|
3947
|
+
if (ordinals.length > 0) requireShared().measureInto(ordinals, sums);
|
|
3967
3948
|
},
|
|
3968
|
-
|
|
3969
|
-
|
|
3949
|
+
quantize(docId) {
|
|
3950
|
+
const ordinal = ordinalOf(docId);
|
|
3951
|
+
const view = requireShared();
|
|
3952
|
+
if (!view.isCalibrated()) view.calibrateFrom(Int32Array.of(ordinal));
|
|
3953
|
+
view.writeCodes(ordinal);
|
|
3970
3954
|
},
|
|
3971
|
-
|
|
3972
|
-
|
|
3955
|
+
writeCodes(ordinal) {
|
|
3956
|
+
shared()?.writeCodes(ordinal);
|
|
3973
3957
|
},
|
|
3974
|
-
|
|
3975
|
-
|
|
3958
|
+
remove(docId) {
|
|
3959
|
+
const ordinal = store.getOrdinal(docId);
|
|
3960
|
+
if (ordinal !== void 0) shared()?.clearCodes(ordinal);
|
|
3976
3961
|
},
|
|
3977
|
-
|
|
3978
|
-
|
|
3962
|
+
removeOrdinal(ordinal) {
|
|
3963
|
+
shared()?.clearCodes(ordinal);
|
|
3979
3964
|
},
|
|
3980
|
-
|
|
3981
|
-
|
|
3965
|
+
hasOrdinal: (ordinal) => shared()?.holdsOrdinal(ordinal) ?? false,
|
|
3966
|
+
getLevels(docId) {
|
|
3967
|
+
const view = shared();
|
|
3968
|
+
const ordinal = store.getOrdinal(docId);
|
|
3969
|
+
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3970
|
+
return unpackLevels(view.recordAt(ordinal), 0, dimension, bits);
|
|
3982
3971
|
},
|
|
3983
|
-
|
|
3984
|
-
|
|
3972
|
+
recordOf(docId) {
|
|
3973
|
+
const view = shared();
|
|
3974
|
+
const ordinal = store.getOrdinal(docId);
|
|
3975
|
+
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3976
|
+
return view.recordAt(ordinal);
|
|
3985
3977
|
},
|
|
3986
|
-
|
|
3987
|
-
|
|
3988
|
-
|
|
3989
|
-
|
|
3990
|
-
if (ord !== void 0) markTombstone(state, ord);
|
|
3978
|
+
recordAtOrdinal(ordinal) {
|
|
3979
|
+
const view = shared();
|
|
3980
|
+
if (view === null || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3981
|
+
return view.recordAt(ordinal);
|
|
3991
3982
|
},
|
|
3992
|
-
|
|
3993
|
-
|
|
3994
|
-
holdsTombstone: (ordinal) => hasNode(state.adjacency, ordinal) && isTombstoned(state, ordinal),
|
|
3995
|
-
has: (docId) => {
|
|
3996
|
-
const ord = store.getOrdinal(docId);
|
|
3997
|
-
return ord !== void 0 && hasNode(state.adjacency, ord) && !isTombstoned(state, ord);
|
|
3983
|
+
restoreRecord(docId, record) {
|
|
3984
|
+
requireShared().restoreRecord(ordinalOf(docId), record);
|
|
3998
3985
|
},
|
|
3999
|
-
|
|
4000
|
-
|
|
4001
|
-
return ord !== void 0 && isTombstoned(state, ord);
|
|
3986
|
+
restoreRecordAtOrdinal(ordinal, record) {
|
|
3987
|
+
requireShared().restoreRecord(ordinal, record);
|
|
4002
3988
|
},
|
|
4003
|
-
|
|
4004
|
-
|
|
4005
|
-
|
|
4006
|
-
|
|
4007
|
-
|
|
4008
|
-
|
|
4009
|
-
|
|
4010
|
-
|
|
4011
|
-
|
|
4012
|
-
|
|
4013
|
-
|
|
4014
|
-
|
|
4015
|
-
|
|
4016
|
-
|
|
3989
|
+
restoreCentroid(centroid) {
|
|
3990
|
+
requireShared().writeCentroid(centroid);
|
|
3991
|
+
},
|
|
3992
|
+
recalibrate(ordinals) {
|
|
3993
|
+
if (ordinals.length === 0) return;
|
|
3994
|
+
const view = requireShared();
|
|
3995
|
+
view.resetCodes();
|
|
3996
|
+
view.calibrateFrom(ordinals);
|
|
3997
|
+
view.writeCodesOf(ordinals);
|
|
3998
|
+
},
|
|
3999
|
+
beginRecoding(centroid) {
|
|
4000
|
+
requireShared().beginRecoding(centroid);
|
|
4001
|
+
},
|
|
4002
|
+
recode(ordinal) {
|
|
4003
|
+
shared()?.recode(ordinal);
|
|
4004
|
+
},
|
|
4005
|
+
finishRecoding: () => shared()?.finishRecoding() ?? false,
|
|
4006
|
+
abandonRecoding() {
|
|
4007
|
+
shared()?.abandonRecoding();
|
|
4008
|
+
},
|
|
4009
|
+
prepareQuery: (query) => shared()?.prepareQuery(query) ?? null,
|
|
4010
|
+
distanceFromPreparedByOrdinal: (prepared, ordinal) => shared()?.distanceFromPreparedByOrdinal(prepared, ordinal) ?? Number.POSITIVE_INFINITY,
|
|
4011
|
+
preparedDistance(prepared) {
|
|
4012
|
+
const view = shared();
|
|
4013
|
+
if (view === null) return () => Number.POSITIVE_INFINITY;
|
|
4014
|
+
return view.preparedDistance(prepared);
|
|
4015
|
+
},
|
|
4016
|
+
pairDistance() {
|
|
4017
|
+
const view = shared();
|
|
4018
|
+
if (view === null) return () => Number.POSITIVE_INFINITY;
|
|
4019
|
+
return view.pairDistance();
|
|
4020
|
+
},
|
|
4021
|
+
placementDistance: (vector) => shared()?.placementDistance(vector) ?? null,
|
|
4022
|
+
clear() {
|
|
4023
|
+
const view = shared();
|
|
4024
|
+
if (view === null) return;
|
|
4025
|
+
view.resetCodes();
|
|
4026
|
+
view.resetCalibration();
|
|
4027
|
+
}
|
|
4017
4028
|
};
|
|
4018
4029
|
}
|
|
4019
4030
|
|
|
4020
|
-
export { BLOCK_MAX_BYTES, GRAPH_RETIRED, IN_MEMORY, NOTHING_STAGED, QUERY_STAGED, STORE_BLOCK_COUNT, STORE_CALIBRATION_GENERATION, STORE_CODE_BLOCK_COUNT, STORE_DOC_ID_BYTES, STORE_LIVE_COUNT, STORE_ORDINAL_LAYOUT_GENERATION, STORE_RELEASED_VECTORS_TO_DISK, STORE_REMOVED_COUNT, STORE_SLOTS, STORE_UNPLACED_COUNT, addToOrdinalFilter, arenaFloat32Distance, blocksGrowthBytes, centroidOfCentroidSums, cosineSimilarityWithMagnitudes, countOfCentroidSums, createCentroidSums, createHNSWIndex, createOrdinalFilter, createOsqQuantizer, createOsqScratch, createSharedVectorStoreHandles, createVectorBlock, detachNativeStore, dotProduct, ensureBlockSlots, euclideanDistance, fixedView, graphWithoutNodes, growBufferTo, grownByteLength, insertNode, magnitude, meanOfCentroidSums, nativeScoresOf, nativeStoreScratchBytes, nodeCountOf, openGraphState, openSharedQuantizer, openVectorBlock, ordinalFilterHas, ordinalFilterValues, osqBitsOf, osqQuantize, releaseLocksHeldBy, removeFromOrdinalFilter, requireWholeNeighbourLists, resetStoreHeader, searchOrdinals, sharedMemoryAvailable, sharedVectorStoreBytes, shuffleInPlace, slotByteOffset, squaredLengthsOfCentroidSums, toDistance, toScore, tombstoneCountOf, topLayerInParts, unplacedChunkCount };
|
|
4031
|
+
export { BLOCK_MAX_BYTES, GRAPH_RETIRED, IN_MEMORY, NOTHING_STAGED, QUERY_STAGED, STORE_BLOCK_COUNT, STORE_CALIBRATION_GENERATION, STORE_CODE_BLOCK_COUNT, STORE_DOC_ID_BYTES, STORE_LIVE_COUNT, STORE_ORDINAL_LAYOUT_GENERATION, STORE_RELEASED_VECTORS_TO_DISK, STORE_REMOVED_COUNT, STORE_SLOTS, STORE_UNPLACED_COUNT, addToOrdinalFilter, arenaFloat32Distance, blocksGrowthBytes, centroidOfCentroidSums, computeCodeBlockLayout, cosineSimilarityWithMagnitudes, countOfCentroidSums, createCentroidSums, createHNSWIndex, createOrdinalFilter, createOsqQuantizer, createOsqScratch, createSharedVectorStoreHandles, createVectorBlock, defaultEfSearch, defaultRescoreDepth, detachNativeStore, dotProduct, ensureBlockSlots, euclideanDistance, fixedView, graphWithoutNodes, growBufferTo, grownByteLength, insertNode, magnitude, meanOfCentroidSums, nativeScoresOf, nativeStoreScratchBytes, nodeCountOf, openGraphState, openSharedQuantizer, openVectorBlock, ordinalFilterHas, ordinalFilterValues, osqBitsOf, osqDistance, osqEstimate, osqQuantize, releaseLocksHeldBy, removeFromOrdinalFilter, requireWholeNeighbourLists, resetStoreHeader, scalarQueryProducts, searchOrdinals, sharedMemoryAvailable, sharedVectorStoreBytes, shuffleInPlace, slotByteOffset, squaredLengthsOfCentroidSums, toDistance, toScore, tombstoneCountOf, topLayerInParts, unplacedChunkCount };
|