@undefineds.co/xpod 0.3.6 → 0.3.15

package/dist/storage/rdf/models-benchmark.js

@@ -0,0 +1,1405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rdfModelsLocalQueryBenchmarkCases = exports.rdfModelsBenchmarkCases = exports.RDF_MODELS_SYNTHETIC_MESSAGE_QUADS = void 0;
+exports.rdfModelsBenchmarkCaseNames = rdfModelsBenchmarkCaseNames;
+exports.rdfModelsLocalQueryBenchmarkCaseNames = rdfModelsLocalQueryBenchmarkCaseNames;
+exports.rdfModelsBenchmarkScaleTargetQuads = rdfModelsBenchmarkScaleTargetQuads;
+exports.rdfModelsBenchmarkSyntheticPodCount = rdfModelsBenchmarkSyntheticPodCount;
+exports.estimateRdfModelsSyntheticQuadCount = estimateRdfModelsSyntheticQuadCount;
+exports.defaultSyntheticMessagesForRdfModelsScale = defaultSyntheticMessagesForRdfModelsScale;
+exports.rdfModelsBenchmarkScaleSatisfied = rdfModelsBenchmarkScaleSatisfied;
+exports.runRdfModelsBenchmark = runRdfModelsBenchmark;
+exports.runRdfModelsShadowBenchmark = runRdfModelsShadowBenchmark;
+exports.runRdfModelsRdf3xShadowBenchmark = runRdfModelsRdf3xShadowBenchmark;
+const node_crypto_1 = require("node:crypto");
+const n3_1 = require("n3");
+const n3_2 = require("n3");
+const types_1 = require("../quint/types");
+const RdfShadowComparator_1 = require("./RdfShadowComparator");
+const RdfTermSemantics_1 = require("./RdfTermSemantics");
+const { namedNode, literal } = n3_1.DataFactory;
+exports.RDF_MODELS_SYNTHETIC_MESSAGE_QUADS = 4;
+const RDF_MODELS_SCALE_TARGET_QUADS = {
+    small: 48,
+    medium: 10_000,
+    large: 1_000_000,
+};
+const RDF_MODELS_SYNTHETIC_POD_COUNTS = {
+    small: 1,
+    medium: 1,
+    large: 4,
+};
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const DCT_CREATED = 'http://purl.org/dc/terms/created';
+const DCT_MODIFIED = 'http://purl.org/dc/terms/modified';
+const DCT_TITLE = 'http://purl.org/dc/terms/title';
+const SIOC_CONTENT = 'http://rdfs.org/sioc/ns#content';
+const SIOC_HAS_MEMBER = 'http://rdfs.org/sioc/ns#has_member';
+const UDFS = 'https://undefineds.co/ns#';
+const MEETING = 'http://www.w3.org/ns/pim/meeting#';
+const SIOC = 'http://rdfs.org/sioc/ns#';
+const FOAF_AGENT = 'http://xmlns.com/foaf/0.1/Agent';
+const VCARD_INDIVIDUAL = 'http://www.w3.org/2006/vcard/ns#Individual';
+const SCHEMA_CREATIVE_WORK = 'http://schema.org/CreativeWork';
+const PERFORMANCE_P95_MIN_ABSOLUTE_HEADROOM_MS = 25;
+const PERFORMANCE_P95_MAX_RATIO = 8;
+exports.rdfModelsBenchmarkCases = [
+    {
+        name: 'list chats',
+        resource: 'chat',
+        purpose: 'surface list with graph-scope and type filter',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(RDF_TYPE),
+                object: namedNode(`${MEETING}LongChat`),
+                graph: { $startsWith: 'https://pod.example/alice/.data/chat/' },
+            },
+            options: { order: ['subject'], limit: 50 },
+        },
+        expectedPlan: ['graph-scope', 'type-filter', 'limit'],
+    },
+    {
+        name: 'list tasks',
+        resource: 'task',
+        purpose: 'task surface list with status/type filtering',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(RDF_TYPE),
+                object: namedNode(`${UDFS}Task`),
+                graph: { $startsWith: 'https://pod.example/alice/.data/task/' },
+            },
+            options: { order: ['subject'], limit: 50 },
+        },
+        expectedPlan: ['graph-scope', 'type-filter', 'limit'],
+    },
+    {
+        name: 'list threads by chat',
+        resource: 'thread',
+        purpose: 'relation lookup under a chat index graph',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(RDF_TYPE),
+                object: namedNode(`${SIOC}Thread`),
+                graph: namedNode('https://pod.example/alice/.data/chat/default/index.ttl'),
+            },
+            options: { order: ['subject'], limit: 100 },
+        },
+        expectedPlan: ['graph-scope', 'type-filter', 'limit'],
+    },
+    {
+        name: 'list threads by task',
+        resource: 'thread',
+        purpose: 'relation lookup under a task index graph',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(RDF_TYPE),
+                object: namedNode(`${SIOC}Thread`),
+                graph: namedNode('https://pod.example/alice/.data/task/default/index.ttl'),
+            },
+            options: { order: ['subject'], limit: 100 },
+        },
+        expectedPlan: ['graph-scope', 'type-filter', 'limit'],
+    },
+    {
+        name: 'list messages by thread',
+        resource: 'message',
+        purpose: 'date-bucketed message lookup through thread inverse membership',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(SIOC_HAS_MEMBER),
+                graph: { $startsWith: 'https://pod.example/alice/.data/chat/default/2026/05/' },
+            },
+            options: { order: ['subject'], limit: 100 },
+        },
+        expectedPlan: ['graph-scope', 'predicate-filter', 'limit'],
+    },
+    {
+        name: 'latest message',
+        resource: 'message',
+        purpose: 'ORDER BY + LIMIT over message date bucket',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(DCT_CREATED),
+                graph: { $startsWith: 'https://pod.example/alice/.data/chat/default/' },
+            },
+            options: { order: ['object'], reverse: true, limit: 1 },
+        },
+        expectedPlan: ['graph-scope', 'predicate-filter', 'order', 'limit'],
+    },
+    {
+        name: 'latest run',
+        resource: 'run',
+        purpose: 'ORDER BY + LIMIT over date-bucketed run documents',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(DCT_CREATED),
+                graph: { $startsWith: 'https://pod.example/alice/.data/task/default/' },
+            },
+            options: { order: ['object'], reverse: true, limit: 1 },
+        },
+        expectedPlan: ['graph-scope', 'predicate-filter', 'order', 'limit'],
+    },
+    {
+        name: 'pending runs',
+        resource: 'run',
+        purpose: 'status filter for scheduler and state center',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(`${UDFS}status`),
+                object: literal('queued'),
+                graph: { $startsWith: 'https://pod.example/alice/.data/task/' },
+            },
+            options: { order: ['subject'], limit: 100 },
+        },
+        expectedPlan: ['graph-scope', 'predicate-object-filter', 'limit'],
+    },
+    {
+        name: 'running runs',
+        resource: 'run',
+        purpose: 'status filter for active runtime execution',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(`${UDFS}status`),
+                object: literal('running'),
+                graph: { $startsWith: 'https://pod.example/alice/.data/task/' },
+            },
+            options: { order: ['subject'], limit: 100 },
+        },
+        expectedPlan: ['graph-scope', 'predicate-object-filter', 'limit'],
+    },
+    {
+        name: 'runs by workspace',
+        resource: 'run',
+        purpose: 'workspace relation filter for runtime placement and steering',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(`${UDFS}workspace`),
+                object: namedNode('file://macbook.local/Users/alice/project/'),
+                graph: { $startsWith: 'https://pod.example/alice/.data/task/default/' },
+            },
+            options: { order: ['subject'], limit: 100 },
+        },
+        expectedPlan: ['graph-scope', 'predicate-object-filter', 'limit'],
+    },
+    {
+        name: 'runs by numeric priority',
+        resource: 'run',
+        purpose: 'typed numeric literal range filter for scheduler priority queues',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(`${UDFS}priority`),
+                object: { $gt: literal('9', namedNode('http://www.w3.org/2001/XMLSchema#integer')) },
+                graph: { $startsWith: 'https://pod.example/alice/.data/task/' },
+            },
+            options: { order: ['subject'], limit: 100 },
+        },
+        expectedPlan: ['graph-scope', 'predicate-object-range-filter', 'limit'],
+    },
+    {
+        name: 'run with steps',
+        resource: 'runStep',
+        purpose: 'one-to-many run-step relation lookup',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(`${UDFS}run`),
+                graph: { $startsWith: 'https://pod.example/alice/.data/task/default/2026/05/' },
+            },
+            options: { order: ['subject'], limit: 200 },
+        },
+        expectedPlan: ['graph-scope', 'predicate-filter', 'limit'],
+    },
+    {
+        name: 'task materialization due time',
+        resource: 'schedule',
+        purpose: 'schedule due-time candidate lookup',
+        minScale: 'medium',
+        query: {
+            pattern: {
+                predicate: namedNode(`${UDFS}nextRunAt`),
+                object: { $lte: literal('2026-05-18T01:30:00.000Z') },
+                graph: { $startsWith: 'https://pod.example/alice/.data/task/' },
+            },
+            options: { order: ['object'], limit: 100 },
+        },
+        expectedPlan: ['graph-scope', 'predicate-object-range-filter', 'order', 'limit'],
+    },
+    {
+        name: 'search message literals',
+        resource: 'message',
+        purpose: 'literal/text index candidate that reconnects to RDF subjects',
+        minScale: 'medium',
+        query: {
+            pattern: {
+                predicate: namedNode(SIOC_CONTENT),
+                object: { $contains: 'searchable' },
+                graph: { $startsWith: 'https://pod.example/alice/.data/chat/' },
+            },
+            options: { order: ['subject'], limit: 50 },
+        },
+        expectedPlan: ['text-index', 'rdf-subject-join'],
+    },
+    {
+        name: 'load by exact id',
+        resource: 'any',
+        purpose: 'base-relative id expands to exact subject IRI',
+        minScale: 'small',
+        query: {
+            pattern: {
+                subject: namedNode('https://pod.example/alice/.data/chat/default/index.ttl#this'),
+            },
+        },
+        expectedPlan: ['SPOG'],
+    },
+    {
+        name: 'acl graph prefix scoped query',
+        resource: 'any',
+        purpose: 'scope filter must avoid unbounded full-pod scans',
+        minScale: 'medium',
+        query: {
+            pattern: {
+                graph: { $startsWith: 'https://pod.example/alice/.data/chat/default/' },
+                predicate: namedNode(DCT_MODIFIED),
+            },
+            options: { order: ['subject'], limit: 100 },
+        },
+        expectedPlan: ['graph-scope', 'predicate-filter', 'limit'],
+    },
+    {
+        name: 'list providers',
+        resource: 'aiProvider',
+        purpose: 'AI provider settings list and provider/model relation baseline',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(RDF_TYPE),
+                object: namedNode(`${UDFS}Provider`),
+                graph: { $startsWith: 'https://pod.example/alice/settings/providers/' },
+            },
+        },
+        expectedPlan: ['graph-scope', 'type-filter'],
+    },
+    {
+        name: 'models by provider',
+        resource: 'aiModel',
+        purpose: 'AI model lookup by provider relation',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(`${UDFS}isProvidedBy`),
+                object: namedNode('https://pod.example/alice/settings/providers/anthropic.ttl'),
+            },
+        },
+        expectedPlan: ['POSG'],
+    },
+    {
+        name: 'credentials by provider',
+        resource: 'credential',
+        purpose: 'credential lookup by provider relation',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(`${UDFS}provider`),
+                object: namedNode('https://pod.example/alice/settings/providers/anthropic.ttl'),
+            },
+        },
+        expectedPlan: ['POSG'],
+    },
+    {
+        name: 'list agents',
+        resource: 'agent',
+        purpose: 'agent identity list under the shared models agent resource base',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(RDF_TYPE),
+                object: namedNode(FOAF_AGENT),
+                graph: { $startsWith: 'https://pod.example/alice/.data/agents/' },
+            },
+            options: { order: ['subject'], limit: 50 },
+        },
+        expectedPlan: ['graph-scope', 'type-filter', 'limit'],
+    },
+    {
+        name: 'list contacts',
+        resource: 'contact',
+        purpose: 'contact index list under the shared models contact resource base',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(RDF_TYPE),
+                object: namedNode(VCARD_INDIVIDUAL),
+                graph: { $startsWith: 'https://pod.example/alice/.data/contacts/' },
+            },
+            options: { order: ['subject'], limit: 50 },
+        },
+        expectedPlan: ['graph-scope', 'type-filter', 'limit'],
+    },
+    {
+        name: 'list favorites',
+        resource: 'favorite',
+        purpose: 'favorite list over date-bucketed favorite documents',
+        minScale: 'small',
+        query: {
+            pattern: {
+                predicate: namedNode(RDF_TYPE),
+                object: namedNode(SCHEMA_CREATIVE_WORK),
+                graph: { $startsWith: 'https://pod.example/alice/.data/favorites/' },
+            },
+            options: { order: ['subject'], limit: 50 },
+        },
+        expectedPlan: ['graph-scope', 'type-filter', 'limit'],
+    },
+];
+exports.rdfModelsLocalQueryBenchmarkCases = [
+    {
+        name: 'latest message by thread local query',
+        resource: 'message',
+        purpose: 'date-bucketed message timeline keeps ORDER BY/LIMIT inside SQL self-join',
+        minScale: 'small',
+        query: {
+            patterns: [
+                {
+                    subject: { variable: 'message' },
+                    predicate: namedNode(SIOC_HAS_MEMBER),
+                    object: namedNode('https://pod.example/alice/.data/chat/default/index.ttl#thread_1'),
+                },
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/chat/default/' },
+                    subject: { variable: 'message' },
+                    predicate: namedNode(DCT_CREATED),
+                    object: { variable: 'createdAt' },
+                },
+            ],
+            select: ['message', 'createdAt'],
+            orderBy: [
+                {
+                    variable: 'createdAt',
+                    direction: 'desc',
+                },
+            ],
+            limit: 1,
+        },
+        expectedPlan: ['join-index', 'join-order-pushdown', 'join-limit-pushdown'],
+    },
+    {
+        name: 'next queued run by workspace local query',
+        resource: 'run',
+        purpose: 'run state center scheduler query keeps status/workspace/date joins in SQL before LIMIT',
+        minScale: 'small',
+        query: {
+            patterns: [
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/task/default/' },
+                    subject: { variable: 'run' },
+                    predicate: namedNode(`${UDFS}status`),
+                    object: literal('queued'),
+                },
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/task/default/' },
+                    subject: { variable: 'run' },
+                    predicate: namedNode(`${UDFS}workspace`),
+                    object: namedNode('file://macbook.local/Users/alice/project/'),
+                },
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/task/default/' },
+                    subject: { variable: 'run' },
+                    predicate: namedNode(DCT_CREATED),
+                    object: { variable: 'createdAt' },
+                },
+            ],
+            select: ['run', 'createdAt'],
+            orderBy: [
+                {
+                    variable: 'createdAt',
+                    direction: 'asc',
+                },
+            ],
+            limit: 1,
+        },
+        expectedPlan: ['join-index', 'join-order-pushdown', 'join-limit-pushdown'],
+    },
+    {
+        name: 'run steps by run local query',
+        resource: 'runStep',
+        purpose: 'one-to-many run-step lookup keeps type and run relation in SQL self-join',
+        minScale: 'small',
+        query: {
+            patterns: [
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/task/default/2026/05/' },
+                    subject: { variable: 'step' },
+                    predicate: namedNode(RDF_TYPE),
+                    object: namedNode(`${UDFS}RunStep`),
+                },
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/task/default/2026/05/' },
+                    subject: { variable: 'step' },
+                    predicate: namedNode(`${UDFS}run`),
+                    object: namedNode('https://pod.example/alice/.data/task/default/2026/05/18/runs.ttl#run_1'),
+                },
+            ],
+            select: ['step'],
+            orderBy: [
+                {
+                    variable: 'step',
+                    direction: 'asc',
+                },
+            ],
+            limit: 50,
+        },
+        expectedPlan: ['join-index', 'join-order-pushdown', 'join-limit-pushdown'],
+    },
+    {
+        name: 'task materialization active due local query',
+        resource: 'schedule',
+        purpose: 'task scheduler materialization keeps active status and due-time filter in SQL self-join',
+        minScale: 'small',
+        query: {
+            patterns: [
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/task/default/' },
+                    subject: { variable: 'schedule' },
+                    predicate: namedNode(RDF_TYPE),
+                    object: namedNode(`${UDFS}Schedule`),
+                },
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/task/default/' },
+                    subject: { variable: 'schedule' },
+                    predicate: namedNode(`${UDFS}status`),
+                    object: literal('active'),
+                },
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/task/default/' },
+                    subject: { variable: 'schedule' },
+                    predicate: namedNode(`${UDFS}nextRunAt`),
+                    object: { variable: 'nextRunAt' },
+                },
+            ],
+            filters: [
+                {
+                    variable: 'nextRunAt',
+                    operator: '$lte',
+                    value: literal('2026-05-18T01:30:00.000Z'),
+                },
+            ],
+            select: ['schedule', 'nextRunAt'],
+            orderBy: [
+                {
+                    variable: 'nextRunAt',
+                    direction: 'asc',
+                },
+            ],
+            limit: 100,
+        },
+        expectedPlan: ['join-index', 'range-filter-pushdown', 'join-order-pushdown', 'join-limit-pushdown'],
+    },
+    {
+        name: 'message count by thread with having',
+        resource: 'message',
+        purpose: 'grouped message count uses SQL GROUP BY/HAVING before pagination',
+        minScale: 'small',
+        query: {
+            patterns: [
+                {
+                    subject: { variable: 'message' },
+                    predicate: namedNode(SIOC_HAS_MEMBER),
+                    object: { variable: 'thread' },
+                },
+            ],
+            groupBy: ['thread'],
+            aggregate: {
+                type: 'count',
+                as: 'count',
+                variable: 'message',
+            },
+            having: [
+                {
+                    variable: 'count',
+                    operator: '$gt',
+                    value: literal('2', namedNode('http://www.w3.org/2001/XMLSchema#integer')),
+                },
+            ],
+            select: ['thread', 'count'],
+            orderBy: [
+                {
+                    variable: 'count',
+                    direction: 'desc',
+                },
+            ],
+            limit: 1,
+        },
+        expectedPlan: ['group-count-index', 'having-pushdown', 'order', 'limit'],
+    },
+    {
+        name: 'message join count distinct',
+        resource: 'message',
+        purpose: 'message/thread BGP aggregate count stays inside SQL self-join',
+        minScale: 'small',
+        query: {
+            patterns: [
+                {
+                    subject: { variable: 'message' },
+                    predicate: namedNode(RDF_TYPE),
+                    object: namedNode(`${MEETING}Message`),
+                },
+                {
+                    subject: { variable: 'message' },
+                    predicate: namedNode(SIOC_HAS_MEMBER),
+                    object: { variable: 'thread' },
+                },
+            ],
+            aggregates: [
+                {
+                    type: 'count',
+                    as: 'messageCount',
+                    variable: 'message',
+                },
+                {
+                    type: 'count',
+                    as: 'threadCount',
+                    variable: 'thread',
+                    distinct: true,
+                },
+            ],
+        },
+        expectedPlan: ['join-count-index'],
+    },
+];
+function rdfModelsBenchmarkCaseNames() {
+    return exports.rdfModelsBenchmarkCases.map((testCase) => testCase.name);
+}
+function rdfModelsLocalQueryBenchmarkCaseNames() {
+    return exports.rdfModelsLocalQueryBenchmarkCases.map((testCase) => testCase.name);
+}
+function rdfModelsBenchmarkScaleTargetQuads(scale) {
+    return RDF_MODELS_SCALE_TARGET_QUADS[scale];
+}
+function rdfModelsBenchmarkSyntheticPodCount(scale) {
+    return RDF_MODELS_SYNTHETIC_POD_COUNTS[scale];
+}
+function estimateRdfModelsSyntheticQuadCount(syntheticMessages) {
+    return Math.max(0, Math.floor(syntheticMessages)) * exports.RDF_MODELS_SYNTHETIC_MESSAGE_QUADS;
+}
+function defaultSyntheticMessagesForRdfModelsScale(scale) {
+    if (scale === 'small') {
+        return 12;
+    }
+    return Math.ceil(rdfModelsBenchmarkScaleTargetQuads(scale) / exports.RDF_MODELS_SYNTHETIC_MESSAGE_QUADS);
+}
+function rdfModelsBenchmarkScaleSatisfied(scale, seedQuadCount) {
+    return seedQuadCount >= rdfModelsBenchmarkScaleTargetQuads(scale);
+}
+function runRdfModelsBenchmark(engine, options = {}) {
+    const scale = options.scale ?? 'small';
+    const iterations = Math.max(1, Math.floor(options.iterations ?? 1));
+    const cases = (options.cases ?? exports.rdfModelsBenchmarkCases)
+        .filter((testCase) => scaleRank(testCase.minScale) <= scaleRank(scale));
+    const localQueryCases = (options.localQueryCases ?? exports.rdfModelsLocalQueryBenchmarkCases)
+        .filter((testCase) => scaleRank(testCase.minScale) <= scaleRank(scale));
+    const results = cases.map((testCase) => runBenchmarkCase(engine, testCase, iterations));
+    const localQueryResults = localQueryCases.map((testCase) => runLocalQueryBenchmarkCase(engine, testCase, iterations));
+    const failedPlanCases = [
+        ...results.filter((result) => !result.planMatched).map((result) => result.name),
+        ...localQueryResults.filter((result) => !result.planMatched).map((result) => result.name),
+    ];
+    return {
+        engine: 'solid-rdf',
+        scale,
+        iterations,
+        generatedAt: new Date().toISOString(),
+        planMatched: failedPlanCases.length === 0,
+        failedPlanCases,
+        cases: results,
+        localQueryCases: localQueryResults,
+    };
+}
+async function runRdfModelsShadowBenchmark(engine, compatibilityStore, options = {}) {
+    const scale = options.scale ?? 'small';
+    const iterations = Math.max(1, Math.floor(options.iterations ?? 1));
+    const cases = (options.cases ?? exports.rdfModelsBenchmarkCases)
+        .filter((testCase) => scaleRank(testCase.minScale) <= scaleRank(scale));
+    const results = [];
+    const compatibilityStats = await compatibilityStore.stats();
+    for (const testCase of cases) {
+        results.push(await runShadowBenchmarkCase(engine, compatibilityStore, testCase, iterations, compatibilityStats));
+    }
+    const spaceGateEnforced = scaleRank(scale) >= scaleRank('medium');
+    const failedPerformanceCases = results.filter((result) => !result.performance.matched).map((result) => result.name);
+    const failedSpaceCases = spaceGateEnforced
+        ? results.filter((result) => !result.space.matched).map((result) => result.name)
+        : [];
+    return {
+        engine: 'shadow',
+        compatibilityEngine: 'quint-store',
+        candidateEngine: 'solid-rdf',
+        scale,
+        iterations,
+        generatedAt: new Date().toISOString(),
+        matched: results.every((result) => result.matched),
+        orderedMatched: results.every((result) => result.orderedMatch),
+        planMatched: results.every((result) => result.planMatched),
+        spaceGateEnforced,
+        performanceMatched: failedPerformanceCases.length === 0,
+        spaceMatched: failedSpaceCases.length === 0,
+        failedPlanCases: results.filter((result) => !result.planMatched).map((result) => result.name),
+        failedPerformanceCases,
+        failedSpaceCases,
+        cases: results,
+    };
+}
+function runRdfModelsRdf3xShadowBenchmark(engine, options = {}) {
+    if (!engine.rdf3xIndex) {
+        throw new Error('runRdfModelsRdf3xShadowBenchmark requires SolidRdfEngine.rdf3xIndex');
+    }
+    const scale = options.scale ?? 'small';
+    const iterations = Math.max(1, Math.floor(options.iterations ?? 1));
+    const cases = (options.cases ?? exports.rdfModelsBenchmarkCases)
+        .filter((testCase) => scaleRank(testCase.minScale) <= scaleRank(scale));
+    const localQueryCases = (options.localQueryCases ?? exports.rdfModelsLocalQueryBenchmarkCases)
+        .filter((testCase) => scaleRank(testCase.minScale) <= scaleRank(scale));
+    const rebuild = engine.rdf3xIndex.rebuildFromCurrentQuads();
+    const results = cases.map((testCase) => runRdf3xShadowBenchmarkCase(engine, testCase, iterations));
+    const joinResults = localQueryCases.map((testCase) => runRdf3xShadowJoinBenchmarkCase(engine, testCase, iterations));
+    const supportedResults = results.filter((result) => result.supported);
+    const supportedJoinResults = joinResults.filter((result) => result.supported);
+    return {
+        engine: 'rdf3x-shadow',
+        primaryEngine: 'solid-rdf',
+        candidateEngine: 'solid-rdf3x',
+        scale,
+        iterations,
+        generatedAt: new Date().toISOString(),
+        matched: supportedResults.every((result) => result.matched)
+            && supportedJoinResults.every((result) => result.matched),
+        orderedMatched: supportedResults.every((result) => result.orderedMatch)
+            && supportedJoinResults.every((result) => result.orderedMatch),
+        skippedCases: results.filter((result) => !result.supported).map((result) => result.name),
+        skippedJoinCases: joinResults.filter((result) => !result.supported).map((result) => result.name),
+        failedCases: supportedResults.filter((result) => !result.matched || !result.orderedMatch).map((result) => result.name),
+        failedJoinCases: supportedJoinResults
+            .filter((result) => !result.matched || !result.orderedMatch)
+            .map((result) => result.name),
+        rebuild,
+        cases: results,
+        joinCases: joinResults,
+    };
+}
+function runBenchmarkCase(engine, testCase, iterations) {
+    const durationsMs = [];
+    let metrics;
+    let keys = [];
+    for (let i = 0; i < iterations; i += 1) {
+        const start = Date.now();
+        const result = engine.scan(testCase.query);
+        durationsMs.push(Math.max(0, Date.now() - start));
+        metrics = result.metrics;
+        keys = result.quads.map(RdfShadowComparator_1.canonicalQuadKey);
+    }
+    const finalMetrics = metrics ?? {
+        engine: 'solid-rdf',
+        indexChoice: 'not-run',
+        matchedRows: 0,
+        returnedRows: 0,
+        durationMs: 0,
+    };
+    const missingPlan = missingExpectedPlan(testCase, finalMetrics);
+    const execution = benchmarkExecution(finalMetrics);
+    return {
+        name: testCase.name,
+        resource: testCase.resource,
+        purpose: testCase.purpose,
+        minScale: testCase.minScale,
+        query: {
+            pattern: serializePattern(testCase.query.pattern),
+            ...(testCase.query.options ? { options: testCase.query.options } : {}),
+        },
+        expectedPlan: [...testCase.expectedPlan],
+        planMatched: missingPlan.length === 0,
+        missingPlan,
+        ...execution,
+        returnedRows: keys.length,
+        checksum: checksum(keys, false),
+        orderedChecksum: checksum(keys, true),
+        durationsMs,
+        p50DurationMs: percentile(durationsMs, 0.5),
+        p95DurationMs: percentile(durationsMs, 0.95),
+        metrics: finalMetrics,
+        indexStats: engine.index.stats(),
+    };
+}
+function runLocalQueryBenchmarkCase(engine, testCase, iterations) {
+    const durationsMs = [];
+    let metrics;
+    let keys = [];
+    for (let i = 0; i < iterations; i += 1) {
+        const start = Date.now();
+        const result = engine.query(testCase.query);
+        durationsMs.push(Math.max(0, Date.now() - start));
+        metrics = result.metrics;
+        keys = result.bindings.map(bindingKey);
+    }
+    const finalMetrics = metrics ?? {
+        engine: 'solid-rdf',
+        plan: [],
+        scannedRows: 0,
+        joinedRows: 0,
+        returnedRows: 0,
+        durationMs: 0,
+        indexChoices: [],
+        filtersApplied: 0,
+        filtersPushedDown: 0,
+    };
+    const missingPlan = missingExpectedLocalQueryPlan(testCase, finalMetrics);
+    return {
+        name: testCase.name,
+        resource: testCase.resource,
+        purpose: testCase.purpose,
+        minScale: testCase.minScale,
+        query: serializeLocalQuery(testCase.query),
+        expectedPlan: [...testCase.expectedPlan],
+        planMatched: missingPlan.length === 0,
+        missingPlan,
+        physicalPlan: finalMetrics.plan,
+        scannedRows: finalMetrics.scannedRows,
+        indexChoices: [...finalMetrics.indexChoices],
+        fallbackReason: null,
+        returnedRows: keys.length,
+        checksum: checksum(keys, false),
+        orderedChecksum: checksum(keys, true),
+        durationsMs,
+        p50DurationMs: percentile(durationsMs, 0.5),
+        p95DurationMs: percentile(durationsMs, 0.95),
+        metrics: finalMetrics,
+        indexStats: engine.index.stats(),
+    };
+}
+function runRdf3xShadowBenchmarkCase(engine, testCase, iterations) {
+    const baseResult = baseRdf3xShadowBenchmarkResult(testCase);
+    const unsupportedReason = unsupportedRdf3xPatternReason(testCase.query.pattern);
+    if (unsupportedReason) {
+        return {
+            ...baseResult,
+            supported: false,
+            unsupportedReason,
+            matched: false,
+            orderedMatch: false,
+            diff: {
+                missingFromPrimary: [],
+                extraInPrimary: [],
+            },
+            solidRdf: emptySolidRdfBenchmarkSide(engine),
+        };
+    }
+    const solidRdfDurationsMs = [];
+    const rdf3xDurationsMs = [];
+    let solidRdfQuads = [];
+    let rdf3xQuads = [];
+    let solidRdfMetrics;
+    let rdf3xMetrics;
+    for (let i = 0; i < iterations; i += 1) {
+        let start = Date.now();
+        const solidRdfResult = engine.scan(testCase.query);
+        solidRdfDurationsMs.push(Math.max(0, Date.now() - start));
+        solidRdfQuads = solidRdfResult.quads;
+        solidRdfMetrics = solidRdfResult.metrics;
+        start = Date.now();
+        const rdf3xResult = engine.rdf3xIndex.scan(rdf3xPatternFor(testCase.query.pattern), testCase.query.options);
+        rdf3xDurationsMs.push(Math.max(0, Date.now() - start));
+        rdf3xQuads = rdf3xResult.quads;
+        rdf3xMetrics = rdf3xResult.metrics;
+    }
+    const solidRdfKeys = solidRdfQuads.map(RdfShadowComparator_1.canonicalQuadKey);
+    const rdf3xKeys = rdf3xQuads.map(RdfShadowComparator_1.canonicalQuadKey);
+    const diff = (0, RdfShadowComparator_1.diffQuads)(solidRdfQuads, rdf3xQuads);
+    const orderedMatch = isSemanticallyOrdered(testCase.query.options)
+        ? rdf3xKeys.join('\n') === solidRdfKeys.join('\n')
+        : true;
+    const finalSolidRdfMetrics = solidRdfMetrics ?? {
+        engine: 'solid-rdf',
+        indexChoice: 'not-run',
+        matchedRows: 0,
+        returnedRows: 0,
+        durationMs: 0,
+    };
+    const finalRdf3xMetrics = rdf3xMetrics ?? {
+        engine: 'solid-rdf3x',
+        indexChoice: 'none',
+        matchedRows: 0,
+        returnedRows: 0,
+        durationMs: 0,
+    };
+    return {
+        ...baseResult,
+        supported: true,
+        matched: diff.missingFromPrimary.length === 0 && diff.extraInPrimary.length === 0,
+        orderedMatch,
+        diff,
+        solidRdf: {
+            ...benchmarkSide(solidRdfKeys, solidRdfDurationsMs),
+            ...benchmarkExecution(finalSolidRdfMetrics),
+            metrics: finalSolidRdfMetrics,
+            indexStats: engine.index.stats(),
+        },
+        rdf3x: {
+            ...benchmarkSide(rdf3xKeys, rdf3xDurationsMs),
+            ...rdf3xBenchmarkExecution(finalRdf3xMetrics),
+            metrics: finalRdf3xMetrics,
+            indexStats: engine.rdf3xIndex.stats(),
+        },
+    };
+}
+function runRdf3xShadowJoinBenchmarkCase(engine, testCase, iterations) {
+    const unsupportedReason = unsupportedRdf3xJoinQueryReason(testCase.query);
+    if (unsupportedReason) {
+        return {
+            ...baseRdf3xShadowJoinBenchmarkResult(testCase),
+            supported: false,
+            unsupportedReason,
+            matched: false,
+            orderedMatch: false,
+            diff: {
+                missingFromPrimary: [],
+                extraInPrimary: [],
+            },
+            solidRdf: emptySolidRdfBenchmarkSide(engine),
+        };
+    }
+    const joinShape = rdf3xJoinShapeFor(testCase.query);
+    const solidRdfDurationsMs = [];
+    const rdf3xDurationsMs = [];
+    let solidRdfBindings = [];
+    let rdf3xBindings = [];
+    let solidRdfMetrics;
+    let rdf3xMetrics;
+    for (let i = 0; i < iterations; i += 1) {
+        let start = Date.now();
+        const solidRdfResult = engine.index.joinPatterns(joinShape.patterns, joinShape.options);
+        solidRdfDurationsMs.push(Math.max(0, Date.now() - start));
+        solidRdfBindings = solidRdfResult.bindings;
+        solidRdfMetrics = solidRdfResult.metrics;
+        start = Date.now();
+        const rdf3xResult = engine.rdf3xIndex.joinPatterns(joinShape.patterns, joinShape.options);
+        rdf3xDurationsMs.push(Math.max(0, Date.now() - start));
+        rdf3xBindings = rdf3xResult.bindings;
+        rdf3xMetrics = rdf3xResult.metrics;
+    }
+    const solidRdfKeys = solidRdfBindings.map(bindingKey);
+    const rdf3xKeys = rdf3xBindings.map(bindingKey);
+    const diff = diffBindingKeys(solidRdfKeys, rdf3xKeys);
+    const orderedMatch = isSemanticallyOrderedJoin(joinShape.options)
+        ? rdf3xKeys.join('\n') === solidRdfKeys.join('\n')
+        : true;
+    const finalSolidRdfMetrics = solidRdfMetrics ?? {
+        engine: 'solid-rdf',
+        indexChoice: 'not-run',
+        matchedRows: 0,
+        returnedRows: 0,
+        durationMs: 0,
+    };
+    const finalRdf3xMetrics = rdf3xMetrics ?? {
+        engine: 'solid-rdf3x',
+        indexChoice: 'none',
+        matchedRows: 0,
+        returnedRows: 0,
+        durationMs: 0,
+    };
+    return {
+        ...baseRdf3xShadowJoinBenchmarkResult(testCase),
+        supported: true,
+        matched: diff.missingFromPrimary.length === 0 && diff.extraInPrimary.length === 0,
+        orderedMatch,
+        diff,
+        solidRdf: {
+            ...benchmarkSide(solidRdfKeys, solidRdfDurationsMs),
+            ...benchmarkExecution(finalSolidRdfMetrics),
+            metrics: finalSolidRdfMetrics,
+            indexStats: engine.index.stats(),
+        },
+        rdf3x: {
+            ...benchmarkSide(rdf3xKeys, rdf3xDurationsMs),
+            ...rdf3xJoinBenchmarkExecution(finalRdf3xMetrics),
+            metrics: finalRdf3xMetrics,
+            indexStats: engine.rdf3xIndex.stats(),
+        },
+    };
+}
+function baseRdf3xShadowBenchmarkResult(testCase) {
+    return {
+        name: testCase.name,
+        resource: testCase.resource,
+        purpose: testCase.purpose,
+        minScale: testCase.minScale,
+        query: {
+            pattern: serializePattern(testCase.query.pattern),
+            ...(testCase.query.options ? { options: testCase.query.options } : {}),
+        },
+    };
+}
+function emptySolidRdfBenchmarkSide(engine) {
+    const metrics = {
+        engine: 'solid-rdf',
+        indexChoice: 'not-run',
+        matchedRows: 0,
+        returnedRows: 0,
+        durationMs: 0,
+    };
+    return {
+        ...benchmarkSide([], []),
+        ...benchmarkExecution(metrics),
+        metrics,
+        indexStats: engine.index.stats(),
+    };
+}
+async function runShadowBenchmarkCase(engine, compatibilityStore, testCase, iterations, compatibilityStats) {
+    const compatibilityDurationsMs = [];
+    const solidRdfDurationsMs = [];
+    let compatibilityQuads = [];
+    let solidRdfQuads = [];
+    let metrics;
+    for (let i = 0; i < iterations; i += 1) {
+        let start = Date.now();
+        compatibilityQuads = await compatibilityStore.get(testCase.query.pattern, testCase.query.options);
+        compatibilityDurationsMs.push(Math.max(0, Date.now() - start));
+        start = Date.now();
+        const solidRdfResult = engine.scan(testCase.query);
+        solidRdfDurationsMs.push(Math.max(0, Date.now() - start));
+        solidRdfQuads = solidRdfResult.quads;
+        metrics = solidRdfResult.metrics;
+    }
+    const compatibilityKeys = compatibilityQuads.map(RdfShadowComparator_1.canonicalQuadKey);
+    const solidRdfKeys = solidRdfQuads.map(RdfShadowComparator_1.canonicalQuadKey);
+    const diff = (0, RdfShadowComparator_1.diffQuads)(solidRdfQuads, compatibilityQuads);
+    const orderedMatch = isSemanticallyOrdered(testCase.query.options)
+        ? solidRdfKeys.join('\n') === compatibilityKeys.join('\n')
+        : true;
+    const finalMetrics = metrics ?? {
+        engine: 'solid-rdf',
+        indexChoice: 'not-run',
+        matchedRows: 0,
+        returnedRows: 0,
+        durationMs: 0,
+    };
+    const missingPlan = missingExpectedPlan(testCase, finalMetrics);
+    const execution = benchmarkExecution(finalMetrics);
+    const compatibilitySide = {
+        ...benchmarkSide(compatibilityKeys, compatibilityDurationsMs),
+        storeStats: compatibilityStats,
+    };
+    const solidRdfSide = {
+        ...benchmarkSide(solidRdfKeys, solidRdfDurationsMs),
+        ...execution,
+        metrics: finalMetrics,
+        indexStats: engine.index.stats(),
+    };
+    return {
+        name: testCase.name,
+        resource: testCase.resource,
+        purpose: testCase.purpose,
+        minScale: testCase.minScale,
+        query: {
+            pattern: serializePattern(testCase.query.pattern),
+            ...(testCase.query.options ? { options: testCase.query.options } : {}),
+        },
+        expectedPlan: [...testCase.expectedPlan],
+        planMatched: missingPlan.length === 0,
+        missingPlan,
+        matched: diff.missingFromPrimary.length === 0 && diff.extraInPrimary.length === 0,
+        orderedMatch,
+        diff,
+        compatibility: compatibilitySide,
+        solidRdf: solidRdfSide,
+        performance: comparePerformance(compatibilitySide, solidRdfSide),
+        space: compareSpace(compatibilityStats, solidRdfSide.indexStats),
+    };
+}
+function benchmarkExecution(metrics) {
+    return {
+        physicalPlan: metrics.queryPlan ?? [],
+        scannedRows: metrics.matchedRows,
+        indexChoice: metrics.indexChoice,
+        joinOrder: [metrics.indexChoice],
+        fallbackReason: null,
+    };
+}
+function rdf3xBenchmarkExecution(metrics) {
+    return {
+        physicalPlan: metrics.queryPlan ?? [],
+        scannedRows: metrics.matchedRows,
+        indexChoice: metrics.indexChoice,
+        joinOrder: [metrics.indexChoice],
+        fallbackReason: null,
+    };
+}
+function rdf3xJoinBenchmarkExecution(metrics) {
+    return {
+        physicalPlan: metrics.queryPlan ?? [],
+        scannedRows: metrics.matchedRows,
+        indexChoice: metrics.indexChoice,
+        joinOrder: [metrics.indexChoice],
+        fallbackReason: null,
+    };
+}
+function baseRdf3xShadowJoinBenchmarkResult(testCase) {
+    return {
+        name: testCase.name,
+        resource: testCase.resource,
+        purpose: testCase.purpose,
+        minScale: testCase.minScale,
+        query: serializeLocalQuery(testCase.query),
+    };
+}
+function unsupportedRdf3xJoinQueryReason(query) {
+    if (query.patterns.length === 0) {
+        return 'RDF-3X join shadow requires at least one required BGP pattern';
+    }
+    if (query.values?.length) {
+        return 'RDF-3X join shadow does not support VALUES yet';
+    }
+    if (query.textSearch?.length || query.vectorSearch?.length) {
+        return 'RDF-3X join shadow does not support search sources yet';
+    }
+    if (query.unions?.length || query.minus?.length || query.exists?.length || query.optional?.length) {
+        return 'RDF-3X join shadow only supports required BGP queries';
+    }
+    if (query.binds?.length || query.filters?.length || query.having?.length) {
+        return 'RDF-3X join shadow does not support local query filters or BIND yet';
+    }
+    if (query.groupBy?.length || query.aggregate || query.aggregates?.length) {
+        return 'RDF-3X join shadow does not support aggregate queries yet';
+    }
+    for (const pattern of query.patterns) {
+        const joinPattern = rdf3xJoinPatternFor(pattern);
+        const unsupportedPattern = unsupportedRdf3xPatternReason(joinPattern.pattern);
+        if (unsupportedPattern) {
+            return unsupportedPattern;
+        }
+    }
+    return undefined;
+}
+function rdf3xJoinShapeFor(query) {
+    return {
+        patterns: query.patterns.map(rdf3xJoinPatternFor),
+        options: {
+            ...(query.select ? { project: query.select } : {}),
+            ...(query.distinct ? { distinct: true } : {}),
+            ...(query.orderBy ? { orderBy: query.orderBy } : {}),
+            ...(query.limit !== undefined ? { limit: query.limit } : {}),
+            ...(query.offset !== undefined ? { offset: query.offset } : {}),
+        },
+    };
+}
+function rdf3xJoinPatternFor(pattern) {
+    const compiledPattern = {};
+    const variables = {};
+    for (const key of ['graph', 'subject', 'predicate', 'object']) {
+        const value = pattern[key];
+        if (!value) {
+            continue;
+        }
+        if (isQueryVariable(value)) {
+            variables[key] = value.variable;
+        }
+        else {
+            compiledPattern[key] = value;
+        }
+    }
+    return {
+        pattern: compiledPattern,
+        variables,
+    };
+}
+function isQueryVariable(value) {
+    return value !== null
+        && typeof value === 'object'
+        && !('termType' in value)
+        && 'variable' in value
+        && typeof value.variable === 'string';
+}
+function unsupportedRdf3xPatternReason(pattern) {
+    for (const key of ['graph', 'subject', 'predicate', 'object']) {
+        const value = pattern[key];
+        if (!value || (0, types_1.isTerm)(value)) {
+            continue;
+        }
+        if (key === 'graph' && isGraphPrefixPattern(value)) {
+            continue;
+        }
+        if (key === 'object' && isSupportedRdf3xNumericObjectRangePattern(value)) {
+            continue;
+        }
+        return `unsupported ${key} pattern for RDF-3X shadow`;
+    }
+    return undefined;
+}
+function rdf3xPatternFor(pattern) {
+    const result = {};
+    for (const key of ['graph', 'subject', 'predicate', 'object']) {
+        const value = pattern[key];
+        if (!value) {
+            continue;
+        }
+        if (key === 'graph' && isGraphPrefixPattern(value)) {
+            result.graph = { $startsWith: value.$startsWith };
+            continue;
+        }
+        if (key === 'object' && isSupportedRdf3xNumericObjectRangePattern(value)) {
+            result.object = value;
+            continue;
+        }
+        if (!(0, types_1.isTerm)(value)) {
+            throw new Error(`RDF-3X shadow benchmark only supports exact ${key} terms or graph prefixes`);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+function isGraphPrefixPattern(value) {
+    return value !== null
+        && typeof value === 'object'
+        && '$startsWith' in value
+        && typeof value.$startsWith === 'string';
+}
+function isSupportedRdf3xNumericObjectRangePattern(value) {
+    if (value === null || typeof value !== 'object' || 'termType' in value) {
+        return false;
+    }
+    let hasRange = false;
+    for (const operator of ['$gt', '$gte', '$lt', '$lte']) {
+        const rangeValue = value[operator];
+        if (rangeValue === undefined) {
+            continue;
+        }
+        hasRange = true;
+        if (numericRangeValue(rangeValue) === undefined) {
+            return false;
+        }
+    }
+    return hasRange;
+}
+function numericRangeValue(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    if (value.termType !== 'Literal' || !(0, RdfTermSemantics_1.isRdfNumericDatatype)(value.datatype.value)) {
+        return undefined;
+    }
+    const parsed = (0, RdfTermSemantics_1.rdfNumericValue)(value.value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function isSemanticallyOrdered(options) {
+    return Boolean(options?.order && options.order.length > 0);
+}
+function isSemanticallyOrderedJoin(options) {
+    return Boolean(options?.orderBy && options.orderBy.length > 0);
+}
+function benchmarkSide(keys, durationsMs) {
+    return {
+        returnedRows: keys.length,
+        checksum: checksum(keys, false),
+        orderedChecksum: checksum(keys, true),
+        durationsMs,
+        p50DurationMs: percentile(durationsMs, 0.5),
+        p95DurationMs: percentile(durationsMs, 0.95),
+    };
+}
+function diffBindingKeys(primaryKeys, candidateKeys) {
+    const primarySet = new Set(primaryKeys);
+    const candidateSet = new Set(candidateKeys);
+    return {
+        missingFromPrimary: Array.from(candidateSet).filter((key) => !primarySet.has(key)).sort(),
+        extraInPrimary: Array.from(primarySet).filter((key) => !candidateSet.has(key)).sort(),
+    };
+}
+function comparePerformance(compatibility, solidRdf) {
+    const p95DeltaMs = solidRdf.p95DurationMs - compatibility.p95DurationMs;
+    const p95Ratio = solidRdf.p95DurationMs / Math.max(1, compatibility.p95DurationMs);
+    return {
+        p95DeltaMs,
+        p95Ratio,
+        matched: p95DeltaMs <= PERFORMANCE_P95_MIN_ABSOLUTE_HEADROOM_MS
+            || p95Ratio <= PERFORMANCE_P95_MAX_RATIO,
+    };
+}
+function compareSpace(compatibility, solidRdf) {
+    if (compatibility.databaseBytes === undefined
+        || compatibility.tableBytes === undefined
+        || compatibility.indexBytes === undefined) {
+        return {
+            databaseDeltaBytes: 0,
+            tableDeltaBytes: 0,
+            indexDeltaBytes: 0,
+            databaseRatio: 0,
+            tableRatio: 0,
+            indexRatio: 0,
+            matched: false,
+            unavailableReason: 'compatibility store did not report database/table/index bytes',
+        };
+    }
+    const databaseDeltaBytes = solidRdf.databaseBytes - compatibility.databaseBytes;
+    const tableDeltaBytes = solidRdf.tableBytes - compatibility.tableBytes;
+    const indexDeltaBytes = solidRdf.indexBytes - compatibility.indexBytes;
+    return {
+        databaseDeltaBytes,
+        tableDeltaBytes,
+        indexDeltaBytes,
+        databaseRatio: ratio(solidRdf.databaseBytes, compatibility.databaseBytes),
+        tableRatio: ratio(solidRdf.tableBytes, compatibility.tableBytes),
+        indexRatio: ratio(solidRdf.indexBytes, compatibility.indexBytes),
+        matched: databaseDeltaBytes <= 0 && tableDeltaBytes <= 0 && indexDeltaBytes <= 0,
+    };
+}
+function ratio(candidate, baseline) {
+    if (baseline <= 0) {
+        return candidate <= 0 ? 1 : Number.POSITIVE_INFINITY;
+    }
+    return candidate / baseline;
+}
+function missingExpectedPlan(testCase, metrics) {
+    return testCase.expectedPlan.filter((label) => !matchesExpectedPlanLabel(label, testCase, metrics));
+}
+function matchesExpectedPlanLabel(label, testCase, metrics) {
+    const pattern = testCase.query.pattern;
+    const planText = (metrics.queryPlan ?? []).join('\n');
+    switch (label) {
+        case 'graph-scope':
+            return Boolean(pattern.graph) && metrics.indexChoice.includes('G');
+        case 'type-filter':
+            return (0, types_1.isTerm)(pattern.predicate)
+                && (0, n3_2.termToId)(pattern.predicate) === RDF_TYPE
+                && Boolean(pattern.object)
+                && metrics.indexChoice !== 'full-scan';
+        case 'predicate-filter':
+            return Boolean(pattern.predicate) && metrics.indexChoice.includes('P');
+        case 'predicate-object-filter':
+            return Boolean(pattern.predicate) && Boolean(pattern.object) && metrics.indexChoice.includes('P');
+        case 'predicate-object-range-filter':
+            return Boolean(pattern.predicate)
+                && (planText.includes('_range') || planText.includes('LexicalRange(') || planText.includes('NumericRange('));
+        case 'limit':
+            return testCase.query.options?.limit !== undefined && planText.includes('LIMIT');
+        case 'order':
+            return Boolean(testCase.query.options?.order?.length) && planText.includes('ORDER BY');
+        case 'text-index':
+            return planText.includes('TextSearch(');
+        case 'rdf-subject-join':
+            return planText.includes('TextSearch(')
+                && metrics.indexChoice !== 'full-scan'
+                && metrics.matchedRows >= metrics.returnedRows;
+        case 'SPOG':
+        case 'POSG':
+        case 'GSPO':
+        case 'GPOS':
+        case 'OSPG':
+            return metrics.indexChoice === label;
+        default:
+            return false;
+    }
+}
+function missingExpectedLocalQueryPlan(testCase, metrics) {
+    return testCase.expectedPlan.filter((label) => !matchesExpectedLocalQueryPlanLabel(label, metrics));
+}
+function matchesExpectedLocalQueryPlanLabel(label, metrics) {
+    const planText = metrics.plan.join('\n');
+    switch (label) {
+        case 'group-count-index':
+            return planText.includes('Aggregate(group-count-index)');
+        case 'having-pushdown':
+            return planText.includes('IndexGroupCountHaving(')
+                && !planText.includes('\nHaving(');
+        case 'order':
+            return planText.includes('IndexGroupCountOrder(') && !planText.includes('\nSort');
+        case 'limit':
+            return planText.includes('IndexGroupCountLimit') && !planText.includes('\nLimit');
+        case 'join-index':
+            return planText.includes('IndexJoin(')
+                && !planText.includes('\nIndexScan(');
+        case 'join-order-pushdown':
+            return planText.includes('IndexJoinOrder(')
+                && !planText.includes('\nSort');
+        case 'join-limit-pushdown':
+            return planText.includes('IndexJoinLimit')
+                && !planText.includes('\nLimit');
+        case 'range-filter-pushdown':
+            return metrics.filtersPushedDown > 0
+                && planText.includes('LexicalRange(');
+        case 'join-count-index':
+            return planText.includes('Aggregate(join-count-distinct-index)')
+                && planText.includes('IndexJoinCount(')
+                && !planText.includes('\nIndexScan(');
+        default:
+            return false;
+    }
+}
+function bindingKey(binding) {
+    return Object.keys(binding)
+        .sort()
+        .map((key) => `${key}=${(0, n3_2.termToId)(binding[key])}`)
+        .join('\u001f');
+}
+function checksum(keys, ordered) {
+    const normalized = ordered ? keys : [...keys].sort();
+    return (0, node_crypto_1.createHash)('sha256')
+        .update(normalized.join('\n'))
+        .digest('hex');
+}
+function percentile(values, percentileValue) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * percentileValue) - 1));
+    return sorted[index];
+}
+function scaleRank(scale) {
+    switch (scale) {
+        case 'small':
+            return 1;
+        case 'medium':
+            return 2;
+        case 'large':
+            return 3;
+        default: {
+            const exhaustive = scale;
+            return exhaustive;
+        }
+    }
+}
+function serializePattern(pattern) {
+    return Object.fromEntries(Object.entries(pattern).map(([key, value]) => [key, serializePatternValue(value)]));
+}
+function serializeLocalQuery(query) {
+    return serializePatternValue(query);
+}
+function serializePatternValue(value) {
+    if (!value) {
+        return value;
+    }
+    if ((0, types_1.isTerm)(value)) {
+        return (0, n3_2.termToId)(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map(serializePatternValue);
+    }
+    if (typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .map(([key, nested]) => [key, serializePatternValue(nested)]));
+    }
+    return value;
+}
+//# sourceMappingURL=models-benchmark.js.map