@lde/pipeline-void 0.31.4 → 0.32.0

package/README.md

@@ -10,15 +10,14 @@ 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)) |
-| `namespaceAliases` | —       | Namespace pairs to treat as equivalent when partitioning (see [Namespace aliases](#namespace-aliases))          |
+| 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)) |
 
 Per-request timeouts are configured at the `Pipeline` level via `PipelineOptions.timeout`, not per VoID stage.
 
@@ -73,28 +72,26 @@ 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
+## Namespace normalization
 
-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.
+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 one class — which crashed the Dataset Register browser (netwerk-digitaal-erfgoed/dataset-knowledge-graph#334).
 
-Pass `namespaceAliases` to merge the variants into one partition per canonical class/property:
+`schemaOrgPartitionMergePlugin` normalizes `http://schema.org/` to `https://schema.org/` **and** merges the duplicate partition nodes the two variants produced. It is a [`beforeDatasetWrite`](../pipeline) plugin — it runs once over a whole dataset’s output at the pipeline edge, so the analysis queries stay unaware of namespace aliases (see [ADR 7](../../docs/decisions/0007-namespace-merge-as-a-dataset-plugin.md)):
 
 ```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).
+import { voidStages, schemaOrgPartitionMergePlugin } from '@lde/pipeline-void';
+import { Pipeline, provenancePlugin } from '@lde/pipeline';
 
-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):
+await new Pipeline({
+  stages: await voidStages(), // plain, no namespace options
+  plugins: [schemaOrgPartitionMergePlugin(), provenancePlugin()],
+  // …
+}).run();
+```
 
-- **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).
+Use `namespacePartitionMergePlugin(aliases)` for namespaces other than schema.org. The transform streams — it buffers only partition quads (bounded by the summary), passing everything else straight through. Datasets typically use a single schema.org namespace, so within one dataset there is one variant per class and every count stays exact; a dataset that mixes both namespaces on one property has its `void:distinctObjects` summed (an over-count for shared objects) rather than deduped.
 
-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.
+> This plugin does more than rename IRIs: rewriting the `void:class` objects alone would still leave two `void:classPartition` nodes for one class. If you only need a blanket namespace rewrite over a dataset’s own quads (not a VoID partition merge) — for example when mapping instance data to an application profile — use the generic [`schemaOrgNormalizationPlugin` / `namespaceNormalizationPlugin`](../pipeline) from `@lde/pipeline` instead.
 
 ## Stage transforms
 

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export { Stage, NotSupported } 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 './partitionIri.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,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"}
+{"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,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}

package/dist/index.js

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

package/dist/partitionIri.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Each partition kind's IRI prefix and the ordered SPARQL string expressions
+ * whose MD5 hash keys it. The queries must bind the standard component
+ * variables (`?class`, `?p`, `?dt`, `?objectClass`, `?lang`).
+ */
+declare const PARTITION_KINDS: {
+    readonly class: readonly ["STR(?class)"];
+    readonly 'class-property': readonly ["STR(?class)", "STR(?p)"];
+    readonly datatype: readonly ["STR(?class)", "STR(?p)", "STR(?dt)"];
+    readonly 'object-class': readonly ["STR(?class)", "STR(?p)", "STR(?objectClass)"];
+    readonly language: readonly ["STR(?class)", "STR(?p)", "?lang"];
+};
+/** A VoID partition kind; also its IRI prefix. */
+export type PartitionKind = keyof typeof PARTITION_KINDS;
+/**
+ * Mint a partition IRI from its canonical component *string values* (the class
+ * IRI, property IRI, datatype IRI, or language tag — the `STR()` forms the
+ * SPARQL side concatenates). The TypeScript counterpart of the query minting.
+ */
+export declare function mintPartitionIri(datasetIri: string, kind: PartitionKind, components: readonly string[]): string;
+/**
+ * Replace every `#mint:<kind>#` marker in a query with the SPARQL value
+ * expression that mints that kind's partition IRI, e.g.
+ * `URI(CONCAT(STR(?dataset), "/.well-known/void#class-", MD5(STR(?class))))`.
+ */
+export declare function substituteMintMarkers(query: string): string;
+export {};
+//# sourceMappingURL=partitionIri.d.ts.map

package/dist/partitionIri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionIri.d.ts","sourceRoot":"","sources":["../src/partitionIri.ts"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,QAAA,MAAM,eAAe;;;;;;CAOX,CAAC;AAEX,kDAAkD;AAClD,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,eAAe,CAAC;AAEzD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,aAAa,EACnB,UAAU,EAAE,SAAS,MAAM,EAAE,GAC5B,MAAM,CAGR;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAY3D"}

