diff --git a/deploy/helm/cockpit/README.md b/deploy/helm/cockpit/README.md
index 175859de..f8410f7c 100644
--- a/deploy/helm/cockpit/README.md
+++ b/deploy/helm/cockpit/README.md
@@ -124,6 +124,7 @@ Optional pre-configured Trino endpoint. When `trino.url` is set, the in-app conn
 | Parameter | Description | Default |
 | --- | --- | --- |
 | `trino.url` | Trino coordinator URL. | `""` |
+| `trino.publicUrl` | Browser-facing URL for "View in Trino" deep links. Defaults to `trino.url`. | `""` |
 | `trino.userImpersonation.enabled` | Forward the logged-in user to Trino as `X-Trino-User`. When `false`, all queries run as `trino.auth.username` (no per-user authorization/audit in Trino). | `true` |
 | `trino.userImpersonation.userClaim` | OIDC claim used as the Trino user. Only consumed when impersonation is enabled and OIDC is configured. | `preferred_username` |
 | `trino.auth.type` | `"none"` or `"basic"`. | `""` |
diff --git a/deploy/helm/cockpit/templates/configmap.yaml b/deploy/helm/cockpit/templates/configmap.yaml
index 7df6c989..14b74443 100644
--- a/deploy/helm/cockpit/templates/configmap.yaml
+++ b/deploy/helm/cockpit/templates/configmap.yaml
@@ -16,6 +16,9 @@ data:
   {{- with .Values.trino.url }}
   trino-url: {{ . | quote }}
   {{- end }}
+  {{- with .Values.trino.publicUrl }}
+  trino-public-url: {{ . | quote }}
+  {{- end }}
   {{- with .Values.trino.auth.type }}
   trino-auth-type: {{ . | quote }}
   {{- end }}
diff --git a/deploy/helm/cockpit/templates/deployment.yaml b/deploy/helm/cockpit/templates/deployment.yaml
index e9553548..a0f02654 100644
--- a/deploy/helm/cockpit/templates/deployment.yaml
+++ b/deploy/helm/cockpit/templates/deployment.yaml
@@ -181,6 +181,13 @@ spec:
                   name: {{ include "cockpit.fullname" . }}
                   key: trino-url
             {{- end }}
+            {{- if .Values.trino.publicUrl }}
+            - name: STACKABLE_COCKPIT_TRINO_PUBLIC_URL
+              valueFrom:
+                configMapKeyRef:
+                  name: {{ include "cockpit.fullname" . }}
+                  key: trino-public-url
+            {{- end }}
             {{- if .Values.trino.auth.type }}
             - name: STACKABLE_COCKPIT_TRINO_AUTH_TYPE
               valueFrom:
diff --git a/deploy/helm/cockpit/values.yaml b/deploy/helm/cockpit/values.yaml
index c8e6f1c7..4a701861 100644
--- a/deploy/helm/cockpit/values.yaml
+++ b/deploy/helm/cockpit/values.yaml
@@ -186,6 +186,8 @@ auth:
 trino:
   # Trino coordinator URL (e.g. https://trino.example.com:8443)
   url: ""
+  # Browser-facing URL for "View in Trino" deep links. Defaults to trino.url.
+  publicUrl: ""
   userImpersonation:
     # Forward the logged-in user to Trino as X-Trino-User. When false, all queries
     # run as trino.auth.username instead (requires basic auth).
diff --git a/e2e/trino/catalog-browser.spec.ts b/e2e/trino/catalog-browser.spec.ts
index be0180ed..be0e0d7e 100644
--- a/e2e/trino/catalog-browser.spec.ts
+++ b/e2e/trino/catalog-browser.spec.ts
@@ -129,6 +129,63 @@ test.describe('Catalog browser', () => {
     await schemaSelect.selectOption('sf1');
   });
 
