@directory-builder/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Civic Data Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# directory-builder-core
+
+Use-case-agnostic engine for config-driven federation pipelines: fetch
+heterogeneous sources, lift them to RDF, clean, map them onto a unified target
+schema, then match, merge and resolve them into one federated directory.
+
+An **instance** is a repo holding only declarative config and per-source
+artefacts — no engine code:
+
+```
+config/
+  federation.ttl        # the decisions: sources + facts, target schemas,
+                        # field mappings, match/merge/resolve rules
+  match-knowledge.ttl   # curated owl:sameAs pairs
+sources/<name>/
+  fetch.js              # how to fetch this source
+  clean.sparql          # how to clean its lifted RDF
+  static/               # the data itself, for static-file sources
+webapp/
+  content/about.md      # optional: the webapp's About page prose
+  exporters/<name>.js   # optional: output adapters the webapp loads at runtime
+```
+
+The `webapp/` half is entirely optional — a pipeline-only instance is just
+`config/` + `sources/`, producing `data/` for downstream use.
+
+Everything else follows by convention from the source names. The discovery
+rule: a named open set (sources, exporters) is declared in federation.ttl and
+its files follow by convention; a single well-known slot (the About page)
+works by file presence alone. See [`example/`](example/) for a runnable
+instance and the full data flow.
+
+## Prerequisites
+
+- Node.js
+- Java (for [SPARQL Anything](https://github.com/SPARQL-Anything/sparql.anything),
+  auto-downloaded on first run)
+
+## Run a pipeline
+
+Two ways — both run the same engines, rooted at the instance directory.
+
+Via command (root = where you invoke):
+
+```sh
+npm install @directory-builder/core
+npx directory-builder            # full pipeline: ingest + federate
+npx directory-builder ingest     # fetch + lift only
+npx directory-builder federate   # clean → map → match → merge → resolve only
+```
+
+Or programmatically:
+
+```js
+import { Pipeline } from "@directory-builder/core"
+
+const pipeline = new Pipeline()   // root defaults to process.cwd()
+await pipeline.run()              // ingest + federate
+```
+
+`new Pipeline({ root })` points the engines at an instance directory other
+than the cwd — e.g. for driving several instances from one process or a test
+fixture.
+
+Each source's `fetch.js` is invoked as `node fetch.js <outDir> <fetchUrl-or-staticDir>
+<runParamsJson>` — the JSON holds all `:hasRunParam` values grouped by name;
+each fetcher picks the parameters it needs.
+
+Engines journal their executed steps as p-plan RDF (`data/ingest/ingest-log.ttl`,
+`data/pipeline/federate-log.ttl`) — evidence of what ran, not a plan.
+
+## Run the webapp
+
+The webapp ships with the package; it fetches an instance's `config/` +
+`data/` at runtime, so one app serves every use case and instances hold no
+webapp code. From an instance directory:
+
+```sh
+npx directory-builder webapp                         # dev server
+npx directory-builder webapp build --base /repo/     # production build → webapp/dist/
+```
+
+`webapp build` stages the instance's `config/`, `data/` and
+`webapp/{content,exporters}/` into `webapp/dist/` next to the bundle —
+`webapp/dist/` is the complete site, ready to publish as-is.
+
+For webapp development in this repo:
+
+```sh
+npm run webapp                                       # dev server on example/
+INSTANCE=../sosuse-directory-builder npm run webapp  # any other instance dir
+```
+
+Instances own the About page by providing `webapp/content/about.md` (markdown,
+served and deployed like config and data); without one, a generic default
+renders. Declaring `:federation :repository "https://github.com/…"` adds the
+GitHub links (nav, static-source folders); without it they stay hidden.
+
+Instances can inject **exporters** — output adapters mapping the directory
+into an external schema. The federation declares them (`:federation
+:hasExporter "x"`), the module lives at `webapp/exporters/x.js` in the instance
+(served and deployed like config and data), and the Download page loads it at
+runtime: it exports `label` / `filename` / `mime` and
+`build(finalTtl, toolkit)`, where the toolkit passes in helpers like
+`sparqlSelect`, since a runtime-loaded module cannot resolve bare imports.
+
+Browser-safe helpers (TTL parsing, path conventions, journal vocabulary) are
+exported separately so bundlers never see the engines' Node imports:
+
+```js
+import { CDP, parseTtl, PATHS } from "@directory-builder/core/utils"
+```

package/bin/cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+// Config-only entry: a default Pipeline rooted at the invoking instance
+// (npm runs scripts with cwd = the instance's package dir, so a downstream
+// repo needs nothing but config/ + sources/ and this on its PATH).
+//   directory-builder                          run the full pipeline (ingest + federate)
+//   directory-builder ingest                   fetch + lift only
+//   directory-builder federate                 clean → map → match → merge → resolve only
+//   directory-builder webapp                   dev server for the instance's webapp
+//   directory-builder webapp build [--base /x/]  build the webapp → <instance>/webapp/dist/
+
+import { webappBuild, webappDev } from "../src/webapp.js"
+import { Pipeline } from "../src/pipeline.js"
+
+const [cmd = "run", ...rest] = process.argv.slice(2)
+const flag = (name) => {
+    const i = rest.indexOf(`--${name}`)
+    return i >= 0 ? rest[i + 1] : rest.find((a) => a.startsWith(`--${name}=`))?.split("=")[1]
+}
+
+const pipeline = new Pipeline()
+const commands = {
+    run:      () => pipeline.run(),
+    ingest:   () => pipeline.ingest(),
+    federate: () => pipeline.federate(),
+    webapp:   () => {
+        if (rest[0] && rest[0] !== "build") {
+            console.error(`Unknown webapp subcommand "${rest[0]}" — expected "build" or nothing (dev server)`)
+            process.exit(1)
+        }
+        return rest[0] === "build" ? webappBuild(process.cwd(), { base: flag("base") }) : webappDev()
+    },
+}
+
+if (!commands[cmd]) {
+    console.error(`Unknown command "${cmd}" — expected one of: ${Object.keys(commands).join(", ")}`)
+    process.exit(1)
+}
+await commands[cmd]()

package/example/README.md

@@ -0,0 +1,64 @@
+# Example use case
+
+A minimal, self-contained example use case that exercises the whole pipeline with two
+**static file sources** — fictional library directories (`cityopen`, `civichub`)
+with **deliberately different schemas** that partly overlap, so the field
+mappings, then Match/Merge/Resolve, all have visible work to do.
+
+It doubles as the engine's smoke test and as the dataset a scaffolded use case can start from.
+
+## Layout
+
+```
+example/
+  config/
+    federation.ttl        # the decisions: sources + facts, one schema:Organization
+                          # target, field mappings, match/merge/resolve rules
+    match-knowledge.ttl   # curated owl:sameAs pairs (empty here)
+  sources/
+    cityopen/  { fetch.js, clean.sparql, static/libraries.json }
+    civichub/  { fetch.js, clean.sparql, static/libraries.json }
+```
+
+That's everything a use case is: config + one folder per source. Each source
+folder is self-contained — how to fetch it, how to clean it, and (for static
+sources) the data itself.
+
+## Run it
+
+```shell
+npm install
+npm run example
+```
+
+To browse the result, `npm run webapp` serves the webapp against this example.
+
+Or programmatically:
+
+```js
+import { Pipeline } from "../src/pipeline.js"   // from the package: @directory-builder/core
+
+await new Pipeline({ root: "example/" }).run()  // root defaults to process.cwd()
+```
+
+A downstream use-case repo does the same with the published package: depend on
+`@directory-builder/core` and call `npx directory-builder` — no engine code in
+the use case.
+
+Outputs land in `data/` (git-ignored, regenerable):
+
+```
+data/ingest/raw/<source>/        raw JSON copied in by fetch.js
+data/ingest/lifted/<source>/     RDF after the generic JSON lift
+data/ingest/ingest-log.ttl       journaled fetch/lift steps + harvest times
+data/pipeline/cleaned/<source>.ttl
+data/pipeline/mapped.ttl         schema: vocabulary, both sources
+data/pipeline/matches.ttl        cross-source match evidence
+data/pipeline/merged.ttl         clustered, minted cluster IRIs
+data/pipeline/provenance.ttl     which source said what
+data/pipeline/final.ttl          one resolved record per organisation
+data/pipeline/federate-log.ttl   journaled clean→…→resolve steps
+```
+
+The two `*-log.ttl` files are the engines' p-plan step journals — written as a
+side effect of execution, they are what the webapp's Pipeline page renders.

package/example/config/federation.ttl

@@ -0,0 +1,136 @@
+@prefix :       <https://civic-data.de/pipeline#> .
+@prefix rdfs:   <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix schema: <http://schema.org/> .
+@prefix foaf:   <http://xmlns.com/foaf/0.1/> .
+@prefix prov:   <http://www.w3.org/ns/prov#> .
+@prefix skos:   <http://www.w3.org/2004/02/skos/core#> .
+@prefix ft:     <http://publications.europa.eu/resource/authority/file-type/> .
+
+# A minimal single-entity federation: two directories of libraries, merged into
+# one set of schema:Organization records. Config declares decisions only —
+# sources and their facts, target schema, mappings, match/merge/resolve rules.
+# The engines own the step shape (fetch → lift, clean → map → match → merge →
+# resolve) and resolve all file paths by convention from the source names.
+# Add target schemas / mappings / match rules to model more entity types
+# (e.g. a Service tier) and their relationships.
+
+:federation a :Federation ;
+    :hasSource       :cityopenSource, :civichubSource ;
+    :hasTargetSchema :organisationSchema ;
+    :hasMatchRule    :organisationMatch ;
+    :hasMergeRule    :merge ;
+    :hasResolveRule  :resolve .
+
+# ---- Target schema ------------------------------------------------------
+
+:organisationSchema a :TargetSchema ;
+    :targetClass schema:Organization ;
+    rdfs:label "Organisation"@en ;
+    :hasTargetField :t-identifier, :t-name, :t-streetAddress, :t-postalCode,
+                    :t-locality, :t-telephone, :t-email, :t-homepage .
+
+# :multiValued - one value per contributing source is expected; the Merge view doesn't flag these as conflicts
+:t-identifier    a :TargetField ; :targetPredicate schema:identifier ; :multiValued true .
+:t-name          a :TargetField ; :targetPredicate schema:name .
+:t-streetAddress a :TargetField ; :targetPredicate schema:streetAddress .
+:t-postalCode    a :TargetField ; :targetPredicate schema:postalCode .
+:t-locality      a :TargetField ; :targetPredicate schema:addressLocality .
+:t-telephone     a :TargetField ; :targetPredicate schema:telephone .
+:t-email         a :TargetField ; :targetPredicate schema:email .
+:t-homepage      a :TargetField ; :targetPredicate foaf:homepage .
+
+# ---- Sources ------------------------------------------------------------
+# Both are static-file sources: no :fetchUrl, so the engine hands their
+# fetch.js the sources/<name>/static/ dir instead of a URL. :format drives
+# which bundled lift query applies. :fieldPath is the JSON key as it appears
+# after lifting (xyz:<fieldPath>).
+
+:cityopenSource a :Source ;
+    rdfs:label    "CityOpen Data" ;
+    skos:notation "co" ;
+    :retrieval    "Files" ;
+    :format       ft:JSON ;
+    :hasField :co-id, :co-name, :co-street, :co-postalCode, :co-city, :co-phone, :co-email, :co-website .
+
+:co-id         a :SourceField ; :fieldPath "id"         .
+:co-name       a :SourceField ; :fieldPath "name"       .
+:co-street     a :SourceField ; :fieldPath "street"     .
+:co-postalCode a :SourceField ; :fieldPath "postalCode" .
+:co-city       a :SourceField ; :fieldPath "city"       .
+:co-phone      a :SourceField ; :fieldPath "phone"      .
+:co-email      a :SourceField ; :fieldPath "email"      .
+:co-website    a :SourceField ; :fieldPath "website"    .
+
+# A deliberately different shape from cityopen: German keys and a nested
+# `anschrift` (address) object whose parts are reached via :hasSubField.
+:civichubSource a :Source ;
+    rdfs:label    "CivicHub Directory" ;
+    skos:notation "ch" ;
+    :retrieval    "Files" ;
+    :format       ft:JSON ;
+    :hasField :ch-uid, :ch-bezeichnung, :ch-telefon, :ch-email, :ch-webseite, :ch-anschrift .
+
+:ch-uid         a :SourceField ; :fieldPath "uid"         .
+:ch-bezeichnung a :SourceField ; :fieldPath "bezeichnung" .
+:ch-telefon     a :SourceField ; :fieldPath "telefon"     .
+:ch-email       a :SourceField ; :fieldPath "email"       .
+:ch-webseite    a :SourceField ; :fieldPath "webseite"    .
+
+:ch-anschrift a :SourceField ; :fieldPath "anschrift" ;
+    :hasSubField :ch-strasse, :ch-plz, :ch-ort .
+:ch-strasse a :SubField ; :fieldPath "strasse" .
+:ch-plz     a :SubField ; :fieldPath "plz"     .
+:ch-ort     a :SubField ; :fieldPath "ort"     .
+
+# ---- Mappings -----------------------------------------------------------
+
+:cityopen-mapping a :Mapping ;
+    :fromSource  :cityopenSource ;
+    :toTarget    :organisationSchema ;
+    :sourceGraph <urn:source:cityopen> ;
+    :hasFieldMapping
+        [ :from :co-id         ; :to :t-identifier    ] ,
+        [ :from :co-name       ; :to :t-name          ] ,
+        [ :from :co-street     ; :to :t-streetAddress ] ,
+        [ :from :co-postalCode ; :to :t-postalCode    ] ,
+        [ :from :co-city       ; :to :t-locality      ] ,
+        [ :from :co-phone      ; :to :t-telephone     ] ,
+        [ :from :co-email      ; :to :t-email         ] ,
+        [ :from :co-website    ; :to :t-homepage      ] .
+
+:civichub-mapping a :Mapping ;
+    :fromSource  :civichubSource ;
+    :toTarget    :organisationSchema ;
+    :sourceGraph <urn:source:civichub> ;
+    :hasFieldMapping
+        [ :from :ch-uid         ; :to :t-identifier    ] ,
+        [ :from :ch-bezeichnung ; :to :t-name          ] ,
+        [ :from :ch-strasse     ; :to :t-streetAddress ] ,
+        [ :from :ch-plz         ; :to :t-postalCode    ] ,
+        [ :from :ch-ort         ; :to :t-locality      ] ,
+        [ :from :ch-telefon     ; :to :t-telephone     ] ,
+        [ :from :ch-email       ; :to :t-email         ] ,
+        [ :from :ch-webseite    ; :to :t-homepage      ] .
+
+# ---- Match --------------------------------------------------------------
+# Records match when their postal code is identical (hard gate) and their names
+# are fuzzily similar enough that the weighted score clears :minScore.
+
+:organisationMatch a :MatchRule ;
+    :forTarget           :organisationSchema ;
+    :targetNamespace     "https://example.org/directory#" ;
+    :mintedSubjectPrefix "org-" ;
+    :hasHardCriterion     [ :on schema:postalCode ] ;
+    :minScore             0.5 ;
+    :hasWeightedCriterion [ :on schema:name ; :weight 1.0 ] .
+
+# ---- Merge --------------------------------------------------------------
+
+:merge a :MergeRule ;
+    :originPredicate prov:wasDerivedFrom .
+
+# ---- Resolve ------------------------------------------------------------
+# One value per predicate per merged record; alphabeticFirst is deterministic.
+
+:resolve a :ResolveRule ;
+    :defaultStrategy :alphabeticFirst .

package/example/config/match-knowledge.ttl

@@ -0,0 +1,8 @@
+@prefix :    <https://civic-data.de/pipeline#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+
+# Curated match knowledge for the example. Empty — the two sources match on
+# postal code + fuzzy name alone. This is where hand-curated owl:sameAs pairs
+# would go, forcing two records into one cluster regardless of score:
+#
+#   :cityopen-co-3 owl:sameAs :civichub-ch-102 .

package/example/sources/cityopen/clean.sparql

@@ -0,0 +1,17 @@
+# Skolemise each library object from its JSON `id` into a stable
+# cdp:cityopen-<id> IRI, copy its scalar fields verbatim, and tag the source.
+# The lift produced one blank node per array element, all in xyz:/fx: vocabulary;
+# clean stays in xyz:/cdp: — schema: vocabulary only enters at the map step.
+
+PREFIX xyz: <http://sparql.xyz/facade-x/data/>
+PREFIX cdp: <https://civic-data.de/pipeline#>
+
+CONSTRUCT {
+    ?org cdp:fromSource cdp:cityopenSource ;
+         ?p ?o .
+} WHERE {
+    ?node xyz:id ?id ;
+          ?p ?o .
+    FILTER(isLiteral(?o))
+    BIND(IRI(CONCAT(STR(cdp:), "cityopen-", STR(?id))) AS ?org)
+}

package/example/sources/cityopen/fetch.js

@@ -0,0 +1,14 @@
+import path from "path"
+import fs from "fs"
+
+// Static-file source: copy the committed JSON straight into the ingest area.
+// A live source would instead call an API here and write the responses out.
+// argv: [outDir, sourceDir, runParamsJson] — params unused for this static example.
+const OUT_DIR = process.argv[2]
+const SRC_DIR = process.argv[3]
+
+fs.mkdirSync(OUT_DIR, { recursive: true })
+for (const f of fs.readdirSync(SRC_DIR).filter((f) => f.endsWith(".json"))) {
+    fs.copyFileSync(path.join(SRC_DIR, f), path.join(OUT_DIR, f))
+    console.log(`  ${f} → ${OUT_DIR}`)
+}

package/example/sources/cityopen/static/libraries.json

@@ -0,0 +1,32 @@
+[
+  {
+    "id": "co-1",
+    "name": "Central City Library",
+    "street": "Main Street 1",
+    "postalCode": "10115",
+    "city": "Berlin",
+    "phone": "+49 30 1110001",
+    "email": "info@central-library.example",
+    "website": "https://central-library.example"
+  },
+  {
+    "id": "co-2",
+    "name": "Riverside Branch Library",
+    "street": "River Road 22",
+    "postalCode": "10243",
+    "city": "Berlin",
+    "phone": "+49 30 1110002",
+    "email": "hello@riverside.example",
+    "website": "https://riverside.example"
+  },
+  {
+    "id": "co-3",
+    "name": "Old Town Reading Room",
+    "street": "Market Square 5",
+    "postalCode": "10178",
+    "city": "Berlin",
+    "phone": "+49 30 1110003",
+    "email": "kontakt@oldtown.example",
+    "website": "https://oldtown.example"
+  }
+]

package/example/sources/civichub/clean.sparql

@@ -0,0 +1,34 @@
+# Skolemise each entry from its JSON `uid` into a stable cdp:civichub-<id> IRI.
+# This source has a different shape from cityopen: German keys and a nested
+# `anschrift` (address) object. Clean copies the top-level scalars and carries
+# the address node through unflattened (as xyz:anschrift) — the map reads its
+# parts via :hasSubField. Clean stays in xyz:/cdp:; schema: enters at the map.
+
+PREFIX xyz: <http://sparql.xyz/facade-x/data/>
+PREFIX cdp: <https://civic-data.de/pipeline#>
+
+CONSTRUCT {
+    ?org cdp:fromSource cdp:civichubSource ;
+         xyz:uid         ?uid ;
+         xyz:bezeichnung ?bezeichnung ;
+         xyz:telefon     ?telefon ;
+         xyz:email       ?email ;
+         xyz:webseite    ?webseite ;
+         xyz:anschrift   ?addr .
+    ?addr xyz:strasse ?strasse ;
+          xyz:plz     ?plz ;
+          xyz:ort     ?ort .
+} WHERE {
+    ?node xyz:uid ?uid .
+    BIND(IRI(CONCAT(STR(cdp:), "civichub-", STR(?uid))) AS ?org)
+    OPTIONAL { ?node xyz:bezeichnung ?bezeichnung }
+    OPTIONAL { ?node xyz:telefon     ?telefon }
+    OPTIONAL { ?node xyz:email       ?email }
+    OPTIONAL { ?node xyz:webseite    ?webseite }
+    OPTIONAL {
+        ?node xyz:anschrift ?addr .
+        OPTIONAL { ?addr xyz:strasse ?strasse }
+        OPTIONAL { ?addr xyz:plz     ?plz }
+        OPTIONAL { ?addr xyz:ort     ?ort }
+    }
+}

package/example/sources/civichub/fetch.js

@@ -0,0 +1,14 @@
+import path from "path"
+import fs from "fs"
+
+// Static-file source: copy the committed JSON straight into the ingest area.
+// A live source would instead call an API here and write the responses out.
+// argv: [outDir, sourceDir, runParamsJson] — params unused for this static example.
+const OUT_DIR = process.argv[2]
+const SRC_DIR = process.argv[3]
+
+fs.mkdirSync(OUT_DIR, { recursive: true })
+for (const f of fs.readdirSync(SRC_DIR).filter((f) => f.endsWith(".json"))) {
+    fs.copyFileSync(path.join(SRC_DIR, f), path.join(OUT_DIR, f))
+    console.log(`  ${f} → ${OUT_DIR}`)
+}

package/example/sources/civichub/static/libraries.json

@@ -0,0 +1,38 @@
+[
+  {
+    "uid": "ch-100",
+    "bezeichnung": "Central City Library (Main Branch)",
+    "anschrift": {
+      "strasse": "Main Street 1",
+      "plz": "10115",
+      "ort": "Berlin"
+    },
+    "telefon": "030 / 111 0001",
+    "email": "info@central-library.example",
+    "webseite": "http://www.central-library.example"
+  },
+  {
+    "uid": "ch-101",
+    "bezeichnung": "Riverside Library",
+    "anschrift": {
+      "strasse": "River Rd. 22",
+      "plz": "10243",
+      "ort": "Berlin"
+    },
+    "telefon": "030 111 0002",
+    "email": "team@riverside.example",
+    "webseite": "https://riverside.example"
+  },
+  {
+    "uid": "ch-102",
+    "bezeichnung": "Northside Community Library",
+    "anschrift": {
+      "strasse": "North Avenue 9",
+      "plz": "13347",
+      "ort": "Berlin"
+    },
+    "telefon": "+49 30 1110102",
+    "email": "mail@northside.example",
+    "webseite": "https://northside.example"
+  }
+]

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@directory-builder/core",
+  "version": "0.1.0",
+  "description": "Use-case-agnostic engine for config-driven federation pipelines",
+  "author": "Civic Data Lab",
+  "repository": "github:foederierter-datenpool/directory-builder-core",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "example": "cd example && node ../bin/cli.js",
+    "webapp": "vite webapp",
+    "webapp:build": "vite build webapp"
+  },
+  "bin": {
+    "directory-builder": "bin/cli.js"
+  },
+  "exports": {
+    ".": "./src/index.js",
+    "./utils": "./src/utils.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@foerderfunke/sem-ops-utils": "^0.5.1",
+    "@vitejs/plugin-react": "^6.0.1",
+    "@xyflow/react": "^12.10.2",
+    "@zazuko/yasgui": "^4.6.1",
+    "fuzzball": "^2.2.6",
+    "lucide-react": "^1.14.0",
+    "marked": "^18.0.5",
+    "n3": "^2.0.3",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "react-router-dom": "^7.14.1",
+    "vite": "^8.0.9"
+  }
+}