package/dist/partitionIri.js

@@ -0,0 +1,56 @@
+import { createHash } from 'node:crypto';
+/**
+ * Single source of truth for the VoID partition-IRI scheme
+ * (`<dataset>/.well-known/void#<prefix>-<MD5(component…)>`), shared by two
+ * derivations that must agree byte-for-byte:
+ *
+ * - {@link mintPartitionIri} mints an IRI in TypeScript (used by the
+ *   partition-merge transform to re-key a partition to its canonical form);
+ * - {@link substituteMintMarkers} generates the equivalent SPARQL `BIND` value
+ *   expression, injected into the analysis queries in place of `#mint:<kind>#`.
+ *
+ * Because both come from {@link PARTITION_KINDS}, a change to the scheme (a
+ * prefix, a component, its order) updates the query minting and the TS minting
+ * together — they cannot silently diverge.
+ */
+/** The `/.well-known/void#` path under a dataset IRI where partitions live. */
+const WELL_KNOWN_VOID = '/.well-known/void#';
+/**
+ * Each partition kind's IRI prefix and the ordered SPARQL string expressions
+ * whose MD5 hash keys it. The queries must bind the standard component
+ * variables (`?class`, `?p`, `?dt`, `?objectClass`, `?lang`).
+ */
+const PARTITION_KINDS = {
+    class: ['STR(?class)'],
+    'class-property': ['STR(?class)', 'STR(?p)'],
+    datatype: ['STR(?class)', 'STR(?p)', 'STR(?dt)'],
+    'object-class': ['STR(?class)', 'STR(?p)', 'STR(?objectClass)'],
+    // ?lang is a plain string literal, so it is hashed without STR().
+    language: ['STR(?class)', 'STR(?p)', '?lang'],
+};
+/**
+ * Mint a partition IRI from its canonical component *string values* (the class
+ * IRI, property IRI, datatype IRI, or language tag — the `STR()` forms the
+ * SPARQL side concatenates). The TypeScript counterpart of the query minting.
+ */
+export function mintPartitionIri(datasetIri, kind, components) {
+    const hash = createHash('md5').update(components.join('')).digest('hex');
+    return `${datasetIri}${WELL_KNOWN_VOID}${kind}-${hash}`;
+}
+/**
+ * Replace every `#mint:<kind>#` marker in a query with the SPARQL value
+ * expression that mints that kind's partition IRI, e.g.
+ * `URI(CONCAT(STR(?dataset), "/.well-known/void#class-", MD5(STR(?class))))`.
+ */
+export function substituteMintMarkers(query) {
+    return query.replace(/#mint:([a-z-]+)#/g, (_match, kind) => {
+        const components = PARTITION_KINDS[kind];
+        if (components === undefined) {
+            throw new Error(`Unknown partition kind in #mint:# marker: ${kind}`);
+        }
+        const hashed = components.length === 1
+            ? components[0]
+            : `CONCAT(${components.join(', ')})`;
+        return `URI(CONCAT(STR(?dataset), "${WELL_KNOWN_VOID}${kind}-", MD5(${hashed})))`;
+    });
+}

package/dist/partitionMerge.d.ts

