glossarist 0.4.32 → 0.4.34

package/src/validators/partitive-relation-coherence-rule.js

@@ -1,80 +1,7 @@
-// Validates PartitiveRelation coherence per ISO 704 / ISO 12620.
-//
-// Checks (per TODO.partitive-relation-v2 item 13):
-//   1. ERROR: each relation has ≥2 partitives (ISO 704 "two or more")
-//   2. ERROR: no two relations on the same concept share the same
-//      comprehensive + same criterion (duplicate decomposition —
-//      violates ISO 12620 coordinate-concept coherence)
-//   3. WARNING: a concept with multiple relations where any relation
-//      lacks criterion (cannot verify distinctness from siblings)
-//   4. WARNING: a TypeSharedPlurality with is_uncertain=true but
-//      is_shared=false (semantically odd — broken line qualifies
-//      the close-set double line; without `double`, what's being
-//      qualified?)
-//
-// Lives in the validator framework, not the model constructor, per
-// invariant I8 (TODO.hyperedges-v2/00). Constructors enforce type-shape;
-// validators enforce semantics.
+// Deprecated. This rule has been generalized and renamed to
+// HyperedgeCoherenceRule (see ./hyperedge-coherence-rule.js). The
+// new rule is type-blind — it validates every AbstractHyperedge
+// subclass, not just PartitiveHyperedge. This file remains as a
+// re-export shim for existing imports.
 
-import { ValidationRule } from './validation-rule.js';
-import { refKey, criterionKey } from './ref-keys.js';
-
-export class PartitiveRelationCoherenceRule extends ValidationRule {
-  constructor() { super('partitive-relation-coherence'); }
-
-  validate(concept, path, result) {
-    const relations = concept.partitiveRelations ?? concept.partitiveHyperedges ?? [];
-    if (relations.length === 0) return;
-
-    // Check 1: ≥2 partitives per relation. (The constructor also
-    // rejects this, but a warning here surfaces it in the result
-    // bundle for CI visibility.)
-    for (let i = 0; i < relations.length; i++) {
-      const partitiveCount = (relations[i]?.partitives ?? []).length;
-      if (partitiveCount < 2) {
-        this.addIssue(result,
-          `${path}partitiveRelations[${i}].partitives`,
-          `PartitiveRelation ${i + 1} has ${partitiveCount} partitive(s); ` +
-          `ISO 704 requires ≥2 (use a binary has_part edge for pairwise facts)`,
-        );
-      }
-    }
-
-    // Check 2: no duplicate (comprehensive + criterion) on the same concept.
-    const seen = new Map();
-    for (let i = 0; i < relations.length; i++) {
-      const rel = relations[i];
-      const compKey = refKey(rel?.comprehensive);
-      const critKey = criterionKey(rel?.criterion);
-      if (compKey == null || critKey == null) continue;
-      const key = `${compKey}|${critKey}`;
-      if (seen.has(key)) {
-        this.addIssue(result,
-          `${path}partitiveRelations[${i}]`,
-          `duplicate PartitiveRelation (same comprehensive + same criterion ` +
-          `as relation ${seen.get(key) + 1}); violates ISO 12620 coordinate-concept coherence`,
-        );
-      } else {
-        seen.set(key, i);
-      }
-    }
-
-    // Check 3: criterion documentation (warning) when concept has multiple relations.
-    if (relations.length > 1) {
-      for (let i = 0; i < relations.length; i++) {
-        if (!relations[i]?.criterion) {
-          result.addWarning(
-            `${path}partitiveRelations[${i}].criterion`,
-            `concept has multiple PartitiveRelations but relation ${i + 1} ` +
-            `has no criterion; cannot verify distinctness from siblings`,
-          );
-        }
-      }
-    }
-
-    // (Check 4 — plurality coherence — removed. The prior plurality
-    // block was based on a misreading of ISO 704; the corrected model
-    // uses per-member multiplicity + is_delimiting, which are validated
-    // at construction by PartitiveMember itself.)
-  }
-}
+export { HyperedgeCoherenceRule, PartitiveRelationCoherenceRule } from './hyperedge-coherence-rule.js';

package/src/validators/ref-keys.js

@@ -1,7 +1,7 @@
 // Shared identity-key helpers for cross-relation validators.
 //
-// Extracted from PartitiveRelationCoherenceRule and
-// BinaryHasPartRedundancyRule per TODO.partitive-relation-v3/06.
+// Extracted from HyperedgeCoherenceRule and
+// BinaryHasPartRedundancyRule.
 // Eliminates drift: both rules now use the same notion of "same ref"
 // and "same criterion" instead of each defining its own _refKey and
 // _criterionKey with subtly different behaviors.

