livedesk 0.1.460 → 0.1.461

package/diagnostics/livedesk-mac-physical-gate-core.mjs

@@ -492,12 +492,13 @@ function check(id, ok, detail) {
 }
 
 export function classifyMacPhysicalGate(snapshot = {}) {
+  const schemaVersion = Math.floor(finite(snapshot.schemaVersion));
   const requestedFps = Math.max(1, finite(snapshot.requestedFps, 30));
   const minimumFps = requestedFps * 0.8;
-  const telemetry = snapshot.telemetry || {};
   const helper = snapshot.helper || {};
   const monitor = snapshot.monitor || {};
   const modifier = snapshot.modifier || {};
+  const lifecycle = snapshot.lifecycle || {};
   const transport = snapshot.transport || {};
   const diagnostic = snapshot.diagnostic || {};
   const abortedSignal = String(diagnostic.abortedSignal || '').trim();
@@ -510,18 +511,65 @@ export function classifyMacPhysicalGate(snapshot = {}) {
   const cleanupErrors = Array.isArray(diagnostic.cleanupErrors)
     ? diagnostic.cleanupErrors.map(value => String(value || '').trim()).filter(Boolean)
     : [];
-  const captureFps = Math.max(0, finite(telemetry.captureFps));
-  const compressionFps = Math.max(0, finite(telemetry.compressionFps));
-  const stdoutFps = Math.max(0, finite(telemetry.stdoutFps));
-  const idleOptimized = finite(telemetry.idleSkipped) > 0
-    && finite(telemetry.backpressureSkipped) === 0;
-  const captureAtTarget = captureFps >= minimumFps;
-  const compressionKeepsUp = idleOptimized
-    || (captureFps > 0 && compressionFps >= captureFps * 0.8);
-  const stdoutKeepsUp = (idleOptimized && compressionFps <= 0)
-    || (compressionFps > 0 && stdoutFps >= compressionFps * 0.8);
-  const deliveredAtTarget = idleOptimized
-    || finite(snapshot.deliveredFps) >= minimumFps;
+  const captureStages = snapshot.stages || {};
+  const requiredStageNames = ['initial', 'switched'];
+  const stageEvidenceAvailable = requiredStageNames.every(name =>
+    captureStages[name]
+    && typeof captureStages[name] === 'object'
+    && captureStages[name].telemetry
+    && typeof captureStages[name].telemetry === 'object'
+    && Number.isFinite(Number(captureStages[name].deliveredFps))
+  );
+  const stageEvaluations = requiredStageNames.map(name => {
+    const stage = captureStages[name] || {};
+    const stageTelemetry = stage.telemetry || {};
+    const captureFps = Math.max(0, finite(stageTelemetry.captureFps));
+    const compressionFps = Math.max(0, finite(stageTelemetry.compressionFps));
+    const stdoutFps = Math.max(0, finite(stageTelemetry.stdoutFps));
+    const deliveredFps = Math.max(0, finite(stage.deliveredFps));
+    const idleSkipped = Math.max(0, finite(stageTelemetry.idleSkipped));
+    const backpressureSkipped = Math.max(0, finite(stageTelemetry.backpressureSkipped));
+    // One incidental idle skip must never mask a 3-4 fps regression. A static
+    // screen is treated as intentionally idle only when most of a current
+    // one-second capture window was suppressed and keepalive output remained.
+    const idleDominant = captureFps >= minimumFps
+      && backpressureSkipped === 0
+      && idleSkipped >= Math.max(10, captureFps * 0.6);
+    return {
+      name,
+      telemetry: stageTelemetry,
+      captureFps,
+      compressionFps,
+      stdoutFps,
+      deliveredFps,
+      idleSkipped,
+      backpressureSkipped,
+      idleDominant,
+      telemetryCurrent: finite(stageTelemetry.version) >= 2
+        && Number.isFinite(Number(stageTelemetry.ageMs))
+        && finite(stageTelemetry.ageMs) <= 3_000,
+      hardwareAccelerated: stageTelemetry.hardwareAccelerated === true,
+      captureAtTarget: captureFps >= minimumFps,
+      compressionKeepsUp: (idleDominant && compressionFps >= 1)
+        || (captureFps > 0 && compressionFps >= captureFps * 0.8),
+      stdoutKeepsUp: (idleDominant && stdoutFps >= 1)
+        || (compressionFps > 0 && stdoutFps >= compressionFps * 0.8),
+      deliveredAtTarget: (idleDominant && deliveredFps >= 1)
+        || deliveredFps >= minimumFps
+    };
+  });
+  const stageMetricDetail = metric => stageEvaluations
+    .map(stage => `${stage.name}=${finite(stage[metric]).toFixed(1)}`)
+    .join(' ');
+  const idleOptimized = stageEvaluations.some(stage => stage.idleDominant);
+  const captureAtTarget = stageEvidenceAvailable
+    && stageEvaluations.every(stage => stage.captureAtTarget);
+  const compressionKeepsUp = stageEvidenceAvailable
+    && stageEvaluations.every(stage => stage.compressionKeepsUp);
+  const stdoutKeepsUp = stageEvidenceAvailable
+    && stageEvaluations.every(stage => stage.stdoutKeepsUp);
+  const deliveredAtTarget = stageEvidenceAvailable
+    && stageEvaluations.every(stage => stage.deliveredAtTarget);
   const helperPids = Array.isArray(helper.observedPids)
     ? helper.observedPids.map(Number).filter(pid => Number.isInteger(pid) && pid > 1)
     : [];
@@ -568,8 +616,53 @@ export function classifyMacPhysicalGate(snapshot = {}) {
       cpuPercentPeak: Math.max(0, finite(processInfo?.cpuPercentPeak)),
       rssBytesPeak: Math.max(0, Math.round(finite(processInfo?.rssBytesPeak)))
     }));
