@undefineds.co/xpod 0.3.75 → 0.4.0-rc.140

package/dist/storage/rdf/RdfTextIndex.js

@@ -18,13 +18,29 @@ exports.normalizeRdfTextRetrievalKind = normalizeRdfTextRetrievalKind;
 exports.rdfTextIndexBudgetSkip = rdfTextIndexBudgetSkip;
 exports.rdfTextIndexChunkCap = rdfTextIndexChunkCap;
 const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const HeadingChunker_1 = require("../../document/HeadingChunker");
+const MarkdownRetrievalPointProjector_1 = require("../../document/MarkdownRetrievalPointProjector");
 const SqliteRuntime_1 = require("../SqliteRuntime");
 const RdfSearchSourceFilter_1 = require("./RdfSearchSourceFilter");
+const RdfSqliteConnection_1 = require("./RdfSqliteConnection");
 exports.RDF_TEXT_TERM_MAX_INDEX_LENGTH = 256;
-exports.RDF_TEXT_SCHEMA_VERSION = 2;
+exports.RDF_TEXT_SCHEMA_VERSION = 3;
+const RDF_TEXT_DOMAIN_TABLES = [
+    'rdf_text_metadata',
+    'rdf_text_sources',
+    'rdf_text_rebuild_status',
+    'rdf_text_chunks',
+    'rdf_text_terms',
+    'rdf_text_entities',
+];
+const RDF_TEXT_REQUIRED_COLUMNS = {
+    rdf_text_metadata: ['key', 'value'],
+    rdf_text_sources: ['id', 'source_key', 'source', 'workspace', 'local_path', 'content_type', 'source_version', 'source_hash', 'updated_at'],
+    rdf_text_rebuild_status: ['source', 'workspace', 'local_path', 'content_type', 'source_version', 'source_hash', 'status', 'reason', 'message', 'updated_at'],
+    rdf_text_chunks: ['id', 'source_id', 'chunk_key', 'retrieval_kind', 'ordinal', 'level', 'heading', 'path', 'content', 'start_offset', 'end_offset', 'normalized_text', 'token_count', 'updated_at'],
+    rdf_text_terms: ['id', 'term', 'source_id', 'chunk_id', 'occurrences', 'updated_at'],
+    rdf_text_entities: ['id', 'entity', 'source_id', 'chunk_id', 'predicate', 'label', 'value', 'datatype', 'language', 'policy_role', 'occurrences', 'updated_at'],
+};
 class RdfTextIndex {
     constructor(options) {
         this.options = options;
@@ -35,13 +51,7 @@ class RdfTextIndex {
         if (this.db) {
             return;
         }
-        if (this.options.path !== ':memory:') {
-            const dir = (0, node_path_1.dirname)(this.options.path);
-            if (!(0, node_fs_1.existsSync)(dir)) {
-                (0, node_fs_1.mkdirSync)(dir, { recursive: true });
-            }
-        }
-        this.db = this.sqliteRuntime.openDatabase(this.options.path);
+        this.db = (0, RdfSqliteConnection_1.openRdfSqliteDatabase)(this.sqliteRuntime, this.options.path);
         this.initializeSchema();
     }
     close() {
@@ -63,6 +73,34 @@ class RdfTextIndex {
             .get(source);
         return row ? rdfTextSourceMetadata(row) : undefined;
     }
+    listSources(options = {}) {
+        const db = this.requireDb();
+        const conditions = [];
+        const params = [];
+        if (options.workspace) {
+            conditions.push('workspace = ?');
+            params.push(options.workspace);
+        }
+        if (options.sourcePrefix) {
+            conditions.push('source >= ? AND source < ?');
+            params.push(options.sourcePrefix, `${options.sourcePrefix}\uffff`);
+        }
+        const limit = normalizeSourceListLimit(options.limit);
+        const offset = normalizeSourceListOffset(options.offset);
+        params.push(limit, offset);
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const rows = db
+            .prepare(`
+        SELECT *
+        FROM rdf_text_sources
+        ${where}
+        ORDER BY source ASC
+        LIMIT ?
+        OFFSET ?
+      `)
+            .all(...params);
+        return rows.map(rdfTextSourceMetadata);
+    }
     recordRebuildStatus(input) {
         this.requireDb().prepare(`
       INSERT INTO rdf_text_rebuild_status (
@@ -192,6 +230,10 @@ class RdfTextIndex {
             if (!oldRow) {
                 return;
             }
+            const sourceKey = oldRow.source_key;
+            if (next.sourceKey && next.sourceKey !== sourceKey) {
+                throw new Error(`RDF text source key mismatch for source ${oldSource}: expected ${sourceKey}, got ${next.sourceKey}`);
+            }
             const chunkCount = db
                 .prepare('SELECT COUNT(*) AS count FROM rdf_text_chunks WHERE source_id = ?')
                 .get(oldRow.id)?.count ?? 0;
@@ -214,7 +256,7 @@ class RdfTextIndex {
           source_hash = ?,
           updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
         WHERE id = ?
-      `).run(next.sourceKey ?? oldRow.source_key ?? oldRow.source, next.source, next.workspace, next.localPath ?? null, next.contentType ?? null, next.sourceVersion ?? null, next.sourceHash ?? null, oldRow.id);
+      `).run(sourceKey, next.source, next.workspace, next.localPath ?? null, next.contentType ?? null, next.sourceVersion ?? null, next.sourceHash ?? oldRow.source_hash ?? null, oldRow.id);
             db.prepare(`
         UPDATE rdf_text_rebuild_status
         SET
@@ -226,7 +268,7 @@ class RdfTextIndex {
           source_hash = ?,
           updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
         WHERE source = ?
-      `).run(next.source, next.workspace, next.localPath ?? null, next.contentType ?? null, next.sourceVersion ?? null, next.sourceHash ?? null, oldSource);
+      `).run(next.source, next.workspace, next.localPath ?? null, next.contentType ?? null, next.sourceVersion ?? null, next.sourceHash ?? oldRow.source_hash ?? null, oldSource);
             affectedRows = Math.max(chunkCount, 1);
         })();
         return affectedRows;
@@ -245,6 +287,38 @@ class RdfTextIndex {
             return deletedChunks;
         })();
     }
