@micha.bigler/ui-core-micha 2.41.0 → 2.41.1

package/WORK_ORDERS.md

@@ -27,6 +27,7 @@ prefixed ID; never reuse a bare flat number across workstreams.
 
 | ID | Titel | Beschreibung | Datum | Status | Commit(s) | Notiz |
 |---|---|---|---|---|---|---|
+| AUTH-5 | `addPublicPath` muss dynamische Routen ausdruecken koennen | `apiClient` leitet bei 401/403 hart auf `/login` um, ausser der Pfad steht auf einer Allowlist — der Mechanismus ist richtig gebaut, kann aber keine **dynamischen** Routen beschreiben: `matchesPublicPath` vergleicht mit `startsWith` (ausser `/`, das Gleichheit verlangt). Eine App mit oeffentlichen Seiten unter einem variablen Segment (`/<slug>`, `/<slug>/team`) kann ihre oeffentliche Flaeche damit nicht ausdruecken: ein konkreter Slug laesst sich eintragen, der naechste faellt wieder heraus. Folge: ein anonymer Besucher landet beim ersten 401 auf `/login` — auf einer Seite, die oeffentlich sein soll, von aussen nicht von "Seite existiert nicht" zu unterscheiden. `addPublicPath` nimmt daher zusaetzlich ein `RegExp` entgegen, geprueft ausschliesslich gegen `pathname`; die eingefrorene Builtin-Liste bleibt string-basiert und unberuehrt. | 2026-08-17 | planned | | Tier 3 (shared-core). Envelope: `work-orders/AUTH-5.md`. Kein Prototyp, keine Oberflaeche — `ui_reviewer` entfaellt, `reviewer` + `sec_reviewer` laufen. **Vorbedingung fuer `jg-ferien` PUB-7 Teil 2**, das ohne die veroeffentlichte Version nicht landen kann (jg pinnt heute `2.37.1`). Die WO ist erst `done`, wenn die Version veroeffentlicht ist. Kernrisiko: die Verantwortung wandert zum Konsumenten — ein unverankertes Muster wie `/team` trifft auch `/admin/team` und unterdrueckt die Weiterleitung dort, wo sie gebraucht wird; das gehoert in die Dokumentation am Aufruf, und die Gegenrichtung (nicht passender Pfad leitet weiterhin um) ist ein eigener Testfall. |
 | PRIM-1 | Promote `StatTile` and `SoftChip` into the shared kit | Both already exist **twice**, independently built, and each second build is an **inline component inside a page** rather than a file — `StatTile` in `fitness-monitor/frontend/src/pages/BodyHistoryPage.jsx:554-568` beside hram's `ResearchComponents/StatTile.jsx`, `SoftChip` in `cockpit/frontend/src/cockpit/BoardView.jsx:65-73` (the lane pill) beside hram's `SoftChip.jsx`. The promotion trigger is met on evidence, not waived. The two builds diverged in seven places; all seven decided by the operator 2026-08-12 and rendered in the prototype. Full order [`work-orders/PRIM-1.md`](work-orders/PRIM-1.md) | 2026-08-12 | done | b5fff23 | Tier 3 (shared-core). `reviewer` + `ui_reviewer` mandatory and concurrent; no `sec_reviewer`. **Prototype in scope** — [`work-orders/assets/PRIM-1-dashboard-primitives.html`](work-orders/assets/PRIM-1-dashboard-primitives.html), so the rendered 375/1280 side-by-side is a commit gate; screenshots have not been legibly obtainable here, so a substitution must be **declared**, not silent. Decisions: value `h5` 18/600 · `tabular-nums` always · `flex: 1` with a `minWidth` floor · `accent` kept (fitness-monitor cannot adopt without it) · responsive padding · `status` uses **`overline`** (cockpit independently chose uppercase + .4px tracking, so this satisfies `THEME-4` with **no** baseline change and only hram's chips shift to uppercase) · dot-or-icon and optional border via props. **Token delta list has one entry:** `caveat`'s 12/500 has no baseline variant (`caption` is 12/400) — operator resolved it as keep-the-value, so it must be **exempted in `THEME-4` with that reason stated**, not flattened to 400 and not fixed by extending the baseline here. Neither `StatTile` build has a test; the promoted tests are written from scratch. Minor bump `2.38.0` → `2.39.0` (new capability area). **The three app adoptions are separate follow-up WOs** and land no app change here. Programme strand `DS-5`. **Codex skipped, dated evidence**: `.claude/codex-status.md` records `unavailable` for 2026-08-12 (`cockpit/UI-10`, out of workspace credits, the day's one allowed probe already spent) — Orchestrator implemented directly, flipping authorship. **Independent `reviewer` (Haiku, mandatory regardless of tier per the WO): no findings.** **`ui_reviewer` (Haiku, mandatory, concurrent): two P1 findings, both fixed** — (1) `StatTile`'s padding had only `px` responsive (`{xs:1, sm:1.5}`) with `py` fixed at 1, against the decided "responsive `{xs:1, sm:1.5}`" (matching fitness-monitor's original `p` shorthand, not hram's split values) — changed to a single `p: {xs:1, sm:1.5}`; (2) the `status` variant's typography was under-tested (only `textTransform` checked) — added explicit `fontSize`/`fontWeight`/`letterSpacing` assertions against `theme.typography.overline`, and separately against the `caveat` variant's raw 12/500, both now green. Re-verified 51/51 scoped tests green after fixes, `tsc -p tsconfig.build.json --noEmit` clean. **Rendered gate: declared substitution**, per the WO's own text — the 375/1280 side-by-side screenshot capture is not legibly obtainable in this repo; computed-style/DOM inspection substituted instead, via the test suite itself (fill/border/text colour per tone verified against `alpha`/`darken` of `theme.palette[tone]`; `borderRadius` 999px status vs non-pill caveat; `fontVariantNumeric: tabular-nums`; accent border width 1px vs 2px; `overline` typography values now explicit). No visual click-through was performed. Commit `b5fff23`. |
 | THEME-3 | Add the missing "subtle surface" baseline token | Adds `palette.background.subtle` (`#F4F5F6`, fixed baseline constant alongside `default`/`paper`) to `createAppTheme` and registers it in `THEME_COMPLETENESS_SURFACES`. Found by `cockpit/UI-6`: the `UI-4` design-language sheet's canonical token table names this as a baseline-supplied "inset surface" replacing `cockpit.surface2` (16 of 195 token reads in that WO), but the value was never actually wired into the shipped package — confirmed by grep, not assumed. `cockpit/UI-6` is blocked on this landing + publishing first, per this estate's own "gap in the shared kit is a ucm WO, not a local workaround" rule. Full spec: [work-orders/THEME-3.md](work-orders/THEME-3.md). `2.33.2` (patch). | 2026-08-11 | done | 1b25117 | Tier 3 — shared-core, this repo publishes to npm on every `main` push touching `src/**`, no staging net. Codex implemented in one pass (stdin invocation), exit 0, `RESULT: DONE`, 17/17 of its own new tests green. **Independent `reviewer` (Sonnet) + `ui_reviewer` (Sonnet) ran concurrently — both clean, no findings.** Both independently re-derived the safety mechanism rather than trusting the WO's claim: `MUI_DEFAULT_THEME = createTheme()` never defines `background.subtle` (vanilla MUI only has `.default`/`.paper`), so `assertThemeComplete`'s `sameValue` check can never flag the new surface for any real adopter — the same unexempted treatment `background.default` already gets; `background.paper`'s exemption (needed because MUI's own default theme is also white) was correctly not copied. Both read `fitness-monitor`'s actual `theme.js`/`theme.test.js` directly (the one real production adopter, hard-asserting `assertThemeComplete(theme).findings` equals `[]`) and confirmed this diff cannot break it. `ui_reviewer` additionally grepped every sibling app repo under `webapps/` for `createAppTheme` — no other live consumer exists; cockpit's own adoption (`UI-6`) isn't wired yet. `reviewer` independently recomputed the contrast ratio in a throwaway script and got the same `5.3748:1` the diff claims (not the design sheet's `4.81:1`, which was computed on the sheet's own static canvas — a source discrepancy, not a functional risk; both clear AA). **Orchestrator's own verification:** built the package (`npm run build`) and attempted to run `fitness-monitor`'s real assertions against the fresh `dist/` via raw Node ESM import — hit a pre-existing (confirmed via `git show`, not introduced here) `tsc`-emitted extensionless-import quirk that only affects raw `node`, not the Vite/Vitest resolution every real consumer (incl. fitness-monitor's own suite) uses; fell back to the scoped vitest run instead. Tests: 17/17 green (`tests/createAppTheme.test.js` + `tests/themeCompleteness.test.js`), run by the Orchestrator. No visual/prototype gate — token-only change with no rendered specimen in this repo (per the Envelope); the rendered check happens downstream in `cockpit/UI-6`. Semver: patch, applied by the Orchestrator per the WO's own reasoning (additive, resolves automatically, no adopter code change needed) — confirmed rather than assumed by both reviews. Unblocks `cockpit/UI-6`, which was waiting on this landing + publish. |
 | CHART-7 | `ChartFrame` gains a `titleVariant` prop | Adds `titleVariant` (default `'h6'`, unchanged from today's hardcoded value) to `ChartFrame`, forwarded to the title `Typography` — lets a dense panel grid (e.g. fitness-monitor's seven body-composition panels beside one hero chart) render smaller titles that recede instead of competing with the one chart that matters. One prop, not a `slotProps.title` system — deliberately minimal per the WO. Precondition of fitness-monitor's `FM-12` (DS-10). `2.32.0` (minor, additive). Full spec: [work-orders/CHART-7.md](work-orders/CHART-7.md). | 2026-08-10 | done | 14020d0 | Envelope authored by Expertenchat, no design question (short-form WO). No preconditions. Orchestrator filled a minimal Implementation map (the whole change is two lines in `ChartFrame.jsx`), ran Codex (stdin invocation). Codex added `titleVariant = 'h6'` to the prop destructure, forwarded it to the title `Typography`, wrote all 3 required tests, and bumped `2.31.1` → `2.32.0` per the WO's own stated version target. **Independent `reviewer` + `ui_reviewer` (both Haiku, proportionate to a small low-risk diff) ran concurrently — both found NO findings**, including explicit confirmation that only the prop-destructure line and the one `Typography` line changed (padding, foot row, subtitle/toolbar/slots byte-for-byte unchanged) and that the default-regression test is non-vacuous. Re-verified: 13/13 scoped vitest tests green, `tsc -p tsconfig.build.json --noEmit` clean. **Two-width rendered side-by-side (DS-1 gate)**: no existing harness specimen used `titleVariant`, so the Orchestrator added one (two `ChartFrame`s side by side, default vs. `titleVariant="subtitle2"`) to `dev/entries.jsx` — confirmed live at 375px and 1280px that the override renders visibly smaller/lighter than the unchanged h6 default. |