+  test('long schema lists scroll instead of being clipped', async ({ page }) => {
+    // Inject many schemas so the tree must scroll within its bounded panel height.
+    await page.route(
+      (url) =>
+        url.pathname.endsWith('/api/trino/catalog') && url.searchParams.get('level') === 'schemas',
+      async (route) => {
+        const schemas = Array.from({ length: 60 }, (_, i) => [
+          `schema_${String(i).padStart(2, '0')}`
+        ]);
+        await route.fulfill({ json: schemas });
+      }
+    );
+
+    await ensureCatalogBrowserOpen(page);
+    const browser = page.getByRole('navigation', { name: 'Catalog browser' });
+
+    await browser.getByRole('button', { name: 'tpch' }).click();
+    await expect(browser.getByText('schema_00', { exact: true })).toBeVisible();
+    await expect(browser.getByText('schema_59', { exact: true })).toBeAttached();
+
+    // The tree container must have a bounded height and actually scroll.
+    const scrollable = browser.locator('div.overflow-auto').first();
+    const canScroll = await scrollable.evaluate((el) => el.scrollHeight > el.clientHeight + 1);
+    expect(canScroll).toBe(true);
+
+    const scrolled = await scrollable.evaluate((el) => {
+      el.scrollTop = el.scrollHeight;
+      return el.scrollTop > 0;
+    });
+    expect(scrolled).toBe(true);
+  });
+
+  test('catalog browser width is resizable and persists across reload', async ({ page }) => {
+    await ensureCatalogBrowserOpen(page);
+
+    const handle = page.getByRole('separator', { name: 'Resize catalog browser' });
+    await expect(handle).toBeVisible();
+
+    const before = Number(await handle.getAttribute('aria-valuenow'));
+    await handle.focus();
+    await page.keyboard.press('Shift+ArrowRight'); // +20px
+
+    await expect(handle).toHaveAttribute('aria-valuenow', String(before + 20));
+
+    const stored = await page.evaluate(() => localStorage.getItem('trino_catalog_browser_width'));
+    expect(Number(stored)).toBe(before + 20);
+
+    // Width persists across reload.
+    await page.reload();
+    await waitForHydration(page);
+    await ensureCatalogBrowserOpen(page);
+    await expect(page.getByRole('separator', { name: 'Resize catalog browser' })).toHaveAttribute(
+      'aria-valuenow',
+      String(before + 20)
+    );
+  });
+
   test('browser is hidden by default on mobile', async ({ page }) => {
     // Set mobile viewport.
     await page.setViewportSize({ width: 375, height: 667 });
diff --git a/e2e/trino/trino.spec.ts b/e2e/trino/trino.spec.ts
index 4d5180db..514794d1 100644
--- a/e2e/trino/trino.spec.ts
+++ b/e2e/trino/trino.spec.ts
@@ -60,6 +60,24 @@ test.describe('Trino query editor', () => {
     await expect(alert.getByText('syntax error at position 7')).toBeVisible();
   });
 
+  test('a transport-level submit failure surfaces the reason, not just a Failed badge', async ({
+    page
+  }) => {
+    // Force the submit endpoint to fail with a server-provided reason.
+    await page.route('**/api/trino/query', async (route, request) => {
+      if (request.method() === 'POST') {
+        await route.fulfill({ status: 400, json: { error: 'Could not reach Trino' } });
+      } else {
+        await route.continue();
+      }
+    });
+
+    await page.getByRole('button', { name: 'Run', exact: true }).click();
+
+    // The reason is shown in the status display.
+    await expect(page.getByText('Could not reach Trino')).toBeVisible();
+  });
+
   test('pagination navigates between pages', async ({ page }) => {
     await setTabSql(page, 'SELECT id, name FROM large_table');
     await page.goto('/trino');
diff --git a/messages/de.json b/messages/de.json
index c54247fe..8b0bc0b1 100644
--- a/messages/de.json
+++ b/messages/de.json
@@ -45,6 +45,7 @@
   "header_sign_out": "Abmelden",
   "trino_results_empty": "Keine Ergebnisse",
   "trino_query_error": "Abfragefehler",
+  "trino_query_connection_lost": "Verbindung zum Server verloren.",
   "trino_running": "Wird ausgeführt...",
   "trino_connection_url_placeholder": "https://trino.example.com:8443",
   "trino_editor_label": "SQL-Editor",
@@ -89,6 +90,7 @@
   "trino_table_type_view": "View",
   "trino_table_type_materialized_view": "Mat. View",
   "trino_catalog_refresh": "Katalog aktualisieren",
+  "trino_catalog_resize_handle": "Katalogbrowser-Breite anpassen",
   "trino_catalog_error": "Katalog konnte nicht geladen werden",
   "trino_catalog_load_children_error": "Laden fehlgeschlagen",
   "trino_view_in_trino": "In Trino anzeigen",
diff --git a/messages/en.json b/messages/en.json
index 55907765..a6ded56d 100644
--- a/messages/en.json
+++ b/messages/en.json
@@ -45,6 +45,7 @@
   "header_sign_out": "Sign out",
   "trino_results_empty": "No results",
   "trino_query_error": "Query error",
+  "trino_query_connection_lost": "Lost connection to the server.",
   "trino_running": "Running...",
   "trino_connection_url_placeholder": "https://trino.example.com:8443",
   "trino_editor_label": "SQL editor",
@@ -89,6 +90,7 @@
   "trino_table_type_view": "View",
   "trino_table_type_materialized_view": "Mat. view",
   "trino_catalog_refresh": "Refresh catalog",
+  "trino_catalog_resize_handle": "Resize catalog browser",
   "trino_catalog_error": "Failed to load catalog",
   "trino_catalog_load_children_error": "Failed to load",
   "trino_view_in_trino": "View in Trino",
diff --git a/src/lib/components/catalog/CatalogBrowser.svelte b/src/lib/components/catalog/CatalogBrowser.svelte
index f73931d8..4ce670a5 100644
--- a/src/lib/components/catalog/CatalogBrowser.svelte
+++ b/src/lib/components/catalog/CatalogBrowser.svelte
@@ -187,12 +187,18 @@
     const catalog = defaultCatalog;
     untrack(() => {
       if (catalog) {
-        loadSchemas(catalog).then((schemaNodes) => {
-          availableSchemas = schemaNodes.map((n) => n.name);
-          if (defaultSchema && !availableSchemas.includes(defaultSchema)) {
-            defaultSchema = '';
-          }
-        });
+        loadSchemas(catalog)
+          .then((schemaNodes) => {
+            availableSchemas = schemaNodes.map((n) => n.name);
+            if (defaultSchema && !availableSchemas.includes(defaultSchema)) {
+              defaultSchema = '';
+            }
+          })
+          .catch((err) => {
+            // Leave the dropdown empty rather than throwing an unhandled rejection.
+            console.error('Failed to load schemas for context selector', err);
+            availableSchemas = [];
+          });
       }
     });
   });
diff --git a/src/lib/components/catalog/CatalogTree.svelte b/src/lib/components/catalog/CatalogTree.svelte
index b9640542..68f05977 100644
--- a/src/lib/components/catalog/CatalogTree.svelte
+++ b/src/lib/components/catalog/CatalogTree.svelte
@@ -192,7 +192,7 @@
 
         {#if node.type === 'table' || node.type === 'view' || node.type === 'materialized_view'}
           <button
-            class="hover:text-primary truncate text-left hover:underline"
+            class="hover:text-primary min-w-0 truncate text-left hover:underline"
             onclick={(e) => {
               e.stopPropagation();
               handleInsert(node);
@@ -212,7 +212,7 @@
             {/if}
           </span>
         {:else}
-          <span class="truncate">{node.name}</span>
+          <span class="min-w-0 truncate">{node.name}</span>
         {/if}
 
         {#if leaf && node.dataType}
diff --git a/src/lib/components/storage/sidebar/ResizeHandle.svelte b/src/lib/components/storage/sidebar/ResizeHandle.svelte
index 325e0440..ebdec8c9 100644
--- a/src/lib/components/storage/sidebar/ResizeHandle.svelte
+++ b/src/lib/components/storage/sidebar/ResizeHandle.svelte
@@ -4,9 +4,11 @@
 
   interface Props {
     panel: ResizablePanel;
+    /** Accessible label for the handle. Defaults to the storage-sidebar label. */
+    label?: string;
   }
 
-  let { panel }: Props = $props();
+  let { panel, label }: Props = $props();
 </script>
 
 <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
@@ -14,7 +16,7 @@
 <div
   role="separator"
   aria-orientation="vertical"
-  aria-label={m.storage_sidebar_resize_handle()}
+  aria-label={label ?? m.storage_sidebar_resize_handle()}
   aria-valuenow={panel.width}
   aria-valuemin={panel.minWidth}
   aria-valuemax={panel.maxWidth}
diff --git a/src/lib/server/trino/client.test.ts b/src/lib/server/trino/client.test.ts
index f9bec305..358e2057 100644
--- a/src/lib/server/trino/client.test.ts
+++ b/src/lib/server/trino/client.test.ts
@@ -1,12 +1,15 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-// Empty env so importing client.ts does not build the env-configured singleton.
-vi.mock('$env/dynamic/private', () => ({ env: {} }));
+// Mutable mock env — empty by default so importing client.ts does not build the
+// env-configured singleton. Tests that need env vars populate it then re-import.
+// vi.hoisted ensures the object exists before the hoisted vi.mock factory runs.
+const { mockEnv } = vi.hoisted(() => ({ mockEnv: {} as Record<string, string | undefined> }));
+vi.mock('$env/dynamic/private', () => ({ env: mockEnv }));
 vi.mock('$lib/server/logging', () => ({
   logger: { child: () => ({ info: vi.fn(), warn: vi.fn(), debug: vi.fn() }) }
 }));
 
-import { TrinoClient } from './client.js';
+import { TrinoClient, trinoMetadataQuery } from './client.js';
 
 describe('TrinoClient X-Trino-User header', () => {
   let fetchMock: ReturnType<typeof vi.fn>;
@@ -42,3 +45,137 @@ describe('TrinoClient X-Trino-User header', () => {
     expect(submittedHeaders()['X-Trino-User']).toBe('anonymous');
   });
 });
+
+describe('TrinoClient.cancelViaUri', () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  it('sends a DELETE to the given nextUri', async () => {
+    const fetchMock = vi.fn(async () => ({ ok: true, status: 200, text: async () => '' }));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new TrinoClient({ serverUrl: 'http://trino:8080' });
+    const uri = 'http://trino:8080/v1/statement/executing/q1/slug/1';
+    await client.cancelViaUri(uri);
+    expect(fetchMock).toHaveBeenCalledWith(uri, expect.objectContaining({ method: 'DELETE' }));
+  });
+
+  it('forwards X-Trino-User when impersonating', async () => {
+    const fetchMock: ReturnType<typeof vi.fn> = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      text: async () => ''
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new TrinoClient({ serverUrl: 'http://trino:8080', authorization: 'Basic abc' });
+    await client.cancelViaUri('http://trino:8080/next', 'alice');
+    expect(fetchMock.mock.calls[0][1].headers['X-Trino-User']).toBe('alice');
+  });
+
+  it('omits X-Trino-User when impersonation is disabled', async () => {
+    const fetchMock: ReturnType<typeof vi.fn> = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      text: async () => ''
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new TrinoClient({
+      serverUrl: 'http://trino:8080',
+      authorization: 'Basic abc',
+      impersonate: false
+    });
+    await client.cancelViaUri('http://trino:8080/next', 'alice');
+    expect(fetchMock.mock.calls[0][1].headers).not.toHaveProperty('X-Trino-User');
+  });
+
+  it('does not throw when the URI is already gone (404/410)', async () => {
+    for (const status of [404, 410]) {
+      const fetchMock = vi.fn(async () => ({ ok: false, status, text: async () => '' }));
+      vi.stubGlobal('fetch', fetchMock);
+      const client = new TrinoClient({ serverUrl: 'http://trino:8080' });
+      await expect(client.cancelViaUri('http://trino:8080/next')).resolves.toBeUndefined();
+    }
+  });
+
+  it('throws on other non-ok responses', async () => {
+    const fetchMock = vi.fn(async () => ({ ok: false, status: 500, text: async () => 'boom' }));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new TrinoClient({ serverUrl: 'http://trino:8080' });
+    await expect(client.cancelViaUri('http://trino:8080/next')).rejects.toThrow(/500/);
+  });
+});
+
+describe('TrinoClient AbortSignal forwarding', () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  it('forwards the signal to fetch on submit', async () => {
+    const fetchMock: ReturnType<typeof vi.fn> = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({ id: 'q1' })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new TrinoClient({ serverUrl: 'http://trino:8080' });
+    const ac = new AbortController();
+    await client.submit('SELECT 1', { user: 'alice', signal: ac.signal });
+    expect(fetchMock.mock.calls[0][1].signal).toBe(ac.signal);
+  });
+
+  it('forwards the signal to fetch on poll', async () => {
+    const fetchMock: ReturnType<typeof vi.fn> = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({ id: 'q1' })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new TrinoClient({ serverUrl: 'http://trino:8080' });
+    const ac = new AbortController();
+    await client.poll('http://trino:8080/next', { signal: ac.signal });
+    expect(fetchMock.mock.calls[0][1].signal).toBe(ac.signal);
+  });
+});
+
+describe('trinoMetadataQuery (connection test path)', () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  it('resolves rows for a successful single-page query', async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({ id: 'q1', columns: [{ name: '_col0', type: 'integer' }], data: [[1]] })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new TrinoClient({ serverUrl: 'http://trino:8080' });
+    const { rows } = await trinoMetadataQuery(client, 'SELECT 1', { user: 'alice' });
+    expect(rows).toEqual([[1]]);
+  });
+
+  it('throws when the query returns an error (bad connection/credentials)', async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({ id: 'q1', error: { message: 'Access Denied' } })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    const client = new TrinoClient({ serverUrl: 'http://trino:8080' });
+    await expect(trinoMetadataQuery(client, 'SELECT 1', { user: 'alice' })).rejects.toThrow(
+      'Access Denied'
+    );
+  });
+});
+
+describe('resolveTrinoPublicUrl', () => {
+  afterEach(() => {
+    for (const key of Object.keys(mockEnv)) delete mockEnv[key];
+    vi.resetModules();
+  });
+
+  it('returns the trimmed public URL when configured', async () => {
+    mockEnv.STACKABLE_COCKPIT_TRINO_URL = 'http://internal:8080';
+    mockEnv.STACKABLE_COCKPIT_TRINO_PUBLIC_URL = 'https://public.example.com/';
+    vi.resetModules();
+    const mod = await import('./client.js');
+    expect(mod.resolveTrinoPublicUrl('user1')).toBe('https://public.example.com');
+  });
+
+  it('falls back to the server URL when no public URL is set', async () => {
+    mockEnv.STACKABLE_COCKPIT_TRINO_URL = 'http://internal:8080';
+    vi.resetModules();
+    const mod = await import('./client.js');
+    expect(mod.resolveTrinoPublicUrl('user1')).toBe('http://internal:8080');
+  });
+});
diff --git a/src/lib/server/trino/client.ts b/src/lib/server/trino/client.ts
index 8aac3765..f3787871 100644
--- a/src/lib/server/trino/client.ts
+++ b/src/lib/server/trino/client.ts
@@ -71,16 +71,12 @@ export class TrinoClient {
   /** POST /v1/statement — submit a new query. */
   async submit(
     sql: string,
-    options: { user: string; catalog?: string; schema?: string }
+    options: { user: string; catalog?: string; schema?: string; signal?: AbortSignal }
   ): Promise<TrinoQueryResult> {
     const headers: Record<string, string> = {
-      ...this.commonHeaders,
+      ...this.headersForUser(options.user),
       'Content-Type': 'text/plain'
     };
-    // Skip X-Trino-User only when not impersonating and Trino can fall back to the authenticated principal.
-    if (this.impersonate || !this.authenticated) {
-      headers['X-Trino-User'] = options.user;
-    }
     if (options.catalog) headers['X-Trino-Catalog'] = options.catalog;
     if (options.schema) headers['X-Trino-Schema'] = options.schema;
 
@@ -88,6 +84,7 @@ export class TrinoClient {
       method: 'POST',
       headers,
       body: sql,
+      signal: options.signal,
       // @ts-expect-error — Node fetch supports dispatcher via undici
       dispatcher: this.dispatcher
     });
@@ -101,10 +98,14 @@ export class TrinoClient {
   }
 
   /** GET nextUri — poll for the next page of results. */
-  async poll(nextUri: string): Promise<TrinoQueryResult> {
+  async poll(
+    nextUri: string,
+    opts: { user?: string; signal?: AbortSignal } = {}
+  ): Promise<TrinoQueryResult> {
     const res = await fetch(nextUri, {
       method: 'GET',
-      headers: this.commonHeaders,
+      headers: this.headersForUser(opts.user),
+      signal: opts.signal,
       // @ts-expect-error — Node fetch supports dispatcher via undici
       dispatcher: this.dispatcher
     });
@@ -117,11 +118,20 @@ export class TrinoClient {
     return res.json() as Promise<TrinoQueryResult>;
   }
 
+  /** commonHeaders plus X-Trino-User for the given user when impersonating. */
+  private headersForUser(user: string | undefined): Record<string, string> {
+    const headers = { ...this.commonHeaders };
+    if (user && (this.impersonate || !this.authenticated)) {
+      headers['X-Trino-User'] = user;
+    }
+    return headers;
+  }
+
   /** DELETE /v1/query/{queryId} — cancel a running query. */
-  async cancel(queryId: string): Promise<void> {
+  async cancel(queryId: string, user?: string): Promise<void> {
     const res = await fetch(`${this.serverUrl}/v1/query/${queryId}`, {
       method: 'DELETE',
-      headers: this.commonHeaders,
+      headers: this.headersForUser(user),
       // @ts-expect-error — Node fetch supports dispatcher via undici
       dispatcher: this.dispatcher
     });
@@ -132,6 +142,21 @@ export class TrinoClient {
       throw new Error(`Trino DELETE /v1/query failed (${res.status}): ${text}`);
     }
   }
+
+  /** DELETE nextUri — client-protocol cancel (no kill-query permission needed). */
+  async cancelViaUri(uri: string, user?: string): Promise<void> {
+    const res = await fetch(uri, {
+      method: 'DELETE',
+      headers: this.headersForUser(user),
+      // @ts-expect-error — Node fetch supports dispatcher via undici
+      dispatcher: this.dispatcher
+    });
+
+    if (!res.ok && res.status !== 404 && res.status !== 410) {
+      const text = await res.text().catch(() => '');
+      throw new Error(`Trino DELETE nextUri failed (${res.status}): ${text}`);
+    }
+  }
 }
 
 // --- Auth helper ---
@@ -144,6 +169,7 @@ export function buildBasicAuthHeader(username: string, password: string): string
 // --- Singleton & env config ---
 
 const trinoUrl = env.STACKABLE_COCKPIT_TRINO_URL;
+const trinoPublicUrl = env.STACKABLE_COCKPIT_TRINO_PUBLIC_URL;
 const authType = (env.STACKABLE_COCKPIT_TRINO_AUTH_TYPE ?? 'none') as 'none' | 'basic';
 const authUsername = env.STACKABLE_COCKPIT_TRINO_AUTH_USERNAME;
 const authPassword = env.STACKABLE_COCKPIT_TRINO_AUTH_PASSWORD;
@@ -189,6 +215,7 @@ if (trinoConfigured) {
   log.info(
     {
       trino_url: trinoUrl,
+      trino_public_url: trinoPublicUrl,
       auth_type: authType,
       tls_insecure: tlsInsecure,
       user_impersonation: trinoUserImpersonation
@@ -206,24 +233,34 @@ export function resolveTrinoClient(userId: string): TrinoClient | null {
   return getUserTrinoClient(userId);
 }
 
-/** Returns the Trino server URL for a user (for building UI links). */
+/** Returns the Trino server URL used for server-side queries. */
 export function resolveTrinoServerUrl(userId: string): string | null {
   if (trinoUrl) return trinoUrl.replace(/\/+$/, '');
   return getUserTrinoUrl(userId);
 }
 
+/** Public (browser-facing) Trino URL for UI deep links; falls back to the query URL. */
+export function resolveTrinoPublicUrl(userId: string): string | null {
+  if (trinoPublicUrl) return trinoPublicUrl.replace(/\/+$/, '');
+  return resolveTrinoServerUrl(userId);
+}
+
 // --- Metadata helper ---
 
+/** Save-time connection-test timeout. */
+export const CONN_TEST_TIMEOUT_MS = 10_000;
+
 /**
  * Submit a SQL query and drain all pages, returning columns and rows.
- * Used for simple metadata queries (catalog browser).
+ * An optional AbortSignal bounds the whole submit/poll run.
  */
 export async function trinoMetadataQuery(
   client: TrinoClient,
   sql: string,
-  options: { user: string; catalog?: string; schema?: string }
+  options: { user: string; catalog?: string; schema?: string },
+  signal?: AbortSignal
 ): Promise<{ columns: TrinoColumn[]; rows: unknown[][] }> {
-  let result = await client.submit(sql, options);
+  let result = await client.submit(sql, { ...options, signal });
 
   let columns: TrinoColumn[] = result.columns ?? [];
   const rows: unknown[][] = result.data ? [...result.data] : [];
@@ -233,7 +270,7 @@ export async function trinoMetadataQuery(
   }
 
   while (result.nextUri) {
-    result = await client.poll(result.nextUri);
+    result = await client.poll(result.nextUri, { user: options.user, signal });
 
     if (result.error) {
       throw new Error(result.error.message);
diff --git a/src/lib/server/trino/queries.ts b/src/lib/server/trino/queries.ts
index 0a717406..935bebcc 100644
--- a/src/lib/server/trino/queries.ts
+++ b/src/lib/server/trino/queries.ts
@@ -9,7 +9,7 @@ import {
   type QuerySnapshot,
   type QueryState
 } from '$lib/types/query.js';
-import { type TrinoClient, type TrinoQueryStats, resolveTrinoServerUrl } from './client.js';
+import { type TrinoClient, type TrinoQueryStats, resolveTrinoPublicUrl } from './client.js';
 import { collectResults } from './result-collector.js';
 
 const log = logger.child({ module: 'trino-queries' });
@@ -34,6 +34,7 @@ export interface TrinoQuery {
   nextUri: string | undefined;
   client: TrinoClient;
   userId: string;
+  trinoUser: string;
   completedAt: number | null;
 }
 
@@ -110,11 +111,11 @@ function getActiveQuery(userId: string, tabId: string): TrinoQuery | undefined {
 
 function buildSnapshot(
   query: TrinoQuery,
-  trinoServerUrl: string | null,
+  trinoPublicUrl: string | null,
   lightweight = false
 ): QuerySnapshot {
   return {
-    trinoQueryUrl: trinoServerUrl ? `${trinoServerUrl}/ui/query.html?${query.trinoQueryId}` : null,
+    trinoQueryUrl: trinoPublicUrl ? `${trinoPublicUrl}/ui/query.html?${query.trinoQueryId}` : null,
     state: query.state,
     progress: query.progress,
     columns: lightweight ? [] : query.columns,
@@ -169,6 +170,7 @@ async function submitStatement(
     nextUri: submitResult.nextUri,
     client,
     userId,
+    trinoUser: options.user,
     completedAt: null
   };
 
@@ -244,18 +246,18 @@ export function getQuerySnapshots(
   lightweight = false
 ): QuerySnapshot[] {
   touchTab(userId, tabId);
-  const trinoServerUrl = resolveTrinoServerUrl(userId);
-  return getTabQueries(userId, tabId).map((q) => buildSnapshot(q, trinoServerUrl, lightweight));
+  const trinoPublicUrl = resolveTrinoPublicUrl(userId);
+  return getTabQueries(userId, tabId).map((q) => buildSnapshot(q, trinoPublicUrl, lightweight));
 }
 
 /** Lightweight summaries without rows/columns — used for SSR to keep the payload small. */
 export function getAllQuerySummaries(userId: string): Record<string, QuerySnapshot[]> {
   const tabMap = userQueries.get(userId);
   if (!tabMap) return {};
-  const trinoServerUrl = resolveTrinoServerUrl(userId);
+  const trinoPublicUrl = resolveTrinoPublicUrl(userId);
   const result: Record<string, QuerySnapshot[]> = {};
   for (const [tabId, queries] of tabMap) {
-    result[tabId] = queries.map((q) => buildSnapshot(q, trinoServerUrl, true));
+    result[tabId] = queries.map((q) => buildSnapshot(q, trinoPublicUrl, true));
   }
   return result;
 }
@@ -283,7 +285,11 @@ export async function cancelQuery(userId: string, tabId: string): Promise<boolea
   );
 
   try {
-    await query.client.cancel(query.trinoQueryId);
+    if (query.nextUri) {
+      await query.client.cancelViaUri(query.nextUri, query.trinoUser);
+    } else {
+      await query.client.cancel(query.trinoQueryId, query.trinoUser);
+    }
   } catch (err) {
     log.warn({ err, trino_query_id: query.trinoQueryId }, 'failed to cancel query in Trino');
   }
diff --git a/src/lib/server/trino/result-collector.test.ts b/src/lib/server/trino/result-collector.test.ts
new file mode 100644
index 00000000..4fbf8131
--- /dev/null
+++ b/src/lib/server/trino/result-collector.test.ts
@@ -0,0 +1,83 @@
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('$env/dynamic/private', () => ({ env: {} }));
+vi.mock('$lib/server/logging', () => ({
+  logger: { child: () => ({ info: vi.fn(), warn: vi.fn(), debug: vi.fn(), error: vi.fn() }) }
+}));
+vi.mock('$lib/server/metrics.js', () => ({
+  trinoQueryTotal: { inc: vi.fn() },
+  trinoActiveQueries: { inc: vi.fn(), dec: vi.fn() }
+}));
+
+import { collectResults } from './result-collector.js';
+import { MAX_CLIENT_ROWS, INITIAL_PROGRESS } from '$lib/types/query.js';
+import type { TrinoQuery } from './queries.js';
+
+/** Just over half the limit, so two pages cross MAX_CLIENT_ROWS. */
+function page(): unknown[][] {
+  const count = Math.ceil(MAX_CLIENT_ROWS / 2) + 1;
+  return Array.from({ length: count }, () => [1]);
+}
+
+function makeQuery(client: Partial<TrinoQuery['client']>): TrinoQuery {
+  return {
+    trinoQueryId: 'q1',
+    state: 'RUNNING',
+    progress: INITIAL_PROGRESS,
+    columns: [],
+    rows: [],
+    error: null,
+    sql: 'SELECT * FROM big',
+    startedAt: 0,
+    nextUri: 'http://trino/next-1',
+    client: client as TrinoQuery['client'],
+    userId: 'u',
+    trinoUser: 'alice',
+    completedAt: null
+  };
+}
+
+describe('collectResults row limit', () => {
+  it('cancels via the live nextUri and finishes when MAX_CLIENT_ROWS is exceeded', async () => {
+    const cancelViaUri = vi.fn(async () => {});
+    const cancel = vi.fn(async () => {});
+    let call = 0;
+    const poll = vi.fn(async () => {
+      call++;
+      return {
+        id: 'q1',
+        data: page(),
+        nextUri: `http://trino/next-${call + 1}`,
+        stats: { state: 'RUNNING' }
+      };
+    });
+
+    const query = makeQuery({ poll, cancelViaUri, cancel });
+    await collectResults(query);
+
+    expect(cancelViaUri).toHaveBeenCalledWith('http://trino/next-3', 'alice');
+    expect(cancel).not.toHaveBeenCalled();
+    expect(query.error).toBe(`ROW_LIMIT:${MAX_CLIENT_ROWS}`);
+    expect(query.state).toBe('FINISHED');
+    expect(query.rows.length).toBeGreaterThanOrEqual(MAX_CLIENT_ROWS);
+  });
+
+  it('falls back to cancel(queryId) when the crossing page has no nextUri', async () => {
+    const cancelViaUri = vi.fn(async () => {});
+    const cancel = vi.fn(async () => {});
+    const poll = vi.fn(async () => ({
+      id: 'q1',
+      data: Array.from({ length: MAX_CLIENT_ROWS + 1 }, () => [1]),
+      nextUri: undefined,
+      stats: { state: 'RUNNING' }
+    }));
+
+    const query = makeQuery({ poll, cancelViaUri, cancel });
+    await collectResults(query);
+
+    expect(cancelViaUri).not.toHaveBeenCalled();
+    expect(cancel).toHaveBeenCalledWith('q1', 'alice');
+    expect(query.error).toBe(`ROW_LIMIT:${MAX_CLIENT_ROWS}`);
+    expect(query.state).toBe('FINISHED');
+  });
+});
diff --git a/src/lib/server/trino/result-collector.ts b/src/lib/server/trino/result-collector.ts
index beb540aa..841b7cb4 100644
--- a/src/lib/server/trino/result-collector.ts
+++ b/src/lib/server/trino/result-collector.ts
@@ -25,7 +25,7 @@ export async function collectResults(query: TrinoQuery): Promise<void> {
 
     let result;
     try {
-      result = await query.client.poll(nextUri);
+      result = await query.client.poll(nextUri, { user: query.trinoUser });
     } catch (err) {
       if (isTerminal(query.state)) return;
 
@@ -71,7 +71,11 @@ export async function collectResults(query: TrinoQuery): Promise<void> {
     if (query.rows.length >= MAX_CLIENT_ROWS) {
       query.error = `ROW_LIMIT:${MAX_CLIENT_ROWS}`;
       try {
-        await query.client.cancel(query.trinoQueryId);
+        if (result.nextUri) {
+          await query.client.cancelViaUri(result.nextUri, query.trinoUser);
+        } else {
+          await query.client.cancel(query.trinoQueryId, query.trinoUser);
+        }
       } catch (err) {
         log.warn({ err, trino_query_id: query.trinoQueryId }, 'failed to cancel after row limit');
       }
@@ -81,6 +85,7 @@ export async function collectResults(query: TrinoQuery): Promise<void> {
     }
 
     nextUri = result.nextUri;
+    query.nextUri = nextUri;
   }
 
   // All pages drained. Safe even if cancelled concurrently (terminateQuery
diff --git a/src/lib/server/trino/user-clients.ts b/src/lib/server/trino/user-clients.ts
index 24a75879..90a538f5 100644
--- a/src/lib/server/trino/user-clients.ts
+++ b/src/lib/server/trino/user-clients.ts
@@ -17,19 +17,23 @@ interface UserEntry {
 
 const userClients = new Map<string, UserEntry>();
 
-/** Create or replace the per-user Trino connection. */
-export function createUserTrinoClient(userId: string, config: UserConnectionConfig): void {
+/** Build a per-user Trino client from a connection config without storing it. */
+export function buildUserTrinoClient(config: UserConnectionConfig): TrinoClient {
   const authorization =
     config.authType === 'basic' && config.username && config.password
       ? buildBasicAuthHeader(config.username, config.password)
       : undefined;
 
-  const client = new TrinoClient({
+  return new TrinoClient({
     serverUrl: config.url,
     authorization,
     impersonate: trinoUserImpersonation
   });
+}
 
+/** Create or replace the per-user Trino connection. */
+export function createUserTrinoClient(userId: string, config: UserConnectionConfig): void {
+  const client = buildUserTrinoClient(config);
   userClients.set(userId, { client, url: config.url });
   log.info({ user_id: userId, trino_url: config.url }, 'user connection created');
 }
diff --git a/src/routes/(app)/trino/+page.server.ts b/src/routes/(app)/trino/+page.server.ts
index 38dcb714..1d7c1252 100644
--- a/src/routes/(app)/trino/+page.server.ts
+++ b/src/routes/(app)/trino/+page.server.ts
@@ -3,9 +3,17 @@ import { superValidate, message } from 'sveltekit-superforms';
 import { zod4 as zod } from 'sveltekit-superforms/adapters';
 import { getUserId } from '$lib/server/auth-utils.js';
 import { getAllQuerySummaries, cancelQuery } from '$lib/server/trino/queries.js';
-import { trinoConfigured } from '$lib/server/trino/client.js';
+import {
+  trinoConfigured,
+  trinoMetadataQuery,
+  CONN_TEST_TIMEOUT_MS
+} from '$lib/server/trino/client.js';
 import { completionEnabled } from '$lib/server/feature-flags.js';
-import { createUserTrinoClient, getUserTrinoClient } from '$lib/server/trino/user-clients.js';
+import {
+  buildUserTrinoClient,
+  createUserTrinoClient,
+  getUserTrinoClient
+} from '$lib/server/trino/user-clients.js';
 import { ConnectionSchema, type ConnectionMessage } from './validation.js';
 import type { Actions, PageServerLoad } from './$types';
 
@@ -34,20 +42,42 @@ export const actions: Actions = {
     }
 
     const userId = getUserId(locals);
+    const user = locals.user?.username ?? 'anonymous';
+    const { connectionUrl, authType, authUsername, authPassword } = form.data;
+    const config = {
+      url: connectionUrl,
+      authType,
+      username: authUsername,
+      password: authPassword
+    };
+
+    // Verify connectivity before storing the client or cancelling running queries.
+    try {
+      const testClient = buildUserTrinoClient(config);
+      await trinoMetadataQuery(
+        testClient,
+        'SELECT 1',
+        { user },
+        AbortSignal.timeout(CONN_TEST_TIMEOUT_MS)
+      );
+    } catch (err) {
+      const name = (err as { name?: string })?.name;
+      const reason =
+        name === 'TimeoutError' || name === 'AbortError'
+          ? 'Connection test timed out'
+          : 'Could not connect to Trino — check the URL and credentials.';
+      log.info({ err, trino_url: connectionUrl }, 'connection test failed');
+      return message(form, { type: 'error', message: reason } satisfies ConnectionMessage, {
+        status: 400
+      });
+    }
 
     // Cancel any running query before replacing the connection.
     for (const tabId of Object.keys(getAllQuerySummaries(userId))) {
       await cancelQuery(userId, tabId);
     }
 
-    const { connectionUrl, authType, authUsername, authPassword } = form.data;
-
-    createUserTrinoClient(userId, {
-      url: connectionUrl,
-      authType,
-      username: authUsername,
-      password: authPassword
-    });
+    createUserTrinoClient(userId, config);
 
     log.info({ trino_url: connectionUrl }, 'user connection saved');
     return message(form, { type: 'success' } satisfies ConnectionMessage);
diff --git a/src/routes/(app)/trino/+page.svelte b/src/routes/(app)/trino/+page.svelte
index 97db2496..d4c01c0c 100644
--- a/src/routes/(app)/trino/+page.svelte
+++ b/src/routes/(app)/trino/+page.svelte
@@ -5,6 +5,8 @@
   import * as m from '$lib/paraglide/messages.js';
   import MonacoEditor from '$lib/components/editor/MonacoEditor.svelte';
   import CatalogBrowser from '$lib/components/catalog/CatalogBrowser.svelte';
+  import ResizeHandle from '$lib/components/storage/sidebar/ResizeHandle.svelte';
+  import { createResizablePanel } from '$lib/components/storage/sidebar/resizable-panel.svelte.js';
   import Modal from '$lib/components/Modal.svelte';
   import { superForm } from 'sveltekit-superforms';
   import { ConnectionSchema, type ConnectionMessage } from './validation.js';
@@ -40,6 +42,14 @@
   let authPassword = $state('');
   let connectionOpen = $state(false);
 
+  // Drag-to-resize state for the desktop catalog browser panel (width persisted).
+  const catalogResize = createResizablePanel({
+    storageKey: 'trino_catalog_browser_width',
+    defaultWidth: 288, // matches the previous fixed w-72
+    minWidth: 240,
+    maxWidth: 560
+  });
+
   let sql = $state(tabStore.activeTab.sql);
   let defaultCatalog = $state('');
   let defaultSchema = $state('');
@@ -135,7 +145,8 @@
   const {
     enhance: connectionEnhance,
     errors: connectionErrors,
-    message: connectionMessage
+    message: connectionMessage,
+    submitting: connectionSubmitting
   } = superForm(
     untrack(() => data.connectionForm),
     {
@@ -405,31 +416,36 @@
 {/snippet}
 
 <div class="flex h-full gap-4">
-  <!-- Catalog browser panel (desktop) — always in DOM, collapses via width transition -->
-  <aside
-    class="
-      border-base-300 bg-base-100 hidden shrink-0 flex-col overflow-hidden rounded-xl
-      border transition-[width] duration-200 ease-out
-      lg:flex
-      {catalogBrowserOpen ? 'w-72' : 'invisible w-0 border-0'}"
-  >
-    <div
+  <!-- Wrapper positions the resize handle outside the aside's overflow-hidden. -->
+  <div class="relative hidden h-full shrink-0 lg:block">
+    <aside
       class="
-        border-base-300 flex w-72 items-center justify-between border-b px-3
-        py-2
-      "
+        border-base-300 bg-base-100 flex h-full flex-col overflow-hidden rounded-xl
+        border ease-out
+        {catalogResize.isDragging ? '' : 'transition-[width] duration-200'}
+        {catalogBrowserOpen ? '' : 'invisible border-0'}"
+      style="width: {catalogBrowserOpen ? catalogResize.width : 0}px"
     >
-      <span class="text-base-content/60 text-sm font-medium">{m.trino_catalog_browser()}</span>
-    </div>
-    <div class="w-72">
-      <CatalogBrowser
-        connectionVersion={catalogVersion}
-        bind:defaultCatalog
-        bind:defaultSchema
-        onInsert={(name) => monacoEditor?.insertAtCursor(name)}
-      />
-    </div>
-  </aside>
+      <!-- Fixed open width so content doesn't reflow while the aside animates to 0. -->
+      <div
+        class="border-base-300 flex items-center justify-between border-b px-3 py-2"
+        style="width: {catalogResize.width}px"
+      >
+        <span class="text-base-content/60 text-sm font-medium">{m.trino_catalog_browser()}</span>
+      </div>
+      <div class="min-h-0 flex-1" style="width: {catalogResize.width}px">
+        <CatalogBrowser
+          connectionVersion={catalogVersion}
+          bind:defaultCatalog
+          bind:defaultSchema
+          onInsert={(name) => monacoEditor?.insertAtCursor(name)}
+        />
+      </div>
+    </aside>
+    {#if catalogBrowserOpen}
+      <ResizeHandle panel={catalogResize} label={m.trino_catalog_resize_handle()} />
+    {/if}
+  </div>
 
   <!-- Mobile catalog browser overlay -->
   <Modal
@@ -454,15 +470,18 @@
           {@render closeIcon()}
         </button>
       </div>
-      <CatalogBrowser
-        connectionVersion={catalogVersion}
-        bind:defaultCatalog
-        bind:defaultSchema
-        onInsert={(name) => {
-          monacoEditor?.insertAtCursor(name);
-          mobileCatalogOpen = false;
-        }}
-      />
+      <!-- Bounded height so the tree scrolls. -->
+      <div class="min-h-0 flex-1">
+        <CatalogBrowser
+          connectionVersion={catalogVersion}
+          bind:defaultCatalog
+          bind:defaultSchema
+          onInsert={(name) => {
+            monacoEditor?.insertAtCursor(name);
+            mobileCatalogOpen = false;
+          }}
+        />
+      </div>
     </div>
   </Modal>
 
@@ -581,7 +600,10 @@
 
             <!-- Save button -->
             <div class="flex justify-end">
-              <button type="submit" class="btn btn-sm btn-primary">
+              <button type="submit" class="btn btn-sm btn-primary" disabled={$connectionSubmitting}>
+                {#if $connectionSubmitting}
+                  <span class="loading loading-spinner loading-xs"></span>
+                {/if}
                 {m.trino_save_connection()}
               </button>
             </div>
@@ -845,6 +867,9 @@
                 {stateBadgeClass}">{stateLabel}</span
             >
           {/if}
+          {#if runner.state === 'FAILED' && runner.error}
+            <span class="text-error text-xs" role="alert">{runner.error}</span>
+          {/if}
           {#if runner.state === 'RUNNING'}
             <span class="text-base-content/60 text-xs tabular-nums"
               >{Math.round(runner.progress.progressPercentage)}%</span
diff --git a/src/routes/(app)/trino/query-runner.svelte.ts b/src/routes/(app)/trino/query-runner.svelte.ts
index af6da899..20222783 100644
--- a/src/routes/(app)/trino/query-runner.svelte.ts
+++ b/src/routes/(app)/trino/query-runner.svelte.ts
@@ -8,6 +8,7 @@ import {
 } from '$lib/types/query.js';
 import type { SqlStatement } from '$lib/editor/split-statements.js';
 import { clearCompletionCache } from '$lib/editor/completion/completion-metadata.js';
+import * as m from '$lib/paraglide/messages.js';
 
 export { INITIAL_PROGRESS, type QueryState, type QueryProgress } from '$lib/types/query.js';
 export type { ScriptProgress } from '$lib/types/query.js';
@@ -18,6 +19,7 @@ export interface QueryRunner {
   readonly results: QuerySnapshot[];
   readonly scriptProgress: ScriptProgress | null;
   readonly currentTrinoQueryUrl: string | null;
+  readonly error: string | null;
   executeScript: (
     statements: SqlStatement[],
     options?: { catalog?: string; schema?: string }
@@ -42,6 +44,7 @@ function createQueryRunner(tabId: string): QueryRunner {
   let results = $state.raw<QuerySnapshot[]>([]);
   let scriptProgress = $state<ScriptProgress | null>(null);
   let currentTrinoQueryUrl = $state<string | null>(null);
+  let error = $state<string | null>(null);
 
   let totalStatements = 0;
   let polling = false;
@@ -58,6 +61,7 @@ function createQueryRunner(tabId: string): QueryRunner {
     results = [];
     scriptProgress = null;
     currentTrinoQueryUrl = null;
+    error = null;
     totalStatements = 0;
     stopPolling();
   }
@@ -108,6 +112,7 @@ function createQueryRunner(tabId: string): QueryRunner {
         const res = await fetch(`/api/trino/query?tabId=${encodeURIComponent(tabId)}`, { signal });
 
         if (!res.ok) {
+          error = m.trino_query_connection_lost();
           state = 'FAILED';
           stopPolling();
           return;
@@ -149,6 +154,7 @@ function createQueryRunner(tabId: string): QueryRunner {
       } catch (err) {
         if (signal.aborted) return;
         console.error('Query poll failed', err);
+        error = m.trino_query_connection_lost();
         state = 'FAILED';
         stopPolling();
         return;
@@ -193,6 +199,7 @@ function createQueryRunner(tabId: string): QueryRunner {
       if (!res.ok) {
         const body = await res.json().catch(() => null);
         console.error('Query submit failed', body?.error ?? `HTTP ${res.status}`);
+        error = body?.error ?? m.trino_query_connection_lost();
         state = 'FAILED';
         return;
       }
@@ -200,6 +207,7 @@ function createQueryRunner(tabId: string): QueryRunner {
       state = 'QUEUED';
       pollStatus();
     } catch {
+      error = m.trino_query_connection_lost();
       state = 'FAILED';
     }
   }
@@ -275,6 +283,9 @@ function createQueryRunner(tabId: string): QueryRunner {
     get currentTrinoQueryUrl() {
       return currentTrinoQueryUrl;
     },
+    get error() {
+      return error;
+    },
     executeScript,
     cancel,
     reset,