@directory-builder/core 0.1.0 → 0.1.2

package/webapp/src/MatchGraph.jsx

@@ -35,7 +35,7 @@ const criteriaPredicates = (() => {
 })()
 
 // Map<recordIri, Map<predIri, [literalValue]>> for the per-member details modal.
-const orgInfo = groupBySubject(parseTtl(mappedTtl), { literalsOnly: true })
+const entityInfo = groupBySubject(parseTtl(mappedTtl), { literalsOnly: true })
 
 const manualPairs = parseTtl(matchKnowledgeTtl)
     .filter(q => q.predicate.value === OWL_SAME_AS)
@@ -52,7 +52,7 @@ function MemberDetailsModal({ clusterId, memberIris, onClose }) {
                     <button onClick={onClose} style={{ border: 0, background: "transparent", fontSize: 18, cursor: "pointer", lineHeight: 1 }}>×</button>
                 </div>
                 {memberIris.map((iri) => {
-                    const info = orgInfo.get(iri)
+                    const info = entityInfo.get(iri)
                     return (
                         <div key={iri} style={{ marginBottom: 14 }}>
                             <div style={{ fontSize: 11, color: "#666", marginBottom: 4 }}><code>{prefixed(iri)}</code></div>
@@ -98,7 +98,7 @@ export default function MatchGraph() {
             if (n.isCluster) n.subtitle = n.id.startsWith(CDF_NS) ? `cdf:${n.id.slice(CDF_NS.length)}` : prefixed(n.id)
             else {                                     // a source (dedup) node
                 n.label = sourceCode(n.id)
-                n.subtitle = orgInfo.get(n.id)?.get(SCHEMA_IDENTIFIER)?.[0]
+                n.subtitle = entityInfo.get(n.id)?.get(SCHEMA_IDENTIFIER)?.[0]
             }
         }
         // Drop columns that ended up empty (schemas with no source duplication when

package/webapp/src/MergeTables.jsx

@@ -1,42 +1,51 @@
-// Merge view: every org with its per-source field values and conflict
-// highlighting; each org's services are nested (indented) beneath it.
-// Reads:  mergedOrgs from mergeOrgs.js (← data/pipeline/merged.ttl + provenance.ttl)
-// Does:   renders the Merge page (compact / wide <OrgCard>, toggleable)
+// Merge view: every entity with its per-source field values and conflict
+// highlighting. An entity referencing another via a relationship the
+// federation declares (mapping :hasRelationship → :toTargetField →
+// :targetPredicate) renders nested beneath it.
+// Reads:  mergedEntities from mergeEntities.js (← merged.ttl + provenance.ttl),
+//         config/federation.ttl (relationship predicates)
+// Does:   renders the Merge page (compact / wide <EntityCard>, toggleable)
 
-import OrgCard from "./OrgCard.jsx"
-import { mergedOrgs } from "./mergeOrgs.js"
+import { CDP, parseTtl } from "@directory-builder/core/utils"
+import { mergedEntities } from "./mergeEntities.js"
+import { federationTtl } from "./instanceData.js"
+import EntityCard from "./EntityCard.jsx"
 import React, { useState } from "react"
 
-const SCHEMA_SERVICE = "schema:Service"
-const PROVIDER = "http://schema.org/provider"
-const providerOf = (e) => e.fields.find((f) => f.predicate === PROVIDER)?.values[0]?.raw
+const fedQuads = parseTtl(federationTtl)
+const relFields = new Set(fedQuads.filter((q) => q.predicate.value === `${CDP}toTargetField`).map((q) => q.object.value))
+const REL_PREDS = new Set(fedQuads.filter((q) => relFields.has(q.subject.value) && q.predicate.value === `${CDP}targetPredicate`).map((q) => q.object.value))
 
-// Top-level orgs keep their existing (conflict-sorted) order; services are
-// grouped under their provider org. Any service whose provider isn't a merged
-// org falls through as an orphan, rendered at the end.
-const orgs = mergedOrgs.filter((e) => e.type !== SCHEMA_SERVICE)
-const orgIris = new Set(orgs.map((o) => o.iri))
-const servicesByOrg = new Map()
-const orphanServices = []
-for (const e of mergedOrgs) {
-    if (e.type !== SCHEMA_SERVICE) continue
-    const provider = providerOf(e)
-    if (provider && orgIris.has(provider)) {
-        if (!servicesByOrg.has(provider)) servicesByOrg.set(provider, [])
-        servicesByOrg.get(provider).push(e)
-    } else {
-        orphanServices.push(e)
-    }
+// An entity's parent = the first relationship value pointing at another merged
+// entity. Entities keep their (conflict-sorted) order within each level.
+const iris = new Set(mergedEntities.map((e) => e.iri))
+const parentOf = (e) => e.fields.find((f) => REL_PREDS.has(f.predicate) && iris.has(f.values[0]?.raw))?.values[0].raw
+const childrenOf = new Map()
+const hasParent = new Set()
+for (const e of mergedEntities) {
+    const p = parentOf(e)
+    if (!p || p === e.iri) continue
+    if (!childrenOf.has(p)) childrenOf.set(p, [])
+    childrenOf.get(p).push(e)
+    hasParent.add(e.iri)
 }
 
+// Flatten to (entity, depth) rows; the second pass catches reference cycles,
+// which would otherwise never be reached from a top-level entity.
+const ROWS = []
+const seen = new Set()
+const walk = (e, depth) => {
+    if (seen.has(e.iri)) return
+    seen.add(e.iri)
+    ROWS.push({ e, depth })
+    for (const c of childrenOf.get(e.iri) ?? []) walk(c, depth + 1)
+}
+for (const e of mergedEntities) if (!hasParent.has(e.iri)) walk(e, 0)
+for (const e of mergedEntities) walk(e, 0)
+
 export default function MergeTables() {
     const [compact, setCompact] = useState(true)
     const [highlight, setHighlight] = useState(true)
-    const service = (svc) => (
-        <div key={svc.iri} style={{ marginLeft: "1.5rem", borderLeft: "2px solid #e0e0e0", paddingLeft: "0.75rem" }}>
-            <OrgCard org={svc} compact={compact} highlight={highlight} />
-        </div>
-    )
     return (
         <div className="page" style={{ overflowY: "auto", height: "100%" }}>
             <div style={{ display: "flex", gap: "1rem", marginBottom: "0.75rem", fontSize: 13 }}>
@@ -49,13 +58,11 @@ export default function MergeTables() {
                     Highlight conflicts
                 </label>
             </div>
-            {orgs.map((org) => (
-                <React.Fragment key={org.iri}>
-                    <OrgCard org={org} compact={compact} highlight={highlight} />
-                    {(servicesByOrg.get(org.iri) ?? []).map(service)}
-                </React.Fragment>
+            {ROWS.map(({ e, depth }) => (
+                <div key={e.iri} style={depth ? { marginLeft: `${depth * 1.5}rem`, borderLeft: "2px solid #e0e0e0", paddingLeft: "0.75rem" } : undefined}>
+                    <EntityCard entity={e} compact={compact} highlight={highlight} />
+                </div>
             ))}
-            {orphanServices.map(service)}
         </div>
     )
 }

package/webapp/src/Query.jsx

@@ -5,7 +5,7 @@
 
 import { storeFromTurtles } from "@foerderfunke/sem-ops-utils/core"
 import { queryEngine } from "@foerderfunke/sem-ops-utils/sparql"
-import { finalTtl } from "./instanceData.js"
+import { finalTtl, querySparql } from "./instanceData.js"
 import React, { useEffect, useRef } from "react"
 import "@zazuko/yasgui/build/yasgui.min.css"
 import Yasgui from "@zazuko/yasgui"
@@ -18,14 +18,9 @@ const ENDPOINT = "http://local/sparql"
 
 const store = storeFromTurtles([finalTtl])
 
-const INITIAL_QUERY = `PREFIX schema: <http://schema.org/>
-PREFIX cdf: <https://civic-data.de/federated-directory#>
-
-SELECT ?org (SAMPLE(?name) AS ?title) WHERE {
-    ?org schema:name ?name .
-}
-GROUP BY ?org
-ORDER BY ?title`
+// Instances own the editor's starting query via webapp/content/query.sparql
+// (fetched at runtime like the About prose); plain select-all without one.
+const INITIAL_QUERY = querySparql || "SELECT * WHERE { ?s ?p ?o } LIMIT 100"
 
 Yasgui.Yasqe.defaults.value = INITIAL_QUERY
 

package/webapp/src/instanceData.js

@@ -6,7 +6,7 @@
 // artifact resolves to "" (pages render empty). Top-level await — importing
 // modules stay synchronous.
 
-import { CDP, objectsOf, parseTtl, PATHS, prefixesOf, sourceName } from "@directory-builder/core/utils"
+import { CDP, enabledSources, objectsOf, parseTtl, PATHS, prefixesOf, sourceName } from "@directory-builder/core/utils"
 
 const fetchText = async (path) => {
     const res = await fetch(`${import.meta.env.BASE_URL}${path}`).catch(() => null)
@@ -16,20 +16,24 @@ const fetchText = async (path) => {
 export const federationTtl = await fetchText(PATHS.federation)
 
 const fedQuads = parseTtl(federationTtl)
-const cleanedPaths = objectsOf(fedQuads, `${CDP}hasSource`).map((iri) => PATHS.cleaned(sourceName(iri)))
+const cleanedPaths = enabledSources(fedQuads).map((iri) => PATHS.cleaned(sourceName(iri)))
 // The instance's repo URL (:federation :repository …) — undefined when not
 // declared; pages hide their GitHub links then.
 export const repositoryUrl = objectsOf(fedQuads, `${CDP}repository`)[0]
 // Display prefixes = the federation's own @prefix declarations; cdp pinned
 // first so cdp:… wins over the empty ":" prefix bound to the same namespace.
 export const displayPrefixes = { cdp: CDP, ...prefixesOf(federationTtl) }
+// The federation's display name (:federation rdfs:label) — optional; the
+// webapp keeps its generic title without one.
+export const federationLabel = fedQuads.find((q) =>
+    q.subject.value === `${CDP}federation` && q.predicate.value === "http://www.w3.org/2000/01/rdf-schema#label")?.object.value
 
 const FIXED = [PATHS.matchKnowledge, PATHS.ingestLog, PATHS.federateLog, PATHS.mapped,
-               PATHS.matches, PATHS.merged, PATHS.provenance, PATHS.final, PATHS.about]
+               PATHS.matches, PATHS.merged, PATHS.provenance, PATHS.final, PATHS.about, PATHS.query]
 const [fixedTexts, cleanedTexts] = await Promise.all([
     Promise.all(FIXED.map(fetchText)),
     Promise.all(cleanedPaths.map(fetchText)),
 ])
 
-export const [matchKnowledgeTtl, ingestLogTtl, federateLogTtl, mappedTtl, matchesTtl, mergedTtl, provenanceTtl, finalTtl, aboutMd] = fixedTexts
+export const [matchKnowledgeTtl, ingestLogTtl, federateLogTtl, mappedTtl, matchesTtl, mergedTtl, provenanceTtl, finalTtl, aboutMd, querySparql] = fixedTexts
 export const cleanedByPath = Object.fromEntries(cleanedPaths.map((p, i) => [p, cleanedTexts[i]]))

package/webapp/src/loadMap.js

@@ -1,7 +1,7 @@
-// Helpers for the Map view: build the schema-mapping graph and resolve per-org
+// Helpers for the Map view: build the schema-mapping graph and resolve per-entity
 // source/target field values. Pure (ttl in → data out).
 // Reads:  TTL strings passed by MapGraph.jsx (federation, mapped, cleaned source TTL)
-// Does:   returns { nodes, edges } plus per-source / per-org value maps
+// Does:   returns { nodes, edges } plus per-source / per-entity value maps
 
 import { CDP as NS, localName, parseTtl, prefixesOf, shrink, sourceName, subjectsOfType, typesOf } from "@directory-builder/core/utils"
 
@@ -9,26 +9,26 @@ const RDFS_LABEL = "http://www.w3.org/2000/01/rdf-schema#label"
 const NODE_TYPES = [`${NS}Source`, `${NS}SourceField`, `${NS}TargetField`, `${NS}TargetSchema`]
 const SUB_FIELD = `${NS}SubField`
 
-// Group orgs by source. Each org carries a cdp:fromSource triple in mapped.ttl
+// Group entities by source. Each entity carries a cdp:fromSource triple in mapped.ttl
 // pointing at its Source IRI, so this is a single-pass scan with no prefix
 // matching.
-export function loadOrgsBySource(_federationTtl, mappedTtl) {
+export function loadEntitiesBySource(_federationTtl, mappedTtl) {
     const SCHEMA_NAME       = "http://schema.org/name"
     const SCHEMA_IDENTIFIER = "http://schema.org/identifier"
     const FROM_SOURCE       = `${NS}fromSource`
 
-    const orgSource = new Map()  // orgIri -> sourceIri
+    const entitySource = new Map()  // entityIri -> sourceIri
     const ids       = new Map()
     const names     = new Map()
     for (const q of parseTtl(mappedTtl)) {
         const p = q.predicate.value
-        if      (p === FROM_SOURCE)       orgSource.set(q.subject.value, q.object.value)
+        if      (p === FROM_SOURCE)       entitySource.set(q.subject.value, q.object.value)
         else if (p === SCHEMA_IDENTIFIER) ids.set(q.subject.value, q.object.value)
         else if (p === SCHEMA_NAME)       names.set(q.subject.value, q.object.value)
     }
 
     const result = new Map()
-    for (const [iri, src] of orgSource) {
+    for (const [iri, src] of entitySource) {
         if (!result.has(src)) result.set(src, [])
         result.get(src).push({
             iri,
@@ -40,11 +40,11 @@ export function loadOrgsBySource(_federationTtl, mappedTtl) {
     return result
 }
 
-// For each org in mapped.ttl, resolve the literal value of each of its
+// For each entity in mapped.ttl, resolve the literal value of each of its
 // source fields/sub-fields (from the source's lifted/cleaned TTL) AND each
 // target field (from mapped.ttl, indirected via the field's :targetPredicate).
-// Returns Map<orgIri, Map<fieldIri, string>>.
-export function loadFieldValuesByOrg(federationTtl, mappedTtl, liftedBySource) {
+// Returns Map<entityIri, Map<fieldIri, string>>.
+export function loadFieldValuesByEntity(federationTtl, mappedTtl, liftedBySource) {
     const fedQuads = parseTtl(federationTtl)
     const fieldPathOf       = new Map()
     const fieldsBySource    = new Map()
@@ -64,13 +64,13 @@ export function loadFieldValuesByOrg(federationTtl, mappedTtl, liftedBySource) {
     }
 
     const FROM_SOURCE = `${NS}fromSource`
-    const orgSource     = new Map() // orgIri -> sourceIri
-    const literalsByOrg = new Map() // orgIri -> Map<predicateIri, string>
+    const entitySource     = new Map() // entityIri -> sourceIri
+    const literalsByEntity = new Map() // entityIri -> Map<predicateIri, string>
     for (const q of parseTtl(mappedTtl)) {
-        if (q.predicate.value === FROM_SOURCE) orgSource.set(q.subject.value, q.object.value)
+        if (q.predicate.value === FROM_SOURCE) entitySource.set(q.subject.value, q.object.value)
         if (q.object.termType === "Literal") {
-            if (!literalsByOrg.has(q.subject.value)) literalsByOrg.set(q.subject.value, new Map())
-            literalsByOrg.get(q.subject.value).set(q.predicate.value, q.object.value)
+            if (!literalsByEntity.has(q.subject.value)) literalsByEntity.set(q.subject.value, new Map())
+            literalsByEntity.get(q.subject.value).set(q.predicate.value, q.object.value)
         }
     }
 
@@ -88,10 +88,10 @@ export function loadFieldValuesByOrg(federationTtl, mappedTtl, liftedBySource) {
         }
 
         const fields = fieldsBySource.get(sourceIri) ?? []
-        for (const [orgIri, src] of orgSource) {
+        for (const [entityIri, src] of entitySource) {
             if (src !== sourceIri) continue
             // Source subject IS the federation IRI post-clean — no lookup needed.
-            const subjectPreds = graph.get(orgIri)
+            const subjectPreds = graph.get(entityIri)
             if (!subjectPreds) continue
 
             const valueMap = new Map()
@@ -115,17 +115,17 @@ export function loadFieldValuesByOrg(federationTtl, mappedTtl, liftedBySource) {
                     }
                 }
             }
-            result.set(orgIri, valueMap)
+            result.set(entityIri, valueMap)
         }
     }
 
     // Layer in target-field values: indirect each :targetPredicate through the
-    // org's literal predicate->value map from mapped.ttl. These are the values
+    // entity's literal predicate->value map from mapped.ttl. These are the values
     // that flow OUT of transform nodes (and equal the source value for direct
     // 1:1 mappings).
-    for (const [orgIri, preds] of literalsByOrg) {
-        if (!result.has(orgIri)) result.set(orgIri, new Map())
-        const valueMap = result.get(orgIri)
+    for (const [entityIri, preds] of literalsByEntity) {
+        if (!result.has(entityIri)) result.set(entityIri, new Map())
+        const valueMap = result.get(entityIri)
         for (const [tfIri, predIri] of targetPredicateOf) {
             const v = preds.get(predIri)
             if (v) valueMap.set(tfIri, v)

package/webapp/src/loadMerge.js

@@ -1,9 +1,9 @@
-// Parses merged + provenance TTL into org objects: each field's values and the
+// Parses merged + provenance TTL into entity objects: each field's values and the
 // :Source(s) that contributed them, ordered by config. Pure (ttl in → data out).
-// Reads:  TTL strings passed by mergeOrgs.js; resolves sources via sourceMeta.js
-// Does:   returns org[] (each {iri, label, type, fields[], sources[]})
+// Reads:  TTL strings passed by mergeEntities.js; resolves sources via sourceMeta.js
+// Does:   returns entity[] (each {iri, label, type, fields[], sources[]})
 
-import { CDP as NS, parseTtl, parseTtlStar, prefixesOf, shrink } from "@directory-builder/core/utils"
+import { CDP as NS, parseTtl, prefixesOf, shrink } from "@directory-builder/core/utils"
 import { compareSources, loadSourceMeta } from "./sourceMeta.js"
 
 const PROV_DERIVED_FROM = "http://www.w3.org/ns/prov#wasDerivedFrom"
@@ -16,13 +16,11 @@ export function loadMerge(mergedTtl, provTtl, federationTtl = "") {
     const prefixes = { cdp: NS, ...prefixesOf(federationTtl) }
     const prefixedIri = (iri) => shrink(iri, prefixes)
     const mergedQuads = parseTtl(mergedTtl)
-    const provQuads = parseTtlStar(provTtl)
+    const provQuads = parseTtl(provTtl)
     const sourceMeta = federationTtl ? loadSourceMeta(federationTtl) : new Map()
 
-    // Each prov:wasDerivedFrom in provenance.ttl annotates a merged triple
-    // `<<s p o>>` with the source record IRI it came from. n3.js exposes the
-    // quoted-triple subject either directly as a Quad term, or via an
-    // auto-generated reifier bnode + rdf:reifies triple — accept both shapes.
+    // provenance.ttl is RDF 1.2 reification: one reifier per derivation
+    // (`_:r rdf:reifies <<( s p o )>> ; prov:wasDerivedFrom record`).
     const reifies = new Map()
     for (const q of provQuads) {
         if (q.predicate.value === RDF_REIFIES && q.object.termType === "Quad") reifies.set(q.subject.value, q.object)
@@ -30,7 +28,7 @@ export function loadMerge(mergedTtl, provTtl, federationTtl = "") {
     const annotations = []
     for (const q of provQuads) {
         if (q.predicate.value !== PROV_DERIVED_FROM) continue
-        const t = q.subject.termType === "Quad" ? q.subject : reifies.get(q.subject.value)
+        const t = reifies.get(q.subject.value)
         if (t) annotations.push({ s: t.subject.value, p: t.predicate.value, o: t.object.value, rec: q.object.value })
     }
     // Resolve each record to its :Source via cdp:fromSource (reified in
@@ -48,46 +46,46 @@ export function loadMerge(mergedTtl, provTtl, federationTtl = "") {
     }
 
     // Walk merged.ttl in parse order so card order = pipeline order.
-    const orgs = []
-    const orgIndex = new Map()
-    const fieldIndexByOrg = new Map()
+    const entities = []
+    const entityIndex = new Map()
+    const fieldIndexByEntity = new Map()
     for (const q of mergedQuads) {
-        const orgIri = q.subject.value
+        const entityIri = q.subject.value
         const predIri = q.predicate.value
         const value = q.object.value
 
-        if (!orgIndex.has(orgIri)) {
-            orgIndex.set(orgIri, orgs.length)
-            fieldIndexByOrg.set(orgIri, new Map())
-            orgs.push({ iri: orgIri, label: prefixedIri(orgIri), fields: [] })
+        if (!entityIndex.has(entityIri)) {
+            entityIndex.set(entityIri, entities.length)
+            fieldIndexByEntity.set(entityIri, new Map())
+            entities.push({ iri: entityIri, label: prefixedIri(entityIri), fields: [] })
         }
-        const org = orgs[orgIndex.get(orgIri)]
-        const fieldIndex = fieldIndexByOrg.get(orgIri)
+        const entity = entities[entityIndex.get(entityIri)]
+        const fieldIndex = fieldIndexByEntity.get(entityIri)
 
         // rdf:type carries the entity class — surface it in the card header
-        // (see OrgCard), not as a field row.
-        if (predIri === RDF_TYPE) { org.type = prefixedIri(value); continue }
+        // (see EntityCard), not as a field row.
+        if (predIri === RDF_TYPE) { entity.type = prefixedIri(value); continue }
 
         if (!fieldIndex.has(predIri)) {
-            fieldIndex.set(predIri, org.fields.length)
-            org.fields.push({ predicate: predIri, predLabel: prefixedIri(predIri), values: [] })
+            fieldIndex.set(predIri, entity.fields.length)
+            entity.fields.push({ predicate: predIri, predLabel: prefixedIri(predIri), values: [] })
         }
-        const field = org.fields[fieldIndex.get(predIri)]
-        const records = [...(provIndex.get(tripleKey(orgIri, predIri, value)) ?? [])]
+        const field = entity.fields[fieldIndex.get(predIri)]
+        const records = [...(provIndex.get(tripleKey(entityIri, predIri, value)) ?? [])]
         const sources = toSources(records)
         const displayValue = q.object.termType === "NamedNode" ? prefixedIri(value) : value
         field.values.push({ value: displayValue, raw: value, sources, records })
     }
 
     // Per-field: sort values by source-count desc so the most-supported one is index 0.
-    // Per-org: one column per contributing record (two records from the same source
+    // Per-entity: one column per contributing record (two records from the same source
     // get two columns), ordered by source then record IRI.
-    for (const org of orgs) {
-        for (const f of org.fields) f.values.sort((a, b) => b.sources.length - a.sources.length)
+    for (const entity of entities) {
+        for (const f of entity.fields) f.values.sort((a, b) => b.sources.length - a.sources.length)
         const all = new Set()
-        for (const f of org.fields) for (const v of f.values) for (const r of v.records) all.add(r)
-        org.columns = [...all].map((r) => ({ record: r, source: sourceOfRecord.get(r) }))
+        for (const f of entity.fields) for (const v of f.values) for (const r of v.records) all.add(r)
+        entity.columns = [...all].map((r) => ({ record: r, source: sourceOfRecord.get(r) }))
             .sort((a, b) => compareSources(a.source, b.source, sourceMeta) || a.record.localeCompare(b.record))
     }
-    return orgs
+    return entities
 }

package/webapp/src/loadSources.js

@@ -3,7 +3,7 @@
 // Reads:  federation, mapped, ingest-log TTL strings passed by Sources.jsx
 // Does:   returns source[] ({iri, label, format, totalFields, mappedFields, records, …})
 
-import { CDP as NS, formatFamily, parseTtl, PATHS, sourceName, subjectsOfType } from "@directory-builder/core/utils"
+import { CDP as NS, enabledSources, formatFamily, parseTtl, PATHS, sourceName } from "@directory-builder/core/utils"
 
 const PROV_AT_TIME = "http://www.w3.org/ns/prov#atTime"
 const RDFS_LABEL = "http://www.w3.org/2000/01/rdf-schema#label"
@@ -18,7 +18,7 @@ export function loadSources(federationTtl, mappedTtl, ingestLogTtl) {
     const mappedQuads = mappedTtl ? parseTtl(mappedTtl) : []
     const logQuads = ingestLogTtl ? parseTtl(ingestLogTtl) : []
 
-    const sourceIris = subjectsOfType(fedQuads, `${NS}Source`)
+    const sourceIris = new Set(enabledSources(fedQuads))
 
     const props = new Map()
     const get = (iri) => {
@@ -68,7 +68,7 @@ export function loadSources(federationTtl, mappedTtl, ingestLogTtl) {
         if (!get(sourceIri).fetchUrl) get(sourceIri).staticSource = PATHS.staticDir(sourceName(sourceIri))
     }
 
-    // Records: count distinct orgs in mapped.ttl per source via cdp:fromSource.
+    // Records: count distinct entities in mapped.ttl per source via cdp:fromSource.
     const FROM_SOURCE = `${NS}fromSource`
     const subjectsBySource = new Map()
     for (const q of mappedQuads) {

package/webapp/src/mergeEntities.js

@@ -0,0 +1,15 @@
+// Builds the entity lists for the Merge and Directory views, in one shared order.
+// Reads:  data/pipeline/{merged,provenance,final}.ttl, config/federation.ttl (via loadMerge.js)
+// Does:   exports mergedEntities and finalEntities (consumed by MergeTables, Directory)
+
+import { loadMerge } from "./loadMerge.js"
+import { isConflict } from "./EntityCard.jsx"
+import { federationTtl, provenanceTtl as provTtl, mergedTtl, finalTtl } from "./instanceData.js"
+
+const conflictCount = (entity) => entity.fields.reduce((n, f) => n + (isConflict(f) ? 1 : 0), 0)
+
+// Merge view sorts by conflict count desc; the directory mirrors that order
+// so the same entity sits in the same visual slot across pages.
+export const mergedEntities = loadMerge(mergedTtl, provTtl, federationTtl).sort((a, b) => conflictCount(b) - conflictCount(a) || a.iri.localeCompare(b.iri))
+const orderIndex = new Map(mergedEntities.map((o, i) => [o.iri, i]))
+export const finalEntities = loadMerge(finalTtl, "", federationTtl).sort((a, b) => (orderIndex.get(a.iri) ?? Infinity) - (orderIndex.get(b.iri) ?? Infinity))

package/webapp/src/sourceMeta.js

@@ -3,7 +3,7 @@
 // the PATHS conventions. JS never hardcodes a source name — it resolves records
 // to a :Source via cdp:fromSource.
 // Reads:  TTL strings passed in (federation, mapped, ingest-log)
-// Does:   returns lookup maps + helpers (used by loadMerge, OrgCard, MapGraph, MatchGraph)
+// Does:   returns lookup maps + helpers (used by loadMerge, EntityCard, MapGraph, MatchGraph)
 
 import { CDP as NS, parseTtl, PATHS, sourceName } from "@directory-builder/core/utils"
 

package/webapp/src/styles.css

@@ -9,12 +9,12 @@ nav a:hover { color: #000 }
 nav a.active { font-weight: bold; color: #000 }
 main { flex: 1; min-height: 0 }
 .page { padding: 1rem }
-.org-card { margin: 0 0 1rem 0; padding: 0.6rem 0.9rem; border: 1px solid #ddd; border-radius: 4px; background: #fff }
-.org-card-header { font-size: 14px; margin-bottom: 0.4rem; color: #444 }
-.org-card-header code { background: #f5f5f5; padding: 2px 4px; border-radius: 2px; font-size: 12px }
-.org-card table { border-collapse: collapse; font-size: 13px }
-.org-card td { padding: 3px 8px 3px 0; vertical-align: middle }
-.org-card td:first-child { color: #666; white-space: nowrap; padding-right: 1rem }
+.entity-card { margin: 0 0 1rem 0; padding: 0.6rem 0.9rem; border: 1px solid #ddd; border-radius: 4px; background: #fff }
+.entity-card-header { font-size: 14px; margin-bottom: 0.4rem; color: #444 }
+.entity-card-header code { background: #f5f5f5; padding: 2px 4px; border-radius: 2px; font-size: 12px }
+.entity-card table { border-collapse: collapse; font-size: 13px }
+.entity-card td { padding: 3px 8px 3px 0; vertical-align: middle }
+.entity-card td:first-child { color: #666; white-space: nowrap; padding-right: 1rem }
 .value-text { display: inline-block; max-width: 60ch; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; vertical-align: middle }
 .source-tag { display: inline-block; padding: 1px 6px; margin-left: 4px; border-radius: 3px; background: #eee; color: #666; font-size: 11px; vertical-align: middle }
 .flip { margin-right: 8px; white-space: nowrap }

package/webapp/vite.js

@@ -16,7 +16,7 @@ export function serveInstanceData({ root = process.cwd() } = {}) {
         // Own the 404: falling through would hit the SPA fallback, which
         // serves index.html with 200 — instanceData would parse HTML as TTL.
         if (!existsSync(file)) { res.statusCode = 404; return res.end() }
-        res.setHeader("Content-Type", { js: "text/javascript", md: "text/markdown" }[rel.split(".").pop()] ?? "text/turtle")
+        res.setHeader("Content-Type", { js: "text/javascript", md: "text/markdown", sparql: "application/sparql-query" }[rel.split(".").pop()] ?? "text/turtle")
         res.end(readFileSync(file))
     }
     return {