+    listSourceChunks(sourceKey) {
+        const rows = this.requireDb().prepare(`
+      SELECT
+        chunk.id,
+        chunk.source_id,
+        source.source_key,
+        source.source,
+        source.workspace,
+        source.local_path,
+        source.content_type,
+        source.source_version,
+        source.source_hash,
+        chunk.chunk_key,
+        chunk.retrieval_kind,
+        chunk.ordinal,
+        chunk.level,
+        chunk.heading,
+        chunk.path,
+        chunk.content,
+        chunk.start_offset,
+        chunk.end_offset,
+        chunk.normalized_text,
+        chunk.token_count,
+        chunk.updated_at
+      FROM rdf_text_chunks chunk
+      JOIN rdf_text_sources source ON source.id = chunk.source_id
+      WHERE source.source_key = ? OR source.source = ?
+      ORDER BY source.source ASC, chunk.ordinal ASC, chunk.chunk_key ASC
+    `).all(sourceKey, sourceKey);
+        const entitiesByChunk = this.entitiesForChunks(rows.map((row) => row.id));
+        return rows.map((row) => this.toSearchResult(row, '', 0, entitiesByChunk.get(row.id) ?? []));
+    }
     search(options) {
         const query = normalizeText(options.query);
         const entityFilter = normalizeEntityFilter(options.entities);
@@ -449,15 +523,20 @@ class RdfTextIndex {
         }));
     }
     initializeSchema() {
-        this.requireDb().exec(`
-      CREATE TABLE IF NOT EXISTS rdf_text_metadata (
+        const db = this.requireDb();
+        if (hasAnyTable(db, RDF_TEXT_DOMAIN_TABLES)) {
+            this.validateSchema();
+            return;
+        }
+        db.exec(`
+      CREATE TABLE rdf_text_metadata (
         key TEXT PRIMARY KEY,
         value TEXT NOT NULL
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_text_sources (
+      CREATE TABLE rdf_text_sources (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
-        source_key TEXT,
+        source_key TEXT NOT NULL UNIQUE,
         source TEXT NOT NULL UNIQUE,
         workspace TEXT NOT NULL,
         local_path TEXT,
@@ -467,7 +546,7 @@ class RdfTextIndex {
         updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_text_rebuild_status (
+      CREATE TABLE rdf_text_rebuild_status (
         source TEXT PRIMARY KEY,
         workspace TEXT NOT NULL,
         local_path TEXT,
@@ -480,7 +559,7 @@ class RdfTextIndex {
         updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_text_chunks (
+      CREATE TABLE rdf_text_chunks (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         source_id INTEGER NOT NULL,
         chunk_key TEXT NOT NULL,
@@ -499,7 +578,7 @@ class RdfTextIndex {
         FOREIGN KEY (source_id) REFERENCES rdf_text_sources(id)
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_text_terms (
+      CREATE TABLE rdf_text_terms (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         term TEXT NOT NULL CHECK (length(term) <= ${exports.RDF_TEXT_TERM_MAX_INDEX_LENGTH}),
         source_id INTEGER NOT NULL,
@@ -511,7 +590,7 @@ class RdfTextIndex {
         FOREIGN KEY (chunk_id) REFERENCES rdf_text_chunks(id)
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_text_entities (
+      CREATE TABLE rdf_text_entities (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         entity TEXT NOT NULL,
         source_id INTEGER NOT NULL,
@@ -533,7 +612,6 @@ class RdfTextIndex {
       CREATE INDEX IF NOT EXISTS rdf_text_sources_local_path ON rdf_text_sources(local_path);
       CREATE INDEX IF NOT EXISTS rdf_text_sources_workspace_local_path ON rdf_text_sources(workspace, local_path);
       CREATE INDEX IF NOT EXISTS rdf_text_chunks_source ON rdf_text_chunks(source_id, ordinal);
-      DELETE FROM rdf_text_terms WHERE length(term) > ${exports.RDF_TEXT_TERM_MAX_INDEX_LENGTH};
       CREATE INDEX IF NOT EXISTS rdf_text_terms_term ON rdf_text_terms(term);
       CREATE INDEX IF NOT EXISTS rdf_text_terms_source_term ON rdf_text_terms(source_id, term);
       CREATE INDEX IF NOT EXISTS rdf_text_terms_chunk ON rdf_text_terms(chunk_id);
@@ -544,94 +622,31 @@ class RdfTextIndex {
       DROP INDEX IF EXISTS rdf_text_chunks_normalized;
 
       INSERT INTO rdf_text_metadata (key, value)
-      VALUES ('schema_version', '${exports.RDF_TEXT_SCHEMA_VERSION}')
-      ON CONFLICT (key) DO UPDATE SET value = excluded.value;
+      VALUES ('schema_version', '${exports.RDF_TEXT_SCHEMA_VERSION}');
     `);
-        this.ensureSourceKeyColumn();
-        this.ensureChunkRetrievalColumns();
-        this.ensureEntityProvenanceColumns();
-        this.backfillTermPostings();
-    }
-    ensureSourceKeyColumn() {
-        const columns = new Set(this.requireDb()
-            .prepare('PRAGMA table_info(rdf_text_sources)')
-            .all()
-            .map((column) => column.name));
-        if (!columns.has('source_key')) {
-            this.requireDb().exec('ALTER TABLE rdf_text_sources ADD COLUMN source_key TEXT;');
-        }
-        this.requireDb().exec('UPDATE rdf_text_sources SET source_key = source WHERE source_key IS NULL;');
-    }
-    ensureChunkRetrievalColumns() {
-        const columns = new Set(this.requireDb()
-            .prepare('PRAGMA table_info(rdf_text_chunks)')
-            .all()
-            .map((column) => column.name));
-        if (!columns.has('retrieval_kind')) {
-            this.requireDb().exec("ALTER TABLE rdf_text_chunks ADD COLUMN retrieval_kind TEXT NOT NULL DEFAULT 'file-chunk';");
-        }
     }
-    ensureEntityProvenanceColumns() {
-        const columns = new Set(this.requireDb()
-            .prepare('PRAGMA table_info(rdf_text_entities)')
-            .all()
-            .map((column) => column.name));
-        for (const [name, type] of [
-            ['value', 'TEXT'],
-            ['datatype', 'TEXT'],
-            ['language', 'TEXT'],
-            ['policy_role', 'TEXT'],
-        ]) {
-            if (!columns.has(name)) {
-                this.requireDb().exec(`ALTER TABLE rdf_text_entities ADD COLUMN ${name} ${type};`);
+    validateSchema() {
+        const db = this.requireDb();
+        for (const table of RDF_TEXT_DOMAIN_TABLES) {
+            if (!hasTable(db, table)) {
+                throw new Error(`Unsupported RDF text index schema: missing table ${table}`);
             }
+            assertRequiredColumns(db, table, RDF_TEXT_REQUIRED_COLUMNS[table]);
         }
-    }
-    backfillTermPostings() {
-        const db = this.requireDb();
-        const rows = db.prepare(`
-      SELECT chunk.id, chunk.source_id, chunk.normalized_text
-      FROM rdf_text_chunks chunk
-      LEFT JOIN rdf_text_terms term ON term.chunk_id = chunk.id
-      WHERE term.chunk_id IS NULL AND chunk.normalized_text <> ''
-    `).all();
-        if (rows.length === 0) {
-            return;
+        const version = this.schemaVersion();
+        if (version !== exports.RDF_TEXT_SCHEMA_VERSION) {
+            throw new Error(`Unsupported RDF text index schema version: expected ${exports.RDF_TEXT_SCHEMA_VERSION}, got ${version}`);
         }
-        const insertTerm = db.prepare(`
-      INSERT INTO rdf_text_terms (
-        term,
-        source_id,
-        chunk_id,
-        occurrences,
-        updated_at
-      )
-      VALUES (?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-    `);
-        const insertEntity = db.prepare(`
-      INSERT INTO rdf_text_entities (
-        entity,
-        source_id,
-        chunk_id,
-        predicate,
-        label,
-        value,
-        datatype,
-        language,
-        policy_role,
-        occurrences,
-        updated_at
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-    `);
-        db.transaction(() => {
-            for (const row of rows) {
-                insertTermOccurrences(insertTerm, row.source_id, row.id, row.normalized_text);
-            }
-        })();
+        assertNotNullColumn(db, 'rdf_text_sources', 'source_key');
+        assertUniqueColumn(db, 'rdf_text_sources', 'source_key');
     }
     upsertSource(source) {
         const db = this.requireDb();
+        const existing = db.prepare('SELECT * FROM rdf_text_sources WHERE source = ?').get(source.source);
+        if (existing && source.sourceKey && existing.source_key !== source.sourceKey) {
+            throw new Error(`RDF text source key mismatch for source ${source.source}: expected ${existing.source_key}, got ${source.sourceKey}`);
+        }
+        const sourceKey = existing?.source_key ?? source.sourceKey ?? source.source;
         db.prepare(`
       INSERT INTO rdf_text_sources (
         source_key,
@@ -646,14 +661,13 @@ class RdfTextIndex {
       VALUES (?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
       ON CONFLICT (source)
       DO UPDATE SET
-        source_key = excluded.source_key,
         workspace = excluded.workspace,
         local_path = excluded.local_path,
         content_type = excluded.content_type,
         source_version = excluded.source_version,
         source_hash = excluded.source_hash,
         updated_at = excluded.updated_at
-    `).run(source.sourceKey ?? source.source, source.source, source.workspace, source.localPath ?? null, source.contentType ?? null, source.sourceVersion ?? null, source.sourceHash ?? null);
+    `).run(sourceKey, source.source, source.workspace, source.localPath ?? null, source.contentType ?? null, source.sourceVersion ?? null, source.sourceHash ?? null);
         const row = db.prepare('SELECT * FROM rdf_text_sources WHERE source = ?').get(source.source);
         if (!row) {
             throw new Error(`Failed to upsert RDF text source: ${source.source}`);
@@ -768,6 +782,18 @@ function rdfTextSourceMetadata(row) {
         updatedAt: row.updated_at,
     };
 }
+function normalizeSourceListLimit(value) {
+    if (!value || !Number.isFinite(value) || value <= 0) {
+        return 1_000;
+    }
+    return Math.min(Math.floor(value), 10_000);
+}
+function normalizeSourceListOffset(value) {
+    if (!value || !Number.isFinite(value) || value <= 0) {
+        return 0;
+    }
+    return Math.floor(value);
+}
 function rdfTextRebuildStatus(row) {
     return {
         source: row.source,
@@ -782,6 +808,46 @@ function rdfTextRebuildStatus(row) {
         updatedAt: row.updated_at,
     };
 }
+function hasAnyTable(db, tables) {
+    return tables.some((table) => hasTable(db, table));
+}
+function hasTable(db, table) {
+    return db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table) != null;
+}
+function assertRequiredColumns(db, table, requiredColumns) {
+    const columns = new Set(db.prepare(`PRAGMA table_info(${table})`)
+        .all()
+        .map((column) => column.name));
+    for (const column of requiredColumns) {
+        if (!columns.has(column)) {
+            throw new Error(`Unsupported RDF text index schema: missing column ${table}.${column}`);
+        }
+    }
+}
+function assertNotNullColumn(db, table, column) {
+    const row = db.prepare(`PRAGMA table_info(${quoteSqliteIdentifier(table)})`)
+        .all()
+        .find((entry) => entry.name === column);
+    if (!row || row.notnull !== 1) {
+        throw new Error(`Unsupported RDF text index schema: column ${table}.${column} must be NOT NULL`);
+    }
+}
+function assertUniqueColumn(db, table, column) {
+    const indexes = db.prepare(`PRAGMA index_list(${quoteSqliteIdentifier(table)})`).all();
+    for (const index of indexes) {
+        if (index.unique !== 1) {
+            continue;
+        }
+        const columns = db.prepare(`PRAGMA index_info(${quoteSqliteIdentifier(index.name)})`).all();
+        if (columns.length === 1 && columns[0].name === column) {
+            return;
+        }
+    }
+    throw new Error(`Unsupported RDF text index schema: column ${table}.${column} must be UNIQUE`);
+}
+function quoteSqliteIdentifier(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
 function chunkRdfTextSource(source, text) {
     if (!text) {
         return [];
@@ -790,18 +856,24 @@ function chunkRdfTextSource(source, text) {
         return chunkFolderCard(source, text);
     }
     if (isMarkdownSource(source)) {
-        const chunker = new HeadingChunker_1.HeadingChunker();
-        return chunker.flatten(chunker.chunk(text))
-            .filter((chunk) => chunk.content.trim().length > 0)
-            .map((chunk, index) => ({
-            chunkKey: deterministicChunkKey(source.source, index),
-            ordinal: index,
-            level: chunk.level,
-            heading: chunk.heading || undefined,
-            path: chunk.path,
-            content: chunk.content,
-            startOffset: chunk.startOffset,
-            endOffset: chunk.endOffset,
+        const projector = new MarkdownRetrievalPointProjector_1.MarkdownRetrievalPointProjector();
+        return projector.project({
+            sourceKey: source.sourceKey ?? source.source,
+            sourceUri: source.source,
+            representationHash: sha256(text),
+            markdown: text,
+        }).map((point) => ({
+            chunkKey: point.chunkKey,
+            retrievalPointKey: point.retrievalPointKey,
+            retrievalKind: point.retrievalKind,
+            chunkPolicyVersion: point.chunkPolicyVersion,
+            ordinal: point.ordinal,
+            level: point.level,
+            heading: point.heading,
+            path: point.path,
+            content: point.content,
+            startOffset: point.startOffset,
+            endOffset: point.endOffset,
         }));
     }
     return chunkPlainText(source.source, text);

package/dist/storage/rdf/RdfTextIndex.jsonld

@@ -78,6 +78,10 @@
           "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_sourceMetadata",
           "memberFieldName": "sourceMetadata"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_listSources",
+          "memberFieldName": "listSources"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_recordRebuildStatus",
           "memberFieldName": "recordRebuildStatus"
@@ -98,6 +102,10 @@
           "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_deleteSource",
           "memberFieldName": "deleteSource"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_listSourceChunks",
+          "memberFieldName": "listSourceChunks"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_search",
           "memberFieldName": "search"
@@ -119,20 +127,8 @@
           "memberFieldName": "initializeSchema"
         },
         {
-          "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_ensureSourceKeyColumn",
-          "memberFieldName": "ensureSourceKeyColumn"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_ensureChunkRetrievalColumns",
-          "memberFieldName": "ensureChunkRetrievalColumns"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_ensureEntityProvenanceColumns",
-          "memberFieldName": "ensureEntityProvenanceColumns"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_backfillTermPostings",
-          "memberFieldName": "backfillTermPostings"
+          "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_validateSchema",
+          "memberFieldName": "validateSchema"
         },
         {
           "@id": "undefineds:dist/storage/rdf/RdfTextIndex.jsonld#RdfTextIndex__member_upsertSource",

package/dist/storage/rdf/RdfVectorIndex.d.ts

@@ -1,4 +1,5 @@
 import type { RdfVectorChunkInput, RdfVectorChunkRow, RdfVectorDistanceMetric, RdfSearchCardinalityEstimate, RdfVectorIndexOptions, RdfVectorIndexSyncLike, RdfVectorIndexStats, RdfVectorModelDistribution, RdfVectorSearchOrder, RdfVectorSearchOptions, RdfVectorSearchResult, RdfVectorSourceInput, RdfVectorScoreComponents, RdfVectorSummaryLifecycleEntry, RdfVectorSummaryLifecycleOptions, RdfVectorSummaryMetadata } from './types';
+export declare const RDF_VECTOR_SCHEMA_VERSION = 2;
 export interface RdfVectorScoredChunkRow extends RdfVectorChunkRow {
     dot_product: number;
     vector_score: number;
@@ -13,18 +14,17 @@ export declare class RdfVectorIndex implements RdfVectorIndexSyncLike {
     open(): void;
     close(): void;
     clear(): void;
+    schemaVersion(): number;
     indexVector(source: RdfVectorSourceInput, chunks: RdfVectorChunkInput[]): void;
     deleteSource(source: string): number;
+    moveSource(oldSource: string, next: RdfVectorSourceInput): number;
     search(options: RdfVectorSearchOptions): RdfVectorSearchResult[];
     summaryLifecycle(options?: RdfVectorSummaryLifecycleOptions): RdfVectorSummaryLifecycleEntry[];
     estimateSearchCardinality(options: RdfVectorSearchOptions): RdfSearchCardinalityEstimate;
     stats(): RdfVectorIndexStats;
     modelDistribution(): RdfVectorModelDistribution[];
     private initializeSchema;
-    private ensureSourceKeyColumn;
-    private ensureVectorIdentityColumns;
-    private ensureVectorChunkIdentityUniqueConstraint;
-    private backfillVectorComponents;
+    private validateSchema;
     private upsertSource;
     private estimateDatabaseBytes;
     private toSearchResult;