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.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Keep Workloads memory freshness visible in every display mode
pulse-triage[bot]8df5051192a0
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.mdindex d53e286ff3..ef8be3984f 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,22 @@ A gate is only `passed` when its automated proof still passes and the manualscenario has been exercised in a staging-like environment with the expectedresult.+## Workloads memory observation presentation++Automated: `GuestRow.test.tsx` (memory observation provenance),+`MetricMiniSparkline.test.tsx`, `memoryObservation.test.ts`, and existing+GuestDrawer/canonical History/selected-source adapter tests. The browser fixture+`frontend-modern/browser-tests/guest-row-memory-provenance.cjs` exercises the+production renderer with synthetic last-known, unknown, unavailable, current,+zero and independent-memory/disk-deferral snapshots on desktop and narrow touch.+Check source/time labels without hovering, every display mode, host-capacity+labels, historical path preservation and same-guest updates without remount.++Installed follow-through remains separate: independent thaw, writes to every+covered filesystem, guest liveness and only-prior-active restoration belong to+the native safety owners. These presentation checks do not set a release gate,+prove a safe guest or authorise a diagnostic/restart.+## How To Use This Matrix1. Run the automated proof first.diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex 1f8e0a6224..ef8cb1c4df 100644--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md@@ -33,6 +33,26 @@ Patrol manual-rule confirmation keeps its title and safe Cancel/Remove controlsAll drawer History fallbacks must distinguish current observations from retained, unavailable or freshness-unknown guest readings, using original memory evidence and filesystem read reasons.+**Workloads rows preserve memory observation provenance.**++Workloads rows use the same selected-memory qualification as both drawers.+Retained and freshness-unknown values keep a visible cue in bars, sparklines,+the hover History lens and host-capacity mode; compact layouts shorten only the+visible label, not the accessible original source/time explanation. Sparkline+accessible values never call retained, unknown or unavailable memory current.+Unavailable numeric carriers remain N/A while recorded History stays intact.+An independent qualified memory reading is not paused by a disk deferral.+Neither Last seen, backup completion nor running power state renews memory.+Unannotated unrelated platforms and actual zero readings retain their meaning.++`GuestRow.test.tsx`, `MetricMiniSparkline.test.tsx` and+`memoryObservation.test.ts` pin these boundaries, with existing drawer, adapter+and History suites. `browser-tests/guest-row-memory-provenance.cjs` checks real+production rows and drawers, visible/accessible labels, pointer/touch/keyboard,+light/dark and narrow/desktop layouts using synthetic observations only.+Presentation acceptance does not establish native thaw, covered-filesystem+writes, guest liveness, service restoration or reporter recovery.+### Canonical drawer History preserves guest read provenanceThe shared resource drawer passes selected memory observation state/source/timediff --git a/docs/release-control/v6/internal/subsystems/performance-and-scalability.md b/docs/release-control/v6/internal/subsystems/performance-and-scalability.mdindex 50344121e9..0079c57c59 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,23 @@## Purpose+**Memory freshness is preserved at the Workloads row boundary.**++`GuestRow.tsx` qualifies selected memory once per reactive reading using the+shared drawer policy. Non-current rows keep a visible/accessibility cue through+bars, sparklines, the History lens and host-capacity mode. An unavailable+numeric carrier is not a current value; retained History paths stay unchanged.+Source-time qualification never uses Last seen or a filesystem deferral,+and same-guest observation updates do not remount the row or request History.+No collection, chart sampling, sorting, retention or alert threshold changes.++`GuestRow.test.tsx` (memory observation provenance),+`MetricMiniSparkline.test.tsx`, `memoryObservation.test.ts` and the existing+drawer/History suites pin this boundary. The production browser fixture+`browser-tests/guest-row-memory-provenance.cjs` checks touch/pointer/keyboard+and narrow/desktop layouts with synthetic observations, not native recovery.++Drawer observation labels derive locally from the selected snapshot without renewing timestamps, adding reads, remounting charts or changing stored metric coordinates.### Drawer provenance stays local to snapshot presentationdiff --git a/frontend-modern/browser-tests/guest-row-memory-provenance.cjs b/frontend-modern/browser-tests/guest-row-memory-provenance.cjsnew file mode 100644index 0000000000..5dea0126ea--- /dev/null+++ b/frontend-modern/browser-tests/guest-row-memory-provenance.cjs@@ -0,0 +1,355 @@+// Production component source in the existing offline Vite preview.+// No installation, full application build, guest operation or external service.+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 root = '/workspace/frontend-modern';+const output = '/workspace/tmp/guest-row-memory-browser';+const origin = 'http://127.0.0.1:5332';+const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');+const manifest = {+ mode: 'source-dev-preview',+ runtime: Object.fromEntries(+ [+ 'frontend-modern/src/components/Workloads/GuestRow.tsx',+ 'frontend-modern/src/components/Workloads/MetricMiniSparkline.tsx',+ 'frontend-modern/src/components/Workloads/guestDrawerModel.ts',+ 'frontend-modern/src/utils/memoryObservation.ts',+ 'frontend-modern/browser-tests/guest-row-memory-provenance.tsx',+ ].map((file) => [file, hash('/workspace/' + file)]),+ ),+ graph: hash(root + '/package-lock.json'),+};+fs.mkdirSync(output, { recursive: true });+const result = {+ result: 'incomplete',+ playwright: require('playwright/package.json').version,+ binding: manifest,+ cases: [],+ captures: [],+ cleanup: {},+ limits:+ 'Production GuestRow, StackedMemoryBar, MetricMiniSparkline, drawer and actual source CSS in a dev preview; synthetic selected memory/history only. This is not a production application build. No full App, native QGA, thaw, filesystem writes, reporter, installed/release 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 started = Date.now();+ const { createServer } = await import(path.join(root, 'node_modules/vite/dist/node/index.js'));+ const server = await createServer({+ root,+ configFile: path.join(root, 'vite.config.ts'),+ cacheDir: output + '/cache',+ server: { host: '127.0.0.1', port: 5332, strictPort: true },+ });+ await server.listen();+ let browser;+ try {+ for (const [name, engine, width, dark] of [+ ['desktop-light', chromium, 1365, false],+ ['desktop-dark', chromium, 1365, true],+ ['phone-dark', webkit, 390, true],+ ['narrow-light', webkit, 320, false],+ ]) {+ 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: [],+ requests: [],+ errors: [],+ captures: [],+ };+ result.cases.push(record);+ page.on('pageerror', (e) => record.errors.push(e.message));+ await page.route('**/*', (route) => {+ const req = route.request(),+ url = new URL(req.url());+ if (url.origin !== origin) {+ record.errors.push('Unexpected external request');+ return route.abort();+ }+ if (!url.pathname.startsWith('/api/')) return route.continue();+ record.requests.push({ path: url.pathname, method: req.method() });+ assert.equal(req.method(), 'GET');+ assert(!/diagnostics|\/run|guest-agent|qemu/.test(url.pathname), 'no live guest operation');+ return route.fulfill({+ json:+ url.pathname === '/api/license/runtime-capabilities'+ ? {+ capabilities: [],+ limits: [],+ max_history_days: 7,+ hosted_mode: false,+ runtime: { build: 'community' },+ blocked_capabilities: [],+ }+ : { 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 + '/browser-tests/guest-row-memory-provenance.html');+ const row = page.locator('[data-guest-id="fixture-pve1-101"]');+ const memory = row.locator('[data-workload-col="memory"]');+ const notice = memory.locator('[data-workload-memory-read-status]');+ const identity = await row.elementHandle();+ const visibleLabel = () => notice.locator('[aria-hidden="true"]');+ const capture = async (state) => {+ const file = `${name}-${state}.png`;+ await page.screenshot({ path: path.join(output, file), fullPage: true });+ record.captures.push(file);+ result.captures.push({ file, sha256: hash(path.join(output, file)) });+ };+ await visibleLabel()+ .getByText(width <= 768 ? 'Prior' : 'Last known', { exact: true })+ .waitFor();+ assert((await notice.locator('.sr-only').textContent()).includes('2026-09-30 11:00:00 UTC'));+ assert((await notice.textContent()).includes('Not a current measurement'));+ assert(+ await visibleLabel().evaluate((el) => {+ const r = el.getBoundingClientRect(),+ cell = el.closest('td').getBoundingClientRect();+ return r.width > 0 && r.x >= cell.x && r.right <= cell.right;+ }),+ 'cue fits memory cell',+ );+ await capture('retained-bars');+ record.checks.push(+ 'retained cue is visible without hover and exposes original UTC/source to assistive technology',+ );+ await page.evaluate(() =>+ window.__memoryRow.update({+ lastSeen: '2026-10-06T10:00:00Z',+ lock: '',+ backupInProgress: false,+ }),+ );+ assert((await notice.textContent()).includes('Last known'));+ assert(!(await notice.textContent()).includes('2026-10-06'));+ record.checks.push('Last seen/running/backup completion cannot renew memory');+ await page.getByLabel('Metric display').selectOption('sparklines');+ let svg = memory.getByRole('img', {+ name: 'backup-guest memory history, last known 25%',+ exact: true,+ });+ await svg.waitFor();+ const plot = await svg.locator('path').getAttribute('d');+ assert(plot.includes('M'));+ await page.getByLabel('Memory basis').selectOption('host');+ await memory+ .getByRole('img', {+ name: 'backup-guest host memory share history, last known 13%',+ exact: true,+ })+ .waitFor();+ assert((await notice.textContent()).includes('Last known'));+ await page.getByLabel('Memory basis').selectOption('guest');+ record.checks.push(+ 'retained sparkline and host-capacity accessible values never become current',+ );+ await page.evaluate(() => {+ const guest = window.__memoryRow.reading();+ window.__memoryRow.update({ memory: { ...guest.memory, observation: undefined } });+ });+ await memory+ .getByRole('img', {+ name: 'backup-guest memory history, freshness unknown 25%',+ exact: true,+ })+ .waitFor();+ await visibleLabel()+ .getByText(width <= 768 ? 'Unknown' : 'Freshness unknown', { exact: true })+ .waitFor();+ assert.equal(await memory.locator('svg[role="img"] path').getAttribute('d'), plot);+ await capture('unknown-sparkline');+ record.checks.push(+ 'legacy unannotated Proxmox values are freshness-unknown without changing History',+ );+ await page.evaluate(() => {+ const guest = window.__memoryRow.reading();+ window.__memoryRow.update({+ memory: {+ ...guest.memory,+ observation: {+ state: 'unavailable',+ source: 'guest-agent-meminfo',+ observedAt: '2026-09-30T11:00:00Z',+ },+ },+ });+ });+ await memory+ .getByRole('img', { name: 'backup-guest memory history, unavailable N/A', exact: true })+ .waitFor();+ assert.equal(await memory.locator('svg[role="img"] path').getAttribute('d'), plot);+ await capture('unavailable-sparkline');+ await page.getByLabel('Metric display').selectOption('bars');+ await memory.getByText('N/A', { exact: true }).first().waitFor();+ assert.equal(+ await memory.locator('[data-stacked-memory-segment]').count(),+ 0,+ 'unavailable numeric carriers have no fill',+ );+ record.checks.push(+ 'unavailable carrier hides percentage/bar while retained recorded points stay intact',+ );+ await page.evaluate(() => {+ const guest = window.__memoryRow.reading();+ window.__memoryRow.update({+ diskStatusReason: 'prev-vm-locked',+ memory: {+ ...guest.memory,+ used: 0,+ usage: 0,+ observation: {+ state: 'last-known',+ source: 'status-mem',+ observedAt: '2026-09-30T11:00:00Z',+ },+ },+ });+ });+ await page.getByLabel('Metric display').selectOption('sparklines');+ await memory+ .getByRole('img', { name: 'backup-guest memory history, last known 0%', exact: true })+ .waitFor();+ await page.evaluate(() => {+ const guest = window.__memoryRow.reading();+ window.__memoryRow.update({+ memory: {+ ...guest.memory,+ used: 1024 ** 3,+ usage: 25,+ observation: { state: 'current', source: 'agent', observedAt: '2026-10-01T11:00:00Z' },+ },+ });+ });+ await memory+ .getByRole('img', { name: 'backup-guest memory history, current 25%', exact: true })+ .waitFor();+ assert.equal(await notice.count(), 0);+ assert.equal(await memory.locator('svg[role="img"] path').getAttribute('d'), plot);+ assert(await identity.evaluate((el) => el.isConnected), 'same row remains mounted');+ record.checks.push(+ 'measured zero preserved; independent current Agent memory withdraws only its cue while disk deferral persists',+ );+ await page.getByLabel('Metric display').selectOption('bars');+ if (width > 768) {+ await page.getByRole('heading', { name: 'Workloads memory freshness' }).hover();+ await page.locator('body').click({ position: { x: 1, y: 1 } });+ await page.keyboard.press('Tab');+ await page.keyboard.press('Tab');+ await page.keyboard.press('Tab');+ assert(+ await row+ .getByRole('button', { name: /Expand.*details/ })+ .evaluate((el) => document.activeElement === el),+ );+ await page.keyboard.press('Enter');+ } else {+ await row.tap();+ }+ const details = page.getByRole('region', { name: 'Guest details' });+ await details.waitFor();+ assert(+ (await details.textContent()).includes('Current · Pulse Agent · 2026-10-01 11:00:00 UTC'),+ );+ assert(+ (await details.textContent()).includes('does not prove thaw') ||+ (await details.textContent()).includes('independent thaw'),+ );+ record.checks.push(+ 'real keyboard/first-touch guest disclosure shares memory policy without clearing backup safety',+ );+ await details.getByRole('button', { name: 'Collapse backup-guest details' }).click();+ await details.waitFor({ state: 'hidden' });+ if (width > 768) {+ await page.evaluate(() => {+ const guest = window.__memoryRow.reading();+ window.__memoryRow.update({+ memory: {+ ...guest.memory,+ observation: {+ state: 'last-known',+ source: 'guest-agent-meminfo',+ observedAt: '2026-09-30T11:00:00Z',+ },+ },+ });+ });+ await row.hover();+ await memory+ .getByRole('img', { name: 'backup-guest memory history, last known 25%', exact: true })+ .waitFor();+ assert((await notice.textContent()).includes('Last known'));+ await page.getByRole('heading', { name: 'Workloads memory freshness' }).hover();+ await memory.getByText('25%', { exact: true }).waitFor();+ record.checks.push('pointer History lens retains provenance and restores the bar');+ }+ assert(+ await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth),+ 'no horizontal overflow',+ );+ assert.deepEqual(record.errors, []);+ await context.close();+ await browser.close();+ browser = null;+ record.closed = true;+ }+ result.result = 'passed';+ } catch (error) {+ result.error = error.stack;+ throw error;+ } finally {+ if (browser) await browser.close();+ result.cleanup.browser_closed = true;+ await server.close();+ const esbuild = await import(path.join(root, 'node_modules/esbuild/lib/main.js'));+ esbuild.stop();+ result.cleanup.compiler_stop_requested = true;+ result.cleanup.server_closed = true;+ result.elapsed_ms = Date.now() - started;+ fs.writeFileSync(path.join(output, 'result.json'), JSON.stringify(result, null, 2) + '\n');+ console.log(+ JSON.stringify({+ result: result.result,+ cases: result.cases.length,+ captures: result.captures.length,+ elapsed_ms: result.elapsed_ms,+ cleanup: result.cleanup,+ }),+ );+ }+})().catch((error) => {+ console.error(error.message);+ process.exitCode = 1;+});diff --git a/frontend-modern/browser-tests/guest-row-memory-provenance.html b/frontend-modern/browser-tests/guest-row-memory-provenance.htmlnew file mode 100644index 0000000000..59b5da497b--- /dev/null+++ b/frontend-modern/browser-tests/guest-row-memory-provenance.html@@ -0,0 +1,12 @@+<!doctype html>+<html lang="en">+ <head>+ <meta charset="UTF-8" />+ <meta name="viewport" content="width=device-width, initial-scale=1" />+ <title>Workloads memory freshness verification</title>+ </head>+ <body>+ <div id="root"></div>+ <script type="module" src="./guest-row-memory-provenance.tsx"></script>+ </body>+</html>diff --git a/frontend-modern/browser-tests/guest-row-memory-provenance.tsx b/frontend-modern/browser-tests/guest-row-memory-provenance.tsxnew file mode 100644index 0000000000..1c99ed4505--- /dev/null+++ b/frontend-modern/browser-tests/guest-row-memory-provenance.tsx@@ -0,0 +1,170 @@+// Production rows/drawer and metric History, synthetic selected observations.+// No guest request, thaw, backup, restart or recovery operation is performed.+import { createSignal, Show } from 'solid-js';+import { render } from 'solid-js/web';+import { Router, Route } from '@solidjs/router';+import { GuestRow } from '../src/components/Workloads/GuestRow';+import {+ getGuestColumnStyle,+ getWorkloadTableLayoutModeForContainer,+} from '../src/components/Workloads/guestRowModel';+import { GuestDrawer } from '../src/components/Workloads/GuestDrawer';+import { DarkModeContext } from '../src/contexts/appRuntime';+import { syncAIRuntimeSettings } from '../src/stores/aiRuntimeState';+import type { WorkloadGuest } from '../src/types/workloads';+import type { WorkloadMetricHistoryReader } from '../src/components/Workloads/workloadMetricHistoryModel';+import '../src/index.css';++syncAIRuntimeSettings({ discovery_enabled: false });+const capacity = 4 * 1024 ** 3;+const observedAt = '2026-09-30T11:00:00Z';+const initial: WorkloadGuest = {+ id: 'fixture-pve1-101',+ vmid: 101,+ name: 'backup-guest',+ instance: 'fixture',+ node: 'pve1',+ type: 'qemu',+ workloadType: 'vm',+ platformScopes: ['proxmox-pve'],+ platformType: 'proxmox-pve',+ status: 'running',+ cpu: 0.1,+ cpus: 2,+ memory: {+ total: capacity,+ used: capacity / 4,+ free: (capacity * 3) / 4,+ usage: 25,+ observation: { state: 'last-known', source: 'guest-agent-meminfo', observedAt },+ },+ disk: { total: capacity, used: capacity / 2, usage: 50 },+ diskStatusReason: 'prev-vm-locked',+ lock: 'backup',+ guestAgentStatus: 'deferred',+ guestAgentExpected: true,+ networkIn: 10,+ networkOut: 20,+ diskRead: 30,+ diskWrite: 40,+ uptime: 3600,+ template: false,+ lastBackup: 0,+ tags: [],+ lastSeen: '2026-10-01T12:00:00Z',+};+const history: WorkloadMetricHistoryReader = {+ getGuestMetricSeries: (_guest, metric) =>+ metric === 'memory'+ ? [+ {+ id: 'memory',+ label: 'Memory',+ color: '#f59e0b',+ points: [+ { timestamp: Date.parse(observedAt) - 60_000, value: 20 },+ { timestamp: Date.parse(observedAt), value: 25 },+ ],+ },+ ]+ : [],+ getNodeMetricSeries: () => [],+};+function Fixture() {+ const columns = ['name', 'cpu', 'memory', 'disk', 'uptime'];+ const layout = getWorkloadTableLayoutModeForContainer(Math.min(window.innerWidth, 896) - 40);+ const [guest, setGuest] = createSignal(initial);+ const [mode, setMode] = createSignal<'bars' | 'sparklines'>('bars');+ const [basis, setBasis] = createSignal<'guest' | 'host'>('guest');+ const [expanded, setExpanded] = createSignal(false);+ (window as any).__memoryRow = {+ update: (next: Partial<WorkloadGuest>) => setGuest({ ...guest(), ...next }),+ reading: () => guest(),+ };+ return (+ <main class="mx-auto min-h-screen max-w-4xl space-y-3 bg-surface p-3 text-base-content">+ <h1 class="text-base font-semibold">Workloads memory freshness</h1>+ <p class="text-xs text-muted">+ Synthetic observations. No guest checks or recovery commands.+ </p>+ <div class="flex flex-wrap gap-3 text-xs">+ <label class="flex gap-2 items-center">+ Display+ <select+ aria-label="Metric display"+ class="rounded-sm border border-border bg-surface p-1"+ value={mode()}+ onChange={(e) => setMode(e.currentTarget.value as 'bars' | 'sparklines')}+ >+ <option value="bars">Bars</option>+ <option value="sparklines">Sparklines</option>+ </select>+ </label>+ <label class="flex gap-2 items-center">+ Memory basis+ <select+ aria-label="Memory basis"+ class="rounded-sm border border-border bg-surface p-1"+ value={basis()}+ onChange={(e) => setBasis(e.currentTarget.value as 'guest' | 'host')}+ >+ <option value="guest">Guest allocation</option>+ <option value="host">Host capacity</option>+ </select>+ </label>+ </div>+ <section aria-label="Guest row" class="rounded-sm border border-border bg-surface-raised p-2">+ <table class="w-full table-fixed">+ <thead>+ <tr>+ {columns.map((column) => (+ <th+ class="text-left text-xs"+ style={getGuestColumnStyle(column, window.innerWidth <= 768, layout, columns)}+ >+ {column === 'cpu' ? 'CPU' : column[0].toUpperCase() + column.slice(1)}+ </th>+ ))}+ </tr>+ </thead>+ <tbody>+ <GuestRow+ guest={guest()}+ visibleColumnIds={columns}+ metricDisplayMode={mode()}+ memoryDisplayBasis={basis()}+ parentMemoryTotal={capacity * 2}+ parentNodeName="pve1"+ workloadTableLayoutMode={layout}+ metricHistory={history}+ isExpanded={expanded()}+ onClick={() => setExpanded(!expanded())}+ />+ </tbody>+ </table>+ </section>+ <Show when={expanded()}>+ <section aria-label="Guest details">+ <GuestDrawer guest={guest()} onClose={() => setExpanded(false)} />+ </section>+ </Show>+ </main>+ );+}+render(+ () => (+ <Router>+ <Route+ path="*"+ component={() => (+ <DarkModeContext.Provider+ value={() => document.documentElement.classList.contains('dark')}+ >+ <Fixture />+ </DarkModeContext.Provider>+ )}+ />+ </Router>+ ),+ document.getElementById('root')!,+);diff --git a/frontend-modern/src/components/Workloads/GuestRow.tsx b/frontend-modern/src/components/Workloads/GuestRow.tsxindex adb2046f0a..18bcd14244 100644--- a/frontend-modern/src/components/Workloads/GuestRow.tsx+++ b/frontend-modern/src/components/Workloads/GuestRow.tsx@@ -33,6 +33,7 @@ import { SummaryRowActionButton } from '@/components/shared/SummaryRowActionButtimport { createRowTextSelectionGuard, nativeRowClickTarget } from '@/components/shared/Table';import { DiscoveryReadinessBadge } from '@/components/shared/DiscoveryReadinessBadge';import { getWorkloadGuestDiskStatusMessage } from '@/utils/workloadGuestPresentation';+import { getWorkloadMemoryObservationPresentation } from '@/utils/memoryObservation';import { ResourceNameWithWebInterfaceLink } from '@/components/shared/WebInterfaceLink';import type { GuestRowProps } from './guestRowModel';import { useGuestRowState } from './useGuestRowState';@@ -171,12 +172,45 @@ export function GuestRow(props: GuestRowProps) {const memoryDisplayTotal = createMemo(() =>isHostMemoryBasis() ? hostMemoryTotal() : (props.guest.memory?.total ?? 0),);+ const memoryReading = createMemo(() =>+ getWorkloadMemoryObservationPresentation(props.guest, { includeCurrent: false }),+ );const memoryDisplayUnavailable = createMemo(() =>!telemetryAvailable('memory') ||props.guest.memory?.usageUnavailable === true ||+ memoryReading()?.state === 'unavailable' ||(isHostMemoryBasis() && hostMemoryTotal() <= 0),);+ const memoryReadStatus = createMemo(() => {+ const reading = memoryReading();+ if (!reading || reading.state === 'current') return undefined;+ return {+ message: reading.message,+ label:+ reading.state === 'last-known'+ ? usesCompactTableLayout()+ ? 'Prior'+ : 'Last known'+ : reading.state === 'unavailable'+ ? usesCompactTableLayout()+ ? 'N/A'+ : 'Unavailable'+ : usesCompactTableLayout()+ ? 'Unknown'+ : 'Freshness unknown',+ valueLabelContext:+ reading.state === 'last-known'+ ? ('last known' as const)+ : reading.state === 'unavailable'+ ? ('unavailable' as const)+ : ('freshness unknown' as const),+ };+ });+ const memoryValueLabelContext = (): MetricMiniSparklineValueLabelContext =>+ memoryDisplayUnavailable()+ ? 'unavailable'+ : (memoryReadStatus()?.valueLabelContext ?? 'current');const detailControlsId = createMemo(() => buildSummaryDisclosureControlsId(guestId()));const nestedWorkloadCueLabel = createMemo(() => {const context = props.nestedWorkloadContext;@@ -503,7 +537,11 @@ export function GuestRow(props: GuestRowProps) {{/* Memory */}<Show when={isColVisible('memory')}>- <td class="px-1.5 sm:px-2 py-0.5 align-middle" data-workload-col="memory">+ <td+ class="px-1.5 sm:px-2 py-0.5 align-middle"+ data-workload-col="memory"+ title={memoryReadStatus()?.message}+ ><Showwhen={isSparklineMode()}fallback={@@ -566,6 +604,7 @@ export function GuestRow(props: GuestRowProps) {memoryDisplayBasis: props.memoryDisplayBasis,parentMemoryTotal: props.parentMemoryTotal,},+ memoryValueLabelContext(),)}</div></Show>@@ -593,6 +632,19 @@ export function GuestRow(props: GuestRowProps) {memoryDisplayBasis: props.memoryDisplayBasis,parentMemoryTotal: props.parentMemoryTotal,},+ memoryValueLabelContext(),+ )}+ </Show>+ <Show when={memoryReadStatus()}>+ {(status) => (+ <p+ data-workload-memory-read-status+ class="mt-0.5 text-center text-[10px] leading-none text-muted"+ title={status().message}+ >+ <span aria-hidden="true">{status().label}</span>+ <span class="sr-only">{status().message}</span>+ </p>)}</Show></td>diff --git a/frontend-modern/src/components/Workloads/MetricMiniSparkline.tsx b/frontend-modern/src/components/Workloads/MetricMiniSparkline.tsxindex eedc2de08f..b803ccb917 100644--- a/frontend-modern/src/components/Workloads/MetricMiniSparkline.tsx+++ b/frontend-modern/src/components/Workloads/MetricMiniSparkline.tsx@@ -13,7 +13,8 @@ import {} from './workloadMetricHistoryModel';type MetricMiniSparklineValueLabelMode = 'inline' | 'tooltip' | 'hidden';-export type MetricMiniSparklineValueLabelContext = 'current' | 'last known';+export type MetricMiniSparklineValueLabelContext =+ 'current' | 'last known' | 'freshness unknown' | 'unavailable';interface MetricMiniSparklineProps {series: WorkloadMetricSparklineSeries[];diff --git a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsxindex 39b59fb197..9febd0c100 100644--- a/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx+++ b/frontend-modern/src/components/Workloads/__tests__/GuestRow.test.tsx@@ -1,4 +1,4 @@-import { describe, it, expect, vi, afterEach } from 'vitest';+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';import { render, screen, fireEvent, cleanup } from '@solidjs/testing-library';import { createSignal } from 'solid-js';import type { WorkloadGuest } from '@/types/workloads';@@ -922,6 +922,241 @@ describe('GuestRow', () => {});});+ describe('memory observation provenance', () => {+ const observedAt = '2026-09-30T11:00:00Z';+ const observation = (state: string, date = observedAt, source = 'guest-agent-meminfo') =>+ makeMemory({ observation: { state, source, observedAt: date } });+ const noticeSelector = '[data-workload-memory-read-status]';+ const history = {+ getGuestMetricSeries: vi.fn(() => [+ {+ id: 'memory',+ label: 'Memory',+ color: '#f59e0b',+ points: [+ { timestamp: 1_000, value: 25 },+ { timestamp: 2_000, value: 50 },+ ],+ },+ ]),+ getNodeMetricSeries: () => [],+ };++ beforeEach(() => {+ vi.spyOn(Date, 'now').mockReturnValue(Date.parse('2026-10-01T12:00:00Z'));+ });++ for (const mode of ['bars', 'sparklines'] as const) {+ it(`labels retained memory in ${mode} without hover or a guest check`, () => {+ const { container } = renderGuestRow({+ guest: makeGuest({ memory: observation('last-known'), lastSeen: '2026-10-01T12:00:00Z' }),+ metricDisplayMode: mode,+ visibleColumnIds: ['name', 'memory'],+ });+ const notice = container.querySelector(noticeSelector);+ expect(notice?.querySelector('[aria-hidden]')).toHaveTextContent('Last known');+ expect(notice?.querySelector('.sr-only')).toHaveTextContent(+ 'Last known. Source: QEMU guest agent. Observed: 2026-09-30 11:00:00 UTC. Not a current measurement.',+ );+ expect(notice).not.toHaveTextContent('2026-10-01');+ expect(notice).not.toHaveAttribute('tabindex');+ if (mode === 'sparklines') {+ expect(+ screen.getByRole('img', { name: 'test-vm memory history, last known 50%' }),+ ).toBeInTheDocument();+ expect(screen.queryByRole('img', { name: /current/ })).not.toBeInTheDocument();+ } else {+ expect(screen.getByTestId('memory-bar')).toHaveAttribute('data-unavailable', 'false');+ }+ });++ it.each(['qemu', 'lxc'])(+ `labels unannotated Proxmox %s memory freshness in ${mode}`,+ (type) => {+ const { container } = renderGuestRow({+ guest: makeGuest({ type, diskStatusReason: 'prev-vm-locked' }),+ metricDisplayMode: mode,+ visibleColumnIds: ['name', 'memory'],+ });+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Freshness unknown');+ expect(container.querySelector(noticeSelector)).toHaveTextContent(+ 'Observation time unknown',+ );+ if (mode === 'sparklines') {+ expect(+ screen.getByRole('img', { name: 'test-vm memory history, freshness unknown 50%' }),+ ).toBeInTheDocument();+ }+ },+ );++ it.each(['', 'not-a-date', '9999-01-01T00:00:00Z'])(+ `does not qualify memory using an unusable current timestamp (%s) in ${mode}`,+ (date) => {+ const { container } = renderGuestRow({+ guest: makeGuest({ memory: observation('current', date) }),+ metricDisplayMode: mode,+ visibleColumnIds: ['name', 'memory'],+ });+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Freshness unknown');+ expect(container.querySelector(noticeSelector)).toHaveTextContent(+ 'Observation time unknown',+ );+ expect(container.querySelector(noticeSelector)).not.toHaveTextContent(+ date || 'not-a-date',+ );+ },+ );++ it(`hides an unavailable numeric carrier without removing recorded history in ${mode}`, () => {+ const { container } = renderGuestRow({+ guest: makeGuest({ memory: observation('unavailable') }),+ metricDisplayMode: mode,+ visibleColumnIds: ['name', 'memory'],+ metricHistory: history,+ });+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Unavailable');+ if (mode === 'sparklines') {+ expect(+ screen.getByRole('img', { name: 'test-vm memory history, unavailable N/A' }),+ ).toBeInTheDocument();+ expect(container.querySelector('path')?.getAttribute('d')).toContain('M');+ expect(screen.queryByText('50%')).not.toBeInTheDocument();+ } else {+ expect(screen.getByTestId('memory-bar')).toHaveAttribute('data-unavailable', 'true');+ }+ });++ it(`withdraws the ${mode} cue only for a qualified same-guest reading`, () => {+ const [guest, setGuest] = createSignal(makeGuest({ memory: observation('last-known') }));+ const { container } = render(() => (+ <table>+ <tbody>+ <GuestRow+ guest={guest()}+ metricDisplayMode={mode}+ visibleColumnIds={['name', 'memory']}+ />+ </tbody>+ </table>+ ));+ const row = container.querySelector('tr');+ setGuest({+ ...guest(),+ lastSeen: '2026-10-01T12:00:00Z',+ backupInProgress: false,+ lock: '',+ });+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Last known');+ setGuest({ ...guest(), memory: observation('current') });+ expect(container.querySelector('tr')).toBe(row);+ expect(container.querySelector(noticeSelector)).toBeNull();+ if (mode === 'sparklines') {+ expect(+ screen.getByRole('img', { name: 'test-vm memory history, current 50%' }),+ ).toBeInTheDocument();+ }+ });++ it(`keeps a qualified independent memory reading current while disk reads defer in ${mode}`, () => {+ const { container } = renderGuestRow({+ guest: makeGuest({+ memory: observation('current', observedAt, 'agent'),+ diskStatusReason: 'prev-vm-locked',+ }),+ metricDisplayMode: mode,+ visibleColumnIds: ['name', 'memory'],+ });+ expect(container.querySelector(noticeSelector)).toBeNull();+ if (mode === 'sparklines')+ expect(+ screen.getByRole('img', { name: 'test-vm memory history, current 50%' }),+ ).toBeInTheDocument();+ });++ it(`keeps measured zero, original source and host-share freshness in ${mode}`, () => {+ const { container } = renderGuestRow({+ guest: makeGuest({+ memory: { ...observation('last-known', observedAt, 'status-mem'), used: 0, usage: 0 },+ }),+ metricDisplayMode: mode,+ visibleColumnIds: ['name', 'memory'],+ memoryDisplayBasis: 'host',+ parentMemoryTotal: 8_589_934_592,+ });+ expect(container.querySelector(noticeSelector)).toHaveTextContent(+ 'Last known. Source: Proxmox',+ );+ if (mode === 'sparklines')+ expect(+ screen.getByRole('img', { name: 'test-vm host memory share history, last known 0%' }),+ ).toBeInTheDocument();+ else expect(screen.getByTestId('memory-bar')).toHaveAttribute('data-unavailable', 'false');+ });+ }++ it('keeps original freshness across the real hover lens and preserves historical points', () => {+ const { container } = renderGuestRow({+ guest: makeGuest({ memory: observation('last-known') }),+ metricDisplayMode: 'bars',+ visibleColumnIds: ['name', 'memory'],+ metricHistory: history,+ });+ const row = container.querySelector('tr')!;+ fireEvent.pointerEnter(row, { pointerType: 'mouse' });+ expect(screen.queryByTestId('memory-bar')).not.toBeInTheDocument();+ expect(+ screen.getByRole('img', { name: 'test-vm memory history, last known 50%' }),+ ).toBeInTheDocument();+ expect(container.querySelector('path')?.getAttribute('d')).toContain('M');+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Last known');+ fireEvent.pointerLeave(row, { pointerType: 'mouse' });+ expect(screen.getByTestId('memory-bar')).toBeInTheDocument();+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Last known');+ });++ it.each([+ ['last-known', 'Prior'],+ ['future-state', 'Unknown'],+ ['unavailable', 'N/A'],+ ])('fits compact %s copy without losing the accessible source and time', (state, label) => {+ const { container } = renderGuestRow({+ guest: makeGuest({ memory: observation(state) }),+ visibleColumnIds: ['name', 'memory'],+ workloadTableLayoutMode: 'phone',+ });+ const notice = container.querySelector(noticeSelector);+ expect(notice?.querySelector('[aria-hidden]')).toHaveTextContent(label);+ expect(notice?.querySelector('.sr-only')).toHaveTextContent('QEMU guest agent');+ expect(notice?.querySelector('.sr-only')).toHaveTextContent('2026-09-30 11:00:00 UTC');+ expect(notice).not.toHaveTextContent('future-state');+ });++ it('does not expose unknown provider labels or borrow disk provenance', () => {+ const { container } = renderGuestRow({+ guest: makeGuest({ memory: observation('private-state', observedAt, 'private-source') }),+ visibleColumnIds: ['name', 'memory'],+ });+ expect(container.querySelector(noticeSelector)).toHaveTextContent('Unknown source');+ expect(container.querySelector(noticeSelector)).not.toHaveTextContent('private-');+ });++ it.each([+ { type: 'vm', platformScopes: ['vmware-vsphere' as const] },+ { type: 'docker', workloadType: 'app-container' as const, vmid: 0 },+ ])('preserves unannotated unrelated platform memory ($type)', (scope) => {+ const { container } = renderGuestRow({+ guest: makeGuest(scope),+ visibleColumnIds: ['name', 'memory'],+ metricDisplayMode: 'sparklines',+ });+ expect(container.querySelector(noticeSelector)).toBeNull();+ expect(+ screen.getByRole('img', { name: 'test-vm memory history, current 50%' }),+ ).toBeInTheDocument();+ });+ });+describe('lock label', () => {it.each(guestDiskDeferrals)('annotates retained row and disk tooltip for %s',diff --git a/frontend-modern/src/components/Workloads/__tests__/MetricMiniSparkline.test.tsx b/frontend-modern/src/components/Workloads/__tests__/MetricMiniSparkline.test.tsxindex d145438de7..39e0befb52 100644--- a/frontend-modern/src/components/Workloads/__tests__/MetricMiniSparkline.test.tsx+++ b/frontend-modern/src/components/Workloads/__tests__/MetricMiniSparkline.test.tsx@@ -66,6 +66,37 @@ describe('MetricMiniSparkline', () => {expect(container.querySelector('path')?.getAttribute('d')).toBe(path);});+ it.each(['freshness unknown', 'unavailable'] as const)(+ 'announces %s context without changing recorded History',+ (context) => {+ const { container } = render(() => (+ <MetricMiniSparkline+ title="Memory history"+ valueLabel={context === 'unavailable' ? 'N/A' : '25%'}+ valueLabelContext={context}+ series={[+ {+ id: 'memory',+ label: 'Memory',+ color: '#f59e0b',+ points: [+ { timestamp: 1, value: 10 },+ { timestamp: 2, value: 25 },+ ],+ },+ ]}+ />+ ));+ expect(+ screen.getByRole('img', {+ name: `Memory history, ${context} ${context === 'unavailable' ? 'N/A' : '25%'}`,+ }),+ ).toBeInTheDocument();+ expect(screen.queryByRole('img', { name: /current/ })).not.toBeInTheDocument();+ expect(container.querySelector('path')?.getAttribute('d')).toContain('M');+ },+ );+it('keeps the label visible when history has no renderable line', () => {render(() => (<MetricMiniSparklinediff --git a/frontend-modern/src/components/Workloads/guestDrawerModel.ts b/frontend-modern/src/components/Workloads/guestDrawerModel.tsindex f78290928c..b955abddf8 100644--- a/frontend-modern/src/components/Workloads/guestDrawerModel.ts+++ b/frontend-modern/src/components/Workloads/guestDrawerModel.ts@@ -18,7 +18,7 @@ import type { NestedWorkloadContext } from './nestedWorkloadContext';import type { WorkloadsMemoryDisplayBasis } from './workloadsFilterModel';import {- getMemoryObservationPresentation,+ getWorkloadMemoryObservationPresentation,type MemoryObservationPresentation,} from '@/utils/memoryObservation';@@ -126,23 +126,7 @@ const getGuestDrawerMemoryUsage = (guest: Guest): number | undefined => {: undefined;};-export const getGuestDrawerMemoryReading = (guest: Guest): GuestDrawerMemoryReading | null => {- const observation = guest.memory?.observation;- const nonProxmoxVMware =- guest.platformScopes?.includes('vmware-vsphere') &&- !guest.platformScopes.includes('proxmox-pve');- const proxmoxGuest =- !nonProxmoxVMware &&- (guest.type === 'qemu' ||- guest.type === 'lxc' ||- guest.platformScopes?.includes('proxmox-pve') ||- (guest.vmid > 0 && Boolean(guest.node && guest.instance)));- return getMemoryObservationPresentation(- getGuestDrawerMemoryUsage(guest),- observation,- proxmoxGuest,- );-};+export const getGuestDrawerMemoryReading = getWorkloadMemoryObservationPresentation;export const getGuestDrawerDeferredMetrics = (guest: Guest,diff --git a/frontend-modern/src/utils/__tests__/memoryObservation.test.ts b/frontend-modern/src/utils/__tests__/memoryObservation.test.tsnew file mode 100644index 0000000000..26dfd44258--- /dev/null+++ b/frontend-modern/src/utils/__tests__/memoryObservation.test.ts@@ -0,0 +1,92 @@+import { describe, expect, it, vi, afterEach } from 'vitest';+import type { WorkloadGuest } from '@/types/workloads';+import { getWorkloadMemoryObservationPresentation } from '../memoryObservation';++const guest = (changes: Partial<WorkloadGuest> = {}): WorkloadGuest =>+ ({+ id: 'fixture-pve1-101',+ vmid: 101,+ node: 'pve1',+ instance: 'fixture',+ type: 'qemu',+ memory: { total: 100, used: 25, free: 75, usage: 25 },+ ...changes,+ }) as WorkloadGuest;+const observedAt = '2026-09-30T11:00:00Z';+afterEach(() => vi.restoreAllMocks());++describe('selected workload memory observation', () => {+ it.each(['qemu', 'lxc'])('requires original provenance for a legacy %s reading', (type) => {+ expect(getWorkloadMemoryObservationPresentation(guest({ type }))?.state).toBe('unknown');+ });+ it('requires provenance for canonical Proxmox guests without legacy IDs', () => {+ expect(+ getWorkloadMemoryObservationPresentation(+ guest({ vmid: 0, node: '', instance: '', type: 'vm', platformScopes: ['proxmox-pve'] }),+ )?.state,+ ).toBe('unknown');+ });+ it.each([+ { type: 'vm', platformScopes: ['vmware-vsphere' as const] },+ { type: 'docker', vmid: 0, node: '', instance: '' },+ ])('preserves unannotated unrelated workloads ($type)', (changes) => {+ expect(getWorkloadMemoryObservationPresentation(guest(changes))).toBeNull();+ });+ it.each([undefined, -1, 101, NaN, Infinity])('keeps invalid usage unavailable (%s)', (usage) => {+ const memory = { ...guest().memory, usage } as WorkloadGuest['memory'];+ expect(getWorkloadMemoryObservationPresentation(guest({ memory }))?.state).toBe('unavailable');+ });+ it.each(['last-known', 'current'])('preserves measured zero and its %s state', (state) => {+ vi.spyOn(Date, 'now').mockReturnValue(Date.parse('2026-10-01T12:00:00Z'));+ expect(+ getWorkloadMemoryObservationPresentation(+ guest({+ memory: {+ total: 100,+ used: 0,+ free: 100,+ usage: 0,+ observation: { state, source: 'agent', observedAt },+ },+ }),+ )?.state,+ ).toBe(state);+ });+ it('qualifies current row memory without allocating an unused date label', () => {+ vi.spyOn(Date, 'now').mockReturnValue(Date.parse('2026-10-01T12:00:00Z'));+ const iso = vi.spyOn(Date.prototype, 'toISOString');+ const input = guest({+ memory: { ...guest().memory, observation: { state: 'current', source: 'agent', observedAt } },+ });+ expect(getWorkloadMemoryObservationPresentation(input, { includeCurrent: false })).toBeNull();+ expect(iso).not.toHaveBeenCalled();+ input.memory.observation!.state = 'last-known';+ expect(getWorkloadMemoryObservationPresentation(input, { includeCurrent: false })?.state).toBe(+ 'last-known',+ );+ expect(iso).toHaveBeenCalledOnce();+ });++ it.each(['usageUnavailable', 'telemetryAvailability'])(+ 'cannot revive a current numeric carrier under %s',+ (flag) => {+ const input = guest({+ memory: {+ ...guest().memory,+ observation: { state: 'current', source: 'agent', observedAt },+ },+ });+ if (flag === 'usageUnavailable') input.memory.usageUnavailable = true;+ else+ input.telemetryAvailability = {+ cpu: true,+ memory: false,+ disk: true,+ networkIO: true,+ diskIO: true,+ uptime: true,+ };+ expect(getWorkloadMemoryObservationPresentation(input)?.state).toBe('unavailable');+ },+ );+});diff --git a/frontend-modern/src/utils/memoryObservation.ts b/frontend-modern/src/utils/memoryObservation.tsindex e34fe41ad6..f034e58838 100644--- a/frontend-modern/src/utils/memoryObservation.ts+++ b/frontend-modern/src/utils/memoryObservation.ts@@ -1,4 +1,5 @@import type { MemoryObservation } from '@/types/api';+import type { WorkloadGuest } from '@/types/workloads';// Keep only the existing server-owned wire fields. Missing/future state is not// replaced by a resource poll time or a platform facet from another metric.@@ -37,6 +38,7 @@ export const getMemoryObservationPresentation = (value: number | undefined,observation: MemoryObservation | undefined,requiresObservation = false,+ options: { includeCurrent?: boolean } = {},): MemoryObservationPresentation | null => {// Unannotated unrelated platforms retain their existing behaviour. Legacy// Proxmox readings lack authority to assert current freshness.@@ -44,9 +46,6 @@ export const getMemoryObservationPresentation = (const timestamp =typeof observation?.observedAt === 'string' ? Date.parse(observation.observedAt) : NaN;const validTime = Number.isFinite(timestamp) && timestamp > 0 && timestamp <= Date.now();- const observed = validTime- ? new Date(timestamp).toISOString().replace('T', ' ').replace('.000Z', 'Z').replace('Z', ' UTC')- : null;const state =typeof value !== 'number' ||!Number.isFinite(value) ||@@ -59,6 +58,12 @@ export const getMemoryObservationPresentation = (: observation?.state === 'current' && validTime? 'current': 'unknown';+ // Most table rows are current and need no cue. Qualify them identically,+ // but avoid building source/date strings that will never be rendered.+ if (state === 'current' && options.includeCurrent === false) return null;+ const observed = validTime+ ? new Date(timestamp).toISOString().replace('T', ' ').replace('.000Z', 'Z').replace('Z', ' UTC')+ : null;const label =state === 'current'? 'Current'@@ -78,3 +83,26 @@ export const getMemoryObservationPresentation = (message: `${label}. Source: ${source}. ${time}${state === 'last-known' || state === 'unknown' ? ' Not a current measurement.' : ''}`,};};++// Rows and drawers qualify the same selected reading. Neither a disk-read+// deferral nor a refreshed Last seen can renew the memory observation.+export const getWorkloadMemoryObservationPresentation = (+ guest: WorkloadGuest,+ options: { includeCurrent?: boolean } = {},+): MemoryObservationPresentation | null => {+ const usage = guest.memory?.usage;+ const value =+ guest.telemetryAvailability?.memory !== false && !guest.memory?.usageUnavailable+ ? usage+ : undefined;+ const nonProxmoxVMware =+ guest.platformScopes?.includes('vmware-vsphere') &&+ !guest.platformScopes.includes('proxmox-pve');+ const proxmoxGuest =+ !nonProxmoxVMware &&+ (guest.type === 'qemu' ||+ guest.type === 'lxc' ||+ guest.platformScopes?.includes('proxmox-pve') ||+ (guest.vmid > 0 && Boolean(guest.node && guest.instance)));+ return getMemoryObservationPresentation(value, guest.memory?.observation, proxmoxGuest, options);+};