@delali/narsil 0.3.1-next.140 → 0.3.1-next.141
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/{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,6 +1,5 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import { markSimdUnavailable, MAX_WASM_PAGES, WASM_PAGE_BYTES, VECTOR_SCRATCH_SLOTS, UNPLACED_FLAG_CHUNK_ORDINALS, COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD,
|
|
3
|
-
import { MAX_DOC_ID_LENGTH } from './chunk-MZI3TEOW.mjs';
|
|
1
|
+
import { osqCodeBytes, osqStagedQueryBytes, osqRecordBytes, unpackLevels, readTrailer, stageQueryLevels, writeRecord } from './chunk-LVY2LI35.mjs';
|
|
2
|
+
import { markSimdUnavailable, MAX_WASM_PAGES, WASM_PAGE_BYTES, VECTOR_SCRATCH_SLOTS, OSQ_STEPS, UNPLACED_FLAG_CHUNK_ORDINALS, DEFAULT_EF_SEARCH, OSQ_GRID, COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, VECTOR_BLOCK_INITIAL_SLOTS, OSQ_QUERY_BITS, MAX_VECTOR_ORDINALS, VECTOR_STORE_INITIAL_CAPACITY, PLACEMENT_ROOM_REQUESTS, LOCK_SPIN_ITERATIONS, LOCK_WAIT_SLICE_MS, MAX_LAYER_CAP, INITIAL_LIST_CAPACITY, OSQ_REFINE_ROUNDS, OSQ_REFINE_TOLERANCE, OSQ_PLACEMENT_QUERY_BITS, GRAPH_LOCK_WAIT_SLICE_MS, GRAPH_LOCK_WAIT_DEADLINE_MS, compareCodePoints, INITIAL_UPPER_SLOTS, OSQ_LAMBDA, threadSlotGone, NEAREST_LINK_FALLBACK_HOSTS, FARTHEST_REJECTED_LINKS_KEPT, MAX_DOC_ID_TABLE_BYTES } from './chunk-D33A5VMU.mjs';
|
|
4
3
|
import { NarsilError, ErrorCodes } from './chunk-35B42UFM.mjs';
|
|
5
4
|
|
|
6
5
|
// src/vector/shared-buffers/growable.ts
|
|
@@ -367,302 +366,6 @@ function releaseSlot(header, held, words, threadSlot) {
|
|
|
367
366
|
}
|
|
368
367
|
}
|
|
369
368
|
|
|
370
|
-
// src/vector/ordinal-filter.ts
|
|
371
|
-
function createOrdinalFilter(slots) {
|
|
372
|
-
return { bits: new Uint8Array(slots + 7 >>> 3), count: 0 };
|
|
373
|
-
}
|
|
374
|
-
function addToOrdinalFilter(filter, ordinal) {
|
|
375
|
-
const index = ordinal >>> 3;
|
|
376
|
-
if (index >= filter.bits.length) return;
|
|
377
|
-
const bit = 1 << (ordinal & 7);
|
|
378
|
-
if ((filter.bits[index] & bit) !== 0) return;
|
|
379
|
-
filter.bits[index] |= bit;
|
|
380
|
-
filter.count += 1;
|
|
381
|
-
}
|
|
382
|
-
function ordinalFilterHas(filter, ordinal) {
|
|
383
|
-
const index = ordinal >>> 3;
|
|
384
|
-
if (index >= filter.bits.length) return false;
|
|
385
|
-
return (filter.bits[index] & 1 << (ordinal & 7)) !== 0;
|
|
386
|
-
}
|
|
387
|
-
function removeFromOrdinalFilter(filter, ordinal) {
|
|
388
|
-
const index = ordinal >>> 3;
|
|
389
|
-
if (index >= filter.bits.length) return;
|
|
390
|
-
const bit = 1 << (ordinal & 7);
|
|
391
|
-
if ((filter.bits[index] & bit) === 0) return;
|
|
392
|
-
filter.bits[index] &= ~bit;
|
|
393
|
-
filter.count -= 1;
|
|
394
|
-
}
|
|
395
|
-
function* ordinalFilterValues(filter) {
|
|
396
|
-
const bits = filter.bits;
|
|
397
|
-
for (let index = 0; index < bits.length; index++) {
|
|
398
|
-
const byte = bits[index];
|
|
399
|
-
if (byte === 0) continue;
|
|
400
|
-
for (let offset = 0; offset < 8; offset++) {
|
|
401
|
-
if ((byte & 1 << offset) !== 0) yield index << 3 | offset;
|
|
402
|
-
}
|
|
403
|
-
}
|
|
404
|
-
}
|
|
405
|
-
|
|
406
|
-
// src/vector/filter-ordinals.ts
|
|
407
|
-
var UNRESOLVED_ORDINAL = -1;
|
|
408
|
-
var NO_VECTOR_MARK = -2;
|
|
409
|
-
function freshOrdinals(length) {
|
|
410
|
-
return new Int32Array(length).fill(UNRESOLVED_ORDINAL);
|
|
411
|
-
}
|
|
412
|
-
function mapsOf(owner) {
|
|
413
|
-
owner.vectorOrdinalMaps ??= { bytes: 0, byField: /* @__PURE__ */ new Map() };
|
|
414
|
-
return owner.vectorOrdinalMaps;
|
|
415
|
-
}
|
|
416
|
-
function mapFor(maps, docStore, space, numberingGeneration) {
|
|
417
|
-
const held = maps.byField.get(space.fieldName);
|
|
418
|
-
if (held !== void 0 && held.header === space.header && held.layoutGeneration === space.layoutGeneration && held.numberingGeneration === numberingGeneration) {
|
|
419
|
-
return held;
|
|
420
|
-
}
|
|
421
|
-
const map = {
|
|
422
|
-
header: space.header,
|
|
423
|
-
layoutGeneration: space.layoutGeneration,
|
|
424
|
-
numberingGeneration,
|
|
425
|
-
ordinals: freshOrdinals(docStore.internalIdCapacity())
|
|
426
|
-
};
|
|
427
|
-
maps.bytes += map.ordinals.byteLength - (held?.ordinals.byteLength ?? 0);
|
|
428
|
-
maps.byField.set(space.fieldName, map);
|
|
429
|
-
return map;
|
|
430
|
-
}
|
|
431
|
-
function growTo(maps, map, length) {
|
|
432
|
-
const grown = freshOrdinals(Math.max(length, map.ordinals.length * 2));
|
|
433
|
-
grown.set(map.ordinals);
|
|
434
|
-
maps.bytes += grown.byteLength - map.ordinals.byteLength;
|
|
435
|
-
map.ordinals = grown;
|
|
436
|
-
}
|
|
437
|
-
function ordinalAt(maps, map, internalId, docStore, space) {
|
|
438
|
-
if (internalId >= map.ordinals.length) growTo(maps, map, internalId + 1);
|
|
439
|
-
const held = map.ordinals[internalId];
|
|
440
|
-
if (held >= 0 && space.holdsCurrentOrdinal(held)) return held;
|
|
441
|
-
if (held <= NO_VECTOR_MARK && NO_VECTOR_MARK - held === space.slots) return UNRESOLVED_ORDINAL;
|
|
442
|
-
const docId = docStore.getExternalId(internalId);
|
|
443
|
-
const resolved = docId === void 0 ? void 0 : space.ordinalOf(docId);
|
|
444
|
-
map.ordinals[internalId] = resolved ?? NO_VECTOR_MARK - space.slots;
|
|
445
|
-
return resolved ?? UNRESOLVED_ORDINAL;
|
|
446
|
-
}
|
|
447
|
-
function ordinalFilterForSubsets(subsets, space) {
|
|
448
|
-
const filter = createOrdinalFilter(space.slots);
|
|
449
|
-
for (const subset of subsets) {
|
|
450
|
-
const docStore = subset.owner.docStore;
|
|
451
|
-
if (docStore.numberingGeneration() !== subset.numberingGeneration) continue;
|
|
452
|
-
const resolver = docStore.resolver();
|
|
453
|
-
const maps = mapsOf(subset.owner);
|
|
454
|
-
const map = mapFor(maps, docStore, space, subset.numberingGeneration);
|
|
455
|
-
const bits = subset.bits;
|
|
456
|
-
for (let wordIndex = 0; wordIndex < bits.length; wordIndex++) {
|
|
457
|
-
let word = bits[wordIndex];
|
|
458
|
-
if (word === 0) continue;
|
|
459
|
-
const base = wordIndex << 5;
|
|
460
|
-
while (word !== 0) {
|
|
461
|
-
const internalId = base + (Math.clz32(word & -word) ^ 31);
|
|
462
|
-
word &= word - 1;
|
|
463
|
-
if (!resolver.isLive(internalId)) continue;
|
|
464
|
-
const ordinal = ordinalAt(maps, map, internalId, docStore, space);
|
|
465
|
-
if (ordinal < 0 || space.isRemoved(ordinal)) continue;
|
|
466
|
-
addToOrdinalFilter(filter, ordinal);
|
|
467
|
-
}
|
|
468
|
-
}
|
|
469
|
-
}
|
|
470
|
-
return filter;
|
|
471
|
-
}
|
|
472
|
-
|
|
473
|
-
// src/vector/simd-wasm-binary.ts
|
|
474
|
-
var SIMD_DISTANCE_WASM_BASE64 = "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";
|
|
475
|
-
var SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64 = "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";
|
|
476
|
-
|
|
477
|
-
// src/vector/simd.ts
|
|
478
|
-
var wasmExports = null;
|
|
479
|
-
var f32View = null;
|
|
480
|
-
function decodeBase64(base64) {
|
|
481
|
-
if (typeof Buffer !== "undefined") {
|
|
482
|
-
return new Uint8Array(Buffer.from(base64, "base64"));
|
|
483
|
-
}
|
|
484
|
-
const binary = atob(base64);
|
|
485
|
-
const bytes = new Uint8Array(binary.length);
|
|
486
|
-
for (let i = 0; i < binary.length; i++) {
|
|
487
|
-
bytes[i] = binary.charCodeAt(i);
|
|
488
|
-
}
|
|
489
|
-
return bytes;
|
|
490
|
-
}
|
|
491
|
-
try {
|
|
492
|
-
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
493
|
-
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
494
|
-
if (typeof WebAssembly !== "undefined" && typeof WebAssembly.validate === "function" && WebAssembly.validate(wasmBuffer)) {
|
|
495
|
-
const module = new WebAssembly.Module(wasmBuffer);
|
|
496
|
-
const instance = new WebAssembly.Instance(module);
|
|
497
|
-
wasmExports = instance.exports;
|
|
498
|
-
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
499
|
-
}
|
|
500
|
-
} catch {
|
|
501
|
-
wasmExports = null;
|
|
502
|
-
f32View = null;
|
|
503
|
-
}
|
|
504
|
-
if (wasmExports === null) markSimdUnavailable();
|
|
505
|
-
var OFFSET_B_BYTES = 16384;
|
|
506
|
-
function ensureMemory(dim) {
|
|
507
|
-
if (!wasmExports || !f32View) return;
|
|
508
|
-
const needed = OFFSET_B_BYTES + dim * 4;
|
|
509
|
-
const currentSize = wasmExports.memory.buffer.byteLength;
|
|
510
|
-
if (needed > currentSize) {
|
|
511
|
-
const pagesNeeded = Math.ceil(needed / 65536);
|
|
512
|
-
const currentPages = currentSize / 65536;
|
|
513
|
-
wasmExports.memory.grow(pagesNeeded - currentPages);
|
|
514
|
-
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
515
|
-
}
|
|
516
|
-
}
|
|
517
|
-
function getF32View() {
|
|
518
|
-
if (!f32View) {
|
|
519
|
-
throw new Error("SIMD memory is not initialized");
|
|
520
|
-
}
|
|
521
|
-
return f32View;
|
|
522
|
-
}
|
|
523
|
-
function copyOneVector(a) {
|
|
524
|
-
getF32View().set(a, 0);
|
|
525
|
-
}
|
|
526
|
-
function copyTwoVectors(a, b) {
|
|
527
|
-
const view = getF32View();
|
|
528
|
-
view.set(a, 0);
|
|
529
|
-
view.set(b, OFFSET_B_BYTES / 4);
|
|
530
|
-
}
|
|
531
|
-
function simdDotProduct(a, b) {
|
|
532
|
-
if (!wasmExports || !f32View) return null;
|
|
533
|
-
ensureMemory(a.length);
|
|
534
|
-
copyTwoVectors(a, b);
|
|
535
|
-
return wasmExports.dot_product(0, OFFSET_B_BYTES, a.length);
|
|
536
|
-
}
|
|
537
|
-
function simdMagnitude(a) {
|
|
538
|
-
if (!wasmExports || !f32View) return null;
|
|
539
|
-
ensureMemory(a.length);
|
|
540
|
-
copyOneVector(a);
|
|
541
|
-
return wasmExports.magnitude(0, a.length);
|
|
542
|
-
}
|
|
543
|
-
function simdSquaredEuclideanDistance(a, b) {
|
|
544
|
-
if (!wasmExports || !f32View) return null;
|
|
545
|
-
ensureMemory(a.length);
|
|
546
|
-
copyTwoVectors(a, b);
|
|
547
|
-
return wasmExports.squared_euclidean_distance(0, OFFSET_B_BYTES, a.length);
|
|
548
|
-
}
|
|
549
|
-
var arenaModule;
|
|
550
|
-
function getArenaModule() {
|
|
551
|
-
if (arenaModule !== void 0) return arenaModule;
|
|
552
|
-
try {
|
|
553
|
-
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
554
|
-
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
555
|
-
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
556
|
-
arenaModule = null;
|
|
557
|
-
return null;
|
|
558
|
-
}
|
|
559
|
-
arenaModule = new WebAssembly.Module(wasmBuffer);
|
|
560
|
-
} catch {
|
|
561
|
-
arenaModule = null;
|
|
562
|
-
}
|
|
563
|
-
return arenaModule;
|
|
564
|
-
}
|
|
565
|
-
function createArenaSimd() {
|
|
566
|
-
try {
|
|
567
|
-
const module = getArenaModule();
|
|
568
|
-
if (module === null) return null;
|
|
569
|
-
const instance = new WebAssembly.Instance(module);
|
|
570
|
-
const exports$1 = instance.exports;
|
|
571
|
-
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)) {
|
|
572
|
-
return null;
|
|
573
|
-
}
|
|
574
|
-
return exports$1;
|
|
575
|
-
} catch {
|
|
576
|
-
return null;
|
|
577
|
-
}
|
|
578
|
-
}
|
|
579
|
-
var sharedMemoryModule;
|
|
580
|
-
function getSharedMemoryModule() {
|
|
581
|
-
if (sharedMemoryModule !== void 0) return sharedMemoryModule;
|
|
582
|
-
try {
|
|
583
|
-
const bytes = decodeBase64(SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64);
|
|
584
|
-
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
585
|
-
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
586
|
-
sharedMemoryModule = null;
|
|
587
|
-
return null;
|
|
588
|
-
}
|
|
589
|
-
sharedMemoryModule = new WebAssembly.Module(wasmBuffer);
|
|
590
|
-
} catch {
|
|
591
|
-
sharedMemoryModule = null;
|
|
592
|
-
}
|
|
593
|
-
return sharedMemoryModule;
|
|
594
|
-
}
|
|
595
|
-
function createSharedArenaSimd(memory) {
|
|
596
|
-
try {
|
|
597
|
-
const module = getSharedMemoryModule();
|
|
598
|
-
if (module === null) return null;
|
|
599
|
-
const instance = new WebAssembly.Instance(module, { env: { memory } });
|
|
600
|
-
const exports$1 = instance.exports;
|
|
601
|
-
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") {
|
|
602
|
-
return null;
|
|
603
|
-
}
|
|
604
|
-
return {
|
|
605
|
-
memory,
|
|
606
|
-
dot_product: exports$1.dot_product,
|
|
607
|
-
magnitude: exports$1.magnitude,
|
|
608
|
-
squared_euclidean_distance: exports$1.squared_euclidean_distance,
|
|
609
|
-
dot_u8: exports$1.dot_u8,
|
|
610
|
-
sqdist_u8: exports$1.sqdist_u8,
|
|
611
|
-
osq_dot_nibbles_4x4: exports$1.osq_dot_nibbles_4x4,
|
|
612
|
-
osq_dot_bits: exports$1.osq_dot_bits,
|
|
613
|
-
osq_dot_bits_pair: exports$1.osq_dot_bits_pair
|
|
614
|
-
};
|
|
615
|
-
} catch {
|
|
616
|
-
return null;
|
|
617
|
-
}
|
|
618
|
-
}
|
|
619
|
-
function arenaFloat32Distance(simd, byteA, byteB, dimension, metric, magnitudeA, magnitudeB) {
|
|
620
|
-
if (metric === "euclidean") {
|
|
621
|
-
return Math.sqrt(simd.squared_euclidean_distance(byteA, byteB, dimension));
|
|
622
|
-
}
|
|
623
|
-
const dot = simd.dot_product(byteA, byteB, dimension);
|
|
624
|
-
if (metric === "dotProduct") return -dot;
|
|
625
|
-
if (magnitudeA === 0 || magnitudeB === 0) return 1;
|
|
626
|
-
return 1 - dot / (magnitudeA * magnitudeB);
|
|
627
|
-
}
|
|
628
|
-
|
|
629
|
-
// src/vector/similarity.ts
|
|
630
|
-
function magnitude(v) {
|
|
631
|
-
const result = simdMagnitude(v);
|
|
632
|
-
if (result !== null) return result;
|
|
633
|
-
let sum = 0;
|
|
634
|
-
for (let i = 0; i < v.length; i++) {
|
|
635
|
-
sum += v[i] * v[i];
|
|
636
|
-
}
|
|
637
|
-
return Math.sqrt(sum);
|
|
638
|
-
}
|
|
639
|
-
function cosineSimilarityWithMagnitudes(a, b, magA, magB) {
|
|
640
|
-
if (magA === 0 || magB === 0) return 0;
|
|
641
|
-
return dotProduct(a, b) / (magA * magB);
|
|
642
|
-
}
|
|
643
|
-
function dotProduct(a, b) {
|
|
644
|
-
const result = simdDotProduct(a, b);
|
|
645
|
-
if (result !== null) return result;
|
|
646
|
-
let sum = 0;
|
|
647
|
-
for (let i = 0; i < a.length; i++) {
|
|
648
|
-
sum += a[i] * b[i];
|
|
649
|
-
}
|
|
650
|
-
return sum;
|
|
651
|
-
}
|
|
652
|
-
function euclideanDistance(a, b) {
|
|
653
|
-
return Math.sqrt(squaredEuclideanDistance(a, b));
|
|
654
|
-
}
|
|
655
|
-
function squaredEuclideanDistance(a, b) {
|
|
656
|
-
const result = simdSquaredEuclideanDistance(a, b);
|
|
657
|
-
if (result !== null) return result;
|
|
658
|
-
let sum = 0;
|
|
659
|
-
for (let i = 0; i < a.length; i++) {
|
|
660
|
-
const diff = a[i] - b[i];
|
|
661
|
-
sum += diff * diff;
|
|
662
|
-
}
|
|
663
|
-
return sum;
|
|
664
|
-
}
|
|
665
|
-
|
|
666
369
|
// src/vector/hnsw/adjacency/views.ts
|
|
667
370
|
var ABSENT = -1;
|
|
668
371
|
function openAdjacency(handles, m, mMax0) {
|
|
@@ -938,157 +641,176 @@ function replaceNeighbors(adj, ord, layer, neighbors, count) {
|
|
|
938
641
|
writeNeighbors(adj, ord, 0, neighbors, count);
|
|
939
642
|
}
|
|
940
643
|
|
|
941
|
-
// src/vector/
|
|
942
|
-
var
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
var TWO_TO_THE_32 = 4294967296;
|
|
946
|
-
var HALF_A_STEP = 0.5;
|
|
947
|
-
function mixedUint32(value) {
|
|
948
|
-
let mixed = value + GOLDEN_GAMMA | 0;
|
|
949
|
-
mixed ^= mixed >>> 16;
|
|
950
|
-
mixed = Math.imul(mixed, FIRST_MIX_MULTIPLIER);
|
|
951
|
-
mixed ^= mixed >>> 15;
|
|
952
|
-
mixed = Math.imul(mixed, SECOND_MIX_MULTIPLIER);
|
|
953
|
-
mixed ^= mixed >>> 15;
|
|
954
|
-
return mixed >>> 0;
|
|
955
|
-
}
|
|
956
|
-
function unitDrawOf(value) {
|
|
957
|
-
return (mixedUint32(value) + HALF_A_STEP) / TWO_TO_THE_32;
|
|
644
|
+
// src/vector/native/backend.ts
|
|
645
|
+
var nativeSearchCoreEnabled = true;
|
|
646
|
+
function nativeSearchCoreIsEnabled() {
|
|
647
|
+
return nativeSearchCoreEnabled;
|
|
958
648
|
}
|
|
959
|
-
function
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
|
|
966
|
-
items[j] = held;
|
|
967
|
-
}
|
|
968
|
-
return items;
|
|
969
|
-
}
|
|
970
|
-
|
|
971
|
-
// src/vector/hnsw/shared.ts
|
|
972
|
-
function entryPointOf(state) {
|
|
973
|
-
return Atomics.load(state.header, GRAPH_ENTRY_POINT);
|
|
974
|
-
}
|
|
975
|
-
function topLayerOf(state) {
|
|
976
|
-
return Atomics.load(state.header, GRAPH_TOP_LAYER);
|
|
977
|
-
}
|
|
978
|
-
function nodeCountOf(state) {
|
|
979
|
-
return Atomics.load(state.header, GRAPH_NODE_COUNT);
|
|
980
|
-
}
|
|
981
|
-
function tombstoneCountOf(state) {
|
|
982
|
-
return Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT);
|
|
983
|
-
}
|
|
984
|
-
function ensureCapacity(state, needed) {
|
|
985
|
-
ensureAdjacencyCapacity(state.adjacency, needed);
|
|
986
|
-
ensureVisited(state, needed);
|
|
649
|
+
function stopUsingTheNativeSearchCore(error) {
|
|
650
|
+
if (!nativeSearchCoreEnabled) return;
|
|
651
|
+
nativeSearchCoreEnabled = false;
|
|
652
|
+
console.warn(
|
|
653
|
+
"The native search core raised an error, so this thread searches through WebAssembly from now on:",
|
|
654
|
+
error instanceof Error ? error.message : String(error)
|
|
655
|
+
);
|
|
987
656
|
}
|
|
988
|
-
function
|
|
989
|
-
if (needed <= state.visited.length) return;
|
|
990
|
-
let capacity = state.visited.length === 0 ? 16 : state.visited.length;
|
|
991
|
-
while (capacity < needed) capacity *= 2;
|
|
992
|
-
const next = new Uint32Array(capacity);
|
|
993
|
-
next.set(state.visited);
|
|
994
|
-
state.visited = next;
|
|
657
|
+
function noteFallback(operation) {
|
|
995
658
|
}
|
|
996
|
-
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
659
|
+
|
|
660
|
+
// src/vector/simd-wasm-binary.ts
|
|
661
|
+
var SIMD_DISTANCE_WASM_BASE64 = "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";
|
|
662
|
+
var SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64 = "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";
|
|
663
|
+
|
|
664
|
+
// src/vector/simd.ts
|
|
665
|
+
var wasmExports = null;
|
|
666
|
+
var f32View = null;
|
|
667
|
+
function decodeBase64(base64) {
|
|
668
|
+
if (typeof Buffer !== "undefined") {
|
|
669
|
+
return new Uint8Array(Buffer.from(base64, "base64"));
|
|
1001
670
|
}
|
|
1002
|
-
|
|
1003
|
-
|
|
1004
|
-
|
|
1005
|
-
|
|
1006
|
-
|
|
1007
|
-
|
|
1008
|
-
return ord < state.tombstones.length;
|
|
1009
|
-
}
|
|
1010
|
-
function isTombstoned(state, ord) {
|
|
1011
|
-
return ord >= 0 && reachTombstone(state, ord) && state.tombstones[ord] === 1;
|
|
1012
|
-
}
|
|
1013
|
-
function nodeExists(state, ord) {
|
|
1014
|
-
return hasNode(state.adjacency, ord);
|
|
1015
|
-
}
|
|
1016
|
-
function nodeMaxLayer(state, ord) {
|
|
1017
|
-
return nodeLevel(state.adjacency, ord);
|
|
671
|
+
const binary = atob(base64);
|
|
672
|
+
const bytes = new Uint8Array(binary.length);
|
|
673
|
+
for (let i = 0; i < binary.length; i++) {
|
|
674
|
+
bytes[i] = binary.charCodeAt(i);
|
|
675
|
+
}
|
|
676
|
+
return bytes;
|
|
1018
677
|
}
|
|
1019
|
-
|
|
1020
|
-
|
|
1021
|
-
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
|
|
678
|
+
try {
|
|
679
|
+
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
680
|
+
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
681
|
+
if (typeof WebAssembly !== "undefined" && typeof WebAssembly.validate === "function" && WebAssembly.validate(wasmBuffer)) {
|
|
682
|
+
const module = new WebAssembly.Module(wasmBuffer);
|
|
683
|
+
const instance = new WebAssembly.Instance(module);
|
|
684
|
+
wasmExports = instance.exports;
|
|
685
|
+
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
1027
686
|
}
|
|
687
|
+
} catch {
|
|
688
|
+
wasmExports = null;
|
|
689
|
+
f32View = null;
|
|
1028
690
|
}
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
|
|
1032
|
-
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
|
|
691
|
+
if (wasmExports === null) markSimdUnavailable();
|
|
692
|
+
var OFFSET_B_BYTES = 16384;
|
|
693
|
+
function ensureMemory(dim) {
|
|
694
|
+
if (!wasmExports || !f32View) return;
|
|
695
|
+
const needed = OFFSET_B_BYTES + dim * 4;
|
|
696
|
+
const currentSize = wasmExports.memory.buffer.byteLength;
|
|
697
|
+
if (needed > currentSize) {
|
|
698
|
+
const pagesNeeded = Math.ceil(needed / 65536);
|
|
699
|
+
const currentPages = currentSize / 65536;
|
|
700
|
+
wasmExports.memory.grow(pagesNeeded - currentPages);
|
|
701
|
+
f32View = new Float32Array(wasmExports.memory.buffer);
|
|
1037
702
|
}
|
|
1038
703
|
}
|
|
1039
|
-
function
|
|
1040
|
-
|
|
704
|
+
function getF32View() {
|
|
705
|
+
if (!f32View) {
|
|
706
|
+
throw new Error("SIMD memory is not initialized");
|
|
707
|
+
}
|
|
708
|
+
return f32View;
|
|
1041
709
|
}
|
|
1042
|
-
function
|
|
1043
|
-
|
|
710
|
+
function copyOneVector(a) {
|
|
711
|
+
getF32View().set(a, 0);
|
|
1044
712
|
}
|
|
1045
|
-
function
|
|
1046
|
-
|
|
713
|
+
function copyTwoVectors(a, b) {
|
|
714
|
+
const view = getF32View();
|
|
715
|
+
view.set(a, 0);
|
|
716
|
+
view.set(b, OFFSET_B_BYTES / 4);
|
|
1047
717
|
}
|
|
1048
|
-
function
|
|
1049
|
-
|
|
1050
|
-
|
|
1051
|
-
|
|
718
|
+
function simdDotProduct(a, b) {
|
|
719
|
+
if (!wasmExports || !f32View) return null;
|
|
720
|
+
ensureMemory(a.length);
|
|
721
|
+
copyTwoVectors(a, b);
|
|
722
|
+
return wasmExports.dot_product(0, OFFSET_B_BYTES, a.length);
|
|
1052
723
|
}
|
|
1053
|
-
function
|
|
1054
|
-
|
|
1055
|
-
|
|
1056
|
-
|
|
1057
|
-
|
|
1058
|
-
return (aOrd, bOrd) => {
|
|
1059
|
-
const estimated = codeDistance(aOrd, bOrd);
|
|
1060
|
-
return estimated === Number.POSITIVE_INFINITY ? storeDistance(aOrd, bOrd) : estimated;
|
|
1061
|
-
};
|
|
724
|
+
function simdMagnitude(a) {
|
|
725
|
+
if (!wasmExports || !f32View) return null;
|
|
726
|
+
ensureMemory(a.length);
|
|
727
|
+
copyOneVector(a);
|
|
728
|
+
return wasmExports.magnitude(0, a.length);
|
|
1062
729
|
}
|
|
1063
|
-
function
|
|
1064
|
-
|
|
1065
|
-
|
|
1066
|
-
|
|
730
|
+
function simdSquaredEuclideanDistance(a, b) {
|
|
731
|
+
if (!wasmExports || !f32View) return null;
|
|
732
|
+
ensureMemory(a.length);
|
|
733
|
+
copyTwoVectors(a, b);
|
|
734
|
+
return wasmExports.squared_euclidean_distance(0, OFFSET_B_BYTES, a.length);
|
|
1067
735
|
}
|
|
1068
|
-
|
|
1069
|
-
|
|
736
|
+
var arenaModule;
|
|
737
|
+
function getArenaModule() {
|
|
738
|
+
if (arenaModule !== void 0) return arenaModule;
|
|
739
|
+
try {
|
|
740
|
+
const bytes = decodeBase64(SIMD_DISTANCE_WASM_BASE64);
|
|
741
|
+
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
742
|
+
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
743
|
+
arenaModule = null;
|
|
744
|
+
return null;
|
|
745
|
+
}
|
|
746
|
+
arenaModule = new WebAssembly.Module(wasmBuffer);
|
|
747
|
+
} catch {
|
|
748
|
+
arenaModule = null;
|
|
749
|
+
}
|
|
750
|
+
return arenaModule;
|
|
1070
751
|
}
|
|
1071
|
-
function
|
|
1072
|
-
|
|
1073
|
-
|
|
752
|
+
function createArenaSimd() {
|
|
753
|
+
try {
|
|
754
|
+
const module = getArenaModule();
|
|
755
|
+
if (module === null) return null;
|
|
756
|
+
const instance = new WebAssembly.Instance(module);
|
|
757
|
+
const exports$1 = instance.exports;
|
|
758
|
+
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)) {
|
|
759
|
+
return null;
|
|
760
|
+
}
|
|
761
|
+
return exports$1;
|
|
762
|
+
} catch {
|
|
763
|
+
return null;
|
|
1074
764
|
}
|
|
1075
|
-
connections.push(ord);
|
|
1076
765
|
}
|
|
1077
|
-
|
|
1078
|
-
|
|
1079
|
-
|
|
1080
|
-
|
|
1081
|
-
|
|
766
|
+
var sharedMemoryModule;
|
|
767
|
+
function getSharedMemoryModule() {
|
|
768
|
+
if (sharedMemoryModule !== void 0) return sharedMemoryModule;
|
|
769
|
+
try {
|
|
770
|
+
const bytes = decodeBase64(SIMD_DISTANCE_SHARED_MEMORY_WASM_BASE64);
|
|
771
|
+
const wasmBuffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
|
|
772
|
+
if (typeof WebAssembly === "undefined" || typeof WebAssembly.validate !== "function" || !WebAssembly.validate(wasmBuffer)) {
|
|
773
|
+
sharedMemoryModule = null;
|
|
774
|
+
return null;
|
|
775
|
+
}
|
|
776
|
+
sharedMemoryModule = new WebAssembly.Module(wasmBuffer);
|
|
777
|
+
} catch {
|
|
778
|
+
sharedMemoryModule = null;
|
|
779
|
+
}
|
|
780
|
+
return sharedMemoryModule;
|
|
1082
781
|
}
|
|
1083
|
-
function
|
|
1084
|
-
|
|
1085
|
-
|
|
1086
|
-
|
|
1087
|
-
|
|
1088
|
-
|
|
1089
|
-
|
|
782
|
+
function createSharedArenaSimd(memory) {
|
|
783
|
+
try {
|
|
784
|
+
const module = getSharedMemoryModule();
|
|
785
|
+
if (module === null) return null;
|
|
786
|
+
const instance = new WebAssembly.Instance(module, { env: { memory } });
|
|
787
|
+
const exports$1 = instance.exports;
|
|
788
|
+
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") {
|
|
789
|
+
return null;
|
|
790
|
+
}
|
|
791
|
+
return {
|
|
792
|
+
memory,
|
|
793
|
+
dot_product: exports$1.dot_product,
|
|
794
|
+
magnitude: exports$1.magnitude,
|
|
795
|
+
squared_euclidean_distance: exports$1.squared_euclidean_distance,
|
|
796
|
+
dot_u8: exports$1.dot_u8,
|
|
797
|
+
sqdist_u8: exports$1.sqdist_u8,
|
|
798
|
+
osq_dot_nibbles_4x4: exports$1.osq_dot_nibbles_4x4,
|
|
799
|
+
osq_dot_bits: exports$1.osq_dot_bits,
|
|
800
|
+
osq_dot_bits_pair: exports$1.osq_dot_bits_pair
|
|
801
|
+
};
|
|
802
|
+
} catch {
|
|
803
|
+
return null;
|
|
804
|
+
}
|
|
1090
805
|
}
|
|
1091
|
-
function
|
|
806
|
+
function arenaFloat32Distance(simd, byteA, byteB, dimension, metric, magnitudeA, magnitudeB) {
|
|
807
|
+
if (metric === "euclidean") {
|
|
808
|
+
return Math.sqrt(simd.squared_euclidean_distance(byteA, byteB, dimension));
|
|
809
|
+
}
|
|
810
|
+
const dot = simd.dot_product(byteA, byteB, dimension);
|
|
811
|
+
if (metric === "dotProduct") return -dot;
|
|
812
|
+
if (magnitudeA === 0 || magnitudeB === 0) return 1;
|
|
813
|
+
return 1 - dot / (magnitudeA * magnitudeB);
|
|
1092
814
|
}
|
|
1093
815
|
|
|
1094
816
|
// src/vector/vector-store/blocks.ts
|
|
@@ -1598,6 +1320,175 @@ function nativeConnect(state, field, metric, nearby) {
|
|
|
1598
1320
|
return writeToTheGraph(state, field, connect) === NATIVE_OK;
|
|
1599
1321
|
}
|
|
1600
1322
|
|
|
1323
|
+
// src/vector/similarity.ts
|
|
1324
|
+
function magnitude(v) {
|
|
1325
|
+
const result = simdMagnitude(v);
|
|
1326
|
+
if (result !== null) return result;
|
|
1327
|
+
let sum = 0;
|
|
1328
|
+
for (let i = 0; i < v.length; i++) {
|
|
1329
|
+
sum += v[i] * v[i];
|
|
1330
|
+
}
|
|
1331
|
+
return Math.sqrt(sum);
|
|
1332
|
+
}
|
|
1333
|
+
function cosineSimilarityWithMagnitudes(a, b, magA, magB) {
|
|
1334
|
+
if (magA === 0 || magB === 0) return 0;
|
|
1335
|
+
return dotProduct(a, b) / (magA * magB);
|
|
1336
|
+
}
|
|
1337
|
+
function dotProduct(a, b) {
|
|
1338
|
+
const result = simdDotProduct(a, b);
|
|
1339
|
+
if (result !== null) return result;
|
|
1340
|
+
let sum = 0;
|
|
1341
|
+
for (let i = 0; i < a.length; i++) {
|
|
1342
|
+
sum += a[i] * b[i];
|
|
1343
|
+
}
|
|
1344
|
+
return sum;
|
|
1345
|
+
}
|
|
1346
|
+
function euclideanDistance(a, b) {
|
|
1347
|
+
return Math.sqrt(squaredEuclideanDistance(a, b));
|
|
1348
|
+
}
|
|
1349
|
+
function squaredEuclideanDistance(a, b) {
|
|
1350
|
+
const result = simdSquaredEuclideanDistance(a, b);
|
|
1351
|
+
if (result !== null) return result;
|
|
1352
|
+
let sum = 0;
|
|
1353
|
+
for (let i = 0; i < a.length; i++) {
|
|
1354
|
+
const diff = a[i] - b[i];
|
|
1355
|
+
sum += diff * diff;
|
|
1356
|
+
}
|
|
1357
|
+
return sum;
|
|
1358
|
+
}
|
|
1359
|
+
|
|
1360
|
+
// src/vector/hnsw/insertion-order.ts
|
|
1361
|
+
var GOLDEN_GAMMA = 2654435769;
|
|
1362
|
+
var FIRST_MIX_MULTIPLIER = 569420461;
|
|
1363
|
+
var SECOND_MIX_MULTIPLIER = 1935289751;
|
|
1364
|
+
var TWO_TO_THE_32 = 4294967296;
|
|
1365
|
+
var HALF_A_STEP = 0.5;
|
|
1366
|
+
function mixedUint32(value) {
|
|
1367
|
+
let mixed = value + GOLDEN_GAMMA | 0;
|
|
1368
|
+
mixed ^= mixed >>> 16;
|
|
1369
|
+
mixed = Math.imul(mixed, FIRST_MIX_MULTIPLIER);
|
|
1370
|
+
mixed ^= mixed >>> 15;
|
|
1371
|
+
mixed = Math.imul(mixed, SECOND_MIX_MULTIPLIER);
|
|
1372
|
+
mixed ^= mixed >>> 15;
|
|
1373
|
+
return mixed >>> 0;
|
|
1374
|
+
}
|
|
1375
|
+
function unitDrawOf(value) {
|
|
1376
|
+
return (mixedUint32(value) + HALF_A_STEP) / TWO_TO_THE_32;
|
|
1377
|
+
}
|
|
1378
|
+
function shuffleInPlace(items) {
|
|
1379
|
+
let stream = items.length;
|
|
1380
|
+
for (let i = items.length - 1; i > 0; i--) {
|
|
1381
|
+
stream = mixedUint32(stream);
|
|
1382
|
+
const j = Math.floor(stream / TWO_TO_THE_32 * (i + 1));
|
|
1383
|
+
const held = items[i];
|
|
1384
|
+
items[i] = items[j];
|
|
1385
|
+
items[j] = held;
|
|
1386
|
+
}
|
|
1387
|
+
return items;
|
|
1388
|
+
}
|
|
1389
|
+
|
|
1390
|
+
// src/vector/hnsw/shared.ts
|
|
1391
|
+
function entryPointOf(state) {
|
|
1392
|
+
return Atomics.load(state.header, GRAPH_ENTRY_POINT);
|
|
1393
|
+
}
|
|
1394
|
+
function topLayerOf(state) {
|
|
1395
|
+
return Atomics.load(state.header, GRAPH_TOP_LAYER);
|
|
1396
|
+
}
|
|
1397
|
+
function nodeCountOf(state) {
|
|
1398
|
+
return Atomics.load(state.header, GRAPH_NODE_COUNT);
|
|
1399
|
+
}
|
|
1400
|
+
function tombstoneCountOf(state) {
|
|
1401
|
+
return Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT);
|
|
1402
|
+
}
|
|
1403
|
+
function ensureCapacity(state, needed) {
|
|
1404
|
+
ensureAdjacencyCapacity(state.adjacency, needed);
|
|
1405
|
+
ensureVisited(state, needed);
|
|
1406
|
+
}
|
|
1407
|
+
function ensureVisited(state, needed) {
|
|
1408
|
+
if (needed <= state.visited.length) return;
|
|
1409
|
+
let capacity = state.visited.length === 0 ? 16 : state.visited.length;
|
|
1410
|
+
while (capacity < needed) capacity *= 2;
|
|
1411
|
+
const next = new Uint32Array(capacity);
|
|
1412
|
+
next.set(state.visited);
|
|
1413
|
+
state.visited = next;
|
|
1414
|
+
}
|
|
1415
|
+
function nextVisitStamp(state) {
|
|
1416
|
+
state.visitStamp++;
|
|
1417
|
+
if (state.visitStamp === 4294967295) {
|
|
1418
|
+
state.visited.fill(0);
|
|
1419
|
+
state.visitStamp = 1;
|
|
1420
|
+
}
|
|
1421
|
+
return state.visitStamp;
|
|
1422
|
+
}
|
|
1423
|
+
function reachTombstone(state, ord) {
|
|
1424
|
+
if (ord < state.tombstones.length) return true;
|
|
1425
|
+
if (ord >= state.adjacency.handles.tombstones.byteLength) return false;
|
|
1426
|
+
state.tombstones = fixedView(state.adjacency.handles.tombstones, Uint8Array);
|
|
1427
|
+
return ord < state.tombstones.length;
|
|
1428
|
+
}
|
|
1429
|
+
function isTombstoned(state, ord) {
|
|
1430
|
+
return ord >= 0 && reachTombstone(state, ord) && state.tombstones[ord] === 1;
|
|
1431
|
+
}
|
|
1432
|
+
function nodeExists(state, ord) {
|
|
1433
|
+
return hasNode(state.adjacency, ord);
|
|
1434
|
+
}
|
|
1435
|
+
function nodeMaxLayer(state, ord) {
|
|
1436
|
+
return nodeLevel(state.adjacency, ord);
|
|
1437
|
+
}
|
|
1438
|
+
function toDistance(a, b, magA, magB, metric) {
|
|
1439
|
+
switch (metric) {
|
|
1440
|
+
case "cosine":
|
|
1441
|
+
return 1 - cosineSimilarityWithMagnitudes(a, b, magA, magB);
|
|
1442
|
+
case "dotProduct":
|
|
1443
|
+
return -dotProduct(a, b);
|
|
1444
|
+
case "euclidean":
|
|
1445
|
+
return euclideanDistance(a, b);
|
|
1446
|
+
}
|
|
1447
|
+
}
|
|
1448
|
+
function toScore(distance, metric) {
|
|
1449
|
+
switch (metric) {
|
|
1450
|
+
case "cosine":
|
|
1451
|
+
return 1 - distance;
|
|
1452
|
+
case "dotProduct":
|
|
1453
|
+
return -distance;
|
|
1454
|
+
case "euclidean":
|
|
1455
|
+
return 1 / (1 + distance);
|
|
1456
|
+
}
|
|
1457
|
+
}
|
|
1458
|
+
function levelOfOrdinal(ord, mL) {
|
|
1459
|
+
return Math.min(Math.floor(-Math.log(unitDrawOf(ord)) * mL), MAX_LAYER_CAP);
|
|
1460
|
+
}
|
|
1461
|
+
function buildsFromCodes(state) {
|
|
1462
|
+
return activeQuantizer(state) !== void 0;
|
|
1463
|
+
}
|
|
1464
|
+
function activeQuantizer(state) {
|
|
1465
|
+
const quantizer = state.quantizer;
|
|
1466
|
+
if (quantizer === void 0 || !quantizer.isCalibrated()) return void 0;
|
|
1467
|
+
return quantizer;
|
|
1468
|
+
}
|
|
1469
|
+
function nodeDistanceFunction(state, metric) {
|
|
1470
|
+
const storeDistance = state.store.pairDistance(metric);
|
|
1471
|
+
const quantizer = state.quantizer;
|
|
1472
|
+
if (quantizer === void 0 || !buildsFromCodes(state)) return storeDistance;
|
|
1473
|
+
const codeDistance = quantizer.pairDistance();
|
|
1474
|
+
return (aOrd, bOrd) => {
|
|
1475
|
+
const estimated = codeDistance(aOrd, bOrd);
|
|
1476
|
+
return estimated === Number.POSITIVE_INFINITY ? storeDistance(aOrd, bOrd) : estimated;
|
|
1477
|
+
};
|
|
1478
|
+
}
|
|
1479
|
+
function queryDistanceByOrd(state, qVec, qMag, ord, metric) {
|
|
1480
|
+
return state.store.distanceFromQuery(qVec, qMag, ord, metric);
|
|
1481
|
+
}
|
|
1482
|
+
function maxConns(state, layer) {
|
|
1483
|
+
return layer === 0 ? state.Mmax0 : state.M;
|
|
1484
|
+
}
|
|
1485
|
+
function addConnection(connections, ord) {
|
|
1486
|
+
for (let i = 0; i < connections.length; i++) {
|
|
1487
|
+
if (connections[i] === ord) return;
|
|
1488
|
+
}
|
|
1489
|
+
connections.push(ord);
|
|
1490
|
+
}
|
|
1491
|
+
|
|
1601
1492
|
// src/vector/hnsw/workspace.ts
|
|
1602
1493
|
function createList(capacity) {
|
|
1603
1494
|
return { ords: new Int32Array(capacity), distances: new Float64Array(capacity), size: 0 };
|
|
@@ -2124,6 +2015,42 @@ function countIncomingBeforeWriting(state, holdsGraphLock) {
|
|
|
2124
2015
|
}
|
|
2125
2016
|
}
|
|
2126
2017
|
|
|
2018
|
+
// src/vector/ordinal-filter.ts
|
|
2019
|
+
function createOrdinalFilter(slots) {
|
|
2020
|
+
return { bits: new Uint8Array(slots + 7 >>> 3), count: 0 };
|
|
2021
|
+
}
|
|
2022
|
+
function addToOrdinalFilter(filter, ordinal) {
|
|
2023
|
+
const index = ordinal >>> 3;
|
|
2024
|
+
if (index >= filter.bits.length) return;
|
|
2025
|
+
const bit = 1 << (ordinal & 7);
|
|
2026
|
+
if ((filter.bits[index] & bit) !== 0) return;
|
|
2027
|
+
filter.bits[index] |= bit;
|
|
2028
|
+
filter.count += 1;
|
|
2029
|
+
}
|
|
2030
|
+
function ordinalFilterHas(filter, ordinal) {
|
|
2031
|
+
const index = ordinal >>> 3;
|
|
2032
|
+
if (index >= filter.bits.length) return false;
|
|
2033
|
+
return (filter.bits[index] & 1 << (ordinal & 7)) !== 0;
|
|
2034
|
+
}
|
|
2035
|
+
function removeFromOrdinalFilter(filter, ordinal) {
|
|
2036
|
+
const index = ordinal >>> 3;
|
|
2037
|
+
if (index >= filter.bits.length) return;
|
|
2038
|
+
const bit = 1 << (ordinal & 7);
|
|
2039
|
+
if ((filter.bits[index] & bit) === 0) return;
|
|
2040
|
+
filter.bits[index] &= ~bit;
|
|
2041
|
+
filter.count -= 1;
|
|
2042
|
+
}
|
|
2043
|
+
function* ordinalFilterValues(filter) {
|
|
2044
|
+
const bits = filter.bits;
|
|
2045
|
+
for (let index = 0; index < bits.length; index++) {
|
|
2046
|
+
const byte = bits[index];
|
|
2047
|
+
if (byte === 0) continue;
|
|
2048
|
+
for (let offset = 0; offset < 8; offset++) {
|
|
2049
|
+
if ((byte & 1 << offset) !== 0) yield index << 3 | offset;
|
|
2050
|
+
}
|
|
2051
|
+
}
|
|
2052
|
+
}
|
|
2053
|
+
|
|
2127
2054
|
// src/vector/hnsw/graph-ops.ts
|
|
2128
2055
|
function readNeighborsLocked(state, ord, layer) {
|
|
2129
2056
|
for (; ; ) {
|
|
@@ -2542,1998 +2469,1420 @@ function rebuild(state) {
|
|
|
2542
2469
|
connectAfterBuild(state);
|
|
2543
2470
|
}
|
|
2544
2471
|
|
|
2545
|
-
// src/vector/
|
|
2546
|
-
|
|
2547
|
-
|
|
2548
|
-
|
|
2549
|
-
|
|
2550
|
-
|
|
2551
|
-
|
|
2552
|
-
|
|
2553
|
-
|
|
2554
|
-
|
|
2555
|
-
|
|
2556
|
-
|
|
2557
|
-
|
|
2558
|
-
|
|
2559
|
-
store.handle,
|
|
2560
|
-
query,
|
|
2561
|
-
nativeMetricCode(metric),
|
|
2562
|
-
candidateCount,
|
|
2563
|
-
state.locks.threadSlot,
|
|
2564
|
-
store.ordinals,
|
|
2565
|
-
store.distances,
|
|
2566
|
-
filter === void 0 ? null : filter.bits
|
|
2567
|
-
);
|
|
2568
|
-
} catch (error) {
|
|
2569
|
-
stopUsingTheNativeSearchCore(error);
|
|
2570
|
-
return false;
|
|
2472
|
+
// src/vector/hnsw/numbered-graph.ts
|
|
2473
|
+
var NO_NUMBER = -1;
|
|
2474
|
+
var NO_ORDINAL = -1;
|
|
2475
|
+
var NO_LAYER = -1;
|
|
2476
|
+
var BYTES_PER_VALUE = 4;
|
|
2477
|
+
var LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
|
|
2478
|
+
function swapEveryValue(bytes) {
|
|
2479
|
+
for (let i = 0; i + 3 < bytes.length; i += BYTES_PER_VALUE) {
|
|
2480
|
+
const first = bytes[i];
|
|
2481
|
+
const second = bytes[i + 1];
|
|
2482
|
+
bytes[i] = bytes[i + 3];
|
|
2483
|
+
bytes[i + 1] = bytes[i + 2];
|
|
2484
|
+
bytes[i + 2] = second;
|
|
2485
|
+
bytes[i + 3] = first;
|
|
2571
2486
|
}
|
|
2572
|
-
if (count < 0) return false;
|
|
2573
|
-
copyCandidates(store, count, candidates);
|
|
2574
|
-
return true;
|
|
2575
2487
|
}
|
|
2576
|
-
function
|
|
2577
|
-
const
|
|
2578
|
-
|
|
2579
|
-
|
|
2580
|
-
let kept = 0;
|
|
2581
|
-
for (let i = 0; i < candidates.size && kept < nearest; i++) {
|
|
2582
|
-
const ord = candidates.ords[i];
|
|
2583
|
-
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2584
|
-
ordinals[kept++] = ord;
|
|
2585
|
-
}
|
|
2586
|
-
const distances = nativeScores(store, query, metric, kept);
|
|
2587
|
-
if (distances === null) return null;
|
|
2588
|
-
const hits = [];
|
|
2589
|
-
for (let i = 0; i < kept; i++) {
|
|
2590
|
-
if (distances[i] === Number.POSITIVE_INFINITY) continue;
|
|
2591
|
-
const score = toScore(distances[i], metric);
|
|
2592
|
-
if (score < minSimilarity) continue;
|
|
2593
|
-
hits.push({ ord: ordinals[i], score });
|
|
2594
|
-
}
|
|
2595
|
-
return hits;
|
|
2488
|
+
function littleEndianBytesOf(values) {
|
|
2489
|
+
const bytes = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
|
|
2490
|
+
if (!LITTLE_ENDIAN) swapEveryValue(bytes);
|
|
2491
|
+
return bytes;
|
|
2596
2492
|
}
|
|
2597
|
-
|
|
2598
|
-
|
|
2599
|
-
|
|
2600
|
-
var WIDE_DIMENSION_LIMIT = 1024;
|
|
2601
|
-
var DEFAULT_EF_SEARCH_MARGIN_BY_BAND = {
|
|
2602
|
-
narrow: 50,
|
|
2603
|
-
middle: 75,
|
|
2604
|
-
wide: 0
|
|
2605
|
-
};
|
|
2606
|
-
var DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT = 18;
|
|
2607
|
-
var DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS = {
|
|
2608
|
-
1: 3,
|
|
2609
|
-
2: 3,
|
|
2610
|
-
4: 1,
|
|
2611
|
-
8: 1
|
|
2612
|
-
};
|
|
2613
|
-
var DEFAULT_RESCORE_DEPTH_BY_BITS = {
|
|
2614
|
-
1: {
|
|
2615
|
-
narrow: { perLimit: 3.23, perSquareRootOfLimit: 55.9 },
|
|
2616
|
-
middle: { perLimit: 2.2, perSquareRootOfLimit: 27 },
|
|
2617
|
-
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2618
|
-
},
|
|
2619
|
-
2: {
|
|
2620
|
-
narrow: { perLimit: 2.6, perSquareRootOfLimit: 22.5 },
|
|
2621
|
-
middle: { perLimit: 1, perSquareRootOfLimit: 16 },
|
|
2622
|
-
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2623
|
-
},
|
|
2624
|
-
4: {
|
|
2625
|
-
narrow: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2626
|
-
middle: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2627
|
-
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
2628
|
-
},
|
|
2629
|
-
8: {
|
|
2630
|
-
narrow: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2631
|
-
middle: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2632
|
-
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
2493
|
+
function valuesOf(bytes) {
|
|
2494
|
+
if (LITTLE_ENDIAN && bytes.byteOffset % BYTES_PER_VALUE === 0) {
|
|
2495
|
+
return new Uint32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / BYTES_PER_VALUE));
|
|
2633
2496
|
}
|
|
2634
|
-
|
|
2635
|
-
|
|
2636
|
-
|
|
2637
|
-
function dimensionBand(dimension) {
|
|
2638
|
-
if (dimension < NARROW_DIMENSION_LIMIT) return "narrow";
|
|
2639
|
-
return dimension < WIDE_DIMENSION_LIMIT ? "middle" : "wide";
|
|
2640
|
-
}
|
|
2641
|
-
function defaultRescoreDepth(bits, dimension, k) {
|
|
2642
|
-
const band = dimensionBand(dimension);
|
|
2643
|
-
const { perLimit, perSquareRootOfLimit } = DEFAULT_RESCORE_DEPTH_BY_BITS[bits][band];
|
|
2644
|
-
const floor = DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS[bits] * k;
|
|
2645
|
-
const depth = Math.max(floor, Math.ceil(perLimit * k + perSquareRootOfLimit * Math.sqrt(k)));
|
|
2646
|
-
if (bits !== 2 || band !== "middle") return depth;
|
|
2647
|
-
const withinDefaultWalk = Math.min(
|
|
2648
|
-
k + DEFAULT_EF_SEARCH_MARGIN_BY_BAND.middle,
|
|
2649
|
-
Math.ceil(k + DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT * Math.sqrt(k))
|
|
2650
|
-
);
|
|
2651
|
-
return Math.max(depth, withinDefaultWalk);
|
|
2497
|
+
const copy = bytes.slice(0, bytes.byteLength - bytes.byteLength % BYTES_PER_VALUE);
|
|
2498
|
+
if (!LITTLE_ENDIAN) swapEveryValue(copy);
|
|
2499
|
+
return new Uint32Array(copy.buffer, 0, copy.byteLength / BYTES_PER_VALUE);
|
|
2652
2500
|
}
|
|
2653
|
-
function
|
|
2654
|
-
|
|
2501
|
+
function savedTopLayer(state, ordinal) {
|
|
2502
|
+
if (ordinal === NO_ORDINAL) return NO_LAYER;
|
|
2503
|
+
return Math.min(nodeMaxLayer(state, ordinal), MAX_LAYER_CAP);
|
|
2655
2504
|
}
|
|
2656
|
-
|
|
2657
|
-
|
|
2658
|
-
|
|
2659
|
-
|
|
2660
|
-
|
|
2661
|
-
|
|
2662
|
-
const window = options.rescoreWindow ?? k;
|
|
2663
|
-
let depth = window;
|
|
2664
|
-
if (quantizer !== void 0) {
|
|
2665
|
-
depth = options.oversample === void 0 ? defaultRescoreDepth(quantizer.bits, state.dimension, window) : Math.ceil(window * options.oversample);
|
|
2505
|
+
function neighbourValueCount(state, topLayers, start, end) {
|
|
2506
|
+
let values = 0;
|
|
2507
|
+
for (let number = start; number < end; number++) {
|
|
2508
|
+
const top = topLayers[number];
|
|
2509
|
+
if (top < 0) continue;
|
|
2510
|
+
values += state.adjacency.level0Stride + top * state.adjacency.upperStride;
|
|
2666
2511
|
}
|
|
2667
|
-
|
|
2668
|
-
|
|
2669
|
-
|
|
2670
|
-
const
|
|
2671
|
-
const
|
|
2672
|
-
|
|
2673
|
-
|
|
2674
|
-
|
|
2675
|
-
|
|
2512
|
+
return values;
|
|
2513
|
+
}
|
|
2514
|
+
function serializePart(state, numbers, start, end) {
|
|
2515
|
+
const { numberOfOrdinal, ordinalOfNumber, topLayers } = numbers;
|
|
2516
|
+
const adjacency = state.adjacency;
|
|
2517
|
+
const levels = new Uint8Array(end - start);
|
|
2518
|
+
const values = new Uint32Array(neighbourValueCount(state, topLayers, start, end));
|
|
2519
|
+
let cursor = 0;
|
|
2520
|
+
for (let number = start; number < end; number++) {
|
|
2521
|
+
const top = topLayers[number];
|
|
2522
|
+
levels[number - start] = top + 1;
|
|
2523
|
+
for (let layer = 0; layer <= top; layer++) {
|
|
2524
|
+
const base = layerBase(adjacency, ordinalOfNumber[number], layer);
|
|
2525
|
+
const array = layerArray(adjacency, layer);
|
|
2526
|
+
const held = base === -1 ? 0 : Math.min(array[base], maxConns(state, layer));
|
|
2527
|
+
const countAt = cursor;
|
|
2528
|
+
cursor += 1;
|
|
2529
|
+
for (let i = 1; i <= held; i++) {
|
|
2530
|
+
const neighbourOrdinal = array[base + i];
|
|
2531
|
+
if (neighbourOrdinal < 0 || neighbourOrdinal >= numberOfOrdinal.length) continue;
|
|
2532
|
+
const neighbour = numberOfOrdinal[neighbourOrdinal];
|
|
2533
|
+
if (neighbour === NO_NUMBER || neighbour === number || topLayers[neighbour] < layer) continue;
|
|
2534
|
+
values[cursor] = neighbour;
|
|
2535
|
+
cursor += 1;
|
|
2536
|
+
}
|
|
2537
|
+
values[countAt] = cursor - countAt - 1;
|
|
2676
2538
|
}
|
|
2677
2539
|
}
|
|
2678
|
-
|
|
2679
|
-
|
|
2680
|
-
|
|
2681
|
-
|
|
2682
|
-
|
|
2683
|
-
|
|
2684
|
-
|
|
2540
|
+
return { levels, neighbours: littleEndianBytesOf(values.subarray(0, cursor)) };
|
|
2541
|
+
}
|
|
2542
|
+
function serializeNumberedGraphParts(state, numberOfOrdinal, ordinalOfNumber, partSize) {
|
|
2543
|
+
const slots = adjacencySlots(state.adjacency);
|
|
2544
|
+
const topLayers = new Int8Array(ordinalOfNumber.length).fill(-1);
|
|
2545
|
+
for (let number = 0; number < ordinalOfNumber.length; number++) {
|
|
2546
|
+
const ordinal = ordinalOfNumber[number];
|
|
2547
|
+
if (ordinal >= slots) continue;
|
|
2548
|
+
topLayers[number] = savedTopLayer(state, ordinal);
|
|
2685
2549
|
}
|
|
2686
|
-
|
|
2687
|
-
|
|
2550
|
+
const entryOrdinal = entryPointOf(state);
|
|
2551
|
+
const entryNumber = entryOrdinal >= 0 && entryOrdinal < numberOfOrdinal.length ? numberOfOrdinal[entryOrdinal] : NO_NUMBER;
|
|
2552
|
+
const entryHoldsNode = entryNumber !== NO_NUMBER && topLayers[entryNumber] >= 0;
|
|
2553
|
+
const header = {
|
|
2554
|
+
entryPoint: entryHoldsNode ? entryNumber : null,
|
|
2555
|
+
maxLayer: Math.max(0, Math.min(topLayerOf(state), MAX_LAYER_CAP)),
|
|
2556
|
+
m: state.M,
|
|
2557
|
+
efConstruction: state.efCons,
|
|
2558
|
+
metric: state.buildMetric
|
|
2559
|
+
};
|
|
2560
|
+
const numbers = { numberOfOrdinal, ordinalOfNumber, topLayers };
|
|
2561
|
+
const parts = [];
|
|
2562
|
+
for (let start = 0; start < ordinalOfNumber.length; start += partSize) {
|
|
2563
|
+
const end = Math.min(start + partSize, ordinalOfNumber.length);
|
|
2564
|
+
parts.push({ ...header, ...serializePart(state, numbers, start, end) });
|
|
2688
2565
|
}
|
|
2689
|
-
|
|
2690
|
-
|
|
2691
|
-
|
|
2692
|
-
|
|
2693
|
-
|
|
2694
|
-
|
|
2695
|
-
|
|
2696
|
-
|
|
2697
|
-
|
|
2698
|
-
|
|
2699
|
-
|
|
2566
|
+
return parts;
|
|
2567
|
+
}
|
|
2568
|
+
function graphWithoutNodes(part, firstNumber, numbers) {
|
|
2569
|
+
const values = valuesOf(part.neighbours);
|
|
2570
|
+
const levels = part.levels.slice();
|
|
2571
|
+
const kept = new Uint32Array(values.length);
|
|
2572
|
+
let cursor = 0;
|
|
2573
|
+
let length = 0;
|
|
2574
|
+
for (let at = 0; at < part.levels.length; at++) {
|
|
2575
|
+
const start = cursor;
|
|
2576
|
+
for (let layer = 0; layer < part.levels[at]; layer++) cursor += values[cursor] + 1;
|
|
2577
|
+
if (numbers.has(firstNumber + at)) {
|
|
2578
|
+
levels[at] = 0;
|
|
2579
|
+
continue;
|
|
2700
2580
|
}
|
|
2701
|
-
|
|
2702
|
-
|
|
2703
|
-
unlockGraphShared(state.locks);
|
|
2581
|
+
kept.set(values.subarray(start, cursor), length);
|
|
2582
|
+
length += cursor - start;
|
|
2704
2583
|
}
|
|
2705
|
-
|
|
2584
|
+
const entryPoint = part.entryPoint !== null && numbers.has(part.entryPoint) ? null : part.entryPoint;
|
|
2585
|
+
return { ...part, entryPoint, levels, neighbours: littleEndianBytesOf(kept.subarray(0, length)) };
|
|
2706
2586
|
}
|
|
2707
|
-
function
|
|
2708
|
-
|
|
2587
|
+
function endsInsideAList() {
|
|
2588
|
+
throw new NarsilError(
|
|
2589
|
+
ErrorCodes.PERSISTENCE_LOAD_FAILED,
|
|
2590
|
+
"Invalid vector graph payload: neighbours ends inside a list"
|
|
2591
|
+
);
|
|
2709
2592
|
}
|
|
2710
|
-
function
|
|
2711
|
-
const
|
|
2712
|
-
|
|
2713
|
-
|
|
2714
|
-
|
|
2593
|
+
function requireWholeNeighbourLists(graph) {
|
|
2594
|
+
const values = valuesOf(graph.neighbours);
|
|
2595
|
+
if (values.length * BYTES_PER_VALUE !== graph.neighbours.byteLength) endsInsideAList();
|
|
2596
|
+
let cursor = 0;
|
|
2597
|
+
for (let number = 0; number < graph.levels.length; number++) {
|
|
2598
|
+
for (let layer = 0; layer < graph.levels[number]; layer++) {
|
|
2599
|
+
if (cursor >= values.length) endsInsideAList();
|
|
2600
|
+
const count = values[cursor];
|
|
2601
|
+
if (count > values.length - cursor - 1) endsInsideAList();
|
|
2602
|
+
cursor += count + 1;
|
|
2603
|
+
}
|
|
2715
2604
|
}
|
|
2716
|
-
return resolved;
|
|
2717
2605
|
}
|
|
2718
|
-
function
|
|
2719
|
-
|
|
2720
|
-
|
|
2721
|
-
|
|
2722
|
-
return
|
|
2606
|
+
function topLayerInParts(graph, number) {
|
|
2607
|
+
const part = graph.parts[Math.floor(number / graph.partSize)];
|
|
2608
|
+
if (part === void 0) return -1;
|
|
2609
|
+
const at = number % graph.partSize;
|
|
2610
|
+
return at < part.levels.length ? part.levels[at] - 1 : -1;
|
|
2723
2611
|
}
|
|
2724
|
-
function
|
|
2725
|
-
|
|
2726
|
-
|
|
2727
|
-
|
|
2728
|
-
|
|
2729
|
-
|
|
2730
|
-
|
|
2731
|
-
|
|
2732
|
-
}
|
|
2733
|
-
const taken = [];
|
|
2734
|
-
for (const hit of ordered) {
|
|
2735
|
-
if (taken.length >= k && hit.score < taken[k - 1].score) break;
|
|
2736
|
-
const docId = docIdOf(hit.ord);
|
|
2737
|
-
if (docId !== void 0) taken.push({ ord: hit.ord, score: hit.score, docId });
|
|
2612
|
+
function highestNodeOrdinal(graph, ordinalAt) {
|
|
2613
|
+
let highest = -1;
|
|
2614
|
+
for (let p = 0; p < graph.parts.length; p++) {
|
|
2615
|
+
const levels = graph.parts[p].levels;
|
|
2616
|
+
for (let at = 0; at < levels.length; at++) {
|
|
2617
|
+
const ordinal = ordinalAt(p * graph.partSize + at);
|
|
2618
|
+
if (levels[at] > 0 && ordinal > highest) highest = ordinal;
|
|
2619
|
+
}
|
|
2738
2620
|
}
|
|
2739
|
-
return
|
|
2621
|
+
return highest;
|
|
2740
2622
|
}
|
|
2741
|
-
function
|
|
2742
|
-
|
|
2743
|
-
|
|
2744
|
-
|
|
2745
|
-
|
|
2746
|
-
|
|
2747
|
-
|
|
2748
|
-
|
|
2749
|
-
|
|
2750
|
-
|
|
2751
|
-
|
|
2623
|
+
function deserializeNumberedGraph(state, graph, ordinalOfNumber) {
|
|
2624
|
+
for (const part of graph.parts) requireWholeNeighbourLists(part);
|
|
2625
|
+
resetGraph(state);
|
|
2626
|
+
const ordinalAt = (number) => number < ordinalOfNumber.length ? ordinalOfNumber[number] : NO_ORDINAL;
|
|
2627
|
+
const highestOrdinal = highestNodeOrdinal(graph, ordinalAt);
|
|
2628
|
+
if (highestOrdinal >= 0) ensureCapacity(state, highestOrdinal + 1);
|
|
2629
|
+
const kept = [];
|
|
2630
|
+
let highestLayer = -1;
|
|
2631
|
+
let nodeOnHighestLayer = NO_ORDINAL;
|
|
2632
|
+
for (let p = 0; p < graph.parts.length; p++) {
|
|
2633
|
+
const part = graph.parts[p];
|
|
2634
|
+
const values = valuesOf(part.neighbours);
|
|
2635
|
+
let cursor = 0;
|
|
2636
|
+
for (let at = 0; at < part.levels.length; at++) {
|
|
2637
|
+
const number = p * graph.partSize + at;
|
|
2638
|
+
const top = part.levels[at] - 1;
|
|
2639
|
+
if (top < 0) continue;
|
|
2640
|
+
const ordinal = ordinalAt(number);
|
|
2641
|
+
const keptTop = Math.min(top, MAX_LAYER_CAP);
|
|
2642
|
+
if (ordinal !== NO_ORDINAL) {
|
|
2643
|
+
createNode(state.adjacency, ordinal, keptTop);
|
|
2644
|
+
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
2645
|
+
if (keptTop > highestLayer) {
|
|
2646
|
+
highestLayer = keptTop;
|
|
2647
|
+
nodeOnHighestLayer = ordinal;
|
|
2648
|
+
}
|
|
2649
|
+
}
|
|
2650
|
+
for (let layer = 0; layer <= top; layer++) {
|
|
2651
|
+
const count = values[cursor];
|
|
2652
|
+
kept.length = 0;
|
|
2653
|
+
const limit = maxConns(state, layer);
|
|
2654
|
+
for (let i = 1; i <= count && kept.length < limit; i++) {
|
|
2655
|
+
const neighbour = values[cursor + i];
|
|
2656
|
+
const neighbourOrdinal = ordinalAt(neighbour);
|
|
2657
|
+
if (neighbourOrdinal === NO_ORDINAL || neighbour === number) continue;
|
|
2658
|
+
if (topLayerInParts(graph, neighbour) < layer) continue;
|
|
2659
|
+
if (!kept.includes(neighbourOrdinal)) kept.push(neighbourOrdinal);
|
|
2660
|
+
}
|
|
2661
|
+
cursor += count + 1;
|
|
2662
|
+
if (ordinal !== NO_ORDINAL && layer <= keptTop) {
|
|
2663
|
+
writeNeighbors(state.adjacency, ordinal, layer, kept, kept.length);
|
|
2664
|
+
}
|
|
2665
|
+
}
|
|
2666
|
+
}
|
|
2752
2667
|
}
|
|
2753
|
-
const
|
|
2754
|
-
const
|
|
2755
|
-
const
|
|
2756
|
-
|
|
2757
|
-
const
|
|
2758
|
-
|
|
2759
|
-
|
|
2760
|
-
|
|
2668
|
+
const first = graph.parts[0];
|
|
2669
|
+
const entryPoint = first === void 0 ? null : first.entryPoint;
|
|
2670
|
+
const entryOrdinal = entryPoint === null ? NO_ORDINAL : ordinalAt(entryPoint);
|
|
2671
|
+
const entryTop = entryPoint === null ? -1 : Math.min(topLayerInParts(graph, entryPoint), MAX_LAYER_CAP);
|
|
2672
|
+
const entryIsUsable = entryOrdinal !== NO_ORDINAL && entryTop >= 0;
|
|
2673
|
+
Atomics.store(state.header, GRAPH_ENTRY_POINT, entryIsUsable ? entryOrdinal : nodeOnHighestLayer);
|
|
2674
|
+
Atomics.store(state.header, GRAPH_TOP_LAYER, entryIsUsable ? entryTop : highestLayer);
|
|
2675
|
+
leaveIncomingUncounted(state);
|
|
2761
2676
|
}
|
|
2762
|
-
|
|
2763
|
-
|
|
2764
|
-
|
|
2765
|
-
|
|
2766
|
-
|
|
2767
|
-
|
|
2768
|
-
|
|
2677
|
+
|
|
2678
|
+
// src/vector/hnsw/persistence.ts
|
|
2679
|
+
function resolveNodes(state, store, data) {
|
|
2680
|
+
const nodes = [];
|
|
2681
|
+
let maxOrd = -1;
|
|
2682
|
+
for (const [docId, maxLayer, layerConns] of data.nodes) {
|
|
2683
|
+
const ord = store.getOrdinal(docId);
|
|
2684
|
+
if (ord === void 0 || !store.holdsOrdinal(ord)) continue;
|
|
2685
|
+
const clampedMaxLayer = Math.min(Math.max(maxLayer, 0), MAX_LAYER_CAP);
|
|
2686
|
+
const layers = [];
|
|
2687
|
+
for (const [layer, neighbors] of layerConns) {
|
|
2688
|
+
if (layer < 0 || layer > clampedMaxLayer) continue;
|
|
2689
|
+
const limit = maxConns(state, layer);
|
|
2690
|
+
const resolved = [];
|
|
2691
|
+
for (const neighborDoc of neighbors) {
|
|
2692
|
+
if (resolved.length >= limit) break;
|
|
2693
|
+
const neighborOrd = store.getOrdinal(neighborDoc);
|
|
2694
|
+
if (neighborOrd === void 0) continue;
|
|
2695
|
+
addConnection(resolved, neighborOrd);
|
|
2696
|
+
if (neighborOrd > maxOrd) maxOrd = neighborOrd;
|
|
2697
|
+
}
|
|
2698
|
+
layers.push([layer, resolved]);
|
|
2699
|
+
}
|
|
2700
|
+
if (ord > maxOrd) maxOrd = ord;
|
|
2701
|
+
nodes.push({ ord, maxLayer: clampedMaxLayer, layers });
|
|
2769
2702
|
}
|
|
2770
|
-
return
|
|
2703
|
+
return { nodes, maxOrd };
|
|
2771
2704
|
}
|
|
2772
|
-
function
|
|
2773
|
-
|
|
2774
|
-
|
|
2775
|
-
|
|
2776
|
-
|
|
2777
|
-
const score = toScore(candidates.distances[i], metric);
|
|
2778
|
-
if (score < minSimilarity) continue;
|
|
2779
|
-
hits.push({ ord, score });
|
|
2705
|
+
function deserializeGraph(state, store, data) {
|
|
2706
|
+
resetGraph(state);
|
|
2707
|
+
const { nodes, maxOrd } = resolveNodes(state, store, data);
|
|
2708
|
+
if (maxOrd >= 0) {
|
|
2709
|
+
ensureCapacity(state, maxOrd + 1);
|
|
2780
2710
|
}
|
|
2781
|
-
|
|
2782
|
-
|
|
2783
|
-
|
|
2784
|
-
|
|
2785
|
-
|
|
2786
|
-
|
|
2787
|
-
if (rescored !== null) return rescored;
|
|
2788
|
-
const arena = state.store.prepareQueryArena(query);
|
|
2789
|
-
const qMag2 = arena ? arena.magnitude : magnitude(query);
|
|
2790
|
-
return rescoreWithFullPrecision(state, candidates, query, qMag2, arena, depth, metric, minSimilarity, filter);
|
|
2711
|
+
for (const node of nodes) {
|
|
2712
|
+
createNode(state.adjacency, node.ord, node.maxLayer);
|
|
2713
|
+
for (const [layer, neighbors] of node.layers) {
|
|
2714
|
+
writeNeighbors(state.adjacency, node.ord, layer, neighbors, neighbors.length);
|
|
2715
|
+
}
|
|
2716
|
+
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
2791
2717
|
}
|
|
2792
|
-
|
|
2793
|
-
|
|
2794
|
-
|
|
2795
|
-
|
|
2796
|
-
|
|
2797
|
-
let taken = 0;
|
|
2798
|
-
for (let i = 0; i < candidates.size && taken < depth; i++) {
|
|
2799
|
-
const ord = candidates.ords[i];
|
|
2800
|
-
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2801
|
-
taken += 1;
|
|
2802
|
-
let fullDistance;
|
|
2803
|
-
if (arenaQuery) {
|
|
2804
|
-
fullDistance = state.store.distanceFromArena(arenaQuery, ord, metric);
|
|
2805
|
-
if (fullDistance === Number.POSITIVE_INFINITY) continue;
|
|
2806
|
-
} else {
|
|
2807
|
-
const entry = entryForOrd(state, ord);
|
|
2808
|
-
if (!entry) continue;
|
|
2809
|
-
fullDistance = toDistance(query, entry.vector, qMag, entry.magnitude, metric);
|
|
2718
|
+
if (data.entryPoint != null && data.entryPoint !== "") {
|
|
2719
|
+
const epOrd = store.getOrdinal(data.entryPoint);
|
|
2720
|
+
if (epOrd !== void 0 && nodeExists(state, epOrd)) {
|
|
2721
|
+
Atomics.store(state.header, GRAPH_ENTRY_POINT, epOrd);
|
|
2722
|
+
Atomics.store(state.header, GRAPH_TOP_LAYER, Math.min(Math.max(data.maxLayer, 0), MAX_LAYER_CAP));
|
|
2810
2723
|
}
|
|
2811
|
-
const score = toScore(fullDistance, metric);
|
|
2812
|
-
if (score < minSimilarity) continue;
|
|
2813
|
-
rescored.push({ ord, score });
|
|
2814
2724
|
}
|
|
2815
|
-
|
|
2725
|
+
if (entryPointOf(state) === -1 && Atomics.load(state.header, GRAPH_NODE_COUNT) > 0) {
|
|
2726
|
+
let bestOrd = -1;
|
|
2727
|
+
let bestLayer = -1;
|
|
2728
|
+
const slots = adjacencySlots(state.adjacency);
|
|
2729
|
+
for (let ord = 0; ord < slots; ord++) {
|
|
2730
|
+
const level2 = nodeMaxLayer(state, ord);
|
|
2731
|
+
if (level2 === -1) continue;
|
|
2732
|
+
if (level2 > bestLayer) {
|
|
2733
|
+
bestLayer = level2;
|
|
2734
|
+
bestOrd = ord;
|
|
2735
|
+
}
|
|
2736
|
+
}
|
|
2737
|
+
Atomics.store(state.header, GRAPH_ENTRY_POINT, bestOrd);
|
|
2738
|
+
Atomics.store(state.header, GRAPH_TOP_LAYER, bestLayer);
|
|
2739
|
+
}
|
|
2740
|
+
leaveIncomingUncounted(state);
|
|
2816
2741
|
}
|
|
2817
|
-
|
|
2818
|
-
|
|
2819
|
-
|
|
2820
|
-
|
|
2821
|
-
score: hit.score,
|
|
2822
|
-
termFrequencies: {},
|
|
2823
|
-
fieldLengths: {},
|
|
2824
|
-
idf: {}
|
|
2825
|
-
}));
|
|
2742
|
+
|
|
2743
|
+
// src/vector/hnsw/scratch-bytes.ts
|
|
2744
|
+
function listBytes(list) {
|
|
2745
|
+
return list.ords.byteLength + list.distances.byteLength;
|
|
2826
2746
|
}
|
|
2827
|
-
function
|
|
2828
|
-
|
|
2829
|
-
|
|
2747
|
+
function workspaceBytes(workspace) {
|
|
2748
|
+
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;
|
|
2749
|
+
for (const list of workspace.linkSelections) bytes += listBytes(list);
|
|
2750
|
+
return bytes;
|
|
2830
2751
|
}
|
|
2831
|
-
|
|
2832
|
-
|
|
2833
|
-
|
|
2834
|
-
|
|
2835
|
-
const adjacency = openAdjacency(handles, shape.m, shape.mMax0);
|
|
2836
|
-
return {
|
|
2837
|
-
dimension,
|
|
2838
|
-
store,
|
|
2839
|
-
quantizer,
|
|
2840
|
-
adjacency,
|
|
2841
|
-
locks: openGraphLocks(handles, threadSlot),
|
|
2842
|
-
header: handles.header,
|
|
2843
|
-
tombstones: fixedView(handles.tombstones, Uint8Array),
|
|
2844
|
-
visited: new Uint32Array(0),
|
|
2845
|
-
visitStamp: 0,
|
|
2846
|
-
workspace: createHNSWWorkspace(),
|
|
2847
|
-
neighborScratch: new Int32Array(adjacency.level0Stride),
|
|
2848
|
-
M: shape.m,
|
|
2849
|
-
Mmax0: shape.mMax0,
|
|
2850
|
-
efCons: shape.efConstruction,
|
|
2851
|
-
buildMetric: shape.metric,
|
|
2852
|
-
mL: 1 / Math.log(shape.m)
|
|
2853
|
-
};
|
|
2752
|
+
function searchScratchBytes(state) {
|
|
2753
|
+
const held = workspaceBytes(state.workspace) + state.neighborScratch.byteLength + state.visited.byteLength;
|
|
2754
|
+
const native = attachedNativeField(state);
|
|
2755
|
+
return native === null ? held : held + nativeScratchBytes(state, native);
|
|
2854
2756
|
}
|
|
2855
2757
|
|
|
2856
|
-
// src/vector/
|
|
2857
|
-
function
|
|
2858
|
-
|
|
2859
|
-
|
|
2860
|
-
|
|
2861
|
-
|
|
2862
|
-
|
|
2863
|
-
|
|
2864
|
-
|
|
2865
|
-
|
|
2866
|
-
|
|
2867
|
-
|
|
2868
|
-
|
|
2758
|
+
// src/vector/native/walk.ts
|
|
2759
|
+
function copyCandidates(store, count, target) {
|
|
2760
|
+
ensureListCapacity(target, count);
|
|
2761
|
+
target.ords.set(store.ordinals.subarray(0, count));
|
|
2762
|
+
target.distances.set(store.distances.subarray(0, count));
|
|
2763
|
+
target.size = count;
|
|
2764
|
+
}
|
|
2765
|
+
function nativeTraverse(state, field, query, candidateCount, metric, filter, candidates) {
|
|
2766
|
+
const store = field.store;
|
|
2767
|
+
reserveOrdinals(store, candidateCount);
|
|
2768
|
+
let count;
|
|
2769
|
+
try {
|
|
2770
|
+
count = field.core.search(
|
|
2771
|
+
field.graph,
|
|
2772
|
+
store.handle,
|
|
2773
|
+
query,
|
|
2774
|
+
nativeMetricCode(metric),
|
|
2775
|
+
candidateCount,
|
|
2776
|
+
state.locks.threadSlot,
|
|
2777
|
+
store.ordinals,
|
|
2778
|
+
store.distances,
|
|
2779
|
+
filter === void 0 ? null : filter.bits
|
|
2780
|
+
);
|
|
2781
|
+
} catch (error) {
|
|
2782
|
+
stopUsingTheNativeSearchCore(error);
|
|
2783
|
+
return false;
|
|
2869
2784
|
}
|
|
2785
|
+
if (count < 0) return false;
|
|
2786
|
+
copyCandidates(store, count, candidates);
|
|
2787
|
+
return true;
|
|
2870
2788
|
}
|
|
2871
|
-
function
|
|
2872
|
-
|
|
2873
|
-
|
|
2874
|
-
|
|
2875
|
-
let
|
|
2876
|
-
for (let i = 0; i <
|
|
2877
|
-
|
|
2878
|
-
|
|
2879
|
-
|
|
2880
|
-
return;
|
|
2789
|
+
function nativeRescoredHits(store, candidates, query, depth, metric, minSimilarity, filter) {
|
|
2790
|
+
const nearest = Math.min(candidates.size, depth);
|
|
2791
|
+
reserveOrdinals(store, nearest);
|
|
2792
|
+
const ordinals = store.ordinals;
|
|
2793
|
+
let kept = 0;
|
|
2794
|
+
for (let i = 0; i < candidates.size && kept < nearest; i++) {
|
|
2795
|
+
const ord = candidates.ords[i];
|
|
2796
|
+
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2797
|
+
ordinals[kept++] = ord;
|
|
2881
2798
|
}
|
|
2882
|
-
|
|
2799
|
+
const distances = nativeScores(store, query, metric, kept);
|
|
2800
|
+
if (distances === null) return null;
|
|
2801
|
+
const hits = [];
|
|
2802
|
+
for (let i = 0; i < kept; i++) {
|
|
2803
|
+
if (distances[i] === Number.POSITIVE_INFINITY) continue;
|
|
2804
|
+
const score = toScore(distances[i], metric);
|
|
2805
|
+
if (score < minSimilarity) continue;
|
|
2806
|
+
hits.push({ ord: ordinals[i], score });
|
|
2807
|
+
}
|
|
2808
|
+
return hits;
|
|
2883
2809
|
}
|
|
2884
|
-
|
|
2885
|
-
|
|
2886
|
-
|
|
2887
|
-
|
|
2888
|
-
|
|
2889
|
-
|
|
2890
|
-
|
|
2891
|
-
|
|
2810
|
+
|
|
2811
|
+
// src/vector/search-depth/constants.ts
|
|
2812
|
+
var NARROW_DIMENSION_LIMIT = 768;
|
|
2813
|
+
var WIDE_DIMENSION_LIMIT = 1024;
|
|
2814
|
+
var DEFAULT_EF_SEARCH_MARGIN_BY_BAND = {
|
|
2815
|
+
narrow: 50,
|
|
2816
|
+
middle: 75,
|
|
2817
|
+
wide: 0
|
|
2818
|
+
};
|
|
2819
|
+
var DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT = 18;
|
|
2820
|
+
var DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS = {
|
|
2821
|
+
1: 3,
|
|
2822
|
+
2: 3,
|
|
2823
|
+
4: 1,
|
|
2824
|
+
8: 1
|
|
2825
|
+
};
|
|
2826
|
+
var DEFAULT_RESCORE_DEPTH_BY_BITS = {
|
|
2827
|
+
1: {
|
|
2828
|
+
narrow: { perLimit: 3.23, perSquareRootOfLimit: 55.9 },
|
|
2829
|
+
middle: { perLimit: 2.2, perSquareRootOfLimit: 27 },
|
|
2830
|
+
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2831
|
+
},
|
|
2832
|
+
2: {
|
|
2833
|
+
narrow: { perLimit: 2.6, perSquareRootOfLimit: 22.5 },
|
|
2834
|
+
middle: { perLimit: 1, perSquareRootOfLimit: 16 },
|
|
2835
|
+
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2836
|
+
},
|
|
2837
|
+
4: {
|
|
2838
|
+
narrow: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2839
|
+
middle: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2840
|
+
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
2841
|
+
},
|
|
2842
|
+
8: {
|
|
2843
|
+
narrow: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2844
|
+
middle: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2845
|
+
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
2846
|
+
}
|
|
2847
|
+
};
|
|
2848
|
+
|
|
2849
|
+
// src/vector/search-depth/index.ts
|
|
2850
|
+
function dimensionBand(dimension) {
|
|
2851
|
+
if (dimension < NARROW_DIMENSION_LIMIT) return "narrow";
|
|
2852
|
+
return dimension < WIDE_DIMENSION_LIMIT ? "middle" : "wide";
|
|
2892
2853
|
}
|
|
2893
|
-
function
|
|
2894
|
-
|
|
2854
|
+
function defaultRescoreDepth(bits, dimension, k) {
|
|
2855
|
+
const band = dimensionBand(dimension);
|
|
2856
|
+
const { perLimit, perSquareRootOfLimit } = DEFAULT_RESCORE_DEPTH_BY_BITS[bits][band];
|
|
2857
|
+
const floor = DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS[bits] * k;
|
|
2858
|
+
const depth = Math.max(floor, Math.ceil(perLimit * k + perSquareRootOfLimit * Math.sqrt(k)));
|
|
2859
|
+
if (bits !== 2 || band !== "middle") return depth;
|
|
2860
|
+
const withinDefaultWalk = Math.min(
|
|
2861
|
+
k + DEFAULT_EF_SEARCH_MARGIN_BY_BAND.middle,
|
|
2862
|
+
Math.ceil(k + DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT * Math.sqrt(k))
|
|
2863
|
+
);
|
|
2864
|
+
return Math.max(depth, withinDefaultWalk);
|
|
2895
2865
|
}
|
|
2896
|
-
function
|
|
2897
|
-
return
|
|
2866
|
+
function defaultEfSearch(dimension, k) {
|
|
2867
|
+
return Math.max(DEFAULT_EF_SEARCH, k + DEFAULT_EF_SEARCH_MARGIN_BY_BAND[dimensionBand(dimension)]);
|
|
2898
2868
|
}
|
|
2899
|
-
|
|
2900
|
-
|
|
2901
|
-
|
|
2902
|
-
|
|
2903
|
-
|
|
2904
|
-
|
|
2905
|
-
|
|
2906
|
-
|
|
2869
|
+
|
|
2870
|
+
// src/vector/hnsw/search.ts
|
|
2871
|
+
function traverse(state, query, k, searchMetric, options) {
|
|
2872
|
+
const calibrated = activeQuantizer(state);
|
|
2873
|
+
const quantizer = calibrated === void 0 || calibrated.size === 0 ? void 0 : calibrated;
|
|
2874
|
+
const useQuantized = quantizer !== void 0;
|
|
2875
|
+
const window = options.rescoreWindow ?? k;
|
|
2876
|
+
let depth = window;
|
|
2877
|
+
if (quantizer !== void 0) {
|
|
2878
|
+
depth = options.oversample === void 0 ? defaultRescoreDepth(quantizer.bits, state.dimension, window) : Math.ceil(window * options.oversample);
|
|
2879
|
+
}
|
|
2880
|
+
const ef = Math.max(options.efSearch ?? defaultEfSearch(state.dimension, window), depth);
|
|
2881
|
+
const filter = options.filter;
|
|
2882
|
+
const workspace = state.workspace;
|
|
2883
|
+
const candidates = workspace.traversal;
|
|
2884
|
+
const native = nativeFieldFor();
|
|
2885
|
+
if (native !== null) {
|
|
2886
|
+
candidates.size = 0;
|
|
2887
|
+
if (nativeTraverse(state, native, query, ef, searchMetric, filter, candidates)) {
|
|
2888
|
+
return { candidates, depth: useQuantized ? depth : 0, arenaQuery: null, qMag: 0, native };
|
|
2907
2889
|
}
|
|
2908
|
-
}
|
|
2909
|
-
|
|
2910
|
-
|
|
2911
|
-
|
|
2890
|
+
}
|
|
2891
|
+
const store = state.store;
|
|
2892
|
+
const arenaQuery = store.prepareQueryArena(query);
|
|
2893
|
+
const qMag = arenaQuery ? arenaQuery.magnitude : magnitude(query);
|
|
2894
|
+
let distFn;
|
|
2895
|
+
if (quantizer !== void 0) {
|
|
2896
|
+
const prepared = quantizer.prepareQuery(query);
|
|
2897
|
+
if (prepared) distFn = quantizer.preparedDistance(prepared);
|
|
2898
|
+
}
|
|
2899
|
+
if (!distFn && arenaQuery) {
|
|
2900
|
+
distFn = store.queryDistance(arenaQuery, searchMetric);
|
|
2901
|
+
}
|
|
2902
|
+
candidates.size = 0;
|
|
2903
|
+
lockGraphShared(state.locks);
|
|
2904
|
+
try {
|
|
2905
|
+
const entryPoint = entryPointOf(state);
|
|
2906
|
+
if (entryPoint === -1) return { candidates, depth: useQuantized ? depth : 0, arenaQuery, qMag, native: null };
|
|
2907
|
+
setSingleEntryPoint(workspace, entryPoint);
|
|
2908
|
+
for (let layer = topLayerOf(state); layer >= 1; layer--) {
|
|
2909
|
+
searchLayer(state, query, qMag, 1, layer, searchMetric, false, distFn, candidates, void 0, options.clock);
|
|
2910
|
+
if (candidates.size > 0) {
|
|
2911
|
+
setSingleEntryPoint(workspace, candidates.ords[0]);
|
|
2912
|
+
}
|
|
2912
2913
|
}
|
|
2914
|
+
searchLayer(state, query, qMag, ef, 0, searchMetric, true, distFn, candidates, filter, options.clock);
|
|
2915
|
+
} finally {
|
|
2916
|
+
unlockGraphShared(state.locks);
|
|
2913
2917
|
}
|
|
2914
|
-
|
|
2915
|
-
totals[dimension + 1] += 1;
|
|
2918
|
+
return { candidates, depth: useQuantized ? depth : 0, arenaQuery, qMag, native: null };
|
|
2916
2919
|
}
|
|
2917
|
-
function
|
|
2918
|
-
|
|
2919
|
-
const mean = new Float64Array(target.dimension);
|
|
2920
|
-
for (let i = 0; i < mean.length; i++) mean[i] = target.totals[i] / count;
|
|
2921
|
-
return mean;
|
|
2920
|
+
function bestFirst(a, b) {
|
|
2921
|
+
return b.score - a.score || compareCodePoints(a.docId, b.docId);
|
|
2922
2922
|
}
|
|
2923
|
-
function
|
|
2924
|
-
|
|
2925
|
-
const
|
|
2926
|
-
|
|
2927
|
-
|
|
2928
|
-
if (target.metric === "cosine") {
|
|
2929
|
-
let squares = 0;
|
|
2930
|
-
for (let i = 0; i < dimension; i++) squares += mean[i] * mean[i];
|
|
2931
|
-
const length = Math.sqrt(squares);
|
|
2932
|
-
for (let i = 0; i < dimension; i++) centroid[i] = length === 0 ? mean[i] : mean[i] / length;
|
|
2933
|
-
return centroid;
|
|
2923
|
+
function resolveEvery(hits, docIdOf) {
|
|
2924
|
+
const resolved = [];
|
|
2925
|
+
for (const hit of hits) {
|
|
2926
|
+
const docId = docIdOf(hit.ord);
|
|
2927
|
+
if (docId !== void 0) resolved.push({ ord: hit.ord, score: hit.score, docId });
|
|
2934
2928
|
}
|
|
2935
|
-
|
|
2936
|
-
return centroid;
|
|
2937
|
-
}
|
|
2938
|
-
function level(value, lower, upper, steps) {
|
|
2939
|
-
if (upper === lower) return 0;
|
|
2940
|
-
return Math.floor((clamp(value, lower, upper) - lower) * steps / (upper - lower) + 0.5);
|
|
2929
|
+
return resolved;
|
|
2941
2930
|
}
|
|
2942
|
-
function
|
|
2943
|
-
let
|
|
2944
|
-
|
|
2945
|
-
const width = (upper - lower) / steps;
|
|
2946
|
-
for (let i = 0; i < x.length; i++) {
|
|
2947
|
-
const q = lower + width * level(x[i], lower, upper, steps);
|
|
2948
|
-
xe += x[i] * (x[i] - q);
|
|
2949
|
-
e += (x[i] - q) * (x[i] - q);
|
|
2931
|
+
function scoresDescend(hits) {
|
|
2932
|
+
for (let i = 1; i < hits.length; i++) {
|
|
2933
|
+
if (!(hits[i].score <= hits[i - 1].score)) return false;
|
|
2950
2934
|
}
|
|
2951
|
-
return
|
|
2935
|
+
return hits.length === 0 || !Number.isNaN(hits[0].score);
|
|
2952
2936
|
}
|
|
2953
|
-
function
|
|
2954
|
-
|
|
2955
|
-
|
|
2956
|
-
let norm = 0;
|
|
2957
|
-
for (let i = 0; i < x.length; i++) norm += x[i] * x[i];
|
|
2958
|
-
if (norm === 0 || upper === lower) return [lower, upper];
|
|
2959
|
-
let best = loss(x, lower, upper, steps, norm);
|
|
2960
|
-
for (let round = 0; round < OSQ_REFINE_ROUNDS; round++) {
|
|
2961
|
-
let daa = 0;
|
|
2962
|
-
let dab = 0;
|
|
2963
|
-
let dbb = 0;
|
|
2964
|
-
let dax = 0;
|
|
2965
|
-
let dbx = 0;
|
|
2966
|
-
for (let i = 0; i < x.length; i++) {
|
|
2967
|
-
const s = level(x[i], lower, upper, steps) / steps;
|
|
2968
|
-
daa += (1 - s) * (1 - s);
|
|
2969
|
-
dab += (1 - s) * s;
|
|
2970
|
-
dbb += s * s;
|
|
2971
|
-
dax += x[i] * (1 - s);
|
|
2972
|
-
dbx += x[i] * s;
|
|
2973
|
-
}
|
|
2974
|
-
const m0 = (1 - OSQ_LAMBDA) * dax * dax / norm + OSQ_LAMBDA * daa;
|
|
2975
|
-
const m1 = (1 - OSQ_LAMBDA) * dax * dbx / norm + OSQ_LAMBDA * dab;
|
|
2976
|
-
const m2 = (1 - OSQ_LAMBDA) * dbx * dbx / norm + OSQ_LAMBDA * dbb;
|
|
2977
|
-
const det = m0 * m2 - m1 * m1;
|
|
2978
|
-
if (det === 0) return [lower, upper];
|
|
2979
|
-
const a = (m2 * dax - m1 * dbx) / det;
|
|
2980
|
-
const b = (m0 * dbx - m1 * dax) / det;
|
|
2981
|
-
if (Math.abs(a - lower) < OSQ_REFINE_TOLERANCE && Math.abs(b - upper) < OSQ_REFINE_TOLERANCE) return [lower, upper];
|
|
2982
|
-
const candidate = loss(x, a, b, steps, norm);
|
|
2983
|
-
if (candidate > best) return [lower, upper];
|
|
2984
|
-
lower = a;
|
|
2985
|
-
upper = b;
|
|
2986
|
-
best = candidate;
|
|
2937
|
+
function bestResolvedHits(hits, k, docIdOf) {
|
|
2938
|
+
if (!Number.isInteger(k) || k <= 0) {
|
|
2939
|
+
return resolveEvery(hits, docIdOf).sort(bestFirst).slice(0, k);
|
|
2987
2940
|
}
|
|
2988
|
-
|
|
2989
|
-
|
|
2990
|
-
|
|
2991
|
-
|
|
2941
|
+
let ordered = hits;
|
|
2942
|
+
if (!scoresDescend(ordered)) {
|
|
2943
|
+
if (hits.some((hit) => Number.isNaN(hit.score))) return resolveEvery(hits, docIdOf).sort(bestFirst).slice(0, k);
|
|
2944
|
+
ordered = hits.slice().sort((a, b) => b.score - a.score);
|
|
2945
|
+
}
|
|
2946
|
+
const taken = [];
|
|
2947
|
+
for (const hit of ordered) {
|
|
2948
|
+
if (taken.length >= k && hit.score < taken[k - 1].score) break;
|
|
2949
|
+
const docId = docIdOf(hit.ord);
|
|
2950
|
+
if (docId !== void 0) taken.push({ ord: hit.ord, score: hit.score, docId });
|
|
2951
|
+
}
|
|
2952
|
+
return taken.sort(bestFirst).slice(0, k);
|
|
2992
2953
|
}
|
|
2993
|
-
function
|
|
2994
|
-
|
|
2995
|
-
|
|
2996
|
-
|
|
2997
|
-
|
|
2998
|
-
|
|
2999
|
-
|
|
3000
|
-
let total = 0;
|
|
3001
|
-
let minimum = Number.POSITIVE_INFINITY;
|
|
3002
|
-
let maximum = Number.NEGATIVE_INFINITY;
|
|
3003
|
-
for (let i = 0; i < dimension; i++) {
|
|
3004
|
-
x[i] = v[i] - centroid[i];
|
|
3005
|
-
correction += metric === "euclidean" ? x[i] * x[i] : v[i] * centroid[i];
|
|
3006
|
-
total += x[i];
|
|
3007
|
-
if (x[i] < minimum) minimum = x[i];
|
|
3008
|
-
if (x[i] > maximum) maximum = x[i];
|
|
2954
|
+
function collectHits(state, query, k, searchMetric, minSimilarity, options) {
|
|
2955
|
+
if (query.length !== state.dimension) {
|
|
2956
|
+
throw new NarsilError(
|
|
2957
|
+
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
2958
|
+
`Vector dimension mismatch: expected ${state.dimension}, got ${query.length}`,
|
|
2959
|
+
{ expected: state.dimension, received: query.length }
|
|
2960
|
+
);
|
|
3009
2961
|
}
|
|
3010
|
-
const
|
|
3011
|
-
|
|
3012
|
-
|
|
3013
|
-
const std = Math.sqrt(spread / dimension);
|
|
3014
|
-
const steps = OSQ_STEPS[bits];
|
|
3015
|
-
const [lower, upper] = refine(
|
|
3016
|
-
x,
|
|
3017
|
-
clamp(mean - OSQ_GRID[bits] * std, minimum, maximum),
|
|
3018
|
-
clamp(mean + OSQ_GRID[bits] * std, minimum, maximum),
|
|
3019
|
-
steps
|
|
3020
|
-
);
|
|
3021
|
-
const levels = new Uint8Array(dimension);
|
|
3022
|
-
let sum = 0;
|
|
3023
|
-
for (let i = 0; i < dimension; i++) {
|
|
3024
|
-
levels[i] = level(x[i], lower, upper, steps);
|
|
3025
|
-
sum += levels[i];
|
|
2962
|
+
const liveSize = nodeCountOf(state) - tombstoneCountOf(state);
|
|
2963
|
+
if (entryPointOf(state) === -1 || liveSize === 0) {
|
|
2964
|
+
return [];
|
|
3026
2965
|
}
|
|
3027
|
-
|
|
3028
|
-
}
|
|
3029
|
-
|
|
3030
|
-
|
|
3031
|
-
|
|
3032
|
-
|
|
3033
|
-
|
|
3034
|
-
|
|
3035
|
-
return simd.osq_dot_bits(documentOffset, queryOffset, codeBytes, bits);
|
|
3036
|
-
}
|
|
3037
|
-
function scalarQueryProducts(layout, document2, documentOffset, packed) {
|
|
3038
|
-
const { bits, dimension, codeBytes } = layout;
|
|
3039
|
-
if (bits === 8) return osqByteLevelProducts(document2, documentOffset, packed, 0, dimension);
|
|
3040
|
-
if (bits === 4) return osqNibbleProducts(document2, documentOffset, packed, 0, codeBytes);
|
|
3041
|
-
return osqStagedQueryProducts(document2, documentOffset, bits, packed, 0, codeBytes);
|
|
3042
|
-
}
|
|
3043
|
-
function simdPairProducts(simd, layout, offsetA, offsetB) {
|
|
3044
|
-
const { bits, dimension, codeBytes } = layout;
|
|
3045
|
-
if (bits === 8) return simd.dot_u8(offsetA, offsetB, dimension);
|
|
3046
|
-
if (bits === 4) return simd.osq_dot_nibbles_4x4(offsetA, offsetB, codeBytes);
|
|
3047
|
-
return simd.osq_dot_bits_pair(offsetA, offsetB, codeBytes, bits);
|
|
3048
|
-
}
|
|
3049
|
-
function scalarPairProducts(layout, bytesA, offsetA, bytesB, offsetB) {
|
|
3050
|
-
const { bits, dimension, codeBytes } = layout;
|
|
3051
|
-
if (bits === 8) return osqByteLevelProducts(bytesA, offsetA, bytesB, offsetB, dimension);
|
|
3052
|
-
if (bits === 4) return osqNibbleProducts(bytesA, offsetA, bytesB, offsetB, codeBytes);
|
|
3053
|
-
return osqNarrowPairProducts(bytesA, offsetA, bytesB, offsetB, bits, codeBytes);
|
|
2966
|
+
const traversal = traverse(state, query, k, searchMetric, options);
|
|
2967
|
+
const { candidates } = traversal;
|
|
2968
|
+
const filter = options.filter;
|
|
2969
|
+
if (traversal.depth === 0) return estimatedHits(candidates, 0, searchMetric, minSimilarity, filter);
|
|
2970
|
+
const rescored = rescoredHits(state, traversal, query, traversal.depth, searchMetric, minSimilarity, filter);
|
|
2971
|
+
if (options.rescoreWindow === void 0 || minSimilarity !== Number.NEGATIVE_INFINITY) return rescored;
|
|
2972
|
+
const rest = endOfRescored(candidates, traversal.depth, filter);
|
|
2973
|
+
return rescored.concat(estimatedHits(candidates, rest, searchMetric, minSimilarity, filter));
|
|
3054
2974
|
}
|
|
3055
|
-
|
|
3056
|
-
|
|
3057
|
-
|
|
3058
|
-
|
|
3059
|
-
|
|
3060
|
-
|
|
3061
|
-
|
|
3062
|
-
let recoded = new Uint8Array(0);
|
|
3063
|
-
function blockReaching(blockIndex, end) {
|
|
3064
|
-
const held = blocks[blockIndex];
|
|
3065
|
-
if (held !== void 0 && held.bytes.length >= end) return held;
|
|
3066
|
-
const length = Math.min(capacity * slotStride, Math.max(end, (held?.bytes.length ?? 0) * 2));
|
|
3067
|
-
const bytes = new Uint8Array(length);
|
|
3068
|
-
if (held !== void 0) bytes.set(held.bytes);
|
|
3069
|
-
const block = { bytes, data: new DataView(bytes.buffer), usedBytes: held?.usedBytes ?? 0 };
|
|
3070
|
-
blocks[blockIndex] = block;
|
|
3071
|
-
return block;
|
|
2975
|
+
function endOfRescored(candidates, depth, filter) {
|
|
2976
|
+
if (filter === void 0) return Math.min(depth, candidates.size);
|
|
2977
|
+
let taken = 0;
|
|
2978
|
+
for (let i = 0; i < candidates.size; i++) {
|
|
2979
|
+
if (!ordinalFilterHas(filter, candidates.ords[i])) continue;
|
|
2980
|
+
taken += 1;
|
|
2981
|
+
if (taken === depth) return i + 1;
|
|
3072
2982
|
}
|
|
3073
|
-
|
|
3074
|
-
|
|
3075
|
-
|
|
3076
|
-
|
|
3077
|
-
|
|
3078
|
-
|
|
3079
|
-
|
|
2983
|
+
return candidates.size;
|
|
2984
|
+
}
|
|
2985
|
+
function estimatedHits(candidates, from, metric, minSimilarity, filter) {
|
|
2986
|
+
const hits = [];
|
|
2987
|
+
for (let i = from; i < candidates.size; i++) {
|
|
2988
|
+
const ord = candidates.ords[i];
|
|
2989
|
+
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2990
|
+
const score = toScore(candidates.distances[i], metric);
|
|
2991
|
+
if (score < minSimilarity) continue;
|
|
2992
|
+
hits.push({ ord, score });
|
|
3080
2993
|
}
|
|
3081
|
-
|
|
3082
|
-
|
|
3083
|
-
|
|
3084
|
-
|
|
3085
|
-
|
|
3086
|
-
|
|
3087
|
-
|
|
3088
|
-
|
|
2994
|
+
return hits;
|
|
2995
|
+
}
|
|
2996
|
+
function rescoredHits(state, traversal, query, depth, metric, minSimilarity, filter) {
|
|
2997
|
+
const { candidates, native } = traversal;
|
|
2998
|
+
if (native !== null) {
|
|
2999
|
+
const rescored = nativeRescoredHits(native.store, candidates, query, depth, metric, minSimilarity, filter);
|
|
3000
|
+
if (rescored !== null) return rescored;
|
|
3001
|
+
const arena = state.store.prepareQueryArena(query);
|
|
3002
|
+
const qMag2 = arena ? arena.magnitude : magnitude(query);
|
|
3003
|
+
return rescoreWithFullPrecision(state, candidates, query, qMag2, arena, depth, metric, minSimilarity, filter);
|
|
3089
3004
|
}
|
|
3090
|
-
|
|
3091
|
-
|
|
3092
|
-
|
|
3093
|
-
|
|
3094
|
-
|
|
3095
|
-
|
|
3096
|
-
|
|
3097
|
-
|
|
3098
|
-
|
|
3099
|
-
|
|
3100
|
-
|
|
3101
|
-
|
|
3005
|
+
const { qMag, arenaQuery } = traversal;
|
|
3006
|
+
return rescoreWithFullPrecision(state, candidates, query, qMag, arenaQuery, depth, metric, minSimilarity, filter);
|
|
3007
|
+
}
|
|
3008
|
+
function rescoreWithFullPrecision(state, candidates, query, qMag, arenaQuery, depth, metric, minSimilarity, filter) {
|
|
3009
|
+
const rescored = [];
|
|
3010
|
+
let taken = 0;
|
|
3011
|
+
for (let i = 0; i < candidates.size && taken < depth; i++) {
|
|
3012
|
+
const ord = candidates.ords[i];
|
|
3013
|
+
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
3014
|
+
taken += 1;
|
|
3015
|
+
let fullDistance;
|
|
3016
|
+
if (arenaQuery) {
|
|
3017
|
+
fullDistance = state.store.distanceFromArena(arenaQuery, ord, metric);
|
|
3018
|
+
if (fullDistance === Number.POSITIVE_INFINITY) continue;
|
|
3019
|
+
} else {
|
|
3020
|
+
fullDistance = state.store.distanceFromQuery(query, qMag, ord, metric);
|
|
3021
|
+
if (fullDistance === Number.POSITIVE_INFINITY) continue;
|
|
3102
3022
|
}
|
|
3023
|
+
const score = toScore(fullDistance, metric);
|
|
3024
|
+
if (score < minSimilarity) continue;
|
|
3025
|
+
rescored.push({ ord, score });
|
|
3103
3026
|
}
|
|
3104
|
-
return
|
|
3027
|
+
return rescored;
|
|
3028
|
+
}
|
|
3029
|
+
function search(state, docIdOf, query, k, searchMetric, minSimilarity, options = {}) {
|
|
3030
|
+
const hits = collectHits(state, query, k, searchMetric, minSimilarity, options);
|
|
3031
|
+
return bestResolvedHits(hits, k, docIdOf).map((hit) => ({
|
|
3032
|
+
docId: hit.docId,
|
|
3033
|
+
score: hit.score,
|
|
3034
|
+
termFrequencies: {},
|
|
3035
|
+
fieldLengths: {},
|
|
3036
|
+
idf: {}
|
|
3037
|
+
}));
|
|
3038
|
+
}
|
|
3039
|
+
function searchOrdinals(state, docIdOf, query, k, searchMetric, minSimilarity, options = {}) {
|
|
3040
|
+
const hits = collectHits(state, query, k, searchMetric, minSimilarity, options);
|
|
3041
|
+
return bestResolvedHits(hits, k, docIdOf);
|
|
3105
3042
|
}
|
|
3106
3043
|
|
|
3107
|
-
// src/vector/
|
|
3108
|
-
function
|
|
3109
|
-
const
|
|
3110
|
-
const
|
|
3111
|
-
const
|
|
3112
|
-
const
|
|
3113
|
-
|
|
3114
|
-
|
|
3115
|
-
|
|
3116
|
-
|
|
3117
|
-
|
|
3118
|
-
|
|
3119
|
-
|
|
3120
|
-
|
|
3121
|
-
|
|
3122
|
-
|
|
3123
|
-
|
|
3124
|
-
|
|
3125
|
-
|
|
3126
|
-
|
|
3127
|
-
|
|
3128
|
-
|
|
3129
|
-
|
|
3130
|
-
|
|
3131
|
-
|
|
3132
|
-
|
|
3133
|
-
|
|
3134
|
-
|
|
3135
|
-
|
|
3136
|
-
|
|
3137
|
-
|
|
3138
|
-
|
|
3139
|
-
|
|
3140
|
-
|
|
3141
|
-
|
|
3142
|
-
|
|
3143
|
-
|
|
3144
|
-
|
|
3145
|
-
|
|
3146
|
-
|
|
3147
|
-
|
|
3148
|
-
|
|
3149
|
-
|
|
3150
|
-
|
|
3151
|
-
|
|
3152
|
-
|
|
3153
|
-
|
|
3154
|
-
|
|
3155
|
-
|
|
3156
|
-
|
|
3157
|
-
|
|
3158
|
-
|
|
3159
|
-
|
|
3160
|
-
|
|
3161
|
-
|
|
3162
|
-
|
|
3163
|
-
|
|
3164
|
-
|
|
3165
|
-
|
|
3166
|
-
|
|
3167
|
-
|
|
3168
|
-
|
|
3169
|
-
|
|
3170
|
-
|
|
3171
|
-
|
|
3172
|
-
|
|
3173
|
-
|
|
3174
|
-
}
|
|
3175
|
-
|
|
3176
|
-
|
|
3177
|
-
|
|
3178
|
-
|
|
3179
|
-
|
|
3180
|
-
|
|
3181
|
-
|
|
3182
|
-
|
|
3183
|
-
|
|
3184
|
-
|
|
3185
|
-
|
|
3186
|
-
|
|
3187
|
-
|
|
3188
|
-
|
|
3189
|
-
|
|
3190
|
-
|
|
3191
|
-
|
|
3044
|
+
// src/vector/hnsw/snapshot.ts
|
|
3045
|
+
function exportSnapshot(state) {
|
|
3046
|
+
const adj = state.adjacency;
|
|
3047
|
+
const slots = adjacencySlots(adj);
|
|
3048
|
+
const used = upperUsed(adj);
|
|
3049
|
+
const stride = adj.level0Stride;
|
|
3050
|
+
rebindNodes(adj);
|
|
3051
|
+
reachTombstone(state, slots);
|
|
3052
|
+
return {
|
|
3053
|
+
dimension: state.dimension,
|
|
3054
|
+
m: state.M,
|
|
3055
|
+
efConstruction: state.efCons,
|
|
3056
|
+
metric: state.buildMetric,
|
|
3057
|
+
slots,
|
|
3058
|
+
upperUsed: used,
|
|
3059
|
+
nodeLevels: adj.nodeLevels.slice(0, slots),
|
|
3060
|
+
level0: adj.level0.slice(0, slots * stride),
|
|
3061
|
+
upperBase: adj.upperBase.slice(0, slots),
|
|
3062
|
+
upper: adj.upper.slice(0, used),
|
|
3063
|
+
tombstones: state.tombstones.slice(0, slots),
|
|
3064
|
+
tombstoneCount: Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT),
|
|
3065
|
+
nodeCount: Atomics.load(state.header, GRAPH_NODE_COUNT),
|
|
3066
|
+
entryPointOrd: Atomics.load(state.header, GRAPH_ENTRY_POINT),
|
|
3067
|
+
topLayer: Atomics.load(state.header, GRAPH_TOP_LAYER)
|
|
3068
|
+
};
|
|
3069
|
+
}
|
|
3070
|
+
function restoreSnapshot(state, snapshot) {
|
|
3071
|
+
resetGraph(state);
|
|
3072
|
+
const adj = state.adjacency;
|
|
3073
|
+
ensureAdjacencyCapacity(adj, snapshot.slots);
|
|
3074
|
+
adj.nodeLevels.set(snapshot.nodeLevels);
|
|
3075
|
+
adj.level0.set(snapshot.level0);
|
|
3076
|
+
adj.upperBase.set(snapshot.upperBase);
|
|
3077
|
+
ensureUpperCapacity(adj, snapshot.upper.length);
|
|
3078
|
+
adj.upper.set(snapshot.upper);
|
|
3079
|
+
Atomics.store(state.header, GRAPH_UPPER_USED, snapshot.upperUsed);
|
|
3080
|
+
Atomics.store(state.header, GRAPH_SLOTS, snapshot.slots);
|
|
3081
|
+
state.tombstones = fixedView(adj.handles.tombstones, Uint8Array);
|
|
3082
|
+
state.tombstones.set(snapshot.tombstones);
|
|
3083
|
+
Atomics.store(state.header, GRAPH_TOMBSTONE_COUNT, snapshot.tombstoneCount);
|
|
3084
|
+
Atomics.store(state.header, GRAPH_NODE_COUNT, snapshot.nodeCount);
|
|
3085
|
+
Atomics.store(state.header, GRAPH_ENTRY_POINT, snapshot.entryPointOrd);
|
|
3086
|
+
Atomics.store(state.header, GRAPH_TOP_LAYER, snapshot.topLayer);
|
|
3087
|
+
leaveIncomingUncounted(state);
|
|
3088
|
+
}
|
|
3089
|
+
|
|
3090
|
+
// src/vector/hnsw/state.ts
|
|
3091
|
+
function openGraphState(handles, dimension, store, quantizer, threadSlot) {
|
|
3092
|
+
const shape = graphShapeOf(handles.header);
|
|
3093
|
+
const adjacency = openAdjacency(handles, shape.m, shape.mMax0);
|
|
3094
|
+
return {
|
|
3095
|
+
dimension,
|
|
3096
|
+
store,
|
|
3097
|
+
quantizer,
|
|
3098
|
+
adjacency,
|
|
3099
|
+
locks: openGraphLocks(handles, threadSlot),
|
|
3100
|
+
header: handles.header,
|
|
3101
|
+
tombstones: fixedView(handles.tombstones, Uint8Array),
|
|
3102
|
+
visited: new Uint32Array(0),
|
|
3103
|
+
visitStamp: 0,
|
|
3104
|
+
workspace: createHNSWWorkspace(),
|
|
3105
|
+
neighborScratch: new Int32Array(adjacency.level0Stride),
|
|
3106
|
+
M: shape.m,
|
|
3107
|
+
Mmax0: shape.mMax0,
|
|
3108
|
+
efCons: shape.efConstruction,
|
|
3109
|
+
buildMetric: shape.metric,
|
|
3110
|
+
mL: 1 / Math.log(shape.m)
|
|
3111
|
+
};
|
|
3112
|
+
}
|
|
3113
|
+
|
|
3114
|
+
// src/vector/hnsw/index.ts
|
|
3115
|
+
function createHNSWIndex(dimension, store, config, quantizer, handles) {
|
|
3116
|
+
const M = config?.m ?? 16;
|
|
3117
|
+
const shared = handles ?? createSharedGraphHandles({
|
|
3118
|
+
m: M,
|
|
3119
|
+
mMax0: M * 2,
|
|
3120
|
+
efConstruction: config?.efConstruction ?? 200,
|
|
3121
|
+
metric: config?.metric ?? "cosine"
|
|
3122
|
+
});
|
|
3123
|
+
const state = openGraphState(shared, dimension, store, quantizer, 0);
|
|
3124
|
+
const docIdOf = (ord) => store.docIdForOrdinal(ord);
|
|
3125
|
+
function exclusively(operation) {
|
|
3126
|
+
lockGraphExclusive(state.locks);
|
|
3127
|
+
try {
|
|
3128
|
+
return operation();
|
|
3129
|
+
} finally {
|
|
3130
|
+
unlockGraphExclusive(state.locks);
|
|
3192
3131
|
}
|
|
3193
|
-
return true;
|
|
3194
3132
|
}
|
|
3195
|
-
function
|
|
3196
|
-
|
|
3197
|
-
|
|
3133
|
+
function insertNode2(docId) {
|
|
3134
|
+
const ord = store.getOrdinal(docId);
|
|
3135
|
+
if (ord === void 0) {
|
|
3136
|
+
throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
|
|
3198
3137
|
}
|
|
3199
|
-
|
|
3200
|
-
|
|
3201
|
-
|
|
3202
|
-
const estimate = osqEstimate(products, documentTrailer, bits, query, levelBits, dimension, centroidDotNow(), metric);
|
|
3203
|
-
return osqDistance(estimate, metric);
|
|
3204
|
-
}
|
|
3205
|
-
function estimateDistance(ordinal, query) {
|
|
3206
|
-
const block = store.codeBlockOf(ordinal);
|
|
3207
|
-
const offset = recordOffset(ordinal);
|
|
3208
|
-
const products = productsAgainstQuery(block, offset, query);
|
|
3209
|
-
readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
|
|
3210
|
-
return distanceFrom(products, query, queryBits);
|
|
3211
|
-
}
|
|
3212
|
-
function prepareQuery(query) {
|
|
3213
|
-
if (!isCalibrated() || query.length !== dimension) return null;
|
|
3214
|
-
const code = osqQuantize(query, store.handles.centroid, queryBits, metric, scratch);
|
|
3215
|
-
const packed = new Uint8Array(layout.queryBytes);
|
|
3216
|
-
stageQueryLevels(code.levels, bits, packed);
|
|
3217
|
-
for (const block of store.openCodeBlocks()) block.stagedOrdinal = NOTHING_STAGED;
|
|
3218
|
-
currentQuery = {
|
|
3219
|
-
packed,
|
|
3220
|
-
lower: code.lower,
|
|
3221
|
-
upper: code.upper,
|
|
3222
|
-
correction: code.correction,
|
|
3223
|
-
sum: code.sum
|
|
3224
|
-
};
|
|
3225
|
-
return currentQuery;
|
|
3226
|
-
}
|
|
3227
|
-
function preparedDistance(prepared) {
|
|
3228
|
-
const generic = (ordinal) => holds2(ordinal) ? estimateDistance(ordinal, prepared) : Number.POSITIVE_INFINITY;
|
|
3229
|
-
if (store.handles.codeBlocks.length === 0) return generic;
|
|
3230
|
-
const block = store.codeBlockOf(0);
|
|
3231
|
-
const simd = block.simd;
|
|
3232
|
-
if (simd === null || !block.hasScratch) return generic;
|
|
3233
|
-
const presentView = codePresent;
|
|
3234
|
-
const limit = Math.min(presentView.length, capacity);
|
|
3235
|
-
const { slotsOffset, slotStride } = layout;
|
|
3236
|
-
const data = block.data(slotsOffset + slotStride);
|
|
3237
|
-
const dataLength = data.byteLength;
|
|
3238
|
-
const queryOffset = block.scratchByteOffset;
|
|
3239
|
-
return (ordinal) => {
|
|
3240
|
-
if (ordinal < 0 || ordinal >= limit || block.stagedOrdinal !== QUERY_STAGED) return generic(ordinal);
|
|
3241
|
-
if (presentView[ordinal] !== 1) return Number.POSITIVE_INFINITY;
|
|
3242
|
-
const offset = slotsOffset + ordinal * slotStride;
|
|
3243
|
-
if (offset + slotStride > dataLength) return generic(ordinal);
|
|
3244
|
-
const products = simdQueryProducts(simd, layout, offset, queryOffset);
|
|
3245
|
-
readTrailer(data, offset, codeBytes, documentTrailer);
|
|
3246
|
-
return distanceFrom(products, prepared, queryBits);
|
|
3247
|
-
};
|
|
3248
|
-
}
|
|
3249
|
-
function placementDistance2(vector) {
|
|
3250
|
-
if (placementQueryBits === queryBits) {
|
|
3251
|
-
const prepared = prepareQuery(vector);
|
|
3252
|
-
return prepared === null ? null : preparedDistance(prepared);
|
|
3138
|
+
const entry = store.entryForOrdinal(ord);
|
|
3139
|
+
if (!entry) {
|
|
3140
|
+
throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
|
|
3253
3141
|
}
|
|
3254
|
-
if (
|
|
3255
|
-
|
|
3256
|
-
|
|
3257
|
-
|
|
3258
|
-
|
|
3259
|
-
|
|
3260
|
-
|
|
3261
|
-
|
|
3262
|
-
const products = osqNibblesByByteLevels(block.bytes(offset + codeBytes), offset, levels, codeBytes);
|
|
3263
|
-
readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
|
|
3264
|
-
return distanceFrom(products, code, placementQueryBits);
|
|
3265
|
-
};
|
|
3142
|
+
if (entry.vector.length !== dimension) {
|
|
3143
|
+
throw new NarsilError(
|
|
3144
|
+
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
3145
|
+
`Vector dimension mismatch: expected ${dimension}, got ${entry.vector.length}`,
|
|
3146
|
+
{ docId, expected: dimension, received: entry.vector.length }
|
|
3147
|
+
);
|
|
3148
|
+
}
|
|
3149
|
+
insertNode(state, ord);
|
|
3266
3150
|
}
|
|
3267
|
-
function
|
|
3268
|
-
|
|
3269
|
-
|
|
3270
|
-
|
|
3271
|
-
|
|
3272
|
-
|
|
3273
|
-
|
|
3274
|
-
|
|
3275
|
-
|
|
3276
|
-
|
|
3277
|
-
|
|
3278
|
-
offsetB
|
|
3279
|
-
);
|
|
3280
|
-
readTrailer(blockA.data(offsetA + layout.slotStride), offsetA, codeBytes, documentTrailer);
|
|
3281
|
-
readTrailer(blockB.data(offsetB + layout.slotStride), offsetB, codeBytes, otherTrailer);
|
|
3282
|
-
return distanceFrom(products, otherTrailer, bits);
|
|
3151
|
+
function* entriesIterator() {
|
|
3152
|
+
const slots = adjacencySlots(state.adjacency);
|
|
3153
|
+
for (let ord = 0; ord < slots; ord++) {
|
|
3154
|
+
if (!hasNode(state.adjacency, ord)) continue;
|
|
3155
|
+
if (isTombstoned(state, ord)) continue;
|
|
3156
|
+
const docId = store.docIdForOrdinal(ord);
|
|
3157
|
+
if (docId === void 0) continue;
|
|
3158
|
+
const entry = store.entryForOrdinal(ord);
|
|
3159
|
+
if (!entry) continue;
|
|
3160
|
+
yield [docId, { docId, vector: entry.vector, magnitude: entry.magnitude }];
|
|
3161
|
+
}
|
|
3283
3162
|
}
|
|
3284
|
-
function
|
|
3285
|
-
|
|
3286
|
-
|
|
3287
|
-
const
|
|
3288
|
-
|
|
3289
|
-
const presentView = codePresent;
|
|
3290
|
-
const limit = Math.min(presentView.length, capacity);
|
|
3291
|
-
const { slotsOffset, slotStride } = layout;
|
|
3292
|
-
const data = block.data(slotsOffset + slotStride);
|
|
3293
|
-
const dataLength = data.byteLength;
|
|
3294
|
-
return (ordA, ordB) => {
|
|
3295
|
-
if (ordA < 0 || ordB < 0 || ordA >= limit || ordB >= limit) return distanceBetween(ordA, ordB);
|
|
3296
|
-
if (presentView[ordA] !== 1 || presentView[ordB] !== 1) return Number.POSITIVE_INFINITY;
|
|
3297
|
-
const offsetA = slotsOffset + ordA * slotStride;
|
|
3298
|
-
const offsetB = slotsOffset + ordB * slotStride;
|
|
3299
|
-
if (Math.max(offsetA, offsetB) + slotStride > dataLength) return distanceBetween(ordA, ordB);
|
|
3300
|
-
const products = simdPairProducts(simd, layout, offsetA, offsetB);
|
|
3301
|
-
readTrailer(data, offsetA, codeBytes, documentTrailer);
|
|
3302
|
-
readTrailer(data, offsetB, codeBytes, otherTrailer);
|
|
3303
|
-
return distanceFrom(products, otherTrailer, bits);
|
|
3304
|
-
};
|
|
3163
|
+
function compactionNeeded() {
|
|
3164
|
+
const nodeCount = nodeCountOf(state);
|
|
3165
|
+
if (nodeCount === 0) return false;
|
|
3166
|
+
const tombstones = tombstoneCountOf(state);
|
|
3167
|
+
return tombstones / nodeCount > COMPACTION_TOMBSTONE_RATIO || tombstones > COMPACTION_ABSOLUTE_THRESHOLD;
|
|
3305
3168
|
}
|
|
3306
3169
|
return {
|
|
3307
|
-
|
|
3308
|
-
|
|
3170
|
+
get dimension() {
|
|
3171
|
+
return dimension;
|
|
3172
|
+
},
|
|
3309
3173
|
get size() {
|
|
3310
|
-
return
|
|
3174
|
+
return nodeCountOf(state) - tombstoneCountOf(state);
|
|
3311
3175
|
},
|
|
3312
|
-
get
|
|
3313
|
-
return
|
|
3176
|
+
get tombstoneCount() {
|
|
3177
|
+
return tombstoneCountOf(state);
|
|
3314
3178
|
},
|
|
3315
|
-
|
|
3316
|
-
|
|
3317
|
-
|
|
3318
|
-
singleOrdinal[0] = ordinal;
|
|
3319
|
-
writeCodesOf(singleOrdinal);
|
|
3179
|
+
get entryPointId() {
|
|
3180
|
+
const entryPoint = entryPointOf(state);
|
|
3181
|
+
return entryPoint === -1 ? null : store.docIdForOrdinal(entryPoint) ?? null;
|
|
3320
3182
|
},
|
|
3321
|
-
|
|
3322
|
-
|
|
3323
|
-
calibrateFrom(ordinals) {
|
|
3324
|
-
const sums = createCentroidSums(dimension, metric);
|
|
3325
|
-
measureInto(ordinals, sums);
|
|
3326
|
-
const centroid = centroidOfCentroidSums(sums);
|
|
3327
|
-
if (centroid === null) return false;
|
|
3328
|
-
writeCentroid(centroid);
|
|
3329
|
-
return true;
|
|
3330
|
-
},
|
|
3331
|
-
restoreRecord(ordinal, record) {
|
|
3332
|
-
if (!reach2(ordinal) || record.length !== layout.slotStride) return;
|
|
3333
|
-
const block = store.codeBlockOf(ordinal);
|
|
3334
|
-
const offset = recordOffset(ordinal);
|
|
3335
|
-
block.bytes(offset + layout.slotStride).set(record, offset);
|
|
3336
|
-
markPresent(ordinal);
|
|
3337
|
-
recoding?.recode(ordinal);
|
|
3338
|
-
},
|
|
3339
|
-
recordAt(ordinal) {
|
|
3340
|
-
const block = store.codeBlockOf(ordinal);
|
|
3341
|
-
const offset = recordOffset(ordinal);
|
|
3342
|
-
return block.bytes(offset + layout.slotStride).subarray(offset, offset + layout.slotStride);
|
|
3343
|
-
},
|
|
3344
|
-
clearCodes,
|
|
3345
|
-
writeCentroid,
|
|
3346
|
-
resetCalibration() {
|
|
3347
|
-
recoding = null;
|
|
3348
|
-
Atomics.store(store.handles.header, STORE_CALIBRATED, 0);
|
|
3349
|
-
store.handles.centroid.fill(0);
|
|
3350
|
-
Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
3351
|
-
},
|
|
3352
|
-
resetCodes() {
|
|
3353
|
-
recoding = null;
|
|
3354
|
-
codePresent = fixedView(store.handles.codePresent, Uint8Array);
|
|
3355
|
-
codePresent.fill(0);
|
|
3356
|
-
Atomics.store(store.handles.header, STORE_CODE_COUNT, 0);
|
|
3357
|
-
},
|
|
3358
|
-
beginRecoding(centroid) {
|
|
3359
|
-
recoding = createCodeRecoding({ store, layout, metric, holds: holds2, clearCodes }, Float32Array.from(centroid));
|
|
3360
|
-
},
|
|
3361
|
-
recode(ordinal) {
|
|
3362
|
-
recoding?.recode(ordinal);
|
|
3363
|
-
},
|
|
3364
|
-
finishRecoding() {
|
|
3365
|
-
if (recoding === null) return false;
|
|
3366
|
-
const finished = recoding;
|
|
3367
|
-
recoding = null;
|
|
3368
|
-
finished.copyIntoStore(store.slots);
|
|
3369
|
-
writeCentroid(finished.centroid);
|
|
3370
|
-
return true;
|
|
3371
|
-
},
|
|
3372
|
-
abandonRecoding() {
|
|
3373
|
-
recoding = null;
|
|
3374
|
-
},
|
|
3375
|
-
prepareQuery,
|
|
3376
|
-
distanceFromPreparedByOrdinal(prepared, ordinal) {
|
|
3377
|
-
if (!holds2(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3378
|
-
return estimateDistance(ordinal, prepared);
|
|
3379
|
-
},
|
|
3380
|
-
preparedDistance,
|
|
3381
|
-
pairDistance,
|
|
3382
|
-
placementDistance: placementDistance2
|
|
3383
|
-
};
|
|
3384
|
-
}
|
|
3385
|
-
|
|
3386
|
-
// src/vector/osq/index.ts
|
|
3387
|
-
function createOsqQuantizer(dimension, bits, metric, store) {
|
|
3388
|
-
let opened = null;
|
|
3389
|
-
function shared() {
|
|
3390
|
-
if (opened === null && store.dimension === dimension && store.handles.codeLayout !== null) {
|
|
3391
|
-
opened = openSharedQuantizer(store.view, store.handles.codeLayout, metric);
|
|
3392
|
-
}
|
|
3393
|
-
return opened;
|
|
3394
|
-
}
|
|
3395
|
-
function requireShared() {
|
|
3396
|
-
const view = shared();
|
|
3397
|
-
if (view === null) throw new Error("The vector store holds no vector for the quantizer to work on");
|
|
3398
|
-
return view;
|
|
3399
|
-
}
|
|
3400
|
-
function ordinalOf(docId) {
|
|
3401
|
-
const ordinal = store.getOrdinal(docId);
|
|
3402
|
-
if (ordinal === void 0) {
|
|
3403
|
-
throw new Error(`Cannot quantize "${docId}": the vector store holds no vector for it`);
|
|
3404
|
-
}
|
|
3405
|
-
return ordinal;
|
|
3406
|
-
}
|
|
3407
|
-
return {
|
|
3408
|
-
dimension,
|
|
3409
|
-
bits,
|
|
3410
|
-
metric,
|
|
3411
|
-
get size() {
|
|
3412
|
-
return shared()?.size ?? 0;
|
|
3413
|
-
},
|
|
3414
|
-
get centroid() {
|
|
3415
|
-
return shared()?.centroid ?? null;
|
|
3416
|
-
},
|
|
3417
|
-
isCalibrated: () => shared()?.isCalibrated() ?? false,
|
|
3418
|
-
calibrate(ordinals) {
|
|
3419
|
-
if (ordinals.length > 0) requireShared().calibrateFrom(ordinals);
|
|
3420
|
-
},
|
|
3421
|
-
measure(ordinals, sums) {
|
|
3422
|
-
if (ordinals.length > 0) requireShared().measureInto(ordinals, sums);
|
|
3423
|
-
},
|
|
3424
|
-
quantize(docId) {
|
|
3425
|
-
const ordinal = ordinalOf(docId);
|
|
3426
|
-
const view = requireShared();
|
|
3427
|
-
if (!view.isCalibrated()) view.calibrateFrom(Int32Array.of(ordinal));
|
|
3428
|
-
view.writeCodes(ordinal);
|
|
3429
|
-
},
|
|
3430
|
-
writeCodes(ordinal) {
|
|
3431
|
-
shared()?.writeCodes(ordinal);
|
|
3432
|
-
},
|
|
3433
|
-
remove(docId) {
|
|
3434
|
-
const ordinal = store.getOrdinal(docId);
|
|
3435
|
-
if (ordinal !== void 0) shared()?.clearCodes(ordinal);
|
|
3436
|
-
},
|
|
3437
|
-
removeOrdinal(ordinal) {
|
|
3438
|
-
shared()?.clearCodes(ordinal);
|
|
3439
|
-
},
|
|
3440
|
-
hasOrdinal: (ordinal) => shared()?.holdsOrdinal(ordinal) ?? false,
|
|
3441
|
-
getLevels(docId) {
|
|
3442
|
-
const view = shared();
|
|
3443
|
-
const ordinal = store.getOrdinal(docId);
|
|
3444
|
-
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3445
|
-
return unpackLevels(view.recordAt(ordinal), 0, dimension, bits);
|
|
3446
|
-
},
|
|
3447
|
-
recordOf(docId) {
|
|
3448
|
-
const view = shared();
|
|
3449
|
-
const ordinal = store.getOrdinal(docId);
|
|
3450
|
-
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3451
|
-
return view.recordAt(ordinal);
|
|
3452
|
-
},
|
|
3453
|
-
recordAtOrdinal(ordinal) {
|
|
3454
|
-
const view = shared();
|
|
3455
|
-
if (view === null || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3456
|
-
return view.recordAt(ordinal);
|
|
3183
|
+
get topLayer() {
|
|
3184
|
+
return topLayerOf(state);
|
|
3457
3185
|
},
|
|
3458
|
-
|
|
3459
|
-
|
|
3186
|
+
get m() {
|
|
3187
|
+
return state.M;
|
|
3460
3188
|
},
|
|
3461
|
-
|
|
3462
|
-
|
|
3189
|
+
get efConstruction() {
|
|
3190
|
+
return state.efCons;
|
|
3463
3191
|
},
|
|
3464
|
-
|
|
3465
|
-
|
|
3192
|
+
get metric() {
|
|
3193
|
+
return state.buildMetric;
|
|
3466
3194
|
},
|
|
3467
|
-
|
|
3468
|
-
|
|
3469
|
-
const view = requireShared();
|
|
3470
|
-
view.resetCodes();
|
|
3471
|
-
view.calibrateFrom(ordinals);
|
|
3472
|
-
view.writeCodesOf(ordinals);
|
|
3195
|
+
get graphBytes() {
|
|
3196
|
+
return graphBytes(state.adjacency);
|
|
3473
3197
|
},
|
|
3474
|
-
|
|
3475
|
-
|
|
3198
|
+
get searchScratchBytes() {
|
|
3199
|
+
return searchScratchBytes(state);
|
|
3476
3200
|
},
|
|
3477
|
-
|
|
3478
|
-
shared
|
|
3201
|
+
get handles() {
|
|
3202
|
+
return shared;
|
|
3479
3203
|
},
|
|
3480
|
-
|
|
3481
|
-
|
|
3482
|
-
|
|
3204
|
+
insertNode: insertNode2,
|
|
3205
|
+
insertOrdinal: (ordinal) => insertNode(state, ordinal),
|
|
3206
|
+
markTombstone: (docId) => {
|
|
3207
|
+
const ord = store.getOrdinal(docId);
|
|
3208
|
+
if (ord !== void 0) markTombstone(state, ord);
|
|
3483
3209
|
},
|
|
3484
|
-
|
|
3485
|
-
|
|
3486
|
-
|
|
3487
|
-
|
|
3488
|
-
|
|
3489
|
-
return
|
|
3210
|
+
markTombstoneOrdinal: (ordinal) => markTombstone(state, ordinal),
|
|
3211
|
+
holdsNode: (ordinal) => hasNode(state.adjacency, ordinal),
|
|
3212
|
+
holdsTombstone: (ordinal) => hasNode(state.adjacency, ordinal) && isTombstoned(state, ordinal),
|
|
3213
|
+
has: (docId) => {
|
|
3214
|
+
const ord = store.getOrdinal(docId);
|
|
3215
|
+
return ord !== void 0 && hasNode(state.adjacency, ord) && !isTombstoned(state, ord);
|
|
3490
3216
|
},
|
|
3491
|
-
|
|
3492
|
-
const
|
|
3493
|
-
|
|
3494
|
-
return view.pairDistance();
|
|
3217
|
+
isTombstoned: (docId) => {
|
|
3218
|
+
const ord = store.getOrdinal(docId);
|
|
3219
|
+
return ord !== void 0 && isTombstoned(state, ord);
|
|
3495
3220
|
},
|
|
3496
|
-
|
|
3497
|
-
clear()
|
|
3498
|
-
|
|
3499
|
-
|
|
3500
|
-
|
|
3501
|
-
|
|
3502
|
-
|
|
3221
|
+
search: (query, k, searchMetric, minSimilarity, options) => search(state, docIdOf, query, k, searchMetric, minSimilarity, options),
|
|
3222
|
+
clear: () => exclusively(() => resetGraph(state)),
|
|
3223
|
+
retire: () => Atomics.store(shared.header, GRAPH_RETIRED, 1),
|
|
3224
|
+
entries: entriesIterator,
|
|
3225
|
+
compactionNeeded,
|
|
3226
|
+
compactTombstones: () => exclusively(() => compactTombstones(state)),
|
|
3227
|
+
connectUnreached: () => exclusively(() => connectAfterBuild(state)),
|
|
3228
|
+
rebuild: () => exclusively(() => rebuild(state)),
|
|
3229
|
+
exclusively,
|
|
3230
|
+
deserialize: (data) => exclusively(() => deserializeGraph(state, store, data)),
|
|
3231
|
+
serializeNumbered: (numberOfOrdinal, ordinalOfNumber, partSize) => serializeNumberedGraphParts(state, numberOfOrdinal, ordinalOfNumber, partSize),
|
|
3232
|
+
deserializeNumbered: (graph, ordinalOfNumber) => exclusively(() => deserializeNumberedGraph(state, graph, ordinalOfNumber)),
|
|
3233
|
+
exportSnapshot: () => exportSnapshot(state),
|
|
3234
|
+
restoreSnapshot: (snapshot) => exclusively(() => restoreSnapshot(state, snapshot))
|
|
3503
3235
|
};
|
|
3504
3236
|
}
|
|
3505
3237
|
|
|
3506
|
-
// src/vector/
|
|
3507
|
-
|
|
3508
|
-
|
|
3509
|
-
|
|
3510
|
-
|
|
3511
|
-
|
|
3512
|
-
|
|
3513
|
-
|
|
3514
|
-
|
|
3515
|
-
|
|
3516
|
-
|
|
3517
|
-
|
|
3518
|
-
|
|
3519
|
-
var RECALIBRATION_DRIFT_RATIO = 2.5;
|
|
3520
|
-
var RECALIBRATION_CHUNK_VECTORS = 512;
|
|
3521
|
-
var VECTOR_FILE_REPLACED_ABOVE_DEAD_SHARE = 0.2;
|
|
3522
|
-
var VECTOR_FILE_FIXED_OVERHEAD_BYTES = 65536;
|
|
3523
|
-
var VECTOR_FILE_STRING_HEADER_BYTES = 5;
|
|
3524
|
-
var VECTOR_FILE_CENTROID_BYTES_PER_COMPONENT = 9;
|
|
3525
|
-
var OSQ4_MIN_DIMENSION = 384;
|
|
3526
|
-
var DISK_ADOPTION_YIELD_INTERVAL = 4096;
|
|
3527
|
-
|
|
3528
|
-
// src/vector/vector-index/shared.ts
|
|
3529
|
-
var VECTOR_WORKER_COPIES_ALLOWED = { enabled: true };
|
|
3530
|
-
function liveSize(state) {
|
|
3531
|
-
return state.store.size - state.tombstones.size;
|
|
3532
|
-
}
|
|
3533
|
-
function threadsHoldCurrentLayout(state) {
|
|
3534
|
-
return state.sharedLayoutRevision === state.store.handles.layoutRevision;
|
|
3535
|
-
}
|
|
3536
|
-
function assignStorePartitions(state, resolve) {
|
|
3537
|
-
for (let ordinal = 0; ordinal < state.store.slots; ordinal += 1) {
|
|
3538
|
-
if (state.store.partitionOfOrdinal(ordinal) !== void 0) continue;
|
|
3539
|
-
const docId = state.store.docIdForOrdinal(ordinal);
|
|
3540
|
-
if (docId === void 0) continue;
|
|
3541
|
-
const partitionId = resolve(docId);
|
|
3542
|
-
if (partitionId === void 0) {
|
|
3543
|
-
state.store.forgetPartition(docId);
|
|
3544
|
-
continue;
|
|
3545
|
-
}
|
|
3546
|
-
state.store.setPartition(docId, partitionId);
|
|
3547
|
-
}
|
|
3548
|
-
}
|
|
3549
|
-
function emptyFieldBeforeRestore(state) {
|
|
3550
|
-
state.store.clear();
|
|
3551
|
-
state.tombstones.clear();
|
|
3552
|
-
state.buffer.clear();
|
|
3553
|
-
state.pendingLocations.clear();
|
|
3554
|
-
adoptGraph(state, null);
|
|
3555
|
-
state.osq?.clear();
|
|
3556
|
-
forgetCalibration(state);
|
|
3557
|
-
state.savedFiles = [];
|
|
3558
|
-
state.savedSignature = null;
|
|
3559
|
-
}
|
|
3560
|
-
function releaseReplacedVectors(state) {
|
|
3561
|
-
for (const ordinal of state.store.releaseReplacedVectors()) state.osq?.removeOrdinal(ordinal);
|
|
3562
|
-
}
|
|
3563
|
-
function adoptGraph(state, graph) {
|
|
3564
|
-
if (state.hnsw !== null && state.hnsw !== graph) state.hnsw.retire();
|
|
3565
|
-
if (graph === null && state.hnsw !== null) {
|
|
3566
|
-
state.hnsw.clear();
|
|
3567
|
-
}
|
|
3568
|
-
state.hnsw = graph;
|
|
3569
|
-
state.shuffledBuildCount = null;
|
|
3570
|
-
state.compactedNodeCount = 0;
|
|
3571
|
-
if (graph === null) return;
|
|
3572
|
-
for (const docId of state.tombstones) {
|
|
3573
|
-
if (graph.has(docId)) {
|
|
3574
|
-
graph.markTombstone(docId);
|
|
3575
|
-
}
|
|
3238
|
+
// src/vector/osq/quantize.ts
|
|
3239
|
+
function osqBitsOf(mode) {
|
|
3240
|
+
switch (mode) {
|
|
3241
|
+
case "osq8":
|
|
3242
|
+
return 8;
|
|
3243
|
+
case "osq4":
|
|
3244
|
+
return 4;
|
|
3245
|
+
case "osq2":
|
|
3246
|
+
return 2;
|
|
3247
|
+
case "osq1":
|
|
3248
|
+
return 1;
|
|
3249
|
+
default:
|
|
3250
|
+
return null;
|
|
3576
3251
|
}
|
|
3577
3252
|
}
|
|
3578
|
-
function
|
|
3579
|
-
|
|
3580
|
-
if (graph === null) return false;
|
|
3581
|
-
const removed = graph.tombstoneCount + state.compactedNodeCount;
|
|
3582
|
-
const held = graph.size + removed;
|
|
3583
|
-
if (held === 0) return false;
|
|
3584
|
-
return removed / held > REBUILD_REMOVED_RATIO;
|
|
3585
|
-
}
|
|
3586
|
-
function yieldBuildTurn(state) {
|
|
3587
|
-
return new Promise((resolve) => {
|
|
3588
|
-
const takeTurn = () => {
|
|
3589
|
-
clearTimeout(timer);
|
|
3590
|
-
state.buildTurnWaiters.delete(takeTurn);
|
|
3591
|
-
resolve();
|
|
3592
|
-
};
|
|
3593
|
-
const timer = setTimeout(takeTurn, 0);
|
|
3594
|
-
state.buildTurnWaiters.set(takeTurn, performance.now());
|
|
3595
|
-
});
|
|
3596
|
-
}
|
|
3597
|
-
function noBuildHistory() {
|
|
3598
|
-
return {
|
|
3599
|
-
shuffledBuildCount: null,
|
|
3600
|
-
calibratedCount: null,
|
|
3601
|
-
calibratedMeanLength: null,
|
|
3602
|
-
nextDriftCheckAt: Number.POSITIVE_INFINITY,
|
|
3603
|
-
shuffledRebuild: null
|
|
3604
|
-
};
|
|
3253
|
+
function clamp(value, low, high) {
|
|
3254
|
+
return Math.min(Math.max(value, low), high);
|
|
3605
3255
|
}
|
|
3606
|
-
function
|
|
3607
|
-
|
|
3608
|
-
|
|
3609
|
-
|
|
3256
|
+
function unitNormaliseInto(target, vector) {
|
|
3257
|
+
let squares = 0;
|
|
3258
|
+
for (let i = 0; i < vector.length; i++) squares += vector[i] * vector[i];
|
|
3259
|
+
const length = Math.sqrt(squares);
|
|
3260
|
+
if (length === 0) {
|
|
3261
|
+
for (let i = 0; i < vector.length; i++) target[i] = vector[i];
|
|
3610
3262
|
return;
|
|
3611
|
-
for (const takeTurn of [...state.buildTurnWaiters.keys()]) takeTurn();
|
|
3612
|
-
}
|
|
3613
|
-
function* allLiveDocIds(state) {
|
|
3614
|
-
for (const docId of state.store.docIds()) {
|
|
3615
|
-
if (state.tombstones.has(docId)) continue;
|
|
3616
|
-
yield docId;
|
|
3617
3263
|
}
|
|
3264
|
+
for (let i = 0; i < vector.length; i++) target[i] = vector[i] / length;
|
|
3618
3265
|
}
|
|
3619
|
-
|
|
3620
|
-
|
|
3621
|
-
for (const docId of state.tombstones) {
|
|
3622
|
-
const ordinal = state.store.getOrdinal(docId);
|
|
3623
|
-
if (ordinal === void 0) continue;
|
|
3624
|
-
removeFromOrdinalFilter(filter, ordinal);
|
|
3625
|
-
}
|
|
3626
|
-
return filter;
|
|
3627
|
-
}
|
|
3628
|
-
function ordinalSpaceOf(state) {
|
|
3629
|
-
const store = state.store;
|
|
3630
|
-
const handles = store.handles;
|
|
3631
|
-
const removed = new Uint8Array(handles.removed);
|
|
3266
|
+
var CENTROID_TOTALS_PAST_DIMENSION = 2;
|
|
3267
|
+
function createCentroidSums(dimension, metric) {
|
|
3632
3268
|
return {
|
|
3633
|
-
|
|
3634
|
-
|
|
3635
|
-
|
|
3636
|
-
|
|
3637
|
-
ordinalOf: (docId) => store.getOrdinal(docId),
|
|
3638
|
-
holdsCurrentOrdinal: (ordinal) => store.holdsOrdinal(ordinal),
|
|
3639
|
-
isRemoved: (ordinal) => ordinal < removed.length && removed[ordinal] === 1
|
|
3269
|
+
metric,
|
|
3270
|
+
dimension,
|
|
3271
|
+
totals: new Float64Array(dimension + CENTROID_TOTALS_PAST_DIMENSION),
|
|
3272
|
+
scratch: new Float64Array(dimension)
|
|
3640
3273
|
};
|
|
3641
3274
|
}
|
|
3642
|
-
function
|
|
3643
|
-
|
|
3644
|
-
if (state.store.dimension === 0) return createOrdinalFilter(0);
|
|
3645
|
-
return ordinalFilterForSubsets(options.filterSubsets, ordinalSpaceOf(state));
|
|
3646
|
-
}
|
|
3647
|
-
if (options.filterPartitions !== void 0) {
|
|
3648
|
-
return ordinalFilterForPartitions(state, options.filterPartitions);
|
|
3649
|
-
}
|
|
3650
|
-
return void 0;
|
|
3275
|
+
function countOfCentroidSums(target) {
|
|
3276
|
+
return target.totals[target.dimension + 1];
|
|
3651
3277
|
}
|
|
3652
|
-
function
|
|
3653
|
-
|
|
3654
|
-
for (let ordinal = 0; ordinal < state.store.slots; ordinal++) {
|
|
3655
|
-
const docId = state.store.docIdForOrdinal(ordinal);
|
|
3656
|
-
if (docId !== void 0 && !state.tombstones.has(docId)) ordinals.push(ordinal);
|
|
3657
|
-
}
|
|
3658
|
-
return Int32Array.from(ordinals);
|
|
3659
|
-
}
|
|
3660
|
-
function forgetCalibration(state) {
|
|
3661
|
-
state.calibratedCount = null;
|
|
3662
|
-
state.calibratedMeanLength = null;
|
|
3663
|
-
state.nextDriftCheckAt = Number.POSITIVE_INFINITY;
|
|
3664
|
-
}
|
|
3665
|
-
function adoptLoadedCalibration(state, calibratedCount, calibratedMeanLength) {
|
|
3666
|
-
if (state.osq === null || !state.osq.isCalibrated()) return;
|
|
3667
|
-
state.calibratedCount = calibratedCount;
|
|
3668
|
-
state.calibratedMeanLength = calibratedMeanLength;
|
|
3669
|
-
state.nextDriftCheckAt = Math.max(1, calibratedCount) * DRIFT_CHECK_GROWTH_FACTOR;
|
|
3670
|
-
}
|
|
3671
|
-
function recalibrateFromStore(state) {
|
|
3672
|
-
if (state.osq === null) return;
|
|
3673
|
-
const ordinals = liveOrdinals(state);
|
|
3674
|
-
state.osq.recalibrate(ordinals);
|
|
3675
|
-
state.calibratedCount = ordinals.length;
|
|
3676
|
-
state.calibratedMeanLength = null;
|
|
3677
|
-
state.nextDriftCheckAt = Math.max(1, ordinals.length) * DRIFT_CHECK_GROWTH_FACTOR;
|
|
3678
|
-
}
|
|
3679
|
-
function fieldHandlesOf(state, graph, searchable) {
|
|
3680
|
-
return {
|
|
3681
|
-
dimension: state.dimension,
|
|
3682
|
-
quantization: state.osq === null ? "none" : state.quantizationMode,
|
|
3683
|
-
metric: state.metric,
|
|
3684
|
-
store: state.store.handles,
|
|
3685
|
-
graph: graph === null ? null : graph.handles,
|
|
3686
|
-
filterThreshold: state.filterThreshold,
|
|
3687
|
-
searchable
|
|
3688
|
-
};
|
|
3278
|
+
function squaredLengthsOfCentroidSums(target) {
|
|
3279
|
+
return target.totals[target.dimension];
|
|
3689
3280
|
}
|
|
3690
|
-
|
|
3691
|
-
|
|
3692
|
-
|
|
3693
|
-
|
|
3694
|
-
|
|
3695
|
-
|
|
3696
|
-
|
|
3697
|
-
|
|
3698
|
-
|
|
3699
|
-
|
|
3700
|
-
|
|
3701
|
-
|
|
3702
|
-
|
|
3703
|
-
|
|
3704
|
-
bytes[i + 3] = first;
|
|
3281
|
+
function addToCentroidSums(target, vector) {
|
|
3282
|
+
const { totals, scratch, dimension } = target;
|
|
3283
|
+
let squares = totals[dimension];
|
|
3284
|
+
if (target.metric === "cosine") {
|
|
3285
|
+
unitNormaliseInto(scratch, vector);
|
|
3286
|
+
for (let i = 0; i < dimension; i++) {
|
|
3287
|
+
totals[i] += scratch[i];
|
|
3288
|
+
squares += scratch[i] * scratch[i];
|
|
3289
|
+
}
|
|
3290
|
+
} else {
|
|
3291
|
+
for (let i = 0; i < dimension; i++) {
|
|
3292
|
+
totals[i] += vector[i];
|
|
3293
|
+
squares += vector[i] * vector[i];
|
|
3294
|
+
}
|
|
3705
3295
|
}
|
|
3296
|
+
totals[dimension] = squares;
|
|
3297
|
+
totals[dimension + 1] += 1;
|
|
3706
3298
|
}
|
|
3707
|
-
function
|
|
3708
|
-
const
|
|
3709
|
-
|
|
3710
|
-
|
|
3299
|
+
function meanOfCentroidSums(target) {
|
|
3300
|
+
const count = countOfCentroidSums(target);
|
|
3301
|
+
const mean = new Float64Array(target.dimension);
|
|
3302
|
+
for (let i = 0; i < mean.length; i++) mean[i] = target.totals[i] / count;
|
|
3303
|
+
return mean;
|
|
3711
3304
|
}
|
|
3712
|
-
function
|
|
3713
|
-
if (
|
|
3714
|
-
|
|
3305
|
+
function centroidOfCentroidSums(target) {
|
|
3306
|
+
if (countOfCentroidSums(target) === 0) return null;
|
|
3307
|
+
const dimension = target.dimension;
|
|
3308
|
+
const mean = meanOfCentroidSums(target);
|
|
3309
|
+
const centroid = new Float32Array(dimension);
|
|
3310
|
+
if (target.metric === "cosine") {
|
|
3311
|
+
let squares = 0;
|
|
3312
|
+
for (let i = 0; i < dimension; i++) squares += mean[i] * mean[i];
|
|
3313
|
+
const length = Math.sqrt(squares);
|
|
3314
|
+
for (let i = 0; i < dimension; i++) centroid[i] = length === 0 ? mean[i] : mean[i] / length;
|
|
3315
|
+
return centroid;
|
|
3715
3316
|
}
|
|
3716
|
-
|
|
3717
|
-
|
|
3718
|
-
return new Uint32Array(copy.buffer, 0, copy.byteLength / BYTES_PER_VALUE);
|
|
3317
|
+
for (let i = 0; i < dimension; i++) centroid[i] = mean[i];
|
|
3318
|
+
return centroid;
|
|
3719
3319
|
}
|
|
3720
|
-
function
|
|
3721
|
-
if (
|
|
3722
|
-
return Math.
|
|
3320
|
+
function level(value, lower, upper, steps) {
|
|
3321
|
+
if (upper === lower) return 0;
|
|
3322
|
+
return Math.floor((clamp(value, lower, upper) - lower) * steps / (upper - lower) + 0.5);
|
|
3723
3323
|
}
|
|
3724
|
-
function
|
|
3725
|
-
let
|
|
3726
|
-
|
|
3727
|
-
|
|
3728
|
-
|
|
3729
|
-
|
|
3324
|
+
function loss(x, lower, upper, steps, norm) {
|
|
3325
|
+
let xe = 0;
|
|
3326
|
+
let e = 0;
|
|
3327
|
+
const width = (upper - lower) / steps;
|
|
3328
|
+
for (let i = 0; i < x.length; i++) {
|
|
3329
|
+
const q = lower + width * level(x[i], lower, upper, steps);
|
|
3330
|
+
xe += x[i] * (x[i] - q);
|
|
3331
|
+
e += (x[i] - q) * (x[i] - q);
|
|
3730
3332
|
}
|
|
3731
|
-
return
|
|
3333
|
+
return (1 - OSQ_LAMBDA) * xe * xe / norm + OSQ_LAMBDA * e;
|
|
3732
3334
|
}
|
|
3733
|
-
function
|
|
3734
|
-
|
|
3735
|
-
|
|
3736
|
-
|
|
3737
|
-
|
|
3738
|
-
|
|
3739
|
-
|
|
3740
|
-
|
|
3741
|
-
|
|
3742
|
-
|
|
3743
|
-
|
|
3744
|
-
|
|
3745
|
-
|
|
3746
|
-
|
|
3747
|
-
|
|
3748
|
-
|
|
3749
|
-
|
|
3750
|
-
|
|
3751
|
-
|
|
3752
|
-
|
|
3753
|
-
values[cursor] = neighbour;
|
|
3754
|
-
cursor += 1;
|
|
3755
|
-
}
|
|
3756
|
-
values[countAt] = cursor - countAt - 1;
|
|
3335
|
+
function refine(x, lowerStart, upperStart, steps) {
|
|
3336
|
+
let lower = lowerStart;
|
|
3337
|
+
let upper = upperStart;
|
|
3338
|
+
let norm = 0;
|
|
3339
|
+
for (let i = 0; i < x.length; i++) norm += x[i] * x[i];
|
|
3340
|
+
if (norm === 0 || upper === lower) return [lower, upper];
|
|
3341
|
+
let best = loss(x, lower, upper, steps, norm);
|
|
3342
|
+
for (let round = 0; round < OSQ_REFINE_ROUNDS; round++) {
|
|
3343
|
+
let daa = 0;
|
|
3344
|
+
let dab = 0;
|
|
3345
|
+
let dbb = 0;
|
|
3346
|
+
let dax = 0;
|
|
3347
|
+
let dbx = 0;
|
|
3348
|
+
for (let i = 0; i < x.length; i++) {
|
|
3349
|
+
const s = level(x[i], lower, upper, steps) / steps;
|
|
3350
|
+
daa += (1 - s) * (1 - s);
|
|
3351
|
+
dab += (1 - s) * s;
|
|
3352
|
+
dbb += s * s;
|
|
3353
|
+
dax += x[i] * (1 - s);
|
|
3354
|
+
dbx += x[i] * s;
|
|
3757
3355
|
}
|
|
3356
|
+
const m0 = (1 - OSQ_LAMBDA) * dax * dax / norm + OSQ_LAMBDA * daa;
|
|
3357
|
+
const m1 = (1 - OSQ_LAMBDA) * dax * dbx / norm + OSQ_LAMBDA * dab;
|
|
3358
|
+
const m2 = (1 - OSQ_LAMBDA) * dbx * dbx / norm + OSQ_LAMBDA * dbb;
|
|
3359
|
+
const det = m0 * m2 - m1 * m1;
|
|
3360
|
+
if (det === 0) return [lower, upper];
|
|
3361
|
+
const a = (m2 * dax - m1 * dbx) / det;
|
|
3362
|
+
const b = (m0 * dbx - m1 * dax) / det;
|
|
3363
|
+
if (Math.abs(a - lower) < OSQ_REFINE_TOLERANCE && Math.abs(b - upper) < OSQ_REFINE_TOLERANCE) return [lower, upper];
|
|
3364
|
+
const candidate = loss(x, a, b, steps, norm);
|
|
3365
|
+
if (candidate > best) return [lower, upper];
|
|
3366
|
+
lower = a;
|
|
3367
|
+
upper = b;
|
|
3368
|
+
best = candidate;
|
|
3758
3369
|
}
|
|
3759
|
-
return
|
|
3370
|
+
return [lower, upper];
|
|
3760
3371
|
}
|
|
3761
|
-
function
|
|
3762
|
-
|
|
3763
|
-
const topLayers = new Int8Array(ordinalOfNumber.length).fill(-1);
|
|
3764
|
-
for (let number = 0; number < ordinalOfNumber.length; number++) {
|
|
3765
|
-
const ordinal = ordinalOfNumber[number];
|
|
3766
|
-
if (ordinal >= slots) continue;
|
|
3767
|
-
topLayers[number] = savedTopLayer(state, ordinal);
|
|
3768
|
-
}
|
|
3769
|
-
const entryOrdinal = entryPointOf(state);
|
|
3770
|
-
const entryNumber = entryOrdinal >= 0 && entryOrdinal < numberOfOrdinal.length ? numberOfOrdinal[entryOrdinal] : NO_NUMBER;
|
|
3771
|
-
const entryHoldsNode = entryNumber !== NO_NUMBER && topLayers[entryNumber] >= 0;
|
|
3772
|
-
const header = {
|
|
3773
|
-
entryPoint: entryHoldsNode ? entryNumber : null,
|
|
3774
|
-
maxLayer: Math.max(0, Math.min(topLayerOf(state), MAX_LAYER_CAP)),
|
|
3775
|
-
m: state.M,
|
|
3776
|
-
efConstruction: state.efCons,
|
|
3777
|
-
metric: state.buildMetric
|
|
3778
|
-
};
|
|
3779
|
-
const numbers = { numberOfOrdinal, ordinalOfNumber, topLayers };
|
|
3780
|
-
const parts = [];
|
|
3781
|
-
for (let start = 0; start < ordinalOfNumber.length; start += partSize) {
|
|
3782
|
-
const end = Math.min(start + partSize, ordinalOfNumber.length);
|
|
3783
|
-
parts.push({ ...header, ...serializePart(state, numbers, start, end) });
|
|
3784
|
-
}
|
|
3785
|
-
return parts;
|
|
3372
|
+
function createOsqScratch(dimension) {
|
|
3373
|
+
return { normalised: new Float64Array(dimension), centred: new Float64Array(dimension) };
|
|
3786
3374
|
}
|
|
3787
|
-
function
|
|
3788
|
-
const
|
|
3789
|
-
const
|
|
3790
|
-
|
|
3791
|
-
let
|
|
3792
|
-
|
|
3793
|
-
|
|
3794
|
-
|
|
3795
|
-
|
|
3796
|
-
|
|
3797
|
-
|
|
3798
|
-
|
|
3799
|
-
|
|
3800
|
-
|
|
3801
|
-
|
|
3375
|
+
function osqQuantize(vector, centroid, bits, metric, scratch) {
|
|
3376
|
+
const dimension = vector.length;
|
|
3377
|
+
const v = scratch.normalised;
|
|
3378
|
+
if (metric === "cosine") unitNormaliseInto(v, vector);
|
|
3379
|
+
else for (let i = 0; i < dimension; i++) v[i] = vector[i];
|
|
3380
|
+
const x = scratch.centred;
|
|
3381
|
+
let correction = 0;
|
|
3382
|
+
let total = 0;
|
|
3383
|
+
let minimum = Number.POSITIVE_INFINITY;
|
|
3384
|
+
let maximum = Number.NEGATIVE_INFINITY;
|
|
3385
|
+
for (let i = 0; i < dimension; i++) {
|
|
3386
|
+
x[i] = v[i] - centroid[i];
|
|
3387
|
+
correction += metric === "euclidean" ? x[i] * x[i] : v[i] * centroid[i];
|
|
3388
|
+
total += x[i];
|
|
3389
|
+
if (x[i] < minimum) minimum = x[i];
|
|
3390
|
+
if (x[i] > maximum) maximum = x[i];
|
|
3802
3391
|
}
|
|
3803
|
-
const
|
|
3804
|
-
|
|
3805
|
-
|
|
3806
|
-
|
|
3807
|
-
|
|
3808
|
-
|
|
3809
|
-
|
|
3392
|
+
const mean = total / dimension;
|
|
3393
|
+
let spread = 0;
|
|
3394
|
+
for (let i = 0; i < dimension; i++) spread += (x[i] - mean) * (x[i] - mean);
|
|
3395
|
+
const std = Math.sqrt(spread / dimension);
|
|
3396
|
+
const steps = OSQ_STEPS[bits];
|
|
3397
|
+
const [lower, upper] = refine(
|
|
3398
|
+
x,
|
|
3399
|
+
clamp(mean - OSQ_GRID[bits] * std, minimum, maximum),
|
|
3400
|
+
clamp(mean + OSQ_GRID[bits] * std, minimum, maximum),
|
|
3401
|
+
steps
|
|
3810
3402
|
);
|
|
3811
|
-
|
|
3812
|
-
|
|
3813
|
-
|
|
3814
|
-
|
|
3815
|
-
|
|
3816
|
-
for (let number = 0; number < graph.levels.length; number++) {
|
|
3817
|
-
for (let layer = 0; layer < graph.levels[number]; layer++) {
|
|
3818
|
-
if (cursor >= values.length) endsInsideAList();
|
|
3819
|
-
const count = values[cursor];
|
|
3820
|
-
if (count > values.length - cursor - 1) endsInsideAList();
|
|
3821
|
-
cursor += count + 1;
|
|
3822
|
-
}
|
|
3403
|
+
const levels = new Uint8Array(dimension);
|
|
3404
|
+
let sum = 0;
|
|
3405
|
+
for (let i = 0; i < dimension; i++) {
|
|
3406
|
+
levels[i] = level(x[i], lower, upper, steps);
|
|
3407
|
+
sum += levels[i];
|
|
3823
3408
|
}
|
|
3409
|
+
return { levels, lower, upper, correction, sum };
|
|
3824
3410
|
}
|
|
3825
|
-
|
|
3826
|
-
|
|
3827
|
-
|
|
3828
|
-
const
|
|
3829
|
-
|
|
3411
|
+
|
|
3412
|
+
// src/vector/osq/products.ts
|
|
3413
|
+
function simdQueryProducts(simd, layout, documentOffset, queryOffset) {
|
|
3414
|
+
const { bits, dimension, codeBytes } = layout;
|
|
3415
|
+
if (bits === 8) return simd.dot_u8(documentOffset, queryOffset, dimension);
|
|
3416
|
+
if (bits === 4) return simd.osq_dot_nibbles_4x4(documentOffset, queryOffset, codeBytes);
|
|
3417
|
+
return simd.osq_dot_bits(documentOffset, queryOffset, codeBytes, bits);
|
|
3830
3418
|
}
|
|
3831
|
-
function
|
|
3832
|
-
|
|
3833
|
-
|
|
3834
|
-
|
|
3835
|
-
|
|
3836
|
-
|
|
3837
|
-
|
|
3419
|
+
function scalarQueryProducts(layout, document2, documentOffset, packed) {
|
|
3420
|
+
const { bits, dimension, codeBytes } = layout;
|
|
3421
|
+
if (bits === 8) return osqByteLevelProducts(document2, documentOffset, packed, 0, dimension);
|
|
3422
|
+
if (bits === 4) return osqNibbleProducts(document2, documentOffset, packed, 0, codeBytes);
|
|
3423
|
+
return osqStagedQueryProducts(document2, documentOffset, bits, packed, 0, codeBytes);
|
|
3424
|
+
}
|
|
3425
|
+
function simdPairProducts(simd, layout, offsetA, offsetB) {
|
|
3426
|
+
const { bits, dimension, codeBytes } = layout;
|
|
3427
|
+
if (bits === 8) return simd.dot_u8(offsetA, offsetB, dimension);
|
|
3428
|
+
if (bits === 4) return simd.osq_dot_nibbles_4x4(offsetA, offsetB, codeBytes);
|
|
3429
|
+
return simd.osq_dot_bits_pair(offsetA, offsetB, codeBytes, bits);
|
|
3430
|
+
}
|
|
3431
|
+
function scalarPairProducts(layout, bytesA, offsetA, bytesB, offsetB) {
|
|
3432
|
+
const { bits, dimension, codeBytes } = layout;
|
|
3433
|
+
if (bits === 8) return osqByteLevelProducts(bytesA, offsetA, bytesB, offsetB, dimension);
|
|
3434
|
+
if (bits === 4) return osqNibbleProducts(bytesA, offsetA, bytesB, offsetB, codeBytes);
|
|
3435
|
+
return osqNarrowPairProducts(bytesA, offsetA, bytesB, offsetB, bits, codeBytes);
|
|
3436
|
+
}
|
|
3437
|
+
|
|
3438
|
+
// src/vector/osq/recoding.ts
|
|
3439
|
+
function createCodeRecoding(source, centroid) {
|
|
3440
|
+
const { store, layout, metric } = source;
|
|
3441
|
+
const { capacity, slotStride, bits } = layout;
|
|
3442
|
+
const scratch = createOsqScratch(layout.dimension);
|
|
3443
|
+
const blocks = [];
|
|
3444
|
+
let recoded = new Uint8Array(0);
|
|
3445
|
+
function blockReaching(blockIndex, end) {
|
|
3446
|
+
const held = blocks[blockIndex];
|
|
3447
|
+
if (held !== void 0 && held.bytes.length >= end) return held;
|
|
3448
|
+
const length = Math.min(capacity * slotStride, Math.max(end, (held?.bytes.length ?? 0) * 2));
|
|
3449
|
+
const bytes = new Uint8Array(length);
|
|
3450
|
+
if (held !== void 0) bytes.set(held.bytes);
|
|
3451
|
+
const block = { bytes, data: new DataView(bytes.buffer), usedBytes: held?.usedBytes ?? 0 };
|
|
3452
|
+
blocks[blockIndex] = block;
|
|
3453
|
+
return block;
|
|
3454
|
+
}
|
|
3455
|
+
function markRecoded(ordinal) {
|
|
3456
|
+
if (ordinal >= recoded.length) {
|
|
3457
|
+
const grown = new Uint8Array(Math.max(ordinal + 1, recoded.length * 2));
|
|
3458
|
+
grown.set(recoded);
|
|
3459
|
+
recoded = grown;
|
|
3838
3460
|
}
|
|
3461
|
+
recoded[ordinal] = 1;
|
|
3839
3462
|
}
|
|
3840
|
-
|
|
3841
|
-
|
|
3842
|
-
|
|
3843
|
-
|
|
3844
|
-
|
|
3845
|
-
|
|
3846
|
-
|
|
3847
|
-
|
|
3848
|
-
|
|
3849
|
-
|
|
3850
|
-
|
|
3851
|
-
|
|
3852
|
-
|
|
3853
|
-
|
|
3854
|
-
|
|
3855
|
-
|
|
3856
|
-
|
|
3857
|
-
const
|
|
3858
|
-
if (
|
|
3859
|
-
const
|
|
3860
|
-
|
|
3861
|
-
if (ordinal !== NO_ORDINAL) {
|
|
3862
|
-
createNode(state.adjacency, ordinal, keptTop);
|
|
3863
|
-
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
3864
|
-
if (keptTop > highestLayer) {
|
|
3865
|
-
highestLayer = keptTop;
|
|
3866
|
-
nodeOnHighestLayer = ordinal;
|
|
3867
|
-
}
|
|
3868
|
-
}
|
|
3869
|
-
for (let layer = 0; layer <= top; layer++) {
|
|
3870
|
-
const count = values[cursor];
|
|
3871
|
-
kept.length = 0;
|
|
3872
|
-
const limit = maxConns(state, layer);
|
|
3873
|
-
for (let i = 1; i <= count && kept.length < limit; i++) {
|
|
3874
|
-
const neighbour = values[cursor + i];
|
|
3875
|
-
const neighbourOrdinal = ordinalAt2(neighbour);
|
|
3876
|
-
if (neighbourOrdinal === NO_ORDINAL || neighbour === number) continue;
|
|
3877
|
-
if (topLayerInParts(graph, neighbour) < layer) continue;
|
|
3878
|
-
if (!kept.includes(neighbourOrdinal)) kept.push(neighbourOrdinal);
|
|
3879
|
-
}
|
|
3880
|
-
cursor += count + 1;
|
|
3881
|
-
if (ordinal !== NO_ORDINAL && layer <= keptTop) {
|
|
3882
|
-
writeNeighbors(state.adjacency, ordinal, layer, kept, kept.length);
|
|
3883
|
-
}
|
|
3884
|
-
}
|
|
3463
|
+
function recode(ordinal) {
|
|
3464
|
+
if (!source.holds(ordinal) || !store.holdsOrdinal(ordinal)) return;
|
|
3465
|
+
const offset = ordinal % capacity * slotStride;
|
|
3466
|
+
const block = blockReaching(Math.floor(ordinal / capacity), offset + slotStride);
|
|
3467
|
+
const code = osqQuantize(store.vectorAt(ordinal), centroid, bits, metric, scratch);
|
|
3468
|
+
writeRecord(block.bytes, offset, code, bits, block.data);
|
|
3469
|
+
block.usedBytes = Math.max(block.usedBytes, offset + slotStride);
|
|
3470
|
+
markRecoded(ordinal);
|
|
3471
|
+
}
|
|
3472
|
+
function copyIntoStore(slots) {
|
|
3473
|
+
for (let ordinal = 0; ordinal < slots; ordinal++) {
|
|
3474
|
+
if (!source.holds(ordinal) || ordinal < recoded.length && recoded[ordinal] === 1) continue;
|
|
3475
|
+
recode(ordinal);
|
|
3476
|
+
if (ordinal >= recoded.length || recoded[ordinal] !== 1) source.clearCodes(ordinal);
|
|
3477
|
+
}
|
|
3478
|
+
const start = slotByteOffset(layout, 0);
|
|
3479
|
+
for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
|
|
3480
|
+
const block = blocks[blockIndex];
|
|
3481
|
+
if (block === void 0 || block.usedBytes === 0) continue;
|
|
3482
|
+
const target = store.codeBlockOf(blockIndex * capacity).bytes(start + block.usedBytes);
|
|
3483
|
+
target.set(block.bytes.subarray(0, block.usedBytes), start);
|
|
3885
3484
|
}
|
|
3886
3485
|
}
|
|
3887
|
-
|
|
3888
|
-
const entryPoint = first === void 0 ? null : first.entryPoint;
|
|
3889
|
-
const entryOrdinal = entryPoint === null ? NO_ORDINAL : ordinalAt2(entryPoint);
|
|
3890
|
-
const entryTop = entryPoint === null ? -1 : Math.min(topLayerInParts(graph, entryPoint), MAX_LAYER_CAP);
|
|
3891
|
-
const entryIsUsable = entryOrdinal !== NO_ORDINAL && entryTop >= 0;
|
|
3892
|
-
Atomics.store(state.header, GRAPH_ENTRY_POINT, entryIsUsable ? entryOrdinal : nodeOnHighestLayer);
|
|
3893
|
-
Atomics.store(state.header, GRAPH_TOP_LAYER, entryIsUsable ? entryTop : highestLayer);
|
|
3894
|
-
leaveIncomingUncounted(state);
|
|
3486
|
+
return { centroid, recode, copyIntoStore };
|
|
3895
3487
|
}
|
|
3896
3488
|
|
|
3897
|
-
// src/vector/
|
|
3898
|
-
function
|
|
3899
|
-
const
|
|
3900
|
-
|
|
3901
|
-
|
|
3902
|
-
|
|
3903
|
-
|
|
3904
|
-
|
|
3905
|
-
|
|
3906
|
-
|
|
3907
|
-
|
|
3908
|
-
|
|
3909
|
-
|
|
3910
|
-
|
|
3911
|
-
|
|
3912
|
-
|
|
3913
|
-
|
|
3914
|
-
|
|
3915
|
-
|
|
3916
|
-
|
|
3917
|
-
|
|
3489
|
+
// src/vector/osq/view.ts
|
|
3490
|
+
function openSharedQuantizer(store, layout, metric) {
|
|
3491
|
+
const { dimension, bits, queryBits, codeBytes, capacity } = layout;
|
|
3492
|
+
const scratch = createOsqScratch(dimension);
|
|
3493
|
+
const placementQueryBits = osqPlacementQueryBits(bits);
|
|
3494
|
+
const documentTrailer = { lower: 0, upper: 0, correction: 0, sum: 0 };
|
|
3495
|
+
const otherTrailer = { lower: 0, upper: 0, correction: 0, sum: 0 };
|
|
3496
|
+
let codePresent = fixedView(store.handles.codePresent, Uint8Array);
|
|
3497
|
+
let centroidDot = 0;
|
|
3498
|
+
let centroidGeneration = -1;
|
|
3499
|
+
let currentQuery = null;
|
|
3500
|
+
let recoding = null;
|
|
3501
|
+
const singleOrdinal = new Int32Array(1);
|
|
3502
|
+
function reach2(ordinal) {
|
|
3503
|
+
if (ordinal < codePresent.length) return true;
|
|
3504
|
+
if (ordinal >= store.handles.codePresent.byteLength) return false;
|
|
3505
|
+
codePresent = fixedView(store.handles.codePresent, Uint8Array);
|
|
3506
|
+
return ordinal < codePresent.length;
|
|
3507
|
+
}
|
|
3508
|
+
function isCalibrated() {
|
|
3509
|
+
return Atomics.load(store.handles.header, STORE_CALIBRATED) === 1;
|
|
3510
|
+
}
|
|
3511
|
+
function recomputeCentroidDot(generation) {
|
|
3512
|
+
const centroid = store.handles.centroid;
|
|
3513
|
+
let total = 0;
|
|
3514
|
+
for (let i = 0; i < dimension; i++) total += centroid[i] * centroid[i];
|
|
3515
|
+
centroidDot = total;
|
|
3516
|
+
centroidGeneration = generation;
|
|
3517
|
+
}
|
|
3518
|
+
function centroidDotNow() {
|
|
3519
|
+
const generation = Atomics.load(store.handles.header, STORE_CALIBRATION_GENERATION);
|
|
3520
|
+
if (generation !== centroidGeneration) recomputeCentroidDot(generation);
|
|
3521
|
+
return centroidDot;
|
|
3522
|
+
}
|
|
3523
|
+
function holds2(ordinal) {
|
|
3524
|
+
return ordinal >= 0 && reach2(ordinal) && codePresent[ordinal] === 1;
|
|
3525
|
+
}
|
|
3526
|
+
function recordOffset(ordinal) {
|
|
3527
|
+
return slotByteOffset(layout, ordinal % capacity);
|
|
3528
|
+
}
|
|
3529
|
+
function markPresent(ordinal) {
|
|
3530
|
+
if (Atomics.load(codePresent, ordinal) !== 0) return;
|
|
3531
|
+
Atomics.add(store.handles.header, STORE_CODE_COUNT, 1);
|
|
3532
|
+
Atomics.store(codePresent, ordinal, 1);
|
|
3533
|
+
}
|
|
3534
|
+
function writeCentroid(centroid) {
|
|
3535
|
+
store.handles.centroid.set(centroid);
|
|
3536
|
+
Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
3537
|
+
Atomics.store(store.handles.header, STORE_CALIBRATED, 1);
|
|
3538
|
+
}
|
|
3539
|
+
function measureInto(ordinals, sums) {
|
|
3540
|
+
if (nativeMeasure(store.handles, metric, ordinals, sums.totals)) return;
|
|
3541
|
+
for (const vector of storedVectors(ordinals)) addToCentroidSums(sums, vector);
|
|
3542
|
+
}
|
|
3543
|
+
function* storedVectors(ordinals) {
|
|
3544
|
+
for (const ordinal of ordinals) {
|
|
3545
|
+
if (store.holdsOrdinal(ordinal)) yield store.vectorAt(ordinal);
|
|
3918
3546
|
}
|
|
3919
|
-
if (ord > maxOrd) maxOrd = ord;
|
|
3920
|
-
nodes.push({ ord, maxLayer: clampedMaxLayer, layers });
|
|
3921
3547
|
}
|
|
3922
|
-
|
|
3923
|
-
|
|
3924
|
-
|
|
3925
|
-
|
|
3926
|
-
|
|
3927
|
-
|
|
3928
|
-
|
|
3548
|
+
function writeRecordOf(ordinal) {
|
|
3549
|
+
if (!reach2(ordinal) || !store.holdsOrdinal(ordinal)) return;
|
|
3550
|
+
const code = osqQuantize(store.vectorAt(ordinal), store.handles.centroid, bits, metric, scratch);
|
|
3551
|
+
const block = store.codeBlockOf(ordinal);
|
|
3552
|
+
const offset = recordOffset(ordinal);
|
|
3553
|
+
writeRecord(block.bytes(offset + layout.slotStride), offset, code, bits, block.data(offset + layout.slotStride));
|
|
3554
|
+
markPresent(ordinal);
|
|
3555
|
+
recoding?.recode(ordinal);
|
|
3929
3556
|
}
|
|
3930
|
-
|
|
3931
|
-
|
|
3932
|
-
|
|
3933
|
-
|
|
3557
|
+
function writeCodesOf(ordinals) {
|
|
3558
|
+
if (!isCalibrated() || ordinals.length === 0) return;
|
|
3559
|
+
if (nativeQuantise(store.handles, metric, ordinals)) {
|
|
3560
|
+
if (recoding !== null) for (const ordinal of ordinals) recoding.recode(ordinal);
|
|
3561
|
+
return;
|
|
3934
3562
|
}
|
|
3935
|
-
|
|
3563
|
+
for (const ordinal of ordinals) writeRecordOf(ordinal);
|
|
3936
3564
|
}
|
|
3937
|
-
|
|
3938
|
-
|
|
3939
|
-
if (
|
|
3940
|
-
|
|
3941
|
-
|
|
3565
|
+
function clearCodes(ordinal) {
|
|
3566
|
+
if (ordinal < 0 || !reach2(ordinal)) return;
|
|
3567
|
+
if (Atomics.exchange(codePresent, ordinal, 0) === 1) Atomics.sub(store.handles.header, STORE_CODE_COUNT, 1);
|
|
3568
|
+
}
|
|
3569
|
+
function stageQuery(block, query) {
|
|
3570
|
+
if (block.simd === null || !block.hasScratch) return false;
|
|
3571
|
+
if (block.stagedOrdinal !== QUERY_STAGED) {
|
|
3572
|
+
block.bytes(block.scratchByteOffset + query.packed.length).set(query.packed, block.scratchByteOffset);
|
|
3573
|
+
block.stagedOrdinal = QUERY_STAGED;
|
|
3942
3574
|
}
|
|
3575
|
+
return true;
|
|
3943
3576
|
}
|
|
3944
|
-
|
|
3945
|
-
|
|
3946
|
-
|
|
3947
|
-
const slots = adjacencySlots(state.adjacency);
|
|
3948
|
-
for (let ord = 0; ord < slots; ord++) {
|
|
3949
|
-
const level2 = nodeMaxLayer(state, ord);
|
|
3950
|
-
if (level2 === -1) continue;
|
|
3951
|
-
if (level2 > bestLayer) {
|
|
3952
|
-
bestLayer = level2;
|
|
3953
|
-
bestOrd = ord;
|
|
3954
|
-
}
|
|
3577
|
+
function productsAgainstQuery(block, documentOffset, query) {
|
|
3578
|
+
if (block.simd !== null && stageQuery(block, query)) {
|
|
3579
|
+
return simdQueryProducts(block.simd, layout, documentOffset, block.scratchByteOffset);
|
|
3955
3580
|
}
|
|
3956
|
-
|
|
3957
|
-
|
|
3581
|
+
return scalarQueryProducts(layout, block.bytes(documentOffset + codeBytes), documentOffset, query.packed);
|
|
3582
|
+
}
|
|
3583
|
+
function distanceFrom(products, query, levelBits) {
|
|
3584
|
+
const estimate = osqEstimate(products, documentTrailer, bits, query, levelBits, dimension, centroidDotNow(), metric);
|
|
3585
|
+
return osqDistance(estimate, metric);
|
|
3586
|
+
}
|
|
3587
|
+
function estimateDistance(ordinal, query) {
|
|
3588
|
+
const block = store.codeBlockOf(ordinal);
|
|
3589
|
+
const offset = recordOffset(ordinal);
|
|
3590
|
+
const products = productsAgainstQuery(block, offset, query);
|
|
3591
|
+
readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
|
|
3592
|
+
return distanceFrom(products, query, queryBits);
|
|
3593
|
+
}
|
|
3594
|
+
function prepareQuery(query) {
|
|
3595
|
+
if (!isCalibrated() || query.length !== dimension) return null;
|
|
3596
|
+
const code = osqQuantize(query, store.handles.centroid, queryBits, metric, scratch);
|
|
3597
|
+
const packed = new Uint8Array(layout.queryBytes);
|
|
3598
|
+
stageQueryLevels(code.levels, bits, packed);
|
|
3599
|
+
for (const block of store.openCodeBlocks()) block.stagedOrdinal = NOTHING_STAGED;
|
|
3600
|
+
currentQuery = {
|
|
3601
|
+
packed,
|
|
3602
|
+
lower: code.lower,
|
|
3603
|
+
upper: code.upper,
|
|
3604
|
+
correction: code.correction,
|
|
3605
|
+
sum: code.sum
|
|
3606
|
+
};
|
|
3607
|
+
return currentQuery;
|
|
3608
|
+
}
|
|
3609
|
+
function preparedDistance(prepared) {
|
|
3610
|
+
const generic = (ordinal) => holds2(ordinal) ? estimateDistance(ordinal, prepared) : Number.POSITIVE_INFINITY;
|
|
3611
|
+
if (store.handles.codeBlocks.length === 0) return generic;
|
|
3612
|
+
const block = store.codeBlockOf(0);
|
|
3613
|
+
const simd = block.simd;
|
|
3614
|
+
if (simd === null || !block.hasScratch) return generic;
|
|
3615
|
+
const presentView = codePresent;
|
|
3616
|
+
const limit = Math.min(presentView.length, capacity);
|
|
3617
|
+
const { slotsOffset, slotStride } = layout;
|
|
3618
|
+
const data = block.data(slotsOffset + slotStride);
|
|
3619
|
+
const dataLength = data.byteLength;
|
|
3620
|
+
const queryOffset = block.scratchByteOffset;
|
|
3621
|
+
return (ordinal) => {
|
|
3622
|
+
if (ordinal < 0 || ordinal >= limit || block.stagedOrdinal !== QUERY_STAGED) return generic(ordinal);
|
|
3623
|
+
if (presentView[ordinal] !== 1) return Number.POSITIVE_INFINITY;
|
|
3624
|
+
const offset = slotsOffset + ordinal * slotStride;
|
|
3625
|
+
if (offset + slotStride > dataLength) return generic(ordinal);
|
|
3626
|
+
const products = simdQueryProducts(simd, layout, offset, queryOffset);
|
|
3627
|
+
readTrailer(data, offset, codeBytes, documentTrailer);
|
|
3628
|
+
return distanceFrom(products, prepared, queryBits);
|
|
3629
|
+
};
|
|
3630
|
+
}
|
|
3631
|
+
function placementDistance2(vector) {
|
|
3632
|
+
if (placementQueryBits === queryBits) {
|
|
3633
|
+
const prepared = prepareQuery(vector);
|
|
3634
|
+
return prepared === null ? null : preparedDistance(prepared);
|
|
3635
|
+
}
|
|
3636
|
+
if (!isCalibrated() || vector.length !== dimension) return null;
|
|
3637
|
+
const code = osqQuantize(vector, store.handles.centroid, placementQueryBits, metric, scratch);
|
|
3638
|
+
const levels = new Uint8Array(2 * codeBytes);
|
|
3639
|
+
levels.set(code.levels);
|
|
3640
|
+
return (ordinal) => {
|
|
3641
|
+
if (!holds2(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3642
|
+
const block = store.codeBlockOf(ordinal);
|
|
3643
|
+
const offset = recordOffset(ordinal);
|
|
3644
|
+
const products = osqNibblesByByteLevels(block.bytes(offset + codeBytes), offset, levels, codeBytes);
|
|
3645
|
+
readTrailer(block.data(offset + layout.slotStride), offset, codeBytes, documentTrailer);
|
|
3646
|
+
return distanceFrom(products, code, placementQueryBits);
|
|
3647
|
+
};
|
|
3648
|
+
}
|
|
3649
|
+
function distanceBetween(ordA, ordB) {
|
|
3650
|
+
if (!holds2(ordA) || !holds2(ordB)) return Number.POSITIVE_INFINITY;
|
|
3651
|
+
const blockA = store.codeBlockOf(ordA);
|
|
3652
|
+
const blockB = store.codeBlockOf(ordB);
|
|
3653
|
+
const offsetA = recordOffset(ordA);
|
|
3654
|
+
const offsetB = recordOffset(ordB);
|
|
3655
|
+
const products = blockA === blockB && blockA.simd !== null ? simdPairProducts(blockA.simd, layout, offsetA, offsetB) : scalarPairProducts(
|
|
3656
|
+
layout,
|
|
3657
|
+
blockA.bytes(offsetA + codeBytes),
|
|
3658
|
+
offsetA,
|
|
3659
|
+
blockB.bytes(offsetB + codeBytes),
|
|
3660
|
+
offsetB
|
|
3661
|
+
);
|
|
3662
|
+
readTrailer(blockA.data(offsetA + layout.slotStride), offsetA, codeBytes, documentTrailer);
|
|
3663
|
+
readTrailer(blockB.data(offsetB + layout.slotStride), offsetB, codeBytes, otherTrailer);
|
|
3664
|
+
return distanceFrom(products, otherTrailer, bits);
|
|
3665
|
+
}
|
|
3666
|
+
function pairDistance() {
|
|
3667
|
+
if (store.handles.codeBlocks.length === 0) return distanceBetween;
|
|
3668
|
+
const block = store.codeBlockOf(0);
|
|
3669
|
+
const simd = block.simd;
|
|
3670
|
+
if (simd === null) return distanceBetween;
|
|
3671
|
+
const presentView = codePresent;
|
|
3672
|
+
const limit = Math.min(presentView.length, capacity);
|
|
3673
|
+
const { slotsOffset, slotStride } = layout;
|
|
3674
|
+
const data = block.data(slotsOffset + slotStride);
|
|
3675
|
+
const dataLength = data.byteLength;
|
|
3676
|
+
return (ordA, ordB) => {
|
|
3677
|
+
if (ordA < 0 || ordB < 0 || ordA >= limit || ordB >= limit) return distanceBetween(ordA, ordB);
|
|
3678
|
+
if (presentView[ordA] !== 1 || presentView[ordB] !== 1) return Number.POSITIVE_INFINITY;
|
|
3679
|
+
const offsetA = slotsOffset + ordA * slotStride;
|
|
3680
|
+
const offsetB = slotsOffset + ordB * slotStride;
|
|
3681
|
+
if (Math.max(offsetA, offsetB) + slotStride > dataLength) return distanceBetween(ordA, ordB);
|
|
3682
|
+
const products = simdPairProducts(simd, layout, offsetA, offsetB);
|
|
3683
|
+
readTrailer(data, offsetA, codeBytes, documentTrailer);
|
|
3684
|
+
readTrailer(data, offsetB, codeBytes, otherTrailer);
|
|
3685
|
+
return distanceFrom(products, otherTrailer, bits);
|
|
3686
|
+
};
|
|
3958
3687
|
}
|
|
3959
|
-
leaveIncomingUncounted(state);
|
|
3960
|
-
}
|
|
3961
|
-
|
|
3962
|
-
// src/vector/hnsw/scratch-bytes.ts
|
|
3963
|
-
function listBytes(list) {
|
|
3964
|
-
return list.ords.byteLength + list.distances.byteLength;
|
|
3965
|
-
}
|
|
3966
|
-
function workspaceBytes(workspace) {
|
|
3967
|
-
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;
|
|
3968
|
-
for (const list of workspace.linkSelections) bytes += listBytes(list);
|
|
3969
|
-
return bytes;
|
|
3970
|
-
}
|
|
3971
|
-
function searchScratchBytes(state) {
|
|
3972
|
-
const held = workspaceBytes(state.workspace) + state.neighborScratch.byteLength + state.visited.byteLength;
|
|
3973
|
-
const native = attachedNativeField(state);
|
|
3974
|
-
return native === null ? held : held + nativeScratchBytes(state, native);
|
|
3975
|
-
}
|
|
3976
|
-
|
|
3977
|
-
// src/vector/hnsw/snapshot.ts
|
|
3978
|
-
function exportSnapshot(state) {
|
|
3979
|
-
const adj = state.adjacency;
|
|
3980
|
-
const slots = adjacencySlots(adj);
|
|
3981
|
-
const used = upperUsed(adj);
|
|
3982
|
-
const stride = adj.level0Stride;
|
|
3983
|
-
rebindNodes(adj);
|
|
3984
|
-
reachTombstone(state, slots);
|
|
3985
3688
|
return {
|
|
3986
|
-
|
|
3987
|
-
|
|
3988
|
-
|
|
3989
|
-
|
|
3990
|
-
|
|
3991
|
-
|
|
3992
|
-
|
|
3993
|
-
|
|
3994
|
-
|
|
3995
|
-
|
|
3996
|
-
|
|
3997
|
-
|
|
3998
|
-
|
|
3999
|
-
|
|
4000
|
-
|
|
4001
|
-
|
|
4002
|
-
|
|
4003
|
-
|
|
4004
|
-
|
|
4005
|
-
|
|
4006
|
-
|
|
4007
|
-
|
|
4008
|
-
|
|
4009
|
-
|
|
4010
|
-
|
|
4011
|
-
|
|
4012
|
-
|
|
4013
|
-
|
|
4014
|
-
|
|
4015
|
-
|
|
4016
|
-
|
|
4017
|
-
|
|
4018
|
-
|
|
4019
|
-
|
|
4020
|
-
|
|
3689
|
+
bits,
|
|
3690
|
+
metric,
|
|
3691
|
+
get size() {
|
|
3692
|
+
return Atomics.load(store.handles.header, STORE_CODE_COUNT);
|
|
3693
|
+
},
|
|
3694
|
+
get centroid() {
|
|
3695
|
+
return isCalibrated() ? store.handles.centroid : null;
|
|
3696
|
+
},
|
|
3697
|
+
isCalibrated,
|
|
3698
|
+
holdsOrdinal: holds2,
|
|
3699
|
+
writeCodes(ordinal) {
|
|
3700
|
+
singleOrdinal[0] = ordinal;
|
|
3701
|
+
writeCodesOf(singleOrdinal);
|
|
3702
|
+
},
|
|
3703
|
+
writeCodesOf,
|
|
3704
|
+
measureInto,
|
|
3705
|
+
calibrateFrom(ordinals) {
|
|
3706
|
+
const sums = createCentroidSums(dimension, metric);
|
|
3707
|
+
measureInto(ordinals, sums);
|
|
3708
|
+
const centroid = centroidOfCentroidSums(sums);
|
|
3709
|
+
if (centroid === null) return false;
|
|
3710
|
+
writeCentroid(centroid);
|
|
3711
|
+
return true;
|
|
3712
|
+
},
|
|
3713
|
+
restoreRecord(ordinal, record) {
|
|
3714
|
+
if (!reach2(ordinal) || record.length !== layout.slotStride) return;
|
|
3715
|
+
const block = store.codeBlockOf(ordinal);
|
|
3716
|
+
const offset = recordOffset(ordinal);
|
|
3717
|
+
block.bytes(offset + layout.slotStride).set(record, offset);
|
|
3718
|
+
markPresent(ordinal);
|
|
3719
|
+
recoding?.recode(ordinal);
|
|
3720
|
+
},
|
|
3721
|
+
recordAt(ordinal) {
|
|
3722
|
+
const block = store.codeBlockOf(ordinal);
|
|
3723
|
+
const offset = recordOffset(ordinal);
|
|
3724
|
+
return block.bytes(offset + layout.slotStride).subarray(offset, offset + layout.slotStride);
|
|
3725
|
+
},
|
|
3726
|
+
clearCodes,
|
|
3727
|
+
writeCentroid,
|
|
3728
|
+
resetCalibration() {
|
|
3729
|
+
recoding = null;
|
|
3730
|
+
Atomics.store(store.handles.header, STORE_CALIBRATED, 0);
|
|
3731
|
+
store.handles.centroid.fill(0);
|
|
3732
|
+
Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
3733
|
+
},
|
|
3734
|
+
resetCodes() {
|
|
3735
|
+
recoding = null;
|
|
3736
|
+
codePresent = fixedView(store.handles.codePresent, Uint8Array);
|
|
3737
|
+
codePresent.fill(0);
|
|
3738
|
+
Atomics.store(store.handles.header, STORE_CODE_COUNT, 0);
|
|
3739
|
+
},
|
|
3740
|
+
beginRecoding(centroid) {
|
|
3741
|
+
recoding = createCodeRecoding({ store, layout, metric, holds: holds2, clearCodes }, Float32Array.from(centroid));
|
|
3742
|
+
},
|
|
3743
|
+
recode(ordinal) {
|
|
3744
|
+
recoding?.recode(ordinal);
|
|
3745
|
+
},
|
|
3746
|
+
finishRecoding() {
|
|
3747
|
+
if (recoding === null) return false;
|
|
3748
|
+
const finished = recoding;
|
|
3749
|
+
recoding = null;
|
|
3750
|
+
finished.copyIntoStore(store.slots);
|
|
3751
|
+
writeCentroid(finished.centroid);
|
|
3752
|
+
return true;
|
|
3753
|
+
},
|
|
3754
|
+
abandonRecoding() {
|
|
3755
|
+
recoding = null;
|
|
3756
|
+
},
|
|
3757
|
+
prepareQuery,
|
|
3758
|
+
distanceFromPreparedByOrdinal(prepared, ordinal) {
|
|
3759
|
+
if (!holds2(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3760
|
+
return estimateDistance(ordinal, prepared);
|
|
3761
|
+
},
|
|
3762
|
+
preparedDistance,
|
|
3763
|
+
pairDistance,
|
|
3764
|
+
placementDistance: placementDistance2
|
|
3765
|
+
};
|
|
4021
3766
|
}
|
|
4022
3767
|
|
|
4023
|
-
// src/vector/
|
|
4024
|
-
function
|
|
4025
|
-
|
|
4026
|
-
|
|
4027
|
-
|
|
4028
|
-
|
|
4029
|
-
efConstruction: config?.efConstruction ?? 200,
|
|
4030
|
-
metric: config?.metric ?? "cosine"
|
|
4031
|
-
});
|
|
4032
|
-
const state = openGraphState(shared, dimension, store, quantizer, 0);
|
|
4033
|
-
const docIdOf = (ord) => store.docIdForOrdinal(ord);
|
|
4034
|
-
function exclusively(operation) {
|
|
4035
|
-
lockGraphExclusive(state.locks);
|
|
4036
|
-
try {
|
|
4037
|
-
return operation();
|
|
4038
|
-
} finally {
|
|
4039
|
-
unlockGraphExclusive(state.locks);
|
|
3768
|
+
// src/vector/osq/index.ts
|
|
3769
|
+
function createOsqQuantizer(dimension, bits, metric, store) {
|
|
3770
|
+
let opened = null;
|
|
3771
|
+
function shared() {
|
|
3772
|
+
if (opened === null && store.dimension === dimension && store.handles.codeLayout !== null) {
|
|
3773
|
+
opened = openSharedQuantizer(store.view, store.handles.codeLayout, metric);
|
|
4040
3774
|
}
|
|
3775
|
+
return opened;
|
|
4041
3776
|
}
|
|
4042
|
-
function
|
|
4043
|
-
const
|
|
4044
|
-
if (
|
|
4045
|
-
|
|
4046
|
-
}
|
|
4047
|
-
const entry = store.entryForOrdinal(ord);
|
|
4048
|
-
if (!entry) {
|
|
4049
|
-
throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
|
|
4050
|
-
}
|
|
4051
|
-
if (entry.vector.length !== dimension) {
|
|
4052
|
-
throw new NarsilError(
|
|
4053
|
-
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
4054
|
-
`Vector dimension mismatch: expected ${dimension}, got ${entry.vector.length}`,
|
|
4055
|
-
{ docId, expected: dimension, received: entry.vector.length }
|
|
4056
|
-
);
|
|
4057
|
-
}
|
|
4058
|
-
insertNode(state, ord);
|
|
3777
|
+
function requireShared() {
|
|
3778
|
+
const view = shared();
|
|
3779
|
+
if (view === null) throw new Error("The vector store holds no vector for the quantizer to work on");
|
|
3780
|
+
return view;
|
|
4059
3781
|
}
|
|
4060
|
-
function
|
|
4061
|
-
const
|
|
4062
|
-
|
|
4063
|
-
|
|
4064
|
-
if (isTombstoned(state, ord)) continue;
|
|
4065
|
-
const docId = store.docIdForOrdinal(ord);
|
|
4066
|
-
if (docId === void 0) continue;
|
|
4067
|
-
const entry = store.entryForOrdinal(ord);
|
|
4068
|
-
if (!entry) continue;
|
|
4069
|
-
yield [docId, { docId, vector: entry.vector, magnitude: entry.magnitude }];
|
|
3782
|
+
function ordinalOf(docId) {
|
|
3783
|
+
const ordinal = store.getOrdinal(docId);
|
|
3784
|
+
if (ordinal === void 0) {
|
|
3785
|
+
throw new Error(`Cannot quantize "${docId}": the vector store holds no vector for it`);
|
|
4070
3786
|
}
|
|
4071
|
-
|
|
4072
|
-
function compactionNeeded() {
|
|
4073
|
-
const nodeCount = nodeCountOf(state);
|
|
4074
|
-
if (nodeCount === 0) return false;
|
|
4075
|
-
const tombstones = tombstoneCountOf(state);
|
|
4076
|
-
return tombstones / nodeCount > COMPACTION_TOMBSTONE_RATIO || tombstones > COMPACTION_ABSOLUTE_THRESHOLD;
|
|
3787
|
+
return ordinal;
|
|
4077
3788
|
}
|
|
4078
3789
|
return {
|
|
4079
|
-
|
|
4080
|
-
|
|
4081
|
-
|
|
3790
|
+
dimension,
|
|
3791
|
+
bits,
|
|
3792
|
+
metric,
|
|
4082
3793
|
get size() {
|
|
4083
|
-
return
|
|
3794
|
+
return shared()?.size ?? 0;
|
|
4084
3795
|
},
|
|
4085
|
-
get
|
|
4086
|
-
return
|
|
3796
|
+
get centroid() {
|
|
3797
|
+
return shared()?.centroid ?? null;
|
|
4087
3798
|
},
|
|
4088
|
-
|
|
4089
|
-
|
|
4090
|
-
|
|
3799
|
+
isCalibrated: () => shared()?.isCalibrated() ?? false,
|
|
3800
|
+
calibrate(ordinals) {
|
|
3801
|
+
if (ordinals.length > 0) requireShared().calibrateFrom(ordinals);
|
|
4091
3802
|
},
|
|
4092
|
-
|
|
4093
|
-
|
|
3803
|
+
measure(ordinals, sums) {
|
|
3804
|
+
if (ordinals.length > 0) requireShared().measureInto(ordinals, sums);
|
|
4094
3805
|
},
|
|
4095
|
-
|
|
4096
|
-
|
|
3806
|
+
quantize(docId) {
|
|
3807
|
+
const ordinal = ordinalOf(docId);
|
|
3808
|
+
const view = requireShared();
|
|
3809
|
+
if (!view.isCalibrated()) view.calibrateFrom(Int32Array.of(ordinal));
|
|
3810
|
+
view.writeCodes(ordinal);
|
|
4097
3811
|
},
|
|
4098
|
-
|
|
4099
|
-
|
|
3812
|
+
writeCodes(ordinal) {
|
|
3813
|
+
shared()?.writeCodes(ordinal);
|
|
4100
3814
|
},
|
|
4101
|
-
|
|
4102
|
-
|
|
3815
|
+
remove(docId) {
|
|
3816
|
+
const ordinal = store.getOrdinal(docId);
|
|
3817
|
+
if (ordinal !== void 0) shared()?.clearCodes(ordinal);
|
|
4103
3818
|
},
|
|
4104
|
-
|
|
4105
|
-
|
|
3819
|
+
removeOrdinal(ordinal) {
|
|
3820
|
+
shared()?.clearCodes(ordinal);
|
|
4106
3821
|
},
|
|
4107
|
-
|
|
4108
|
-
|
|
3822
|
+
hasOrdinal: (ordinal) => shared()?.holdsOrdinal(ordinal) ?? false,
|
|
3823
|
+
getLevels(docId) {
|
|
3824
|
+
const view = shared();
|
|
3825
|
+
const ordinal = store.getOrdinal(docId);
|
|
3826
|
+
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3827
|
+
return unpackLevels(view.recordAt(ordinal), 0, dimension, bits);
|
|
4109
3828
|
},
|
|
4110
|
-
|
|
4111
|
-
|
|
3829
|
+
recordOf(docId) {
|
|
3830
|
+
const view = shared();
|
|
3831
|
+
const ordinal = store.getOrdinal(docId);
|
|
3832
|
+
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3833
|
+
return view.recordAt(ordinal);
|
|
4112
3834
|
},
|
|
4113
|
-
|
|
4114
|
-
|
|
4115
|
-
|
|
4116
|
-
|
|
4117
|
-
if (ord !== void 0) markTombstone(state, ord);
|
|
3835
|
+
recordAtOrdinal(ordinal) {
|
|
3836
|
+
const view = shared();
|
|
3837
|
+
if (view === null || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3838
|
+
return view.recordAt(ordinal);
|
|
4118
3839
|
},
|
|
4119
|
-
|
|
4120
|
-
|
|
4121
|
-
holdsTombstone: (ordinal) => hasNode(state.adjacency, ordinal) && isTombstoned(state, ordinal),
|
|
4122
|
-
has: (docId) => {
|
|
4123
|
-
const ord = store.getOrdinal(docId);
|
|
4124
|
-
return ord !== void 0 && hasNode(state.adjacency, ord) && !isTombstoned(state, ord);
|
|
3840
|
+
restoreRecord(docId, record) {
|
|
3841
|
+
requireShared().restoreRecord(ordinalOf(docId), record);
|
|
4125
3842
|
},
|
|
4126
|
-
|
|
4127
|
-
|
|
4128
|
-
return ord !== void 0 && isTombstoned(state, ord);
|
|
3843
|
+
restoreRecordAtOrdinal(ordinal, record) {
|
|
3844
|
+
requireShared().restoreRecord(ordinal, record);
|
|
4129
3845
|
},
|
|
4130
|
-
|
|
4131
|
-
|
|
4132
|
-
retire: () => Atomics.store(shared.header, GRAPH_RETIRED, 1),
|
|
4133
|
-
entries: entriesIterator,
|
|
4134
|
-
compactionNeeded,
|
|
4135
|
-
compactTombstones: () => exclusively(() => compactTombstones(state)),
|
|
4136
|
-
connectUnreached: () => exclusively(() => connectAfterBuild(state)),
|
|
4137
|
-
rebuild: () => exclusively(() => rebuild(state)),
|
|
4138
|
-
exclusively,
|
|
4139
|
-
deserialize: (data) => exclusively(() => deserializeGraph(state, store, data)),
|
|
4140
|
-
serializeNumbered: (numberOfOrdinal, ordinalOfNumber, partSize) => serializeNumberedGraphParts(state, numberOfOrdinal, ordinalOfNumber, partSize),
|
|
4141
|
-
deserializeNumbered: (graph, ordinalOfNumber) => exclusively(() => deserializeNumberedGraph(state, graph, ordinalOfNumber)),
|
|
4142
|
-
exportSnapshot: () => exportSnapshot(state),
|
|
4143
|
-
restoreSnapshot: (snapshot) => exclusively(() => restoreSnapshot(state, snapshot))
|
|
4144
|
-
};
|
|
4145
|
-
}
|
|
4146
|
-
|
|
4147
|
-
// src/vector/vector-index/persistence.ts
|
|
4148
|
-
function recordFor(state, quantizer, docId) {
|
|
4149
|
-
const record = quantizer.recordOf(docId);
|
|
4150
|
-
if (record !== void 0) return record;
|
|
4151
|
-
if (!state.store.has(docId)) return void 0;
|
|
4152
|
-
quantizer.quantize(docId);
|
|
4153
|
-
return quantizer.recordOf(docId);
|
|
4154
|
-
}
|
|
4155
|
-
function codedCentroid(state) {
|
|
4156
|
-
const centroid = state.osq?.centroid ?? null;
|
|
4157
|
-
if (centroid === null || state.store.handles.codeLayout === null || state.hnsw === null) return null;
|
|
4158
|
-
return Array.from(centroid);
|
|
4159
|
-
}
|
|
4160
|
-
function sameCentroid(state, planned) {
|
|
4161
|
-
const current = state.osq?.centroid ?? null;
|
|
4162
|
-
if (current === null || current.length !== planned.length) return false;
|
|
4163
|
-
for (let i = 0; i < planned.length; i++) {
|
|
4164
|
-
if (current[i] !== planned[i]) return false;
|
|
4165
|
-
}
|
|
4166
|
-
return true;
|
|
4167
|
-
}
|
|
4168
|
-
function codesAgainstPlannedCentroid(quantizer, slotStride, centroid, vectors, ordinals) {
|
|
4169
|
-
const planned = Float32Array.from(centroid);
|
|
4170
|
-
const dimension = planned.length;
|
|
4171
|
-
const scratch = createOsqScratch(dimension);
|
|
4172
|
-
const records = new Uint8Array(ordinals.length * slotStride);
|
|
4173
|
-
const trailer = new DataView(records.buffer, records.byteOffset, records.byteLength);
|
|
4174
|
-
for (let i = 0; i < ordinals.length; i++) {
|
|
4175
|
-
if (ordinals[i] === NO_LIVE_VECTOR_AT_POSITION) continue;
|
|
4176
|
-
const vector = vectors.subarray(i * dimension, (i + 1) * dimension);
|
|
4177
|
-
const code = osqQuantize(vector, planned, quantizer.bits, quantizer.metric, scratch);
|
|
4178
|
-
writeRecord(records, i * slotStride, code, quantizer.bits, trailer);
|
|
4179
|
-
}
|
|
4180
|
-
return { bits: quantizer.bits, centroid, records };
|
|
4181
|
-
}
|
|
4182
|
-
function partCodes(state, docIds, centroid, tombstonedAt, vectors, ordinals) {
|
|
4183
|
-
const quantizer = state.osq;
|
|
4184
|
-
const layout = state.store.handles.codeLayout;
|
|
4185
|
-
if (centroid === null || quantizer === null || layout === null) return null;
|
|
4186
|
-
if (!sameCentroid(state, centroid)) {
|
|
4187
|
-
return codesAgainstPlannedCentroid(quantizer, layout.slotStride, centroid, vectors, ordinals);
|
|
4188
|
-
}
|
|
4189
|
-
const records = new Uint8Array(docIds.length * layout.slotStride);
|
|
4190
|
-
for (let i = 0; i < docIds.length; i++) {
|
|
4191
|
-
const tombstoned = tombstonedAt.get(i);
|
|
4192
|
-
const record = tombstoned === void 0 ? recordFor(state, quantizer, docIds[i]) : quantizer.recordAtOrdinal(tombstoned);
|
|
4193
|
-
if (record !== void 0) records.set(record, i * layout.slotStride);
|
|
4194
|
-
}
|
|
4195
|
-
return { bits: quantizer.bits, centroid, records };
|
|
4196
|
-
}
|
|
4197
|
-
function splitSequences(parts) {
|
|
4198
|
-
const sequences = [];
|
|
4199
|
-
let current = null;
|
|
4200
|
-
for (const part of parts) {
|
|
4201
|
-
if (current === null || part.part === 0) {
|
|
4202
|
-
current = { docIds: [], graphs: [], codes: null, codesComplete: true };
|
|
4203
|
-
sequences.push(current);
|
|
4204
|
-
}
|
|
4205
|
-
current.docIds.push(...part.docIds);
|
|
4206
|
-
for (let index = 0; index < part.graphs.length; index++) {
|
|
4207
|
-
const graph = part.graphs[index];
|
|
4208
|
-
const held = current.graphs[index];
|
|
4209
|
-
if (held === void 0) current.graphs[index] = { ...graph, nodes: [...graph.nodes] };
|
|
4210
|
-
else held.nodes.push(...graph.nodes);
|
|
4211
|
-
}
|
|
4212
|
-
if (part.codes === null) {
|
|
4213
|
-
if (part.docIds.length > 0) current.codesComplete = false;
|
|
4214
|
-
continue;
|
|
4215
|
-
}
|
|
4216
|
-
if (current.codes === null) {
|
|
4217
|
-
current.codes = { bits: part.codes.bits, centroid: part.codes.centroid, records: part.codes.records };
|
|
4218
|
-
continue;
|
|
4219
|
-
}
|
|
4220
|
-
if (current.codes.bits !== part.codes.bits) {
|
|
4221
|
-
current.codesComplete = false;
|
|
4222
|
-
continue;
|
|
4223
|
-
}
|
|
4224
|
-
const joined = new Uint8Array(current.codes.records.length + part.codes.records.length);
|
|
4225
|
-
joined.set(current.codes.records, 0);
|
|
4226
|
-
joined.set(part.codes.records, current.codes.records.length);
|
|
4227
|
-
current.codes = { ...current.codes, records: joined };
|
|
4228
|
-
}
|
|
4229
|
-
return sequences;
|
|
4230
|
-
}
|
|
4231
|
-
function restoreCodes(state, sequences) {
|
|
4232
|
-
const quantizer = state.osq;
|
|
4233
|
-
const layout = state.store.handles.codeLayout;
|
|
4234
|
-
if (quantizer === null || layout === null) return;
|
|
4235
|
-
const usable = sequences.filter((sequence) => sequence.docIds.length > 0);
|
|
4236
|
-
const single = usable.length === 1 ? usable[0] : null;
|
|
4237
|
-
if (single === null || single.codes === null || !single.codesComplete || single.codes.bits !== quantizer.bits) {
|
|
4238
|
-
recalibrateFromStore(state);
|
|
4239
|
-
return;
|
|
4240
|
-
}
|
|
4241
|
-
quantizer.restoreCentroid(Float32Array.from(single.codes.centroid));
|
|
4242
|
-
const recordBytes = layout.slotStride;
|
|
4243
|
-
for (let i = 0; i < single.docIds.length; i++) {
|
|
4244
|
-
quantizer.restoreRecord(single.docIds[i], single.codes.records.subarray(i * recordBytes, (i + 1) * recordBytes));
|
|
4245
|
-
}
|
|
4246
|
-
}
|
|
4247
|
-
function restoreGraphs(state, graphs) {
|
|
4248
|
-
if (graphs.length === 0) {
|
|
4249
|
-
for (const docId of state.store.docIds()) {
|
|
4250
|
-
if (!state.tombstones.has(docId)) state.buffer.add(docId);
|
|
4251
|
-
}
|
|
4252
|
-
return;
|
|
4253
|
-
}
|
|
4254
|
-
const graphData = graphs[0];
|
|
4255
|
-
const restoredHnsw = createHNSWIndex(
|
|
4256
|
-
state.dimension,
|
|
4257
|
-
state.store,
|
|
4258
|
-
{
|
|
4259
|
-
m: graphData.m ?? state.hnswConfig?.m,
|
|
4260
|
-
efConstruction: graphData.efConstruction ?? state.hnswConfig?.efConstruction,
|
|
4261
|
-
metric: graphData.metric ?? state.hnswConfig?.metric
|
|
3846
|
+
restoreCentroid(centroid) {
|
|
3847
|
+
requireShared().writeCentroid(centroid);
|
|
4262
3848
|
},
|
|
4263
|
-
|
|
4264
|
-
|
|
4265
|
-
|
|
4266
|
-
|
|
4267
|
-
|
|
4268
|
-
|
|
4269
|
-
if (!restoredHnsw.has(nodeDocId) && state.store.has(nodeDocId)) restoredHnsw.insertNode(nodeDocId);
|
|
4270
|
-
}
|
|
4271
|
-
}
|
|
4272
|
-
for (const docId of state.store.docIds()) {
|
|
4273
|
-
if (state.tombstones.has(docId)) continue;
|
|
4274
|
-
if (!restoredHnsw.has(docId)) state.buffer.add(docId);
|
|
4275
|
-
}
|
|
4276
|
-
if (state.buffer.size > restoredHnsw.size) {
|
|
4277
|
-
adoptGraph(state, null);
|
|
4278
|
-
state.buffer.clear();
|
|
4279
|
-
for (const docId of state.store.docIds()) {
|
|
4280
|
-
if (!state.tombstones.has(docId)) state.buffer.add(docId);
|
|
4281
|
-
}
|
|
4282
|
-
}
|
|
4283
|
-
}
|
|
4284
|
-
function insertPart(state, part) {
|
|
4285
|
-
const dimension = state.dimension;
|
|
4286
|
-
const vectors = bytesToVectors(part.vectors);
|
|
4287
|
-
for (let i = 0; i < part.docIds.length; i++) {
|
|
4288
|
-
state.store.insert(part.docIds[i], vectors.subarray(i * dimension, (i + 1) * dimension));
|
|
4289
|
-
}
|
|
4290
|
-
}
|
|
4291
|
-
function deserialize(state, parts) {
|
|
4292
|
-
for (const part of parts) {
|
|
4293
|
-
if (part.dimension !== state.dimension) {
|
|
4294
|
-
throw new NarsilError(
|
|
4295
|
-
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
4296
|
-
`Payload dimension ${part.dimension} does not match index dimension ${state.dimension}`,
|
|
4297
|
-
{ expected: state.dimension, received: part.dimension }
|
|
4298
|
-
);
|
|
4299
|
-
}
|
|
4300
|
-
}
|
|
4301
|
-
const sequences = splitSequences(parts);
|
|
4302
|
-
const graphs = [];
|
|
4303
|
-
for (const sequence of sequences) {
|
|
4304
|
-
for (const graph of sequence.graphs) {
|
|
4305
|
-
if (graph.nodes.length > 0) graphs.push(graph);
|
|
4306
|
-
}
|
|
4307
|
-
}
|
|
4308
|
-
emptyFieldBeforeRestore(state);
|
|
4309
|
-
for (const part of parts) insertPart(state, part);
|
|
4310
|
-
if (state.osq !== null && osqBitsOf(state.quantizationMode) !== null && graphs.length > 0) {
|
|
4311
|
-
restoreCodes(state, sequences);
|
|
4312
|
-
}
|
|
4313
|
-
restoreGraphs(state, graphs);
|
|
4314
|
-
}
|
|
4315
|
-
|
|
4316
|
-
// src/vector/vector-index/checkpoint-plan.ts
|
|
4317
|
-
var ORDINAL_HOLDS_NO_NUMBER = -1;
|
|
4318
|
-
function vectorsPerFile(dimension, codeBits) {
|
|
4319
|
-
const recordBytes = codeBits === 1 || codeBits === 2 || codeBits === 4 || codeBits === 8 ? osqRecordBytes(dimension, codeBits) : 0;
|
|
4320
|
-
const docIdBytes = VECTOR_FILE_STRING_HEADER_BYTES + MAX_DOC_ID_LENGTH * 3;
|
|
4321
|
-
const perVector = dimension * 4 + recordBytes + docIdBytes;
|
|
4322
|
-
const overhead = VECTOR_FILE_FIXED_OVERHEAD_BYTES + dimension * VECTOR_FILE_CENTROID_BYTES_PER_COMPONENT;
|
|
4323
|
-
const fitting = Math.floor((MAX_FILE_BYTES - overhead) / perVector);
|
|
4324
|
-
return Math.max(1, Math.min(VECTOR_FILE_MAX_VECTORS, fitting));
|
|
4325
|
-
}
|
|
4326
|
-
function fileCapacityOf(state) {
|
|
4327
|
-
return vectorsPerFile(state.dimension, osqBitsOf(state.quantizationMode));
|
|
4328
|
-
}
|
|
4329
|
-
function calibrationOf(state) {
|
|
4330
|
-
if (codedCentroid(state) === null) return null;
|
|
4331
|
-
return Atomics.load(state.store.handles.header, STORE_CALIBRATION_GENERATION);
|
|
4332
|
-
}
|
|
4333
|
-
function signatureOf(state) {
|
|
4334
|
-
return { revision: state.revision, graphSize: state.hnsw?.size ?? -1, calibration: calibrationOf(state) };
|
|
4335
|
-
}
|
|
4336
|
-
function sameSignature(a, b) {
|
|
4337
|
-
return a !== null && a.revision === b.revision && a.graphSize === b.graphSize && a.calibration === b.calibration;
|
|
4338
|
-
}
|
|
4339
|
-
function registryMatches(state, listedKeys) {
|
|
4340
|
-
const listed = listedKeys ?? [];
|
|
4341
|
-
if (listed.length !== state.savedFiles.length) return false;
|
|
4342
|
-
return state.savedFiles.every((file, index) => file.key === listed[index]);
|
|
4343
|
-
}
|
|
4344
|
-
function isLive2(state, ordinal) {
|
|
4345
|
-
if (ordinal === NO_LIVE_VECTOR_AT_POSITION) return false;
|
|
4346
|
-
const docId = state.store.docIdForOrdinal(ordinal);
|
|
4347
|
-
return docId !== void 0 && !state.tombstones.has(docId);
|
|
4348
|
-
}
|
|
4349
|
-
function isGraphTombstone(state, ordinal) {
|
|
4350
|
-
return ordinal !== NO_LIVE_VECTOR_AT_POSITION && state.hnsw !== null && state.hnsw.holdsTombstone(ordinal);
|
|
4351
|
-
}
|
|
4352
|
-
function isCarried(state, ordinal) {
|
|
4353
|
-
return isLive2(state, ordinal) || isGraphTombstone(state, ordinal);
|
|
4354
|
-
}
|
|
4355
|
-
function carriedCountOf(state, file) {
|
|
4356
|
-
let carried = 0;
|
|
4357
|
-
for (let i = 0; i < file.ordinals.length; i++) if (isCarried(state, file.ordinals[i])) carried += 1;
|
|
4358
|
-
return carried;
|
|
4359
|
-
}
|
|
4360
|
-
function deadBitsOf(state, file) {
|
|
4361
|
-
return deadBitsWhere(file.ordinals.length, (position) => !isLive2(state, file.ordinals[position]));
|
|
4362
|
-
}
|
|
4363
|
-
function filesWorthKeeping(state, listed, calibration, carriedCounts) {
|
|
4364
|
-
const kept = [];
|
|
4365
|
-
for (const file of listed) {
|
|
4366
|
-
const carried = carriedCountOf(state, file);
|
|
4367
|
-
const deadWithoutNodeShare = file.ordinals.length === 0 ? 1 : 1 - carried / file.ordinals.length;
|
|
4368
|
-
if (file.calibration !== calibration || deadWithoutNodeShare > VECTOR_FILE_REPLACED_ABOVE_DEAD_SHARE) continue;
|
|
4369
|
-
kept.push(file);
|
|
4370
|
-
carriedCounts.push(carried);
|
|
4371
|
-
}
|
|
4372
|
-
return kept;
|
|
4373
|
-
}
|
|
4374
|
-
function absorbSmallerPartialFiles(kept, carriedCounts, vectorsToWrite, capacity) {
|
|
4375
|
-
let pending = vectorsToWrite;
|
|
4376
|
-
for (let index = kept.length - 1; index >= 0 && pending > 0; index--) {
|
|
4377
|
-
if (kept[index].ordinals.length >= capacity) continue;
|
|
4378
|
-
if (carriedCounts[index] > pending) return;
|
|
4379
|
-
pending += carriedCounts[index];
|
|
4380
|
-
kept.splice(index, 1);
|
|
4381
|
-
carriedCounts.splice(index, 1);
|
|
4382
|
-
}
|
|
4383
|
-
}
|
|
4384
|
-
function ordinalsOutsideOf(state, kept) {
|
|
4385
|
-
const slots = state.store.slots;
|
|
4386
|
-
const saved = new Uint8Array(slots);
|
|
4387
|
-
for (const file of kept) {
|
|
4388
|
-
for (let i = 0; i < file.ordinals.length; i++) {
|
|
4389
|
-
const ordinal = file.ordinals[i];
|
|
4390
|
-
if (ordinal !== NO_LIVE_VECTOR_AT_POSITION && ordinal < slots) saved[ordinal] = 1;
|
|
4391
|
-
}
|
|
4392
|
-
}
|
|
4393
|
-
const outside = [];
|
|
4394
|
-
for (let ordinal = 0; ordinal < slots; ordinal++) {
|
|
4395
|
-
if (saved[ordinal] === 0 && isCarried(state, ordinal)) outside.push(ordinal);
|
|
4396
|
-
}
|
|
4397
|
-
return outside;
|
|
4398
|
-
}
|
|
4399
|
-
function countOutside(state, carriedCounts) {
|
|
4400
|
-
let held = 0;
|
|
4401
|
-
for (const carried of carriedCounts) held += carried;
|
|
4402
|
-
const tombstonedNodes = state.hnsw?.tombstoneCount ?? 0;
|
|
4403
|
-
return Math.max(0, state.store.size - state.tombstones.size + tombstonedNodes - held);
|
|
4404
|
-
}
|
|
4405
|
-
function numberEveryVector(state, kept, written) {
|
|
4406
|
-
let total = written.length;
|
|
4407
|
-
for (const file of kept) total += file.ordinals.length;
|
|
4408
|
-
const numberOfOrdinal = new Int32Array(state.store.slots).fill(ORDINAL_HOLDS_NO_NUMBER);
|
|
4409
|
-
const ordinalOfNumber = new Int32Array(total).fill(NO_LIVE_VECTOR_AT_POSITION);
|
|
4410
|
-
let number = 0;
|
|
4411
|
-
for (const file of kept) {
|
|
4412
|
-
for (let i = 0; i < file.ordinals.length; i++, number++) {
|
|
4413
|
-
const ordinal = file.ordinals[i];
|
|
4414
|
-
if (!isCarried(state, ordinal)) continue;
|
|
4415
|
-
numberOfOrdinal[ordinal] = number;
|
|
4416
|
-
ordinalOfNumber[number] = ordinal;
|
|
4417
|
-
}
|
|
4418
|
-
}
|
|
4419
|
-
for (const ordinal of written) {
|
|
4420
|
-
numberOfOrdinal[ordinal] = number;
|
|
4421
|
-
ordinalOfNumber[number] = ordinal;
|
|
4422
|
-
number += 1;
|
|
4423
|
-
}
|
|
4424
|
-
return { numberOfOrdinal, ordinalOfNumber };
|
|
4425
|
-
}
|
|
4426
|
-
function withBuildHistory(state, graph) {
|
|
4427
|
-
const shuffledBuildCount = state.shuffledBuildCount;
|
|
4428
|
-
if (shuffledBuildCount === null) return graph;
|
|
4429
|
-
const calibratedMeanLength = state.calibratedMeanLength;
|
|
4430
|
-
if (calibratedMeanLength === null) return { ...graph, shuffledBuildCount };
|
|
4431
|
-
return { ...graph, shuffledBuildCount, calibratedMeanLength };
|
|
4432
|
-
}
|
|
4433
|
-
function graphPartsOf(state, numbers) {
|
|
4434
|
-
if (state.hnsw === null || numbers.ordinalOfNumber.length === 0) return null;
|
|
4435
|
-
const parts = state.hnsw.serializeNumbered(
|
|
4436
|
-
numbers.numberOfOrdinal,
|
|
4437
|
-
numbers.ordinalOfNumber,
|
|
4438
|
-
VECTOR_GRAPH_PART_VECTORS
|
|
4439
|
-
);
|
|
4440
|
-
return parts.map((graph) => ({
|
|
4441
|
-
v: VECTOR_GRAPH_PART_PAYLOAD_VERSION,
|
|
4442
|
-
fieldName: state.fieldName,
|
|
4443
|
-
graphs: [withBuildHistory(state, graph)]
|
|
4444
|
-
}));
|
|
4445
|
-
}
|
|
4446
|
-
function graphPartsWithoutNodes(parts, numbers) {
|
|
4447
|
-
return parts.map((part, index) => ({
|
|
4448
|
-
...part,
|
|
4449
|
-
graphs: part.graphs.map((graph) => graphWithoutNodes(graph, index * VECTOR_GRAPH_PART_VECTORS, numbers))
|
|
4450
|
-
}));
|
|
4451
|
-
}
|
|
4452
|
-
function plannedVectorOf(state, ordinal) {
|
|
4453
|
-
const docId = state.store.docIdForOrdinal(ordinal) ?? state.store.view.docIdAt(ordinal) ?? "";
|
|
4454
|
-
return { ordinal, docId, tombstoned: !isLive2(state, ordinal) };
|
|
4455
|
-
}
|
|
4456
|
-
function readFile(state, planned, centroid) {
|
|
4457
|
-
const dimension = state.dimension;
|
|
4458
|
-
const vectors = new Float32Array(planned.length * dimension);
|
|
4459
|
-
const ordinals = new Int32Array(planned.length).fill(NO_LIVE_VECTOR_AT_POSITION);
|
|
4460
|
-
const tombstonedAt = /* @__PURE__ */ new Map();
|
|
4461
|
-
const docIds = planned.map((vector) => vector.docId);
|
|
4462
|
-
for (let i = 0; i < planned.length; i++) {
|
|
4463
|
-
const { ordinal, docId, tombstoned } = planned[i];
|
|
4464
|
-
const held = tombstoned || state.store.holdsOrdinal(ordinal) ? ordinal : state.store.getOrdinal(docId);
|
|
4465
|
-
const entry = held === void 0 ? void 0 : state.store.entryForOrdinal(held);
|
|
4466
|
-
if (held === void 0 || entry === void 0) continue;
|
|
4467
|
-
vectors.set(entry.vector, i * dimension);
|
|
4468
|
-
ordinals[i] = held;
|
|
4469
|
-
if (tombstoned) tombstonedAt.set(i, held);
|
|
4470
|
-
}
|
|
4471
|
-
return {
|
|
4472
|
-
payload: {
|
|
4473
|
-
v: VECTOR_FILE_PAYLOAD_VERSION,
|
|
4474
|
-
fieldName: state.fieldName,
|
|
4475
|
-
dimension,
|
|
4476
|
-
docIds,
|
|
4477
|
-
codes: partCodes(state, docIds, centroid, tombstonedAt, vectors, ordinals),
|
|
4478
|
-
vectors: vectorsToBytes(vectors)
|
|
3849
|
+
recalibrate(ordinals) {
|
|
3850
|
+
if (ordinals.length === 0) return;
|
|
3851
|
+
const view = requireShared();
|
|
3852
|
+
view.resetCodes();
|
|
3853
|
+
view.calibrateFrom(ordinals);
|
|
3854
|
+
view.writeCodesOf(ordinals);
|
|
4479
3855
|
},
|
|
4480
|
-
|
|
4481
|
-
|
|
4482
|
-
};
|
|
4483
|
-
}
|
|
4484
|
-
function planCheckpoint(state, listedKeys, rewritesGraph = false) {
|
|
4485
|
-
const signature = signatureOf(state);
|
|
4486
|
-
const calibration = signature.calibration;
|
|
4487
|
-
const trusted = registryMatches(state, listedKeys);
|
|
4488
|
-
const capacity = fileCapacityOf(state);
|
|
4489
|
-
const carriedCounts = [];
|
|
4490
|
-
const keptFiles = filesWorthKeeping(state, trusted ? state.savedFiles : [], calibration, carriedCounts);
|
|
4491
|
-
absorbSmallerPartialFiles(keptFiles, carriedCounts, countOutside(state, carriedCounts), capacity);
|
|
4492
|
-
const written = ordinalsOutsideOf(state, keptFiles);
|
|
4493
|
-
const planned = written.map((ordinal) => plannedVectorOf(state, ordinal));
|
|
4494
|
-
const centroid = codedCentroid(state);
|
|
4495
|
-
const listedBefore = trusted && listedKeys !== null;
|
|
4496
|
-
const unchanged = !rewritesGraph && listedBefore && sameSignature(state.savedSignature, signature) && written.length === 0;
|
|
4497
|
-
let firstWrittenNumber = 0;
|
|
4498
|
-
for (const file of keptFiles) firstWrittenNumber += file.ordinals.length;
|
|
4499
|
-
const graphParts = unchanged ? null : graphPartsOf(state, numberEveryVector(state, keptFiles, written));
|
|
4500
|
-
const vanished = /* @__PURE__ */ new Set();
|
|
4501
|
-
let vanishedWhenStripped = 0;
|
|
4502
|
-
let graphPartsToWrite = graphParts;
|
|
4503
|
-
return {
|
|
4504
|
-
unchanged,
|
|
4505
|
-
keptFiles,
|
|
4506
|
-
kept: keptFiles.map((file) => ({
|
|
4507
|
-
id: file.id,
|
|
4508
|
-
key: file.key,
|
|
4509
|
-
count: file.ordinals.length,
|
|
4510
|
-
dead: deadBitsOf(state, file)
|
|
4511
|
-
})),
|
|
4512
|
-
newFiles: Math.ceil(written.length / capacity),
|
|
4513
|
-
get graphParts() {
|
|
4514
|
-
if (graphParts !== null && vanished.size !== vanishedWhenStripped) {
|
|
4515
|
-
graphPartsToWrite = graphPartsWithoutNodes(graphParts, vanished);
|
|
4516
|
-
vanishedWhenStripped = vanished.size;
|
|
4517
|
-
}
|
|
4518
|
-
return graphPartsToWrite;
|
|
3856
|
+
beginRecoding(centroid) {
|
|
3857
|
+
requireShared().beginRecoding(centroid);
|
|
4519
3858
|
},
|
|
4520
|
-
|
|
4521
|
-
|
|
4522
|
-
|
|
4523
|
-
|
|
4524
|
-
|
|
4525
|
-
|
|
4526
|
-
|
|
4527
|
-
|
|
4528
|
-
|
|
3859
|
+
recode(ordinal) {
|
|
3860
|
+
shared()?.recode(ordinal);
|
|
3861
|
+
},
|
|
3862
|
+
finishRecoding: () => shared()?.finishRecoding() ?? false,
|
|
3863
|
+
abandonRecoding() {
|
|
3864
|
+
shared()?.abandonRecoding();
|
|
3865
|
+
},
|
|
3866
|
+
prepareQuery: (query) => shared()?.prepareQuery(query) ?? null,
|
|
3867
|
+
distanceFromPreparedByOrdinal: (prepared, ordinal) => shared()?.distanceFromPreparedByOrdinal(prepared, ordinal) ?? Number.POSITIVE_INFINITY,
|
|
3868
|
+
preparedDistance(prepared) {
|
|
3869
|
+
const view = shared();
|
|
3870
|
+
if (view === null) return () => Number.POSITIVE_INFINITY;
|
|
3871
|
+
return view.preparedDistance(prepared);
|
|
3872
|
+
},
|
|
3873
|
+
pairDistance() {
|
|
3874
|
+
const view = shared();
|
|
3875
|
+
if (view === null) return () => Number.POSITIVE_INFINITY;
|
|
3876
|
+
return view.pairDistance();
|
|
3877
|
+
},
|
|
3878
|
+
placementDistance: (vector) => shared()?.placementDistance(vector) ?? null,
|
|
3879
|
+
clear() {
|
|
3880
|
+
const view = shared();
|
|
3881
|
+
if (view === null) return;
|
|
3882
|
+
view.resetCodes();
|
|
3883
|
+
view.resetCalibration();
|
|
4529
3884
|
}
|
|
4530
3885
|
};
|
|
4531
3886
|
}
|
|
4532
|
-
function recordCheckpoint(state, plan, written) {
|
|
4533
|
-
if (plan.unchanged) return;
|
|
4534
|
-
const calibration = plan.signature.calibration;
|
|
4535
|
-
state.savedFiles = [...plan.keptFiles, ...written.map((file) => ({ ...file, calibration }))];
|
|
4536
|
-
state.savedSignature = plan.signature;
|
|
4537
|
-
}
|
|
4538
3887
|
|
|
4539
|
-
export { BLOCK_MAX_BYTES,
|
|
3888
|
+
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, noteFallback, 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 };
|