Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

Keep phone guest names separate from backup controls and locks

pulse-triage[bot]aff24f6dbc7d
diff --git a/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md b/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md
index ef8be3984f..6bd98740cc 100644
--- a/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md
+++ b/docs/release-control/v6/internal/HIGH_RISK_RELEASE_VERIFICATION_MATRIX.md
@@ -8,6 +8,20 @@ A gate is only `passed` when its automated proof still passes and the manual
scenario has been exercised in a staging-like environment with the expected
result.
+## Workloads locked-guest identity on phones
+
+Automated: `GuestRow.test.tsx` lock-label cases and
+`frontend-modern/browser-tests/guest-row-lock-identity.cjs` after precompiling
+with `node browser-tests/build-guest-row-lock-fixture.mjs --with-parent --parent <full-parent-SHA>`. The parent
+row is the exact own-parent source, not a replay of a terminated preview. Inspect the real
+name, status/backup indicator, full lock and visible memory-freshness cue at
+320 and 390 px in light/dark bars and sparklines. The backup evidence control sits below the name on phones without shrinking
+its touch target; the lock remains separately visible. Long locks wrap inside the identity cell and long names retain their full title.
+Check that desktop keyboard Enter and the first phone touch open the same guest,
+that drawer safety copy stays intact, and that lock transitions on the same row
+do not renew the original memory timestamp. Wider rows keep their inline layout.
+This fixture uses synthetic data, not installed/native guest recovery proof.
+
## Workloads memory observation presentation
Automated: `GuestRow.test.tsx` (memory observation provenance),
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
index d79ce3fffc..4d5684a764 100644
--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md
+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
@@ -20,6 +20,28 @@
## Purpose
+### Narrow Workloads identity during guest locks
+
+In narrow and phone layouts, the guest name and status occupy the first line;
+the unchanged backup evidence control moves below the name, retaining its
+44 px touch target. The guest lock occupies a separate, wrapping line below
+that identity. It must not consume the name's
+horizontal space or spill into the adjacent metrics. The full lock remains
+visible; a long name keeps its full title and existing truncation. Wider layouts
+keep the inline lock. Disclosure, first-touch row activation and memory
+observation source/time are unchanged. This is presentation only: a backup lock
+or successful backup never proves guest recovery.
+
+`GuestRow.test.tsx` checks layout structure, lock updates and existing action
+ownership. `browser-tests/build-guest-row-lock-fixture.mjs` compiles the real row,
+stylesheet and drawer before bounded static browser execution. Use
+`node browser-tests/build-guest-row-lock-fixture.mjs --with-parent --parent <full-parent-SHA>`
+to read the exact parent row from Git; no manually supplied control is accepted.
+`browser-tests/guest-row-lock-identity.cjs` measures the rendered name/lock at 320 and 390 px in bars and sparklines, and exercises keyboard/first
+touch through the existing drawer, checks long-name bounds, and rejects the current
+parent with the same static fixture. No dev compiler or old terminated preview
+is replayed. Native recovery remains separate.
+
### Confirmed operations opt out of silent transport fallback
The shared API client accepts expectedOrgID and retry:false for confirmed
diff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
index 0079c57c59..7641da0d28 100644
--- a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
+++ b/docs/release-control/v6/internal/subsystems/performance-and-scalability.md
@@ -15,6 +15,28 @@
## Purpose
+### Narrow Workloads identity during guest locks
+
+In narrow and phone layouts, the guest name and status occupy the first line;
+the unchanged backup evidence control moves below the name, retaining its
+44 px touch target. The guest lock occupies a separate, wrapping line below
+that identity. It must not consume the name's
+horizontal space or spill into the adjacent metrics. The full lock remains
+visible; a long name keeps its full title and existing truncation. Wider layouts
+keep the inline lock. Disclosure, first-touch row activation and memory
+observation source/time are unchanged. This is presentation only: a backup lock
+or successful backup never proves guest recovery.
+
+`GuestRow.test.tsx` checks layout structure, lock updates and existing action
+ownership. `browser-tests/build-guest-row-lock-fixture.mjs` compiles the real row,
+stylesheet and drawer before bounded static browser execution. Use
+`node browser-tests/build-guest-row-lock-fixture.mjs --with-parent --parent <full-parent-SHA>`
+to read the exact parent row from Git; no manually supplied control is accepted.
+`browser-tests/guest-row-lock-identity.cjs` measures the rendered name/lock at 320 and 390 px in bars and sparklines, and exercises keyboard/first
+touch through the existing drawer, checks long-name bounds, and rejects the current
+parent with the same static fixture. No dev compiler or old terminated preview
+is replayed. Native recovery remains separate.
+
**Memory freshness is preserved at the Workloads row boundary.**
`GuestRow.tsx` qualifies selected memory once per reactive reading using the
diff --git a/frontend-modern/browser-tests/build-guest-row-lock-fixture.mjs b/frontend-modern/browser-tests/build-guest-row-lock-fixture.mjs
new file mode 100644
index 0000000000..40447f29dc
--- /dev/null
+++ b/frontend-modern/browser-tests/build-guest-row-lock-fixture.mjs
@@ -0,0 +1,110 @@
+// Compile the existing real-row/drawer fixture once, before bounded browser execution.
+// No dev compiler, App, guest request or installer runs inside the browser tree.
+import { build } from 'vite';
+import solid from 'vite-plugin-solid';
+import tailwindcss from '@tailwindcss/vite';
+import { stop } from 'esbuild';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { execFileSync } from 'node:child_process';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const output = path.resolve(root, '../tmp/guest-row-lock-static');
+const row = path.join(root, 'src/components/Workloads/GuestRow.tsx');
+const parentRow = path.join(output, 'parent-row.tsx');
+const hash = (data) => crypto.createHash('sha256').update(data).digest('hex');
+const parentOnly = process.argv.includes('--with-parent');
+const parentIndex = process.argv.indexOf('--parent');
+const parentSha = parentIndex < 0 ? undefined : process.argv[parentIndex + 1];
+if (parentOnly) {
+ if (!/^[a-f0-9]{40}$/.test(parentSha ?? '')) {
+ throw new Error('--with-parent requires --parent <exact 40-character parent SHA>');
+ }
+ fs.mkdirSync(output, { recursive: true });
+ fs.writeFileSync(
+ parentRow,
+ execFileSync(
+ 'git',
+ ['show', `${parentSha}:frontend-modern/src/components/Workloads/GuestRow.tsx`],
+ { cwd: root },
+ ),
+ );
+}
+
+try {
+ for (const variant of parentOnly ? ['parent', 'final'] : ['final']) {
+ const sources = {};
+ const artifacts = {};
+ const outDir = path.join(output, variant);
+ await build({
+ root,
+ // Both variants are served below their own prefix, including nested HTML.
+ base: './',
+ configFile: false,
+ publicDir: false,
+ plugins: [
+ {
+ name: 'exact-guest-row-fixture-binding',
+ enforce: 'pre',
+ load(id) {
+ if (variant === 'parent' && id === row) return fs.readFileSync(parentRow, 'utf8');
+ },
+ generateBundle(_options, bundle) {
+ for (const id of this.getModuleIds()) {
+ if (!id.startsWith(root + '/') || id.includes('/node_modules/')) continue;
+ const file = id.split('?')[0];
+ if (!fs.existsSync(file) || !fs.statSync(file).isFile()) continue;
+ sources[path.relative(root, file)] = hash(
+ fs.readFileSync(variant === 'parent' && file === row ? parentRow : file),
+ );
+ }
+ for (const [file, asset] of Object.entries(bundle)) {
+ artifacts[file] = hash(asset.type === 'chunk' ? asset.code : asset.source);
+ }
+ },
+ },
+ tailwindcss(),
+ solid(),
+ ],
+ resolve: {
+ alias: { '@': path.join(root, 'src') },
+ conditions: ['import', 'browser', 'default'],
+ },
+ build: {
+ // Match the application's declared target, not Vite's older default.
+ target: 'esnext',
+ outDir,
+ emptyOutDir: true,
+ rollupOptions: { input: path.join(root, 'browser-tests/guest-row-memory-provenance.html') },
+ },
+ });
+ // Hash the bytes actually written, including HTML post-processing.
+ const walk = (dir) => {
+ for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+ const file = path.join(dir, entry.name);
+ if (entry.isDirectory()) walk(file);
+ else artifacts[path.relative(outDir, file)] = hash(fs.readFileSync(file));
+ }
+ };
+ walk(outDir);
+ fs.writeFileSync(
+ path.join(outDir, 'binding.json'),
+ JSON.stringify(
+ {
+ variant,
+ ...(variant === 'parent' ? { parent_sha: parentSha } : {}),
+ graph: hash(fs.readFileSync(path.join(root, 'package-lock.json'))),
+ builder: hash(fs.readFileSync(fileURLToPath(import.meta.url))),
+ sources,
+ artifacts,
+ },
+ null,
+ 2,
+ ) + '\n',
+ );
+ }
+} finally {
+ stop();
+}
diff --git a/frontend-modern/browser-tests/guest-row-lock-identity.cjs b/frontend-modern/browser-tests/guest-row-lock-identity.cjs
new file mode 100644
index 0000000000..d4982dc0d2
--- /dev/null
+++ b/frontend-modern/browser-tests/guest-row-lock-identity.cjs
@@ -0,0 +1,341 @@
+// Precompiled production GuestRow/CSS/drawer fixture, not a live guest or full App.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { chromium, webkit } = require('playwright');
+const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const root = '/workspace/frontend-modern';
+const output = '/workspace/tmp/guest-row-lock-identity';
+const compiled = '/workspace/tmp/guest-row-lock-static';
+const http = require('node:http');
+const origin = 'http://127.0.0.1:5334';
+fs.mkdirSync(output, { recursive: true });
+const result = {
+ result: 'incomplete',
+ playwright: require('playwright/package.json').version,
+ binding: {
+ builder: hash(root + '/browser-tests/build-guest-row-lock-fixture.mjs'),
+ runtime: hash(root + '/src/components/Workloads/GuestRow.tsx'),
+ stylesheet: hash(root + '/src/index.css'),
+ fixture: hash(root + '/browser-tests/guest-row-memory-provenance.tsx'),
+ script: hash(root + '/browser-tests/guest-row-lock-identity.cjs'),
+ graph: hash(root + '/package-lock.json'),
+ },
+ cases: [],
+ captures: [],
+ cleanup: {},
+ limits:
+ 'Production GuestRow, source stylesheet, actual drawer and existing synthetic memory/History fixture in a precompiled static bundle. No full App or production-build browser claim, native QGA, thaw/writes/liveness/restoration, installed/release/reporter or physical-device acceptance.',
+};
+assert.equal(
+ result.playwright,
+ JSON.parse(fs.readFileSync('/workspace/tests/integration/package-lock.json')).packages[
+ 'node_modules/@playwright/test'
+ ].version,
+);
+(async () => {
+ const bindings = {};
+ for (const variant of ['parent', 'final']) {
+ const dir = path.join(compiled, variant);
+ const binding = JSON.parse(fs.readFileSync(path.join(dir, 'binding.json')));
+ assert.equal(binding.graph, hash(root + '/package-lock.json'));
+ assert.equal(binding.builder, hash(root + '/browser-tests/build-guest-row-lock-fixture.mjs'));
+ for (const [file, digest] of Object.entries(binding.artifacts))
+ assert.equal(hash(path.join(dir, file)), digest, 'served artifact matches compiler output');
+ for (const [file, digest] of Object.entries(binding.sources))
+ assert.equal(
+ hash(
+ variant === 'parent' && file === 'src/components/Workloads/GuestRow.tsx'
+ ? path.join(compiled, 'parent-row.tsx')
+ : path.join(root, file),
+ ),
+ digest,
+ 'every imported source byte matches its binding',
+ );
+ bindings[variant] = binding;
+ }
+ result.compiled = bindings;
+ const server = http.createServer((req, res) => {
+ const pathname = new URL(req.url, origin).pathname;
+ const file = path.resolve(compiled, '.' + pathname);
+ if (!file.startsWith(compiled + '/') || !fs.existsSync(file) || !fs.statSync(file).isFile()) {
+ res.writeHead(404);
+ res.end();
+ return;
+ }
+ const ext = path.extname(file);
+ res.setHeader(
+ 'Content-Type',
+ ext === '.html'
+ ? 'text/html'
+ : ext === '.js'
+ ? 'application/javascript'
+ : ext === '.css'
+ ? 'text/css'
+ : 'application/octet-stream',
+ );
+ res.end(fs.readFileSync(file));
+ });
+ await new Promise((resolve, reject) => {
+ server.once('error', reject);
+ server.listen(5334, '127.0.0.1', resolve);
+ });
+ let browser;
+ try {
+ for (const [name, engine, width, dark] of [
+ ['parent-control', webkit, 320, false],
+ ['narrow-light', webkit, 320, false],
+ ['phone-dark', webkit, 390, true],
+ ['narrow-dark-chromium', chromium, 320, true],
+ ['phone-light-chromium', chromium, 390, false],
+ ['desktop-light', chromium, 1365, false],
+ ['desktop-dark', chromium, 1365, true],
+ ]) {
+ browser = await engine.launch(
+ engine === chromium
+ ? { headless: true, channel: 'chromium', args: ['--no-sandbox'] }
+ : { headless: true },
+ );
+ const context = await browser.newContext({
+ viewport: { width, height: width <= 768 ? 844 : 900 },
+ isMobile: width <= 768,
+ hasTouch: width <= 768,
+ locale: 'en-GB',
+ timezoneId: 'UTC',
+ reducedMotion: 'reduce',
+ });
+ const page = await context.newPage();
+ page.setDefaultTimeout(7000);
+ const record = {
+ name,
+ width,
+ dark,
+ browser: browser.version(),
+ checks: [],
+ errors: [],
+ requests: [],
+ };
+ result.cases.push(record);
+ page.on('pageerror', (error) => record.errors.push(error.message));
+ page.on('response', (response) => {
+ if (response.status() >= 400) record.errors.push(`${response.status()} ${response.url()}`);
+ });
+ await page.route('**/*', (route) => {
+ const url = new URL(route.request().url());
+ assert.equal(url.origin, origin, 'no external access');
+ if (!url.pathname.startsWith('/api/')) return route.continue();
+ assert.equal(route.request().method(), 'GET');
+ assert(!/diagnostics|\/run|guest-agent|qemu/.test(url.pathname));
+ record.requests.push(url.pathname);
+ return route.fulfill({
+ json: { success: true, data: [], alerts: [], anomalies: [], config: null },
+ });
+ });
+ await page.addInitScript(
+ (value) =>
+ document.addEventListener('DOMContentLoaded', () =>
+ document.documentElement.classList.toggle('dark', value),
+ ),
+ dark,
+ );
+ await page.goto(
+ origin +
+ (name === 'parent-control' ? '/parent' : '/final') +
+ '/browser-tests/guest-row-memory-provenance.html',
+ {
+ timeout: 10000,
+ waitUntil: 'domcontentloaded',
+ },
+ );
+ const row = page.locator('[data-guest-id="fixture:pve1:101"]');
+ const cell = row.locator('[data-workload-col="name"]');
+ const notice = row.locator('[data-workload-memory-read-status]');
+ await notice.waitFor();
+ const identity = await row.elementHandle();
+ const capture = async (state) => {
+ const file = `${name}-${state}.png`;
+ await page.screenshot({ path: path.join(output, file), fullPage: true });
+ result.captures.push({ file, sha256: hash(path.join(output, file)) });
+ };
+ const geometry = async (guestName = 'backup-guest', lock = 'backup') =>
+ cell.evaluate(
+ (cell, values) => {
+ const name = [...cell.querySelectorAll('[title]')].find(
+ (el) => el.title === values.guestName,
+ );
+ const badge = [...cell.querySelectorAll('[title]')].find(
+ (el) => el.title === `Guest is locked (${values.lock})`,
+ );
+ const box = (el) => {
+ const r = el.getBoundingClientRect();
+ return {
+ x: r.x,
+ y: r.y,
+ width: r.width,
+ height: r.height,
+ right: r.right,
+ bottom: r.bottom,
+ };
+ };
+ return {
+ cell: box(cell),
+ name: box(name),
+ nameWidth: name.clientWidth,
+ nameScrollWidth: name.scrollWidth,
+ lock: box(badge),
+ lockWidth: badge.clientWidth,
+ lockScrollWidth: badge.scrollWidth,
+ };
+ },
+ { guestName, lock },
+ );
+ const g = await geometry();
+ record.geometry = g;
+ await capture('backup-bars');
+ if (name === 'parent-control') {
+ assert(g.nameWidth < g.nameScrollWidth - 1, 'current parent reproduces clipped guest name');
+ record.checks.push('same static fixture rejects current parent: ordinary name clipped');
+ await context.close();
+ await browser.close();
+ browser = undefined;
+ record.closed = true;
+ continue;
+ }
+ assert(g.nameWidth >= g.nameScrollWidth - 1, 'ordinary guest name remains readable');
+ assert(
+ g.lock.x >= g.cell.x && g.lock.right <= g.cell.right + 1,
+ 'complete lock fits its cell',
+ );
+ assert(g.lockScrollWidth <= g.lockWidth + 1, 'lock is not clipped');
+ if (width <= 768)
+ assert(g.lock.y >= g.name.bottom, 'lock is below, not competing with identity');
+ assert((await notice.textContent()).includes('Not a current measurement'));
+ assert((await notice.locator('.sr-only').textContent()).includes('2026-09-30 11:00:00 UTC'));
+ assert(
+ await notice
+ .locator('[aria-hidden="true"]')
+ .getByText(width <= 768 ? 'Prior' : 'Last known', { exact: true })
+ .isVisible(),
+ );
+ record.checks.push(
+ 'ordinary name, full backup lock and original memory freshness fit without hover',
+ );
+ await page.getByLabel('Metric display').selectOption('sparklines');
+ await row
+ .getByRole('img', { name: 'backup-guest memory history, last known 25%', exact: true })
+ .waitFor();
+ assert.equal((await geometry()).nameWidth, g.nameWidth);
+ if (name === 'phone-dark') await capture('backup-sparkline');
+ record.checks.push(
+ 'sparkline mode retains the same readable identity/lock and last-known value',
+ );
+ await page.getByLabel('Metric display').selectOption('bars');
+ const backupControl = cell.getByRole('button', { name: 'No backup found', exact: true });
+ const backupBounds = await backupControl.boundingBox();
+ assert(backupBounds.width >= 44 || width > 768, 'phone backup target retains 44 px width');
+ assert(backupBounds.height >= 44 || width > 768, 'phone backup target retains 44 px height');
+ assert(backupBounds.x >= g.cell.x && backupBounds.x + backupBounds.width <= g.cell.right + 1);
+ if (width <= 768) await backupControl.tap();
+ else await backupControl.click();
+ const backupDialog = page.getByRole('dialog', {
+ name: 'Backup status details for backup-guest',
+ exact: true,
+ });
+ await backupDialog.waitFor();
+ assert((await backupDialog.textContent()).includes('No completed backup found'));
+ assert.equal(await page.getByRole('region', { name: 'Guest details' }).count(), 0);
+ if (name === 'narrow-light') await capture('backup-evidence-dialog');
+ await backupDialog.getByRole('button', { name: 'Close backup details', exact: true }).click();
+ record.checks.push(
+ 'backup control retains its touch target and opens only same-guest completion evidence',
+ );
+ if (width <= 768) await cell.getByText('backup-guest', { exact: true }).tap();
+ else {
+ await page.getByLabel('Metric display').focus();
+ for (let i = 0; i < 2; i++) await page.keyboard.press('Tab');
+ assert(
+ await row
+ .getByRole('button', { name: 'Expand backup-guest', exact: true })
+ .evaluate((el) => document.activeElement === el),
+ );
+ await page.keyboard.press('Enter');
+ }
+ const details = page.getByRole('region', { name: 'Guest details' });
+ await details.waitFor();
+ assert((await details.getByText('backup-guest', { exact: true }).count()) > 0);
+ const precaution = await details.getByTestId('guest-read-precaution').textContent();
+ assert(precaution.includes('Do not run live diagnostics or restart the guest agent'));
+ assert(precaution.includes('An OK backup or a running VM does not prove thaw'));
+ assert(
+ precaution.includes(
+ 'Confirm thaw and writes to the filesystems covered by the backup independently',
+ ),
+ );
+ assert((await details.textContent()).includes('Last known'));
+ if (name === 'phone-dark') await capture('same-guest-drawer');
+ await details
+ .getByRole('button', { name: 'Collapse backup-guest details', exact: true })
+ .click();
+ assert.equal(await details.count(), 0);
+ record.checks.push(
+ 'first touch or real keyboard Enter opens the same guest and preserves recovery precaution; collapse works',
+ );
+ await page.evaluate(() =>
+ window.__memoryRow.update({
+ name: 'long-backup-guest-identity-101',
+ lock: 'snapshot-delete',
+ backupInProgress: true,
+ }),
+ );
+ const long = await geometry('long-backup-guest-identity-101', 'snapshot-delete');
+ assert(long.name.width > 20, 'long identity must not disappear');
+ if (width <= 768) {
+ assert(
+ long.nameScrollWidth > long.nameWidth,
+ 'long phone name truncates with its full title',
+ );
+ }
+ assert(
+ long.lock.right <= long.cell.right + 1 && long.lockScrollWidth <= long.lockWidth + 1,
+ 'long lock wraps inside identity cell',
+ );
+ if (name === 'narrow-light') await capture('long-identity-lock');
+ record.longGeometry = long;
+ await page.evaluate(() =>
+ window.__memoryRow.update({
+ name: 'backup-guest',
+ lock: '',
+ backupInProgress: false,
+ lastSeen: '2026-10-06T10:00:00Z',
+ }),
+ );
+ assert.equal(await cell.locator('[title^="Guest is locked"]').count(), 0);
+ assert((await notice.textContent()).includes('2026-09-30 11:00:00 UTC'));
+ assert(await identity.evaluate((el) => el.isConnected));
+ assert(await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth));
+ assert.deepEqual(record.errors, []);
+ record.checks.push(
+ 'same mounted row updates/removes locks without renewing memory; long identity stays titled, no page overflow/errors',
+ );
+ await context.close();
+ await browser.close();
+ browser = undefined;
+ record.closed = true;
+ }
+ result.result = 'passed';
+ } catch (error) {
+ result.error = error.message;
+ throw error;
+ } finally {
+ if (browser) await browser.close();
+ result.cleanup.browser_closed = true;
+ await new Promise((resolve) => server.close(resolve));
+ result.cleanup.compiler_not_started = true;
+ result.cleanup.server_closed = true;
+ fs.writeFileSync(output + '/result.json', JSON.stringify(result, null, 2));
+ }
+})().catch((error) => {
+ console.error(error);
+ process.exitCode = 1;
+});
diff --git a/frontend-modern/src/components/Workloads/GuestRow.tsx b/frontend-modern/src/components/Workloads/GuestRow.tsx
index 18bcd14244..7b09f1bcee 100644
--- a/frontend-modern/src/components/Workloads/GuestRow.tsx
+++ b/frontend-modern/src/components/Workloads/GuestRow.tsx
@@ -350,51 +350,60 @@ export function GuestRow(props: GuestRowProps) {
onPreviewClear={() => props.onHoverChange?.(null)}
/>
</Show>
- <div class="flex items-center gap-1.5 min-w-0">
- <StatusDot
- variant={guestStatus().variant}
- title={guestStatus().label}
- ariaLabel={guestStatus().label}
- size="xs"
- />
- <div class="flex items-center gap-1.5 min-w-0 group/name">
- <ResourceNameWithWebInterfaceLink
- name={props.guest.name}
- url={customUrl()}
- class={`min-w-0 ${usesCondensedIdentity() ? '[&>a]:hidden' : ''}`}
- nameClass="truncate text-[11px] font-medium text-base-content select-none"
+ <div
+ class={`min-w-0 ${usesCondensedIdentity() ? 'flex flex-1 flex-col items-start gap-0.5' : 'flex items-center gap-2'}`}
+ >
+ <div
+ class={`flex items-center gap-1.5 min-w-0 ${usesCondensedIdentity() ? 'w-full' : ''}`}
+ >
+ <StatusDot
+ variant={guestStatus().variant}
+ title={guestStatus().label}
+ ariaLabel={guestStatus().label}
+ size="xs"
+ class={usesCondensedIdentity() ? 'self-start mt-1.5' : undefined}
/>
- {/* Show backup indicator in name cell only if backup column is hidden */}
- <Show when={!isColVisible('backup') && supportsBackup()}>
- <BackupIndicator
- guestName={props.guest.name}
- lastBackup={props.guest.lastBackup}
- isTemplate={props.guest.template}
- backupRunning={props.guest.backupInProgress}
+ <div
+ class={`min-w-0 group/name ${usesCondensedIdentity() ? 'flex flex-1 flex-col items-start gap-0.5' : 'flex items-center gap-1.5'}`}
+ >
+ <ResourceNameWithWebInterfaceLink
+ name={props.guest.name}
+ url={customUrl()}
+ class={`min-w-0 ${usesCondensedIdentity() ? 'w-full [&>a]:hidden' : ''}`}
+ nameClass="truncate text-[11px] font-medium text-base-content select-none"
/>
- </Show>
- <Show when={nestedWorkloadCueLabel()}>
- <span
- class="inline-flex shrink-0 items-center gap-0.5 text-[10px] font-medium leading-none text-muted"
- data-testid="nested-workload-cue"
- title={nestedWorkloadCueLabel()}
- aria-label={nestedWorkloadCueLabel()}
- >
- <BoxIcon class="h-3 w-3" aria-hidden="true" />
- <span class="tabular-nums">{props.nestedWorkloadContext?.count}</span>
- </span>
- </Show>
+ {/* Show backup indicator in name cell only if backup column is hidden */}
+ <Show when={!isColVisible('backup') && supportsBackup()}>
+ <BackupIndicator
+ guestName={props.guest.name}
+ lastBackup={props.guest.lastBackup}
+ isTemplate={props.guest.template}
+ backupRunning={props.guest.backupInProgress}
+ />
+ </Show>
+ <Show when={nestedWorkloadCueLabel()}>
+ <span
+ class="inline-flex shrink-0 items-center gap-0.5 text-[10px] font-medium leading-none text-muted"
+ data-testid="nested-workload-cue"
+ title={nestedWorkloadCueLabel()}
+ aria-label={nestedWorkloadCueLabel()}
+ >
+ <BoxIcon class="h-3 w-3" aria-hidden="true" />
+ <span class="tabular-nums">{props.nestedWorkloadContext?.count}</span>
+ </span>
+ </Show>
+ </div>
</div>
- </div>
- <Show when={lockLabel()}>
- <span
- class="text-[10px] font-medium text-muted uppercase tracking-wide whitespace-nowrap"
- title={`Guest is locked (${lockLabel()})`}
- >
- Lock: {lockLabel()}
- </span>
- </Show>
+ <Show when={lockLabel()}>
+ <span
+ class={`max-w-full text-[10px] font-medium text-muted uppercase tracking-wide ${usesCondensedIdentity() ? 'whitespace-normal break-words' : 'whitespace-nowrap'}`}
+ title={`Guest is locked (${lockLabel()})`}
+ >
+ Lock: {lockLabel()}
+ </span>
+ </Show>
+ </div>
</div>
</td>
diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
index 9febd0c100..9257c215c0 100644
--- a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
+++ b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx
@@ -1196,6 +1196,79 @@ describe('GuestRow', () => {
expect(screen.getByText(/Lock:.*migrate/)).toBeTruthy();
});
+ it.each(['narrow', 'phone'] as const)(
+ 'keeps a %s lock below the identity without changing row activation',
+ (layout) => {
+ const onClick = vi.fn();
+ const { container } = renderGuestRow({
+ guest: makeGuest({ name: 'backup-guest', lock: 'backup' }),
+ workloadTableLayoutMode: layout,
+ onClick,
+ });
+ const lock = screen.getByTitle('Guest is locked (backup)');
+ const name = screen.getByText('backup-guest');
+ expect(lock.parentElement).toHaveClass('flex-col', 'items-start', 'min-w-0');
+ expect(lock.parentElement).toContainElement(name);
+ expect(name.parentElement).toHaveClass('w-full');
+ expect(name.parentElement?.parentElement).toHaveClass('flex-col', 'items-start');
+ expect(name.parentElement?.parentElement?.parentElement).toHaveClass('w-full');
+ expect(lock).toHaveClass('whitespace-normal', 'break-words', 'max-w-full');
+ expect(lock).not.toHaveAttribute('tabindex');
+ fireEvent.click(lock);
+ expect(onClick).toHaveBeenCalledTimes(1);
+ fireEvent.keyDown(screen.getByRole('button', { name: 'Expand backup-guest' }), {
+ key: 'Enter',
+ });
+ expect(onClick).toHaveBeenCalledTimes(2);
+ expect(container.querySelector('tr')).not.toHaveAttribute('tabindex');
+ },
+ );
+
+ it.each(['mobile', 'tablet', 'compact', 'wide'] as const)(
+ 'preserves inline identity and lock at the %s table layout',
+ (layout) => {
+ renderGuestRow({
+ guest: makeGuest({ lock: 'migrate' }),
+ workloadTableLayoutMode: layout,
+ });
+ const lock = screen.getByTitle('Guest is locked (migrate)');
+ expect(lock.parentElement).toHaveClass('items-center');
+ expect(lock.parentElement).not.toHaveClass('flex-col');
+ expect(lock).toHaveClass('whitespace-nowrap');
+ },
+ );
+
+ it('updates a lock on the same guest without renewing retained memory', () => {
+ const initial = makeGuest({
+ lock: 'backup',
+ memory: makeMemory({
+ observation: {
+ state: 'last-known',
+ source: 'guest-agent-meminfo',
+ observedAt: '2026-09-30T11:00:00Z',
+ },
+ }),
+ });
+ const [guest, setGuest] = createSignal(initial);
+ const { container } = render(() => (
+ <table>
+ <tbody>
+ <GuestRow guest={guest()} workloadTableLayoutMode="phone" />
+ </tbody>
+ </table>
+ ));
+ const row = container.querySelector('tr');
+ const notice = container.querySelector('[data-workload-memory-read-status]');
+ expect(notice).toHaveTextContent('2026-09-30 11:00:00 UTC');
+ setGuest({ ...initial, lock: 'snapshot-delete' });
+ expect(screen.getByTitle('Guest is locked (snapshot-delete)')).toBeVisible();
+ setGuest({ ...initial, lock: '', lastSeen: '2026-10-06T10:00:00Z' });
+ expect(screen.queryByTitle('Guest is locked (snapshot-delete)')).toBeNull();
+ expect(container.querySelector('tr')).toBe(row);
+ expect(container.querySelector('[data-workload-memory-read-status]')).toBe(notice);
+ expect(notice).toHaveTextContent('2026-09-30 11:00:00 UTC');
+ });
+
it('does not show lock label when not locked', () => {
renderGuestRow({ guest: makeGuest({ lock: '' }) });
expect(screen.queryByText('Lock:')).toBeNull();