npm - llm-wiki-compiler - Versions diffs - 0.6.0 → 0.7.0 - Mend

llm-wiki-compiler 0.6.0 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md +128 -8
package/dist/cli.js +1577 -337
package/dist/cli.js.map +1 -1
package/dist/viewer/assets/index.html +71 -0
package/dist/viewer/assets/llmwiki-logo-64.png +0 -0
package/dist/viewer/assets/viewer-rail.js +181 -0
package/dist/viewer/assets/viewer-search.js +185 -0
package/dist/viewer/assets/viewer-sidebar.js +151 -0
package/dist/viewer/assets/viewer.css +314 -0
package/dist/viewer/assets/viewer.js +363 -0
package/package.json +6 -1

package/dist/viewer/assets/index.html ADDED Viewed

@@ -0,0 +1,71 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>llmwiki viewer</title>
+    <link rel="icon" type="image/png" href="/assets/llmwiki-logo-64.png" />
+    <link rel="stylesheet" href="/assets/viewer.css" />
+  </head>
+  <body>
+    <a class="skip-link" href="#main-pane">Skip to main content</a>
+    <header class="app-header">
+      <div class="app-brand">
+        <img
+          class="app-logo"
+          src="/assets/llmwiki-logo-64.png"
+          width="32"
+          height="32"
+          alt=""
+          aria-hidden="true"
+        />
+        <strong class="app-title" data-app-title>llmwiki</strong>
+      </div>
+      <a
+        class="github-link"
+        href="https://github.com/atomicmemory/llm-wiki-compiler"
+        target="_blank"
+        rel="noopener noreferrer"
+        aria-label="Open llm-wiki-compiler on GitHub"
+      >
+        <svg class="github-mark" viewBox="0 0 16 16" aria-hidden="true" focusable="false">
+          <path
+            d="M8 0C3.58 0 0 3.64 0 8.13c0 3.59 2.29 6.63 5.47 7.71.4.08.55-.18.55-.39 0-.19-.01-.83-.01-1.5-2.01.37-2.53-.5-2.69-.96-.09-.24-.48-.96-.82-1.15-.28-.15-.68-.52-.01-.53.63-.01 1.08.59 1.23.83.72 1.23 1.87.88 2.33.67.07-.53.28-.88.51-1.08-1.78-.21-3.64-.9-3.64-4 0-.88.31-1.61.82-2.18-.08-.2-.36-1.03.08-2.15 0 0 .67-.22 2.2.83A7.47 7.47 0 0 1 8 3.96c.68 0 1.36.09 2 .27 1.53-1.05 2.2-.83 2.2-.83.44 1.12.16 1.95.08 2.15.51.57.82 1.29.82 2.18 0 3.11-1.87 3.79-3.65 4 .29.25.54.74.54 1.5 0 1.08-.01 1.95-.01 2.22 0 .21.15.47.55.39A8.05 8.05 0 0 0 16 8.13C16 3.64 12.42 0 8 0Z"
+          />
+        </svg>
+        <span>GitHub</span>
+      </a>
+    </header>
+    <div class="app-layout">
+      <nav class="sidebar" aria-label="Wiki navigation">
+        <form class="sidebar-search" role="search" data-search-form autocomplete="off">
+          <label for="search-input" class="visually-hidden">Search wiki</label>
+          <input
+            id="search-input"
+            type="search"
+            placeholder="Search…"
+            aria-controls="search-results"
+            data-search-input
+          />
+        </form>
+        <ul
+          id="search-results"
+          class="search-results"
+          role="listbox"
+          aria-label="Search results"
+          data-search-results
+          hidden
+        ></ul>
+        <div data-sidebar>
+          <p class="placeholder">Loading…</p>
+        </div>
+      </nav>
+      <main id="main-pane" class="main-pane" tabindex="-1" data-main-pane>
+        <p class="placeholder">Select a page from the sidebar.</p>
+      </main>
+      <aside class="support-rail" aria-label="Page metadata" data-support-rail></aside>
+    </div>
+    <!--PAGE_INDEX-->
+    <script type="module" src="/assets/viewer.js"></script>
+  </body>
+</html>

package/dist/viewer/assets/llmwiki-logo-64.png ADDED Viewed

