test(webui): update the source expectations the terminal and browser work left behind

The terminal and browser work changed what these suites read. The panel
mounts the browser host for the tab it kept mounted rather than for the
selected one; the launcher hands the browser its own normalised address,
which is what gives a bare host its trailing slash; the terminal's create
button became an automatic create once the roster lands, so the panel
states what the service says instead of keeping a copy of the limit; the
browser control is an icon button whose accessible name is an `aria-label`
rather than a title; and the shell's stylesheet list now includes the
terminal's own stylesheet, which is a package stylesheet and so is not
counted among the shell's rules.

Each expectation now names the behaviour that replaced it rather than the
shape it used to have.

Author: stevenjj33

packages/webui/test/unit/browser-web-tab-toolbar.test.tsx

@@ -136,11 +136,12 @@ describe("a web tab's toolbar", () => {
   });
 
   it("is carried by the browser business's host, over the tab's target", () => {
-    // The toolbar is rendered by the host the strip mounts, and the strip hands
-    // it the tab's own target and url — so the row and the frame describe the
-    // same page rather than a pair that has drifted.
-    expect(WORKSPACE_PANELS_SOURCE).toContain("canGoBack={activeTab.content.canGoBack}");
-    expect(WORKSPACE_PANELS_SOURCE).toContain("canGoForward={activeTab.content.canGoForward}");
+    // The toolbar is rendered by the host the panel mounts, and the panel hands
+    // it one tab's own target and url — so the row and the frame describe the
+    // same page rather than a pair that has drifted. That tab is the one the
+    // panel kept mounted, which is the one whose frame the reader is looking at.
+    expect(WORKSPACE_PANELS_SOURCE).toContain("canGoBack={browserTab.content.canGoBack}");
+    expect(WORKSPACE_PANELS_SOURCE).toContain("canGoForward={browserTab.content.canGoForward}");
     expect(WORKSPACE_PANELS_SOURCE).toContain('type: "return-web-tab-to-launcher"');
   });
 

packages/webui/test/unit/webui-shell.test.ts

