@glossarist/concept-browser 0.7.99 → 0.7.101

package/src/__tests__/views/learn/learn-relationships-view.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import LearnRelationshipsView from '../../../views/learn/LearnRelationshipsView.vue';
+
+async function makeRouter() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/learn/relationships', name: 'learn-relationships', component: LearnRelationshipsView },
+    ],
+  });
+  await router.push('/learn/relationships');
+  await router.isReady();
+  return router;
+}
+
+describe('LearnRelationshipsView', () => {
+  beforeEach(() => setActivePinia(createPinia()));
+
+  it('renders the page header with translated title', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    expect(w.find('h1').text()).toContain('Relationships');
+  });
+
+  it('renders three top-level sections (bilateral, partitive, general)', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const sections = w.findAll('section[aria-label]');
+    expect(sections.length).toBe(3);
+  });
+
+  it('renders the hyperedge cards with the expected anchors', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const ids = w.findAll('.learn-card[id]').map(c => c.attributes('id'));
+    expect(ids).toContain('__partitive__');
+    expect(ids).toContain('__generic__');
+  });
+
+  it('renders three DimensionCards for the partitive dimensions', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const dimIds = w.findAll('.dimension-card[id]').map(c => c.attributes('id'));
+    expect(dimIds).toEqual(expect.arrayContaining(['partitive-presence', 'partitive-count', 'partitive-delimiting']));
+  });
+
+  it('renders the bilateral section grouped by category', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const bilateralArticles = w.find('section[aria-label="Bilateral relations (one-to-one)"]').findAll('article');
+    expect(bilateralArticles.length).toBeGreaterThanOrEqual(5);
+  });
+
+  it('every bilateral type row has an id anchor matching the type key', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const rows = w.findAll('.bilateral-row');
+    expect(rows.length).toBeGreaterThan(10);
+    for (const row of rows) {
+      const id = row.attributes('id');
+      expect(id).toBeTruthy();
+      expect(id).toMatch(/^[a-z_]+$/);
+    }
+  });
+
+  it('renders a live diagram for each hyperedge card', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    expect(w.findAll('svg.hyperedge-diagram').length).toBe(2);
+  });
+
+  it('renders ISO references on each hyperedge card', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const isoRefs = w.findAll('.learn-card span.font-mono').map(s => s.text());
+    expect(isoRefs.some(t => t.includes('ISO 704:2022 §5.5.4.3'))).toBe(true);
+    expect(isoRefs.some(t => t.includes('ISO 704:2022 §5.5.4.2'))).toBe(true);
+  });
+});

package/src/__tests__/views/learn/learn-statuses-view.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import LearnStatusesView from '../../../views/learn/LearnStatusesView.vue';
+
+async function makeRouter() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/learn/statuses', name: 'learn-statuses', component: LearnStatusesView },
+      { path: '/learn/designations', name: 'learn-designations', component: { template: '<div/>' } },
+    ],
+  });
+  await router.push('/learn/statuses');
+  await router.isReady();
+  return router;
+}
+
+describe('LearnStatusesView', () => {
+  beforeEach(() => setActivePinia(createPinia()));
+
+  it('renders the page header', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnStatusesView, { global: { plugins: [router] } });
+    expect(w.find('h1').text()).toContain('Statuses');
+  });
+
+  it('renders three top-level sections (entry, normative, source)', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnStatusesView, { global: { plugins: [router] } });
+    const sections = w.findAll('section[aria-label]');
+    expect(sections.length).toBe(3);
+  });
+
+  it('entry section renders all four entry statuses with anchors', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnStatusesView, { global: { plugins: [router] } });
+    const entrySection = w.find('section[aria-label="Entry status"]');
+    const ids = entrySection.findAll('.learn-card[id]').map(c => c.attributes('id'));
+    expect(ids).toEqual(expect.arrayContaining(['entry-valid', 'entry-withdrawn', 'entry-draft', 'entry-superseded']));
+  });
+
+  it('normative section cross-links to /learn/designations', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnStatusesView, { global: { plugins: [router] } });
+    const normative = w.find('section[aria-label="Normative status"]');
+    const link = normative.find('a');
+    expect(link.attributes('href')).toBe('/learn/designations');
+  });
+
+  it('source section renders the four source statuses with anchors', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnStatusesView, { global: { plugins: [router] } });
+    const sourceSection = w.find('section[aria-label="Source status"]');
+    const ids = sourceSection.findAll('.learn-card[id]').map(c => c.attributes('id'));
+    expect(ids).toEqual(expect.arrayContaining(['source-identical', 'source-modified', 'source-restyled', 'source-lineage']));
+  });
+});

