glossarist 0.4.24 → 0.4.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glossarist",
-  "version": "0.4.24",
+  "version": "0.4.26",
   "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,36 @@ 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.
+//
+// v4: presence and count are independent dimensions. Stats include
+// byPresence and byCount breakdowns so tools can query each axis
+// independently ("show me all optional parts" or "show me all
+// multiple-count parts").
+export function multiplicityStats(relations) {
+  const byMultiplicity = {};
+  const byPresence = {};
+  const byCount = {};
+  let delimitingCount = 0;
+  let total = 0;
+  for (const rel of relations ?? []) {
+    for (const m of rel?.partitives ?? []) {
+      total += 1;
+      const mult = m?.multiplicity ?? 'compulsory';
+      byMultiplicity[mult] = (byMultiplicity[mult] ?? 0) + 1;
+      const p = m?.presence ?? 'required';
+      const c = m?.count ?? 'exactly_one';
+      byPresence[p] = (byPresence[p] ?? 0) + 1;
+      byCount[c] = (byCount[c] ?? 0) + 1;
+      if (m?.is_delimiting === true) delimitingCount += 1;
+    }
   }
-  return flags.join(',');
+  return { total, byMultiplicity, byPresence, byCount, 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;
@@ -35,7 +54,8 @@ export function migrateHyperedgeToRelation(v1Hash) {
   const parts = Array.isArray(v1Hash.parts) ? v1Hash.parts : [];
   out.partitives = parts.map(ref => ({
     ref: { ...ref },
-    multiplicity: 'compulsory',
+    presence: 'required',
+    count: 'exactly_one',
   }));
 
   out.completeness = _migrateEnumeration(v1Hash.enumeration);

package/src/models/index.js

@@ -38,6 +38,18 @@ export {
 // backward-compat input. New code should use v2 exclusively.
 export { PartitiveRelation } from './partitive-relation.js';
 export { PartitiveMember } from './partitive-member.js';
+export {
+  PARTITIVE_PRESENCE,
+  PARTITIVE_PRESENCE_VALUES,
+  DEFAULT_PRESENCE,
+  isValidPresence,
+} from './partitive-presence.js';
+export {
+  PARTITIVE_COUNT,
+  PARTITIVE_COUNT_VALUES,
+  DEFAULT_COUNT,
+  isValidCount,
+} from './partitive-count.js';
 export {
   COMPLETENESS,
   COMPLETENESS_VALUES,
@@ -49,6 +61,8 @@ export {
   MULTIPLICITY_VALUES,
   DEFAULT_MULTIPLICITY,
   isValidMultiplicity,
+  multiplicityFromPair,
+  pairFromMultiplicity,
 } from './multiplicity.js';
 
 // v1 → v2 migration helper. Pure function; idempotent.

package/src/models/multiplicity.js

@@ -1,24 +1,74 @@
-// Multiplicity — ISO 704:2022 partitive member multiplicity.
+// Multiplicity — ISO 704:2022 partitive multiplicity (derived view).
 //
-// Encodes the diagram line notation as structured data:
-//   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 (at least one must exist)
+// ISO 704:2022 multiplicity is the cross product of two orthogonal
+// dimensions (PartitivePresence × PartitiveCount). The 5 valid
+// combinations map to the 5 ISO 704 names:
 //
-// Defaults to `compulsory` when omitted.
+//   required × exactly_one  → compulsory
+//   optional × exactly_one  → optional
+//   required × multiple     → compulsory_multiple
+//   optional × multiple     → optional_multiple
+//   required × at_least_one → compulsory_at_least_one
+//
+// (optional × at_least_one is REDUNDANT with optional × multiple —
+// "may exist, ≥1 if it does" = "may exist in any number" — and is
+// explicitly rejected at construction with a clear error message.)
+//
+// This module is the SSOT for the (presence, count) → ISO name
+// mapping. Both MULTIPLICITY constants and MULTIPLICITY_VALUES are
+// derived from this single table; no duplicate string literals.
 
-import { makeEnum } from './enum.js';
+import { PARTITIVE_PRESENCE } from './partitive-presence.js';
+import { PARTITIVE_COUNT } from './partitive-count.js';
 
-export const MULTIPLICITY = makeEnum('MULTIPLICITY', {
-  COMPULSORY: 'compulsory',
-  OPTIONAL: 'optional',
-  COMPULSORY_MULTIPLE: 'compulsory_multiple',
-  OPTIONAL_MULTIPLE: 'optional_multiple',
-  COMPULSORY_AT_LEAST_ONE: 'compulsory_at_least_one',
+const NAME_BY_PAIR = Object.freeze({
+  [`${PARTITIVE_PRESENCE.REQUIRED}:${PARTITIVE_COUNT.EXACTLY_ONE}`]:  'compulsory',
+  [`${PARTITIVE_PRESENCE.OPTIONAL}:${PARTITIVE_COUNT.EXACTLY_ONE}`]:  'optional',
+  [`${PARTITIVE_PRESENCE.REQUIRED}:${PARTITIVE_COUNT.MULTIPLE}`]:     'compulsory_multiple',
+  [`${PARTITIVE_PRESENCE.OPTIONAL}:${PARTITIVE_COUNT.MULTIPLE}`]:     'optional_multiple',
+  [`${PARTITIVE_PRESENCE.REQUIRED}:${PARTITIVE_COUNT.AT_LEAST_ONE}`]: 'compulsory_at_least_one',
 });
 
-export const MULTIPLICITY_VALUES = MULTIPLICITY.VALUES;
+const PAIR_BY_NAME = Object.freeze(
+  Object.fromEntries(
+    Object.entries(NAME_BY_PAIR).map(([pair, name]) => [name, pair]),
+  ),
+);
+
+export const MULTIPLICITY = Object.freeze(
+  Object.fromEntries(
+    Object.values(NAME_BY_PAIR).map(name => [name.toUpperCase(), name]),
+  ),
+);
+
+export const MULTIPLICITY_VALUES = Object.freeze(Object.values(NAME_BY_PAIR));
+
 export const DEFAULT_MULTIPLICITY = MULTIPLICITY.COMPULSORY;
-export const isValidMultiplicity = MULTIPLICITY.isValid;
+
+export function multiplicityFromPair(presence, count) {
+  const name = NAME_BY_PAIR[`${presence}:${count}`];
+  if (name == null) {
+    throw invalidCombinationError(presence, count);
+  }
+  return name;
+}
+
+export function pairFromMultiplicity(name) {
+  const pair = PAIR_BY_NAME[name];
+  if (pair == null) {
+    throw new Error(`Unknown multiplicity: ${JSON.stringify(name)}`);
+  }
+  const [presence, count] = pair.split(':');
+  return { presence, count };
+}
+
+export function isValidMultiplicity(name) {
+  return Object.prototype.hasOwnProperty.call(PAIR_BY_NAME, name);
+}
+
+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-count.js

@@ -0,0 +1,20 @@
+// PartitiveCount — ISO 704:2022 partitive member count.
+//
+// count (line count):
+//   exactly_one  — 1 line (exactly one instance)
+//   at_least_one — 1 solid + 1 dashed (at least one instance)
+//   multiple     — 2 lines (multiple instances)
+//
+// Default: exactly_one.
+
+import { makeEnum } from './enum.js';
+
+export const PARTITIVE_COUNT = makeEnum('PARTITIVE_COUNT', {
+  EXACTLY_ONE: 'exactly_one',
+  AT_LEAST_ONE: 'at_least_one',
+  MULTIPLE: 'multiple',
+});
+
+export const PARTITIVE_COUNT_VALUES = PARTITIVE_COUNT.VALUES;
+export const DEFAULT_COUNT = PARTITIVE_COUNT.EXACTLY_ONE;
+export const isValidCount = PARTITIVE_COUNT.isValid;

package/src/models/partitive-member.js

@@ -1,29 +1,35 @@
 // PartitiveMember — one member of a PartitiveRelation.
 //
 // Carries a ConceptRef (the subordinate concept partitive) plus
-// ISO 704:2022 multiplicity and delimiting metadata.
+// ISO 704:2022 presence + count + is_delimiting.
 //
-// ISO 704:2022 partitive member notation:
+// Matches concept-model/models/concepts/PartitiveMember.lutaml exactly:
+//   +ref            — ConceptRef [1]
+//   +presence       — PartitivePresence [0..1] (default: required)
+//   +count          — PartitiveCount [0..1] (default: exactly_one)
+//   +is_delimiting  — Boolean [0..1] (default: false)
 //
-//   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)
+// The combination (optional, at_least_one) is invalid: if a part is
+// optional, the at-least-one constraint is vacuous and collapses to
+// (optional, multiple). Rejected at construction.
 //
-//   is_delimiting (orthogonal, bold 3x-width line in diagram):
-//     A delimiting part behaves like a delimiting characteristic:
-//     it distinguishes the comprehensive from coordinate concepts.
+// ISO 704 "name" strings (compulsory, optional, etc.) are NOT part of
+// the model — they're a display concern handled by multiplicityFromPair
+// in the renderer/viewer layer. The model is purely presence + count.
 
 import { GlossaristModel } from './base.js';
 import { ConceptRef } from './concept-ref.js';
 import {
-  MULTIPLICITY,
-  DEFAULT_MULTIPLICITY,
-  MULTIPLICITY_VALUES,
-  isValidMultiplicity,
-} from './multiplicity.js';
+  PARTITIVE_PRESENCE,
+  DEFAULT_PRESENCE,
+  PARTITIVE_PRESENCE_VALUES,
+  isValidPresence,
+} from './partitive-presence.js';
+import {
+  DEFAULT_COUNT,
+  PARTITIVE_COUNT_VALUES,
+  isValidCount,
+} from './partitive-count.js';
 
 export class PartitiveMember extends GlossaristModel {
   constructor(data = {}) {
@@ -31,23 +37,17 @@ export class PartitiveMember extends GlossaristModel {
     this.ref = data.ref instanceof ConceptRef
       ? data.ref
       : new ConceptRef(data.ref ?? {});
-    this.multiplicity = _resolveMultiplicity(data.multiplicity);
+    this.presence = _resolvePresence(data.presence);
+    this.count = _resolveCount(data.count);
     this.is_delimiting = data.is_delimiting === true;
 
     _assertNonEmptyRef(this.ref);
+    _assertValidCombination(this.presence, this.count);
   }
 
-  get isCompulsory() {
-    return this.multiplicity === MULTIPLICITY.COMPULSORY;
-  }
-
-  get isOptional() {
-    return this.multiplicity === MULTIPLICITY.OPTIONAL;
-  }
-
-  get isDelimiting() {
-    return this.is_delimiting === true;
-  }
+  get isRequired() { return this.presence === PARTITIVE_PRESENCE.REQUIRED; }
+  get isOptional() { return this.presence === PARTITIVE_PRESENCE.OPTIONAL; }
+  get isDelimiting() { return this.is_delimiting === true; }
 
   identity() {
     return PartitiveMember.identityOf(this);
@@ -55,12 +55,9 @@ export class PartitiveMember extends GlossaristModel {
 
   toJSON() {
     const obj = { ref: this.ref.toJSON() };
-    if (this.multiplicity !== DEFAULT_MULTIPLICITY) {
-      obj.multiplicity = this.multiplicity;
-    }
-    if (this.is_delimiting === true) {
-      obj.is_delimiting = true;
-    }
+    if (this.presence !== DEFAULT_PRESENCE) obj.presence = this.presence;
+    if (this.count !== DEFAULT_COUNT) obj.count = this.count;
+    if (this.is_delimiting === true) obj.is_delimiting = true;
     return obj;
   }
 
@@ -75,22 +72,34 @@ export class PartitiveMember extends GlossaristModel {
   }
 }
 
-function _resolveMultiplicity(value) {
-  if (value == null) return DEFAULT_MULTIPLICITY;
-  if (!isValidMultiplicity(value)) {
-    throw new Error(
-      `invalid multiplicity ${JSON.stringify(value)}; ` +
-      `must be one of ${MULTIPLICITY_VALUES.join(', ')}`,
-    );
+function _resolvePresence(value) {
+  if (value == null) return DEFAULT_PRESENCE;
+  if (!isValidPresence(value)) {
+    throw new Error(`invalid presence ${JSON.stringify(value)}; must be one of ${PARTITIVE_PRESENCE_VALUES.join(', ')}`);
+  }
+  return value;
+}
+
+function _resolveCount(value) {
+  if (value == null) return DEFAULT_COUNT;
+  if (!isValidCount(value)) {
+    throw new Error(`invalid count ${JSON.stringify(value)}; must be one of ${PARTITIVE_COUNT_VALUES.join(', ')}`);
   }
   return value;
 }
 
 function _assertNonEmptyRef(ref) {
   if (!ref.source && !ref.id && !ref.text) {
+    throw new Error('PartitiveMember#ref must be a non-empty ConceptRef (source, id, or text required)');
+  }
+}
+
+function _assertValidCombination(presence, count) {
+  if (presence === 'optional' && count === 'at_least_one') {
     throw new Error(
-      'PartitiveMember#ref must be a non-empty ConceptRef ' +
-      '(source, id, or text required)',
+      'PartitiveMember presence=optional + count=at_least_one is invalid — ' +
+      'it collapses to optional + multiple (zero or more). ' +
+      'Use presence: optional, count: multiple instead.',
     );
   }
 }

package/src/models/partitive-presence.js

@@ -0,0 +1,18 @@
+// PartitivePresence — ISO 704:2022 partitive member presence.
+//
+// presence (line style):
+//   required — solid line (must exist in every instance)
+//   optional — dashed line (may exist; exists in some instances)
+//
+// Default: required.
+
+import { makeEnum } from './enum.js';
+
+export const PARTITIVE_PRESENCE = makeEnum('PARTITIVE_PRESENCE', {
+  REQUIRED: 'required',
+  OPTIONAL: 'optional',
+});
+
+export const PARTITIVE_PRESENCE_VALUES = PARTITIVE_PRESENCE.VALUES;
+export const DEFAULT_PRESENCE = PARTITIVE_PRESENCE.REQUIRED;
+export const isValidPresence = PARTITIVE_PRESENCE.isValid;

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,67 @@
+// PartitiveMember → RDF quads.
+//
+// Emits per-member predicates (presence, count, is_delimiting,
+// derived multiplicity) 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).
+//
+// v4 decomposition: ISO 704:2022 multiplicity is the cross product of
+// two orthogonal dimensions (presence × count). Per the JSON-LD
+// context (`"@type": "@id"`), all three are emitted as URI references
+// into the corresponding SKOS taxonomy namespaces — none as literals.
+//
+//   <member-uri> gloss:presence     <.../presence/required|optional>
+//   <member-uri> gloss:count        <.../count/exactly_one|at_least_one|multiple>
+//   <member-uri> gloss:multiplicity  <.../multiplicity/{ISO name}>   (derived, v3 compat)
+//   <member-uri> gloss:isDelimiting  "true"                           (xsd:boolean)
+
+import { PRED } from './predicates.js';
+import { namedNode, literal, quad } from './terms.js';
+
+// SKOS taxonomy namespaces (concept-model will ship these taxonomies).
+// Until then, the URIs are forward-compatible and resolve once the
+// taxonomies land.
+export const PRESENCE_NS = 'https://www.glossarist.org/ontologies/presence/';
+export const COUNT_NS = 'https://www.glossarist.org/ontologies/count/';
+export const MULTIPLICITY_NS = 'https://www.glossarist.org/ontologies/multiplicity/';
+
+export function* partitiveMemberToQuads(member, { memberUri }) {
+  if (member?.presence) {
+    yield quad(
+      namedNode(memberUri),
+      namedNode(PRED.gloss.presence),
+      namedNode(PRESENCE_NS + member.presence),
+    );
+  }
+  if (member?.count) {
+    yield quad(
+      namedNode(memberUri),
+      namedNode(PRED.gloss.count),
+      namedNode(COUNT_NS + member.count),
+    );
+  }
+  // Derived multiplicity URI for v3 RDF consumer backward compat.
+  // multiplicity is computed from (presence, count) via the model's
+  // accessor; fall back to the raw field for raw JSON input.
+  const mult = typeof member?.multiplicity === 'string'
+    ? member.multiplicity
+    : null;
+  if (mult) {
+    yield quad(
+      namedNode(memberUri),
+      namedNode(PRED.gloss.multiplicity),
+      namedNode(MULTIPLICITY_NS + mult),
+    );
+  }
+  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,21 @@ 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 const PRESENCE_NS: string;
+export declare const COUNT_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, PRESENCE_NS, COUNT_NS } from './gloss-partitive-member.js';
 export { partitiveRelationToQuads, partitiveRelationSubjectUri } from './gloss-partitive-relation.js';
 export {
   nonVerbalRepToQuads,

package/src/rdf/predicates.d.ts

@@ -110,6 +110,8 @@ export declare const PRED = {
     "hasPartitiveRelation": "https://www.glossarist.org/ontologies/hasPartitiveRelation",
     "hasPartitive": "https://www.glossarist.org/ontologies/hasPartitive",
     "completeness": "https://www.glossarist.org/ontologies/completeness",
+    "presence": "https://www.glossarist.org/ontologies/presence",
+    "count": "https://www.glossarist.org/ontologies/count",
     "multiplicity": "https://www.glossarist.org/ontologies/multiplicity",
     "isDelimiting": "https://www.glossarist.org/ontologies/isDelimiting",
     "criterion": "https://www.glossarist.org/ontologies/criterion",
@@ -392,6 +394,8 @@ export type Predicate =
   | "https://www.glossarist.org/ontologies/hasPartitiveRelation"
   | "https://www.glossarist.org/ontologies/hasPartitive"
   | "https://www.glossarist.org/ontologies/completeness"
+  | "https://www.glossarist.org/ontologies/presence"
+  | "https://www.glossarist.org/ontologies/count"
   | "https://www.glossarist.org/ontologies/multiplicity"
   | "https://www.glossarist.org/ontologies/isDelimiting"
   | "https://www.glossarist.org/ontologies/criterion"

package/src/rdf/predicates.js

@@ -110,6 +110,8 @@ export const PRED = {
     "hasPartitiveRelation": "https://www.glossarist.org/ontologies/hasPartitiveRelation",
     "hasPartitive": "https://www.glossarist.org/ontologies/hasPartitive",
     "completeness": "https://www.glossarist.org/ontologies/completeness",
+    "presence": "https://www.glossarist.org/ontologies/presence",
+    "count": "https://www.glossarist.org/ontologies/count",
     "multiplicity": "https://www.glossarist.org/ontologies/multiplicity",
     "isDelimiting": "https://www.glossarist.org/ontologies/isDelimiting",
     "criterion": "https://www.glossarist.org/ontologies/criterion",

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;
+}