sparkforensics-server 0.5.2 → 0.8.1

package/vendor-core/finding-types.js

@@ -10,16 +10,27 @@
                                                                       
                                                           
 
-/** One concrete change a finding's fix makes, alongside its prose `recommendation`. Only a Spark
- * property the detector already names; `suggested` is null when it computes no value. Sizes carry a
- * Spark unit suffix ("384m"), counts are plain numbers, switches are booleans. */
-                              
+/** One concrete change a finding's fix makes, alongside its prose `recommendation`. Entries are
+ * applied together unless the recommendation words them as alternatives ("either ... or"), as an
+ * idle-capacity finding does with dynamic allocation off: then a consumer applies one. */
+                                                            
+
+/** A Spark property the detector already names; `suggested` is null when it computes no value.
+ * Sizes carry a Spark unit suffix ("384m"), counts are plain numbers, switches are booleans. */
+                                  
                
               
                                              
                                               
  
 
+/** A fix no Spark property makes: the job's code or data has to change. `hint` is the same
+ * wording the finding's `recommendation` gives. */
+                                  
+               
+               
+ 
+
 // The columns every finding carries, whatever its detector.
                                          
               
@@ -77,12 +88,20 @@
                        
  
 
-// ── Per-stage detectors ─────────────────────────────────────────────────────
-
 /** What a skewed stage reads, which decides the fix: 'shuffleJoin' (a shuffle feeding a join, where
  * AQE skew-join handling applies), 'inputScan' (uneven input files) or 'other'. */
                                                                
 
+/** What AQE skew-join handling did for a 'shuffleJoin' stage, read from the final plan and the
+ * effective conf: 'split' (it split the skewed partition, so the rest is not join skew),
+ * 'evenReads' (the shuffle reads are even, so no partition is skewed for AQE to split),
+ * 'belowThreshold' (the partition is under the effective skew threshold or factor), 'planShape' (an
+ * operator sits between the join and its shuffle), 'userRepartition' (the shuffle is an explicit
+ * repartition), 'joinType' (the join type does not let AQE split the skewed side),
+ * 'extraShuffle' (splitting would add a shuffle for the operator above the join) or 'notSplit'
+ * (nothing in the log explains it). */
+                                                                                                                                                
+
 /** What a stage reads, by the dominant side: a shuffle, input files, or neither. */
                                                        
 
@@ -92,8 +111,23 @@
  * enough, so the stage's own repartition(n) or RDD parallelism is). */
                                                                                             
 
+/** Why a stage's slow tail is slow (attributeTail in stage-quantiles.ts). 'data': the slow tasks
+ * read far more than the median task, so run time follows data volume. 'gc', 'fetchWait' and
+ * 'host': the tail's extra time is GC, shuffle fetch wait, or tasks piled on one host.
+ * 'unexplained': the slow tasks read no more than the median and none of those accounts for their
+ * time. 'unattributed': the stage has no data volume to compare and what data, GC, fetch wait and
+ * host do not explain is the largest share (or the stage has no tail attribution), so only the
+ * duration is known. */
+                                                                                              
+
                                
                       
+                                                                                                     
+                        
+                                                                                                          
+                    
+                                                                                   
+                     
  
                                                                             
 
@@ -112,8 +146,9 @@
 
                                           
                                                                                 
-                                                    
+                                                                    
                       
+                        
                                                                                                            
                                  
  
@@ -144,6 +179,10 @@
                       
                                                                                                 
                         
+                                                                                                  
+                                                                                          
+                         
+                     
  
                                                                                         
 
@@ -174,11 +213,23 @@
                                                                                         
 
                                     
-                        
+                                                                                                 
+                                  
                            
                          
-                                                                                     
+                                                                                              
+                              
                       
+                        
+                                                                                                     
+                    
+                                                                             
+                         
+                                                                                            
+                
+                     
+                                                                                              
+                  
  
                                                                                            
 
@@ -200,8 +251,6 @@
                      
  
                                                                                         
-
-// ── App-level detectors ─────────────────────────────────────────────────────
 
                                                          
 // valueText is always 'missing': the ApplicationEnd event the log lacks.
@@ -214,35 +263,38 @@
                                                                                            
 
                                       
-                                                                                               
+                                                                      
                                    
  
                                                                                                 
