glossarist 0.4.38 → 0.4.40

package/src/models/register.ts

@@ -0,0 +1,315 @@
+import { GlossaristModel } from './base.js';
+import { Section } from './section.js';
+import type { SectionJson } from './section.js';
+import { resolveColor } from './dataset-color.js';
+import type { DatasetColor } from './dataset-color.js';
+import type { LocalizedString } from './generic-member.js';
+
+export const REGISTER_STATUSES: ReadonlyArray<string> = Object.freeze([
+  'current',
+  'superseded',
+  'withdrawn',
+  'draft',
+]);
+
+export interface RegisterJson {
+  schema_version?: string;
+  schemaVersion?: string;
+  id?: string | null;
+  name?: string | LocalizedString | null;
+  ref?: string | null;
+  refAliases?: ReadonlyArray<string>;
+  ref_aliases?: ReadonlyArray<string>;
+  year?: number | string | null;
+  urn?: string | null;
+  urnAliases?: ReadonlyArray<string>;
+  urn_aliases?: ReadonlyArray<string>;
+  status?: string | null;
+  supersedes?: string | null;
+  owner?: string | null;
+  sourceRepo?: string | null;
+  source_repo?: string | null;
+  tags?: ReadonlyArray<string>;
+  languages?: ReadonlyArray<string>;
+  languageOrder?: ReadonlyArray<string>;
+  language_order?: ReadonlyArray<string>;
+  ordering?: string | null;
+  logo?: Record<string, unknown> | null;
+  color?: DatasetColor | null;
+  description?: LocalizedString;
+  about?: LocalizedString;
+  provenance?: ReadonlyArray<Record<string, unknown>>;
+  contributors?: ReadonlyArray<Record<string, unknown>>;
+  sections?: ReadonlyArray<SectionJson | Section>;
+  [key: string]: unknown;
+}
+
+export class Register extends GlossaristModel {
+  readonly schemaVersion: string;
+  readonly id: string | null;
+  readonly name: string | LocalizedString | null;
+  readonly ref: string | null;
+  readonly refAliases: ReadonlyArray<string>;
+  readonly year: number | string | null;
+  readonly urn: string | null;
+  readonly urnAliases: ReadonlyArray<string>;
+  readonly status: string | null;
+  readonly supersedes: string | null;
+  readonly owner: string | null;
+  readonly sourceRepo: string | null;
+  readonly tags: ReadonlyArray<string>;
+  readonly languages: ReadonlyArray<string>;
+  readonly languageOrder: ReadonlyArray<string>;
+  readonly ordering: string | null;
+  readonly logo: Record<string, unknown> | null;
+  readonly color: DatasetColor | null;
+  readonly description: LocalizedString;
+  readonly about: LocalizedString;
+  readonly provenance: ReadonlyArray<Record<string, unknown>>;
+  readonly contributors: ReadonlyArray<Record<string, unknown>>;
+  readonly sections: ReadonlyArray<Section>;
+  private readonly _raw: Record<string, unknown>;
+
+  constructor(data: RegisterJson = {}) {
+    super();
+    this.schemaVersion = data.schema_version ?? data.schemaVersion ?? '3';
+    this.id = data.id ?? null;
+    this.name = (data.name as string | LocalizedString | null) ?? null;
+    this.ref = data.ref ?? null;
+    this.refAliases = data.refAliases ?? data.ref_aliases ?? [];
+    this.year = (data.year as number | string | null) ?? null;
+    this.urn = data.urn ?? null;
+    this.urnAliases = data.urnAliases ?? data.urn_aliases ?? [];
+    this.status = data.status ?? null;
+    this.supersedes = data.supersedes ?? null;
+    this.owner = data.owner ?? null;
+    this.sourceRepo = data.sourceRepo ?? data.source_repo ?? null;
+    this.tags = (data.tags as ReadonlyArray<string>) ?? [];
+    this.languages = (data.languages as ReadonlyArray<string>) ?? [];
+    this.languageOrder = data.languageOrder ?? data.language_order ?? [];
+    this.ordering = data.ordering ?? null;
+    this.logo = (data.logo as Record<string, unknown> | null) ?? null;
+    this.color = (data.color as DatasetColor | null) ?? null;
+    this.description = (data.description as LocalizedString) ?? {};
+    this.about = (data.about as LocalizedString) ?? {};
+    this.provenance = (data.provenance as ReadonlyArray<Record<string, unknown>>) ?? [];
+    this.contributors = (data.contributors as ReadonlyArray<Record<string, unknown>>) ?? [];
+    this.sections = (data.sections ?? []).map((s) =>
+      s instanceof Section ? s : new Section(s as SectionJson),
+    );
+    this._raw = this._extractRaw(data);
+  }
+
+  private _extractRaw(data: RegisterJson): Record<string, unknown> {
+    const known = new Set([
+      'schema_version', 'schemaVersion',
+      'id', 'name', 'ref', 'refAliases', 'ref_aliases',
+      'year', 'urn', 'urnAliases', 'urn_aliases',
+      'status', 'supersedes', 'owner',
+      'sourceRepo', 'source_repo', 'tags',
+      'languages', 'languageOrder', 'language_order',
+      'ordering', 'logo', 'color', 'description', 'about',
+      'provenance', 'contributors', 'sections',
+    ]);
+    const extra: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (!known.has(k)) extra[k] = v;
+    }
+    return extra;
+  }
+
+  sectionById(id: string): Section | null {
+    for (const section of this.sections) {
+      if (section.id === id) return section;
+      const found = section.descendantById(id);
+      if (found) return found;
+    }
+    return null;
+  }
+
+  /**
+   * Walks the section tree upward from `sectionId`, returning the
+   * ancestor chain in immediate-parent-first order. The returned array
+   * does NOT include sectionId itself. Returns [] when sectionId is
+   * unknown or is a top-level section.
+   */
+  sectionAncestorIds(sectionId: string | null | undefined): string[] {
+    if (!sectionId) return [];
+    for (const root of this.sections) {
+      const chain = _ancestorChain(root, sectionId);
+      if (chain) return chain;
+    }
+    return [];
+  }
+
+  /**
+   * Returns the closure of `sectionId`: the section plus all of its
+   * ancestors. Concept-section membership tests should intersect the
+   * concept's section list with this closure.
+   */
+  sectionClosure(sectionId: string | null | undefined): string[] {
+    return sectionId ? [sectionId, ...this.sectionAncestorIds(sectionId)] : [];
+  }
+
+  /**
+   * Walks the section tree DOWNWARD from `sectionId`, returning all
+   * descendant section IDs in pre-order.
+   */
+  sectionDescendantIds(sectionId: string | null | undefined): string[] {
+    if (!sectionId) return [];
+    const section = this.sectionById(sectionId);
+    if (!section) return [];
+    const out: string[] = [];
+    for (const child of section.children) {
+      if (child.id) out.push(child.id);
+      out.push(...this.sectionDescendantIds(child.id));
+    }
+    return out;
+  }
+
+  sectionDescendantClosure(sectionId: string | null | undefined): string[] {
+    return sectionId ? [sectionId, ...this.sectionDescendantIds(sectionId)] : [];
+  }
+
+  /**
+   * Returns all section IDs the concept belongs to: the concept's own
+   * sections plus every ancestor of each.
+   */
+  conceptSectionIds(concept: { sections?: unknown; groups?: unknown }): string[] {
+    const own = conceptSectionIdList(concept);
+    if (own.length === 0) return [];
+    const closure = new Set<string>();
+    for (const id of own) {
+      for (const ancestor of this.sectionClosure(id)) closure.add(ancestor);
+    }
+    return [...closure];
+  }
+
+  sectionName(sectionId: string, lang: string): string | null {
+    const section = this.sectionById(sectionId);
+    return section ? section.name(lang) : null;
+  }
+
+  /**
+   * Localized display name. Returns the best-matching name string for
+   * the requested language, falling back to English, then to the first
+   * available language, then to null.
+   */
+  displayName(lang: string): string | null {
+    if (this.name == null) return null;
+    if (typeof this.name === 'string') return this.name;
+    if (typeof this.name === 'object') {
+      return (
+        this.name[lang] ??
+        this.name['eng'] ??
+        (Object.values(this.name)[0] as string | undefined) ??
+        null
+      );
+    }
+    return null;
+  }
+
+  resolvedColor(mode: 'light' | 'dark'): string | null {
+    return resolveColor(this.color, mode);
+  }
+
+  override toJSON(): RegisterJson {
+    const obj = { ...this._raw, schema_version: this.schemaVersion } as RegisterJson;
+    if (this.id != null) obj.id = this.id;
+    if (this.name != null) obj.name = this.name;
+    if (this.ref != null) obj.ref = this.ref;
+    if (this.refAliases.length > 0) obj.refAliases = [...this.refAliases];
+    if (this.year != null) obj.year = this.year;
+    if (this.urn != null) obj.urn = this.urn;
+    if (this.urnAliases.length > 0) obj.urnAliases = [...this.urnAliases];
+    if (this.status != null) obj.status = this.status;
+    if (this.supersedes != null) obj.supersedes = this.supersedes;
+    if (this.owner != null) obj.owner = this.owner;
+    if (this.sourceRepo != null) obj.sourceRepo = this.sourceRepo;
+    if (this.tags.length > 0) obj.tags = [...this.tags];
+    if (this.languages.length > 0) obj.languages = [...this.languages];
+    if (this.languageOrder.length > 0) obj.languageOrder = [...this.languageOrder];
+    if (this.ordering != null) obj.ordering = this.ordering;
+    if (this.logo != null) obj.logo = { ...this.logo };
+    if (this.color != null) {
+      obj.color =
+        typeof this.color === 'object' && this.color !== null
+          ? { ...this.color }
+          : this.color;
+    }
+    if (Object.keys(this.description).length > 0) obj.description = { ...this.description };
+    if (Object.keys(this.about).length > 0) obj.about = { ...this.about };
+    if (this.provenance.length > 0) obj.provenance = this.provenance.map((p) => ({ ...p }));
+    if (this.contributors.length > 0) obj.contributors = this.contributors.map((c) => ({ ...c }));
+    if (this.sections.length > 0) obj.sections = this.sections.map((s) => s.toJSON());
+    return obj;
+  }
+
+  static override fromJSON(data: RegisterJson): Register {
+    const instance = new Register(data);
+    const snakeToCamel = (k: string): string =>
+      k.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase());
+    return new Proxy(instance, {
+      get(target: Register, prop: string | symbol): unknown {
+        if (typeof prop === 'string') {
+          if (prop in target) return (target as unknown as Record<string, unknown>)[prop];
+          if (prop in target._raw) return target._raw[prop];
+          const camel = snakeToCamel(prop);
+          if (camel in target) return (target as unknown as Record<string, unknown>)[camel];
+        }
+        return undefined;
+      },
+    });
+  }
+}
+
+/**
+ * Recursive walk: returns the ancestor chain of `targetId` within the
+ * subtree rooted at `section`, or null if targetId is not in this
+ * subtree.
+ */
+function _ancestorChain(
+  section: Section,
+  targetId: string,
+  ancestors: string[] = [],
+): string[] | null {
+  if (section.id === targetId) return [...ancestors].reverse();
+  for (const child of section.children) {
+    const childId = child.id;
+    if (childId == null) continue;
+    const nextAncestors = section.id != null ? [...ancestors, section.id] : [...ancestors];
+    const found = _ancestorChain(child, targetId, nextAncestors);
+    if (found) return found;
+  }
+  return null;
+}
+
+/**
+ * Returns the list of section IDs a concept claims membership in.
+ * Concepts may carry section IDs via either `sections` (preferred) or
+ * `groups` (legacy). Each entry may be a string or an object with an
+ * `id` field; both forms are flattened to a string list.
+ */
+function conceptSectionIdList(concept: { sections?: unknown; groups?: unknown }): string[] {
+  if (!concept) return [];
+  const fromSections = concept.sections
+    ? _flattenSectionIds(concept.sections)
+    : [];
+  const fromGroups = concept.groups ? _flattenSectionIds(concept.groups) : [];
+  return [...fromSections, ...fromGroups];
+}
+
+function _flattenSectionIds(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  const out: string[] = [];
+  for (const entry of value) {
+    if (typeof entry === 'string') {
+      out.push(entry);
+    } else if (entry && typeof entry === 'object') {
+      const e = entry as { id?: string; sectionId?: string; ref?: { id?: string } };
+      const id = e.id ?? e.sectionId ?? e.ref?.id;
+      if (id) out.push(String(id));
+    }
+  }
+  return out;
+}

