@levalicious/server-memory 0.0.12 → 0.0.14

package/dist/server.js

@@ -2,11 +2,13 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { randomBytes } from 'crypto';
+import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { GraphFile, DIR_FORWARD, DIR_BACKWARD } from './src/graphfile.js';
 import { StringTable } from './src/stringtable.js';
 import { structuralSample } from './src/pagerank.js';
+import { validateExtension, loadDocument } from './src/kb_load.js';
 // Define memory file path using environment variable with fallback
 const defaultMemoryPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'memory.json');
 // If MEMORY_FILE_PATH is just a filename, put it in the same directory as the script
@@ -104,7 +106,7 @@ function paginateItems(items, cursor = 0, maxChars = MAX_CHARS) {
     let i = cursor;
     // Calculate overhead for wrapper: {"items":[],"nextCursor":null,"totalCount":123}
     const wrapperTemplate = { items: [], nextCursor: null, totalCount: items.length };
-    let overhead = JSON.stringify(wrapperTemplate).length;
+    const overhead = JSON.stringify(wrapperTemplate).length;
     let charCount = overhead;
     while (i < items.length) {
         const itemJson = JSON.stringify(items[i]);
@@ -199,6 +201,13 @@ export class KnowledgeGraphManager {
             this.gf.sync();
         }
     }
+    /**
+     * Run the loadDocument pipeline under a shared (read) lock,
+     * so the StringTable is consistent during IDF derivation.
+     */
+    prepareDocumentLoad(text, title, topK) {
+        return this.withReadLock(() => loadDocument(text, title, this.st, topK));
+    }
     // --- Locking helpers ---
     /**
      * Acquire a shared (read) lock, refresh mappings (in case another process
@@ -528,7 +537,7 @@ export class KnowledgeGraphManager {
         try {
             regex = new RegExp(query, 'i');
         }
-        catch (e) {
+        catch {
             throw new Error(`Invalid regex pattern: ${query}`);
         }
         return this.withReadLock(() => {
@@ -950,7 +959,7 @@ export function createServer(memoryFilePath) {
                 sizes: ["any"]
             }
         ],
-        version: "0.0.12",
+        version: "0.0.14",
     }, {
         capabilities: {
             tools: {},
@@ -1271,6 +1280,30 @@ Use this to build chains of reasoning that persist in the graph. Each thought ca
                         required: ["observations"],
                     },
                 },
+                {
+                    name: "kb_load",
+                    description: `Load a plaintext document into the knowledge graph. Chunks the text into entities connected by a doubly-linked chain, runs sentence TextRank to identify the most important sentences, and creates an index entity that links directly to the chunks containing those sentences.
+
+The file MUST be plaintext (.txt, .tex, .md, source code, etc.). For PDFs, use pdftotext first. For other binary formats, convert to text before calling this tool.`,
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            filePath: {
+                                type: "string",
+                                description: "Absolute path to the plaintext file to load. Must have a plaintext extension (.txt, .tex, .md, .py, .ts, etc.).",
+                            },
+                            title: {
+                                type: "string",
+                                description: "Optional title for the document entity. Defaults to the filename without extension.",
+                            },
+                            topK: {
+                                type: "number",
+                                description: "Number of top-ranked sentences to highlight in the index (default: 15).",
+                            },
+                        },
+                        required: ["filePath"],
+                    },
+                },
             ],
         };
     });
@@ -1351,6 +1384,47 @@ Use this to build chains of reasoning that persist in the graph. Each thought ca
                 const result = await knowledgeGraphManager.addThought(args.observations, args.previousCtxId);
                 return { content: [{ type: "text", text: JSON.stringify(result) }] };
             }
+            case "kb_load": {
+                const filePath = args.filePath;
+                // Validate extension
+                validateExtension(filePath);
+                // Read file
+                let text;
+                try {
+                    text = fs.readFileSync(filePath, 'utf-8');
+                }
+                catch (err) {
+                    throw new Error(`Failed to read file: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                // Derive title
+                const title = args.title ?? path.basename(filePath, path.extname(filePath));
+                const topK = args.topK ?? 15;
+                // Run the pipeline (reads string table under read lock)
+                const loadResult = knowledgeGraphManager.prepareDocumentLoad(text, title, topK);
+                // Insert into KB
+                const entities = await knowledgeGraphManager.createEntities(loadResult.entities.map(e => ({
+                    name: e.name,
+                    entityType: e.entityType,
+                    observations: e.observations,
+                })));
+                const relations = await knowledgeGraphManager.createRelations(loadResult.relations.map(r => ({
+                    from: r.from,
+                    to: r.to,
+                    relationType: r.relationType,
+                })));
+                knowledgeGraphManager.resample();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                document: title,
+                                stats: loadResult.stats,
+                                entitiesCreated: entities.length,
+                                relationsCreated: relations.length,
+                            }, null, 2),
+                        }],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/src/kb_load.js

@@ -0,0 +1,396 @@
+/**
+ * kb_load.ts — Load a plaintext document into the knowledge graph.
+ *
+ * Pipeline:
+ *   1. Normalize text
+ *   2. Split into observations (≤140 chars, word-boundary aligned)
+ *   3. Group observations into chunks (≤2 per entity)
+ *   4. Build chain: Document → starts_with/ends_with → chunks ↔ follows/preceded_by
+ *   5. Sentence TextRank: rank sentences by TF-IDF cosine PageRank
+ *   6. Build index entity: Document → has_index → Index → highlights → top chunks
+ *
+ * Returns arrays of entities and relations ready for createEntities/createRelations.
+ */
+import * as crypto from 'crypto';
+import * as path from 'path';
+// ─── Constants ──────────────────────────────────────────────────────
+const MAX_OBS_LENGTH = 140;
+const MAX_OBS_PER_ENTITY = 2;
+const TEXTRANK_DAMPING = 0.85;
+const TEXTRANK_MAX_ITER = 30000;
+const TEXTRANK_CONVERGENCE = 1e-6;
+const ALLOWED_EXTENSIONS = new Set([
+    '.txt', '.tex', '.md', '.markdown', '.rst', '.org', '.adoc',
+    '.asciidoc', '.html', '.htm', '.xml', '.json', '.yaml', '.yml',
+    '.toml', '.csv', '.tsv', '.log', '.cfg', '.ini', '.conf',
+    '.py', '.js', '.ts', '.c', '.h', '.cpp', '.hpp', '.java',
+    '.go', '.rs', '.rb', '.pl', '.sh', '.bash', '.zsh', '.fish',
+    '.el', '.lisp', '.clj', '.hs', '.ml', '.scala', '.kt',
+    '.r', '.m', '.swift', '.lua', '.vim', '.sql',
+    '.bib', '.sty', '.cls',
+]);
+// ─── Text Processing ────────────────────────────────────────────────
+function normalize(text) {
+    text = text.replace(/\r\n/g, '\n');
+    text = text.replace(/[ \t]+/g, ' ');
+    text = text.replace(/\n{3,}/g, '\n\n');
+    text = text.trim();
+    return text.split(/\s+/).join(' ');
+}
+function labelWords(text, offset) {
+    const words = [];
+    let i = 0;
+    const n = text.length;
+    while (i < n) {
+        while (i < n && text[i] === ' ')
+            i++;
+        if (i >= n)
+            break;
+        const start = i;
+        while (i < n && text[i] !== ' ')
+            i++;
+        const raw = text.slice(start, i);
+        words.push({
+            text: raw,
+            normalized: raw.toLowerCase(),
+            start: offset + start,
+            end: offset + i,
+        });
+    }
+    return words;
+}
+function splitIntoObservations(text) {
+    const observations = [];
+    let pos = 0;
+    while (pos < text.length) {
+        const remaining = text.slice(pos);
+        if (remaining.length <= MAX_OBS_LENGTH) {
+            observations.push({
+                text: remaining,
+                start: pos,
+                end: pos + remaining.length,
+                words: labelWords(remaining, pos),
+            });
+            break;
+        }
+        let splitAt = 0;
+        for (let i = 0; i < remaining.length; i++) {
+            if (remaining[i] === ' ') {
+                if (remaining.slice(0, i).length <= MAX_OBS_LENGTH) {
+                    splitAt = i;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        if (splitAt === 0) {
+            // No space fits — hard split
+            let jsLen = 0;
+            for (let i = 0; i < remaining.length; i++) {
+                const charLen = remaining.codePointAt(i) > 0xFFFF ? 2 : 1;
+                if (jsLen + charLen > MAX_OBS_LENGTH) {
+                    splitAt = i;
+                    break;
+                }
+                jsLen += charLen;
+                if (charLen === 2)
+                    i++;
+            }
+            if (splitAt === 0)
+                splitAt = remaining.length;
+        }
+        const obsText = remaining.slice(0, splitAt).trimEnd();
+        observations.push({
+            text: obsText,
+            start: pos,
+            end: pos + obsText.length,
+            words: labelWords(obsText, pos),
+        });
+        pos += splitAt;
+        while (pos < text.length && text[pos] === ' ')
+            pos++;
+    }
+    return observations;
+}
+function chunkObservations(observations) {
+    const chunks = [];
+    for (let i = 0; i < observations.length; i += MAX_OBS_PER_ENTITY) {
+        chunks.push({
+            index: chunks.length,
+            id: crypto.randomBytes(12).toString('hex'),
+            observations: observations.slice(i, i + MAX_OBS_PER_ENTITY),
+        });
+    }
+    return chunks;
+}
+// ─── Sentence Splitting ─────────────────────────────────────────────
+function splitSentences(normalizedText) {
+    const sentences = [];
+    const re = /(?<=[.?!])\s+/g;
+    let pos = 0;
+    let match;
+    while ((match = re.exec(normalizedText)) !== null) {
+        const text = normalizedText.slice(pos, match.index + 1).trim();
+        if (text.length > 0) {
+            const words = text.toLowerCase().split(/\s+/).filter(w => w.length > 0);
+            if (words.length >= 3) {
+                sentences.push({ index: sentences.length, text, start: pos, words });
+            }
+        }
+        pos = match.index + match[0].length;
+    }
+    if (pos < normalizedText.length) {
+        const text = normalizedText.slice(pos).trim();
+        if (text.length > 0) {
+            const words = text.toLowerCase().split(/\s+/).filter(w => w.length > 0);
+            if (words.length >= 3) {
+                sentences.push({ index: sentences.length, text, start: pos, words });
+            }
+        }
+    }
+    return sentences;
+}
+// ─── TF-IDF ─────────────────────────────────────────────────────────
+function buildWeightVector(allWords, idf) {
+    const rawCounts = new Map();
+    for (const w of allWords) {
+        rawCounts.set(w.normalized, (rawCounts.get(w.normalized) ?? 0) + 1);
+    }
+    const weights = new Map();
+    for (const [word, raw] of rawCounts) {
+        weights.set(word, raw * (idf.get(word) ?? 0));
+    }
+    return weights;
+}
+function deriveCorpusDocFreqs(st) {
+    const df = new Map();
+    let corpusSize = 0;
+    for (const entry of st.entries()) {
+        corpusSize += entry.refcount;
+        const uniqueWords = new Set(entry.text.toLowerCase().split(/\s+/).filter(w => w.length > 0));
+        for (const word of uniqueWords) {
+            df.set(word, (df.get(word) ?? 0) + entry.refcount);
+        }
+    }
+    return { df, corpusSize };
+}
+function buildIdfVector(docVocab, df, corpusSize) {
+    const idf = new Map();
+    for (const word of docVocab) {
+        const docFreq = df.get(word) ?? 0;
+        idf.set(word, Math.log(corpusSize / (1 + docFreq)) + 1);
+    }
+    return idf;
+}
+// ─── Cosine Similarity ──────────────────────────────────────────────
+function cosineSimilarity(weights, keysA, keysB) {
+    let dot = 0;
+    for (const word of keysA) {
+        if (keysB.has(word)) {
+            const w = weights.get(word) ?? 0;
+            dot += w * w;
+        }
+    }
+    let normA = 0;
+    for (const word of keysA) {
+        const w = weights.get(word) ?? 0;
+        normA += w * w;
+    }
+    let normB = 0;
+    for (const word of keysB) {
+        const w = weights.get(word) ?? 0;
+        normB += w * w;
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dot / denom;
+}
+// ─── PageRank ───────────────────────────────────────────────────────
+function pageRank(matrix) {
+    const n = matrix.length;
+    if (n === 0)
+        return [];
+    const rowSums = matrix.map(row => row.reduce((a, b) => a + b, 0));
+    let scores = new Array(n).fill(1 / n);
+    for (let iter = 0; iter < TEXTRANK_MAX_ITER; iter++) {
+        const next = new Array(n).fill(0);
+        for (let i = 0; i < n; i++) {
+            let sum = 0;
+            for (let j = 0; j < n; j++) {
+                if (j !== i && rowSums[j] > 0) {
+                    sum += (matrix[j][i] / rowSums[j]) * scores[j];
+                }
+            }
+            next[i] = (1 - TEXTRANK_DAMPING) / n + TEXTRANK_DAMPING * sum;
+        }
+        let delta = 0;
+        for (let i = 0; i < n; i++)
+            delta += Math.abs(next[i] - scores[i]);
+        scores = next;
+        if (delta < TEXTRANK_CONVERGENCE)
+            break;
+    }
+    return scores;
+}
+// ─── Sentence TextRank ──────────────────────────────────────────────
+function sentenceTextRank(sentences, weights) {
+    const n = sentences.length;
+    const keySets = sentences.map(s => new Set(s.words));
+    const matrix = Array.from({ length: n }, () => new Array(n).fill(0));
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            const sim = cosineSimilarity(weights, keySets[i], keySets[j]);
+            matrix[i][j] = sim;
+            matrix[j][i] = sim;
+        }
+    }
+    const scores = pageRank(matrix);
+    return sentences
+        .map((sentence, i) => ({ sentence, score: scores[i] }))
+        .sort((a, b) => b.score - a.score);
+}
+// ─── Sentence → Chunk mapping ───────────────────────────────────────
+function sentenceToChunk(sentence, chunks) {
+    const target = sentence.start;
+    for (const chunk of chunks) {
+        const first = chunk.observations[0];
+        const last = chunk.observations[chunk.observations.length - 1];
+        if (target >= first.start && target < last.end)
+            return chunk;
+    }
+    return null;
+}
+// ─── Public API ─────────────────────────────────────────────────────
+/**
+ * Validate that a file path has a plaintext extension.
+ * Returns the extension if valid, throws if not.
+ */
+export function validateExtension(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (!ext) {
+        throw new Error(`File has no extension: ${filePath}. Only plaintext files are accepted.`);
+    }
+    if (!ALLOWED_EXTENSIONS.has(ext)) {
+        throw new Error(`Unsupported file extension "${ext}". Only plaintext formats are accepted ` +
+            `(${[...ALLOWED_EXTENSIONS].slice(0, 10).join(', ')}, ...). ` +
+            `For PDFs, use pdftotext first. For other binary formats, convert to text.`);
+    }
+    return ext;
+}
+/**
+ * Load a plaintext document into the knowledge graph.
+ *
+ * @param text       Raw document text
+ * @param title      Document entity name (e.g. filename without extension)
+ * @param st         StringTable for IDF corpus frequencies
+ * @param topK       Number of sentences to highlight in the index (default: 15)
+ * @returns Entities and relations ready for createEntities/createRelations
+ */
+export function loadDocument(text, title, st, topK = 15) {
+    // 1. Normalize and chunk
+    const normalizedText = normalize(text);
+    const observations = splitIntoObservations(normalizedText);
+    const chunks = chunkObservations(observations);
+    // Collect all words
+    const allWords = [];
+    for (const chunk of chunks) {
+        for (const obs of chunk.observations)
+            allWords.push(...obs.words);
+    }
+    const vocab = new Set(allWords.map(w => w.normalized));
+    // 2. IDF from corpus
+    const { df, corpusSize } = deriveCorpusDocFreqs(st);
+    const idf = buildIdfVector(vocab, df, corpusSize);
+    // 3. TF-IDF weight vector
+    const weights = buildWeightVector(allWords, idf);
+    // 4. Sentence TextRank
+    const sentences = splitSentences(normalizedText);
+    const rankedSentences = sentenceTextRank(sentences, weights);
+    // 5. Map top sentences to chunks (deduplicate)
+    const topSents = rankedSentences.slice(0, topK);
+    const highlights = [];
+    const seenChunks = new Set();
+    for (const { sentence, score } of topSents) {
+        const chunk = sentenceToChunk(sentence, chunks);
+        if (!chunk || seenChunks.has(chunk.id))
+            continue;
+        seenChunks.add(chunk.id);
+        highlights.push({ chunk, sentence, score });
+    }
+    // 6. Build index observations (compressed sentence previews)
+    const indexId = `${title}__index`;
+    const indexObs = [];
+    let current = '';
+    for (const { sentence } of highlights) {
+        const preview = sentence.text.length > 60
+            ? sentence.text.slice(0, 57) + '...'
+            : sentence.text;
+        const candidate = current ? current + ' | ' + preview : preview;
+        if (candidate.length <= MAX_OBS_LENGTH) {
+            current = candidate;
+        }
+        else {
+            if (current)
+                indexObs.push(current);
+            if (indexObs.length >= MAX_OBS_PER_ENTITY)
+                break;
+            current = preview.length <= MAX_OBS_LENGTH ? preview : preview.slice(0, MAX_OBS_LENGTH);
+        }
+    }
+    if (current && indexObs.length < MAX_OBS_PER_ENTITY)
+        indexObs.push(current);
+    // ─── Assemble entities ──────────────────────────────────────────
+    const entities = [];
+    const relations = [];
+    // Document entity (no observations — it's a pointer node)
+    entities.push({ name: title, entityType: 'Document', observations: [] });
+    // Chunk entities
+    for (const chunk of chunks) {
+        entities.push({
+            name: chunk.id,
+            entityType: 'TextChunk',
+            observations: chunk.observations.map(o => o.text),
+        });
+    }
+    // Index entity
+    entities.push({
+        name: indexId,
+        entityType: 'DocumentIndex',
+        observations: indexObs,
+    });
+    // ─── Assemble relations ─────────────────────────────────────────
+    // Document → chain endpoints
+    if (chunks.length > 0) {
+        relations.push({ from: title, to: chunks[0].id, relationType: 'starts_with' });
+        relations.push({ from: chunks[0].id, to: title, relationType: 'belongs_to' });
+        if (chunks.length > 1) {
+            relations.push({ from: title, to: chunks[chunks.length - 1].id, relationType: 'ends_with' });
+            relations.push({ from: chunks[chunks.length - 1].id, to: title, relationType: 'belongs_to' });
+        }
+    }
+    // Chain: follows/preceded_by
+    for (let i = 0; i < chunks.length - 1; i++) {
+        relations.push({ from: chunks[i].id, to: chunks[i + 1].id, relationType: 'follows' });
+        relations.push({ from: chunks[i + 1].id, to: chunks[i].id, relationType: 'preceded_by' });
+    }
+    // Document → index
+    relations.push({ from: title, to: indexId, relationType: 'has_index' });
+    relations.push({ from: indexId, to: title, relationType: 'indexes' });
+    // Index → highlighted chunks
+    for (const { chunk } of highlights) {
+        relations.push({ from: indexId, to: chunk.id, relationType: 'highlights' });
+        relations.push({ from: chunk.id, to: indexId, relationType: 'highlighted_by' });
+    }
+    return {
+        entities,
+        relations,
+        stats: {
+            chars: text.length,
+            words: allWords.length,
+            uniqueWords: vocab.size,
+            chunks: chunks.length,
+            sentences: sentences.length,
+            indexHighlights: highlights.length,
+        },
+    };
+}

package/dist/src/memoryfile.js

@@ -5,12 +5,25 @@
  * Buffers passed to/from the native layer are Node Buffers.
  */
 import { createRequire } from 'module';
+import { existsSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
-// The .node binary is in build/Release/ relative to project root
-const native = require(join(__dirname, '..', 'build', 'Release', 'memoryfile.node'));
+// Walk up from __dirname to find the package root containing build/Release/memoryfile.node.
+// Works from source (src/), compiled (dist/src/), and npx cache contexts.
+function findNative() {
+    let dir = __dirname;
+    const { root } = require('path').parse(dir);
+    while (dir !== root) {
+        const candidate = join(dir, 'build', 'Release', 'memoryfile.node');
+        if (existsSync(candidate))
+            return candidate;
+        dir = dirname(dir);
+    }
+    throw new Error('Could not find native memoryfile.node — was the C addon built? Run: node-gyp rebuild');
+}
+const native = require(findNative());
 export class MemoryFile {
     handle;
     closed = false;

package/dist/src/stringtable.js

@@ -43,7 +43,7 @@ const ENT_LEN = 8; // u16
 const ENT_DATA = 10; // u8[len]
 const ENT_HEADER_SIZE = 10;
 // Hash index field offsets (relative to index block start)
-const IDX_BUCKET_COUNT = 0; // u32
+const _IDX_BUCKET_COUNT = 0; // u32
 const IDX_BUCKETS = 8; // u64[bucket_count]
 const INITIAL_BUCKETS = 4096;
 const LOAD_FACTOR_THRESHOLD = 0.7;
@@ -159,7 +159,7 @@ export class StringTable {
         const data = Buffer.from(str, 'utf-8');
         const hash = fnv1a(data);
         const bucketCount = this.getBucketCount();
-        let bucket = hash % bucketCount;
+        const bucket = hash % bucketCount;
         // Linear probe to find existing or empty slot
         for (let i = 0; i < bucketCount; i++) {
             const slotIdx = (bucket + i) % bucketCount;
@@ -215,7 +215,7 @@ export class StringTable {
         const data = Buffer.from(str, 'utf-8');
         const hash = fnv1a(data);
         const bucketCount = this.getBucketCount();
-        let bucket = hash % bucketCount;
+        const bucket = hash % bucketCount;
         for (let i = 0; i < bucketCount; i++) {
             const slotIdx = (bucket + i) % bucketCount;
             const entryOffset = this.getBucket(slotIdx);
@@ -264,10 +264,28 @@ export class StringTable {
     get count() {
         return this.getEntryCount();
     }
+    /**
+     * Iterate over all live strings in the table.
+     * Yields { id, text, refcount } for each entry.
+     */
+    *entries() {
+        const bucketCount = this.getBucketCount();
+        for (let i = 0; i < bucketCount; i++) {
+            const entryOffset = this.getBucket(i);
+            if (entryOffset === 0n)
+                continue;
+            const entry = this.readEntry(entryOffset);
+            yield {
+                id: entryOffset,
+                text: entry.data.toString('utf-8'),
+                refcount: entry.refcount,
+            };
+        }
+    }
     // --- Hash index management ---
     removeFromIndex(offset, hash) {
         const bucketCount = this.getBucketCount();
-        let bucket = hash % bucketCount;
+        const bucket = hash % bucketCount;
         // Find the entry in the index
         for (let i = 0; i < bucketCount; i++) {
             const slotIdx = (bucket + i) % bucketCount;
@@ -305,7 +323,7 @@ export class StringTable {
             slot = (slot + 1) % bucketCount;
         }
     }
-    needsRelocation(natural, empty, current, size) {
+    needsRelocation(natural, empty, current, _size) {
         // Is 'empty' between 'natural' and 'current' in the circular probe sequence?
         if (natural <= current) {
             return natural <= empty && empty < current;
@@ -343,7 +361,7 @@ export class StringTable {
                 continue;
             // Read hash and insert into new index
             const entry = this.readEntry(entryOffset);
-            let bucket = entry.hash % newBucketCount;
+            const bucket = entry.hash % newBucketCount;
             for (let j = 0; j < newBucketCount; j++) {
                 const slotIdx = (bucket + j) % newBucketCount;
                 const slotPos = newIndexOffset + BigInt(IDX_BUCKETS + slotIdx * 8);