@lde/pipeline-void 0.31.3 → 0.31.4

package/README.md

@@ -10,14 +10,15 @@ Returns all VoID stages in their recommended execution order. The ordering is op
 
 Accepts an optional `VoidStagesOptions` object:
 
-| Option           | Default | Description                                                                                                     |
-| ---------------- | ------- | --------------------------------------------------------------------------------------------------------------- |
-| `batchSize`      | 10      | Maximum class bindings per reader call (per-class stages only)                                                  |
-| `maxConcurrency` | 10      | Maximum concurrent in-flight reader batches (per-class stages only)                                             |
-| `perClass`       | —       | Override per-class iteration for all five per-class stages                                                      |
-| `uriSpaces`      | —       | When provided, includes the object URI space stage                                                              |
-| `vocabularies`   | —       | Additional vocabulary namespace URIs to detect beyond the built-in defaults                                     |
-| `transforms`     | —       | Transforms to attach to bundled stages, keyed by `VOID_STAGE_NAMES` (see [Stage transforms](#stage-transforms)) |
+| Option             | Default | Description                                                                                                     |
+| ------------------ | ------- | --------------------------------------------------------------------------------------------------------------- |
+| `batchSize`        | 10      | Maximum class bindings per reader call (per-class stages only)                                                  |
+| `maxConcurrency`   | 10      | Maximum concurrent in-flight reader batches (per-class stages only)                                             |
+| `perClass`         | —       | Override per-class iteration for all five per-class stages                                                      |
+| `uriSpaces`        | —       | When provided, includes the object URI space stage                                                              |
+| `vocabularies`     | —       | Additional vocabulary namespace URIs to detect beyond the built-in defaults                                     |
+| `transforms`       | —       | Transforms to attach to bundled stages, keyed by `VOID_STAGE_NAMES` (see [Stage transforms](#stage-transforms)) |
+| `namespaceAliases` | —       | Namespace pairs to treat as equivalent when partitioning (see [Namespace aliases](#namespace-aliases))          |
 
 Per-request timeouts are configured at the `Pipeline` level via `PipelineOptions.timeout`, not per VoID stage.
 
@@ -72,6 +73,29 @@ Global and domain-specific factories accept `VoidStageOptions` (`transform`) and
 | `detectVocabularies()`   | [`entity-properties.rq`](queries/entity-properties.rq) — Entity properties with automatic `void:vocabulary` detection. Accepts `DetectVocabulariesOptions` with an optional `vocabularies` array to extend the built-in defaults. |
 | `uriSpaces(uriSpaceMap)` | [`object-uri-space.rq`](queries/object-uri-space.rq) — Object URI namespace linksets, aggregated against a provided URI space map                                                                                                 |
 
+## Namespace aliases
+
+Some vocabularies publish under both HTTP and HTTPS variants of the same namespace (notably schema.org), and datasets mix them. Without normalization, each variant gets its own `void:classPartition`/`void:propertyPartition`, so consumers see two partitions for what is semantically one class.
+
+Pass `namespaceAliases` to merge the variants into one partition per canonical class/property:
+
+```typescript
+const stages = await voidStages({
+  namespaceAliases: [
+    { canonical: 'https://schema.org/', alias: 'http://schema.org/' },
+  ],
+});
+```
+
+Merging happens **after** aggregation, in a single partition-merge transform (`mergeNamespaceVariants`) attached to the class and property partition stages: it re-mints each partition IRI from its canonical key components, collapses the duplicates, and sums `void:entities` / `void:triples`. The analysis queries stay plain — except `class-properties-objects.rq`, which normalizes at query time because its `void:distinctObjects` is a distinct-count over object values that overlap across variants and so cannot be recovered by summing. See [ADR 7](../../docs/decisions/0007-merge-namespace-alias-partitions.md).
+
+Summing pre-aggregated counts is exact only under two assumptions, both of which hold for the schema.org datasets that motivate this (the variants appear as disjoint subsets):
+
+- **Subject/class disjointness** — no resource is typed under both namespace variants of a class (guards the class-partition and triple-count sums).
+- **Predicate-namespace disjointness** — no subject uses both variants of the same property (guards the property-partition entity sum).
+
+A resource typed under both variants over-counts its class entities. With no aliases configured the transform is a no-op. The top-level property partitions from `entity-properties.rq` and `void:vocabulary` detection keep the source namespaces, so consumers can still see which namespace the dataset actually uses.
+
 ## Stage transforms
 
 A VoID stage decorates its reader’s output with a `QuadTransform<ReaderContext>` attached as data (see [@lde/pipeline](../pipeline)’s extension model and [ADR 2](../../docs/decisions/0002-unify-pipeline-extension-on-quad-transforms.md)). It runs once per reader call and may fire its own SPARQL queries against the `distribution` in scope — so write it to accept being called more than once: a global stage calls it once over the complete output, a per-class stage with batching enabled once per batch (one class at `batchSize: 1`).

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { Stage, NotSupported } from '@lde/pipeline';
-export type { AttachedReader, ReaderContext, QuadTransform, } from '@lde/pipeline';
+export type { AttachedReader, NamespaceAlias, ReaderContext, QuadTransform, } from '@lde/pipeline';
 export * from './stage.js';
+export * from './namespaceAliases.js';
+export * from './partitionMerge.js';
 export * from './vocabularyTransform.js';
 export * from './uriSpaceTransform.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACpD,YAAY,EACV,cAAc,EACd,aAAa,EACb,aAAa,GACd,MAAM,eAAe,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACpD,YAAY,EACV,cAAc,EACd,cAAc,EACd,aAAa,EACb,aAAa,GACd,MAAM,eAAe,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -1,4 +1,6 @@
 export { Stage, NotSupported } from '@lde/pipeline';
 export * from './stage.js';
+export * from './namespaceAliases.js';
+export * from './partitionMerge.js';
 export * from './vocabularyTransform.js';
 export * from './uriSpaceTransform.js';

package/dist/namespaceAliases.d.ts

@@ -0,0 +1,23 @@
+import { type NamespaceAlias, type Reader, type VariableBindings } from '@lde/pipeline';
+/**
+ * Replace every {@link NORMALIZATION_MARKER} in a query template with the
+ * normalization expression for its raw variable.
+ */
+export declare function substituteNormalizationMarkers(query: string, namespaceAliases: readonly NamespaceAlias[]): string;
+/**
+ * Canonicalize and deduplicate the `?class` bindings a class selector
+ * yields, so every namespace-alias variant of a class becomes one item and
+ * its variants are queried together in one batch (split across batches,
+ * each batch would emit its own partial counts for the same partition IRI).
+ */
+export declare function canonicalizeClassBindings(rows: AsyncIterable<VariableBindings>, namespaceAliases: readonly NamespaceAlias[]): AsyncIterable<VariableBindings>;
+/**
+ * Decorate a {@link Reader} so each canonical `?class` binding is expanded to
+ * one `?class` binding per namespace-alias variant. The per-class VoID queries
+ * match `?s a ?class`, so this makes them pick up instances typed under either
+ * namespace; the partition-merge transform then collapses the variants. The
+ * expansion happens within one executor call, so the variants of a class are
+ * co-located in a single batch — a prerequisite for the per-stage merge.
+ */
+export declare function withAliasVariantBindings(inner: Reader, namespaceAliases: readonly NamespaceAlias[]): Reader;
+//# sourceMappingURL=namespaceAliases.d.ts.map

package/dist/namespaceAliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespaceAliases.d.ts","sourceRoot":"","sources":["../src/namespaceAliases.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,MAAM,EACX,KAAK,gBAAgB,EACtB,MAAM,eAAe,CAAC;AAcvB;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,EACb,gBAAgB,EAAE,SAAS,cAAc,EAAE,GAC1C,MAAM,CAIR;AAED;;;;;GAKG;AACH,wBAAuB,yBAAyB,CAC9C,IAAI,EAAE,aAAa,CAAC,gBAAgB,CAAC,EACrC,gBAAgB,EAAE,SAAS,cAAc,EAAE,GAC1C,aAAa,CAAC,gBAAgB,CAAC,CAQjC;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,gBAAgB,EAAE,SAAS,cAAc,EAAE,GAC1C,MAAM,CAWR"}

package/dist/namespaceAliases.js

@@ -0,0 +1,77 @@
+import { aliasVariants, canonicalizeIri, } from '@lde/pipeline';
+import { assertSafeIri } from '@lde/dataset';
+import { DataFactory } from 'n3';
+const { namedNode } = DataFactory;
+/**
+ * Marker in a VoID query template that expands to a SPARQL expression
+ * normalizing the named raw variable to its canonical namespace, e.g.
+ * `BIND(#normalized:rawClass# AS ?class)`. With no aliases configured the
+ * marker expands to the raw variable itself.
+ */
+const NORMALIZATION_MARKER = /#normalized:([A-Za-z][A-Za-z0-9]*)#/g;
+/**
+ * Replace every {@link NORMALIZATION_MARKER} in a query template with the
+ * normalization expression for its raw variable.
+ */
+export function substituteNormalizationMarkers(query, namespaceAliases) {
+    return query.replace(NORMALIZATION_MARKER, (_match, rawVariable) => normalizedExpression(rawVariable, namespaceAliases));
+}
+/**
+ * Canonicalize and deduplicate the `?class` bindings a class selector
+ * yields, so every namespace-alias variant of a class becomes one item and
+ * its variants are queried together in one batch (split across batches,
+ * each batch would emit its own partial counts for the same partition IRI).
+ */
+export async function* canonicalizeClassBindings(rows, namespaceAliases) {
+    const seen = new Set();
+    for await (const row of rows) {
+        const canonical = canonicalizeIri(row.class.value, namespaceAliases);
+        if (seen.has(canonical))
+            continue;
+        seen.add(canonical);
+        yield { class: namedNode(canonical) };
+    }
+}
+/**
+ * Decorate a {@link Reader} so each canonical `?class` binding is expanded to
+ * one `?class` binding per namespace-alias variant. The per-class VoID queries
+ * match `?s a ?class`, so this makes them pick up instances typed under either
+ * namespace; the partition-merge transform then collapses the variants. The
+ * expansion happens within one executor call, so the variants of a class are
+ * co-located in a single batch — a prerequisite for the per-stage merge.
+ */
+export function withAliasVariantBindings(inner, namespaceAliases) {
+    return {
+        read(dataset, distribution, options) {
+            const bindings = options?.bindings?.flatMap((row) => aliasVariants(row.class.value, namespaceAliases).map((iri) => ({
+                class: namedNode(iri),
+            })));
+            return inner.read(dataset, distribution, { ...options, bindings });
+        },
+    };
+}
+/**
+ * SPARQL expression rewriting `?rawVariable` from any alias namespace to its
+ * canonical namespace: nested `IF(STRSTARTS(...), IRI(CONCAT(...)), ...)`
+ * per alias, or the bare variable when no aliases are configured.
+ */
+function normalizedExpression(rawVariable, namespaceAliases) {
+    let expression = `?${rawVariable}`;
+    // Build from the inside out so the first alias is the outermost check.
+    for (const { canonical, alias } of [...namespaceAliases].reverse()) {
+        assertSafeSparqlString(canonical);
+        assertSafeSparqlString(alias);
+        expression = `IF(STRSTARTS(STR(?${rawVariable}), "${alias}"), IRI(CONCAT("${canonical}", STRAFTER(STR(?${rawVariable}), "${alias}"))), ${expression})`;
+    }
+    return expression;
+}
+/**
+ * Namespaces are interpolated into double-quoted SPARQL string literals, so
+ * beyond {@link assertSafeIri} they must not contain quotes or backslashes.
+ */
+function assertSafeSparqlString(namespace) {
+    assertSafeIri(namespace);
+    if (namespace.includes('"') || namespace.includes('\\')) {
+        throw new Error(`Namespace contains unsafe characters and cannot be interpolated into SPARQL: ${namespace}`);
+    }
+}

package/dist/partitionMerge.d.ts

@@ -0,0 +1,37 @@
+import { type NamespaceAlias, type QuadTransform, type ReaderContext } from '@lde/pipeline';
+/**
+ * A {@link QuadTransform} that merges the `void:classPartition` /
+ * `void:propertyPartition` subtrees of namespace-alias variants (e.g.
+ * `http://schema.org/CreativeWork` and `https://schema.org/CreativeWork`) into
+ * a single partition per canonical class/property.
+ *
+ * VoID partitions are keyed by an opaque `MD5(class[, property[, …]])` IRI, so
+ * two namespace variants yield two partition nodes that both, after
+ * canonicalization, describe the same class. This transform re-mints every
+ * partition IRI from its **canonical** key components (replicating the queries’
+ * SPARQL `MD5(CONCAT(STR(…)))`), collapses the duplicates, and **sums** their
+ * numeric measures (`void:entities`, `void:triples`).
+ *
+ * ## Correctness assumptions
+ *
+ * Summing pre-aggregated counts is exact only under these assumptions; the
+ * queries whose measures cannot be safely summed keep their normalization at
+ * query time instead (notably `class-properties-objects.rq`’s
+ * `void:distinctObjects`, which this transform never sees):
+ *
+ * - **Subject/class disjointness** — no resource is typed under two namespace
+ *   variants of the same class. Guards the `void:entities` sum on class
+ *   partitions and every `void:triples` sum (a doubly-typed resource’s triples
+ *   would otherwise count under both variants).
+ * - **Predicate-namespace disjointness** — no subject uses two namespace
+ *   variants of the same property (e.g. both `http://schema.org/name` and
+ *   `https://schema.org/name`). Guards the `void:entities` sum on property
+ *   partitions.
+ *
+ * With no aliases configured the transform is a no-op.
+ *
+ * @see substituteNormalizationMarkers for the query-time normalization used
+ *   where summing is not safe.
+ */
+export declare function mergeNamespaceVariants(namespaceAliases: readonly NamespaceAlias[]): QuadTransform<ReaderContext>;
+//# sourceMappingURL=partitionMerge.d.ts.map

package/dist/partitionMerge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionMerge.d.ts","sourceRoot":"","sources":["../src/partitionMerge.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,aAAa,EACnB,MAAM,eAAe,CAAC;AAyCvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,SAAS,cAAc,EAAE,GAC1C,aAAa,CAAC,aAAa,CAAC,CAY9B"}

package/dist/partitionMerge.js

@@ -0,0 +1,275 @@
+import { canonicalizeIri, } from '@lde/pipeline';
+import { DataFactory } from 'n3';
+import { createHash } from 'node:crypto';
+const { namedNode, literal, quad } = DataFactory;
+const VOID = 'http://rdfs.org/ns/void#';
+const VOID_EXT = 'http://ldf.fi/void-ext#';
+const XSD_INTEGER = 'http://www.w3.org/2001/XMLSchema#integer';
+const VOID_CLASS = `${VOID}class`;
+const VOID_PROPERTY = `${VOID}property`;
+const VOID_ENTITIES = `${VOID}entities`;
+const VOID_TRIPLES = `${VOID}triples`;
+const VOID_CLASS_PARTITION = `${VOID}classPartition`;
+const VOID_PROPERTY_PARTITION = `${VOID}propertyPartition`;
+const VOIDEXT_DATATYPE = `${VOID_EXT}datatype`;
+const VOIDEXT_LANGUAGE = `${VOID_EXT}language`;
+const VOIDEXT_DATATYPE_PARTITION = `${VOID_EXT}datatypePartition`;
+const VOIDEXT_OBJECTCLASS_PARTITION = `${VOID_EXT}objectClassPartition`;
+const VOIDEXT_LANGUAGE_PARTITION = `${VOID_EXT}languagePartition`;
+// Predicates whose integer-literal objects are summed across merged partitions.
+// `void:distinctObjects` is deliberately excluded: distinct-object sets overlap
+// across namespace variants, so summing would over-count. It is normalized at
+// query time in `class-properties-objects.rq` and never reaches this transform.
+const NUMERIC_MEASURES = new Set([VOID_ENTITIES, VOID_TRIPLES]);
+/** Structural links whose object is a child partition node. */
+const CHILD_LINKS = new Set([
+    VOID_CLASS_PARTITION,
+    VOID_PROPERTY_PARTITION,
+    VOIDEXT_DATATYPE_PARTITION,
+    VOIDEXT_OBJECTCLASS_PARTITION,
+    VOIDEXT_LANGUAGE_PARTITION,
+]);
+/** `void:class` / `void:property` objects are IRIs subject to canonicalization. */
+const CANONICALIZED_OBJECT_PREDICATES = new Set([VOID_CLASS, VOID_PROPERTY]);
+/**
+ * A {@link QuadTransform} that merges the `void:classPartition` /
+ * `void:propertyPartition` subtrees of namespace-alias variants (e.g.
+ * `http://schema.org/CreativeWork` and `https://schema.org/CreativeWork`) into
+ * a single partition per canonical class/property.
+ *
+ * VoID partitions are keyed by an opaque `MD5(class[, property[, …]])` IRI, so
+ * two namespace variants yield two partition nodes that both, after
+ * canonicalization, describe the same class. This transform re-mints every
+ * partition IRI from its **canonical** key components (replicating the queries’
+ * SPARQL `MD5(CONCAT(STR(…)))`), collapses the duplicates, and **sums** their
+ * numeric measures (`void:entities`, `void:triples`).
+ *
+ * ## Correctness assumptions
+ *
+ * Summing pre-aggregated counts is exact only under these assumptions; the
+ * queries whose measures cannot be safely summed keep their normalization at
+ * query time instead (notably `class-properties-objects.rq`’s
+ * `void:distinctObjects`, which this transform never sees):
+ *
+ * - **Subject/class disjointness** — no resource is typed under two namespace
+ *   variants of the same class. Guards the `void:entities` sum on class
+ *   partitions and every `void:triples` sum (a doubly-typed resource’s triples
+ *   would otherwise count under both variants).
+ * - **Predicate-namespace disjointness** — no subject uses two namespace
+ *   variants of the same property (e.g. both `http://schema.org/name` and
+ *   `https://schema.org/name`). Guards the `void:entities` sum on property
+ *   partitions.
+ *
+ * With no aliases configured the transform is a no-op.
+ *
+ * @see substituteNormalizationMarkers for the query-time normalization used
+ *   where summing is not safe.
+ */
+export function mergeNamespaceVariants(namespaceAliases) {
+    if (namespaceAliases.length === 0) {
+        return (quads) => quads;
+    }
+    return async function* (quads, { dataset }) {
+        const datasetIri = dataset.iri.toString();
+        const buffered = [];
+        for await (const q of quads) {
+            buffered.push(q);
+        }
+        yield* mergeBuffered(buffered, datasetIri, namespaceAliases);
+    };
+}
+function* mergeBuffered(buffered, datasetIri, namespaceAliases) {
+    const nodes = indexNodes(buffered);
+    const remap = buildRemap(nodes, datasetIri, namespaceAliases);
+    const measureSums = new Map();
+    const emitted = new Set();
+    const structural = [];
+    for (const original of buffered) {
+        const subject = remapTerm(original.subject, remap);
+        const object = canonicalizeObject(remapTerm(original.object, remap), original.predicate.value, namespaceAliases);
+        const rewritten = quad(subject, original.predicate, object, original.graph);
+        if (NUMERIC_MEASURES.has(original.predicate.value)) {
+            accumulateMeasure(measureSums, rewritten);
+            continue;
+        }
+        const key = quadKey(rewritten);
+        if (!emitted.has(key)) {
+            emitted.add(key);
+            structural.push(rewritten);
+        }
+    }
+    yield* structural;
+    for (const sum of measureSums.values()) {
+        yield reconstructMeasure(sum);
+    }
+}
+function indexNodes(buffered) {
+    const nodes = new Map();
+    const nodeOf = (value) => {
+        let node = nodes.get(value);
+        if (!node) {
+            node = { values: new Map() };
+            nodes.set(value, node);
+        }
+        return node;
+    };
+    for (const q of buffered) {
+        if (CHILD_LINKS.has(q.predicate.value) &&
+            q.object.termType === 'NamedNode') {
+            nodeOf(q.object.value).incomingLink = {
+                predicate: q.predicate.value,
+                parent: q.subject.value,
+            };
+        }
+        else {
+            nodeOf(q.subject.value).values.set(q.predicate.value, q.object);
+        }
+    }
+    return nodes;
+}
+/**
+ * Build a raw-IRI → canonical-IRI map for every partition node whose canonical
+ * key differs from its current IRI.
+ */
+function buildRemap(nodes, datasetIri, namespaceAliases) {
+    const remap = new Map();
+    for (const [iri, node] of nodes) {
+        const canonicalIri = canonicalPartitionIri(node, nodes, datasetIri, namespaceAliases);
+        if (canonicalIri !== undefined && canonicalIri !== iri) {
+            remap.set(iri, canonicalIri);
+        }
+    }
+    return remap;
+}
+/**
+ * The canonical partition IRI for a node, or `undefined` if the node is not a
+ * partition (no incoming structural link). Replicates the queries’ minting:
+ * `<dataset>/.well-known/void#<prefix>-<MD5(STR(component)…)>`.
+ */
+function canonicalPartitionIri(node, nodes, datasetIri, namespaceAliases) {
+    const link = node.incomingLink;
+    if (link === undefined)
+        return undefined;
+    const canon = (value) => canonicalizeIri(value, namespaceAliases);
+    const classOf = (partition) => nodes.get(partition)?.values.get(VOID_CLASS)?.value;
+    switch (link.predicate) {
+        case VOID_CLASS_PARTITION: {
+            const klass = node.values.get(VOID_CLASS)?.value;
+            return klass ? mint(datasetIri, 'class', [canon(klass)]) : undefined;
+        }
+        case VOID_PROPERTY_PARTITION: {
+            const klass = classOf(link.parent);
+            const property = node.values.get(VOID_PROPERTY)?.value;
+            return klass && property
+                ? mint(datasetIri, 'class-property', [canon(klass), canon(property)])
+                : undefined;
+        }
+        case VOIDEXT_DATATYPE_PARTITION: {
+            const [klass, property] = classProperty(link.parent, nodes);
+            const datatype = node.values.get(VOIDEXT_DATATYPE)?.value;
+            return klass && property && datatype
+                ? mint(datasetIri, 'datatype', [
+                    canon(klass),
+                    canon(property),
+                    datatype,
+                ])
+                : undefined;
+        }
+        case VOIDEXT_OBJECTCLASS_PARTITION: {
+            const [klass, property] = classProperty(link.parent, nodes);
+            const objectClass = node.values.get(VOID_CLASS)?.value;
+            return klass && property && objectClass
+                ? mint(datasetIri, 'object-class', [
+                    canon(klass),
+                    canon(property),
+                    canon(objectClass),
+                ])
+                : undefined;
+        }
+        case VOIDEXT_LANGUAGE_PARTITION: {
+            const [klass, property] = classProperty(link.parent, nodes);
+            const language = node.values.get(VOIDEXT_LANGUAGE)?.value;
+            return klass && property && language !== undefined
+                ? mint(datasetIri, 'language', [
+                    canon(klass),
+                    canon(property),
+                    language,
+                ])
+                : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+/** The (class, property) of a property partition, following it up to its class partition. */
+function classProperty(propertyPartition, nodes) {
+    const node = nodes.get(propertyPartition);
+    const property = node?.values.get(VOID_PROPERTY)?.value;
+    const classPartition = node?.incomingLink?.parent;
+    const klass = classPartition
+        ? nodes.get(classPartition)?.values.get(VOID_CLASS)?.value
+        : undefined;
+    return [klass, property];
+}
+function mint(datasetIri, prefix, components) {
+    const hash = createHash('md5').update(components.join('')).digest('hex');
+    return `${datasetIri}/.well-known/void#${prefix}-${hash}`;
+}
+function remapTerm(term, remap) {
+    if (term.termType === 'NamedNode') {
+        const canonical = remap.get(term.value);
+        if (canonical !== undefined)
+            return namedNode(canonical);
+    }
+    return term;
+}
+function canonicalizeObject(object, predicate, namespaceAliases) {
+    if (CANONICALIZED_OBJECT_PREDICATES.has(predicate) &&
+        object.termType === 'NamedNode') {
+        const canonical = canonicalizeIri(object.value, namespaceAliases);
+        if (canonical !== object.value)
+            return namedNode(canonical);
+    }
+    return object;
+}
+function accumulateMeasure(sums, measure) {
+    const key = `${measure.subject.value} ${measure.predicate.value} ${measure.graph.value}`;
+    const existing = sums.get(key);
+    if (existing === undefined) {
+        sums.set(key, {
+            subject: measure.subject,
+            predicate: measure.predicate,
+            graph: measure.graph,
+            datatype: measure.object.termType === 'Literal'
+                ? measure.object.datatype.value
+                : XSD_INTEGER,
+            total: parseInteger(measure.object),
+        });
+    }
+    else {
+        existing.total += parseInteger(measure.object);
+    }
+}
+function parseInteger(object) {
+    if (object.termType === 'Literal' && /^[+-]?\d+$/.test(object.value)) {
+        return BigInt(object.value);
+    }
+    return 0n;
+}
+function reconstructMeasure(sum) {
+    return quad(sum.subject, sum.predicate, literal(sum.total.toString(), namedNode(sum.datatype)), sum.graph);
+}
+function quadKey(q) {
+    return [
+        q.subject.value,
+        q.predicate.value,
+        termKey(q.object),
+        q.graph.value,
+    ].join(' ');
+}
+function termKey(term) {
+    if (term.termType === 'Literal') {
+        return `"${term.value}"^^${term.datatype.value}@${term.language}`;
+    }
+    return term.value;
+}

package/dist/stage.d.ts

@@ -1,4 +1,4 @@
-import { Stage, type ReaderContext, type QuadTransform } from '@lde/pipeline';
+import { Stage, type ReaderContext, type NamespaceAlias, type QuadTransform } from '@lde/pipeline';
 import type { Quad } from '@rdfjs/types';
 /**
  * Stable names for every VoID stage, equal to the underlying query filename.
@@ -46,6 +46,27 @@ export interface VoidStageOptions {
      * with these, built-in first.
      */
     transform?: VoidStageTransform;
+    /**
+     * Namespace pairs to treat as equivalent when partitioning by class and
+     * property, so alias variants (e.g. `http://schema.org/CreativeWork` and
+     * `https://schema.org/CreativeWork`) merge into a single partition instead
+     * of two that both claim the canonical `void:class`.
+     *
+     * Merging happens after aggregation, in the {@link mergeNamespaceVariants}
+     * transform, which sums `void:entities` / `void:triples`; only
+     * `class-properties-objects.rq` normalizes at query time (its
+     * `void:distinctObjects` cannot be recovered by summing). Correct under the
+     * subject/class- and predicate-namespace-disjointness assumptions documented
+     * on {@link mergeNamespaceVariants}. The top-level property partitions
+     * ({@link detectVocabularies}’s `entity-properties.rq`) and `void:vocabulary`
+     * detection keep the source namespaces, so consumers can still see which
+     * namespace the dataset actually uses.
+     *
+     * Defaults to no aliases. To cover schema.org datasets that publish under
+     * both `http://schema.org/` and `https://schema.org/`, pass
+     * `[{ canonical: 'https://schema.org/', alias: 'http://schema.org/' }]`.
+     */
+    namespaceAliases?: readonly NamespaceAlias[];
 }
 /**
  * Options for per-class VoID stages that iterate over classes.

package/dist/stage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../src/stage.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../src/stage.ts"],"names":[],"mappings":"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"}

package/dist/stage.js

@@ -4,6 +4,8 @@ import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { withVocabularies, defaultVocabularies, } from './vocabularyTransform.js';
 import { withUriSpaces } from './uriSpaceTransform.js';
+import { canonicalizeClassBindings, substituteNormalizationMarkers, withAliasVariantBindings, } from './namespaceAliases.js';
+import { mergeNamespaceVariants } from './partitionMerge.js';
 const queriesDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'queries');
 /**
  * Stable names for every VoID stage, equal to the underlying query filename.
@@ -31,15 +33,30 @@ export const VOID_STAGE_NAMES = {
     objectUriSpace: 'object-uri-space.rq',
 };
 async function createVoidStage(filename, options) {
-    const query = await readQueryFile(resolve(queriesDir, filename));
+    const namespaceAliases = options?.namespaceAliases ?? [];
+    const query = substituteNormalizationMarkers(await readQueryFile(resolve(queriesDir, filename)), namespaceAliases);
+    const constructReader = new SparqlConstructReader({ query });
+    // Partition stages merge their namespace-alias variants (e.g. http:// and
+    // https://schema.org/) into one partition per canonical class/property.
+    // Runs first, so any consumer transform sees the already-merged output.
+    const mergeTransform = options?.mergePartitions && namespaceAliases.length > 0
+        ? [mergeNamespaceVariants(namespaceAliases)]
+        : [];
     const reader = {
-        reader: new SparqlConstructReader({ query }),
-        transform: options?.transform,
+        // Per-class stages receive canonical `?class` bindings from the selector;
+        // expand each into one `?class` binding per alias variant so the query
+        // (`?s a ?class`) matches instances under either namespace.
+        reader: options?.perClass
+            ? withAliasVariantBindings(constructReader, namespaceAliases)
+            : constructReader,
+        transform: [...mergeTransform, ...asTransforms(options?.transform)],
     };
     return new Stage({
         name: filename,
         readers: reader,
-        itemSelector: options?.perClass ? classSelector() : undefined,
+        itemSelector: options?.perClass
+            ? classSelector(namespaceAliases)
+            : undefined,
         batchSize: options?.batchSize,
         maxConcurrency: options?.maxConcurrency,
         expectsOutput: options?.expectsOutput,
@@ -51,7 +68,7 @@ function asTransforms(transform) {
         return [];
     return Array.isArray(transform) ? [...transform] : [transform];
 }
-function classSelector() {
+function classSelector(namespaceAliases) {
     return {
         // Forward `options` so the Pipeline’s per-dataset TimeoutPolicy
         // reaches the inner SparqlItemSelector — without this the adaptive
@@ -69,9 +86,10 @@ function classSelector() {
                 `WHERE { ${subjectFilter} ?s a ?class . }`,
                 'LIMIT 1000',
             ].join('\n');
-            return new SparqlItemSelector({
+            const rows = new SparqlItemSelector({
                 query: selectorQuery,
             }).select(distribution, batchSize, options);
+            return canonicalizeClassBindings(rows, namespaceAliases);
         },
     };
 }
@@ -80,7 +98,10 @@ export function subjectUriSpaces(options) {
     return createVoidStage(VOID_STAGE_NAMES.subjectUriSpace, options);
 }
 export function classPartitions(options) {
-    return createVoidStage(VOID_STAGE_NAMES.classPartitions, options);
+    return createVoidStage(VOID_STAGE_NAMES.classPartitions, {
+        ...options,
+        mergePartitions: true,
+    });
 }
 // Scalar-aggregate counts: each query is a single COUNT with no GROUP BY/HAVING,
 // so it always returns exactly one row. Zero output therefore means the endpoint
@@ -120,6 +141,7 @@ export function classPropertySubjects(options) {
     return createVoidStage(VOID_STAGE_NAMES.classPropertySubjects, {
         ...options,
         perClass: options?.perClass ?? true,
+        mergePartitions: true,
     });
 }
 export function classPropertyObjects(options) {
@@ -142,18 +164,21 @@ export function perClassObjectClasses(options) {
     return createVoidStage(VOID_STAGE_NAMES.perClassObjectClasses, {
         ...options,
         perClass: options?.perClass ?? true,
+        mergePartitions: true,
     });
 }
 export function perClassDatatypes(options) {
     return createVoidStage(VOID_STAGE_NAMES.perClassDatatypes, {
         ...options,
         perClass: options?.perClass ?? true,
+        mergePartitions: true,
     });
 }
 export function perClassLanguages(options) {
     return createVoidStage(VOID_STAGE_NAMES.perClassLanguages, {
         ...options,
         perClass: options?.perClass ?? true,
+        mergePartitions: true,
     });
 }
 // Stages with a built-in transform

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/pipeline-void",
-  "version": "0.31.3",
+  "version": "0.31.4",
   "description": "VOiD (Vocabulary of Interlinked Datasets) statistical analysis for RDF datasets",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
@@ -34,6 +34,6 @@
   },
   "peerDependencies": {
     "@lde/dataset": "^0.7.8",
-    "@lde/pipeline": "^0.33.3"
+    "@lde/pipeline": "^0.33.4"
   }
 }

package/queries/class-properties-objects.rq

@@ -5,17 +5,27 @@ CONSTRUCT {
 }
 WHERE {
     # Object counts only. Subject counts in class-properties-subjects.rq.
+    #
+    # Unlike the other per-class queries, this one normalizes the class and
+    # property to their canonical namespace *before* the COUNT(DISTINCT ?o):
+    # merging distinct-object counts by summing would over-count objects shared
+    # between namespace variants (e.g. the same name under http:name and
+    # https:name), so the dedup must happen here rather than in the
+    # partition-merge transform. `?class` is bound per namespace variant by the
+    # injected VALUES clause; `?property` is discovered.
     {
-        SELECT ?class ?p (COUNT(DISTINCT ?o) AS ?objects) {
+        SELECT ?canonicalClass ?canonicalProperty (COUNT(DISTINCT ?o) AS ?objects) {
             {
-                SELECT ?class ?p ?o {
+                SELECT ?canonicalClass ?canonicalProperty ?o {
                     #subjectFilter#
-                    ?s a ?class ; ?p ?o .
+                    ?s a ?class ; ?property ?o .
+                    BIND(#normalized:class# AS ?canonicalClass)
+                    BIND(#normalized:property# AS ?canonicalProperty)
                 }
             }
         }
-        GROUP BY ?class ?p
+        GROUP BY ?canonicalClass ?canonicalProperty
     }
-    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?class), STR(?p))))) AS ?propertyPartition)
+    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?canonicalClass), STR(?canonicalProperty))))) AS ?propertyPartition)
 }
 LIMIT 100000

package/queries/class-property-datatypes.rq

@@ -2,7 +2,17 @@ PREFIX void: <http://rdfs.org/ns/void#>
 PREFIX void-ext: <http://ldf.fi/void-ext#>
 
 CONSTRUCT {
-  ?propertyPartition void-ext:datatypePartition ?datatypePartition .
+  # Self-describing parent chain so the namespace-merge transform can re-key
+  # this partition from its (class, property) components. The
+  # `?dataset void:classPartition ?classPartition` link is what gives the class
+  # partition an incoming edge, so the transform re-keys it too (without it, the
+  # alias-variant class partition leaks unmerged).
+  ?dataset a void:Dataset ;
+      void:classPartition ?classPartition .
+  ?classPartition void:class ?class ;
+      void:propertyPartition ?propertyPartition .
+  ?propertyPartition void:property ?p ;
+      void-ext:datatypePartition ?datatypePartition .
   ?datatypePartition
       void-ext:datatype ?dt ;
       void:triples ?count .
@@ -22,6 +32,7 @@ WHERE {
     }
     GROUP BY ?class ?p ?dt
   }
+  BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-", MD5(STR(?class)))) AS ?classPartition)
   BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?class), STR(?p))))) AS ?propertyPartition)
   BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#datatype-", MD5(CONCAT(STR(?class), STR(?p), STR(?dt))))) AS ?datatypePartition)
 }

package/queries/class-property-languages.rq

@@ -2,7 +2,17 @@ PREFIX void: <http://rdfs.org/ns/void#>
 PREFIX void-ext: <http://ldf.fi/void-ext#>
 
 CONSTRUCT {
-  ?propertyPartition void-ext:languagePartition ?languagePartition .
+  # Self-describing parent chain so the namespace-merge transform can re-key
+  # this partition from its (class, property) components. The
+  # `?dataset void:classPartition ?classPartition` link is what gives the class
+  # partition an incoming edge, so the transform re-keys it too (without it, the
+  # alias-variant class partition leaks unmerged).
+  ?dataset a void:Dataset ;
+      void:classPartition ?classPartition .
+  ?classPartition void:class ?class ;
+      void:propertyPartition ?propertyPartition .
+  ?propertyPartition void:property ?p ;
+      void-ext:languagePartition ?languagePartition .
   ?languagePartition
     void-ext:language ?lang ;
     void:triples ?count .
@@ -24,6 +34,7 @@ WHERE {
     }
     GROUP BY ?class ?p ?lang
   }
+  BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-", MD5(STR(?class)))) AS ?classPartition)
   BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?class), STR(?p))))) AS ?propertyPartition)
   BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#language-", MD5(CONCAT(STR(?class), STR(?p), ?lang)))) AS ?languagePartition)
 }

package/queries/class-property-object-classes.rq

@@ -2,7 +2,17 @@ PREFIX void: <http://rdfs.org/ns/void#>
 PREFIX void-ext: <http://ldf.fi/void-ext#>
 
 CONSTRUCT {
-  ?propertyPartition void-ext:objectClassPartition ?objectClassPartition .
+  # Self-describing parent chain so the namespace-merge transform can re-key
+  # this partition from its (class, property) components. The
+  # `?dataset void:classPartition ?classPartition` link is what gives the class
+  # partition an incoming edge, so the transform re-keys it too (without it, the
+  # alias-variant class partition leaks unmerged).
+  ?dataset a void:Dataset ;
+      void:classPartition ?classPartition .
+  ?classPartition void:class ?class ;
+      void:propertyPartition ?propertyPartition .
+  ?propertyPartition void:property ?p ;
+      void-ext:objectClassPartition ?objectClassPartition .
   ?objectClassPartition
       void:class ?objectClass ;
       void:triples ?count .
@@ -22,6 +32,7 @@ WHERE {
     }
     GROUP BY ?class ?p ?objectClass
   }
+  BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-", MD5(STR(?class)))) AS ?classPartition)
   BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?class), STR(?p))))) AS ?propertyPartition)
   BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#object-class-", MD5(CONCAT(STR(?class), STR(?p), STR(?objectClass))))) AS ?objectClassPartition)
 }