package/src/models/partitive-relation.js

@@ -1,76 +0,0 @@
-// PartitiveRelation — 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 AbstractNaryRelation; the leaf-specific concern is the
-// PartitiveMember type for `members`. The wire-level field name
-// stays `partitives` for v1/v2 backward compat.
-//
-// ISO 704:2022 rake diagram semantics:
-//
-//   comprehensive concept
-//   ─────────────────────
-//   │ partitive (one or more) with per-member multiplicity + optional delimiting
-//   ─────────────────────
-//
-// All partitives within one relation are coordinate concepts
-// (ISO 12620): they share the comprehensive AND share the
-// criterion of subdivision.
-//
-// "Delimiting" parts (bold/3x-width line in source diagrams) behave
-// like delimiting characteristics — they distinguish the comprehensive
-// from coordinate concepts. Whether a part is delimiting depends on
-// the concept system, the coordinate concepts, the inheritance
-// principle, and the criterion of subdivision used
-// (ISO 704:2022 §5.5.4.2.1).
-//
-// Distinguished from binary `has_part` / `is_part_of` edges, which
-// express pairwise part-of assertions without completeness,
-// multiplicity, or criterion claims. A single partitive should be
-// expressed as a binary edge, not a PartitiveRelation (ISO requires
-// "two or more").
-
-import { AbstractNaryRelation } from './abstract-nary-relation.js';
-import { PartitiveMember } from './partitive-member.js';
-
-export class PartitiveRelation extends AbstractNaryRelation {
-  constructor(data = {}) {
-    const members = data?.members ?? data?.partitives;
-    super({ ...data, members });
-    this.members = members == null
-      ? this.members
-      : (Array.isArray(members)
-          ? members.map(m =>
-              m instanceof PartitiveMember ? m : new PartitiveMember(m))
-          : this.members);
-  }
-
-  get partitives() { return this.members; }
-
-  toJSON() {
-    const base = super.toJSON();
-    const { members, ...rest } = base;
-    return { ...rest, partitives: members };
-  }
-
-  static identityOf(value) {
-    const v = value ?? {};
-    const c = v.comprehensive ?? {};
-    const partKeys = Array.isArray(v.partitives ?? v.members)
-      ? (v.partitives ?? v.members).map(p => {
-          const r = p?.ref ?? p ?? {};
-          return `${r.source ?? ''}:${r.id ?? ''}`;
-        }).sort()
-      : [];
-    return `${c.source ?? ''}:${c.id ?? ''}|${partKeys.join('|')}`;
-  }
-
-  static fromJSON(data) {
-    const normalized = { ...(data ?? {}), members: data?.partitives ?? data?.members };
-    return new PartitiveRelation(normalized);
-  }
-}
-
-export default PartitiveRelation;

package/src/models/relation-type-registry.js

@@ -1,25 +0,0 @@
-// N-ary relation type registry. Single source of truth for the
-// `type` → class dispatch used by the parser, the per-file loader,
-// and Concept's unified relations resolver.
-//
-// Adding a new n-ary relation type (Sequential, Associative, …)
-// = one entry here plus one new class. Nothing else changes:
-// not Concept, not parser, not serializer, not diff, not patch,
-// not renderer.
-//
-// Lives in its own module (not relation-loader.js) because the loader
-// pulls in node:fs, which is off-limits on the browser-gcr path that
-// transitively imports this registry via Concept.
-
-import { PartitiveRelation } from './partitive-relation.js';
-import { GenericRelation } from './generic-relation.js';
-
-export const TYPE_TO_CLASS = Object.freeze({
-  partitive_relation: PartitiveRelation,
-  generic_relation: GenericRelation,
-});
-
-export function classForRelationType(type) {
-  if (typeof type !== 'string') return null;
-  return TYPE_TO_CLASS[type] ?? null;
-}

package/src/rdf/gloss-hyperedge.js