@@ -1,37 +1,55 @@
-import { type NamespaceAlias, type QuadTransform, type ReaderContext } from '@lde/pipeline';
+import { type BeforeDatasetWriteContext, type NamespaceAlias, type PipelinePlugin, type QuadTransform } 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.
+ * A {@link QuadTransform} for the {@link PipelinePlugin.beforeDatasetWrite} hook
+ * that merges the `void:classPartition` / `void:propertyPartition` subtrees of
+ * namespace-alias variants (e.g. `http://schema.org/CreativeWork` and
+ * `https://schema.org/CreativeWork`) into one 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`).
+ * two namespace variants produce two partition nodes that, once the class IRI is
+ * canonicalized, describe the same class. Seeing a whole dataset's output at
+ * once, this transform re-mints every partition IRI from its **canonical** key
+ * components via {@link mintPartitionIri} — the single source of truth the
+ * queries' SPARQL minting is also generated from — collapses the duplicates,
+ * and sums their numeric measures.
  *
- * ## Correctness assumptions
+ * It streams: only partition quads are buffered (bounded by the summary — a
+ * handful of classes × properties, not the dataset), and every other quad
+ * passes straight through.
  *
- * 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.
+ * Datasets typically use a single schema.org namespace, so within one dataset
+ * there is one variant per class and the transform merely renames and re-keys —
+ * `void:distinctObjects` and every count stay exact. A dataset that genuinely
+ * mixes both namespaces on the same property collapses the variants by summing,
+ * which over-counts shared distinct objects; this is not optimized for.
  *
  * With no aliases configured the transform is a no-op.
+ */
+export declare function mergeNamespaceVariants(namespaceAliases: readonly NamespaceAlias[]): QuadTransform<BeforeDatasetWriteContext>;
+/**
+ * A {@link PipelinePlugin} that canonicalizes schema.org namespace variants in
+ * the VoID output — rewriting `http://schema.org/` to `https://schema.org/` —
+ * _and_ merges the duplicate partition nodes the two variants produced. Runs on
+ * the whole dataset's output via {@link PipelinePlugin.beforeDatasetWrite}, so
+ * the analysis queries stay unaware of namespace aliases.
+ *
+ * This does more than a plain namespace rewrite: rewriting the `void:class`
+ * objects alone would leave two `void:classPartition` nodes for the same class.
+ * For a non-VoID, blanket namespace rewrite (e.g. mapping instance data to an
+ * application profile), use `schemaOrgNormalizationPlugin` from `@lde/pipeline`.
+ */
+export declare function schemaOrgPartitionMergePlugin(): PipelinePlugin;
+/**
+ * A {@link PipelinePlugin} that canonicalizes the given namespace aliases in the
+ * VoID output and merges the duplicate partition nodes their variants produced.
+ * Generic form of {@link schemaOrgPartitionMergePlugin}.
  *
- * @see substituteNormalizationMarkers for the query-time normalization used
- *   where summing is not safe.
+ * Required stages: re-keying a datatype/language/object-class partition walks up
+ * its `cp → pp → dp` chain, reading `void:class` and `void:property` that
+ * `classPartitions` and `classPropertySubjects` emit. Use this plugin with a
+ * stage set that includes both (as {@link voidStages} does); without them a
+ * void-ext partition cannot be re-keyed and its alias variants ship unmerged.
  */
-export declare function mergeNamespaceVariants(namespaceAliases: readonly NamespaceAlias[]): QuadTransform<ReaderContext>;
+export declare function namespacePartitionMergePlugin(namespaceAliases: readonly NamespaceAlias[]): PipelinePlugin;
 //# sourceMappingURL=partitionMerge.d.ts.map

package/dist/partitionMerge.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"partitionMerge.d.ts","sourceRoot":"","sources":["../src/partitionMerge.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,eAAe,CAAC;AAqEvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,SAAS,cAAc,EAAE,GAC1C,aAAa,CAAC,yBAAyB,CAAC,CAgB1C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,IAAI,cAAc,CAI9D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC3C,gBAAgB,EAAE,SAAS,cAAc,EAAE,GAC1C,cAAc,CAKhB"}

package/dist/partitionMerge.js

@@ -1,14 +1,17 @@
 import { canonicalizeIri, } from '@lde/pipeline';
 import { DataFactory } from 'n3';
-import { createHash } from 'node:crypto';
+import { mintPartitionIri } from './partitionIri.js';
 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 SCHEMA_HTTP = 'http://schema.org/';
+const SCHEMA_HTTPS = 'https://schema.org/';
 const VOID_CLASS = `${VOID}class`;
 const VOID_PROPERTY = `${VOID}property`;
 const VOID_ENTITIES = `${VOID}entities`;
 const VOID_TRIPLES = `${VOID}triples`;
