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

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