package/src/models/registrable.ts

@@ -0,0 +1,48 @@
+import { GlossaristModel } from './base.js';
+
+/**
+ * Per-class registry of named subtypes. The registry is keyed by
+ * `type` discriminator and maps to the constructor function. Used by
+ * NonVerbalEntity (Figure/Table/Formula), NonVerbalReference
+ * (Figure/Table/Formula references), and any future RegistrableModel
+ * subclass that needs polymorphic dispatch on a string discriminator.
+ *
+ * Stored as a WeakMap keyed by the base class function, so each base
+ * gets its own namespace (NonVerbalEntity.register does not collide
+ * with NonVerbalReference.register).
+ *
+ * The registry stores constructors as `Function` because TS's strict
+ * variance on constructor params makes a typed constraint reject
+ * subclasses with narrower param types. The dispatch site casts the
+ * result back to the specific subclass.
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- see docstring.
+type AnyCtor = new (...args: any[]) => any;
+
+const _registries = new WeakMap<object, Map<string, AnyCtor>>();
+
+export class RegistrableModel extends GlossaristModel {
+  static _registry(): Map<string, AnyCtor> {
+    const existing = _registries.get(this) ?? new Map();
+    if (!_registries.has(this)) _registries.set(this, existing);
+    return existing;
+  }
+
+  static register(type: string, cls: AnyCtor): void {
+    this._registry().set(type, cls);
+  }
+
+  static fromData<T extends RegistrableModel>(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- any ctor signature accepted.
+    this: new (...args: any[]) => T,
+    data: unknown,
+  ): T {
+    if (data instanceof this) return data;
+    const type = (data as { type?: string } | null)?.type;
+    const Self = this as unknown as { _registry(): Map<string, AnyCtor> };
+    const registry = Self._registry();
+    const Cls = type ? (registry.get(type) ?? (this as AnyCtor)) : (this as AnyCtor);
+    return new (Cls as new (data: unknown) => T)(data);
+  }
+}

package/src/models/{related-concept.js → related-concept.ts}

@@ -1,7 +1,9 @@
 import { GlossaristModel } from './base.js';
 import { ConceptRef } from './concept-ref.js';
+import type { ConceptRefJson } from './concept-ref.js';
+import type { LocalizedString } from './generic-member.js';
 
-export const RELATIONSHIP_TYPES = Object.freeze([
+export const RELATIONSHIP_TYPES: ReadonlyArray<string> = Object.freeze([
   // Lifecycle (ISO 10241-1)
   'deprecates', 'deprecated_by', 'supersedes', 'superseded_by',
   'replaces', 'replaced_by', 'invalidates', 'invalidated_by',
@@ -25,10 +27,9 @@ export const RELATIONSHIP_TYPES = Object.freeze([
   // Associative (ISO 10241-1 / ISO 25964)
   'see', 'related_concept', 'related_concept_broader', 'related_concept_narrower',
   'references',
-  // ExternalConcept resolution (Glossarist extension — v2 partitive-relation)
-  // Direction: real concept `provides` substance for an external concept;
-  // external concept `provided_by` real concept. Stored on the
-  // ExternalConcept. See TODO.partitive-relation-v2 item 07.
+  // ExternalConcept resolution (Glossarist extension). Direction: real
+  // concept `provides` substance for an external concept; external concept
+  // `provided_by` real concept. Stored on the ExternalConcept.
   'provides', 'provided_by',
   // Comparative (ISO 10241-1)
   'compare', 'contrast',
@@ -38,56 +39,79 @@ export const RELATIONSHIP_TYPES = Object.freeze([
   'homograph', 'false_friend',
 ]);
 
+export type RelationshipType = string;
+
+export interface RelatedConceptJson {
+  type?: RelationshipType;
+  content?: LocalizedString | string | null;
+  ref?: ConceptRefJson | ConceptRef | null;
+}
+
 export class RelatedConcept extends GlossaristModel {
-  constructor(data = {}) {
+  readonly type: RelationshipType;
+  readonly content: LocalizedString | null;
+  readonly ref: ConceptRef | null;
+
+  constructor(data: RelatedConceptJson = {}) {
     super();
     this.type = data.type ?? 'see';
-    this.content = normalizeContent(data.content);
+    this.content = _normalizeContent(data.content);
     this.ref = data.ref
-      ? (data.ref instanceof ConceptRef ? data.ref : new ConceptRef(data.ref))
+      ? data.ref instanceof ConceptRef
+        ? data.ref
+        : new ConceptRef(data.ref)
       : null;
   }
 
-  // Convenience reader: returns the first available string value
-  // from the localized hash, or null if absent. Mirrors
-  // PartitiveHyperedge#contentString.
-  get contentString() {
+  /**
+   * Convenience reader: returns the first available string value from
+   * the localized hash, or null if absent.
+   */
+  get contentString(): string | null {
     if (!this.content) return null;
     const values = Object.values(this.content);
-    return values.length > 0 ? values[0] : null;
+    return values.length > 0 ? (values[0] ?? null) : null;
   }
 
