glossarist 0.4.19 → 0.4.22

package/src/rdf/gloss-concept.js

@@ -7,6 +7,8 @@ import { PRED } from './predicates.js';
 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 { namedNode, literal, quad } from './terms.js';
 
 // Kind tag → URI segment. Each NonVerbalReference subtype has a
@@ -69,4 +71,28 @@ export function* conceptToQuads(concept, options) {
     yield* conceptSourceToQuads(source, { subjectUri, index: srcIndex });
     srcIndex += 1;
   }
+
+  // v2 canonical: concept.partitiveRelations. v1 alias
+  // (concept.partitiveHyperedges) points at the same array — both
+  // work here.
+  const relations = concept.partitiveRelations ?? concept.partitiveHyperedges ?? [];
+  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 });
+    }
+    relIdx += 1;
+  }
 }

package/src/rdf/gloss-hyperedge.js

@@ -0,0 +1,90 @@
+// 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'}:`;
+}

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

@@ -0,0 +1,88 @@
+// PartitiveRelation → RDF quads.
+//
+// Shape (per concept-model ontology, v3.2.0):
+//
+//   <base>/partitive-relation/<carrying-id>/<comprehensive-id>
+//     rdf:type                       gloss:PartitiveRelation
+//     gloss:comprehensive            <base>/concept/<comprehensive-id>      (named node)
+//     gloss:hasPartitive             <base>/concept/<partitive-id>         (named node, one per member)
+//     gloss:completeness             "complete"|"partial"                   (literal)
+//     gloss:criterion                "..."@lang                             (one per language, when present)
+//
+// Per-member multiplicity + is_delimiting are emitted as part of
+// each member's named-node object via the partitiveMemberToQuads
+// helper (separate file).
+//
+// The carrying concept links via `gloss:hasPartitiveRelation`.
+//
+// Replaces gloss-hyperedge.js (the v1 emitter) per TODO.partitive-relation-v2 item 01.
+// Cross-repo alignment with glossarist-ruby's Rdf::GlossPartitiveRelation.
+
+import { PRED } from './predicates.js';
+import { WELL_KNOWN } from './prefixes.js';
+import { namedNode, literal, quad } from './terms.js';
+
+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));
+
+  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.partitives) ? relation.partitives : [];
+  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(PRED.gloss.hasPartitive), namedNode(memberUri));
+
+    // Per-member multiplicity (ISO 704:2022) and is_delimiting.
+    if (member?.multiplicity) {
+      yield quad(namedNode(memberUri), namedNode(PRED.gloss.multiplicity),
+        literal(member.multiplicity));
+    }
+    if (member?.is_delimiting === true) {
+      yield quad(namedNode(memberUri), namedNode(PRED.gloss.isDelimiting),
+        literal('true', 'xsd:boolean'));
+    }
+  }
+
+  if (relation.completeness) {
+    yield quad(s, namedNode(PRED.gloss.completeness), literal(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>/partitive-relation/<carrying-id>/<comprehensive-id>`.
+// Matches the Ruby emitter's scheme. Falls back to an index suffix if
+// the comprehensive has no id, so two relations on the same concept
+// never collide.
+export function partitiveRelationSubjectUri(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}/partitive-relation/${carrierId}/${compId}`;
+}
+
+// ConceptRef URI resolution: `<base>/concept/<id>` for any ref with an
+// id. Source is dropped (matches Ruby). Falls back to a stable urn:/
+// form for refs with only a source (rare).
+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-source.js

@@ -30,7 +30,7 @@ export function* conceptSourceToQuads(source, { subjectUri, index }) {
     yield* citationToQuads(source.origin, { subjectUri: srcSubject, predicate: PRED.gloss.sourceOrigin, bnodeKey: 'origin' });
   }
 
-  const sourcedFrom = source.sourced_from ?? [];
+  const sourcedFrom = source.sourcedFrom ?? source.sourced_from ?? [];
   for (let i = 0; i < sourcedFrom.length; i++) {
     yield* citationToQuads(sourcedFrom[i], { subjectUri: srcSubject, predicate: PRED.gloss.sourcedFrom, bnodeKey: 'sourced_from', index: i });
   }

package/src/rdf/index.d.ts

@@ -11,6 +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 } from '../models/index';
 
 export { PRED, PREFIXES } from './predicates';
 export type PredicateMap = typeof PRED;
@@ -77,6 +78,42 @@ export interface ConceptSourceEmitOptions {
 
 export declare function conceptSourceToQuads(source: ConceptSource, options: ConceptSourceEmitOptions): Generator<Quad, void, unknown>;
 
+// ── Hyperedge emitter ─────────────────────────────────────────────────
+
+export interface HyperedgeEmitOptions {
+  parentUri: string;
+  index: number;
+}
+
+export declare function hyperedgeToQuads(
+  hyperedge: PartitiveHyperedge,
+  options: HyperedgeEmitOptions,
+): Generator<Quad, void, unknown>;
+
+export declare function hyperedgeSubjectUri(
+  parentUri: string,
+  hyperedge: PartitiveHyperedge,
+  index: number,
+): string;
+
+// ── PartitiveRelation emitter (v2) ────────────────────────────────────
+
+export interface PartitiveRelationEmitOptions {
+  parentUri: string;
+  index: number;
+}
+
+export declare function partitiveRelationToQuads(
+  relation: PartitiveRelation,
+  options: PartitiveRelationEmitOptions,
+): Generator<Quad, void, unknown>;
+
+export declare function partitiveRelationSubjectUri(
+  parentUri: string,
+  relation: PartitiveRelation,
+  index: number,
+): string;
+
 // ── Non-verbal representation emitters ─────────────────────────────────
 
 export interface NonVerbalRepEmitOptions {

package/src/rdf/index.js

@@ -26,6 +26,8 @@ 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 { partitiveRelationToQuads, partitiveRelationSubjectUri } from './gloss-partitive-relation.js';
 export {
   nonVerbalRepToQuads,
   nonVerbalEntityToQuads,

package/src/rdf/predicates.d.ts

@@ -23,6 +23,9 @@ export declare const PRED = {
     "ConceptRef": "https://www.glossarist.org/ontologies/ConceptRef",
     "Reference": "https://www.glossarist.org/ontologies/Reference",
     "RelatedConcept": "https://www.glossarist.org/ontologies/RelatedConcept",
+    "PartitiveHyperedge": "https://www.glossarist.org/ontologies/PartitiveHyperedge",
+    "PartitiveEnumeration": "https://www.glossarist.org/ontologies/PartitiveEnumeration",
+    "PluralityMarker": "https://www.glossarist.org/ontologies/PluralityMarker",
     "DesignationRelationship": "https://www.glossarist.org/ontologies/DesignationRelationship",
     "ConceptDate": "https://www.glossarist.org/ontologies/ConceptDate",
     "NonVerbalRepresentation": "https://www.glossarist.org/ontologies/NonVerbalRepresentation",
@@ -42,6 +45,7 @@ export declare const PRED = {
     "isLocalizationOf": "https://www.glossarist.org/ontologies/isLocalizationOf",
     "hasStatus": "https://www.glossarist.org/ontologies/hasStatus",
     "hasDomain": "https://www.glossarist.org/ontologies/hasDomain",
+    "tag": "https://www.glossarist.org/ontologies/tag",
     "hasRelatedConcept": "https://www.glossarist.org/ontologies/hasRelatedConcept",
     "hasDate": "https://www.glossarist.org/ontologies/hasDate",
     "hasSource": "https://www.glossarist.org/ontologies/hasSource",
@@ -93,7 +97,26 @@ export declare const PRED = {
     "relationshipType": "https://www.glossarist.org/ontologies/relationshipType",
     "relationshipContent": "https://www.glossarist.org/ontologies/relationshipContent",
     "relationshipRef": "https://www.glossarist.org/ontologies/relationshipRef",
+    "relatedConceptBroader": "https://www.glossarist.org/ontologies/relatedConceptBroader",
+    "relatedConceptNarrower": "https://www.glossarist.org/ontologies/relatedConceptNarrower",
+    "hasPartitiveHyperedge": "https://www.glossarist.org/ontologies/hasPartitiveHyperedge",
+    "comprehensive": "https://www.glossarist.org/ontologies/comprehensive",
+    "hasPart": "https://www.glossarist.org/ontologies/hasPart",
+    "enumeration": "https://www.glossarist.org/ontologies/enumeration",
+    "hasPluralityMarker": "https://www.glossarist.org/ontologies/hasPluralityMarker",
+    "hyperedgeContent": "https://www.glossarist.org/ontologies/hyperedgeContent",
+    "PartitiveRelation": "https://www.glossarist.org/ontologies/PartitiveRelation",
+    "PartitiveMember": "https://www.glossarist.org/ontologies/PartitiveMember",
+    "hasPartitiveRelation": "https://www.glossarist.org/ontologies/hasPartitiveRelation",
+    "hasPartitive": "https://www.glossarist.org/ontologies/hasPartitive",
+    "completeness": "https://www.glossarist.org/ontologies/completeness",
+    "multiplicity": "https://www.glossarist.org/ontologies/multiplicity",
+    "isDelimiting": "https://www.glossarist.org/ontologies/isDelimiting",
+    "criterion": "https://www.glossarist.org/ontologies/criterion",
+    "provides": "https://www.glossarist.org/ontologies/provides",
+    "providedBy": "https://www.glossarist.org/ontologies/providedBy",
     "refType": "https://www.glossarist.org/ontologies/refType",
+    "source": "https://www.glossarist.org/ontologies/source",
     "urn": "https://www.glossarist.org/ontologies/urn",
     "term": "https://www.glossarist.org/ontologies/term",
     "refId": "https://www.glossarist.org/ontologies/refId",
@@ -282,6 +305,9 @@ export type Predicate =
   | "https://www.glossarist.org/ontologies/ConceptRef"
   | "https://www.glossarist.org/ontologies/Reference"
   | "https://www.glossarist.org/ontologies/RelatedConcept"
+  | "https://www.glossarist.org/ontologies/PartitiveHyperedge"
+  | "https://www.glossarist.org/ontologies/PartitiveEnumeration"
+  | "https://www.glossarist.org/ontologies/PluralityMarker"
   | "https://www.glossarist.org/ontologies/DesignationRelationship"
   | "https://www.glossarist.org/ontologies/ConceptDate"
   | "https://www.glossarist.org/ontologies/NonVerbalRepresentation"
@@ -301,6 +327,7 @@ export type Predicate =
   | "https://www.glossarist.org/ontologies/isLocalizationOf"
   | "https://www.glossarist.org/ontologies/hasStatus"
   | "https://www.glossarist.org/ontologies/hasDomain"
+  | "https://www.glossarist.org/ontologies/tag"
   | "https://www.glossarist.org/ontologies/hasRelatedConcept"
   | "https://www.glossarist.org/ontologies/hasDate"
   | "https://www.glossarist.org/ontologies/hasSource"
@@ -352,7 +379,26 @@ export type Predicate =
   | "https://www.glossarist.org/ontologies/relationshipType"
   | "https://www.glossarist.org/ontologies/relationshipContent"
   | "https://www.glossarist.org/ontologies/relationshipRef"
+  | "https://www.glossarist.org/ontologies/relatedConceptBroader"
+  | "https://www.glossarist.org/ontologies/relatedConceptNarrower"
+  | "https://www.glossarist.org/ontologies/hasPartitiveHyperedge"
+  | "https://www.glossarist.org/ontologies/comprehensive"
+  | "https://www.glossarist.org/ontologies/hasPart"
+  | "https://www.glossarist.org/ontologies/enumeration"
+  | "https://www.glossarist.org/ontologies/hasPluralityMarker"
+  | "https://www.glossarist.org/ontologies/hyperedgeContent"
+  | "https://www.glossarist.org/ontologies/PartitiveRelation"
+  | "https://www.glossarist.org/ontologies/PartitiveMember"
+  | "https://www.glossarist.org/ontologies/hasPartitiveRelation"
+  | "https://www.glossarist.org/ontologies/hasPartitive"
+  | "https://www.glossarist.org/ontologies/completeness"
+  | "https://www.glossarist.org/ontologies/multiplicity"
+  | "https://www.glossarist.org/ontologies/isDelimiting"
+  | "https://www.glossarist.org/ontologies/criterion"
+  | "https://www.glossarist.org/ontologies/provides"
+  | "https://www.glossarist.org/ontologies/providedBy"
   | "https://www.glossarist.org/ontologies/refType"
+  | "https://www.glossarist.org/ontologies/source"
   | "https://www.glossarist.org/ontologies/urn"
   | "https://www.glossarist.org/ontologies/term"
   | "https://www.glossarist.org/ontologies/refId"

package/src/rdf/predicates.js

@@ -23,6 +23,9 @@ export const PRED = {
     "ConceptRef": "https://www.glossarist.org/ontologies/ConceptRef",
     "Reference": "https://www.glossarist.org/ontologies/Reference",
     "RelatedConcept": "https://www.glossarist.org/ontologies/RelatedConcept",
+    "PartitiveHyperedge": "https://www.glossarist.org/ontologies/PartitiveHyperedge",
+    "PartitiveEnumeration": "https://www.glossarist.org/ontologies/PartitiveEnumeration",
+    "PluralityMarker": "https://www.glossarist.org/ontologies/PluralityMarker",
     "DesignationRelationship": "https://www.glossarist.org/ontologies/DesignationRelationship",
     "ConceptDate": "https://www.glossarist.org/ontologies/ConceptDate",
     "NonVerbalRepresentation": "https://www.glossarist.org/ontologies/NonVerbalRepresentation",
@@ -42,6 +45,7 @@ export const PRED = {
     "isLocalizationOf": "https://www.glossarist.org/ontologies/isLocalizationOf",
     "hasStatus": "https://www.glossarist.org/ontologies/hasStatus",
     "hasDomain": "https://www.glossarist.org/ontologies/hasDomain",
+    "tag": "https://www.glossarist.org/ontologies/tag",
     "hasRelatedConcept": "https://www.glossarist.org/ontologies/hasRelatedConcept",
     "hasDate": "https://www.glossarist.org/ontologies/hasDate",
     "hasSource": "https://www.glossarist.org/ontologies/hasSource",
@@ -93,7 +97,26 @@ export const PRED = {
     "relationshipType": "https://www.glossarist.org/ontologies/relationshipType",
     "relationshipContent": "https://www.glossarist.org/ontologies/relationshipContent",
     "relationshipRef": "https://www.glossarist.org/ontologies/relationshipRef",
+    "relatedConceptBroader": "https://www.glossarist.org/ontologies/relatedConceptBroader",
+    "relatedConceptNarrower": "https://www.glossarist.org/ontologies/relatedConceptNarrower",
+    "hasPartitiveHyperedge": "https://www.glossarist.org/ontologies/hasPartitiveHyperedge",
+    "comprehensive": "https://www.glossarist.org/ontologies/comprehensive",
+    "hasPart": "https://www.glossarist.org/ontologies/hasPart",
+    "enumeration": "https://www.glossarist.org/ontologies/enumeration",
+    "hasPluralityMarker": "https://www.glossarist.org/ontologies/hasPluralityMarker",
+    "hyperedgeContent": "https://www.glossarist.org/ontologies/hyperedgeContent",
+    "PartitiveRelation": "https://www.glossarist.org/ontologies/PartitiveRelation",
+    "PartitiveMember": "https://www.glossarist.org/ontologies/PartitiveMember",
+    "hasPartitiveRelation": "https://www.glossarist.org/ontologies/hasPartitiveRelation",
+    "hasPartitive": "https://www.glossarist.org/ontologies/hasPartitive",
+    "completeness": "https://www.glossarist.org/ontologies/completeness",
+    "multiplicity": "https://www.glossarist.org/ontologies/multiplicity",
+    "isDelimiting": "https://www.glossarist.org/ontologies/isDelimiting",
+    "criterion": "https://www.glossarist.org/ontologies/criterion",
+    "provides": "https://www.glossarist.org/ontologies/provides",
+    "providedBy": "https://www.glossarist.org/ontologies/providedBy",
     "refType": "https://www.glossarist.org/ontologies/refType",
+    "source": "https://www.glossarist.org/ontologies/source",
     "urn": "https://www.glossarist.org/ontologies/urn",
     "term": "https://www.glossarist.org/ontologies/term",
     "refId": "https://www.glossarist.org/ontologies/refId",

package/src/reference-resolver.js

@@ -38,6 +38,17 @@ function refTarget(rc) {
   return '';
 }
 
+// Extract a concept-ref target from a hyperedge comprehensive/part
+// ConceptRef. Returns the id (preferred) or source. Returns '' if
+// the ref is empty (the constructor already rejects empty refs; this
+// is a defensive guard for data that bypassed the constructor).
+function hyperedgeRefTarget(ref) {
+  if (!ref) return '';
+  if (ref.id) return ref.id;
+  if (ref.source) return ref.source;
+  return '';
+}
+
 export function resolveBibliographyRecord(citationRef, registry) {
   if (!citationRef?.source || !citationRef?.id) return null;
   const bioColl = registry[`bibliography:${citationRef.source}`]?.concepts;
@@ -73,6 +84,44 @@ 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 ?? [];
+    for (let i = 0; i < relations.length; i++) {
+      const rel = relations[i];
+      const relPath = `partitiveRelations[${i}]`;
+
+      const compTarget = hyperedgeRefTarget(rel.comprehensive);
+      if (compTarget) {
+        refs.push(new Reference(
+          'concept',
+          compTarget,
+          'partitive_relation',
+          `${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 ?? [];
+      for (let j = 0; j < members.length; j++) {
+        const m = members[j];
+        const memberRef = m?.ref ?? m;
+        const pTarget = hyperedgeRefTarget(memberRef);
+        if (!pTarget) continue;
+        refs.push(new Reference(
+          'concept',
+          pTarget,
+          'partitive_relation',
+          `${relPath}.partitives[${j}]`,
+          { lookupKey: { id: pTarget } },
+        ));
+      }
+    }
+
     for (const ref of concept.figures) {
       refs.push(new Reference('figure', ref.display ?? ref.entityId, 'structural', 'figures', {
         lookupKey: { entityType: 'figure', entityId: ref.entityId },

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

@@ -0,0 +1,74 @@
+// 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.
+//
+// Per TODO.partitive-relation-v2 item 14, binary edges and
+// PartitiveRelations coexist by design. The asymmetry is pragmatic:
+// binary edges are compact for single pairwise facts; relations
+// carry completeness/plurality/criterion metadata. The redundancy
+// case (same fact encoded both ways) is harmless data-wise but
+// wasteful and should be flagged for migration.
+//
+// Severity: warning. Never blocks save.
+
+import { ValidationRule } from './validation-rule.js';
+
+const BINARY_HAS_PART_TYPES = new Set(['has_part', 'is_part_of']);
+
+export class BinaryHasPartRedundancyRule extends ValidationRule {
+  constructor() { super('binary-has-part-redundancy', 'warning'); }
+
+  validate(concept, path, result) {
+    const relations = concept.partitiveRelations ?? concept.partitiveHyperedges ?? [];
+
+    // Collect partitive refs from PartitiveRelations.
+    const relationTargets = new Set();
+    for (const rel of relations) {
+      const compKey = _refKey(rel?.comprehensive);
+      const members = rel?.partitives ?? rel?.parts ?? [];
+      for (const member of members) {
+        const ref = member?.ref ?? member;
+        const key = _refKey(ref);
+        if (key && key !== compKey) relationTargets.add(key);
+      }
+    }
+
+    // Collect binary has_part refs.
+    const binaryTargets = new Set();
+    const related = concept.relatedConcepts ?? [];
+    for (const rc of related) {
+      if (!BINARY_HAS_PART_TYPES.has(rc.type)) continue;
+      const key = _refKey(rc?.ref);
+      if (key) binaryTargets.add(key);
+    }
+
+    // Redundancy: refs in both.
+    for (const target of relationTargets) {
+      if (binaryTargets.has(target)) {
+        this.addIssue(result,
+          `${path}relatedConcepts`,
+          `binary has_part edge for (${target}) is redundant — already in a ` +
+          `PartitiveRelation member; pick one encoding to avoid divergence`,
+        );
+      }
+    }
+
+    // Cluster: 3+ binary has_part edges suggests PartitiveRelation 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 ` +
+        `completeness, plurality, and criterion metadata)`,
+      );
+    }
+  }
+}
+
+function _refKey(ref) {
+  if (!ref) return null;
+  const source = ref.source ?? '';
+  const id = ref.id ?? '';
+  if (!source && !id) return null;
+  return `${source}:${id}`;
+}

package/src/validators/external-concept-shape-rule.js

@@ -0,0 +1,60 @@
+// Validates ExternalConcept shape (status: external).
+//
+// Per TODO.partitive-relation-v2 item 06, an ExternalConcept is a
+// ManagedConcept with status: external. External concepts:
+//   - MUST have at least one designation (the name by which they're referenced)
+//   - MUST NOT have a definition (contradicts status: external)
+//   - MUST NOT have sources (we don't define them)
+//
+// Severity: error. An external concept with a definition or sources
+// contradicts the semantic role of "external" and should be re-typed
+// to a real concept status (valid, draft, etc.).
+
+import { ValidationRule } from './validation-rule.js';
+
+export class ExternalConceptShapeRule extends ValidationRule {
+  constructor() { super('external-concept-shape', 'error'); }
+
+  validate(concept, path, result) {
+    if (concept.status !== 'external') return;
+
+    // Every concept — even an external one — needs at least one
+    // designation (the name by which it is referenced).
+    let designationCount = 0;
+    for (const lang of concept.languages ?? []) {
+      const lc = concept.localization?.(lang);
+      if (!lc) continue;
+      designationCount += (lc.terms ?? []).length;
+    }
+    if (designationCount === 0) {
+      this.addIssue(result,
+        `${path}localizations.*.terms`,
+        'ExternalConcept has no designations; every concept (including external) ' +
+        'needs at least one designation (the name by which it is referenced)',
+      );
+    }
+
+    // External concepts must NOT have a definition or sources.
+    for (const lang of concept.languages ?? []) {
+      const lc = concept.localization?.(lang);
+      if (!lc) continue;
+
+      if ((lc.definitions ?? []).length > 0) {
+        this.addIssue(result,
+          `${path}localizations.${lang}.definitions`,
+          `ExternalConcept has a definition in language '${lang}'; ` +
+          `external concepts are referenced but not defined here ` +
+          `(move the definition to the providing dataset and add a provided_by edge)`,
+        );
+      }
+
+      if ((lc.sources ?? []).length > 0) {
+        this.addIssue(result,
+          `${path}localizations.${lang}.sources`,
+          `ExternalConcept has sources in language '${lang}'; ` +
+          `external concepts should not carry sources (sources belong on the providing concept)`,
+        );
+      }
+    }
+  }
+}