glossarist 0.4.35 → 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/{multiplicity.js → multiplicity.ts}

@@ -18,34 +18,47 @@
 // mapping. Both MULTIPLICITY constants and MULTIPLICITY_VALUES are
 // derived from this single table; no duplicate string literals.
 
-import { PARTITIVE_PRESENCE } from './partitive-presence.js';
-import { PARTITIVE_COUNT } from './partitive-count.js';
+import type { PartitivePresence } from './partitive-presence.js';
+import type { PartitiveCount } from './partitive-count.js';
 
-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 type MultiplicityName =
+  | 'compulsory'
+  | 'optional'
+  | 'compulsory_multiple'
+  | 'optional_multiple'
+  | 'compulsory_at_least_one';
+
+const NAME_BY_PAIR: Readonly<Record<string, MultiplicityName>> = Object.freeze({
+  'required:exactly_one': 'compulsory',
+  'optional:exactly_one': 'optional',
+  'required:multiple': 'compulsory_multiple',
+  'optional:multiple': 'optional_multiple',
+  'required:at_least_one': 'compulsory_at_least_one',
 });
 
-const PAIR_BY_NAME = Object.freeze(
+const PAIR_BY_NAME: Readonly<Record<MultiplicityName, string>> = Object.freeze(
   Object.fromEntries(
     Object.entries(NAME_BY_PAIR).map(([pair, name]) => [name, pair]),
-  ),
+  ) as Record<MultiplicityName, string>,
 );
 
-export const MULTIPLICITY = Object.freeze(
-  Object.fromEntries(
-    Object.values(NAME_BY_PAIR).map(name => [name.toUpperCase(), name]),
-  ),
-);
+export const MULTIPLICITY: Readonly<Record<Uppercase<MultiplicityName>, MultiplicityName>> =
+  Object.freeze(
+    Object.fromEntries(
+      Object.values(NAME_BY_PAIR).map((name) => [name.toUpperCase(), name]),
+    ),
+  ) as Readonly<Record<Uppercase<MultiplicityName>, MultiplicityName>>;
 
-export const MULTIPLICITY_VALUES = Object.freeze(Object.values(NAME_BY_PAIR));
+export const MULTIPLICITY_VALUES: ReadonlyArray<MultiplicityName> = Object.freeze(
+  Object.values(NAME_BY_PAIR),
+);
 
-export const DEFAULT_MULTIPLICITY = MULTIPLICITY.COMPULSORY;
+export const DEFAULT_MULTIPLICITY: MultiplicityName = MULTIPLICITY.COMPULSORY;
 
