md-semantic-search 0.5.0 → 1.0.2

package/dist/federation.js

@@ -0,0 +1,94 @@
+/**
+ * Multi-Vault & Multi-Repository Search Federation (issue #97).
+ *
+ * Coordinates querying across multiple independent vaults / repositories,
+ * executing per-vault index loads in parallel and merging candidates with
+ * calibrated reciprocal rank fusion (RRF) and vault attribution.
+ */
+import path from 'node:path';
+import fs from 'node:fs';
+import { loadIndex, searchIndex } from './search.js';
+export async function searchFederated(opts) {
+    const { vaults, k = 10, cacheDir = '', ...searchOpts } = opts;
+    if (!vaults || vaults.length === 0) {
+        throw new Error('Federated search requires at least one vault specified');
+    }
+    const normalizedVaults = vaults.map((v) => {
+        if (typeof v === 'string') {
+            const absPath = path.resolve(v);
+            const name = path.basename(absPath);
+            return { name, path: absPath };
+        }
+        const absPath = path.resolve(v.path);
+        const name = v.name || path.basename(absPath);
+        return { name, path: absPath, indexDir: v.indexDir };
+    });
+    // Load and query each vault concurrently
+    const perVaultResults = await Promise.all(normalizedVaults.map(async (vault) => {
+        const indexDir = vault.indexDir || path.join(vault.path, '.mdss');
+        if (!fs.existsSync(indexDir)) {
+            return { vault, hits: [], error: `No index at ${indexDir}` };
+        }
+        let loaded;
+        try {
+            loaded = loadIndex(indexDir);
+        }
+        catch (err) {
+            return { vault, hits: [], error: err.message };
+        }
+        try {
+            // Query vault index with a slightly larger pool to ensure healthy global fusion
+            const poolK = Math.max(k * 2, 20);
+            const resolvedCache = cacheDir || path.join(vault.path, '.cache');
+            const hits = await searchIndex({
+                ...searchOpts,
+                cacheDir: resolvedCache,
+                loaded,
+                k: poolK,
+            });
+            return { vault, hits, error: null };
+        }
+        catch (err) {
+            return { vault, hits: [], error: err.message };
+        }
+    }));
+    // If single vault, return directly with attribution
+    if (normalizedVaults.length === 1) {
+        const { vault, hits } = perVaultResults[0];
+        return hits.slice(0, k).map((h) => ({
+            ...h,
+            vault: vault.name || path.basename(vault.path),
+            vaultPath: vault.path,
+        }));
+    }
+    // Multi-vault reciprocal rank fusion (RRF)
+    // Collect all hits across vaults
+    const hitKeys = new Map();
+    for (const { vault, hits } of perVaultResults) {
+        hits.forEach((hit, rank) => {
+            const key = `${vault.path}::${hit.file}::${hit.heading || ''}`;
+            const rrfScore = 1.0 / (60 + rank + 1);
+            const existing = hitKeys.get(key);
+            if (!existing) {
+                hitKeys.set(key, { hit, vault, rrfSum: rrfScore });
+            }
+            else {
+                existing.rrfSum += rrfScore;
+            }
+        });
+    }
+    // Sort fused hits by combined rrfSum (or fallback to score)
+    const fused = Array.from(hitKeys.values())
+        .sort((a, b) => {
+        if (b.rrfSum !== a.rrfSum)
+            return b.rrfSum - a.rrfSum;
+        return b.hit.score - a.hit.score;
+    })
+        .slice(0, k);
+    return fused.map(({ hit, vault, rrfSum }) => ({
+        ...hit,
+        score: rrfSum,
+        vault: vault.name || path.basename(vault.path),
+        vaultPath: vault.path,
+    }));
+}

