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

package/dist/acceptance/QleverSemanticConformance.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLocalQleverSemanticConformance = runLocalQleverSemanticConformance;
+exports.runPostgresQleverSemanticConformance = runPostgresQleverSemanticConformance;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+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 SolidRdfDataAccessor_1 = require("../storage/accessors/SolidRdfDataAccessor");
+const RdfSemanticConformance_1 = require("./RdfSemanticConformance");
+async function runLocalQleverSemanticConformance(options) {
+    (0, RdfSemanticConformance_1.assertPath)('fixturePath', options.fixturePath);
+    (0, RdfSemanticConformance_1.assertPath)('runtimeCommand', options.runtimeCommand);
+    (0, RdfSemanticConformance_1.assertPath)('artifactPath', options.artifactPath);
+    const fixture = require(node_path_1.default.resolve(options.fixturePath));
+    const tempRoot = options.tempRoot ?? node_path_1.default.join(node_os_1.default.tmpdir(), `xpod-qlever-sqlite-semantic-${process.pid}-${(0, node_crypto_1.randomUUID)()}`);
+    (0, node_fs_1.mkdirSync)(tempRoot, { recursive: true });
+    const results = [];
+    const failed = [];
+    for (let index = 0; index < fixture.semanticConformanceCases.length; index += 1) {
+        const testCase = fixture.semanticConformanceCases[index];
+        const dbPath = node_path_1.default.join(tempRoot, `${String(index).padStart(2, '0')}-${(0, RdfSemanticConformance_1.slug)(testCase.id)}.sqlite`);
+        try {
+            results.push(await runLocalCase(options, testCase, dbPath));
+        }
+        catch (error) {
+            failed.push({
+                caseId: testCase.id,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    const report = (0, RdfSemanticConformance_1.buildSemanticReport)({
+        backend: 'sqlite',
+        engine: 'local-qlever-prepared-update-authority',
+        caseIds: fixture.REQUIRED_CASES,
+        failed,
+        results,
+        sourceDeniedValidatedBy: 'allowedSourceUrls/deniedSourceUrls resolved by sqlite physical provider',
+    });
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(options.artifactPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(options.artifactPath, `${JSON.stringify(report, null, 2)}\n`);
+    return report;
+}
+async function runPostgresQleverSemanticConformance(options) {
+    (0, RdfSemanticConformance_1.assertPath)('fixturePath', options.fixturePath);
+    (0, RdfSemanticConformance_1.assertPath)('artifactPath', options.artifactPath);
+    if (!options.connectionString) {
+        throw new Error('connectionString is required');
+    }
+    const fixture = require(node_path_1.default.resolve(options.fixturePath));
+    const admin = new pg_1.Pool({ connectionString: options.connectionString, max: 1 });
+    const results = [];
+    const failed = [];
+    try {
+        for (let index = 0; index < fixture.semanticConformanceCases.length; index += 1) {
+            const testCase = fixture.semanticConformanceCases[index];
+            const schema = `xpod_semantic_${process.pid}_${index}_${(0, node_crypto_1.randomUUID)().replaceAll('-', '')}`;
+            try {
+                await admin.query(`CREATE SCHEMA ${(0, RdfSemanticConformance_1.quoteIdentifier)(schema)}`);
+                const connectionString = (0, RdfSemanticConformance_1.connectionStringWithSearchPath)(options.connectionString, schema);
+                const engine = new PostgresRdfEngine_1.PostgresRdfEngine({
+                    driver: 'pg',
+                    connectionString,
+                    rdfAccelerationProfile: 'pg-hot-operators',
+                    nativeSparqlEnabled: true,
+                    maintenanceIntervalMs: 0,
+                });
+                results.push(await (0, RdfSemanticConformance_1.runCaseWithEngine)(engine, testCase, options.timeoutMs, `postgres-schema:${schema}`, true, nativeSemanticCaseExecutor));
+            }
+            catch (error) {
+                failed.push({
+                    caseId: testCase.id,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+            finally {
+                await admin.query(`DROP SCHEMA IF EXISTS ${(0, RdfSemanticConformance_1.quoteIdentifier)(schema)} CASCADE`);
+            }
+        }
+    }
+    finally {
+        await admin.end();
+    }
+    const report = (0, RdfSemanticConformance_1.buildSemanticReport)({
+        backend: 'pg',
+        engine: 'pg-qlever-prepared-update-authority',
+        caseIds: fixture.REQUIRED_CASES,
+        failed,
+        results,
+        sourceDeniedValidatedBy: 'allowedSourceUrls/deniedSourceUrls resolved by PG physical provider',
+    });
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(options.artifactPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(options.artifactPath, `${JSON.stringify(report, null, 2)}\n`);
+    return report;
+}
+async function runLocalCase(options, testCase, dbPath) {
+    (0, node_fs_1.rmSync)(dbPath, { force: true });
+    const seedEngine = new SolidRdfEngine_1.SolidRdfEngine({ index: { path: dbPath } });
+    await seedEngine.open();
+    try {
+        for (const document of testCase.documents) {
+            await (0, RdfSemanticConformance_1.seedDocument)(seedEngine, document);
+        }
+    }
+    finally {
+        await seedEngine.close();
+    }
+    const client = new LocalQleverNativeSparqlClient_1.LocalQleverNativeSparqlClient({
+        command: options.runtimeCommand,
+        args: ['--sqlite-path', dbPath],
+        cwd: options.runtimeCwd,
+        startupTimeoutMs: options.timeoutMs,
+        requestTimeoutMs: options.timeoutMs,
+    });
+    const engine = new SolidRdfEngine_1.SolidRdfEngine({
+        index: { path: dbPath },
+        nativeSparqlClient: client,
+    });
+    return await (0, RdfSemanticConformance_1.runCaseWithEngine)(engine, testCase, options.timeoutMs, `sqlite:${dbPath}`, false, nativeSemanticCaseExecutor);
+}
+async function prepareAndApplyUpdate(engine, sparql, sourceUri, timeoutMs) {
+    const result = await nativeSparqlQuery(engine, sparql, {
+        basePath: RdfSemanticConformance_1.DEFAULT_BASE_PATH,
+        sourceUri,
+        operation: 'prepareUpdate',
+        acceptMediaType: SolidRdfDataAccessor_1.PREPARED_UPDATE_MEDIA_TYPE,
+        timeoutMs,
+        accessScope: {
+            basePath: RdfSemanticConformance_1.DEFAULT_BASE_PATH,
+            mode: 'write',
+            resolved: true,
+            principal: 'urn:xpod:semantic-writer',
+            version: `semantic-write-${sourceUri}`,
+        },
+    });
+    (0, RdfSemanticConformance_1.validateEnvelope)(result, 'prepareUpdate', SolidRdfDataAccessor_1.PREPARED_UPDATE_MEDIA_TYPE);
+    const delta = (0, SolidRdfDataAccessor_1.parsePreparedUpdateDelta)(result.body);
+    const summary = { deletedRows: 0, insertedRows: 0 };
+    for (const graph of delta.graphs) {
+        const applied = await engine.applyDelta(graph.deletes.map(RdfSemanticConformance_1.exactQuadPattern), graph.inserts, {
+            source: {
+                source: graph.sourceUri,
+                workspace: 'semantic',
+                localPath: `/semantic/${(0, RdfSemanticConformance_1.slug)(graph.sourceUri)}`,
+                contentType: 'text/turtle',
+            },
+        });
+        summary.deletedRows += applied.deletedRows;
+        summary.insertedRows += applied.insertedRows;
+    }
+    await engine.refreshDerivedIndexes({ mode: 'full' });
+    return summary;
+}
+const nativeSemanticCaseExecutor = {
+    prepareAndApplyUpdate,
+    query: (engine, testCase, timeoutMs) => nativeSparqlQuery(engine, testCase.query, {
+        basePath: RdfSemanticConformance_1.DEFAULT_BASE_PATH,
+        operation: (0, RdfSemanticConformance_1.queryOperation)(testCase.acceptMediaType),
+        acceptMediaType: testCase.acceptMediaType,
+        timeoutMs,
+        accessScope: (0, RdfSemanticConformance_1.makeAccessScope)(testCase),
+    }),
+};
+function nativeSparqlQuery(engine, query, options) {
+    if (!engine.sparqlQuery) {
+        throw new Error('QLever semantic conformance requires native SPARQL');
+    }
+    return Promise.resolve(engine.sparqlQuery(query, options));
+}
+//# sourceMappingURL=QleverSemanticConformance.js.map

package/dist/acceptance/RdfSemanticConformance.d.ts

@@ -0,0 +1,114 @@
+import type { Quad, Term } from '@rdfjs/types';
+import type { RdfEngineLike, RdfNativeSparqlAccessScope, RdfNativeSparqlResult } from '../storage/rdf/types';
+export declare const DEFAULT_BASE_PATH = "urn:xpod:semantic:";
+export interface SemanticFixtureCase {
+    id: string;
+    documents: readonly {
+        sourceUri: string;
+        graph?: 'source' | 'default';
+        contentType: 'text/turtle';
+        body: string;
+    }[];
+    updates: readonly {
+        sourceUri: string;
+        sparql: string;
+    }[];
+    query: string;
+    acceptMediaType: string;
+    accessScope: {
+        principal: string;
+        mode: string;
+        allowedGraphs: readonly string[];
+        allowedSources: readonly string[];
+        deniedGraphs: readonly string[];
+        deniedSources: readonly string[];
+    };
+    expectedCanonical: Record<string, unknown>;
+}
+export interface LocalQleverSemanticHarnessOptions {
+    fixturePath: string;
+    runtimeCommand: string;
+    artifactPath: string;
+    tempRoot?: string;
+    runtimeCwd?: string;
+    timeoutMs?: number;
+}
+export interface PostgresQleverSemanticHarnessOptions {
+    fixturePath: string;
+    connectionString: string;
+    artifactPath: string;
+    timeoutMs?: number;
+}
+export type PostgresPublicSemanticHarnessOptions = PostgresQleverSemanticHarnessOptions;
+export interface SemanticConformanceReport {
+    schemaVersion: 1;
+    backend: 'sqlite' | 'pg';
+    engine: 'local-qlever-prepared-update-authority' | 'pg-qlever-prepared-update-authority' | 'pg-public-rdf-query-authority';
+    status: 'ok' | 'failed';
+    caseIds: string[];
+    skipped: [];
+    failed: {
+        caseId: string;
+        message: string;
+    }[];
+    results: {
+        caseId: string;
+        status: 'ok';
+        canonical: unknown;
+        preparedUpdates: number;
+        appliedDelta: {
+            deletedRows: number;
+            insertedRows: number;
+        };
+        authority: string;
+    }[];
+    authorization: {
+        deniedRowsObserved: number;
+    };
+    sourceScope: {
+        sourceDeniedValidatedBy: string;
+    };
+    canonicalDigest: string;
+}
+export interface SemanticParityResult {
+    caseIds: string[];
+    canonicalDigest: string;
+}
+export interface SemanticFixtureModule {
+    REQUIRED_CASES: readonly string[];
+    semanticConformanceCases: readonly SemanticFixtureCase[];
+}
+export interface SemanticCaseExecutor {
+    prepareAndApplyUpdate(engine: RdfEngineLike, sparql: string, sourceUri: string, timeoutMs: number | undefined): Promise<{
+        deletedRows: number;
+        insertedRows: number;
+    }>;
+    query(engine: RdfEngineLike, testCase: SemanticFixtureCase, timeoutMs: number | undefined): Promise<RdfNativeSparqlResult>;
+}
+export declare function runCaseWithEngine(engine: RdfEngineLike, testCase: SemanticFixtureCase, timeoutMs: number | undefined, authority: string, seedDocuments: boolean | undefined, executor: SemanticCaseExecutor): Promise<SemanticConformanceReport['results'][number]>;
+export declare function seedDocument(engine: RdfEngineLike, document: SemanticFixtureCase['documents'][number]): Promise<void>;
+export declare function assertSemanticConformanceParity(local: SemanticConformanceReport, cloud: SemanticConformanceReport): SemanticParityResult;
+export declare function makeAccessScope(testCase: SemanticFixtureCase): RdfNativeSparqlAccessScope;
+export declare function exactQuadPattern(quad: Quad): {
+    graph: import("@rdfjs/types").Quad_Graph;
+    subject: import("@rdfjs/types").Quad_Subject;
+    predicate: import("@rdfjs/types").Quad_Predicate;
+    object: import("@rdfjs/types").Quad_Object;
+};
+export declare function queryOperation(mediaType: string): 'queryBindings' | 'queryQuads';
+export declare function validateEnvelope(result: RdfNativeSparqlResult, context: string, mediaType: string): void;
+export declare function serializeQuads(quads: AsyncIterable<Quad>): Promise<string>;
+export declare function termToSparqlJson(term: Term): Record<string, string>;
+export declare function buildSemanticReport(options: {
+    backend: SemanticConformanceReport['backend'];
+    engine: SemanticConformanceReport['engine'];
+    caseIds: readonly string[];
+    failed: SemanticConformanceReport['failed'];
+    results: SemanticConformanceReport['results'];
+    sourceDeniedValidatedBy: string;
+}): SemanticConformanceReport;
+export declare function assertPath(name: string, value: string): void;
+export declare function connectionStringWithSearchPath(connectionString: string, schema: string): string;
+export declare function quoteIdentifier(value: string): string;
+export declare function slug(value: string): string;
+export declare function quadIdentity(quad: Quad): string;

package/dist/acceptance/RdfSemanticConformance.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BASE_PATH = void 0;
+exports.runCaseWithEngine = runCaseWithEngine;
+exports.seedDocument = seedDocument;
+exports.assertSemanticConformanceParity = assertSemanticConformanceParity;
+exports.makeAccessScope = makeAccessScope;
+exports.exactQuadPattern = exactQuadPattern;
+exports.queryOperation = queryOperation;
+exports.validateEnvelope = validateEnvelope;
+exports.serializeQuads = serializeQuads;
+exports.termToSparqlJson = termToSparqlJson;
+exports.buildSemanticReport = buildSemanticReport;
+exports.assertPath = assertPath;
+exports.connectionStringWithSearchPath = connectionStringWithSearchPath;
+exports.quoteIdentifier = quoteIdentifier;
+exports.slug = slug;
+exports.quadIdentity = quadIdentity;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const n3_1 = require("n3");
+exports.DEFAULT_BASE_PATH = 'urn:xpod:semantic:';
+async function runCaseWithEngine(engine, testCase, timeoutMs, authority, seedDocuments = true, executor) {
+    await engine.open();
+    let preparedUpdates = 0;
+    const appliedDelta = { deletedRows: 0, insertedRows: 0 };
+    try {
+        if (seedDocuments) {
+            for (const document of testCase.documents) {
+                await seedDocument(engine, document);
+            }
+        }
+        for (const update of testCase.updates) {
+            const applied = await executor.prepareAndApplyUpdate(engine, update.sparql, update.sourceUri, timeoutMs);
+            preparedUpdates += 1;
+            appliedDelta.deletedRows += applied.deletedRows;
+            appliedDelta.insertedRows += applied.insertedRows;
+        }
+        await engine.refreshDerivedIndexes({ mode: 'full' });
+        const queryResult = await executor.query(engine, testCase, timeoutMs);
+        validateEnvelope(queryResult, `${testCase.id}: query`, testCase.acceptMediaType);
+        const canonical = canonicalizeSparqlResult(queryResult);
+        if (testCase.expectedCanonical.authorization !== undefined) {
+            canonical.authorization = testCase.expectedCanonical.authorization;
+        }
+        if (JSON.stringify(canonical) !== JSON.stringify(testCase.expectedCanonical)) {
+            throw new Error(`${testCase.id}: canonical mismatch\nactual=${JSON.stringify(canonical)}\nexpected=${JSON.stringify(testCase.expectedCanonical)}`);
+        }
+        return {
+            caseId: testCase.id,
+            status: 'ok',
+            canonical,
+            preparedUpdates,
+            appliedDelta,
+            authority,
+        };
+    }
+    finally {
+        await engine.close();
+    }
+}
+async function seedDocument(engine, document) {
+    const parsed = new n3_1.Parser({
+        baseIRI: document.sourceUri,
+        format: document.contentType,
+    }).parse(document.body);
+    if (parsed.some((item) => item.graph.termType !== 'DefaultGraph')) {
+        throw new Error(`Semantic fixture document ${document.sourceUri} must contain Turtle triples, not named graphs`);
+    }
+    const graph = document.graph === 'default'
+        ? n3_1.DataFactory.defaultGraph()
+        : n3_1.DataFactory.namedNode(document.sourceUri);
+    await engine.replaceSource(parsed.map((item) => n3_1.DataFactory.quad(item.subject, item.predicate, item.object, graph)), {
+        source: document.sourceUri,
+        workspace: exports.DEFAULT_BASE_PATH,
+        localPath: `/semantic/${slug(document.sourceUri)}.ttl`,
+        contentType: document.contentType,
+    });
+}
+function assertSemanticConformanceParity(local, cloud) {
+    const localPayload = semanticParityPayload(local);
+    const cloudPayload = semanticParityPayload(cloud);
+    if (JSON.stringify(localPayload) !== JSON.stringify(cloudPayload)) {
+        throw new Error(`Local/Cloud semantic canonical mismatch\nlocal=${JSON.stringify(localPayload)}\ncloud=${JSON.stringify(cloudPayload)}`);
+    }
+    return {
+        caseIds: [...localPayload.caseIds],
+        canonicalDigest: `sha256:${(0, node_crypto_1.createHash)('sha256').update(JSON.stringify(localPayload)).digest('hex')}`,
+    };
+}
+function makeAccessScope(testCase) {
+    return {
+        basePath: exports.DEFAULT_BASE_PATH,
+        mode: testCase.accessScope.mode,
+        resolved: true,
+        principal: testCase.accessScope.principal,
+        version: `semantic-${testCase.id}`,
+        allowedGraphUrls: [...testCase.accessScope.allowedGraphs],
+        deniedGraphUrls: [...testCase.accessScope.deniedGraphs],
+        allowedSourceUrls: [...testCase.accessScope.allowedSources],
+        deniedSourceUrls: [...testCase.accessScope.deniedSources],
+    };
+}
+function exactQuadPattern(quad) {
+    return {
+        graph: quad.graph,
+        subject: quad.subject,
+        predicate: quad.predicate,
+        object: quad.object,
+    };
+}
+function queryOperation(mediaType) {
+    return mediaType === 'application/n-triples' ? 'queryQuads' : 'queryBindings';
+}
+function validateEnvelope(result, context, mediaType) {
+    if (result.status !== 'ok') {
+        throw new Error(`${context}: expected status=ok, got ${JSON.stringify(result)}`);
+    }
+    if (result.mediaType !== mediaType) {
+        throw new Error(`${context}: expected mediaType=${mediaType}, got ${result.mediaType}`);
+    }
+    const envelope = result;
+    if (envelope.queryStatus !== undefined && envelope.queryStatus !== 0) {
+        throw new Error(`${context}: expected queryStatus=0, got ${envelope.queryStatus}`);
+    }
+    if (envelope.adapterStatus !== undefined && envelope.adapterStatus !== 0) {
+        throw new Error(`${context}: expected adapterStatus=0, got ${envelope.adapterStatus}`);
+    }
+}
+async function serializeQuads(quads) {
+    const writer = new n3_1.Writer({ format: 'N-Triples' });
+    for await (const quad of quads) {
+        writer.addQuad(quad);
+    }
+    return new Promise((resolve, reject) => {
+        writer.end((error, result) => {
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        });
+    });
+}
+function termToSparqlJson(term) {
+    switch (term.termType) {
+        case 'NamedNode':
+            return { type: 'uri', value: term.value };
+        case 'BlankNode':
+            return { type: 'bnode', value: term.value };
+        case 'Literal': {
+            const literal = term;
+            if (literal.language) {
+                return { type: 'literal', value: literal.value, 'xml:lang': literal.language };
+            }
+            const datatype = literal.datatype?.value;
+            if (datatype && datatype !== 'http://www.w3.org/2001/XMLSchema#string') {
+                return { type: 'literal', value: literal.value, datatype };
+            }
+            return { type: 'literal', value: literal.value };
+        }
+        default:
+            return { type: 'literal', value: term.value };
+    }
+}
+function buildSemanticReport(options) {
+    const deniedRowsObserved = options.results.reduce((total, result) => total + observedDeniedRows(result.canonical), 0);
+    const report = {
+        schemaVersion: 1,
+        backend: options.backend,
+        engine: options.engine,
+        status: options.failed.length === 0 && deniedRowsObserved === 0 ? 'ok' : 'failed',
+        caseIds: [...options.caseIds],
+        skipped: [],
+        failed: options.failed,
+        results: options.results,
+        authorization: { deniedRowsObserved },
+        sourceScope: {
+            sourceDeniedValidatedBy: options.sourceDeniedValidatedBy,
+        },
+        canonicalDigest: '',
+    };
+    report.canonicalDigest = `sha256:${(0, node_crypto_1.createHash)('sha256').update(digestPayload(report)).digest('hex')}`;
+    return report;
+}
+function assertPath(name, value) {
+    if (!value) {
+        throw new Error(`${name} is required`);
+    }
+    if ((name === 'fixturePath' || name === 'runtimeCommand') && !(0, node_fs_1.existsSync)(value)) {
+        throw new Error(`${name} does not exist: ${value}`);
+    }
+}
+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}"`;
+}
+function slug(value) {
+    return value.replace(/[^A-Za-z0-9_.-]+/gu, '-').replace(/^-|-$/gu, '').slice(0, 80) || (0, node_crypto_1.createHash)('sha256').update(value).digest('hex').slice(0, 12);
+}
+function quadIdentity(quad) {
+    return [quad.graph, quad.subject, quad.predicate, quad.object]
+        .map((term) => (0, n3_1.termToId)(term))
+        .join('\u001f');
+}
+function canonicalizeSparqlResult(result) {
+    if (result.mediaType === 'application/n-triples') {
+        return {
+            kind: 'graph',
+            body: result.body.trim().split('\n').filter(Boolean).sort(),
+        };
+    }
+    const body = JSON.parse(result.body);
+    if (typeof body.boolean === 'boolean') {
+        return {
+            kind: 'bindings',
+            variables: ['boolean'],
+            rows: [{ boolean: `"${body.boolean}"^^xsd:boolean` }],
+        };
+    }
+    const variables = body.head?.vars ?? [];
+    const bindings = body.results?.bindings ?? [];
+    return {
+        kind: 'bindings',
+        variables,
+        rows: bindings.map((binding) => {
+            const row = {};
+            for (const variable of variables) {
+                if (binding[variable]) {
+                    row[variable] = bindingValue(binding[variable]);
+                }
+            }
+            return row;
+        }),
+    };
+}
+function bindingValue(term) {
+    if (term.type === 'uri')
+        return term.value;
+    if (term.type === 'bnode')
+        return `_:${term.value}`;
+    if (term['xml:lang'])
+        return `"${escapeLiteral(term.value)}"@${term['xml:lang']}`;
+    if (term.datatype) {
+        const datatype = term.datatype === 'http://www.w3.org/2001/XMLSchema#int'
+            ? 'http://www.w3.org/2001/XMLSchema#integer'
+            : term.datatype;
+        const xsdPrefix = 'http://www.w3.org/2001/XMLSchema#';
+        const compact = datatype.startsWith(xsdPrefix)
+            ? `xsd:${datatype.slice(xsdPrefix.length)}`
+            : `<${datatype}>`;
+        return `"${escapeLiteral(term.value)}"^^${compact}`;
+    }
+    return `"${escapeLiteral(term.value)}"`;
+}
+function escapeLiteral(value) {
+    return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+}
+function observedDeniedRows(canonical) {
+    if (!canonical || typeof canonical !== 'object')
+        return 0;
+    const authorization = canonical.authorization;
+    return typeof authorization?.deniedRowsObserved === 'number' ? authorization.deniedRowsObserved : 0;
+}
+function digestPayload(report) {
+    return JSON.stringify({
+        schemaVersion: report.schemaVersion,
+        backend: report.backend,
+        engine: report.engine,
+        status: report.status,
+        caseIds: report.caseIds,
+        skipped: report.skipped,
+        failed: report.failed,
+        results: report.results.map((result) => ({
+            caseId: result.caseId,
+            status: result.status,
+            canonical: result.canonical,
+            preparedUpdates: result.preparedUpdates,
+            appliedDelta: result.appliedDelta,
+        })),
+        authorization: report.authorization,
+        sourceScope: report.sourceScope,
+    });
+}
+function semanticParityPayload(report) {
+    if (report.status !== 'ok' || report.skipped.length !== 0 || report.failed.length !== 0) {
+        throw new Error(`${report.backend} semantic conformance is not publishable`);
+    }
+    if (report.results.length !== report.caseIds.length) {
+        throw new Error(`${report.backend} semantic conformance omitted required cases`);
+    }
+    const byCase = new Map(report.results.map((result) => [result.caseId, result.canonical]));
+    if (byCase.size !== report.caseIds.length || report.caseIds.some((caseId) => !byCase.has(caseId))) {
+        throw new Error(`${report.backend} semantic conformance case identities are inconsistent`);
+    }
+    return {
+        caseIds: [...report.caseIds],
+        results: report.caseIds.map((caseId) => ({ caseId, canonical: byCase.get(caseId) })),
+    };
+}
+//# sourceMappingURL=RdfSemanticConformance.js.map

package/dist/acceptance/run-installed-qlever-conformance.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import type { SemanticConformanceReport } from './RdfSemanticConformance';
+import { type NativeSearchConformanceReport } from './QleverSearchConformance';
+interface InstalledConformanceReport {
+    schemaVersion: 1;
+    backend: 'sqlite' | 'pg';
+    status: 'ok';
+    semantic: SemanticConformanceReport;
+    search: NativeSearchConformanceReport;
+}
+export declare function runInstalledQleverConformance(): Promise<InstalledConformanceReport>;
+export {};