package/src/components/HyperedgeDiagram.vue

@@ -0,0 +1,115 @@
+<script setup lang="ts">
+/**
+ * HyperedgeDiagram — small inline SVG that calls the actual sphere
+ * renderers (drawRakeBundles / drawGenericPipes) on hand-picked
+ * sample data. Used on the Relation Types teaching page.
+ *
+ * The diagrams stay in sync with the real sphere rendering by
+ * construction — no static SVG to drift out of date.
+ */
+import { onMounted, ref } from 'vue';
+import { drawRakeBundles } from './relation-sphere/rake-bundles';
+import { drawGenericPipes } from './relation-sphere/pipe-bundles';
+import type {
+  PartitiveRelationWire,
+  PartitiveMemberWire,
+  GenericRelationWire,
+} from '../adapters/types';
+import { useUiStore } from '../stores/ui';
+
+const props = defineProps<{
+  kind: 'partitive' | 'generic';
+}>();
+
+const svgRef = ref<SVGSVGElement | null>(null);
+const uiStore = useUiStore();
+
+/* Synthetic positions: comp at top-center, members fanned across the
+   bottom. Mirrors the layout the sphere produces for a 3-member
+   hyperedge with the focus at the center. */
+const POS = new Map<string, { x: number; y: number }>([
+  ['vim-2012/1.3', { x: 120, y: 24 }],
+  ['vim-2012/1.4', { x: 36, y: 132 }],
+  ['vim-2012/1.5', { x: 120, y: 144 }],
+  ['vim-2012/1.22', { x: 204, y: 132 }],
+]);
+
+const PARTITIVE: PartitiveRelationWire = {
+  source: 'https://example.org/vim-2012/concept/1.3',
+  comprehensive: 'https://example.org/vim-2012/concept/1.3',
+  completeness: 'partial',
+  register: 'vim-2012',
+  partitives: [
+    /* required + multiple → solid double-line */
+    { uri: 'https://example.org/vim-2012/concept/1.4', presence: 'required', count: 'multiple', isDelimiting: false },
+    /* required + exactly_one + delimiting → 3× width single solid */
+    { uri: 'https://example.org/vim-2012/concept/1.5', presence: 'required', count: 'exactly_one', isDelimiting: true },
+    /* optional + at_least_one → dashed double-line */
+    { uri: 'https://example.org/vim-2012/concept/1.22', presence: 'optional', count: 'at_least_one', isDelimiting: false },
+  ] satisfies PartitiveMemberWire[],
+};
+
+const GENERIC: GenericRelationWire = {
+  source: 'https://example.org/vim-2012/concept/1.9',
+  comprehensive: 'https://example.org/vim-2012/concept/1.9',
+  completeness: 'partial',
+  register: 'vim-2012',
+  criterion: { eng: 'by magnitude relationship', fra: 'selon la relation de grandeur' },
+  members: [
+    { uri: 'https://example.org/vim-2012/concept/1.17', presence: 'required', count: 'at_least_one',
+      delimitingCharacteristic: { eng: 'multiple of a unit', fra: "multiple d'une unité" } },
+    { uri: 'https://example.org/vim-2012/concept/1.18', presence: 'required', count: 'at_least_one',
+      delimitingCharacteristic: { eng: 'submultiple of a unit', fra: "sous-multiple d'une unité" } },
+    { uri: 'https://example.org/vim-2012/concept/1.12', presence: 'required', count: 'at_least_one',
+      delimitingCharacteristic: { eng: 'coherent derived unit', fra: 'unité dérivée cohérente' } },
+  ],
+};
+
+/* Override positions for the generic sample (comp is 1.9, members are 1.17/1.18/1.12). */
+const GENERIC_POS = new Map<string, { x: number; y: number }>([
+  ['vim-2012/1.9', { x: 120, y: 24 }],
+  ['vim-2012/1.17', { x: 36, y: 132 }],
+  ['vim-2012/1.18', { x: 120, y: 144 }],
+  ['vim-2012/1.12', { x: 204, y: 132 }],
+]);
+
+onMounted(() => {
+  const svg = svgRef.value;
+  if (!svg) return;
+  if (props.kind === 'partitive') {
+    drawRakeBundles(svg, POS, {
+      isDark: uiStore.isDark,
+      color: uiStore.isDark ? '#2dd4bf' : '#0d9488',
+      isMuted: false,
+      relations: [PARTITIVE],
+    });
+  } else {
+    drawGenericPipes(svg, GENERIC_POS, {
+      isDark: uiStore.isDark,
+      color: uiStore.isDark ? '#fbbf24' : '#b45309',
+      isMuted: false,
+      relations: [GENERIC],
+      locale: 'eng',
+    });
+  }
+});
+</script>
+
+<template>
+  <svg
+    ref="svgRef"
+    class="hyperedge-diagram"
+    viewBox="0 0 240 168"
+    xmlns="http://www.w3.org/2000/svg"
+    aria-hidden="true"
+  />
+</template>
+
+<style scoped>
+.hyperedge-diagram {
+  width: 100%;
+  max-width: 240px;
+  height: auto;
+  display: block;
+}
+</style>