@@ -315,7 +315,10 @@ describe("WebUI shell", () => {
 
     const controls = renderToStaticMarkup(createElement(WebuiWorkspacePanelControls, { browserPanelOpen: false, progressPanelOpen: true, onOpenBrowser: () => undefined, onToggleProgressPanel: () => undefined }));
     expect(controls).toContain('aria-label="浏览器"');
-    expect(controls).toContain('title="浏览器"');
+    // The control is an icon button now, so the label is the accessible name
+    // rather than a tooltip: `aria-label` is what a screen reader reads, and a
+    // `title` would only add a hover affordance the glyph already carries.
+    expect(controls).not.toContain('title="浏览器"');
     // The control's glyph is the tabler browser icon. It used to be a globe
     // drawn by hand, so the assertion names the icon rather than the shape it
     // happens to be made of.

packages/webui/test/unit/webui-w0-css-structure.test.ts

@@ -238,7 +238,11 @@ beforeAll(() => {
     .map((match) => match[1])
     .filter(
       (specifier) =>
-        !specifier.startsWith("katex/") &&
+        // Only the shell's own stylesheets count. A package stylesheet —
+        // `katex/`, and now `@xterm/` — is not the shell's CSS: its rules sit
+        // outside the components layer, so counting them would answer questions
+        // the assertions below never asked.
+        specifier.startsWith(".") &&
         !carved.has(specifier.replace(/^.*\//u, "")),
     )
     .map((specifier) => path.resolve(stylesDir, specifier));
@@ -512,6 +516,9 @@ describe("W0 · stylesheet composition", () => {
     expect(imports).toEqual([
       "./tokens.css",
       "./shell.css",
+      // The terminal's own stylesheet, brought in by the package that owns it
+      // rather than copied into the shell's tree.
+      "@xterm/xterm/css/xterm.css",
       // The shared dropdown surface: the look, the motion and the shape every
       // floating popup in the client shares.
       "./dropdown.css",

packages/webui/test/unit/workspace-panel-state.test.ts

@@ -417,14 +417,14 @@ describe("the terminal roster is read before it is shown", () => {
 
   it("does not paint an empty roster before the first answer lands", () => {
     // On a reload whose sessions still hold PTYs, an empty first paint reads as
-    // "all my terminals exited" and offers a create button that would exceed the
+    // "all my terminals exited" and invites a create that would exceed the
     // limit. The panel waits for the roster instead.
     expect(panelSource).toContain("terminalsReady");
-    expect(panelSource).toContain("{!terminalsReady ? <><p>{DESKTOP_COPY.terminalLoading}</p>");
-    // The standalone create button lives outside the ready/not-ready branch, so
-    // it is gated explicitly: offering it before the roster lands is what invites
-    // the create that exceeds the limit.
-    expect(panelSource).toContain("terminalsReady && terminals.length === 0");
+    expect(panelSource).toContain("{!terminalsReady ? DESKTOP_COPY.terminalLoading");
+    // The create waits for the roster too: the panel opens a terminal only once
+    // the first answer has landed, so a reload cannot open a second shell
+    // before the roster has said what is already running.
+    expect(panelSource).toContain("!terminalsReady || terminalTargetId");
   });
 
   it("drops a roster read that a later read has superseded", () => {
@@ -435,16 +435,20 @@ describe("the terminal roster is read before it is shown", () => {
     expect(panelSource).toContain("if (rosterRead.current !== read) return;");
   });
 
-  it("says the limit rather than discovering it through a refused create", () => {
-    // The panel knows the rule the process half enforces, so a full set is
-    // stated before the request instead of after it.
-    expect(panelSource).toContain("const DESKTOP_TERMINAL_LIMIT = 5;");
-    expect(panelSource).toContain("const terminalSlotsFull = terminals.length >= DESKTOP_TERMINAL_LIMIT;");
-    expect(panelSource).toContain("const terminalCreateDisabled = terminalSlotsFull || !terminalOwner?.canCreate;");
-    expect(panelSource).toContain("disabled={terminalCreateDisabled}");
-    // One helper, not three copies of the create-then-catch dance.
-    const createHandlers = panelSource.split("onClick={createTerminal}").length - 1;
-    expect(createHandlers).toBe(2);
-    expect(panelSource).not.toContain("terminalOwner.create(activeWorkspace).then");
+  it("states what the terminal service says rather than discovering a refusal", () => {
+    // The limit is the process half's rule now, so the panel keeps no copy of
+    // it. It asks the owner what it can do and says that answer — an absent
+    // service, a service that is not ready, an interface that does not match —
+    // instead of letting a refused create speak for itself.
+    expect(panelSource).toContain("terminalSupport");
+    expect(panelSource).toContain("terminalAvailability");
+    expect(panelSource).toContain("terminalError");
+    expect(panelSource).toContain("data-webui-terminal-availability={terminalSupport}");
+    // The create is gated by what the owner can do, so the panel never opens a
+    // terminal the service would refuse.
+    expect(panelSource).toContain("!terminalOwner?.canCreate");
+    // One create call, not a copy per button.
+    const createCalls = panelSource.split("terminalOwner.create(").length - 1;
+    expect(createCalls).toBe(1);
   });
 });

packages/webui/test/unit/workspace-tab-strip.test.tsx

@@ -415,11 +415,14 @@ describe("the new tab page", () => {
   });
 
   it("passes a bare host to the browser as a url it can open", () => {
-    expect(webuiWorkspaceLauncherUrl("example.test")).toBe("https://example.test");
+    // The launcher hands the browser its own address form: a bare host is a
+    // web address, and the browser's normalisation is what says which one it
+    // is. A host with no path keeps the browser's own trailing slash.
+    expect(webuiWorkspaceLauncherUrl("example.test")).toBe("https://example.test/");
     expect(webuiWorkspaceLauncherUrl("  example.test/a  ")).toBe("https://example.test/a");
     expect(webuiWorkspaceLauncherUrl("http://example.test/a")).toBe("http://example.test/a");
     // A host with a port is a host, not a scheme.
-    expect(webuiWorkspaceLauncherUrl("localhost:3000")).toBe("https://localhost:3000");
+    expect(webuiWorkspaceLauncherUrl("localhost:3000")).toBe("https://localhost:3000/");
     // An empty box opens nothing rather than opening a blank page.
     expect(webuiWorkspaceLauncherUrl("   ")).toBe("");
   });