glossarist 0.4.20 → 0.4.22

package/package.json

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

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

@@ -4,25 +4,24 @@
 // PartitiveRelation hash. Idempotent. Used by the parser when loading
 // legacy YAML; available as a public API for one-shot dataset migrations.
 //
-// Field mapping (per TODO.partitive-relation-v2 items 01–05):
+// Field mapping (per TODO.partitive-relation-v2 items 01–05 and the
+// ISO 704:2022 correction):
 //
 //   comprehensive      → comprehensive     (unchanged shape)
-//   parts: [ref, ...]  → partitives: [{ ref, certainty: 'confirmed' }, ...]
+//   parts: [ref, ...]  → partitives: [{ ref, multiplicity: 'compulsory' }, ...]
 //   enumeration: open  → completeness: partial
 //   enumeration: closed→ completeness: complete
-//   markers: [double]                 ┐
-//   markers: [dashed]                 ├→ plurality: { is_shared, is_uncertain }
-//   markers: [double, dashed]         ┘
-//   content: "..."    → (dropped — structural edges carry no prose)
+//   markers: [...]     → (dropped — v2 uses per-member multiplicity
+//                          + is_delimiting; v1 markers encoded the
+//                          same information imprecisely and cannot
+//                          round-trip losslessly)
+//   content: "..."     → (dropped — structural edges carry no prose)
 //
 // Cardinality check: v1 allowed [1..*] parts; v2 requires [2..*].
 // 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).
 
