glossarist 0.4.36 → 0.4.37

package/src/models/{hyperedge-member.js → hyperedge-member.ts}

@@ -19,21 +19,25 @@
 
 import { GlossaristModel } from './base.js';
 import { ConceptRef } from './concept-ref.js';
-import {
-  PARTITIVE_PRESENCE,
-  PARTITIVE_PRESENCE_VALUES,
-  DEFAULT_PRESENCE,
-  isValidPresence,
-} from './partitive-presence.js';
-import {
-  PARTITIVE_COUNT_VALUES,
-  DEFAULT_COUNT,
-  isValidCount,
-} from './partitive-count.js';
+import type { ConceptRefJson } from './concept-ref.js';
+import { PARTITIVE_PRESENCE_VALUES, DEFAULT_PRESENCE, isValidPresence } from './partitive-presence.js';
+import type { PartitivePresence } from './partitive-presence.js';
+import { PARTITIVE_COUNT_VALUES, DEFAULT_COUNT, isValidCount } from './partitive-count.js';
+import type { PartitiveCount } from './partitive-count.js';
 import { multiplicityFromPair } from './multiplicity.js';
 
-export class HyperedgeMember extends GlossaristModel {
-  constructor(data = {}) {
+export interface HyperedgeMemberJson {
+  ref: ConceptRefJson | ConceptRef;
+  presence?: PartitivePresence;
+  count?: PartitiveCount;
+}
+
+export abstract class HyperedgeMember extends GlossaristModel {
+  readonly ref: ConceptRef;
+  readonly presence: PartitivePresence;
+  readonly count: PartitiveCount;
+
+  constructor(data: HyperedgeMemberJson = { ref: {} }) {
     super();
     this.ref = _ensureRef(data.ref);
     this.presence = _resolvePresence(data.presence);
@@ -42,32 +46,40 @@ export class HyperedgeMember extends GlossaristModel {
     _assertValidPair(this.presence, this.count);
   }
 
-  get isRequired() { return this.presence === PARTITIVE_PRESENCE.REQUIRED; }
-  get isOptional() { return this.presence === PARTITIVE_PRESENCE.OPTIONAL; }
+  get isRequired(): boolean { return this.presence === 'required'; }
+  get isOptional(): boolean { return this.presence === 'optional'; }
 
-  identity() {
+  override identity(): string {
     return HyperedgeMember.identityOf(this);
   }
 
-  toJSON() {
-    const obj = { ref: this.ref.toJSON() };
+  override toJSON(): HyperedgeMemberJson {
+    const obj: HyperedgeMemberJson = { ref: this.ref.toJSON() };
     if (this.presence !== DEFAULT_PRESENCE) obj.presence = this.presence;
     if (this.count !== DEFAULT_COUNT) obj.count = this.count;
     return obj;
   }
 
-  static identityOf(value) {
+  static identityOf(
+    value: { ref?: { source?: string | null; id?: string | null } | null } | null | undefined,
+  ): string {
     const v = value ?? {};
     const ref = v.ref ?? {};
     return `${ref.source ?? ''}:${ref.id ?? ''}`;
   }
 
-  static fromJSON(data) {
-    return new HyperedgeMember(data);
+  static override fromJSON(_data: HyperedgeMemberJson): HyperedgeMember {
+    // Abstract base — subclasses MUST override. The base
+    // implementation is a typed marker that dispatches to the wrong
+    // class would surface as a runtime error rather than silently
+    // returning a mis-typed instance.
+    throw new Error(
+      'HyperedgeMember.fromJSON must be overridden by a subclass',
+    );
   }
 }
 
-function _ensureRef(value) {
+function _ensureRef(value: ConceptRefJson | ConceptRef | null | undefined): ConceptRef {
   const ref = value instanceof ConceptRef ? value : new ConceptRef(value ?? {});
   if (!ref.source && !ref.id && !ref.text) {
     throw new Error(
@@ -78,7 +90,7 @@ function _ensureRef(value) {
   return ref;
 }
 
-function _resolvePresence(value) {
+function _resolvePresence(value: PartitivePresence | null | undefined): PartitivePresence {
   const p = value ?? DEFAULT_PRESENCE;
   if (!isValidPresence(p)) {
     throw new Error(
@@ -89,7 +101,7 @@ function _resolvePresence(value) {
   return p;
 }
 
-function _resolveCount(value) {
+function _resolveCount(value: PartitiveCount | null | undefined): PartitiveCount {
   const c = value ?? DEFAULT_COUNT;
   if (!isValidCount(c)) {
     throw new Error(
@@ -100,9 +112,9 @@ function _resolveCount(value) {
   return c;
 }
 
-function _assertValidPair(presence, count) {
+function _assertValidPair(presence: PartitivePresence, count: PartitiveCount): void {
   // Delegate to the multiplicity SSOT. The canonical error string
-  // lives in one place: multiplicity.js. Calling multiplicityFromPair
+  // lives in one place: multiplicity.ts. Calling multiplicityFromPair
   // throws on the invalid combination; we don't need to duplicate the
   // error message here.
   multiplicityFromPair(presence, count);

package/src/models/{hyperedge-registry.js → hyperedge-registry.ts}

@@ -21,18 +21,34 @@
 // The abstract base (AbstractHyperedge) has no wireKey and is skipped
 // by register() — it cannot be instantiated through the registry.
 
+import type { AbstractHyperedge } from './abstract-hyperedge.js';
+
+/**
+ * Shape a registered hyperedge class must satisfy. Every leaf class
+ * in src/models/ matches this shape (declared as static fields).
+ */
+export interface HyperedgeClass {
+  readonly wireKey: string;
+  readonly typeTag: string;
+  readonly rdfType: string;
+  readonly memberClass: new (...args: never[]) => unknown;
+  readonly v1WireKeys?: ReadonlyArray<string>;
+  readonly kindLabel?: string;
+  readonly name: string;
+}
+
 class HyperedgeRegistry {
-  static _byWireKey = new Map();
-  static _byTypeTag = new Map();
-  static _byRdfType = new Map();
+  static _byWireKey: Map<string, HyperedgeClass> = new Map();
+  static _byTypeTag: Map<string, HyperedgeClass> = new Map();
+  static _byRdfType: Map<string, HyperedgeClass> = new Map();
 
-  static register(cls) {
+  static register(cls: HyperedgeClass | undefined): boolean {
     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})`,
+        `${this._byWireKey.get(cls.wireKey)?.name})`,
       );
     }
     if (this._byTypeTag.has(cls.typeTag)) {
@@ -53,9 +69,11 @@ class HyperedgeRegistry {
     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) {
+  /**
+   * 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: HyperedgeClass | undefined): boolean {
     if (!cls) return false;
     const r1 = this._byWireKey.delete(cls.wireKey);
     const r2 = this._byTypeTag.delete(cls.typeTag);
@@ -63,14 +81,20 @@ class HyperedgeRegistry {
     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 forWireKey(key: string): HyperedgeClass | null {
+    return this._byWireKey.get(key) ?? null;
+  }
+  static forTypeTag(tag: string): HyperedgeClass | null {
+    return this._byTypeTag.get(tag) ?? null;
+  }
+  static forRdfType(type: string): HyperedgeClass | null {
+    return this._byRdfType.get(type) ?? null;
+  }
 
-  static allClasses() {
+  static allClasses(): HyperedgeClass[] {
     // Dedup in case the same class is reachable via multiple indexes.
-    const seen = new Set();
-    const out = [];
+    const seen = new Set<HyperedgeClass>();
+    const out: HyperedgeClass[] = [];
     for (const cls of this._byTypeTag.values()) {
       if (!seen.has(cls)) {
         seen.add(cls);
@@ -80,14 +104,16 @@ class HyperedgeRegistry {
     return out;
   }
 
-  static allWireKeys()  { return [...this._byWireKey.keys()]; }
-  static allTypeTags()  { return [...this._byTypeTag.keys()]; }
+  static allWireKeys(): string[] { return [...this._byWireKey.keys()]; }
+  static allTypeTags(): string[] { 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 = [];
+  /**
+   * 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(): string[] {
+    const out: string[] = [];
     for (const cls of this.allClasses()) {
       out.push(cls.wireKey);
       for (const k of cls.v1WireKeys ?? []) out.push(k);
@@ -96,15 +122,19 @@ class HyperedgeRegistry {
   }
 }
 
-// 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 = {};
+/**
+ * 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: ReadonlyArray<AbstractHyperedge> | null | undefined,
+): Record<string, AbstractHyperedge[]> {
+  const out: Record<string, AbstractHyperedge[]> = {};
   for (const h of hyperedges ?? []) {
-    const key = h?.constructor?.wireKey;
+    const key = (h?.constructor as unknown as HyperedgeClass | undefined)?.wireKey;
     if (!key) continue;
     if (!out[key]) out[key] = [];
     out[key].push(h);

package/src/models/partitive-hyperedge.ts

@@ -0,0 +1,90 @@
+// 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.
+//
+// Extends AbstractHyperedge; the leaf-specific concern is the
+// PartitiveMember type for `members`. The wire-level field name
+// stays `partitives` for v1/v2 backward compat.
+
+import { AbstractHyperedge } from './abstract-hyperedge.js';
+import type { AbstractHyperedgeJson } from './abstract-hyperedge.js';
+import { PartitiveMember } from './partitive-member.js';
+import type { PartitiveMemberJson } from './partitive-member.js';
+import { HyperedgeRegistry } from './hyperedge-registry.js';
+
+export interface PartitiveHyperedgeJson extends AbstractHyperedgeJson {
+  members: ReadonlyArray<PartitiveMemberJson | PartitiveMember>;
+  /** PartitiveHyperedge wire alias of `members`. Both emitted for
+   *  backward compat with consumers that read `partitives`. */
+  partitives?: ReadonlyArray<PartitiveMemberJson | PartitiveMember>;
+}
+
+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' as const;
+  static typeTag = 'partitive_relation' as const;
+  static rdfType = 'gloss:PartitiveRelation' as const;
+  static memberClass = PartitiveMember;
+  static v1WireKeys = ['partitive_hyperedges'];
+  static kindLabel = 'PART';
+
+  declare readonly members: ReadonlyArray<PartitiveMember>;
+
+  constructor(data: Partial<PartitiveHyperedgeJson> = {}) {
+    const memberSource = data.members ?? data.partitives;
+    const normalized: AbstractHyperedgeJson = {
+      comprehensive: data.comprehensive ?? {},
+      members: memberSource ?? [],
+      completeness: data.completeness ?? 'complete',
+      criterion: data.criterion,
+      sources: data.sources,
+      notes: data.notes,
+      status: data.status,
+    };
+    super(normalized);
+    this.members = (Array.isArray(memberSource) ? memberSource : []).map((m) =>
+      m instanceof PartitiveMember ? m : new PartitiveMember(m as PartitiveMemberJson),
+    );
+  }
+
+  get partitives(): ReadonlyArray<PartitiveMember> { return this.members; }
+
+  override toJSON(): PartitiveHyperedgeJson {
+    const base = super.toJSON() as Omit<PartitiveHyperedgeJson, 'partitives'>;
+    const { members, ...rest } = base;
+    return { ...rest, members: members as ReadonlyArray<PartitiveMemberJson | PartitiveMember>, partitives: members };
+  }
+
+  static identityOf(
+    value: {
+      comprehensive?: { source?: string | null; id?: string | null } | null;
+      partitives?: ReadonlyArray<{ ref?: { source?: string | null; id?: string | null } | null } | null>;
+      members?: ReadonlyArray<{ ref?: { source?: string | null; id?: string | null } | null } | null>;
+    } | null | undefined,
+  ): string {
+    const v = value ?? {};
+    const c = v.comprehensive ?? {};
+    const source = v.partitives ?? v.members ?? [];
+    const partKeys = source
+      .map((p) => {
+        const r = p?.ref ?? (p as { source?: string; id?: string } | null) ?? {};
+        return `${r.source ?? ''}:${r.id ?? ''}`;
+      })
+      .sort();
+    return `${c.source ?? ''}:${c.id ?? ''}|${partKeys.join('|')}`;
+  }
+
+  static override fromJSON(data: PartitiveHyperedgeJson): PartitiveHyperedge {
+    return new PartitiveHyperedge(data);
+  }
+}
+
+export default PartitiveHyperedge;
+
+HyperedgeRegistry.register(PartitiveHyperedge);

package/src/models/{partitive-member.js → partitive-member.ts}

@@ -13,36 +13,37 @@
 // 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]
-//   +presence       — PartitivePresence [0..1] (default: required)
-//   +count          — PartitiveCount [0..1] (default: exactly_one)
-//   +is_delimiting  — Boolean [0..1] (default: false)
-//
-// 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 by HyperedgeMember's
-// delegate to multiplicityFromPair.
 
 import { HyperedgeMember } from './hyperedge-member.js';
+import type { HyperedgeMemberJson } from './hyperedge-member.js';
+
+export interface PartitiveMemberJson extends HyperedgeMemberJson {
+  is_delimiting?: boolean;
+}
 
 export class PartitiveMember extends HyperedgeMember {
-  constructor(data = {}) {
+  readonly is_delimiting: boolean;
+
+  constructor(data: PartitiveMemberJson = { ref: {} }) {
     super(data);
     this.is_delimiting = _resolveDelimiting(data.is_delimiting);
   }
 
-  get isDelimiting() { return this.is_delimiting === true; }
+  get isDelimiting(): boolean { return this.is_delimiting === true; }
 
-  toJSON() {
+  override toJSON(): PartitiveMemberJson {
     const base = super.toJSON();
-    if (this.is_delimiting) base.is_delimiting = true;
-    return base;
+    const out: PartitiveMemberJson = { ...base };
+    if (this.is_delimiting) out.is_delimiting = true;
+    return out;
+  }
+
+  static override fromJSON(data: PartitiveMemberJson): PartitiveMember {
+    return new PartitiveMember(data);
   }
 }
 
-function _resolveDelimiting(value) {
+function _resolveDelimiting(value: boolean | null | undefined): boolean {
   if (value == null) return false;
   if (typeof value !== 'boolean') {
     throw new Error(

package/src/models/sequential-hyperedge.ts

@@ -0,0 +1,70 @@
+// SequentialHyperedge — an ISO 12620 A.6.3 / ISO 704:2022 §5.5.5
+// sequential relation connecting a comprehensive concept to two or
+// more subordinate concepts in an ORDERED sequence (temporal,
+// spatial, causal, developmental).
+//
+// Mirror of PartitiveHyperedge and GenericHyperedge. Member array
+// order IS significant — reversing the array reverses the sequence.
+// Use cases: manufacturing process steps, biological life cycles,
+// software release lifecycles, supply chain stages, geological eras.
+
+import { AbstractHyperedge } from './abstract-hyperedge.js';
+import type { AbstractHyperedgeJson } from './abstract-hyperedge.js';
+import { SequentialMember } from './sequential-member.js';
+import type { SequentialMemberJson } from './sequential-member.js';
+import { HyperedgeRegistry } from './hyperedge-registry.js';
+
+export interface SequentialHyperedgeJson extends AbstractHyperedgeJson {
+  members: ReadonlyArray<SequentialMemberJson | SequentialMember>;
+}
+
+export class SequentialHyperedge extends AbstractHyperedge {
+  // Per-class metadata block — the OCP contract.
+  static wireKey = 'sequential_relations' as const;
+  static typeTag = 'sequential_relation' as const;
+  static rdfType = 'gloss:SequentialRelation' as const;
+  static memberClass = SequentialMember;
+  static v1WireKeys: ReadonlyArray<string> = [];
+  static kindLabel = 'SEQ';
+
+  declare readonly members: ReadonlyArray<SequentialMember>;
+
+  constructor(data: Partial<SequentialHyperedgeJson> = {}) {
+    super({
+      comprehensive: data.comprehensive ?? {},
+      members: data.members ?? [],
+      completeness: data.completeness ?? 'complete',
+      criterion: data.criterion,
+      sources: data.sources,
+      notes: data.notes,
+      status: data.status,
+    });
+    this.members = (Array.isArray(data.members) ? data.members : []).map((m) =>
+      m instanceof SequentialMember ? m : new SequentialMember(m as SequentialMemberJson),
+    );
+  }
+
+  static identityOf(
+    value: {
+      comprehensive?: { source?: string | null; id?: string | null } | null;
+      members?: ReadonlyArray<{ ref?: { source?: string | null; id?: string | null } | null } | null>;
+    } | null | undefined,
+  ): string {
+    const v = value ?? {};
+    const c = v.comprehensive ?? {};
+    // For sequential, member order IS significant — do NOT sort.
+    const memberKeys = (v.members ?? []).map((m) => {
+      const r = m?.ref ?? (m as { source?: string; id?: string } | null) ?? {};
+      return `${r.source ?? ''}:${r.id ?? ''}`;
+    });
+    return `${c.source ?? ''}:${c.id ?? ''}|${memberKeys.join('|')}`;
+  }
+
+  static override fromJSON(data: SequentialHyperedgeJson): SequentialHyperedge {
+    return new SequentialHyperedge(data);
+  }
+}
+
+export default SequentialHyperedge;
+
+HyperedgeRegistry.register(SequentialHyperedge);

package/src/models/{sequential-member.js → sequential-member.ts}

@@ -1,13 +1,16 @@
 // SequentialMember — one member of a SequentialHyperedge. Inherits
 // the MECE shape from HyperedgeMember. Distinct leaf class for type
 // safety. Member array order IS significant for sequential hyperedges.
-//
-// See docs/design/abstract-nary-relation.md (concept-model repo).
 
 import { HyperedgeMember } from './hyperedge-member.js';
+import type { HyperedgeMemberJson } from './hyperedge-member.js';
+
+export type SequentialMemberJson = HyperedgeMemberJson;
 
 export class SequentialMember extends HyperedgeMember {
-  // Inherits all attributes and validations from HyperedgeMember.
+  static override fromJSON(data: SequentialMemberJson): SequentialMember {
+    return new SequentialMember(data);
+  }
 }
 
 export default SequentialMember;

package/src/models/abstract-hyperedge.js

@@ -1,119 +0,0 @@
-// AbstractHyperedge — shared base for directed 1→N hyperedges
-// relations (PartitiveHyperedge, GenericHyperedge, future
-// SequentialRelation, AssociativeRelation).
-//
-// Carries the common shape:
-//   - comprehensive: ConceptRef
-//   - members: 2+ MECE dimensioned concept refs (≥2 per ISO 704)
-//   - completeness: complete | partial
-//   - criterion: localized subdivision criterion (ISO 12620)
-//   - sources / notes / status: administrative metadata
-//
-// Concrete leaves add type-specific fields if needed (currently none).
-// See docs/design/abstract-hyperedge.md (concept-model repo).
-
-import { GlossaristModel } from './base.js';
-import { ConceptRef } from './concept-ref.js';
-import {
-  COMPLETENESS,
-  DEFAULT_COMPLETENESS,
-  isValidCompleteness,
-} from './completeness.js';
-
-export class AbstractHyperedge extends GlossaristModel {
-  constructor(data = {}) {
-    super();
-    this.comprehensive = _ensureComprehensive(data.comprehensive);
-    this.members = _ensureMembers(data.members, this.constructor.name);
-    this.completeness = _resolveCompleteness(data.completeness);
-    this.criterion = _normalizeCriterion(data.criterion);
-    this.sources = Array.isArray(data.sources) ? [...data.sources] : [];
-    this.notes = data.notes ?? null;
-    this.status = data.status ?? null;
-
-    _assertNoSelfLoop(this.comprehensive, this.members);
-  }
-
-  get isComplete() { return this.completeness === COMPLETENESS.COMPLETE; }
-  get isPartial() { return this.completeness === COMPLETENESS.PARTIAL; }
-  get isCoordinate() { return this.members.length >= 2; }
-
-  hasCriterion() { return this.criterion != null; }
-
-  identity() {
-    return this.constructor.identityOf(this);
-  }
-
-  toJSON() {
-    const obj = {
-      comprehensive: this.comprehensive.toJSON(),
-      members: this.members.map(m => m.toJSON()),
-      completeness: this.completeness,
-    };
-    if (this.criterion != null) obj.criterion = { ...this.criterion };
-    if (this.sources.length > 0) obj.sources = [...this.sources];
-    if (this.notes != null) obj.notes = { ...this.notes };
-    if (this.status != null) obj.status = this.status;
-    return obj;
-  }
-}
-
-function _ensureComprehensive(value) {
-  const ref = value instanceof ConceptRef ? value : new ConceptRef(value ?? {});
-  if (!ref.source && !ref.id && !ref.text) {
-    throw new Error(
-      'AbstractHyperedge.comprehensive must be a non-empty ConceptReference ' +
-      '(source, id, or text required)',
-    );
-  }
-  return ref;
-}
-
-function _ensureMembers(values, typeName) {
-  if (!Array.isArray(values)) {
-    throw new Error(
-      `${typeName}.members must be an array (got ${typeof values})`,
-    );
-  }
-  if (values.length < 2) {
-    throw new Error(
-      `${typeName} requires ≥2 partitives (ISO 704); got ${values.length}`,
-    );
-  }
-  return values;
-}
-
-function _resolveCompleteness(value) {
-  const c = value ?? DEFAULT_COMPLETENESS;
-  if (!isValidCompleteness(c)) {
-    throw new Error(
-      `${c === value ? 'completeness' : 'completeness'} has invalid value ${JSON.stringify(value)}`,
-    );
-  }
-  return c;
-}
-
-function _normalizeCriterion(value) {
-  if (value == null) return null;
-  if (typeof value === 'string') {
-    return value.length > 0 ? { default: value } : null;
-  }
-  if (typeof value === 'object') {
-    const entries = Object.entries(value).filter(([, v]) => typeof v === 'string');
-    return entries.length > 0 ? Object.fromEntries(entries) : null;
-  }
-  return null;
-}
-
-function _assertNoSelfLoop(comprehensive, members) {
-  const cKey = `${comprehensive.source ?? ''}:${comprehensive.id ?? ''}`;
-  for (const m of members) {
-    const ref = m.ref;
-    const pKey = `${ref?.source ?? ''}:${ref?.id ?? ''}`;
-    if (pKey === cKey && (ref?.source || ref?.id)) {
-      throw new Error(
-        'Relation.members cannot include the comprehensive (no self-loops)',
-      );
-    }
-  }
-}