package/dist/filter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Rich Frontmatter & Tag Filter Expression DSL (issue #94).
+ * Supports boolean expressions (AND, OR, NOT, grouping parentheses)
+ * across frontmatter tags, properties, dates, and custom fields.
+ */
+import { DocumentMetadata } from './frontmatter.js';
+export type FilterNode = {
+    type: 'AND';
+    left: FilterNode;
+    right: FilterNode;
+} | {
+    type: 'OR';
+    left: FilterNode;
+    right: FilterNode;
+} | {
+    type: 'NOT';
+    child: FilterNode;
+} | {
+    type: 'COMPARE';
+    field: string;
+    op: ':' | 'contains' | '=' | '==' | '!=' | '>' | '>=' | '<' | '<=';
+    value: string | number | boolean;
+};
+export declare function tokenizeFilter(expr: string): string[];
+export declare function parseFilter(expr: string): FilterNode;
+export declare function evaluateFilter(node: FilterNode | string, meta?: DocumentMetadata, doc?: {
+    file?: string;
+    title?: string;
+}): boolean;

package/dist/filter.js

@@ -0,0 +1,317 @@
+export function tokenizeFilter(expr) {
+    const tokens = [];
+    let i = 0;
+    while (i < expr.length) {
+        const ch = expr[i];
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        if (ch === '(' || ch === ')') {
+            tokens.push(ch);
+            i++;
+            continue;
+        }
+        // Quoted string
+        if (ch === '"' || ch === "'") {
+            const quote = ch;
+            let str = '';
+            i++;
+            while (i < expr.length && expr[i] !== quote) {
+                if (expr[i] === '\\' && i + 1 < expr.length) {
+                    str += expr[i + 1];
+                    i += 2;
+                }
+                else {
+                    str += expr[i];
+                    i++;
+                }
+            }
+            i++; // skip closing quote
+            tokens.push(`"${str}"`);
+            continue;
+        }
+        // Two-character operators: >=, <=, !=, ==
+        if (i + 1 < expr.length) {
+            const two = expr.slice(i, i + 2);
+            if (two === '>=' || two === '<=' || two === '!=' || two === '==') {
+                tokens.push(two);
+                i += 2;
+                continue;
+            }
+        }
+        // Single-character operators: >, <, =, :
+        if (ch === '>' || ch === '<' || ch === '=' || ch === ':') {
+            tokens.push(ch);
+            i++;
+            continue;
+        }
+        // Word / identifier / value token
+        let word = '';
+        while (i < expr.length &&
+            !/\s/.test(expr[i]) &&
+            expr[i] !== '(' &&
+            expr[i] !== ')' &&
+            expr[i] !== ':' &&
+            expr[i] !== '=' &&
+            expr[i] !== '!' &&
+            expr[i] !== '>' &&
+            expr[i] !== '<' &&
+            expr[i] !== '"' &&
+            expr[i] !== "'") {
+            word += expr[i];
+            i++;
+        }
+        if (word) {
+            tokens.push(word);
+        }
+        else if (i < expr.length) {
+            tokens.push(expr[i]);
+            i++;
+        }
+    }
+    return tokens;
+}
+export function parseFilter(expr) {
+    const tokens = tokenizeFilter(expr);
+    if (tokens.length === 0) {
+        throw new Error('Empty filter expression');
+    }
+    let pos = 0;
+    function peek() {
+        return tokens[pos];
+    }
+    function consume() {
+        return tokens[pos++];
+    }
+    function parseExpression() {
+        return parseOr();
+    }
+    function parseOr() {
+        let node = parseAnd();
+        while (pos < tokens.length && peek()?.toUpperCase() === 'OR') {
+            consume(); // OR
+            const beforePos = pos;
+            const right = parseAnd();
+            if (pos === beforePos) {
+                throw new Error(`Invalid syntax in filter expression near token "${peek()}"`);
+            }
+            node = { type: 'OR', left: node, right };
+        }
+        return node;
+    }
+    function parseAnd() {
+        let node = parseNot();
+        while (pos < tokens.length &&
+            peek()?.toUpperCase() !== 'OR' &&
+            peek() !== ')') {
+            if (peek()?.toUpperCase() === 'AND') {
+                consume(); // AND
+            }
+            const beforePos = pos;
+            const right = parseNot();
+            if (pos === beforePos) {
+                throw new Error(`Invalid syntax in filter expression near token "${peek()}"`);
+            }
+            node = { type: 'AND', left: node, right };
+        }
+        return node;
+    }
+    function parseNot() {
+        if (pos < tokens.length && (peek()?.toUpperCase() === 'NOT' || peek() === '!')) {
+            consume(); // NOT / !
+            const child = parsePrimary();
+            return { type: 'NOT', child };
+        }
+        return parsePrimary();
+    }
+    function parsePrimary() {
+        const token = peek();
+        if (!token) {
+            throw new Error(`Unexpected end of filter expression at position ${pos}`);
+        }
+        if (token === '(') {
+            consume(); // (
+            const node = parseExpression();
+            if (peek() !== ')') {
+                throw new Error('Expected closing parenthesis ")" in filter expression');
+            }
+            consume(); // )
+            return node;
+        }
+        // Comparison term: <field> <op> <value> or <field>:<value>
+        const fieldToken = consume();
+        const cleanField = fieldToken.replace(/^["']|["']$/g, '');
+        let op = ':';
+        let rawVal = '';
+        const nextTok = peek();
+        if (nextTok === ':' ||
+            nextTok === '=' ||
+            nextTok === '==' ||
+            nextTok === '!=' ||
+            nextTok === '>' ||
+            nextTok === '>=' ||
+            nextTok === '<' ||
+            nextTok === '<=' ||
+            nextTok?.toLowerCase() === 'contains') {
+            op = consume();
+            if (op === '==')
+                op = '=';
+            rawVal = consume();
+            if (!rawVal) {
+                throw new Error(`Missing value after operator "${op}" for field "${cleanField}"`);
+            }
+        }
+        else {
+            op = ':';
+            rawVal = cleanField;
+        }
+        const unquoted = rawVal.replace(/^["']|["']$/g, '');
+        let parsedVal = unquoted;
+        if (/^true$/i.test(unquoted))
+            parsedVal = true;
+        else if (/^false$/i.test(unquoted))
+            parsedVal = false;
+        else if (/^-?\d+(\.\d+)?$/.test(unquoted))
+            parsedVal = Number(unquoted);
+        return {
+            type: 'COMPARE',
+            field: cleanField,
+            op,
+            value: parsedVal,
+        };
+    }
+    const result = parseExpression();
+    if (pos < tokens.length) {
+        throw new Error(`Unexpected trailing token in filter: "${tokens[pos]}"`);
+    }
+    return result;
+}
+export function evaluateFilter(node, meta, doc) {
+    if (typeof node === 'string') {
+        if (!node.trim())
+            return true;
+        try {
+            node = parseFilter(node);
+        }
+        catch {
+            return false;
+        }
+    }
+    if (node.type === 'AND') {
+        return evaluateFilter(node.left, meta, doc) && evaluateFilter(node.right, meta, doc);
+    }
+    if (node.type === 'OR') {
+        return evaluateFilter(node.left, meta, doc) || evaluateFilter(node.right, meta, doc);
+    }
+    if (node.type === 'NOT') {
+        return !evaluateFilter(node.child, meta, doc);
+    }
+    if (node.type === 'COMPARE') {
+        return evaluateCompare(node.field, node.op, node.value, meta, doc);
+    }
+    return true;
+}
+function evaluateCompare(field, op, targetVal, meta, doc) {
+    const normField = field.toLowerCase().replace(/[-_]/g, '');
+    let actualVal = undefined;
+    if (normField === 'file' || normField === 'path') {
+        actualVal = doc?.file;
+    }
+    else if (normField === 'title') {
+        actualVal = meta?.title || doc?.title;
+    }
+    else if (normField === 'tag' || normField === 'tags') {
+        actualVal = meta?.tags || [];
+    }
+    else if (normField === 'alias' || normField === 'aliases') {
+        actualVal = meta?.aliases || [];
+    }
+    else if (normField === 'project') {
+        actualVal = meta?.project;
+    }
+    else if (normField === 'type') {
+        actualVal = meta?.type;
+    }
+    else if (normField === 'status') {
+        actualVal = meta?.status;
+    }
+    else if (normField === 'canonical') {
+        actualVal = meta?.canonical;
+    }
+    else if (normField === 'date' || normField === 'created') {
+        actualVal = meta?.created;
+    }
+    else if (normField === 'updated') {
+        actualVal = meta?.updated;
+    }
+    else if (meta?.custom && field in meta.custom) {
+        actualVal = meta.custom[field];
+    }
+    // Tag array membership
+    if (normField === 'tag' || normField === 'tags' || Array.isArray(actualVal)) {
+        const list = Array.isArray(actualVal) ? actualVal : [];
+        const searchTarget = String(targetVal).toLowerCase().replace(/^#/, '');
+        if (op === ':' || op === 'contains' || op === '=' || op === '==') {
+            return list.some((item) => String(item).toLowerCase().replace(/^#/, '') === searchTarget);
+        }
+        if (op === '!=') {
+            return !list.some((item) => String(item).toLowerCase().replace(/^#/, '') === searchTarget);
+        }
+    }
+    if (actualVal === undefined || actualVal === null) {
+        if (op === '!=')
+            return true;
+        return false;
+    }
+    // Boolean compare
+    if (typeof targetVal === 'boolean') {
+        const b = Boolean(actualVal);
+        return op === '!=' ? b !== targetVal : b === targetVal;
+    }
+    // Number compare
+    if (typeof targetVal === 'number') {
+        const num = Number(actualVal);
+        if (Number.isNaN(num))
+            return false;
+        switch (op) {
+            case '=':
+            case ':':
+                return num === targetVal;
+            case '!=':
+                return num !== targetVal;
+            case '>':
+                return num > targetVal;
+            case '>=':
+                return num >= targetVal;
+            case '<':
+                return num < targetVal;
+            case '<=':
+                return num <= targetVal;
+            default:
+                return false;
+        }
+    }
+    // String / Date comparison
+    const strActual = String(actualVal).toLowerCase();
+    const strTarget = String(targetVal).toLowerCase();
+    switch (op) {
+        case '=':
+            return strActual === strTarget;
+        case ':':
+        case 'contains':
+            return strActual.includes(strTarget);
+        case '!=':
+            return strActual !== strTarget;
+        case '>':
+            return strActual > strTarget;
+        case '>=':
+            return strActual >= strTarget;
+        case '<':
+            return strActual < strTarget;
+        case '<=':
+            return strActual <= strTarget;
+        default:
+            return false;
+    }
+}

package/dist/index-format.js

@@ -10,7 +10,7 @@ export function inspectIndexSchema(value, location) {
     return { index, schema: parseSchemaVersion(index.schemaVersion) };
 }
 export function validateNumericVector(value, expectedDim, where) {
-    if (!Array.isArray(value) && !(value instanceof Float32Array)) {
+    if (!Array.isArray(value) && !(value instanceof Float32Array || value instanceof Int8Array)) {
         throw new Error(`${where}: missing vector${REBUILD}`);
     }
     const vec = value;

package/dist/index.d.ts

@@ -26,4 +26,12 @@ export { getReranker, rerankScores, RERANK_MODEL, } from './rerank.js';
 export { embed, getExtractor, cosine, walkMarkdown, parseFile, chunkMarkdown, splitFrontmatter, extractTitle, globToRegExp, encodeVec, decodeVec, isBinaryIndex, } from './core.js';
 export { MCP_TOOLS, handleMcpRequest, startMcpServer, } from './mcp.js';
 export { trainIVF, searchIVFCandidates, serializeIVF, deserializeIVF, ANN_THRESHOLD, DEFAULT_NPROBE, } from './ivf.js';
-export { runTui } from './tui.js';
+export { extractLinks, resolveLinks, buildRelationshipGraph, getRelatedNotes, computePageRank, expandGraphNeighborhood, } from './wikilinks.js';
+export { parseFilter, tokenizeFilter, evaluateFilter, FilterNode, } from './filter.js';
+export { serializeBinaryIndex, deserializeBinaryIndex, readBinaryHeader, BINARY_MAGIC, BINARY_HEADER_SIZE, } from './binary-format.js';
+export { quantizeToInt8, dequantizeFromInt8, asymmetricCosineInt8, INT8_SCALE, INT8_INV_SCALE, } from './quantization.js';
+export { searchFederated, FederatedSearchOptions, FederatedSearchResultHit, VaultConfig, } from './federation.js';
+export { createFileWatcher, FileWatcher, WatcherOptions, } from './watcher.js';
+export { askQuestion, synthesizeAnswer, extractAnswerFallback, AskOptions, SynthesisResult, Citation, DEFAULT_RAG_SYSTEM_PROMPT, } from './rag.js';
+export { extractKeyphraseTags, summarizePassage, analyzeNote, NoteAnalysis, } from './summarize.js';
+export { runTui, TuiOptions } from './tui.js';

package/dist/index.js

@@ -26,4 +26,12 @@ export { getReranker, rerankScores, RERANK_MODEL, } from './rerank.js';
 export { embed, getExtractor, cosine, walkMarkdown, parseFile, chunkMarkdown, splitFrontmatter, extractTitle, globToRegExp, encodeVec, decodeVec, isBinaryIndex, } from './core.js';
 export { MCP_TOOLS, handleMcpRequest, startMcpServer, } from './mcp.js';
 export { trainIVF, searchIVFCandidates, serializeIVF, deserializeIVF, ANN_THRESHOLD, DEFAULT_NPROBE, } from './ivf.js';
+export { extractLinks, resolveLinks, buildRelationshipGraph, getRelatedNotes, computePageRank, expandGraphNeighborhood, } from './wikilinks.js';
+export { parseFilter, tokenizeFilter, evaluateFilter, } from './filter.js';
+export { serializeBinaryIndex, deserializeBinaryIndex, readBinaryHeader, BINARY_MAGIC, BINARY_HEADER_SIZE, } from './binary-format.js';
+export { quantizeToInt8, dequantizeFromInt8, asymmetricCosineInt8, INT8_SCALE, INT8_INV_SCALE, } from './quantization.js';
+export { searchFederated, } from './federation.js';
+export { createFileWatcher, } from './watcher.js';
+export { askQuestion, synthesizeAnswer, extractAnswerFallback, DEFAULT_RAG_SYSTEM_PROMPT, } from './rag.js';
+export { extractKeyphraseTags, summarizePassage, analyzeNote, } from './summarize.js';
 export { runTui } from './tui.js';

package/dist/indexer.d.ts

@@ -1,4 +1,5 @@
 import { LexicalIndex } from './lexical.js';
+import { DocumentMetadata } from './frontmatter.js';
 export interface IndexChunk {
     file: string;
     title: string;
@@ -7,6 +8,9 @@ export interface IndexChunk {
     text: string;
     vec?: number[] | Float32Array | string;
     chunkHash?: string;
+    startLine?: number;
+    endLine?: number;
+    meta?: DocumentMetadata;
 }
 export interface PersistedIndex {
     schemaVersion?: number;
@@ -21,13 +25,20 @@ export interface PersistedIndex {
     chunkCount?: number;
     hashes?: Record<string, string>;
     lexical?: LexicalIndex;
+    lexicalFormat?: string;
     chunks: IndexChunk[];
 }
+export declare const _stats: {
+    chunkHits: number;
+    fileHits: number;
+    embedCount: number;
+};
 export declare function canonicalPassage(chunk: {
     title: string;
     heading: string;
     headingPath?: string[];
     text: string;
+    meta?: DocumentMetadata;
 }): string;
 export declare function chunkHash(model: {
     id: string;
@@ -39,6 +50,7 @@ export declare function chunkHash(model: {
     heading: string;
     headingPath?: string[];
     text: string;
+    meta?: DocumentMetadata;
 }): string;
 export interface BuildIndexOptions {
     db: string;
@@ -54,6 +66,7 @@ export interface BuildIndexOptions {
     onProgress?: (done: number, total: number, chunksPerSec: number) => void;
     workers?: number;
     ann?: boolean;
+    quantize?: 'fp32' | 'int8';
 }
 export interface BuildIndexResult {
     files: number;

package/dist/indexer.js

@@ -15,8 +15,14 @@ import { validateIndexEnvelope, validateNumericVector } from './index-format.js'
 import { analyzeLexicalDocument, buildLexicalIndex, lexicalIdentity, reverseLexicalIndex, validateLexicalIndex, } from './lexical.js';
 import { embeddingAdapterFingerprint, legacyEmbeddingAdapterFingerprint } from './models.js';
 import { trainIVF, serializeIVF, ANN_THRESHOLD } from './ivf.js';
+import { serializeBinaryIndex } from './binary-format.js';
 const md5 = (s) => crypto.createHash('md5').update(s).digest('hex');
 const sha256 = (s) => crypto.createHash('sha256').update(s).digest('hex');
+export const _stats = {
+    chunkHits: 0,
+    fileHits: 0,
+    embedCount: 0,
+};
 const BATCH = 32;
 const CHECKPOINT_BATCHES = 8;
 const INDEX_FORMAT = 'binary-v1';
@@ -41,11 +47,12 @@ function atomicWrite(target, data) {
     const tmp = `${target}.${process.pid}.tmp`;
     fs.writeFileSync(tmp, data);
     fs.renameSync(tmp, target);
-    if (path.basename(target) === 'vectors.json') {
+    const base = path.basename(target);
+    if (base === 'vectors.json' || base === 'vectors.bin') {
         const digest = crypto.createHash('sha256').update(data).digest('hex');
         const shaPath = `${target}.sha256`;
         const shaTmp = `${shaPath}.${process.pid}.tmp`;
-        fs.writeFileSync(shaTmp, `${digest}  vectors.json\n`);
+        fs.writeFileSync(shaTmp, `${digest}  ${base}\n`);
         fs.renameSync(shaTmp, shaPath);
     }
 }
@@ -56,7 +63,9 @@ export function canonicalPassage(chunk) {
     const title = normalize(chunk.title);
     const headingPath = (chunk.headingPath ?? (normalize(chunk.heading) ? [chunk.heading] : [])).map(normalize);
     const serializedPath = (headingPath[0] === title ? headingPath.slice(1) : headingPath).join(' > ');
-    return [title, serializedPath, normalize(chunk.text)].join('\n');
+    const tagsStr = chunk.meta?.tags && chunk.meta.tags.length > 0 ? `tags: ${chunk.meta.tags.map(t => `#${t}`).join(' ')}` : '';
+    const parts = [title, serializedPath, tagsStr, normalize(chunk.text)].filter(Boolean);
+    return parts.join('\n');
 }
 export function chunkHash(model, chunk) {
     const pooling = model.pooling ?? 'mean';
@@ -70,12 +79,12 @@ export function chunkHash(model, chunk) {
     return sha256(input);
 }
 export async function buildIndex(opts) {
-    const { db, indexDir, cacheDir, modelName, ignore = [], log = () => { }, offline = false, embedFn = embed, _lockHeld = false, maxRetries = 3, onProgress, workers = 1, ann = false, } = opts;
+    const { db, indexDir, cacheDir, modelName, ignore = [], log = () => { }, offline = false, embedFn = embed, _lockHeld = false, maxRetries = 3, onProgress, workers = 1, ann = false, quantize = 'fp32', } = opts;
     if (_lockHeld)
-        return _buildIndexInner({ db, indexDir, cacheDir, modelName, ignore, log, offline, embedFn, maxRetries, onProgress, workers, ann });
-    return withIndexLock(indexDir, () => _buildIndexInner({ db, indexDir, cacheDir, modelName, ignore, log, offline, embedFn, maxRetries, onProgress, workers, ann }));
+        return _buildIndexInner({ db, indexDir, cacheDir, modelName, ignore, log, offline, embedFn, maxRetries, onProgress, workers, ann, quantize });
+    return withIndexLock(indexDir, () => _buildIndexInner({ db, indexDir, cacheDir, modelName, ignore, log, offline, embedFn, maxRetries, onProgress, workers, ann, quantize }));
 }
-async function _buildIndexInner({ db, indexDir, cacheDir, modelName, ignore = [], log = () => { }, offline = false, embedFn = embed, maxRetries = 3, onProgress, workers = 1, ann = false, }) {
+async function _buildIndexInner({ db, indexDir, cacheDir, modelName, ignore = [], log = () => { }, offline = false, embedFn = embed, maxRetries = 3, onProgress, workers = 1, ann = false, quantize = 'fp32', }) {
     const model = resolveModel(modelName);
     const modelIdentity = `${model.id}@${model.revision || 'main'}`;
     const adapterFingerprint = embeddingAdapterFingerprint(model);
@@ -424,6 +433,11 @@ async function _buildIndexInner({ db, indexDir, cacheDir, modelName, ignore = []
     atomicWrite(checkpointPath, JSON.stringify({ ...index, complete: true, hashes: newHashes }));
     atomicWrite(vectorsPath, JSON.stringify(index));
     atomicWrite(hashesPath, JSON.stringify(newHashes, null, 2));
+    const vectorsBinPath = path.join(indexDir, 'vectors.bin');
+    if (dim !== undefined && dim > 0) {
+        const binBuffer = serializeBinaryIndex(index, dim, { quantize });
+        atomicWrite(vectorsBinPath, binBuffer);
+    }
     const ivfPath = path.join(indexDir, 'ivf.json');
     if (ann || chunks.length >= ANN_THRESHOLD) {
         const rawVecs = chunks.map((c) => (c.vec instanceof Float32Array ? c.vec : Float32Array.from(c.vec)));

package/dist/markdown-parser.d.ts

@@ -25,3 +25,4 @@ export declare function chunkMarkdownStructural(input: string | MarkdownBlock[],
     maxChunk?: number;
     targetTokens?: number;
 }): StructuralChunk[];
+export declare function splitOversizedBlock(text: string, maxChunk: number, blockType?: MarkdownBlock['type']): string[];