package/dist/auth/apiClient.js

@@ -26,6 +26,18 @@ const CONSUMER_PUBLIC_PATHS = new Set();
  * Register an additional public path so a 401 on that route does not auto-redirect
  * to `/login`. Typical use: a public landing on `/` in an otherwise authenticated app.
  *
+ * Accepts a `string` (matched like the builtins: exact for "/", prefix otherwise) or
+ * a `RegExp` (AUTH-5) for consumers whose public area includes a dynamic segment —
+ * e.g. `/<slug>`, `/<slug>/team` — that no finite set of string prefixes can describe.
+ *
+ * A `RegExp` is tested via `.test()` against `window.location.pathname` ONLY — never
+ * against the query string or fragment. Anchor it (`^…$`): this library does not add
+ * anchors for you, and an unanchored pattern like `/team` also matches `/admin/team`,
+ * silently suppressing the redirect somewhere it's still needed. That failure is
+ * invisible until someone opens the over-matched page anonymously and lands on a
+ * blank error instead of `/login` — so test the non-matching direction too, not just
+ * the intended match.
+ *
  * MUST be called before the AuthProvider mounts (i.e. before `ReactDOM.render`).
  * Calling it later won't help the bootstrap probe which fires on AuthProvider mount.
  */
@@ -33,18 +45,36 @@ export function addPublicPath(path) {
     if (typeof path === "string" && path) {
         CONSUMER_PUBLIC_PATHS.add(path);
     }
+    else if (path instanceof RegExp) {
+        CONSUMER_PUBLIC_PATHS.add(path);
+    }
 }
