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

package/dist/storage/rdf/PostgresRdfTextIndex.js

@@ -5,8 +5,26 @@ const pglite_1 = require("@electric-sql/pglite");
 const PostgresPoolManager_1 = require("../database/PostgresPoolManager");
 const RdfSearchSourceFilter_1 = require("./RdfSearchSourceFilter");
 const PostgresRdfSqlExecutor_1 = require("./PostgresRdfSqlExecutor");
+const PostgresRdfSchemaValidation_1 = require("./PostgresRdfSchemaValidation");
 const RdfTextIndex_1 = require("./RdfTextIndex");
 const PG_NATIVE_FTS_BACKEND_VERSION = 1;
+const PG_RDF_TEXT_SCHEMA_LOCK_KEY = 2026072901;
+const PG_RDF_TEXT_DOMAIN_TABLES = [
+    'rdf_text_metadata',
+    'rdf_text_sources',
+    'rdf_text_rebuild_status',
+    'rdf_text_chunks',
+    'rdf_text_terms',
+    'rdf_text_entities',
+];
+const PG_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 PostgresRdfTextIndex {
     constructor(options = {}) {
         this.executor = null;
@@ -50,7 +68,10 @@ class PostgresRdfTextIndex {
         await this.requireExecutor().exec('DELETE FROM rdf_text_rebuild_status; DELETE FROM rdf_text_entities; DELETE FROM rdf_text_terms; DELETE FROM rdf_text_chunks; DELETE FROM rdf_text_sources;');
     }
     async schemaVersion() {
-        const row = await this.requireExecutor()
+        return await this.readSchemaVersion(this.requireExecutor());
+    }
+    async readSchemaVersion(executor) {
+        const row = await executor
             .query("SELECT value FROM rdf_text_metadata WHERE key = 'schema_version'");
         return Number(row[0]?.value ?? 0) || 0;
     }
@@ -59,6 +80,34 @@ class PostgresRdfTextIndex {
             .query('SELECT * FROM rdf_text_sources WHERE source = $1', [source]);
         return rows[0] ? rdfTextSourceMetadata(rows[0]) : undefined;
     }
+    async listSources(options = {}) {
+        const conditions = [];
+        const params = [];
+        if (options.workspace) {
+            params.push(options.workspace);
+            conditions.push(`workspace = $${params.length}`);
+        }
+        if (options.sourcePrefix) {
+            params.push(options.sourcePrefix);
+            conditions.push(`source >= $${params.length}`);
+            params.push(`${options.sourcePrefix}\uffff`);
+            conditions.push(`source < $${params.length}`);
+        }
+        params.push(normalizeSourceListLimit(options.limit));
+        const limitPlaceholder = `$${params.length}`;
+        params.push(normalizeSourceListOffset(options.offset));
+        const offsetPlaceholder = `$${params.length}`;
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const rows = await this.requireExecutor().query(`
+      SELECT *
+      FROM rdf_text_sources
+      ${where}
+      ORDER BY source ASC
+      LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}
+    `, params);
+        return rows.map(rdfTextSourceMetadata);
+    }
     async recordRebuildStatus(input) {
         await this.requireExecutor().exec(`
       INSERT INTO rdf_text_rebuild_status (
@@ -191,6 +240,10 @@ class PostgresRdfTextIndex {
                 return 0;
             }
             const oldId = Number(oldRow.id);
+            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 countRows = await tx.query('SELECT COUNT(*) AS count FROM rdf_text_chunks WHERE source_id = $1', [oldId]);
             const targetRows = await tx.query('SELECT * FROM rdf_text_sources WHERE source = $1', [next.source]);
             const targetRow = targetRows[0];
@@ -214,13 +267,13 @@ class PostgresRdfTextIndex {
           updated_at = now()
         WHERE id = $8
       `, [
-                next.sourceKey ?? oldRow.source_key ?? oldRow.source,
+                sourceKey,
                 next.source,
                 next.workspace,
                 next.localPath ?? null,
                 next.contentType ?? null,
                 next.sourceVersion ?? null,
-                next.sourceHash ?? null,
+                next.sourceHash ?? oldRow.source_hash ?? null,
                 oldId,
             ]);
             await tx.exec(`
@@ -240,7 +293,7 @@ class PostgresRdfTextIndex {
                 next.localPath ?? null,
                 next.contentType ?? null,
                 next.sourceVersion ?? null,
-                next.sourceHash ?? null,
+                next.sourceHash ?? oldRow.source_hash ?? null,
                 oldSource,
             ]);
             return Math.max(Number(countRows[0]?.count ?? 0), 1);
@@ -391,6 +444,39 @@ class PostgresRdfTextIndex {
         const entities = await this.entitiesForChunks(normalizedRows.map((result) => result.row.id));
         return normalizedRows.map((result) => toSearchResult(result.row, query, result.score, entities.get(result.row.id) ?? []));
     }
+    async listSourceChunks(sourceKey) {
+        const rows = await this.requireExecutor().query(`
+      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,
+        0 AS score
+      FROM rdf_text_chunks chunk
+      JOIN rdf_text_sources source ON source.id = chunk.source_id
+      WHERE source.source_key = $1 OR source.source = $1
+      ORDER BY source.source ASC, chunk.ordinal ASC, chunk.chunk_key ASC
+    `, [sourceKey]);
+        const normalizedRows = rows.map((row) => normalizeTextChunkRow(row));
+        const entities = await this.entitiesForChunks(normalizedRows.map((row) => row.id));
+        return normalizedRows.map((row) => toSearchResult(row, '', 0, entities.get(row.id) ?? []));
+    }
     async estimateSearchCardinality(options) {
         const query = (0, RdfTextIndex_1.normalizeRdfText)(options.query);
         const entityFilter = normalizeEntityFilter(options.entities);
@@ -628,15 +714,24 @@ class PostgresRdfTextIndex {
         await this.initializeSchema();
     }
     async initializeSchema() {
-        await this.requireExecutor().exec(`
-      CREATE TABLE IF NOT EXISTS rdf_text_metadata (
+        await this.requireExecutor().transaction(async (executor) => {
+            await executor.exec('SELECT pg_advisory_xact_lock($1)', [PG_RDF_TEXT_SCHEMA_LOCK_KEY]);
+            if (await (0, PostgresRdfSchemaValidation_1.pgHasAnyDomainTable)(executor, PG_RDF_TEXT_DOMAIN_TABLES)) {
+                await this.validateSchema(executor);
+                if (this.nativeFtsEnabled()) {
+                    await this.validateNativeFtsSchema(executor);
+                }
+                return;
+            }
+            await executor.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 BIGSERIAL PRIMARY KEY,
-        source_key TEXT,
+        source_key TEXT NOT NULL UNIQUE,
         source TEXT NOT NULL UNIQUE,
         workspace TEXT NOT NULL,
         local_path TEXT,
@@ -646,7 +741,7 @@ class PostgresRdfTextIndex {
         updated_at TIMESTAMPTZ NOT NULL DEFAULT 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,
@@ -659,7 +754,7 @@ class PostgresRdfTextIndex {
         updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_text_chunks (
+      CREATE TABLE rdf_text_chunks (
         id BIGSERIAL PRIMARY KEY,
         source_id BIGINT NOT NULL REFERENCES rdf_text_sources(id) ON DELETE CASCADE,
         chunk_key TEXT NOT NULL,
@@ -677,7 +772,7 @@ class PostgresRdfTextIndex {
         UNIQUE (source_id, chunk_key)
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_text_terms (
+      CREATE TABLE rdf_text_terms (
         id BIGSERIAL PRIMARY KEY,
         term TEXT NOT NULL CHECK (length(term) <= ${RdfTextIndex_1.RDF_TEXT_TERM_MAX_INDEX_LENGTH}),
         source_id BIGINT NOT NULL REFERENCES rdf_text_sources(id) ON DELETE CASCADE,
@@ -687,7 +782,7 @@ class PostgresRdfTextIndex {
         UNIQUE (term, chunk_id)
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_text_entities (
+      CREATE TABLE rdf_text_entities (
         id BIGSERIAL PRIMARY KEY,
         entity TEXT NOT NULL,
         source_id BIGINT NOT NULL REFERENCES rdf_text_sources(id) ON DELETE CASCADE,
@@ -702,40 +797,29 @@ class PostgresRdfTextIndex {
         updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
       );
 
-      ALTER TABLE rdf_text_sources ADD COLUMN IF NOT EXISTS source_key TEXT;
-      UPDATE rdf_text_sources SET source_key = source WHERE source_key IS NULL;
-      ALTER TABLE rdf_text_chunks ADD COLUMN IF NOT EXISTS retrieval_kind TEXT NOT NULL DEFAULT 'file-chunk';
-      ALTER TABLE rdf_text_entities ADD COLUMN IF NOT EXISTS value TEXT;
-      ALTER TABLE rdf_text_entities ADD COLUMN IF NOT EXISTS datatype TEXT;
-      ALTER TABLE rdf_text_entities ADD COLUMN IF NOT EXISTS language TEXT;
-      ALTER TABLE rdf_text_entities ADD COLUMN IF NOT EXISTS policy_role TEXT;
-
-      CREATE INDEX IF NOT EXISTS rdf_text_sources_workspace ON rdf_text_sources(workspace);
-      CREATE INDEX IF NOT EXISTS rdf_text_sources_source ON rdf_text_sources(source);
-      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) > ${RdfTextIndex_1.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);
-      CREATE INDEX IF NOT EXISTS rdf_text_entities_entity ON rdf_text_entities(entity);
-      CREATE INDEX IF NOT EXISTS rdf_text_entities_source_entity ON rdf_text_entities(source_id, entity);
-      CREATE INDEX IF NOT EXISTS rdf_text_entities_chunk ON rdf_text_entities(chunk_id);
+      CREATE INDEX rdf_text_sources_workspace ON rdf_text_sources(workspace);
+      CREATE INDEX rdf_text_sources_source ON rdf_text_sources(source);
+      CREATE INDEX rdf_text_sources_local_path ON rdf_text_sources(local_path);
+      CREATE INDEX rdf_text_sources_workspace_local_path ON rdf_text_sources(workspace, local_path);
+      CREATE INDEX rdf_text_chunks_source ON rdf_text_chunks(source_id, ordinal);
+      CREATE INDEX rdf_text_terms_term ON rdf_text_terms(term);
+      CREATE INDEX rdf_text_terms_source_term ON rdf_text_terms(source_id, term);
+      CREATE INDEX rdf_text_terms_chunk ON rdf_text_terms(chunk_id);
+      CREATE INDEX rdf_text_entities_entity ON rdf_text_entities(entity);
+      CREATE INDEX rdf_text_entities_source_entity ON rdf_text_entities(source_id, entity);
+      CREATE INDEX rdf_text_entities_chunk ON rdf_text_entities(chunk_id);
 
       INSERT INTO rdf_text_metadata (key, value)
-      VALUES ('schema_version', '${RdfTextIndex_1.RDF_TEXT_SCHEMA_VERSION}')
-      ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value;
-    `);
-        await this.backfillTermPostings();
-        if (this.nativeFtsEnabled()) {
-            await this.initializeNativeFtsSchema();
-            await this.backfillNativeFtsRows();
-        }
+      VALUES ('schema_version', '${RdfTextIndex_1.RDF_TEXT_SCHEMA_VERSION}');
+      `);
+            if (this.nativeFtsEnabled()) {
+                await this.initializeNativeFtsSchema(executor);
+            }
+        });
     }
-    async initializeNativeFtsSchema() {
-        await this.requireExecutor().exec(`
-      CREATE TABLE IF NOT EXISTS rdf_text_fts_pg (
+    async initializeNativeFtsSchema(executor) {
+        await executor.exec(`
+      CREATE TABLE rdf_text_fts_pg (
         chunk_id BIGINT PRIMARY KEY REFERENCES rdf_text_chunks(id) ON DELETE CASCADE,
         backend_version INTEGER NOT NULL,
         config REGCONFIG NOT NULL,
@@ -744,48 +828,26 @@ class PostgresRdfTextIndex {
         updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
       );
 
-      CREATE INDEX IF NOT EXISTS rdf_text_fts_pg_vector_gin
+      CREATE INDEX rdf_text_fts_pg_vector_gin
         ON rdf_text_fts_pg USING GIN (fts_vector);
 
-      CREATE INDEX IF NOT EXISTS rdf_text_fts_pg_config
+      CREATE INDEX rdf_text_fts_pg_config
         ON rdf_text_fts_pg (backend_version, config);
     `);
     }
-    async backfillTermPostings() {
-        const rows = await this.requireExecutor().query(`
-      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 <> ''
-    `);
-        if (rows.length === 0) {
-            return;
+    async validateSchema(executor = this.requireExecutor()) {
+        for (const table of PG_RDF_TEXT_DOMAIN_TABLES) {
+            await (0, PostgresRdfSchemaValidation_1.assertPgRequiredColumns)(executor, table, PG_RDF_TEXT_REQUIRED_COLUMNS[table], 'text');
         }
-        await this.requireExecutor().transaction(async (tx) => {
-            for (const row of rows) {
-                await insertTermOccurrences(tx, Number(row.source_id), Number(row.id), row.normalized_text);
-            }
-        });
-    }
-    async backfillNativeFtsRows() {
-        const rows = await this.requireExecutor().query(`
-      SELECT chunk.id, chunk.heading, chunk.path, chunk.content
-      FROM rdf_text_chunks chunk
-      LEFT JOIN rdf_text_fts_pg fts ON fts.chunk_id = chunk.id
-      WHERE fts.chunk_id IS NULL OR fts.backend_version <> $1
-    `, [PG_NATIVE_FTS_BACKEND_VERSION]);
-        if (rows.length === 0) {
-            return;
+        const version = await this.readSchemaVersion(executor);
+        if (version !== RdfTextIndex_1.RDF_TEXT_SCHEMA_VERSION) {
+            throw new Error(`Unsupported PostgreSQL RDF text index schema version: expected ${RdfTextIndex_1.RDF_TEXT_SCHEMA_VERSION}, got ${version}`);
         }
-        await this.requireExecutor().transaction(async (tx) => {
-            for (const row of rows) {
-                await upsertNativeFtsProjection(tx, Number(row.id), {
-                    heading: row.heading ?? undefined,
-                    path: (0, RdfTextIndex_1.parseRdfTextPath)(row.path),
-                    content: row.content,
-                });
-            }
-        });
+        await (0, PostgresRdfSchemaValidation_1.assertPgNotNullColumn)(executor, 'rdf_text_sources', 'source_key', 'text');
+        await (0, PostgresRdfSchemaValidation_1.assertPgUniqueColumn)(executor, 'rdf_text_sources', 'source_key', 'text');
+    }
+    async validateNativeFtsSchema(executor = this.requireExecutor()) {
+        await (0, PostgresRdfSchemaValidation_1.assertPgRequiredColumns)(executor, 'rdf_text_fts_pg', ['chunk_id', 'backend_version', 'config', 'projection_hash', 'fts_vector', 'updated_at'], 'text');
     }
     nativeFtsEnabled() {
         return this.options.textSearchBackend === 'pg-native-fts' || this.options.textSearchBackend === 'auto';
@@ -794,6 +856,11 @@ class PostgresRdfTextIndex {
         return this.nativeFtsEnabled() && Boolean(query) && !containsNoSpaceCjk(query);
     }
     async upsertSource(tx, source) {
+        const existing = await tx.query('SELECT * FROM rdf_text_sources WHERE source = $1', [source.source]);
+        if (existing[0] && source.sourceKey && existing[0].source_key !== source.sourceKey) {
+            throw new Error(`RDF text source key mismatch for source ${source.source}: expected ${existing[0].source_key}, got ${source.sourceKey}`);
+        }
+        const sourceKey = existing[0]?.source_key ?? source.sourceKey ?? source.source;
         const rows = await tx.query(`
       INSERT INTO rdf_text_sources (
         source_key,
@@ -808,7 +875,6 @@ class PostgresRdfTextIndex {
       VALUES ($1, $2, $3, $4, $5, $6, $7, 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,
@@ -817,7 +883,7 @@ class PostgresRdfTextIndex {
         updated_at = EXCLUDED.updated_at
       RETURNING id
     `, [
-            source.sourceKey ?? source.source,
+            sourceKey,
             source.source,
             source.workspace,
             source.localPath ?? null,
@@ -1226,6 +1292,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,

package/dist/storage/rdf/PostgresRdfTextIndex.jsonld

@@ -300,10 +300,18 @@
           "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_schemaVersion",
           "memberFieldName": "schemaVersion"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_readSchemaVersion",
+          "memberFieldName": "readSchemaVersion"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_sourceMetadata",
           "memberFieldName": "sourceMetadata"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_listSources",
+          "memberFieldName": "listSources"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_recordRebuildStatus",
           "memberFieldName": "recordRebuildStatus"
@@ -328,6 +336,10 @@
           "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_search",
           "memberFieldName": "search"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_listSourceChunks",
+          "memberFieldName": "listSourceChunks"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_estimateSearchCardinality",
           "memberFieldName": "estimateSearchCardinality"
@@ -361,12 +373,12 @@
           "memberFieldName": "initializeNativeFtsSchema"
         },
         {
-          "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_backfillTermPostings",
-          "memberFieldName": "backfillTermPostings"
+          "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_validateSchema",
+          "memberFieldName": "validateSchema"
         },
         {
-          "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_backfillNativeFtsRows",
-          "memberFieldName": "backfillNativeFtsRows"
+          "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_validateNativeFtsSchema",
+          "memberFieldName": "validateNativeFtsSchema"
         },
         {
           "@id": "undefineds:dist/storage/rdf/PostgresRdfTextIndex.jsonld#PostgresRdfTextIndex__member_nativeFtsEnabled",

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

@@ -25,8 +25,11 @@ export declare class PostgresRdfVectorIndex implements RdfVectorIndexLike {
     open(): Promise<void>;
     close(): Promise<void>;
     clear(): Promise<void>;
+    schemaVersion(): Promise<number>;
+    private readSchemaVersion;
     indexVector(source: RdfVectorSourceInput, chunks: RdfVectorChunkInput[]): Promise<void>;
     deleteSource(source: string): Promise<number>;
+    moveSource(oldSource: string, next: RdfVectorSourceInput): Promise<number>;
     search(options: RdfVectorSearchOptions): Promise<RdfVectorSearchResult[]>;
     summaryLifecycle(options?: RdfVectorSummaryLifecycleOptions): Promise<RdfVectorSummaryLifecycleEntry[]>;
     estimateSearchCardinality(options: RdfVectorSearchOptions): Promise<RdfSearchCardinalityEstimate>;
@@ -34,12 +37,8 @@ export declare class PostgresRdfVectorIndex implements RdfVectorIndexLike {
     modelDistribution(): Promise<RdfVectorModelDistribution[]>;
     private openInternal;
     private initializeSchema;
-    private ensurePgVectorColumn;
+    private validateSchema;
     private ensurePgVectorSearchIndex;
-    private ensureSourceKeyColumn;
-    private ensureVectorIdentityColumns;
-    private ensureVectorChunkIdentityUniqueConstraint;
-    private backfillVectorComponents;
     private upsertSource;
     private estimateDatabaseBytes;
     private requireExecutor;