glossarist 0.4.31 → 0.4.33

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)
@@ -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());

package/src/validators/partitive-relation-coherence-rule.js

@@ -1,80 +1,7 @@
-// Validates PartitiveRelation coherence per ISO 704 / ISO 12620.
-//
-// Checks (per TODO.partitive-relation-v2 item 13):
-//   1. ERROR: each relation has ≥2 partitives (ISO 704 "two or more")
-//   2. ERROR: no two relations on the same concept share the same
-//      comprehensive + same criterion (duplicate decomposition —
-//      violates ISO 12620 coordinate-concept coherence)
-//   3. WARNING: a concept with multiple relations where any relation
-//      lacks criterion (cannot verify distinctness from siblings)
-//   4. WARNING: a TypeSharedPlurality with is_uncertain=true but
-//      is_shared=false (semantically odd — broken line qualifies
-//      the close-set double line; without `double`, what's being
-//      qualified?)
-//
-// Lives in the validator framework, not the model constructor, per
-// invariant I8 (TODO.hyperedges-v2/00). Constructors enforce type-shape;
-// validators enforce semantics.
+// Deprecated. This rule has been generalized and renamed to
+// HyperedgeCoherenceRule (see ./hyperedge-coherence-rule.js). The
+// new rule is type-blind — it validates every AbstractHyperedge
+// subclass, not just PartitiveHyperedge. This file remains as a
+// re-export shim for existing imports.
 
