glossarist 0.4.31 → 0.4.33

package/src/models/index.d.ts

@@ -328,11 +328,11 @@ export class PartitiveHyperedge extends GlossaristModel {
   static fromJSON(data: Record<string, unknown>): PartitiveHyperedge;
 }
 
-// v2 PartitiveRelation + GenericRelation (MECE per-member model).
+// v2 PartitiveHyperedge + GenericHyperedge (MECE per-member model).
 // These supersede the v1 PartitiveHyperedge model above. New code
 // should use v2 exclusively; the v1 model is kept for backward-compat
 // input.
-export class ConceptSystemMember extends GlossaristModel {
+export class HyperedgeMember extends GlossaristModel {
   readonly ref: ConceptRef;
   readonly presence: 'required' | 'optional';
   readonly count: 'exactly_one' | 'at_least_one' | 'multiple';
@@ -342,17 +342,17 @@ export class ConceptSystemMember extends GlossaristModel {
   delimiting(): boolean;
   identity(): string;
   toJSON(): Record<string, unknown>;
-  static fromJSON(data: Record<string, unknown>): ConceptSystemMember;
+  static fromJSON(data: Record<string, unknown>): HyperedgeMember;
   static identityOf(value: unknown): string;
 }
 
-export class PartitiveMember extends ConceptSystemMember {}
+export class PartitiveMember extends HyperedgeMember {}
 
-export class GenericMember extends ConceptSystemMember {}
+export class GenericMember extends HyperedgeMember {}
 
-export class AbstractNaryRelation extends GlossaristModel {
+export class AbstractHyperedge extends GlossaristModel {
   readonly comprehensive: ConceptRef;
-  readonly members: ConceptSystemMember[];
+  readonly members: HyperedgeMember[];
   readonly completeness: 'complete' | 'partial';
   readonly criterion: Record<string, string> | null;
   readonly sources: ConceptSource[];
@@ -362,19 +362,19 @@ export class AbstractNaryRelation extends GlossaristModel {
   readonly isPartial: boolean;
   readonly isCoordinate: boolean;
   toJSON(): Record<string, unknown>;
-  static fromJSON(data: Record<string, unknown>): AbstractNaryRelation;
+  static fromJSON(data: Record<string, unknown>): AbstractHyperedge;
   static identityOf(value: unknown): string;
 }
 
-export class PartitiveRelation extends AbstractNaryRelation {
+export class PartitiveHyperedge extends AbstractHyperedge {
   /** @deprecated use {@link members} — kept for v1/v2 wire compat. */
-  readonly partitives: ConceptSystemMember[];
-  static fromJSON(data: Record<string, unknown>): PartitiveRelation;
+  readonly partitives: HyperedgeMember[];
+  static fromJSON(data: Record<string, unknown>): PartitiveHyperedge;
   static identityOf(value: unknown): string;
 }
 
-export class GenericRelation extends AbstractNaryRelation {
-  static fromJSON(data: Record<string, unknown>): GenericRelation;
+export class GenericHyperedge extends AbstractHyperedge {
+  static fromJSON(data: Record<string, unknown>): GenericHyperedge;
   static identityOf(value: unknown): string;
 }
 
@@ -383,14 +383,14 @@ export const DEFINITION_TYPE: Readonly<Record<string, DefinitionType>>;
 export const DEFAULT_DEFINITION_TYPE: DefinitionType;
 export const DEFINITION_TYPE_VALUES: readonly DefinitionType[];
 
-export const RELATION_TYPE_TO_CLASS: Readonly<Record<string, typeof AbstractNaryRelation>>;
+export const RELATION_TYPE_TO_CLASS: Readonly<Record<string, typeof AbstractHyperedge>>;
 export class RelationLoadError extends Error {
   readonly path: string;
   constructor(path: string, message: string);
 }
 export const RelationLoader: {
-  loadAll(relationsDir: string): Map<string, AbstractNaryRelation[]>;
-  loadOne(path: string): AbstractNaryRelation | null;
+  loadAll(relationsDir: string): Map<string, AbstractHyperedge[]>;
+  loadOne(path: string): AbstractHyperedge | null;
 };
 
 export const DESIGNATION_RELATIONSHIP_TYPES: readonly string[];

package/src/models/index.js

@@ -21,7 +21,6 @@ export { Citation } from './citation.js';
 export { ConceptRef } from './concept-ref.js';
 export { ConceptSource } from './concept-source.js';
 export { RelatedConcept, RELATIONSHIP_TYPES } from './related-concept.js';
-export { PartitiveHyperedge } from './partitive-hyperedge.js';
 export {
   PARTITIVE_ENUMERATION,
   PARTITIVE_ENUMERATION_VALUES,
@@ -33,17 +32,17 @@ export {
   isValidPluralityMarker,
 } from './plurality-marker.js';
 
-// v2 PartitiveRelation models (TODO.partitive-relation-v2). These
+// v2 PartitiveHyperedge models (TODO.partitive-relation-v2). These
 // supersede the v1 hyperedge models above; the v1 models are kept for
 // backward-compat input. New code should use v2 exclusively.
-export { PartitiveRelation } from './partitive-relation.js';
+export { PartitiveHyperedge } from './partitive-hyperedge.js';
 export { PartitiveMember } from './partitive-member.js';
 
-// v2 GenericRelation models (per-file relation storage). Mirrors
-// PartitiveRelation shape; uses the same MECE member shape.
-export { AbstractNaryRelation } from './abstract-nary-relation.js';
-export { ConceptSystemMember } from './concept-system-member.js';
-export { GenericRelation } from './generic-relation.js';
+// v2 GenericHyperedge models (per-file relation storage). Mirrors
+// PartitiveHyperedge shape; uses the same MECE member shape.
+export { AbstractHyperedge } from './abstract-hyperedge.js';
+export { HyperedgeMember } from './hyperedge-member.js';
+export { GenericHyperedge } from './generic-hyperedge.js';
 export { GenericMember } from './generic-member.js';
 export {
   DEFINITION_TYPE,
@@ -51,9 +50,13 @@ export {
 } from './definition-type.js';
 
 // Per-file relation loader (Node-side runtime; not browser-bundled).
-// Walks a relations/ directory and dispatches to PartitiveRelation /
-// GenericRelation by file type.
+// Walks a relations/ directory and dispatches to PartitiveHyperedge /
+// GenericHyperedge by file type.
 export { RelationLoader, RelationLoadError, TYPE_TO_CLASS as RELATION_TYPE_TO_CLASS } from './relation-loader.js';
+
+// Directional index over hyperedge sets. Built on demand from a flat
+// hyperedge list (typically concept.relations or a dataset union).
+export { HyperedgeIndex, buildDatasetIndex } from './hyperedge-index.js';
 export {
   PARTITIVE_PRESENCE,
   PARTITIVE_PRESENCE_VALUES,

package/src/models/multiplicity.js

@@ -53,6 +53,17 @@ export function multiplicityFromPair(presence, count) {
   return name;
 }
 
+// Canonical error message for the invalid (presence, count) combination.
+// Single source of truth — hyperedge-member.js delegates to this so the
+// error string doesn't drift across the two files. Phase 8 of
+// TODO.abstract-hyperedge.
+export function invalidCombinationError(presence, count) {
+  return new Error(
+    `Invalid multiplicity combination: presence=${presence}, count=${count}. ` +
+    `(optional + at_least_one collapses to optional + multiple — use count=multiple.)`,
+  );
+}
+
 export function pairFromMultiplicity(name) {
   const pair = PAIR_BY_NAME[name];
   if (pair == null) {
@@ -92,9 +103,3 @@ export function resolveMultiplicity(member) {
   return DEFAULT_MULTIPLICITY;
 }
 
-function invalidCombinationError(presence, count) {
-  return new Error(
-    `Invalid multiplicity combination: presence=${presence}, count=${count}. ` +
-    `(optional + at_least_one collapses to optional + multiple — use count=multiple.)`,
-  );
-}

package/src/models/partitive-hyperedge.js

@@ -1,175 +1,91 @@
-// PartitiveHyperedge — a one-to-many partitive decomposition.
+// PartitiveHyperedge — 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.
 //
-// One comprehensive concept (the whole) is related to one or more
-// parts as a SINGLE relationship. Captures invariants that binary
-// RelatedConcept edges cannot:
+// Extends AbstractHyperedge; the leaf-specific concern is the
+// PartitiveMember type for `members`. The wire-level field name
+// stays `partitives` for v1/v2 backward compat.
 //
-//   - which comprehensive owns which parts (set membership)
-//   - plurality markers from the source diagram (double / dashed)
-//   - enumeration completeness (closed: all parts listed; open:
-//     other parts may exist)
+// ISO 704:2022 rake diagram semantics:
 //
-// See concept-model/TODO.hyperedge/00-design-overview.md for the
-// design rationale.
+//   comprehensive concept
+//   ─────────────────────
+//   │ partitive (one or more) with per-member multiplicity + optional delimiting
+//   ─────────────────────
 //
-// Hyperedges coexist with binary `broader_partitive` /
-// `narrower_partitive` edges. Use a binary edge for pairwise
-// relationships without diagram metadata; use a hyperedge when the
-// relationship is one-to-many with enumeration/marker metadata.
-
-import { GlossaristModel } from './base.js';
-import { ConceptRef } from './concept-ref.js';
-import {
-  PARTITIVE_ENUMERATION,
-  PARTITIVE_ENUMERATION_VALUES,
-  isValidPartitiveEnumeration,
-} from './partitive-enumeration.js';
-import {
-  PLURALITY_MARKER_VALUES,
-  isValidPluralityMarker,
-} from './plurality-marker.js';
-
-const DEFAULT_ENUMERATION = PARTITIVE_ENUMERATION.CLOSED;
+// 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 PartitiveHyperedge (ISO requires
+// "two or more").
+
+import { AbstractHyperedge } from './abstract-hyperedge.js';
+import { PartitiveMember } from './partitive-member.js';
+import { HyperedgeRegistry } from './hyperedge-registry.js';
+
+export class PartitiveHyperedge extends AbstractHyperedge {
+  // Per-class metadata block — the OCP contract. External systems
+  // (parser, serializer, diff, RDF emitter, validators) read from
+  // these statics and the HyperedgeRegistry. Adding a new hyperedge
+  // type = declaring these fields on a new subclass + registering
+  // it. Nothing else in the codebase changes.
+  static wireKey     = 'partitive_relations';
+  static typeTag     = 'partitive_relation';
+  static rdfType     = 'gloss:PartitiveRelation';
+  static memberClass = PartitiveMember;
+  static v1WireKeys  = ['partitive_hyperedges'];
+  static kindLabel   = 'PART';
 
-export class PartitiveHyperedge extends GlossaristModel {
   constructor(data = {}) {
-    super();
-    this.comprehensive = ensureConceptRef(data.comprehensive, 'comprehensive');
-    this.parts = ensureConceptRefArray(data.parts, 'parts');
-    this.enumeration = resolveEnumeration(data.enumeration);
-    this.markers = validateMarkers(data.markers ?? []);
-    this.content = normalizeContent(data.content);
-
-    assertNonEmptyParts(this.parts);
-    assertNoSelfLoop(this.comprehensive, this.parts);
-  }
-
-  get isClosed() { return this.enumeration === PARTITIVE_ENUMERATION.CLOSED; }
-  get isOpen() { return this.enumeration === PARTITIVE_ENUMERATION.OPEN; }
-  get isMarked() { return this.markers.length > 0; }
-
-  hasMarker(value) {
-    return this.markers.includes(value);
+    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);
   }
 
-  hasEnumeration(value) {
-    return this.enumeration === value;
-  }
-
-  get contentString() {
-    if (!this.content) return null;
-    const values = Object.values(this.content);
-    return values.length > 0 ? values[0] : null;
-  }
+  get partitives() { return this.members; }
 
   toJSON() {
-    const obj = {
-      comprehensive: this.comprehensive.toJSON(),
-      parts: this.parts.map(p => p.toJSON()),
-      enumeration: this.enumeration,
-    };
-    if (this.markers.length > 0) obj.markers = [...this.markers];
-    if (this.content != null) obj.content = this.content;
-    return obj;
+    const base = super.toJSON();
+    const { members, ...rest } = base;
+    return { ...rest, partitives: members };
   }
 
   static identityOf(value) {
     const v = value ?? {};
     const c = v.comprehensive ?? {};
-    const parts = Array.isArray(v.parts) ? v.parts : [];
-    const partsStr = parts
-      .map(p => `${p?.source ?? ''}:${p?.id ?? ''}`)
-      .sort();
-    return `${c.source ?? ''}:${c.id ?? ''}|${partsStr.join('|')}`;
-  }
-
-  identity() {
-    return PartitiveHyperedge.identityOf(this);
+    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) {
-    return new PartitiveHyperedge(data);
-  }
-}
-
-function resolveEnumeration(value) {
-  if (value == null) return DEFAULT_ENUMERATION;
-  if (!isValidPartitiveEnumeration(value)) {
-    throw new Error(
-      `invalid enumeration ${JSON.stringify(value)}; ` +
-      `must be one of ${PARTITIVE_ENUMERATION_VALUES.join(', ')}`,
-    );
+    const normalized = { ...(data ?? {}), members: data?.partitives ?? data?.members };
+    return new PartitiveHyperedge(normalized);
   }
-  return value;
 }
 
-function validateMarkers(values) {
-  const arr = Array.isArray(values) ? values : [values];
-  const seen = new Set();
-  for (const m of arr) {
-    if (!isValidPluralityMarker(m)) {
-      throw new Error(
-        `invalid plurality marker ${JSON.stringify(m)}; ` +
-        `must be one of ${PLURALITY_MARKER_VALUES.join(', ')}`,
-      );
-    }
-    if (seen.has(m)) {
-      throw new Error(
-        `duplicate plurality marker ${JSON.stringify(m)} in partitive_hyperedge`,
-      );
-    }
-    seen.add(m);
-  }
-  return arr;
-}
-
-function ensureConceptRef(value, fieldName) {
-  const ref = value instanceof ConceptRef ? value : new ConceptRef(value ?? {});
-  if (!ref.source && !ref.id) {
-    throw new Error(
-      `PartitiveHyperedge#${fieldName} must be a non-empty ConceptRef ` +
-      `(source or id required)`,
-    );
-  }
-  return ref;
-}
-
-function ensureConceptRefArray(values, fieldName) {
-  if (!Array.isArray(values)) values = values == null ? [] : [values];
-  return values.map((v, i) => ensureConceptRef(v, `${fieldName}[${i}]`));
-}
-
-function assertNonEmptyParts(parts) {
-  if (!parts || parts.length === 0) {
-    throw new Error('PartitiveHyperedge requires at least one part');
-  }
-}
-
-function assertNoSelfLoop(comprehensive, parts) {
-  const cKey = `${comprehensive.source ?? ''}:${comprehensive.id ?? ''}`;
-  for (const p of parts) {
-    const pKey = `${p.source ?? ''}:${p.id ?? ''}`;
-    if (pKey === cKey) {
-      throw new Error('PartitiveHyperedge#parts cannot include the comprehensive');
-    }
-  }
-}
+export default PartitiveHyperedge;
 
-// Content is a localized string (language -> text). Plain strings on
-// input are normalized to `{ default: '...' }` so callers always see
-// the same shape. `null` is preserved.
-//
-// Cross-repo symmetry: glossarist-ruby's `PartitiveHyperedge#content=`
-// (lib/glossarist/v3/partitive_hyperedge.rb) applies the same
-// normalization since commit c917846 (was previously a plain string;
-// aligned with invariant I7 in TODO.hyperedges round 1, item 29).
-// Datasets now round-trip identically across repos.
-function normalizeContent(value) {
-  if (value == null) return null;
-  if (typeof value === 'string') return { default: value };
-  if (typeof value === 'object') {
-    const entries = Object.entries(value).filter(([, v]) => typeof v === 'string');
-    return entries.length > 0 ? Object.fromEntries(entries) : null;
-  }
-  return null;
-}
+HyperedgeRegistry.register(PartitiveHyperedge);

package/src/models/partitive-member.js

@@ -1,6 +1,6 @@
-// PartitiveMember — one member of a PartitiveRelation. Inherits the
-// ISO 704:2022 MECE shape from ConceptSystemMember; the `comprehensive`
-// of its parent PartitiveRelation denotes the whole concept.
+// PartitiveMember — one member of a PartitiveHyperedge. Inherits the
+// ISO 704:2022 MECE shape from HyperedgeMember; the `comprehensive`
+// of its parent PartitiveHyperedge denotes the whole concept.
 //
 // Distinct leaf class for type safety and to leave room for
 // Partitive-specific extensions.
@@ -15,10 +15,10 @@
 // optional, the at-least-one constraint is vacuous and collapses to
 // (optional, multiple). Rejected at construction.
 
-import { ConceptSystemMember } from './concept-system-member.js';
+import { HyperedgeMember } from './hyperedge-member.js';
 
-export class PartitiveMember extends ConceptSystemMember {
-  // Inherits all attributes and validations from ConceptSystemMember.
+export class PartitiveMember extends HyperedgeMember {
+  // Inherits all attributes and validations from HyperedgeMember.
   // Declared as a distinct class for type safety and to leave room
   // for future partitive-specific extensions.
 }

package/src/models/relation-loader.js

@@ -1,33 +1,38 @@
-// 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 { PartitiveRelation } from './partitive-relation.js';
-import { GenericRelation } from './generic-relation.js';
+import { HyperedgeRegistry } from './hyperedge-registry.js';
 
-/**
- * Per-type class dispatch. Keys are the `type` field of the relation
- * file. Adding a new relation type (e.g. AssociativeRelation) means
- * one entry here plus one new class.
- */
-export const TYPE_TO_CLASS = Object.freeze({
-  partitive_relation: PartitiveRelation,
-  generic_relation: GenericRelation,
+// 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 };
+  },
 });
 
 /**
@@ -50,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();
@@ -84,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,
@@ -101,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;
   }
 }