Binary file

package/dist/viewer/assets/viewer-rail.js ADDED Viewed

@@ -0,0 +1,181 @@
+/**
+ * llmwiki viewer — right-hand support rail renderer.
+ *
+ * Populates `[data-support-rail]` with the page metadata fields the
+ * spec's §Support Rail section requires: kind, sources, confidence,
+ * provenanceState, contradictedBy, tags, aliases, created/updated
+ * timestamps, plus a "Warnings" block fed by `payload.warnings`
+ * (parser issues, unresolved citations, malformed citation entries).
+ *
+ * Fields render only when the frontmatter actually carries a value, so
+ * a legacy page with no provenance metadata shows a compact rail
+ * rather than a wall of `(none)` rows. Labels mirror `review show`
+ * where practical.
+ */
+const SUPPORT_SELECTOR = "[data-support-rail]";
+const RAIL_FIELDS = [
+  { key: "kind", label: "Kind", type: "string" },
+  { key: "sources", label: "Sources", type: "stringArray" },
+  { key: "confidence", label: "Confidence", type: "confidence" },
+  { key: "provenanceState", label: "Provenance state", type: "string" },
+  { key: "contradictedBy", label: "Contradicted by", type: "contradictedBy" },
+  { key: "tags", label: "Tags", type: "stringArray" },
+  { key: "aliases", label: "Aliases", type: "stringArray" },
+  { key: "createdAt", label: "Created", type: "string" },
+  { key: "updatedAt", label: "Updated", type: "string" },
+];
+/** Render project-level metadata for the dashboard route. */
+export function renderProjectRail(envelope) {
+  const support = document.querySelector(SUPPORT_SELECTOR);
+  if (!support) return;
+  support.innerHTML = "";
+  const dl = document.createElement("dl");
+  appendPlainRailField(dl, "Project", envelope.project?.title || "llmwiki");
+  appendPlainRailField(dl, "Root", envelope.project?.rootName || "");
+  appendPlainRailField(dl, "Generated", envelope.generatedAt || "");
+  appendPlainRailField(dl, "Pages", String((envelope.pages || []).length));
+  if (envelope.index?.available) appendPlainRailField(dl, "Index", "Available");
+  support.appendChild(dl);
+}
+/**
+ * Render the page metadata into the support rail. Replaces whatever
+ * was there before — callers don't need to clear separately.
+ */
+export function renderSupportRail(payload) {
+  const support = document.querySelector(SUPPORT_SELECTOR);
+  if (!support) return;
+  support.innerHTML = "";
+  const fm = (payload && payload.frontmatter) || {};
+  const dl = document.createElement("dl");
+  for (const field of RAIL_FIELDS) appendRailField(dl, field, fm[field.key]);
+  if (dl.children.length > 0) support.appendChild(dl);
+  const warnings = (payload && Array.isArray(payload.warnings)) ? payload.warnings : [];
+  if (warnings.length > 0) support.appendChild(buildRailWarnings(warnings));
+}
+/** Clear the support rail entirely (used on non-page routes). */
+export function clearSupportRail() {
+  const support = document.querySelector(SUPPORT_SELECTOR);
+  if (support) support.innerHTML = "";
+}
+/** Append one (dt, dd) pair to the rail's <dl> when the value renders. */
+function appendRailField(dl, field, value) {
+  const dd = renderRailValue(field.type, value);
+  if (!dd) return;
+  appendDtDd(dl, field.label, dd);
+}
+/** Append a plain text rail field when `value` is non-empty. */
+function appendPlainRailField(dl, label, value) {
+  if (typeof value !== "string" || value.length === 0) return;
+  appendDtDd(dl, label, buildPlainDd(value));
+}
+/** Append a complete rail definition row. */
+function appendDtDd(dl, label, dd) {
+  const dt = document.createElement("dt");
+  dt.textContent = label;
+  dl.appendChild(dt);
+  dl.appendChild(dd);
+}
+/** Dispatch on field type and produce a <dd>, or null to skip the row. */
+function renderRailValue(type, value) {
+  if (type === "string") return renderStringValue(value);
+  if (type === "stringArray") return renderStringArrayValue(value);
+  if (type === "confidence") return renderConfidenceValue(value);
+  if (type === "contradictedBy") return renderContradictionList(value);
+  return null;
+}
+/** String field — empty/non-string values omit the row. */
+function renderStringValue(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  return buildPlainDd(value);
+}
+/** Array-of-strings field — joined with commas, empty array omits the row. */
+function renderStringArrayValue(value) {
+  if (!Array.isArray(value)) return null;
+  const strings = value.filter((v) => typeof v === "string" && v.length > 0);
+  if (strings.length === 0) return null;
+  return buildPlainDd(strings.join(", "));
+}
+/** Numeric confidence in 0..1 rendered as a percentage. */
+function renderConfidenceValue(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) return null;
+  const clamped = Math.max(0, Math.min(1, value));
+  return buildPlainDd(`${Math.round(clamped * 100)}%`);
+}
+/** `contradictedBy` is an array of `{ slug, reason? }` references. */
+function renderContradictionList(value) {
+  if (!Array.isArray(value) || value.length === 0) return null;
+  const dd = document.createElement("dd");
+  const ul = document.createElement("ul");
+  let any = false;
+  for (const ref of value) {
+    const li = buildContradictionItem(ref);
+    if (!li) continue;
+    any = true;
+    ul.appendChild(li);
+  }
+  if (!any) return null;
+  dd.appendChild(ul);
+  return dd;
+}
+/** One contradiction <li> — slug link plus optional reason. */
+function buildContradictionItem(ref) {
+  const slug = ref && typeof ref.slug === "string" ? ref.slug : "";
+  if (!slug) return null;
+  const li = document.createElement("li");
+  li.dataset.contradictionSlug = slug;
+  const a = document.createElement("a");
+  a.href = `#/concepts/${encodeURIComponent(slug)}`;
+  a.textContent = slug;
+  li.appendChild(a);
+  if (ref && typeof ref.reason === "string" && ref.reason.length > 0) {
+    const reason = document.createElement("span");
+    reason.className = "support-rail-reason";
+    reason.textContent = ` — ${ref.reason}`;
+    li.appendChild(reason);
+  }
+  return li;
+}
+/** Build a plain `<dd>` with a single text node — used by the simpler field types. */
+function buildPlainDd(text) {
+  const dd = document.createElement("dd");
+  dd.textContent = text;
+  return dd;
+}
+/**
+ * Render the warnings block at the bottom of the rail. Each warning is
+ * a `<li>` carrying `data-code` so styling/tests can target specific
+ * warning kinds (`unresolved_citation`, `malformed_citation`,
+ * `missing_title`, etc.).
+ */
+function buildRailWarnings(warnings) {
+  const wrap = document.createElement("section");
+  wrap.className = "support-rail-warnings";
+  const h = document.createElement("h2");
+  h.textContent = "Warnings";
+  wrap.appendChild(h);
+  const ul = document.createElement("ul");
+  for (const w of warnings) {
+    const li = document.createElement("li");
+    if (w && typeof w.code === "string") li.dataset.code = w.code;
+    li.textContent = (w && w.message) || (w && w.code) || "";
+    ul.appendChild(li);
+  }
+  wrap.appendChild(ul);
+  return wrap;
+}