-const MARKER_DOUBLE = 'double';
-const MARKER_DASHED = 'dashed';
-
 export function migrateHyperedgeToRelation(v1Hash) {
   if (v1Hash == null) return null;
   if (Array.isArray(v1Hash)) {
@@ -36,17 +35,12 @@ export function migrateHyperedgeToRelation(v1Hash) {
   const parts = Array.isArray(v1Hash.parts) ? v1Hash.parts : [];
   out.partitives = parts.map(ref => ({
     ref: { ...ref },
-    certainty: 'confirmed',
+    multiplicity: 'compulsory',
   }));
 
   out.completeness = _migrateEnumeration(v1Hash.enumeration);
 
-  const plurality = _migrateMarkers(v1Hash.markers);
-  if (plurality != null) out.plurality = plurality;
-
-  // v1 content field is dropped per TODO.partitive-relation-v2 item 04.
-  // Caller (parser) may surface this as a warning if the text matters.
-
+  // v1 content + markers fields are dropped per TODO.partitive-relation-v2.
   if (parts.length < 2) {
     out.migrationWarning =
       `v1 PartitiveHyperedge had ${parts.length} part(s); v2 requires ≥2. ` +
@@ -59,12 +53,19 @@ export function migrateHyperedgeToRelation(v1Hash) {
       `move valuable text to the comprehensive concept's notes).`;
   }
 
+  if (Array.isArray(v1Hash.markers) && v1Hash.markers.length > 0) {
+    out.migrationWarning = (out.migrationWarning ?? '') +
+      ` v1 'markers' field (${v1Hash.markers.join(', ')}) was dropped; ` +
+      `v2 uses per-member 'multiplicity' + 'is_delimiting'. Reviewer ` +
+      `should set these per partitive based on ISO 704:2022 notation.`;
+  }
+
   return out;
 }
 
 // Inverse — v2 → v1 — exists only for tooling that must round-trip
 // through v1 consumers. NOT used by the parser; the serializer emits
-// v2 only.
+// v2 only. Lossy: drops criterion, multiplicity, is_delimiting.
 export function downgradeRelationToHyperedge(v2Hash) {
   if (v2Hash == null) return null;
   if (Array.isArray(v2Hash)) {
@@ -78,11 +79,8 @@ export function downgradeRelationToHyperedge(v2Hash) {
   out.parts = (v2Hash.partitives ?? []).map(m => ({ ...(m.ref ?? {}) }));
   out.enumeration = _downgradeCompleteness(v2Hash.completeness);
 
-  const markers = _downgradePlurality(v2Hash.plurality);
-  if (markers.length > 0) out.markers = markers;
-
-  // criterion has no v1 equivalent — dropped silently
-  // per-member certainty has no v1 equivalent — dropped silently
+  // criterion, multiplicity, is_delimiting have no v1 equivalent —
+  // dropped silently.
 
   return out;
 }
@@ -99,27 +97,3 @@ function _downgradeCompleteness(value) {
   if (value === 'partial') return 'open';
   return 'closed';
 }
-
-function _migrateMarkers(markers) {
-  if (!Array.isArray(markers) || markers.length === 0) return null;
-
-  const isShared = markers.includes(MARKER_DOUBLE);
-  const isUncertain = markers.includes(MARKER_DASHED);
-
-  // Per TODO.partitive-relation-v2 item 03 migration table:
-  //   [dashed] alone is semantically odd (broken line qualifies
-  //   plurality; without double, what's being qualified?). We
-  //   migrate it to is_shared=false, is_uncertain=true and rely on
-  //   the PartitiveRelationCoherenceRule to warn.
-  if (!isShared && !isUncertain) return null;
-
-  return { is_shared: isShared, is_uncertain: isUncertain };
-}
-
-function _downgradePlurality(plurality) {
-  if (plurality == null) return [];
-  const markers = [];
-  if (plurality.is_shared) markers.push(MARKER_DOUBLE);
-  if (plurality.is_uncertain) markers.push(MARKER_DASHED);
-  return markers;
-}

package/src/models/index.js

@@ -38,7 +38,6 @@ export {
 // backward-compat input. New code should use v2 exclusively.
 export { PartitiveRelation } from './partitive-relation.js';
 export { PartitiveMember } from './partitive-member.js';
-export { TypeSharedPlurality } from './type-shared-plurality.js';
 export {
   COMPLETENESS,
   COMPLETENESS_VALUES,
@@ -46,11 +45,11 @@ export {
   isValidCompleteness,
 } from './completeness.js';
 export {
-  MEMBER_CERTAINTY,
-  MEMBER_CERTAINTY_VALUES,
-  DEFAULT_MEMBER_CERTAINTY,
-  isValidMemberCertainty,
-} from './member-certainty.js';
+  MULTIPLICITY,
+  MULTIPLICITY_VALUES,
+  DEFAULT_MULTIPLICITY,
+  isValidMultiplicity,
+} from './multiplicity.js';
 
 // v1 → v2 migration helper. Pure function; idempotent.
 export {

package/src/models/multiplicity.js

@@ -0,0 +1,24 @@
+// Multiplicity — ISO 704:2022 partitive member multiplicity.
+//
+// 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)
+//   at_least_one        — 1 solid + 1 dashed line (at least one must exist)
+//
+// Defaults to `compulsory` when omitted.
+
+import { makeEnum } from './enum.js';
+
+export const MULTIPLICITY = makeEnum('MULTIPLICITY', {
+  COMPULSORY: 'compulsory',
+  OPTIONAL: 'optional',
+  COMPULSORY_MULTIPLE: 'compulsory_multiple',
+  OPTIONAL_MULTIPLE: 'optional_multiple',
+  AT_LEAST_ONE: 'at_least_one',
+});
+
+export const MULTIPLICITY_VALUES = MULTIPLICITY.VALUES;
+export const DEFAULT_MULTIPLICITY = MULTIPLICITY.COMPULSORY;
+export const isValidMultiplicity = MULTIPLICITY.isValid;

package/src/models/partitive-member.js

@@ -1,21 +1,29 @@
 // PartitiveMember — one member of a PartitiveRelation.
 //
-// A partitive member carries a ConceptRef (the subordinate concept
-// partitive) and optional certainty metadata. A PartitiveMember with
-// no certainty field is implicitly confirmed.
+// Carries a ConceptRef (the subordinate concept partitive) plus
+// ISO 704:2022 multiplicity and delimiting metadata.
 //
-// Glossarist extension beyond ISO 704: ISO notation expresses
-// plurality-level uncertainty (broken line); per-member certainty
-// lets a relation assert "member b is confirmed, member d is possible"
-// at the member level.
+// 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)
+//     at_least_one        — 1 solid + 1 dashed line (≥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.
 
 import { GlossaristModel } from './base.js';
 import { ConceptRef } from './concept-ref.js';
 import {
-  MEMBER_CERTAINTY,
-  DEFAULT_MEMBER_CERTAINTY,
-  isValidMemberCertainty,
-} from './member-certainty.js';
+  MULTIPLICITY,
+  DEFAULT_MULTIPLICITY,
+  MULTIPLICITY_VALUES,
+  isValidMultiplicity,
+} from './multiplicity.js';
 
 export class PartitiveMember extends GlossaristModel {
   constructor(data = {}) {
@@ -23,17 +31,22 @@ export class PartitiveMember extends GlossaristModel {
     this.ref = data.ref instanceof ConceptRef
       ? data.ref
       : new ConceptRef(data.ref ?? {});
-    this.certainty = _resolveCertainty(data.certainty);
+    this.multiplicity = _resolveMultiplicity(data.multiplicity);
+    this.is_delimiting = data.is_delimiting === true;
 
     _assertNonEmptyRef(this.ref);
   }
 
-  get isConfirmed() {
-    return this.certainty === MEMBER_CERTAINTY.CONFIRMED;
+  get isCompulsory() {
+    return this.multiplicity === MULTIPLICITY.COMPULSORY;
   }
 
-  get isPossible() {
-    return this.certainty === MEMBER_CERTAINTY.POSSIBLE;
+  get isOptional() {
+    return this.multiplicity === MULTIPLICITY.OPTIONAL;
+  }
+
+  get isDelimiting() {
+    return this.is_delimiting === true;
   }
 
   identity() {
@@ -42,8 +55,11 @@ export class PartitiveMember extends GlossaristModel {
 
   toJSON() {
     const obj = { ref: this.ref.toJSON() };
-    if (this.certainty !== DEFAULT_MEMBER_CERTAINTY) {
-      obj.certainty = this.certainty;
+    if (this.multiplicity !== DEFAULT_MULTIPLICITY) {
+      obj.multiplicity = this.multiplicity;
+    }
+    if (this.is_delimiting === true) {
+      obj.is_delimiting = true;
     }
     return obj;
   }
@@ -51,7 +67,7 @@ export class PartitiveMember extends GlossaristModel {
   static identityOf(value) {
     const v = value ?? {};
     const ref = v.ref ?? {};
-    return `${ref.source ?? ''}|${ref.id ?? ''}|${v.certainty ?? DEFAULT_MEMBER_CERTAINTY}`;
+    return `${ref.source ?? ''}:${ref.id ?? ''}`;
   }
 
   static fromJSON(data) {
@@ -59,21 +75,22 @@ export class PartitiveMember extends GlossaristModel {
   }
 }
 
-function _resolveCertainty(value) {
-  const cert = value ?? DEFAULT_MEMBER_CERTAINTY;
-  if (!isValidMemberCertainty(cert)) {
+function _resolveMultiplicity(value) {
+  if (value == null) return DEFAULT_MULTIPLICITY;
+  if (!isValidMultiplicity(value)) {
     throw new Error(
-      `PartitiveMember.certainty has invalid value ${JSON.stringify(value)}; ` +
-      `must be one of: ${MEMBER_CERTAINTY.VALUES.join(', ')}`,
+      `invalid multiplicity ${JSON.stringify(value)}; ` +
+      `must be one of ${MULTIPLICITY_VALUES.join(', ')}`,
     );
   }
-  return cert;
+  return value;
 }
 
 function _assertNonEmptyRef(ref) {
   if (!ref.source && !ref.id && !ref.text) {
     throw new Error(
-      'PartitiveMember.ref must be non-empty (source, id, or text required)',
+      'PartitiveMember#ref must be a non-empty ConceptRef ' +
+      '(source, id, or text required)',
     );
   }
 }

package/src/models/partitive-relation.js

@@ -1,31 +1,29 @@
-// PartitiveRelation — a one-to-many partitive decomposition.
-//
-// Connects a comprehensive concept (superordinate concept partitive)
-// to two or more partitive concepts (subordinate concepts partitive)
-// which fitted together constitute the comprehensive.
-//
-// Renamed from the v1 `PartitiveHyperedge` per TODO.partitive-relation-v2
-// item 01. ISO 704 / 1087-1 / 12620 call this a *partitive relation*,
-// not a hyperedge.
+// PartitiveRelation — an ISO 704 / 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.
 //
 // Field renames (v1 → v2):
 //   parts [1..*]              → partitives [2..*]  (as PartitiveMember)
 //   enumeration: closed|open  → completeness: complete|partial
-//   markers: [double, dashed] → plurality: TypeSharedPlurality (structured)
 //   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)
 //
 // Distinguished from binary `has_part` / `is_part_of` edges, which
-// express pairwise part-of assertions without completeness, plurality,
-// or criterion claims. A single partitive should be expressed as a
-// binary edge, not a PartitiveRelation (ISO requires "two or more").
+// express pairwise part-of assertions without completeness,
+// multiplicity, or criterion claims. A single partitive should be
+// expressed as a binary edge, not a PartitiveRelation (ISO requires
+// "two or more").
 
 import { GlossaristModel } from './base.js';
 import { ConceptRef } from './concept-ref.js';
 import { PartitiveMember } from './partitive-member.js';
-import { TypeSharedPlurality } from './type-shared-plurality.js';
 import {
   COMPLETENESS,
   COMPLETENESS_VALUES,
@@ -39,11 +37,6 @@ export class PartitiveRelation extends GlossaristModel {
     this.comprehensive = _ensureComprehensive(data.comprehensive);
     this.partitives = _ensurePartitives(data.partitives);
     this.completeness = _resolveCompleteness(data.completeness);
-    this.plurality = data.plurality == null
-      ? null
-      : (data.plurality instanceof TypeSharedPlurality
-          ? data.plurality
-          : new TypeSharedPlurality(data.plurality));
     this.criterion = _normalizeCriterion(data.criterion);
 
     _assertNoSelfLoop(this.comprehensive, this.partitives);
@@ -57,7 +50,6 @@ export class PartitiveRelation extends GlossaristModel {
   // coordinate concepts by definition).
   get isCoordinate() { return this.partitives.length >= 2; }
 
-  hasPlurality() { return this.plurality != null; }
   hasCriterion() { return this.criterion != null; }
 
   identity() {
@@ -70,15 +62,14 @@ export class PartitiveRelation extends GlossaristModel {
       partitives: this.partitives.map(p => p.toJSON()),
       completeness: this.completeness,
     };
-    if (this.plurality != null) obj.plurality = this.plurality.toJSON();
     if (this.criterion != null) obj.criterion = { ...this.criterion };
     return obj;
   }
 
   // Stable identity for diffing: same comprehensive + same partitive
   // set (by ref identity) = same relation. Changes to completeness,
-  // plurality, or criterion produce "changed" entries rather than
-  // add+remove. Matches the v1 hyperedgeIdentity semantics.
+  // multiplicity, is_delimiting, or criterion produce "changed"
+  // entries rather than add+remove.
   static identityOf(value) {
     const v = value ?? {};
     const c = v.comprehensive ?? {};

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

@@ -7,16 +7,11 @@
 //     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:hasPlurality             <plurality bnode>                      (when plurality present)
 //     gloss:criterion                "..."@lang                             (one per language, when present)
 //
-// Plurality bnode (when present):
-//
-//   _:b<n>
-//     rdf:type                       gloss:TypeSharedPlurality
-//     gloss:isShared                 true|false                             (literal)
-//     gloss:isUncertain              true|false                             (literal, when non-default)
-//     gloss:sharedType               <base>/concept/<shared-type-id>        (when shared_type 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`.
 //
@@ -25,7 +20,6 @@
 
 import { PRED } from './predicates.js';
 import { WELL_KNOWN } from './prefixes.js';
-import { deterministicBnode } from './deterministic-id.js';
 import { namedNode, literal, quad } from './terms.js';
 
 export function* partitiveRelationToQuads(relation, { parentUri, index }) {
@@ -44,20 +38,24 @@ export function* partitiveRelationToQuads(relation, { parentUri, index }) {
   for (const member of members) {
     const ref = member?.ref ?? member;
     if (!ref || (!ref.source && !ref.id)) continue;
-    yield quad(s, namedNode(PRED.gloss.hasPartitive),
-      namedNode(conceptRefUri(ref, parentUri)));
+    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.plurality != null) {
-    const pSubject = deterministicBnode(subjectUri, 'plurality', 0);
-    yield quad(s, namedNode(PRED.gloss.hasPlurality), namedNode(pSubject));
-    yield* pluralityToQuads(relation.plurality, pSubject);
-  }
-
   if (relation.criterion && typeof relation.criterion === 'object') {
     for (const [lang, text] of Object.entries(relation.criterion)) {
       if (typeof text !== 'string') continue;
@@ -66,25 +64,6 @@ export function* partitiveRelationToQuads(relation, { parentUri, index }) {
   }
 }
 
-function* pluralityToQuads(plurality, subjectUri) {
-  const s = namedNode(subjectUri);
-  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.TypeSharedPlurality));
-  yield quad(s, namedNode(PRED.gloss.isShared), literal(plurality.isShared ? 'true' : 'false', 'xsd:boolean'));
-  if (plurality.isUncertain) {
-    yield quad(s, namedNode(PRED.gloss.isUncertain), literal('true', 'xsd:boolean'));
-  }
-  if (plurality.sharedType) {
-    // sharedType is a ConceptRef-like object; emit as a concept URI.
-    // We don't have parentUri here, but sharedType typically points at
-    // an external concept. Fall back to urn form.
-    const st = plurality.sharedType;
-    const uri = st.id
-      ? `urn:glossarist:${st.source ?? 'unknown'}:${st.id}`
-      : `urn:glossarist:${st.source ?? 'unknown'}:`;
-    yield quad(s, namedNode(PRED.gloss.sharedType), namedNode(uri));
-  }
-}
-
 // 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

package/src/rdf/predicates.d.ts

@@ -107,16 +107,12 @@ export declare const PRED = {
     "hyperedgeContent": "https://www.glossarist.org/ontologies/hyperedgeContent",
     "PartitiveRelation": "https://www.glossarist.org/ontologies/PartitiveRelation",
     "PartitiveMember": "https://www.glossarist.org/ontologies/PartitiveMember",
-    "TypeSharedPlurality": "https://www.glossarist.org/ontologies/TypeSharedPlurality",
     "hasPartitiveRelation": "https://www.glossarist.org/ontologies/hasPartitiveRelation",
     "hasPartitive": "https://www.glossarist.org/ontologies/hasPartitive",
     "completeness": "https://www.glossarist.org/ontologies/completeness",
-    "hasPlurality": "https://www.glossarist.org/ontologies/hasPlurality",
-    "isShared": "https://www.glossarist.org/ontologies/isShared",
-    "isUncertain": "https://www.glossarist.org/ontologies/isUncertain",
-    "sharedType": "https://www.glossarist.org/ontologies/sharedType",
+    "multiplicity": "https://www.glossarist.org/ontologies/multiplicity",
+    "isDelimiting": "https://www.glossarist.org/ontologies/isDelimiting",
     "criterion": "https://www.glossarist.org/ontologies/criterion",
-    "certainty": "https://www.glossarist.org/ontologies/certainty",
     "provides": "https://www.glossarist.org/ontologies/provides",
     "providedBy": "https://www.glossarist.org/ontologies/providedBy",
     "refType": "https://www.glossarist.org/ontologies/refType",
@@ -393,16 +389,12 @@ export type Predicate =
   | "https://www.glossarist.org/ontologies/hyperedgeContent"
   | "https://www.glossarist.org/ontologies/PartitiveRelation"
   | "https://www.glossarist.org/ontologies/PartitiveMember"
-  | "https://www.glossarist.org/ontologies/TypeSharedPlurality"
   | "https://www.glossarist.org/ontologies/hasPartitiveRelation"
   | "https://www.glossarist.org/ontologies/hasPartitive"
   | "https://www.glossarist.org/ontologies/completeness"
-  | "https://www.glossarist.org/ontologies/hasPlurality"
-  | "https://www.glossarist.org/ontologies/isShared"
-  | "https://www.glossarist.org/ontologies/isUncertain"
-  | "https://www.glossarist.org/ontologies/sharedType"
+  | "https://www.glossarist.org/ontologies/multiplicity"
+  | "https://www.glossarist.org/ontologies/isDelimiting"
   | "https://www.glossarist.org/ontologies/criterion"
-  | "https://www.glossarist.org/ontologies/certainty"
   | "https://www.glossarist.org/ontologies/provides"
   | "https://www.glossarist.org/ontologies/providedBy"
   | "https://www.glossarist.org/ontologies/refType"

package/src/rdf/predicates.js

@@ -107,16 +107,12 @@ export const PRED = {
     "hyperedgeContent": "https://www.glossarist.org/ontologies/hyperedgeContent",
     "PartitiveRelation": "https://www.glossarist.org/ontologies/PartitiveRelation",
     "PartitiveMember": "https://www.glossarist.org/ontologies/PartitiveMember",
-    "TypeSharedPlurality": "https://www.glossarist.org/ontologies/TypeSharedPlurality",
     "hasPartitiveRelation": "https://www.glossarist.org/ontologies/hasPartitiveRelation",
     "hasPartitive": "https://www.glossarist.org/ontologies/hasPartitive",
     "completeness": "https://www.glossarist.org/ontologies/completeness",
-    "hasPlurality": "https://www.glossarist.org/ontologies/hasPlurality",
-    "isShared": "https://www.glossarist.org/ontologies/isShared",
-    "isUncertain": "https://www.glossarist.org/ontologies/isUncertain",
-    "sharedType": "https://www.glossarist.org/ontologies/sharedType",
+    "multiplicity": "https://www.glossarist.org/ontologies/multiplicity",
+    "isDelimiting": "https://www.glossarist.org/ontologies/isDelimiting",
     "criterion": "https://www.glossarist.org/ontologies/criterion",
-    "certainty": "https://www.glossarist.org/ontologies/certainty",
     "provides": "https://www.glossarist.org/ontologies/provides",
     "providedBy": "https://www.glossarist.org/ontologies/providedBy",
     "refType": "https://www.glossarist.org/ontologies/refType",

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

@@ -71,19 +71,10 @@ export class PartitiveRelationCoherenceRule extends ValidationRule {
       }
     }
 
-    // Check 4: plurality coherence (warning).
-    for (let i = 0; i < relations.length; i++) {
-      const plural = relations[i]?.plurality;
-      if (!plural) continue;
-      if (plural.isUncertain && !plural.isShared) {
-        result.addWarning(
-          `${path}partitiveRelations[${i}].plurality`,
-          `plurality has isUncertain=true without isShared=true (semantically odd: ` +
-          `ISO 704 broken line qualifies the close-set double line plurality; ` +
-          `without double, what is being qualified?)`,
-        );
-      }
-    }
+    // (Check 4 — plurality coherence — removed. The prior plurality
+    // block was based on a misreading of ISO 704; the corrected model
+    // uses per-member multiplicity + is_delimiting, which are validated
+    // at construction by PartitiveMember itself.)
   }
 }
 

package/src/models/member-certainty.js

@@ -1,21 +0,0 @@
-// MemberCertainty — per-partitive certainty for a PartitiveMember.
-//
-// Glossarist extension beyond ISO 704 notation. ISO 704's broken-line
-// notation marks plurality-level uncertainty; per-member certainty
-// lets a relation assert "member b is confirmed, member d is possible"
-// at the member level.
-//
-// Defaults to `confirmed` when omitted (a member with no certainty
-// field is implicitly confirmed).
-
-import { makeEnum } from './enum.js';
-
-export const MEMBER_CERTAINTY = makeEnum('MEMBER_CERTAINTY', {
-  CONFIRMED: 'confirmed',
-  POSSIBLE: 'possible',
-});
-
-export const MEMBER_CERTAINTY_VALUES = MEMBER_CERTAINTY.VALUES;
-export const isValidMemberCertainty = MEMBER_CERTAINTY.isValid;
-
-export const DEFAULT_MEMBER_CERTAINTY = MEMBER_CERTAINTY.CONFIRMED;

package/src/models/type-shared-plurality.js

@@ -1,71 +0,0 @@
-// TypeSharedPlurality — semantic claims encoded by ISO 704's
-// close-set double line and broken line notation, promoted from
-// diagram-notation flags to structured data.
-//
-//   is_shared    — ISO 704 close-set double line. True when several
-//                  partitives of a given type are involved.
-//   is_uncertain — ISO 704 broken line. True when the type-shared
-//                  plurality is uncertain (asserted to exist but its
-//                  boundaries are not firmly established).
-//                  Defaults to false when omitted.
-//   shared_type  — Glossarist extension. The type the partitives
-//                  share, when known. ISO notation does not encode
-//                  this; left for the reader to infer. Optional even
-//                  when is_shared is true.
-//
-// A PartitiveRelation has at most one TypeSharedPlurality block.
-// Absent means: no type-shared plurality claim is being made.
-//
-// Replaces the v1 `markers: [double, dashed]` field per
-// TODO.partitive-relation-v2 item 03.
-
-import { GlossaristModel } from './base.js';
-import { ConceptRef } from './concept-ref.js';
-
-export class TypeSharedPlurality extends GlossaristModel {
-  constructor(data = {}) {
-    super();
-    if (typeof data.isShared !== 'boolean' && typeof data.is_shared !== 'boolean') {
-      throw new Error(
-        'TypeSharedPlurality requires isShared (boolean); got: ' +
-        `${JSON.stringify(data.isShared ?? data.is_shared)}`,
-      );
-    }
-    this.isShared = data.isShared ?? data.is_shared;
-    this.isUncertain = data.isUncertain ?? data.is_uncertain ?? false;
-    this.sharedType = data.sharedType
-      ? (data.sharedType instanceof ConceptRef ? data.sharedType : new ConceptRef(data.sharedType))
-      : null;
-
-    _validate(this);
-  }
-
-  hasSharedType() {
-    return this.sharedType != null;
-  }
-
-  toJSON() {
-    const obj = { is_shared: this.isShared };
-    if (this.isUncertain) obj.is_uncertain = this.isUncertain;
-    if (this.sharedType != null) obj.shared_type = this.sharedType.toJSON();
-    return obj;
-  }
-
-  static fromJSON(data) {
-    return new TypeSharedPlurality(data);
-  }
-}
-
-function _validate(plurality) {
-  if (typeof plurality.isShared !== 'boolean') {
-    throw new Error('TypeSharedPlurality.isShared must be boolean');
-  }
-  if (typeof plurality.isUncertain !== 'boolean') {
-    throw new Error('TypeSharedPlurality.isUncertain must be boolean');
-  }
-  // ISO 704 semantic check: a broken line qualifies the close-set
-  // double-line plurality claim. is_uncertain without is_shared is
-  // semantically odd. The model accepts it (data is data); the
-  // PartitiveRelationCoherenceRule surfaces it as a warning so
-  // reviewers can decide whether the data shape is intentional.
-}