glossarist 0.4.32 → 0.4.34

package/src/models/relation-loader.js

@@ -1,32 +1,39 @@
-// RelationLoader — runtime loader for per-file n-ary relation YAMLs.
+// HyperedgeLoader — runtime loader for per-file hyperedge YAMLs.
 //
 // Walks a `relations/<comprehensive-id>/<slug>.yaml` directory and
-// dispatches each file to the appropriate class (PartitiveRelation
-// or GenericRelation) based on its `type` field.
+// dispatches each file to the appropriate class (PartitiveHyperedge,
+// GenericHyperedge, future leaves) based on its `type` field, via
+// HyperedgeRegistry.
 //
 // The wire-shape contract is owned by the JSON Schema at
 // `schemas/v3/relation.yaml` (concept-model repo) — this loader
 // produces the corresponding JS model instances. See
 // docs/design/relations-as-files.md (concept-model).
 //
-// This is the runtime equivalent of concept-model's
-// CheckPartitiveRelationCoherence#each_relation /
-// CheckGenericRelationCoherence#each_relation validators.
-// Both readers and validators must agree on the type-dispatch
-// table (TYPE_TO_CLASS). Keep them in sync via the JSON Schema.
+// Adding a new hyperedge type means: declare the leaf class with the
+// metadata block, register it. The loader picks it up automatically —
+// no edits here.
 
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import * as yaml from 'js-yaml';
-import { TYPE_TO_CLASS } from './relation-type-registry.js';
+import { HyperedgeRegistry } from './hyperedge-registry.js';
 
