@delali/narsil 0.3.1-next.131 → 0.3.1-next.141
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/adapters/filesystem.mjs +1 -1
- package/dist/adapters/indexeddb.mjs +1 -1
- package/dist/analysis-change-HQUT2Z3I.mjs +43 -0
- package/dist/analysis-change-entry-TZTG4AZB.mjs +1 -0
- package/dist/browser/analysis-change-JPV775LR.mjs +900 -0
- package/dist/browser/analysis-change-entry-7HR4LWL3.mjs +1 -0
- package/dist/browser/{chunk-UDGB2MWT.mjs → chunk-35B42UFM.mjs} +4 -0
- package/dist/browser/chunk-3ZBJYAS4.mjs +19 -0
- package/dist/browser/{chunk-2Y3CO4EQ.mjs → chunk-5DB2VDGI.mjs} +1149 -1853
- package/dist/browser/chunk-6RHTAVZX.mjs +656 -0
- package/dist/browser/chunk-CCOAOO73.mjs +86 -0
- package/dist/browser/{chunk-AIIJDWMG.mjs → chunk-D33A5VMU.mjs} +16 -16
- package/dist/browser/{chunk-VBBLTD7O.mjs → chunk-HKX2G6WH.mjs} +1520 -2159
- package/dist/browser/{chunk-NSCSR6MA.mjs → chunk-KTOK275N.mjs} +606 -830
- package/dist/browser/{chunk-D7WQF6DV.mjs → chunk-LVY2LI35.mjs} +2 -2
- package/dist/browser/chunk-MVM33ZUL.mjs +993 -0
- package/dist/browser/chunk-MWUK3DA5.mjs +2634 -0
- package/dist/browser/{chunk-VEGHFP2P.mjs → chunk-MZI3TEOW.mjs} +4 -2
- package/dist/browser/chunk-OIZS5KIX.mjs +6 -0
- package/dist/browser/chunk-R4WUDZQV.mjs +176 -0
- package/dist/browser/{chunk-M5UAAXGU.mjs → chunk-TCLEOZ4P.mjs} +3 -3
- package/dist/browser/chunk-VFYMPCOV.mjs +212 -0
- package/dist/browser/chunk-WCFCHIBB.mjs +177 -0
- package/dist/browser/chunk-XNWPP5NS.mjs +21 -0
- package/dist/browser/chunk-ZEV26AQ6.mjs +270 -0
- package/dist/browser/cold-module-MJMKNUYJ.mjs +745 -0
- package/dist/browser/{durability-wiring-FNZSRH4N.mjs → durability-wiring-SNOWIT6Z.mjs} +370 -95
- package/dist/browser/import-TLB2A5LJ.mjs +9 -0
- package/dist/browser/module-BUFNZMEU.mjs +12 -0
- package/dist/browser/{module-4HIMOQM5.mjs → module-BVP4TKZU.mjs} +397 -109
- package/dist/browser/{phrase-module-WESYVU7K.mjs → phrase-module-HGVBO24W.mjs} +1 -1
- package/dist/{restore-queue-JAMNRC6T.mjs → browser/restore-queue-ONYNYUDE.mjs} +8 -2
- package/dist/browser/{runtime-3X7ZJ5T3.mjs → runtime-VEUH674B.mjs} +2 -2
- package/dist/browser/{snapshot-V7VF6BN6.mjs → snapshot-QXBKHJAG.mjs} +135 -183
- package/dist/browser/{write-YIC2MKRY.mjs → write-WHFBDWQS.mjs} +64 -90
- package/dist/{capabilities-B6WxrWxt.d.ts → capabilities-BCdUwK_L.d.ts} +10 -3
- package/dist/chunk-46NZOPHS.mjs +21 -0
- package/dist/{chunk-JT3YZGCE.mjs → chunk-5WYVUPGD.mjs} +3 -188
- package/dist/chunk-6SNBQESJ.mjs +214 -0
- package/dist/{chunk-2C3WXBQS.mjs → chunk-74XB2SXI.mjs} +1 -1
- package/dist/chunk-7AUASRE7.mjs +653 -0
- package/dist/{chunk-NMXRXFGZ.mjs → chunk-AST3SHFA.mjs} +27 -25
- package/dist/chunk-BOJZGUS6.mjs +177 -0
- package/dist/{chunk-T4OFG4IQ.mjs → chunk-BRUUBXCB.mjs} +92 -17
- package/dist/{chunk-5LX6MOIB.mjs → chunk-C3YDYX6C.mjs} +1 -1
- package/dist/chunk-CZQ33DLW.mjs +78 -0
- package/dist/{chunk-4GDLFDPZ.mjs → chunk-DD2673TX.mjs} +3 -2
- package/dist/{chunk-EUCX5K74.mjs → chunk-DQNKVOJ2.mjs} +65 -65
- package/dist/{chunk-RNSC4NFI.mjs → chunk-EEBCDP36.mjs} +3 -1
- package/dist/chunk-FOCV4CBZ.mjs +87 -0
- package/dist/{chunk-HCGJKDZV.mjs → chunk-GLZHNSGB.mjs} +1 -1
- package/dist/chunk-GWOS5DYC.mjs +2637 -0
- package/dist/{chunk-PATMDIMN.mjs → chunk-HJJWY6PT.mjs} +1 -1
- package/dist/{chunk-CZ7ISLXA.mjs → chunk-HNHCNTVG.mjs} +4 -0
- package/dist/{chunk-Y2U5VVWX.mjs → chunk-ICW45TTU.mjs} +1 -1
- package/dist/{chunk-TGHNXN7W.mjs → chunk-IO5F7ZBE.mjs} +261 -948
- package/dist/{chunk-P36MUFEJ.mjs → chunk-JDDXV6UF.mjs} +2 -1
- package/dist/{chunk-7OIQ2SIO.mjs → chunk-KEIYVZUX.mjs} +5 -5
- package/dist/{chunk-PU6SKH7O.mjs → chunk-KGOXHLLZ.mjs} +7 -3
- package/dist/{chunk-WVRDRLIC.mjs → chunk-KZL72VTC.mjs} +70 -18
- package/dist/chunk-L76W3IZJ.mjs +193 -0
- package/dist/{chunk-2JWNJSNE.mjs → chunk-LA4WNDHL.mjs} +88 -801
- package/dist/{chunk-ZR4VM4A6.mjs → chunk-N37VMC62.mjs} +1 -18
- package/dist/{chunk-JJ6EUMXB.mjs → chunk-NJJCPFXN.mjs} +2 -2
- package/dist/chunk-NN33CZRE.mjs +86 -0
- package/dist/{chunk-2WBY4Y4M.mjs → chunk-NOT5QOHU.mjs} +1 -1
- package/dist/{chunk-D5TFRB5G.mjs → chunk-NPNK57CA.mjs} +1 -1
- package/dist/chunk-NRUXBYPH.mjs +121 -0
- package/dist/{chunk-6SSVIW7Y.mjs → chunk-O4LJQI4G.mjs} +31 -5
- package/dist/{chunk-UJWGQIXU.mjs → chunk-QHPYS427.mjs} +1 -0
- package/dist/{chunk-F6AAXI7T.mjs → chunk-RHKRTYGO.mjs} +13 -4
- package/dist/{chunk-2SEL6SBS.mjs → chunk-RKAVHNRW.mjs} +2 -2
- package/dist/{chunk-RCMNL7RI.mjs → chunk-SBMAWTRG.mjs} +41 -4
- package/dist/chunk-SRJBFG2T.mjs +881 -0
- package/dist/{chunk-X5CNUKD5.mjs → chunk-TNBIK2LQ.mjs} +1663 -1652
- package/dist/{chunk-NNO7CO3A.mjs → chunk-UIKN2OTQ.mjs} +1 -1
- package/dist/chunk-UUZCQQG2.mjs +209 -0
- package/dist/{chunk-6M6SDH3S.mjs → chunk-VEFN6X6Q.mjs} +8 -8
- package/dist/chunk-VJEGOELZ.mjs +177 -0
- package/dist/chunk-W2COJ5AH.mjs +148 -0
- package/dist/{chunk-RWESFSJI.mjs → chunk-WJGO5PGV.mjs} +317 -174
- package/dist/{chunk-7X5JST5L.mjs → chunk-WNBRW4Q2.mjs} +16 -2
- package/dist/{chunk-SZGRYEIC.mjs → chunk-XS2VM7UE.mjs} +3 -3
- package/dist/{chunk-Y4BVTQ53.mjs → chunk-XZ3SRNDJ.mjs} +25 -64
- package/dist/{chunk-K77FJXKS.mjs → chunk-YHUTF6EA.mjs} +474 -93
- package/dist/{chunk-OGLV4I3L.mjs → chunk-YLNSJQLX.mjs} +12 -7
- package/dist/{chunk-SOHMMNCH.mjs → chunk-Z4HFMYNX.mjs} +32 -27
- package/dist/{chunk-5W7AEVTH.mjs → chunk-ZMBFWQXN.mjs} +2 -2
- package/dist/{chunk-2MKX2SCO.mjs → chunk-ZPWS2SKJ.mjs} +297 -274
- package/dist/{chunk-7XY6VD7B.mjs → chunk-ZSWHPKGM.mjs} +1 -1
- package/dist/{client-gNAfaHcE.d.ts → client-B12YFALP.d.ts} +18 -3
- package/dist/client.d.ts +7 -7
- package/dist/client.mjs +11 -1
- package/dist/cold-module-4X7WJCFM.mjs +783 -0
- package/dist/{config-D1cDv3sE.d.ts → config-BhZxIeb1.d.ts} +10 -1
- package/dist/{config-CmYJO34X.d.ts → config-CIG5yDyg.d.ts} +2 -2
- package/dist/{direct-executor-HQ4QVDX7.mjs → direct-executor-7XOQ7VQP.mjs} +14 -14
- package/dist/distribution/coordinator/etcd.d.ts +2 -2
- package/dist/distribution/coordinator/etcd.mjs +1 -1
- package/dist/distribution/coordinator/in-memory.d.ts +2 -2
- package/dist/distribution/transport/grpc.mjs +1 -1
- package/dist/distribution.d.ts +24 -8
- package/dist/distribution.mjs +982 -211
- package/dist/{durability-wiring-S7OX2MAI.mjs → durability-wiring-324D2DDD.mjs} +362 -94
- package/dist/embeddings/openai.mjs +2 -2
- package/dist/{engine-m_Ddr1bz.d.ts → engine-CtzbHOmG.d.ts} +64 -7
- package/dist/import-OOBUW3RR.mjs +44 -0
- package/dist/{index-HYnqS1SE.d.ts → index-DsEurhSl.d.ts} +1 -1
- package/dist/index.browser.mjs +5 -5
- package/dist/index.d.ts +6 -6
- package/dist/index.mjs +22 -22
- package/dist/{long-query-thread-BSL25PD6.mjs → long-query-thread-4SW7RWDE.mjs} +15 -15
- package/dist/{module-2E4XYSGT.mjs → module-DXSJ5LT2.mjs} +378 -87
- package/dist/module-IYPLWHGC.mjs +48 -0
- package/dist/paged-partition-archive-HFP45PLU.mjs +269 -0
- package/dist/partial-words.mjs +5 -5
- package/dist/pattern.mjs +3 -3
- package/dist/persistence/durability/checkpoint-worker.d.ts +16 -1
- package/dist/persistence/durability/checkpoint-worker.mjs +28 -26
- package/dist/{phrase-module-JERF2IDG.mjs → phrase-module-5QHBD2VJ.mjs} +1 -1
- package/dist/react.d.ts +9 -9
- package/dist/react.mjs +4 -0
- package/dist/{rerank-DMMT4FZA.mjs → rerank-KTLC3E6N.mjs} +5 -5
- package/dist/rerankers/http.mjs +2 -2
- package/dist/{browser/restore-queue-GEZ54CA5.mjs → restore-queue-FEYAC4SB.mjs} +8 -2
- package/dist/{runtime-7MLQ7J64.mjs → runtime-DYV75DCB.mjs} +6 -6
- package/dist/{schema-BTXbHCqA.d.ts → schema-B-Runv0n.d.ts} +7 -0
- package/dist/server.d.ts +12 -10
- package/dist/server.mjs +54 -21
- package/dist/{snapshot-DOQLGGEX.mjs → snapshot-CGM65VCD.mjs} +101 -197
- package/dist/synonyms.mjs +6 -4
- package/dist/{tasks-Co8HfRD7.d.ts → tasks-CjRJRGTb.d.ts} +26 -8
- package/dist/{thread-SKO7CN3R.mjs → thread-KGNAIKPD.mjs} +14 -14
- package/dist/vector/search-worker.d.ts +1 -1
- package/dist/vector/search-worker.mjs +6 -5
- package/dist/workers/entry.mjs +8 -8
- package/dist/{write-ZKR7SNRT.mjs → write-2DZPEQL2.mjs} +82 -107
- package/openapi.json +114 -6
- package/package.json +12 -8
|
@@ -1,7 +1,6 @@
|
|
|
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 {
|
|
4
|
-
import { NarsilError, ErrorCodes } from './chunk-UDGB2MWT.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';
|
|
3
|
+
import { NarsilError, ErrorCodes } from './chunk-35B42UFM.mjs';
|
|
5
4
|
|
|
6
5
|
// src/vector/shared-buffers/growable.ts
|
|
7
6
|
function sharedMemoryAvailable() {
|
|
@@ -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 = "AGFzbQEAAAABIgVgA39/fwF9YAJ/fwF9YAN/f38Bf2ABewF/YAR/f39/AX8DDw4AAQAAAgIDAgIEAgQCAgUDAQABB6QBCgZtZW1vcnkCAAtkb3RfcHJvZHVjdAAACW1hZ25pdHVkZQABGnNxdWFyZWRfZXVjbGlkZWFuX2Rpc3RhbmNlAAISZXVjbGlkZWFuX2Rpc3RhbmNlAAMGZG90X3U4AAQJc3FkaXN0X3U4AAUMb3NxX2RvdF9iaXRzAAkRb3NxX2RvdF9iaXRzX3BhaXIACxNvc3FfZG90X25pYmJsZXNfNHg0AA0KqhQOygIEAX8EewF9BH8gAkFwcSEJIAJBfHEhCv0MAAAAAAAAAAAAAAAAAAAAACEEQQAhAwJAA0AgAyAJTw0BIAAgA0ECdGohCyABIANBAnRqIQwgBCAL/QAEACAM/QAEAP3mAf3kASEEIAUgC/0ABBAgDP0ABBD95gH95AEhBSAGIAv9AAQgIAz9AAQg/eYB/eQBIQYgByAL/QAEMCAM/QAEMP3mAf3kASEHIANBEGohAwwACwsCQANAIAMgCk8NASAEIAAgA0ECdGr9AAQAIAEgA0ECdGr9AAQA/eYB/eQBIQQgA0EEaiEDDAALCyAEIAX95AEgBiAH/eQB/eQBIQQgBP0fACAE/R8BkiAE/R8CIAT9HwOSkiEIAkADQCADIAJPDQEgCCAAIANBAnRqKgIAIAEgA0ECdGoqAgCUkiEIIANBAWohAwwACwsgCAupAQQBfwJ7AX0BfyABQXxxIQb9DAAAAAAAAAAAAAAAAAAAAAAhA0EAIQICQANAIAIgBk8NASAAIAJBAnRq/QAEACEEIAMgBCAE/eYB/eQBIQMgAkEEaiECDAALCyAD/R8AIAP9HwGSIAP9HwIgA/0fA5KSIQUCQANAIAIgAU8NASAFIAAgAkECdGoqAgAgACACQQJ0aioCAJSSIQUgAkEBaiECDAALCyAFkQvAAQUBfwJ7AX0BfwF9IAJBfHEhB/0MAAAAAAAAAAAAAAAAAAAAACEEQQAhAwJAA0AgAyAHTw0BIAAgA0ECdGr9AAQAIAEgA0ECdGr9AAQA/eUBIQUgBCAFIAX95gH95AEhBCADQQRqIQMMAAsLIAT9HwAgBP0fAZIgBP0fAiAE/R8DkpIhBgJAA0AgAyACTw0BIAAgA0ECdGoqAgAgASADQQJ0aioCAJMhCCAGIAggCJSSIQYgA0EBaiEDDAALCyAGCwsAIAAgASACEAKRC7QBAwF/A3sCfyACQXBxIQhBAP0RIQRBACEDAkADQCADIAhPDQEgACADav0ABAAhBSABIANq/QAEACEGIAQgBf2JASAG/YkB/boB/a4BIQQgBCAF/YoBIAb9igH9ugH9rgEhBCADQRBqIQMMAAsLIAT9GwAgBP0bAWogBP0bAiAE/RsDamohBwJAA0AgAyACTw0BIAcgACADai0AACABIANqLQAAbGohByADQQFqIQMMAAsLIAcLzQEDAX8FewN/IAJBcHEhC0EA/REhBEEAIQMCQANAIAMgC08NASAAIANq/QAEACEFIAEgA2r9AAQAIQYgBf2JASAG/YkB/ZEBIQcgBf2KASAG/YoB/ZEBIQggBCAHIAf9ugH9rgEhBCAEIAggCP26Af2uASEEIANBEGohAwwACwsgBP0bACAE/RsBaiAE/RsCIAT9GwNqaiEJAkADQCADIAJPDQEgACADai0AACABIANqLQAAayEKIAkgCiAKbGohCSADQQFqIQMMAAsLIAkLIQEBeyAA/X8hASAB/RsAIAH9GwFqIAH9GwIgAf0bA2pqC68CAwh/A3sBfyABIAJqIQggCCACaiEJIAkgAmohCiACQXBxIQUCQANAIAMgBU8NASADQYAQaiEGIAYgBUsEQCAFIQYLQQD9ECENA0AgACADav0ABAAhCyALIAogA2r9AAQA/U79YiEMIAwgDP1uIAsgCSADav0ABAD9Tv1i/W4hDCAMIAz9biALIAggA2r9AAQA/U79Yv1uIQwgDCAM/W4gCyABIANq/QAEAP1O/WL9biEMIA0gDP19/Y4BIQ0gA0EQaiEDIAMgBkkNAAsgByANEAZqIQcMAAsLAkADQCADIAJPDQEgACADai0AACEOQQAhBAJAA0AgBEEETw0BIAcgDiABIAIgBGxqIANqLQAAcWkgBHRqIQcgBEEBaiEEDAALCyADQQFqIQMMAAsLIAcL2AIDCH8DewF/IAEgAmohCCAIIAJqIQkgCSACaiEKQQP9DyEMIAJBcHEhBQJAA0AgAyAFTw0BIANBgBBqIQYgBiAFSwRAIAUhBgtBAP0QIQ0DQCAAIANq/QAEACAM/Q0BAAMCBQQHBgkICwoNDA8OIQsgDSALIAz9TiABIANq/QAEAP2VASALQQL9jQEgDP1OIAggA2r9AAQA/ZUB/Y4BQQj9jQEgC0EE/Y0BIAz9TiAJIANq/QAEAP2VASALQQb9jQEgDP1OIAogA2r9AAQA/ZUB/Y4BQQj9jQH9jgH9jgEhDSADQRBqIQMgAyAGSQ0ACyAHIA0QBmohBwwACwsCQANAIAMgAk8NASAAIANqLQAAIQ5BACEEAkADQCAEQQRPDQEgByAOIARBAXR2QQNxIAEgAiAEbGogA2otAABsaiEHIARBAWohBAwACwsgA0EBaiEDDAALCyAHCxsAIANBAkYEfyAAIAEgAhAIBSAAIAEgAhAHCwueAQIEfwF7IAJBcHEhBAJAA0AgAyAETw0BIANBgBBqIQUgBSAESwRAIAQhBQtBAP0QIQcDQCAHIAAgA2r9AAQAIAEgA2r9AAQA/U79Yv19/Y4BIQcgA0EQaiEDIAMgBUkNAAsgBiAHEAZqIQYMAAsLAkADQCADIAJPDQEgBiAAIANqLQAAIAEgA2otAABxaWohBiADQQFqIQMMAAsLIAYLGwAgA0ECRgR/IAAgASACEAwFIAAgASACEAoLC9oCAwR/CHsEf0HVACERQdUAIRJB1QD9DyEHQaoB/Q8hCCACQXBxIQQCQANAIAMgBE8NASADQeADaiEFIAUgBEsEQCAEIQULQQD9DyEOQQD9DyEMQQD9DyENA0AgACADav0ABAAhCSABIANq/QAEACEKIAkgCv1OIQsgDiAL/WL9biEOIAwgCyAI/U79Yv1uIQwgDSAJIApBAf1tIAf9TiAKQQH9ayAI/U79UP1O/WL9biENIANBEGohAyADIAVJDQALIAYgDv19EAYgDP19EAZBA2wgDf19EAZBAXRqamohBgwACwsCQANAIAMgAk8NASAAIANqLQAAIQ8gASADai0AACEQIAYgDyARcSAQcWkgDyARcSAQQQF2IBJxcWlBAXRqIA9BAXYgEnEgECARcXFpQQF0IA9BAXYgEnEgEEEBdiAScXFpQQJ0ampqIQYgA0EBaiEDDAALCyAGC/wBAwN/CHsCfyACQXBxIQRBD/0PIQxBAP0RIQ1BACEDAkADQCADIARPDQEgACADav0ABAAhBiABIANq/QAEACEHIAYgDP1OIQggBkEE/W0hCSAHIAz9TiEKIAdBBP1tIQsgDSAIIAr9ngEgCSAL/Z4B/Y4B/X8gCCAK/Z8BIAkgC/2fAf2OAf1//a4B/a4BIQ0gA0EQaiEDDAALCyAN/RsAIA39GwFqIA39GwIgDf0bA2pqIQUCQANAIAMgAk8NASAAIANqLQAAIQ8gASADai0AACEOIAUgD0EPcSAOQQ9xbCAPQQR2IA5BBHZsamohBSADQQFqIQMMAAsLIAUL";
|
|
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,129 +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
|
-
|
|
943
|
-
|
|
644
|
+
// src/vector/native/backend.ts
|
|
645
|
+
var nativeSearchCoreEnabled = true;
|
|
646
|
+
function nativeSearchCoreIsEnabled() {
|
|
647
|
+
return nativeSearchCoreEnabled;
|
|
944
648
|
}
|
|
945
|
-
function
|
|
946
|
-
|
|
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
|
+
);
|
|
947
656
|
}
|
|
948
|
-
function
|
|
949
|
-
return Atomics.load(state.header, GRAPH_NODE_COUNT);
|
|
657
|
+
function noteFallback(operation) {
|
|
950
658
|
}
|
|
951
|
-
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
|
|
957
|
-
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
const next = new Uint32Array(capacity);
|
|
963
|
-
next.set(state.visited);
|
|
964
|
-
state.visited = next;
|
|
965
|
-
}
|
|
966
|
-
function nextVisitStamp(state) {
|
|
967
|
-
state.visitStamp++;
|
|
968
|
-
if (state.visitStamp === 4294967295) {
|
|
969
|
-
state.visited.fill(0);
|
|
970
|
-
state.visitStamp = 1;
|
|
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"));
|
|
971
670
|
}
|
|
972
|
-
|
|
973
|
-
|
|
974
|
-
|
|
975
|
-
|
|
976
|
-
|
|
977
|
-
|
|
978
|
-
return ord < state.tombstones.length;
|
|
979
|
-
}
|
|
980
|
-
function isTombstoned(state, ord) {
|
|
981
|
-
return ord >= 0 && reachTombstone(state, ord) && state.tombstones[ord] === 1;
|
|
982
|
-
}
|
|
983
|
-
function nodeExists(state, ord) {
|
|
984
|
-
return hasNode(state.adjacency, ord);
|
|
985
|
-
}
|
|
986
|
-
function nodeMaxLayer(state, ord) {
|
|
987
|
-
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;
|
|
988
677
|
}
|
|
989
|
-
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
995
|
-
|
|
996
|
-
|
|
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);
|
|
997
686
|
}
|
|
687
|
+
} catch {
|
|
688
|
+
wasmExports = null;
|
|
689
|
+
f32View = null;
|
|
998
690
|
}
|
|
999
|
-
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
|
|
1004
|
-
|
|
1005
|
-
|
|
1006
|
-
|
|
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);
|
|
1007
702
|
}
|
|
1008
703
|
}
|
|
1009
|
-
function
|
|
1010
|
-
|
|
1011
|
-
|
|
1012
|
-
|
|
704
|
+
function getF32View() {
|
|
705
|
+
if (!f32View) {
|
|
706
|
+
throw new Error("SIMD memory is not initialized");
|
|
707
|
+
}
|
|
708
|
+
return f32View;
|
|
1013
709
|
}
|
|
1014
|
-
function
|
|
1015
|
-
|
|
710
|
+
function copyOneVector(a) {
|
|
711
|
+
getF32View().set(a, 0);
|
|
1016
712
|
}
|
|
1017
|
-
function
|
|
1018
|
-
|
|
713
|
+
function copyTwoVectors(a, b) {
|
|
714
|
+
const view = getF32View();
|
|
715
|
+
view.set(a, 0);
|
|
716
|
+
view.set(b, OFFSET_B_BYTES / 4);
|
|
1019
717
|
}
|
|
1020
|
-
function
|
|
1021
|
-
|
|
1022
|
-
|
|
1023
|
-
|
|
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);
|
|
1024
723
|
}
|
|
1025
|
-
function
|
|
1026
|
-
|
|
1027
|
-
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
return (aOrd, bOrd) => {
|
|
1031
|
-
const estimated = codeDistance(aOrd, bOrd);
|
|
1032
|
-
return estimated === Number.POSITIVE_INFINITY ? storeDistance(aOrd, bOrd) : estimated;
|
|
1033
|
-
};
|
|
724
|
+
function simdMagnitude(a) {
|
|
725
|
+
if (!wasmExports || !f32View) return null;
|
|
726
|
+
ensureMemory(a.length);
|
|
727
|
+
copyOneVector(a);
|
|
728
|
+
return wasmExports.magnitude(0, a.length);
|
|
1034
729
|
}
|
|
1035
|
-
function
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
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);
|
|
1039
735
|
}
|
|
1040
|
-
|
|
1041
|
-
|
|
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;
|
|
1042
751
|
}
|
|
1043
|
-
function
|
|
1044
|
-
|
|
1045
|
-
|
|
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;
|
|
1046
764
|
}
|
|
1047
|
-
connections.push(ord);
|
|
1048
765
|
}
|
|
1049
|
-
|
|
1050
|
-
|
|
1051
|
-
|
|
1052
|
-
|
|
1053
|
-
|
|
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;
|
|
1054
781
|
}
|
|
1055
|
-
function
|
|
1056
|
-
|
|
1057
|
-
|
|
1058
|
-
|
|
1059
|
-
|
|
1060
|
-
|
|
1061
|
-
|
|
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
|
+
}
|
|
1062
805
|
}
|
|
1063
|
-
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);
|
|
1064
814
|
}
|
|
1065
815
|
|
|
1066
816
|
// src/vector/vector-store/blocks.ts
|
|
@@ -1570,28 +1320,197 @@ function nativeConnect(state, field, metric, nearby) {
|
|
|
1570
1320
|
return writeToTheGraph(state, field, connect) === NATIVE_OK;
|
|
1571
1321
|
}
|
|
1572
1322
|
|
|
1573
|
-
// src/vector/
|
|
1574
|
-
function
|
|
1575
|
-
|
|
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);
|
|
1576
1332
|
}
|
|
1577
|
-
function
|
|
1578
|
-
|
|
1333
|
+
function cosineSimilarityWithMagnitudes(a, b, magA, magB) {
|
|
1334
|
+
if (magA === 0 || magB === 0) return 0;
|
|
1335
|
+
return dotProduct(a, b) / (magA * magB);
|
|
1579
1336
|
}
|
|
1580
|
-
function
|
|
1581
|
-
|
|
1582
|
-
|
|
1583
|
-
|
|
1584
|
-
|
|
1585
|
-
|
|
1586
|
-
|
|
1587
|
-
|
|
1588
|
-
|
|
1589
|
-
|
|
1590
|
-
|
|
1591
|
-
|
|
1592
|
-
|
|
1593
|
-
|
|
1594
|
-
|
|
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
|
+
|
|
1492
|
+
// src/vector/hnsw/workspace.ts
|
|
1493
|
+
function createList(capacity) {
|
|
1494
|
+
return { ords: new Int32Array(capacity), distances: new Float64Array(capacity), size: 0 };
|
|
1495
|
+
}
|
|
1496
|
+
function createHeap(greatestFirst) {
|
|
1497
|
+
return { ...createList(INITIAL_LIST_CAPACITY), greatestFirst, topOrd: -1, topDistance: 0 };
|
|
1498
|
+
}
|
|
1499
|
+
function createHNSWWorkspace() {
|
|
1500
|
+
return {
|
|
1501
|
+
frontier: createHeap(false),
|
|
1502
|
+
found: createHeap(true),
|
|
1503
|
+
entryPoints: new Int32Array(INITIAL_LIST_CAPACITY),
|
|
1504
|
+
entryPointCount: 0,
|
|
1505
|
+
traversal: createList(INITIAL_LIST_CAPACITY),
|
|
1506
|
+
working: createList(INITIAL_LIST_CAPACITY),
|
|
1507
|
+
linkSelections: [],
|
|
1508
|
+
pruneCandidates: createList(INITIAL_LIST_CAPACITY),
|
|
1509
|
+
pruneSelection: createList(INITIAL_LIST_CAPACITY),
|
|
1510
|
+
repairCandidates: createList(INITIAL_LIST_CAPACITY),
|
|
1511
|
+
repairSelection: createList(INITIAL_LIST_CAPACITY),
|
|
1512
|
+
droppedLinks: createList(INITIAL_LIST_CAPACITY)
|
|
1513
|
+
};
|
|
1595
1514
|
}
|
|
1596
1515
|
function linkSelectionsFor(workspace, layers) {
|
|
1597
1516
|
const selections = workspace.linkSelections;
|
|
@@ -2096,6 +2015,42 @@ function countIncomingBeforeWriting(state, holdsGraphLock) {
|
|
|
2096
2015
|
}
|
|
2097
2016
|
}
|
|
2098
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
|
+
|
|
2099
2054
|
// src/vector/hnsw/graph-ops.ts
|
|
2100
2055
|
function readNeighborsLocked(state, ord, layer) {
|
|
2101
2056
|
for (; ; ) {
|
|
@@ -2232,17 +2187,6 @@ function everyCandidateWasHeld() {
|
|
|
2232
2187
|
return true;
|
|
2233
2188
|
}
|
|
2234
2189
|
|
|
2235
|
-
// src/vector/hnsw/insertion-order.ts
|
|
2236
|
-
function shuffleInPlace(items) {
|
|
2237
|
-
for (let i = items.length - 1; i > 0; i--) {
|
|
2238
|
-
const j = Math.floor(Math.random() * (i + 1));
|
|
2239
|
-
const held = items[i];
|
|
2240
|
-
items[i] = items[j];
|
|
2241
|
-
items[j] = held;
|
|
2242
|
-
}
|
|
2243
|
-
return items;
|
|
2244
|
-
}
|
|
2245
|
-
|
|
2246
2190
|
// src/vector/hnsw/mutation.ts
|
|
2247
2191
|
function clearTombstone(state, ord) {
|
|
2248
2192
|
if (!reachTombstone(state, ord) || Atomics.load(state.tombstones, ord) !== 1) return;
|
|
@@ -2370,7 +2314,7 @@ function writeRecordBeforePlacement(state, ord) {
|
|
|
2370
2314
|
function placeThroughTheCore(state, ord, holdsGraphLock) {
|
|
2371
2315
|
let field = nativeFieldFor();
|
|
2372
2316
|
if (field === null) return false;
|
|
2373
|
-
const level2 =
|
|
2317
|
+
const level2 = levelOfOrdinal(ord, state.mL);
|
|
2374
2318
|
for (let request = 0; request < PLACEMENT_ROOM_REQUESTS && field !== null; request++) {
|
|
2375
2319
|
ensureUpperRoom(state.adjacency, level2);
|
|
2376
2320
|
const placement = nativePlace(state, field, state.buildMetric, ord, level2, holdsGraphLock);
|
|
@@ -2396,7 +2340,7 @@ function insertNode(state, ord, holdsGraphLock = false) {
|
|
|
2396
2340
|
if (!holdsGraphLock) lockGraphShared(state.locks);
|
|
2397
2341
|
try {
|
|
2398
2342
|
clearTombstone(state, ord);
|
|
2399
|
-
const level2 =
|
|
2343
|
+
const level2 = levelOfOrdinal(ord, state.mL);
|
|
2400
2344
|
createNode(state.adjacency, ord, level2);
|
|
2401
2345
|
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
2402
2346
|
if (!claimEntryIfEmpty(state, ord, level2)) linkNode(state, ord, level2);
|
|
@@ -2525,652 +2469,1107 @@ function rebuild(state) {
|
|
|
2525
2469
|
connectAfterBuild(state);
|
|
2526
2470
|
}
|
|
2527
2471
|
|
|
2528
|
-
// src/vector/
|
|
2529
|
-
|
|
2530
|
-
|
|
2531
|
-
|
|
2532
|
-
|
|
2533
|
-
|
|
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;
|
|
2486
|
+
}
|
|
2534
2487
|
}
|
|
2535
|
-
function
|
|
2536
|
-
const
|
|
2537
|
-
|
|
2538
|
-
|
|
2539
|
-
|
|
2540
|
-
|
|
2541
|
-
|
|
2542
|
-
|
|
2543
|
-
query,
|
|
2544
|
-
nativeMetricCode(metric),
|
|
2545
|
-
candidateCount,
|
|
2546
|
-
state.locks.threadSlot,
|
|
2547
|
-
store.ordinals,
|
|
2548
|
-
store.distances,
|
|
2549
|
-
filter === void 0 ? null : filter.bits
|
|
2550
|
-
);
|
|
2551
|
-
} catch (error) {
|
|
2552
|
-
stopUsingTheNativeSearchCore(error);
|
|
2553
|
-
return false;
|
|
2488
|
+
function littleEndianBytesOf(values) {
|
|
2489
|
+
const bytes = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
|
|
2490
|
+
if (!LITTLE_ENDIAN) swapEveryValue(bytes);
|
|
2491
|
+
return bytes;
|
|
2492
|
+
}
|
|
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));
|
|
2554
2496
|
}
|
|
2555
|
-
|
|
2556
|
-
|
|
2557
|
-
return
|
|
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);
|
|
2558
2500
|
}
|
|
2559
|
-
function
|
|
2560
|
-
|
|
2561
|
-
|
|
2562
|
-
const ordinals = store.ordinals;
|
|
2563
|
-
let kept = 0;
|
|
2564
|
-
for (let i = 0; i < candidates.size && kept < nearest; i++) {
|
|
2565
|
-
const ord = candidates.ords[i];
|
|
2566
|
-
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2567
|
-
ordinals[kept++] = ord;
|
|
2568
|
-
}
|
|
2569
|
-
const distances = nativeScores(store, query, metric, kept);
|
|
2570
|
-
if (distances === null) return null;
|
|
2571
|
-
const hits = [];
|
|
2572
|
-
for (let i = 0; i < kept; i++) {
|
|
2573
|
-
if (distances[i] === Number.POSITIVE_INFINITY) continue;
|
|
2574
|
-
const score = toScore(distances[i], metric);
|
|
2575
|
-
if (score < minSimilarity) continue;
|
|
2576
|
-
hits.push({ ord: ordinals[i], score });
|
|
2577
|
-
}
|
|
2578
|
-
return hits;
|
|
2501
|
+
function savedTopLayer(state, ordinal) {
|
|
2502
|
+
if (ordinal === NO_ORDINAL) return NO_LAYER;
|
|
2503
|
+
return Math.min(nodeMaxLayer(state, ordinal), MAX_LAYER_CAP);
|
|
2579
2504
|
}
|
|
2580
|
-
|
|
2581
|
-
|
|
2582
|
-
|
|
2583
|
-
|
|
2584
|
-
|
|
2585
|
-
|
|
2586
|
-
middle: 75,
|
|
2587
|
-
wide: 0
|
|
2588
|
-
};
|
|
2589
|
-
var DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT = 18;
|
|
2590
|
-
var DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS = {
|
|
2591
|
-
1: 3,
|
|
2592
|
-
2: 3,
|
|
2593
|
-
4: 1,
|
|
2594
|
-
8: 1
|
|
2595
|
-
};
|
|
2596
|
-
var DEFAULT_RESCORE_DEPTH_BY_BITS = {
|
|
2597
|
-
1: {
|
|
2598
|
-
narrow: { perLimit: 3.23, perSquareRootOfLimit: 55.9 },
|
|
2599
|
-
middle: { perLimit: 2.2, perSquareRootOfLimit: 27 },
|
|
2600
|
-
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2601
|
-
},
|
|
2602
|
-
2: {
|
|
2603
|
-
narrow: { perLimit: 2.6, perSquareRootOfLimit: 22.5 },
|
|
2604
|
-
middle: { perLimit: 1, perSquareRootOfLimit: 16 },
|
|
2605
|
-
wide: { perLimit: 3, perSquareRootOfLimit: 0 }
|
|
2606
|
-
},
|
|
2607
|
-
4: {
|
|
2608
|
-
narrow: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2609
|
-
middle: { perLimit: 5, perSquareRootOfLimit: 0 },
|
|
2610
|
-
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
2611
|
-
},
|
|
2612
|
-
8: {
|
|
2613
|
-
narrow: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2614
|
-
middle: { perLimit: 2, perSquareRootOfLimit: 0 },
|
|
2615
|
-
wide: { perLimit: 2, perSquareRootOfLimit: 0 }
|
|
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;
|
|
2616
2511
|
}
|
|
2617
|
-
|
|
2618
|
-
|
|
2619
|
-
// src/vector/search-depth/index.ts
|
|
2620
|
-
function dimensionBand(dimension) {
|
|
2621
|
-
if (dimension < NARROW_DIMENSION_LIMIT) return "narrow";
|
|
2622
|
-
return dimension < WIDE_DIMENSION_LIMIT ? "middle" : "wide";
|
|
2623
|
-
}
|
|
2624
|
-
function defaultRescoreDepth(bits, dimension, k) {
|
|
2625
|
-
const band = dimensionBand(dimension);
|
|
2626
|
-
const { perLimit, perSquareRootOfLimit } = DEFAULT_RESCORE_DEPTH_BY_BITS[bits][band];
|
|
2627
|
-
const floor = DEFAULT_RESCORE_DEPTH_FLOOR_PER_LIMIT_BY_BITS[bits] * k;
|
|
2628
|
-
const depth = Math.max(floor, Math.ceil(perLimit * k + perSquareRootOfLimit * Math.sqrt(k)));
|
|
2629
|
-
if (bits !== 2 || band !== "middle") return depth;
|
|
2630
|
-
const withinDefaultWalk = Math.min(
|
|
2631
|
-
k + DEFAULT_EF_SEARCH_MARGIN_BY_BAND.middle,
|
|
2632
|
-
Math.ceil(k + DEFAULT_OSQ2_MIDDLE_RESCORE_DEPTH_WITHIN_WALK_PER_SQUARE_ROOT_OF_LIMIT * Math.sqrt(k))
|
|
2633
|
-
);
|
|
2634
|
-
return Math.max(depth, withinDefaultWalk);
|
|
2635
|
-
}
|
|
2636
|
-
function defaultEfSearch(dimension, k) {
|
|
2637
|
-
return Math.max(DEFAULT_EF_SEARCH, k + DEFAULT_EF_SEARCH_MARGIN_BY_BAND[dimensionBand(dimension)]);
|
|
2512
|
+
return values;
|
|
2638
2513
|
}
|
|
2639
|
-
|
|
2640
|
-
|
|
2641
|
-
|
|
2642
|
-
const
|
|
2643
|
-
const
|
|
2644
|
-
|
|
2645
|
-
|
|
2646
|
-
|
|
2647
|
-
|
|
2648
|
-
|
|
2649
|
-
|
|
2650
|
-
|
|
2651
|
-
|
|
2652
|
-
|
|
2653
|
-
|
|
2654
|
-
|
|
2655
|
-
|
|
2656
|
-
|
|
2657
|
-
|
|
2658
|
-
|
|
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;
|
|
2659
2538
|
}
|
|
2660
2539
|
}
|
|
2661
|
-
|
|
2662
|
-
|
|
2663
|
-
|
|
2664
|
-
|
|
2665
|
-
|
|
2666
|
-
|
|
2667
|
-
|
|
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);
|
|
2668
2549
|
}
|
|
2669
|
-
|
|
2670
|
-
|
|
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) });
|
|
2671
2565
|
}
|
|
2672
|
-
|
|
2673
|
-
|
|
2674
|
-
|
|
2675
|
-
|
|
2676
|
-
|
|
2677
|
-
|
|
2678
|
-
|
|
2679
|
-
|
|
2680
|
-
|
|
2681
|
-
|
|
2682
|
-
|
|
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;
|
|
2683
2580
|
}
|
|
2684
|
-
|
|
2685
|
-
|
|
2686
|
-
unlockGraphShared(state.locks);
|
|
2581
|
+
kept.set(values.subarray(start, cursor), length);
|
|
2582
|
+
length += cursor - start;
|
|
2687
2583
|
}
|
|
2688
|
-
|
|
2584
|
+
const entryPoint = part.entryPoint !== null && numbers.has(part.entryPoint) ? null : part.entryPoint;
|
|
2585
|
+
return { ...part, entryPoint, levels, neighbours: littleEndianBytesOf(kept.subarray(0, length)) };
|
|
2689
2586
|
}
|
|
2690
|
-
function
|
|
2691
|
-
|
|
2587
|
+
function endsInsideAList() {
|
|
2588
|
+
throw new NarsilError(
|
|
2589
|
+
ErrorCodes.PERSISTENCE_LOAD_FAILED,
|
|
2590
|
+
"Invalid vector graph payload: neighbours ends inside a list"
|
|
2591
|
+
);
|
|
2692
2592
|
}
|
|
2693
|
-
function
|
|
2694
|
-
const
|
|
2695
|
-
|
|
2696
|
-
|
|
2697
|
-
|
|
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
|
+
}
|
|
2698
2604
|
}
|
|
2699
|
-
return resolved;
|
|
2700
2605
|
}
|
|
2701
|
-
function
|
|
2702
|
-
|
|
2703
|
-
|
|
2704
|
-
|
|
2705
|
-
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;
|
|
2706
2611
|
}
|
|
2707
|
-
function
|
|
2708
|
-
|
|
2709
|
-
|
|
2710
|
-
|
|
2711
|
-
|
|
2712
|
-
|
|
2713
|
-
|
|
2714
|
-
|
|
2715
|
-
}
|
|
2716
|
-
const taken = [];
|
|
2717
|
-
for (const hit of ordered) {
|
|
2718
|
-
if (taken.length >= k && hit.score < taken[k - 1].score) break;
|
|
2719
|
-
const docId = docIdOf(hit.ord);
|
|
2720
|
-
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
|
+
}
|
|
2721
2620
|
}
|
|
2722
|
-
return
|
|
2621
|
+
return highest;
|
|
2723
2622
|
}
|
|
2724
|
-
function
|
|
2725
|
-
|
|
2726
|
-
|
|
2727
|
-
|
|
2728
|
-
|
|
2729
|
-
|
|
2730
|
-
|
|
2731
|
-
|
|
2732
|
-
|
|
2733
|
-
|
|
2734
|
-
|
|
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
|
+
}
|
|
2735
2667
|
}
|
|
2736
|
-
const
|
|
2737
|
-
const
|
|
2738
|
-
const
|
|
2739
|
-
|
|
2740
|
-
const
|
|
2741
|
-
|
|
2742
|
-
|
|
2743
|
-
|
|
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);
|
|
2744
2676
|
}
|
|
2745
|
-
|
|
2746
|
-
|
|
2747
|
-
|
|
2748
|
-
|
|
2749
|
-
|
|
2750
|
-
|
|
2751
|
-
|
|
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 });
|
|
2752
2702
|
}
|
|
2753
|
-
return
|
|
2703
|
+
return { nodes, maxOrd };
|
|
2754
2704
|
}
|
|
2755
|
-
function
|
|
2756
|
-
|
|
2757
|
-
|
|
2758
|
-
|
|
2759
|
-
|
|
2760
|
-
const score = toScore(candidates.distances[i], metric);
|
|
2761
|
-
if (score < minSimilarity) continue;
|
|
2762
|
-
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);
|
|
2763
2710
|
}
|
|
2764
|
-
|
|
2765
|
-
|
|
2766
|
-
|
|
2767
|
-
|
|
2768
|
-
|
|
2769
|
-
|
|
2770
|
-
if (rescored !== null) return rescored;
|
|
2771
|
-
const arena = state.store.prepareQueryArena(query);
|
|
2772
|
-
const qMag2 = arena ? arena.magnitude : magnitude(query);
|
|
2773
|
-
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);
|
|
2774
2717
|
}
|
|
2775
|
-
|
|
2776
|
-
|
|
2777
|
-
|
|
2778
|
-
|
|
2779
|
-
|
|
2780
|
-
let taken = 0;
|
|
2781
|
-
for (let i = 0; i < candidates.size && taken < depth; i++) {
|
|
2782
|
-
const ord = candidates.ords[i];
|
|
2783
|
-
if (filter && !ordinalFilterHas(filter, ord)) continue;
|
|
2784
|
-
taken += 1;
|
|
2785
|
-
let fullDistance;
|
|
2786
|
-
if (arenaQuery) {
|
|
2787
|
-
fullDistance = state.store.distanceFromArena(arenaQuery, ord, metric);
|
|
2788
|
-
if (fullDistance === Number.POSITIVE_INFINITY) continue;
|
|
2789
|
-
} else {
|
|
2790
|
-
const entry = entryForOrd(state, ord);
|
|
2791
|
-
if (!entry) continue;
|
|
2792
|
-
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));
|
|
2793
2723
|
}
|
|
2794
|
-
const score = toScore(fullDistance, metric);
|
|
2795
|
-
if (score < minSimilarity) continue;
|
|
2796
|
-
rescored.push({ ord, score });
|
|
2797
2724
|
}
|
|
2798
|
-
|
|
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);
|
|
2799
2741
|
}
|
|
2800
|
-
|
|
2801
|
-
|
|
2802
|
-
|
|
2803
|
-
|
|
2804
|
-
score: hit.score,
|
|
2805
|
-
termFrequencies: {},
|
|
2806
|
-
fieldLengths: {},
|
|
2807
|
-
idf: {}
|
|
2808
|
-
}));
|
|
2742
|
+
|
|
2743
|
+
// src/vector/hnsw/scratch-bytes.ts
|
|
2744
|
+
function listBytes(list) {
|
|
2745
|
+
return list.ords.byteLength + list.distances.byteLength;
|
|
2809
2746
|
}
|
|
2810
|
-
function
|
|
2811
|
-
|
|
2812
|
-
|
|
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;
|
|
2813
2751
|
}
|
|
2814
|
-
|
|
2815
|
-
|
|
2816
|
-
|
|
2817
|
-
|
|
2818
|
-
const adjacency = openAdjacency(handles, shape.m, shape.mMax0);
|
|
2819
|
-
return {
|
|
2820
|
-
dimension,
|
|
2821
|
-
store,
|
|
2822
|
-
quantizer,
|
|
2823
|
-
adjacency,
|
|
2824
|
-
locks: openGraphLocks(handles, threadSlot),
|
|
2825
|
-
header: handles.header,
|
|
2826
|
-
tombstones: fixedView(handles.tombstones, Uint8Array),
|
|
2827
|
-
visited: new Uint32Array(0),
|
|
2828
|
-
visitStamp: 0,
|
|
2829
|
-
workspace: createHNSWWorkspace(),
|
|
2830
|
-
neighborScratch: new Int32Array(adjacency.level0Stride),
|
|
2831
|
-
M: shape.m,
|
|
2832
|
-
Mmax0: shape.mMax0,
|
|
2833
|
-
efCons: shape.efConstruction,
|
|
2834
|
-
buildMetric: shape.metric,
|
|
2835
|
-
mL: 1 / Math.log(shape.m)
|
|
2836
|
-
};
|
|
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);
|
|
2837
2756
|
}
|
|
2838
2757
|
|
|
2839
|
-
// src/vector/
|
|
2840
|
-
function
|
|
2841
|
-
|
|
2842
|
-
|
|
2843
|
-
|
|
2844
|
-
|
|
2845
|
-
return 4;
|
|
2846
|
-
case "osq2":
|
|
2847
|
-
return 2;
|
|
2848
|
-
case "osq1":
|
|
2849
|
-
return 1;
|
|
2850
|
-
default:
|
|
2851
|
-
return null;
|
|
2852
|
-
}
|
|
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;
|
|
2853
2764
|
}
|
|
2854
|
-
function
|
|
2855
|
-
|
|
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;
|
|
2784
|
+
}
|
|
2785
|
+
if (count < 0) return false;
|
|
2786
|
+
copyCandidates(store, count, candidates);
|
|
2787
|
+
return true;
|
|
2856
2788
|
}
|
|
2857
|
-
function
|
|
2858
|
-
|
|
2859
|
-
|
|
2860
|
-
const
|
|
2861
|
-
|
|
2862
|
-
|
|
2863
|
-
|
|
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;
|
|
2864
2798
|
}
|
|
2865
|
-
|
|
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;
|
|
2866
2809
|
}
|
|
2867
|
-
|
|
2868
|
-
|
|
2869
|
-
|
|
2870
|
-
|
|
2871
|
-
|
|
2872
|
-
|
|
2873
|
-
|
|
2874
|
-
|
|
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";
|
|
2875
2853
|
}
|
|
2876
|
-
function
|
|
2877
|
-
|
|
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);
|
|
2878
2865
|
}
|
|
2879
|
-
function
|
|
2880
|
-
return
|
|
2866
|
+
function defaultEfSearch(dimension, k) {
|
|
2867
|
+
return Math.max(DEFAULT_EF_SEARCH, k + DEFAULT_EF_SEARCH_MARGIN_BY_BAND[dimensionBand(dimension)]);
|
|
2881
2868
|
}
|
|
2882
|
-
|
|
2883
|
-
|
|
2884
|
-
|
|
2885
|
-
|
|
2886
|
-
|
|
2887
|
-
|
|
2888
|
-
|
|
2889
|
-
|
|
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 };
|
|
2890
2889
|
}
|
|
2891
|
-
}
|
|
2892
|
-
|
|
2893
|
-
|
|
2894
|
-
|
|
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
|
+
}
|
|
2895
2913
|
}
|
|
2914
|
+
searchLayer(state, query, qMag, ef, 0, searchMetric, true, distFn, candidates, filter, options.clock);
|
|
2915
|
+
} finally {
|
|
2916
|
+
unlockGraphShared(state.locks);
|
|
2896
2917
|
}
|
|
2897
|
-
|
|
2898
|
-
totals[dimension + 1] += 1;
|
|
2918
|
+
return { candidates, depth: useQuantized ? depth : 0, arenaQuery, qMag, native: null };
|
|
2899
2919
|
}
|
|
2900
|
-
function
|
|
2901
|
-
|
|
2902
|
-
const mean = new Float64Array(target.dimension);
|
|
2903
|
-
for (let i = 0; i < mean.length; i++) mean[i] = target.totals[i] / count;
|
|
2904
|
-
return mean;
|
|
2920
|
+
function bestFirst(a, b) {
|
|
2921
|
+
return b.score - a.score || compareCodePoints(a.docId, b.docId);
|
|
2905
2922
|
}
|
|
2906
|
-
function
|
|
2907
|
-
|
|
2908
|
-
const
|
|
2909
|
-
|
|
2910
|
-
|
|
2911
|
-
if (target.metric === "cosine") {
|
|
2912
|
-
let squares = 0;
|
|
2913
|
-
for (let i = 0; i < dimension; i++) squares += mean[i] * mean[i];
|
|
2914
|
-
const length = Math.sqrt(squares);
|
|
2915
|
-
for (let i = 0; i < dimension; i++) centroid[i] = length === 0 ? mean[i] : mean[i] / length;
|
|
2916
|
-
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 });
|
|
2917
2928
|
}
|
|
2918
|
-
|
|
2919
|
-
return centroid;
|
|
2920
|
-
}
|
|
2921
|
-
function level(value, lower, upper, steps) {
|
|
2922
|
-
if (upper === lower) return 0;
|
|
2923
|
-
return Math.floor((clamp(value, lower, upper) - lower) * steps / (upper - lower) + 0.5);
|
|
2929
|
+
return resolved;
|
|
2924
2930
|
}
|
|
2925
|
-
function
|
|
2926
|
-
let
|
|
2927
|
-
|
|
2928
|
-
const width = (upper - lower) / steps;
|
|
2929
|
-
for (let i = 0; i < x.length; i++) {
|
|
2930
|
-
const q = lower + width * level(x[i], lower, upper, steps);
|
|
2931
|
-
xe += x[i] * (x[i] - q);
|
|
2932
|
-
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;
|
|
2933
2934
|
}
|
|
2934
|
-
return
|
|
2935
|
+
return hits.length === 0 || !Number.isNaN(hits[0].score);
|
|
2935
2936
|
}
|
|
2936
|
-
function
|
|
2937
|
-
|
|
2938
|
-
|
|
2939
|
-
let norm = 0;
|
|
2940
|
-
for (let i = 0; i < x.length; i++) norm += x[i] * x[i];
|
|
2941
|
-
if (norm === 0 || upper === lower) return [lower, upper];
|
|
2942
|
-
let best = loss(x, lower, upper, steps, norm);
|
|
2943
|
-
for (let round = 0; round < OSQ_REFINE_ROUNDS; round++) {
|
|
2944
|
-
let daa = 0;
|
|
2945
|
-
let dab = 0;
|
|
2946
|
-
let dbb = 0;
|
|
2947
|
-
let dax = 0;
|
|
2948
|
-
let dbx = 0;
|
|
2949
|
-
for (let i = 0; i < x.length; i++) {
|
|
2950
|
-
const s = level(x[i], lower, upper, steps) / steps;
|
|
2951
|
-
daa += (1 - s) * (1 - s);
|
|
2952
|
-
dab += (1 - s) * s;
|
|
2953
|
-
dbb += s * s;
|
|
2954
|
-
dax += x[i] * (1 - s);
|
|
2955
|
-
dbx += x[i] * s;
|
|
2956
|
-
}
|
|
2957
|
-
const m0 = (1 - OSQ_LAMBDA) * dax * dax / norm + OSQ_LAMBDA * daa;
|
|
2958
|
-
const m1 = (1 - OSQ_LAMBDA) * dax * dbx / norm + OSQ_LAMBDA * dab;
|
|
2959
|
-
const m2 = (1 - OSQ_LAMBDA) * dbx * dbx / norm + OSQ_LAMBDA * dbb;
|
|
2960
|
-
const det = m0 * m2 - m1 * m1;
|
|
2961
|
-
if (det === 0) return [lower, upper];
|
|
2962
|
-
const a = (m2 * dax - m1 * dbx) / det;
|
|
2963
|
-
const b = (m0 * dbx - m1 * dax) / det;
|
|
2964
|
-
if (Math.abs(a - lower) < OSQ_REFINE_TOLERANCE && Math.abs(b - upper) < OSQ_REFINE_TOLERANCE) return [lower, upper];
|
|
2965
|
-
const candidate = loss(x, a, b, steps, norm);
|
|
2966
|
-
if (candidate > best) return [lower, upper];
|
|
2967
|
-
lower = a;
|
|
2968
|
-
upper = b;
|
|
2969
|
-
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);
|
|
2970
2940
|
}
|
|
2971
|
-
|
|
2972
|
-
|
|
2973
|
-
|
|
2974
|
-
|
|
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);
|
|
2975
2953
|
}
|
|
2976
|
-
function
|
|
2977
|
-
|
|
2978
|
-
|
|
2979
|
-
|
|
2980
|
-
|
|
2981
|
-
|
|
2982
|
-
|
|
2983
|
-
let total = 0;
|
|
2984
|
-
let minimum = Number.POSITIVE_INFINITY;
|
|
2985
|
-
let maximum = Number.NEGATIVE_INFINITY;
|
|
2986
|
-
for (let i = 0; i < dimension; i++) {
|
|
2987
|
-
x[i] = v[i] - centroid[i];
|
|
2988
|
-
correction += metric === "euclidean" ? x[i] * x[i] : v[i] * centroid[i];
|
|
2989
|
-
total += x[i];
|
|
2990
|
-
if (x[i] < minimum) minimum = x[i];
|
|
2991
|
-
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
|
+
);
|
|
2992
2961
|
}
|
|
2993
|
-
const
|
|
2994
|
-
|
|
2995
|
-
|
|
2996
|
-
const std = Math.sqrt(spread / dimension);
|
|
2997
|
-
const steps = OSQ_STEPS[bits];
|
|
2998
|
-
const [lower, upper] = refine(
|
|
2999
|
-
x,
|
|
3000
|
-
clamp(mean - OSQ_GRID[bits] * std, minimum, maximum),
|
|
3001
|
-
clamp(mean + OSQ_GRID[bits] * std, minimum, maximum),
|
|
3002
|
-
steps
|
|
3003
|
-
);
|
|
3004
|
-
const levels = new Uint8Array(dimension);
|
|
3005
|
-
let sum = 0;
|
|
3006
|
-
for (let i = 0; i < dimension; i++) {
|
|
3007
|
-
levels[i] = level(x[i], lower, upper, steps);
|
|
3008
|
-
sum += levels[i];
|
|
2962
|
+
const liveSize = nodeCountOf(state) - tombstoneCountOf(state);
|
|
2963
|
+
if (entryPointOf(state) === -1 || liveSize === 0) {
|
|
2964
|
+
return [];
|
|
3009
2965
|
}
|
|
3010
|
-
|
|
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));
|
|
3011
2974
|
}
|
|
3012
|
-
|
|
3013
|
-
|
|
3014
|
-
|
|
3015
|
-
|
|
3016
|
-
|
|
3017
|
-
|
|
3018
|
-
|
|
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;
|
|
2982
|
+
}
|
|
2983
|
+
return candidates.size;
|
|
3019
2984
|
}
|
|
3020
|
-
function
|
|
3021
|
-
const
|
|
3022
|
-
|
|
3023
|
-
|
|
3024
|
-
|
|
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 });
|
|
2993
|
+
}
|
|
2994
|
+
return hits;
|
|
3025
2995
|
}
|
|
3026
|
-
function
|
|
3027
|
-
const {
|
|
3028
|
-
if (
|
|
3029
|
-
|
|
3030
|
-
|
|
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);
|
|
3004
|
+
}
|
|
3005
|
+
const { qMag, arenaQuery } = traversal;
|
|
3006
|
+
return rescoreWithFullPrecision(state, candidates, query, qMag, arenaQuery, depth, metric, minSimilarity, filter);
|
|
3031
3007
|
}
|
|
3032
|
-
function
|
|
3033
|
-
const
|
|
3034
|
-
|
|
3035
|
-
|
|
3036
|
-
|
|
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;
|
|
3022
|
+
}
|
|
3023
|
+
const score = toScore(fullDistance, metric);
|
|
3024
|
+
if (score < minSimilarity) continue;
|
|
3025
|
+
rescored.push({ ord, score });
|
|
3026
|
+
}
|
|
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);
|
|
3037
3042
|
}
|
|
3038
3043
|
|
|
3039
|
-
// src/vector/
|
|
3040
|
-
function
|
|
3041
|
-
const
|
|
3042
|
-
const
|
|
3043
|
-
const
|
|
3044
|
-
const
|
|
3045
|
-
|
|
3046
|
-
|
|
3047
|
-
|
|
3048
|
-
|
|
3049
|
-
|
|
3050
|
-
|
|
3051
|
-
|
|
3052
|
-
|
|
3053
|
-
|
|
3054
|
-
|
|
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);
|
|
3131
|
+
}
|
|
3055
3132
|
}
|
|
3056
|
-
function
|
|
3057
|
-
|
|
3058
|
-
|
|
3059
|
-
|
|
3060
|
-
recoded = grown;
|
|
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`);
|
|
3061
3137
|
}
|
|
3062
|
-
|
|
3138
|
+
const entry = store.entryForOrdinal(ord);
|
|
3139
|
+
if (!entry) {
|
|
3140
|
+
throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
|
|
3141
|
+
}
|
|
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);
|
|
3063
3150
|
}
|
|
3064
|
-
function
|
|
3065
|
-
|
|
3066
|
-
|
|
3067
|
-
|
|
3068
|
-
|
|
3069
|
-
|
|
3070
|
-
|
|
3071
|
-
|
|
3072
|
-
|
|
3073
|
-
|
|
3074
|
-
for (let ordinal = 0; ordinal < slots; ordinal++) {
|
|
3075
|
-
if (!source.holds(ordinal) || ordinal < recoded.length && recoded[ordinal] === 1) continue;
|
|
3076
|
-
recode(ordinal);
|
|
3077
|
-
if (ordinal >= recoded.length || recoded[ordinal] !== 1) source.clearCodes(ordinal);
|
|
3078
|
-
}
|
|
3079
|
-
const start = slotByteOffset(layout, 0);
|
|
3080
|
-
for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
|
|
3081
|
-
const block = blocks[blockIndex];
|
|
3082
|
-
if (block === void 0 || block.usedBytes === 0) continue;
|
|
3083
|
-
const target = store.codeBlockOf(blockIndex * capacity).bytes(start + block.usedBytes);
|
|
3084
|
-
target.set(block.bytes.subarray(0, block.usedBytes), start);
|
|
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 }];
|
|
3085
3161
|
}
|
|
3086
3162
|
}
|
|
3087
|
-
|
|
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;
|
|
3168
|
+
}
|
|
3169
|
+
return {
|
|
3170
|
+
get dimension() {
|
|
3171
|
+
return dimension;
|
|
3172
|
+
},
|
|
3173
|
+
get size() {
|
|
3174
|
+
return nodeCountOf(state) - tombstoneCountOf(state);
|
|
3175
|
+
},
|
|
3176
|
+
get tombstoneCount() {
|
|
3177
|
+
return tombstoneCountOf(state);
|
|
3178
|
+
},
|
|
3179
|
+
get entryPointId() {
|
|
3180
|
+
const entryPoint = entryPointOf(state);
|
|
3181
|
+
return entryPoint === -1 ? null : store.docIdForOrdinal(entryPoint) ?? null;
|
|
3182
|
+
},
|
|
3183
|
+
get topLayer() {
|
|
3184
|
+
return topLayerOf(state);
|
|
3185
|
+
},
|
|
3186
|
+
get m() {
|
|
3187
|
+
return state.M;
|
|
3188
|
+
},
|
|
3189
|
+
get efConstruction() {
|
|
3190
|
+
return state.efCons;
|
|
3191
|
+
},
|
|
3192
|
+
get metric() {
|
|
3193
|
+
return state.buildMetric;
|
|
3194
|
+
},
|
|
3195
|
+
get graphBytes() {
|
|
3196
|
+
return graphBytes(state.adjacency);
|
|
3197
|
+
},
|
|
3198
|
+
get searchScratchBytes() {
|
|
3199
|
+
return searchScratchBytes(state);
|
|
3200
|
+
},
|
|
3201
|
+
get handles() {
|
|
3202
|
+
return shared;
|
|
3203
|
+
},
|
|
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);
|
|
3209
|
+
},
|
|
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);
|
|
3216
|
+
},
|
|
3217
|
+
isTombstoned: (docId) => {
|
|
3218
|
+
const ord = store.getOrdinal(docId);
|
|
3219
|
+
return ord !== void 0 && isTombstoned(state, ord);
|
|
3220
|
+
},
|
|
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))
|
|
3235
|
+
};
|
|
3088
3236
|
}
|
|
3089
3237
|
|
|
3090
|
-
// src/vector/osq/
|
|
3091
|
-
function
|
|
3092
|
-
|
|
3093
|
-
|
|
3094
|
-
|
|
3095
|
-
|
|
3096
|
-
|
|
3097
|
-
|
|
3098
|
-
|
|
3099
|
-
|
|
3100
|
-
|
|
3101
|
-
|
|
3102
|
-
|
|
3103
|
-
function reach2(ordinal) {
|
|
3104
|
-
if (ordinal < codePresent.length) return true;
|
|
3105
|
-
if (ordinal >= store.handles.codePresent.byteLength) return false;
|
|
3106
|
-
codePresent = fixedView(store.handles.codePresent, Uint8Array);
|
|
3107
|
-
return ordinal < codePresent.length;
|
|
3108
|
-
}
|
|
3109
|
-
function isCalibrated() {
|
|
3110
|
-
return Atomics.load(store.handles.header, STORE_CALIBRATED) === 1;
|
|
3111
|
-
}
|
|
3112
|
-
function recomputeCentroidDot(generation) {
|
|
3113
|
-
const centroid = store.handles.centroid;
|
|
3114
|
-
let total = 0;
|
|
3115
|
-
for (let i = 0; i < dimension; i++) total += centroid[i] * centroid[i];
|
|
3116
|
-
centroidDot = total;
|
|
3117
|
-
centroidGeneration = generation;
|
|
3118
|
-
}
|
|
3119
|
-
function centroidDotNow() {
|
|
3120
|
-
const generation = Atomics.load(store.handles.header, STORE_CALIBRATION_GENERATION);
|
|
3121
|
-
if (generation !== centroidGeneration) recomputeCentroidDot(generation);
|
|
3122
|
-
return centroidDot;
|
|
3123
|
-
}
|
|
3124
|
-
function holds2(ordinal) {
|
|
3125
|
-
return ordinal >= 0 && reach2(ordinal) && codePresent[ordinal] === 1;
|
|
3126
|
-
}
|
|
3127
|
-
function recordOffset(ordinal) {
|
|
3128
|
-
return slotByteOffset(layout, ordinal % capacity);
|
|
3129
|
-
}
|
|
3130
|
-
function markPresent(ordinal) {
|
|
3131
|
-
if (Atomics.load(codePresent, ordinal) !== 0) return;
|
|
3132
|
-
Atomics.add(store.handles.header, STORE_CODE_COUNT, 1);
|
|
3133
|
-
Atomics.store(codePresent, ordinal, 1);
|
|
3134
|
-
}
|
|
3135
|
-
function writeCentroid(centroid) {
|
|
3136
|
-
store.handles.centroid.set(centroid);
|
|
3137
|
-
Atomics.add(store.handles.header, STORE_CALIBRATION_GENERATION, 1);
|
|
3138
|
-
Atomics.store(store.handles.header, STORE_CALIBRATED, 1);
|
|
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;
|
|
3139
3251
|
}
|
|
3140
|
-
|
|
3141
|
-
|
|
3142
|
-
|
|
3252
|
+
}
|
|
3253
|
+
function clamp(value, low, high) {
|
|
3254
|
+
return Math.min(Math.max(value, low), high);
|
|
3255
|
+
}
|
|
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];
|
|
3262
|
+
return;
|
|
3143
3263
|
}
|
|
3144
|
-
|
|
3145
|
-
|
|
3146
|
-
|
|
3264
|
+
for (let i = 0; i < vector.length; i++) target[i] = vector[i] / length;
|
|
3265
|
+
}
|
|
3266
|
+
var CENTROID_TOTALS_PAST_DIMENSION = 2;
|
|
3267
|
+
function createCentroidSums(dimension, metric) {
|
|
3268
|
+
return {
|
|
3269
|
+
metric,
|
|
3270
|
+
dimension,
|
|
3271
|
+
totals: new Float64Array(dimension + CENTROID_TOTALS_PAST_DIMENSION),
|
|
3272
|
+
scratch: new Float64Array(dimension)
|
|
3273
|
+
};
|
|
3274
|
+
}
|
|
3275
|
+
function countOfCentroidSums(target) {
|
|
3276
|
+
return target.totals[target.dimension + 1];
|
|
3277
|
+
}
|
|
3278
|
+
function squaredLengthsOfCentroidSums(target) {
|
|
3279
|
+
return target.totals[target.dimension];
|
|
3280
|
+
}
|
|
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];
|
|
3147
3289
|
}
|
|
3148
|
-
}
|
|
3149
|
-
|
|
3150
|
-
|
|
3151
|
-
|
|
3152
|
-
const block = store.codeBlockOf(ordinal);
|
|
3153
|
-
const offset = recordOffset(ordinal);
|
|
3154
|
-
writeRecord(block.bytes(offset + layout.slotStride), offset, code, bits, block.data(offset + layout.slotStride));
|
|
3155
|
-
markPresent(ordinal);
|
|
3156
|
-
recoding?.recode(ordinal);
|
|
3157
|
-
}
|
|
3158
|
-
function writeCodesOf(ordinals) {
|
|
3159
|
-
if (!isCalibrated() || ordinals.length === 0) return;
|
|
3160
|
-
if (nativeQuantise(store.handles, metric, ordinals)) {
|
|
3161
|
-
if (recoding !== null) for (const ordinal of ordinals) recoding.recode(ordinal);
|
|
3162
|
-
return;
|
|
3290
|
+
} else {
|
|
3291
|
+
for (let i = 0; i < dimension; i++) {
|
|
3292
|
+
totals[i] += vector[i];
|
|
3293
|
+
squares += vector[i] * vector[i];
|
|
3163
3294
|
}
|
|
3164
|
-
for (const ordinal of ordinals) writeRecordOf(ordinal);
|
|
3165
3295
|
}
|
|
3166
|
-
|
|
3167
|
-
|
|
3168
|
-
|
|
3296
|
+
totals[dimension] = squares;
|
|
3297
|
+
totals[dimension + 1] += 1;
|
|
3298
|
+
}
|
|
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;
|
|
3304
|
+
}
|
|
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;
|
|
3169
3316
|
}
|
|
3170
|
-
|
|
3171
|
-
|
|
3172
|
-
|
|
3173
|
-
|
|
3317
|
+
for (let i = 0; i < dimension; i++) centroid[i] = mean[i];
|
|
3318
|
+
return centroid;
|
|
3319
|
+
}
|
|
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);
|
|
3323
|
+
}
|
|
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);
|
|
3332
|
+
}
|
|
3333
|
+
return (1 - OSQ_LAMBDA) * xe * xe / norm + OSQ_LAMBDA * e;
|
|
3334
|
+
}
|
|
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;
|
|
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;
|
|
3369
|
+
}
|
|
3370
|
+
return [lower, upper];
|
|
3371
|
+
}
|
|
3372
|
+
function createOsqScratch(dimension) {
|
|
3373
|
+
return { normalised: new Float64Array(dimension), centred: new Float64Array(dimension) };
|
|
3374
|
+
}
|
|
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];
|
|
3391
|
+
}
|
|
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
|
|
3402
|
+
);
|
|
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];
|
|
3408
|
+
}
|
|
3409
|
+
return { levels, lower, upper, correction, sum };
|
|
3410
|
+
}
|
|
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);
|
|
3418
|
+
}
|
|
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;
|
|
3460
|
+
}
|
|
3461
|
+
recoded[ordinal] = 1;
|
|
3462
|
+
}
|
|
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);
|
|
3484
|
+
}
|
|
3485
|
+
}
|
|
3486
|
+
return { centroid, recode, copyIntoStore };
|
|
3487
|
+
}
|
|
3488
|
+
|
|
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);
|
|
3546
|
+
}
|
|
3547
|
+
}
|
|
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);
|
|
3556
|
+
}
|
|
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;
|
|
3562
|
+
}
|
|
3563
|
+
for (const ordinal of ordinals) writeRecordOf(ordinal);
|
|
3564
|
+
}
|
|
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);
|
|
3174
3573
|
block.stagedOrdinal = QUERY_STAGED;
|
|
3175
3574
|
}
|
|
3176
3575
|
return true;
|
|
@@ -3350,1178 +3749,140 @@ function openSharedQuantizer(store, layout, metric) {
|
|
|
3350
3749
|
recoding = null;
|
|
3351
3750
|
finished.copyIntoStore(store.slots);
|
|
3352
3751
|
writeCentroid(finished.centroid);
|
|
3353
|
-
return true;
|
|
3354
|
-
},
|
|
3355
|
-
abandonRecoding() {
|
|
3356
|
-
recoding = null;
|
|
3357
|
-
},
|
|
3358
|
-
prepareQuery,
|
|
3359
|
-
distanceFromPreparedByOrdinal(prepared, ordinal) {
|
|
3360
|
-
if (!holds2(ordinal)) return Number.POSITIVE_INFINITY;
|
|
3361
|
-
return estimateDistance(ordinal, prepared);
|
|
3362
|
-
},
|
|
3363
|
-
preparedDistance,
|
|
3364
|
-
pairDistance,
|
|
3365
|
-
placementDistance: placementDistance2
|
|
3366
|
-
};
|
|
3367
|
-
}
|
|
3368
|
-
|
|
3369
|
-
// src/vector/osq/index.ts
|
|
3370
|
-
function createOsqQuantizer(dimension, bits, metric, store) {
|
|
3371
|
-
let opened = null;
|
|
3372
|
-
function shared() {
|
|
3373
|
-
if (opened === null && store.dimension === dimension && store.handles.codeLayout !== null) {
|
|
3374
|
-
opened = openSharedQuantizer(store.view, store.handles.codeLayout, metric);
|
|
3375
|
-
}
|
|
3376
|
-
return opened;
|
|
3377
|
-
}
|
|
3378
|
-
function requireShared() {
|
|
3379
|
-
const view = shared();
|
|
3380
|
-
if (view === null) throw new Error("The vector store holds no vector for the quantizer to work on");
|
|
3381
|
-
return view;
|
|
3382
|
-
}
|
|
3383
|
-
function ordinalOf(docId) {
|
|
3384
|
-
const ordinal = store.getOrdinal(docId);
|
|
3385
|
-
if (ordinal === void 0) {
|
|
3386
|
-
throw new Error(`Cannot quantize "${docId}": the vector store holds no vector for it`);
|
|
3387
|
-
}
|
|
3388
|
-
return ordinal;
|
|
3389
|
-
}
|
|
3390
|
-
return {
|
|
3391
|
-
dimension,
|
|
3392
|
-
bits,
|
|
3393
|
-
metric,
|
|
3394
|
-
get size() {
|
|
3395
|
-
return shared()?.size ?? 0;
|
|
3396
|
-
},
|
|
3397
|
-
get centroid() {
|
|
3398
|
-
return shared()?.centroid ?? null;
|
|
3399
|
-
},
|
|
3400
|
-
isCalibrated: () => shared()?.isCalibrated() ?? false,
|
|
3401
|
-
calibrate(ordinals) {
|
|
3402
|
-
if (ordinals.length > 0) requireShared().calibrateFrom(ordinals);
|
|
3403
|
-
},
|
|
3404
|
-
measure(ordinals, sums) {
|
|
3405
|
-
if (ordinals.length > 0) requireShared().measureInto(ordinals, sums);
|
|
3406
|
-
},
|
|
3407
|
-
quantize(docId) {
|
|
3408
|
-
const ordinal = ordinalOf(docId);
|
|
3409
|
-
const view = requireShared();
|
|
3410
|
-
if (!view.isCalibrated()) view.calibrateFrom(Int32Array.of(ordinal));
|
|
3411
|
-
view.writeCodes(ordinal);
|
|
3412
|
-
},
|
|
3413
|
-
writeCodes(ordinal) {
|
|
3414
|
-
shared()?.writeCodes(ordinal);
|
|
3415
|
-
},
|
|
3416
|
-
remove(docId) {
|
|
3417
|
-
const ordinal = store.getOrdinal(docId);
|
|
3418
|
-
if (ordinal !== void 0) shared()?.clearCodes(ordinal);
|
|
3419
|
-
},
|
|
3420
|
-
removeOrdinal(ordinal) {
|
|
3421
|
-
shared()?.clearCodes(ordinal);
|
|
3422
|
-
},
|
|
3423
|
-
hasOrdinal: (ordinal) => shared()?.holdsOrdinal(ordinal) ?? false,
|
|
3424
|
-
getLevels(docId) {
|
|
3425
|
-
const view = shared();
|
|
3426
|
-
const ordinal = store.getOrdinal(docId);
|
|
3427
|
-
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3428
|
-
return unpackLevels(view.recordAt(ordinal), 0, dimension, bits);
|
|
3429
|
-
},
|
|
3430
|
-
recordOf(docId) {
|
|
3431
|
-
const view = shared();
|
|
3432
|
-
const ordinal = store.getOrdinal(docId);
|
|
3433
|
-
if (view === null || ordinal === void 0 || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3434
|
-
return view.recordAt(ordinal);
|
|
3435
|
-
},
|
|
3436
|
-
recordAtOrdinal(ordinal) {
|
|
3437
|
-
const view = shared();
|
|
3438
|
-
if (view === null || !view.holdsOrdinal(ordinal)) return void 0;
|
|
3439
|
-
return view.recordAt(ordinal);
|
|
3440
|
-
},
|
|
3441
|
-
restoreRecord(docId, record) {
|
|
3442
|
-
requireShared().restoreRecord(ordinalOf(docId), record);
|
|
3443
|
-
},
|
|
3444
|
-
restoreRecordAtOrdinal(ordinal, record) {
|
|
3445
|
-
requireShared().restoreRecord(ordinal, record);
|
|
3446
|
-
},
|
|
3447
|
-
restoreCentroid(centroid) {
|
|
3448
|
-
requireShared().writeCentroid(centroid);
|
|
3449
|
-
},
|
|
3450
|
-
recalibrate(ordinals) {
|
|
3451
|
-
if (ordinals.length === 0) return;
|
|
3452
|
-
const view = requireShared();
|
|
3453
|
-
view.resetCodes();
|
|
3454
|
-
view.calibrateFrom(ordinals);
|
|
3455
|
-
view.writeCodesOf(ordinals);
|
|
3456
|
-
},
|
|
3457
|
-
beginRecoding(centroid) {
|
|
3458
|
-
requireShared().beginRecoding(centroid);
|
|
3459
|
-
},
|
|
3460
|
-
recode(ordinal) {
|
|
3461
|
-
shared()?.recode(ordinal);
|
|
3462
|
-
},
|
|
3463
|
-
finishRecoding: () => shared()?.finishRecoding() ?? false,
|
|
3464
|
-
abandonRecoding() {
|
|
3465
|
-
shared()?.abandonRecoding();
|
|
3466
|
-
},
|
|
3467
|
-
prepareQuery: (query) => shared()?.prepareQuery(query) ?? null,
|
|
3468
|
-
distanceFromPreparedByOrdinal: (prepared, ordinal) => shared()?.distanceFromPreparedByOrdinal(prepared, ordinal) ?? Number.POSITIVE_INFINITY,
|
|
3469
|
-
preparedDistance(prepared) {
|
|
3470
|
-
const view = shared();
|
|
3471
|
-
if (view === null) return () => Number.POSITIVE_INFINITY;
|
|
3472
|
-
return view.preparedDistance(prepared);
|
|
3473
|
-
},
|
|
3474
|
-
pairDistance() {
|
|
3475
|
-
const view = shared();
|
|
3476
|
-
if (view === null) return () => Number.POSITIVE_INFINITY;
|
|
3477
|
-
return view.pairDistance();
|
|
3478
|
-
},
|
|
3479
|
-
placementDistance: (vector) => shared()?.placementDistance(vector) ?? null,
|
|
3480
|
-
clear() {
|
|
3481
|
-
const view = shared();
|
|
3482
|
-
if (view === null) return;
|
|
3483
|
-
view.resetCodes();
|
|
3484
|
-
view.resetCalibration();
|
|
3485
|
-
}
|
|
3486
|
-
};
|
|
3487
|
-
}
|
|
3488
|
-
|
|
3489
|
-
// src/vector/vector-index/constants.ts
|
|
3490
|
-
var DEFAULT_PROMOTION_THRESHOLD = 1024;
|
|
3491
|
-
var DEFAULT_FILTER_THRESHOLD = 0.03;
|
|
3492
|
-
var ESTIMATED_MS_PER_TOMBSTONE = 0.05;
|
|
3493
|
-
var ESTIMATED_MS_PER_VECTOR_REBUILD = 0.15;
|
|
3494
|
-
var WORKER_COPY_MIN_VECTORS = 1024;
|
|
3495
|
-
var BUILD_CHUNK_SIZE = 100;
|
|
3496
|
-
var BUILD_TURN_HANDOVER_AFTER_MS = 50;
|
|
3497
|
-
var BUILD_RETRY_FIRST_DELAY_MS = 250;
|
|
3498
|
-
var BUILD_RETRY_MAX_DELAY_MS = 3e4;
|
|
3499
|
-
var SHUFFLED_REBUILD_MEMORY_RETRY_MS = 1e3;
|
|
3500
|
-
var REBUILD_REMOVED_RATIO = 0.2;
|
|
3501
|
-
var DRIFT_CHECK_GROWTH_FACTOR = 2;
|
|
3502
|
-
var RECALIBRATION_DRIFT_RATIO = 2.5;
|
|
3503
|
-
var RECALIBRATION_CHUNK_VECTORS = 512;
|
|
3504
|
-
var VECTOR_FILE_REPLACED_ABOVE_DEAD_SHARE = 0.2;
|
|
3505
|
-
var VECTOR_FILE_FIXED_OVERHEAD_BYTES = 65536;
|
|
3506
|
-
var VECTOR_FILE_STRING_HEADER_BYTES = 5;
|
|
3507
|
-
var VECTOR_FILE_CENTROID_BYTES_PER_COMPONENT = 9;
|
|
3508
|
-
var OSQ4_MIN_DIMENSION = 384;
|
|
3509
|
-
var DISK_ADOPTION_YIELD_INTERVAL = 4096;
|
|
3510
|
-
|
|
3511
|
-
// src/vector/vector-index/shared.ts
|
|
3512
|
-
var VECTOR_WORKER_COPIES_ALLOWED = { enabled: true };
|
|
3513
|
-
function liveSize(state) {
|
|
3514
|
-
return state.store.size - state.tombstones.size;
|
|
3515
|
-
}
|
|
3516
|
-
function threadsHoldCurrentLayout(state) {
|
|
3517
|
-
return state.sharedLayoutRevision === state.store.handles.layoutRevision;
|
|
3518
|
-
}
|
|
3519
|
-
function assignStorePartitions(state, resolve) {
|
|
3520
|
-
for (let ordinal = 0; ordinal < state.store.slots; ordinal += 1) {
|
|
3521
|
-
if (state.store.partitionOfOrdinal(ordinal) !== void 0) continue;
|
|
3522
|
-
const docId = state.store.docIdForOrdinal(ordinal);
|
|
3523
|
-
if (docId === void 0) continue;
|
|
3524
|
-
const partitionId = resolve(docId);
|
|
3525
|
-
if (partitionId === void 0) {
|
|
3526
|
-
state.store.forgetPartition(docId);
|
|
3527
|
-
continue;
|
|
3528
|
-
}
|
|
3529
|
-
state.store.setPartition(docId, partitionId);
|
|
3530
|
-
}
|
|
3531
|
-
}
|
|
3532
|
-
function emptyFieldBeforeRestore(state) {
|
|
3533
|
-
state.store.clear();
|
|
3534
|
-
state.tombstones.clear();
|
|
3535
|
-
state.buffer.clear();
|
|
3536
|
-
state.pendingLocations.clear();
|
|
3537
|
-
adoptGraph(state, null);
|
|
3538
|
-
state.osq?.clear();
|
|
3539
|
-
forgetCalibration(state);
|
|
3540
|
-
state.savedFiles = [];
|
|
3541
|
-
state.savedSignature = null;
|
|
3542
|
-
}
|
|
3543
|
-
function releaseReplacedVectors(state) {
|
|
3544
|
-
for (const ordinal of state.store.releaseReplacedVectors()) state.osq?.removeOrdinal(ordinal);
|
|
3545
|
-
}
|
|
3546
|
-
function adoptGraph(state, graph) {
|
|
3547
|
-
if (state.hnsw !== null && state.hnsw !== graph) state.hnsw.retire();
|
|
3548
|
-
if (graph === null && state.hnsw !== null) {
|
|
3549
|
-
state.hnsw.clear();
|
|
3550
|
-
}
|
|
3551
|
-
state.hnsw = graph;
|
|
3552
|
-
state.shuffledBuildCount = null;
|
|
3553
|
-
state.compactedNodeCount = 0;
|
|
3554
|
-
if (graph === null) return;
|
|
3555
|
-
for (const docId of state.tombstones) {
|
|
3556
|
-
if (graph.has(docId)) {
|
|
3557
|
-
graph.markTombstone(docId);
|
|
3558
|
-
}
|
|
3559
|
-
}
|
|
3560
|
-
}
|
|
3561
|
-
function graphNeedsRebuild(state) {
|
|
3562
|
-
const graph = state.hnsw;
|
|
3563
|
-
if (graph === null) return false;
|
|
3564
|
-
const removed = graph.tombstoneCount + state.compactedNodeCount;
|
|
3565
|
-
const held = graph.size + removed;
|
|
3566
|
-
if (held === 0) return false;
|
|
3567
|
-
return removed / held > REBUILD_REMOVED_RATIO;
|
|
3568
|
-
}
|
|
3569
|
-
function yieldBuildTurn(state) {
|
|
3570
|
-
return new Promise((resolve) => {
|
|
3571
|
-
const takeTurn = () => {
|
|
3572
|
-
clearTimeout(timer);
|
|
3573
|
-
state.buildTurnWaiters.delete(takeTurn);
|
|
3574
|
-
resolve();
|
|
3575
|
-
};
|
|
3576
|
-
const timer = setTimeout(takeTurn, 0);
|
|
3577
|
-
state.buildTurnWaiters.set(takeTurn, performance.now());
|
|
3578
|
-
});
|
|
3579
|
-
}
|
|
3580
|
-
function noBuildHistory() {
|
|
3581
|
-
return {
|
|
3582
|
-
shuffledBuildCount: null,
|
|
3583
|
-
calibratedCount: null,
|
|
3584
|
-
calibratedMeanLength: null,
|
|
3585
|
-
nextDriftCheckAt: Number.POSITIVE_INFINITY,
|
|
3586
|
-
shuffledRebuild: null
|
|
3587
|
-
};
|
|
3588
|
-
}
|
|
3589
|
-
function handOverBuildTurns(state) {
|
|
3590
|
-
if (state.buildTurnWaiters.size === 0) return;
|
|
3591
|
-
const [longestWaitingSince] = state.buildTurnWaiters.values();
|
|
3592
|
-
if (longestWaitingSince === void 0 || performance.now() - longestWaitingSince < BUILD_TURN_HANDOVER_AFTER_MS)
|
|
3593
|
-
return;
|
|
3594
|
-
for (const takeTurn of [...state.buildTurnWaiters.keys()]) takeTurn();
|
|
3595
|
-
}
|
|
3596
|
-
function* allLiveDocIds(state) {
|
|
3597
|
-
for (const docId of state.store.docIds()) {
|
|
3598
|
-
if (state.tombstones.has(docId)) continue;
|
|
3599
|
-
yield docId;
|
|
3600
|
-
}
|
|
3601
|
-
}
|
|
3602
|
-
function ordinalFilterForPartitions(state, partitionIds) {
|
|
3603
|
-
const filter = state.store.partitionFilter(partitionIds);
|
|
3604
|
-
for (const docId of state.tombstones) {
|
|
3605
|
-
const ordinal = state.store.getOrdinal(docId);
|
|
3606
|
-
if (ordinal === void 0) continue;
|
|
3607
|
-
removeFromOrdinalFilter(filter, ordinal);
|
|
3608
|
-
}
|
|
3609
|
-
return filter;
|
|
3610
|
-
}
|
|
3611
|
-
function ordinalSpaceOf(state) {
|
|
3612
|
-
const store = state.store;
|
|
3613
|
-
const handles = store.handles;
|
|
3614
|
-
const removed = new Uint8Array(handles.removed);
|
|
3615
|
-
return {
|
|
3616
|
-
fieldName: state.fieldName,
|
|
3617
|
-
slots: store.slots,
|
|
3618
|
-
header: handles.header,
|
|
3619
|
-
layoutGeneration: Atomics.load(handles.header, STORE_ORDINAL_LAYOUT_GENERATION),
|
|
3620
|
-
ordinalOf: (docId) => store.getOrdinal(docId),
|
|
3621
|
-
holdsCurrentOrdinal: (ordinal) => store.holdsOrdinal(ordinal),
|
|
3622
|
-
isRemoved: (ordinal) => ordinal < removed.length && removed[ordinal] === 1
|
|
3623
|
-
};
|
|
3624
|
-
}
|
|
3625
|
-
function filterForOptions(state, options) {
|
|
3626
|
-
if (options.filterSubsets !== void 0) {
|
|
3627
|
-
if (state.store.dimension === 0) return createOrdinalFilter(0);
|
|
3628
|
-
return ordinalFilterForSubsets(options.filterSubsets, ordinalSpaceOf(state));
|
|
3629
|
-
}
|
|
3630
|
-
if (options.filterPartitions !== void 0) {
|
|
3631
|
-
return ordinalFilterForPartitions(state, options.filterPartitions);
|
|
3632
|
-
}
|
|
3633
|
-
return void 0;
|
|
3634
|
-
}
|
|
3635
|
-
function liveOrdinals(state) {
|
|
3636
|
-
const ordinals = [];
|
|
3637
|
-
for (let ordinal = 0; ordinal < state.store.slots; ordinal++) {
|
|
3638
|
-
const docId = state.store.docIdForOrdinal(ordinal);
|
|
3639
|
-
if (docId !== void 0 && !state.tombstones.has(docId)) ordinals.push(ordinal);
|
|
3640
|
-
}
|
|
3641
|
-
return Int32Array.from(ordinals);
|
|
3642
|
-
}
|
|
3643
|
-
function forgetCalibration(state) {
|
|
3644
|
-
state.calibratedCount = null;
|
|
3645
|
-
state.calibratedMeanLength = null;
|
|
3646
|
-
state.nextDriftCheckAt = Number.POSITIVE_INFINITY;
|
|
3647
|
-
}
|
|
3648
|
-
function adoptLoadedCalibration(state, calibratedCount, calibratedMeanLength) {
|
|
3649
|
-
if (state.osq === null || !state.osq.isCalibrated()) return;
|
|
3650
|
-
state.calibratedCount = calibratedCount;
|
|
3651
|
-
state.calibratedMeanLength = calibratedMeanLength;
|
|
3652
|
-
state.nextDriftCheckAt = Math.max(1, calibratedCount) * DRIFT_CHECK_GROWTH_FACTOR;
|
|
3653
|
-
}
|
|
3654
|
-
function recalibrateFromStore(state) {
|
|
3655
|
-
if (state.osq === null) return;
|
|
3656
|
-
const ordinals = liveOrdinals(state);
|
|
3657
|
-
state.osq.recalibrate(ordinals);
|
|
3658
|
-
state.calibratedCount = ordinals.length;
|
|
3659
|
-
state.calibratedMeanLength = null;
|
|
3660
|
-
state.nextDriftCheckAt = Math.max(1, ordinals.length) * DRIFT_CHECK_GROWTH_FACTOR;
|
|
3661
|
-
}
|
|
3662
|
-
function fieldHandlesOf(state, graph, searchable) {
|
|
3663
|
-
return {
|
|
3664
|
-
dimension: state.dimension,
|
|
3665
|
-
quantization: state.osq === null ? "none" : state.quantizationMode,
|
|
3666
|
-
metric: state.metric,
|
|
3667
|
-
store: state.store.handles,
|
|
3668
|
-
graph: graph === null ? null : graph.handles,
|
|
3669
|
-
filterThreshold: state.filterThreshold,
|
|
3670
|
-
searchable
|
|
3671
|
-
};
|
|
3672
|
-
}
|
|
3673
|
-
|
|
3674
|
-
// src/vector/hnsw/numbered-graph.ts
|
|
3675
|
-
var NO_NUMBER = -1;
|
|
3676
|
-
var NO_ORDINAL = -1;
|
|
3677
|
-
var NO_LAYER = -1;
|
|
3678
|
-
var BYTES_PER_VALUE = 4;
|
|
3679
|
-
var LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
|
|
3680
|
-
function swapEveryValue(bytes) {
|
|
3681
|
-
for (let i = 0; i + 3 < bytes.length; i += BYTES_PER_VALUE) {
|
|
3682
|
-
const first = bytes[i];
|
|
3683
|
-
const second = bytes[i + 1];
|
|
3684
|
-
bytes[i] = bytes[i + 3];
|
|
3685
|
-
bytes[i + 1] = bytes[i + 2];
|
|
3686
|
-
bytes[i + 2] = second;
|
|
3687
|
-
bytes[i + 3] = first;
|
|
3688
|
-
}
|
|
3689
|
-
}
|
|
3690
|
-
function littleEndianBytesOf(values) {
|
|
3691
|
-
const bytes = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
|
|
3692
|
-
if (!LITTLE_ENDIAN) swapEveryValue(bytes);
|
|
3693
|
-
return bytes;
|
|
3694
|
-
}
|
|
3695
|
-
function valuesOf(bytes) {
|
|
3696
|
-
if (LITTLE_ENDIAN && bytes.byteOffset % BYTES_PER_VALUE === 0) {
|
|
3697
|
-
return new Uint32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / BYTES_PER_VALUE));
|
|
3698
|
-
}
|
|
3699
|
-
const copy = bytes.slice(0, bytes.byteLength - bytes.byteLength % BYTES_PER_VALUE);
|
|
3700
|
-
if (!LITTLE_ENDIAN) swapEveryValue(copy);
|
|
3701
|
-
return new Uint32Array(copy.buffer, 0, copy.byteLength / BYTES_PER_VALUE);
|
|
3702
|
-
}
|
|
3703
|
-
function savedTopLayer(state, ordinal) {
|
|
3704
|
-
if (ordinal === NO_ORDINAL) return NO_LAYER;
|
|
3705
|
-
return Math.min(nodeMaxLayer(state, ordinal), MAX_LAYER_CAP);
|
|
3706
|
-
}
|
|
3707
|
-
function neighbourValueCount(state, topLayers, start, end) {
|
|
3708
|
-
let values = 0;
|
|
3709
|
-
for (let number = start; number < end; number++) {
|
|
3710
|
-
const top = topLayers[number];
|
|
3711
|
-
if (top < 0) continue;
|
|
3712
|
-
values += state.adjacency.level0Stride + top * state.adjacency.upperStride;
|
|
3713
|
-
}
|
|
3714
|
-
return values;
|
|
3715
|
-
}
|
|
3716
|
-
function serializePart(state, numbers, start, end) {
|
|
3717
|
-
const { numberOfOrdinal, ordinalOfNumber, topLayers } = numbers;
|
|
3718
|
-
const adjacency = state.adjacency;
|
|
3719
|
-
const levels = new Uint8Array(end - start);
|
|
3720
|
-
const values = new Uint32Array(neighbourValueCount(state, topLayers, start, end));
|
|
3721
|
-
let cursor = 0;
|
|
3722
|
-
for (let number = start; number < end; number++) {
|
|
3723
|
-
const top = topLayers[number];
|
|
3724
|
-
levels[number - start] = top + 1;
|
|
3725
|
-
for (let layer = 0; layer <= top; layer++) {
|
|
3726
|
-
const base = layerBase(adjacency, ordinalOfNumber[number], layer);
|
|
3727
|
-
const array = layerArray(adjacency, layer);
|
|
3728
|
-
const held = base === -1 ? 0 : Math.min(array[base], maxConns(state, layer));
|
|
3729
|
-
const countAt = cursor;
|
|
3730
|
-
cursor += 1;
|
|
3731
|
-
for (let i = 1; i <= held; i++) {
|
|
3732
|
-
const neighbourOrdinal = array[base + i];
|
|
3733
|
-
if (neighbourOrdinal < 0 || neighbourOrdinal >= numberOfOrdinal.length) continue;
|
|
3734
|
-
const neighbour = numberOfOrdinal[neighbourOrdinal];
|
|
3735
|
-
if (neighbour === NO_NUMBER || neighbour === number || topLayers[neighbour] < layer) continue;
|
|
3736
|
-
values[cursor] = neighbour;
|
|
3737
|
-
cursor += 1;
|
|
3738
|
-
}
|
|
3739
|
-
values[countAt] = cursor - countAt - 1;
|
|
3740
|
-
}
|
|
3741
|
-
}
|
|
3742
|
-
return { levels, neighbours: littleEndianBytesOf(values.subarray(0, cursor)) };
|
|
3743
|
-
}
|
|
3744
|
-
function serializeNumberedGraphParts(state, numberOfOrdinal, ordinalOfNumber, partSize) {
|
|
3745
|
-
const slots = adjacencySlots(state.adjacency);
|
|
3746
|
-
const topLayers = new Int8Array(ordinalOfNumber.length).fill(-1);
|
|
3747
|
-
for (let number = 0; number < ordinalOfNumber.length; number++) {
|
|
3748
|
-
const ordinal = ordinalOfNumber[number];
|
|
3749
|
-
if (ordinal >= slots) continue;
|
|
3750
|
-
topLayers[number] = savedTopLayer(state, ordinal);
|
|
3751
|
-
}
|
|
3752
|
-
const entryOrdinal = entryPointOf(state);
|
|
3753
|
-
const entryNumber = entryOrdinal >= 0 && entryOrdinal < numberOfOrdinal.length ? numberOfOrdinal[entryOrdinal] : NO_NUMBER;
|
|
3754
|
-
const entryHoldsNode = entryNumber !== NO_NUMBER && topLayers[entryNumber] >= 0;
|
|
3755
|
-
const header = {
|
|
3756
|
-
entryPoint: entryHoldsNode ? entryNumber : null,
|
|
3757
|
-
maxLayer: Math.max(0, Math.min(topLayerOf(state), MAX_LAYER_CAP)),
|
|
3758
|
-
m: state.M,
|
|
3759
|
-
efConstruction: state.efCons,
|
|
3760
|
-
metric: state.buildMetric
|
|
3761
|
-
};
|
|
3762
|
-
const numbers = { numberOfOrdinal, ordinalOfNumber, topLayers };
|
|
3763
|
-
const parts = [];
|
|
3764
|
-
for (let start = 0; start < ordinalOfNumber.length; start += partSize) {
|
|
3765
|
-
const end = Math.min(start + partSize, ordinalOfNumber.length);
|
|
3766
|
-
parts.push({ ...header, ...serializePart(state, numbers, start, end) });
|
|
3767
|
-
}
|
|
3768
|
-
return parts;
|
|
3769
|
-
}
|
|
3770
|
-
function graphWithoutNodes(part, firstNumber, numbers) {
|
|
3771
|
-
const values = valuesOf(part.neighbours);
|
|
3772
|
-
const levels = part.levels.slice();
|
|
3773
|
-
const kept = new Uint32Array(values.length);
|
|
3774
|
-
let cursor = 0;
|
|
3775
|
-
let length = 0;
|
|
3776
|
-
for (let at = 0; at < part.levels.length; at++) {
|
|
3777
|
-
const start = cursor;
|
|
3778
|
-
for (let layer = 0; layer < part.levels[at]; layer++) cursor += values[cursor] + 1;
|
|
3779
|
-
if (numbers.has(firstNumber + at)) {
|
|
3780
|
-
levels[at] = 0;
|
|
3781
|
-
continue;
|
|
3782
|
-
}
|
|
3783
|
-
kept.set(values.subarray(start, cursor), length);
|
|
3784
|
-
length += cursor - start;
|
|
3785
|
-
}
|
|
3786
|
-
const entryPoint = part.entryPoint !== null && numbers.has(part.entryPoint) ? null : part.entryPoint;
|
|
3787
|
-
return { ...part, entryPoint, levels, neighbours: littleEndianBytesOf(kept.subarray(0, length)) };
|
|
3788
|
-
}
|
|
3789
|
-
function endsInsideAList() {
|
|
3790
|
-
throw new NarsilError(
|
|
3791
|
-
ErrorCodes.PERSISTENCE_LOAD_FAILED,
|
|
3792
|
-
"Invalid vector graph payload: neighbours ends inside a list"
|
|
3793
|
-
);
|
|
3794
|
-
}
|
|
3795
|
-
function requireWholeNeighbourLists(graph) {
|
|
3796
|
-
const values = valuesOf(graph.neighbours);
|
|
3797
|
-
if (values.length * BYTES_PER_VALUE !== graph.neighbours.byteLength) endsInsideAList();
|
|
3798
|
-
let cursor = 0;
|
|
3799
|
-
for (let number = 0; number < graph.levels.length; number++) {
|
|
3800
|
-
for (let layer = 0; layer < graph.levels[number]; layer++) {
|
|
3801
|
-
if (cursor >= values.length) endsInsideAList();
|
|
3802
|
-
const count = values[cursor];
|
|
3803
|
-
if (count > values.length - cursor - 1) endsInsideAList();
|
|
3804
|
-
cursor += count + 1;
|
|
3805
|
-
}
|
|
3806
|
-
}
|
|
3807
|
-
}
|
|
3808
|
-
function topLayerInParts(graph, number) {
|
|
3809
|
-
const part = graph.parts[Math.floor(number / graph.partSize)];
|
|
3810
|
-
if (part === void 0) return -1;
|
|
3811
|
-
const at = number % graph.partSize;
|
|
3812
|
-
return at < part.levels.length ? part.levels[at] - 1 : -1;
|
|
3813
|
-
}
|
|
3814
|
-
function highestNodeOrdinal(graph, ordinalAt2) {
|
|
3815
|
-
let highest = -1;
|
|
3816
|
-
for (let p = 0; p < graph.parts.length; p++) {
|
|
3817
|
-
const levels = graph.parts[p].levels;
|
|
3818
|
-
for (let at = 0; at < levels.length; at++) {
|
|
3819
|
-
const ordinal = ordinalAt2(p * graph.partSize + at);
|
|
3820
|
-
if (levels[at] > 0 && ordinal > highest) highest = ordinal;
|
|
3821
|
-
}
|
|
3822
|
-
}
|
|
3823
|
-
return highest;
|
|
3824
|
-
}
|
|
3825
|
-
function deserializeNumberedGraph(state, graph, ordinalOfNumber) {
|
|
3826
|
-
for (const part of graph.parts) requireWholeNeighbourLists(part);
|
|
3827
|
-
resetGraph(state);
|
|
3828
|
-
const ordinalAt2 = (number) => number < ordinalOfNumber.length ? ordinalOfNumber[number] : NO_ORDINAL;
|
|
3829
|
-
const highestOrdinal = highestNodeOrdinal(graph, ordinalAt2);
|
|
3830
|
-
if (highestOrdinal >= 0) ensureCapacity(state, highestOrdinal + 1);
|
|
3831
|
-
const kept = [];
|
|
3832
|
-
let highestLayer = -1;
|
|
3833
|
-
let nodeOnHighestLayer = NO_ORDINAL;
|
|
3834
|
-
for (let p = 0; p < graph.parts.length; p++) {
|
|
3835
|
-
const part = graph.parts[p];
|
|
3836
|
-
const values = valuesOf(part.neighbours);
|
|
3837
|
-
let cursor = 0;
|
|
3838
|
-
for (let at = 0; at < part.levels.length; at++) {
|
|
3839
|
-
const number = p * graph.partSize + at;
|
|
3840
|
-
const top = part.levels[at] - 1;
|
|
3841
|
-
if (top < 0) continue;
|
|
3842
|
-
const ordinal = ordinalAt2(number);
|
|
3843
|
-
const keptTop = Math.min(top, MAX_LAYER_CAP);
|
|
3844
|
-
if (ordinal !== NO_ORDINAL) {
|
|
3845
|
-
createNode(state.adjacency, ordinal, keptTop);
|
|
3846
|
-
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
3847
|
-
if (keptTop > highestLayer) {
|
|
3848
|
-
highestLayer = keptTop;
|
|
3849
|
-
nodeOnHighestLayer = ordinal;
|
|
3850
|
-
}
|
|
3851
|
-
}
|
|
3852
|
-
for (let layer = 0; layer <= top; layer++) {
|
|
3853
|
-
const count = values[cursor];
|
|
3854
|
-
kept.length = 0;
|
|
3855
|
-
const limit = maxConns(state, layer);
|
|
3856
|
-
for (let i = 1; i <= count && kept.length < limit; i++) {
|
|
3857
|
-
const neighbour = values[cursor + i];
|
|
3858
|
-
const neighbourOrdinal = ordinalAt2(neighbour);
|
|
3859
|
-
if (neighbourOrdinal === NO_ORDINAL || neighbour === number) continue;
|
|
3860
|
-
if (topLayerInParts(graph, neighbour) < layer) continue;
|
|
3861
|
-
if (!kept.includes(neighbourOrdinal)) kept.push(neighbourOrdinal);
|
|
3862
|
-
}
|
|
3863
|
-
cursor += count + 1;
|
|
3864
|
-
if (ordinal !== NO_ORDINAL && layer <= keptTop) {
|
|
3865
|
-
writeNeighbors(state.adjacency, ordinal, layer, kept, kept.length);
|
|
3866
|
-
}
|
|
3867
|
-
}
|
|
3868
|
-
}
|
|
3869
|
-
}
|
|
3870
|
-
const first = graph.parts[0];
|
|
3871
|
-
const entryPoint = first === void 0 ? null : first.entryPoint;
|
|
3872
|
-
const entryOrdinal = entryPoint === null ? NO_ORDINAL : ordinalAt2(entryPoint);
|
|
3873
|
-
const entryTop = entryPoint === null ? -1 : Math.min(topLayerInParts(graph, entryPoint), MAX_LAYER_CAP);
|
|
3874
|
-
const entryIsUsable = entryOrdinal !== NO_ORDINAL && entryTop >= 0;
|
|
3875
|
-
Atomics.store(state.header, GRAPH_ENTRY_POINT, entryIsUsable ? entryOrdinal : nodeOnHighestLayer);
|
|
3876
|
-
Atomics.store(state.header, GRAPH_TOP_LAYER, entryIsUsable ? entryTop : highestLayer);
|
|
3877
|
-
leaveIncomingUncounted(state);
|
|
3878
|
-
}
|
|
3879
|
-
|
|
3880
|
-
// src/vector/hnsw/persistence.ts
|
|
3881
|
-
function resolveNodes(state, store, data) {
|
|
3882
|
-
const nodes = [];
|
|
3883
|
-
let maxOrd = -1;
|
|
3884
|
-
for (const [docId, maxLayer, layerConns] of data.nodes) {
|
|
3885
|
-
const ord = store.getOrdinal(docId);
|
|
3886
|
-
if (ord === void 0 || !store.holdsOrdinal(ord)) continue;
|
|
3887
|
-
const clampedMaxLayer = Math.min(Math.max(maxLayer, 0), MAX_LAYER_CAP);
|
|
3888
|
-
const layers = [];
|
|
3889
|
-
for (const [layer, neighbors] of layerConns) {
|
|
3890
|
-
if (layer < 0 || layer > clampedMaxLayer) continue;
|
|
3891
|
-
const limit = maxConns(state, layer);
|
|
3892
|
-
const resolved = [];
|
|
3893
|
-
for (const neighborDoc of neighbors) {
|
|
3894
|
-
if (resolved.length >= limit) break;
|
|
3895
|
-
const neighborOrd = store.getOrdinal(neighborDoc);
|
|
3896
|
-
if (neighborOrd === void 0) continue;
|
|
3897
|
-
addConnection(resolved, neighborOrd);
|
|
3898
|
-
if (neighborOrd > maxOrd) maxOrd = neighborOrd;
|
|
3899
|
-
}
|
|
3900
|
-
layers.push([layer, resolved]);
|
|
3901
|
-
}
|
|
3902
|
-
if (ord > maxOrd) maxOrd = ord;
|
|
3903
|
-
nodes.push({ ord, maxLayer: clampedMaxLayer, layers });
|
|
3904
|
-
}
|
|
3905
|
-
return { nodes, maxOrd };
|
|
3906
|
-
}
|
|
3907
|
-
function deserializeGraph(state, store, data) {
|
|
3908
|
-
resetGraph(state);
|
|
3909
|
-
const { nodes, maxOrd } = resolveNodes(state, store, data);
|
|
3910
|
-
if (maxOrd >= 0) {
|
|
3911
|
-
ensureCapacity(state, maxOrd + 1);
|
|
3912
|
-
}
|
|
3913
|
-
for (const node of nodes) {
|
|
3914
|
-
createNode(state.adjacency, node.ord, node.maxLayer);
|
|
3915
|
-
for (const [layer, neighbors] of node.layers) {
|
|
3916
|
-
writeNeighbors(state.adjacency, node.ord, layer, neighbors, neighbors.length);
|
|
3917
|
-
}
|
|
3918
|
-
Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
|
|
3919
|
-
}
|
|
3920
|
-
if (data.entryPoint != null && data.entryPoint !== "") {
|
|
3921
|
-
const epOrd = store.getOrdinal(data.entryPoint);
|
|
3922
|
-
if (epOrd !== void 0 && nodeExists(state, epOrd)) {
|
|
3923
|
-
Atomics.store(state.header, GRAPH_ENTRY_POINT, epOrd);
|
|
3924
|
-
Atomics.store(state.header, GRAPH_TOP_LAYER, Math.min(Math.max(data.maxLayer, 0), MAX_LAYER_CAP));
|
|
3925
|
-
}
|
|
3926
|
-
}
|
|
3927
|
-
if (entryPointOf(state) === -1 && Atomics.load(state.header, GRAPH_NODE_COUNT) > 0) {
|
|
3928
|
-
let bestOrd = -1;
|
|
3929
|
-
let bestLayer = -1;
|
|
3930
|
-
const slots = adjacencySlots(state.adjacency);
|
|
3931
|
-
for (let ord = 0; ord < slots; ord++) {
|
|
3932
|
-
const level2 = nodeMaxLayer(state, ord);
|
|
3933
|
-
if (level2 === -1) continue;
|
|
3934
|
-
if (level2 > bestLayer) {
|
|
3935
|
-
bestLayer = level2;
|
|
3936
|
-
bestOrd = ord;
|
|
3937
|
-
}
|
|
3938
|
-
}
|
|
3939
|
-
Atomics.store(state.header, GRAPH_ENTRY_POINT, bestOrd);
|
|
3940
|
-
Atomics.store(state.header, GRAPH_TOP_LAYER, bestLayer);
|
|
3941
|
-
}
|
|
3942
|
-
leaveIncomingUncounted(state);
|
|
3943
|
-
}
|
|
3944
|
-
|
|
3945
|
-
// src/vector/hnsw/scratch-bytes.ts
|
|
3946
|
-
function listBytes(list) {
|
|
3947
|
-
return list.ords.byteLength + list.distances.byteLength;
|
|
3948
|
-
}
|
|
3949
|
-
function workspaceBytes(workspace) {
|
|
3950
|
-
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;
|
|
3951
|
-
for (const list of workspace.linkSelections) bytes += listBytes(list);
|
|
3952
|
-
return bytes;
|
|
3953
|
-
}
|
|
3954
|
-
function searchScratchBytes(state) {
|
|
3955
|
-
const held = workspaceBytes(state.workspace) + state.neighborScratch.byteLength + state.visited.byteLength;
|
|
3956
|
-
const native = attachedNativeField(state);
|
|
3957
|
-
return native === null ? held : held + nativeScratchBytes(state, native);
|
|
3958
|
-
}
|
|
3959
|
-
|
|
3960
|
-
// src/vector/hnsw/snapshot.ts
|
|
3961
|
-
function exportSnapshot(state) {
|
|
3962
|
-
const adj = state.adjacency;
|
|
3963
|
-
const slots = adjacencySlots(adj);
|
|
3964
|
-
const used = upperUsed(adj);
|
|
3965
|
-
const stride = adj.level0Stride;
|
|
3966
|
-
rebindNodes(adj);
|
|
3967
|
-
reachTombstone(state, slots);
|
|
3968
|
-
return {
|
|
3969
|
-
dimension: state.dimension,
|
|
3970
|
-
m: state.M,
|
|
3971
|
-
efConstruction: state.efCons,
|
|
3972
|
-
metric: state.buildMetric,
|
|
3973
|
-
slots,
|
|
3974
|
-
upperUsed: used,
|
|
3975
|
-
nodeLevels: adj.nodeLevels.slice(0, slots),
|
|
3976
|
-
level0: adj.level0.slice(0, slots * stride),
|
|
3977
|
-
upperBase: adj.upperBase.slice(0, slots),
|
|
3978
|
-
upper: adj.upper.slice(0, used),
|
|
3979
|
-
tombstones: state.tombstones.slice(0, slots),
|
|
3980
|
-
tombstoneCount: Atomics.load(state.header, GRAPH_TOMBSTONE_COUNT),
|
|
3981
|
-
nodeCount: Atomics.load(state.header, GRAPH_NODE_COUNT),
|
|
3982
|
-
entryPointOrd: Atomics.load(state.header, GRAPH_ENTRY_POINT),
|
|
3983
|
-
topLayer: Atomics.load(state.header, GRAPH_TOP_LAYER)
|
|
3984
|
-
};
|
|
3985
|
-
}
|
|
3986
|
-
function restoreSnapshot(state, snapshot) {
|
|
3987
|
-
resetGraph(state);
|
|
3988
|
-
const adj = state.adjacency;
|
|
3989
|
-
ensureAdjacencyCapacity(adj, snapshot.slots);
|
|
3990
|
-
adj.nodeLevels.set(snapshot.nodeLevels);
|
|
3991
|
-
adj.level0.set(snapshot.level0);
|
|
3992
|
-
adj.upperBase.set(snapshot.upperBase);
|
|
3993
|
-
ensureUpperCapacity(adj, snapshot.upper.length);
|
|
3994
|
-
adj.upper.set(snapshot.upper);
|
|
3995
|
-
Atomics.store(state.header, GRAPH_UPPER_USED, snapshot.upperUsed);
|
|
3996
|
-
Atomics.store(state.header, GRAPH_SLOTS, snapshot.slots);
|
|
3997
|
-
state.tombstones = fixedView(adj.handles.tombstones, Uint8Array);
|
|
3998
|
-
state.tombstones.set(snapshot.tombstones);
|
|
3999
|
-
Atomics.store(state.header, GRAPH_TOMBSTONE_COUNT, snapshot.tombstoneCount);
|
|
4000
|
-
Atomics.store(state.header, GRAPH_NODE_COUNT, snapshot.nodeCount);
|
|
4001
|
-
Atomics.store(state.header, GRAPH_ENTRY_POINT, snapshot.entryPointOrd);
|
|
4002
|
-
Atomics.store(state.header, GRAPH_TOP_LAYER, snapshot.topLayer);
|
|
4003
|
-
leaveIncomingUncounted(state);
|
|
4004
|
-
}
|
|
4005
|
-
|
|
4006
|
-
// src/vector/hnsw/index.ts
|
|
4007
|
-
function createHNSWIndex(dimension, store, config, quantizer, handles) {
|
|
4008
|
-
const M = config?.m ?? 16;
|
|
4009
|
-
const shared = handles ?? createSharedGraphHandles({
|
|
4010
|
-
m: M,
|
|
4011
|
-
mMax0: M * 2,
|
|
4012
|
-
efConstruction: config?.efConstruction ?? 200,
|
|
4013
|
-
metric: config?.metric ?? "cosine"
|
|
4014
|
-
});
|
|
4015
|
-
const state = openGraphState(shared, dimension, store, quantizer, 0);
|
|
4016
|
-
const docIdOf = (ord) => store.docIdForOrdinal(ord);
|
|
4017
|
-
function exclusively(operation) {
|
|
4018
|
-
lockGraphExclusive(state.locks);
|
|
4019
|
-
try {
|
|
4020
|
-
return operation();
|
|
4021
|
-
} finally {
|
|
4022
|
-
unlockGraphExclusive(state.locks);
|
|
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
|
+
};
|
|
3766
|
+
}
|
|
3767
|
+
|
|
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);
|
|
4023
3774
|
}
|
|
3775
|
+
return opened;
|
|
4024
3776
|
}
|
|
4025
|
-
function
|
|
4026
|
-
const
|
|
4027
|
-
if (
|
|
4028
|
-
|
|
4029
|
-
}
|
|
4030
|
-
const entry = store.entryForOrdinal(ord);
|
|
4031
|
-
if (!entry) {
|
|
4032
|
-
throw new Error(`Cannot insert HNSW node: vector for "${docId}" not found in VectorStore`);
|
|
4033
|
-
}
|
|
4034
|
-
if (entry.vector.length !== dimension) {
|
|
4035
|
-
throw new NarsilError(
|
|
4036
|
-
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
4037
|
-
`Vector dimension mismatch: expected ${dimension}, got ${entry.vector.length}`,
|
|
4038
|
-
{ docId, expected: dimension, received: entry.vector.length }
|
|
4039
|
-
);
|
|
4040
|
-
}
|
|
4041
|
-
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;
|
|
4042
3781
|
}
|
|
4043
|
-
function
|
|
4044
|
-
const
|
|
4045
|
-
|
|
4046
|
-
|
|
4047
|
-
if (isTombstoned(state, ord)) continue;
|
|
4048
|
-
const docId = store.docIdForOrdinal(ord);
|
|
4049
|
-
if (docId === void 0) continue;
|
|
4050
|
-
const entry = store.entryForOrdinal(ord);
|
|
4051
|
-
if (!entry) continue;
|
|
4052
|
-
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`);
|
|
4053
3786
|
}
|
|
4054
|
-
|
|
4055
|
-
function compactionNeeded() {
|
|
4056
|
-
const nodeCount = nodeCountOf(state);
|
|
4057
|
-
if (nodeCount === 0) return false;
|
|
4058
|
-
const tombstones = tombstoneCountOf(state);
|
|
4059
|
-
return tombstones / nodeCount > COMPACTION_TOMBSTONE_RATIO || tombstones > COMPACTION_ABSOLUTE_THRESHOLD;
|
|
3787
|
+
return ordinal;
|
|
4060
3788
|
}
|
|
4061
3789
|
return {
|
|
4062
|
-
|
|
4063
|
-
|
|
4064
|
-
|
|
3790
|
+
dimension,
|
|
3791
|
+
bits,
|
|
3792
|
+
metric,
|
|
4065
3793
|
get size() {
|
|
4066
|
-
return
|
|
3794
|
+
return shared()?.size ?? 0;
|
|
4067
3795
|
},
|
|
4068
|
-
get
|
|
4069
|
-
return
|
|
3796
|
+
get centroid() {
|
|
3797
|
+
return shared()?.centroid ?? null;
|
|
4070
3798
|
},
|
|
4071
|
-
|
|
4072
|
-
|
|
4073
|
-
|
|
3799
|
+
isCalibrated: () => shared()?.isCalibrated() ?? false,
|
|
3800
|
+
calibrate(ordinals) {
|
|
3801
|
+
if (ordinals.length > 0) requireShared().calibrateFrom(ordinals);
|
|
4074
3802
|
},
|
|
4075
|
-
|
|
4076
|
-
|
|
3803
|
+
measure(ordinals, sums) {
|
|
3804
|
+
if (ordinals.length > 0) requireShared().measureInto(ordinals, sums);
|
|
4077
3805
|
},
|
|
4078
|
-
|
|
4079
|
-
|
|
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);
|
|
4080
3811
|
},
|
|
4081
|
-
|
|
4082
|
-
|
|
3812
|
+
writeCodes(ordinal) {
|
|
3813
|
+
shared()?.writeCodes(ordinal);
|
|
4083
3814
|
},
|
|
4084
|
-
|
|
4085
|
-
|
|
3815
|
+
remove(docId) {
|
|
3816
|
+
const ordinal = store.getOrdinal(docId);
|
|
3817
|
+
if (ordinal !== void 0) shared()?.clearCodes(ordinal);
|
|
4086
3818
|
},
|
|
4087
|
-
|
|
4088
|
-
|
|
3819
|
+
removeOrdinal(ordinal) {
|
|
3820
|
+
shared()?.clearCodes(ordinal);
|
|
4089
3821
|
},
|
|
4090
|
-
|
|
4091
|
-
|
|
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);
|
|
4092
3828
|
},
|
|
4093
|
-
|
|
4094
|
-
|
|
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);
|
|
4095
3834
|
},
|
|
4096
|
-
|
|
4097
|
-
|
|
4098
|
-
|
|
4099
|
-
|
|
4100
|
-
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);
|
|
4101
3839
|
},
|
|
4102
|
-
|
|
4103
|
-
|
|
4104
|
-
holdsTombstone: (ordinal) => hasNode(state.adjacency, ordinal) && isTombstoned(state, ordinal),
|
|
4105
|
-
has: (docId) => {
|
|
4106
|
-
const ord = store.getOrdinal(docId);
|
|
4107
|
-
return ord !== void 0 && hasNode(state.adjacency, ord) && !isTombstoned(state, ord);
|
|
3840
|
+
restoreRecord(docId, record) {
|
|
3841
|
+
requireShared().restoreRecord(ordinalOf(docId), record);
|
|
4108
3842
|
},
|
|
4109
|
-
|
|
4110
|
-
|
|
4111
|
-
return ord !== void 0 && isTombstoned(state, ord);
|
|
3843
|
+
restoreRecordAtOrdinal(ordinal, record) {
|
|
3844
|
+
requireShared().restoreRecord(ordinal, record);
|
|
4112
3845
|
},
|
|
4113
|
-
|
|
4114
|
-
|
|
4115
|
-
retire: () => Atomics.store(shared.header, GRAPH_RETIRED, 1),
|
|
4116
|
-
entries: entriesIterator,
|
|
4117
|
-
compactionNeeded,
|
|
4118
|
-
compactTombstones: () => exclusively(() => compactTombstones(state)),
|
|
4119
|
-
connectUnreached: () => exclusively(() => connectAfterBuild(state)),
|
|
4120
|
-
rebuild: () => exclusively(() => rebuild(state)),
|
|
4121
|
-
exclusively,
|
|
4122
|
-
deserialize: (data) => exclusively(() => deserializeGraph(state, store, data)),
|
|
4123
|
-
serializeNumbered: (numberOfOrdinal, ordinalOfNumber, partSize) => serializeNumberedGraphParts(state, numberOfOrdinal, ordinalOfNumber, partSize),
|
|
4124
|
-
deserializeNumbered: (graph, ordinalOfNumber) => exclusively(() => deserializeNumberedGraph(state, graph, ordinalOfNumber)),
|
|
4125
|
-
exportSnapshot: () => exportSnapshot(state),
|
|
4126
|
-
restoreSnapshot: (snapshot) => exclusively(() => restoreSnapshot(state, snapshot))
|
|
4127
|
-
};
|
|
4128
|
-
}
|
|
4129
|
-
|
|
4130
|
-
// src/vector/vector-index/persistence.ts
|
|
4131
|
-
function recordFor(state, quantizer, docId) {
|
|
4132
|
-
const record = quantizer.recordOf(docId);
|
|
4133
|
-
if (record !== void 0) return record;
|
|
4134
|
-
if (!state.store.has(docId)) return void 0;
|
|
4135
|
-
quantizer.quantize(docId);
|
|
4136
|
-
return quantizer.recordOf(docId);
|
|
4137
|
-
}
|
|
4138
|
-
function codedCentroid(state) {
|
|
4139
|
-
const centroid = state.osq?.centroid ?? null;
|
|
4140
|
-
if (centroid === null || state.store.handles.codeLayout === null || state.hnsw === null) return null;
|
|
4141
|
-
return Array.from(centroid);
|
|
4142
|
-
}
|
|
4143
|
-
function sameCentroid(state, planned) {
|
|
4144
|
-
const current = state.osq?.centroid ?? null;
|
|
4145
|
-
if (current === null || current.length !== planned.length) return false;
|
|
4146
|
-
for (let i = 0; i < planned.length; i++) {
|
|
4147
|
-
if (current[i] !== planned[i]) return false;
|
|
4148
|
-
}
|
|
4149
|
-
return true;
|
|
4150
|
-
}
|
|
4151
|
-
function codesAgainstPlannedCentroid(quantizer, slotStride, centroid, vectors, ordinals) {
|
|
4152
|
-
const planned = Float32Array.from(centroid);
|
|
4153
|
-
const dimension = planned.length;
|
|
4154
|
-
const scratch = createOsqScratch(dimension);
|
|
4155
|
-
const records = new Uint8Array(ordinals.length * slotStride);
|
|
4156
|
-
const trailer = new DataView(records.buffer, records.byteOffset, records.byteLength);
|
|
4157
|
-
for (let i = 0; i < ordinals.length; i++) {
|
|
4158
|
-
if (ordinals[i] === NO_LIVE_VECTOR_AT_POSITION) continue;
|
|
4159
|
-
const vector = vectors.subarray(i * dimension, (i + 1) * dimension);
|
|
4160
|
-
const code = osqQuantize(vector, planned, quantizer.bits, quantizer.metric, scratch);
|
|
4161
|
-
writeRecord(records, i * slotStride, code, quantizer.bits, trailer);
|
|
4162
|
-
}
|
|
4163
|
-
return { bits: quantizer.bits, centroid, records };
|
|
4164
|
-
}
|
|
4165
|
-
function partCodes(state, docIds, centroid, tombstonedAt, vectors, ordinals) {
|
|
4166
|
-
const quantizer = state.osq;
|
|
4167
|
-
const layout = state.store.handles.codeLayout;
|
|
4168
|
-
if (centroid === null || quantizer === null || layout === null) return null;
|
|
4169
|
-
if (!sameCentroid(state, centroid)) {
|
|
4170
|
-
return codesAgainstPlannedCentroid(quantizer, layout.slotStride, centroid, vectors, ordinals);
|
|
4171
|
-
}
|
|
4172
|
-
const records = new Uint8Array(docIds.length * layout.slotStride);
|
|
4173
|
-
for (let i = 0; i < docIds.length; i++) {
|
|
4174
|
-
const tombstoned = tombstonedAt.get(i);
|
|
4175
|
-
const record = tombstoned === void 0 ? recordFor(state, quantizer, docIds[i]) : quantizer.recordAtOrdinal(tombstoned);
|
|
4176
|
-
if (record !== void 0) records.set(record, i * layout.slotStride);
|
|
4177
|
-
}
|
|
4178
|
-
return { bits: quantizer.bits, centroid, records };
|
|
4179
|
-
}
|
|
4180
|
-
function splitSequences(parts) {
|
|
4181
|
-
const sequences = [];
|
|
4182
|
-
let current = null;
|
|
4183
|
-
for (const part of parts) {
|
|
4184
|
-
if (current === null || part.part === 0) {
|
|
4185
|
-
current = { docIds: [], graphs: [], codes: null, codesComplete: true };
|
|
4186
|
-
sequences.push(current);
|
|
4187
|
-
}
|
|
4188
|
-
current.docIds.push(...part.docIds);
|
|
4189
|
-
for (let index = 0; index < part.graphs.length; index++) {
|
|
4190
|
-
const graph = part.graphs[index];
|
|
4191
|
-
const held = current.graphs[index];
|
|
4192
|
-
if (held === void 0) current.graphs[index] = { ...graph, nodes: [...graph.nodes] };
|
|
4193
|
-
else held.nodes.push(...graph.nodes);
|
|
4194
|
-
}
|
|
4195
|
-
if (part.codes === null) {
|
|
4196
|
-
if (part.docIds.length > 0) current.codesComplete = false;
|
|
4197
|
-
continue;
|
|
4198
|
-
}
|
|
4199
|
-
if (current.codes === null) {
|
|
4200
|
-
current.codes = { bits: part.codes.bits, centroid: part.codes.centroid, records: part.codes.records };
|
|
4201
|
-
continue;
|
|
4202
|
-
}
|
|
4203
|
-
if (current.codes.bits !== part.codes.bits) {
|
|
4204
|
-
current.codesComplete = false;
|
|
4205
|
-
continue;
|
|
4206
|
-
}
|
|
4207
|
-
const joined = new Uint8Array(current.codes.records.length + part.codes.records.length);
|
|
4208
|
-
joined.set(current.codes.records, 0);
|
|
4209
|
-
joined.set(part.codes.records, current.codes.records.length);
|
|
4210
|
-
current.codes = { ...current.codes, records: joined };
|
|
4211
|
-
}
|
|
4212
|
-
return sequences;
|
|
4213
|
-
}
|
|
4214
|
-
function restoreCodes(state, sequences) {
|
|
4215
|
-
const quantizer = state.osq;
|
|
4216
|
-
const layout = state.store.handles.codeLayout;
|
|
4217
|
-
if (quantizer === null || layout === null) return;
|
|
4218
|
-
const usable = sequences.filter((sequence) => sequence.docIds.length > 0);
|
|
4219
|
-
const single = usable.length === 1 ? usable[0] : null;
|
|
4220
|
-
if (single === null || single.codes === null || !single.codesComplete || single.codes.bits !== quantizer.bits) {
|
|
4221
|
-
recalibrateFromStore(state);
|
|
4222
|
-
return;
|
|
4223
|
-
}
|
|
4224
|
-
quantizer.restoreCentroid(Float32Array.from(single.codes.centroid));
|
|
4225
|
-
const recordBytes = layout.slotStride;
|
|
4226
|
-
for (let i = 0; i < single.docIds.length; i++) {
|
|
4227
|
-
quantizer.restoreRecord(single.docIds[i], single.codes.records.subarray(i * recordBytes, (i + 1) * recordBytes));
|
|
4228
|
-
}
|
|
4229
|
-
}
|
|
4230
|
-
function restoreGraphs(state, graphs) {
|
|
4231
|
-
if (graphs.length === 0) {
|
|
4232
|
-
for (const docId of state.store.docIds()) {
|
|
4233
|
-
if (!state.tombstones.has(docId)) state.buffer.add(docId);
|
|
4234
|
-
}
|
|
4235
|
-
return;
|
|
4236
|
-
}
|
|
4237
|
-
const graphData = graphs[0];
|
|
4238
|
-
const restoredHnsw = createHNSWIndex(
|
|
4239
|
-
state.dimension,
|
|
4240
|
-
state.store,
|
|
4241
|
-
{
|
|
4242
|
-
m: graphData.m ?? state.hnswConfig?.m,
|
|
4243
|
-
efConstruction: graphData.efConstruction ?? state.hnswConfig?.efConstruction,
|
|
4244
|
-
metric: graphData.metric ?? state.hnswConfig?.metric
|
|
3846
|
+
restoreCentroid(centroid) {
|
|
3847
|
+
requireShared().writeCentroid(centroid);
|
|
4245
3848
|
},
|
|
4246
|
-
|
|
4247
|
-
|
|
4248
|
-
|
|
4249
|
-
|
|
4250
|
-
|
|
4251
|
-
|
|
4252
|
-
if (!restoredHnsw.has(nodeDocId) && state.store.has(nodeDocId)) restoredHnsw.insertNode(nodeDocId);
|
|
4253
|
-
}
|
|
4254
|
-
}
|
|
4255
|
-
for (const docId of state.store.docIds()) {
|
|
4256
|
-
if (state.tombstones.has(docId)) continue;
|
|
4257
|
-
if (!restoredHnsw.has(docId)) state.buffer.add(docId);
|
|
4258
|
-
}
|
|
4259
|
-
if (state.buffer.size > restoredHnsw.size) {
|
|
4260
|
-
adoptGraph(state, null);
|
|
4261
|
-
state.buffer.clear();
|
|
4262
|
-
for (const docId of state.store.docIds()) {
|
|
4263
|
-
if (!state.tombstones.has(docId)) state.buffer.add(docId);
|
|
4264
|
-
}
|
|
4265
|
-
}
|
|
4266
|
-
}
|
|
4267
|
-
function insertPart(state, part) {
|
|
4268
|
-
const dimension = state.dimension;
|
|
4269
|
-
const vectors = bytesToVectors(part.vectors);
|
|
4270
|
-
for (let i = 0; i < part.docIds.length; i++) {
|
|
4271
|
-
state.store.insert(part.docIds[i], vectors.subarray(i * dimension, (i + 1) * dimension));
|
|
4272
|
-
}
|
|
4273
|
-
}
|
|
4274
|
-
function deserialize(state, parts) {
|
|
4275
|
-
for (const part of parts) {
|
|
4276
|
-
if (part.dimension !== state.dimension) {
|
|
4277
|
-
throw new NarsilError(
|
|
4278
|
-
ErrorCodes.VECTOR_DIMENSION_MISMATCH,
|
|
4279
|
-
`Payload dimension ${part.dimension} does not match index dimension ${state.dimension}`,
|
|
4280
|
-
{ expected: state.dimension, received: part.dimension }
|
|
4281
|
-
);
|
|
4282
|
-
}
|
|
4283
|
-
}
|
|
4284
|
-
const sequences = splitSequences(parts);
|
|
4285
|
-
const graphs = [];
|
|
4286
|
-
for (const sequence of sequences) {
|
|
4287
|
-
for (const graph of sequence.graphs) {
|
|
4288
|
-
if (graph.nodes.length > 0) graphs.push(graph);
|
|
4289
|
-
}
|
|
4290
|
-
}
|
|
4291
|
-
emptyFieldBeforeRestore(state);
|
|
4292
|
-
for (const part of parts) insertPart(state, part);
|
|
4293
|
-
if (state.osq !== null && osqBitsOf(state.quantizationMode) !== null && graphs.length > 0) {
|
|
4294
|
-
restoreCodes(state, sequences);
|
|
4295
|
-
}
|
|
4296
|
-
restoreGraphs(state, graphs);
|
|
4297
|
-
}
|
|
4298
|
-
|
|
4299
|
-
// src/vector/vector-index/checkpoint-plan.ts
|
|
4300
|
-
var ORDINAL_HOLDS_NO_NUMBER = -1;
|
|
4301
|
-
function vectorsPerFile(dimension, codeBits) {
|
|
4302
|
-
const recordBytes = codeBits === 1 || codeBits === 2 || codeBits === 4 || codeBits === 8 ? osqRecordBytes(dimension, codeBits) : 0;
|
|
4303
|
-
const docIdBytes = VECTOR_FILE_STRING_HEADER_BYTES + MAX_DOC_ID_LENGTH * 3;
|
|
4304
|
-
const perVector = dimension * 4 + recordBytes + docIdBytes;
|
|
4305
|
-
const overhead = VECTOR_FILE_FIXED_OVERHEAD_BYTES + dimension * VECTOR_FILE_CENTROID_BYTES_PER_COMPONENT;
|
|
4306
|
-
const fitting = Math.floor((MAX_FILE_BYTES - overhead) / perVector);
|
|
4307
|
-
return Math.max(1, Math.min(VECTOR_FILE_MAX_VECTORS, fitting));
|
|
4308
|
-
}
|
|
4309
|
-
function fileCapacityOf(state) {
|
|
4310
|
-
return vectorsPerFile(state.dimension, osqBitsOf(state.quantizationMode));
|
|
4311
|
-
}
|
|
4312
|
-
function calibrationOf(state) {
|
|
4313
|
-
if (codedCentroid(state) === null) return null;
|
|
4314
|
-
return Atomics.load(state.store.handles.header, STORE_CALIBRATION_GENERATION);
|
|
4315
|
-
}
|
|
4316
|
-
function signatureOf(state) {
|
|
4317
|
-
return { revision: state.revision, graphSize: state.hnsw?.size ?? -1, calibration: calibrationOf(state) };
|
|
4318
|
-
}
|
|
4319
|
-
function sameSignature(a, b) {
|
|
4320
|
-
return a !== null && a.revision === b.revision && a.graphSize === b.graphSize && a.calibration === b.calibration;
|
|
4321
|
-
}
|
|
4322
|
-
function registryMatches(state, listedKeys) {
|
|
4323
|
-
const listed = listedKeys ?? [];
|
|
4324
|
-
if (listed.length !== state.savedFiles.length) return false;
|
|
4325
|
-
return state.savedFiles.every((file, index) => file.key === listed[index]);
|
|
4326
|
-
}
|
|
4327
|
-
function isLive2(state, ordinal) {
|
|
4328
|
-
if (ordinal === NO_LIVE_VECTOR_AT_POSITION) return false;
|
|
4329
|
-
const docId = state.store.docIdForOrdinal(ordinal);
|
|
4330
|
-
return docId !== void 0 && !state.tombstones.has(docId);
|
|
4331
|
-
}
|
|
4332
|
-
function isGraphTombstone(state, ordinal) {
|
|
4333
|
-
return ordinal !== NO_LIVE_VECTOR_AT_POSITION && state.hnsw !== null && state.hnsw.holdsTombstone(ordinal);
|
|
4334
|
-
}
|
|
4335
|
-
function isCarried(state, ordinal) {
|
|
4336
|
-
return isLive2(state, ordinal) || isGraphTombstone(state, ordinal);
|
|
4337
|
-
}
|
|
4338
|
-
function carriedCountOf(state, file) {
|
|
4339
|
-
let carried = 0;
|
|
4340
|
-
for (let i = 0; i < file.ordinals.length; i++) if (isCarried(state, file.ordinals[i])) carried += 1;
|
|
4341
|
-
return carried;
|
|
4342
|
-
}
|
|
4343
|
-
function deadBitsOf(state, file) {
|
|
4344
|
-
return deadBitsWhere(file.ordinals.length, (position) => !isLive2(state, file.ordinals[position]));
|
|
4345
|
-
}
|
|
4346
|
-
function filesWorthKeeping(state, listed, calibration, carriedCounts) {
|
|
4347
|
-
const kept = [];
|
|
4348
|
-
for (const file of listed) {
|
|
4349
|
-
const carried = carriedCountOf(state, file);
|
|
4350
|
-
const deadWithoutNodeShare = file.ordinals.length === 0 ? 1 : 1 - carried / file.ordinals.length;
|
|
4351
|
-
if (file.calibration !== calibration || deadWithoutNodeShare > VECTOR_FILE_REPLACED_ABOVE_DEAD_SHARE) continue;
|
|
4352
|
-
kept.push(file);
|
|
4353
|
-
carriedCounts.push(carried);
|
|
4354
|
-
}
|
|
4355
|
-
return kept;
|
|
4356
|
-
}
|
|
4357
|
-
function absorbSmallerPartialFiles(kept, carriedCounts, vectorsToWrite, capacity) {
|
|
4358
|
-
let pending = vectorsToWrite;
|
|
4359
|
-
for (let index = kept.length - 1; index >= 0 && pending > 0; index--) {
|
|
4360
|
-
if (kept[index].ordinals.length >= capacity) continue;
|
|
4361
|
-
if (carriedCounts[index] > pending) return;
|
|
4362
|
-
pending += carriedCounts[index];
|
|
4363
|
-
kept.splice(index, 1);
|
|
4364
|
-
carriedCounts.splice(index, 1);
|
|
4365
|
-
}
|
|
4366
|
-
}
|
|
4367
|
-
function ordinalsOutsideOf(state, kept) {
|
|
4368
|
-
const slots = state.store.slots;
|
|
4369
|
-
const saved = new Uint8Array(slots);
|
|
4370
|
-
for (const file of kept) {
|
|
4371
|
-
for (let i = 0; i < file.ordinals.length; i++) {
|
|
4372
|
-
const ordinal = file.ordinals[i];
|
|
4373
|
-
if (ordinal !== NO_LIVE_VECTOR_AT_POSITION && ordinal < slots) saved[ordinal] = 1;
|
|
4374
|
-
}
|
|
4375
|
-
}
|
|
4376
|
-
const outside = [];
|
|
4377
|
-
for (let ordinal = 0; ordinal < slots; ordinal++) {
|
|
4378
|
-
if (saved[ordinal] === 0 && isCarried(state, ordinal)) outside.push(ordinal);
|
|
4379
|
-
}
|
|
4380
|
-
return outside;
|
|
4381
|
-
}
|
|
4382
|
-
function countOutside(state, carriedCounts) {
|
|
4383
|
-
let held = 0;
|
|
4384
|
-
for (const carried of carriedCounts) held += carried;
|
|
4385
|
-
const tombstonedNodes = state.hnsw?.tombstoneCount ?? 0;
|
|
4386
|
-
return Math.max(0, state.store.size - state.tombstones.size + tombstonedNodes - held);
|
|
4387
|
-
}
|
|
4388
|
-
function numberEveryVector(state, kept, written) {
|
|
4389
|
-
let total = written.length;
|
|
4390
|
-
for (const file of kept) total += file.ordinals.length;
|
|
4391
|
-
const numberOfOrdinal = new Int32Array(state.store.slots).fill(ORDINAL_HOLDS_NO_NUMBER);
|
|
4392
|
-
const ordinalOfNumber = new Int32Array(total).fill(NO_LIVE_VECTOR_AT_POSITION);
|
|
4393
|
-
let number = 0;
|
|
4394
|
-
for (const file of kept) {
|
|
4395
|
-
for (let i = 0; i < file.ordinals.length; i++, number++) {
|
|
4396
|
-
const ordinal = file.ordinals[i];
|
|
4397
|
-
if (!isCarried(state, ordinal)) continue;
|
|
4398
|
-
numberOfOrdinal[ordinal] = number;
|
|
4399
|
-
ordinalOfNumber[number] = ordinal;
|
|
4400
|
-
}
|
|
4401
|
-
}
|
|
4402
|
-
for (const ordinal of written) {
|
|
4403
|
-
numberOfOrdinal[ordinal] = number;
|
|
4404
|
-
ordinalOfNumber[number] = ordinal;
|
|
4405
|
-
number += 1;
|
|
4406
|
-
}
|
|
4407
|
-
return { numberOfOrdinal, ordinalOfNumber };
|
|
4408
|
-
}
|
|
4409
|
-
function withBuildHistory(state, graph) {
|
|
4410
|
-
const shuffledBuildCount = state.shuffledBuildCount;
|
|
4411
|
-
if (shuffledBuildCount === null) return graph;
|
|
4412
|
-
const calibratedMeanLength = state.calibratedMeanLength;
|
|
4413
|
-
if (calibratedMeanLength === null) return { ...graph, shuffledBuildCount };
|
|
4414
|
-
return { ...graph, shuffledBuildCount, calibratedMeanLength };
|
|
4415
|
-
}
|
|
4416
|
-
function graphPartsOf(state, numbers) {
|
|
4417
|
-
if (state.hnsw === null || numbers.ordinalOfNumber.length === 0) return null;
|
|
4418
|
-
const parts = state.hnsw.serializeNumbered(
|
|
4419
|
-
numbers.numberOfOrdinal,
|
|
4420
|
-
numbers.ordinalOfNumber,
|
|
4421
|
-
VECTOR_GRAPH_PART_VECTORS
|
|
4422
|
-
);
|
|
4423
|
-
return parts.map((graph) => ({
|
|
4424
|
-
v: VECTOR_GRAPH_PART_PAYLOAD_VERSION,
|
|
4425
|
-
fieldName: state.fieldName,
|
|
4426
|
-
graphs: [withBuildHistory(state, graph)]
|
|
4427
|
-
}));
|
|
4428
|
-
}
|
|
4429
|
-
function graphPartsWithoutNodes(parts, numbers) {
|
|
4430
|
-
return parts.map((part, index) => ({
|
|
4431
|
-
...part,
|
|
4432
|
-
graphs: part.graphs.map((graph) => graphWithoutNodes(graph, index * VECTOR_GRAPH_PART_VECTORS, numbers))
|
|
4433
|
-
}));
|
|
4434
|
-
}
|
|
4435
|
-
function plannedVectorOf(state, ordinal) {
|
|
4436
|
-
const docId = state.store.docIdForOrdinal(ordinal) ?? state.store.view.docIdAt(ordinal) ?? "";
|
|
4437
|
-
return { ordinal, docId, tombstoned: !isLive2(state, ordinal) };
|
|
4438
|
-
}
|
|
4439
|
-
function readFile(state, planned, centroid) {
|
|
4440
|
-
const dimension = state.dimension;
|
|
4441
|
-
const vectors = new Float32Array(planned.length * dimension);
|
|
4442
|
-
const ordinals = new Int32Array(planned.length).fill(NO_LIVE_VECTOR_AT_POSITION);
|
|
4443
|
-
const tombstonedAt = /* @__PURE__ */ new Map();
|
|
4444
|
-
const docIds = planned.map((vector) => vector.docId);
|
|
4445
|
-
for (let i = 0; i < planned.length; i++) {
|
|
4446
|
-
const { ordinal, docId, tombstoned } = planned[i];
|
|
4447
|
-
const held = tombstoned || state.store.holdsOrdinal(ordinal) ? ordinal : state.store.getOrdinal(docId);
|
|
4448
|
-
const entry = held === void 0 ? void 0 : state.store.entryForOrdinal(held);
|
|
4449
|
-
if (held === void 0 || entry === void 0) continue;
|
|
4450
|
-
vectors.set(entry.vector, i * dimension);
|
|
4451
|
-
ordinals[i] = held;
|
|
4452
|
-
if (tombstoned) tombstonedAt.set(i, held);
|
|
4453
|
-
}
|
|
4454
|
-
return {
|
|
4455
|
-
payload: {
|
|
4456
|
-
v: VECTOR_FILE_PAYLOAD_VERSION,
|
|
4457
|
-
fieldName: state.fieldName,
|
|
4458
|
-
dimension,
|
|
4459
|
-
docIds,
|
|
4460
|
-
codes: partCodes(state, docIds, centroid, tombstonedAt, vectors, ordinals),
|
|
4461
|
-
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);
|
|
4462
3855
|
},
|
|
4463
|
-
|
|
4464
|
-
|
|
4465
|
-
};
|
|
4466
|
-
}
|
|
4467
|
-
function planCheckpoint(state, listedKeys, rewritesGraph = false) {
|
|
4468
|
-
const signature = signatureOf(state);
|
|
4469
|
-
const calibration = signature.calibration;
|
|
4470
|
-
const trusted = registryMatches(state, listedKeys);
|
|
4471
|
-
const capacity = fileCapacityOf(state);
|
|
4472
|
-
const carriedCounts = [];
|
|
4473
|
-
const keptFiles = filesWorthKeeping(state, trusted ? state.savedFiles : [], calibration, carriedCounts);
|
|
4474
|
-
absorbSmallerPartialFiles(keptFiles, carriedCounts, countOutside(state, carriedCounts), capacity);
|
|
4475
|
-
const written = ordinalsOutsideOf(state, keptFiles);
|
|
4476
|
-
const planned = written.map((ordinal) => plannedVectorOf(state, ordinal));
|
|
4477
|
-
const centroid = codedCentroid(state);
|
|
4478
|
-
const listedBefore = trusted && listedKeys !== null;
|
|
4479
|
-
const unchanged = !rewritesGraph && listedBefore && sameSignature(state.savedSignature, signature) && written.length === 0;
|
|
4480
|
-
let firstWrittenNumber = 0;
|
|
4481
|
-
for (const file of keptFiles) firstWrittenNumber += file.ordinals.length;
|
|
4482
|
-
const graphParts = unchanged ? null : graphPartsOf(state, numberEveryVector(state, keptFiles, written));
|
|
4483
|
-
const vanished = /* @__PURE__ */ new Set();
|
|
4484
|
-
let vanishedWhenStripped = 0;
|
|
4485
|
-
let graphPartsToWrite = graphParts;
|
|
4486
|
-
return {
|
|
4487
|
-
unchanged,
|
|
4488
|
-
keptFiles,
|
|
4489
|
-
kept: keptFiles.map((file) => ({
|
|
4490
|
-
id: file.id,
|
|
4491
|
-
key: file.key,
|
|
4492
|
-
count: file.ordinals.length,
|
|
4493
|
-
dead: deadBitsOf(state, file)
|
|
4494
|
-
})),
|
|
4495
|
-
newFiles: Math.ceil(written.length / capacity),
|
|
4496
|
-
get graphParts() {
|
|
4497
|
-
if (graphParts !== null && vanished.size !== vanishedWhenStripped) {
|
|
4498
|
-
graphPartsToWrite = graphPartsWithoutNodes(graphParts, vanished);
|
|
4499
|
-
vanishedWhenStripped = vanished.size;
|
|
4500
|
-
}
|
|
4501
|
-
return graphPartsToWrite;
|
|
3856
|
+
beginRecoding(centroid) {
|
|
3857
|
+
requireShared().beginRecoding(centroid);
|
|
4502
3858
|
},
|
|
4503
|
-
|
|
4504
|
-
|
|
4505
|
-
|
|
4506
|
-
|
|
4507
|
-
|
|
4508
|
-
|
|
4509
|
-
|
|
4510
|
-
|
|
4511
|
-
|
|
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();
|
|
4512
3884
|
}
|
|
4513
3885
|
};
|
|
4514
3886
|
}
|
|
4515
|
-
function recordCheckpoint(state, plan, written) {
|
|
4516
|
-
if (plan.unchanged) return;
|
|
4517
|
-
const calibration = plan.signature.calibration;
|
|
4518
|
-
state.savedFiles = [...plan.keptFiles, ...written.map((file) => ({ ...file, calibration }))];
|
|
4519
|
-
state.savedSignature = plan.signature;
|
|
4520
|
-
}
|
|
4521
|
-
|
|
4522
|
-
// src/runtime/idle-heap-cleanup.browser.ts
|
|
4523
|
-
function collectAndReturnPages() {
|
|
4524
|
-
return false;
|
|
4525
|
-
}
|
|
4526
3887
|
|
|
4527
|
-
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 };
|