package/src/components/RelationSphere.vue

@@ -1068,7 +1068,7 @@ const legendItems = computed(() => {
   if (partitiveCount > 0) {
     typeMap.set('__partitive__', {
       type: '__partitive__',
-      label: 'Partitive Relation',
+      label: 'partitive relation',
       color: uiStore.isDark ? '#2dd4bf' : '#0d9488',
       count: partitiveCount,
     });
@@ -1078,7 +1078,7 @@ const legendItems = computed(() => {
   if (genericCount > 0) {
     typeMap.set('__generic__', {
       type: '__generic__',
-      label: 'General Relation',
+      label: 'general relation',
       color: uiStore.isDark ? '#fbbf24' : '#b45309',
       count: genericCount,
     });
@@ -1405,16 +1405,23 @@ defineExpose({ navigate });
         <div v-if="legendItems.length" class="sp-section">
           <div class="sp-section-label">{{ t('sphere.relationTypes') }}</div>
           <div class="sp-legend-grid">
-            <button v-for="item in legendItems" :key="item.type" class="sp-legend-item"
+            <div v-for="item in legendItems" :key="item.type"
+              class="sp-legend-item"
               :class="{ muted: isTypeMuted(item.type), 'is-partitive': item.type === '__partitive__' }"
-              @click="toggleType(item.type)"
-              :title="item.type">
-              <span v-if="item.type === '__partitive__'" class="sp-swatch sp-swatch-rake"
-                :style="{ '--rake-color': isTypeMuted(item.type) ? '#b8b9cc' : item.color }"></span>
-              <span v-else class="sp-swatch" :style="{ background: isTypeMuted(item.type) ? '#b8b9cc' : item.color }"></span>
-              <span>{{ item.label }}</span>
-              <span class="sp-count">{{ item.count }}</span>
-            </button>
+            >
+              <button class="sp-legend-toggle"
+                @click="toggleType(item.type)"
+                :title="item.type"
+                :aria-label="`${t('sphere.toggleMute')}: ${item.label}`">
+                <span v-if="item.type === '__partitive__'" class="sp-swatch sp-swatch-rake"
+                  :style="{ '--rake-color': isTypeMuted(item.type) ? '#b8b9cc' : item.color }"></span>
+                <span v-else class="sp-swatch" :style="{ background: isTypeMuted(item.type) ? '#b8b9cc' : item.color }"></span>
+                <span class="sp-count">{{ item.count }}</span>
+              </button>
+              <router-link class="sp-legend-label"
+                :to="{ name: 'learn-relationships', hash: '#' + item.type }"
+                :title="t('sphere.learnAbout') + ': ' + item.label">{{ item.label }}</router-link>
+            </div>
           </div>
         </div>
 
@@ -1653,12 +1660,22 @@ defineExpose({ navigate });
 /* Type legend */
 .sp-legend-grid { display: flex; flex-direction: column; gap: 2px; }
 .sp-legend-item {
-  display: flex; align-items: center; gap: 8px; padding: 3px 6px; border-radius: 3px;
-  cursor: pointer; border: 1px solid transparent; background: transparent; text-align: left;
+  display: flex; align-items: center; gap: 6px; padding: 3px 6px; border-radius: 3px;
+  border: 1px solid transparent; background: transparent; text-align: left;
   width: 100%; font-family: inherit; font-size: 11px; color: var(--ink-mute);
 }
 .sp-legend-item:hover { background: var(--rule); }
 .sp-legend-item.muted { opacity: 0.35; }
+.sp-legend-toggle {
+  display: inline-flex; align-items: center; gap: 6px; flex-shrink: 0;
+  cursor: pointer; border: none; background: transparent; padding: 0;
+  font: inherit; color: inherit;
+}
+.sp-legend-label {
+  color: inherit; text-decoration: none; flex: 1; min-width: 0;
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}
+.sp-legend-label:hover { text-decoration: underline; }
 .sp-swatch { width: 18px; height: 2px; flex-shrink: 0; border-radius: 1px; }
 /* Rake swatch — small bracket icon signaling a PartitiveRelation hyperedge
    (not a single binary edge). Two parallel solid lines (close-set double)

package/src/components/learn/DimensionCard.vue

@@ -0,0 +1,71 @@
+<script setup lang="ts">
+/**
+ * DimensionCard — structured breakdown of a single dimension along
+ * which hyperedge members vary. Used on /learn/relationships for the
+ * partitive dimensions (presence, count, delimiting).
+ *
+ * Renders one row per value showing:
+ *   - the raw value (machine key)
+ *   - the human label
+ *   - a short meaning (what it encodes)
+ *   - a small visual representation (slot — typically a mini SVG)
+ *
+ * The user's specific concern: "individually show what dimensions
+ * there are and how lines look like". This component is the answer.
+ */
+export interface DimensionValue {
+  value: string;
+  label: string;
+  meaning: string;
+}
+
+defineProps<{
+  id?: string;
+  name: string;
+  isoReference?: string;
+  /** Plain-language summary of what this dimension captures. */
+  summary: string;
+  values: readonly DimensionValue[];
+}>();
+</script>
+
+<template>
+  <article :id="id" class="dimension-card card p-5 scroll-mt-20">
+    <header class="flex items-baseline justify-between gap-3 mb-2 flex-wrap">
+      <h4 class="text-base font-semibold text-ink-800 dark:text-ink-50">{{ name }}</h4>
+      <span v-if="isoReference" class="text-xs font-mono text-ink-400 dark:text-ink-500">
+        {{ isoReference }}
+      </span>
+    </header>
+    <p class="text-sm text-ink-600 dark:text-ink-200 mb-4">{{ summary }}</p>
+    <ul class="dimension-values space-y-3">
+      <li v-for="v in values" :key="v.value" class="dimension-value-row">
+        <div class="flex items-center gap-3">
+          <div class="dimension-visual">
+            <slot name="visual" :value="v.value" />
+          </div>
+          <div class="flex-1 min-w-0">
+            <div class="flex items-baseline gap-2 flex-wrap">
+              <span class="font-medium text-ink-800 dark:text-ink-100">{{ v.label }}</span>
+              <code class="text-xs text-ink-400 dark:text-ink-500 font-mono">{{ v.value }}</code>
+            </div>
+            <p class="text-sm text-ink-600 dark:text-ink-300 mt-0.5">{{ v.meaning }}</p>
+          </div>
+        </div>
+      </li>
+    </ul>
+  </article>
+</template>
+
+<style scoped>
+.dimension-card {
+  scroll-margin-top: 5rem;
+}
+.dimension-visual {
+  flex-shrink: 0;
+  width: 48px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+</style>

package/src/components/learn/LearnCard.vue

@@ -0,0 +1,59 @@
+<script setup lang="ts">
+/**
+ * LearnCard — the standard topic container across all /learn pages.
+ *
+ * Layout: title + ISO reference on top, then a flexible body. Optional
+ * named slots:
+ *   - `diagram` — a small visual (live SVG, badge samples, etc.)
+ *   - `example` — a concrete real-world example
+ * Optional `learnMoreUrl` renders a "Learn more on glossarist.org"
+ * link at the bottom — keeps concept-browser reader-focused while
+ * bridging to the canonical author docs on glossarist.org.
+ *
+ * Anchored at the `id` prop so URLs like `/learn/relationships#partitive`
+ * deep-link to the right card.
+ */
+defineProps<{
+  id?: string;
+  title: string;
+  isoReference?: string;
+  learnMoreUrl?: string;
+  learnMoreLabel?: string;
+}>();
+</script>
+
+<template>
+  <article :id="id" class="learn-card card p-5 scroll-mt-20">
+    <header class="flex items-baseline justify-between gap-3 mb-3 flex-wrap">
+      <h3 class="text-lg font-semibold text-ink-800 dark:text-ink-50">{{ title }}</h3>
+      <span v-if="isoReference" class="text-xs font-mono text-ink-400 dark:text-ink-500">
+        {{ isoReference }}
+      </span>
+    </header>
+    <div v-if="$slots.diagram" class="learn-card-diagram mb-3">
+      <slot name="diagram" />
+    </div>
+    <div class="learn-card-body text-sm text-ink-600 dark:text-ink-200">
+      <slot />
+    </div>
+    <div v-if="$slots.example" class="learn-card-example mt-3 pt-3 border-t border-ink-100 dark:border-ink-700 text-xs text-ink-500 dark:text-ink-400">
+      <slot name="example" />
+    </div>
+    <footer v-if="learnMoreUrl" class="learn-card-footer mt-3 text-xs">
+      <a :href="learnMoreUrl" target="_blank" rel="noopener"
+         class="text-ink-500 dark:text-ink-400 hover:text-ink-800 dark:hover:text-ink-100 underline">
+        {{ learnMoreLabel ?? 'Learn more on glossarist.org' }} ↗
+      </a>
+    </footer>
+  </article>
+</template>
+
+<style scoped>
+.learn-card {
+  scroll-margin-top: 5rem;
+}
+.learn-card-diagram {
+  display: flex;
+  justify-content: center;
+}
+</style>

package/src/config/page-types.ts

@@ -35,6 +35,7 @@ export const PAGE_TYPES: readonly PageTypeDefinition[] = [
   { type: 'stats',      route: 'stats',   title: 'Statistics',   icon: 'chart',      scope: 'dataset', featureFlag: '!stats',     autoSynthesize: true },
   { type: 'sources',    route: 'sources', title: 'Sources',      icon: 'database',   scope: 'dataset', autoSynthesize: true },
   { type: 'about',      route: 'about',   title: 'About',        icon: 'info',       scope: 'dataset', featureFlag: '!about',     autoSynthesize: true },
+  { type: 'learn',      route: 'learn',   title: 'Learn',        icon: 'book-open',  scope: 'global',  autoSynthesize: true },
 ] as const;
 
 export type BuiltinPageType = typeof PAGE_TYPES[number]['type'];

package/src/i18n/locales/eng.yml

@@ -12,6 +12,110 @@ nav.about: About
 nav.sources: Sources
 nav.navigation: Navigation
 nav.datasets: Datasets
+nav.relationTypes: Relation Types
+nav.learn: Learn
+
+# Learn section (reader-focused teaching)
+learn.intro: This section explains what you see on this site and what each label means. For canonical methodology docs (authoring datasets, ISO alignment), see glossarist.org.
+learn.glossaristOrgNote: Methodology documentation for dataset authors lives on glossarist.org.
+learn.example: Example
+learn.learnMore: Learn more on glossarist.org
+learn.relationships.title: Relationships
+learn.relationships.short: How to read the bilateral edges, partitive rake, and general pipe-and-thread.
+learn.relationships.intro: Every line and label on the Relation Sphere, the detail page, and the graph view maps to a typed semantic relation. This page explains what each kind means and how to read its visual encoding.
+learn.relationships.bilateralSection: Bilateral relations (one-to-one)
+learn.relationships.bilateralIntro: One-to-one typed relations between two concepts. Drawn as straight colored lines with arrowheads in the sphere.
+learn.relationships.partitiveSection: Partitive hyperedge (one-to-many)
+learn.relationships.partitiveTitle: partitive relation
+learn.relationships.partitiveBody: A whole/part decomposition. The comprehensive concept is the whole; each member is a part. Rendered as a rake — a stem from the comprehensive to a perpendicular spine, with teeth dropping to each partitive member.
+learn.relationships.generalSection: General hyperedge (one-to-many)
+learn.relationships.generalTitle: general relation
+learn.relationships.generalBody: A genus/species decomposition. The comprehensive concept is the genus; each member is a coordinate species differing along a shared dimension. Rendered as a tree branch — a thick parent pipe from the comprehensive to a middle node, with thin threads radiating to each member.
+learn.relationships.criterionTitle: Criterion of subdivision
+learn.relationships.criterionBody: "The dimension along which coordinate concepts differ. Shown once on the parent pipe body. Optional: when no criterion is described, no label is drawn."
+learn.relationships.thickThinTitle: Thick/thin hierarchy
+learn.relationships.thickThinBody: ISO 704 traditionally uses thicker lines to mark different criteria of subdivision (multidimensionality). The pipe-and-thread honors this with a thick parent pipe (3.2px) and thinner child threads (1.0px) — the tree-branch metaphor (trunk vs twigs).
+learn.dimensions.sectionTitle: Partitive dimensions (how to read the rake teeth)
+learn.dimensions.presence.title: Presence
+learn.dimensions.presence.summary: Whether the part must be present (compulsory) or may be absent (optional).
+learn.dimensions.presence.required.label: required
+learn.dimensions.presence.required.meaning: The part must be present. Drawn as a solid line.
+learn.dimensions.presence.optional.label: optional
+learn.dimensions.presence.optional.meaning: The part may be absent. Drawn as a dashed line.
+learn.dimensions.count.title: Count
+learn.dimensions.count.summary: How many instances of the part occur in the whole.
+learn.dimensions.count.exactly_one.label: exactly one
+learn.dimensions.count.exactly_one.meaning: One and only one. Drawn as a single line.
+learn.dimensions.count.at_least_one.label: at least one
+learn.dimensions.count.at_least_one.meaning: One or more. Drawn as a double line, the secondary dashed ("possibly more").
+learn.dimensions.count.multiple.label: multiple
+learn.dimensions.count.multiple.meaning: Two or more. Drawn as a double line, both the same style as the primary.
+learn.dimensions.delimiting.title: Delimiting
+learn.dimensions.delimiting.summary: Whether the part reflects a delimiting characteristic — one that distinguishes the whole from coordinate concepts.
+learn.dimensions.delimiting.false.label: not delimiting
+learn.dimensions.delimiting.false.meaning: An ordinary part. Drawn at normal stroke width (1.5px).
+learn.dimensions.delimiting.true.label: delimiting
+learn.dimensions.delimiting.true.meaning: The part is essential to the whole's identity. Drawn at 3× normal stroke width (4.5px).
+learn.designations.title: Designations
+learn.designations.short: Terms and symbols — preferred, admitted, deprecated, full form, abbreviation, acronym, initialism.
+learn.designations.intro: Concepts are designated by terms, proper names, and symbols. This page explains the vocabulary you'll see on each concept page.
+learn.designations.normativeSection: Normative status
+learn.designations.normativeIntro: Each term carries a normative rating from the standardizing body. There can be MORE THAN ONE of each rating — preferred terms aren't unique.
+learn.designations.preferred.label: preferred term
+learn.designations.preferred.meaning: The primary term for the concept, rated by a standardizing body.
+learn.designations.preferred.multipleNote: There can be more than one preferred term.
+learn.designations.admitted.label: admitted term
+learn.designations.admitted.meaning: A synonym for the preferred term, but not rated as preferred.
+learn.designations.admitted.multipleNote: There can be more than one admitted term.
+learn.designations.deprecated.label: deprecated term
+learn.designations.deprecated.meaning: A synonym for the preferred term, but rated as undesired.
+learn.designations.deprecated.multipleNote: There can be more than one deprecated term.
+learn.designations.kindsSection: Kinds and forms of term
+learn.designations.fullForm.label: full form
+learn.designations.fullForm.meaning: The complete representation of a designation.
+learn.designations.abbreviatedForm.label: abbreviated form
+learn.designations.abbreviatedForm.meaning: A representation resulting from the omission of any part of the full form.
+learn.designations.abbreviatedForm.multipleNote: For some full forms, two or more abbreviated forms may exist.
+learn.designations.borrowed.label: borrowed term
+learn.designations.borrowed.meaning: A term taken from another language or from another domain.
+learn.designations.variant.label: variant
+learn.designations.variant.meaning: One of the alternative forms of a designation (e.g. spelling differences across regions).
+learn.designations.typesSection: Designation types
+learn.designations.typesIntro: Three top-level types — terms, proper names, and symbols. Within terms, abbreviations split further into acronyms vs initialisms based on how they're pronounced.
+learn.designations.term.label: term (expression)
+learn.designations.term.meaning: A spoken or written designation — the most common type.
+learn.designations.acronym.label: acronym
+learn.designations.acronym.meaning: An abbreviated form pronounced as a single word.
+learn.designations.initialism.label: initialism
+learn.designations.initialism.meaning: An abbreviated form pronounced letter by letter.
+learn.designations.symbol.label: symbol
+learn.designations.symbol.meaning: A graphical or mathematical designation governed by ISO 80000 / IEC 60027.
+learn.statuses.title: Statuses
+learn.statuses.short: Entry status (valid/withdrawn/draft), normative status, source status — what each badge means.
+learn.statuses.intro: Status badges appear throughout the site. This page is a quick reference for what each one means.
+learn.statuses.entrySection: Entry status
+learn.statuses.entry.valid.label: valid
+learn.statuses.entry.valid.meaning: The concept entry is currently in force.
+learn.statuses.entry.withdrawn.label: withdrawn
+learn.statuses.entry.withdrawn.meaning: The entry has been removed from active use.
+learn.statuses.entry.draft.label: draft
+learn.statuses.entry.draft.meaning: The entry is under development and not yet finalized.
+learn.statuses.entry.superseded.label: superseded
+learn.statuses.entry.superseded.meaning: The entry has been replaced by a newer one.
+learn.statuses.normativeSection: Normative status
+learn.statuses.normativeTitle: preferred / admitted / deprecated
+learn.statuses.normativeSummary: Per-term rating (preferred, admitted, deprecated). Each rating can apply to more than one term per concept.
+learn.statuses.normativeGoDeeper: See designation types for examples
+learn.statuses.sourceSection: Source status
+learn.statuses.sourceIntro: Each citation carries a status describing how faithfully it reproduces the source.
+learn.statuses.source.identical.label: identical
+learn.statuses.source.identical.meaning: The definition matches the source verbatim.
+learn.statuses.source.modified.label: modified
+learn.statuses.source.modified.meaning: The definition is adapted from the source with editorial changes.
+learn.statuses.source.restyled.label: restyled
+learn.statuses.source.restyled.meaning: The definition preserves the source meaning but rewords it heavily.
+learn.statuses.source.lineage.label: lineage
+learn.statuses.source.lineage.meaning: The source is the historical ancestor of this concept, not a direct citation.
 
 # Home page
 home.search: Search
@@ -213,6 +317,8 @@ sphere.tight: tight
 sphere.loose: loose
 sphere.redraw: Redraw
 sphere.focus: FOCUS
+sphere.toggleMute: Toggle visibility
+sphere.learnAbout: Learn about this relation type
 concept.detailView: Detail
 concept.relationSphere: Relation Sphere
 concept.permalink: Permalink