feat(shell): make module pages first-class top-level routes

Module pages move from `/modules/<id>` to `/<module-id>` (`/signage`),
beside `/settings` and `/account`, so the implementation concept
"module" never appears in a user-facing address. ADR 0057 is rewritten
to match.

- Core reserves the top-level names the platform actually serves today
  (`account`, `api`, `assets`, `display`, `settings`), and discovery
  refuses a module that declares one with `MODULE_ID_RESERVED`. That
  covers startup, `modules:validate`, and package verification. Tests in
  `apps/api` hold the set to every top-level route the API registers and
  every page the shell interprets.
- The API serves the Dashboard page at `/<module-id>` and below only for
  modules discovered with a Dashboard UI, enabled or not: a disabled
  module's bookmark still opens the Dashboard, which says it is
  unavailable. An arbitrary root path such as
  `/definitely-not-a-real-module` stays the sanitized 404.
- Both reference proxies forward every top-level path shaped like a
  module id and let the API decide; the split Dashboard hostname still
  refuses `/api`, `/display`, and `/assets`. Installing a module needs no
  proxy change.
- `/<module-id>/<page>` is already served and forwarded, so a later
  module sub-page contract needs no routing or deployment change; the
  shell shows "Page not found" there until it exists.
- The deploy smoke checks a module's address before install, while
  installed, while disabled, after removal, and after reinstall, plus
  unknown names and the old `/modules/…` form through the real proxy.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

surfaces/shell/tests/dashboard-routes.test.ts

@@ -4,60 +4,17 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
 import {
-  DASHBOARD_PAGE_PREFIXES,
+  DASHBOARD_PLATFORM_PAGES,
   dashboardPath,
-  isDashboardPagePath,
   parseDashboardPath,
 } from "../src/dashboard-routes.js";
 
 const packageDirectory = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 
-describe("the Dashboard URL space", () => {
-  it("reserves exactly the platform's page namespaces, frozen", () => {
-    expect(Object.isFrozen(DASHBOARD_PAGE_PREFIXES)).toBe(true);
-    expect(DASHBOARD_PAGE_PREFIXES).toEqual(["/modules", "/settings", "/account"]);
-  });
-
-  it("never reserves a namespace the API, display host, or host assets already own", () => {
-    for (const prefix of DASHBOARD_PAGE_PREFIXES) {
-      for (const owned of ["/api", "/display", "/assets"]) {
-        expect(prefix === owned || prefix.startsWith(`${owned}/`), prefix).toBe(false);
-        expect(owned.startsWith(`${prefix}/`), prefix).toBe(false);
-      }
-    }
-  });
-
-  it("recognizes the root and every path inside a reserved namespace as a Dashboard page", () => {
-    for (const pathname of [
-      "/",
-      "/modules",
-      "/modules/",
-      "/modules/signage",
-      "/modules/signage/timelines/abc",
-      "/settings",
-      "/settings/displays/add",
-      "/account",
-      "/account/appearance",
-    ]) {
-      expect(isDashboardPagePath(pathname), pathname).toBe(true);
-    }
-  });
-
-  it("does not claim anything outside them, including look-alike prefixes", () => {
-    for (const pathname of [
-      "",
-      "/api/v1/principal",
-      "/display/signage",
-      "/assets/ekklesia-dashboard/app.js",
-      "/modulesx",
-      "/settings-old",
-      "/accounts",
-      "/index.html",
-      "/login",
-      "modules/signage",
-    ]) {
-      expect(isDashboardPagePath(pathname), pathname).toBe(false);
-    }
+describe("the Dashboard's own top-level pages", () => {
+  it("are exactly Settings and Account, frozen", () => {
+    expect(Object.isFrozen(DASHBOARD_PLATFORM_PAGES)).toBe(true);
+    expect(DASHBOARD_PLATFORM_PAGES).toEqual(["settings", "account"]);
   });
 });
 
@@ -66,40 +23,34 @@ describe("parseDashboardPath", () => {
     expect(parseDashboardPath("/")).toEqual({ kind: "overview" });
   });
 
-  it("names a module page by its id, tolerating one trailing slash", () => {
-    expect(parseDashboardPath("/modules/signage")).toEqual({
-      kind: "module",
-      moduleId: "signage",
-    });
-    expect(parseDashboardPath("/modules/signage/")).toEqual({
-      kind: "module",
-      moduleId: "signage",
-    });
+  it("names a module page by its id at the top level, tolerating one trailing slash", () => {
+    expect(parseDashboardPath("/signage")).toEqual({ kind: "module", moduleId: "signage" });
+    expect(parseDashboardPath("/signage/")).toEqual({ kind: "module", moduleId: "signage" });
+    expect(parseDashboardPath("/people")).toEqual({ kind: "module", moduleId: "people" });
   });
 
   it("decodes a percent-encoded segment, so an id is compared as the server spells it", () => {
-    expect(parseDashboardPath("/modules/sign%61ge")).toEqual({
-      kind: "module",
-      moduleId: "signage",
-    });
+    expect(parseDashboardPath("/sign%61ge")).toEqual({ kind: "module", moduleId: "signage" });
+  });
+
+  it("never reads a platform page as a module page", () => {
+    for (const pathname of ["/settings", "/settings/", "/account", "/account/appearance"]) {
+      expect(parseDashboardPath(pathname), pathname).toEqual({ kind: "not-found" });
+    }
   });
 
   it("treats every other shape as not found rather than guessing", () => {
     for (const pathname of [
       "",
-      "/modules",
-      "/modules/",
-      "/modules//",
-      "//modules/signage",
-      "/modules/signage//",
+      "//",
+      "//signage",
+      "/signage//",
       // A module's own sub-pages need a contract that does not exist yet (ADR 0057).
-      "/modules/signage/timelines",
-      "/modules/%E0%A4%A",
-      "/settings",
-      "/settings/displays",
-      "/account",
-      "/overview",
-      "/index.html",
+      "/signage/timelines",
+      "/signage/timelines/abc",
+      "/%E0%A4%A",
+      "/settings/displays/add",
+      "signage",
     ]) {
       expect(parseDashboardPath(pathname), pathname).toEqual({ kind: "not-found" });
     }
@@ -107,13 +58,13 @@ describe("parseDashboardPath", () => {
 });
 
 describe("dashboardPath", () => {
-  it("spells each route canonically", () => {
+  it("spells each route canonically, with no implementation prefix", () => {
     expect(dashboardPath({ kind: "overview" })).toBe("/");
-    expect(dashboardPath({ kind: "module", moduleId: "signage" })).toBe("/modules/signage");
+    expect(dashboardPath({ kind: "module", moduleId: "signage" })).toBe("/signage");
   });
 
   it("encodes a module id so it can never escape its own segment", () => {
-    expect(dashboardPath({ kind: "module", moduleId: "a/../b" })).toBe("/modules/a%2F..%2Fb");
+    expect(dashboardPath({ kind: "module", moduleId: "a/../b" })).toBe("/a%2F..%2Fb");
     expect(parseDashboardPath(dashboardPath({ kind: "module", moduleId: "a/../b" }))).toEqual({
       kind: "module",
       moduleId: "a/../b",
@@ -126,7 +77,6 @@ describe("dashboardPath", () => {
       { kind: "module", moduleId: "example" } as const,
     ]) {
       expect(parseDashboardPath(dashboardPath(route))).toEqual(route);
-      expect(isDashboardPagePath(dashboardPath(route))).toBe(true);
     }
   });
 });