package/dist/viewer/assets/viewer-search.js ADDED Viewed

@@ -0,0 +1,185 @@
+/**
+ * llmwiki viewer — sidebar search UI.
+ *
+ * Wires the search input in the shell template to `/api/search?q=...`.
+ * Input is debounced before each fetch (spec §Slice 5 acceptance:
+ * "client input is debounced before calling `/api/search`"). The
+ * sidebar's results <ul> doubles as a focus-cyclable result list:
+ * ArrowDown from the input jumps to the first result; ArrowUp/Down
+ * within results cycles; Escape returns focus to the input; Enter
+ * activates the focused anchor (the browser handles `<a href="#/...">`
+ * activation natively, so we don't intercept it).
+ *
+ * Imported by `viewer.js` and invoked from `main()` after the sidebar
+ * first paint. Keeps the entry file small (CLAUDE.md 400-LOC rule) and
+ * isolates the keyboard-navigation surface for unit testing.
+ */
+const SEARCH_INPUT_SELECTOR = "[data-search-input]";
+const SEARCH_RESULTS_SELECTOR = "[data-search-results]";
+const SEARCH_DEBOUNCE_MS = 200;
+/**
+ * Wire the search input + results panel. Idempotent: calling more than
+ * once attaches multiple listeners, so call exactly once in bootstrap.
+ * Returns silently when either the input or results element is missing
+ * (the shell template owns those selectors).
+ *
+ * Concurrency contract: a monotonically increasing `generation` counter
+ * (bumped on every input event) gates BOTH the pending-debounce timer
+ * AND any in-flight `fetch`. An older response that arrives after the
+ * user has cleared the input or typed a newer query is discarded
+ * silently — the results panel only ever reflects the most recent
+ * input-vs-render decision.
+ */
+export function wireSearch({ fetchJson }) {
+  const input = document.querySelector(SEARCH_INPUT_SELECTOR);
+  const results = document.querySelector(SEARCH_RESULTS_SELECTOR);
+  if (!input || !results) return;
+  const sidebar = input.closest(".sidebar");
+  let currentGeneration = 0;
+  let pendingTimer = 0;
+  const cancelPending = () => {
+    if (pendingTimer) {
+      clearTimeout(pendingTimer);
+      pendingTimer = 0;
+    }
+  };
+  input.addEventListener("input", () => {
+    currentGeneration += 1;
+    cancelPending();
+    const value = input.value.trim();
+    if (value.length === 0) {
+      hideSearchResults(results, sidebar);
+      return;
+    }
+    const generation = currentGeneration;
+    pendingTimer = setTimeout(() => {
+      pendingTimer = 0;
+      void runSearchAndRender(value, results, fetchJson, () => generation === currentGeneration);
+    }, SEARCH_DEBOUNCE_MS);
+  });
+  input.addEventListener("keydown", (event) => onSearchInputKeydown(event, results));
+  results.addEventListener("keydown", (event) => onSearchResultsKeydown(event, input));
+  results.addEventListener("click", (event) => {
+    if (event.target instanceof HTMLElement && event.target.closest("a")) {
+      currentGeneration += 1;
+      cancelPending();
+      hideSearchResults(results, sidebar);
+      input.value = "";
+    }
+  });
+}
+/**
+ * Fetch /api/search for `query` and render the results list, but only
+ * when `stillCurrent()` returns true at the moment the response
+ * resolves. A later-typed query supersedes an earlier one regardless
+ * of which network response arrives first.
+ *
+ * Search-failure UX intentionally stays inline in the results panel
+ * (rather than blowing away the main pane) so an ephemeral network
+ * blip doesn't drop the user out of the page they're reading.
+ */
+async function runSearchAndRender(query, results, fetchJson, stillCurrent) {
+  try {
+    const data = await fetchJson(`/api/search?q=${encodeURIComponent(query)}`);
+    if (!stillCurrent()) return;
+    renderSearchResults(data.results ?? [], results);
+  } catch (err) {
+    if (!stillCurrent()) return;
+    results.innerHTML = "";
+    const li = document.createElement("li");
+    li.className = "empty";
+    li.textContent = `Search failed: ${err.message}`;
+    results.appendChild(li);
+    results.hidden = false;
+  }
+}
+/** Render rows into the results <ul>; show an "empty" message for zero hits. */
+function renderSearchResults(rows, results) {
+  results.innerHTML = "";
+  results.hidden = false;
+  results.closest(".sidebar")?.classList.add("search-active");
+  if (rows.length === 0) {
+    const li = document.createElement("li");
+    li.className = "empty";
+    li.textContent = "No matches.";
+    results.appendChild(li);
+    return;
+  }
+  for (const row of rows) results.appendChild(buildSearchResultRow(row));
+}
+/** Build one search-result <li> with anchor + kind tag + snippet. */
+function buildSearchResultRow(row) {
+  const li = document.createElement("li");
+  li.setAttribute("role", "option");
+  const link = document.createElement("a");
+  const slug = deriveSlug(row.id);
+  link.href = `#/${encodeURIComponent(row.pageDirectory)}/${encodeURIComponent(slug)}`;
+  link.dataset.searchResult = "true";
+  const kind = document.createElement("span");
+  kind.className = "result-kind";
+  kind.textContent = row.pageDirectory === "queries" ? "query" : "concept";
+  const title = document.createElement("span");
+  title.className = "result-title";
+  title.textContent = row.title || row.id;
+  const snippet = document.createElement("span");
+  snippet.className = "result-snippet";
+  snippet.textContent = cleanSnippet(row.snippet || "");
+  link.appendChild(kind);
+  link.appendChild(title);
+  link.appendChild(snippet);
+  li.appendChild(link);
+  return li;
+}
+/** Mirror server-side snippet cleanup so existing viewer processes improve after asset reload. */
+function cleanSnippet(value) {
+  return value
+    .replace(/\[\[([^\]|\n]+)\|([^\]\n]+)\]\]/g, "$2")
+    .replace(/\[\[([^\]\n]+)\]\]/g, "$1");
+}
+/** Extract the slug from a PageId of the form `concepts/<slug>`. */
+function deriveSlug(id) {
+  const slash = String(id).indexOf("/");
+  return slash >= 0 ? id.slice(slash + 1) : id;
+}
+/** Hide the results panel and restore the standing sidebar contents. */
+function hideSearchResults(results, sidebar) {
+  results.innerHTML = "";
+  results.hidden = true;
+  sidebar?.classList.remove("search-active");
+}
+/** ArrowDown from the search input moves focus to the first result anchor. */
+function onSearchInputKeydown(event, results) {
+  if (event.key !== "ArrowDown") return;
+  const first = results.querySelector("a[data-search-result]");
+  if (!first) return;
+  event.preventDefault();
+  first.focus();
+}
+/** ArrowUp/Down within results cycle focus; Escape returns focus to input. */
+function onSearchResultsKeydown(event, input) {
+  if (event.key === "Escape") {
+    event.preventDefault();
+    input.focus();
+    return;
+  }
+  if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+  const target = event.target instanceof HTMLAnchorElement ? event.target : null;
+  if (!target) return;
+  event.preventDefault();
+  const all = Array.from(target.closest("ul").querySelectorAll("a[data-search-result]"));
+  const idx = all.indexOf(target);
+  const next = event.key === "ArrowDown"
+    ? all[(idx + 1) % all.length]
+    : all[(idx - 1 + all.length) % all.length];
+  if (next) next.focus();
+}