-  toJSON() {
-    const obj = { type: this.type };
+  override toJSON(): RelatedConceptJson {
+    const obj: RelatedConceptJson = { type: this.type };
     if (this.content != null) obj.content = this.content;
     if (this.ref != null) obj.ref = this.ref.toJSON();
     return obj;
   }
 
-  static identityOf(value) {
+  static identityOf(
+    value: {
+      type?: string;
+      ref?: { source?: string | null; id?: string | null } | null;
+    } | null | undefined,
+  ): string {
     const v = value ?? {};
-    const ref = v?.ref;
+    const ref = v.ref;
     return `${v.type ?? ''}|${ref?.source ?? ''}|${ref?.id ?? ''}`;
   }
 
-  identity() {
+  override identity(): string {
     return RelatedConcept.identityOf(this);
   }
 
-  static fromJSON(data) {
+  static override fromJSON(data: RelatedConceptJson): RelatedConcept {
     return new RelatedConcept(data);
   }
 }
 
-// Content is a localized string (language → text). Plain strings on
-// input are normalized to `{ default: '...' }` so callers always see
-// the same shape. Mirrors PartitiveHyperedge's normalizeContent.
-function normalizeContent(value) {
+function _normalizeContent(
+  value: LocalizedString | string | null | undefined,
+): LocalizedString | null {
   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;
+    const entries = Object.entries(value).filter(
+      ([, v]) => typeof v === 'string',
+    );
+    return entries.length > 0
+      ? (Object.fromEntries(entries) as LocalizedString)
+      : null;
   }
   return null;
 }

package/src/models/relation-categories.ts

@@ -0,0 +1,167 @@
+// Categorization SSOT for the 52 glossarist relationship types.
+
+import { RELATIONSHIP_TYPES } from './related-concept.js';
+
+export interface CategoryDefinition {
+  label: string;
+  description: string;
+  types: ReadonlyArray<string>;
+}
+
+type CategoryKey =
+  | 'lifecycle'
+  | 'hierarchical'
+  | 'associative'
+  | 'comparative'
+  | 'spatiotemporal'
+  | 'lexical'
+  | 'mapping'
+  | 'definitional';
+
+/**
+ * Each type in RELATIONSHIP_TYPES belongs to exactly one category. The
+ * categories mirror the concept-model taxonomy. Adding a new type
+ * means adding a taxonomy entry — no code changes here.
+ */
+export const RELATION_CATEGORIES: Readonly<Record<CategoryKey, CategoryDefinition>> = Object.freeze({
+  lifecycle: Object.freeze({
+    label: 'Lifecycle',
+    description: 'Concept lifecycle transitions: supersession, deprecation, replacement.',
+    types: Object.freeze([
+      'deprecates', 'deprecated_by',
+      'supersedes', 'superseded_by',
+      'replaces', 'replaced_by',
+      'invalidates', 'invalidated_by',
+      'retires', 'retired_by',
+    ]),
+  }) as CategoryDefinition,
+
+  hierarchical: Object.freeze({
+    label: 'Hierarchical',
+    description: 'Broader/narrower relations, including SKOS and ISO 25964 generic/partitive/instantial.',
+    types: Object.freeze([
+      'broader', 'narrower',
+      'broader_generic', 'narrower_generic',
+      'broader_partitive', 'narrower_partitive',
+      'broader_instantial', 'narrower_instantial',
+    ]),
+  }) as CategoryDefinition,
+
+  associative: Object.freeze({
+    label: 'Associative',
+    description: 'Generic see-also references between concepts.',
+    types: Object.freeze([
+      'see', 'related_concept',
+      'related_concept_broader', 'related_concept_narrower',
+      'references',
+    ]),
+  }) as CategoryDefinition,
+
+  comparative: Object.freeze({
+    label: 'Comparative',
+    description: 'Compare / contrast relations between concepts.',
+    types: Object.freeze(['compare', 'contrast']),
+  }) as CategoryDefinition,
+
+  spatiotemporal: Object.freeze({
+    label: 'Spatiotemporal',
+    description: 'Sequential, spatial, and temporal relations.',
+    types: Object.freeze([
+      'sequentially_related_concept',
+      'spatially_related_concept',
+      'temporally_related_concept',
+    ]),
+  }) as CategoryDefinition,
+
+  lexical: Object.freeze({
+    label: 'Lexical',
+    description: 'Lexical relations between designations across languages.',
+    types: Object.freeze(['homograph', 'false_friend']),
+  }) as CategoryDefinition,
+
+  mapping: Object.freeze({
+    label: 'Mapping',
+    description: 'SKOS mapping properties for cross-vocabulary alignment.',
+    types: Object.freeze([
+      'equivalent', 'close_match',
+      'broad_match', 'narrow_match', 'related_match',
+    ]),
+  }) as CategoryDefinition,
+
+  definitional: Object.freeze({
+    label: 'Definitional',
+    description: 'ISO 19135 concept-to-concept relations: definition, part, instance, inheritance, versioning.',
+    types: Object.freeze([
+      'has_concept', 'is_concept_of',
+      'instance_of', 'has_instance',
+      'has_definition', 'definition_of',
+      'has_part', 'is_part_of',
+      'inherits', 'inherited_by',
+      'has_version', 'version_of',
+      'current_version', 'current_version_of',
+      'provides', 'provided_by',
+    ]),
+  }) as CategoryDefinition,
+});
+
+const _CATEGORY_BY_TYPE: ReadonlyMap<string, string> = (() => {
+  const map = new Map<string, string>();
+  for (const [cat, def] of Object.entries(RELATION_CATEGORIES)) {
+    for (const t of def.types) map.set(t, cat);
+  }
+  return map;
+})();
+
+const _CATEGORY_ALIASES: Readonly<Record<string, string>> = {
+  conceptInstance: 'definitional',
+  versioning: 'definitional',
+};
+
+/**
+ * Returns the category key for the given relationship type, or null
+ * when the type is not categorized.
+ */
+export function categoryOf(type: string): string | null {
+  return _CATEGORY_BY_TYPE.get(type) ?? null;
+}
+
+/**
+ * Returns the category definition for the given category key.
+ * Accepts both canonical names (definitional) and aliases from
+ * earlier glossarist-js versions.
+ */
+export function categoryDefinition(categoryKey: string): CategoryDefinition | null {
+  const canonical = _CATEGORY_ALIASES[categoryKey] ?? categoryKey;
+  return (RELATION_CATEGORIES as Readonly<Record<string, CategoryDefinition>>)[canonical] ?? null;
+}
+
+/**
+ * MECE sanity check. Returns the list of relationship types that are
+ * NOT categorized.
+ */
+export function uncategorizedTypes(): string[] {
+  return RELATIONSHIP_TYPES.filter((t) => !_CATEGORY_BY_TYPE.has(t));
+}
+
+/**
+ * MECE sanity check. Returns a list of { type, count } entries for any
+ * type that appears in MORE than one category.
+ */
+export function duplicatedTypes(): ReadonlyArray<{ type: string; count: number }> {
+  const counts = new Map<string, number>();
+  for (const def of Object.values(RELATION_CATEGORIES)) {
+    for (const t of def.types) {
+      counts.set(t, (counts.get(t) ?? 0) + 1);
+    }
+  }
+  const out: { type: string; count: number }[] = [];
+  for (const [type, count] of counts) {
+    if (count > 1) out.push({ type, count });
+  }
+  return out;
+}
+
+export {
+  RELATION_CATEGORIES as RELATION_CATEGORIES_READONLY,
+  type CategoryKey as RelationCategoryKey,
+};