-                                                                                             
-                      
+                                                                                            
+                                                                                         
                               
                         
                      
+                          
  
 
                                             
                                                      
-                                                             
-                                                    
+                                                              
+                               
+                                                                          
                       
-                                                               
+                                                                                                 
                 
                                                               
                             
  
                                                                                                                   
-                                                                                               
-                                                                    
+                                                                                         
+                                                                                                  
                             
-                              
-                         
-                         
+                                     
                           
+                                                                                                         
+                         
+                           
  
 
                                            
@@ -293,17 +345,13 @@
                           
  
                                                                                                           
-
-// ── Config-scope detectors ──────────────────────────────────────────────────
 
                                       
                    
  
-// valueText is the audited property's current value, or a note that it is unset or inverted.
+// valueText is the audited property's current value, or a note that it is unset.
                                                                                               
 
-// ── SQL-scope (Plan Advisor) detectors ──────────────────────────────────────
-
                                
                       
                      
@@ -333,13 +381,41 @@
  
                                                                                                               
 
-/** How the effective spark.sql.autoBroadcastJoinThreshold relates to the finding: 'limits' (the
+                                                                
+                                                                                                
+                        
+                                                                           
+                                   
+                                                                         
+                          
+ 
+                                                                                                           
+/** A BroadcastNestedLoopJoin or CartesianProduct whose output is far larger than both inputs.
+ * `nodeName` is the operator, `joinType` the Spark join type (null when the plan line has none)
+ * and `condition` the join condition with expression ids removed (null for a join without one).
+ * `leftRows` and `rightRows` are the input row counts the executors reported, null for a
+ * CartesianProduct, which re-reads its inputs so their counts are not row counts. */
+                                                                     
+                                                           
+                          
+                           
+                     
+                          
+                           
+ 
+                                                                                                                          
+
+/** How the effective broadcast threshold (spark.sql.autoBroadcastJoinThreshold, or its adaptive counterpart under AQE) relates to the finding: 'limits' (the
  * property decided it, or is unknown), 'notLimiting' (already admits, or already below, the
  * broadcast, so something else decided it) or 'disabled' (-1). */
                                                                        
 
                                                                      
+                                                                            
                           
+                                                                                                       
+                   
+                              
                                           
  
                                                                                                                           
@@ -349,8 +425,6 @@
  
                                                                                                                        
 
-// ── Unions ──────────────────────────────────────────────────────────────────
-
 /** Public evidence fields per finding type: what a report row's `evidence` carries. */
                                      
                      
@@ -379,6 +453,8 @@
                                    
                                                      
                                  
+                               
+                                         
                                          
                                        
  
@@ -410,6 +486,8 @@
                       
                                
                      
+                    
+                         
                          
                          
 

package/vendor-core/format-utils.js

@@ -14,9 +14,9 @@ const BOTTLENECK_WIDGET                                   = {
   coldStart: 'executor-timeline', utilization: 'executor-timeline', speculationWaste: 'executor-timeline',
 }                                               ;
 