package/dist/viewer/assets/viewer-sidebar.js ADDED Viewed

@@ -0,0 +1,151 @@
+/**
+ * llmwiki viewer — sidebar renderer.
+ *
+ * Renders concept pages grouped by frontmatter `kind` (defaulting to
+ * "concept" when absent — spec line 347), then a "Saved Queries"
+ * group, then the standing "Health" entry. Groups use native
+ * `<details><summary>` so keyboard users get Enter/Space collapse for
+ * free without bespoke ARIA wiring.
+ *
+ * First paint runs against the embedded page-index blob (which now
+ * includes `kind` so the grouping is correct from the first byte);
+ * the full `/api/pages` envelope replaces the contents once it
+ * arrives.
+ */
+const SIDEBAR_SELECTOR = "[data-sidebar]";
+const DEFAULT_KIND = "concept";
+/** Render the sidebar groups + standing Health entry, then mark active. */
+export function renderSidebar(pages) {
+  const sidebar = document.querySelector(SIDEBAR_SELECTOR);
+  if (!sidebar) return;
+  sidebar.innerHTML = "";
+  const concepts = pages.filter((p) => p.pageDirectory === "concepts");
+  const queries = pages.filter((p) => p.pageDirectory === "queries");
+  const conceptGroups = groupConceptsByKind(concepts);
+  for (const [kind, groupPages] of conceptGroups) {
+    sidebar.appendChild(buildCollapsibleGroup(formatKindLabel(kind), groupPages, "kind", kind));
+  }
+  if (queries.length > 0) {
+    sidebar.appendChild(buildCollapsibleGroup("Saved Queries", queries, "kind", "query"));
+  }
+  if (concepts.length === 0 && queries.length === 0) {
+    const empty = document.createElement("p");
+    empty.className = "placeholder";
+    empty.textContent = "No pages yet — run `llmwiki compile`.";
+    sidebar.appendChild(empty);
+  }
+  sidebar.appendChild(buildHealthEntry());
+  markActive();
+}
+/**
+ * Mark the sidebar entry matching the current hash route as
+ * `aria-current="page"` and clear it from every other entry. Exported
+ * so `viewer.js` can call it after route changes without duplicating
+ * the parsing logic. Reads `location.hash` directly so the call site
+ * doesn't need to thread the route descriptor through.
+ */
+export function markActive() {
+  const hash = location.hash;
+  const expectedId = parseExpectedPageId(hash);
+  const links = document.querySelectorAll(`${SIDEBAR_SELECTOR} a`);
+  for (const link of links) link.removeAttribute("aria-current");
+  if (!expectedId) return;
+  for (const link of links) {
+    if (link.dataset.pageId === expectedId) {
+      link.setAttribute("aria-current", "page");
+      return;
+    }
+  }
+}
+/**
+ * Group concept pages by their `kind` field. Missing/non-string kinds
+ * fall back to `"concept"` per spec §Sidebar. Group order is stable
+ * by kind name (locale-aware), with the default `concept` bucket
+ * floated to the top so a typical wiki shows "Concept" first.
+ */
+function groupConceptsByKind(concepts) {
+  const byKind = new Map();
+  for (const page of concepts) {
+    const kind = (typeof page.kind === "string" && page.kind.length > 0) ? page.kind : DEFAULT_KIND;
+    if (!byKind.has(kind)) byKind.set(kind, []);
+    byKind.get(kind).push(page);
+  }
+  const kinds = Array.from(byKind.keys()).sort((a, b) => {
+    if (a === DEFAULT_KIND) return -1;
+    if (b === DEFAULT_KIND) return 1;
+    return a.localeCompare(b);
+  });
+  return kinds.map((kind) => /** @type {[string, Array]} */ ([kind, byKind.get(kind)]));
+}
+/** Title-case a kind for the group heading. */
+function formatKindLabel(kind) {
+  if (kind === DEFAULT_KIND) return "Concepts";
+  return kind.charAt(0).toUpperCase() + kind.slice(1);
+}
+/** Build a collapsible `<details>` group with a flat link list of pages. */
+function buildCollapsibleGroup(label, pages, datasetKey, datasetValue) {
+  const wrap = document.createElement("details");
+  wrap.open = true;
+  if (datasetKey) wrap.dataset[datasetKey] = datasetValue;
+  const summary = document.createElement("summary");
+  summary.textContent = label;
+  wrap.appendChild(summary);
+  const list = document.createElement("ul");
+  for (const page of pages) list.appendChild(buildPageListItem(page));
+  wrap.appendChild(list);
+  return wrap;
+}
+/** Build one `<li><a>` entry for a sidebar page list. */
+function buildPageListItem(page) {
+  const li = document.createElement("li");
+  const a = document.createElement("a");
+  a.href = `#/${encodeURIComponent(page.pageDirectory)}/${encodeURIComponent(page.slug)}`;
+  a.dataset.pageId = page.id;
+  a.textContent = page.title || page.slug;
+  li.appendChild(a);
+  return li;
+}
+/** Build the standing "Health" sidebar entry that routes to #/health. */
+function buildHealthEntry() {
+  const wrap = document.createElement("section");
+  wrap.className = "sidebar-health";
+  const heading = document.createElement("h2");
+  heading.textContent = "Project";
+  wrap.appendChild(heading);
+  const list = document.createElement("ul");
+  const item = document.createElement("li");
+  const link = document.createElement("a");
+  link.href = "#/health";
+  link.dataset.healthLink = "true";
+  link.textContent = "Health";
+  item.appendChild(link);
+  list.appendChild(item);
+  wrap.appendChild(list);
+  return wrap;
+}
+/**
+ * Read `location.hash` and return the namespaced `<dir>/<slug>` that
+ * should carry `aria-current` — or null if the route is not a page
+ * route. Malformed percent-encoding falls through to null rather than
+ * throwing.
+ */
+function parseExpectedPageId(hash) {
+  const match = hash.match(/^#\/(concepts|queries)\/(.+)$/);
+  if (!match) return null;
+  let slug;
+  try {
+    slug = decodeURIComponent(match[2]);
+  } catch {
+    return null;
+  }
+  return `${match[1]}/${slug}`;
+}