glossarist 0.4.36 → 0.4.38

package/src/models/grammar-info.ts

@@ -0,0 +1,78 @@
+import { GlossaristModel } from './base.js';
+
+export type GrammarGender = 'm' | 'f' | 'n' | 'c' | string;
+export type GrammarNumber = 'singular' | 'dual' | 'plural' | string;
+export type GrammarPartOfSpeech =
+  | 'noun'
+  | 'verb'
+  | 'adj'
+  | 'adverb'
+  | 'preposition'
+  | 'participle'
+  | string;
+
+export const GRAMMAR_GENDERS: ReadonlyArray<string> = Object.freeze([
+  'm', 'f', 'n', 'c',
+]);
+export const GRAMMAR_NUMBERS: ReadonlyArray<string> = Object.freeze([
+  'singular', 'dual', 'plural',
+]);
+export const GRAMMAR_PARTS_OF_SPEECH: ReadonlyArray<string> = Object.freeze([
+  'noun', 'verb', 'adj', 'adverb', 'preposition', 'participle',
+]);
+
+export interface GrammarInfoJson {
+  gender?: GrammarGender | null;
+  number?: GrammarNumber | null;
+  part_of_speech?: GrammarPartOfSpeech | null;
+  partOfSpeech?: GrammarPartOfSpeech | null;
+  noun?: boolean;
+  verb?: boolean;
+  adj?: boolean;
+  adverb?: boolean;
+  preposition?: boolean;
+  participle?: boolean;
+}
+
+export class GrammarInfo extends GlossaristModel {
+  readonly gender: GrammarGender | null;
+  readonly number: GrammarNumber | null;
+  readonly partOfSpeech: GrammarPartOfSpeech | null;
+  readonly noun: boolean;
+  readonly verb: boolean;
+  readonly adj: boolean;
+  readonly adverb: boolean;
+  readonly preposition: boolean;
+  readonly participle: boolean;
+
+  constructor(data: GrammarInfoJson = {}) {
+    super();
+    this.gender = data.gender ?? null;
+    this.number = data.number ?? null;
+    this.partOfSpeech = data.part_of_speech ?? data.partOfSpeech ?? null;
+    this.noun = data.noun ?? false;
+    this.verb = data.verb ?? false;
+    this.adj = data.adj ?? false;
+    this.adverb = data.adverb ?? false;
+    this.preposition = data.preposition ?? false;
+    this.participle = data.participle ?? false;
+  }
+
+  override toJSON(): GrammarInfoJson {
+    const obj: GrammarInfoJson = {};
+    if (this.gender != null) obj.gender = this.gender;
+    if (this.number != null) obj.number = this.number;
+    if (this.partOfSpeech != null) obj.part_of_speech = this.partOfSpeech;
+    if (this.noun) obj.noun = true;
+    if (this.verb) obj.verb = true;
+    if (this.adj) obj.adj = true;
+    if (this.adverb) obj.adverb = true;
+    if (this.preposition) obj.preposition = true;
+    if (this.participle) obj.participle = true;
+    return obj;
+  }
+
+  static override fromJSON(data: GrammarInfoJson): GrammarInfo {
+    return new GrammarInfo(data);
+  }
+}

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

@@ -15,11 +15,19 @@
 //
 // Identity key matches HyperedgeRegistry / ConceptRef conventions:
 //   `${source}:${id}`   (empty source or id is rejected)