+const VOID_DISTINCT_OBJECTS = `${VOID}distinctObjects`;
 const VOID_CLASS_PARTITION = `${VOID}classPartition`;
 const VOID_PROPERTY_PARTITION = `${VOID}propertyPartition`;
 const VOIDEXT_DATATYPE = `${VOID_EXT}datatype`;
@@ -16,11 +19,19 @@ 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]);
+/**
+ * Integer-literal measures summed when partitions collapse.
+ * `void:distinctObjects` is included: a dataset that uses a single schema.org
+ * namespace has one variant per class, so there is nothing to combine and the
+ * count is unchanged; only a dataset that mixes both namespaces on the same
+ * property (rare) sums two distinct-object counts — an over-count we accept
+ * rather than optimize for.
+ */
+const NUMERIC_MEASURES = new Set([
+    VOID_ENTITIES,
+    VOID_TRIPLES,
+    VOID_DISTINCT_OBJECTS,
+]);
 /** Structural links whose object is a child partition node. */
 const CHILD_LINKS = new Set([
     VOID_CLASS_PARTITION,
@@ -29,41 +40,50 @@ const CHILD_LINKS = new Set([
     VOIDEXT_OBJECTCLASS_PARTITION,
     VOIDEXT_LANGUAGE_PARTITION,
 ]);
+/**
+ * Every predicate that describes a partition. A quad with one of these
+ * predicates is buffered for merging; every other quad streams through
+ * untouched, so the transform's memory is bounded by the VoID summary, not the
+ * dataset.
+ */
+const PARTITION_VOCABULARY = new Set([
+    VOID_CLASS,
+    VOID_PROPERTY,
+    VOIDEXT_DATATYPE,
+    VOIDEXT_LANGUAGE,
+    // Derived, not re-listed: a measure added to NUMERIC_MEASURES must also be
+    // buffered here, or it would stream through un-summed.
+    ...NUMERIC_MEASURES,
+    ...CHILD_LINKS,
+]);
 /** `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.
+ * A {@link QuadTransform} for the {@link PipelinePlugin.beforeDatasetWrite} hook
+ * that merges the `void:classPartition` / `void:propertyPartition` subtrees of
+ * namespace-alias variants (e.g. `http://schema.org/CreativeWork` and
+ * `https://schema.org/CreativeWork`) into one 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`).
+ * two namespace variants produce two partition nodes that, once the class IRI is
+ * canonicalized, describe the same class. Seeing a whole dataset's output at
+ * once, this transform re-mints every partition IRI from its **canonical** key
+ * components via {@link mintPartitionIri} — the single source of truth the
+ * queries' SPARQL minting is also generated from — collapses the duplicates,
+ * and sums their numeric measures.
  *
- * ## Correctness assumptions
+ * It streams: only partition quads are buffered (bounded by the summary — a
+ * handful of classes × properties, not the dataset), and every other quad
+ * passes straight through.
  *
- * 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.
+ * Datasets typically use a single schema.org namespace, so within one dataset
+ * there is one variant per class and the transform merely renames and re-keys —
+ * `void:distinctObjects` and every count stay exact. A dataset that genuinely
+ * mixes both namespaces on the same property collapses the variants by summing,
+ * which over-counts shared distinct objects; this is not optimized for.
  *
  * 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) {
@@ -71,11 +91,50 @@ export function mergeNamespaceVariants(namespaceAliases) {
     }
     return async function* (quads, { dataset }) {
         const datasetIri = dataset.iri.toString();
-        const buffered = [];
+        const partitionQuads = [];
         for await (const q of quads) {
-            buffered.push(q);
+            if (PARTITION_VOCABULARY.has(q.predicate.value)) {
+                partitionQuads.push(q);
+            }
+            else {
+                yield q;
+            }
         }
-        yield* mergeBuffered(buffered, datasetIri, namespaceAliases);
+        yield* mergeBuffered(partitionQuads, datasetIri, namespaceAliases);
+    };
+}
+/**
+ * A {@link PipelinePlugin} that canonicalizes schema.org namespace variants in
+ * the VoID output — rewriting `http://schema.org/` to `https://schema.org/` —
+ * _and_ merges the duplicate partition nodes the two variants produced. Runs on
+ * the whole dataset's output via {@link PipelinePlugin.beforeDatasetWrite}, so
+ * the analysis queries stay unaware of namespace aliases.
+ *
+ * This does more than a plain namespace rewrite: rewriting the `void:class`
+ * objects alone would leave two `void:classPartition` nodes for the same class.
+ * For a non-VoID, blanket namespace rewrite (e.g. mapping instance data to an
+ * application profile), use `schemaOrgNormalizationPlugin` from `@lde/pipeline`.
+ */
+export function schemaOrgPartitionMergePlugin() {
+    return namespacePartitionMergePlugin([
+        { canonical: SCHEMA_HTTPS, alias: SCHEMA_HTTP },
+    ]);
+}
+/**
+ * A {@link PipelinePlugin} that canonicalizes the given namespace aliases in the
+ * VoID output and merges the duplicate partition nodes their variants produced.
+ * Generic form of {@link schemaOrgPartitionMergePlugin}.
+ *
+ * Required stages: re-keying a datatype/language/object-class partition walks up
+ * its `cp → pp → dp` chain, reading `void:class` and `void:property` that
+ * `classPartitions` and `classPropertySubjects` emit. Use this plugin with a
+ * stage set that includes both (as {@link voidStages} does); without them a
+ * void-ext partition cannot be re-keyed and its alias variants ship unmerged.
+ */
+export function namespacePartitionMergePlugin(namespaceAliases) {
+    return {
+        name: 'void-namespace-partition-merge',
+        beforeDatasetWrite: mergeNamespaceVariants(namespaceAliases),
     };
 }
 function* mergeBuffered(buffered, datasetIri, namespaceAliases) {
@@ -83,10 +142,17 @@ function* mergeBuffered(buffered, datasetIri, namespaceAliases) {
     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);
+        let object = remapTerm(original.object, remap);
+        // Canonicalize a void:class/void:property object only when its own
+        // partition node is being re-keyed. The top-level property partitions from
+        // entity-properties.rq are never merged (their parent is the dataset, not a
+        // class), so they keep the source namespace — consumers can still see which
+        // namespace the dataset actually uses (see ADR 7).
+        if (remap.has(original.subject.value)) {
+            object = canonicalizeObject(object, original.predicate.value, namespaceAliases);
+        }
         const rewritten = quad(subject, original.predicate, object, original.graph);
         if (NUMERIC_MEASURES.has(original.predicate.value)) {
             accumulateMeasure(measureSums, rewritten);
@@ -95,10 +161,9 @@ function* mergeBuffered(buffered, datasetIri, namespaceAliases) {
         const key = quadKey(rewritten);
         if (!emitted.has(key)) {
             emitted.add(key);
-            structural.push(rewritten);
+            yield rewritten;
         }
     }
-    yield* structural;
     for (const sum of measureSums.values()) {
         yield reconstructMeasure(sum);
     }
@@ -143,7 +208,7 @@ function buildRemap(nodes, datasetIri, namespaceAliases) {
 }
 /**
  * The canonical partition IRI for a node, or `undefined` if the node is not a
- * partition (no incoming structural link). Replicates the queries’ minting:
+ * partition (no incoming structural link). Replicates the queries' minting:
  * `<dataset>/.well-known/void#<prefix>-<MD5(STR(component)…)>`.
  */
 function canonicalPartitionIri(node, nodes, datasetIri, namespaceAliases) {
@@ -155,20 +220,25 @@ function canonicalPartitionIri(node, nodes, datasetIri, namespaceAliases) {
     switch (link.predicate) {
         case VOID_CLASS_PARTITION: {
             const klass = node.values.get(VOID_CLASS)?.value;
-            return klass ? mint(datasetIri, 'class', [canon(klass)]) : undefined;
+            return klass
+                ? mintPartitionIri(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)])
+                ? mintPartitionIri(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', [
+                ? mintPartitionIri(datasetIri, 'datatype', [
                     canon(klass),
                     canon(property),
                     datatype,
@@ -179,7 +249,7 @@ function canonicalPartitionIri(node, nodes, datasetIri, namespaceAliases) {
             const [klass, property] = classProperty(link.parent, nodes);
             const objectClass = node.values.get(VOID_CLASS)?.value;
             return klass && property && objectClass
-                ? mint(datasetIri, 'object-class', [
+                ? mintPartitionIri(datasetIri, 'object-class', [
                     canon(klass),
                     canon(property),
                     canon(objectClass),
@@ -190,7 +260,7 @@ function canonicalPartitionIri(node, nodes, datasetIri, namespaceAliases) {
             const [klass, property] = classProperty(link.parent, nodes);
             const language = node.values.get(VOIDEXT_LANGUAGE)?.value;
             return klass && property && language !== undefined
-                ? mint(datasetIri, 'language', [
+                ? mintPartitionIri(datasetIri, 'language', [
                     canon(klass),
                     canon(property),
                     language,
@@ -211,10 +281,6 @@ function classProperty(propertyPartition, nodes) {
         : 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);

package/dist/stage.d.ts

@@ -1,4 +1,4 @@
-import { Stage, type ReaderContext, type NamespaceAlias, type QuadTransform } from '@lde/pipeline';
+import { Stage, type ReaderContext, type QuadTransform } from '@lde/pipeline';
 import type { Quad } from '@rdfjs/types';
 /**
  * Stable names for every VoID stage, equal to the underlying query filename.
@@ -46,27 +46,6 @@ 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,8 +4,7 @@ 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';
+import { substituteMintMarkers } from './partitionIri.js';
 const queriesDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'queries');
 /**
  * Stable names for every VoID stage, equal to the underlying query filename.
@@ -33,30 +32,15 @@ export const VOID_STAGE_NAMES = {
     objectUriSpace: 'object-uri-space.rq',
 };
 async function createVoidStage(filename, options) {
-    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 query = substituteMintMarkers(await readQueryFile(resolve(queriesDir, filename)));
     const reader = {
-        // 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)],
+        reader: new SparqlConstructReader({ query }),
+        transform: options?.transform,
     };
     return new Stage({
         name: filename,
         readers: reader,
-        itemSelector: options?.perClass
-            ? classSelector(namespaceAliases)
-            : undefined,
+        itemSelector: options?.perClass ? classSelector() : undefined,
         batchSize: options?.batchSize,
         maxConcurrency: options?.maxConcurrency,
         expectsOutput: options?.expectsOutput,
@@ -68,7 +52,7 @@ function asTransforms(transform) {
         return [];
     return Array.isArray(transform) ? [...transform] : [transform];
 }
-function classSelector(namespaceAliases) {
+function classSelector() {
     return {
         // Forward `options` so the Pipeline’s per-dataset TimeoutPolicy
         // reaches the inner SparqlItemSelector — without this the adaptive
@@ -86,10 +70,9 @@ function classSelector(namespaceAliases) {
                 `WHERE { ${subjectFilter} ?s a ?class . }`,
                 'LIMIT 1000',
             ].join('\n');
-            const rows = new SparqlItemSelector({
+            return new SparqlItemSelector({
                 query: selectorQuery,
             }).select(distribution, batchSize, options);
-            return canonicalizeClassBindings(rows, namespaceAliases);
         },
     };
 }
@@ -98,10 +81,7 @@ export function subjectUriSpaces(options) {
     return createVoidStage(VOID_STAGE_NAMES.subjectUriSpace, options);
 }
 export function classPartitions(options) {
-    return createVoidStage(VOID_STAGE_NAMES.classPartitions, {
-        ...options,
-        mergePartitions: true,
-    });
+    return createVoidStage(VOID_STAGE_NAMES.classPartitions, options);
 }
 // 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
@@ -141,7 +121,6 @@ export function classPropertySubjects(options) {
     return createVoidStage(VOID_STAGE_NAMES.classPropertySubjects, {
         ...options,
         perClass: options?.perClass ?? true,
-        mergePartitions: true,
     });
 }
 export function classPropertyObjects(options) {
@@ -164,21 +143,18 @@ 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.4",
+  "version": "0.32.0",
   "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.4"
+    "@lde/pipeline": "^0.34.0"
   }
 }

package/queries/class-partition.rq

@@ -3,17 +3,17 @@ PREFIX void: <http://rdfs.org/ns/void#>
 CONSTRUCT {
     ?dataset a void:Dataset ;
         void:classPartition ?classPartition .
-    ?classPartition void:class ?type ;
+    ?classPartition void:class ?class ;
         void:entities ?entities .
 }
 WHERE {
     {
-        SELECT (COUNT(?type) AS ?entities) ?type {
+        SELECT (COUNT(?class) AS ?entities) ?class {
             #subjectFilter#
-            ?s a ?type .
+            ?s a ?class .
         }
-        GROUP BY ?type
+        GROUP BY ?class
     }
-    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-", MD5(STR(?type)))) AS ?classPartition)
+    BIND(#mint:class# AS ?classPartition)
 }
 LIMIT 10000

package/queries/class-properties-objects.rq

@@ -5,27 +5,17 @@ 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 ?canonicalClass ?canonicalProperty (COUNT(DISTINCT ?o) AS ?objects) {
+        SELECT ?class ?p (COUNT(DISTINCT ?o) AS ?objects) {
             {
-                SELECT ?canonicalClass ?canonicalProperty ?o {
+                SELECT ?class ?p ?o {
                     #subjectFilter#
-                    ?s a ?class ; ?property ?o .
-                    BIND(#normalized:class# AS ?canonicalClass)
-                    BIND(#normalized:property# AS ?canonicalProperty)
+                    ?s a ?class ; ?p ?o .
                 }
             }
         }
-        GROUP BY ?canonicalClass ?canonicalProperty
+        GROUP BY ?class ?p
     }
-    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?canonicalClass), STR(?canonicalProperty))))) AS ?propertyPartition)
+    BIND(#mint:class-property# AS ?propertyPartition)
 }
 LIMIT 100000

package/queries/class-properties-subjects.rq

@@ -21,7 +21,7 @@ WHERE {
         }
         GROUP BY ?class ?p
     }
-    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(#mint:class# AS ?classPartition)
+    BIND(#mint:class-property# AS ?propertyPartition)
 }
 LIMIT 100000

package/queries/class-property-datatypes.rq

@@ -2,17 +2,7 @@ PREFIX void: <http://rdfs.org/ns/void#>
 PREFIX void-ext: <http://ldf.fi/void-ext#>
 
 CONSTRUCT {
-  # 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 .
+  ?propertyPartition void-ext:datatypePartition ?datatypePartition .
   ?datatypePartition
       void-ext:datatype ?dt ;
       void:triples ?count .
@@ -32,8 +22,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)
+  BIND(#mint:class-property# AS ?propertyPartition)
+  BIND(#mint:datatype# AS ?datatypePartition)
 }
 LIMIT 100000

package/queries/class-property-languages.rq

@@ -2,17 +2,7 @@ PREFIX void: <http://rdfs.org/ns/void#>
 PREFIX void-ext: <http://ldf.fi/void-ext#>
 
 CONSTRUCT {
-  # 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 .
+  ?propertyPartition void-ext:languagePartition ?languagePartition .
   ?languagePartition
     void-ext:language ?lang ;
     void:triples ?count .
@@ -34,8 +24,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)
+  BIND(#mint:class-property# AS ?propertyPartition)
+  BIND(#mint:language# AS ?languagePartition)
 }
 LIMIT 100000

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

@@ -2,17 +2,7 @@ PREFIX void: <http://rdfs.org/ns/void#>
 PREFIX void-ext: <http://ldf.fi/void-ext#>
 
 CONSTRUCT {
-  # 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 .
+  ?propertyPartition void-ext:objectClassPartition ?objectClassPartition .
   ?objectClassPartition
       void:class ?objectClass ;
       void:triples ?count .
@@ -32,8 +22,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)
+  BIND(#mint:class-property# AS ?propertyPartition)
+  BIND(#mint:object-class# AS ?objectClassPartition)
 }
 LIMIT 100000

package/dist/namespaceAliases.d.ts

@@ -1,23 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,77 +0,0 @@
-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}`);
-    }
-}