Eleven classifier nodes participate in the per-record DAG. Nine run concurrently in a parallel: collect placement; two run sequentially after the parallel because they read other classifiers' proposals. The conflict resolver reduces every non-sentinel proposal into a single winning state.classification.
The cascade is deterministic: same config + same record produce identical proposals, identical winner, identical PROV-O quads.
Classifiers are registered by the plugin via register(dispatcher). Each classifier is a generic ScalarNode subclass instantiated with domain config in the plugin. The plugin also authors its own per-record DAG (*.dag.jsonld) that chains only the classifiers it needs.
The nine parallel classifiers + two sequential classifiers + the conflict resolver are wired in SquashageRun.forRun(...) from the matching config slots.
For targets where records carry a discriminator field (e.g. _type), the classify:discriminator node is the primary classification path. It reads the literal value at a configured JSON Pointer and uses it directly as the class name proposal — no per-class enumeration required.
classify:discriminatorparallelReads a configured JSON Pointer (default /_type) from the record. Uses the resolved string (after optional sanitization) as the className proposal. Open-world: any non-empty string value classifies without enumeration.
classification.discriminatorConfig slot: classification.discriminator
{
"discriminator": {
"from": "/_type",
"sanitize": "pascalCase",
"priority": 80
}
}| Field | Type | Default | Description |
|---|---|---|---|
from | string | required | JSON Pointer (RFC 6901) into the record. |
fallback | string | — | Pointer used when from is absent or non-string. |
priority | number | 50 | Proposal priority; set higher than the other classifiers to ensure it wins on conflict. |
sanitize | string | "verbatim" | "verbatim" uses the value as-is; "pascalCase" and "kebabToPascal" split on [-_\s]+ and capitalize each segment. |
When the pointer resolves to a non-empty string, a proposal is emitted with confidence: 1.0. When the pointer is absent or non-string, the node outputs no-match and the other classifiers may still produce a proposal.
Source: src/nodes/record/classifiers/DiscriminatorClassifierNode.ts
These run concurrently inside classify-all. Each writes to its own slot in state.proposals[<classifier-name>], so the writes are race-free. Each classifier's outputs (proposed / no-match) route to null within the parallel placement; the parallel's combined output (success) routes forward to the first sequential classifier.
classify:sourceparallelInspects the record's _source block; emits a __source__ metadata marker. Never proposes a class.
classification.sourceclassify:url-patternparallelCompiled regex over _source.url (priority) or top-level url. Highest-priority matching pattern wins the slot.
classification.urlPatternclassify:structuralparallelCompiled JSON-pointer predicates over state.input via the Predicate engine.
classification.structuralclassify:rulesparallelFull decision-table predicates (equals, in, exists, range, length, regex, all/any composition). Same engine as structural; different config slot.
classification.rulesclassify:schemaparallelPer-class AJV validators loaded from JSON Schema files and compiled via services.ajv.
classification.schemasclassify:shacl-shapeparallelSHACL NodeShape ABox validation against record-projected quads. Reads shapes from a Turtle file or services.ontology.shacl().
classification.shaclShapeclassify:property-fingerprintparallelJaccard similarity between the record's top-level key set and pre-compiled fingerprints. Confidence = the Jaccard score.
classification.propertyFingerprintclassify:winknlp-entitiesparallelwinkNLP custom-entity pattern NER over configured prose fields. Patterns compiled once at construction.
classification.winknlpEntitiesThese read every other classifier's proposal, so they cannot run in parallel without race conditions. Order: classify:ontology runs first, then classify:taxonomic-narrowing.
classify:ontologysequentialValidates every other classifier's className against config.classes. Emits a __validation__ sentinel listing unknown classes.
classification.ontologyClassifierclassify:taxonomic-narrowingsequentialDrops supertype proposals when a more-specific subtype is also present. Uses OWL subClassOf transitive closure built once at construction.
classification.taxonomicNarrowingclassify-conflict runs after the gate (record-health-gate) has confirmed at least one non-sentinel proposal exists. It implements the documented resolution algorithm:
__source__, __validation__, __narrowing_applied__, unknown).onConflict: quarantine: bucket 'conflicts', exit via the quarantine path.pickPriority: lexicographically first className wins; candidates lists all tied classes.Configure via classification.conflict:
{
"onConflict": "pickPriority",
"evidence": true
}evidence: true concatenates every contributing proposal's reasons into the final state.classification.reasons. evidence: false keeps only the winner's first reason.
| Sentinel | Producer | Meaning |
|---|---|---|
__source__ | classify:source | The record's _source block was inspected; preserved in evidence as provenance. |
__validation__ | classify:ontology | One or more classifiers proposed a class outside the known map. |
__narrowing_applied__ | classify:taxonomic-narrowing | Supertype proposals were dropped in favor of subtypes. |
All three are filtered before conflict resolution and preserved in the final ClassificationEvidence.reasons array when conflict.evidence: true.
parents DSL, and TaxonomicInheritanceEnricher.