-import { ValidationRule } from './validation-rule.js';
-import { refKey, criterionKey } from './ref-keys.js';
-
-export class PartitiveRelationCoherenceRule extends ValidationRule {
-  constructor() { super('partitive-relation-coherence'); }
-
-  validate(concept, path, result) {
-    const relations = concept.partitiveRelations ?? concept.partitiveHyperedges ?? [];
-    if (relations.length === 0) return;
-
-    // Check 1: ≥2 partitives per relation. (The constructor also
-    // rejects this, but a warning here surfaces it in the result
-    // bundle for CI visibility.)
-    for (let i = 0; i < relations.length; i++) {
-      const partitiveCount = (relations[i]?.partitives ?? []).length;
-      if (partitiveCount < 2) {
-        this.addIssue(result,
-          `${path}partitiveRelations[${i}].partitives`,
-          `PartitiveRelation ${i + 1} has ${partitiveCount} partitive(s); ` +
-          `ISO 704 requires ≥2 (use a binary has_part edge for pairwise facts)`,
-        );
-      }
-    }
-
-    // Check 2: no duplicate (comprehensive + criterion) on the same concept.
-    const seen = new Map();
-    for (let i = 0; i < relations.length; i++) {
-      const rel = relations[i];
-      const compKey = refKey(rel?.comprehensive);
-      const critKey = criterionKey(rel?.criterion);
-      if (compKey == null || critKey == null) continue;
-      const key = `${compKey}|${critKey}`;
-      if (seen.has(key)) {
-        this.addIssue(result,
-          `${path}partitiveRelations[${i}]`,
-          `duplicate PartitiveRelation (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 relations.
-    if (relations.length > 1) {
-      for (let i = 0; i < relations.length; i++) {
-        if (!relations[i]?.criterion) {
-          result.addWarning(
-            `${path}partitiveRelations[${i}].criterion`,
-            `concept has multiple PartitiveRelations but relation ${i + 1} ` +
-            `has no criterion; cannot verify distinctness from siblings`,
-          );
-        }
-      }
-    }
-
-    // (Check 4 — plurality coherence — removed. The prior plurality
-    // block was based on a misreading of ISO 704; the corrected model
-    // uses per-member multiplicity + is_delimiting, which are validated
-    // at construction by PartitiveMember itself.)
-  }
-}
+export { HyperedgeCoherenceRule, PartitiveRelationCoherenceRule } from './hyperedge-coherence-rule.js';

package/src/models/partitive-relation.js

@@ -1,76 +0,0 @@
-// PartitiveRelation — an ISO 704:2022 / ISO 1087-1 / ISO 12620
-// partitive relation connecting a comprehensive concept
-// (superordinate concept partitive) to two or more partitive
-// concepts (subordinate concepts partitive) which fitted together
-// constitute the comprehensive.
-//
-// Extends AbstractNaryRelation; the leaf-specific concern is the
-// PartitiveMember type for `members`. The wire-level field name
-// stays `partitives` for v1/v2 backward compat.
-//
-// ISO 704:2022 rake diagram semantics:
-//
-//   comprehensive concept
-//   ─────────────────────
-//   │ partitive (one or more) with per-member multiplicity + optional delimiting
-//   ─────────────────────
-//
-// All partitives within one relation are coordinate concepts
-// (ISO 12620): they share the comprehensive AND share the
-// criterion of subdivision.
-//
-// "Delimiting" parts (bold/3x-width line in source diagrams) behave
-// like delimiting characteristics — they distinguish the comprehensive
-// from coordinate concepts. Whether a part is delimiting depends on
-// the concept system, the coordinate concepts, the inheritance
-// principle, and the criterion of subdivision used
-// (ISO 704:2022 §5.5.4.2.1).
-//
-// Distinguished from binary `has_part` / `is_part_of` edges, which
-// express pairwise part-of assertions without completeness,
-// multiplicity, or criterion claims. A single partitive should be
-// expressed as a binary edge, not a PartitiveRelation (ISO requires
-// "two or more").
-
-import { AbstractNaryRelation } from './abstract-nary-relation.js';
-import { PartitiveMember } from './partitive-member.js';
-
-export class PartitiveRelation extends AbstractNaryRelation {
-  constructor(data = {}) {
-    const members = data?.members ?? data?.partitives;
-    super({ ...data, members });
-    this.members = members == null
-      ? this.members
-      : (Array.isArray(members)
-          ? members.map(m =>
-              m instanceof PartitiveMember ? m : new PartitiveMember(m))
-          : this.members);
-  }
-
-  get partitives() { return this.members; }
-
-  toJSON() {
-    const base = super.toJSON();
-    const { members, ...rest } = base;
-    return { ...rest, partitives: members };
-  }
-
-  static identityOf(value) {
-    const v = value ?? {};
-    const c = v.comprehensive ?? {};
-    const partKeys = Array.isArray(v.partitives ?? v.members)
-      ? (v.partitives ?? v.members).map(p => {
-          const r = p?.ref ?? p ?? {};
-          return `${r.source ?? ''}:${r.id ?? ''}`;
-        }).sort()
-      : [];
-    return `${c.source ?? ''}:${c.id ?? ''}|${partKeys.join('|')}`;
-  }
-
-  static fromJSON(data) {
-    const normalized = { ...(data ?? {}), members: data?.partitives ?? data?.members };
-    return new PartitiveRelation(normalized);
-  }
-}
-
-export default PartitiveRelation;

package/src/rdf/gloss-hyperedge.js

@@ -1,90 +0,0 @@
-// PartitiveHyperedge → RDF quads.
-//
-// Shape (per concept-model ontology, v3.1.0):
-//   <base>/hyperedge/<carrying-id>/<comprehensive-id>
-//     rdf:type                    gloss:PartitiveHyperedge
-//     gloss:comprehensive         <base>/concept/<comprehensive-id>
-//     gloss:hasPart               <base>/concept/<part-id>        (one per part)
-//     gloss:enumeration           "closed"|"open"                 (literal)
-//     gloss:hasPluralityMarker    "double"|"dashed"               (literal, one per marker)
-//     gloss:hyperedgeContent      "..."                           (literal, omitted if absent)
-//
-// The carrying concept links to this hyperedge via `gloss:hasPartitiveHyperedge`
-// (emitted by gloss-concept.js#conceptToQuads).
-//
-// CROSS-REPO STATUS (validated 2026-07-22):
-//   - Subject URI scheme: matches Ruby (`hyperedge/<c>/<comp>`).
-//   - `comprehensive`, `enumeration`, `hasPluralityMarker`, `hyperedgeContent`:
-//     predicates + object types match Ruby.
-//   - `hasPart`: JS follows the concept-model ontology; Ruby emits
-//     `gloss:part` instead. This is a Ruby bug — tracked as a cross-repo
-//     follow-up. Once Ruby aligns with the ontology, output will be
-//     byte-equivalent (modulo serialization order).
-
-import { PRED } from './predicates.js';
-import { WELL_KNOWN } from './prefixes.js';
-import { namedNode, literal, quad } from './terms.js';
-
-export function* hyperedgeToQuads(hyperedge, { parentUri, index }) {
-  const heSubject = hyperedgeSubjectUri(parentUri, hyperedge, index);
-  const s = namedNode(heSubject);
-
-  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.PartitiveHyperedge));
-
-  const comp = hyperedge.comprehensive;
-  if (comp && (comp.source || comp.id)) {
-    yield quad(s, namedNode(PRED.gloss.comprehensive),
-      namedNode(conceptRefUri(comp, parentUri)));
-  }
-
-  const parts = Array.isArray(hyperedge.parts) ? hyperedge.parts : [];
-  for (const p of parts) {
-    if (p && (p.source || p.id)) {
-      yield quad(s, namedNode(PRED.gloss.hasPart),
-        namedNode(conceptRefUri(p, parentUri)));
-    }
-  }
-
-  if (hyperedge.enumeration) {
-    yield quad(s, namedNode(PRED.gloss.enumeration), literal(hyperedge.enumeration));
-  }
-
-  for (const marker of Array.isArray(hyperedge.markers) ? hyperedge.markers : []) {
-    yield quad(s, namedNode(PRED.gloss.hasPluralityMarker), literal(marker));
-  }
-
-  if (hyperedge.content) {
-    const content = hyperedge.content;
-    if (typeof content === 'string') {
-      yield quad(s, namedNode(PRED.gloss.hyperedgeContent), literal(content));
-    } else if (typeof content === 'object') {
-      for (const [lang, text] of Object.entries(content)) {
-        if (typeof text !== 'string') continue;
-        yield quad(s, namedNode(PRED.gloss.hyperedgeContent), literal(text, lang));
-      }
-    }
-  }
-}
-
-// Subject URI scheme: `<base>/hyperedge/<carrying-id>/<comprehensive-id>`.
-// Matches Ruby's `subject { |h| "hyperedge/#{h.identifier}/#{h.comprehensive_id}" }`.
-// Falls back to an index suffix if comprehensive has no id, so two
-// hyperedges on the same concept never collide.
-export function hyperedgeSubjectUri(parentUri, hyperedge, index) {
-  const base = parentUri.replace(/\/concept\/[^/]+$/, '');
-  const carrierId = parentUri.split('/concept/')[1] ?? `carrier-${index}`;
-  const compId = hyperedge?.comprehensive?.id ?? `comp-${index}`;
-  return `${base}/hyperedge/${carrierId}/${compId}`;
-}
-
-// ConceptRef URI: `<base>/concept/<id>`. Matches Ruby's
-// `concept_to_gloss_transform.rb#hyperedge_concept_uri`. Source is
-// dropped from the URI; it stays on the ConceptRef object if needed.
-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'}:`;
-}