@undefineds.co/xpod 0.3.5 → 0.3.14

package/dist/storage/rdf/SolidRdfSparqlEngine.jsonld

@@ -0,0 +1,257 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@undefineds.co/xpod",
+  "components": [
+    {
+      "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngineOptions",
+      "@type": "AbstractClass",
+      "requireElement": "SolidRdfSparqlEngineOptions",
+      "parameters": [],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngineOptions__member_rdfEngine",
+          "memberFieldName": "rdfEngine"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngineOptions__member_fallback",
+          "memberFieldName": "fallback"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngineOptions__member_shadowStore",
+          "memberFieldName": "shadowStore"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngineOptions__member_enablePrimary",
+          "memberFieldName": "enablePrimary"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngineOptions__member_onFallback",
+          "memberFieldName": "onFallback"
+        }
+      ],
+      "constructorArguments": []
+    },
+    {
+      "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlFallback",
+      "@type": "AbstractClass",
+      "requireElement": "SolidRdfSparqlFallback",
+      "parameters": [],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlFallback__member_operation",
+          "memberFieldName": "operation"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlFallback__member_reason",
+          "memberFieldName": "reason"
+        }
+      ],
+      "constructorArguments": []
+    },
+    {
+      "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine",
+      "@type": "Class",
+      "requireElement": "SolidRdfSparqlEngine",
+      "extends": [
+        "undefineds:dist/storage/sparql/SubgraphQueryEngine.jsonld#SparqlEngine"
+      ],
+      "parameters": [
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine_enablePrimary",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "xsd:boolean",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine_onFallback",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              {
+                "@type": "ParameterRangeWildcard"
+              },
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine_rdfEngine",
+          "range": "undefineds:dist/storage/rdf/SolidRdfEngine.jsonld#SolidRdfEngine"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine_fallback",
+          "range": "undefineds:dist/storage/sparql/SubgraphQueryEngine.jsonld#SparqlEngine"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine_shadowStore",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "undefineds:dist/storage/rdf/ShadowRdfQuintStore.jsonld#ShadowRdfQuintStore",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_adapter",
+          "memberFieldName": "adapter"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_bindingsFactory",
+          "memberFieldName": "bindingsFactory"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_rdfEngine",
+          "memberFieldName": "rdfEngine"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_fallback",
+          "memberFieldName": "fallback"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_shadowStore",
+          "memberFieldName": "shadowStore"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_enablePrimary",
+          "memberFieldName": "enablePrimary"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_onFallback",
+          "memberFieldName": "onFallback"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_operationCounts",
+          "memberFieldName": "operationCounts"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_lastPrimary",
+          "memberFieldName": "lastPrimary"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_lastFallback",
+          "memberFieldName": "lastFallback"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_queryBindings",
+          "memberFieldName": "queryBindings"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_queryBoolean",
+          "memberFieldName": "queryBoolean"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_queryQuads",
+          "memberFieldName": "queryQuads"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_queryVoid",
+          "memberFieldName": "queryVoid"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_constructGraph",
+          "memberFieldName": "constructGraph"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_listGraphs",
+          "memberFieldName": "listGraphs"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_close",
+          "memberFieldName": "close"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_getMetrics",
+          "memberFieldName": "getMetrics"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_assertFallbackBudget",
+          "memberFieldName": "assertFallbackBudget"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_resetMetrics",
+          "memberFieldName": "resetMetrics"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_bindingsStream",
+          "memberFieldName": "bindingsStream"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_bindings",
+          "memberFieldName": "bindings"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_fallbackWith",
+          "memberFieldName": "fallbackWith"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_ensureReady",
+          "memberFieldName": "ensureReady"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_executeSelectPrimary",
+          "memberFieldName": "executeSelectPrimary"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_executeConstructPrimary",
+          "memberFieldName": "executeConstructPrimary"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_executeQuadsPrimary",
+          "memberFieldName": "executeQuadsPrimary"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_executeDescribePrimary",
+          "memberFieldName": "executeDescribePrimary"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_recordPrimary",
+          "memberFieldName": "recordPrimary"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_recordFallback",
+          "memberFieldName": "recordFallback"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine__member_countsFor",
+          "memberFieldName": "countsFor"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine_rdfEngine"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine_fallback"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine_shadowStore"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine_enablePrimary"
+        },
+        {
+          "@id": "undefineds:dist/storage/rdf/SolidRdfSparqlEngine.jsonld#SolidRdfSparqlEngine_onFallback"
+        }
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,15 @@
+export { RdfTermDictionary } from './RdfTermDictionary';
+export { RDF_NUMERIC_DATATYPES, isFiniteNumericLexical, isRdfNumericDatatype, isRdfNumericTerm, rdfNumericValue, } from './RdfTermSemantics';
+export { RdfQuadIndex } from './RdfQuadIndex';
+export { Rdf3xTripleIndex } from './Rdf3xTripleIndex';
+export { RdfTextIndex } from './RdfTextIndex';
+export { RdfVectorIndex } from './RdfVectorIndex';
+export { isLineAddressableRdf, isLineAddressableRdfContentType, isLineAddressableRdfPath, isRdfDocument, isRdfDocumentContentType, isRdfDocumentPath, isSafeRdfDocumentContentType, normalizeContentType, rdfContentTypeForPath, } from './RdfContentTypes';
+export { RdfShadowComparator, canonicalQuadKey, diffQuads } from './RdfShadowComparator';
+export { RdfLocalQueryEngine, variable as rdfVar } from './RdfLocalQueryEngine';
+export { ShadowRdfQuintStore, type ShadowRdfQuintStoreOptions } from './ShadowRdfQuintStore';
+export { SolidRdfEngine, type SolidRdfEngineOptions } from './SolidRdfEngine';
+export { DisabledSparqlFeatureError, RdfSparqlAdapter, UnsupportedSparqlQueryError, type RdfSparqlCompileResult, type RdfSparqlDeleteOperation, type RdfSparqlDeleteWhereOperation, type RdfSparqlDeleteWhereTemplate, type RdfSparqlInsertOperation, type RdfSparqlUpdateDelta, type RdfSparqlUpdateDeltaOperation, } from './RdfSparqlAdapter';
+export { SolidRdfSparqlEngine, type SolidRdfSparqlEngineOptions, type SolidRdfSparqlFallback, type SolidRdfSparqlFallbackMetric, type SolidRdfSparqlMetricsSnapshot, type SolidRdfSparqlOperation, type SolidRdfSparqlOperationCount, type SolidRdfSparqlPrimaryMetric, } from './SolidRdfSparqlEngine';
+export { rdfModelsBenchmarkCases, rdfModelsBenchmarkCaseNames, rdfModelsLocalQueryBenchmarkCases, rdfModelsLocalQueryBenchmarkCaseNames, defaultSyntheticMessagesForRdfModelsScale, estimateRdfModelsSyntheticQuadCount, rdfModelsBenchmarkScaleSatisfied, rdfModelsBenchmarkSyntheticPodCount, rdfModelsBenchmarkScaleTargetQuads, runRdfModelsBenchmark, runRdfModelsRdf3xShadowBenchmark, runRdfModelsShadowBenchmark, RDF_MODELS_SYNTHETIC_MESSAGE_QUADS, type RdfBenchmarkScale, type RdfModelBenchmarkCase, type RdfModelLocalQueryBenchmarkCase, type RdfModelLocalQueryBenchmarkResult, type RdfModelBenchmarkReport, type RdfModelBenchmarkResult, type RdfModelBenchmarkRunOptions, type RdfModelShadowBenchmarkReport, type RdfModelRdf3xShadowBenchmarkReport, type RdfModelRdf3xShadowJoinBenchmarkResult, type RdfModelRdf3xShadowBenchmarkResult, type RdfModelShadowBenchmarkResult, type RdfModelShadowBenchmarkRunOptions, type RdfModelShadowBenchmarkSide, } from './models-benchmark';
+export type { RdfIndexStats, Rdf3xCardinalityEstimate, Rdf3xJoinMetrics, Rdf3xJoinOptions, Rdf3xJoinScanResult, Rdf3xIndexMetrics, Rdf3xIndexStats, Rdf3xPairProjectionName, Rdf3xPatternKey, Rdf3xPermutationName, Rdf3xRebuildResult, Rdf3xTermKey, Rdf3xTermProjectionName, Rdf3xTripleIndexOptions, Rdf3xTriplePattern, Rdf3xTripleScanOptions, Rdf3xTripleScanResult, Rdf3xShadowBindingDiff, Rdf3xShadowQuadDiff, Rdf3xShadowJoinResult, Rdf3xShadowScanResult, RdfIndexSpaceObject, RdfIndexMetrics, RdfIndexPutOptions, RdfBindingRow, RdfConstructTemplate, RdfQuadJoinOptions, RdfQuadJoinCountOptions, RdfQuadJoinOrder, RdfQuadJoinPattern, RdfQuadJoinScanResult, RdfLocalQuery, RdfQueryAggregate, RdfLocalQueryMetrics, RdfLocalQueryResult, RdfPatternQuery, RdfQuadIndexOptions, RdfQuadIndexScanResult, RdfQuadRow, RdfQueryOrder, RdfQueryPattern, RdfQueryPatternKey, RdfQueryTermPattern, RdfQueryVariable, RdfShadowBackfillOptions, RdfShadowBackfillResult, RdfShadowDiff, RdfShadowScanResult, RdfSourceInput, RdfSourceRow, RdfTextChunkInput, RdfTextChunkRow, RdfTextIndexOptions, RdfTextIndexStats, RdfTextSearchOptions, RdfTextSearchPattern, RdfTextSearchResult, RdfTextSourceInput, RdfTextTermDocumentFrequency, RdfVectorChunkInput, RdfVectorChunkRow, RdfVectorDistanceMetric, RdfVectorIndexOptions, RdfVectorIndexStats, RdfVectorModelDistribution, RdfVectorSearchOptions, RdfVectorSearchPattern, RdfVectorSearchResult, RdfVectorSourceInput, RdfTermKind, RdfTermLookup, RdfTermRow, RdfTermSelection, } from './types';

package/dist/storage/rdf/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RDF_MODELS_SYNTHETIC_MESSAGE_QUADS = exports.runRdfModelsShadowBenchmark = exports.runRdfModelsRdf3xShadowBenchmark = exports.runRdfModelsBenchmark = exports.rdfModelsBenchmarkScaleTargetQuads = exports.rdfModelsBenchmarkSyntheticPodCount = exports.rdfModelsBenchmarkScaleSatisfied = exports.estimateRdfModelsSyntheticQuadCount = exports.defaultSyntheticMessagesForRdfModelsScale = exports.rdfModelsLocalQueryBenchmarkCaseNames = exports.rdfModelsLocalQueryBenchmarkCases = exports.rdfModelsBenchmarkCaseNames = exports.rdfModelsBenchmarkCases = exports.SolidRdfSparqlEngine = exports.UnsupportedSparqlQueryError = exports.RdfSparqlAdapter = exports.DisabledSparqlFeatureError = exports.SolidRdfEngine = exports.ShadowRdfQuintStore = exports.rdfVar = exports.RdfLocalQueryEngine = exports.diffQuads = exports.canonicalQuadKey = exports.RdfShadowComparator = exports.rdfContentTypeForPath = exports.normalizeContentType = exports.isSafeRdfDocumentContentType = exports.isRdfDocumentPath = exports.isRdfDocumentContentType = exports.isRdfDocument = exports.isLineAddressableRdfPath = exports.isLineAddressableRdfContentType = exports.isLineAddressableRdf = exports.RdfVectorIndex = exports.RdfTextIndex = exports.Rdf3xTripleIndex = exports.RdfQuadIndex = exports.rdfNumericValue = exports.isRdfNumericTerm = exports.isRdfNumericDatatype = exports.isFiniteNumericLexical = exports.RDF_NUMERIC_DATATYPES = exports.RdfTermDictionary = void 0;
+var RdfTermDictionary_1 = require("./RdfTermDictionary");
+Object.defineProperty(exports, "RdfTermDictionary", { enumerable: true, get: function () { return RdfTermDictionary_1.RdfTermDictionary; } });
+var RdfTermSemantics_1 = require("./RdfTermSemantics");
+Object.defineProperty(exports, "RDF_NUMERIC_DATATYPES", { enumerable: true, get: function () { return RdfTermSemantics_1.RDF_NUMERIC_DATATYPES; } });
+Object.defineProperty(exports, "isFiniteNumericLexical", { enumerable: true, get: function () { return RdfTermSemantics_1.isFiniteNumericLexical; } });
+Object.defineProperty(exports, "isRdfNumericDatatype", { enumerable: true, get: function () { return RdfTermSemantics_1.isRdfNumericDatatype; } });
+Object.defineProperty(exports, "isRdfNumericTerm", { enumerable: true, get: function () { return RdfTermSemantics_1.isRdfNumericTerm; } });
+Object.defineProperty(exports, "rdfNumericValue", { enumerable: true, get: function () { return RdfTermSemantics_1.rdfNumericValue; } });
+var RdfQuadIndex_1 = require("./RdfQuadIndex");
+Object.defineProperty(exports, "RdfQuadIndex", { enumerable: true, get: function () { return RdfQuadIndex_1.RdfQuadIndex; } });
+var Rdf3xTripleIndex_1 = require("./Rdf3xTripleIndex");
+Object.defineProperty(exports, "Rdf3xTripleIndex", { enumerable: true, get: function () { return Rdf3xTripleIndex_1.Rdf3xTripleIndex; } });
+var RdfTextIndex_1 = require("./RdfTextIndex");
+Object.defineProperty(exports, "RdfTextIndex", { enumerable: true, get: function () { return RdfTextIndex_1.RdfTextIndex; } });
+var RdfVectorIndex_1 = require("./RdfVectorIndex");
+Object.defineProperty(exports, "RdfVectorIndex", { enumerable: true, get: function () { return RdfVectorIndex_1.RdfVectorIndex; } });
+var RdfContentTypes_1 = require("./RdfContentTypes");
+Object.defineProperty(exports, "isLineAddressableRdf", { enumerable: true, get: function () { return RdfContentTypes_1.isLineAddressableRdf; } });
+Object.defineProperty(exports, "isLineAddressableRdfContentType", { enumerable: true, get: function () { return RdfContentTypes_1.isLineAddressableRdfContentType; } });
+Object.defineProperty(exports, "isLineAddressableRdfPath", { enumerable: true, get: function () { return RdfContentTypes_1.isLineAddressableRdfPath; } });
+Object.defineProperty(exports, "isRdfDocument", { enumerable: true, get: function () { return RdfContentTypes_1.isRdfDocument; } });
+Object.defineProperty(exports, "isRdfDocumentContentType", { enumerable: true, get: function () { return RdfContentTypes_1.isRdfDocumentContentType; } });
+Object.defineProperty(exports, "isRdfDocumentPath", { enumerable: true, get: function () { return RdfContentTypes_1.isRdfDocumentPath; } });
+Object.defineProperty(exports, "isSafeRdfDocumentContentType", { enumerable: true, get: function () { return RdfContentTypes_1.isSafeRdfDocumentContentType; } });
+Object.defineProperty(exports, "normalizeContentType", { enumerable: true, get: function () { return RdfContentTypes_1.normalizeContentType; } });
+Object.defineProperty(exports, "rdfContentTypeForPath", { enumerable: true, get: function () { return RdfContentTypes_1.rdfContentTypeForPath; } });
+var RdfShadowComparator_1 = require("./RdfShadowComparator");
+Object.defineProperty(exports, "RdfShadowComparator", { enumerable: true, get: function () { return RdfShadowComparator_1.RdfShadowComparator; } });
+Object.defineProperty(exports, "canonicalQuadKey", { enumerable: true, get: function () { return RdfShadowComparator_1.canonicalQuadKey; } });
+Object.defineProperty(exports, "diffQuads", { enumerable: true, get: function () { return RdfShadowComparator_1.diffQuads; } });
+var RdfLocalQueryEngine_1 = require("./RdfLocalQueryEngine");
+Object.defineProperty(exports, "RdfLocalQueryEngine", { enumerable: true, get: function () { return RdfLocalQueryEngine_1.RdfLocalQueryEngine; } });
+Object.defineProperty(exports, "rdfVar", { enumerable: true, get: function () { return RdfLocalQueryEngine_1.variable; } });
+var ShadowRdfQuintStore_1 = require("./ShadowRdfQuintStore");
+Object.defineProperty(exports, "ShadowRdfQuintStore", { enumerable: true, get: function () { return ShadowRdfQuintStore_1.ShadowRdfQuintStore; } });
+var SolidRdfEngine_1 = require("./SolidRdfEngine");
+Object.defineProperty(exports, "SolidRdfEngine", { enumerable: true, get: function () { return SolidRdfEngine_1.SolidRdfEngine; } });
+var RdfSparqlAdapter_1 = require("./RdfSparqlAdapter");
+Object.defineProperty(exports, "DisabledSparqlFeatureError", { enumerable: true, get: function () { return RdfSparqlAdapter_1.DisabledSparqlFeatureError; } });
+Object.defineProperty(exports, "RdfSparqlAdapter", { enumerable: true, get: function () { return RdfSparqlAdapter_1.RdfSparqlAdapter; } });
+Object.defineProperty(exports, "UnsupportedSparqlQueryError", { enumerable: true, get: function () { return RdfSparqlAdapter_1.UnsupportedSparqlQueryError; } });
+var SolidRdfSparqlEngine_1 = require("./SolidRdfSparqlEngine");
+Object.defineProperty(exports, "SolidRdfSparqlEngine", { enumerable: true, get: function () { return SolidRdfSparqlEngine_1.SolidRdfSparqlEngine; } });
+var models_benchmark_1 = require("./models-benchmark");
+Object.defineProperty(exports, "rdfModelsBenchmarkCases", { enumerable: true, get: function () { return models_benchmark_1.rdfModelsBenchmarkCases; } });
+Object.defineProperty(exports, "rdfModelsBenchmarkCaseNames", { enumerable: true, get: function () { return models_benchmark_1.rdfModelsBenchmarkCaseNames; } });
+Object.defineProperty(exports, "rdfModelsLocalQueryBenchmarkCases", { enumerable: true, get: function () { return models_benchmark_1.rdfModelsLocalQueryBenchmarkCases; } });
+Object.defineProperty(exports, "rdfModelsLocalQueryBenchmarkCaseNames", { enumerable: true, get: function () { return models_benchmark_1.rdfModelsLocalQueryBenchmarkCaseNames; } });
+Object.defineProperty(exports, "defaultSyntheticMessagesForRdfModelsScale", { enumerable: true, get: function () { return models_benchmark_1.defaultSyntheticMessagesForRdfModelsScale; } });
+Object.defineProperty(exports, "estimateRdfModelsSyntheticQuadCount", { enumerable: true, get: function () { return models_benchmark_1.estimateRdfModelsSyntheticQuadCount; } });
+Object.defineProperty(exports, "rdfModelsBenchmarkScaleSatisfied", { enumerable: true, get: function () { return models_benchmark_1.rdfModelsBenchmarkScaleSatisfied; } });
+Object.defineProperty(exports, "rdfModelsBenchmarkSyntheticPodCount", { enumerable: true, get: function () { return models_benchmark_1.rdfModelsBenchmarkSyntheticPodCount; } });
+Object.defineProperty(exports, "rdfModelsBenchmarkScaleTargetQuads", { enumerable: true, get: function () { return models_benchmark_1.rdfModelsBenchmarkScaleTargetQuads; } });
+Object.defineProperty(exports, "runRdfModelsBenchmark", { enumerable: true, get: function () { return models_benchmark_1.runRdfModelsBenchmark; } });
+Object.defineProperty(exports, "runRdfModelsRdf3xShadowBenchmark", { enumerable: true, get: function () { return models_benchmark_1.runRdfModelsRdf3xShadowBenchmark; } });
+Object.defineProperty(exports, "runRdfModelsShadowBenchmark", { enumerable: true, get: function () { return models_benchmark_1.runRdfModelsShadowBenchmark; } });
+Object.defineProperty(exports, "RDF_MODELS_SYNTHETIC_MESSAGE_QUADS", { enumerable: true, get: function () { return models_benchmark_1.RDF_MODELS_SYNTHETIC_MESSAGE_QUADS; } });
+//# sourceMappingURL=index.js.map

package/dist/storage/rdf/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/storage/rdf/index.ts"],"names":[],"mappings":";;;AAAA,yDAAwD;AAA/C,sHAAA,iBAAiB,OAAA;AAC1B,uDAM4B;AAL1B,yHAAA,qBAAqB,OAAA;AACrB,0HAAA,sBAAsB,OAAA;AACtB,wHAAA,oBAAoB,OAAA;AACpB,oHAAA,gBAAgB,OAAA;AAChB,mHAAA,eAAe,OAAA;AAEjB,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AACrB,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AACrB,mDAAkD;AAAzC,gHAAA,cAAc,OAAA;AACvB,qDAU2B;AATzB,uHAAA,oBAAoB,OAAA;AACpB,kIAAA,+BAA+B,OAAA;AAC/B,2HAAA,wBAAwB,OAAA;AACxB,gHAAA,aAAa,OAAA;AACb,2HAAA,wBAAwB,OAAA;AACxB,oHAAA,iBAAiB,OAAA;AACjB,+HAAA,4BAA4B,OAAA;AAC5B,uHAAA,oBAAoB,OAAA;AACpB,wHAAA,qBAAqB,OAAA;AAEvB,6DAAyF;AAAhF,0HAAA,mBAAmB,OAAA;AAAE,uHAAA,gBAAgB,OAAA;AAAE,gHAAA,SAAS,OAAA;AACzD,6DAAgF;AAAvE,0HAAA,mBAAmB,OAAA;AAAE,6GAAA,QAAQ,OAAU;AAChD,6DAA6F;AAApF,0HAAA,mBAAmB,OAAA;AAC5B,mDAA8E;AAArE,gHAAA,cAAc,OAAA;AACvB,uDAW4B;AAV1B,8HAAA,0BAA0B,OAAA;AAC1B,oHAAA,gBAAgB,OAAA;AAChB,+HAAA,2BAA2B,OAAA;AAS7B,+DASgC;AAR9B,4HAAA,oBAAoB,OAAA;AAStB,uDA4B4B;AA3B1B,2HAAA,uBAAuB,OAAA;AACvB,+HAAA,2BAA2B,OAAA;AAC3B,qIAAA,iCAAiC,OAAA;AACjC,yIAAA,qCAAqC,OAAA;AACrC,6IAAA,yCAAyC,OAAA;AACzC,uIAAA,mCAAmC,OAAA;AACnC,oIAAA,gCAAgC,OAAA;AAChC,uIAAA,mCAAmC,OAAA;AACnC,sIAAA,kCAAkC,OAAA;AAClC,yHAAA,qBAAqB,OAAA;AACrB,oIAAA,gCAAgC,OAAA;AAChC,+HAAA,2BAA2B,OAAA;AAC3B,sIAAA,kCAAkC,OAAA","sourcesContent":["export { RdfTermDictionary } from './RdfTermDictionary';\nexport {\n  RDF_NUMERIC_DATATYPES,\n  isFiniteNumericLexical,\n  isRdfNumericDatatype,\n  isRdfNumericTerm,\n  rdfNumericValue,\n} from './RdfTermSemantics';\nexport { RdfQuadIndex } from './RdfQuadIndex';\nexport { Rdf3xTripleIndex } from './Rdf3xTripleIndex';\nexport { RdfTextIndex } from './RdfTextIndex';\nexport { RdfVectorIndex } from './RdfVectorIndex';\nexport {\n  isLineAddressableRdf,\n  isLineAddressableRdfContentType,\n  isLineAddressableRdfPath,\n  isRdfDocument,\n  isRdfDocumentContentType,\n  isRdfDocumentPath,\n  isSafeRdfDocumentContentType,\n  normalizeContentType,\n  rdfContentTypeForPath,\n} from './RdfContentTypes';\nexport { RdfShadowComparator, canonicalQuadKey, diffQuads } from './RdfShadowComparator';\nexport { RdfLocalQueryEngine, variable as rdfVar } from './RdfLocalQueryEngine';\nexport { ShadowRdfQuintStore, type ShadowRdfQuintStoreOptions } from './ShadowRdfQuintStore';\nexport { SolidRdfEngine, type SolidRdfEngineOptions } from './SolidRdfEngine';\nexport {\n  DisabledSparqlFeatureError,\n  RdfSparqlAdapter,\n  UnsupportedSparqlQueryError,\n  type RdfSparqlCompileResult,\n  type RdfSparqlDeleteOperation,\n  type RdfSparqlDeleteWhereOperation,\n  type RdfSparqlDeleteWhereTemplate,\n  type RdfSparqlInsertOperation,\n  type RdfSparqlUpdateDelta,\n  type RdfSparqlUpdateDeltaOperation,\n} from './RdfSparqlAdapter';\nexport {\n  SolidRdfSparqlEngine,\n  type SolidRdfSparqlEngineOptions,\n  type SolidRdfSparqlFallback,\n  type SolidRdfSparqlFallbackMetric,\n  type SolidRdfSparqlMetricsSnapshot,\n  type SolidRdfSparqlOperation,\n  type SolidRdfSparqlOperationCount,\n  type SolidRdfSparqlPrimaryMetric,\n} from './SolidRdfSparqlEngine';\nexport {\n  rdfModelsBenchmarkCases,\n  rdfModelsBenchmarkCaseNames,\n  rdfModelsLocalQueryBenchmarkCases,\n  rdfModelsLocalQueryBenchmarkCaseNames,\n  defaultSyntheticMessagesForRdfModelsScale,\n  estimateRdfModelsSyntheticQuadCount,\n  rdfModelsBenchmarkScaleSatisfied,\n  rdfModelsBenchmarkSyntheticPodCount,\n  rdfModelsBenchmarkScaleTargetQuads,\n  runRdfModelsBenchmark,\n  runRdfModelsRdf3xShadowBenchmark,\n  runRdfModelsShadowBenchmark,\n  RDF_MODELS_SYNTHETIC_MESSAGE_QUADS,\n  type RdfBenchmarkScale,\n  type RdfModelBenchmarkCase,\n  type RdfModelLocalQueryBenchmarkCase,\n  type RdfModelLocalQueryBenchmarkResult,\n  type RdfModelBenchmarkReport,\n  type RdfModelBenchmarkResult,\n  type RdfModelBenchmarkRunOptions,\n  type RdfModelShadowBenchmarkReport,\n  type RdfModelRdf3xShadowBenchmarkReport,\n  type RdfModelRdf3xShadowJoinBenchmarkResult,\n  type RdfModelRdf3xShadowBenchmarkResult,\n  type RdfModelShadowBenchmarkResult,\n  type RdfModelShadowBenchmarkRunOptions,\n  type RdfModelShadowBenchmarkSide,\n} from './models-benchmark';\nexport type {\n  RdfIndexStats,\n  Rdf3xCardinalityEstimate,\n  Rdf3xJoinMetrics,\n  Rdf3xJoinOptions,\n  Rdf3xJoinScanResult,\n  Rdf3xIndexMetrics,\n  Rdf3xIndexStats,\n  Rdf3xPairProjectionName,\n  Rdf3xPatternKey,\n  Rdf3xPermutationName,\n  Rdf3xRebuildResult,\n  Rdf3xTermKey,\n  Rdf3xTermProjectionName,\n  Rdf3xTripleIndexOptions,\n  Rdf3xTriplePattern,\n  Rdf3xTripleScanOptions,\n  Rdf3xTripleScanResult,\n  Rdf3xShadowBindingDiff,\n  Rdf3xShadowQuadDiff,\n  Rdf3xShadowJoinResult,\n  Rdf3xShadowScanResult,\n  RdfIndexSpaceObject,\n  RdfIndexMetrics,\n  RdfIndexPutOptions,\n  RdfBindingRow,\n  RdfConstructTemplate,\n  RdfQuadJoinOptions,\n  RdfQuadJoinCountOptions,\n  RdfQuadJoinOrder,\n  RdfQuadJoinPattern,\n  RdfQuadJoinScanResult,\n  RdfLocalQuery,\n  RdfQueryAggregate,\n  RdfLocalQueryMetrics,\n  RdfLocalQueryResult,\n  RdfPatternQuery,\n  RdfQuadIndexOptions,\n  RdfQuadIndexScanResult,\n  RdfQuadRow,\n  RdfQueryOrder,\n  RdfQueryPattern,\n  RdfQueryPatternKey,\n  RdfQueryTermPattern,\n  RdfQueryVariable,\n  RdfShadowBackfillOptions,\n  RdfShadowBackfillResult,\n  RdfShadowDiff,\n  RdfShadowScanResult,\n  RdfSourceInput,\n  RdfSourceRow,\n  RdfTextChunkInput,\n  RdfTextChunkRow,\n  RdfTextIndexOptions,\n  RdfTextIndexStats,\n  RdfTextSearchOptions,\n  RdfTextSearchPattern,\n  RdfTextSearchResult,\n  RdfTextSourceInput,\n  RdfTextTermDocumentFrequency,\n  RdfVectorChunkInput,\n  RdfVectorChunkRow,\n  RdfVectorDistanceMetric,\n  RdfVectorIndexOptions,\n  RdfVectorIndexStats,\n  RdfVectorModelDistribution,\n  RdfVectorSearchOptions,\n  RdfVectorSearchPattern,\n  RdfVectorSearchResult,\n  RdfVectorSourceInput,\n  RdfTermKind,\n  RdfTermLookup,\n  RdfTermRow,\n  RdfTermSelection,\n} from './types';\n"]}

package/dist/storage/rdf/models-benchmark.d.ts

@@ -0,0 +1,260 @@
+import type { QuintPattern, QueryOptions, QuintStore, StoreStats } from '../quint/types';
+import type { Rdf3xJoinMetrics, Rdf3xIndexMetrics, Rdf3xIndexStats, RdfIndexMetrics, RdfIndexStats, RdfLocalQuery, RdfLocalQueryMetrics, RdfShadowDiff } from './types';
+import type { SolidRdfEngine } from './SolidRdfEngine';
+export type RdfBenchmarkScale = 'small' | 'medium' | 'large';
+export declare const RDF_MODELS_SYNTHETIC_MESSAGE_QUADS = 4;
+export interface RdfModelBenchmarkCase {
+    name: string;
+    resource: string;
+    purpose: string;
+    minScale: RdfBenchmarkScale;
+    query: {
+        pattern: QuintPattern;
+        options?: QueryOptions;
+    };
+    expectedPlan: string[];
+}
+export interface RdfModelLocalQueryBenchmarkCase {
+    name: string;
+    resource: string;
+    purpose: string;
+    minScale: RdfBenchmarkScale;
+    query: RdfLocalQuery;
+    expectedPlan: string[];
+}
+export interface RdfModelBenchmarkRunOptions {
+    cases?: readonly RdfModelBenchmarkCase[];
+    localQueryCases?: readonly RdfModelLocalQueryBenchmarkCase[];
+    scale?: RdfBenchmarkScale;
+    iterations?: number;
+}
+export interface RdfModelBenchmarkResult {
+    name: string;
+    resource: string;
+    purpose: string;
+    minScale: RdfBenchmarkScale;
+    query: {
+        pattern: JsonPattern;
+        options?: QueryOptions;
+    };
+    expectedPlan: string[];
+    planMatched: boolean;
+    missingPlan: string[];
+    physicalPlan: string[];
+    scannedRows: number;
+    indexChoice: string;
+    joinOrder: string[];
+    fallbackReason: string | null;
+    returnedRows: number;
+    checksum: string;
+    orderedChecksum: string;
+    durationsMs: number[];
+    p50DurationMs: number;
+    p95DurationMs: number;
+    metrics: RdfIndexMetrics;
+    indexStats: RdfIndexStats;
+}
+export interface RdfModelLocalQueryBenchmarkResult {
+    name: string;
+    resource: string;
+    purpose: string;
+    minScale: RdfBenchmarkScale;
+    query: JsonPattern;
+    expectedPlan: string[];
+    planMatched: boolean;
+    missingPlan: string[];
+    physicalPlan: string[];
+    scannedRows: number;
+    indexChoices: string[];
+    fallbackReason: string | null;
+    returnedRows: number;
+    checksum: string;
+    orderedChecksum: string;
+    durationsMs: number[];
+    p50DurationMs: number;
+    p95DurationMs: number;
+    metrics: RdfLocalQueryMetrics;
+    indexStats: RdfIndexStats;
+}
+export interface RdfModelBenchmarkReport {
+    engine: 'solid-rdf';
+    scale: RdfBenchmarkScale;
+    iterations: number;
+    generatedAt: string;
+    planMatched: boolean;
+    failedPlanCases: string[];
+    cases: RdfModelBenchmarkResult[];
+    localQueryCases: RdfModelLocalQueryBenchmarkResult[];
+}
+export interface RdfModelShadowBenchmarkRunOptions extends RdfModelBenchmarkRunOptions {
+}
+export interface RdfModelShadowBenchmarkSide {
+    returnedRows: number;
+    checksum: string;
+    orderedChecksum: string;
+    durationsMs: number[];
+    p50DurationMs: number;
+    p95DurationMs: number;
+    storeStats?: StoreStats;
+}
+export interface RdfModelShadowPerformanceComparison {
+    p95DeltaMs: number;
+    p95Ratio: number;
+    matched: boolean;
+}
+export interface RdfModelShadowSpaceComparison {
+    databaseDeltaBytes: number;
+    tableDeltaBytes: number;
+    indexDeltaBytes: number;
+    databaseRatio: number;
+    tableRatio: number;
+    indexRatio: number;
+    matched: boolean;
+    unavailableReason?: string;
+}
+export interface RdfModelShadowBenchmarkResult {
+    name: string;
+    resource: string;
+    purpose: string;
+    minScale: RdfBenchmarkScale;
+    query: {
+        pattern: JsonPattern;
+        options?: QueryOptions;
+    };
+    expectedPlan: string[];
+    planMatched: boolean;
+    missingPlan: string[];
+    matched: boolean;
+    orderedMatch: boolean;
+    diff: RdfShadowDiff;
+    compatibility: RdfModelShadowBenchmarkSide;
+    solidRdf: RdfModelShadowBenchmarkSide & {
+        physicalPlan: string[];
+        scannedRows: number;
+        indexChoice: string;
+        joinOrder: string[];
+        fallbackReason: string | null;
+        metrics: RdfIndexMetrics;
+        indexStats: RdfIndexStats;
+    };
+    performance: RdfModelShadowPerformanceComparison;
+    space: RdfModelShadowSpaceComparison;
+}
+export interface RdfModelShadowBenchmarkReport {
+    engine: 'shadow';
+    compatibilityEngine: 'quint-store';
+    candidateEngine: 'solid-rdf';
+    scale: RdfBenchmarkScale;
+    iterations: number;
+    generatedAt: string;
+    matched: boolean;
+    orderedMatched: boolean;
+    planMatched: boolean;
+    spaceGateEnforced: boolean;
+    performanceMatched: boolean;
+    spaceMatched: boolean;
+    failedPlanCases: string[];
+    failedPerformanceCases: string[];
+    failedSpaceCases: string[];
+    cases: RdfModelShadowBenchmarkResult[];
+}
+export interface RdfModelRdf3xShadowBenchmarkResult {
+    name: string;
+    resource: string;
+    purpose: string;
+    minScale: RdfBenchmarkScale;
+    query: {
+        pattern: JsonPattern;
+        options?: QueryOptions;
+    };
+    supported: boolean;
+    unsupportedReason?: string;
+    matched: boolean;
+    orderedMatch: boolean;
+    diff: RdfShadowDiff;
+    solidRdf: RdfModelShadowBenchmarkSide & {
+        physicalPlan: string[];
+        scannedRows: number;
+        indexChoice: string;
+        joinOrder: string[];
+        fallbackReason: string | null;
+        metrics: RdfIndexMetrics;
+        indexStats: RdfIndexStats;
+    };
+    rdf3x?: RdfModelShadowBenchmarkSide & {
+        physicalPlan: string[];
+        scannedRows: number;
+        indexChoice: string;
+        joinOrder: string[];
+        fallbackReason: string | null;
+        metrics: Rdf3xIndexMetrics;
+        indexStats: Rdf3xIndexStats;
+    };
+}
+export interface RdfModelRdf3xShadowJoinBenchmarkResult {
+    name: string;
+    resource: string;
+    purpose: string;
+    minScale: RdfBenchmarkScale;
+    query: JsonPattern;
+    supported: boolean;
+    unsupportedReason?: string;
+    matched: boolean;
+    orderedMatch: boolean;
+    diff: RdfShadowDiff;
+    solidRdf: RdfModelShadowBenchmarkSide & {
+        physicalPlan: string[];
+        scannedRows: number;
+        indexChoice: string;
+        joinOrder: string[];
+        fallbackReason: string | null;
+        metrics: RdfIndexMetrics;
+        indexStats: RdfIndexStats;
+    };
+    rdf3x?: RdfModelShadowBenchmarkSide & {
+        physicalPlan: string[];
+        scannedRows: number;
+        indexChoice: string;
+        joinOrder: string[];
+        fallbackReason: string | null;
+        metrics: Rdf3xJoinMetrics;
+        indexStats: Rdf3xIndexStats;
+    };
+}
+export interface RdfModelRdf3xShadowBenchmarkReport {
+    engine: 'rdf3x-shadow';
+    primaryEngine: 'solid-rdf';
+    candidateEngine: 'solid-rdf3x';
+    scale: RdfBenchmarkScale;
+    iterations: number;
+    generatedAt: string;
+    matched: boolean;
+    orderedMatched: boolean;
+    skippedCases: string[];
+    skippedJoinCases: string[];
+    failedCases: string[];
+    failedJoinCases: string[];
+    rebuild: {
+        scannedQuads: number;
+        uniqueTriples: number;
+        memberships: number;
+        projectionRows: number;
+        durationMs: number;
+    };
+    cases: RdfModelRdf3xShadowBenchmarkResult[];
+    joinCases: RdfModelRdf3xShadowJoinBenchmarkResult[];
+}
+type JsonPattern = Record<string, unknown>;
+export declare const rdfModelsBenchmarkCases: readonly RdfModelBenchmarkCase[];
+export declare const rdfModelsLocalQueryBenchmarkCases: readonly RdfModelLocalQueryBenchmarkCase[];
+export declare function rdfModelsBenchmarkCaseNames(): string[];
+export declare function rdfModelsLocalQueryBenchmarkCaseNames(): string[];
+export declare function rdfModelsBenchmarkScaleTargetQuads(scale: RdfBenchmarkScale): number;
+export declare function rdfModelsBenchmarkSyntheticPodCount(scale: RdfBenchmarkScale): number;
+export declare function estimateRdfModelsSyntheticQuadCount(syntheticMessages: number): number;
+export declare function defaultSyntheticMessagesForRdfModelsScale(scale: RdfBenchmarkScale): number;
+export declare function rdfModelsBenchmarkScaleSatisfied(scale: RdfBenchmarkScale, seedQuadCount: number): boolean;
+export declare function runRdfModelsBenchmark(engine: SolidRdfEngine, options?: RdfModelBenchmarkRunOptions): RdfModelBenchmarkReport;
+export declare function runRdfModelsShadowBenchmark(engine: SolidRdfEngine, compatibilityStore: QuintStore, options?: RdfModelShadowBenchmarkRunOptions): Promise<RdfModelShadowBenchmarkReport>;
+export declare function runRdfModelsRdf3xShadowBenchmark(engine: SolidRdfEngine, options?: RdfModelBenchmarkRunOptions): RdfModelRdf3xShadowBenchmarkReport;
+export {};