@@ -1,90 +0,0 @@
-// PartitiveHyperedge → RDF quads.
-//
-// Shape (per concept-model ontology, v3.1.0):
-//   <base>/hyperedge/<carrying-id>/<comprehensive-id>
-//     rdf:type                    gloss:PartitiveHyperedge
-//     gloss:comprehensive         <base>/concept/<comprehensive-id>
-//     gloss:hasPart               <base>/concept/<part-id>        (one per part)
-//     gloss:enumeration           "closed"|"open"                 (literal)
-//     gloss:hasPluralityMarker    "double"|"dashed"               (literal, one per marker)
-//     gloss:hyperedgeContent      "..."                           (literal, omitted if absent)
-//
-// The carrying concept links to this hyperedge via `gloss:hasPartitiveHyperedge`
-// (emitted by gloss-concept.js#conceptToQuads).
-//
-// CROSS-REPO STATUS (validated 2026-07-22):
-//   - Subject URI scheme: matches Ruby (`hyperedge/<c>/<comp>`).
-//   - `comprehensive`, `enumeration`, `hasPluralityMarker`, `hyperedgeContent`:
-//     predicates + object types match Ruby.
-//   - `hasPart`: JS follows the concept-model ontology; Ruby emits
-//     `gloss:part` instead. This is a Ruby bug — tracked as a cross-repo
-//     follow-up. Once Ruby aligns with the ontology, output will be
-//     byte-equivalent (modulo serialization order).
-
-import { PRED } from './predicates.js';
-import { WELL_KNOWN } from './prefixes.js';
-import { namedNode, literal, quad } from './terms.js';
-
-export function* hyperedgeToQuads(hyperedge, { parentUri, index }) {
-  const heSubject = hyperedgeSubjectUri(parentUri, hyperedge, index);
-  const s = namedNode(heSubject);
-
-  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.PartitiveHyperedge));
-
-  const comp = hyperedge.comprehensive;
-  if (comp && (comp.source || comp.id)) {
-    yield quad(s, namedNode(PRED.gloss.comprehensive),
-      namedNode(conceptRefUri(comp, parentUri)));
-  }
-
-  const parts = Array.isArray(hyperedge.parts) ? hyperedge.parts : [];
-  for (const p of parts) {
-    if (p && (p.source || p.id)) {
-      yield quad(s, namedNode(PRED.gloss.hasPart),
-        namedNode(conceptRefUri(p, parentUri)));
-    }
-  }
-
-  if (hyperedge.enumeration) {
-    yield quad(s, namedNode(PRED.gloss.enumeration), literal(hyperedge.enumeration));
-  }
-
-  for (const marker of Array.isArray(hyperedge.markers) ? hyperedge.markers : []) {
-    yield quad(s, namedNode(PRED.gloss.hasPluralityMarker), literal(marker));
-  }
-
-  if (hyperedge.content) {
-    const content = hyperedge.content;
-    if (typeof content === 'string') {
-      yield quad(s, namedNode(PRED.gloss.hyperedgeContent), literal(content));
-    } else if (typeof content === 'object') {
-      for (const [lang, text] of Object.entries(content)) {
-        if (typeof text !== 'string') continue;
-        yield quad(s, namedNode(PRED.gloss.hyperedgeContent), literal(text, lang));
-      }
-    }
-  }
-}
-
-// Subject URI scheme: `<base>/hyperedge/<carrying-id>/<comprehensive-id>`.
-// Matches Ruby's `subject { |h| "hyperedge/#{h.identifier}/#{h.comprehensive_id}" }`.
-// Falls back to an index suffix if comprehensive has no id, so two
-// hyperedges on the same concept never collide.
-export function hyperedgeSubjectUri(parentUri, hyperedge, index) {
-  const base = parentUri.replace(/\/concept\/[^/]+$/, '');
-  const carrierId = parentUri.split('/concept/')[1] ?? `carrier-${index}`;
-  const compId = hyperedge?.comprehensive?.id ?? `comp-${index}`;
-  return `${base}/hyperedge/${carrierId}/${compId}`;
-}
-
-// ConceptRef URI: `<base>/concept/<id>`. Matches Ruby's
-// `concept_to_gloss_transform.rb#hyperedge_concept_uri`. Source is
-// dropped from the URI; it stays on the ConceptRef object if needed.
-function conceptRefUri(ref, parentUri) {
-  const id = ref?.id;
-  if (id) {
-    const base = parentUri.split('/concept/')[0];
-    return `${base}/concept/${id}`;
-  }
-  return `urn:glossarist:${ref?.source ?? 'unknown'}:`;
-}

package/src/validators/partitive-drift-rule.js

