@jskit-ai/assistant-core 0.2.24 → 0.2.26

package/test/assistantScroll.browser.test.js

@@ -3,16 +3,14 @@ import path from "node:path";
 import process from "node:process";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
-import { chromium, expect } from "@playwright/test";
-import {
-  createChromiumLaunchOptions,
-  startViteFixture,
-  stopProcess
-} from "../../../tooling/testUtils/browserFixture.mjs";
+import { expect } from "../../../tooling/testUtils/browserExpect.mjs";
+import { sharedBrowserFixture } from "../../../tooling/testUtils/browserFixture.mjs";
 
 const TEST_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
 const FIXTURE_ROOT = path.resolve(TEST_DIRECTORY, "../fixtures/responsive-assistant");
 const RUN_BROWSER_TEST = process.env.JSKIT_ASSISTANT_CORE_BROWSER_INTEGRATION === "1";
+// Every test reads the same fixture app, so the file shares one server and one Chromium; each test gets its own pages.
+const openFixture = sharedBrowserFixture({ fixtureRoot: FIXTURE_ROOT });
 // Turns use content-visibility estimates. Moving the reader materializes rows
 // near the new position, and Chromium's scroll anchoring then shifts scrollTop
 // to keep the same content in view. Hold a reading position only once that
@@ -109,9 +107,8 @@ const VIEWPORTS = Object.freeze([
 
 test("progress previews omit expandable details without hiding the current update", {
   skip: !RUN_BROWSER_TEST, timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 800, 1365]) {
       const page = await browser.newPage({ viewport: { width, height: 900 } });
@@ -137,15 +134,13 @@ test("progress previews omit expandable details without hiding the current updat
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("saved reply attribution remains when the current assistant changes", {
   skip: !RUN_BROWSER_TEST, timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     const page = await browser.newPage();
     await page.goto(`${vite.baseURL}/?conversation=1&attribution=1`);
@@ -157,15 +152,13 @@ test("saved reply attribution remains when the current assistant changes", {
     await expect(names).toHaveText(["First assistant", "Message assistant", "Next assistant"]);
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("streaming answers grow in one bubble, preserve drafts and settle once at every width", {
   skip: !RUN_BROWSER_TEST, timeout: 90_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 800, 1365]) {
       const page = await browser.newPage({ viewport: { width, height: 900 } });
@@ -189,16 +182,14 @@ test("streaming answers grow in one bubble, preserve drafts and settle once at e
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("adjacent reasoning stays grouped across storage rows, history pages and execution changes", {
   skip: !RUN_BROWSER_TEST,
   timeout: 90_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 800, 1365]) {
       const page = await browser.newPage({ viewport: { width, height: 900 } });
@@ -262,7 +253,6 @@ test("adjacent reasoning stays grouped across storage rows, history pages and ex
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
@@ -286,13 +276,11 @@ test("AssistantConversationElement keeps long conversations scrollable across re
   skip: RUN_BROWSER_TEST
     ? false
     : "set JSKIT_ASSISTANT_CORE_BROWSER_INTEGRATION=1 to run assistant-core browser integration",
-  timeout: 180_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  let browser = null;
+  timeout: 90_000
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
 
   try {
-    browser = await chromium.launch(createChromiumLaunchOptions());
     const context = await browser.newContext({
       baseURL: vite.baseURL,
       locale: "en-US"
@@ -315,16 +303,14 @@ test("AssistantConversationElement keeps long conversations scrollable across re
     );
   } finally {
     await browser?.close();
-    await stopProcess(vite);
   }
 });
 
 test("conversation scrolling preserves history anchors and resets expansion on selection", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     const page = await browser.newPage();
     await page.goto(`${vite.baseURL}/?controls=1`);
@@ -375,16 +361,14 @@ test("conversation scrolling preserves history anchors and resets expansion on s
     assert.equal(await page.evaluate(() => window.revealPlaceholders), 0, "reopening loaded text does not flash a loading placeholder");
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("a delayed final history page preserves the visible message at every width", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 800, 1365]) {
       const page = await browser.newPage({ viewport: { width, height: 900 } });
@@ -410,16 +394,14 @@ test("a delayed final history page preserves the visible message at every width"
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("upward scrolling loads older history once and preserves retry and selection behavior", {
   skip: !RUN_BROWSER_TEST,
   timeout: 90_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 800, 1365]) {
       const touch = width < 1000;
@@ -504,16 +486,14 @@ test("upward scrolling loads older history once and preserves retry and selectio
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("a reader's own upward scrolling leaves the latest message from its first frame", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 1365]) {
       const touch = width < 1000;
@@ -580,16 +560,14 @@ test("a reader's own upward scrolling leaves the latest message from its first f
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("a reader moved away from the end without a scroll direction stays there", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     const page = await browser.newPage({ viewport: { width: 1365, height: 900 } });
     const errors = [];
@@ -618,16 +596,14 @@ test("a reader moved away from the end without a scroll direction stays there",
     assert.deepEqual(errors, []);
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("retained hidden transcripts preserve readers and follow only at the latest message", {
   skip: !RUN_BROWSER_TEST,
   timeout: 90_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 800, 1365]) {
       const page = await browser.newPage({ viewport: { width, height: 900 } });
@@ -683,16 +659,14 @@ test("retained hidden transcripts preserve readers and follow only at the latest
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("transient update errors keep the loaded transcript, reader, draft and focus in a compact banner", {
   skip: !RUN_BROWSER_TEST,
   timeout: 90_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 800, 1365]) {
       const page = await browser.newPage({ viewport: { width, height: 900 } });
@@ -750,16 +724,14 @@ test("transient update errors keep the loaded transcript, reader, draft and focu
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("retained hidden history loads restore their original anchor and invalidate retired requests", {
   skip: !RUN_BROWSER_TEST,
   timeout: 90_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 800, 1365]) {
       const page = await browser.newPage({ viewport: { width, height: 900 } });
@@ -818,16 +790,14 @@ test("retained hidden history loads restore their original anchor and invalidate
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("conversation composer preserves typing and reacts to external state and pane resizing", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     const page = await browser.newPage({ viewport: { width: 1365, height: 900 } });
     await page.goto(`${vite.baseURL}/?conversation=1`);
@@ -872,16 +842,14 @@ test("conversation composer preserves typing and reacts to external state and pa
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("working state appears before output and suggestion agents and activity rendering are replaceable", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     const page = await browser.newPage({ viewport: { width: 390, height: 844 } });
     await page.goto(`${vite.baseURL}/?conversation=1&support=1`);
@@ -910,7 +878,6 @@ test("working state appears before output and suggestion agents and activity ren
     await expect(input).toHaveValue("Keep typing while waiting");
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
@@ -918,9 +885,8 @@ test("working state appears before output and suggestion agents and activity ren
 test("long goal objectives keep Start reachable on short phone, tablet and desktop screens", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     const objective = "Complete the requested work and verify the result. ".repeat(80).slice(0, 3990);
     for (const width of [390, 800, 1280]) {
@@ -947,16 +913,14 @@ test("long goal objectives keep Start reachable on short phone, tablet and deskt
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("optional goals show running and paused lights, count only active time, and adapt to pane width", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     const page = await browser.newPage({ viewport: { width: 1365, height: 900 } });
     await page.clock.install();
@@ -1035,7 +999,6 @@ test("optional goals show running and paused lights, count only active time, and
     await expect(input).toHaveValue("Preserve this draft and caret");
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
@@ -1043,9 +1006,8 @@ test("optional goals show running and paused lights, count only active time, and
 test("shared model choices and file delivery preserve a responsive composer", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     const page = await browser.newPage({ viewport: { width: 390, height: 844 } });
     await page.goto(`${vite.baseURL}/?conversation=1&capabilities=1`);
@@ -1084,15 +1046,13 @@ test("shared model choices and file delivery preserve a responsive composer", {
     assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 test("an optional avatar clamps in a short conversation without consuming its preference or draft", {
   skip: !RUN_BROWSER_TEST, timeout: 90_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 800, 1365]) {
       const page = await browser.newPage({ viewport: { width, height: 900 } });
@@ -1122,8 +1082,7 @@ test("an optional avatar clamps in a short conversation without consuming its pr
         assert.ok(send.y + send.height <= bounds.y + bounds.height + 1, "Send stays inside the supplied container");
         assert.ok(feedback.y + feedback.height <= bounds.y + bounds.height + 1, "Feedback stays inside the supplied container");
         assert.ok((await input.boundingBox()).height >= 40);
-        const avatarExpanded = await sizeControl.getAttribute("aria-expanded") === "true";
-        assert.equal(avatarButton.width, avatarExpanded ? 40 : 44, "Expanded minimise is compact; collapsed Show retains its wider target");
+        assert.equal(Math.round(avatarButton.width), 40, "Avatar visibility is a 40dp icon button, Show and Minimise alike");
         assert.equal(Math.round(avatarButton.height), 40, "Avatar visibility is a 40dp icon button, with no fixed height");
         const avatarTarget = await sizeControl.evaluate((element) => Number.parseFloat(window.getComputedStyle(element, "::before").height));
         assert.ok(avatarTarget >= 48, "Avatar visibility keeps Material's 48dp touch target");
@@ -1175,7 +1134,7 @@ test("an optional avatar clamps in a short conversation without consuming its pr
       await expect(artwork).toHaveCount(0);
       await expect(sizeControl).toBeVisible();
       const showBounds = await sizeControl.boundingBox();
-      assert.equal(showBounds.width, 44, "Collapsed Show retains its original wider target");
+      assert.equal(Math.round(showBounds.width), 40, "Collapsed Show is the small icon button, as Minimise is");
       assert.equal(Math.round(showBounds.height), 40, "Collapsed Show keeps the small icon button's height");
       assert.ok(await sizeControl.evaluate(element => Number.parseFloat(getComputedStyle(element, "::before").height)) >= 48,
         "Collapsed Show keeps a 48dp touch target");
@@ -1249,16 +1208,14 @@ test("an optional avatar clamps in a short conversation without consuming its pr
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 
 test("unsent preview edits stay in their bubble and disappear for the canonical message", {
   skip: !RUN_BROWSER_TEST, timeout: 60_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     const page = await browser.newPage({ viewport: { width: 320, height: 844 } });
     await page.goto(`${vite.baseURL}/?conversation=1&preview=1`);
@@ -1363,7 +1320,6 @@ test("unsent preview edits stay in their bubble and disappear for the canonical
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
@@ -1371,9 +1327,8 @@ test("unsent preview edits stay in their bubble and disappear for the canonical
 test("pending history keeps following the reader when a new reply changes transcript height", {
   skip: !RUN_BROWSER_TEST,
   timeout: 90_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [390, 1365]) {
       const page = await browser.newPage({ viewport: { width, height: 900 } });
@@ -1414,16 +1369,14 @@ test("pending history keeps following the reader when a new reply changes transc
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 
 test("connection warnings keep avatar controls and Reload reachable without replacing history", {
   skip: !RUN_BROWSER_TEST, timeout: 90_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [320, 800]) {
       const page = await browser.newPage({ viewport: { width, height: 1000 } });
@@ -1498,16 +1451,14 @@ test("connection warnings keep avatar controls and Reload reachable without repl
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });
 
 
 test("short connection warnings preserve full text and recovery targets at phone widths", {
   skip: !RUN_BROWSER_TEST, timeout: 90_000
-}, async () => {
-  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
-  const browser = await chromium.launch(createChromiumLaunchOptions());
+}, async (t) => {
+  const { vite, browser } = await openFixture(t);
   try {
     for (const width of [320, 390]) {
       const page = await browser.newPage({ viewport: { width, height: 768 } });
@@ -1580,6 +1531,5 @@ test("short connection warnings preserve full text and recovery targets at phone
     }
   } finally {
     await browser.close();
-    await stopProcess(vite);
   }
 });

package/test/claudeConversationSession.test.js

@@ -759,8 +759,23 @@ test("Claude cancellation waits for an application effect after closing the nati
 });
 
 test("the common request deadline stops an unfinished native turn and retains its admitted history", async t => {
-  const f = await fixture(t, { limits: { timeoutMs: 2000 } });
+  // The deadline also covers starting the native process and admitting the turn, which took up to 8.4 s (median 1.3 to
+  // 2.5 s) with 4 to 8 copies of this test running on an 8-thread host. Rather than a deadline long enough to outlast
+  // that, the test holds the request's deadline timer and runs it once the turn is admitted, so it always stops an
+  // admitted turn and never waits for the clock.
+  const timeoutMs = 10_000;
+  const setTimer = globalThis.setTimeout;
+  let deadline = null;
+  t.mock.method(globalThis, "setTimeout", (callback, delay, ...args) => {
+    if (deadline || delay !== timeoutMs) return setTimer(callback, delay, ...args);
+    deadline = () => callback(...args);
+    return setTimer(() => {}, 0);
+  });
+  const f = await fixture(t, { limits: { timeoutMs } });
   await f.conversation.send({ messageId: "waiting", text: "wait" });
+  assert.equal(typeof deadline, "function", "The request armed its deadline with the configured time limit");
+  assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 1, "The turn was admitted");
+  deadline();
   const snapshot = await f.conversation.wait();
   assert.equal(snapshot.conversationLog[0].metadata.runtime.status, "failed");
   assert.match(snapshot.error, /time limit/);

package/test/componentContracts.test.js

@@ -11,3 +11,47 @@ test("client entry points expose one conversation implementation and retain sett
   const conversation = await readFile(new URL("../src/client/conversation/index.js", import.meta.url), "utf8");
   assert.match(conversation, /AssistantConversationElement/);
 });
+
+// Material 3: one container at most, the composer an outlined text field, and no heading inside a titled pane.
+test("the transcript, composer and settings card each draw one Material 3 container", async () => {
+  const transcript = await readFile(new URL("../src/client/conversation/AssistantTranscript.css", import.meta.url), "utf8");
+  const block = (css, selector) => new RegExp(`(?:^|\\n)${selector.replaceAll(".", "\\.")} \\{([^}]*)\\}`, "u").exec(css)?.[1] ?? "";
+  assert.doesNotMatch(block(transcript, ".assistant-transcript"), /border/u, "the transcript area is not outlined");
+  assert.doesNotMatch(block(transcript, ".assistant-transcript__welcome"), /\bborder:/u, "the welcome bubble is a tonal fill only");
+  const prompt = await readFile(new URL("../src/client/conversation/AssistantPromptInput.vue", import.meta.url), "utf8");
+  const field = block(prompt, ".assistant-prompt-input__field");
+  assert.match(field, /border: 1px solid rgb\(var\(--v-theme-outline\)\);/u);
+  assert.match(field, /border-radius: 4px;/u);
+  assert.match(block(prompt, ".assistant-prompt-input__footer"), /padding: 0 12px 12px;/u);
+  const card = await readFile(new URL("../src/client/components/AssistantSettingsFormCard.vue", import.meta.url), "utf8");
+  assert.doesNotMatch(card, /<v-card-title|<v-card-subtitle|<v-divider/u);
+  assert.match(card, /:aria-label="props\.title"/u);
+  // Given a formId, the page's app bar carries Save: the form takes the id and the card draws no Save of its own.
+  assert.match(card, /<v-form :id="props\.formId \|\| undefined"/u);
+  assert.match(card, /<div v-if="!props\.formId \|\| !props\.addEdit\.canSave"/u);
+});
+
+// Material 3 tonal containers: inside the conversation only the composer, an outlined text field, draws an outline;
+// attachments, questions, code, tables, details and the model menu are surface-container tones.
+test("the conversation's containers are surface-container tones, not outlined boxes", async () => {
+  const folder = new URL("../src/client/conversation/", import.meta.url);
+  const files = ["AssistantTranscript.css", "AssistantAttachmentQueue.vue", "AssistantMessageAttachments.vue",
+    "AssistantModelControl.vue", "LongTextPreviewBlocks.vue", "LongTextInlineParts.vue", "AssistantPromptInput.vue"];
+  const outlines = [];
+  for (const file of files) {
+    const source = await readFile(new URL(file, folder), "utf8");
+    for (const [declaration] of source.matchAll(/\bborder(?:-(?:top|bottom|left|right|inline|block)(?:-(?:start|end))?)?: [^;]*\d[^;]*;/gu)) {
+      if (!/: 0;/u.test(declaration)) outlines.push(`${file}: ${declaration}`);
+    }
+    if (file === "AssistantModelControl.vue") {
+      assert.doesNotMatch(source, /<v-sheet[^>]*\n\s*border\n/u, "the model menu has no outline");
+      assert.match(source, /color="surface-container"\s+:elevation="2"/u);
+    }
+  }
+  assert.deepEqual(outlines, [
+    "AssistantModelControl.vue: border-bottom: 1px solid rgb(var(--v-theme-outline-variant));",
+    "AssistantModelControl.vue: border-top: 1px solid rgb(var(--v-theme-outline-variant));",
+    "LongTextPreviewBlocks.vue: border-bottom: 1px solid rgb(var(--v-theme-outline-variant));",
+    "AssistantPromptInput.vue: border: 1px solid rgb(var(--v-theme-outline));"
+  ], "only outline-variant dividers and the composer's outlined field draw lines");
+});

package/test/conversationAvatarThumbnail.test.js

@@ -40,7 +40,6 @@ async function renderShowAvatarButton(element, slots) {
   assert.equal(buttons.length, 1, "One Show avatar button while the avatar is hidden");
   const [, attributes, content] = buttons[0];
   assert.match(attributes, /title="jskit.assistant.chat.showAvatar"/u);
-  assert.match(attributes, /width="44"/u);
   return content;
 }
 
@@ -61,10 +60,10 @@ test("the hidden avatar's Show button shows the avatar-thumbnail slot, or the ac
   assert.doesNotMatch(fallback, /fixture-thumbnail/u);
 });
 
-test("the avatar's Show and Minimise buttons set no fixed height, so material-web gives them the 48dp touch target", () => {
+test("the avatar's Show and Minimise buttons set no fixed size, so material-web gives them the 48dp touch target", () => {
   const source = readFileSync(new URL(elementUrl), "utf8");
   const buttons = [...source.matchAll(/<v-btn\b[^>]*>/gu)].map(([tag]) => tag).filter((tag) => tag.includes("assistant-conversation__avatar-size"));
   assert.equal(buttons.length, 2);
-  for (const tag of buttons) assert.doesNotMatch(tag, /(?:^|\s):?(?:min-)?height=/u);
-  assert.doesNotMatch(source, /\.assistant-conversation__avatar-size\s*\{[^}]*height/u);
+  for (const tag of buttons) assert.doesNotMatch(tag, /(?:^|\s):?(?:min-)?(?:height|width)=/u);
+  assert.doesNotMatch(source, /\.assistant-conversation__avatar-size\s*\{[^}]*(?:height|width)/u);
 });

package/test/conversationSession.test.js

@@ -75,6 +75,69 @@ test("API runtime persists one admission for concurrent identical sends and stre
   assert.equal(f.requests.length, 1);
 });
 
+// A reply streamed as `deltas` chunks to one subscriber, each written once the one before it
+// was heard, with Date frozen from the send on (a streamed delta reuses a subscriber's
+// authorization while it is under a second old). `during` runs before the reply finishes.
+async function streamedReply(t, deltas, { subscriberAllowed = () => true, during } = {}) {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  const write = text => writer.write(new TextEncoder().encode(text));
+  let subscribeChecks = 0;
+  const f = await fixture(t, {
+    authorize: ({ operation }) => operation !== "subscribe" || (subscribeChecks += 1, subscriberAllowed()),
+    fetch: () => new Response(source.readable, { headers: { "content-type": "text/event-stream" } })
+  });
+  const heard = [];
+  let deltaHeard = Promise.withResolvers();
+  await f.conversation.subscribe(event => {
+    heard.push(event);
+    if (event.type === "message" && event.status === "inProgress") deltaHeard.resolve();
+  });
+  t.mock.timers.enable({ apis: ["Date"], now: Date.now() });
+  await f.conversation.send(input);
+  for (let index = 0; index < deltas; index += 1) {
+    deltaHeard = Promise.withResolvers();
+    await write(event(`w${index} `));
+    await deltaHeard.promise;
+  }
+  await during?.({ heard, delta: text => write(event(text)) });
+  await write(event("", true));
+  await writer.close();
+  const result = await f.conversation.wait();
+  t.mock.timers.reset();
+  return { result, heard, subscribeChecks };
+}
+
+const words = count => Array.from({ length: count }, (_, index) => `w${index}`).join(" ");
+
+test("a streamed reply authorizes its subscriber as often for 200 deltas as for 10", async t => {
+  const short = await streamedReply(t, 10);
+  const long = await streamedReply(t, 200);
+  assert.equal(short.result.conversationLog[0].assistant.text.trim(), words(10));
+  assert.equal(long.result.conversationLog[0].assistant.text.trim(), words(200));
+  assert.equal(long.heard.filter(event => event.type === "message" && event.status === "inProgress").length, 200,
+    "The subscriber hears every delta");
+  assert.equal(long.heard.at(-1).type, "settled");
+  assert.equal(long.subscribeChecks, short.subscribeChecks, "Streamed deltas reuse the subscriber's authorization for a second");
+});
+
+test("a subscriber whose access is revoked stops hearing a streamed reply within a second", async t => {
+  let allowed = true;
+  let heardAtRevocation = 0;
+  const { result, heard } = await streamedReply(t, 3, {
+    subscriberAllowed: () => allowed,
+    during: async ({ heard: heardSoFar, delta }) => {
+      allowed = false;
+      heardAtRevocation = heardSoFar.length;
+      t.mock.timers.tick(1000);
+      await delta("after revocation");
+    }
+  });
+  assert.equal(result.conversationLog[0].assistant.text, "w0 w1 w2 after revocation", "The turn itself continues");
+  assert.ok(heardAtRevocation > 3);
+  assert.deepEqual(heard.slice(heardAtRevocation), [], "Nothing reaches the subscriber once its authorization is a second old");
+});
+
 test("saved history and current instructions use the existing authorized model connection", async t => {
   const f = await fixture(t);
   await f.conversation.send(input);