-/**
- * Per-type class dispatch. Re-exported from the registry so the
- * loader's old `TYPE_TO_CLASS` import path keeps working. The
- * registry is the single source of truth — adding a relation type
- * there makes it available to both the loader and Concept's
- * unified relations array.
- */
-export { TYPE_TO_CLASS };
+// Backward-compat: snapshot of registered classes keyed by typeTag.
+// Prefer HyperedgeRegistry.forTypeTag() for new code — this snapshot
+// is frozen at module load and won't pick up runtime registrations
+// from tests (the OCP test in Phase 11 registers a mock type after
+// import).
+export const TYPE_TO_CLASS = new Proxy({}, {
+  get(_target, prop) {
+    return HyperedgeRegistry.forTypeTag(prop);
+  },
+  ownKeys() {
+    return HyperedgeRegistry.allTypeTags();
+  },
+  getOwnPropertyDescriptor() {
+    return { enumerable: true, configurable: true };
+  },
+});
 
 /**
  * Thrown by `loadAll` when a relation file has an unknown `type`,
@@ -48,10 +55,9 @@ export class RelationLoadError extends Error {
  * @param {string} relationsDir — path to a `relations/` directory
  *   containing `<comprehensive-id>/<slug>.yaml` files (per the
  *   schema in schemas/v3/relation.yaml).
- * @returns {Map<string, Array<AbstractNaryRelation>>} — for each
+ * @returns {Map<string, Array<AbstractHyperedge>>} — for each
  *   comprehensive id, the list of relations that have it as their
- *   comprehensive. Type-discriminated (PartitiveRelation or
- *   GenericRelation).
+ *   comprehensive.
  */
 export function loadAll(relationsDir) {
   const result = new Map();
@@ -82,7 +88,7 @@ export function loadAll(relationsDir) {
  * `RelationLoader.loadAll(dir)`. The individual functions are also
  * exported directly for tree-shakeable single-call sites.
  */
-export const RelationLoader = Object.freeze({ loadAll });
+export const RelationLoader = Object.freeze({ loadAll, loadOne });
 
 /**
  * Load a single relation file. Returns null if the file is missing,
@@ -99,7 +105,7 @@ export function loadOne(path) {
   }
   if (!doc || typeof doc !== 'object') return null;
   if (!doc.type) return null;
-  const Cls = TYPE_TO_CLASS[doc.type];
+  const Cls = HyperedgeRegistry.forTypeTag(doc.type);
   if (!Cls) return null;  // Unknown type — let the validator report it
   return Cls.fromJSON(doc);
 }

package/src/rdf/gloss-concept.js

@@ -8,9 +8,29 @@ import { WELL_KNOWN } from './prefixes.js';
 import { localizedConceptToQuads } from './gloss-localized-concept.js';
 import { conceptSourceToQuads } from './gloss-source.js';
 import { partitiveRelationToQuads, partitiveRelationSubjectUri } from './gloss-partitive-relation.js';
-import { hyperedgeToQuads, hyperedgeSubjectUri } from './gloss-hyperedge.js';
+import { genericHyperedgeToQuads, genericHyperedgeSubjectUri, GENERIC_HYPEREDGE_LINK_PREDICATE } from './gloss-generic-hyperedge.js';
+import { PartitiveHyperedge } from '../models/partitive-hyperedge.js';
+import { GenericHyperedge } from '../models/generic-hyperedge.js';
 import { namedNode, literal, quad } from './terms.js';
 
+// Per-type RDF emitter dispatch. Keyed by class. Adding a new hyperedge
+// type with its own emitter means: (1) write the emitter module,
+// (2) add one entry here. Per TODO Phase 6e this should be a
+// self-registering registry; for the two current types, the dispatch
+// table is simpler and keeps the dependency graph acyclic.
+const HYPEREDGE_EMITTERS = new Map([
+  [PartitiveHyperedge, {
+    linkPredicate: PRED.gloss.hasPartitiveRelation,
+    subjectUri: partitiveRelationSubjectUri,
+    toQuads: partitiveRelationToQuads,
+  }],
+  [GenericHyperedge, {
+    linkPredicate: GENERIC_HYPEREDGE_LINK_PREDICATE,
+    subjectUri: genericHyperedgeSubjectUri,
+    toQuads: genericHyperedgeToQuads,
+  }],
+]);
+
 // Kind tag → URI segment. Each NonVerbalReference subtype has a
 // predictable URL path so the same entity is reachable from any
 // concept that references it.
@@ -72,27 +92,23 @@ export function* conceptToQuads(concept, options) {
     srcIndex += 1;
   }
 
-  // v2 canonical: concept.partitiveRelations. v1 alias
-  // (concept.partitiveHyperedges) points at the same array — both
-  // work here.
-  const relations = concept.partitiveRelations ?? concept.partitiveHyperedges ?? [];
+  // Iterate the unified relations array. Dispatch via per-type
+  // emitter table.
   let relIdx = 0;
-  for (const relation of relations) {
-    // Skip v1 PartitiveHyperedge instances — they have their own
-    // emitter (gloss-hyperedge.js) and would double-emit. The parser
-    // always produces v2 PartitiveRelation instances; only direct
-    // callers using the v1 model would see this branch.
-    const isV2 = !relation.enumeration && !relation.markers && !relation.parts
-      || (relation.completeness != null || relation.partitives != null);
-    if (!isV2) {
-      const heSubject = hyperedgeSubjectUri(subjectUri, relation, relIdx);
-      yield quad(s, namedNode(PRED.gloss.hasPartitiveHyperedge), namedNode(heSubject));
-      yield* hyperedgeToQuads(relation, { parentUri: subjectUri, index: relIdx });
-    } else {
-      const relSubject = partitiveRelationSubjectUri(subjectUri, relation, relIdx);
-      yield quad(s, namedNode(PRED.gloss.hasPartitiveRelation), namedNode(relSubject));
-      yield* partitiveRelationToQuads(relation, { parentUri: subjectUri, index: relIdx });
+  for (const relation of concept.relations ?? []) {
+    const emitter = HYPEREDGE_EMITTERS.get(relation.constructor);
+    if (!emitter) {
+      // Unknown hyperedge type — skip rather than crash. The OCP
+      // contract (Phase 11) tests that new types register an emitter;
+      // skipping here gives external consumers a soft-failure path
+      // when they pass around abstract hyperedges the JS layer doesn't
+      // recognize yet.
+      relIdx += 1;
+      continue;
     }
+    const relSubject = emitter.subjectUri(subjectUri, relation, relIdx);
+    yield quad(s, namedNode(emitter.linkPredicate), namedNode(relSubject));
+    yield* emitter.toQuads(relation, { parentUri: subjectUri, index: relIdx });
     relIdx += 1;
   }
 }

package/src/rdf/gloss-generic-hyperedge.js

@@ -0,0 +1,92 @@
+// GenericHyperedge → RDF quads.
+//
+// Shape (mirrors gloss-partitive-relation.js, swapping partitive
+// predicates for generic predicates per the concept-model ontology
+// extension that introduces gloss:GenericRelation):
+//
+//   <base>/generic-relation/<carrying-id>/<comprehensive-id>
+//     rdf:type                       gloss:GenericRelation
+//     gloss:comprehensive            <base>/concept/<comprehensive-id>      (named node)
+//     gloss:hasGeneric               <base>/concept/<member-id>            (named node, one per member)
+//     gloss:completeness             <.../completeness/complete|partial>   (named node, SKOS)
+//     gloss:criterion                "..."@lang                             (literal, one per language)
+//
+// Per-member multiplicity + is_delimiting reuse the same shape as
+// partitive members (HyperedgeMember is the shared base). Emitted via
+// `partitiveMemberToQuads` — the per-member shape is type-blind.
+//
+// The carrying concept links via `gloss:hasGenericRelation`.
+//
+// Per TODO Phase 6e. When the concept-model ontology publishes the
+// generic-relation predicates, this file is the single place to update
+// the predicate strings; nothing else in the RDF layer changes.
+
+import { PRED } from './predicates.js';
+import { WELL_KNOWN } from './prefixes.js';
+import { partitiveMemberToQuads } from './gloss-partitive-member.js';
+import { namedNode, literal, quad } from './terms.js';
+
+const COMPLETENESS_NS = 'https://www.glossarist.org/ontologies/completeness/';
+
+// Predicate IRIs. concept-model ontology v3.2.0 does not yet publish
+// GenericRelation predicates; we mint them under the same gloss:
+// namespace following the PartitiveRelation naming convention. Update
+// to match concept-model once finalized.
+const HAS_GENERIC_RELATION = 'https://www.glossarist.org/ontologies/hasGenericRelation';
+const HAS_GENERIC = 'https://www.glossarist.org/ontologies/hasGeneric';
+const GENERIC_RELATION_TYPE = 'https://www.glossarist.org/ontologies/GenericRelation';
+
+export function* genericHyperedgeToQuads(relation, { parentUri, index }) {
+  const subjectUri = genericHyperedgeSubjectUri(parentUri, relation, index);
+  const s = namedNode(subjectUri);
+
+  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(GENERIC_RELATION_TYPE));
+
+  const comp = relation.comprehensive;
+  if (comp && (comp.source || comp.id)) {
+    yield quad(s, namedNode(PRED.gloss.comprehensive),
+      namedNode(conceptRefUri(comp, parentUri)));
+  }
+
+  const members = Array.isArray(relation.members) ? relation.members : [];
+  for (const member of members) {
+    const ref = member?.ref ?? member;
+    if (!ref || (!ref.source && !ref.id)) continue;
+    const memberUri = conceptRefUri(ref, parentUri);
+    yield quad(s, namedNode(HAS_GENERIC), namedNode(memberUri));
+    yield* partitiveMemberToQuads(member, { memberUri });
+  }
+
+  if (relation.completeness) {
+    yield quad(s, namedNode(PRED.gloss.completeness),
+      namedNode(COMPLETENESS_NS + relation.completeness));
+  }
+
+  if (relation.criterion && typeof relation.criterion === 'object') {
+    for (const [lang, text] of Object.entries(relation.criterion)) {
+      if (typeof text !== 'string') continue;
+      yield quad(s, namedNode(PRED.gloss.criterion), literal(text, lang));
+    }
+  }
+}
+
+// Subject URI scheme: `<base>/generic-relation/<carrying-id>/<comprehensive-id>`.
+// Mirrors the partitive scheme so consumers can predict either path.
+export function genericHyperedgeSubjectUri(parentUri, relation, index) {
+  const base = parentUri.replace(/\/concept\/[^/]+$/, '');
+  const carrierId = parentUri.split('/concept/')[1] ?? `carrier-${index}`;
+  const compId = relation?.comprehensive?.id ?? `comp-${index}`;
+  return `${base}/generic-relation/${carrierId}/${compId}`;
+}
+
+// Exported for gloss-concept.js to use when linking the carrying concept.
+export const GENERIC_HYPEREDGE_LINK_PREDICATE = HAS_GENERIC_RELATION;
+
+function conceptRefUri(ref, parentUri) {
+  const id = ref?.id;
+  if (id) {
+    const base = parentUri.split('/concept/')[0];
+    return `${base}/concept/${id}`;
+  }
+  return `urn:glossarist:${ref?.source ?? 'unknown'}:`;
+}

package/src/rdf/gloss-partitive-relation.js

@@ -1,9 +1,9 @@
-// PartitiveRelation → RDF quads.
+// PartitiveHyperedge → RDF quads.
 //
 // Shape (per concept-model ontology, v3.2.0):
 //
 //   <base>/partitive-relation/<carrying-id>/<comprehensive-id>
-//     rdf:type                       gloss:PartitiveRelation
+//     rdf:type                       gloss:PartitiveHyperedge
 //     gloss:comprehensive            <base>/concept/<comprehensive-id>      (named node)
 //     gloss:hasPartitive             <base>/concept/<partitive-id>         (named node, one per member)
 //     gloss:completeness             <.../completeness/complete|partial>   (named node, SKOS)
@@ -14,7 +14,7 @@
 //
 // The carrying concept links via `gloss:hasPartitiveRelation`.
 //
-// Replaces gloss-hyperedge.js (the v1 emitter) per
+// Per
 // TODO.partitive-relation-v2 item 01.
 // Cross-repo alignment with glossarist-ruby's Rdf::GlossPartitiveRelation.
 //
@@ -35,7 +35,7 @@ export function* partitiveRelationToQuads(relation, { parentUri, index }) {
   const subjectUri = partitiveRelationSubjectUri(parentUri, relation, index);
   const s = namedNode(subjectUri);
 
-  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.PartitiveRelation));
+  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.PartitiveHyperedge));
 
   const comp = relation.comprehensive;
   if (comp && (comp.source || comp.id)) {

package/src/rdf/index.d.ts

@@ -11,7 +11,7 @@ import type { Designation } from '../models/index';
 import type { DetailedDefinition } from '../models/index';
 import type { ConceptSource } from '../models/index';
 import type { NonVerbRep, Figure, Table, Formula } from '../models/index';
-import type { PartitiveHyperedge, PartitiveRelation, PartitiveMember } from '../models/index';
+import type { PartitiveHyperedge, PartitiveHyperedge, PartitiveMember } from '../models/index';
 
 export { PRED, PREFIXES } from './predicates';
 export type PredicateMap = typeof PRED;
@@ -96,7 +96,7 @@ export declare function hyperedgeSubjectUri(
   index: number,
 ): string;
 
-// ── PartitiveRelation emitter (v2) ────────────────────────────────────
+// ── PartitiveHyperedge emitter (v2) ────────────────────────────────────
 
 export interface PartitiveRelationEmitOptions {
   parentUri: string;
@@ -104,13 +104,13 @@ export interface PartitiveRelationEmitOptions {
 }
 
 export declare function partitiveRelationToQuads(
-  relation: PartitiveRelation,
+  relation: PartitiveHyperedge,
   options: PartitiveRelationEmitOptions,
 ): Generator<Quad, void, unknown>;
 
 export declare function partitiveRelationSubjectUri(
   parentUri: string,
-  relation: PartitiveRelation,
+  relation: PartitiveHyperedge,
   index: number,
 ): string;
 

package/src/rdf/index.js

@@ -26,7 +26,6 @@ export {
 } from './gloss-designation.js';
 export { detailedDefinitionToQuads } from './gloss-detailed-definition.js';
 export { conceptSourceToQuads } from './gloss-source.js';
-export { hyperedgeToQuads, hyperedgeSubjectUri } from './gloss-hyperedge.js';
 export { partitiveMemberToQuads, MULTIPLICITY_NS, PRESENCE_NS, COUNT_NS } from './gloss-partitive-member.js';
 export { partitiveRelationToQuads, partitiveRelationSubjectUri } from './gloss-partitive-relation.js';
 export {

package/src/reference-resolver.js

@@ -84,29 +84,31 @@ export class ReferenceResolver {
       }
     }
 
-    // v2 model: concept.partitiveRelations is canonical; v1 alias
-    // concept.partitiveHyperedges points at the same array. Each
-    // relation has a comprehensive ConceptRef and 2+ partitive members
-    // each carrying a ConceptRef.
-    const relations = concept.partitiveRelations ?? concept.partitiveHyperedges ?? [];
+    // All hyperedges (Partitive + Generic + future types) live in
+    // concept.relations. Each has a comprehensive ConceptRef and 2+
+    // members each carrying a ConceptRef. The reference type is the
+    // relation's typeTag (partitive_relation, generic_relation, …).
+    const relations = concept.relations ?? [];
     for (let i = 0; i < relations.length; i++) {
       const rel = relations[i];
-      const relPath = `partitiveRelations[${i}]`;
+      const relType = rel?.constructor?.typeTag ?? 'hyperedge';
+      const relPath = `relations[${i}]`;
 
       const compTarget = hyperedgeRefTarget(rel.comprehensive);
       if (compTarget) {
         refs.push(new Reference(
           'concept',
           compTarget,
-          'partitive_relation',
+          relType,
           `${relPath}.comprehensive`,
           { lookupKey: { id: compTarget } },
         ));
       }
 
-      // v2 shape: rel.partitives is [{ ref, certainty }, ...].
-      // v1 shape: rel.parts is [ref, ...]. Accept both.
-      const members = rel.partitives ?? rel.parts ?? [];
+      // Member shape: members is [{ ref, presence, count, is_delimiting }, ...]
+      // (HyperedgeMember / PartitiveMember / GenericMember). The wire
+      // alias .partitives is also handled for backward compat with v2 wire consumers.
+      const members = rel.members ?? rel.partitives ?? rel.parts ?? [];
       for (let j = 0; j < members.length; j++) {
         const m = members[j];
         const memberRef = m?.ref ?? m;
@@ -115,8 +117,8 @@ export class ReferenceResolver {
         refs.push(new Reference(
           'concept',
           pTarget,
-          'partitive_relation',
-          `${relPath}.partitives[${j}]`,
+          relType,
+          `${relPath}.members[${j}]`,
           { lookupKey: { id: pTarget } },
         ));
       }

package/src/validators/binary-has-part-redundancy-rule.js

@@ -1,6 +1,6 @@
 // Warns when binary `has_part` / `is_part_of` edges duplicate
-// PartitiveRelation members, or when a concept has many binary
-// has_part edges that should be consolidated into a PartitiveRelation.
+// PartitiveHyperedge members, or when a concept has many binary
+// has_part edges that should be consolidated into a PartitiveHyperedge.
 //
 // Per TODO.partitive-relation-v2 item 14, binary edges and
 // PartitiveRelations coexist by design. The asymmetry is pragmatic:
@@ -20,7 +20,7 @@ export class BinaryHasPartRedundancyRule extends ValidationRule {
   constructor() { super('binary-has-part-redundancy', 'warning'); }
 
   validate(concept, path, result) {
-    const relations = concept.partitiveRelations ?? concept.partitiveHyperedges ?? [];
+    const relations = concept.relations ?? [];
 
     // Collect partitive refs from PartitiveRelations.
     const relationTargets = new Set();
@@ -49,17 +49,17 @@ export class BinaryHasPartRedundancyRule extends ValidationRule {
         this.addIssue(result,
           `${path}relatedConcepts`,
           `binary has_part edge for (${target}) is redundant — already in a ` +
-          `PartitiveRelation member; pick one encoding to avoid divergence`,
+          `PartitiveHyperedge member; pick one encoding to avoid divergence`,
         );
       }
     }
 
-    // Cluster: 3+ binary has_part edges suggests PartitiveRelation territory.
+    // Cluster: 3+ binary has_part edges suggests PartitiveHyperedge territory.
     if (binaryTargets.size >= 3) {
       this.addIssue(result,
         `${path}relatedConcepts`,
         `${binaryTargets.size} binary has_part edges on this concept; ` +
-        `consider converting to a PartitiveRelation (which can carry ` +
+        `consider converting to a PartitiveHyperedge (which can carry ` +
         `completeness, multiplicity, and criterion metadata)`,
       );
     }

package/src/validators/delimiting-coherence-rule.js

@@ -9,7 +9,7 @@
 // This rule surfaces three categories of issues that the model
 // constructor cannot catch (they're cross-relation, not per-instance):
 //
-//   1. WARNING: A PartitiveRelation where every partitive is
+//   1. WARNING: A PartitiveHyperedge where every partitive is
 //      is_delimiting=true overuses delimiting. Typically only some
 //      parts distinguish the comprehensive from coordinate concepts.
 //   2. ERROR: Two PartitiveRelations on the same concept with the
@@ -30,7 +30,7 @@ export class DelimitingCoherenceRule extends ValidationRule {
   constructor() { super('delimiting-coherence'); }
 
   validate(concept, path, result) {
-    const relations = concept.partitiveRelations ?? concept.partitiveHyperedges ?? [];
+    const relations = concept.relations ?? [];
     if (relations.length === 0) return;
 
     _checkOveruse(relations, path, result);

package/src/validators/hyperedge-coherence-rule.js

@@ -0,0 +1,98 @@
+// Validates hyperedge coherence per ISO 704 / ISO 12620.
+//
+// Applies to every AbstractHyperedge subclass (PartitiveHyperedge,
+// GenericHyperedge, future TemporalHyperedge / AssociativeHyperedge /
+// SequentialHyperedge). The ISO 704 / ISO 12620 invariants are
+// type-blind:
+//
+//   1. ERROR: each hyperedge has ≥2 members (ISO 704 "two or more")
+//   2. ERROR: no two hyperedges of the same type on the same concept
+//      share the same comprehensive + same criterion (duplicate
+//      decomposition — violates ISO 12620 coordinate-concept coherence)
+//   3. WARNING: a concept with multiple hyperedges of the same type
+//      where any lacks criterion (cannot verify distinctness from
+//      siblings)
+//
+// Lives in the validator framework, not the model constructor, per
+// invariant I8 (TODO.hyperedges-v2/00). Constructors enforce type-shape;
+// validators enforce semantics.
+//
+// Per TODO Phase 7: rule renamed from PartitiveRelationCoherenceRule
+// to HyperedgeCoherenceRule. The rule applies to all hyperedges; the
+// duplicate check is scoped per type so a Partitive and a Generic with
+// the same comprehensive+criterion don't false-positive.
+
+import { ValidationRule } from './validation-rule.js';
+import { refKey, criterionKey } from './ref-keys.js';
+import { AbstractHyperedge } from '../models/abstract-hyperedge.js';
+
+export class HyperedgeCoherenceRule extends ValidationRule {
+  constructor() { super('hyperedge-coherence'); }
+
+  validate(concept, path, result) {
+    const hyperedges = (concept.relations ?? []).filter(r => r instanceof AbstractHyperedge);
+    if (hyperedges.length === 0) return;
+
+    // Check 1: ≥2 members per hyperedge. (The constructor also
+    // rejects this, but a warning here surfaces it in the result
+    // bundle for CI visibility.)
+    for (let i = 0; i < hyperedges.length; i++) {
+      const memberCount = (hyperedges[i]?.members ?? []).length;
+      if (memberCount < 2) {
+        this.addIssue(result,
+          `${path}relations[${i}].members`,
+          `hyperedge ${i + 1} has ${memberCount} member(s); ` +
+          `ISO 704 requires ≥2 (use a binary edge for pairwise facts)`,
+        );
+      }
+    }
+
+    // Check 2: no duplicate (type + comprehensive + criterion) on the same concept.
+    // Scope by type so a Partitive and a Generic with the same comp+criterion
+    // don't false-positive — they're different decompositions.
+    const seen = new Map();
+    for (let i = 0; i < hyperedges.length; i++) {
+      const rel = hyperedges[i];
+      const typeTag = rel?.constructor?.typeTag ?? '';
+      const compKey = refKey(rel?.comprehensive);
+      const critKey = criterionKey(rel?.criterion);
+      if (compKey == null || critKey == null) continue;
+      const key = `${typeTag}|${compKey}|${critKey}`;
+      if (seen.has(key)) {
+        this.addIssue(result,
+          `${path}relations[${i}]`,
+          `duplicate ${rel.constructor.name} (same comprehensive + same criterion ` +
+          `as relation ${seen.get(key) + 1}); violates ISO 12620 coordinate-concept coherence`,
+        );
+      } else {
+        seen.set(key, i);
+      }
+    }
+
+    // Check 3: criterion documentation (warning) when concept has multiple
+    // hyperedges of the same type. Same-type-scope rationale as Check 2.
+    const byType = new Map();
+    for (const rel of hyperedges) {
+      const typeTag = rel?.constructor?.typeTag ?? '';
+      if (!byType.has(typeTag)) byType.set(typeTag, []);
+      byType.get(typeTag).push(rel);
+    }
+    for (const [typeTag, rels] of byType) {
+      if (rels.length <= 1) continue;
+      for (const rel of rels) {
+        if (!rel.criterion) {
+          const idx = hyperedges.indexOf(rel);
+          result.addWarning(
+            `${path}relations[${idx}].criterion`,
+            `concept has multiple ${typeTag} hyperedges but this one ` +
+            `has no criterion; cannot verify distinctness from siblings`,
+          );
+        }
+      }
+    }
+  }
+}
+
+// Backward-compat alias. Existing imports of PartitiveRelationCoherenceRule
+// continue to work; the rule is now type-blind.
+export const PartitiveRelationCoherenceRule = HyperedgeCoherenceRule;

package/src/validators/index.js

@@ -17,10 +17,8 @@ export {
   NonVerbalRefIntegrityRule,
   OrphanedImagesRule,
 } from './v3-rules.js';
-export { PartitiveHyperedgeShapeRule } from './partitive-hyperedge-rule.js';
-export { PartitiveDriftRule } from './partitive-drift-rule.js';
 export { SourcedFromLocalityRule } from './sourced-from-locality-rule.js';
-export { PartitiveRelationCoherenceRule } from './partitive-relation-coherence-rule.js';
+export { PartitiveRelationCoherenceRule, HyperedgeCoherenceRule } from './hyperedge-coherence-rule.js';
 export { ExternalConceptShapeRule } from './external-concept-shape-rule.js';
 export { BinaryHasPartRedundancyRule } from './binary-has-part-redundancy-rule.js';
 export { DelimitingCoherenceRule } from './delimiting-coherence-rule.js';
@@ -40,10 +38,8 @@ import {
   CiteRefIntegrityRule,
   NonVerbalRefIntegrityRule,
 } from './v3-rules.js';
-import { PartitiveHyperedgeShapeRule } from './partitive-hyperedge-rule.js';
-import { PartitiveDriftRule } from './partitive-drift-rule.js';
 import { SourcedFromLocalityRule } from './sourced-from-locality-rule.js';
-import { PartitiveRelationCoherenceRule } from './partitive-relation-coherence-rule.js';
+import { HyperedgeCoherenceRule } from './hyperedge-coherence-rule.js';
 import { ExternalConceptShapeRule } from './external-concept-shape-rule.js';
 import { BinaryHasPartRedundancyRule } from './binary-has-part-redundancy-rule.js';
 import { DelimitingCoherenceRule } from './delimiting-coherence-rule.js';
@@ -62,10 +58,8 @@ const _default = new ConceptValidator()
   .addRule(new RelationshipTypeRule())
   .addRule(new CiteRefIntegrityRule())
   .addRule(new NonVerbalRefIntegrityRule())
-  .addRule(new PartitiveHyperedgeShapeRule())
-  .addRule(new PartitiveDriftRule())
   .addRule(new SourcedFromLocalityRule())
-  .addRule(new PartitiveRelationCoherenceRule())
+  .addRule(new HyperedgeCoherenceRule())
   .addRule(new ExternalConceptShapeRule())
   .addRule(new BinaryHasPartRedundancyRule())
   .addRule(new DelimitingCoherenceRule());