@glossarist/concept-browser 0.7.77 → 0.7.80

package/src/components/groups/LineageGroupSidebar.vue

@@ -1,12 +1,15 @@
 <script setup lang="ts">
 /**
  * LineageGroupSidebar — timeline-style entries for edition series.
- * Replaces the inline v-if="group.kind === 'lineage'" template in
- * AppSidebar. Open/closed: new group kinds get their own component.
+ * Invoked via DatasetGroupRenderer dispatch when group.kind === 'lineage'.
+ *
+ * Slot `expanded` receives `{ entry, isCurrent }` per entry so callers
+ * can render shared per-entry content (sub-pages, sections, etc.)
+ * without touching this component.
  */
 import { useRouter } from 'vue-router';
 
-const props = defineProps<{
+defineProps<{
   entries: Array<{
     id: string;
     title: string;
@@ -22,24 +25,27 @@ const props = defineProps<{
 
 const router = useRouter();
 
-function navigate(id: string) {
-  if (id === props.currentDataset) return;
+function navigate(id: string, current: string) {
+  if (id === current) return;
   router.push({ name: 'dataset', params: { registerId: id } });
 }
 </script>
 
 <template>
-  <div class="series-timeline">
+  <div
+    v-for="ds in entries"
+    :key="ds.id"
+    class="rounded-lg transition-all duration-150"
+    :class="currentDataset === ds.id ? 'bg-surface' : ''"
+  >
     <button
-      v-for="ds in entries"
-      :key="ds.id"
       type="button"
       class="series-entry w-full text-left flex items-center gap-2 pl-6 pr-3 py-1.5 rounded-md text-sm border-l-2 transition-all duration-150"
       :class="currentDataset === ds.id
         ? 'bg-amber-50/70 dark:bg-amber-400/10 border-l-[3px] text-ink-900 dark:text-ink-50 font-semibold'
         : 'border-transparent text-ink-600 dark:text-ink-300 hover:bg-ink-50 dark:hover:bg-ink-700/40 hover:text-ink-900 dark:hover:text-ink-50'"
-      :style="currentDataset === ds.id ? { borderLeftColor: 'var(--group-kind-lineage-light, #B8935A)' } : {}"
-      @click="navigate(ds.id)"
+      :style="currentDataset === ds.id ? { borderLeftColor: 'var(--gold-accent, #B8935A)' } : {}"
+      @click="navigate(ds.id, currentDataset)"
     >
       <span class="flex-1 truncate text-[13.5px] font-medium leading-snug">{{ ds.ref || ds.title || ds.id }}</span>
       <span
@@ -52,24 +58,6 @@ function navigate(id: string) {
         title="Current edition"
       >✦</span>
     </button>
+    <slot name="expanded" :entry="ds" :is-current="currentDataset === ds.id" />
   </div>
 </template>
-
-<style scoped>
-.series-entry {
-  position: relative;
-}
-.current-star {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  font-size: 16px;
-  line-height: 1;
-  color: var(--group-kind-lineage-light, #B8935A);
-  filter: drop-shadow(0 0 4px rgba(184, 147, 90, 0.45));
-}
-:global(.dark) .current-star {
-  color: var(--group-kind-lineage-dark, #D4AF6E);
-  filter: drop-shadow(0 0 4px rgba(212, 175, 110, 0.55));
-}
-</style>

package/src/composables/use-concept-diff.ts

@@ -0,0 +1,231 @@
+/**
+ * useConceptDiff — diff two concepts and derive render-ready sections.
+ *
+ * Consolidates logic that was previously duplicated across
+ * ConceptDiffIsland.vue and SupersessionDiffIsland.vue (DRY).
+ *
+ * Pipeline:
+ *   raw wire data → DiffableConcept → diffConcepts → ConceptDiff
+ *                                                   ↓
+ *                                               deriveDiffSections
+ *                                               computeSimilarity
+ *
+ * `similarity` is not a field on ConceptDiff (it doesn't exist in
+ * glossarist-js's type). It is computed from stats:
+ *   similarity = 1 - (added + removed + changed) / total
+ */
+
+import { ref } from 'vue';
+import { diffConcepts } from 'glossarist/diff';
+import type { ConceptDiff } from 'glossarist/diff';
+
+// ── Inputs ────────────────────────────────────────────────────────────────
+
+/** Wire shape of a concept as stored in fetched JSON or content collections. */
+export interface ConceptLikeData {
+  conceptId?: string;
+  id?: string;
+  uri?: string;
+  status?: string;
+  languages?: string[];
+  localizations?: Record<string, unknown>;
+}
+
+/** Normalized concept shape consumed by diffConcepts. */
+export interface DiffableConcept {
+  readonly id: string;
+  readonly termid: string;
+  readonly status?: string;
+  readonly uri?: string;
+  readonly languages: readonly string[];
+  localization(lang: string): {
+    languageCode: string;
+    terms: unknown[];
+    definitions: unknown[];
+    notes: unknown[];
+    examples: unknown[];
+  } | null;
+}
+
+// ── Outputs ───────────────────────────────────────────────────────────────
+
+export type DiffHunk = { type: 'added' | 'removed' | 'equal'; text: string };
+
+export interface DefinitionDiff {
+  hunks?: readonly DiffHunk[];
+  type?: 'added' | 'removed';
+  value?: string;
+}
+
+export interface DesignationsDiff {
+  items: Array<{ type?: string; text: string }>;
+}
+
+export interface SimpleChangesDiff {
+  items: Array<{ type?: string; text: string }>;
+}
+
+export interface DiffSections {
+  definition?: DefinitionDiff;
+  designations?: DesignationsDiff;
+  terms?: { hunks?: readonly DiffHunk[]; oldValue?: string; newValue?: string };
+  notes?: SimpleChangesDiff;
+  examples?: SimpleChangesDiff;
+}
+
+// ── Adapters ──────────────────────────────────────────────────────────────
+
+export function toDiffableConcept(data: ConceptLikeData): DiffableConcept {
+  const langs = data.languages
+    ?? (data.localizations ? Object.keys(data.localizations) : []);
+  const id = String(data.conceptId ?? data.id ?? '');
+  return {
+    id,
+    termid: id,
+    status: data.status,
+    uri: data.uri,
+    languages: langs,
+    localization(lang: string) {
+      const locs = (data.localizations ?? {}) as Record<string, any>;
+      const loc = locs[lang];
+      if (!loc) return null;
+      return {
+        languageCode: loc.languageCode ?? lang,
+        terms: loc.terms ?? [],
+        definitions: loc.definitions ?? [],
+        notes: loc.notes ?? [],
+        examples: loc.examples ?? [],
+      };
+    },
+  };
+}
+
+// ── Pure derivations ──────────────────────────────────────────────────────
+
+interface ReadableConceptDiff {
+  localization?(lang: string): any;
+  localizations?: Record<string, any>;
+  stats?: { added?: number; removed?: number; changed?: number; total?: number };
+}
+
+function asReadable(diff: ConceptDiff): ReadableConceptDiff {
+  return diff as unknown as ReadableConceptDiff;
+}
+
+function extractDesignationText(value: any): string {
+  if (value == null) return '';
+  if (typeof value === 'string') return value;
+  return value.designation ?? value.text ?? String(value);
+}
+
+function extractContentText(value: any): string {
+  if (value == null) return '';
+  if (typeof value === 'string') return value;
+  return value.content ?? value.text ?? String(value);
+}
+
+/**
+ * Derive render-ready DiffSections from a ConceptDiff for a single language.
+ * Pure function — same diff + lang always yields the same sections.
+ */
+export function deriveDiffSections(diff: ConceptDiff | null, lang: string): DiffSections {
+  if (!diff) return {};
+  const d = asReadable(diff);
+  const loc = d.localization?.(lang) ?? d.localizations?.[lang];
+  if (!loc) return {};
+  const out: DiffSections = {};
+
+  const defChanged = loc.definitions?.changed?.[0];
+  if (defChanged?.textDiff?.hunks?.length) {
+    out.definition = { hunks: defChanged.textDiff.hunks };
+  } else if (loc.definitions?.added?.length) {
+    out.definition = { type: 'added', value: extractContentText(loc.definitions.added[0].value) };
+  } else if (loc.definitions?.removed?.length) {
+    out.definition = { type: 'removed', value: extractContentText(loc.definitions.removed[0].value) };
+  }
+
+  const hasDesignationChanges =
+    loc.designations?.added?.length
+    || loc.designations?.removed?.length
+    || loc.designations?.changed?.length;
+  if (hasDesignationChanges) {
+    const items: Array<{ type?: string; text: string }> = [];
+    for (const d of loc.designations.added ?? []) {
+      items.push({ type: 'added', text: extractDesignationText(d.value) });
+    }
+    for (const d of loc.designations.removed ?? []) {
+      items.push({ type: 'removed', text: extractDesignationText(d.value) });
+    }
+    for (const d of loc.designations.changed ?? []) {
+      items.push({ type: 'removed', text: extractDesignationText(d.oldValue) });
+      items.push({ type: 'added', text: extractDesignationText(d.newValue) });
+    }
+    out.designations = { items };
+  }
+
+  if (loc.notes?.added?.length || loc.notes?.removed?.length) {
+    out.notes = {
+      items: [
+        ...(loc.notes.added ?? []).map((n: any) => ({ type: 'added', text: extractContentText(n.value) })),
+        ...(loc.notes.removed ?? []).map((n: any) => ({ type: 'removed', text: extractContentText(n.value) })),
+      ],
+    };
+  }
+
+  if (loc.examples?.added?.length || loc.examples?.removed?.length) {
+    out.examples = {
+      items: [
+        ...(loc.examples.added ?? []).map((e: any) => ({ type: 'added', text: extractContentText(e.value) })),
+        ...(loc.examples.removed ?? []).map((e: any) => ({ type: 'removed', text: extractContentText(e.value) })),
+      ],
+    };
+  }
+
+  return out;
+}
+
+/**
+ * Similarity score in [0, 1]. Returns null when no comparable stats.
+ *
+ * Computed as 1 − (added + removed + changed) / total — i.e. the
+ * fraction of the concept that did NOT change. `added` counts as a
+ * change because it represents content present in only one version.
+ */
+export function computeSimilarity(diff: ConceptDiff | null): number | null {
+  if (!diff) return null;
+  const stats = asReadable(diff).stats;
+  if (!stats || !stats.total) return null;
+  const changed = (stats.added ?? 0) + (stats.removed ?? 0) + (stats.changed ?? 0);
+  return Math.max(0, Math.min(1, 1 - changed / stats.total));
+}
+
+// ── Composable ────────────────────────────────────────────────────────────
+
+export function useConceptDiff() {
+  const diffResult = ref<ConceptDiff | null>(null);
+  const loading = ref(false);
+  const error = ref<string | null>(null);
+
+  function diff(oldData: ConceptLikeData | null, newData: ConceptLikeData | null): void {
+    loading.value = true;
+    error.value = null;
+    try {
+      diffResult.value = diffConcepts(
+        oldData ? toDiffableConcept(oldData) : null,
+        newData ? toDiffableConcept(newData) : null,
+      );
+    } catch (e: unknown) {
+      error.value = e instanceof Error ? e.message : String(e);
+      diffResult.value = null;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  function clear(): void {
+    diffResult.value = null;
+    error.value = null;
+  }
+
+  return { diffResult, loading, error, diff, clear };
+}

package/src/composables/use-concept-edges.ts

@@ -1,9 +1,23 @@
 import { computed, type ComputedRef } from 'vue';
 import type { Router } from 'vue-router';
-import type { Concept, RelatedConcept } from 'glossarist';
-import type { Manifest, GraphEdge } from '../adapters/types';
+import type {
+  Concept,
+  RelatedConcept,
+  PartitiveRelation as GlsPartitiveRelation,
+  PartitiveMember as GlsPartitiveMember,
+  TypeSharedPlurality as GlsTypeSharedPlurality,
+  ConceptRef,
+} from 'glossarist';
+import type {
+  Manifest,
+  GraphEdge,
+  PartitiveRelationWire,
+  PartitiveMemberWire,
+  TypeSharedPluralityWire,
+} from '../adapters/types';
 import { getFactory } from '../adapters/factory';
 import { conceptUri } from '../adapters/model-bridge';
+import { UriRouter } from '../adapters/UriRouter';
 import { useVocabularyStore } from '../stores/vocabulary';
 import { useDsStyle } from '../utils/dataset-style';
 import { categorizeRelationship, relationshipLabel, INVERSE_RELATIONSHIPS } from '../utils/relationship-categories';
@@ -111,9 +125,80 @@ export function useConceptEdges(
           content: '',
         };
       });
-    return [...direct, ...derived];
+    return [...direct, ...derived].filter(edge => {
+      if (edge.type === 'broader_partitive' || edge.type === 'narrower_partitive') {
+        const refUri = resolveRefUri(edge.ref as { source: string | null; id: string | null } | null);
+        if (!refUri) return true;
+        const rels = conceptPartitiveRelations.value;
+        return !rels.some(rel =>
+          rel.comprehensive === refUri
+          || rel.partitives.some(m => m.uri === refUri),
+        );
+      }
+      return true;
+    });
   });
 
+  // Concept-level partitive relations (ISO 704 one-to-many decompositions).
+  // Reads the glossarist-js native model (`concept.partitiveRelations`)
+  // and projects each relation into a URI-resolved wire shape for display.
+  // Independent of binary `conceptRelated`.
+  // v2 shape per concept-model/TODO.partitive-relation-v2.
+  const conceptPartitiveRelations = computed<PartitiveRelationWire[]>(() => {
+    const source = conceptUriValue.value;
+    const relations: readonly GlsPartitiveRelation[] = concept.value.partitiveRelations;
+    return relations
+      .map((rel): PartitiveRelationWire | null => {
+        const comprehensive = resolveConceptRefUri(rel.comprehensive);
+        if (!comprehensive) return null;
+        const partitives: PartitiveMemberWire[] = rel.partitives
+          .map((m: GlsPartitiveMember): PartitiveMemberWire | null => {
+            const uri = resolveConceptRefUri(m.ref);
+            if (!uri || uri === source) return null;
+            return { uri, certainty: m.certainty };
+          })
+          .filter((m: PartitiveMemberWire | null): m is PartitiveMemberWire => m !== null);
+        if (partitives.length === 0) return null;
+
+        return {
+          source,
+          comprehensive,
+          partitives,
+          completeness: rel.completeness,
+          plurality: projectPlurality(rel.plurality),
+          criterion: rel.criterion ?? undefined,
+          register: registerId.value,
+        };
+      })
+      .filter((r: PartitiveRelationWire | null): r is PartitiveRelationWire => r !== null);
+  });
+
+  function projectPlurality(p: GlsTypeSharedPlurality | null): TypeSharedPluralityWire | null {
+    if (!p) return null;
+    const sharedTypeRef: ConceptRef | null = p.sharedType;
+    const sharedType = sharedTypeRef
+      ? [sharedTypeRef.source, sharedTypeRef.id].filter(Boolean).join(':') || null
+      : null;
+    return {
+      isShared: p.isShared,
+      isUncertain: p.isUncertain,
+      sharedType,
+    };
+  }
+
+  function resolveConceptRefUri(ref: ConceptRef | null): string | null {
+    if (!ref) return null;
+    return resolveRefUri({ source: ref.source ?? null, id: ref.id ?? null });
+  }
+
+  function resolveRefUri(ref: { source: string | null; id: string | null } | null): string | null {
+    const target = resolveRelatedRef(ref);
+    if (!target) return null;
+    const m = store.manifests.get(target.registerId);
+    if (!m) return null;
+    return UriRouter.buildConceptUri(m.uriBase, target.registerId, target.conceptId);
+  }
+
   function resolveRelatedRef(ref: { source: string | null; id: string | null } | null) {
     return factory.resolveRelatedRef(ref, registerId.value);
   }
@@ -134,8 +219,15 @@ export function useConceptEdges(
     return resolvedRefs.value.get(key) ?? { target: resolveRelatedRef(ref) };
   }
 
-  function relatedLabel(dr: { content?: string | null; ref?: { source: string | null; id: string | null } | null }): string {
-    if (dr.content) return dr.content;
+  function relatedLabel(dr: { content?: Record<string, string> | string | null; ref?: { source: string | null; id: string | null } | null }): string {
+    if (dr.content) {
+      // Content is a localized hash { eng: "...", fra: "..." }.
+      // Legacy data may still carry a plain string; tolerate both.
+      const c = dr.content as Record<string, string> | string;
+      if (typeof c === 'string') return c;
+      const values = Object.values(c);
+      if (values.length > 0) return values[0];
+    }
     const resolved = dr.ref ? getResolvedRef(dr.ref).target : null;
     if (resolved) {
       const m = store.manifests.get(resolved.registerId);
@@ -173,6 +265,7 @@ export function useConceptEdges(
     edgeBadgeColor,
     inverseEdgeType,
     conceptRelated,
+    conceptPartitiveRelations,
     resolveRelatedRef,
     getResolvedRef,
     relatedLabel,

package/src/composables/use-dataset-stats.ts

@@ -0,0 +1,52 @@
+/**
+ * useDatasetStats — loads stats.json for a dataset register.
+ *
+ * Single source of truth for the DatasetStats wire shape; both
+ * DatasetView (summary badges) and StatsView (full table) consume it.
+ */
+import { ref, watch, type Ref } from 'vue';
+import type { DatasetStats } from '../adapters/dataset-stats';
+
+export function useDatasetStats(
+  registerId: Ref<string> | (() => string),
+  baseUrl: string = import.meta.env.BASE_URL,
+) {
+  const stats = ref<DatasetStats | null>(null);
+  const loading = ref(false);
+  const error = ref<string | null>(null);
+
+  const resolved = typeof registerId === 'function' ? registerId() : registerId.value;
+
+  async function load(id: string) {
+    if (!id) return;
+    loading.value = true;
+    error.value = null;
+    try {
+      const resp = await fetch(`${baseUrl}data/${id}/stats.json`);
+      if (resp.ok) {
+        stats.value = await resp.json() as DatasetStats;
+      } else {
+        stats.value = null;
+      }
+    } catch (e: unknown) {
+      stats.value = null;
+      error.value = e instanceof Error ? e.message : String(e);
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  if (typeof registerId === 'function') {
+    // Re-fetch on app boot only; callers can call reload() to refresh.
+    load(resolved);
+  } else {
+    watch(registerId, id => load(id), { immediate: true });
+  }
+
+  function reload() {
+    const id = typeof registerId === 'function' ? registerId() : registerId.value;
+    load(id);
+  }
+
+  return { stats, loading, error, reload };
+}

package/src/config/page-types.ts

@@ -0,0 +1,67 @@
+/**
+ * Page type registry — OCP-compliant metadata for synthesized pages.
+ *
+ * Adding a new built-in page type = add one entry to PAGE_TYPES.
+ * `synthesizeGlobalPages` and `synthesizeDatasetPages` iterate the
+ * registry; no switches to edit.
+ *
+ * PageConfig.type stays a string — it tags the page's semantic kind
+ * for consumers (sidebar, future renderers). The router is the SSOT
+ * for route → view dispatch, not this registry.
+ *
+ * Mirrors the group-renderers.ts pattern: registry + lookup helper.
+ */
+
+export interface PageTypeDefinition {
+  readonly type: string;
+  readonly route: string;
+  readonly title: string;
+  readonly icon: string;
+  readonly scope: 'global' | 'dataset';
+  /** When defined, the page is only synthesized when features[flag] is truthy
+   *  (or, if the flag starts with '!', when features[flag.slice(1)] is falsy). */
+  readonly featureFlag?: string;
+  /** Synthesize automatically unless a declared page already uses this route. */
+  readonly autoSynthesize?: boolean;
+}
+
+export const PAGE_TYPES: readonly PageTypeDefinition[] = [
+  { type: 'home',       route: '',        title: 'Home',         icon: 'home',       scope: 'global',  autoSynthesize: true },
+  { type: 'concepts',   route: '',        title: 'Concepts',     icon: 'list',       scope: 'dataset', autoSynthesize: true },
+  { type: 'search',     route: 'search',  title: 'Search',       icon: 'search',     scope: 'global',  featureFlag: '!search',    autoSynthesize: true },
+  { type: 'graph',      route: 'graph',   title: 'Graph',        icon: 'graph',      scope: 'global',  featureFlag: '!graph',     autoSynthesize: true },
+  { type: 'ontology',   route: 'ontology',title: 'Ontology',     icon: 'schema',     scope: 'global',  featureFlag: '!ontology',  autoSynthesize: true },
+  { type: 'news',       route: 'news',    title: 'News',         icon: 'newspaper',  scope: 'global',  featureFlag: 'news', autoSynthesize: true },
+  { 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 },
+] as const;
+
+export type BuiltinPageType = typeof PAGE_TYPES[number]['type'];
+
+const PAGE_TYPE_INDEX: ReadonlyMap<string, PageTypeDefinition> = new Map(
+  PAGE_TYPES.map(p => [p.type, p]),
+);
+
+export function pageTypeOf(type: string): PageTypeDefinition | undefined {
+  return PAGE_TYPE_INDEX.get(type);
+}
+
+function featureEnabled(features: Record<string, unknown> | undefined, flag: string): boolean {
+  if (flag.startsWith('!')) {
+    return features?.[flag.slice(1)] !== false;
+  }
+  return Boolean(features?.[flag]);
+}
+
+/** Synthesize the auto-on pages for a given scope, respecting feature flags
+ *  and skipping routes already declared by the user. */
+export function synthesizePages(
+  scope: 'global' | 'dataset',
+  features: Record<string, unknown> | undefined,
+  declaredRoutes: ReadonlySet<string>,
+): PageTypeDefinition[] {
+  return PAGE_TYPES.filter(p => p.scope === scope && p.autoSynthesize)
+    .filter(p => !p.featureFlag || featureEnabled(features, p.featureFlag))
+    .filter(p => !declaredRoutes.has(p.route));
+}

package/src/config/types.ts

@@ -137,7 +137,12 @@ export const FORMAT_LABELS: Record<string, string> = {
 
 // === Pages ===
 
-export type PageType = 'page' | 'news' | 'contributors' | 'about' | 'stats' | 'custom';
+/**
+ * Page type tag. Any string is allowed — built-in tags are listed in
+ * `page-types.ts` PAGE_TYPES registry. Adding a new built-in type is
+ * a registry entry, not an edit to this union.
+ */
+export type PageType = string;
 
 export interface PageConfig {
   type: PageType;

package/src/config/use-site-config.ts

@@ -1,6 +1,7 @@
 import { ref, computed } from 'vue';
 import type { PageConfig, SiteColors } from './types';
 import type { DatasetGroup } from './types';
+import { synthesizePages } from './page-types';
 import { locale } from '../i18n';
 
 export interface RuntimeSiteConfig {
@@ -128,43 +129,26 @@ function synthesizeGlobalPages(features?: Record<string, unknown>, pages?: PageC
   const declared = pages?.filter(p => !p.datasetScoped) ?? [];
   const declaredRoutes = new Set(declared.map(p => p.route));
 
-  const result: PageConfig[] = [
-    { type: 'custom', route: '', title: 'Home', icon: 'home' },
-  ];
-  if (features?.search !== false && !declaredRoutes.has('search')) {
-    result.push({ type: 'custom', route: 'search', title: 'Search', icon: 'search' });
-  }
-  if (features?.graph !== false && !declaredRoutes.has('graph')) {
-    result.push({ type: 'custom', route: 'graph', title: 'Graph', icon: 'graph' });
-  }
-  if (features?.ontology !== false && !declaredRoutes.has('ontology')) {
-    result.push({ type: 'custom', route: 'ontology', title: 'Ontology', icon: 'schema' });
-  }
-  if (features?.news && !declaredRoutes.has('news')) {
-    result.push({ type: 'news', route: 'news', title: 'News', icon: 'newspaper' });
-  }
+  const synthesized = synthesizePages('global', features, declaredRoutes)
+    .map(p => ({ type: p.type, route: p.route, title: p.title, icon: p.icon }));
 
-  return [...result, ...declared];
+  return [...synthesized, ...declared];
 }
 
 function synthesizeDatasetPages(features?: Record<string, unknown>, pages?: PageConfig[]): PageConfig[] {
   const declared = pages?.filter(p => p.datasetScoped) ?? [];
   const declaredRoutes = new Set(declared.map(p => p.route));
 
-  const result: PageConfig[] = [
-    { type: 'custom', route: '', title: 'Concepts', icon: 'list', datasetScoped: true },
-  ];
-  if (features?.stats !== false && !declaredRoutes.has('stats')) {
-    result.push({ type: 'stats', route: 'stats', title: 'Statistics', icon: 'chart', datasetScoped: true });
-  }
-  if (!declaredRoutes.has('sources')) {
-    result.push({ type: 'sources', route: 'sources', title: 'Sources', icon: 'database', datasetScoped: true });
-  }
-  if (features?.about !== false && !declaredRoutes.has('about')) {
-    result.push({ type: 'about', route: 'about', title: 'About', icon: 'info', datasetScoped: true });
-  }
+  const synthesized = synthesizePages('dataset', features, declaredRoutes)
+    .map(p => ({
+      type: p.type,
+      route: p.route,
+      title: p.title,
+      icon: p.icon,
+      datasetScoped: true as const,
+    }));
 
-  return [...result, ...declared];
+  return [...synthesized, ...declared];
 }
 
 export function useSiteConfig() {