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

package/dist/storage/rdf/Rdf3xIndex.js

@@ -6,6 +6,8 @@ const node_path_1 = require("node:path");
 const n3_1 = require("n3");
 const SqliteRuntime_1 = require("../SqliteRuntime");
 const RdfTermDictionary_1 = require("./RdfTermDictionary");
+const RdfQuadIndex_1 = require("./RdfQuadIndex");
+const RdfSqliteConnection_1 = require("./RdfSqliteConnection");
 const RdfTermSemantics_1 = require("./RdfTermSemantics");
 const RdfJoinShape_1 = require("./RdfJoinShape");
 const Rdf3xSchema_1 = require("./Rdf3xSchema");
@@ -68,10 +70,18 @@ class Rdf3xIndex {
                 (0, node_fs_1.mkdirSync)(dir, { recursive: true });
             }
         }
-        this.db = this.sqliteRuntime.openDatabase(this.options.path);
-        this.dictionary = new RdfTermDictionary_1.RdfTermDictionary(this.db);
-        this.dictionary.initialize();
-        this.initializeSchema();
+        this.db = (0, RdfSqliteConnection_1.openRdfSqliteDatabase)(this.sqliteRuntime, this.options.path);
+        try {
+            (0, RdfQuadIndex_1.assertRdfFactsSchemaCompatible)(this.db);
+            this.dictionary = new RdfTermDictionary_1.RdfTermDictionary(this.db);
+            this.initializeSchema();
+        }
+        catch (error) {
+            this.db.close();
+            this.db = null;
+            this.dictionary = null;
+            throw error;
+        }
     }
     close() {
         this.db?.close();
@@ -677,10 +687,6 @@ class Rdf3xIndex {
     }
     initializeDirtyTrackingTriggers() {
         const db = this.requireDb();
-        const factsTable = db.prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name = 'rdf_quads'").get();
-        if (!factsTable) {
-            return;
-        }
         db.exec(`
       CREATE TRIGGER IF NOT EXISTS rdf3x_dirty_quads_insert
       AFTER INSERT ON rdf_quads
@@ -763,15 +769,13 @@ class Rdf3xIndex {
         (0, Rdf3xSchema_1.dropRdf3xDerivedSchemaObjects)(this.requireDb());
     }
     currentFactsDataVersion() {
-        try {
-            const row = this.requireDb()
-                .prepare("SELECT value FROM rdf_index_metadata WHERE key = 'data_version'")
-                .get();
-            return Number(row?.value ?? 0) || 0;
-        }
-        catch {
-            return 0;
+        const value = this.requireDb()
+            .prepare("SELECT value FROM rdf_index_metadata WHERE key = 'data_version'")
+            .get()?.value;
+        if (value === undefined || !/^(0|[1-9]\d*)$/.test(value)) {
+            throw new Error(`Unsupported RDF facts data version: ${value ?? 'missing'}`);
         }
+        return Number(value);
     }
     setFactsDataVersion(version) {
         this.requireDb().prepare(`

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

@@ -9,10 +9,14 @@ export type RdfAccessMode = typeof RdfAccessMode[keyof typeof RdfAccessMode];
 export interface RdfAccessScope {
     basePath: string;
     mode: RdfAccessMode;
+    resolved?: boolean;
     principal?: string;
     allowedGraphUrls?: string[];
     deniedGraphUrls?: string[];
     deniedGraphPrefixes?: string[];
+    allowedSourceUrls?: string[];
+    deniedSourceUrls?: string[];
+    deniedSourcePrefixes?: string[];
     version?: string;
 }
 export declare function isRestrictiveRdfAccessScope(scope?: RdfAccessScope): boolean;

package/dist/storage/rdf/RdfAccessScope.js

@@ -18,7 +18,10 @@ function isRestrictiveRdfAccessScope(scope) {
     return Boolean(scope
         && ((scope.allowedGraphUrls?.length ?? 0) > 0
             || (scope.deniedGraphUrls?.length ?? 0) > 0
-            || (scope.deniedGraphPrefixes?.length ?? 0) > 0));
+            || (scope.deniedGraphPrefixes?.length ?? 0) > 0
+            || (scope.allowedSourceUrls?.length ?? 0) > 0
+            || (scope.deniedSourceUrls?.length ?? 0) > 0
+            || (scope.deniedSourcePrefixes?.length ?? 0) > 0));
 }
 function rdfAccessCacheScope(scope) {
     if (!scope) {
@@ -32,6 +35,9 @@ function rdfAccessCacheScope(scope) {
         allowedGraphUrls: scope.allowedGraphUrls,
         deniedGraphUrls: scope.deniedGraphUrls,
         deniedGraphPrefixes: scope.deniedGraphPrefixes,
+        allowedSourceUrls: scope.allowedSourceUrls,
+        deniedSourceUrls: scope.deniedSourceUrls,
+        deniedSourcePrefixes: scope.deniedSourcePrefixes,
     };
 }
 function applyRdfAccessScope(query, scope) {
@@ -161,21 +167,51 @@ function scopeOptionalGroup(group, scope, state) {
     };
 }
 function scopePattern(pattern, filters, scope, state) {
+    const sourceScope = scopeFactSources(pattern.sourceScope, scope);
     const graph = pattern.graph ?? { $startsWith: scope.basePath };
     if (isVariable(graph)) {
         addGraphAccessFilters(filters, graph.variable, scope);
-        return pattern.graph ? pattern : { ...pattern, graph };
+        return {
+            ...pattern,
+            ...(pattern.graph ? {} : { graph }),
+            ...(sourceScope ? { sourceScope } : {}),
+        };
     }
     if ((0, types_1.isTerm)(graph)) {
+        if (graph.termType === 'DefaultGraph') {
+            const defaultGraphSourceScope = defaultGraphFactSources(pattern.sourceScope, scope);
+            if (defaultGraphSourceScope === false) {
+                return { ...pattern, graph: state.impossibleGraph, ...(sourceScope ? { sourceScope } : {}) };
+            }
+            return scope.allowedGraphUrls?.length
+                ? { ...pattern, graph: state.impossibleGraph, ...(sourceScope ? { sourceScope } : {}) }
+                : { ...pattern, ...(defaultGraphSourceScope ? { sourceScope: defaultGraphSourceScope } : {}) };
+        }
         return rdfAccessGraphAllowed(graph.value, scope)
-            ? pattern
-            : { ...pattern, graph: state.impossibleGraph };
+            ? { ...pattern, ...(sourceScope ? { sourceScope } : {}) }
+            : { ...pattern, graph: state.impossibleGraph, ...(sourceScope ? { sourceScope } : {}) };
     }
     return {
         ...pattern,
         graph: scopeGraphOperators(graph, scope, state.impossibleGraph),
+        ...(sourceScope ? { sourceScope } : {}),
     };
 }
+function defaultGraphFactSources(existing, scope) {
+    const sourcePrefix = intersectSourcePrefix(existing?.sourcePrefix, scope.basePath);
+    if (sourcePrefix === false) {
+        return false;
+    }
+    const defaultGraphScope = {
+        ...scope,
+        deniedSourceUrls: unionStringArrays(scope.deniedSourceUrls, scope.deniedGraphUrls),
+        deniedSourcePrefixes: unionStringArrays(scope.deniedSourcePrefixes, scope.deniedGraphPrefixes),
+    };
+    return scopeFactSources({
+        ...existing,
+        ...(sourcePrefix ? { sourcePrefix } : {}),
+    }, defaultGraphScope);
+}
 function scopeGraphOperators(graph, scope, impossibleGraph) {
     const operators = { ...graph };
     const prefix = intersectSourcePrefix(typeof operators.$startsWith === 'string' ? operators.$startsWith : undefined, scope.basePath);
@@ -276,8 +312,8 @@ function unionTermArrays(existing, incoming) {
 }
 function scopeSearchSources(existing, scope) {
     const prefix = intersectSourcePrefix(existing?.sourcePrefix, scope.basePath);
-    const deniedPrefixes = unionStringArrays(existing?.deniedSourcePrefixes, scope.deniedGraphPrefixes);
-    const deniedSources = unionStringArrays(existing?.deniedSources, scope.deniedGraphUrls);
+    const deniedPrefixes = unionStringArrays(unionStringArrays(existing?.deniedSourcePrefixes, scope.deniedGraphPrefixes), scope.deniedSourcePrefixes);
+    const deniedSources = unionStringArrays(unionStringArrays(existing?.deniedSources, scope.deniedGraphUrls), scope.deniedSourceUrls);
     if (prefix === false) {
         return {
             ...existing,
@@ -286,9 +322,8 @@ function scopeSearchSources(existing, scope) {
             deniedSourcePrefixes: deniedPrefixes,
         };
     }
-    const allowedFromScope = scope.allowedGraphUrls
-        ? scope.allowedGraphUrls.filter((source) => sourceMatchesPrefix(source, prefix))
-        : undefined;
+    const allowedFromScope = (scope.allowedSourceUrls ?? scope.allowedGraphUrls)
+        ?.filter((source) => sourceMatchesPrefix(source, prefix));
     const allowedSources = filterStringsByPrefix(intersectStringArrays(existing?.allowedSources, allowedFromScope), prefix);
     return {
         ...existing,
@@ -299,6 +334,33 @@ function scopeSearchSources(existing, scope) {
         ...(deniedPrefixes ? { deniedSourcePrefixes: deniedPrefixes } : {}),
     };
 }
+function scopeFactSources(existing, scope) {
+    const prefix = existing?.sourcePrefix;
+    const deniedPrefixes = nonEmptyStrings(unionStringArrays(existing?.deniedSourcePrefixes, scope.deniedSourcePrefixes));
+    const deniedSources = nonEmptyStrings(unionStringArrays(existing?.deniedSources, scope.deniedSourceUrls));
+    // An empty access-scope allow-list means that no source restriction was
+    // resolved. An explicitly empty pattern sourceScope remains fail-closed via
+    // existing?.allowedSources.
+    const allowedFromScope = scope.allowedSourceUrls?.length
+        ? scope.allowedSourceUrls
+        : undefined;
+    const allowedSources = filterStringsByPrefix(intersectStringArrays(existing?.allowedSources, allowedFromScope), prefix);
+    const hasAllowedRestriction = existing?.allowedSources !== undefined || allowedFromScope !== undefined;
+    if (!existing
+        && !prefix
+        && !hasAllowedRestriction
+        && !deniedSources
+        && !deniedPrefixes) {
+        return undefined;
+    }
+    return {
+        ...existing,
+        ...(prefix ? { sourcePrefix: prefix } : {}),
+        ...(hasAllowedRestriction && allowedSources !== undefined ? { allowedSources } : {}),
+        ...(deniedSources ? { deniedSources } : {}),
+        ...(deniedPrefixes ? { deniedSourcePrefixes: deniedPrefixes } : {}),
+    };
+}
 function intersectSourcePrefix(left, right) {
     if (!left) {
         return right;
@@ -342,4 +404,7 @@ function sourceMatchesPrefix(source, prefix) {
 function uniqueStrings(values) {
     return [...new Set(values.filter((value) => value.length > 0))].sort();
 }
+function nonEmptyStrings(values) {
+    return values && values.length > 0 ? values : undefined;
+}
 //# sourceMappingURL=RdfAccessScope.js.map

package/dist/storage/rdf/RdfAccessScope.jsonld

@@ -18,6 +18,10 @@
           "@id": "undefineds:dist/storage/rdf/RdfAccessScope.jsonld#RdfAccessScope__member_mode",
           "memberFieldName": "mode"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfAccessScope.jsonld#RdfAccessScope__member_resolved",
+          "memberFieldName": "resolved"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfAccessScope.jsonld#RdfAccessScope__member_principal",
           "memberFieldName": "principal"
@@ -34,6 +38,18 @@
           "@id": "undefineds:dist/storage/rdf/RdfAccessScope.jsonld#RdfAccessScope__member_deniedGraphPrefixes",
           "memberFieldName": "deniedGraphPrefixes"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfAccessScope.jsonld#RdfAccessScope__member_allowedSourceUrls",
+          "memberFieldName": "allowedSourceUrls"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfAccessScope.jsonld#RdfAccessScope__member_deniedSourceUrls",
+          "memberFieldName": "deniedSourceUrls"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfAccessScope.jsonld#RdfAccessScope__member_deniedSourcePrefixes",
+          "memberFieldName": "deniedSourcePrefixes"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfAccessScope.jsonld#RdfAccessScope__member_version",
           "memberFieldName": "version"

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

@@ -0,0 +1,14 @@
+import type { Source, Stream, Term } from '@rdfjs/types';
+import { type RdfAccessScope } from './RdfAccessScope';
+import type { RdfEngineLike } from './types';
+export interface RdfEngineRdfJsSourceOptions {
+    accessScope?: RdfAccessScope;
+    signal?: AbortSignal;
+}
+export declare class RdfEngineRdfJsSource implements Source {
+    private readonly rdfEngine;
+    private readonly options;
+    constructor(rdfEngine: RdfEngineLike, options?: RdfEngineRdfJsSourceOptions);
+    match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): Stream;
+    countQuads(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): Promise<number>;
+}

package/dist/storage/rdf/RdfEngineRdfJsSource.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RdfEngineRdfJsSource = void 0;
+const asynciterator_1 = require("asynciterator");
+const n3_1 = require("n3");
+const RdfAccessScope_1 = require("./RdfAccessScope");
+const { quad, defaultGraph } = n3_1.DataFactory;
+class RdfEngineRdfJsSource {
+    constructor(rdfEngine, options = {}) {
+        this.rdfEngine = rdfEngine;
+        this.options = options;
+    }
+    match(subject, predicate, object, graph) {
+        return new RdfEngineMatchIterator(this.rdfEngine, {
+            subject,
+            predicate,
+            object,
+            graph,
+        }, this.options);
+    }
+    async countQuads(subject, predicate, object, graph) {
+        return executeCount(this.rdfEngine, {
+            subject,
+            predicate,
+            object,
+            graph,
+        }, this.options);
+    }
+}
+exports.RdfEngineRdfJsSource = RdfEngineRdfJsSource;
+class RdfEngineMatchIterator extends asynciterator_1.BufferedIterator {
+    constructor(rdfEngine, terms, options) {
+        super({ autoStart: false });
+        this.rdfEngine = rdfEngine;
+        this.terms = terms;
+        this.options = options;
+        this.started = false;
+        this.abort = () => this.destroy(createAbortError(options.signal));
+        options.signal?.addEventListener('abort', this.abort, { once: true });
+    }
+    _read(_count, done) {
+        if (this.started) {
+            done();
+            return;
+        }
+        this.started = true;
+        executeMatch(this.rdfEngine, this.terms, this.options)
+            .then((quads) => {
+            for (const item of quads) {
+                this._push(item);
+            }
+            this.close();
+            done();
+        })
+            .catch((error) => {
+            this.destroy(error instanceof Error ? error : new Error(String(error)));
+            done();
+        });
+    }
+    _destroy(cause, callback) {
+        this.options.signal?.removeEventListener('abort', this.abort);
+        super._destroy(cause, callback);
+    }
+}
+const SLOT_NAMES = ['subject', 'predicate', 'object', 'graph'];
+async function executeMatch(rdfEngine, terms, options) {
+    const select = SLOT_NAMES.filter((slot) => isUnboundMatchTerm(terms[slot]));
+    const result = await queryWithAbort(rdfEngine, (0, RdfAccessScope_1.applyRdfAccessScope)({
+        patterns: [matchPattern(terms)],
+        select,
+    }, options.accessScope), options.signal);
+    assertNotAborted(options.signal);
+    return result.bindings.map((row) => {
+        assertNotAborted(options.signal);
+        return quad(requireQuadSubject(isUnboundMatchTerm(terms.subject) ? requireBinding(row, 'subject') : terms.subject), requireQuadPredicate(isUnboundMatchTerm(terms.predicate) ? requireBinding(row, 'predicate') : terms.predicate), requireQuadObject(isUnboundMatchTerm(terms.object) ? requireBinding(row, 'object') : terms.object), requireQuadGraph(isUnboundMatchTerm(terms.graph) ? (row.graph ?? defaultGraph()) : terms.graph));
+    });
+}
+async function executeCount(rdfEngine, terms, options) {
+    const countSlot = 'count';
+    const result = await queryWithAbort(rdfEngine, (0, RdfAccessScope_1.applyRdfAccessScope)({
+        patterns: [matchPattern(terms)],
+        select: [countSlot],
+        aggregates: [{ type: 'count', as: countSlot }],
+    }, options.accessScope), options.signal);
+    const count = Number(result.bindings[0]?.[countSlot]?.value ?? result.count);
+    if (!Number.isSafeInteger(count) || count < 0) {
+        throw new Error('RDF/JS source count query returned an invalid count');
+    }
+    return count;
+}
+function matchPattern(terms) {
+    return {
+        subject: termPattern(terms.subject, 'subject'),
+        predicate: termPattern(terms.predicate, 'predicate'),
+        object: termPattern(terms.object, 'object'),
+        graph: termPattern(terms.graph, 'graph'),
+    };
+}
+function queryWithAbort(rdfEngine, query, signal) {
+    assertNotAborted(signal);
+    if (!signal) {
+        return Promise.resolve(rdfEngine.query(query));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (complete) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            complete();
+        };
+        const onAbort = () => settle(() => reject(createAbortError(signal)));
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted) {
+            onAbort();
+            return;
+        }
+        Promise.resolve()
+            .then(() => {
+            assertNotAborted(signal);
+            return rdfEngine.query(query);
+        })
+            .then((result) => settle(() => resolve(result)), (error) => settle(() => reject(error)));
+    });
+}
+function termPattern(term, variable) {
+    if (isUnboundMatchTerm(term)) {
+        return { variable };
+    }
+    return term;
+}
+function isUnboundMatchTerm(term) {
+    return !term || term.termType === 'Variable';
+}
+function requireBinding(row, slot) {
+    const term = row[slot];
+    if (!term) {
+        throw new Error(`RDF/JS source query result is missing ${slot} binding`);
+    }
+    return term;
+}
+function requireQuadSubject(term) {
+    if (term.termType === 'NamedNode' || term.termType === 'BlankNode') {
+        return term;
+    }
+    throw new Error(`RDF/JS source query result has invalid subject term type ${term.termType}`);
+}
+function requireQuadPredicate(term) {
+    if (term.termType === 'NamedNode') {
+        return term;
+    }
+    throw new Error(`RDF/JS source query result has invalid predicate term type ${term.termType}`);
+}
+function requireQuadObject(term) {
+    if (term.termType === 'NamedNode'
+        || term.termType === 'BlankNode'
+        || term.termType === 'Literal') {
+        return term;
+    }
+    throw new Error(`RDF/JS source query result has invalid object term type ${term.termType}`);
+}
+function requireQuadGraph(term) {
+    if (term.termType === 'DefaultGraph' || term.termType === 'NamedNode' || term.termType === 'BlankNode') {
+        return term;
+    }
+    throw new Error(`RDF/JS source query result has invalid graph term type ${term.termType}`);
+}
+function assertNotAborted(signal) {
+    if (signal?.aborted) {
+        throw createAbortError(signal);
+    }
+}
+function createAbortError(signal) {
+    return signal?.reason instanceof Error
+        ? signal.reason
+        : new DOMException('RDF/JS source match aborted', 'AbortError');
+}
+//# sourceMappingURL=RdfEngineRdfJsSource.js.map

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

@@ -1,7 +1,9 @@
 import type { Quad } from '@rdfjs/types';
+import { type SqliteDatabase } from '../SqliteRuntime';
 import type { QuintPattern } from '../quint/types';
-import type { RdfCardinalityEstimate, RdfCardinalityDistributions, RdfIndexStats, RdfLiteralDatatypeDistribution, RdfIndexPutOptions, RdfIndexSpaceObject, RdfQuadJoinAggregateOptions, RdfQuadJoinCountOptions, RdfQuadJoinGroupAggregateOptions, RdfQuadJoinOptions, RdfQuadJoinPattern, RdfQuadJoinScanResult, RdfQuadTupleConstraintSource, RdfQuadIndexOptions, RdfQuadIndexScanResult, RdfQuadScanOptions, RdfPatternQuery, RdfSourceInput, RdfTermRewriteInput, RdfTermRewriteResult } from './types';
+import type { RdfCardinalityEstimate, RdfCardinalityDistributions, RdfIndexStats, RdfLiteralDatatypeDistribution, RdfIndexPutOptions, RdfIndexSpaceObject, RdfQuadJoinAggregateOptions, RdfQuadJoinCountOptions, RdfQuadJoinGroupAggregateOptions, RdfQuadJoinOptions, RdfQuadJoinPattern, RdfQuadJoinScanResult, RdfQuadTupleConstraintSource, RdfQuadIndexOptions, RdfQuadIndexScanResult, RdfQuadScanOptions, RdfPatternQuery, RdfSourceInput, RdfStoragePattern, RdfTermRewriteInput, RdfTermRewriteResult } from './types';
 type PatternKey = 'graph' | 'subject' | 'predicate' | 'object';
+export declare function assertRdfFactsSchemaCompatible(db: SqliteDatabase): void;
 export declare class RdfQuadIndex {
     private readonly options;
     private readonly sqliteRuntime;
@@ -27,10 +29,8 @@ export declare class RdfQuadIndex {
     rewriteTerms(input: RdfTermRewriteInput): RdfTermRewriteResult;
     private deleteInternal;
     dataVersion(): number;
-    migrationState(name: string): string | undefined;
-    setMigrationState(name: string, state: string): void;
-    scan(pattern: QuintPattern | RdfPatternQuery, options?: RdfQuadScanOptions): RdfQuadIndexScanResult;
-    scanWithTupleConstraints(pattern: QuintPattern, tupleSource: RdfQuadTupleConstraintSource, options?: RdfQuadScanOptions): RdfQuadIndexScanResult;
+    scan(pattern: RdfStoragePattern | RdfPatternQuery, options?: RdfQuadScanOptions): RdfQuadIndexScanResult;
+    scanWithTupleConstraints(pattern: RdfStoragePattern, tupleSource: RdfQuadTupleConstraintSource, options?: RdfQuadScanOptions): RdfQuadIndexScanResult;
     joinPatterns(patterns: RdfQuadJoinPattern[], options?: RdfQuadJoinOptions): RdfQuadJoinScanResult;
     countJoinPatterns(patterns: RdfQuadJoinPattern[], options: RdfQuadJoinCountOptions): RdfQuadJoinScanResult;
     aggregateJoinPatterns(patterns: RdfQuadJoinPattern[], options: RdfQuadJoinAggregateOptions): RdfQuadJoinScanResult;
@@ -49,10 +49,10 @@ export declare class RdfQuadIndex {
     private buildGroupAggregateOrderScope;
     private matchToJoinCondition;
     private joinRowsToBindings;
-    count(pattern: QuintPattern): number;
-    estimateCardinality(pattern: QuintPattern): RdfCardinalityEstimate;
-    countDistinct(pattern: QuintPattern, distinctKey: PatternKey): RdfCardinalityEstimate;
-    countDistinctTuple(pattern: QuintPattern, distinctKeys: PatternKey[]): RdfCardinalityEstimate;
+    count(pattern: RdfStoragePattern): number;
+    estimateCardinality(pattern: RdfStoragePattern): RdfCardinalityEstimate;
+    countDistinct(pattern: RdfStoragePattern, distinctKey: PatternKey): RdfCardinalityEstimate;
+    countDistinctTuple(pattern: RdfStoragePattern, distinctKeys: PatternKey[]): RdfCardinalityEstimate;
     stats(): RdfIndexStats;
     cardinalityDistributions(limit?: number): RdfCardinalityDistributions;
     literalDatatypeDistribution(): RdfLiteralDatatypeDistribution[];
@@ -66,15 +66,14 @@ export declare class RdfQuadIndex {
     collectSpaceObjects(): RdfIndexSpaceObject[];
     private estimateSpaceObjectsFromSchema;
     private estimatePageSize;
-    private initializeSchema;
-    private prepareSchemaVersion;
-    private ensureMetadataTable;
-    private dropIndexSchema;
+    private prepareFactsSchema;
+    private createFreshFactsSchema;
+    private hasExistingFactsSchema;
     private bumpDataVersion;
-    private setMetadataValue;
     private upsertSource;
     private updateSourceRow;
     private buildWhereClause;
+    private addSourceScopeConditions;
     private matchToCondition;
     private termTypeConditionJoin;
     private languageConditionJoin;