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

package/dist/acceptance/QleverSearchConformance.js

@@ -0,0 +1,686 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QLEVER_ACCEPTANCE_GATE_ENV = void 0;
+exports.qleverAcceptanceGateEnabled = qleverAcceptanceGateEnabled;
+exports.requireAcceptanceEnv = requireAcceptanceEnv;
+exports.createAcceptanceTempDir = createAcceptanceTempDir;
+exports.runLocalSearchFusionAcceptance = runLocalSearchFusionAcceptance;
+exports.createLocalNativeSearchEngine = createLocalNativeSearchEngine;
+exports.createPostgresSearchEngine = createPostgresSearchEngine;
+exports.runPostgresNativeSearchFusionAcceptance = runPostgresNativeSearchFusionAcceptance;
+exports.runPostgresPublicSearchFusionAcceptance = runPostgresPublicSearchFusionAcceptance;
+exports.runNativeSearchFusionAcceptance = runNativeSearchFusionAcceptance;
+exports.runPublicSearchFusionAcceptance = runPublicSearchFusionAcceptance;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const n3_1 = require("n3");
+const pg_1 = require("pg");
+const LocalQleverNativeSparqlClient_1 = require("../storage/rdf/LocalQleverNativeSparqlClient");
+const PostgresRdfEngine_1 = require("../storage/rdf/PostgresRdfEngine");
+const SolidRdfEngine_1 = require("../storage/rdf/SolidRdfEngine");
+const RdfQueryExecutor_1 = require("../storage/rdf/RdfQueryExecutor");
+const { namedNode, quad } = n3_1.DataFactory;
+exports.QLEVER_ACCEPTANCE_GATE_ENV = 'XPOD_QLEVER_ACCEPTANCE_GATE';
+function qleverAcceptanceGateEnabled() {
+    return process.env[exports.QLEVER_ACCEPTANCE_GATE_ENV] === '1';
+}
+function requireAcceptanceEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        throw new Error(`${name} is required when ${exports.QLEVER_ACCEPTANCE_GATE_ENV}=1`);
+    }
+    return value;
+}
+function createAcceptanceTempDir(name) {
+    const dir = (0, node_path_1.join)(process.cwd(), '.test-data', `${name}-${process.pid}`);
+    (0, node_fs_1.rmSync)(dir, { recursive: true, force: true });
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    return dir;
+}
+async function runLocalSearchFusionAcceptance(engine = new SolidRdfEngine_1.SolidRdfEngine({
+    index: { path: ':memory:' },
+    textIndex: { path: ':memory:' },
+    vectorIndex: { path: ':memory:' },
+    autoOpen: true,
+})) {
+    const oldSource = namedNode('https://pod.example/alice/projects/demo/old-card.md');
+    const movedSource = namedNode('https://pod.example/alice/projects/demo/moved-card.md');
+    const deniedSource = namedNode('https://pod.example/alice/projects/demo/private-card.md');
+    const docType = namedNode('https://schema.org/DigitalDocument');
+    const stableSourceKey = 'entity:card:fusion-stable';
+    const stablePointKey = 'point:intro';
+    try {
+        engine.put([
+            quad(movedSource, namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), docType, movedSource),
+            quad(deniedSource, namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), docType, deniedSource),
+        ]);
+        engine.indexTextSource({
+            sourceKey: stableSourceKey,
+            source: oldSource.value,
+            workspace: 'https://pod.example/alice/projects/demo/',
+            localPath: 'old-card.md',
+            contentType: 'text/markdown',
+            sourceHash: 'sha256:stable-card',
+        }, 'alpha late vector canonical card', [
+            {
+                chunkKey: stablePointKey,
+                retrievalPointKey: stablePointKey,
+                retrievalKind: 'file-chunk',
+                ordinal: 0,
+                level: 1,
+                content: 'alpha late vector canonical card',
+                startOffset: 0,
+                endOffset: 32,
+            },
+        ]);
+        const beforeVector = engine.query({
+            patterns: [],
+            textSearch: [{
+                    query: 'alpha late',
+                    scope: { workspace: 'https://pod.example/alice/projects/demo/' },
+                    source: 'source',
+                    sourceKey: 'sourceKey',
+                    retrievalPoint: 'retrievalPointKey',
+                    content: 'textSnippet',
+                }],
+            vectorSearch: [{
+                    embedding: [1, 0],
+                    vectorModel: 'acceptance-embed',
+                    scope: { workspace: 'https://pod.example/alice/projects/demo/' },
+                    source: 'vectorSource',
+                    sourceKey: 'sourceKey',
+                    retrievalPoint: 'retrievalPointKey',
+                    content: 'vectorSnippet',
+                }],
+            select: ['sourceKey', 'retrievalPointKey'],
+        });
+        if (beforeVector.bindings.length !== 0) {
+            throw new Error(`late vector invariant failed: expected no fused bindings before vector indexing, got ${beforeVector.bindings.length}`);
+        }
+        engine.indexVectorSource({
+            sourceKey: stableSourceKey,
+            source: oldSource.value,
+            workspace: 'https://pod.example/alice/projects/demo/',
+            localPath: 'old-card.md',
+            contentType: 'text/markdown',
+            sourceHash: 'sha256:stable-card',
+        }, [{
+                chunkKey: stablePointKey,
+                ordinal: 0,
+                level: 1,
+                content: 'alpha late vector canonical card',
+                startOffset: 0,
+                endOffset: 32,
+                embedding: [1, 0],
+                model: 'acceptance-embed',
+            }]);
+        engine.indexTextSource({
+            sourceKey: 'entity:card:denied',
+            source: deniedSource.value,
+            workspace: 'https://pod.example/alice/projects/demo/',
+            localPath: 'private-card.md',
+            contentType: 'text/markdown',
+        }, 'alpha late vector canonical card', [{
+                chunkKey: 'point:denied',
+                retrievalPointKey: 'point:denied',
+                retrievalKind: 'file-chunk',
+                ordinal: 0,
+                level: 1,
+                content: 'alpha late vector canonical card',
+                startOffset: 0,
+                endOffset: 32,
+            }]);
+        engine.indexVectorSource({
+            sourceKey: 'entity:card:denied',
+            source: deniedSource.value,
+            workspace: 'https://pod.example/alice/projects/demo/',
+            localPath: 'private-card.md',
+            contentType: 'text/markdown',
+        }, [{
+                chunkKey: 'point:denied',
+                ordinal: 0,
+                level: 1,
+                content: 'alpha late vector canonical card',
+                startOffset: 0,
+                endOffset: 32,
+                embedding: [1, 0],
+                model: 'acceptance-embed',
+            }]);
+        engine.moveTextSource(oldSource.value, {
+            source: movedSource.value,
+            workspace: 'https://pod.example/alice/projects/demo/',
+            localPath: 'moved-card.md',
+            contentType: 'text/markdown',
+        });
+        engine.moveVectorSource(oldSource.value, {
+            source: movedSource.value,
+            workspace: 'https://pod.example/alice/projects/demo/',
+            localPath: 'moved-card.md',
+            contentType: 'text/markdown',
+        });
+        const result = engine.query({
+            textSearch: [{
+                    query: 'alpha late',
+                    scope: {
+                        workspace: 'https://pod.example/alice/projects/demo/',
+                        deniedSources: [deniedSource.value],
+                    },
+                    source: 'source',
+                    sourceKey: 'sourceKey',
+                    retrievalPoint: 'retrievalPointKey',
+                    content: 'textSnippet',
+                }],
+            vectorSearch: [{
+                    embedding: [1, 0],
+                    vectorModel: 'acceptance-embed',
+                    scope: {
+                        workspace: 'https://pod.example/alice/projects/demo/',
+                        deniedSources: [deniedSource.value],
+                    },
+                    source: 'vectorSource',
+                    sourceKey: 'sourceKey',
+                    retrievalPoint: 'retrievalPointKey',
+                    content: 'vectorSnippet',
+                }],
+            patterns: [{
+                    graph: (0, RdfQueryExecutor_1.variable)('source'),
+                    subject: (0, RdfQueryExecutor_1.variable)('source'),
+                    predicate: namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'),
+                    object: docType,
+                }],
+            select: ['source', 'sourceKey', 'retrievalPointKey', 'textSnippet', 'vectorSnippet'],
+            orderBy: [{ variable: 'source' }],
+        });
+        return result.bindings.map((binding) => ({
+            source: binding.source.value,
+            sourceKey: binding.sourceKey.value,
+            retrievalPointKey: binding.retrievalPointKey.value,
+            textSnippet: binding.textSnippet.value,
+            vectorSnippet: binding.vectorSnippet.value,
+        }));
+    }
+    finally {
+        await engine.close();
+    }
+}
+function createLocalNativeSearchEngine(runtimeCommand, databasePath) {
+    return new SolidRdfEngine_1.SolidRdfEngine({
+        index: { path: databasePath },
+        textIndex: { path: databasePath },
+        vectorIndex: { path: databasePath },
+        nativeSparqlClient: new LocalQleverNativeSparqlClient_1.LocalQleverNativeSparqlClient({
+            command: runtimeCommand,
+            args: ['--sqlite-path', databasePath],
+        }),
+    });
+}
+function createPostgresSearchEngine(connectionString, nativeSparqlEnabled) {
+    return new PostgresRdfEngine_1.PostgresRdfEngine({
+        driver: 'pg',
+        connectionString,
+        nativeSparqlEnabled,
+        rdfAccelerationProfile: 'pg-hot-operators',
+        maintenanceIntervalMs: 0,
+        textIndex: { driver: 'pg', connectionString },
+        vectorIndex: { driver: 'pg', connectionString },
+    });
+}
+async function runPostgresNativeSearchFusionAcceptance(connectionString) {
+    const schema = `xpod_search_${process.pid}_${(0, node_crypto_1.randomUUID)().replaceAll('-', '')}`;
+    const admin = new pg_1.Pool({ connectionString, max: 1 });
+    try {
+        await admin.query(`CREATE SCHEMA ${quoteIdentifier(schema)}`);
+        return await runNativeSearchFusionAcceptance(createPostgresSearchEngine(connectionStringWithSearchPath(connectionString, schema), true));
+    }
+    finally {
+        await admin.query(`DROP SCHEMA IF EXISTS ${quoteIdentifier(schema)} CASCADE`);
+        await admin.end();
+    }
+}
+async function runPostgresPublicSearchFusionAcceptance(connectionString) {
+    const schema = `xpod_search_${process.pid}_${(0, node_crypto_1.randomUUID)().replaceAll('-', '')}`;
+    const admin = new pg_1.Pool({ connectionString, max: 1 });
+    try {
+        await admin.query(`CREATE SCHEMA ${quoteIdentifier(schema)}`);
+        return await runPublicSearchFusionAcceptance(createPostgresSearchEngine(connectionStringWithSearchPath(connectionString, schema), false));
+    }
+    finally {
+        await admin.query(`DROP SCHEMA IF EXISTS ${quoteIdentifier(schema)} CASCADE`);
+        await admin.end();
+    }
+}
+async function runNativeSearchFusionAcceptance(engine, options = {}) {
+    const fixture = searchConformanceFixture(options);
+    const { workspace, oldSource, movedSource, deniedSource, stableSourceKey, stablePointKey, content, } = fixture;
+    await engine.open();
+    try {
+        await seedSearchConformanceBase(engine, fixture);
+        const textOnlyBeforeVector = await nativeBindings(engine, nativeTextOnlyQuery(), {
+            basePath: workspace,
+            operation: 'queryBindings',
+            acceptMediaType: 'application/sparql-results+json',
+            accessScope: resolvedReadScope(workspace),
+        });
+        const fusedBeforeVector = await nativeBindings(engine, nativeFusedQuery(), {
+            basePath: workspace,
+            operation: 'queryBindings',
+            acceptMediaType: 'application/sparql-results+json',
+            accessScope: resolvedReadScope(workspace),
+            vectorQuery: vectorQuery(),
+        });
+        await requireIndexVector(engine, {
+            ...sourceInput(oldSource, workspace, 'old-card.md'),
+            sourceKey: stableSourceKey,
+        }, content, stablePointKey);
+        const fusedAfterVector = await nativeBindings(engine, nativeFusedQuery(), {
+            basePath: workspace,
+            operation: 'queryBindings',
+            acceptMediaType: 'application/sparql-results+json',
+            accessScope: resolvedReadScope(workspace, [deniedSource]),
+            vectorQuery: vectorQuery(),
+        });
+        const fusedAfterVectorExact = await nativeBindings(engine, nativeFusedQuery(), {
+            basePath: workspace,
+            sourceUri: oldSource,
+            operation: 'queryBindings',
+            acceptMediaType: 'application/sparql-results+json',
+            accessScope: resolvedReadScope(workspace, [deniedSource]),
+            vectorQuery: vectorQuery(),
+        });
+        if (!engine.moveSource || !engine.moveTextSource || !engine.moveVectorSource) {
+            throw new Error('QLever search conformance requires source, FTS, and VEC move operations');
+        }
+        await engine.moveSource(oldSource, sourceInput(movedSource, workspace, 'moved-card.md'));
+        await engine.moveTextSource(oldSource, sourceInput(movedSource, workspace, 'moved-card.md'));
+        const fusedDuringMove = await nativeBindings(engine, nativeFusedQuery(), {
+            basePath: workspace,
+            operation: 'queryBindings',
+            acceptMediaType: 'application/sparql-results+json',
+            accessScope: resolvedReadScope(workspace, [deniedSource]),
+            vectorQuery: vectorQuery(),
+        });
+        const fusedDuringMoveExact = await nativeBindings(engine, nativeFusedQuery(), {
+            basePath: workspace,
+            sourceUri: movedSource,
+            operation: 'queryBindings',
+            acceptMediaType: 'application/sparql-results+json',
+            accessScope: resolvedReadScope(workspace, [deniedSource]),
+            vectorQuery: vectorQuery(),
+        });
+        await engine.moveVectorSource(oldSource, sourceInput(movedSource, workspace, 'moved-card.md'));
+        const oldSourceAfterMove = await nativeBindings(engine, nativeFusedQuery(), {
+            basePath: workspace,
+            sourceUri: oldSource,
+            operation: 'queryBindings',
+            acceptMediaType: 'application/sparql-results+json',
+            accessScope: resolvedReadScope(workspace),
+            vectorQuery: vectorQuery(),
+        });
+        const fusedAfterMove = await nativeBindings(engine, nativeFusedQuery(), {
+            basePath: workspace,
+            sourceUri: movedSource,
+            operation: 'queryBindings',
+            acceptMediaType: 'application/sparql-results+json',
+            accessScope: resolvedReadScope(workspace),
+            vectorQuery: vectorQuery(),
+        });
+        await seedDeniedSearchConformanceSource(engine, fixture);
+        const denied = resolvedReadScope(workspace, [deniedSource]);
+        const deniedSourceResult = await nativeBindings(engine, nativeFusedQuery(), {
+            basePath: workspace,
+            sourceUri: deniedSource,
+            operation: 'queryBindings',
+            acceptMediaType: 'application/sparql-results+json',
+            accessScope: denied,
+            vectorQuery: vectorQuery(),
+        });
+        const report = {
+            textOnlyBeforeVector,
+            fusedBeforeVector,
+            fusedAfterVector,
+            fusedAfterVectorExact,
+            fusedDuringMove,
+            fusedDuringMoveExact,
+            fusedAfterMove,
+            oldSourceAfterMove,
+            deniedSource: deniedSourceResult,
+        };
+        assertNativeSearchInvariants(report, { content, oldSource, movedSource });
+        return report;
+    }
+    finally {
+        await engine.close();
+    }
+}
+async function runPublicSearchFusionAcceptance(engine, options = {}) {
+    const fixture = searchConformanceFixture(options);
+    const { workspace, oldSource, movedSource, deniedSource, stableSourceKey, stablePointKey, content, } = fixture;
+    await engine.open();
+    try {
+        await seedSearchConformanceBase(engine, fixture);
+        const textOnlyBeforeVector = await publicBindings(engine, publicTextOnlyQuery(workspace));
+        const fusedBeforeVector = await publicBindings(engine, publicFusedQuery(workspace));
+        await requireIndexVector(engine, {
+            ...sourceInput(oldSource, workspace, 'old-card.md'),
+            sourceKey: stableSourceKey,
+        }, content, stablePointKey);
+        const fusedAfterVector = await publicBindings(engine, publicFusedQuery(workspace, {
+            deniedSources: [deniedSource],
+        }));
+        const fusedAfterVectorExact = await publicBindings(engine, publicFusedQuery(workspace, {
+            sourceUri: oldSource,
+            deniedSources: [deniedSource],
+        }));
+        if (!engine.moveSource || !engine.moveTextSource || !engine.moveVectorSource) {
+            throw new Error('Public search conformance requires source, FTS, and VEC move operations');
+        }
+        await engine.moveSource(oldSource, sourceInput(movedSource, workspace, 'moved-card.md'));
+        await engine.moveTextSource(oldSource, sourceInput(movedSource, workspace, 'moved-card.md'));
+        const fusedDuringMove = await publicBindings(engine, publicFusedQuery(workspace, {
+            deniedSources: [deniedSource],
+        }));
+        const fusedDuringMoveExact = await publicBindings(engine, publicFusedQuery(workspace, {
+            sourceUri: movedSource,
+            deniedSources: [deniedSource],
+        }));
+        await engine.moveVectorSource(oldSource, sourceInput(movedSource, workspace, 'moved-card.md'));
+        const oldSourceAfterMove = await publicBindings(engine, publicFusedQuery(workspace, {
+            sourceUri: oldSource,
+        }));
+        const fusedAfterMove = await publicBindings(engine, publicFusedQuery(workspace, {
+            sourceUri: movedSource,
+        }));
+        await seedDeniedSearchConformanceSource(engine, fixture);
+        const deniedSourceResult = await publicBindings(engine, publicFusedQuery(workspace, {
+            sourceUri: deniedSource,
+            deniedSources: [deniedSource],
+        }));
+        const report = {
+            textOnlyBeforeVector,
+            fusedBeforeVector,
+            fusedAfterVector,
+            fusedAfterVectorExact,
+            fusedDuringMove,
+            fusedDuringMoveExact,
+            fusedAfterMove,
+            oldSourceAfterMove,
+            deniedSource: deniedSourceResult,
+        };
+        assertNativeSearchInvariants(report, { content, oldSource, movedSource });
+        return report;
+    }
+    finally {
+        await engine.close();
+    }
+}
+function searchConformanceFixture(options = {}) {
+    const workspace = options.workspace ?? 'https://pod.example/alice/projects/native/';
+    return {
+        workspace,
+        oldSource: `${workspace}old-card.md`,
+        movedSource: `${workspace}moved-card.md`,
+        decoySource: `${workspace}decoy-card.md`,
+        deniedSource: `${workspace}private-card.md`,
+        stableSourceKey: 'entity:card:fusion-stable',
+        stablePointKey: 'point:intro',
+        decoySourceKey: 'entity:card:fusion-decoy',
+        deniedSourceKey: 'entity:card:denied',
+        deniedPointKey: 'point:denied',
+        content: 'alpha late vector canonical card',
+        decoyContent: 'beta same-point different-source decoy card',
+        deniedContent: 'alpha late vector denied private card',
+        graphPredicate: namedNode('urn:xpod:qlever:search:predicate'),
+        graphObject: namedNode('urn:xpod:qlever:search:object'),
+    };
+}
+async function seedSearchConformanceBase(engine, fixture) {
+    await engine.put(quad(namedNode(fixture.oldSource), fixture.graphPredicate, fixture.graphObject, namedNode(fixture.oldSource)), {
+        source: sourceInput(fixture.oldSource, fixture.workspace, 'old-card.md'),
+    });
+    await engine.put(quad(namedNode(fixture.decoySource), fixture.graphPredicate, fixture.graphObject, namedNode(fixture.decoySource)), {
+        source: sourceInput(fixture.decoySource, fixture.workspace, 'decoy-card.md'),
+    });
+    await requireIndexText(engine, {
+        ...sourceInput(fixture.oldSource, fixture.workspace, 'old-card.md'),
+        sourceKey: fixture.stableSourceKey,
+    }, fixture.content, fixture.stablePointKey);
+    await requireIndexText(engine, {
+        ...sourceInput(fixture.decoySource, fixture.workspace, 'decoy-card.md'),
+        sourceKey: fixture.decoySourceKey,
+    }, fixture.decoyContent, fixture.stablePointKey);
+    await requireIndexVector(engine, {
+        ...sourceInput(fixture.decoySource, fixture.workspace, 'decoy-card.md'),
+        sourceKey: fixture.decoySourceKey,
+    }, fixture.decoyContent, fixture.stablePointKey);
+}
+async function seedDeniedSearchConformanceSource(engine, fixture) {
+    await engine.put(quad(namedNode(fixture.deniedSource), fixture.graphPredicate, fixture.graphObject, namedNode(fixture.deniedSource)), {
+        source: sourceInput(fixture.deniedSource, fixture.workspace, 'private-card.md'),
+    });
+    await requireIndexText(engine, {
+        ...sourceInput(fixture.deniedSource, fixture.workspace, 'private-card.md'),
+        sourceKey: fixture.deniedSourceKey,
+    }, fixture.deniedContent, fixture.deniedPointKey);
+    await requireIndexVector(engine, {
+        ...sourceInput(fixture.deniedSource, fixture.workspace, 'private-card.md'),
+        sourceKey: fixture.deniedSourceKey,
+    }, fixture.deniedContent, fixture.deniedPointKey);
+}
+function sourceInput(source, workspace, localPath) {
+    return {
+        source,
+        workspace,
+        localPath,
+        contentType: 'text/markdown',
+        sourceHash: 'sha256:stable-card',
+    };
+}
+function textChunk(content, retrievalPointKey) {
+    return {
+        chunkKey: retrievalPointKey,
+        retrievalPointKey,
+        retrievalKind: 'file-chunk',
+        ordinal: 0,
+        level: 1,
+        content,
+        startOffset: 0,
+        endOffset: content.length,
+    };
+}
+async function requireIndexText(engine, source, content, retrievalPointKey) {
+    if (!engine.indexTextSource)
+        throw new Error('Search conformance requires FTS indexing');
+    await engine.indexTextSource(source, content, [textChunk(content, retrievalPointKey)]);
+}
+async function requireIndexVector(engine, source, content, retrievalPointKey) {
+    if (!engine.indexVectorSource)
+        throw new Error('Search conformance requires VEC indexing');
+    await engine.indexVectorSource(source, [{
+            chunkKey: retrievalPointKey,
+            ordinal: 0,
+            level: 1,
+            content,
+            startOffset: 0,
+            endOffset: content.length,
+            embedding: [1, 0],
+            provider: 'xpod',
+            model: 'acceptance-embed',
+            modelVersion: '2026-08-13',
+            inputKind: 'entity-card',
+            inputHash: 'sha256:stable-card',
+            projectionPolicyVersion: 'policy-v1',
+        }]);
+}
+function nativeTextOnlyQuery() {
+    return [
+        'SELECT ?retrieval WHERE {',
+        '  ?retrieval ql:contains-word "alpha" .',
+        '} ORDER BY ?retrieval',
+    ].join('\n');
+}
+function nativeFusedQuery() {
+    return [
+        'SELECT ?retrieval ?source WHERE {',
+        '  ?retrieval ql:contains-word "alpha" .',
+        '} ORDER BY ?source ?retrieval',
+    ].join('\n');
+}
+function vectorQuery() {
+    return {
+        embedding: [1, 0],
+        metric: 'cosine',
+        provider: 'xpod',
+        model: 'acceptance-embed',
+        modelVersion: '2026-08-13',
+        inputKind: 'entity-card',
+        projectionPolicyVersion: 'policy-v1',
+        limit: 10,
+        retrievalPointVariable: '?retrieval',
+        resourceVariable: '?source',
+    };
+}
+function publicTextOnlyQuery(workspace) {
+    return {
+        patterns: [],
+        textSearch: [{
+                query: 'alpha',
+                scope: { workspace },
+                content: 'retrieval',
+                sourceKey: 'sourceKey',
+                retrievalPoint: 'retrievalPointKey',
+            }],
+        select: ['retrieval'],
+        orderBy: [{ variable: 'retrieval' }],
+    };
+}
+function publicFusedQuery(workspace, options = {}) {
+    const textScope = {
+        workspace,
+        ...(options.sourceUri ? { allowedSources: [options.sourceUri] } : {}),
+        ...(options.deniedSources ? { deniedSources: options.deniedSources } : {}),
+    };
+    const vectorScope = {
+        workspace,
+        ...(options.deniedSources ? { deniedSources: options.deniedSources } : {}),
+    };
+    return {
+        patterns: [],
+        textSearch: [{
+                query: 'alpha',
+                scope: textScope,
+                source: 'source',
+                sourceKey: 'sourceKey',
+                retrievalPoint: 'retrievalPointKey',
+                content: 'retrieval',
+            }],
+        vectorSearch: [{
+                embedding: [1, 0],
+                metric: 'cosine',
+                vectorProvider: 'xpod',
+                vectorModel: 'acceptance-embed',
+                vectorModelVersion: '2026-08-13',
+                vectorInputKind: 'entity-card',
+                vectorProjectionPolicyVersion: 'policy-v1',
+                scope: vectorScope,
+                source: 'vectorSource',
+                sourceKey: 'sourceKey',
+                retrievalPoint: 'retrievalPointKey',
+                content: 'vectorRetrieval',
+            }],
+        select: ['retrieval', 'source'],
+        orderBy: [
+            { variable: 'source' },
+            { variable: 'retrieval' },
+        ],
+    };
+}
+function resolvedReadScope(basePath, deniedSourceUrls = []) {
+    return {
+        basePath,
+        mode: 'read',
+        resolved: true,
+        principal: 'urn:xpod:qlever-search-reader',
+        version: 'qlever-search-v1',
+        deniedSourceUrls,
+    };
+}
+async function nativeBindings(engine, sparql, options) {
+    if (!engine.sparqlQuery)
+        throw new Error('QLever search conformance requires native SPARQL');
+    const result = await engine.sparqlQuery(sparql, options);
+    validateNativeResult(result);
+    const parsed = JSON.parse(result.body);
+    return (parsed.results?.bindings ?? [])
+        .map((binding) => ({
+        retrieval: binding.retrieval?.value ?? '',
+        source: binding.source?.value,
+    }))
+        .filter((row) => row.retrieval)
+        .sort((left, right) => rowKey(left).localeCompare(rowKey(right)));
+}
+async function publicBindings(engine, query) {
+    const result = await engine.query(query);
+    return result.bindings
+        .map(publicRow)
+        .filter((row) => row.retrieval)
+        .sort((left, right) => rowKey(left).localeCompare(rowKey(right)));
+}
+function publicRow(binding) {
+    return {
+        retrieval: binding.retrieval?.value ?? '',
+        source: binding.source?.value,
+    };
+}
+function validateNativeResult(result) {
+    if (result.status !== 'ok' || result.mediaType !== 'application/sparql-results+json') {
+        throw new Error(`QLever search query failed: ${JSON.stringify(result)}`);
+    }
+}
+function assertNativeSearchInvariants(report, expected) {
+    if (report.textOnlyBeforeVector.length !== 1 ||
+        report.textOnlyBeforeVector[0].retrieval !== expected.content ||
+        report.textOnlyBeforeVector[0].source !== undefined) {
+        throw new Error(`FTS must remain available before any matching vector row exists: ${JSON.stringify(report.textOnlyBeforeVector)}`);
+    }
+    if (report.fusedBeforeVector.length !== 0) {
+        throw new Error(`FTS/VEC fusion must stay empty before the matching late vector; same-point decoys are not enough: ${JSON.stringify(report.fusedBeforeVector)}`);
+    }
+    assertExactStableRows(report.fusedAfterVector, expected.content, expected.oldSource, 'Late vector fusion mismatch');
+    assertExactStableRows(report.fusedAfterVectorExact, expected.content, expected.oldSource, 'Late vector exact-source fusion mismatch');
+    assertExactStableRows(report.fusedDuringMove, expected.content, expected.movedSource, 'Stable-key fusion failed while FTS/VEC locators differed');
+    assertExactStableRows(report.fusedDuringMoveExact, expected.content, expected.movedSource, 'Moved exact-source scope failed while the vector locator was stale');
+    assertExactStableRows(report.fusedAfterMove, expected.content, expected.movedSource, 'Move-stable fusion mismatch');
+    if (report.oldSourceAfterMove.length !== 0) {
+        throw new Error(`Old source returned after move: ${JSON.stringify(report.oldSourceAfterMove)}`);
+    }
+    if (report.deniedSource.length !== 0) {
+        throw new Error(`Denied source leaked from native search: ${JSON.stringify(report.deniedSource)}`);
+    }
+}
+function assertExactStableRows(rows, content, source, message) {
+    const expected = {
+        retrieval: content,
+        source,
+    };
+    if (rows.length !== 1 ||
+        rows[0].retrieval !== expected.retrieval ||
+        rows[0].source !== expected.source) {
+        throw new Error(`${message}: ${JSON.stringify(rows)}`);
+    }
+}
+function rowKey(row) {
+    return [row.source ?? '', row.retrieval].join('\u001f');
+}
+function connectionStringWithSearchPath(connectionString, schema) {
+    const url = new URL(connectionString);
+    url.searchParams.set('options', `-csearch_path=${schema},public`);
+    return url.toString();
+}
+function quoteIdentifier(value) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(value)) {
+        throw new Error(`Unsafe PostgreSQL identifier: ${value}`);
+    }
+    return `"${value}"`;
+}
+//# sourceMappingURL=QleverSearchConformance.js.map

package/dist/acceptance/QleverSemanticConformance.d.ts

@@ -0,0 +1,3 @@
+import { type LocalQleverSemanticHarnessOptions, type PostgresQleverSemanticHarnessOptions, type SemanticConformanceReport } from './RdfSemanticConformance';
+export declare function runLocalQleverSemanticConformance(options: LocalQleverSemanticHarnessOptions): Promise<SemanticConformanceReport>;
+export declare function runPostgresQleverSemanticConformance(options: PostgresQleverSemanticHarnessOptions): Promise<SemanticConformanceReport>;