glossarist 0.4.32 → 0.4.34

package/src/models/hyperedge-registry.js

@@ -0,0 +1,115 @@
+// HyperedgeRegistry — single source of truth for hyperedge type dispatch.
+//
+// Each hyperedge leaf class (PartitiveHyperedge, GenericHyperedge, future
+// TemporalHyperedge, AssociativeHyperedge, etc.) registers itself once at
+// module load. External systems (parser, serializer, diff, RDF emitter,
+// validators) read from this registry instead of branching on instanceof
+// or hardcoding per-type tables.
+//
+// Adding a new hyperedge type:
+//   1. Declare the leaf class with the 6-field metadata block
+//      (wireKey, typeTag, rdfType, memberClass, v1WireKeys, kindLabel).
+//   2. Call HyperedgeRegistry.register(MyClass) at the bottom of the file.
+//
+// Nothing else in the codebase changes. That is the OCP contract.
+//
+// Three indexes support three lookup patterns:
+//   byWireKey  — parser/serializer/diff-patch dispatch by YAML/JSON key
+//   byTypeTag  — per-file loader dispatch by `type: ...` discriminator
+//   byRdfType  — RDF emitter dispatch by ontology class IRI
+//
+// The abstract base (AbstractHyperedge) has no wireKey and is skipped
+// by register() — it cannot be instantiated through the registry.
+
+class HyperedgeRegistry {
+  static _byWireKey = new Map();
+  static _byTypeTag = new Map();
+  static _byRdfType = new Map();
+
+  static register(cls) {
+    if (!cls || !cls.wireKey || !cls.typeTag || !cls.rdfType) return false;
+    if (this._byWireKey.has(cls.wireKey)) {
+      throw new Error(
+        `HyperedgeRegistry: duplicate wireKey '${cls.wireKey}' ` +
+        `(trying to register ${cls.name}; already registered to ` +
+        `${this._byWireKey.get(cls.wireKey).name})`,
+      );
+    }
+    if (this._byTypeTag.has(cls.typeTag)) {
+      throw new Error(
+        `HyperedgeRegistry: duplicate typeTag '${cls.typeTag}' ` +
+        `(trying to register ${cls.name})`,
+      );
+    }
+    if (this._byRdfType.has(cls.rdfType)) {
+      throw new Error(
+        `HyperedgeRegistry: duplicate rdfType '${cls.rdfType}' ` +
+        `(trying to register ${cls.name})`,
+      );
+    }
+    this._byWireKey.set(cls.wireKey, cls);
+    this._byTypeTag.set(cls.typeTag, cls);
+    this._byRdfType.set(cls.rdfType, cls);
+    return true;
+  }
+
+  // Test-only. Removes a class from all three indexes. Used by the OCP
+  // spec to clean up mock types it adds during a test run.
+  static unregister(cls) {
+    if (!cls) return false;
+    const r1 = this._byWireKey.delete(cls.wireKey);
+    const r2 = this._byTypeTag.delete(cls.typeTag);
+    const r3 = this._byRdfType.delete(cls.rdfType);
+    return r1 || r2 || r3;
+  }
+
+  static forWireKey(key) { return this._byWireKey.get(key) ?? null; }
+  static forTypeTag(tag) { return this._byTypeTag.get(tag) ?? null; }
+  static forRdfType(type) { return this._byRdfType.get(type) ?? null; }
+
+  static allClasses() {
+    // Dedup in case the same class is reachable via multiple indexes.
+    const seen = new Set();
+    const out = [];
+    for (const cls of this._byTypeTag.values()) {
+      if (!seen.has(cls)) {
+        seen.add(cls);
+        out.push(cls);
+      }
+    }
+    return out;
+  }
+
+  static allWireKeys()  { return [...this._byWireKey.keys()]; }
+  static allTypeTags()  { return [...this._byTypeTag.keys()]; }
+
+  // Snapshot of every registered wire-shape identifier (v2 wireKey plus
+  // any v1 legacy keys). Used by the parser to reserve STRUCTURAL_KEYS
+  // and to know which top-level YAML keys to walk for hyperedge data.
+  static allWireAndLegacyKeys() {
+    const out = [];
+    for (const cls of this.allClasses()) {
+      out.push(cls.wireKey);
+      for (const k of cls.v1WireKeys ?? []) out.push(k);
+    }
+    return out;
+  }
+}
+
+// Helper: partition a unified hyperedge array by wire key. Used by
+// Concept.toJSON, ConceptSerializer, and diff-patch to emit per-type
+// wire keys without per-type branching in those files. Adding a new
+// hyperedge type "just works" because the group is keyed by the
+// class's static wireKey.
+export function groupHyperedgesByWireKey(hyperedges) {
+  const out = {};
+  for (const h of hyperedges ?? []) {
+    const key = h?.constructor?.wireKey;
+    if (!key) continue;
+    if (!out[key]) out[key] = [];
+    out[key].push(h);
+  }
+  return out;
+}
+
+export { HyperedgeRegistry };

package/src/models/index.d.ts

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

package/src/models/index.js

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

package/src/models/multiplicity.js

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

package/src/models/partitive-hyperedge.js

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

package/src/models/partitive-member.js

@@ -1,9 +1,18 @@
-// PartitiveMember — one member of a PartitiveRelation. Inherits the
-// ISO 704:2022 MECE shape from ConceptSystemMember; the `comprehensive`
-// of its parent PartitiveRelation denotes the whole concept.
+// PartitiveMember — one member of a PartitiveHyperedge.
 //
-// Distinct leaf class for type safety and to leave room for
-// Partitive-specific extensions.
+// Adds to HyperedgeMember the partitive-specific `is_delimiting` flag
+// from ISO 704:2022 §5.5.4.2.2 (rake diagram semantics):
+//
+//   "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.
+//
+// `is_delimiting` lives here on PartitiveMember, not on the base
+// HyperedgeMember, because it is partitive-specific. GenericMember
+// carries `delimitingCharacteristic` instead (the intension-difference
+// value per §5.5.4.2.1, which always applies to every generic member).
 //
 // Matches concept-model/models/concepts/PartitiveMember.lutaml exactly:
 //   +ref            — ConceptRef [1]
@@ -13,14 +22,34 @@
 //
 // 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.
+// (optional, multiple). Rejected at construction by HyperedgeMember's
+// delegate to multiplicityFromPair.
+
+import { HyperedgeMember } from './hyperedge-member.js';
 
-import { ConceptSystemMember } from './concept-system-member.js';
+export class PartitiveMember extends HyperedgeMember {
+  constructor(data = {}) {
+    super(data);
+    this.is_delimiting = _resolveDelimiting(data.is_delimiting);
+  }
+
+  get isDelimiting() { return this.is_delimiting === true; }
+
+  toJSON() {
+    const base = super.toJSON();
+    if (this.is_delimiting) base.is_delimiting = true;
+    return base;
+  }
+}
 
-export class PartitiveMember extends ConceptSystemMember {
-  // Inherits all attributes and validations from ConceptSystemMember.
-  // Declared as a distinct class for type safety and to leave room
-  // for future partitive-specific extensions.
+function _resolveDelimiting(value) {
+  if (value == null) return false;
+  if (typeof value !== 'boolean') {
+    throw new Error(
+      `PartitiveMember.is_delimiting must be boolean; got ${typeof value}`,
+    );
+  }
+  return value;
 }
 
 export default PartitiveMember;