-//
-// See TODO Phase 9.
+
+import type { AbstractHyperedge } from './abstract-hyperedge.js';
+
+interface HyperedgeLike {
+  comprehensive?: { source?: string | null; id?: string | null } | null;
+  members?: ReadonlyArray<{ ref?: { source?: string | null; id?: string | null } | null }>;
+}
 
 export class HyperedgeIndex {
-  constructor(hyperedges = []) {
+  private readonly _byComprehensive: Map<string, HyperedgeLike[]>;
+  private readonly _byMember: Map<string, HyperedgeLike[]>;
+
+  constructor(hyperedges: ReadonlyArray<HyperedgeLike> = []) {
     this._byComprehensive = new Map();
     this._byMember = new Map();
 
@@ -35,45 +43,51 @@ export class HyperedgeIndex {
   }
 
   // Hyperedges where the given concept is the comprehensive (the "1" side).
-  forComprehensive(qualifiedId) {
+  forComprehensive(qualifiedId: string): HyperedgeLike[] {
     return this._byComprehensive.get(qualifiedId) ?? [];
   }
 
   // Hyperedges where the given concept appears as a member (the "many" side).
-  forMember(qualifiedId) {
+  forMember(qualifiedId: string): HyperedgeLike[] {
     return this._byMember.get(qualifiedId) ?? [];
   }
 
   // All concepts that appear as a comprehensive in any indexed hyperedge.
-  comprehensives() {
+  comprehensives(): string[] {
     return [...this._byComprehensive.keys()];
   }
 
   // All concepts that appear as a member in any indexed hyperedge.
-  members() {
+  members(): string[] {
     return [...this._byMember.keys()];
   }
 
-  get size() {
+  get size(): number {
     return this._byComprehensive.size;
   }
 }
 
-// Build a HyperedgeIndex across multiple Concepts' relations arrays
-// (a dataset-wide view). Each Concept contributes its own .relations.
-// Helper for the most common pattern: index once at collection load,
-// query many times.
-export function buildDatasetIndex(concepts = []) {
-  const all = [];
+/**
+ * Build a HyperedgeIndex across multiple Concepts' relations arrays
+ * (a dataset-wide view). Each Concept contributes its own .relations.
+ * Helper for the most common pattern: index once at collection load,
+ * query many times.
+ */
+export function buildDatasetIndex(
+  concepts: ReadonlyArray<{ relations?: ReadonlyArray<AbstractHyperedge | HyperedgeLike> }> = [],
+): HyperedgeIndex {
+  const all: HyperedgeLike[] = [];
   for (const concept of concepts) {
     for (const h of concept.relations ?? []) {
-      all.push(h);
+      all.push(h as HyperedgeLike);
     }
   }
   return new HyperedgeIndex(all);
 }
 
-function _qualifiedId(ref) {
+function _qualifiedId(
+  ref: { source?: string | null; id?: string | null } | null | undefined,
+): string | null {
   if (!ref) return null;
   const source = ref.source ?? '';
   const id = ref.id ?? '';
@@ -81,7 +95,7 @@ function _qualifiedId(ref) {
   return `${source}:${id}`;
 }
 
-function _addToMapList(map, key, value) {
+function _addToMapList<T>(map: Map<string, T[]>, key: string, value: T): void {
   if (!map.has(key)) map.set(key, []);
-  map.get(key).push(value);
+  map.get(key)?.push(value);
 }

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

@@ -1,22 +1,34 @@
 import { GlossaristModel } from './base.js';
 
+export interface LocalityJson {
+  type?: string | null;
+  reference_from?: string | null;
+  referenceFrom?: string | null;
+  reference_to?: string | null;
+  referenceTo?: string | null;
+}
+
 export class Locality extends GlossaristModel {
-  constructor(data = {}) {
+  readonly type: string | null;
+  readonly referenceFrom: string | null;
+  readonly referenceTo: string | null;
+
+  constructor(data: LocalityJson = {}) {
     super();
     this.type = data.type ?? null;
     this.referenceFrom = data.reference_from ?? data.referenceFrom ?? null;
     this.referenceTo = data.reference_to ?? data.referenceTo ?? null;
   }
 
-  toJSON() {
-    const obj = {};
+  override toJSON(): LocalityJson {
+    const obj: LocalityJson = {};
     if (this.type != null) obj.type = this.type;
     if (this.referenceFrom != null) obj.reference_from = this.referenceFrom;
     if (this.referenceTo != null) obj.reference_to = this.referenceTo;
     return obj;
   }
 
-  static fromJSON(data) {
+  static override fromJSON(data: LocalityJson): Locality {
     return new Locality(data);
   }
 }

package/src/models/localized-string.ts

@@ -0,0 +1,32 @@
+const FALLBACK_LANG = 'eng';
+
+export type LocalizedStringHash = Readonly<Record<string, string>>;
+
+export function fetchLocalizedString(
+  hash: LocalizedStringHash | null | undefined,
+  lang: string,
+  fallback: string | null = FALLBACK_LANG,
+): string | null {
+  if (hash == null || typeof hash !== 'object') return null;
+  const direct = hash[lang] ?? hash[String(lang)];
+  if (direct != null) return direct;
+  if (fallback != null && fallback !== lang) {
+    return hash[fallback] ?? hash[String(fallback)] ?? null;
+  }
+  return null;
+}
+
+export function localizedStringIsEmpty(
+  hash: LocalizedStringHash | null | undefined,
+): boolean {
+  return (
+    hash == null ||
+    (typeof hash === 'object' && Object.keys(hash).length === 0)
+  );
+}
+
+export function localizedStringIsPresent(
+  hash: LocalizedStringHash | null | undefined,
+): boolean {
+  return !localizedStringIsEmpty(hash);
+}

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(