@lde/pipeline-void 0.31.3 → 0.32.0

package/README.md

@@ -72,6 +72,27 @@ 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 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 one class — which crashed the Dataset Register browser (netwerk-digitaal-erfgoed/dataset-knowledge-graph#334).
+
+`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
+import { voidStages, schemaOrgPartitionMergePlugin } from '@lde/pipeline-void';
+import { Pipeline, provenancePlugin } from '@lde/pipeline';
+
+await new Pipeline({
+  stages: await voidStages(), // plain, no namespace options
+  plugins: [schemaOrgPartitionMergePlugin(), provenancePlugin()],
+  // …
+}).run();
+```
+
+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.
+
+> 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
 
 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 './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,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,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,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 './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

@@ -0,0 +1,55 @@
+import { type BeforeDatasetWriteContext, type NamespaceAlias, type PipelinePlugin, type QuadTransform } from '@lde/pipeline';
+/**
+ * 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 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.
+ *
+ * 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.
+ *
+ * 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}.
+ *
+ * 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 namespacePartitionMergePlugin(namespaceAliases: readonly NamespaceAlias[]): PipelinePlugin;
+//# 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,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

@@ -0,0 +1,341 @@
+import { canonicalizeIri, } from '@lde/pipeline';
+import { DataFactory } from 'n3';
+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`;
+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`;
+/**
+ * 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,
+    VOID_PROPERTY_PARTITION,
+    VOIDEXT_DATATYPE_PARTITION,
+    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} 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 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.
+ *
+ * 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.
+ *
+ * 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 function mergeNamespaceVariants(namespaceAliases) {
+    if (namespaceAliases.length === 0) {
+        return (quads) => quads;
+    }
+    return async function* (quads, { dataset }) {
+        const datasetIri = dataset.iri.toString();
+        const partitionQuads = [];
+        for await (const q of quads) {
+            if (PARTITION_VOCABULARY.has(q.predicate.value)) {
+                partitionQuads.push(q);
+            }
+            else {
+                yield q;
+            }
+        }
+        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) {
+    const nodes = indexNodes(buffered);
+    const remap = buildRemap(nodes, datasetIri, namespaceAliases);
+    const measureSums = new Map();
+    const emitted = new Set();
+    for (const original of buffered) {
+        const subject = remapTerm(original.subject, remap);
+        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);
+            continue;
+        }
+        const key = quadKey(rewritten);
+        if (!emitted.has(key)) {
+            emitted.add(key);
+            yield rewritten;
+        }
+    }
+    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
+                ? 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
+                ? 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
+                ? mintPartitionIri(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
+                ? mintPartitionIri(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
+                ? mintPartitionIri(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 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.map

@@ -1 +1 @@
-{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../src/stage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAKL,KAAK,aAAa,EAElB,KAAK,aAAa,EACnB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAezC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAiBnB,CAAC;AAEX,sDAAsD;AACtD,MAAM,MAAM,aAAa,GACvB,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAE3D,2EAA2E;AAC3E,MAAM,MAAM,kBAAkB,GAC1B,aAAa,CAAC,aAAa,CAAC,GAC5B,aAAa,CAAC,aAAa,CAAC,EAAE,CAAC;AAEnC;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,kBAAkB,CAAC;CAChC;AAED;;;;;GAKG;AACH,MAAM,WAAW,wBAAyB,SAAQ,gBAAgB;IAChE,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iFAAiF;IACjF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAkB,SAAQ,IAAI,CAC7C,wBAAwB,EACxB,WAAW,CACZ;IACC,yEAAyE;IACzE,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC;IACjD,mFAAmF;IACnF,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC,CAAC;CACjE;AAgED,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAE3E;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAE1E;AAOD,wBAAgB,mBAAmB,CACjC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAK1E;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAK1E;AAED,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAKxE;AAED,wBAAgB,YAAY,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAKvE;AAED,wBAAgB,qBAAqB,CACnC,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,wBAAgB,oBAAoB,CAClC,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAKzE;AAED,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAEzE;AAID,wBAAgB,qBAAqB,CACnC,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,KAAK,CAAC,CAKhB;AAID,wBAAgB,SAAS,CACvB,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,EACjD,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,KAAK,CAAC,CAOhB;AAED,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IACjE,mFAAmF;IACnF,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED,wBAAgB,kBAAkB,CAChC,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,KAAK,CAAC,CAQhB;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,KAAK,EAAE,CAAC,CAgDlB"}
+{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../src/stage.ts"],"names":[],"mappings":"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"}

package/dist/stage.js

@@ -4,6 +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 { 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.
@@ -31,7 +32,7 @@ export const VOID_STAGE_NAMES = {
     objectUriSpace: 'object-uri-space.rq',
 };
 async function createVoidStage(filename, options) {
-    const query = await readQueryFile(resolve(queriesDir, filename));
+    const query = substituteMintMarkers(await readQueryFile(resolve(queriesDir, filename)));
     const reader = {
         reader: new SparqlConstructReader({ query }),
         transform: options?.transform,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/pipeline-void",
-  "version": "0.31.3",
+  "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.3"
+    "@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

@@ -16,6 +16,6 @@ WHERE {
         }
         GROUP BY ?class ?p
     }
-    BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?class), STR(?p))))) 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

@@ -22,7 +22,7 @@ WHERE {
     }
     GROUP BY ?class ?p ?dt
   }
-  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

@@ -24,7 +24,7 @@ WHERE {
     }
     GROUP BY ?class ?p ?lang
   }
-  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

@@ -22,7 +22,7 @@ WHERE {
     }
     GROUP BY ?class ?p ?objectClass
   }
-  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