-// Cross-widget stage recurrence: how many distinct board widgets (skew+straggler on one stage
-// still count as one, task-skew) flag a stage. Computed once from the full catalog each widget
-// already receives.
+// Cross-widget stage recurrence: how many distinct widget groups (skew, slowHost and straggler
+// share task-skew) flag a stage. No production code calls it, and the group names in
+// BOTTLENECK_WIDGET are labels, not ids of rendered widgets.
 // `stageId` may be number|null|undefined: sql/config-scope findings never set it; `stageId == null`
 // below treats both the same.
 export function stageWidgetFrequency(catalog                                                )                      {
@@ -69,9 +69,7 @@ export function formatStageIdsLabel(stageIds          , maxShown         = DEFAU
 }
 
 /** Worst (lowest IMPACT_BAND_ORDER) impact band across findings, undefined when empty. Shared by
- * every widget that badges/colors a group of findings.
- * @param {{ impactBand: 'critical' | 'warning' | 'info' }[]} findings
- * @returns {'critical' | 'warning' | 'info' | undefined} */
+ * every widget that badges/colors a group of findings. */
 export function worstImpactBand(
   findings                                                   ,
 )                                              {
@@ -285,15 +283,16 @@ export function formatRawWaste(rawWaste                )         {
   }
 }
 
-// formatRawWaste/fmtMs round to a fixed precision (one decimal place, or
-// whole milliseconds below 1s), which can collapse a small but genuinely
-// nonzero value down to a formatted string that reads exactly like zero
-// (0.04 coreHours -> "0.0 core-h"). Checking the raw value against 0 misses
-// this; checking the *formatted* text against zero's own formatted text
-// catches it regardless of unit. The fractional group must consume the
-// entire decimal part (all zeros) before the terminator: otherwise a real
-// value like "0.5 core-h" leaves the "." unconsumed, and the terminator
-// char class excludes ".", so it correctly fails to match.
+/** A cost-only figure as core time. Task time summed over tasks (`ms`) is core time, and printing
+ * it as a duration beside wall-clock savings reads as run time it does not shorten. */
+export function asCoreTime(rawWaste                )                 {
+  return rawWaste.unit === 'ms' ? { ...rawWaste, unit: 'coreMs' } : rawWaste;
+}
+
+// True when a formatted figure reads as zero, including a small nonzero value the fixed rounding
+// collapsed (0.04 coreHours -> "0.0 core-h"). It tests the formatted text, so it holds for any unit.
+// The fractional group must consume the whole decimal part before the terminator, so "0.5 core-h"
+// does not match.
 export function readsAsZero(formatted        )          {
   return /^0(\.0+)?(?:[^0-9.]|$)/.test(formatted);
 }

package/vendor-core/html-export.js

@@ -25,7 +25,7 @@ export function buildHtmlExportData(
   skippedLines        ,
   { redact, buildId, producer }                                                        ,
 )                {
-  const raw = { appModel, catalog, configFindings: auditConfig(appModel.app) };
+  const raw = { appModel, catalog, configFindings: auditConfig(appModel.app, appModel.stages) };
   const run = redact ? redactRunModel(raw.appModel, raw.catalog, raw.configFindings) : raw;
   const interpretation = interpretRun(run.appModel, run.catalog, run.configFindings);
   const provenance                   = { coreVersion: CORE_VERSION, buildId, producer };

package/vendor-core/impact-band.js

@@ -1,8 +1,8 @@
                                                         
 
 // The run-wide noise floor, as a share of the run's duration, that grades every wall-clock
-// estimate (NOT SOURCED: our own, unvalidated). skew and straggler default their firing floors to
-// these same figures (detectors.ts), so a finding they admit grades at least warning here.
+// estimate. skew and straggler default their firing floors to these same figures (detectors.ts), so
+// a finding they admit grades at least warning here. Source status: threshold-tables.md.
 export const IMPACT_FLOOR_PCT_WARN = 0.005;
 export const IMPACT_FLOOR_PCT_CRIT = 0.02;
 

package/vendor-core/impact-format.js

@@ -1,18 +1,33 @@
 // Savings figures as every surface prints them: the dashboard's widgets and verdict, and the
 // CLI/MCP evidence report. One formatter set, so units and rounding never drift between paths.
-import { fmtMs, formatRawWaste, formatWallClockRange, readsAsZero } from './format-utils.js';
+// A figure that rounds to zero ("0s", "0.0 core-h") reads as a measured nothing, so every
+// formatter here shows no figure for it (see readsAsZero in format-utils.ts).
+import { asCoreTime, fmtMs, formatRawWaste, formatWallClockRange, readsAsZero } from './format-utils.js';
                                                                           
 
+/** The raw figure as the surfaces print it: a cost-only (`resourceOnly`) task-time figure in core
+ * time, anything else as the detector emitted it. `rawWaste` itself stays untouched. */
+function shownRawWaste(estimate                )                             {
+  const rawWaste = estimate.rawWaste;
+  return rawWaste && estimate.basis === 'resourceOnly' ? asCoreTime(rawWaste) : rawWaste;
+}
+
+/** " (modeled)" after a cost-only figure that rests on an assumed constant, so a modeled core
+ * time never reads as a measured one. Empty for any other estimate. */
+function certaintyNote(estimate                )         {
+  return estimate.basis === 'resourceOnly' && estimate.estimateMethod === 'modeled' ? ' (modeled)' : '';
+}
+
 /** A finding's one-line savings figure: the wall-clock range for a time-based
  * finding, the raw resource figure for a `resourceOnly` one, or nothing for a
- * purely informational estimate or a raw figure that rounds to zero ("0.0
- * core-h" reads as a measured nothing). */
+ * purely informational estimate. */
 export function impactFigure(finding         )                {
   const estimate = finding.impactEstimate;
   if (!estimate) return null;
   if (estimate.wallClock) return formatWallClockRange(estimate.wallClock.low, estimate.wallClock.high);
-  if (estimate.rawWaste) {
-    const text = formatRawWaste(estimate.rawWaste);
+  const rawWaste = shownRawWaste(estimate);
+  if (rawWaste) {
+    const text = formatRawWaste(rawWaste);
     return readsAsZero(text) ? null : text;
   }
   return null;
@@ -25,7 +40,7 @@ export function rawWasteMeaning(rawWaste                            )
     case 'mbSeconds': return 'of unused executor memory';
     case 'coreHours':
     case 'coreMs': return rawWaste.idle ? 'of idle core capacity' : 'of core time';
-    case 'bytes': return 'of extra data written';
+    case 'bytes': return rawWaste.reread ? 'of input read by the repeated scans' : 'of extra data written';
     case 'ms': return 'of task time';
     default: return null;
   }
@@ -40,30 +55,34 @@ export function savingsMeaning(finding         )                {
   const estimate = finding.impactEstimate;
   if (!estimate) return null;
   if (estimate.wallClock) return 'of run time';
-  return rawWasteMeaning(estimate.rawWaste);
+  const meaning = rawWasteMeaning(estimate.rawWaste);
+  return meaning && `${meaning}${certaintyNote(estimate)}`;
 }
 
 /** A finding's "Potential savings" figure as the widget board shows it: the
  * wall-clock range, or the raw waste only when there is no wall-clock claim,
  * never both (they would read as two competing numbers). A zero-value
- * estimate is suppressed like an informational one: "0s" reads as a measured
- * figure. `meaning` says what the shown figure counts. */
+ * estimate is suppressed like an informational one. `meaning` says what the
+ * shown figure counts. */
 export function impactEstimateFigure(estimate                            )                                                  {
   if (!estimate) return null;
   const highText = estimate.wallClock && estimate.wallClock.high > 0 ? fmtMs(estimate.wallClock.high) : null;
   if (highText && !readsAsZero(highText)) {
     return { text: formatWallClockRange(estimate.wallClock .low, estimate.wallClock .high), meaning: 'of run time' };
   }
-  const rawWasteText = estimate.rawWaste && estimate.rawWaste.value > 0 ? formatRawWaste(estimate.rawWaste) : null;
-  if (rawWasteText && !readsAsZero(rawWasteText)) return { text: rawWasteText, meaning: rawWasteMeaning(estimate.rawWaste) };
+  const rawWaste = shownRawWaste(estimate);
+  const rawWasteText = rawWaste && rawWaste.value > 0 ? formatRawWaste(rawWaste) : null;
+  if (rawWasteText && !readsAsZero(rawWasteText)) {
+    const meaning = rawWasteMeaning(estimate.rawWaste);
+    return { text: rawWasteText, meaning: meaning && `${meaning}${certaintyNote(estimate)}` };
+  }
   return null;
 }
 
 /** Compact single-value form for dense lists (the stage table's finding chips,
  * the stage dialog): the high-end wall-clock figure, or the raw-waste figure
  * when there's no wall-clock claim, or `null` for a purely informational or a
- * zero-value estimate (a `0s` in the spot a real estimate goes would read as a
- * measured nothing). */
+ * zero-value estimate. */
 export function impactEstimateCompact(estimate                            )                {
   if (!estimate) return null;
   if (estimate.wallClock) {
@@ -71,10 +90,11 @@ export function impactEstimateCompact(estimate                            )
     const text = fmtMs(estimate.wallClock.high);
     return readsAsZero(text) ? null : text;
   }
-  if (estimate.rawWaste) {
-    if (estimate.rawWaste.value <= 0) return null;
-    const text = formatRawWaste(estimate.rawWaste);
-    return readsAsZero(text) ? null : text;
+  const rawWaste = shownRawWaste(estimate);
+  if (rawWaste) {
+    if (rawWaste.value <= 0) return null;
+    const text = formatRawWaste(rawWaste);
+    return readsAsZero(text) ? null : `${text}${certaintyNote(estimate)}`;
   }
   return null;
 }
@@ -88,14 +108,22 @@ export function impactEstimateCompact(estimate                            )
  * formatting and zero rules as the step's own savings figure, which it does
  * not repeat: the step already shows it. */
 export function estimateProvenance(finding                                 )                {
+  const sentence = provenanceSentence(finding);
+  const assumptions = finding.impactEstimate?.assumptions;
+  if (!sentence || !assumptions) return sentence;
+  return `${sentence} ${assumptions[0].toUpperCase()}${assumptions.slice(1)}.`;
+}
+
+function provenanceSentence(finding                                 )                {
   const estimate = finding.impactEstimate;
   if (!estimate || estimate.estimateMethod === 'none') return null;
   const method = `${estimate.estimateMethod[0].toUpperCase()}${estimate.estimateMethod.slice(1)}`;
-  const rawWaste = estimate.rawWaste && estimate.rawWaste.value > 0 ? estimate.rawWaste : null;
+  const shown = shownRawWaste(estimate);
+  const rawWaste = shown && shown.value > 0 ? shown : null;
   const raw = rawWaste && !readsAsZero(formatRawWaste(rawWaste)) ? formatRawWaste(rawWaste) : null;
   const wallClock = estimate.wallClock;
   if (estimate.basis === 'resourceOnly') {
-    return raw ? `${method}; ${raw} wasted, which may not shorten the run.` : null;
+    return raw ? `${method}; ${raw} ${rawWasteMeaning(estimate.rawWaste) ?? 'wasted'}, which may not shorten the run.` : null;
   }
   if (!wallClock || wallClock.high <= 0) return null;
   const highText = formatWallClockRange(wallClock.high, wallClock.high);

package/vendor-core/impact-model.js

@@ -19,6 +19,10 @@ import {
                      
                                                                                                   
                                   
+                                                                                                  
+                                                                                                 
+                             
+                                
  
 
 // Assumed shuffle-network throughput per executor link, ~1 Gbps. Starting assumption, unvalidated.
@@ -43,10 +47,8 @@ export function measuredTaskOverhead(stage       )
 
 // Both constants above are single-device figures (one NIC, one local disk). A stage's shuffle
 // reads and spills are spread over every executor that ran its tasks, each moving its own share
-// in parallel, so the stage's aggregate bandwidth scales with that executor count. Dividing a
-// stage-wide byte total by one device's bandwidth modeled the whole cluster as one link: on 14
-// real logs that claimed up to 1,870s of shuffle time on stages whose tasks measured ~0s of
-// shuffle fetch wait (222 of 284 shuffle findings). No executor data falls back to one device.
+// in parallel, so the stage's aggregate bandwidth scales with that executor count. No executor
+// data falls back to one device.
 export function stageIoParallelism(stage       )         {
   const executors = Array.isArray(stage.executorStats) ? stage.executorStats.length : 0;
   return Math.max(1, executors);
@@ -55,9 +57,7 @@ export function stageIoParallelism(stage       )         {
 // Wall-clock the stage's tasks spent blocked fetching shuffle blocks: fetchWaitTime is a
 // cross-task sum like executorRunTime, so dividing by the stage's average concurrency converts it
 // (the gc estimate's conversion). Null when the stage has no run time or duration to convert with.
-// On 14 real logs the link model claimed 2780s over 284 shuffle findings, 256s once capped at
-// this, with about zero fetch wait on 5 of the 10 non-info ones: reads that overlapped compute
-// stalled nothing.
+// The link model caps at this because reads that overlap compute stall nothing.
 export function fetchWaitWallClockMs(stage       )                {
   const fetchWaitMs = stage.fetchWaitTime;
   const runTimeMs = stage.executorRunTime ?? 0;
@@ -66,10 +66,9 @@ export function fetchWaitWallClockMs(stage       )                {
   return fetchWaitMs / (runTimeMs / durationMs);
 }
 
-// Wall-clock a stage's wasted (retried) attempts cost it. Each one delayed only its own task, and
-// attempts of different tasks ran side by side: one lost executor fails every task it was running
-// at once (4 wasted attempts of 36.6s each, all first attempts, on a real stage that ran 41 tasks
-// at once, claimed as 146.6s). So the stage lost at most its longest retry chain, the most attempts
+// Wall-clock a stage's wasted (retried) attempts cost it. Each one delays only its own task, and
+// attempts of different tasks run side by side: one lost executor fails every task it was running
+// at once. So the stage loses at most its longest retry chain, the most attempts
 // one task wasted (its highest attempt number + 1) times the mean wasted attempt, or their summed
 // time spread over its slots, whichever is larger. Without a sample of every wasted attempt
 // (retryTaskSamples is capped), the chain isn't known: the summed time.
@@ -99,10 +98,8 @@ export const EXECUTOR_STARTUP_OVERHEAD_MS = 15000;
 // Assumed re-read throughput, shared by cachingOpportunity and cacheUtilization.
 export const RE_READ_THROUGHPUT_BPS = 125_000_000;
 
-// Below this share of executorRunTime spent on CPU, a stage's tasks were idle, waiting on something
-// outside Spark: on 14 real logs (2026-09-23) every non-Python stage under 1% was a JDBC read, a
-// file listing or a Delta log read, while file writes, which more partitions do parallelize,
-// start at 2%.
+// Below this share of executorRunTime spent on CPU, a stage's tasks are idle, waiting on something
+// outside Spark (rationale: impact-estimation/caveats-tuning-and-coverage.md, Idle CPU share).
 const IDLE_CPU_SHARE_MAX = 0.01;
 
 // True when the stage's tasks spent under IDLE_CPU_SHARE_MAX of their run time on CPU. False when
@@ -118,8 +115,8 @@ export function tasksMostlyIdle(stage       , sql                            = n
   return cpuMs / runMs < IDLE_CPU_SHARE_MAX;
 }
 
-// skew, straggler and stageSlowness claim time off the stage's longest task itself, so the
-// occupancy clip must not floor them at that same task (see estimateSingleStage).
+// skew, straggler, stageSlowness and lowShuffleParallelism claim time off the stage's longest task
+// itself, so the occupancy clip must not floor them at that same task (see estimateSingleStage).
 export const TAIL_CLAIM                             = { shortensLongestTask: true };
 
 // No quantifiable magnitude -> 'informational'; a rawWaste figure with no stage window ->
@@ -130,6 +127,20 @@ export function costOnly(estimateMethod                      , rawWaste
     : { basis: 'informational', wallClock: null, estimateMethod };
 }
 
+/** The estimate with what its model assumes and leaves out (`ImpactEstimate.assumptions`). */
+export function withAssumptions(estimate                , assumptions        )                 {
+  return { ...estimate, assumptions };
+}
+
+/** The throughput assumption behind a per-executor I/O model (stageIoParallelism), in the words
+ * `ImpactEstimate.assumptions` carries: the rate and how many executors it was spread over. */
+export function ioModelAssumption(bytesPerSecond        , stage       )         {
+  const executors = Array.isArray(stage.executorStats) ? stage.executorStats.length : 0;
+  const rate = `${Math.round(bytesPerSecond / 1e6)} MB/s`;
+  if (executors === 0) return `assumes ${rate} on one device, as the stage has no per-executor data`;
+  return `assumes ${rate} per executor over ${executors} ${executors === 1 ? 'executor' : 'executors'}`;
+}
+
 /** The estimate() of an entry whose findings have no waste model at all. */
 export function noWasteModel()                 {
   return costOnly('none');

package/vendor-core/job-groups.js

@@ -1,10 +1,10 @@
-// §8 Concurrent-job-group reliability guard. Groups jobs by SQL
-// execution id (jobs with none form singleton groups). If two DIFFERENT groups' intervals overlap,
-// wall-clock-based estimates become unreliable. Jobs WITHIN a group overlapping (AQE) is normal.
+// Concurrent-job-group reliability guard. Groups jobs by SQL execution id (jobs with none form
+// singleton groups). If two DIFFERENT groups' intervals overlap, wall-clock-based estimates become
+// unreliable. Jobs WITHIN a group overlapping (AQE) is normal.
 export function checkConcurrentJobGroups(jobs                                                                                                                             )                                                                        {
   const list = jobs ? [...jobs.values()] : [];
   // Build one interval per group: [min submission, max completion].
-  const groups = new Map(); // key -> { start, end }
+  const groups = new Map();
   let singletonSeq = 0;
   for (const j of list) {
     if (j.submissionTime == null || j.completionTime == null) continue;