@@ -532,14 +532,28 @@ try {
     }
     assert(snapshot.url === `${pageOrigin}/ticket`, 'Source URL contains query or fragment')
   })
-  await check('Selection attaches only the selected excerpt', async () => {
+  await check('A focused read-only custom element attaches only the selected excerpt', async () => {
     await page.evaluate(() => {
       const selected = document.getElementById('selected')
       if (!selected) throw new Error('Missing selection fixture')
+      customElements.define('readable-article', class extends HTMLElement {})
+      const host = document.createElement('readable-article')
+      host.tabIndex = 0
+      selected.replaceWith(host)
+      host.append(selected)
+      host.focus()
       const range = document.createRange()
       range.selectNodeContents(selected)
-      window.getSelection()?.removeAllRanges()
-      window.getSelection()?.addRange(range)
+      const selection = window.getSelection()
+      selection?.removeAllRanges()
+      selection?.addRange(range)
+      if (
+        document.activeElement !== host ||
+        host.isContentEditable ||
+        host.shadowRoot ||
+        selection?.toString() !== selected.textContent
+      )
+        throw new Error('Fixture did not focus and select ordinary custom-element text')
     })
     await capture('Selection')
     await app.waitForFunction(
@@ -551,6 +565,7 @@ try {
         snapshot.text === 'The customer needs a replacement by Friday.',
       'Selection widened beyond the user excerpt'
     )
+    await page.locator('readable-article').evaluate((host) => host.replaceWith(...host.childNodes))
   })
   await check('A focused child frame cannot substitute an old parent-page selection', async () => {
     await page.evaluate(() => {
 
@@ -2030,11 +2030,24 @@ try {
           await input().fill(draft)
           count = received.length
           phase = 'denied-send'
-          await input().press('Enter')
+          await frame()
+            .getByRole('button', { name: org ? 'Send' : 'Send message', exact: true })
+            .click()
           await expect(
             shell.getByRole('button', { name: 'Request site access', exact: true })
           ).toBeEnabled()
           await expect(input()).toHaveValue(draft)
+          await expect
+            .poll(() => input().evaluate((element) => Boolean(element.closest('[inert]'))))
+            .toBe(false)
+          assert.equal(received.length, count)
+          assert(
+            await frame().evaluate(() => document.hasFocus()),
+            'The denied mouse send must keep the chat document focused'
+          )
+          await expect(input()).toBeFocused()
+          await shell.keyboard.type(' Continue typing after the denied capture.')
+          await expect(input()).toHaveValue(`${draft} Continue typing after the denied capture.`)
           assert.equal(received.length, count)
           await screenshot(`reference-${org ? 'organization' : 'workspace'}-denied`)
           const accessNotice = await shell
 
@@ -327,6 +327,34 @@ async function run() {
     assert.deepEqual(failures, [])
   })
 
+  await check(
+    'legacy Sim aliases preserve queries without redirecting the Sim Links entry',
+    async () => {
+      const entry = await get('/sim')
+      assert.equal(entry.status, 307)
+      assert(entry.location, 'The Sim Links entry must offer sign-in')
+      const login = new URL(entry.location, baseUrl)
+      assert.equal(login.pathname, '/login')
+      assert.equal(login.searchParams.get('callbackUrl'), '/sim')
+      for (const path of ['/Sim', '/SIM', '/sIm']) {
+        const { status, location } = await get(`${path}?home&utm_source=legacy`)
+        assert.equal(status, 308, path)
+        assert(location, `${path}: expected the legacy homepage redirect`)
+        const target = new URL(location, baseUrl)
+        assert.equal(target.origin, baseUrl.origin, path)
+        assert.equal(target.pathname, '/', path)
+        assert.deepEqual(
+          [...target.searchParams],
+          [
+            ['home', ''],
+            ['utm_source', 'legacy'],
+          ],
+          path
+        )
+      }
+    }
+  )
+
   await check('integration sitemap dates are per integration, not one catalog date', async () => {
     const mismatches: string[] = []
     for (const integration of integrations) {
 
@@ -403,24 +403,30 @@ async function run() {
     await api({ ...outsider, orgId }, '', { expected: 404 })
   })
 
-  await check(
-    'a team bookmark keeps its organization across sign-in and a same-name link elsewhere',
-    async () => {
-      const name = 'managed-help'
-      const path = `/sim-links/${encodeURIComponent(orgId)}/${name}`
-      const destination = 'https://team.example.com/help'
+  await check('team bookmarks preserve encoded names and organization across sign-in', async () => {
+    const destination = 'https://team.example.com/help'
+    for (const name of ['managed-help', 'managed:help@team&docs']) {
+      const path = `/sim-links/${encodeURIComponent(orgId)}/${encodeURIComponent(name)}`
       await create(owner, { name, url: destination })
       await create(outsider, { name, url: 'https://another-team.example.com/help' })
       const signedOut = await send(path, null)
+      assert.equal(signedOut.status, 307, `${name}: expected sign-in redirect`)
       const login = new URL(signedOut.headers.get('location') ?? '/', baseUrl)
-      assert.equal(login.pathname, '/login')
-      assert.equal(login.searchParams.get('callbackUrl'), path)
-      assert.equal((await send(path, member)).headers.get('location'), destination)
+      assert.equal(login.pathname, '/login', name)
+      assert.equal(login.searchParams.get('callbackUrl'), path, name)
+      const opened = await send(path, member)
+      assert.equal(opened.status, 307, `${name}: expected destination redirect`)
+      assert.equal(opened.headers.get('location'), destination, name)
       const denied = await send(path, outsider)
-      assert.equal(denied.status, 404)
-      assert(!denied.headers.get('location'))
+      assert.equal(denied.status, 404, name)
+      assert(!denied.headers.get('location'), name)
     }
-  )
+    for (const encodedName of ['%256Danaged-help', 'managed%2Fhelp']) {
+      const denied = await send(`/sim-links/${encodeURIComponent(orgId)}/${encodedName}`, member)
+      assert.equal(denied.status, 404, encodedName)
+      assert(!denied.headers.get('location'), encodedName)
+    }
+  })
 
   await check(
     'bookmark export requires admin access and drops stale or foreign selections',