-/** Remove a consumer-added public path. Library-internal paths are protected. */
+/**
+ * Remove a consumer-added public path. Library-internal paths are protected.
+ *
+ * For a `RegExp` entry, removal is by object identity (`Set.delete` uses SameValueZero
+ * equality) — pass the exact same `RegExp` instance `addPublicPath` was given, not a
+ * new literal that merely looks the same. Two `/^\/team$/` literals are not equal.
+ */
 export function removePublicPath(path) {
     CONSUMER_PUBLIC_PATHS.delete(path);
 }
 function isPublicSitePath(pathname) {
     return pathname === "/sites" || pathname.startsWith("/sites/");
 }
-// Match rule: an entry of exactly "/" requires strict equality (avoids matching
-// every path with startsWith). Other entries keep the looser prefix match so
-// dynamic routes like /invite/:uid/:token still work.
+// Match rule: a RegExp entry is tested against pathname only (AUTH-5). A string entry
+// of exactly "/" requires strict equality (avoids matching every path with
+// startsWith); other string entries keep the looser prefix match so dynamic routes
+// like /invite/:uid/:token still work.
 function matchesPublicPath(pathname, entry) {
+    if (entry instanceof RegExp) {
+        // `g`/`y` flags make `.test()` stateful (`lastIndex` advances on match), which would
+        // make the same pathname alternate matched/unmatched across calls to this
+        // long-lived, module-scoped RegExp — a redirect that only fires every other time.
+        // Reset before every test so a consumer's flags can't leak state across calls.
+        entry.lastIndex = 0;
+        return entry.test(pathname);
+    }
     if (entry === "/")
         return pathname === "/";
     return pathname.startsWith(entry);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@micha.bigler/ui-core-micha",
-  "version": "2.41.0",
+  "version": "2.41.1",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "repository": {

package/src/auth/apiClient.jsx

@@ -32,16 +32,36 @@ const CONSUMER_PUBLIC_PATHS = new Set();
  * Register an additional public path so a 401 on that route does not auto-redirect
  * to `/login`. Typical use: a public landing on `/` in an otherwise authenticated app.
  *
+ * Accepts a `string` (matched like the builtins: exact for "/", prefix otherwise) or
+ * a `RegExp` (AUTH-5) for consumers whose public area includes a dynamic segment —
+ * e.g. `/<slug>`, `/<slug>/team` — that no finite set of string prefixes can describe.
+ *
+ * A `RegExp` is tested via `.test()` against `window.location.pathname` ONLY — never
+ * against the query string or fragment. Anchor it (`^…$`): this library does not add
+ * anchors for you, and an unanchored pattern like `/team` also matches `/admin/team`,
+ * silently suppressing the redirect somewhere it's still needed. That failure is
+ * invisible until someone opens the over-matched page anonymously and lands on a
+ * blank error instead of `/login` — so test the non-matching direction too, not just
+ * the intended match.
+ *
  * MUST be called before the AuthProvider mounts (i.e. before `ReactDOM.render`).
  * Calling it later won't help the bootstrap probe which fires on AuthProvider mount.
  */
 export function addPublicPath(path) {
   if (typeof path === "string" && path) {
     CONSUMER_PUBLIC_PATHS.add(path);
+  } else if (path instanceof RegExp) {
+    CONSUMER_PUBLIC_PATHS.add(path);
   }
 }
 
-/** Remove a consumer-added public path. Library-internal paths are protected. */
+/**
+ * Remove a consumer-added public path. Library-internal paths are protected.
+ *
+ * For a `RegExp` entry, removal is by object identity (`Set.delete` uses SameValueZero
+ * equality) — pass the exact same `RegExp` instance `addPublicPath` was given, not a
+ * new literal that merely looks the same. Two `/^\/team$/` literals are not equal.
+ */
 export function removePublicPath(path) {
   CONSUMER_PUBLIC_PATHS.delete(path);
 }
@@ -50,10 +70,19 @@ function isPublicSitePath(pathname) {
   return pathname === "/sites" || pathname.startsWith("/sites/");
 }
 
-// Match rule: an entry of exactly "/" requires strict equality (avoids matching
-// every path with startsWith). Other entries keep the looser prefix match so
-// dynamic routes like /invite/:uid/:token still work.
+// Match rule: a RegExp entry is tested against pathname only (AUTH-5). A string entry
+// of exactly "/" requires strict equality (avoids matching every path with
+// startsWith); other string entries keep the looser prefix match so dynamic routes
+// like /invite/:uid/:token still work.
 function matchesPublicPath(pathname, entry) {
+  if (entry instanceof RegExp) {
+    // `g`/`y` flags make `.test()` stateful (`lastIndex` advances on match), which would
+    // make the same pathname alternate matched/unmatched across calls to this
+    // long-lived, module-scoped RegExp — a redirect that only fires every other time.
+    // Reset before every test so a consumer's flags can't leak state across calls.
+    entry.lastIndex = 0;
+    return entry.test(pathname);
+  }
   if (entry === "/") return pathname === "/";
   return pathname.startsWith(entry);
 }

package/tests/apiClientPublicPaths.test.js

@@ -0,0 +1,178 @@
+// @vitest-environment jsdom
+// AUTH-5: addPublicPath/matchesPublicPath/removePublicPath must accept a RegExp alongside a
+// string, evaluated exclusively against pathname. Driven through the real response interceptor
+// (not a reimplementation of matchesPublicPath) so these tests fail if the wiring, not just the
+// matcher, breaks.
+//
+// The module keeps a `redirectingToLogin` latch that only resets on a real navigation, which
+// never happens in jsdom — so each test re-imports a fresh module instance via
+// vi.resetModules()/dynamic import, rather than sharing one import across the file.
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function notAuthenticatedError(status = 401) {
+  return {
+    response: {
+      status,
+      data: { code: 'not_authenticated' },
+    },
+    config: {},
+  };
+}
+
+async function rejectThroughInterceptor(client, error) {
+  const handler = client.interceptors.response.handlers.find(Boolean);
+  try {
+    await handler.rejected(error);
+  } catch {
+    // The interceptor always re-rejects after handling — expected, not the assertion.
+  }
+}
+
+// jsdom's real `window.location` ties `pathname` to `history.pushState` through internal
+// wiring that a deleted/replaced `location` object doesn't preserve, and `assign` is
+// non-configurable so `vi.spyOn` can't touch it directly either. Sidestep both by installing a
+// fully synthetic `location` this file controls end to end — the interceptor only ever reads
+// `.pathname` and calls `.assign()`, so nothing else needs to be real.
+function installLocationMock(initialPathname = '/') {
+  const assign = vi.fn();
+  delete window.location;
+  window.location = { pathname: initialPathname, search: '', hash: '', assign };
+  return assign;
+}
+
+function setPathname(pathname) {
+  window.location.pathname = pathname;
+}
+
+describe('apiClient public-path registry (AUTH-5)', () => {
+  let assignSpy;
+  let apiClient;
+  let addPublicPath;
+  let removePublicPath;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    ({ default: apiClient, addPublicPath, removePublicPath } = await import('../src/auth/apiClient'));
+    assignSpy = installLocationMock();
+  });
+
+  it('string registration still matches by prefix (regression)', async () => {
+    setPathname('/custom-public');
+    addPublicPath('/custom-public');
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).not.toHaveBeenCalled();
+  });
+
+  it('a bare "/" registration does not match a deeper path via startsWith (regression)', async () => {
+    addPublicPath('/');
+    setPathname('/somewhere-else');
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).toHaveBeenCalledWith('/login');
+  });
+
+  it('a registered RegExp matches the intended dynamic path', async () => {
+    addPublicPath(/^\/[^/]+\/team$/);
+    setPathname('/jg-bern/team');
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).not.toHaveBeenCalled();
+  });
+
+  it('a non-matching path still redirects even with an unrelated RegExp registered', async () => {
+    addPublicPath(/^\/[^/]+\/team$/);
+    setPathname('/account');
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).toHaveBeenCalledWith('/login');
+  });
+
+  it('the RegExp is tested against pathname, not the query string', async () => {
+    // A pattern that would only match if the query string leaked into the tested value.
+    setPathname('/blocked-page');
+    window.location.search = '?next=/public';
+    addPublicPath(/public/);
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).toHaveBeenCalledWith('/login');
+  });
+
+  it('the RegExp is tested against pathname, not the fragment', async () => {
+    setPathname('/blocked-page');
+    window.location.hash = '#panel';
+    addPublicPath(/panel/);
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).toHaveBeenCalledWith('/login');
+  });
+
+  it('a pathname-anchored RegExp still matches when the URL also carries a query string', async () => {
+    setPathname('/public');
+    window.location.search = '?next=/admin';
+    addPublicPath(/^\/public$/);
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).not.toHaveBeenCalled();
+  });
+
+  it('removePublicPath removes a RegExp entry by identity', async () => {
+    const pattern = /^\/temp$/;
+    addPublicPath(pattern);
+    removePublicPath(pattern);
+    setPathname('/temp');
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).toHaveBeenCalledWith('/login');
+  });
+
+  it('removePublicPath does not remove a RegExp entry given only an equal-looking literal', async () => {
+    addPublicPath(/^\/temp$/);
+    removePublicPath(/^\/temp$/); // a different object, same source — must NOT remove the original
+    setPathname('/temp');
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).not.toHaveBeenCalled();
+  });
+
+  it('removePublicPath cannot remove a builtin path', async () => {
+    removePublicPath('/login');
+    setPathname('/login');
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).not.toHaveBeenCalled();
+  });
+
+  it('a stateful (global-flag) RegExp matches consistently across repeated calls', async () => {
+    // Without resetting lastIndex, a `g`-flagged RegExp would alternate
+    // matched/unmatched across calls since it is reused from the module-level Set.
+    addPublicPath(/^\/public$/g);
+    setPathname('/public');
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+    expect(assignSpy).not.toHaveBeenCalled();
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+    expect(assignSpy).not.toHaveBeenCalled();
+  });
+
+  it('a RegExp entry in the registry does not break evaluation of string entries', async () => {
+    addPublicPath(/^\/gallery\/\d+$/);
+    addPublicPath('/custom-string');
+    setPathname('/custom-string');
+
+    await rejectThroughInterceptor(apiClient, notAuthenticatedError());
+
+    expect(assignSpy).not.toHaveBeenCalled();
+  });
+});