@@ -1,51 +0,0 @@
-// Warns when a concept expresses the same partitive relationship via
-// BOTH a binary edge (broader_partitive / narrower_partitive /
-// has_part / is_part_of) AND a PartitiveHyperedge part targeting the
-// same concept. Round 1's decision (TODO.hyperedges/24) was "binary
-// and hyperedge coexist, no automatic reconciliation." This rule is
-// the detector for the resulting drift: pure warning, doesn't block
-// save, just surfaces the duplication so the author can pick one
-// encoding.
-//
-// See TODO.hyperedges-v2/21 for the design rationale.
-
-import { ValidationRule } from './validation-rule.js';
-
-const BINARY_PARTITIVE_TYPES = new Set([
-  'broader_partitive', 'narrower_partitive',
-  'has_part', 'is_part_of',
-]);
-
-export class PartitiveDriftRule extends ValidationRule {
-  constructor() { super('partitive-drift', 'warning'); }
-
-  validate(concept, path, result) {
-    const hyperedgeTargets = new Set();
-    for (const he of concept.partitiveHyperedges ?? []) {
-      const comp = he.comprehensive;
-      const compKey = `${comp?.source ?? ''}|${comp?.id ?? ''}`;
-      for (const part of he.parts ?? []) {
-        const key = `${part.source ?? ''}|${part.id ?? ''}`;
-        if (key === '|' || key === compKey) continue;
-        hyperedgeTargets.add(key);
-      }
-    }
-
-    if (hyperedgeTargets.size === 0) return;
-
-    const related = concept.relatedConcepts ?? [];
-    for (let i = 0; i < related.length; i++) {
-      const rc = related[i];
-      if (!BINARY_PARTITIVE_TYPES.has(rc.type)) continue;
-      const ref = rc.ref;
-      const key = `${ref?.source ?? ''}|${ref?.id ?? ''}`;
-      if (hyperedgeTargets.has(key)) {
-        this.addIssue(result,
-          `${path}relatedConcepts[${i}]`,
-          `concept has both a binary '${rc.type}' edge and a ` +
-          `PartitiveHyperedge part targeting (${ref?.source ?? '?'}, ` +
-          `${ref?.id ?? '?'}); pick one encoding to avoid divergence`);
-      }
-    }
-  }
-}

package/src/validators/partitive-hyperedge-rule.js

@@ -1,75 +0,0 @@
-import { ValidationRule } from './validation-rule.js';
-
-// Validates semantic invariants of PartitiveHyperedge entries that
-// the model constructor does NOT enforce. The constructor already
-// rejects empty comprehensive, empty parts, self-loops, invalid
-// marker values, and duplicate markers. This rule provides a
-// defensive walk at validation time plus a warning for the
-// implicit-enumeration case (absent in the source YAML, filled by
-// the model's DEFAULT_ENUMERATION constant).
-export class PartitiveHyperedgeShapeRule extends ValidationRule {
-  constructor() { super('partitive-hyperedge-shape'); }
-
-  validate(concept, path, result) {
-    const edges = concept.partitiveHyperedges ?? [];
-    for (let i = 0; i < edges.length; i++) {
-      const he = edges[i];
-      const base = `${path}partitiveHyperedges[${i}]`;
-
-      this._checkComprehensive(he, i, base, result);
-      this._checkParts(he, i, base, result);
-      this._checkMarkers(he, i, base, result);
-      this._checkSelfLoop(he, i, base, result);
-    }
-  }
-
-  _checkComprehensive(he, idx, base, result) {
-    const ref = he.comprehensive;
-    if (!ref || (!ref.source && !ref.id)) {
-      this.addIssue(result, `${base}.comprehensive`,
-        `partitive_hyperedge ${idx + 1} has empty comprehensive`);
-    }
-  }
-
-  _checkParts(he, idx, base, result) {
-    const parts = he.parts ?? [];
-    if (parts.length === 0) {
-      this.addIssue(result, `${base}.parts`,
-        `partitive_hyperedge ${idx + 1} has no parts`);
-      return;
-    }
-    for (let j = 0; j < parts.length; j++) {
-      const p = parts[j];
-      if (!p || (!p.source && !p.id)) {
-        this.addIssue(result, `${base}.parts[${j}]`,
-          `partitive_hyperedge ${idx + 1} part ${j + 1} has empty ref`);
-      }
-    }
-  }
-
-  _checkMarkers(he, idx, base, result) {
-    const markers = he.markers ?? [];
-    const seen = new Set();
-    for (const m of markers) {
-      if (seen.has(m)) {
-        this.addIssue(result, `${base}.markers`,
-          `partitive_hyperedge ${idx + 1} has duplicate marker '${m}'`);
-      }
-      seen.add(m);
-    }
-  }
-
-  _checkSelfLoop(he, idx, base, result) {
-    const c = he.comprehensive;
-    if (!c) return;
-    const cKey = `${c.source ?? ''}:${c.id ?? ''}`;
-    for (let j = 0; j < (he.parts ?? []).length; j++) {
-      const p = he.parts[j];
-      const pKey = `${p?.source ?? ''}:${p?.id ?? ''}`;
-      if (pKey === cKey) {
-        this.addIssue(result, `${base}.parts[${j}]`,
-          `partitive_hyperedge ${idx + 1} part ${j + 1} cannot be the comprehensive`);
-      }
-    }
-  }
-}