@delali/narsil 0.3.1-next.140 → 0.3.1-next.141

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