package/work-orders/AUTH-5.md

@@ -0,0 +1,154 @@
+# AUTH-5 — `addPublicPath` muss dynamische Routen ausdrücken können
+
+**Target repo:** `ui-core-micha` (branch `main`)
+**Tier:** 3 — shared-core. Die Änderung betrifft die Login-Weiterleitung jeder konsumierenden App.
+
+**Kein Prototyp.** Diese Work Order hat keine Oberfläche — sie erweitert eine Registrierungs-API.
+
+**Auslöser:** `jg-ferien` PUB-7 Teil 2. Diese WO ist dessen Vorbedingung; nach der Veröffentlichung
+zieht jg seinen Pin von **`2.37.1`** hoch.
+
+---
+
+## A. Envelope
+
+### Goal
+
+`apiClient` leitet bei 401/403 per hartem `window.location.assign("/login")` um — **ausser** der
+aktuelle Pfad steht auf einer Allowlist (`redirectToLoginOnce`, `src/auth/apiClient.jsx`). Der
+Mechanismus ist richtig gebaut: auf einer öffentlichen Seite unterbleibt die Weiterleitung und der
+401 wird an die Komponente durchgereicht.
+
+**Was er nicht kann, ist dynamische Routen.** `matchesPublicPath` vergleicht mit `startsWith`, ausser
+bei `/`, wo Gleichheit verlangt wird. Eine App mit öffentlichen Seiten unter einem **variablen
+Segment** — `/<slug>`, `/<slug>/team` — kann ihre öffentliche Fläche damit nicht beschreiben. Ein
+konkreter Slug lässt sich eintragen; der nächste, den jemand anlegt, fällt wieder heraus.
+
+**Warum das mehr ist als eine Unbequemlichkeit.** Fehlt der Pfad in der Liste, landet ein anonymer
+Besucher beim ersten 401 auf `/login` — auf einer Seite, die öffentlich sein soll. Von aussen ist das
+nicht von „diese Seite gibt es nicht" zu unterscheiden, und der Fehler zeigt sich erst, wenn ein
+zweites Department existiert. Er sieht dann aus wie ein Zufall, nicht wie eine Lücke.
+
+**Erwartetes Ergebnis.** Eine konsumierende App kann ihre öffentliche Fläche vollständig beschreiben,
+auch wenn Teile davon aus variablen Segmenten bestehen.
+
+### Scope
+
+- **`addPublicPath` nimmt zusätzlich ein `RegExp` entgegen** (String bleibt unverändert gültig).
+- **`matchesPublicPath` unterscheidet nach Typ**: String wie bisher (`/` exakt, sonst `startsWith`),
+  `RegExp` per `test()` gegen **ausschliesslich `window.location.pathname`** — nie gegen Query oder
+  Fragment, damit ein Muster nicht versehentlich über den Pfad hinaus greift.
+- **`removePublicPath` funktioniert für beide Formen.** Bei `RegExp` über Identität des übergebenen
+  Objekts; das gehört dokumentiert, weil zwei gleich aussehende Literale nicht dasselbe Objekt sind.
+- **`BUILTIN_PUBLIC_PATHS` bleibt eingefroren und rein string-basiert.** Kein Muster in der
+  Bibliotheks-Liste — sie darf sich nicht durch eine Konsumenten-Erweiterung verschieben.
+- **Die Dokumentation am Aufruf sagt, was der Konsument nun selbst trägt**: ein zu weites Muster
+  unterdrückt die Weiterleitung dort, wo sie gebraucht wird, und ein abgelaufener Login endet dann in
+  einer stillen Fehlerseite statt am Login. Muster gehören verankert (`^…$`).
+
+### Non-goals / do not touch
+
+- **Keine Änderung am Weiterleitungsverhalten selbst** — weder Ziel, noch `?next=`, noch der
+  einmalige Sperrmechanismus (`redirectingToLogin`).
+- **Keine Änderung an der eingefrorenen Builtin-Liste** und keine an `isPublicSitePath`.
+- **Keine Änderung am Per-Request-Opt-out** für Bootstrap-Proben.
+- **Keine neue Prüfung gegen Query oder Fragment.**
+
+### Risks
+
+- **Die Verantwortung wandert zum Konsumenten.** Ein unverankertes Muster wie `/team` trifft auch
+  `/admin/team`. Das ist der Preis der Flexibilität und muss in der Dokumentation stehen, nicht nur
+  im Kopf des Autors.
+- **Geteilter Code**: jede konsumierende App bekommt die Änderung. Deshalb rein additiv — bestehende
+  String-Registrierungen müssen sich zeichengenau gleich verhalten.
+- **Ein Muster, das zu eng greift, ist unsichtbar**, bis jemand die betroffene Seite anonym öffnet.
+  Deshalb gehört die Gegenrichtung mitgetestet.
+
+### Required tests to WRITE
+
+- **Regression, nicht verhandelbar:** String-Registrierungen verhalten sich exakt wie bisher — `/`
+  nur bei Gleichheit, andere Einträge per Präfix.
+- Ein registriertes `RegExp` trifft die passenden Pfade; ein nicht passender Pfad **löst weiterhin
+  die Weiterleitung aus**.
+- Das Muster wird gegen `pathname` geprüft, nicht gegen Query oder Fragment.
+- `removePublicPath` entfernt einen `RegExp`-Eintrag; ein Builtin-Pfad lässt sich weiterhin **nicht**
+  entfernen.
+- Ein `RegExp` in `CONSUMER_PUBLIC_PATHS` bricht die bestehende Auswertung der String-Einträge nicht.
+- **Affected set** (laufen, nicht schreiben): die vorhandenen `apiClient`-Tests.
+
+---
+
+## B. Implementation map
+
+**Selbst umgesetzt (nicht per Codex)** — laufende Operator-Anweisung für diese Session.
+
+### Design-Entscheidungen
+
+- **`addPublicPath`/`removePublicPath`** akzeptieren jetzt zusätzlich `instanceof RegExp` neben
+  `string`; `CONSUMER_PUBLIC_PATHS` bleibt ein `Set`, das für `RegExp`-Objekte automatisch
+  Identitäts-Löschung liefert (`Set.delete` nutzt SameValueZero) — kein Sonderfall nötig.
+- **`matchesPublicPath`** prüft `entry instanceof RegExp` zuerst und ruft `entry.test(pathname)` —
+  ausschliesslich gegen `window.location.pathname`, nie gegen `search`/`hash`, da die Funktion
+  ohnehin nur `pathname` als Parameter erhält (kein Risiko einer versehentlichen Konkatenation).
+- **`BUILTIN_PUBLIC_PATHS` unverändert** — bleibt string-only und eingefroren, keine Berührung.
+- Dokumentation an `addPublicPath`/`removePublicPath` erweitert: Anker-Pflicht (`^…$`) für
+  `RegExp`-Muster und Identitäts-Hinweis für `removePublicPath`.
+
+### Kontextpaket
+
+- `src/auth/apiClient.jsx` — einzige geänderte Quelldatei.
+
+### Tests
+
+`tests/apiClientPublicPaths.test.js` (neu, 11 Fälle) — fährt durch den echten
+Response-Interceptor (nicht durch eine Nachbildung von `matchesPublicPath`), damit ein Fehler in
+der Verdrahtung selbst auffällt, nicht nur ein Fehler im Matcher. Jeder Test importiert das Modul
+frisch (`vi.resetModules()` + dynamisches `import()`), weil `redirectingToLogin` ein
+Modul-Level-Riegel ist, der sich in jsdom nie durch echte Navigation zurücksetzt.
+`window.location` wird durch ein rein synthetisches Objekt ersetzt (jsdoms echtes
+`location.assign` ist nicht konfigurierbar, und `pushState` bindet nicht an ein ersetztes
+`location`-Objekt) — deckt exakt das ab, was der Interceptor liest (`pathname`) und aufruft
+(`assign`). Affected set: `authApiRegistration.test.js`, `AuthContext.test.jsx`,
+`feedApi.test.js`, `messagingApi.test.js`, `notificationsApi.test.js` — alle grün.
+
+---
+
+## C. Orchestrator only
+
+> **STOPP — wer diesen Auftrag als eigene Spezifikation liest, ist mit diesem Abschnitt nicht
+> gemeint.** Er beschreibt dem Orchestrator, wie er dich aufruft, wie das Ergebnis geprüft und wie es
+> verbucht wird. **Du BIST dieser Aufruf — starte kein `codex exec`, spawne keine Reviewer, pflege
+> das Register nicht, committe nicht.** Deine Aufgabe endet beim Diff.
+
+### Execution directive
+
+`.claude/codex-status.md` im Workspace-Root vor dem Aufruf prüfen. Ohne Zeile für den
+Ausführungstag Codex verwenden — direkt per Bash, nie über die `debugger`/`*_coder`-Wrapper, mit
+BEIDEN Flags `--skip-git-repo-check` und `--dangerously-bypass-approvals-and-sandbox`. Der Rückfall
+auf direkte Umsetzung dreht die Autorschaft und macht den unabhängigen `reviewer` zwingend.
+
+### Review routing
+
+Tier 3 (shared-core): **`reviewer` und `sec_reviewer`**, gleichzeitig in einem Hintergrund-Batch vor
+dem Commit. `ui_reviewer` entfällt — es gibt keine Oberfläche. `sec_reviewer` prüft die Kernfrage:
+kann ein registriertes Muster die Weiterleitung dort unterdrücken, wo sie gebraucht wird, und ist die
+Auswertung auf `pathname` beschränkt.
+
+### Verification
+
+Kein Prototyp, kein Zwei-Breiten-Abgleich. Der Nachweis sind die Tests, insbesondere die
+Regressionsfälle für die String-Registrierung.
+
+Nach grünem Review: Version anheben und veröffentlichen. **Die WO ist erst abgeschlossen, wenn die
+Version veröffentlicht ist** — jg-ferien PUB-7 hängt daran und kann ohne sie nicht landen.
+
+### Register + commit
+
+Zeile `AUTH-5` erreicht `done` nur mit beiden Reviewern samt Verdikt in der `Notiz` und der
+veröffentlichten Version. Auf grün nach `main` committen und pushen.
+
+### Mini-handover
+
+Repo: `ui-core-micha` (`C:\Users\biglmi\Documents\webapps\ui-core-micha`), Branch `main`.
+WO: `work-orders/AUTH-5.md`. Konsument: `jg-ferien` PUB-7 Teil 2 (Pin heute `2.37.1`).
+`git pull`, WO lesen, dann `orchestrate-codex` folgen.