@delali/narsil 0.3.1-next.140 → 0.3.1-next.143
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/{analysis-change-JN23AZQP.mjs → analysis-change-HQUT2Z3I.mjs} +13 -13
- package/dist/{analysis-change-entry-5JSIMEKG.mjs → analysis-change-entry-TZTG4AZB.mjs} +1 -1
- package/dist/browser/{analysis-change-57MIRJWR.mjs → analysis-change-JPV775LR.mjs} +407 -6
- package/dist/browser/{analysis-change-entry-ICGRR3IN.mjs → analysis-change-entry-7HR4LWL3.mjs} +1 -1
- package/dist/browser/chunk-3ZBJYAS4.mjs +19 -0
- package/dist/browser/{chunk-ZAIZQOTM.mjs → chunk-5DB2VDGI.mjs} +951 -1134
- package/dist/browser/chunk-6RHTAVZX.mjs +656 -0
- package/dist/browser/chunk-CCOAOO73.mjs +86 -0
- package/dist/browser/{chunk-3EYDURFD.mjs → chunk-HKX2G6WH.mjs} +1615 -2266
- package/dist/browser/{chunk-CGVBGHBX.mjs → chunk-KTOK275N.mjs} +531 -830
- package/dist/browser/{chunk-5LYWZJE2.mjs → chunk-LVY2LI35.mjs} +1 -1
- package/dist/browser/chunk-MVM33ZUL.mjs +993 -0
- package/dist/browser/chunk-MWUK3DA5.mjs +2634 -0
- package/dist/browser/{chunk-67KSBUYR.mjs → chunk-R4WUDZQV.mjs} +8 -5
- package/dist/browser/{chunk-6BSB4N6B.mjs → chunk-TCLEOZ4P.mjs} +2 -2
- package/dist/browser/chunk-VFYMPCOV.mjs +212 -0
- package/dist/browser/chunk-WCFCHIBB.mjs +177 -0
- package/dist/browser/{chunk-E5SFTOQR.mjs → chunk-XNWPP5NS.mjs} +2 -2
- package/dist/browser/{chunk-QHNNULPW.mjs → chunk-ZEV26AQ6.mjs} +5 -0
- package/dist/browser/cold-module-MJMKNUYJ.mjs +745 -0
- package/dist/browser/{durability-wiring-MTIAN6VT.mjs → durability-wiring-SNOWIT6Z.mjs} +231 -51
- package/dist/browser/{import-Q7MXD6BS.mjs → import-TLB2A5LJ.mjs} +6 -5
- package/dist/browser/module-BUFNZMEU.mjs +12 -0
- package/dist/browser/{module-5J3PEUEB.mjs → module-BVP4TKZU.mjs} +395 -108
- package/dist/{restore-queue-RYSRRFS4.mjs → browser/restore-queue-ONYNYUDE.mjs} +2 -2
- package/dist/browser/{snapshot-YBJ5MF2M.mjs → snapshot-QXBKHJAG.mjs} +108 -25
- package/dist/browser/{write-RTWI5MXL.mjs → write-WHFBDWQS.mjs} +63 -91
- package/dist/{capabilities-DXAmysqJ.d.ts → capabilities-BCdUwK_L.d.ts} +2 -2
- package/dist/{chunk-HMDT3I63.mjs → chunk-46NZOPHS.mjs} +2 -2
- package/dist/{chunk-XXKWEG53.mjs → chunk-5WYVUPGD.mjs} +1 -1
- package/dist/chunk-6SNBQESJ.mjs +214 -0
- package/dist/chunk-7AUASRE7.mjs +653 -0
- package/dist/{chunk-4GCN34JV.mjs → chunk-AST3SHFA.mjs} +26 -24
- package/dist/chunk-BOJZGUS6.mjs +177 -0
- package/dist/{chunk-IP4HJOGC.mjs → chunk-BRUUBXCB.mjs} +4 -3
- package/dist/{chunk-J3EHATEZ.mjs → chunk-DQNKVOJ2.mjs} +63 -63
- package/dist/chunk-FOCV4CBZ.mjs +87 -0
- package/dist/{chunk-FFVLPCLH.mjs → chunk-GLZHNSGB.mjs} +1 -1
- package/dist/chunk-GWOS5DYC.mjs +2637 -0
- package/dist/{chunk-W2XDK66Z.mjs → chunk-IO5F7ZBE.mjs} +112 -438
- package/dist/{chunk-P36MUFEJ.mjs → chunk-JDDXV6UF.mjs} +2 -1
- package/dist/{chunk-LLDFIKGP.mjs → chunk-KEIYVZUX.mjs} +4 -4
- package/dist/{chunk-UBXJQJII.mjs → chunk-KGOXHLLZ.mjs} +5 -1
- package/dist/{chunk-FKARMUWH.mjs → chunk-KZL72VTC.mjs} +68 -16
- package/dist/{chunk-TCWQJL7O.mjs → chunk-L76W3IZJ.mjs} +5 -0
- package/dist/{chunk-CPCGEIOM.mjs → chunk-LA4WNDHL.mjs} +83 -799
- package/dist/{chunk-PNNVTKMT.mjs → chunk-NJJCPFXN.mjs} +2 -2
- package/dist/chunk-NN33CZRE.mjs +86 -0
- package/dist/chunk-NRUXBYPH.mjs +121 -0
- package/dist/{chunk-UJWGQIXU.mjs → chunk-QHPYS427.mjs} +1 -0
- package/dist/{chunk-VSUYTPME.mjs → chunk-RHKRTYGO.mjs} +13 -4
- package/dist/{chunk-UEV53BBO.mjs → chunk-SRJBFG2T.mjs} +406 -5
- package/dist/{chunk-K3AQOZVM.mjs → chunk-TNBIK2LQ.mjs} +1638 -1644
- package/dist/chunk-UUZCQQG2.mjs +209 -0
- package/dist/{chunk-XMQNOD5V.mjs → chunk-VEFN6X6Q.mjs} +2 -2
- package/dist/{chunk-LK3MOTXF.mjs → chunk-VJEGOELZ.mjs} +8 -5
- package/dist/chunk-W2COJ5AH.mjs +148 -0
- package/dist/{chunk-IBATGS3J.mjs → chunk-WJGO5PGV.mjs} +241 -124
- package/dist/{chunk-CCCGEPJM.mjs → chunk-XZ3SRNDJ.mjs} +24 -63
- package/dist/{chunk-MTQTX4BP.mjs → chunk-YHUTF6EA.mjs} +400 -92
- package/dist/{chunk-B5I3IL4H.mjs → chunk-YLNSJQLX.mjs} +4 -4
- package/dist/{chunk-6VHWXAOI.mjs → chunk-Z4HFMYNX.mjs} +29 -24
- package/dist/{chunk-U4X4AWKL.mjs → chunk-ZPWS2SKJ.mjs} +293 -270
- package/dist/{client-DApBeLbk.d.ts → client-B12YFALP.d.ts} +3 -3
- package/dist/client.d.ts +7 -7
- package/dist/cold-module-4X7WJCFM.mjs +783 -0
- package/dist/{config-B0H-vp4U.d.ts → config-BhZxIeb1.d.ts} +6 -1
- package/dist/{config-Brysl9NO.d.ts → config-CIG5yDyg.d.ts} +2 -2
- package/dist/{direct-executor-J5UDLPL3.mjs → direct-executor-7XOQ7VQP.mjs} +5 -5
- package/dist/distribution/coordinator/etcd.d.ts +2 -2
- package/dist/distribution/coordinator/in-memory.d.ts +2 -2
- package/dist/distribution.d.ts +7 -7
- package/dist/distribution.mjs +123 -42
- package/dist/{durability-wiring-AYOTAPNQ.mjs → durability-wiring-324D2DDD.mjs} +213 -40
- package/dist/{engine-CuLMbH1-.d.ts → engine-CtzbHOmG.d.ts} +2 -2
- package/dist/{import-QRZAQ5RH.mjs → import-OOBUW3RR.mjs} +14 -13
- package/dist/{index-HYnqS1SE.d.ts → index-DsEurhSl.d.ts} +1 -1
- package/dist/index.browser.mjs +3 -3
- package/dist/index.d.ts +6 -6
- package/dist/index.mjs +11 -11
- package/dist/{long-query-thread-U7K5A72G.mjs → long-query-thread-4SW7RWDE.mjs} +8 -8
- package/dist/{module-L2OZO5PQ.mjs → module-DXSJ5LT2.mjs} +374 -83
- package/dist/module-IYPLWHGC.mjs +48 -0
- package/dist/paged-partition-archive-HFP45PLU.mjs +269 -0
- package/dist/partial-words.mjs +2 -2
- package/dist/persistence/durability/checkpoint-worker.d.ts +5 -1
- package/dist/persistence/durability/checkpoint-worker.mjs +17 -15
- package/dist/react.d.ts +9 -9
- package/dist/{browser/restore-queue-DISFECE4.mjs → restore-queue-FEYAC4SB.mjs} +2 -2
- package/dist/{schema-BTXbHCqA.d.ts → schema-B-Runv0n.d.ts} +7 -0
- package/dist/server.d.ts +10 -10
- package/dist/server.mjs +8 -7
- package/dist/{snapshot-BTRZ3MZK.mjs → snapshot-CGM65VCD.mjs} +60 -25
- package/dist/{tasks-DjGjK70Y.d.ts → tasks-CjRJRGTb.d.ts} +6 -4
- package/dist/{thread-USB3GOPY.mjs → thread-KGNAIKPD.mjs} +8 -8
- package/dist/vector/search-worker.d.ts +1 -1
- package/dist/vector/search-worker.mjs +3 -2
- package/dist/workers/entry.mjs +7 -7
- package/dist/{write-GHTA56OW.mjs → write-2DZPEQL2.mjs} +70 -98
- package/openapi.json +13 -0
- package/package.json +12 -8
- package/dist/browser/chunk-XVMOQQ34.mjs +0 -384
- package/dist/chunk-BDIDUW2B.mjs +0 -387
- package/dist/browser/{chunk-4MFH226Q.mjs → chunk-D33A5VMU.mjs} +15 -15
|
@@ -1,9 +1,9 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { osqCodeBytes, osqStagedQueryBytes, osqRecordBytes, unpackLevels, readTrailer, stageQueryLevels, writeRecord } from './chunk-37CD3OKS.mjs';
|
|
2
2
|
import { stopUsingTheNativeSearchCore, noteFallback, nativeSearchCoreIsEnabled } from './chunk-DJHHF2L5.mjs';
|
|
3
3
|
import { markSimdUnavailable } from './chunk-KOKM4PQN.mjs';
|
|
4
|
-
import { MAX_WASM_PAGES, WASM_PAGE_BYTES, VECTOR_SCRATCH_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
5
|
import { loadNativeCore } from './chunk-74XB2SXI.mjs';
|
|
6
|
-
import { COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, PLACEMENT_ROOM_REQUESTS, MAX_LAYER_CAP, INITIAL_LIST_CAPACITY, INITIAL_UPPER_SLOTS,
|
|
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
9
|
import { NarsilError, ErrorCodes } from './chunk-HNHCNTVG.mjs';
|
|
@@ -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,141 +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
|
-
var
|
|
881
|
-
var
|
|
882
|
-
var SECOND_MIX_MULTIPLIER = 1935289751;
|
|
883
|
-
var TWO_TO_THE_32 = 4294967296;
|
|
884
|
-
var HALF_A_STEP = 0.5;
|
|
885
|
-
function mixedUint32(value) {
|
|
886
|
-
let mixed = value + GOLDEN_GAMMA | 0;
|
|
887
|
-
mixed ^= mixed >>> 16;
|
|
888
|
-
mixed = Math.imul(mixed, FIRST_MIX_MULTIPLIER);
|
|
889
|
-
mixed ^= mixed >>> 15;
|
|
890
|
-
mixed = Math.imul(mixed, SECOND_MIX_MULTIPLIER);
|
|
891
|
-
mixed ^= mixed >>> 15;
|
|
892
|
-
return mixed >>> 0;
|
|
893
|
-
}
|
|
894
|
-
function unitDrawOf(value) {
|
|
895
|
-
return (mixedUint32(value) + HALF_A_STEP) / TWO_TO_THE_32;
|
|
896
|
-
}
|
|
897
|
-
function shuffleInPlace(items) {
|
|
898
|
-
let stream = items.length;
|
|
899
|
-
for (let i = items.length - 1; i > 0; i--) {
|
|
900
|
-
stream = mixedUint32(stream);
|
|
901
|
-
const j = Math.floor(stream / TWO_TO_THE_32 * (i + 1));
|
|
902
|
-
const held = items[i];
|
|
903
|
-
items[i] = items[j];
|
|
904
|
-
items[j] = held;
|
|
905
|
-
}
|
|
906
|
-
return items;
|
|
907
|
-
}
|
|
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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";
|
|
908
653
|
|
|
909
|
-
// src/vector/
|
|
910
|
-
|
|
911
|
-
|
|
912
|
-
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
}
|
|
916
|
-
|
|
917
|
-
|
|
918
|
-
|
|
919
|
-
|
|
920
|
-
|
|
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;
|
|
921
667
|
}
|
|
922
|
-
|
|
923
|
-
|
|
924
|
-
|
|
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;
|
|
925
680
|
}
|
|
926
|
-
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
const
|
|
931
|
-
|
|
932
|
-
|
|
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
|
+
}
|
|
933
693
|
}
|
|
934
|
-
function
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
state.visited.fill(0);
|
|
938
|
-
state.visitStamp = 1;
|
|
694
|
+
function getF32View() {
|
|
695
|
+
if (!f32View) {
|
|
696
|
+
throw new Error("SIMD memory is not initialized");
|
|
939
697
|
}
|
|
940
|
-
return
|
|
698
|
+
return f32View;
|
|
941
699
|
}
|
|
942
|
-
function
|
|
943
|
-
|
|
944
|
-
if (ord >= state.adjacency.handles.tombstones.byteLength) return false;
|
|
945
|
-
state.tombstones = fixedView(state.adjacency.handles.tombstones, Uint8Array);
|
|
946
|
-
return ord < state.tombstones.length;
|
|
700
|
+
function copyOneVector(a) {
|
|
701
|
+
getF32View().set(a, 0);
|
|
947
702
|
}
|
|
948
|
-
function
|
|
949
|
-
|
|
703
|
+
function copyTwoVectors(a, b) {
|
|
704
|
+
const view = getF32View();
|
|
705
|
+
view.set(a, 0);
|
|
706
|
+
view.set(b, OFFSET_B_BYTES / 4);
|
|
950
707
|
}
|
|
951
|
-
function
|
|
952
|
-
|
|
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);
|
|
953
713
|
}
|
|
954
|
-
function
|
|
955
|
-
|
|
714
|
+
function simdMagnitude(a) {
|
|
715
|
+
if (!wasmExports || !f32View) return null;
|
|
716
|
+
ensureMemory(a.length);
|
|
717
|
+
copyOneVector(a);
|
|
718
|
+
return wasmExports.magnitude(0, a.length);
|
|
956
719
|
}
|
|
957
|
-
function
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
return -dotProduct(a, b);
|
|
963
|
-
case "euclidean":
|
|
964
|
-
return euclideanDistance(a, b);
|
|
965
|
-
}
|
|
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);
|
|
966
725
|
}
|
|
967
|
-
|
|
968
|
-
|
|
969
|
-
|
|
970
|
-
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
|
|
974
|
-
|
|
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;
|
|
975
739
|
}
|
|
740
|
+
return arenaModule;
|
|
976
741
|
}
|
|
977
|
-
function
|
|
978
|
-
|
|
979
|
-
|
|
980
|
-
|
|
981
|
-
|
|
982
|
-
|
|
983
|
-
function
|
|
984
|
-
|
|
985
|
-
}
|
|
986
|
-
|
|
987
|
-
|
|
988
|
-
|
|
989
|
-
|
|
990
|
-
}
|
|
991
|
-
function nodeDistanceFunction(state, metric) {
|
|
992
|
-
const storeDistance = state.store.pairDistance(metric);
|
|
993
|
-
const quantizer = state.quantizer;
|
|
994
|
-
if (quantizer === void 0 || !buildsFromCodes(state)) return storeDistance;
|
|
995
|
-
const codeDistance = quantizer.pairDistance();
|
|
996
|
-
return (aOrd, bOrd) => {
|
|
997
|
-
const estimated = codeDistance(aOrd, bOrd);
|
|
998
|
-
return estimated === Number.POSITIVE_INFINITY ? storeDistance(aOrd, bOrd) : estimated;
|
|
999
|
-
};
|
|
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
|
+
}
|
|
1000
755
|
}
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
if (
|
|
1004
|
-
|
|
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;
|
|
1005
771
|
}
|
|
1006
|
-
function
|
|
1007
|
-
|
|
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
|
+
}
|
|
1008
795
|
}
|
|
1009
|
-
function
|
|
1010
|
-
|
|
1011
|
-
|
|
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));
|
|
1012
799
|
}
|
|
1013
|
-
|
|
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);
|
|
1014
804
|
}
|
|
1015
805
|
|
|
1016
806
|
// src/vector/vector-store/blocks.ts
|
|
@@ -1665,28 +1455,197 @@ function nativeConnect(state, field, metric, nearby) {
|
|
|
1665
1455
|
return writeToTheGraph(state, field, connect) === NATIVE_OK;
|
|
1666
1456
|
}
|
|
1667
1457
|
|
|
1668
|
-
// src/vector/
|
|
1669
|
-
function
|
|
1670
|
-
|
|
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);
|
|
1671
1467
|
}
|
|
1672
|
-
function
|
|
1673
|
-
|
|
1468
|
+
function cosineSimilarityWithMagnitudes(a, b, magA, magB) {
|
|
1469
|
+
if (magA === 0 || magB === 0) return 0;
|
|
1470
|
+
return dotProduct(a, b) / (magA * magB);
|
|
1674
1471
|
}
|
|
1675
|
-
function
|
|
1676
|
-
|
|
1677
|
-
|
|
1678
|
-
|
|
1679
|
-
|
|
1680
|
-
|
|
1681
|
-
|
|
1682
|
-
|
|
1683
|
-
|
|
1684
|
-
|
|
1685
|
-
|
|
1686
|
-
|
|
1687
|
-
|
|
1688
|
-
|
|
1689
|
-
|
|
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;
|
|
1480
|
+
}
|
|
1481
|
+
function euclideanDistance(a, b) {
|
|
1482
|
+
return Math.sqrt(squaredEuclideanDistance(a, b));
|
|
1483
|
+
}
|
|
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
|
+
};
|
|
1690
1649
|
}
|
|
1691
1650
|
function linkSelectionsFor(workspace, layers) {
|
|
1692
1651
|
const selections = workspace.linkSelections;
|
|
@@ -2192,6 +2151,42 @@ function countIncomingBeforeWriting(state, holdsGraphLock) {
|
|
|
2192
2151
|
}
|
|
2193
2152
|
}
|
|
2194
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
|
+
|
|
2195
2190
|
// src/vector/hnsw/graph-ops.ts
|
|
2196
2191
|
function readNeighborsLocked(state, ord, layer) {
|
|
2197
2192
|
for (; ; ) {
|
|
@@ -2613,1425 +2608,1424 @@ function rebuild(state) {
|
|
|
2613
2608
|
connectAfterBuild(state);
|
|
2614
2609
|
}
|
|
2615
2610
|
|
|
2616
|
-
// src/vector/
|
|
2617
|
-
|
|
2618
|
-
|
|
2619
|
-
|
|
2620
|
-
|
|
2621
|
-
|
|
2622
|
-
|
|
2623
|
-
|
|
2624
|
-
|
|
2625
|
-
|
|
2626
|
-
|
|
2627
|
-
|
|
2628
|
-
|
|
2629
|
-
|
|
2630
|
-
store.handle,
|
|
2631
|
-
query,
|
|
2632
|
-
nativeMetricCode(metric),
|
|
2633
|
-
candidateCount,
|
|
2634
|
-
state.locks.threadSlot,
|
|
2635
|
-
store.ordinals,
|
|
2636
|
-
store.distances,
|
|
2637
|
-
filter === void 0 ? null : filter.bits
|
|
2638
|
-
);
|
|
2639
|
-
} catch (error) {
|
|
2640
|
-
stopUsingTheNativeSearchCore(error);
|
|
2641
|
-
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;
|
|
2642
2625
|
}
|
|
2643
|
-
if (count < 0) return false;
|
|
2644
|
-
copyCandidates(store, count, candidates);
|
|
2645
|
-
return true;
|
|
2646
2626
|
}
|
|
2647
|
-
function
|
|
2648
|
-
const
|
|
2649
|
-
|
|
2650
|
-
|
|
2651
|
-
let kept = 0;
|
|
2652
|
-
for (let i = 0; i < candidates.size && kept < nearest; i++) {
|
|
2653
|
-
const ord = candidates.ords[i];
|
|
2654
|
-
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2655
|
-
ordinals[kept++] = ord;
|
|
2656
|
-
}
|
|
2657
|
-
const distances = nativeScores(store, query, metric, kept);
|
|
2658
|
-
if (distances === null) return null;
|
|
2659
|
-
const hits = [];
|
|
2660
|
-
for (let i = 0; i < kept; i++) {
|
|
2661
|
-
if (distances[i] === Number.POSITIVE_INFINITY) continue;
|
|
2662
|
-
const score = toScore(distances[i], metric);
|
|
2663
|
-
if (score < minSimilarity) continue;
|
|
2664
|
-
hits.push({ ord: ordinals[i], score });
|
|
2665
|
-
}
|
|
2666
|
-
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;
|
|
2667
2631
|
}
|
|
2668
|
-
|
|
2669
|
-
|
|
2670
|
-
|
|
2671
|
-
var WIDE_DIMENSION_LIMIT = 1024;
|
|
2672
|
-
var DEFAULT_EF_SEARCH_MARGIN_BY_BAND = {
|
|
2673
|
-
narrow: 50,
|
|
2674
|
-
middle: 75,
|
|
2675
|
-
wide: 0
|
|
2676
|
-
};
|
|
2677
|
-
var DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT = 18;
|
|
2678
|
-
var DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS = {
|
|
2679
|
-
1: 3,
|
|
2680
|
-
2: 3,
|
|
2681
|
-
4: 1,
|
|
2682
|
-
8: 1
|
|
2683
|
-
};
|
|
2684
|
-
var DEFAULT_RESCORE_DEPTH_BY_BITS = {
|
|
2685
|
-
1: {
|
|
2686
|
-
narrow: { perLimit: 3.23, perSquareRootOfLimit: 55.9 },
|
|
2687
|
-
middle: { perLimit: 2.2, perSquareRootOfLimit: 27 },
|
|
2688
|
-
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2689
|
-
},
|
|
2690
|
-
2: {
|
|
2691
|
-
narrow: { perLimit: 2.6, perSquareRootOfLimit: 22.5 },
|
|
2692
|
-
middle: { perLimit: 1, perSquareRootOfLimit: 16 },
|
|
2693
|
-
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2694
|
-
},
|
|
2695
|
-
4: {
|
|
2696
|
-
narrow: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2697
|
-
middle: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2698
|
-
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
2699
|
-
},
|
|
2700
|
-
8: {
|
|
2701
|
-
narrow: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2702
|
-
middle: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2703
|
-
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));
|
|
2704
2635
|
}
|
|
2705
|
-
|
|
2706
|
-
|
|
2707
|
-
|
|
2708
|
-
function dimensionBand(dimension) {
|
|
2709
|
-
if (dimension < NARROW_DIMENSION_LIMIT) return "narrow";
|
|
2710
|
-
return dimension < WIDE_DIMENSION_LIMIT ? "middle" : "wide";
|
|
2711
|
-
}
|
|
2712
|
-
function defaultRescoreDepth(bits, dimension, k) {
|
|
2713
|
-
const band = dimensionBand(dimension);
|
|
2714
|
-
const { perLimit, perSquareRootOfLimit } = DEFAULT_RESCORE_DEPTH_BY_BITS[bits][band];
|
|
2715
|
-
const floor = DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS[bits] * k;
|
|
2716
|
-
const depth = Math.max(floor, Math.ceil(perLimit * k + perSquareRootOfLimit * Math.sqrt(k)));
|
|
2717
|
-
if (bits !== 2 || band !== "middle") return depth;
|
|
2718
|
-
const withinDefaultWalk = Math.min(
|
|
2719
|
-
k + DEFAULT_EF_SEARCH_MARGIN_BY_BAND.middle,
|
|
2720
|
-
Math.ceil(k + DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT * Math.sqrt(k))
|
|
2721
|
-
);
|
|
2722
|
-
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);
|
|
2723
2639
|
}
|
|
2724
|
-
function
|
|
2725
|
-
|
|
2640
|
+
function savedTopLayer(state, ordinal) {
|
|
2641
|
+
if (ordinal === NO_ORDINAL) return NO_LAYER;
|
|
2642
|
+
return Math.min(nodeMaxLayer(state, ordinal), MAX_LAYER_CAP);
|
|
2726
2643
|
}
|
|
2727
|
-
|
|
2728
|
-
|
|
2729
|
-
|
|
2730
|
-
|
|
2731
|
-
|
|
2732
|
-
|
|
2733
|
-
const window = options.rescoreWindow ?? k;
|
|
2734
|
-
let depth = window;
|
|
2735
|
-
if (quantizer !== void 0) {
|
|
2736
|
-
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;
|
|
2737
2650
|
}
|
|
2738
|
-
|
|
2739
|
-
|
|
2740
|
-
|
|
2741
|
-
const
|
|
2742
|
-
const
|
|
2743
|
-
|
|
2744
|
-
|
|
2745
|
-
|
|
2746
|
-
|
|
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;
|
|
2747
2677
|
}
|
|
2748
2678
|
}
|
|
2749
|
-
|
|
2750
|
-
|
|
2751
|
-
|
|
2752
|
-
const
|
|
2753
|
-
|
|
2754
|
-
|
|
2755
|
-
const
|
|
2756
|
-
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);
|
|
2757
2688
|
}
|
|
2758
|
-
|
|
2759
|
-
|
|
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) });
|
|
2760
2704
|
}
|
|
2761
|
-
|
|
2762
|
-
|
|
2763
|
-
|
|
2764
|
-
|
|
2765
|
-
|
|
2766
|
-
|
|
2767
|
-
|
|
2768
|
-
|
|
2769
|
-
|
|
2770
|
-
|
|
2771
|
-
|
|
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;
|
|
2772
2719
|
}
|
|
2773
|
-
|
|
2774
|
-
|
|
2775
|
-
unlockGraphShared(state.locks);
|
|
2720
|
+
kept.set(values.subarray(start, cursor), length);
|
|
2721
|
+
length += cursor - start;
|
|
2776
2722
|
}
|
|
2777
|
-
|
|
2723
|
+
const entryPoint = part.entryPoint !== null && numbers.has(part.entryPoint) ? null : part.entryPoint;
|
|
2724
|
+
return { ...part, entryPoint, levels, neighbours: littleEndianBytesOf(kept.subarray(0, length)) };
|
|
2778
2725
|
}
|
|
2779
|
-
function
|
|
2780
|
-
|
|
2726
|
+
function endsInsideAList() {
|
|
2727
|
+
throw new NarsilError(
|
|
2728
|
+
ErrorCodes.PERSISTENCE_LOAD_FAILED,
|
|
2729
|
+
"Invalid vector graph payload: neighbours ends inside a list"
|
|
2730
|
+
);
|
|
2781
2731
|
}
|
|
2782
|
-
function
|
|
2783
|
-
const
|
|
2784
|
-
|
|
2785
|
-
|
|
2786
|
-
|
|
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
|
+
}
|
|
2787
2743
|
}
|
|
2788
|
-
return resolved;
|
|
2789
2744
|
}
|
|
2790
|
-
function
|
|
2791
|
-
|
|
2792
|
-
|
|
2793
|
-
|
|
2794
|
-
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;
|
|
2795
2750
|
}
|
|
2796
|
-
function
|
|
2797
|
-
|
|
2798
|
-
|
|
2799
|
-
|
|
2800
|
-
|
|
2801
|
-
|
|
2802
|
-
|
|
2803
|
-
|
|
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
|
+
}
|
|
2804
2759
|
}
|
|
2805
|
-
|
|
2806
|
-
for (const hit of ordered) {
|
|
2807
|
-
if (taken.length >= k && hit.score < taken[k - 1].score) break;
|
|
2808
|
-
const docId = docIdOf(hit.ord);
|
|
2809
|
-
if (docId !== void 0) taken.push({ ord: hit.ord, score: hit.score, docId });
|
|
2810
|
-
}
|
|
2811
|
-
return taken.sort(bestFirst).slice(0, k);
|
|
2760
|
+
return highest;
|
|
2812
2761
|
}
|
|
2813
|
-
function
|
|
2814
|
-
|
|
2815
|
-
|
|
2816
|
-
|
|
2817
|
-
|
|
2818
|
-
|
|
2819
|
-
|
|
2820
|
-
|
|
2821
|
-
|
|
2822
|
-
|
|
2823
|
-
|
|
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
|
+
}
|
|
2824
2806
|
}
|
|
2825
|
-
const
|
|
2826
|
-
const
|
|
2827
|
-
const
|
|
2828
|
-
|
|
2829
|
-
const
|
|
2830
|
-
|
|
2831
|
-
|
|
2832
|
-
|
|
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);
|
|
2833
2815
|
}
|
|
2834
|
-
|
|
2835
|
-
|
|
2836
|
-
|
|
2837
|
-
|
|
2838
|
-
|
|
2839
|
-
|
|
2840
|
-
|
|
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 });
|
|
2841
2841
|
}
|
|
2842
|
-
return
|
|
2842
|
+
return { nodes, maxOrd };
|
|
2843
2843
|
}
|
|
2844
|
-
function
|
|
2845
|
-
|
|
2846
|
-
|
|
2847
|
-
|
|
2848
|
-
|
|
2849
|
-
const score = toScore(candidates.distances[i], metric);
|
|
2850
|
-
if (score < minSimilarity) continue;
|
|
2851
|
-
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);
|
|
2852
2849
|
}
|
|
2853
|
-
|
|
2854
|
-
|
|
2855
|
-
|
|
2856
|
-
|
|
2857
|
-
|
|
2858
|
-
|
|
2859
|
-
if (rescored !== null) return rescored;
|
|
2860
|
-
const arena = state.store.prepareQueryArena(query);
|
|
2861
|
-
const qMag2 = arena ? arena.magnitude : magnitude(query);
|
|
2862
|
-
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);
|
|
2863
2856
|
}
|
|
2864
|
-
|
|
2865
|
-
|
|
2866
|
-
|
|
2867
|
-
|
|
2868
|
-
|
|
2869
|
-
const rescored = [];
|
|
2870
|
-
let taken = 0;
|
|
2871
|
-
for (let i = 0; i < candidates.size && taken < depth; i++) {
|
|
2872
|
-
const ord = candidates.ords[i];
|
|
2873
|
-
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2874
|
-
taken += 1;
|
|
2875
|
-
let fullDistance;
|
|
2876
|
-
if (arenaQuery) {
|
|
2877
|
-
fullDistance = state.store.distanceFromArena(arenaQuery, ord, metric);
|
|
2878
|
-
if (fullDistance === Number.POSITIVE_INFINITY) continue;
|
|
2879
|
-
} else {
|
|
2880
|
-
const entry = entryForOrd(state, ord);
|
|
2881
|
-
if (!entry) continue;
|
|
2882
|
-
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));
|
|
2883
2862
|
}
|
|
2884
|
-
const score = toScore(fullDistance, metric);
|
|
2885
|
-
if (score < minSimilarity) continue;
|
|
2886
|
-
rescored.push({ ord, score });
|
|
2887
2863
|
}
|
|
2888
|
-
|
|
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);
|
|
2889
2880
|
}
|
|
2890
|
-
|
|
2891
|
-
|
|
2892
|
-
|
|
2893
|
-
|
|
2894
|
-
score: hit.score,
|
|
2895
|
-
termFrequencies: {},
|
|
2896
|
-
fieldLengths: {},
|
|
2897
|
-
idf: {}
|
|
2898
|
-
}));
|
|
2881
|
+
|
|
2882
|
+
// src/vector/hnsw/scratch-bytes.ts
|
|
2883
|
+
function listBytes(list) {
|
|
2884
|
+
return list.ords.byteLength + list.distances.byteLength;
|
|
2899
2885
|
}
|
|
2900
|
-
function
|
|
2901
|
-
|
|
2902
|
-
|
|
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;
|
|
2903
2890
|
}
|
|
2904
|
-
|
|
2905
|
-
|
|
2906
|
-
|
|
2907
|
-
|
|
2908
|
-
const adjacency = openAdjacency(handles, shape.m, shape.mMax0);
|
|
2909
|
-
return {
|
|
2910
|
-
dimension,
|
|
2911
|
-
store,
|
|
2912
|
-
quantizer,
|
|
2913
|
-
adjacency,
|
|
2914
|
-
locks: openGraphLocks(handles, threadSlot),
|
|
2915
|
-
header: handles.header,
|
|
2916
|
-
tombstones: fixedView(handles.tombstones, Uint8Array),
|
|
2917
|
-
visited: new Uint32Array(0),
|
|
2918
|
-
visitStamp: 0,
|
|
2919
|
-
workspace: createHNSWWorkspace(),
|
|
2920
|
-
neighborScratch: new Int32Array(adjacency.level0Stride),
|
|
2921
|
-
M: shape.m,
|
|
2922
|
-
Mmax0: shape.mMax0,
|
|
2923
|
-
efCons: shape.efConstruction,
|
|
2924
|
-
buildMetric: shape.metric,
|
|
2925
|
-
mL: 1 / Math.log(shape.m)
|
|
2926
|
-
};
|
|
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);
|
|
2927
2895
|
}
|
|
2928
2896
|
|
|
2929
|
-
// src/vector/
|
|
2930
|
-
function
|
|
2931
|
-
|
|
2932
|
-
|
|
2933
|
-
|
|
2934
|
-
|
|
2935
|
-
return 4;
|
|
2936
|
-
case "osq2":
|
|
2937
|
-
return 2;
|
|
2938
|
-
case "osq1":
|
|
2939
|
-
return 1;
|
|
2940
|
-
default:
|
|
2941
|
-
return null;
|
|
2942
|
-
}
|
|
2943
|
-
}
|
|
2944
|
-
function clamp(value, low, high) {
|
|
2945
|
-
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;
|
|
2946
2903
|
}
|
|
2947
|
-
function
|
|
2948
|
-
|
|
2949
|
-
|
|
2950
|
-
|
|
2951
|
-
|
|
2952
|
-
|
|
2953
|
-
|
|
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;
|
|
2954
2923
|
}
|
|
2955
|
-
|
|
2924
|
+
if (count < 0) return false;
|
|
2925
|
+
copyCandidates(store, count, candidates);
|
|
2926
|
+
return true;
|
|
2956
2927
|
}
|
|
2957
|
-
|
|
2958
|
-
|
|
2959
|
-
|
|
2960
|
-
|
|
2961
|
-
|
|
2962
|
-
|
|
2963
|
-
|
|
2964
|
-
|
|
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;
|
|
2965
2948
|
}
|
|
2966
|
-
|
|
2967
|
-
|
|
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";
|
|
2968
2992
|
}
|
|
2969
|
-
function
|
|
2970
|
-
|
|
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);
|
|
2971
3004
|
}
|
|
2972
|
-
function
|
|
2973
|
-
|
|
2974
|
-
|
|
2975
|
-
|
|
2976
|
-
|
|
2977
|
-
|
|
2978
|
-
|
|
2979
|
-
|
|
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 };
|
|
2980
3028
|
}
|
|
2981
|
-
}
|
|
2982
|
-
|
|
2983
|
-
|
|
2984
|
-
|
|
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
|
+
}
|
|
2985
3053
|
}
|
|
3054
|
+
searchLayer(state, query, qMag, ef, 0, searchMetric, true, distFn, candidates, filter, options.clock);
|
|
3055
|
+
} finally {
|
|
3056
|
+
unlockGraphShared(state.locks);
|
|
2986
3057
|
}
|
|
2987
|
-
|
|
2988
|
-
totals[dimension + 1] += 1;
|
|
3058
|
+
return { candidates, depth: useQuantized ? depth : 0, arenaQuery, qMag, native: null };
|
|
2989
3059
|
}
|
|
2990
|
-
function
|
|
2991
|
-
|
|
2992
|
-
const mean = new Float64Array(target.dimension);
|
|
2993
|
-
for (let i = 0; i < mean.length; i++) mean[i] = target.totals[i] / count;
|
|
2994
|
-
return mean;
|
|
3060
|
+
function bestFirst(a, b) {
|
|
3061
|
+
return b.score - a.score || compareCodePoints(a.docId, b.docId);
|
|
2995
3062
|
}
|
|
2996
|
-
function
|
|
2997
|
-
|
|
2998
|
-
const
|
|
2999
|
-
|
|
3000
|
-
|
|
3001
|
-
if (target.metric === "cosine") {
|
|
3002
|
-
let squares = 0;
|
|
3003
|
-
for (let i = 0; i < dimension; i++) squares += mean[i] * mean[i];
|
|
3004
|
-
const length = Math.sqrt(squares);
|
|
3005
|
-
for (let i = 0; i < dimension; i++) centroid[i] = length === 0 ? mean[i] : mean[i] / length;
|
|
3006
|
-
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 });
|
|
3007
3068
|
}
|
|
3008
|
-
|
|
3009
|
-
return centroid;
|
|
3069
|
+
return resolved;
|
|
3010
3070
|
}
|
|
3011
|
-
function
|
|
3012
|
-
|
|
3013
|
-
|
|
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);
|
|
3014
3076
|
}
|
|
3015
|
-
function
|
|
3016
|
-
|
|
3017
|
-
|
|
3018
|
-
const width = (upper - lower) / steps;
|
|
3019
|
-
for (let i = 0; i < x.length; i++) {
|
|
3020
|
-
const q = lower + width * level(x[i], lower, upper, steps);
|
|
3021
|
-
xe += x[i] * (x[i] - q);
|
|
3022
|
-
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);
|
|
3023
3080
|
}
|
|
3024
|
-
|
|
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);
|
|
3025
3093
|
}
|
|
3026
|
-
function
|
|
3027
|
-
|
|
3028
|
-
|
|
3029
|
-
|
|
3030
|
-
|
|
3031
|
-
|
|
3032
|
-
|
|
3033
|
-
for (let round = 0; round < OSQ_REFINE_ROUNDS; round++) {
|
|
3034
|
-
let daa = 0;
|
|
3035
|
-
let dab = 0;
|
|
3036
|
-
let dbb = 0;
|
|
3037
|
-
let dax = 0;
|
|
3038
|
-
let dbx = 0;
|
|
3039
|
-
for (let i = 0; i < x.length; i++) {
|
|
3040
|
-
const s = level(x[i], lower, upper, steps) / steps;
|
|
3041
|
-
daa += (1 - s) * (1 - s);
|
|
3042
|
-
dab += (1 - s) * s;
|
|
3043
|
-
dbb += s * s;
|
|
3044
|
-
dax += x[i] * (1 - s);
|
|
3045
|
-
dbx += x[i] * s;
|
|
3046
|
-
}
|
|
3047
|
-
const m0 = (1 - OSQ_LAMBDA) * dax * dax / norm + OSQ_LAMBDA * daa;
|
|
3048
|
-
const m1 = (1 - OSQ_LAMBDA) * dax * dbx / norm + OSQ_LAMBDA * dab;
|
|
3049
|
-
const m2 = (1 - OSQ_LAMBDA) * dbx * dbx / norm + OSQ_LAMBDA * dbb;
|
|
3050
|
-
const det = m0 * m2 - m1 * m1;
|
|
3051
|
-
if (det === 0) return [lower, upper];
|
|
3052
|
-
const a = (m2 * dax - m1 * dbx) / det;
|
|
3053
|
-
const b = (m0 * dbx - m1 * dax) / det;
|
|
3054
|
-
if (Math.abs(a - lower) < OSQ_REFINE_TOLERANCE && Math.abs(b - upper) < OSQ_REFINE_TOLERANCE) return [lower, upper];
|
|
3055
|
-
const candidate = loss(x, a, b, steps, norm);
|
|
3056
|
-
if (candidate > best) return [lower, upper];
|
|
3057
|
-
lower = a;
|
|
3058
|
-
upper = b;
|
|
3059
|
-
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
|
+
);
|
|
3060
3101
|
}
|
|
3061
|
-
|
|
3062
|
-
|
|
3063
|
-
|
|
3064
|
-
|
|
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));
|
|
3065
3114
|
}
|
|
3066
|
-
function
|
|
3067
|
-
|
|
3068
|
-
|
|
3069
|
-
|
|
3070
|
-
|
|
3071
|
-
|
|
3072
|
-
|
|
3073
|
-
let total = 0;
|
|
3074
|
-
let minimum = Number.POSITIVE_INFINITY;
|
|
3075
|
-
let maximum = Number.NEGATIVE_INFINITY;
|
|
3076
|
-
for (let i = 0; i < dimension; i++) {
|
|
3077
|
-
x[i] = v[i] - centroid[i];
|
|
3078
|
-
correction += metric === "euclidean" ? x[i] * x[i] : v[i] * centroid[i];
|
|
3079
|
-
total += x[i];
|
|
3080
|
-
if (x[i] < minimum) minimum = x[i];
|
|
3081
|
-
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;
|
|
3082
3122
|
}
|
|
3083
|
-
|
|
3084
|
-
|
|
3085
|
-
|
|
3086
|
-
const
|
|
3087
|
-
|
|
3088
|
-
|
|
3089
|
-
|
|
3090
|
-
|
|
3091
|
-
|
|
3092
|
-
|
|
3093
|
-
);
|
|
3094
|
-
const levels = new Uint8Array(dimension);
|
|
3095
|
-
let sum = 0;
|
|
3096
|
-
for (let i = 0; i < dimension; i++) {
|
|
3097
|
-
levels[i] = level(x[i], lower, upper, steps);
|
|
3098
|
-
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 });
|
|
3099
3133
|
}
|
|
3100
|
-
return
|
|
3134
|
+
return hits;
|
|
3101
3135
|
}
|
|
3102
|
-
|
|
3103
|
-
|
|
3104
|
-
|
|
3105
|
-
|
|
3106
|
-
|
|
3107
|
-
|
|
3108
|
-
|
|
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);
|
|
3109
3147
|
}
|
|
3110
|
-
function
|
|
3111
|
-
|
|
3112
|
-
|
|
3113
|
-
|
|
3114
|
-
|
|
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;
|
|
3115
3169
|
}
|
|
3116
|
-
function
|
|
3117
|
-
const
|
|
3118
|
-
|
|
3119
|
-
|
|
3120
|
-
|
|
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
|
+
}));
|
|
3121
3179
|
}
|
|
3122
|
-
function
|
|
3123
|
-
const
|
|
3124
|
-
|
|
3125
|
-
if (bits === 4) return osqNibbleProducts(bytesA, offsetA, bytesB, offsetB, codeBytes);
|
|
3126
|
-
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);
|
|
3127
3183
|
}
|
|
3128
3184
|
|
|
3129
|
-
// src/vector/
|
|
3130
|
-
function
|
|
3131
|
-
const
|
|
3132
|
-
const
|
|
3133
|
-
const
|
|
3134
|
-
const
|
|
3135
|
-
|
|
3136
|
-
|
|
3137
|
-
|
|
3138
|
-
|
|
3139
|
-
|
|
3140
|
-
|
|
3141
|
-
|
|
3142
|
-
|
|
3143
|
-
|
|
3144
|
-
|
|
3145
|
-
|
|
3146
|
-
|
|
3147
|
-
|
|
3148
|
-
|
|
3149
|
-
|
|
3150
|
-
|
|
3151
|
-
|
|
3152
|
-
|
|
3153
|
-
}
|
|
3154
|
-
|
|
3155
|
-
|
|
3156
|
-
|
|
3157
|
-
|
|
3158
|
-
|
|
3159
|
-
|
|
3160
|
-
|
|
3161
|
-
|
|
3162
|
-
|
|
3163
|
-
|
|
3164
|
-
|
|
3165
|
-
|
|
3166
|
-
|
|
3167
|
-
|
|
3168
|
-
|
|
3169
|
-
|
|
3170
|
-
|
|
3171
|
-
|
|
3172
|
-
|
|
3173
|
-
const target = store.codeBlockOf(blockIndex * capacity).bytes(start + block.usedBytes);
|
|
3174
|
-
target.set(block.bytes.subarray(0, block.usedBytes), start);
|
|
3175
|
-
}
|
|
3176
|
-
}
|
|
3177
|
-
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);
|
|
3178
3229
|
}
|
|
3179
3230
|
|
|
3180
|
-
// src/vector/
|
|
3181
|
-
function
|
|
3182
|
-
const
|
|
3183
|
-
const
|
|
3184
|
-
|
|
3185
|
-
|
|
3186
|
-
|
|
3187
|
-
|
|
3188
|
-
|
|
3189
|
-
|
|
3190
|
-
|
|
3191
|
-
|
|
3192
|
-
|
|
3193
|
-
|
|
3194
|
-
|
|
3195
|
-
|
|
3196
|
-
|
|
3197
|
-
|
|
3198
|
-
|
|
3199
|
-
|
|
3200
|
-
|
|
3201
|
-
}
|
|
3202
|
-
|
|
3203
|
-
|
|
3204
|
-
|
|
3205
|
-
|
|
3206
|
-
|
|
3207
|
-
|
|
3208
|
-
|
|
3209
|
-
|
|
3210
|
-
|
|
3211
|
-
|
|
3212
|
-
|
|
3213
|
-
|
|
3214
|
-
|
|
3215
|
-
|
|
3216
|
-
|
|
3217
|
-
|
|
3218
|
-
|
|
3219
|
-
|
|
3220
|
-
|
|
3221
|
-
if (Atomics.load(codePresent, ordinal) !== 0) return;
|
|
3222
|
-
Atomics.add(store.handles.header, STORE_CODE_COUNT, 1);
|
|
3223
|
-
Atomics.store(codePresent, ordinal, 1);
|
|
3224
|
-
}
|
|
3225
|
-
function writeCentroid(centroid) {
|
|
3226
|
-
store.handles.centroid.set(centroid);
|
|
3227
|
-
Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
3228
|
-
Atomics.store(store.handles.header, STORE_CALIBRATED, 1);
|
|
3229
|
-
}
|
|
3230
|
-
function measureInto(ordinals, sums) {
|
|
3231
|
-
if (nativeMeasure(store.handles, metric, ordinals, sums.totals)) return;
|
|
3232
|
-
noteFallback("measure");
|
|
3233
|
-
for (const vector of storedVectors(ordinals)) addToCentroidSums(sums, vector);
|
|
3234
|
-
}
|
|
3235
|
-
function* storedVectors(ordinals) {
|
|
3236
|
-
for (const ordinal of ordinals) {
|
|
3237
|
-
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);
|
|
3238
3272
|
}
|
|
3239
3273
|
}
|
|
3240
|
-
function
|
|
3241
|
-
|
|
3242
|
-
|
|
3243
|
-
|
|
3244
|
-
const offset = recordOffset(ordinal);
|
|
3245
|
-
writeRecord(block.bytes(offset + layout.slotStride), offset, code, bits, block.data(offset + layout.slotStride));
|
|
3246
|
-
markPresent(ordinal);
|
|
3247
|
-
recoding?.recode(ordinal);
|
|
3248
|
-
}
|
|
3249
|
-
function writeCodesOf(ordinals) {
|
|
3250
|
-
if (!isCalibrated() || ordinals.length === 0) return;
|
|
3251
|
-
if (nativeQuantise(store.handles, metric, ordinals)) {
|
|
3252
|
-
if (recoding !== null) for (const ordinal of ordinals) recoding.recode(ordinal);
|
|
3253
|
-
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`);
|
|
3254
3278
|
}
|
|
3255
|
-
|
|
3256
|
-
|
|
3257
|
-
|
|
3258
|
-
function clearCodes(ordinal) {
|
|
3259
|
-
if (ordinal < 0 || !reach2(ordinal)) return;
|
|
3260
|
-
if (Atomics.exchange(codePresent, ordinal, 0) === 1) Atomics.sub(store.handles.header, STORE_CODE_COUNT, 1);
|
|
3261
|
-
}
|
|
3262
|
-
function stageQuery(block, query) {
|
|
3263
|
-
if (block.simd === null || !block.hasScratch) return false;
|
|
3264
|
-
if (block.stagedOrdinal !== QUERY_STAGED) {
|
|
3265
|
-
block.bytes(block.scratchByteOffset + query.packed.length).set(query.packed, block.scratchByteOffset);
|
|
3266
|
-
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`);
|
|
3267
3282
|
}
|
|
3268
|
-
|
|
3269
|
-
|
|
3270
|
-
|
|
3271
|
-
|
|
3272
|
-
|
|
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
|
+
);
|
|
3273
3289
|
}
|
|
3274
|
-
|
|
3275
|
-
}
|
|
3276
|
-
function distanceFrom(products, query, levelBits) {
|
|
3277
|
-
const estimate = osqEstimate(products, documentTrailer, bits, query, levelBits, dimension, centroidDotNow(), metric);
|
|
3278
|
-
return osqDistance(estimate, metric);
|
|
3279
|
-
}
|
|
3280
|
-
function estimateDistance(ordinal, query) {
|
|
3281
|
-
const block = store.codeBlockOf(ordinal);
|
|
3282
|
-
const offset = recordOffset(ordinal);
|
|
3283
|
-
const products = productsAgainstQuery(block, offset, query);
|
|
3284
|
-
readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
|
|
3285
|
-
return distanceFrom(products, query, queryBits);
|
|
3286
|
-
}
|
|
3287
|
-
function prepareQuery(query) {
|
|
3288
|
-
if (!isCalibrated() || query.length !== dimension) return null;
|
|
3289
|
-
const code = osqQuantize(query, store.handles.centroid, queryBits, metric, scratch);
|
|
3290
|
-
const packed = new Uint8Array(layout.queryBytes);
|
|
3291
|
-
stageQueryLevels(code.levels, bits, packed);
|
|
3292
|
-
for (const block of store.openCodeBlocks()) block.stagedOrdinal = NOTHING_STAGED;
|
|
3293
|
-
currentQuery = {
|
|
3294
|
-
packed,
|
|
3295
|
-
lower: code.lower,
|
|
3296
|
-
upper: code.upper,
|
|
3297
|
-
correction: code.correction,
|
|
3298
|
-
sum: code.sum
|
|
3299
|
-
};
|
|
3300
|
-
return currentQuery;
|
|
3301
|
-
}
|
|
3302
|
-
function preparedDistance(prepared) {
|
|
3303
|
-
const generic = (ordinal) => holds2(ordinal) ? estimateDistance(ordinal, prepared) : Number.POSITIVE_INFINITY;
|
|
3304
|
-
if (store.handles.codeBlocks.length === 0) return generic;
|
|
3305
|
-
const block = store.codeBlockOf(0);
|
|
3306
|
-
const simd = block.simd;
|
|
3307
|
-
if (simd === null || !block.hasScratch) return generic;
|
|
3308
|
-
const presentView = codePresent;
|
|
3309
|
-
const limit = Math.min(presentView.length, capacity);
|
|
3310
|
-
const { slotsOffset, slotStride } = layout;
|
|
3311
|
-
const data = block.data(slotsOffset + slotStride);
|
|
3312
|
-
const dataLength = data.byteLength;
|
|
3313
|
-
const queryOffset = block.scratchByteOffset;
|
|
3314
|
-
return (ordinal) => {
|
|
3315
|
-
if (ordinal < 0 || ordinal >= limit || block.stagedOrdinal !== QUERY_STAGED) return generic(ordinal);
|
|
3316
|
-
if (presentView[ordinal] !== 1) return Number.POSITIVE_INFINITY;
|
|
3317
|
-
const offset = slotsOffset + ordinal * slotStride;
|
|
3318
|
-
if (offset + slotStride > dataLength) return generic(ordinal);
|
|
3319
|
-
const products = simdQueryProducts(simd, layout, offset, queryOffset);
|
|
3320
|
-
readTrailer(data, offset, codeBytes, documentTrailer);
|
|
3321
|
-
return distanceFrom(products, prepared, queryBits);
|
|
3322
|
-
};
|
|
3290
|
+
insertNode(state, ord);
|
|
3323
3291
|
}
|
|
3324
|
-
function
|
|
3325
|
-
|
|
3326
|
-
|
|
3327
|
-
|
|
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 }];
|
|
3328
3302
|
}
|
|
3329
|
-
if (!isCalibrated() || vector.length !== dimension) return null;
|
|
3330
|
-
const code = osqQuantize(vector, store.handles.centroid, placementQueryBits, metric, scratch);
|
|
3331
|
-
const levels = new Uint8Array(2 * codeBytes);
|
|
3332
|
-
levels.set(code.levels);
|
|
3333
|
-
return (ordinal) => {
|
|
3334
|
-
if (!holds2(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3335
|
-
const block = store.codeBlockOf(ordinal);
|
|
3336
|
-
const offset = recordOffset(ordinal);
|
|
3337
|
-
const products = osqNibblesByByteLevels(block.bytes(offset + codeBytes), offset, levels, codeBytes);
|
|
3338
|
-
readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
|
|
3339
|
-
return distanceFrom(products, code, placementQueryBits);
|
|
3340
|
-
};
|
|
3341
|
-
}
|
|
3342
|
-
function distanceBetween(ordA, ordB) {
|
|
3343
|
-
if (!holds2(ordA) || !holds2(ordB)) return Number.POSITIVE_INFINITY;
|
|
3344
|
-
const blockA = store.codeBlockOf(ordA);
|
|
3345
|
-
const blockB = store.codeBlockOf(ordB);
|
|
3346
|
-
const offsetA = recordOffset(ordA);
|
|
3347
|
-
const offsetB = recordOffset(ordB);
|
|
3348
|
-
const products = blockA === blockB && blockA.simd !== null ? simdPairProducts(blockA.simd, layout, offsetA, offsetB) : scalarPairProducts(
|
|
3349
|
-
layout,
|
|
3350
|
-
blockA.bytes(offsetA + codeBytes),
|
|
3351
|
-
offsetA,
|
|
3352
|
-
blockB.bytes(offsetB + codeBytes),
|
|
3353
|
-
offsetB
|
|
3354
|
-
);
|
|
3355
|
-
readTrailer(blockA.data(offsetA + layout.slotStride), offsetA, codeBytes, documentTrailer);
|
|
3356
|
-
readTrailer(blockB.data(offsetB + layout.slotStride), offsetB, codeBytes, otherTrailer);
|
|
3357
|
-
return distanceFrom(products, otherTrailer, bits);
|
|
3358
3303
|
}
|
|
3359
|
-
function
|
|
3360
|
-
|
|
3361
|
-
|
|
3362
|
-
const
|
|
3363
|
-
|
|
3364
|
-
const presentView = codePresent;
|
|
3365
|
-
const limit = Math.min(presentView.length, capacity);
|
|
3366
|
-
const { slotsOffset, slotStride } = layout;
|
|
3367
|
-
const data = block.data(slotsOffset + slotStride);
|
|
3368
|
-
const dataLength = data.byteLength;
|
|
3369
|
-
return (ordA, ordB) => {
|
|
3370
|
-
if (ordA < 0 || ordB < 0 || ordA >= limit || ordB >= limit) return distanceBetween(ordA, ordB);
|
|
3371
|
-
if (presentView[ordA] !== 1 || presentView[ordB] !== 1) return Number.POSITIVE_INFINITY;
|
|
3372
|
-
const offsetA = slotsOffset + ordA * slotStride;
|
|
3373
|
-
const offsetB = slotsOffset + ordB * slotStride;
|
|
3374
|
-
if (Math.max(offsetA, offsetB) + slotStride > dataLength) return distanceBetween(ordA, ordB);
|
|
3375
|
-
const products = simdPairProducts(simd, layout, offsetA, offsetB);
|
|
3376
|
-
readTrailer(data, offsetA, codeBytes, documentTrailer);
|
|
3377
|
-
readTrailer(data, offsetB, codeBytes, otherTrailer);
|
|
3378
|
-
return distanceFrom(products, otherTrailer, bits);
|
|
3379
|
-
};
|
|
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;
|
|
3380
3309
|
}
|
|
3381
3310
|
return {
|
|
3382
|
-
|
|
3383
|
-
|
|
3384
|
-
get size() {
|
|
3385
|
-
return Atomics.load(store.handles.header, STORE_CODE_COUNT);
|
|
3386
|
-
},
|
|
3387
|
-
get centroid() {
|
|
3388
|
-
return isCalibrated() ? store.handles.centroid : null;
|
|
3389
|
-
},
|
|
3390
|
-
isCalibrated,
|
|
3391
|
-
holdsOrdinal: holds2,
|
|
3392
|
-
writeCodes(ordinal) {
|
|
3393
|
-
singleOrdinal[0] = ordinal;
|
|
3394
|
-
writeCodesOf(singleOrdinal);
|
|
3395
|
-
},
|
|
3396
|
-
writeCodesOf,
|
|
3397
|
-
measureInto,
|
|
3398
|
-
calibrateFrom(ordinals) {
|
|
3399
|
-
const sums = createCentroidSums(dimension, metric);
|
|
3400
|
-
measureInto(ordinals, sums);
|
|
3401
|
-
const centroid = centroidOfCentroidSums(sums);
|
|
3402
|
-
if (centroid === null) return false;
|
|
3403
|
-
writeCentroid(centroid);
|
|
3404
|
-
return true;
|
|
3405
|
-
},
|
|
3406
|
-
restoreRecord(ordinal, record) {
|
|
3407
|
-
if (!reach2(ordinal) || record.length !== layout.slotStride) return;
|
|
3408
|
-
const block = store.codeBlockOf(ordinal);
|
|
3409
|
-
const offset = recordOffset(ordinal);
|
|
3410
|
-
block.bytes(offset + layout.slotStride).set(record, offset);
|
|
3411
|
-
markPresent(ordinal);
|
|
3412
|
-
recoding?.recode(ordinal);
|
|
3413
|
-
},
|
|
3414
|
-
recordAt(ordinal) {
|
|
3415
|
-
const block = store.codeBlockOf(ordinal);
|
|
3416
|
-
const offset = recordOffset(ordinal);
|
|
3417
|
-
return block.bytes(offset + layout.slotStride).subarray(offset, offset + layout.slotStride);
|
|
3418
|
-
},
|
|
3419
|
-
clearCodes,
|
|
3420
|
-
writeCentroid,
|
|
3421
|
-
resetCalibration() {
|
|
3422
|
-
recoding = null;
|
|
3423
|
-
Atomics.store(store.handles.header, STORE_CALIBRATED, 0);
|
|
3424
|
-
store.handles.centroid.fill(0);
|
|
3425
|
-
Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
3426
|
-
},
|
|
3427
|
-
resetCodes() {
|
|
3428
|
-
recoding = null;
|
|
3429
|
-
codePresent = fixedView(store.handles.codePresent, Uint8Array);
|
|
3430
|
-
codePresent.fill(0);
|
|
3431
|
-
Atomics.store(store.handles.header, STORE_CODE_COUNT, 0);
|
|
3432
|
-
},
|
|
3433
|
-
beginRecoding(centroid) {
|
|
3434
|
-
recoding = createCodeRecoding({ store, layout, metric, holds: holds2, clearCodes }, Float32Array.from(centroid));
|
|
3435
|
-
},
|
|
3436
|
-
recode(ordinal) {
|
|
3437
|
-
recoding?.recode(ordinal);
|
|
3438
|
-
},
|
|
3439
|
-
finishRecoding() {
|
|
3440
|
-
if (recoding === null) return false;
|
|
3441
|
-
const finished = recoding;
|
|
3442
|
-
recoding = null;
|
|
3443
|
-
finished.copyIntoStore(store.slots);
|
|
3444
|
-
writeCentroid(finished.centroid);
|
|
3445
|
-
return true;
|
|
3446
|
-
},
|
|
3447
|
-
abandonRecoding() {
|
|
3448
|
-
recoding = null;
|
|
3449
|
-
},
|
|
3450
|
-
prepareQuery,
|
|
3451
|
-
distanceFromPreparedByOrdinal(prepared, ordinal) {
|
|
3452
|
-
if (!holds2(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3453
|
-
return estimateDistance(ordinal, prepared);
|
|
3311
|
+
get dimension() {
|
|
3312
|
+
return dimension;
|
|
3454
3313
|
},
|
|
3455
|
-
preparedDistance,
|
|
3456
|
-
pairDistance,
|
|
3457
|
-
placementDistance: placementDistance2
|
|
3458
|
-
};
|
|
3459
|
-
}
|
|
3460
|
-
|
|
3461
|
-
// src/vector/osq/index.ts
|
|
3462
|
-
function createOsqQuantizer(dimension, bits, metric, store) {
|
|
3463
|
-
let opened = null;
|
|
3464
|
-
function shared() {
|
|
3465
|
-
if (opened === null && store.dimension === dimension && store.handles.codeLayout !== null) {
|
|
3466
|
-
opened = openSharedQuantizer(store.view, store.handles.codeLayout, metric);
|
|
3467
|
-
}
|
|
3468
|
-
return opened;
|
|
3469
|
-
}
|
|
3470
|
-
function requireShared() {
|
|
3471
|
-
const view = shared();
|
|
3472
|
-
if (view === null) throw new Error("The vector store holds no vector for the quantizer to work on");
|
|
3473
|
-
return view;
|
|
3474
|
-
}
|
|
3475
|
-
function ordinalOf(docId) {
|
|
3476
|
-
const ordinal = store.getOrdinal(docId);
|
|
3477
|
-
if (ordinal === void 0) {
|
|
3478
|
-
throw new Error(`Cannot quantize "${docId}": the vector store holds no vector for it`);
|
|
3479
|
-
}
|
|
3480
|
-
return ordinal;
|
|
3481
|
-
}
|
|
3482
|
-
return {
|
|
3483
|
-
dimension,
|
|
3484
|
-
bits,
|
|
3485
|
-
metric,
|
|
3486
3314
|
get size() {
|
|
3487
|
-
return
|
|
3488
|
-
},
|
|
3489
|
-
get centroid() {
|
|
3490
|
-
return shared()?.centroid ?? null;
|
|
3491
|
-
},
|
|
3492
|
-
isCalibrated: () => shared()?.isCalibrated() ?? false,
|
|
3493
|
-
calibrate(ordinals) {
|
|
3494
|
-
if (ordinals.length > 0) requireShared().calibrateFrom(ordinals);
|
|
3495
|
-
},
|
|
3496
|
-
measure(ordinals, sums) {
|
|
3497
|
-
if (ordinals.length > 0) requireShared().measureInto(ordinals, sums);
|
|
3498
|
-
},
|
|
3499
|
-
quantize(docId) {
|
|
3500
|
-
const ordinal = ordinalOf(docId);
|
|
3501
|
-
const view = requireShared();
|
|
3502
|
-
if (!view.isCalibrated()) view.calibrateFrom(Int32Array.of(ordinal));
|
|
3503
|
-
view.writeCodes(ordinal);
|
|
3504
|
-
},
|
|
3505
|
-
writeCodes(ordinal) {
|
|
3506
|
-
shared()?.writeCodes(ordinal);
|
|
3507
|
-
},
|
|
3508
|
-
remove(docId) {
|
|
3509
|
-
const ordinal = store.getOrdinal(docId);
|
|
3510
|
-
if (ordinal !== void 0) shared()?.clearCodes(ordinal);
|
|
3511
|
-
},
|
|
3512
|
-
removeOrdinal(ordinal) {
|
|
3513
|
-
shared()?.clearCodes(ordinal);
|
|
3315
|
+
return nodeCountOf(state) - tombstoneCountOf(state);
|
|
3514
3316
|
},
|
|
3515
|
-
|
|
3516
|
-
|
|
3517
|
-
const view = shared();
|
|
3518
|
-
const ordinal = store.getOrdinal(docId);
|
|
3519
|
-
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3520
|
-
return unpackLevels(view.recordAt(ordinal), 0, dimension, bits);
|
|
3317
|
+
get tombstoneCount() {
|
|
3318
|
+
return tombstoneCountOf(state);
|
|
3521
3319
|
},
|
|
3522
|
-
|
|
3523
|
-
const
|
|
3524
|
-
|
|
3525
|
-
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3526
|
-
return view.recordAt(ordinal);
|
|
3320
|
+
get entryPointId() {
|
|
3321
|
+
const entryPoint = entryPointOf(state);
|
|
3322
|
+
return entryPoint === -1 ? null : store.docIdForOrdinal(entryPoint) ?? null;
|
|
3527
3323
|
},
|
|
3528
|
-
|
|
3529
|
-
|
|
3530
|
-
if (view === null || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3531
|
-
return view.recordAt(ordinal);
|
|
3324
|
+
get topLayer() {
|
|
3325
|
+
return topLayerOf(state);
|
|
3532
3326
|
},
|
|
3533
|
-
|
|
3534
|
-
|
|
3327
|
+
get m() {
|
|
3328
|
+
return state.M;
|
|
3535
3329
|
},
|
|
3536
|
-
|
|
3537
|
-
|
|
3330
|
+
get efConstruction() {
|
|
3331
|
+
return state.efCons;
|
|
3538
3332
|
},
|
|
3539
|
-
|
|
3540
|
-
|
|
3333
|
+
get metric() {
|
|
3334
|
+
return state.buildMetric;
|
|
3541
3335
|
},
|
|
3542
|
-
|
|
3543
|
-
|
|
3544
|
-
const view = requireShared();
|
|
3545
|
-
view.resetCodes();
|
|
3546
|
-
view.calibrateFrom(ordinals);
|
|
3547
|
-
view.writeCodesOf(ordinals);
|
|
3336
|
+
get graphBytes() {
|
|
3337
|
+
return graphBytes(state.adjacency);
|
|
3548
3338
|
},
|
|
3549
|
-
|
|
3550
|
-
|
|
3339
|
+
get searchScratchBytes() {
|
|
3340
|
+
return searchScratchBytes(state);
|
|
3551
3341
|
},
|
|
3552
|
-
|
|
3553
|
-
shared
|
|
3342
|
+
get handles() {
|
|
3343
|
+
return shared;
|
|
3554
3344
|
},
|
|
3555
|
-
|
|
3556
|
-
|
|
3557
|
-
|
|
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);
|
|
3558
3350
|
},
|
|
3559
|
-
|
|
3560
|
-
|
|
3561
|
-
|
|
3562
|
-
|
|
3563
|
-
|
|
3564
|
-
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);
|
|
3565
3357
|
},
|
|
3566
|
-
|
|
3567
|
-
const
|
|
3568
|
-
|
|
3569
|
-
return view.pairDistance();
|
|
3358
|
+
isTombstoned: (docId) => {
|
|
3359
|
+
const ord = store.getOrdinal(docId);
|
|
3360
|
+
return ord !== void 0 && isTombstoned(state, ord);
|
|
3570
3361
|
},
|
|
3571
|
-
|
|
3572
|
-
clear()
|
|
3573
|
-
|
|
3574
|
-
|
|
3575
|
-
|
|
3576
|
-
|
|
3577
|
-
|
|
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))
|
|
3578
3376
|
};
|
|
3579
3377
|
}
|
|
3580
3378
|
|
|
3581
|
-
// src/vector/
|
|
3582
|
-
|
|
3583
|
-
|
|
3584
|
-
|
|
3585
|
-
|
|
3586
|
-
|
|
3587
|
-
|
|
3588
|
-
|
|
3589
|
-
|
|
3590
|
-
|
|
3591
|
-
|
|
3592
|
-
|
|
3593
|
-
|
|
3594
|
-
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;
|
|
3595
3392
|
}
|
|
3596
3393
|
}
|
|
3597
|
-
function
|
|
3598
|
-
|
|
3599
|
-
if (!LITTLE_ENDIAN) swapEveryValue(bytes);
|
|
3600
|
-
return bytes;
|
|
3394
|
+
function clamp(value, low, high) {
|
|
3395
|
+
return Math.min(Math.max(value, low), high);
|
|
3601
3396
|
}
|
|
3602
|
-
function
|
|
3603
|
-
|
|
3604
|
-
|
|
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;
|
|
3605
3404
|
}
|
|
3606
|
-
|
|
3607
|
-
if (!LITTLE_ENDIAN) swapEveryValue(copy);
|
|
3608
|
-
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;
|
|
3609
3406
|
}
|
|
3610
|
-
|
|
3611
|
-
|
|
3612
|
-
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
|
+
};
|
|
3613
3415
|
}
|
|
3614
|
-
function
|
|
3615
|
-
|
|
3616
|
-
for (let number = start; number < end; number++) {
|
|
3617
|
-
const top = topLayers[number];
|
|
3618
|
-
if (top < 0) continue;
|
|
3619
|
-
values += state.adjacency.level0Stride + top * state.adjacency.upperStride;
|
|
3620
|
-
}
|
|
3621
|
-
return values;
|
|
3416
|
+
function countOfCentroidSums(target) {
|
|
3417
|
+
return target.totals[target.dimension + 1];
|
|
3622
3418
|
}
|
|
3623
|
-
function
|
|
3624
|
-
|
|
3625
|
-
|
|
3626
|
-
|
|
3627
|
-
const
|
|
3628
|
-
let
|
|
3629
|
-
|
|
3630
|
-
|
|
3631
|
-
|
|
3632
|
-
|
|
3633
|
-
|
|
3634
|
-
|
|
3635
|
-
|
|
3636
|
-
|
|
3637
|
-
|
|
3638
|
-
|
|
3639
|
-
const neighbourOrdinal = array[base + i];
|
|
3640
|
-
if (neighbourOrdinal < 0 || neighbourOrdinal >= numberOfOrdinal.length) continue;
|
|
3641
|
-
const neighbour = numberOfOrdinal[neighbourOrdinal];
|
|
3642
|
-
if (neighbour === NO_NUMBER || neighbour === number || topLayers[neighbour] < layer) continue;
|
|
3643
|
-
values[cursor] = neighbour;
|
|
3644
|
-
cursor += 1;
|
|
3645
|
-
}
|
|
3646
|
-
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];
|
|
3647
3435
|
}
|
|
3648
3436
|
}
|
|
3649
|
-
|
|
3437
|
+
totals[dimension] = squares;
|
|
3438
|
+
totals[dimension + 1] += 1;
|
|
3650
3439
|
}
|
|
3651
|
-
function
|
|
3652
|
-
const
|
|
3653
|
-
const
|
|
3654
|
-
for (let
|
|
3655
|
-
|
|
3656
|
-
|
|
3657
|
-
|
|
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;
|
|
3658
3457
|
}
|
|
3659
|
-
|
|
3660
|
-
|
|
3661
|
-
|
|
3662
|
-
|
|
3663
|
-
|
|
3664
|
-
|
|
3665
|
-
|
|
3666
|
-
|
|
3667
|
-
|
|
3668
|
-
|
|
3669
|
-
const
|
|
3670
|
-
|
|
3671
|
-
|
|
3672
|
-
|
|
3673
|
-
|
|
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];
|
|
3674
3532
|
}
|
|
3675
|
-
|
|
3676
|
-
|
|
3677
|
-
|
|
3678
|
-
const
|
|
3679
|
-
const
|
|
3680
|
-
const
|
|
3681
|
-
|
|
3682
|
-
|
|
3683
|
-
|
|
3684
|
-
|
|
3685
|
-
|
|
3686
|
-
|
|
3687
|
-
|
|
3688
|
-
|
|
3689
|
-
|
|
3690
|
-
|
|
3691
|
-
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];
|
|
3692
3549
|
}
|
|
3693
|
-
|
|
3694
|
-
return { ...part, entryPoint, levels, neighbours: littleEndianBytesOf(kept.subarray(0, length)) };
|
|
3550
|
+
return { levels, lower, upper, correction, sum };
|
|
3695
3551
|
}
|
|
3696
|
-
|
|
3697
|
-
|
|
3698
|
-
|
|
3699
|
-
|
|
3700
|
-
);
|
|
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);
|
|
3701
3559
|
}
|
|
3702
|
-
function
|
|
3703
|
-
const
|
|
3704
|
-
if (
|
|
3705
|
-
|
|
3706
|
-
|
|
3707
|
-
for (let layer = 0; layer < graph.levels[number]; layer++) {
|
|
3708
|
-
if (cursor >= values.length) endsInsideAList();
|
|
3709
|
-
const count = values[cursor];
|
|
3710
|
-
if (count > values.length - cursor - 1) endsInsideAList();
|
|
3711
|
-
cursor += count + 1;
|
|
3712
|
-
}
|
|
3713
|
-
}
|
|
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);
|
|
3714
3565
|
}
|
|
3715
|
-
function
|
|
3716
|
-
const
|
|
3717
|
-
if (
|
|
3718
|
-
|
|
3719
|
-
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);
|
|
3720
3571
|
}
|
|
3721
|
-
function
|
|
3722
|
-
|
|
3723
|
-
|
|
3724
|
-
|
|
3725
|
-
|
|
3726
|
-
|
|
3727
|
-
|
|
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;
|
|
3728
3601
|
}
|
|
3602
|
+
recoded[ordinal] = 1;
|
|
3729
3603
|
}
|
|
3730
|
-
|
|
3731
|
-
|
|
3732
|
-
|
|
3733
|
-
|
|
3734
|
-
|
|
3735
|
-
|
|
3736
|
-
|
|
3737
|
-
|
|
3738
|
-
|
|
3739
|
-
|
|
3740
|
-
|
|
3741
|
-
|
|
3742
|
-
|
|
3743
|
-
|
|
3744
|
-
|
|
3745
|
-
|
|
3746
|
-
|
|
3747
|
-
const
|
|
3748
|
-
if (
|
|
3749
|
-
const
|
|
3750
|
-
|
|
3751
|
-
if (ordinal !== NO_ORDINAL) {
|
|
3752
|
-
createNode(state.adjacency, ordinal, keptTop);
|
|
3753
|
-
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
3754
|
-
if (keptTop > highestLayer) {
|
|
3755
|
-
highestLayer = keptTop;
|
|
3756
|
-
nodeOnHighestLayer = ordinal;
|
|
3757
|
-
}
|
|
3758
|
-
}
|
|
3759
|
-
for (let layer = 0; layer <= top; layer++) {
|
|
3760
|
-
const count = values[cursor];
|
|
3761
|
-
kept.length = 0;
|
|
3762
|
-
const limit = maxConns(state, layer);
|
|
3763
|
-
for (let i = 1; i <= count && kept.length < limit; i++) {
|
|
3764
|
-
const neighbour = values[cursor + i];
|
|
3765
|
-
const neighbourOrdinal = ordinalAt(neighbour);
|
|
3766
|
-
if (neighbourOrdinal === NO_ORDINAL || neighbour === number) continue;
|
|
3767
|
-
if (topLayerInParts(graph, neighbour) < layer) continue;
|
|
3768
|
-
if (!kept.includes(neighbourOrdinal)) kept.push(neighbourOrdinal);
|
|
3769
|
-
}
|
|
3770
|
-
cursor += count + 1;
|
|
3771
|
-
if (ordinal !== NO_ORDINAL && layer <= keptTop) {
|
|
3772
|
-
writeNeighbors(state.adjacency, ordinal, layer, kept, kept.length);
|
|
3773
|
-
}
|
|
3774
|
-
}
|
|
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);
|
|
3775
3625
|
}
|
|
3776
3626
|
}
|
|
3777
|
-
|
|
3778
|
-
const entryPoint = first === void 0 ? null : first.entryPoint;
|
|
3779
|
-
const entryOrdinal = entryPoint === null ? NO_ORDINAL : ordinalAt(entryPoint);
|
|
3780
|
-
const entryTop = entryPoint === null ? -1 : Math.min(topLayerInParts(graph, entryPoint), MAX_LAYER_CAP);
|
|
3781
|
-
const entryIsUsable = entryOrdinal !== NO_ORDINAL && entryTop >= 0;
|
|
3782
|
-
Atomics.store(state.header, GRAPH_ENTRY_POINT, entryIsUsable ? entryOrdinal : nodeOnHighestLayer);
|
|
3783
|
-
Atomics.store(state.header, GRAPH_TOP_LAYER, entryIsUsable ? entryTop : highestLayer);
|
|
3784
|
-
leaveIncomingUncounted(state);
|
|
3627
|
+
return { centroid, recode, copyIntoStore };
|
|
3785
3628
|
}
|
|
3786
3629
|
|
|
3787
|
-
// src/vector/
|
|
3788
|
-
function
|
|
3789
|
-
const
|
|
3790
|
-
|
|
3791
|
-
|
|
3792
|
-
|
|
3793
|
-
|
|
3794
|
-
|
|
3795
|
-
|
|
3796
|
-
|
|
3797
|
-
|
|
3798
|
-
|
|
3799
|
-
|
|
3800
|
-
|
|
3801
|
-
|
|
3802
|
-
|
|
3803
|
-
|
|
3804
|
-
|
|
3805
|
-
|
|
3806
|
-
|
|
3807
|
-
|
|
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);
|
|
3808
3688
|
}
|
|
3809
|
-
if (ord > maxOrd) maxOrd = ord;
|
|
3810
|
-
nodes.push({ ord, maxLayer: clampedMaxLayer, layers });
|
|
3811
3689
|
}
|
|
3812
|
-
|
|
3813
|
-
|
|
3814
|
-
|
|
3815
|
-
|
|
3816
|
-
|
|
3817
|
-
|
|
3818
|
-
|
|
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);
|
|
3819
3698
|
}
|
|
3820
|
-
|
|
3821
|
-
|
|
3822
|
-
|
|
3823
|
-
|
|
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;
|
|
3824
3704
|
}
|
|
3825
|
-
|
|
3705
|
+
noteFallback("quantise");
|
|
3706
|
+
for (const ordinal of ordinals) writeRecordOf(ordinal);
|
|
3826
3707
|
}
|
|
3827
|
-
|
|
3828
|
-
|
|
3829
|
-
if (
|
|
3830
|
-
|
|
3831
|
-
|
|
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;
|
|
3832
3717
|
}
|
|
3718
|
+
return true;
|
|
3833
3719
|
}
|
|
3834
|
-
|
|
3835
|
-
|
|
3836
|
-
|
|
3837
|
-
const slots = adjacencySlots(state.adjacency);
|
|
3838
|
-
for (let ord = 0; ord < slots; ord++) {
|
|
3839
|
-
const level2 = nodeMaxLayer(state, ord);
|
|
3840
|
-
if (level2 === -1) continue;
|
|
3841
|
-
if (level2 > bestLayer) {
|
|
3842
|
-
bestLayer = level2;
|
|
3843
|
-
bestOrd = ord;
|
|
3844
|
-
}
|
|
3720
|
+
function productsAgainstQuery(block, documentOffset, query) {
|
|
3721
|
+
if (block.simd !== null && stageQuery(block, query)) {
|
|
3722
|
+
return simdQueryProducts(block.simd, layout, documentOffset, block.scratchByteOffset);
|
|
3845
3723
|
}
|
|
3846
|
-
|
|
3847
|
-
|
|
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
|
+
};
|
|
3848
3830
|
}
|
|
3849
|
-
leaveIncomingUncounted(state);
|
|
3850
|
-
}
|
|
3851
|
-
|
|
3852
|
-
// src/vector/hnsw/scratch-bytes.ts
|
|
3853
|
-
function listBytes(list) {
|
|
3854
|
-
return list.ords.byteLength + list.distances.byteLength;
|
|
3855
|
-
}
|
|
3856
|
-
function workspaceBytes(workspace) {
|
|
3857
|
-
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;
|
|
3858
|
-
for (const list of workspace.linkSelections) bytes += listBytes(list);
|
|
3859
|
-
return bytes;
|
|
3860
|
-
}
|
|
3861
|
-
function searchScratchBytes(state) {
|
|
3862
|
-
const held = workspaceBytes(state.workspace) + state.neighborScratch.byteLength + state.visited.byteLength;
|
|
3863
|
-
const native = attachedNativeField(state);
|
|
3864
|
-
return native === null ? held : held + nativeScratchBytes(state, native);
|
|
3865
|
-
}
|
|
3866
|
-
|
|
3867
|
-
// src/vector/hnsw/snapshot.ts
|
|
3868
|
-
function exportSnapshot(state) {
|
|
3869
|
-
const adj = state.adjacency;
|
|
3870
|
-
const slots = adjacencySlots(adj);
|
|
3871
|
-
const used = upperUsed(adj);
|
|
3872
|
-
const stride = adj.level0Stride;
|
|
3873
|
-
rebindNodes(adj);
|
|
3874
|
-
reachTombstone(state, slots);
|
|
3875
3831
|
return {
|
|
3876
|
-
|
|
3877
|
-
|
|
3878
|
-
|
|
3879
|
-
|
|
3880
|
-
|
|
3881
|
-
|
|
3882
|
-
|
|
3883
|
-
|
|
3884
|
-
|
|
3885
|
-
|
|
3886
|
-
|
|
3887
|
-
|
|
3888
|
-
|
|
3889
|
-
|
|
3890
|
-
|
|
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
|
|
3891
3908
|
};
|
|
3892
3909
|
}
|
|
3893
|
-
function restoreSnapshot(state, snapshot) {
|
|
3894
|
-
resetGraph(state);
|
|
3895
|
-
const adj = state.adjacency;
|
|
3896
|
-
ensureAdjacencyCapacity(adj, snapshot.slots);
|
|
3897
|
-
adj.nodeLevels.set(snapshot.nodeLevels);
|
|
3898
|
-
adj.level0.set(snapshot.level0);
|
|
3899
|
-
adj.upperBase.set(snapshot.upperBase);
|
|
3900
|
-
ensureUpperCapacity(adj, snapshot.upper.length);
|
|
3901
|
-
adj.upper.set(snapshot.upper);
|
|
3902
|
-
Atomics.store(state.header, GRAPH_UPPER_USED, snapshot.upperUsed);
|
|
3903
|
-
Atomics.store(state.header, GRAPH_SLOTS, snapshot.slots);
|
|
3904
|
-
state.tombstones = fixedView(adj.handles.tombstones, Uint8Array);
|
|
3905
|
-
state.tombstones.set(snapshot.tombstones);
|
|
3906
|
-
Atomics.store(state.header, GRAPH_TOMBSTONE_COUNT, snapshot.tombstoneCount);
|
|
3907
|
-
Atomics.store(state.header, GRAPH_NODE_COUNT, snapshot.nodeCount);
|
|
3908
|
-
Atomics.store(state.header, GRAPH_ENTRY_POINT, snapshot.entryPointOrd);
|
|
3909
|
-
Atomics.store(state.header, GRAPH_TOP_LAYER, snapshot.topLayer);
|
|
3910
|
-
leaveIncomingUncounted(state);
|
|
3911
|
-
}
|
|
3912
3910
|
|
|
3913
|
-
// src/vector/
|
|
3914
|
-
function
|
|
3915
|
-
|
|
3916
|
-
|
|
3917
|
-
|
|
3918
|
-
|
|
3919
|
-
efConstruction: config?.efConstruction ?? 200,
|
|
3920
|
-
metric: config?.metric ?? "cosine"
|
|
3921
|
-
});
|
|
3922
|
-
const state = openGraphState(shared, dimension, store, quantizer, 0);
|
|
3923
|
-
const docIdOf = (ord) => store.docIdForOrdinal(ord);
|
|
3924
|
-
function exclusively(operation) {
|
|
3925
|
-
lockGraphExclusive(state.locks);
|
|
3926
|
-
try {
|
|
3927
|
-
return operation();
|
|
3928
|
-
} finally {
|
|
3929
|
-
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);
|
|
3930
3917
|
}
|
|
3918
|
+
return opened;
|
|
3931
3919
|
}
|
|
3932
|
-
function
|
|
3933
|
-
const
|
|
3934
|
-
if (
|
|
3935
|
-
|
|
3936
|
-
}
|
|
3937
|
-
const entry = store.entryForOrdinal(ord);
|
|
3938
|
-
if (!entry) {
|
|
3939
|
-
throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
|
|
3940
|
-
}
|
|
3941
|
-
if (entry.vector.length !== dimension) {
|
|
3942
|
-
throw new NarsilError(
|
|
3943
|
-
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
3944
|
-
`Vector dimension mismatch: expected ${dimension}, got ${entry.vector.length}`,
|
|
3945
|
-
{ docId, expected: dimension, received: entry.vector.length }
|
|
3946
|
-
);
|
|
3947
|
-
}
|
|
3948
|
-
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;
|
|
3949
3924
|
}
|
|
3950
|
-
function
|
|
3951
|
-
const
|
|
3952
|
-
|
|
3953
|
-
|
|
3954
|
-
if (isTombstoned(state, ord)) continue;
|
|
3955
|
-
const docId = store.docIdForOrdinal(ord);
|
|
3956
|
-
if (docId === void 0) continue;
|
|
3957
|
-
const entry = store.entryForOrdinal(ord);
|
|
3958
|
-
if (!entry) continue;
|
|
3959
|
-
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`);
|
|
3960
3929
|
}
|
|
3961
|
-
|
|
3962
|
-
function compactionNeeded() {
|
|
3963
|
-
const nodeCount = nodeCountOf(state);
|
|
3964
|
-
if (nodeCount === 0) return false;
|
|
3965
|
-
const tombstones = tombstoneCountOf(state);
|
|
3966
|
-
return tombstones / nodeCount > COMPACTION_TOMBSTONE_RATIO || tombstones > COMPACTION_ABSOLUTE_THRESHOLD;
|
|
3930
|
+
return ordinal;
|
|
3967
3931
|
}
|
|
3968
3932
|
return {
|
|
3969
|
-
|
|
3970
|
-
|
|
3971
|
-
|
|
3933
|
+
dimension,
|
|
3934
|
+
bits,
|
|
3935
|
+
metric,
|
|
3972
3936
|
get size() {
|
|
3973
|
-
return
|
|
3937
|
+
return shared()?.size ?? 0;
|
|
3974
3938
|
},
|
|
3975
|
-
get
|
|
3976
|
-
return
|
|
3939
|
+
get centroid() {
|
|
3940
|
+
return shared()?.centroid ?? null;
|
|
3977
3941
|
},
|
|
3978
|
-
|
|
3979
|
-
|
|
3980
|
-
|
|
3942
|
+
isCalibrated: () => shared()?.isCalibrated() ?? false,
|
|
3943
|
+
calibrate(ordinals) {
|
|
3944
|
+
if (ordinals.length > 0) requireShared().calibrateFrom(ordinals);
|
|
3981
3945
|
},
|
|
3982
|
-
|
|
3983
|
-
|
|
3946
|
+
measure(ordinals, sums) {
|
|
3947
|
+
if (ordinals.length > 0) requireShared().measureInto(ordinals, sums);
|
|
3984
3948
|
},
|
|
3985
|
-
|
|
3986
|
-
|
|
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);
|
|
3987
3954
|
},
|
|
3988
|
-
|
|
3989
|
-
|
|
3955
|
+
writeCodes(ordinal) {
|
|
3956
|
+
shared()?.writeCodes(ordinal);
|
|
3990
3957
|
},
|
|
3991
|
-
|
|
3992
|
-
|
|
3958
|
+
remove(docId) {
|
|
3959
|
+
const ordinal = store.getOrdinal(docId);
|
|
3960
|
+
if (ordinal !== void 0) shared()?.clearCodes(ordinal);
|
|
3993
3961
|
},
|
|
3994
|
-
|
|
3995
|
-
|
|
3962
|
+
removeOrdinal(ordinal) {
|
|
3963
|
+
shared()?.clearCodes(ordinal);
|
|
3996
3964
|
},
|
|
3997
|
-
|
|
3998
|
-
|
|
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);
|
|
3999
3971
|
},
|
|
4000
|
-
|
|
4001
|
-
|
|
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);
|
|
4002
3977
|
},
|
|
4003
|
-
|
|
4004
|
-
|
|
4005
|
-
|
|
4006
|
-
|
|
4007
|
-
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);
|
|
4008
3982
|
},
|
|
4009
|
-
|
|
4010
|
-
|
|
4011
|
-
holdsTombstone: (ordinal) => hasNode(state.adjacency, ordinal) && isTombstoned(state, ordinal),
|
|
4012
|
-
has: (docId) => {
|
|
4013
|
-
const ord = store.getOrdinal(docId);
|
|
4014
|
-
return ord !== void 0 && hasNode(state.adjacency, ord) && !isTombstoned(state, ord);
|
|
3983
|
+
restoreRecord(docId, record) {
|
|
3984
|
+
requireShared().restoreRecord(ordinalOf(docId), record);
|
|
4015
3985
|
},
|
|
4016
|
-
|
|
4017
|
-
|
|
4018
|
-
return ord !== void 0 && isTombstoned(state, ord);
|
|
3986
|
+
restoreRecordAtOrdinal(ordinal, record) {
|
|
3987
|
+
requireShared().restoreRecord(ordinal, record);
|
|
4019
3988
|
},
|
|
4020
|
-
|
|
4021
|
-
|
|
4022
|
-
|
|
4023
|
-
|
|
4024
|
-
|
|
4025
|
-
|
|
4026
|
-
|
|
4027
|
-
|
|
4028
|
-
|
|
4029
|
-
|
|
4030
|
-
|
|
4031
|
-
|
|
4032
|
-
|
|
4033
|
-
|
|
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
|
+
}
|
|
4034
4028
|
};
|
|
4035
4029
|
}
|
|
4036
4030
|
|
|
4037
|
-
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 };
|