-export function multiplicityFromPair(presence, count) {
+export function multiplicityFromPair(
+  presence: PartitivePresence,
+  count: PartitiveCount,
+): MultiplicityName {
   const name = NAME_BY_PAIR[`${presence}:${count}`];
   if (name == null) {
     throw invalidCombinationError(presence, count);
@@ -53,28 +66,43 @@ 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) {
+/**
+ * Canonical error for the invalid (presence, count) combination.
+ * Single source of truth — hyperedge-member.ts delegates to this so
+ * the error string doesn't drift across the two files.
+ */
+export function invalidCombinationError(
+  presence: unknown,
+  count: unknown,
+): Error {
   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) {
+export function pairFromMultiplicity(
+  name: MultiplicityName,
+): { presence: PartitivePresence; count: PartitiveCount } {
   const pair = PAIR_BY_NAME[name];
   if (pair == null) {
     throw new Error(`Unknown multiplicity: ${JSON.stringify(name)}`);
   }
-  const [presence, count] = pair.split(':');
+  const [presence, count] = pair.split(':') as [PartitivePresence, PartitiveCount];
   return { presence, count };
 }
 
-export function isValidMultiplicity(name) {
-  return Object.prototype.hasOwnProperty.call(PAIR_BY_NAME, name);
+export function isValidMultiplicity(name: unknown): name is MultiplicityName {
+  return (
+    typeof name === 'string' &&
+    Object.prototype.hasOwnProperty.call(PAIR_BY_NAME, name)
+  );
+}
+
+interface MemberWithMultiplicity {
+  presence?: PartitivePresence;
+  count?: PartitiveCount;
+  multiplicity?: string;
 }
 
 /**
@@ -93,7 +121,9 @@ export function isValidMultiplicity(name) {
  * rather than silently returning 'compulsory' (which would mask the
  * data corruption).
  */
-export function resolveMultiplicity(member) {
+export function resolveMultiplicity(
+  member: MemberWithMultiplicity | null | undefined,
+): MultiplicityName | string {
   if (member?.presence && member?.count) {
     return multiplicityFromPair(member.presence, member.count);
   }
@@ -102,4 +132,3 @@ export function resolveMultiplicity(member) {
   }
   return DEFAULT_MULTIPLICITY;
 }
-

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

@@ -9,6 +9,8 @@
 
 import { makeEnum } from './enum.js';
 
+export type PartitiveCount = 'exactly_one' | 'at_least_one' | 'multiple';
+
 export const PARTITIVE_COUNT = makeEnum('PARTITIVE_COUNT', {
   EXACTLY_ONE: 'exactly_one',
   AT_LEAST_ONE: 'at_least_one',
@@ -16,5 +18,5 @@ export const PARTITIVE_COUNT = makeEnum('PARTITIVE_COUNT', {
 });
 
 export const PARTITIVE_COUNT_VALUES = PARTITIVE_COUNT.VALUES;
-export const DEFAULT_COUNT = PARTITIVE_COUNT.EXACTLY_ONE;
+export const DEFAULT_COUNT: PartitiveCount = PARTITIVE_COUNT.EXACTLY_ONE;
 export const isValidCount = PARTITIVE_COUNT.isValid;

package/src/models/partitive-enumeration.ts

@@ -0,0 +1,27 @@
+// PartitiveEnumeration — allowed values for PartitiveHyperedge#enumeration.
+//
+//   closed — the encoded parts are ALL the parts of the comprehensive.
+//            Adding or removing a part would change the relationship.
+//   open   — the encoded parts are SOME of the parts; others may exist
+//            but are not encoded.
+
+export type PartitiveEnumeration = 'closed' | 'open';
+
+export const PARTITIVE_ENUMERATION: Readonly<
+  Record<'CLOSED' | 'OPEN', PartitiveEnumeration>
+> = Object.freeze({
+  CLOSED: 'closed',
+  OPEN: 'open',
+});
+
+export const PARTITIVE_ENUMERATION_VALUES: ReadonlyArray<PartitiveEnumeration> =
+  Object.freeze([PARTITIVE_ENUMERATION.CLOSED, PARTITIVE_ENUMERATION.OPEN]);
+
+export function isValidPartitiveEnumeration(
+  value: unknown,
+): value is PartitiveEnumeration {
+  return (
+    typeof value === 'string' &&
+    (PARTITIVE_ENUMERATION_VALUES as readonly string[]).includes(value)
+  );
+}

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/{partitive-presence.js → partitive-presence.ts}

@@ -8,11 +8,13 @@
 
 import { makeEnum } from './enum.js';
 
+export type PartitivePresence = 'required' | 'optional';
+
 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 DEFAULT_PRESENCE: PartitivePresence = PARTITIVE_PRESENCE.REQUIRED;
 export const isValidPresence = PARTITIVE_PRESENCE.isValid;

package/src/models/{plurality-marker.js → plurality-marker.ts}

@@ -9,16 +9,23 @@
 // Orthogonal to PartitiveEnumeration — both may be set on the same
 // hyperedge.
 
-export const PLURALITY_MARKER = Object.freeze({
+export type PluralityMarker = 'double' | 'dashed';
+
+export const PLURALITY_MARKER: Readonly<
+  Record<'DOUBLE' | 'DASHED', PluralityMarker>
+> = Object.freeze({
   DOUBLE: 'double',
   DASHED: 'dashed',
 });
 
-export const PLURALITY_MARKER_VALUES = Object.freeze([
-  PLURALITY_MARKER.DOUBLE,
-  PLURALITY_MARKER.DASHED,
-]);
+export const PLURALITY_MARKER_VALUES: ReadonlyArray<PluralityMarker> =
+  Object.freeze([PLURALITY_MARKER.DOUBLE, PLURALITY_MARKER.DASHED]);
 
-export function isValidPluralityMarker(value) {
-  return PLURALITY_MARKER_VALUES.includes(value);
+export function isValidPluralityMarker(
+  value: unknown,
+): value is PluralityMarker {
+  return (
+    typeof value === 'string' &&
+    (PLURALITY_MARKER_VALUES as readonly string[]).includes(value)
+  );
 }