glossarist 0.4.23 → 0.4.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glossarist",
-  "version": "0.4.23",
+  "version": "0.4.25",
   "description": "JavaScript SDK for Glossarist GCR packages — read, write, validate, and manage terminology concepts",
   "type": "module",
   "main": "src/index.js",

package/src/diff/diff-renderer.js

@@ -205,7 +205,10 @@ function relationLabel(r) {
   const partitives = Array.isArray(r.partitives)
     ? r.partitives.map(m => {
         const ref = m?.ref ?? m ?? {};
-        const tail = m?.certainty === 'possible' ? '?' : '';
+        let tail = '';
+        const mult = m?.multiplicity;
+        if (mult && mult !== 'compulsory') tail = ` (${mult})`;
+        if (m?.is_delimiting === true) tail += ' ⊘';
         return `${ref.id ?? ref.source ?? ref.text ?? '?'}${tail}`;
       }).join(', ')
     : '';
@@ -213,22 +216,25 @@ function relationLabel(r) {
   const criterion = r.criterion
     ? ` / ${Object.values(r.criterion)[0] ?? ''}`
     : '';
-  const plurality = r.plurality
-    ? ` [${_pluralityLabel(r.plurality)}]`
-    : '';
-  return `${head} → {${partitives}}${completeness}${criterion}${plurality}`;
+  return `${head} → {${partitives}}${completeness}${criterion}`;
 }
 
-function _pluralityLabel(p) {
-  if (!p) return '';
-  const flags = [];
-  if (p.is_shared) flags.push('shared');
-  if (p.is_uncertain) flags.push('uncertain');
-  if (p.shared_type) {
-    const t = p.shared_type;
-    flags.push(`type=${t.id ?? t.source ?? '?'}`);
+// Aggregate multiplicity + delimiting stats across a concept's
+// PartitiveRelations. Used by dataset-level summaries, not by the
+// per-relation diff label.
+export function multiplicityStats(relations) {
+  const byMultiplicity = {};
+  let delimitingCount = 0;
+  let total = 0;
+  for (const rel of relations ?? []) {
+    for (const m of rel?.partitives ?? []) {
+      total += 1;
+      const k = m?.multiplicity ?? 'compulsory';
+      byMultiplicity[k] = (byMultiplicity[k] ?? 0) + 1;
+      if (m?.is_delimiting === true) delimitingCount += 1;
+    }
   }
-  return flags.join(',');
+  return { total, byMultiplicity, delimiting: delimitingCount };
 }
 
 function itemLabel(item) {

package/src/migration/partitive-relation-migrator.js

@@ -21,6 +21,25 @@
 // A v1 hyperedge with exactly 1 part cannot migrate to v2 and is
 // returned with a `migrationWarning` field set so callers can decide
 // whether to surface it (the parser drops these with a warning).
+//
+// ─── Migration decision table (v1 markers → v2 multiplicity) ──────
+//
+// v1 markers encoded per-relation plurality claims. v2 multiplicity
+// is per-member. The mapping is lossy; reviewers must set per-member
+// multiplicity individually after migration.
+//
+//   | v1 markers              | Likely multiplicity for each partitive         | Notes                                                  |
+//   |-------------------------|------------------------------------------------|--------------------------------------------------------|
+//   | (none)                  | `compulsory`                                   | Default; reviewer confirms                             |
+//   | `[double]`              | `compulsory_multiple` or `compulsory_at_least_one` | Reviewer distinguishes "all required" from "≥1 required" |
+//   | `[dashed]`              | `optional` or `optional_multiple`              | Reviewer distinguishes single vs multiple              |
+//   | `[double, dashed]`      | `optional_multiple` or `compulsory_at_least_one` | Plurality claim; reviewer distinguishes uncertain vs required |
+//   | (single-part v1 edge)   | (cannot migrate — needs ≥2 partitives)         | Convert to a binary `has_part` edge                    |
+//
+// `is_delimiting` is NEVER set by migration. ISO 704:2022 says
+// delimiting depends on the concept system and coordinate concepts,
+// which migration cannot infer. Reviewer sets it based on domain
+// knowledge (see DelimitingCoherenceRule for cross-relation checks).
 
 export function migrateHyperedgeToRelation(v1Hash) {
   if (v1Hash == null) return null;

package/src/models/partitive-member.js

@@ -6,15 +6,19 @@
 // ISO 704:2022 partitive member notation:
 //
 //   multiplicity (diagram line notation):
-//     compulsory          — 1 solid line (must exist in every instance)
-//     optional            — 1 dashed line (exists in some instances only)
-//     compulsory_multiple — 2 solid lines (multiple must exist)
-//     optional_multiple   — 2 dashed lines (multiple may exist)
-//     compulsory_at_least_one        — 1 solid + 1 dashed line (≥1 must exist)
+//     compulsory                — 1 solid line         (must exist in every instance)
+//     optional                  — 1 dashed line        (exists in some instances only)
+//     compulsory_multiple       — 2 solid lines        (multiple must exist)
+//     optional_multiple         — 2 dashed lines       (multiple may exist)
+//     compulsory_at_least_one  — 1 solid + 1 dashed   (≥1 must exist)
 //
 //   is_delimiting (orthogonal, bold 3x-width line in diagram):
 //     A delimiting part behaves like a delimiting characteristic:
 //     it distinguishes 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).
 
 import { GlossaristModel } from './base.js';
 import { ConceptRef } from './concept-ref.js';
@@ -32,11 +36,14 @@ export class PartitiveMember extends GlossaristModel {
       ? data.ref
       : new ConceptRef(data.ref ?? {});
     this.multiplicity = _resolveMultiplicity(data.multiplicity);
-    this.is_delimiting = data.is_delimiting === true;
+    this.is_delimiting = _resolveBoolean(data.is_delimiting, 'is_delimiting');
 
     _assertNonEmptyRef(this.ref);
   }
 
+  // Per-value multiplicity predicates. Each new enum value gets one
+  // line — OCP-friendly: the predicates grow with the enum without
+  // touching unrelated code. (TODO.partitive-relation-v3/05.)
   get isCompulsory() {
     return this.multiplicity === MULTIPLICITY.COMPULSORY;
   }
@@ -45,6 +52,18 @@ export class PartitiveMember extends GlossaristModel {
     return this.multiplicity === MULTIPLICITY.OPTIONAL;
   }
 
+  get isCompulsoryMultiple() {
+    return this.multiplicity === MULTIPLICITY.COMPULSORY_MULTIPLE;
+  }
+
+  get isOptionalMultiple() {
+    return this.multiplicity === MULTIPLICITY.OPTIONAL_MULTIPLE;
+  }
+
+  get isCompulsoryAtLeastOne() {
+    return this.multiplicity === MULTIPLICITY.COMPULSORY_AT_LEAST_ONE;
+  }
+
   get isDelimiting() {
     return this.is_delimiting === true;
   }
@@ -86,6 +105,17 @@ function _resolveMultiplicity(value) {
   return value;
 }
 
+// Boolean coercion with strict type check. Rejects strings, numbers,
+// objects (silent coercion was the v3 bug TODO.partitive-relation-v3/02).
+function _resolveBoolean(value, fieldName) {
+  if (value == null) return false;
+  if (typeof value === 'boolean') return value;
+  throw new Error(
+    `PartitiveMember.${fieldName} must be a boolean; got ${typeof value} ` +
+    `${JSON.stringify(value)}`,
+  );
+}
+
 function _assertNonEmptyRef(ref) {
   if (!ref.source && !ref.id && !ref.text) {
     throw new Error(

package/src/models/partitive-relation.js

@@ -1,19 +1,33 @@
-// PartitiveRelation — an ISO 704 / ISO 1087-1 / ISO 12620
+// 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.
 //
+// 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).
+//
 // Field renames (v1 → v2):
 //   parts [1..*]              → partitives [2..*]  (as PartitiveMember)
 //   enumeration: closed|open  → completeness: complete|partial
+//   markers: [double, dashed] → (per-member multiplicity + is_delimiting)
 //   content: LocalizedString  → (dropped — structural edges carry no prose)
-//
-// Per-member metadata (ISO 704:2022):
-//   multiplicity (5 values) + is_delimiting (boolean)
-//
-// New field:
-//   criterion: LocalizedString [0..1]  (ISO 12620 coordinate-concept coherence)
+//   plural-positive is_shared / is_uncertain → multiplicity (ISO 704:2022)
 //
 // Distinguished from binary `has_part` / `is_part_of` edges, which
 // express pairwise part-of assertions without completeness,

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

@@ -0,0 +1,39 @@
+// PartitiveMember → RDF quads.
+//
+// Emits per-member predicates (multiplicity, is_delimiting) onto the
+// member's concept URI. The member URI is constructed by the caller
+// (typically `gloss-partitive-relation.js`).
+//
+// Extracted from `gloss-partitive-relation.js` per
+// TODO.partitive-relation-v3/04 so future emitters (a standalone
+// PartitiveMember listing, a stats aggregator) can reuse this
+// emission without modifying the relation emitter (OCP).
+
+import { PRED } from './predicates.js';
+import { namedNode, literal, quad } from './terms.js';
+
+// SKOS taxonomy namespace for multiplicity values. concept-model will
+// ship the corresponding taxonomy; until then, the URIs are forward-
+// compatible and resolve once the taxonomy lands.
+//
+// Per the JSON-LD context (`"@type": "@id"`), multiplicity objects
+// MUST be URI references, not string literals. Emitted shape:
+//   <member-uri> gloss:multiplicity <.../multiplicity/compulsory>
+export const MULTIPLICITY_NS = 'https://www.glossarist.org/ontologies/multiplicity/';
+
+export function* partitiveMemberToQuads(member, { memberUri }) {
+  if (member?.multiplicity) {
+    yield quad(
+      namedNode(memberUri),
+      namedNode(PRED.gloss.multiplicity),
+      namedNode(MULTIPLICITY_NS + member.multiplicity),
+    );
+  }
+  if (member?.is_delimiting === true) {
+    yield quad(
+      namedNode(memberUri),
+      namedNode(PRED.gloss.isDelimiting),
+      literal('true', 'xsd:boolean'),
+    );
+  }
+}

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

@@ -6,22 +6,31 @@
 //     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)
+//     gloss:completeness             <.../completeness/complete|partial>   (named node, SKOS)
+//     gloss:criterion                "..."@lang                             (literal, one per language)
 //
-// Per-member multiplicity + is_delimiting are emitted as part of
-// each member's named-node object via the partitiveMemberToQuads
-// helper (separate file).
+// Per-member multiplicity + is_delimiting are emitted by the
+// `partitiveMemberToQuads` helper in `gloss-partitive-member.js`.
 //
 // The carrying concept links via `gloss:hasPartitiveRelation`.
 //
-// Replaces gloss-hyperedge.js (the v1 emitter) per TODO.partitive-relation-v2 item 01.
+// Replaces gloss-hyperedge.js (the v1 emitter) per
+// TODO.partitive-relation-v2 item 01.
 // Cross-repo alignment with glossarist-ruby's Rdf::GlossPartitiveRelation.
+//
+// JSON-LD `@type: @id` invariant: `multiplicity` and `completeness`
+// are URI references into SKOS taxonomies (per
+// `data/concept-model/glossarist.context.jsonld`), not literals.
+// `criterion` is `@container: @language` (one literal per language).
+// `isDelimiting` is `xsd:boolean` literal.
 
 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/';
+
 export function* partitiveRelationToQuads(relation, { parentUri, index }) {
   const subjectUri = partitiveRelationSubjectUri(parentUri, relation, index);
   const s = namedNode(subjectUri);
@@ -40,20 +49,12 @@ export function* partitiveRelationToQuads(relation, { parentUri, index }) {
     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'));
-    }
+    yield* partitiveMemberToQuads(member, { memberUri });
   }
 
   if (relation.completeness) {
-    yield quad(s, namedNode(PRED.gloss.completeness), literal(relation.completeness));
+    yield quad(s, namedNode(PRED.gloss.completeness),
+      namedNode(COMPLETENESS_NS + relation.completeness));
   }
 
   if (relation.criterion && typeof relation.criterion === 'object') {

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 } from '../models/index';
+import type { PartitiveHyperedge, PartitiveRelation, PartitiveMember } from '../models/index';
 
 export { PRED, PREFIXES } from './predicates';
 export type PredicateMap = typeof PRED;
@@ -114,6 +114,19 @@ export declare function partitiveRelationSubjectUri(
   index: number,
 ): string;
 
+// ── PartitiveMember emitter (per-member multiplicity + is_delimiting) ──
+
+export interface PartitiveMemberEmitOptions {
+  memberUri: string;
+}
+
+export declare const MULTIPLICITY_NS: string;
+
+export declare function partitiveMemberToQuads(
+  member: PartitiveMember,
+  options: PartitiveMemberEmitOptions,
+): Generator<Quad, void, unknown>;
+
 // ── Non-verbal representation emitters ─────────────────────────────────
 
 export interface NonVerbalRepEmitOptions {

package/src/rdf/index.js

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

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

@@ -12,6 +12,7 @@
 // Severity: warning. Never blocks save.
 
 import { ValidationRule } from './validation-rule.js';
+import { refKey } from './ref-keys.js';
 
 const BINARY_HAS_PART_TYPES = new Set(['has_part', 'is_part_of']);
 
@@ -24,11 +25,11 @@ export class BinaryHasPartRedundancyRule extends ValidationRule {
     // Collect partitive refs from PartitiveRelations.
     const relationTargets = new Set();
     for (const rel of relations) {
-      const compKey = _refKey(rel?.comprehensive);
+      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);
+        const key = refKey(ref);
         if (key && key !== compKey) relationTargets.add(key);
       }
     }
@@ -38,7 +39,7 @@ export class BinaryHasPartRedundancyRule extends ValidationRule {
     const related = concept.relatedConcepts ?? [];
     for (const rc of related) {
       if (!BINARY_HAS_PART_TYPES.has(rc.type)) continue;
-      const key = _refKey(rc?.ref);
+      const key = refKey(rc?.ref);
       if (key) binaryTargets.add(key);
     }
 
@@ -59,16 +60,8 @@ export class BinaryHasPartRedundancyRule extends ValidationRule {
         `${path}relatedConcepts`,
         `${binaryTargets.size} binary has_part edges on this concept; ` +
         `consider converting to a PartitiveRelation (which can carry ` +
-        `completeness, plurality, and criterion metadata)`,
+        `completeness, multiplicity, 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/delimiting-coherence-rule.js

@@ -0,0 +1,105 @@
+// Validates delimiting coherence across a concept's PartitiveRelations
+// per ISO 704:2022.
+//
+// ISO 704:2022 (§5.5.4.2.1, rake diagram semantics):
+//   "Whether a part is delimiting depends on the concept system, the
+//    coordinate concepts, the inheritance principle, and the criterion
+//    of subdivision used."
+//
+// 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
+//      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
+//      same criterion but different is_delimiting for the same
+//      partitive ref — inconsistent delimiting claim about the same
+//      part. ISO 704 requires delimiting claims about a given part to
+//      be consistent across decompositions sharing a criterion.
+//   3. WARNING: A partitive marked is_delimiting=true on a relation
+//      with no criterion set. Delimiting is meaningful only relative
+//      to a subdivision criterion.
+//
+// Per TODO.partitive-relation-v3/06.
+
+import { ValidationRule } from './validation-rule.js';
+import { refKey, criterionKey } from './ref-keys.js';
+
+export class DelimitingCoherenceRule extends ValidationRule {
+  constructor() { super('delimiting-coherence'); }
+
+  validate(concept, path, result) {
+    const relations = concept.partitiveRelations ?? concept.partitiveHyperedges ?? [];
+    if (relations.length === 0) return;
+
+    _checkOveruse(relations, path, result);
+    _checkInconsistentAcrossRelations(relations, path, result, this);
+    _checkDelimitingWithoutCriterion(relations, path, result);
+  }
+}
+
+function _checkOveruse(relations, path, result) {
+  for (let i = 0; i < relations.length; i++) {
+    const rel = relations[i];
+    const members = rel?.partitives ?? [];
+    if (members.length < 2) continue;
+    const delimitingCount = members.filter(m => m?.is_delimiting === true).length;
+    if (delimitingCount === members.length) {
+      result.addWarning(
+        `${path}partitiveRelations[${i}]`,
+        `every partitive is marked is_delimiting=true; typically only ` +
+        `some parts distinguish the comprehensive from coordinate concepts`,
+      );
+    }
+  }
+}
+
+function _checkInconsistentAcrossRelations(relations, path, result, rule) {
+  const byCriterion = new Map();
+  for (let i = 0; i < relations.length; i++) {
+    const rel = relations[i];
+    const critKey = criterionKey(rel?.criterion);
+    if (critKey == null) continue;
+    if (!byCriterion.has(critKey)) byCriterion.set(critKey, []);
+    byCriterion.get(critKey).push({ rel, i });
+  }
+
+  for (const [, group] of byCriterion) {
+    const refDelimiting = new Map();
+    for (const { rel, i } of group) {
+      for (const m of rel?.partitives ?? []) {
+        const key = refKey(m?.ref);
+        if (key == null) continue;
+        const delimiting = m?.is_delimiting === true;
+        const existing = refDelimiting.get(key);
+        if (existing != null && existing.delimiting !== delimiting) {
+          rule.addIssue(result,
+            `${path}partitiveRelations[${i}].partitives`,
+            `inconsistent is_delimiting for ref (${key}) across ` +
+            `relations ${existing.relIdx} and ${i} with the same ` +
+            `criterion; ISO 704 requires delimiting claims about the ` +
+            `same part to be consistent`,
+          );
+        } else if (existing == null) {
+          refDelimiting.set(key, { delimiting, relIdx: i });
+        }
+      }
+    }
+  }
+}
+
+function _checkDelimitingWithoutCriterion(relations, path, result) {
+  for (let i = 0; i < relations.length; i++) {
+    const rel = relations[i];
+    if (rel?.criterion) continue;
+    const anyDelimiting = (rel?.partitives ?? []).some(m => m?.is_delimiting === true);
+    if (anyDelimiting) {
+      result.addWarning(
+        `${path}partitiveRelations[${i}].criterion`,
+        `relation has is_delimiting=true on partitives but no criterion; ` +
+        `delimiting is meaningful only relative to a subdivision criterion`,
+      );
+    }
+  }
+}

package/src/validators/index.js

@@ -23,6 +23,7 @@ export { SourcedFromLocalityRule } from './sourced-from-locality-rule.js';
 export { PartitiveRelationCoherenceRule } from './partitive-relation-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';
 
 import { ConceptValidator, LanguageCodeRule, DesignationTypeRule, EntryStatusRule } from './concept-validator.js';
 import { RegisterValidator } from './register-validator.js';
@@ -45,6 +46,7 @@ import { SourcedFromLocalityRule } from './sourced-from-locality-rule.js';
 import { PartitiveRelationCoherenceRule } from './partitive-relation-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';
 
 const _default = new ConceptValidator()
   .addRule(new LanguageCodeRule())
@@ -65,7 +67,8 @@ const _default = new ConceptValidator()
   .addRule(new SourcedFromLocalityRule())
   .addRule(new PartitiveRelationCoherenceRule())
   .addRule(new ExternalConceptShapeRule())
-  .addRule(new BinaryHasPartRedundancyRule());
+  .addRule(new BinaryHasPartRedundancyRule())
+  .addRule(new DelimitingCoherenceRule());
 
 export function validateConcept(concept) {
   return _default.validate(concept);

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

@@ -17,6 +17,7 @@
 // validators enforce semantics.
 
 import { ValidationRule } from './validation-rule.js';
+import { refKey, criterionKey } from './ref-keys.js';
 
 export class PartitiveRelationCoherenceRule extends ValidationRule {
   constructor() { super('partitive-relation-coherence'); }
@@ -43,8 +44,8 @@ export class PartitiveRelationCoherenceRule extends ValidationRule {
     const seen = new Map();
     for (let i = 0; i < relations.length; i++) {
       const rel = relations[i];
-      const compKey = _conceptRefKey(rel?.comprehensive);
-      const critKey = _criterionKey(rel?.criterion);
+      const compKey = refKey(rel?.comprehensive);
+      const critKey = criterionKey(rel?.criterion);
       if (compKey == null || critKey == null) continue;
       const key = `${compKey}|${critKey}`;
       if (seen.has(key)) {
@@ -77,22 +78,3 @@ export class PartitiveRelationCoherenceRule extends ValidationRule {
     // at construction by PartitiveMember itself.)
   }
 }
-
-function _conceptRefKey(ref) {
-  if (!ref) return null;
-  const source = ref.source ?? '';
-  const id = ref.id ?? '';
-  if (!source && !id) return null;
-  return `${source}:${id}`;
-}
-
-function _criterionKey(criterion) {
-  if (!criterion || typeof criterion !== 'object') return null;
-  // Sort values for stable comparison regardless of language key order.
-  const values = Object.values(criterion)
-    .filter(v => typeof v === 'string')
-    .map(s => s.trim())
-    .filter(s => s.length > 0)
-    .sort();
-  return values.length > 0 ? values.join('|') : null;
-}

package/src/validators/ref-keys.js

@@ -0,0 +1,31 @@
+// Shared identity-key helpers for cross-relation validators.
+//
+// Extracted from PartitiveRelationCoherenceRule and
+// BinaryHasPartRedundancyRule per TODO.partitive-relation-v3/06.
+// Eliminates drift: both rules now use the same notion of "same ref"
+// and "same criterion" instead of each defining its own _refKey and
+// _criterionKey with subtly different behaviors.
+
+export function refKey(ref) {
+  if (!ref) return null;
+  const source = ref.source ?? '';
+  const id = ref.id ?? '';
+  if (!source && !id) return null;
+  return `${source}:${id}`;
+}
+
+// Hashable key for a criterion (lang-keyed hash). Returns null when
+// no criterion is set OR when the criterion contains no string values.
+// Values are sorted so two criteria with the same strings in different
+// language-key order produce the same key (ISO 12620 coordinate-
+// concept coherence cares about the criterion's content, not the
+// language label order).
+export function criterionKey(criterion) {
+  if (!criterion || typeof criterion !== 'object') return null;
+  const values = Object.values(criterion)
+    .filter(v => typeof v === 'string')
+    .map(s => s.trim())
+    .filter(s => s.length > 0)
+    .sort();
+  return values.length > 0 ? values.join('|') : null;
+}