-  const expectedModifierAcks = Math.max(1, finite(modifier.expectedAcks, 8));
+  const expectedModifierSteps = buildMacModifierProbeSteps(1).map(step => ({
+    inputSeq: step.inputSeq,
+    type: step.type,
+    code: step.code
+  }));
+  const modifierApplied = Array.isArray(modifier.applied) ? modifier.applied : [];
+  const modifierSequenceMatches = modifierApplied.length === expectedModifierSteps.length
+    && modifierApplied.every((actual, index) => {
+      const expected = expectedModifierSteps[index];
+      return actual?.inputSeq === expected.inputSeq
+        && actual?.type === expected.type
+        && actual?.code === expected.code;
+    });
+  const lifecycleOrder = Array.isArray(lifecycle.order)
+    ? lifecycle.order.map(value => String(value || '').trim()).filter(Boolean)
+    : [];
+  const expectedLifecycleOrder = [
+    'wall',
+    'control',
+    'paused',
+    'blocked',
+    'resumed',
+    'control-resumed',
+    'control-stopped',
+    'wall-restored',
+    'stopped'
+  ];
+  const lifecycleHelperCounts = [
+    finite(lifecycle.wallHelperCount, -1),
+    finite(lifecycle.controlHelperCount, -1),
+    finite(lifecycle.pausedHelperCount, -1),
+    finite(lifecycle.resumedControlHelperCount, -1),
+    finite(lifecycle.controlStoppedHelperCount, -1),
+    finite(lifecycle.restoredWallHelperCount, -1),
+    finite(lifecycle.finalHelperCount, -1)
+  ];
+  const lifecycleCompletedAtMs = Date.parse(String(lifecycle.completedAt || ''));
+  const registrySampledAtMs = Date.parse(String(lifecycle.registrySampledAt || ''));
+  const lifecycleRegistryFresh = Number.isFinite(lifecycleCompletedAtMs)
+    && Number.isFinite(registrySampledAtMs)
+    && registrySampledAtMs >= lifecycleCompletedAtMs;
   const checks = [
+    check(
+      'report-schema',
+      schemaVersion === 3,
+      `v${schemaVersion || 'missing'}`
+    ),
     check(
       'diagnostic-run',
       !runError,
@@ -580,6 +673,51 @@ export function classifyMacPhysicalGate(snapshot = {}) {
       cleanupErrors.length === 0,
       cleanupErrors.length === 0 ? 'completed' : cleanupErrors.join('; ')
     ),
+    check(
+      'capture-lifecycle-order',
+      lifecycleOrder.join('>') === expectedLifecycleOrder.join('>'),
+      lifecycleOrder.join(' -> ') || 'missing'
+    ),
+    check(
+      'capture-lifecycle-generation',
+      finite(lifecycle.wallGeneration) > 0
+        && finite(lifecycle.controlGeneration) > finite(lifecycle.wallGeneration)
+        && finite(lifecycle.resumedControlGeneration) > finite(lifecycle.controlGeneration)
+        && finite(lifecycle.restoredWallGeneration) > finite(lifecycle.resumedControlGeneration),
+      `${finite(lifecycle.wallGeneration)} -> ${finite(lifecycle.controlGeneration)}`
+        + ` -> ${finite(lifecycle.resumedControlGeneration)}`
+        + ` -> ${finite(lifecycle.restoredWallGeneration)}`
+    ),
+    check(
+      'capture-lifecycle-pause',
+      lifecycle.pauseStopConfirmed === true
+        && lifecycle.pauseStopAcknowledged === true
+        && lifecycle.blockedWhilePaused === true
+        && lifecycle.resumeAccepted === true,
+      `stop=${lifecycle.pauseStopConfirmed === true}/${lifecycle.pauseStopAcknowledged === true} `
+        + `blocked=${lifecycle.blockedWhilePaused === true} resume=${lifecycle.resumeAccepted === true}`
+    ),
+    check(
+      'capture-lifecycle-helper',
+      lifecycleHelperCounts.join(',') === '1,1,0,1,0,1,0',
+      lifecycleHelperCounts.join(' -> ')
+    ),
+    check(
+      'capture-lifecycle-registry',
+      lifecycleRegistryFresh
+        && finite(lifecycle.registryMaxConcurrent, -1) === 1
+        && finite(lifecycle.registryFinalHelperCount, -1) === 0,
+      `completed=${String(lifecycle.completedAt || '-')} `
+        + `sampled=${String(lifecycle.registrySampledAt || '-')} `
+        + `max=${finite(lifecycle.registryMaxConcurrent, -1)} `
+        + `final=${finite(lifecycle.registryFinalHelperCount, -1)}`
+    ),
+    check(
+      'capture-lifecycle-stop',
+      lifecycle.controlStopConfirmed === true
+        && lifecycle.finalStopConfirmed === true,
+      `control=${lifecycle.controlStopConfirmed === true} final=${lifecycle.finalStopConfirmed === true}`
+    ),
     check(
       'first-frame',
       finite(snapshot.firstFrameMs) > 0 && finite(snapshot.firstFrameMs) < 8_000,
@@ -591,6 +729,11 @@ export function classifyMacPhysicalGate(snapshot = {}) {
         && finite(snapshot.monitorSwitchFirstFrameMs) < 8_000,
       `${Math.round(finite(snapshot.monitorSwitchFirstFrameMs))}ms`
     ),
+    check(
+      'capture-stage-evidence',
+      stageEvidenceAvailable,
+      stageEvidenceAvailable ? requiredStageNames.join(',') : 'initial and switched stages required'
+    ),
     check(
       'native-profile',
       snapshot.platformProfile === 'macos-screencapturekit-nv12-videotoolbox',
@@ -598,31 +741,57 @@ export function classifyMacPhysicalGate(snapshot = {}) {
     ),
     check(
       'telemetry-current',
-      finite(telemetry.version) >= 2
-        && Number.isFinite(Number(telemetry.ageMs))
-        && finite(telemetry.ageMs) <= 3_000,
-      `v${finite(telemetry.version)} age=${Number.isFinite(Number(telemetry.ageMs)) ? Math.round(finite(telemetry.ageMs)) : '-'}ms`
+      stageEvidenceAvailable
+        && stageEvaluations.every(stage => stage.telemetryCurrent),
+      stageEvaluations
+        .map(stage =>
+          `${stage.name}=v${finite(stage.telemetry.version)}`
+          + `/age=${Number.isFinite(Number(stage.telemetry.ageMs))
+            ? Math.round(finite(stage.telemetry.ageMs))
+            : '-'}ms`
+        )
+        .join(' ')
     ),
     check(
       'hardware-videotoolbox',
-      telemetry.hardwareAccelerated === true,
-      telemetry.hardwareAccelerated === true ? 'hardware' : 'not-confirmed'
+      stageEvidenceAvailable
+        && stageEvaluations.every(stage => stage.hardwareAccelerated),
+      stageEvaluations
+        .map(stage => `${stage.name}=${stage.hardwareAccelerated ? 'hardware' : 'not-confirmed'}`)
+        .join(' ')
+    ),
+    check(
+      'screencapturekit-fps',
+      captureAtTarget,
+      `${stageMetricDetail('captureFps')} target=${requestedFps}`
     ),
-    check('screencapturekit-fps', captureAtTarget, `${captureFps.toFixed(1)}/${requestedFps}`),
     check(
       'videotoolbox-fps',
       compressionKeepsUp,
-      `${compressionFps.toFixed(1)} after ${captureFps.toFixed(1)}${idleOptimized ? ' idle-optimized' : ''}`
+      stageEvaluations
+        .map(stage =>
+          `${stage.name}=${stage.compressionFps.toFixed(1)}`
+          + `/${stage.captureFps.toFixed(1)}`
+          + `${stage.idleDominant ? ' idle-dominant' : ''}`
+        )
+        .join(' ')
     ),
     check(
       'stdout-fps',
       stdoutKeepsUp,
-      `${stdoutFps.toFixed(1)} after ${compressionFps.toFixed(1)}${idleOptimized ? ' idle-optimized' : ''}`
+      stageEvaluations
+        .map(stage =>
+          `${stage.name}=${stage.stdoutFps.toFixed(1)}`
+          + `/${stage.compressionFps.toFixed(1)}`
+          + `${stage.idleDominant ? ' idle-dominant' : ''}`
+        )
+        .join(' ')
     ),
     check(
       'delivered-fps',
       deliveredAtTarget,
-      `${finite(snapshot.deliveredFps).toFixed(1)}/${requestedFps}${idleOptimized ? ' idle-optimized' : ''}`
+      `${stageMetricDetail('deliveredFps')} target=${requestedFps}`
+        + `${idleOptimized ? ' idle-dominant-stage' : ''}`
     ),
     check(
       'single-helper',
@@ -656,6 +825,13 @@ export function classifyMacPhysicalGate(snapshot = {}) {
       finite(monitor.nextGeneration) > finite(monitor.initialGeneration),
       `${finite(monitor.initialGeneration)} -> ${finite(monitor.nextGeneration)}`
     ),
+    check(
+      'monitor-native-identity',
+      finite(monitor.initialDisplayId) > 0
+        && finite(monitor.nextDisplayId) > 0
+        && finite(monitor.initialDisplayId) !== finite(monitor.nextDisplayId),
+      `${finite(monitor.initialDisplayId)} -> ${finite(monitor.nextDisplayId)}`
+    ),
     check(
       'monitor-pixels',
       Boolean(monitor.initialHash)
@@ -665,9 +841,12 @@ export function classifyMacPhysicalGate(snapshot = {}) {
     ),
     check(
       'modifier-native-ack',
-      finite(modifier.appliedAcks) === expectedModifierAcks
+      modifier.expectedAcks === expectedModifierSteps.length
+        && modifier.appliedAcks === expectedModifierSteps.length
+        && modifierSequenceMatches
         && (!Array.isArray(modifier.errors) || modifier.errors.length === 0),
-      `${finite(modifier.appliedAcks)}/${expectedModifierAcks} native ACK`
+      `${finite(modifier.appliedAcks)}/${expectedModifierSteps.length} native ACK, `
+        + `sequence=${modifierSequenceMatches ? 'exact' : 'invalid'}`
     ),
     check(
       'active-transport',
@@ -682,10 +861,18 @@ export function classifyMacPhysicalGate(snapshot = {}) {
 
   const failed = checks.filter(item => !item.ok);
   const bottleneckByCheck = {
+    'report-schema': 'report-schema',
     'diagnostic-run': 'diagnostic-run',
     'diagnostic-cleanup': 'diagnostic-cleanup',
+    'capture-lifecycle-order': 'capture-lifecycle-order',
+    'capture-lifecycle-generation': 'capture-generation',
+    'capture-lifecycle-pause': 'capture-pause-resume',
+    'capture-lifecycle-helper': 'capture-helper-lifecycle',
+    'capture-lifecycle-registry': 'capture-helper-registry',
+    'capture-lifecycle-stop': 'capture-stop',
     'first-frame': 'capture-startup',
     'monitor-first-frame': 'monitor-restart',
+    'capture-stage-evidence': 'capture-stage-evidence',
     'native-profile': 'capture-fallback',
     'telemetry-current': 'native-telemetry-stale',
     'hardware-videotoolbox': 'videotoolbox-software',
@@ -700,6 +887,7 @@ export function classifyMacPhysicalGate(snapshot = {}) {
     'resource-drained': 'resource-not-drained',
     'two-monitors': 'monitor-topology',
     'monitor-generation': 'monitor-generation',
+    'monitor-native-identity': 'monitor-binding',
     'monitor-pixels': 'monitor-binding',
     'modifier-native-ack': 'remote-input',
     'active-transport': 'transport-telemetry'